@askexenow/exe-os 0.8.41 → 0.8.43

package/dist/gateway/index.js

@@ -19,6 +19,61 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// 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/gateway/crm-bridge.ts
 var crm_bridge_exports = {};
 __export(crm_bridge_exports, {
@@ -568,6 +623,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`,
@@ -1014,6 +1076,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,
@@ -2128,6 +2202,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 as randomUUID2 } 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(input) {
+  const id = randomUUID2();
+  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, input.title, input.content, input.priority ?? "p0", input.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, {
@@ -2207,6 +2346,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;
@@ -2248,6 +2392,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;
@@ -2593,6 +2743,7 @@ var init_store = __esm({
     init_database();
     init_keychain();
     init_config();
+    init_state_bus();
     INIT_MAX_RETRIES = 3;
     INIT_RETRY_DELAY_MS = 1e3;
     _pendingRecords = [];
@@ -3132,7 +3283,7 @@ var init_employees = __esm({
 
 // src/lib/license.ts
 import { readFileSync as readFileSync7, writeFileSync as writeFileSync3, existsSync as existsSync8, mkdirSync as mkdirSync5 } from "fs";
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 import path9 from "path";
 import { jwtVerify, importSPKI } from "jose";
 var LICENSE_PATH, CACHE_PATH, DEVICE_ID_PATH, PLAN_LIMITS;
@@ -3231,2156 +3382,2607 @@ var init_plan_limits = __esm({
   }
 });
 
-// src/lib/tmux-routing.ts
-import { execFileSync as execFileSync2, execSync as execSync4 } from "child_process";
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync4, mkdirSync as mkdirSync6, existsSync as existsSync10, appendFileSync } from "fs";
+// src/lib/notifications.ts
+import crypto3 from "crypto";
 import path11 from "path";
 import os6 from "os";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { unlinkSync as unlinkSync2 } from "fs";
-function spawnLockPath(sessionName) {
-  return path11.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
-}
-function isProcessAlive(pid) {
+import {
+  readFileSync as readFileSync9,
+  readdirSync as readdirSync2,
+  unlinkSync as unlinkSync2,
+  existsSync as existsSync10,
+  rmdirSync
+} from "fs";
+async function writeNotification(notification) {
   try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function acquireSpawnLock2(sessionName) {
-  if (!existsSync10(SPAWN_LOCK_DIR)) {
-    mkdirSync6(SPAWN_LOCK_DIR, { recursive: true });
-  }
-  const lockFile = spawnLockPath(sessionName);
-  if (existsSync10(lockFile)) {
-    try {
-      const lock = JSON.parse(readFileSync9(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)}
+`);
   }
-  writeFileSync4(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
-  return true;
 }
-function releaseSpawnLock2(sessionName) {
+async function markAsReadByTaskFile(taskFile) {
   try {
-    unlinkSync2(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 = path11.join(
-      path11.dirname(thisFile),
-      "..",
-      "bin",
-      "exe-export-behaviors.js"
-    );
-    return existsSync10(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(input) {
   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(),
+        input.sessionName,
+        input.agentId,
+        (/* @__PURE__ */ new Date()).toISOString(),
+        input.reason,
+        input.ticksIdle ?? null,
+        input.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(readFileSync9(path11.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
-    return data.parentExe || null;
-  } catch {
-    return null;
-  }
-}
-function getDispatchedBy(sessionKey) {
-  try {
-    const data = JSON.parse(readFileSync9(
-      path11.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 {
+var init_session_kill_telemetry = __esm({
+  "src/lib/session-kill-telemetry.ts"() {
+    "use strict";
+    init_database();
   }
-  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;
+});
+
+// src/lib/tasks-crud.ts
+import crypto5 from "crypto";
+import path12 from "path";
+import { execSync as execSync4 } from "child_process";
+import { mkdir as mkdir4, writeFile as writeFile4, appendFile } from "fs/promises";
+import { existsSync as existsSync11, readFileSync as readFileSync10 } from "fs";
+async function writeCheckpoint(input) {
+  const client = getClient();
+  const row = await resolveTask(client, input.taskId);
+  const taskId = String(row.id);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const blockedByIds = [];
+  if (row.blocked_by) {
+    blockedByIds.push(String(row.blocked_by));
   }
-  return null;
-}
-function readDebounceState() {
-  try {
-    if (!existsSync10(DEBOUNCE_FILE)) return {};
-    return JSON.parse(readFileSync9(DEBOUNCE_FILE, "utf8"));
-  } catch {
-    return {};
+  const checkpoint = {
+    step: input.step,
+    context_summary: input.contextSummary,
+    files_touched: input.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`);
   }
+  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 writeDebounceState(state) {
-  try {
-    if (!existsSync10(SESSION_CACHE)) mkdirSync6(SESSION_CACHE, { recursive: true });
-    writeFileSync4(DEBOUNCE_FILE, JSON.stringify(state));
-  } catch {
-  }
+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 isDebounced(targetSession) {
-  const state = readDebounceState();
-  const lastSent = state[targetSession] ?? 0;
-  return Date.now() - lastSent < INTERCOM_DEBOUNCE_MS;
+function slugify(title) {
+  return title.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
-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];
+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.`
+    );
   }
-  writeDebounceState(state);
-}
-function logIntercom(msg) {
-  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
-`;
-  process.stderr.write(`[intercom] ${msg}
-`);
-  try {
-    appendFileSync(INTERCOM_LOG2, line);
-  } catch {
+  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.`
+    );
   }
+  throw new Error(`Task not found: ${identifier}`);
 }
-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";
+async function createTaskCore(input) {
+  const client = getClient();
+  const id = crypto5.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const slug = slugify(input.title);
+  const taskFile = input.taskFile ?? `exe/${input.assignedTo}/${slug}.md`;
+  let blockedById = null;
+  const initialStatus = input.blockedBy ? "blocked" : "open";
+  if (input.blockedBy) {
+    const blocker = await resolveTask(client, input.blockedBy);
+    blockedById = String(blocker.id);
+  }
+  let parentTaskId = null;
+  let parentRef = input.parentTaskId;
+  if (!parentRef) {
+    const extracted = extractParentFromContext(input.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 (!input.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";
-  } catch {
-    return "offline";
   }
-}
-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";
+  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: [input.title, input.assignedTo]
+  });
+  if (dupCheck.rows.length > 0) {
+    warning = `similar active task already exists (${String(dupCheck.rows[0].id)}). Created new task anyway.`;
   }
-  if (isDebounced(targetSession)) {
-    logIntercom(`DEBOUNCE \u2192 ${targetSession} (cross-process file debounce)`);
-    return "debounced";
+  if (input.baseDir) {
+    try {
+      await mkdir4(path12.join(input.baseDir, "exe", "output"), { recursive: true });
+      await mkdir4(path12.join(input.baseDir, "exe", "research"), { recursive: true });
+      await ensureArchitectureDoc(input.baseDir, input.projectName);
+      await ensureGitignoreExe(input.baseDir);
+    } catch {
+    }
   }
+  const complexity = input.complexity ?? "standard";
+  let sessionScope = null;
   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";
+    const { resolveExeSession: resolveExeSession2 } = await Promise.resolve().then(() => (init_tmux_routing(), tmux_routing_exports));
+    sessionScope = resolveExeSession2();
   } catch {
-    logIntercom(`FAIL \u2192 ${targetSession}`);
-    return "failed";
   }
+  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,
+      input.title,
+      input.assignedTo,
+      input.assignedBy,
+      input.projectName,
+      input.priority,
+      initialStatus,
+      taskFile,
+      blockedById,
+      parentTaskId,
+      input.reviewer ?? null,
+      input.context,
+      complexity,
+      input.budgetTokens ?? null,
+      input.budgetFallbackModel ?? null,
+      0,
+      null,
+      sessionScope,
+      now,
+      now
+    ]
+  });
+  return {
+    id,
+    title: input.title,
+    assignedTo: input.assignedTo,
+    assignedBy: input.assignedBy,
+    projectName: input.projectName,
+    priority: input.priority,
+    status: initialStatus,
+    taskFile,
+    createdAt: now,
+    updatedAt: now,
+    warning,
+    budgetTokens: input.budgetTokens ?? null,
+    budgetFallbackModel: input.budgetFallbackModel ?? null,
+    tokensUsed: 0,
+    tokensWarnedAt: null
+  };
 }
-function notifyParentExe(sessionKey) {
-  const target = getDispatchedBy(sessionKey);
-  if (!target) {
-    process.stderr.write(`[intercom] notifyParentExe: no dispatcher found for key ${sessionKey}
-`);
-    return false;
+async function listTasks(input) {
+  const client = getClient();
+  const conditions = [];
+  const args = [];
+  if (input.assignedTo) {
+    conditions.push("assigned_to = ?");
+    args.push(input.assignedTo);
   }
-  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;
+  if (input.status) {
+    conditions.push("status = ?");
+    args.push(input.status);
+  } else {
+    conditions.push("status IN ('open', 'in_progress', 'blocked')");
   }
-  return true;
-}
-function ensureEmployee(employeeName, exeSession, projectDir, opts) {
-  if (employeeName === "exe") {
-    return { status: "failed", sessionName: "", error: "exe is the COO, not a dispatchable employee" };
+  if (input.projectName) {
+    conditions.push("project_name = ?");
+    args.push(input.projectName);
+  }
+  if (input.priority) {
+    conditions.push("priority = ?");
+    args.push(input.priority);
   }
   try {
-    assertEmployeeLimitSync();
-  } catch (err) {
-    if (err instanceof PlanLimitError) {
-      return { status: "failed", sessionName: "", error: err.message };
+    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);
     }
+  } catch {
   }
-  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
-    );
-    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 };
+  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 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 = path11.join(os6.homedir(), ".exe-os", "session-logs");
-  const logFile = path11.join(logDir, `${instanceLabel}-${Date.now()}.log`);
-  if (!existsSync10(logDir)) {
-    mkdirSync6(logDir, { recursive: true });
-  }
-  transport.kill(sessionName);
-  let cleanupSuffix = "";
+function checkStaleCompletion(taskContext, taskCreatedAt) {
+  if (!taskContext) return null;
+  if (!DELEGATION_KEYWORDS.test(taskContext)) return null;
   try {
-    const thisFile = fileURLToPath2(import.meta.url);
-    const cleanupScript = path11.join(path11.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
-    if (existsSync10(cleanupScript)) {
-      cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession}"`;
+    const since = new Date(taskCreatedAt).toISOString();
+    const branch = execSync4(
+      "git rev-parse --abbrev-ref HEAD 2>/dev/null",
+      { encoding: "utf8", timeout: 3e3 }
+    ).trim();
+    const branchArg = branch && branch !== "HEAD" ? branch : "";
+    const commitCount = execSync4(
+      `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;
   }
-  try {
-    const claudeJsonPath = path11.join(os6.homedir(), ".claude.json");
-    let claudeJson = {};
-    try {
-      claudeJson = JSON.parse(readFileSync9(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;
-    writeFileSync4(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
-  } catch {
+}
+async function updateTaskStatus(input) {
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const row = await resolveTask(client, input.taskId);
+  const taskId = String(row.id);
+  const taskFile = String(row.task_file);
+  if (input.status === "done" && String(row.assigned_by) === "system" && taskFile.includes("review-")) {
+    process.stderr.write(
+      `[updateTask] Review task "${String(row.title)}" being marked done (assigned to ${String(row.assigned_to)})
+`
+    );
   }
-  try {
-    const settingsDir = path11.join(os6.homedir(), ".claude", "projects");
-    const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
-    const projSettingsDir = path11.join(settingsDir, normalizedKey);
-    const settingsPath = path11.join(projSettingsDir, "settings.json");
-    let settings = {};
-    try {
-      settings = JSON.parse(readFileSync9(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 (input.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) {
+        input.result = input.result ? `\u26A0\uFE0F ${warning}
+
+${input.result}` : `\u26A0\uFE0F ${warning}`;
+        process.stderr.write(`[tasks] ${warning} (task: ${taskId})
+`);
       }
     }
-    if (changed) {
-      perms.allow = allow;
-      settings.permissions = perms;
-      mkdirSync6(projSettingsDir, { recursive: true });
-      writeFileSync4(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 = path11.join(
-      os6.homedir(),
-      ".exe-os",
-      "identity",
-      `${employeeName}.md`
-    );
-    _resetCcAgentSupportCache();
-    const hasAgentFlag = claudeSupportsAgentFlag();
-    if (hasAgentFlag) {
-      identityFlag = ` --agent ${employeeName}`;
-    } else if (existsSync10(identityPath)) {
-      identityFlag = ` --append-system-prompt-file ${identityPath}`;
-      legacyFallbackWarned = true;
+  if (input.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}`);
     }
-    const behaviorsFile = exportBehaviorsSync(
-      employeeName,
-      path11.basename(spawnCwd),
-      sessionName
-    );
-    if (behaviorsFile) {
-      behaviorsFlag = ` --append-system-prompt-file ${behaviorsFile}`;
+    try {
+      await writeCheckpoint({
+        taskId,
+        step: "claimed",
+        contextSummary: `Task claimed by session. Transitioning open \u2192 in_progress.`
+      });
+    } catch {
     }
+    return { row, taskFile, now, taskId };
   }
-  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.
-`
-    );
+  if (input.result) {
+    await client.execute({
+      sql: "UPDATE tasks SET status = ?, result = ?, updated_at = ? WHERE id = ?",
+      args: [input.status, input.result, now, taskId]
+    });
+  } else {
+    await client.execute({
+      sql: "UPDATE tasks SET status = ?, updated_at = ? WHERE id = ?",
+      args: [input.status, now, taskId]
+    });
   }
-  let sessionContextFlag = "";
   try {
-    const ctxDir = path11.join(os6.homedir(), ".exe-os", "session-cache");
-    mkdirSync6(ctxDir, { recursive: true });
-    const ctxFile = path11.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");
-    writeFileSync4(ctxFile, ctxContent);
-    sessionContextFlag = ` --append-system-prompt-file ${ctxFile}`;
+    await writeCheckpoint({
+      taskId,
+      step: `status_transition:${input.status}`,
+      contextSummary: input.result ? `Transitioned to ${input.status}. Result: ${input.result.slice(0, 500)}` : `Transitioned to ${input.status}.`
+    });
   } 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}`;
-      }
-    }
-  }
-  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}`;
-  }
-  const spawnResult = transport.spawn(sessionName, {
-    cwd: spawnCwd,
-    command: spawnCommand
-  });
-  if (spawnResult.error) {
-    releaseSpawnLock2(sessionName);
-    return { sessionName, error: `tmux new-session failed: ${spawnResult.error}` };
-  }
-  transport.pipeLog(sessionName, logFile);
-  try {
-    const mySession = getMySession();
-    const dispatchInfo = path11.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
-    writeFileSync4(dispatchInfo, JSON.stringify({
-      dispatchedBy: mySession,
-      rootExe: exeSession,
-      provider: useBinSymlink ? ccProvider : useExeAgent ? opts.provider : "anthropic",
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    }));
+  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 = path12.join(baseDir, "exe", "ARCHITECTURE.md");
+  try {
+    if (existsSync11(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 {
   }
-  let booted = false;
-  for (let i = 0; i < 30; i++) {
-    try {
-      execSync4("sleep 0.5");
-    } catch {
-    }
-    try {
-      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;
-        }
-      }
-    } catch {
-    }
-  }
-  if (!booted) {
-    releaseSpawnLock2(sessionName);
-    return { sessionName, error: `${useExeAgent ? "exe-agent" : "claude"} did not boot within 15s` };
-  }
-  if (!useExeAgent) {
-    try {
-      transport.sendKeys(sessionName, `/exe-call ${employeeName}`);
-    } catch {
+}
+async function ensureGitignoreExe(baseDir) {
+  const gitignorePath = path12.join(baseDir, ".gitignore");
+  try {
+    if (existsSync11(gitignorePath)) {
+      const content = readFileSync10(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 {
   }
-  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, INTERCOM_DEBOUNCE_MS, INTERCOM_LOG2, DEBOUNCE_FILE, DEBOUNCE_CLEANUP_AGE_MS, BUSY_PATTERN;
-var init_tmux_routing = __esm({
-  "src/lib/tmux-routing.ts"() {
+var DELEGATION_KEYWORDS, TASK_ALREADY_CLAIMED_PREFIX;
+var init_tasks_crud = __esm({
+  "src/lib/tasks-crud.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 = path11.join(os6.homedir(), ".exe-os", "spawn-locks");
-    SESSION_CACHE = path11.join(os6.homedir(), ".exe-os", "session-cache");
-    BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
-    INTERCOM_DEBOUNCE_MS = 3e4;
-    INTERCOM_LOG2 = path11.join(os6.homedir(), ".exe-os", "intercom.log");
-    DEBOUNCE_FILE = path11.join(SESSION_CACHE, "intercom-debounce.json");
-    DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
-    BUSY_PATTERN = /[✻✽✶✳·].*…|Running…/;
+    init_database();
+    DELEGATION_KEYWORDS = /parallel|delegate|wave|tom\d*-exe/i;
+    TASK_ALREADY_CLAIMED_PREFIX = "TASK_ALREADY_CLAIMED";
   }
 });
 
-// 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 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 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(input) {
+// src/lib/tasks-review.ts
+import path13 from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync3, unlinkSync as unlinkSync3 } from "fs";
+async function countPendingReviews() {
   const client = getClient();
-  const id = generateUlid();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const targetDevice = input.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,
-      input.fromAgent,
-      input.targetAgent,
-      input.targetProject ?? null,
-      targetDevice,
-      input.content,
-      input.priority ?? "normal",
-      now
-    ]
-  });
-  try {
-    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]
+    sql: "SELECT COUNT(*) as cnt FROM tasks WHERE status = 'needs_review'",
+    args: []
   });
-  return rowToMessage(result.rows[0]);
-}
-function setWsClientSend(fn) {
-  _wsClientSend = fn;
+  return Number(result.rows[0]?.cnt) || 0;
 }
-async function deliverCrossMachineMessage(messageId, targetDevice) {
+async function countNewPendingReviewsSince(sinceIso) {
   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
+    sql: `SELECT COUNT(*) as cnt FROM tasks
+          WHERE status = 'needs_review' AND updated_at > ?`,
+    args: [sinceIso]
   });
-  const sent = _wsClientSend(targetDevice, payload);
-  if (sent) {
-    await client.execute({
-      sql: "UPDATE messages SET status = 'synced' WHERE id = ?",
-      args: [messageId]
-    });
-    return true;
-  }
-  return false;
+  return Number(result.rows[0]?.cnt) || 0;
 }
-async function deliverLocalMessage(messageId) {
+async function listPendingReviews(limit) {
   const client = getClient();
   const result = await client.execute({
-    sql: "SELECT * FROM messages WHERE id = ?",
-    args: [messageId]
+    sql: `SELECT title, assigned_to, project_name FROM tasks
+          WHERE status = 'needs_review'
+          ORDER BY priority ASC, created_at DESC LIMIT ?`,
+    args: [limit]
   });
-  if (result.rows.length === 0) return false;
-  const msg = rowToMessage(result.rows[0]);
-  if (msg.status !== "pending") return false;
-  const targetAgent = msg.targetAgent;
+  return result.rows;
+}
+async function cleanupOrphanedReviews() {
+  const client = getClient();
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  try {
-    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_RETRIES2) {
-      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;
-  }
-}
-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));
-}
-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 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 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]
-  });
-  return result.rows.map((row) => rowToMessage(row));
-}
-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 getFailedMessages() {
-  const client = getClient();
-  const result = await client.execute({
-    sql: "SELECT * FROM messages WHERE status = 'failed' ORDER BY created_at DESC",
-    args: []
+  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]
   });
-  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_RETRIES2]
+  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]
   });
-  let delivered = 0;
-  for (const row of result.rows) {
-    const msg = rowToMessage(row);
-    try {
-      const success = await deliverLocalMessage(msg.id);
-      if (success) delivered++;
-    } catch {
-    }
+  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 delivered;
+  return total;
 }
-var MAX_RETRIES2, _wsClientSend;
-var init_messaging = __esm({
-  "src/lib/messaging.ts"() {
-    "use strict";
-    init_database();
-    init_tmux_routing();
-    MAX_RETRIES2 = 10;
-    _wsClientSend = null;
+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?"
+      ]
+    };
   }
-});
-
-// src/lib/notifications.ts
-import crypto4 from "crypto";
-import path12 from "path";
-import os7 from "os";
-import {
-  readFileSync as readFileSync10,
-  readdirSync as readdirSync2,
-  unlinkSync as unlinkSync3,
-  existsSync as existsSync11,
-  rmdirSync
-} from "fs";
-async function writeNotification(notification) {
+  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 cleanupReviewFile(row, taskFile, _baseDir) {
+  if (String(row.assigned_by) !== "system" || !taskFile.includes("review-")) return;
   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
-      ]
-    });
+    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(`[notifications] WRITE FAILED: ${err instanceof Error ? err.message : String(err)}
-`);
+    process.stderr.write(
+      `[review-cleanup] Failed to cascade original task: ${err instanceof Error ? err.message : String(err)}
+`
+    );
   }
-}
-async function markAsReadByTaskFile(taskFile) {
   try {
-    const client = getClient();
-    await client.execute({
-      sql: "UPDATE notifications SET read = 1 WHERE task_file = ? AND read = 0",
-      args: [taskFile]
-    });
+    const cacheDir = path13.join(EXE_AI_DIR, "session-cache");
+    if (existsSync12(cacheDir)) {
+      for (const f of readdirSync3(cacheDir)) {
+        if (f.startsWith("review-notified-")) {
+          unlinkSync3(path13.join(cacheDir, f));
+        }
+      }
+    }
   } catch {
   }
 }
-var init_notifications = __esm({
-  "src/lib/notifications.ts"() {
+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();
+  }
+});
 
-// src/lib/tasks-crud.ts
-import crypto5 from "crypto";
-import path13 from "path";
-import { execSync as execSync5 } from "child_process";
-import { mkdir as mkdir4, writeFile as writeFile4, appendFile } from "fs/promises";
-import { existsSync as existsSync12, readFileSync as readFileSync11 } from "fs";
-async function writeCheckpoint(input) {
+// src/lib/tasks-chain.ts
+import path14 from "path";
+import { readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
+async function cascadeUnblock(taskId, baseDir, now) {
   const client = getClient();
-  const row = await resolveTask(client, input.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: input.step,
-    context_summary: input.contextSummary,
-    files_touched: input.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]
+  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 (result.rowsAffected === 0) {
-    throw new Error(`Checkpoint write failed: task ${taskId} not found`);
+  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 = path14.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 {
+      }
+    }
   }
-  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 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.`
-    );
-  }
-  result = await client.execute({
-    sql: "SELECT * FROM tasks WHERE title LIKE ?",
-    args: [`%${identifier}%`]
+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]
   });
-  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 (nextResult.rows.length === 1) {
+    const nr = nextResult.rows[0];
+    return {
+      title: String(nr.title),
+      priority: String(nr.priority),
+      taskFile: String(nr.task_file)
+    };
   }
-  throw new Error(`Task not found: ${identifier}`);
+  return void 0;
 }
-async function createTaskCore(input) {
+async function checkSubtaskCompletion(parentTaskId, projectName) {
   const client = getClient();
-  const id = crypto5.randomUUID();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const slug = slugify(input.title);
-  const taskFile = input.taskFile ?? `exe/${input.assignedTo}/${slug}.md`;
-  let blockedById = null;
-  const initialStatus = input.blockedBy ? "blocked" : "open";
-  if (input.blockedBy) {
-    const blocker = await resolveTask(client, input.blockedBy);
-    blockedById = String(blocker.id);
-  }
-  let parentTaskId = null;
-  let parentRef = input.parentTaskId;
-  if (!parentRef) {
-    const extracted = extractParentFromContext(input.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 (!input.parentTaskId) {
-        throw new Error(
-          `create_task: parent reference "${parentRef}" in context body does not resolve to an existing task`
-        );
-      }
-      throw err;
+  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)
+      });
     }
   }
-  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: [input.title, input.assignedTo]
-  });
-  if (dupCheck.rows.length > 0) {
-    warning = `similar active task already exists (${String(dupCheck.rows[0].id)}). Created new task anyway.`;
+}
+var init_tasks_chain = __esm({
+  "src/lib/tasks-chain.ts"() {
+    "use strict";
+    init_database();
+    init_notifications();
   }
-  if (input.baseDir) {
+});
+
+// src/lib/project-name.ts
+import { execSync as execSync5 } from "child_process";
+import path15 from "path";
+function getProjectName(cwd) {
+  const dir = cwd ?? process.cwd();
+  if (_cached2 && _cachedCwd === dir) return _cached2;
+  try {
+    let repoRoot;
     try {
-      await mkdir4(path13.join(input.baseDir, "exe", "output"), { recursive: true });
-      await mkdir4(path13.join(input.baseDir, "exe", "research"), { recursive: true });
-      await ensureArchitectureDoc(input.baseDir, input.projectName);
-      await ensureGitignoreExe(input.baseDir);
+      const gitCommonDir = execSync5("git rev-parse --path-format=absolute --git-common-dir", {
+        cwd: dir,
+        encoding: "utf8",
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      repoRoot = path15.dirname(gitCommonDir);
     } catch {
+      repoRoot = execSync5("git rev-parse --show-toplevel", {
+        cwd: dir,
+        encoding: "utf8",
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
     }
+    _cached2 = path15.basename(repoRoot);
+    _cachedCwd = dir;
+    return _cached2;
+  } catch {
+    _cached2 = path15.basename(dir);
+    _cachedCwd = dir;
+    return _cached2;
   }
-  const complexity = input.complexity ?? "standard";
-  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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    args: [
-      id,
-      input.title,
-      input.assignedTo,
-      input.assignedBy,
-      input.projectName,
-      input.priority,
-      initialStatus,
-      taskFile,
-      blockedById,
-      parentTaskId,
-      input.reviewer ?? null,
-      input.context,
-      complexity,
-      input.budgetTokens ?? null,
-      input.budgetFallbackModel ?? null,
-      0,
-      null,
-      now,
-      now
-    ]
-  });
-  return {
-    id,
-    title: input.title,
-    assignedTo: input.assignedTo,
-    assignedBy: input.assignedBy,
-    projectName: input.projectName,
-    priority: input.priority,
-    status: initialStatus,
-    taskFile,
-    createdAt: now,
-    updatedAt: now,
-    warning,
-    budgetTokens: input.budgetTokens ?? null,
-    budgetFallbackModel: input.budgetFallbackModel ?? null,
-    tokensUsed: 0,
-    tokensWarnedAt: null
-  };
 }
-async function listTasks(input) {
-  const client = getClient();
-  const conditions = [];
-  const args = [];
-  if (input.assignedTo) {
-    conditions.push("assigned_to = ?");
-    args.push(input.assignedTo);
-  }
-  if (input.status) {
-    conditions.push("status = ?");
-    args.push(input.status);
-  } else {
-    conditions.push("status IN ('open', 'in_progress', 'blocked')");
-  }
-  if (input.projectName) {
-    conditions.push("project_name = ?");
-    args.push(input.projectName);
+var _cached2, _cachedCwd;
+var init_project_name = __esm({
+  "src/lib/project-name.ts"() {
+    "use strict";
+    _cached2 = null;
+    _cachedCwd = null;
   }
-  if (input.priority) {
-    conditions.push("priority = ?");
-    args.push(input.priority);
+});
+
+// src/lib/session-scope.ts
+var session_scope_exports = {};
+__export(session_scope_exports, {
+  assertSessionScope: () => assertSessionScope,
+  findSessionForProject: () => findSessionForProject,
+  getSessionProject: () => getSessionProject
+});
+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 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;
   }
-  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
-  }));
+  return null;
 }
-function checkStaleCompletion(taskContext, taskCreatedAt) {
-  if (!taskContext) return null;
-  if (!DELEGATION_KEYWORDS.test(taskContext)) return null;
+function assertSessionScope(actionType, targetProject) {
   try {
-    const since = new Date(taskCreatedAt).toISOString();
-    const branch = execSync5(
-      "git rev-parse --abbrev-ref HEAD 2>/dev/null",
-      { encoding: "utf8", timeout: 3e3 }
-    ).trim();
-    const branchArg = branch && branch !== "HEAD" ? branch : "";
-    const commitCount = execSync5(
-      `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.";
+    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
+      };
     }
-    return null;
-  } catch {
-    return null;
-  }
-}
-async function updateTaskStatus(input) {
-  const client = getClient();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const row = await resolveTask(client, input.taskId);
-  const taskId = String(row.id);
-  const taskFile = String(row.task_file);
-  if (input.status === "done" && String(row.assigned_by) === "system" && taskFile.includes("review-")) {
     process.stderr.write(
-      `[updateTask] Review task "${String(row.title)}" being marked done (assigned to ${String(row.assigned_to)})
+      `[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" };
   }
-  if (input.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) {
-        input.result = input.result ? `\u26A0\uFE0F ${warning}
+}
+var init_session_scope = __esm({
+  "src/lib/session-scope.ts"() {
+    "use strict";
+    init_session_registry();
+    init_project_name();
+    init_tmux_routing();
+  }
+});
 
-${input.result}` : `\u26A0\uFE0F ${warning}`;
-        process.stderr.write(`[tasks] ${warning} (task: ${taskId})
-`);
+// src/lib/tasks-notify.ts
+async function dispatchTaskToEmployee(input) {
+  if (input.assignedTo === "exe") return { dispatched: "skipped" };
+  let crossProject = false;
+  if (input.projectName) {
+    try {
+      const { assertSessionScope: assertSessionScope2 } = (init_session_scope(), __toCommonJS(session_scope_exports));
+      const check = assertSessionScope2("dispatch_task", input.projectName);
+      if (check.reason === "cross_session_denied") {
+        crossProject = true;
+        return { dispatched: "skipped", crossProject: true };
       }
+    } catch {
     }
   }
-  if (input.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}`);
-    }
-    try {
-      await writeCheckpoint({
-        taskId,
-        step: "claimed",
-        contextSummary: `Task claimed by session. Transitioning open \u2192 in_progress.`
+  try {
+    const transport = getTransport();
+    const exeSession = resolveExeSession();
+    if (!exeSession) return { dispatched: "session_missing" };
+    const sessionName = employeeSessionName(input.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 {
+      const projectDir = input.projectDir ?? process.cwd();
+      const result = ensureEmployee(input.assignedTo, exeSession, projectDir, {
+        autoInstance: isMultiInstance(input.assignedTo)
       });
-    } catch {
+      if (result.status === "failed") {
+        process.stderr.write(
+          `[dispatch] Failed to spawn ${input.assignedTo}: ${result.error}
+`
+        );
+        return { dispatched: "session_missing" };
+      }
+      return { dispatched: "spawned", session: result.sessionName, crossProject };
     }
-    return { row, taskFile, now, taskId };
+  } catch {
+    return { dispatched: "session_missing" };
   }
-  if (input.result) {
-    await client.execute({
-      sql: "UPDATE tasks SET status = ?, result = ?, updated_at = ? WHERE id = ?",
-      args: [input.status, input.result, now, taskId]
-    });
-  } else {
-    await client.execute({
-      sql: "UPDATE tasks SET status = ?, updated_at = ? WHERE id = ?",
-      args: [input.status, now, taskId]
-    });
+}
+function notifyTaskDone() {
+  try {
+    const key = getSessionKey();
+    if (key && !process.env.VITEST) notifyParentExe(key);
+  } catch {
   }
+}
+async function markTaskNotificationsRead(taskFile) {
   try {
-    await writeCheckpoint({
-      taskId,
-      step: `status_transition:${input.status}`,
-      contextSummary: input.result ? `Transitioned to ${input.status}. Result: ${input.result.slice(0, 500)}` : `Transitioned to ${input.status}.`
-    });
+    await markAsReadByTaskFile(taskFile);
   } catch {
   }
-  return { row, taskFile, now, taskId };
 }
-async function deleteTaskCore(taskId, _baseDir) {
+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 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 = path13.join(baseDir, "exe", "ARCHITECTURE.md");
-  try {
-    if (existsSync12(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 = path13.join(baseDir, ".gitignore");
-  try {
-    if (existsSync12(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 id = crypto6.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await client.execute({
+    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;
 }
-var DELEGATION_KEYWORDS, TASK_ALREADY_CLAIMED_PREFIX;
-var init_tasks_crud = __esm({
-  "src/lib/tasks-crud.ts"() {
+var init_behaviors = __esm({
+  "src/lib/behaviors.ts"() {
     "use strict";
     init_database();
-    DELEGATION_KEYWORDS = /parallel|delegate|wave|tom\d*-exe/i;
-    TASK_ALREADY_CLAIMED_PREFIX = "TASK_ALREADY_CLAIMED";
   }
 });
 
-// src/lib/tasks-review.ts
-import path14 from "path";
-import { existsSync as existsSync13, readdirSync as readdirSync3, unlinkSync as unlinkSync4 } from "fs";
-async function countPendingReviews() {
+// 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();
   const result = await client.execute({
-    sql: "SELECT COUNT(*) as cnt FROM tasks WHERE status = 'needs_review'",
-    args: []
+    sql: `SELECT tool_name, raw_text
+          FROM memories
+          WHERE task_id = ? AND agent_id = ?
+          ORDER BY timestamp ASC`,
+    args: [taskId, agentId]
   });
-  return Number(result.rows[0]?.cnt) || 0;
+  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 countNewPendingReviewsSince(sinceIso) {
+function hashSignature(signature) {
+  return crypto7.createHash("sha256").update(signature.join("|")).digest("hex").slice(0, 16);
+}
+async function storeTrajectory(opts) {
   const client = getClient();
-  const result = await client.execute({
-    sql: `SELECT COUNT(*) as cnt FROM tasks
-          WHERE status = 'needs_review' AND updated_at > ?`,
-    args: [sinceIso]
+  const id = crypto7.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const signatureHash = hashSignature(opts.signature);
+  await client.execute({
+    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 Number(result.rows[0]?.cnt) || 0;
+  return id;
 }
-async function listPendingReviews(limit) {
+async function findSimilarTrajectories(signature, threshold = DEFAULT_SKILL_THRESHOLD) {
   const client = getClient();
+  const hash = hashSignature(signature);
   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 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;
-}
-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 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)
   });
-  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 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
+    ]
   });
-  const total = r1.rowsAffected + r2.rowsAffected;
-  if (total > 0) {
-    process.stderr.write(
-      `[cleanup] Closed ${total} orphaned review(s): ${r1.rowsAffected} cascade + ${r2.rowsAffected} stale
-`
-    );
+  for (const r of nearResult.rows) {
+    const candidateSig = JSON.parse(String(r.signature));
+    if (editDistance(signature, candidateSig) <= 2) {
+      matches.push(mapRow(r));
+    }
   }
-  return total;
+  return matches;
 }
-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?"
-      ]
-    };
+async function captureTrajectory(opts) {
+  const signature = await extractTrajectory(opts.taskId, opts.agentId);
+  if (signature.length < 3) {
+    return { trajectoryId: "", similarCount: 0, similar: [] };
   }
-  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 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}
+  const trajectoryId = await storeTrajectory({
+    taskId: opts.taskId,
+    agentId: opts.agentId,
+    projectName: opts.projectName,
+    taskTitle: opts.taskTitle,
+    signature
+  });
+  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 config2 = await loadConfig();
+  const skillModel = model ?? config2.skillModel;
+  const Anthropic4 = (await import("@anthropic-ai/sdk")).default;
+  const client = new Anthropic4();
+  const prompt = buildExtractionPrompt(trajectories);
+  const response = await client.messages.create({
+    model: skillModel,
+    max_tokens: 500,
+    messages: [{ role: "user", content: prompt }]
+  });
+  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}
 `
-        );
-      }
-    } 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) {
+  );
+  return skillId;
+}
+async function captureAndLearn(opts) {
+  try {
+    const config2 = await loadConfig();
+    if (!config2.skillLearning) return;
+    const { trajectoryId, similarCount, similar } = await captureTrajectory({
+      ...opts,
+      skillThreshold: config2.skillThreshold
+    });
+    if (!trajectoryId) return;
+    if (similarCount >= config2.skillThreshold) {
+      const unprocessed = similar.filter((t) => !t.skillId);
+      if (unprocessed.length >= config2.skillThreshold) {
+        extractSkill(unprocessed, config2.skillModel).catch((err) => {
           process.stderr.write(
-            `[review-cleanup] Cascaded original task to done (legacy path): ${originalTaskFile}
+            `[skill-learning] Extraction failed: ${err instanceof Error ? err.message : String(err)}
 `
           );
-        }
+        });
       }
     }
   } catch (err) {
     process.stderr.write(
-      `[review-cleanup] Failed to cascade original task: ${err instanceof Error ? err.message : String(err)}
+      `[skill-learning] captureAndLearn failed: ${err instanceof Error ? err.message : String(err)}
 `
     );
   }
-  try {
-    const cacheDir = path14.join(EXE_AI_DIR, "session-cache");
-    if (existsSync13(cacheDir)) {
-      for (const f of readdirSync3(cacheDir)) {
-        if (f.startsWith("review-notified-")) {
-          unlinkSync4(path14.join(cacheDir, f));
-        }
-      }
+}
+async function sweepTrajectories(threshold, model) {
+  const config2 = await loadConfig();
+  if (!config2.skillLearning) return { clustersProcessed: 0, skillsExtracted: 0 };
+  const t = threshold ?? config2.skillThreshold;
+  const client = getClient();
+  const result = await client.execute({
+    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 clustersProcessed = 0;
+  let skillsExtracted = 0;
+  for (const row of result.rows) {
+    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 ?? config2.skillModel);
+      if (skillId) skillsExtracted++;
     }
-  } catch {
   }
+  return { clustersProcessed, skillsExtracted };
 }
-var init_tasks_review = __esm({
-  "src/lib/tasks-review.ts"() {
+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();
-    init_employees();
-    init_notifications();
-    init_tasks_crud();
-    init_tmux_routing();
-    init_session_key();
+    DEFAULT_SKILL_THRESHOLD = 3;
   }
 });
 
-// src/lib/tasks-chain.ts
-import path15 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]
+// 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 path16 from "path";
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync6, unlinkSync as unlinkSync4 } from "fs";
+async function createTask(input) {
+  const result = await createTaskCore(input);
+  if (!input.skipDispatch && result.status !== "blocked" && !process.env.VITEST) {
+    dispatchTaskToEmployee({
+      assignedTo: input.assignedTo,
+      title: input.title,
+      priority: input.priority,
+      taskFile: result.taskFile,
+      initialStatus: result.status,
+      projectName: input.projectName
     });
-    for (const ur of unblockedRows.rows) {
+  }
+  return result;
+}
+async function updateTask(input) {
+  const { row, taskFile, now, taskId } = await updateTaskStatus(input);
+  try {
+    const agent = String(row.assigned_to);
+    const cacheDir = path16.join(EXE_AI_DIR, "session-cache");
+    const cachePath = path16.join(cacheDir, `current-task-${agent}.json`);
+    if (input.status === "in_progress") {
+      mkdirSync6(cacheDir, { recursive: true });
+      writeFileSync4(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
+    } else if (input.status === "done" || input.status === "blocked" || input.status === "cancelled") {
       try {
-        const ubFile = path15.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");
+        unlinkSync4(cachePath);
       } catch {
       }
     }
+  } catch {
   }
-}
-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]
-  });
-  if (nextResult.rows.length === 1) {
-    const nr = nextResult.rows[0];
-    return {
-      title: String(nr.title),
-      priority: String(nr.priority),
-      taskFile: String(nr.task_file)
-    };
+  if (input.status === "done") {
+    await cleanupReviewFile(row, taskFile, input.baseDir);
   }
-  return void 0;
-}
-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)
+  if (input.status === "done" || input.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 = input.status === "done" || input.status === "needs_review";
+  if (isTerminal) {
+    const isExe = String(row.assigned_to) === "exe";
+    if (!isExe) {
+      notifyTaskDone();
+    }
+    await markTaskNotificationsRead(taskFile);
+    if (input.status === "done") {
+      try {
+        await cascadeUnblock(taskId, input.baseDir, now);
+      } catch {
+      }
+      orgBus.emit({
+        type: "task_completed",
+        taskId,
+        employee: String(row.assigned_to),
+        result: input.result ?? "",
+        timestamp: now
       });
+      if (row.parent_task_id) {
+        try {
+          await checkSubtaskCompletion(String(row.parent_task_id), String(row.project_name));
+        } catch {
+        }
+      }
     }
   }
-}
-var init_tasks_chain = __esm({
-  "src/lib/tasks-chain.ts"() {
-    "use strict";
-    init_database();
-    init_notifications();
+  if (input.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)}
+`
+      );
+    });
   }
-});
-
-// src/lib/project-name.ts
-import { execSync as execSync6 } from "child_process";
-import path16 from "path";
-function getProjectName(cwd) {
-  const dir = cwd ?? process.cwd();
-  if (_cached2 && _cachedCwd === dir) return _cached2;
-  try {
-    let repoRoot;
+  let nextTask;
+  if (isTerminal && String(row.assigned_to) !== "exe") {
     try {
-      const gitCommonDir = execSync6("git rev-parse --path-format=absolute --git-common-dir", {
-        cwd: dir,
-        encoding: "utf8",
-        timeout: 2e3,
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trim();
-      repoRoot = path16.dirname(gitCommonDir);
+      nextTask = await findNextTask(String(row.assigned_to));
     } catch {
-      repoRoot = execSync6("git rev-parse --show-toplevel", {
-        cwd: dir,
-        encoding: "utf8",
-        timeout: 2e3,
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trim();
     }
-    _cached2 = path16.basename(repoRoot);
-    _cachedCwd = dir;
-    return _cached2;
-  } catch {
-    _cached2 = path16.basename(dir);
-    _cachedCwd = dir;
-    return _cached2;
   }
+  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: input.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
+  };
 }
-var _cached2, _cachedCwd;
-var init_project_name = __esm({
-  "src/lib/project-name.ts"() {
+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";
-    _cached2 = null;
-    _cachedCwd = null;
+    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/session-scope.ts
-var session_scope_exports = {};
-__export(session_scope_exports, {
-  assertSessionScope: () => assertSessionScope,
-  findSessionForProject: () => findSessionForProject,
-  getSessionProject: () => getSessionProject
+// 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 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 resumeTaskTitle(agentId) {
+  return `${RESUME_TITLE_PREFIX} ${agentId} hit context capacity \u2014 continue open tasks`;
 }
-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;
+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;
   }
-  return null;
+  if (now - pendingSince > CONFIRMATION_WINDOW_MS) {
+    _pendingCapacityKill.set(agentId, now);
+    return false;
+  }
+  _pendingCapacityKill.delete(agentId);
+  return true;
 }
-function assertSessionScope(actionType, targetProject) {
+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 {
-    const currentProject = getProjectName();
-    const exeSession = resolveExeSession();
-    if (!exeSession) {
-      return { allowed: true, reason: "no_session" };
+    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 (currentProject === targetProject) {
-      return {
-        allowed: true,
-        reason: "same_session",
-        currentProject,
-        targetProject
-      };
+    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(
-      `[session-scope] Cross-project ${actionType}: session project="${currentProject}" \u2260 target project="${targetProject}"
+      `[capacity-monitor] Detected ${agentId} at capacity in session ${windowName} (confirmed). Auto-relaunching.
 `
     );
-    return {
-      allowed: true,
-      // v1: warn-only, don't block
-      reason: "cross_session_granted",
-      currentProject,
-      targetProject,
-      targetSession: findSessionForProject(targetProject)?.windowName
-    };
-  } catch {
-    return { allowed: true, reason: "no_session" };
+    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 init_session_scope = __esm({
-  "src/lib/session-scope.ts"() {
+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_project_name();
+    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/tasks-notify.ts
-async function dispatchTaskToEmployee(input) {
-  if (input.assignedTo === "exe") return { dispatched: "skipped" };
-  let crossProject = false;
-  if (input.projectName) {
+// 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 execSync6 } from "child_process";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync5, mkdirSync as mkdirSync7, existsSync as existsSync13, appendFileSync } from "fs";
+import path17 from "path";
+import os7 from "os";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { unlinkSync as unlinkSync5 } from "fs";
+function spawnLockPath(sessionName) {
+  return path17.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function acquireSpawnLock2(sessionName) {
+  if (!existsSync13(SPAWN_LOCK_DIR)) {
+    mkdirSync7(SPAWN_LOCK_DIR, { recursive: true });
+  }
+  const lockFile = spawnLockPath(sessionName);
+  if (existsSync13(lockFile)) {
     try {
-      const { assertSessionScope: assertSessionScope2 } = (init_session_scope(), __toCommonJS(session_scope_exports));
-      const check = assertSessionScope2("dispatch_task", input.projectName);
-      if (check.reason === "cross_session_granted") {
-        crossProject = true;
+      const lock = JSON.parse(readFileSync11(lockFile, "utf8"));
+      const age = Date.now() - lock.timestamp;
+      if (isProcessAlive(lock.pid) && age < 6e4) {
+        return false;
       }
     } catch {
     }
   }
+  writeFileSync5(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
+  return true;
+}
+function releaseSpawnLock2(sessionName) {
   try {
-    const transport = getTransport();
-    const exeSession = resolveExeSession();
-    if (!exeSession) return { dispatched: "session_missing" };
-    const sessionName = employeeSessionName(input.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 {
-      const projectDir = input.projectDir ?? process.cwd();
-      const result = ensureEmployee(input.assignedTo, exeSession, projectDir, {
-        autoInstance: isMultiInstance(input.assignedTo)
-      });
-      if (result.status === "failed") {
-        process.stderr.write(
-          `[dispatch] Failed to spawn ${input.assignedTo}: ${result.error}
+    unlinkSync5(spawnLockPath(sessionName));
+  } catch {
+  }
+}
+function resolveBehaviorsExporterScript() {
+  try {
+    const thisFile = fileURLToPath2(import.meta.url);
+    const scriptPath = path17.join(
+      path17.dirname(thisFile),
+      "..",
+      "bin",
+      "exe-export-behaviors.js"
+    );
+    return existsSync13(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 { dispatched: "session_missing" };
-      }
-      return { dispatched: "spawned", session: result.sessionName, crossProject };
+    );
+    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 (!existsSync13(SESSION_CACHE)) {
+    mkdirSync7(SESSION_CACHE, { recursive: true });
+  }
+  const rootExe = extractRootExe(parentExe) ?? parentExe;
+  const filePath = path17.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
+  writeFileSync5(filePath, JSON.stringify({
+    parentExe: rootExe,
+    dispatchedBy: dispatchedBy || rootExe,
+    registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+  }));
+}
+function getParentExe(sessionKey) {
+  try {
+    const data = JSON.parse(readFileSync11(path17.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    return data.parentExe || null;
   } catch {
-    return { dispatched: "session_missing" };
+    return null;
   }
 }
-function notifyTaskDone() {
+function getDispatchedBy(sessionKey) {
   try {
-    const key = getSessionKey();
-    if (key && !process.env.VITEST) notifyParentExe(key);
+    const data = JSON.parse(readFileSync11(
+      path17.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
+      "utf8"
+    ));
+    return data.dispatchedBy ?? data.parentExe ?? null;
   } catch {
+    return null;
   }
 }
-async function markTaskNotificationsRead(taskFile) {
+function resolveExeSession() {
+  const mySession = getMySession();
+  if (!mySession) return null;
   try {
-    await markAsReadByTaskFile(taskFile);
+    const key = getSessionKey();
+    const parentExe = getParentExe(key);
+    if (parentExe) {
+      return extractRootExe(parentExe) ?? parentExe;
+    }
   } catch {
   }
+  return extractRootExe(mySession) ?? mySession;
 }
-var init_tasks_notify = __esm({
-  "src/lib/tasks-notify.ts"() {
-    "use strict";
-    init_tmux_routing();
-    init_session_key();
-    init_notifications();
-    init_transport();
-    init_employees();
+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;
   }
-});
-
-// 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: `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;
+  return null;
 }
-var init_behaviors = __esm({
-  "src/lib/behaviors.ts"() {
-    "use strict";
-    init_database();
+async function verifyPaneAtCapacity(sessionName) {
+  const transport = getTransport();
+  if (!transport.isAlive(sessionName)) {
+    return { atCapacity: false, reason: `session ${sessionName} is not alive` };
   }
-});
-
-// 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();
-  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);
-    }
+  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)}`
+    };
   }
-  return signature;
-}
-function hashSignature(signature) {
-  return crypto7.createHash("sha256").update(signature.join("|")).digest("hex").slice(0, 16);
+  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"
+  };
 }
-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: `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;
+function readDebounceState() {
+  try {
+    if (!existsSync13(DEBOUNCE_FILE)) return {};
+    return JSON.parse(readFileSync11(DEBOUNCE_FILE, "utf8"));
+  } catch {
+    return {};
+  }
 }
-async function findSimilarTrajectories(signature, threshold = DEFAULT_SKILL_THRESHOLD) {
-  const client = getClient();
-  const hash = hashSignature(signature);
-  const result = 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 signature_hash = ?
-          ORDER BY created_at DESC
-          LIMIT 20`,
-    args: [hash]
-  });
-  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)
-  });
-  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
-    ]
-  });
-  for (const r of nearResult.rows) {
-    const candidateSig = JSON.parse(String(r.signature));
-    if (editDistance(signature, candidateSig) <= 2) {
-      matches.push(mapRow(r));
+function writeDebounceState(state) {
+  try {
+    if (!existsSync13(SESSION_CACHE)) mkdirSync7(SESSION_CACHE, { recursive: true });
+    writeFileSync5(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";
   }
-  return matches;
 }
-async function captureTrajectory(opts) {
-  const signature = await extractTrajectory(opts.taskId, opts.agentId);
-  if (signature.length < 3) {
-    return { trajectoryId: "", similarCount: 0, similar: [] };
+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";
   }
-  const trajectoryId = await storeTrajectory({
-    taskId: opts.taskId,
-    agentId: opts.agentId,
-    projectName: opts.projectName,
-    taskTitle: opts.taskTitle,
-    signature
-  });
-  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.`;
+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;
 }
-async function extractSkill(trajectories, model) {
-  if (trajectories.length === 0) return null;
-  const config2 = await loadConfig();
-  const skillModel = model ?? config2.skillModel;
-  const Anthropic4 = (await import("@anthropic-ai/sdk")).default;
-  const client = new Anthropic4();
-  const prompt = buildExtractionPrompt(trajectories);
-  const response = await client.messages.create({
-    model: skillModel,
-    max_tokens: 500,
-    messages: [{ role: "user", content: prompt }]
-  });
-  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]
-    });
+function ensureEmployee(employeeName, exeSession, projectDir, opts) {
+  if (employeeName === "exe") {
+    return { status: "failed", sessionName: "", error: "exe is the COO, not a dispatchable employee" };
   }
-  process.stderr.write(
-    `[skill-learning] Skill extracted from ${trajectories.length} trajectories \u2192 behavior ${skillId}
+  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}".
 `
-  );
-  return skillId;
+      );
+      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 };
 }
-async function captureAndLearn(opts) {
+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 = path17.join(os7.homedir(), ".exe-os", "session-logs");
+  const logFile = path17.join(logDir, `${instanceLabel}-${Date.now()}.log`);
+  if (!existsSync13(logDir)) {
+    mkdirSync7(logDir, { recursive: true });
+  }
+  transport.kill(sessionName);
+  let cleanupSuffix = "";
   try {
-    const config2 = await loadConfig();
-    if (!config2.skillLearning) return;
-    const { trajectoryId, similarCount, similar } = await captureTrajectory({
-      ...opts,
-      skillThreshold: config2.skillThreshold
-    });
-    if (!trajectoryId) return;
-    if (similarCount >= config2.skillThreshold) {
-      const unprocessed = similar.filter((t) => !t.skillId);
-      if (unprocessed.length >= config2.skillThreshold) {
-        extractSkill(unprocessed, config2.skillModel).catch((err) => {
-          process.stderr.write(
-            `[skill-learning] Extraction failed: ${err instanceof Error ? err.message : String(err)}
+    const thisFile = fileURLToPath2(import.meta.url);
+    const cleanupScript = path17.join(path17.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
+    if (existsSync13(cleanupScript)) {
+      cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession}"`;
+    }
+  } catch {
+  }
+  try {
+    const claudeJsonPath = path17.join(os7.homedir(), ".claude.json");
+    let claudeJson = {};
+    try {
+      claudeJson = JSON.parse(readFileSync11(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");
+  } catch {
+  }
+  try {
+    const settingsDir = path17.join(os7.homedir(), ".claude", "projects");
+    const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
+    const projSettingsDir = path17.join(settingsDir, normalizedKey);
+    const settingsPath = path17.join(projSettingsDir, "settings.json");
+    let settings = {};
+    try {
+      settings = JSON.parse(readFileSync11(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 });
+      writeFileSync5(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 = path17.join(
+      os7.homedir(),
+      ".exe-os",
+      "identity",
+      `${employeeName}.md`
+    );
+    _resetCcAgentSupportCache();
+    const hasAgentFlag = claudeSupportsAgentFlag();
+    if (hasAgentFlag) {
+      identityFlag = ` --agent ${employeeName}`;
+    } else if (existsSync13(identityPath)) {
+      identityFlag = ` --append-system-prompt-file ${identityPath}`;
+      legacyFallbackWarned = true;
+    }
+    const behaviorsFile = exportBehaviorsSync(
+      employeeName,
+      path17.basename(spawnCwd),
+      sessionName
+    );
+    if (behaviorsFile) {
+      behaviorsFlag = ` --append-system-prompt-file ${behaviorsFile}`;
+    }
+  }
+  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.
 `
-          );
-        });
+    );
+  }
+  let sessionContextFlag = "";
+  try {
+    const ctxDir = path17.join(os7.homedir(), ".exe-os", "session-cache");
+    mkdirSync7(ctxDir, { recursive: true });
+    const ctxFile = path17.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}`;
       }
     }
-  } catch (err) {
+  }
+  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(
-      `[skill-learning] captureAndLearn failed: ${err instanceof Error ? err.message : String(err)}
+      `[tmux-routing] provider cascade: ${ccProvider} \u2192 spawning ${binName}
 `
     );
+    spawnCommand = `${envPrefix} ${binName}${cleanupSuffix}`;
+  } else {
+    spawnCommand = `${envPrefix} claude --dangerously-skip-permissions${identityFlag}${behaviorsFlag}${sessionContextFlag}${cleanupSuffix}`;
   }
-}
-async function sweepTrajectories(threshold, model) {
-  const config2 = await loadConfig();
-  if (!config2.skillLearning) return { clustersProcessed: 0, skillsExtracted: 0 };
-  const t = threshold ?? config2.skillThreshold;
-  const client = getClient();
-  const result = await client.execute({
-    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]
+  const spawnResult = transport.spawn(sessionName, {
+    cwd: spawnCwd,
+    command: spawnCommand
   });
-  let clustersProcessed = 0;
-  let skillsExtracted = 0;
-  for (const row of result.rows) {
-    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 (spawnResult.error) {
+    releaseSpawnLock2(sessionName);
+    return { sessionName, error: `tmux new-session failed: ${spawnResult.error}` };
+  }
+  transport.pipeLog(sessionName, logFile);
+  try {
+    const mySession = getMySession();
+    const dispatchInfo = path17.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()
     }));
-    if (trajectories.length >= t) {
-      clustersProcessed++;
-      const skillId = await extractSkill(trajectories, model ?? config2.skillModel);
-      if (skillId) skillsExtracted++;
+  } catch {
+  }
+  let booted = false;
+  for (let i = 0; i < 30; i++) {
+    try {
+      execSync6("sleep 0.5");
+    } catch {
+    }
+    try {
+      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;
+        }
+      }
+    } catch {
     }
   }
-  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
-      );
+  if (!booted) {
+    releaseSpawnLock2(sessionName);
+    return { sessionName, error: `${useExeAgent ? "exe-agent" : "claude"} did not boot within 15s` };
+  }
+  if (!useExeAgent) {
+    try {
+      transport.sendKeys(sessionName, `/exe-call ${employeeName}`);
+    } catch {
     }
   }
-  return dp[m][n];
+  registerSession({
+    windowName: sessionName,
+    agentId: employeeName,
+    projectDir: spawnCwd,
+    parentExe: exeSession,
+    pid: 0,
+    registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  releaseSpawnLock2(sessionName);
+  return { sessionName };
 }
-var DEFAULT_SKILL_THRESHOLD;
-var init_skill_learning = __esm({
-  "src/lib/skill-learning.ts"() {
+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_database();
-    init_behaviors();
-    init_config();
-    DEFAULT_SKILL_THRESHOLD = 3;
+    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 = path17.join(os7.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path17.join(os7.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 = path17.join(os7.homedir(), ".exe-os", "intercom.log");
+    DEBOUNCE_FILE = path17.join(SESSION_CACHE, "intercom-debounce.json");
+    DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
+    BUSY_PATTERN = /[✻✽✶✳·].*…|Running…/;
   }
 });
 
-// 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
+// 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 path17 from "path";
-import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync7, unlinkSync as unlinkSync5 } from "fs";
-async function createTask(input) {
-  const result = await createTaskCore(input);
-  if (!input.skipDispatch && result.status !== "blocked" && !process.env.VITEST) {
-    dispatchTaskToEmployee({
-      assignedTo: input.assignedTo,
-      title: input.title,
-      priority: input.priority,
-      taskFile: result.taskFile,
-      initialStatus: result.status,
-      projectName: input.projectName
+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(input) {
+  const client = getClient();
+  const id = generateUlid();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const targetDevice = input.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,
+      input.fromAgent,
+      input.targetAgent,
+      input.targetProject ?? null,
+      targetDevice,
+      input.content,
+      input.priority ?? "normal",
+      now
+    ]
+  });
+  try {
+    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]);
+}
+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 result;
+  return false;
 }
-async function updateTask(input) {
-  const { row, taskFile, now, taskId } = await updateTaskStatus(input);
+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 agent = String(row.assigned_to);
-    const cacheDir = path17.join(EXE_AI_DIR, "session-cache");
-    const cachePath = path17.join(cacheDir, `current-task-${agent}.json`);
-    if (input.status === "in_progress") {
-      mkdirSync7(cacheDir, { recursive: true });
-      writeFileSync5(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
-    } else if (input.status === "done" || input.status === "blocked" || input.status === "cancelled") {
-      try {
-        unlinkSync5(cachePath);
-      } catch {
-      }
+    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 {
-  }
-  if (input.status === "done") {
-    await cleanupReviewFile(row, taskFile, input.baseDir);
-  }
-  if (input.status === "done" || input.status === "cancelled") {
-    try {
-      const client = getClient();
-      const taskTitle = String(row.title);
-      const escaped = taskTitle.replace(/%/g, "\\%").replace(/_/g, "\\_");
+    const newRetryCount = msg.retryCount + 1;
+    if (newRetryCount >= MAX_RETRIES2) {
+      await markFailed(messageId, "session unavailable after 10 retries");
+    } else {
       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]
+        sql: "UPDATE messages SET retry_count = ? WHERE id = ?",
+        args: [newRetryCount, messageId]
       });
-      if (cascaded.rowsAffected > 0) {
-        process.stderr.write(
-          `[cascade] Closed ${cascaded.rowsAffected} orphaned review task(s) for parent ${taskId}
-`
-        );
-      }
-    } catch {
-    }
-  }
-  const isTerminal = input.status === "done" || input.status === "needs_review";
-  if (isTerminal) {
-    const isExe = String(row.assigned_to) === "exe";
-    if (!isExe) {
-      notifyTaskDone();
-    }
-    await markTaskNotificationsRead(taskFile);
-    if (input.status === "done") {
-      try {
-        await cascadeUnblock(taskId, input.baseDir, now);
-      } catch {
-      }
-      if (row.parent_task_id) {
-        try {
-          await checkSubtaskCompletion(String(row.parent_task_id), String(row.project_name));
-        } catch {
-        }
-      }
-    }
-  }
-  if (input.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 false;
   }
-  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: input.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) {
+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));
+}
+async function markRead(messageId) {
   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`]
+    sql: "UPDATE messages SET status = 'read' WHERE id = ? AND status IN ('pending', 'delivered')",
+    args: [messageId]
   });
-  await markAsReadByTaskFile(taskFile);
-  await markAsReadByTaskFile(reviewFile);
 }
-var init_tasks = __esm({
-  "src/lib/tasks.ts"() {
+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 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 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]
+  });
+  return result.rows.map((row) => rowToMessage(row));
+}
+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 getFailedMessages() {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT * FROM messages WHERE status = 'failed' ORDER BY created_at DESC",
+    args: []
+  });
+  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_RETRIES2]
+  });
+  let delivered = 0;
+  for (const row of result.rows) {
+    const msg = rowToMessage(row);
+    try {
+      const success = await deliverLocalMessage(msg.id);
+      if (success) delivered++;
+    } catch {
+    }
+  }
+  return delivered;
+}
+var MAX_RETRIES2, _wsClientSend;
+var init_messaging = __esm({
+  "src/lib/messaging.ts"() {
     "use strict";
     init_database();
-    init_config();
-    init_notifications();
-    init_tasks_crud();
-    init_tasks_review();
-    init_tasks_crud();
-    init_tasks_chain();
-    init_tasks_review();
-    init_tasks_notify();
+    init_tmux_routing();
+    MAX_RETRIES2 = 10;
+    _wsClientSend = null;
   }
 });
 
+// src/gateway/gateway.ts
+init_state_bus();
+
 // src/gateway/router.ts
 function matchesPlatform(msgPlatform, matchPlatform) {
   if (!matchPlatform) return true;
@@ -5817,6 +6419,13 @@ var Gateway = class {
     console.log(
       `[gateway] ${msg.platform}/${msg.senderId} \u2192 ${route.employee} (${route.routeName})`
     );
+    orgBus.emit({
+      type: "gateway_message",
+      platform: msg.platform,
+      senderId: msg.senderId,
+      botId: route.employee,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
     const bot = this.botRegistry.get(route.employee);
     if (!bot) {
       console.error(`[gateway] No bot registered for target: ${route.employee}`);
@@ -6610,7 +7219,7 @@ var AnthropicProvider = class {
 
 // src/gateway/providers/openai-compat.ts
 import OpenAI from "openai";
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 var OpenAICompatProvider = class {
   name;
   client;
@@ -6723,7 +7332,7 @@ var OpenAICompatProvider = class {
         }
         content.push({
           type: "tool_use",
-          id: call.id ?? randomUUID2(),
+          id: call.id ?? randomUUID3(),
           name: fn.name,
           input
         });
@@ -6745,7 +7354,7 @@ var OpenAICompatProvider = class {
 };
 
 // src/gateway/providers/ollama.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 var OllamaProvider = class {
   name;
   host;
@@ -6814,7 +7423,7 @@ var OllamaProvider = class {
       for (const call of data.message.tool_calls) {
         content.push({
           type: "tool_use",
-          id: randomUUID3(),
+          id: randomUUID4(),
           name: call.function.name,
           input: call.function.arguments
         });
@@ -6836,7 +7445,7 @@ var OllamaProvider = class {
 };
 
 // src/gateway/adapters/whatsapp.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import { homedir } from "os";
 import { join } from "path";
 import { mkdirSync as mkdirSync2 } from "fs";
@@ -7018,7 +7627,7 @@ var WhatsAppAdapter = class {
     const location = this.extractLocation(msg.message);
     const dataCategory = location ? "location" : "message";
     return {
-      messageId: msg.key.id ?? randomUUID4(),
+      messageId: msg.key.id ?? randomUUID5(),
       platform: "whatsapp",
       senderId,
       senderName: msg.pushName ?? void 0,
@@ -7063,7 +7672,7 @@ var WhatsAppAdapter = class {
     }
     const timestamp = receipt.readTimestamp ?? receipt.receiptTimestamp ?? Date.now() / 1e3;
     return {
-      messageId: randomUUID4(),
+      messageId: randomUUID5(),
       platform: "whatsapp",
       senderId: remoteJid.replace("@s.whatsapp.net", "").replace("@g.us", ""),
       channelId: remoteJid,
@@ -7086,7 +7695,7 @@ var WhatsAppAdapter = class {
     const phone = id.replace("@s.whatsapp.net", "").replace("@g.us", "");
     const name = contact.name ?? contact.notify ?? phone;
     return {
-      messageId: randomUUID4(),
+      messageId: randomUUID5(),
       platform: "whatsapp",
       senderId: phone,
       senderName: name,
@@ -7110,7 +7719,7 @@ var WhatsAppAdapter = class {
     const participants = (group.participants ?? []).map((p) => p.id ?? p);
     const admins = (group.participants ?? []).filter((p) => p.admin === "admin" || p.admin === "superadmin").map((p) => p.id ?? p);
     return {
-      messageId: randomUUID4(),
+      messageId: randomUUID5(),
       platform: "whatsapp",
       senderId: groupId,
       channelId: groupId,
@@ -7135,7 +7744,7 @@ var WhatsAppAdapter = class {
     if (!reactionData) return null;
     const remoteJid = key.remoteJid ?? "";
     return {
-      messageId: randomUUID4(),
+      messageId: randomUUID5(),
       platform: "whatsapp",
       senderId: reactionData.key?.participant ?? reactionData.key?.remoteJid?.replace("@s.whatsapp.net", "") ?? "",
       channelId: remoteJid,
@@ -7157,7 +7766,7 @@ var WhatsAppAdapter = class {
     if (!chatId) return null;
     const caller = call.from?.replace("@s.whatsapp.net", "") ?? "";
     return {
-      messageId: randomUUID4(),
+      messageId: randomUUID5(),
       platform: "whatsapp",
       senderId: caller,
       channelId: chatId,
@@ -7200,7 +7809,7 @@ var WhatsAppAdapter = class {
 };
 
 // src/gateway/adapters/signal.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 var DEFAULT_TIMEOUT_MS = 1e4;
 var SignalAdapter = class {
   platform = "signal";
@@ -7285,7 +7894,7 @@ var SignalAdapter = class {
     }
   }
   async rpcRequest(method, params) {
-    const id = randomUUID5();
+    const id = randomUUID6();
     const res = await fetch(`${this.baseUrl}/api/v1/rpc`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -7375,7 +7984,7 @@ ${val}` : val;
     if (envelope.reactionMessage) {
       const rm = envelope.reactionMessage;
       const normalized2 = {
-        messageId: randomUUID5(),
+        messageId: randomUUID6(),
         platform: "signal",
         senderId,
         senderName: envelope.sourceName ?? void 0,
@@ -7403,7 +8012,7 @@ ${val}` : val;
       const rcpt = envelope.receiptMessage;
       for (const ts of rcpt.timestamps) {
         const normalized2 = {
-          messageId: randomUUID5(),
+          messageId: randomUUID6(),
           platform: "signal",
           senderId,
           senderName: envelope.sourceName ?? void 0,
@@ -7433,7 +8042,7 @@ ${val}` : val;
       const dm2 = em.dataMessage;
       const isGroup2 = !!dm2.groupInfo?.groupId;
       const normalized2 = {
-        messageId: String(dm2.timestamp ?? randomUUID5()),
+        messageId: String(dm2.timestamp ?? randomUUID6()),
         platform: "signal",
         senderId,
         senderName: envelope.sourceName ?? void 0,
@@ -7459,7 +8068,7 @@ ${val}` : val;
     const dm = envelope.dataMessage;
     const isGroup = !!dm.groupInfo?.groupId;
     const normalized = {
-      messageId: String(dm.timestamp ?? randomUUID5()),
+      messageId: String(dm.timestamp ?? randomUUID6()),
       platform: "signal",
       senderId,
       senderName: envelope.sourceName ?? void 0,
@@ -7500,7 +8109,7 @@ ${val}` : val;
       if (!phone) continue;
       const name = contact.name ?? contact.profileName ?? phone;
       const normalized = {
-        messageId: randomUUID5(),
+        messageId: randomUUID6(),
         platform: "signal",
         senderId: phone,
         senderName: name,
@@ -7529,7 +8138,7 @@ ${val}` : val;
     if (!Array.isArray(groups)) return;
     for (const group of groups) {
       const normalized = {
-        messageId: randomUUID5(),
+        messageId: randomUUID6(),
         platform: "signal",
         senderId: `group:${group.id}`,
         channelId: `group:${group.id}`,
@@ -7564,7 +8173,7 @@ ${val}` : val;
 };
 
 // src/gateway/adapters/webchat.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 import { createServer } from "http";
 var WebChatAdapter = class {
   platform = "webchat";
@@ -7660,7 +8269,7 @@ var WebChatAdapter = class {
       res.end(JSON.stringify({ error: "No message text" }));
       return;
     }
-    const requestId = randomUUID6();
+    const requestId = randomUUID7();
     const sessionId = parsed.sessionId ?? this.extractSessionId(req);
     const normalized = {
       messageId: requestId,
@@ -7703,7 +8312,7 @@ var WebChatAdapter = class {
   extractSessionId(req) {
     const cookies = req.headers.cookie ?? "";
     const match = cookies.match(/exe_session=([^;]+)/);
-    return match?.[1] ?? `anon-${randomUUID6().slice(0, 8)}`;
+    return match?.[1] ?? `anon-${randomUUID7().slice(0, 8)}`;
   }
 };
 
@@ -7985,7 +8594,7 @@ var DiscordAdapter = class {
 };
 
 // src/gateway/adapters/slack.ts
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 var SlackAdapter = class {
   platform = "slack";
   webClient = null;
@@ -8023,7 +8632,7 @@ var SlackAdapter = class {
       if (event.subtype) return;
       const isGroup = event.channel_type !== "im";
       const normalized = {
-        messageId: event.client_msg_id ?? event.ts ?? randomUUID7(),
+        messageId: event.client_msg_id ?? event.ts ?? randomUUID8(),
         platform: "slack",
         senderId: event.user ?? "",
         channelId: event.channel ?? "",
@@ -8085,7 +8694,7 @@ var SlackAdapter = class {
     if (!event.text) return;
     const isGroup = event.channel_type !== "im";
     const normalized = {
-      messageId: event.ts ?? randomUUID7(),
+      messageId: event.ts ?? randomUUID8(),
       platform: "slack",
       senderId: event.user ?? "",
       senderName: event.user_profile?.display_name ?? event.user_profile?.real_name ?? void 0,
@@ -8470,7 +9079,7 @@ var FailoverExhaustedError = class extends Error {
 };
 
 // src/gateway/session-store.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 var DEFAULT_CONFIG3 = {
   idleTimeoutMs: 30 * 6e4,
   maxMessages: 100
@@ -8497,7 +9106,7 @@ var SessionStore = class {
       existing.status = "closed";
     }
     const session = {
-      sessionId: randomUUID8(),
+      sessionId: randomUUID9(),
       customerId,
       botId,
       platform,
@@ -8894,7 +9503,7 @@ function formatAlert(alert) {
 }
 
 // src/gateway/customer-store.ts
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 var CustomerStore = class {
   customers = /* @__PURE__ */ new Map();
   identities = /* @__PURE__ */ new Map();
@@ -8913,7 +9522,7 @@ var CustomerStore = class {
       return customer2;
     }
     const customer = {
-      id: randomUUID9(),
+      id: randomUUID10(),
       firstSeenAt: (/* @__PURE__ */ new Date()).toISOString(),
       lastSeenAt: (/* @__PURE__ */ new Date()).toISOString(),
       interactionCount: 1
@@ -8973,7 +9582,7 @@ async function ensureCRMContact(info) {
 
 // src/automation/trigger-engine.ts
 import { readFileSync as readFileSync12, writeFileSync as writeFileSync6, existsSync as existsSync14, mkdirSync as mkdirSync8 } from "fs";
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 import path18 from "path";
 import os8 from "os";
 var TRIGGERS_PATH = path18.join(os8.homedir(), ".exe-os", "triggers.json");