@askexenow/exe-os 0.8.83 → 0.8.85

package/dist/hooks/session-end.js

@@ -273,7 +273,13 @@ function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
 function getEmployee(employees, name) {
   return employees.find((e) => e.name.toLowerCase() === name.toLowerCase());
 }
-var EMPLOYEES_PATH, DEFAULT_COORDINATOR_TEMPLATE_NAME, COORDINATOR_ROLE;
+function isMultiInstance(agentName, employees) {
+  const roster = employees ?? loadEmployeesSync();
+  const emp = getEmployee(roster, agentName);
+  if (!emp) return false;
+  return MULTI_INSTANCE_ROLES.has(emp.role.toLowerCase());
+}
+var EMPLOYEES_PATH, DEFAULT_COORDINATOR_TEMPLATE_NAME, COORDINATOR_ROLE, MULTI_INSTANCE_ROLES;
 var init_employees = __esm({
   "src/lib/employees.ts"() {
     "use strict";
@@ -281,12 +287,36 @@ var init_employees = __esm({
     EMPLOYEES_PATH = path2.join(EXE_AI_DIR, "exe-employees.json");
     DEFAULT_COORDINATOR_TEMPLATE_NAME = "exe";
     COORDINATOR_ROLE = "COO";
+    MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["principal engineer", "content production specialist", "staff code reviewer"]);
   }
 });
 
 // src/lib/session-registry.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
 import path4 from "path";
 import os3 from "os";
+function registerSession(entry) {
+  const dir = path4.dirname(REGISTRY_PATH);
+  if (!existsSync3(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  const sessions = listSessions();
+  const idx = sessions.findIndex((s) => s.windowName === entry.windowName);
+  if (idx >= 0) {
+    sessions[idx] = entry;
+  } else {
+    sessions.push(entry);
+  }
+  writeFileSync3(REGISTRY_PATH, JSON.stringify(sessions, null, 2));
+}
+function listSessions() {
+  try {
+    const raw = readFileSync4(REGISTRY_PATH, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
 var REGISTRY_PATH;
 var init_session_registry = __esm({
   "src/lib/session-registry.ts"() {
@@ -404,13 +434,40 @@ var init_transport = __esm({
 
 // src/lib/cc-agent-support.ts
 import { execSync as execSync4 } from "child_process";
+function _resetCcAgentSupportCache() {
+  _cachedSupport = null;
+}
+function claudeSupportsAgentFlag() {
+  if (_cachedSupport !== null) return _cachedSupport;
+  try {
+    const helpOutput = execSync4("claude --help 2>&1", {
+      encoding: "utf-8",
+      timeout: 5e3
+    });
+    _cachedSupport = /(^|\s)--agent(\b|=)/.test(helpOutput);
+  } catch {
+    _cachedSupport = false;
+  }
+  return _cachedSupport;
+}
+var _cachedSupport;
 var init_cc_agent_support = __esm({
   "src/lib/cc-agent-support.ts"() {
     "use strict";
+    _cachedSupport = null;
   }
 });
 
 // src/lib/mcp-prefix.ts
+function expandDualPrefixTools(shortNames) {
+  const out = [];
+  for (const name of shortNames) {
+    for (const prefix of MCP_TOOL_PREFIXES) {
+      out.push(prefix + name);
+    }
+  }
+  return out;
+}
 var MCP_PRIMARY_KEY, MCP_LEGACY_KEY, MCP_TOOL_PREFIXES;
 var init_mcp_prefix = __esm({
   "src/lib/mcp-prefix.ts"() {
@@ -425,16 +482,68 @@ var init_mcp_prefix = __esm({
 });
 
 // src/lib/provider-table.ts
+function detectActiveProvider(env = process.env) {
+  const baseUrl = env.ANTHROPIC_BASE_URL;
+  if (!baseUrl) return DEFAULT_PROVIDER;
+  for (const [name, cfg] of Object.entries(PROVIDER_TABLE)) {
+    if (cfg.baseUrl === baseUrl) return name;
+  }
+  return DEFAULT_PROVIDER;
+}
+var PROVIDER_TABLE, DEFAULT_PROVIDER;
 var init_provider_table = __esm({
   "src/lib/provider-table.ts"() {
     "use strict";
+    PROVIDER_TABLE = {
+      opencode: {
+        baseUrl: "https://opencode.ai/zen/go",
+        apiKeyEnv: "OPENCODE_API_KEY",
+        defaultModel: "minimax-m2.7"
+      }
+    };
+    DEFAULT_PROVIDER = "default";
   }
 });
 
 // src/lib/intercom-queue.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, renameSync as renameSync3, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, renameSync as renameSync3, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
 import path5 from "path";
 import os4 from "os";
+function ensureDir() {
+  const dir = path5.dirname(QUEUE_PATH);
+  if (!existsSync4(dir)) mkdirSync3(dir, { recursive: true });
+}
+function readQueue() {
+  try {
+    if (!existsSync4(QUEUE_PATH)) return [];
+    return JSON.parse(readFileSync5(QUEUE_PATH, "utf8"));
+  } catch {
+    return [];
+  }
+}
+function writeQueue(queue) {
+  ensureDir();
+  const tmp = `${QUEUE_PATH}.tmp`;
+  writeFileSync4(tmp, JSON.stringify(queue, null, 2));
+  renameSync3(tmp, QUEUE_PATH);
+}
+function queueIntercom(targetSession, reason) {
+  const queue = readQueue();
+  const existing = queue.find((q) => q.targetSession === targetSession);
+  if (existing) {
+    existing.attempts++;
+    existing.queuedAt = (/* @__PURE__ */ new Date()).toISOString();
+    existing.reason = reason;
+  } else {
+    queue.push({
+      targetSession,
+      queuedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      attempts: 0,
+      reason
+    });
+  }
+  writeQueue(queue);
+}
 var QUEUE_PATH, TTL_MS, INTERCOM_LOG;
 var init_intercom_queue = __esm({
   "src/lib/intercom-queue.ts"() {
@@ -500,6 +609,443 @@ var init_db_retry = __esm({
   }
 });
 
+// src/lib/exe-daemon-client.ts
+import net from "net";
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import { existsSync as existsSync5, unlinkSync as unlinkSync3, readFileSync as readFileSync6, openSync, closeSync, statSync } from "fs";
+import path6 from "path";
+import { fileURLToPath } from "url";
+function handleData(chunk) {
+  _buffer += chunk.toString();
+  if (_buffer.length > MAX_BUFFER) {
+    _buffer = "";
+    return;
+  }
+  let newlineIdx;
+  while ((newlineIdx = _buffer.indexOf("\n")) !== -1) {
+    const line = _buffer.slice(0, newlineIdx).trim();
+    _buffer = _buffer.slice(newlineIdx + 1);
+    if (!line) continue;
+    try {
+      const response = JSON.parse(line);
+      const id = response.id;
+      if (!id) continue;
+      const entry = _pending.get(id);
+      if (entry) {
+        clearTimeout(entry.timer);
+        _pending.delete(id);
+        entry.resolve(response);
+      }
+    } catch {
+    }
+  }
+}
+function cleanupStaleFiles() {
+  if (existsSync5(PID_PATH)) {
+    try {
+      const pid = parseInt(readFileSync6(PID_PATH, "utf8").trim(), 10);
+      if (pid > 0) {
+        try {
+          process.kill(pid, 0);
+          return;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    try {
+      unlinkSync3(PID_PATH);
+    } catch {
+    }
+    try {
+      unlinkSync3(SOCKET_PATH);
+    } catch {
+    }
+  }
+}
+function findPackageRoot() {
+  let dir = path6.dirname(fileURLToPath(import.meta.url));
+  const { root } = path6.parse(dir);
+  while (dir !== root) {
+    if (existsSync5(path6.join(dir, "package.json"))) return dir;
+    dir = path6.dirname(dir);
+  }
+  return null;
+}
+function spawnDaemon() {
+  const pkgRoot = findPackageRoot();
+  if (!pkgRoot) {
+    process.stderr.write("[exed-client] WARN: cannot find package root\n");
+    return;
+  }
+  const daemonPath = path6.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync5(daemonPath)) {
+    process.stderr.write(`[exed-client] WARN: daemon script not found at ${daemonPath}
+`);
+    return;
+  }
+  const resolvedPath = daemonPath;
+  process.stderr.write(`[exed-client] Spawning daemon: ${resolvedPath}
+`);
+  const logPath = path6.join(path6.dirname(SOCKET_PATH), "exed.log");
+  let stderrFd = "ignore";
+  try {
+    stderrFd = openSync(logPath, "a");
+  } catch {
+  }
+  const child = spawn(process.execPath, [resolvedPath], {
+    detached: true,
+    stdio: ["ignore", "ignore", stderrFd],
+    env: {
+      ...process.env,
+      TMUX: void 0,
+      // Daemon is global — must not inherit session scope
+      TMUX_PANE: void 0,
+      // Prevents resolveExeSession() from scoping to one session
+      EXE_DAEMON_SOCK: SOCKET_PATH,
+      EXE_DAEMON_PID: PID_PATH
+    }
+  });
+  child.unref();
+  if (typeof stderrFd === "number") {
+    try {
+      closeSync(stderrFd);
+    } catch {
+    }
+  }
+}
+function acquireSpawnLock() {
+  try {
+    const fd = openSync(SPAWN_LOCK_PATH, "wx");
+    closeSync(fd);
+    return true;
+  } catch {
+    try {
+      const stat = statSync(SPAWN_LOCK_PATH);
+      if (Date.now() - stat.mtimeMs > SPAWN_LOCK_STALE_MS) {
+        try {
+          unlinkSync3(SPAWN_LOCK_PATH);
+        } catch {
+        }
+        try {
+          const fd = openSync(SPAWN_LOCK_PATH, "wx");
+          closeSync(fd);
+          return true;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return false;
+  }
+}
+function releaseSpawnLock() {
+  try {
+    unlinkSync3(SPAWN_LOCK_PATH);
+  } catch {
+  }
+}
+function connectToSocket() {
+  return new Promise((resolve) => {
+    if (_socket && _connected) {
+      resolve(true);
+      return;
+    }
+    const socket = net.createConnection({ path: SOCKET_PATH });
+    const connectTimeout = setTimeout(() => {
+      socket.destroy();
+      resolve(false);
+    }, 2e3);
+    socket.on("connect", () => {
+      clearTimeout(connectTimeout);
+      _socket = socket;
+      _connected = true;
+      _buffer = "";
+      socket.on("data", handleData);
+      socket.on("close", () => {
+        _connected = false;
+        _socket = null;
+        for (const [id, entry] of _pending) {
+          clearTimeout(entry.timer);
+          _pending.delete(id);
+          entry.resolve({ error: "Connection closed" });
+        }
+      });
+      socket.on("error", () => {
+        _connected = false;
+        _socket = null;
+      });
+      resolve(true);
+    });
+    socket.on("error", () => {
+      clearTimeout(connectTimeout);
+      resolve(false);
+    });
+  });
+}
+async function connectEmbedDaemon() {
+  if (_socket && _connected) return true;
+  if (await connectToSocket()) return true;
+  if (acquireSpawnLock()) {
+    try {
+      cleanupStaleFiles();
+      spawnDaemon();
+    } finally {
+      releaseSpawnLock();
+    }
+  }
+  const start = Date.now();
+  let delay2 = 100;
+  while (Date.now() - start < CONNECT_TIMEOUT_MS) {
+    await new Promise((r) => setTimeout(r, delay2));
+    if (await connectToSocket()) return true;
+    delay2 = Math.min(delay2 * 2, 3e3);
+  }
+  return false;
+}
+function sendDaemonRequest(payload, timeoutMs = REQUEST_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    if (!_socket || !_connected) {
+      resolve({ error: "Not connected" });
+      return;
+    }
+    const id = randomUUID();
+    const timer = setTimeout(() => {
+      _pending.delete(id);
+      resolve({ error: "Request timeout" });
+    }, timeoutMs);
+    _pending.set(id, { resolve, timer });
+    try {
+      _socket.write(JSON.stringify({ id, ...payload }) + "\n");
+    } catch {
+      clearTimeout(timer);
+      _pending.delete(id);
+      resolve({ error: "Write failed" });
+    }
+  });
+}
+function isClientConnected() {
+  return _connected;
+}
+var SOCKET_PATH, PID_PATH, SPAWN_LOCK_PATH, SPAWN_LOCK_STALE_MS, CONNECT_TIMEOUT_MS, REQUEST_TIMEOUT_MS, _socket, _connected, _buffer, _pending, MAX_BUFFER;
+var init_exe_daemon_client = __esm({
+  "src/lib/exe-daemon-client.ts"() {
+    "use strict";
+    init_config();
+    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path6.join(EXE_AI_DIR, "exed.sock");
+    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path6.join(EXE_AI_DIR, "exed.pid");
+    SPAWN_LOCK_PATH = path6.join(EXE_AI_DIR, "exed-spawn.lock");
+    SPAWN_LOCK_STALE_MS = 3e4;
+    CONNECT_TIMEOUT_MS = 15e3;
+    REQUEST_TIMEOUT_MS = 3e4;
+    _socket = null;
+    _connected = false;
+    _buffer = "";
+    _pending = /* @__PURE__ */ new Map();
+    MAX_BUFFER = 1e7;
+  }
+});
+
+// src/lib/daemon-protocol.ts
+function serializeValue(v) {
+  if (v === null || v === void 0) return null;
+  if (typeof v === "bigint") return Number(v);
+  if (typeof v === "boolean") return v ? 1 : 0;
+  if (v instanceof Uint8Array) {
+    return { __blob: Buffer.from(v).toString("base64") };
+  }
+  if (ArrayBuffer.isView(v)) {
+    return { __blob: Buffer.from(v.buffer, v.byteOffset, v.byteLength).toString("base64") };
+  }
+  if (v instanceof ArrayBuffer) {
+    return { __blob: Buffer.from(v).toString("base64") };
+  }
+  if (typeof v === "string" || typeof v === "number") return v;
+  return String(v);
+}
+function deserializeValue(v) {
+  if (v === null) return null;
+  if (typeof v === "object" && v !== null && "__blob" in v) {
+    const buf = Buffer.from(v.__blob, "base64");
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+  }
+  return v;
+}
+function deserializeResultSet(srs) {
+  const rows = srs.rows.map((obj) => {
+    const values = srs.columns.map(
+      (col) => deserializeValue(obj[col] ?? null)
+    );
+    const row = values;
+    for (let i = 0; i < srs.columns.length; i++) {
+      const col = srs.columns[i];
+      if (col !== void 0) {
+        row[col] = values[i] ?? null;
+      }
+    }
+    Object.defineProperty(row, "length", {
+      value: values.length,
+      enumerable: false
+    });
+    return row;
+  });
+  return {
+    columns: srs.columns,
+    columnTypes: srs.columnTypes ?? [],
+    rows,
+    rowsAffected: srs.rowsAffected,
+    lastInsertRowid: srs.lastInsertRowid != null ? BigInt(srs.lastInsertRowid) : void 0,
+    toJSON: () => ({
+      columns: srs.columns,
+      columnTypes: srs.columnTypes ?? [],
+      rows: srs.rows,
+      rowsAffected: srs.rowsAffected,
+      lastInsertRowid: srs.lastInsertRowid
+    })
+  };
+}
+var init_daemon_protocol = __esm({
+  "src/lib/daemon-protocol.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/db-daemon-client.ts
+var db_daemon_client_exports = {};
+__export(db_daemon_client_exports, {
+  createDaemonDbClient: () => createDaemonDbClient,
+  initDaemonDbClient: () => initDaemonDbClient
+});
+function normalizeStatement(stmt) {
+  if (typeof stmt === "string") {
+    return { sql: stmt, args: [] };
+  }
+  const sql = stmt.sql;
+  let args = [];
+  if (Array.isArray(stmt.args)) {
+    args = stmt.args.map((v) => serializeValue(v));
+  } else if (stmt.args && typeof stmt.args === "object") {
+    const named = {};
+    for (const [key, val] of Object.entries(stmt.args)) {
+      named[key] = serializeValue(val);
+    }
+    return { sql, args: named };
+  }
+  return { sql, args };
+}
+function createDaemonDbClient(fallbackClient) {
+  let _useDaemon = false;
+  const client = {
+    async execute(stmt) {
+      if (!_useDaemon || !isClientConnected()) {
+        return fallbackClient.execute(stmt);
+      }
+      const { sql, args } = normalizeStatement(stmt);
+      const response = await sendDaemonRequest({
+        type: "db-execute",
+        sql,
+        args
+      });
+      if (response.error) {
+        const errMsg = String(response.error);
+        if (errMsg === "Not connected" || errMsg === "Request timeout" || errMsg === "Write failed") {
+          process.stderr.write(`[db-daemon] Transport error (${errMsg}), falling back to direct
+`);
+          return fallbackClient.execute(stmt);
+        }
+        throw new Error(errMsg);
+      }
+      if (response.db) {
+        return deserializeResultSet(response.db);
+      }
+      process.stderr.write("[db-daemon] Unexpected response shape, falling back to direct\n");
+      return fallbackClient.execute(stmt);
+    },
+    async batch(stmts, mode) {
+      if (!_useDaemon || !isClientConnected()) {
+        return fallbackClient.batch(stmts, mode);
+      }
+      const statements = stmts.map(normalizeStatement);
+      const response = await sendDaemonRequest({
+        type: "db-batch",
+        statements,
+        mode: mode ?? "deferred"
+      });
+      if (response.error) {
+        const errMsg = String(response.error);
+        if (errMsg === "Not connected" || errMsg === "Request timeout" || errMsg === "Write failed") {
+          process.stderr.write(`[db-daemon] Batch transport error (${errMsg}), falling back to direct
+`);
+          return fallbackClient.batch(stmts, mode);
+        }
+        throw new Error(errMsg);
+      }
+      const batchResults = response["db-batch"];
+      if (batchResults) {
+        return batchResults.map(deserializeResultSet);
+      }
+      process.stderr.write("[db-daemon] Unexpected batch response shape, falling back to direct\n");
+      return fallbackClient.batch(stmts, mode);
+    },
+    // Transaction support — delegate to fallback (transactions need direct connection)
+    async transaction(mode) {
+      return fallbackClient.transaction(mode);
+    },
+    // executeMultiple — delegate to fallback (used only for schema migrations)
+    async executeMultiple(sql) {
+      return fallbackClient.executeMultiple(sql);
+    },
+    // migrate — delegate to fallback
+    async migrate(stmts) {
+      return fallbackClient.migrate(stmts);
+    },
+    // Sync mode — delegate to fallback
+    sync() {
+      return fallbackClient.sync();
+    },
+    close() {
+      _useDaemon = false;
+    },
+    get closed() {
+      return fallbackClient.closed;
+    },
+    get protocol() {
+      return fallbackClient.protocol;
+    }
+  };
+  return {
+    ...client,
+    /** Enable daemon routing (call after confirming daemon is connected) */
+    _enableDaemon() {
+      _useDaemon = true;
+    },
+    /** Check if daemon routing is active */
+    _isDaemonActive() {
+      return _useDaemon && isClientConnected();
+    }
+  };
+}
+async function initDaemonDbClient(fallbackClient) {
+  if (process.env.EXE_IS_DAEMON === "1") return null;
+  const connected = await connectEmbedDaemon();
+  if (!connected) {
+    process.stderr.write("[db-daemon] Daemon unavailable \u2014 using direct SQLite\n");
+    return null;
+  }
+  const client = createDaemonDbClient(fallbackClient);
+  client._enableDaemon();
+  process.stderr.write("[db-daemon] DB routing through daemon (single-writer)\n");
+  return client;
+}
+var init_db_daemon_client = __esm({
+  "src/lib/db-daemon-client.ts"() {
+    "use strict";
+    init_exe_daemon_client();
+    init_daemon_protocol();
+  }
+});
+
 // src/lib/database.ts
 var database_exports = {};
 __export(database_exports, {
@@ -508,6 +1054,7 @@ __export(database_exports, {
   ensureSchema: () => ensureSchema,
   getClient: () => getClient,
   getRawClient: () => getRawClient,
+  initDaemonClient: () => initDaemonClient,
   initDatabase: () => initDatabase,
   initTurso: () => initTurso,
   isInitialized: () => isInitialized
@@ -535,8 +1082,27 @@ function getClient() {
   if (!_resilientClient) {
     throw new Error("Database client not initialized. Call initDatabase() first.");
   }
+  if (process.env.EXE_IS_DAEMON === "1") {
+    return _resilientClient;
+  }
+  if (_daemonClient && _daemonClient._isDaemonActive()) {
+    return _daemonClient;
+  }
   return _resilientClient;
 }
+async function initDaemonClient() {
+  if (process.env.EXE_IS_DAEMON === "1") return;
+  if (!_resilientClient) return;
+  try {
+    const { initDaemonDbClient: initDaemonDbClient2 } = await Promise.resolve().then(() => (init_db_daemon_client(), db_daemon_client_exports));
+    _daemonClient = await initDaemonDbClient2(_resilientClient);
+  } catch (err) {
+    process.stderr.write(
+      `[database] Daemon client init failed (non-fatal): ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
 function getRawClient() {
   if (!_client) {
     throw new Error("Database client not initialized. Call initDatabase() first.");
@@ -1023,6 +1589,12 @@ async function ensureSchema() {
     } catch {
     }
   }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_content_hash ON memories(content_hash, agent_id)`
+    );
+  } catch {
+  }
   await client.executeMultiple(`
     CREATE TABLE IF NOT EXISTS entities (
       id TEXT PRIMARY KEY,
@@ -1075,7 +1647,30 @@ async function ensureSchema() {
       entity_id TEXT NOT NULL,
       PRIMARY KEY (hyperedge_id, entity_id)
     );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS entities_fts USING fts5(
+      name,
+      content=entities,
+      content_rowid=rowid
+    );
+
+    CREATE TRIGGER IF NOT EXISTS entities_fts_ai AFTER INSERT ON entities BEGIN
+      INSERT INTO entities_fts(rowid, name) VALUES (new.rowid, new.name);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS entities_fts_ad AFTER DELETE ON entities BEGIN
+      INSERT INTO entities_fts(entities_fts, rowid, name) VALUES('delete', old.rowid, old.name);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS entities_fts_au AFTER UPDATE ON entities BEGIN
+      INSERT INTO entities_fts(entities_fts, rowid, name) VALUES('delete', old.rowid, old.name);
+      INSERT INTO entities_fts(rowid, name) VALUES (new.rowid, new.name);
+    END;
   `);
+  try {
+    await client.execute("INSERT INTO entities_fts(entities_fts) VALUES('rebuild')");
+  } catch {
+  }
   await client.executeMultiple(`
     CREATE TABLE IF NOT EXISTS entity_aliases (
       alias TEXT NOT NULL PRIMARY KEY,
@@ -1256,6 +1851,33 @@ async function ensureSchema() {
     CREATE INDEX IF NOT EXISTS idx_conversations_channel
       ON conversations(channel_id);
   `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS session_agent_map (
+      session_uuid TEXT PRIMARY KEY,
+      agent_id TEXT NOT NULL,
+      session_name TEXT,
+      task_id TEXT,
+      project_name TEXT,
+      started_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_session_agent_map_agent
+      ON session_agent_map(agent_id);
+  `);
+  try {
+    const mapCount = await client.execute({ sql: `SELECT COUNT(*) as cnt FROM session_agent_map`, args: [] });
+    if (Number(mapCount.rows[0]?.cnt ?? 0) === 0) {
+      await client.execute({
+        sql: `INSERT OR IGNORE INTO session_agent_map (session_uuid, agent_id, session_name, started_at)
+              SELECT session_id, agent_id, '', MIN(timestamp)
+              FROM memories
+              WHERE session_id IS NOT NULL AND session_id != '' AND agent_id IS NOT NULL AND agent_id != ''
+              GROUP BY session_id, agent_id`,
+        args: []
+      });
+    }
+  } catch {
+  }
   try {
     await client.execute({
       sql: `ALTER TABLE tasks ADD COLUMN budget_tokens INTEGER`,
@@ -1389,15 +2011,41 @@ async function ensureSchema() {
     });
   } catch {
   }
+  for (const col of [
+    "ALTER TABLE memories ADD COLUMN intent TEXT",
+    "ALTER TABLE memories ADD COLUMN outcome TEXT",
+    "ALTER TABLE memories ADD COLUMN domain TEXT",
+    "ALTER TABLE memories ADD COLUMN referenced_entities TEXT",
+    "ALTER TABLE memories ADD COLUMN retrieval_count INTEGER DEFAULT 0",
+    "ALTER TABLE memories ADD COLUMN chain_position TEXT",
+    "ALTER TABLE memories ADD COLUMN review_status TEXT",
+    "ALTER TABLE memories ADD COLUMN context_window_pct INTEGER",
+    "ALTER TABLE memories ADD COLUMN file_paths TEXT",
+    "ALTER TABLE memories ADD COLUMN commit_hash TEXT",
+    "ALTER TABLE memories ADD COLUMN duration_ms INTEGER",
+    "ALTER TABLE memories ADD COLUMN token_cost REAL",
+    "ALTER TABLE memories ADD COLUMN audience TEXT",
+    "ALTER TABLE memories ADD COLUMN language_type TEXT",
+    "ALTER TABLE memories ADD COLUMN parent_memory_id TEXT"
+  ]) {
+    try {
+      await client.execute(col);
+    } catch {
+    }
+  }
 }
 async function disposeDatabase() {
+  if (_daemonClient) {
+    _daemonClient.close();
+    _daemonClient = null;
+  }
   if (_client) {
     _client.close();
     _client = null;
     _resilientClient = null;
   }
 }
-var _client, _resilientClient, initTurso, disposeTurso;
+var _client, _resilientClient, _daemonClient, initTurso, disposeTurso;
 var init_database = __esm({
   "src/lib/database.ts"() {
     "use strict";
@@ -1405,31 +2053,96 @@ var init_database = __esm({
     init_employees();
     _client = null;
     _resilientClient = null;
+    _daemonClient = null;
     initTurso = initDatabase;
     disposeTurso = disposeDatabase;
   }
 });
 
 // src/lib/license.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
-import { randomUUID } from "crypto";
-import path6 from "path";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
+import path7 from "path";
 import { jwtVerify, importSPKI } from "jose";
-var LICENSE_PATH, CACHE_PATH, DEVICE_ID_PATH;
+var LICENSE_PATH, CACHE_PATH, DEVICE_ID_PATH, PLAN_LIMITS;
 var init_license = __esm({
   "src/lib/license.ts"() {
     "use strict";
     init_config();
-    LICENSE_PATH = path6.join(EXE_AI_DIR, "license.key");
-    CACHE_PATH = path6.join(EXE_AI_DIR, "license-cache.json");
-    DEVICE_ID_PATH = path6.join(EXE_AI_DIR, "device-id");
+    LICENSE_PATH = path7.join(EXE_AI_DIR, "license.key");
+    CACHE_PATH = path7.join(EXE_AI_DIR, "license-cache.json");
+    DEVICE_ID_PATH = path7.join(EXE_AI_DIR, "device-id");
+    PLAN_LIMITS = {
+      free: { devices: 1, employees: 1, memories: 5e3 },
+      pro: { devices: 3, employees: 5, memories: 1e5 },
+      team: { devices: 10, employees: 20, memories: 1e6 },
+      agency: { devices: 50, employees: 100, memories: 1e7 },
+      enterprise: { devices: -1, employees: -1, memories: -1 }
+    };
   }
 });
 
 // src/lib/plan-limits.ts
-import { readFileSync as readFileSync6, existsSync as existsSync5 } from "fs";
-import path7 from "path";
-var CACHE_PATH2;
+import { readFileSync as readFileSync8, existsSync as existsSync7 } from "fs";
+import path8 from "path";
+function getLicenseSync() {
+  try {
+    if (!existsSync7(CACHE_PATH2)) return freeLicense();
+    const raw = JSON.parse(readFileSync8(CACHE_PATH2, "utf8"));
+    if (!raw.token || typeof raw.token !== "string") return freeLicense();
+    const parts = raw.token.split(".");
+    if (parts.length !== 3) return freeLicense();
+    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString());
+    const plan = payload.plan ?? "free";
+    const limits = PLAN_LIMITS[plan] ?? PLAN_LIMITS.free;
+    return {
+      valid: true,
+      plan,
+      email: payload.sub ?? "",
+      expiresAt: payload.exp ? new Date(payload.exp * 1e3).toISOString() : null,
+      deviceLimit: limits.devices,
+      employeeLimit: limits.employees,
+      memoryLimit: limits.memories
+    };
+  } catch {
+    return freeLicense();
+  }
+}
+function freeLicense() {
+  const limits = PLAN_LIMITS.free;
+  return {
+    valid: true,
+    plan: "free",
+    email: "",
+    expiresAt: null,
+    deviceLimit: limits.devices,
+    employeeLimit: limits.employees,
+    memoryLimit: limits.memories
+  };
+}
+function assertEmployeeLimitSync(rosterPath) {
+  const license = getLicenseSync();
+  if (license.employeeLimit < 0) return;
+  const filePath = rosterPath ?? EMPLOYEES_PATH;
+  let count = 0;
+  try {
+    if (existsSync7(filePath)) {
+      const raw = readFileSync8(filePath, "utf8");
+      const employees = JSON.parse(raw);
+      count = Array.isArray(employees) ? employees.length : 0;
+    }
+  } catch {
+    throw new PlanLimitError(
+      `Cannot verify employee count: roster unreadable at ${filePath}. Refusing to proceed. Check file permissions or upgrade plan.`
+    );
+  }
+  if (count >= license.employeeLimit) {
+    throw new PlanLimitError(
+      `Employee limit reached: ${count}/${license.employeeLimit} employees on the ${license.plan} plan. Upgrade at https://askexe.com to add more.`
+    );
+  }
+}
+var PlanLimitError, CACHE_PATH2;
 var init_plan_limits = __esm({
   "src/lib/plan-limits.ts"() {
     "use strict";
@@ -1437,32 +2150,2359 @@ var init_plan_limits = __esm({
     init_employees();
     init_license();
     init_config();
-    CACHE_PATH2 = path7.join(EXE_AI_DIR, "license-cache.json");
+    PlanLimitError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "PlanLimitError";
+      }
+    };
+    CACHE_PATH2 = path8.join(EXE_AI_DIR, "license-cache.json");
   }
 });
 
-// src/lib/tmux-routing.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, existsSync as existsSync6, appendFileSync } from "fs";
-import path8 from "path";
+// src/lib/notifications.ts
+var notifications_exports = {};
+__export(notifications_exports, {
+  cleanupOldNotifications: () => cleanupOldNotifications,
+  formatNotifications: () => formatNotifications,
+  markAsRead: () => markAsRead,
+  markAsReadByTaskFile: () => markAsReadByTaskFile,
+  markDoneTaskNotificationsAsRead: () => markDoneTaskNotificationsAsRead,
+  migrateJsonNotifications: () => migrateJsonNotifications,
+  readUnreadNotifications: () => readUnreadNotifications,
+  writeNotification: () => writeNotification
+});
+import crypto from "crypto";
+import path9 from "path";
 import os5 from "os";
-import { fileURLToPath } from "url";
-function getMySession() {
-  return getTransport().getMySession();
-}
-function extractRootExe(name) {
-  if (!name) return null;
-  if (!name.includes("-")) return name;
+import {
+  readFileSync as readFileSync9,
+  readdirSync as readdirSync2,
+  unlinkSync as unlinkSync4,
+  existsSync as existsSync8,
+  rmdirSync
+} from "fs";
+async function writeNotification(notification) {
+  try {
+    const client = getClient();
+    const id = crypto.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)}
+`);
+  }
+}
+async function readUnreadNotifications(agentFilter) {
+  try {
+    const client = getClient();
+    const conditions = ["read = 0"];
+    const args = [];
+    if (agentFilter) {
+      conditions.push("agent_id = ?");
+      args.push(agentFilter);
+    }
+    const result = await client.execute({
+      sql: `SELECT id, agent_id, agent_role, event, project, summary, task_file, created_at
+            FROM notifications
+            WHERE ${conditions.join(" AND ")}
+            ORDER BY created_at ASC`,
+      args
+    });
+    return result.rows.map((r) => ({
+      id: String(r.id),
+      agentId: String(r.agent_id),
+      agentRole: String(r.agent_role),
+      event: String(r.event),
+      project: String(r.project),
+      summary: String(r.summary),
+      taskFile: r.task_file ? String(r.task_file) : void 0,
+      timestamp: String(r.created_at),
+      read: false
+    }));
+  } catch {
+    return [];
+  }
+}
+async function markAsRead(ids) {
+  if (ids.length === 0) return;
+  try {
+    const client = getClient();
+    const placeholders = ids.map(() => "?").join(", ");
+    await client.execute({
+      sql: `UPDATE notifications SET read = 1 WHERE id IN (${placeholders})`,
+      args: ids
+    });
+  } catch {
+  }
+}
+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]
+    });
+  } catch {
+  }
+}
+async function cleanupOldNotifications(daysOld = CLEANUP_DAYS) {
+  try {
+    const client = getClient();
+    const cutoff = new Date(
+      Date.now() - daysOld * 24 * 60 * 60 * 1e3
+    ).toISOString();
+    const result = await client.execute({
+      sql: "DELETE FROM notifications WHERE created_at < ?",
+      args: [cutoff]
+    });
+    return result.rowsAffected;
+  } catch {
+    return 0;
+  }
+}
+async function markDoneTaskNotificationsAsRead() {
+  try {
+    const client = getClient();
+    const result = await client.execute({
+      sql: `UPDATE notifications SET read = 1
+            WHERE read = 0
+              AND task_file IS NOT NULL
+              AND task_file IN (
+                SELECT task_file FROM tasks WHERE status = 'done'
+              )`,
+      args: []
+    });
+    return result.rowsAffected;
+  } catch {
+    return 0;
+  }
+}
+function formatNotifications(notifications) {
+  if (notifications.length === 0) return "";
+  const grouped = /* @__PURE__ */ new Map();
+  for (const n of notifications) {
+    const key = `${n.agentId}|${n.agentRole}`;
+    if (!grouped.has(key)) grouped.set(key, []);
+    grouped.get(key).push(n);
+  }
+  const lines = [];
+  lines.push(`## Notifications (${notifications.length} unread)
+`);
+  for (const [key, items] of grouped) {
+    const [agentId, agentRole] = key.split("|");
+    lines.push(`**${agentId}** (${agentRole}):`);
+    for (const item of items) {
+      const ago = formatTimeAgo(item.timestamp);
+      const icon = eventIcon(item.event);
+      lines.push(`- ${icon} ${item.summary} (${item.project}) \u2014 ${ago}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function migrateJsonNotifications() {
+  const base = process.env.EXE_OS_DIR || process.env.EXE_MEM_DIR || path9.join(os5.homedir(), ".exe-os");
+  const notifDir = path9.join(base, "notifications");
+  if (!existsSync8(notifDir)) return 0;
+  let migrated = 0;
+  try {
+    const files = readdirSync2(notifDir).filter((f) => f.endsWith(".json"));
+    if (files.length === 0) return 0;
+    const client = getClient();
+    for (const file of files) {
+      try {
+        const filePath = path9.join(notifDir, file);
+        const data = JSON.parse(readFileSync9(filePath, "utf8"));
+        await client.execute({
+          sql: `INSERT OR IGNORE INTO notifications (id, agent_id, agent_role, event, project, summary, task_file, read, created_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          args: [
+            crypto.randomUUID(),
+            data.agentId ?? "unknown",
+            data.agentRole ?? "unknown",
+            data.event ?? "session_summary",
+            data.project ?? "unknown",
+            data.summary ?? "",
+            data.taskFile ?? null,
+            data.read ? 1 : 0,
+            data.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+          ]
+        });
+        unlinkSync4(filePath);
+        migrated++;
+      } catch {
+      }
+    }
+    try {
+      const remaining = readdirSync2(notifDir);
+      if (remaining.length === 0) {
+        rmdirSync(notifDir);
+      }
+    } catch {
+    }
+  } catch {
+  }
+  return migrated;
+}
+function eventIcon(event) {
+  switch (event) {
+    case "task_complete":
+      return "Completed:";
+    case "task_needs_fix":
+      return "Needs fix:";
+    case "session_summary":
+      return "Session:";
+    case "error_spike":
+      return "Errors:";
+    case "orphan_task":
+      return "Orphan:";
+    case "subtasks_complete":
+      return "Subtasks done:";
+    case "capacity_relaunch":
+      return "Relaunched:";
+  }
+}
+function formatTimeAgo(timestamp) {
+  const diffMs = Date.now() - new Date(timestamp).getTime();
+  const mins = Math.floor(diffMs / 6e4);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+var CLEANUP_DAYS;
+var init_notifications = __esm({
+  "src/lib/notifications.ts"() {
+    "use strict";
+    init_database();
+    CLEANUP_DAYS = 7;
+  }
+});
+
+// src/lib/session-kill-telemetry.ts
+import crypto2 from "crypto";
+async function recordSessionKill(input2) {
+  try {
+    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: [
+        crypto2.randomUUID(),
+        input2.sessionName,
+        input2.agentId,
+        (/* @__PURE__ */ new Date()).toISOString(),
+        input2.reason,
+        input2.ticksIdle ?? null,
+        input2.estimatedTokensSaved ?? null
+      ]
+    });
+  } catch (err) {
+    process.stderr.write(
+      `[session-kill-telemetry] write failed: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
+var init_session_kill_telemetry = __esm({
+  "src/lib/session-kill-telemetry.ts"() {
+    "use strict";
+    init_database();
+  }
+});
+
+// src/lib/state-bus.ts
+var StateBus, orgBus;
+var init_state_bus = __esm({
+  "src/lib/state-bus.ts"() {
+    "use strict";
+    StateBus = class {
+      handlers = /* @__PURE__ */ new Map();
+      globalHandlers = /* @__PURE__ */ new Set();
+      /** Emit an event to all subscribers */
+      emit(event) {
+        const typeHandlers = this.handlers.get(event.type);
+        if (typeHandlers) {
+          for (const handler of typeHandlers) {
+            try {
+              handler(event);
+            } catch {
+            }
+          }
+        }
+        for (const handler of this.globalHandlers) {
+          try {
+            handler(event);
+          } catch {
+          }
+        }
+      }
+      /** Subscribe to a specific event type */
+      on(type, handler) {
+        if (!this.handlers.has(type)) {
+          this.handlers.set(type, /* @__PURE__ */ new Set());
+        }
+        this.handlers.get(type).add(handler);
+      }
+      /** Subscribe to ALL events */
+      onAny(handler) {
+        this.globalHandlers.add(handler);
+      }
+      /** Unsubscribe from a specific event type */
+      off(type, handler) {
+        this.handlers.get(type)?.delete(handler);
+      }
+      /** Unsubscribe from ALL events */
+      offAny(handler) {
+        this.globalHandlers.delete(handler);
+      }
+      /** Remove all listeners */
+      clear() {
+        this.handlers.clear();
+        this.globalHandlers.clear();
+      }
+    };
+    orgBus = new StateBus();
+  }
+});
+
+// src/lib/tasks-crud.ts
+var tasks_crud_exports = {};
+__export(tasks_crud_exports, {
+  TASK_ALREADY_CLAIMED_PREFIX: () => TASK_ALREADY_CLAIMED_PREFIX,
+  checkStaleCompletion: () => checkStaleCompletion,
+  createTaskCore: () => createTaskCore,
+  deleteTaskCore: () => deleteTaskCore,
+  ensureArchitectureDoc: () => ensureArchitectureDoc,
+  ensureGitignoreExe: () => ensureGitignoreExe,
+  extractParentFromContext: () => extractParentFromContext,
+  isTmuxSessionAlive: () => isTmuxSessionAlive,
+  listTasks: () => listTasks,
+  resolveTask: () => resolveTask,
+  slugify: () => slugify,
+  updateTaskStatus: () => updateTaskStatus,
+  writeCheckpoint: () => writeCheckpoint
+});
+import crypto3 from "crypto";
+import path10 from "path";
+import os6 from "os";
+import { execSync as execSync5 } from "child_process";
+import { mkdir as mkdir3, writeFile as writeFile3, appendFile } from "fs/promises";
+import { existsSync as existsSync9, readFileSync as readFileSync10 } from "fs";
+async function writeCheckpoint(input2) {
+  const client = getClient();
+  const row = await resolveTask(client, input2.taskId);
+  const taskId = String(row.id);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const blockedByIds = [];
+  if (row.blocked_by) {
+    blockedByIds.push(String(row.blocked_by));
+  }
+  const checkpoint = {
+    step: input2.step,
+    context_summary: input2.contextSummary,
+    files_touched: input2.filesTouched ?? [],
+    blocked_by_ids: blockedByIds,
+    last_checkpoint_at: now
+  };
+  const result = await client.execute({
+    sql: `UPDATE tasks SET checkpoint = ?, checkpoint_count = checkpoint_count + 1, updated_at = ? WHERE id = ?`,
+    args: [JSON.stringify(checkpoint), now, taskId]
+  });
+  if (result.rowsAffected === 0) {
+    throw new Error(`Checkpoint write failed: task ${taskId} not found`);
+  }
+  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, "");
+}
+function buildKeywordIndex() {
+  const idx = /* @__PURE__ */ new Map();
+  for (const [role, keywords] of Object.entries(LANE_KEYWORDS)) {
+    for (const kw of keywords) {
+      const existing = idx.get(kw) ?? [];
+      existing.push(role);
+      idx.set(kw, existing);
+    }
+  }
+  return idx;
+}
+function checkLaneAffinity(title, context, assigneeName) {
+  const employees = loadEmployeesSync();
+  const employee = employees.find((e) => e.name === assigneeName);
+  if (!employee) return void 0;
+  const assigneeRole = employee.role;
+  const text = `${title} ${context}`.toLowerCase();
+  const matchedRoles = /* @__PURE__ */ new Set();
+  for (const [keyword, roles] of KEYWORD_INDEX) {
+    if (text.includes(keyword)) {
+      for (const role of roles) matchedRoles.add(role);
+    }
+  }
+  if (matchedRoles.size === 0) return void 0;
+  if (matchedRoles.has(assigneeRole)) return void 0;
+  if (assigneeRole === "COO") return void 0;
+  const expectedRoles = Array.from(matchedRoles).join(" or ");
+  return `\u26A0\uFE0F Lane mismatch: task content suggests ${expectedRoles}, but assigned to ${assigneeName} (${assigneeRole}).`;
+}
+async function resolveTask(client, identifier, scopeSession) {
+  const scope = sessionScopeFilter(scopeSession);
+  let result = await client.execute({
+    sql: `SELECT * FROM tasks WHERE id = ?${scope.sql}`,
+    args: [identifier, ...scope.args]
+  });
+  if (result.rows.length === 1) return result.rows[0];
+  result = await client.execute({
+    sql: `SELECT * FROM tasks WHERE task_file LIKE ?${scope.sql}`,
+    args: [`%${identifier}%`, ...scope.args]
+  });
+  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 ?${scope.sql}`,
+    args: [`%${identifier}%`, ...scope.args]
+  });
+  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}`);
+}
+async function createTaskCore(input2) {
+  const client = getClient();
+  const id = crypto3.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const slug = slugify(input2.title);
+  let earlySessionScope = null;
+  try {
+    const { resolveExeSession: resolveExeSession2 } = await Promise.resolve().then(() => (init_tmux_routing(), tmux_routing_exports));
+    earlySessionScope = resolveExeSession2();
+  } catch {
+  }
+  const scope = earlySessionScope ?? "default";
+  const taskFile = input2.taskFile ?? `tasks/${scope}/${input2.assignedTo}/${slug}.md`;
+  let blockedById = null;
+  const initialStatus = input2.blockedBy ? "blocked" : "open";
+  if (input2.blockedBy) {
+    const blocker = await resolveTask(client, input2.blockedBy);
+    blockedById = String(blocker.id);
+  }
+  let parentTaskId = null;
+  let parentRef = input2.parentTaskId;
+  if (!parentRef) {
+    const extracted = extractParentFromContext(input2.context);
+    if (extracted) {
+      parentRef = extracted;
+      process.stderr.write(
+        "[create_task] auto-populated parent_task_id from context body \u2014 dispatchers should pass parent_task_id explicitly\n"
+      );
+    }
+  }
+  if (parentRef) {
+    try {
+      const parent = await resolveTask(client, parentRef);
+      parentTaskId = String(parent.id);
+    } catch (err) {
+      if (!input2.parentTaskId) {
+        throw new Error(
+          `create_task: parent reference "${parentRef}" in context body does not resolve to an existing task`
+        );
+      }
+      throw err;
+    }
+  }
+  let warning;
+  const dupScope = sessionScopeFilter();
+  const dupCheck = await client.execute({
+    sql: `SELECT id FROM tasks WHERE title = ? AND assigned_to = ? AND status IN ('open', 'in_progress', 'blocked')${dupScope.sql}`,
+    args: [input2.title, input2.assignedTo, ...dupScope.args]
+  });
+  if (dupCheck.rows.length > 0) {
+    warning = `similar active task already exists (${String(dupCheck.rows[0].id)}). Created new task anyway.`;
+  }
+  if (!process.env.DISABLE_LANE_AFFINITY) {
+    const laneWarning = checkLaneAffinity(input2.title, input2.context, input2.assignedTo);
+    if (laneWarning) {
+      warning = warning ? `${warning}
+${laneWarning}` : laneWarning;
+    }
+  }
+  if (input2.baseDir) {
+    try {
+      await mkdir3(path10.join(input2.baseDir, "exe", "output"), { recursive: true });
+      await mkdir3(path10.join(input2.baseDir, "exe", "research"), { recursive: true });
+      await ensureArchitectureDoc(input2.baseDir, input2.projectName);
+      await ensureGitignoreExe(input2.baseDir);
+    } catch {
+    }
+  }
+  const complexity = input2.complexity ?? "standard";
+  const sessionScope = earlySessionScope;
+  await client.execute({
+    sql: `INSERT INTO tasks (id, title, assigned_to, assigned_by, project_name, priority, status, task_file, blocked_by, parent_task_id, reviewer, context, complexity, budget_tokens, budget_fallback_model, tokens_used, tokens_warned_at, session_scope, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    args: [
+      id,
+      input2.title,
+      input2.assignedTo,
+      input2.assignedBy,
+      input2.projectName,
+      input2.priority,
+      initialStatus,
+      taskFile,
+      blockedById,
+      parentTaskId,
+      input2.reviewer ?? null,
+      input2.context,
+      complexity,
+      input2.budgetTokens ?? null,
+      input2.budgetFallbackModel ?? null,
+      0,
+      null,
+      sessionScope,
+      now,
+      now
+    ]
+  });
+  if (input2.baseDir) {
+    try {
+      const EXE_OS_DIR = path10.join(os6.homedir(), ".exe-os");
+      const mdPath = path10.join(EXE_OS_DIR, taskFile);
+      const mdDir = path10.dirname(mdPath);
+      if (!existsSync9(mdDir)) await mkdir3(mdDir, { recursive: true });
+      const reviewer = input2.reviewer ?? input2.assignedBy;
+      const mdContent = `# ${input2.title}
+
+**ID:** ${id}
+**Status:** ${initialStatus}
+**Priority:** ${input2.priority}
+**Assigned by:** ${input2.assignedBy}
+**Assigned to:** ${input2.assignedTo}
+**Project:** ${input2.projectName}
+**Created:** ${now.split("T")[0]}${parentTaskId ? `
+**Parent task:** ${parentTaskId}` : ""}
+**Reviewer:** ${reviewer}
+
+## Context
+
+${input2.context}
+
+## MANDATORY: When done
+
+You MUST call update_task with status "done" and a result summary when finished.
+If you skip this, your reviewer will not know you're done and your work won't be reviewed.
+Do NOT let a failed commit or any error prevent you from calling update_task(done).
+`;
+      await writeFile3(mdPath, mdContent, "utf-8");
+    } catch {
+    }
+  }
+  return {
+    id,
+    title: input2.title,
+    assignedTo: input2.assignedTo,
+    assignedBy: input2.assignedBy,
+    projectName: input2.projectName,
+    priority: input2.priority,
+    status: initialStatus,
+    taskFile,
+    createdAt: now,
+    updatedAt: now,
+    warning,
+    budgetTokens: input2.budgetTokens ?? null,
+    budgetFallbackModel: input2.budgetFallbackModel ?? null,
+    tokensUsed: 0,
+    tokensWarnedAt: null
+  };
+}
+async function listTasks(input2) {
+  const client = getClient();
+  const conditions = [];
+  const args = [];
+  if (input2.assignedTo) {
+    conditions.push("assigned_to = ?");
+    args.push(input2.assignedTo);
+  }
+  if (input2.status) {
+    conditions.push("status = ?");
+    args.push(input2.status);
+  } else {
+    conditions.push("status IN ('open', 'in_progress', 'blocked')");
+  }
+  if (input2.projectName) {
+    conditions.push("project_name = ?");
+    args.push(input2.projectName);
+  }
+  if (input2.priority) {
+    conditions.push("priority = ?");
+    args.push(input2.priority);
+  }
+  const scope = sessionScopeFilter();
+  if (scope.sql) {
+    conditions.push("(session_scope IS NULL OR session_scope = ?)");
+    args.push(...scope.args);
+  }
+  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 isTmuxSessionAlive(identifier) {
+  if (!identifier || identifier === "unknown") return true;
+  try {
+    if (identifier.startsWith("%")) {
+      const output = execSync5("tmux list-panes -a -F '#{pane_id}'", {
+        timeout: 2e3,
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return output.split("\n").some((l) => l.trim() === identifier);
+    } else {
+      execSync5(`tmux has-session -t ${JSON.stringify(identifier)}`, {
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return true;
+    }
+  } catch {
+    if (identifier.startsWith("%")) return true;
+    try {
+      execSync5("tmux list-sessions", {
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return false;
+    } catch {
+      return true;
+    }
+  }
+}
+function checkStaleCompletion(taskContext, taskCreatedAt) {
+  if (!taskContext) return null;
+  if (!DELEGATION_KEYWORDS.test(taskContext)) return null;
+  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.";
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function updateTaskStatus(input2) {
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const row = await resolveTask(client, input2.taskId);
+  const taskId = String(row.id);
+  const taskFile = String(row.task_file);
+  if (input2.status === "done" && String(row.assigned_by) === "system" && taskFile.includes("review-")) {
+    process.stderr.write(
+      `[updateTask] Review task "${String(row.title)}" being marked done (assigned to ${String(row.assigned_to)})
+`
+    );
+  }
+  if (input2.status === "done") {
+    const existingRow = await client.execute({
+      sql: "SELECT context, created_at FROM tasks WHERE id = ?",
+      args: [taskId]
+    });
+    if (existingRow.rows.length > 0) {
+      const ctx = existingRow.rows[0];
+      const warning = checkStaleCompletion(ctx.context, ctx.created_at);
+      if (warning) {
+        input2.result = input2.result ? `\u26A0\uFE0F ${warning}
+
+${input2.result}` : `\u26A0\uFE0F ${warning}`;
+        process.stderr.write(`[tasks] ${warning} (task: ${taskId})
+`);
+      }
+    }
+  }
+  if (input2.status === "in_progress") {
+    const tmuxSession = process.env.TMUX_PANE ?? process.env.MY_TMUX_SESSION ?? "unknown";
+    const claim = await client.execute({
+      sql: `UPDATE tasks
+            SET status = 'in_progress', assigned_tmux = ?, updated_at = ?
+            WHERE id = ? AND status = 'open'`,
+      args: [tmuxSession, now, taskId]
+    });
+    if (claim.rowsAffected === 0) {
+      const current = await client.execute({
+        sql: "SELECT status, assigned_tmux, assigned_by FROM tasks WHERE id = ?",
+        args: [taskId]
+      });
+      const cur = current.rows[0];
+      const curStatus = cur?.status ?? "unknown";
+      const claimedBySession = cur?.assigned_tmux ?? "";
+      const assignedBy = cur?.assigned_by ?? "";
+      if (curStatus === "in_progress" && claimedBySession && !isTmuxSessionAlive(claimedBySession)) {
+        process.stderr.write(
+          `[tasks] Auto-releasing dead claim on ${taskId} (was ${claimedBySession})
+`
+        );
+        await client.execute({
+          sql: "UPDATE tasks SET status = 'open', assigned_tmux = NULL, updated_at = ? WHERE id = ?",
+          args: [now, taskId]
+        });
+        const retried = await client.execute({
+          sql: `UPDATE tasks SET status = 'in_progress', assigned_tmux = ?, updated_at = ? WHERE id = ? AND status = 'open'`,
+          args: [tmuxSession, now, taskId]
+        });
+        if (retried.rowsAffected > 0) {
+          try {
+            await writeCheckpoint({
+              taskId,
+              step: "reclaimed_dead_session",
+              contextSummary: `Task reclaimed after dead session ${claimedBySession} released.`
+            });
+          } catch {
+          }
+          return { row, taskFile, now, taskId };
+        }
+      }
+      if (curStatus === "in_progress" && input2.callerAgentId && (input2.callerAgentId === assignedBy || isCoordinatorName(input2.callerAgentId))) {
+        process.stderr.write(
+          `[tasks] Assigner override: ${input2.callerAgentId} reclaiming ${taskId}
+`
+        );
+        await client.execute({
+          sql: `UPDATE tasks SET status = 'in_progress', assigned_tmux = ?, updated_at = ? WHERE id = ?`,
+          args: [tmuxSession, now, taskId]
+        });
+        try {
+          await writeCheckpoint({
+            taskId,
+            step: "assigner_override",
+            contextSummary: `Task force-reclaimed by assigner ${input2.callerAgentId}.`
+          });
+        } catch {
+        }
+        return { row, taskFile, now, taskId };
+      }
+      const claimedBy = claimedBySession ? ` (claimed by ${claimedBySession})` : "";
+      throw new Error(`${TASK_ALREADY_CLAIMED_PREFIX}: task ${taskId} is ${curStatus}${claimedBy}`);
+    }
+    try {
+      await writeCheckpoint({
+        taskId,
+        step: "claimed",
+        contextSummary: `Task claimed by session. Transitioning open \u2192 in_progress.`
+      });
+    } catch {
+    }
+    return { row, taskFile, now, taskId };
+  }
+  if (input2.result) {
+    await client.execute({
+      sql: "UPDATE tasks SET status = ?, result = ?, updated_at = ? WHERE id = ?",
+      args: [input2.status, input2.result, now, taskId]
+    });
+  } else {
+    await client.execute({
+      sql: "UPDATE tasks SET status = ?, updated_at = ? WHERE id = ?",
+      args: [input2.status, now, taskId]
+    });
+  }
+  try {
+    await writeCheckpoint({
+      taskId,
+      step: `status_transition:${input2.status}`,
+      contextSummary: input2.result ? `Transitioned to ${input2.status}. Result: ${input2.result.slice(0, 500)}` : `Transitioned to ${input2.status}.`
+    });
+  } catch {
+  }
+  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 = path10.join(baseDir, "exe", "ARCHITECTURE.md");
+  try {
+    if (existsSync9(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 writeFile3(archPath, template, "utf-8");
+  } catch {
+  }
+}
+async function ensureGitignoreExe(baseDir) {
+  const gitignorePath = path10.join(baseDir, ".gitignore");
+  try {
+    if (existsSync9(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 writeFile3(gitignorePath, "# Employee task assignments (private)\n/exe/\n", "utf-8");
+    }
+  } catch {
+  }
+}
+var LANE_KEYWORDS, KEYWORD_INDEX, DELEGATION_KEYWORDS, TASK_ALREADY_CLAIMED_PREFIX;
+var init_tasks_crud = __esm({
+  "src/lib/tasks-crud.ts"() {
+    "use strict";
+    init_database();
+    init_task_scope();
+    init_employees();
+    LANE_KEYWORDS = {
+      CMO: ["sales", "script", "pitch", "offer", "copy", "objection", "brand", "content", "seo", "marketing", "newsletter", "carousel", "social", "campaign"],
+      CTO: ["spec", "architecture", "migration", "schema", "database", "design doc", "adr", "security audit", "tech stack"],
+      "Principal Engineer": ["implement", "build", "fix", "commit", "refactor", "bug", "feature", "wire", "integration"],
+      "Staff Code Reviewer": ["critique", "verdict", "review", "audit", "code quality"],
+      "Content Production Specialist": ["render", "video", "image", "b-roll", "remotion", "animation", "thumbnail"],
+      "AI Product Lead": ["competitive", "analysis", "benchmark", "compare", "scout", "evaluate", "poc"]
+    };
+    KEYWORD_INDEX = buildKeywordIndex();
+    DELEGATION_KEYWORDS = /parallel|delegate|wave|worktree|multi-instance/i;
+    TASK_ALREADY_CLAIMED_PREFIX = "TASK_ALREADY_CLAIMED";
+  }
+});
+
+// src/lib/tasks-review.ts
+import path11 from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync3, unlinkSync as unlinkSync5 } from "fs";
+async function countPendingReviews(sessionScope) {
+  const client = getClient();
+  if (sessionScope) {
+    const result2 = await client.execute({
+      sql: "SELECT COUNT(*) as cnt FROM tasks WHERE status = 'needs_review' AND (session_scope = ? OR session_scope IS NULL)",
+      args: [sessionScope]
+    });
+    return Number(result2.rows[0]?.cnt) || 0;
+  }
+  const result = await client.execute({
+    sql: "SELECT COUNT(*) as cnt FROM tasks WHERE status = 'needs_review'",
+    args: []
+  });
+  return Number(result.rows[0]?.cnt) || 0;
+}
+async function countNewPendingReviewsSince(sinceIso, sessionScope) {
+  const client = getClient();
+  if (sessionScope) {
+    const result2 = await client.execute({
+      sql: `SELECT COUNT(*) as cnt FROM tasks
+            WHERE status = 'needs_review' AND updated_at > ?
+              AND session_scope = ?`,
+      args: [sinceIso, sessionScope]
+    });
+    return Number(result2.rows[0]?.cnt) || 0;
+  }
+  const result = await client.execute({
+    sql: `SELECT COUNT(*) as cnt FROM tasks
+          WHERE status = 'needs_review' AND updated_at > ?`,
+    args: [sinceIso]
+  });
+  return Number(result.rows[0]?.cnt) || 0;
+}
+async function listPendingReviews(limit, sessionScope) {
+  const client = getClient();
+  if (sessionScope) {
+    const result2 = await client.execute({
+      sql: `SELECT title, assigned_to, project_name FROM tasks
+            WHERE status = 'needs_review'
+              AND session_scope = ?
+            ORDER BY priority ASC, created_at DESC LIMIT ?`,
+      args: [sessionScope, limit]
+    });
+    return result2.rows;
+  }
+  const result = await client.execute({
+    sql: `SELECT title, assigned_to, project_name FROM tasks
+          WHERE status = 'needs_review'
+          ORDER BY priority ASC, created_at DESC LIMIT ?`,
+    args: [limit]
+  });
+  return result.rows;
+}
+async function cleanupOrphanedReviews() {
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const r1 = await client.execute({
+    sql: `UPDATE tasks SET status = 'cancelled', updated_at = ?
+          WHERE status IN ('open', 'needs_review', 'in_progress')
+          AND assigned_by = 'system'
+          AND title LIKE 'Review:%'
+          AND parent_task_id IN (SELECT id FROM tasks WHERE status IN ('done', 'cancelled'))`,
+    args: [now]
+  });
+  const r1b = await client.execute({
+    sql: `UPDATE tasks SET status = 'cancelled', updated_at = ?
+          WHERE status IN ('open', 'needs_review')
+          AND title LIKE 'Review:%completed%'
+          AND (parent_task_id IS NULL OR parent_task_id NOT IN (SELECT id FROM tasks WHERE status IN ('open', 'in_progress', 'needs_review', 'blocked')))`,
+    args: [now]
+  });
+  const staleThreshold = new Date(Date.now() - 60 * 60 * 1e3).toISOString();
+  const r2 = await client.execute({
+    sql: `UPDATE tasks SET status = 'done', updated_at = ?
+          WHERE status = 'needs_review'
+          AND result IS NOT NULL
+          AND updated_at < ?`,
+    args: [now, staleThreshold]
+  });
+  const total = r1.rowsAffected + (r1b?.rowsAffected ?? 0) + r2.rowsAffected;
+  if (total > 0) {
+    process.stderr.write(
+      `[cleanup] Closed ${total} orphaned review(s): ${r1.rowsAffected} cascade + ${r1b?.rowsAffected ?? 0} orphan + ${r2.rowsAffected} stale
+`
+    );
+  }
+  return total;
+}
+function getReviewChecklist(role, agent, taskSlug) {
+  const roleLower = role.toLowerCase();
+  if (roleLower.includes("engineer") || roleLower === "principal engineer") {
+    return {
+      lens: "Code Quality (Engineer)",
+      checklist: [
+        "1. Do all tests pass? Any new tests needed?",
+        "2. Is the code clean \u2014 no dead code, no TODOs left?",
+        "3. Does it follow existing patterns and conventions in the codebase?",
+        "4. Any regressions in the test suite?"
+      ]
+    };
+  }
+  if (roleLower === "cto" || roleLower.includes("architect")) {
+    return {
+      lens: "Architecture (CTO)",
+      checklist: [
+        "1. Does this fit the existing architecture? Consistent with ARCHITECTURE.md?",
+        "2. Is it backward compatible? Any breaking changes?",
+        "3. Does it introduce technical debt? Is that debt justified?",
+        "4. Security implications? Any new attack surface?",
+        "5. Does it scale? Performance considerations?",
+        "6. Coordination: does this affect other employees' work or other projects?"
+      ]
+    };
+  }
+  if (roleLower === "coo" || roleLower.includes("operations")) {
+    return {
+      lens: "Strategic (COO)",
+      checklist: [
+        "1. Does this serve the project mission?",
+        "2. Is this the right work at the right time?",
+        "3. Does the architectural assessment make sense for the business?",
+        "4. Any cross-project implications?"
+      ]
+    };
+  }
+  return {
+    lens: "General",
+    checklist: [
+      "1. Read the original task's acceptance criteria",
+      `2. Check git log for related commits: \`git log --oneline --author-date-order -10\``,
+      "3. Verify code changes match requirements",
+      "4. Check if tests were added/updated",
+      `5. Look for output files in exe/output/${agent}-${taskSlug}*`
+    ]
+  };
+}
+async function cleanupReviewFile(row, taskFile, _baseDir) {
+  if (String(row.assigned_by) !== "system" || !taskFile.includes("review-")) return;
+  try {
+    const client = getClient();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const parentId = row.parent_task_id ? String(row.parent_task_id) : null;
+    if (parentId) {
+      const result = await client.execute({
+        sql: "UPDATE tasks SET status = 'done', updated_at = ? WHERE id = ? AND status = 'needs_review'",
+        args: [now, parentId]
+      });
+      if (result.rowsAffected > 0) {
+        process.stderr.write(
+          `[review-cleanup] Cascaded original task to done via parent_task_id: ${parentId}
+`
+        );
+      }
+    } else {
+      const fileName = taskFile.split("/").pop() ?? "";
+      const reviewPrefix = fileName.replace(".md", "");
+      const parts = reviewPrefix.split("-");
+      if (parts.length >= 3 && parts[0] === "review") {
+        const agent = parts[1];
+        const slug = parts.slice(2).join("-");
+        const legacyTaskFile = `exe/${agent}/${slug}.md`;
+        const result = await client.execute({
+          sql: "UPDATE tasks SET status = 'done', updated_at = ? WHERE (task_file = ? OR task_file LIKE ?) AND status = 'needs_review'",
+          args: [now, legacyTaskFile, `tasks/%/${agent}/${slug}.md`]
+        });
+        if (result.rowsAffected > 0) {
+          process.stderr.write(
+            `[review-cleanup] Cascaded original task to done: ${agent}/${slug}.md
+`
+          );
+        }
+      }
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[review-cleanup] Failed to cascade original task: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+  try {
+    const cacheDir = path11.join(EXE_AI_DIR, "session-cache");
+    if (existsSync10(cacheDir)) {
+      for (const f of readdirSync3(cacheDir)) {
+        if (f.startsWith("review-notified-")) {
+          unlinkSync5(path11.join(cacheDir, f));
+        }
+      }
+    }
+  } catch {
+  }
+}
+var init_tasks_review = __esm({
+  "src/lib/tasks-review.ts"() {
+    "use strict";
+    init_database();
+    init_config();
+    init_employees();
+    init_notifications();
+    init_tmux_routing();
+    init_session_key();
+    init_state_bus();
+  }
+});
+
+// src/lib/tasks-chain.ts
+import path12 from "path";
+import { readFile as readFile3, writeFile as writeFile4 } 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 ubScope = sessionScopeFilter();
+    const unblockedRows = await client.execute({
+      sql: `SELECT task_file FROM tasks WHERE blocked_by IS NULL AND updated_at = ?${ubScope.sql}`,
+      args: [now, ...ubScope.args]
+    });
+    for (const ur of unblockedRows.rows) {
+      try {
+        const ubFile = path12.join(baseDir, String(ur.task_file));
+        let ubContent = await readFile3(ubFile, "utf-8");
+        ubContent = ubContent.replace(/\*\*Status:\*\* blocked/, "**Status:** open");
+        ubContent = ubContent.replace(/\n\*\*Blocked by:\*\*.*\n/, "\n");
+        await writeFile4(ubFile, ubContent, "utf-8");
+      } catch {
+      }
+    }
+  }
+}
+async function findNextTask(assignedTo) {
+  const client = getClient();
+  const ntScope = sessionScopeFilter();
+  const nextResult = await client.execute({
+    sql: `SELECT title, task_file, priority FROM tasks
+          WHERE assigned_to = ? AND status = 'open'${ntScope.sql}
+          ORDER BY priority ASC, created_at ASC
+          LIMIT 1`,
+    args: [assignedTo, ...ntScope.args]
+  });
+  if (nextResult.rows.length === 1) {
+    const nr = nextResult.rows[0];
+    return {
+      title: String(nr.title),
+      priority: String(nr.priority),
+      taskFile: String(nr.task_file)
+    };
+  }
+  return void 0;
+}
+async function checkSubtaskCompletion(parentTaskId, projectName) {
+  const client = getClient();
+  const scScope = sessionScopeFilter();
+  const remaining = await client.execute({
+    sql: `SELECT COUNT(*) as cnt FROM tasks
+          WHERE parent_task_id = ? AND status NOT IN ('done', 'cancelled')${scScope.sql}`,
+    args: [parentTaskId, ...scScope.args]
+  });
+  const cnt = Number(remaining.rows[0]?.cnt ?? 1);
+  if (cnt === 0) {
+    const parentRow = await client.execute({
+      sql: `SELECT assigned_to, title, task_file, project_name FROM tasks WHERE id = ?`,
+      args: [parentTaskId]
+    });
+    if (parentRow.rows.length === 1) {
+      const pr = parentRow.rows[0];
+      const parentProject = pr.project_name == null ? projectName : String(pr.project_name);
+      await writeNotification({
+        agentId: String(pr.assigned_to),
+        agentRole: "system",
+        event: "subtasks_complete",
+        project: parentProject,
+        summary: `All subtasks complete for "${String(pr.title)}" \u2014 ready for rollup review`,
+        taskFile: String(pr.task_file)
+      });
+    }
+  }
+}
+var init_tasks_chain = __esm({
+  "src/lib/tasks-chain.ts"() {
+    "use strict";
+    init_database();
+    init_notifications();
+    init_task_scope();
+  }
+});
+
+// src/lib/project-name.ts
+import { execSync as execSync6 } from "child_process";
+import path13 from "path";
+function getProjectName(cwd) {
+  const dir = cwd ?? process.cwd();
+  if (_cached2 && _cachedCwd === dir) return _cached2;
+  try {
+    let repoRoot;
+    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 = path13.dirname(gitCommonDir);
+    } catch {
+      repoRoot = execSync6("git rev-parse --show-toplevel", {
+        cwd: dir,
+        encoding: "utf8",
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+    }
+    _cached2 = path13.basename(repoRoot);
+    _cachedCwd = dir;
+    return _cached2;
+  } catch {
+    _cached2 = path13.basename(dir);
+    _cachedCwd = dir;
+    return _cached2;
+  }
+}
+var _cached2, _cachedCwd;
+var init_project_name = __esm({
+  "src/lib/project-name.ts"() {
+    "use strict";
+    _cached2 = null;
+    _cachedCwd = null;
+  }
+});
+
+// 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 && isCoordinatorName(s.agentId)) return s;
+  }
+  return null;
+}
+function assertSessionScope(actionType, targetProject) {
+  try {
+    const currentProject = getProjectName();
+    const exeSession = resolveExeSession();
+    if (!exeSession) {
+      return { allowed: true, reason: "no_session" };
+    }
+    if (currentProject === targetProject) {
+      return {
+        allowed: true,
+        reason: "same_session",
+        currentProject,
+        targetProject
+      };
+    }
+    process.stderr.write(
+      `[session-scope] BLOCKED cross-project ${actionType}: session project="${currentProject}" \u2260 target project="${targetProject}"
+`
+    );
+    return {
+      allowed: false,
+      reason: "cross_session_denied",
+      currentProject,
+      targetProject,
+      targetSession: findSessionForProject(targetProject)?.windowName
+    };
+  } catch {
+    return { allowed: true, reason: "no_session" };
+  }
+}
+var init_session_scope = __esm({
+  "src/lib/session-scope.ts"() {
+    "use strict";
+    init_session_registry();
+    init_project_name();
+    init_tmux_routing();
+    init_employees();
+  }
+});
+
+// src/lib/tasks-notify.ts
+async function dispatchTaskToEmployee(input2) {
+  if (isCoordinatorName(input2.assignedTo)) return { dispatched: "skipped" };
+  let crossProject = false;
+  if (input2.projectName) {
+    try {
+      const { assertSessionScope: assertSessionScope2 } = (init_session_scope(), __toCommonJS(session_scope_exports));
+      const check = assertSessionScope2("dispatch_task", input2.projectName);
+      if (check.reason === "cross_session_denied") {
+        crossProject = true;
+        return { dispatched: "skipped", crossProject: true };
+      }
+    } catch {
+    }
+  }
+  try {
+    const transport = getTransport();
+    const exeSession = resolveExeSession();
+    if (!exeSession) return { dispatched: "session_missing" };
+    const sessionName = employeeSessionName(input2.assignedTo, exeSession);
+    if (transport.isAlive(sessionName)) {
+      const result = sendIntercom(sessionName);
+      const dispatched = result === "acknowledged" || result === "debounced" || result === "queued" ? "verified" : result === "delivered" ? "sent_unverified" : "session_dead";
+      return { dispatched, session: sessionName, crossProject };
+    } else {
+      const projectDir = input2.projectDir ?? process.cwd();
+      const result = ensureEmployee(input2.assignedTo, exeSession, projectDir, {
+        autoInstance: isMultiInstance(input2.assignedTo)
+      });
+      if (result.status === "failed") {
+        process.stderr.write(
+          `[dispatch] Failed to spawn ${input2.assignedTo}: ${result.error}
+`
+        );
+        return { dispatched: "session_missing" };
+      }
+      return { dispatched: "spawned", session: result.sessionName, crossProject };
+    }
+  } catch {
+    return { dispatched: "session_missing" };
+  }
+}
+function notifyTaskDone() {
+  try {
+    const key = getSessionKey();
+    if (key && !process.env.VITEST) notifyParentExe(key);
+  } catch {
+  }
+}
+async function markTaskNotificationsRead(taskFile) {
+  try {
+    await markAsReadByTaskFile(taskFile);
+  } catch {
+  }
+}
+var init_tasks_notify = __esm({
+  "src/lib/tasks-notify.ts"() {
+    "use strict";
+    init_tmux_routing();
+    init_session_key();
+    init_notifications();
+    init_transport();
+    init_employees();
+  }
+});
+
+// src/lib/behaviors.ts
+import crypto4 from "crypto";
+async function storeBehavior(opts) {
+  const client = getClient();
+  const id = crypto4.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 init_behaviors = __esm({
+  "src/lib/behaviors.ts"() {
+    "use strict";
+    init_database();
+  }
+});
+
+// src/lib/skill-learning.ts
+var skill_learning_exports = {};
+__export(skill_learning_exports, {
+  captureAndLearn: () => captureAndLearn,
+  captureTrajectory: () => captureTrajectory,
+  editDistance: () => editDistance,
+  extractSkill: () => extractSkill,
+  extractTrajectory: () => extractTrajectory,
+  findSimilarTrajectories: () => findSimilarTrajectories,
+  hashSignature: () => hashSignature,
+  storeTrajectory: () => storeTrajectory,
+  sweepTrajectories: () => sweepTrajectories
+});
+import crypto5 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);
+    }
+  }
+  return signature;
+}
+function hashSignature(signature) {
+  return crypto5.createHash("sha256").update(signature.join("|")).digest("hex").slice(0, 16);
+}
+async function storeTrajectory(opts) {
+  const client = getClient();
+  const id = crypto5.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;
+}
+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));
+    }
+  }
+  return matches;
+}
+async function captureTrajectory(opts) {
+  const signature = await extractTrajectory(opts.taskId, opts.agentId);
+  if (signature.length < 3) {
+    return { trajectoryId: "", similarCount: 0, similar: [] };
+  }
+  const trajectoryId = await storeTrajectory({
+    taskId: opts.taskId,
+    agentId: opts.agentId,
+    projectName: opts.projectName,
+    taskTitle: opts.taskTitle,
+    signature
+  });
+  const similar = await findSimilarTrajectories(
+    signature,
+    opts.skillThreshold ?? DEFAULT_SKILL_THRESHOLD
+  );
+  return { trajectoryId, similarCount: similar.length, similar };
+}
+function buildExtractionPrompt(trajectories) {
+  const items = trajectories.map((t, i) => {
+    const sig = t.signature.join(" \u2192 ");
+    return `Task ${i + 1}: "${t.taskTitle}" (${t.agentId}, ${t.projectName}) \u2014 ${t.toolCount} tool calls
+Signature: ${sig}`;
+  }).join("\n\n");
+  return `You are analyzing ${trajectories.length} completed tasks that followed similar procedures:
+
+${items}
+
+Extract the reusable procedure. Format your response EXACTLY like this:
+
+SKILL: {name \u2014 short, descriptive}
+TRIGGER: {when to use this \u2014 one sentence}
+STEPS:
+1. ...
+2. ...
+PITFALLS: {common mistakes to avoid}
+
+Be specific and actionable. Include tool names, file patterns, and concrete commands where applicable.`;
+}
+async function extractSkill(trajectories, model) {
+  if (trajectories.length === 0) return null;
+  const config = await loadConfig();
+  const skillModel = model ?? config.skillModel;
+  const Anthropic = (await import("@anthropic-ai/sdk")).default;
+  const client = new Anthropic();
+  const prompt = buildExtractionPrompt(trajectories);
+  const response = await client.messages.create({
+    model: skillModel,
+    max_tokens: 500,
+    messages: [{ role: "user", content: prompt }]
+  });
+  const textBlock = response.content.find((b) => b.type === "text");
+  const skillText = textBlock?.text;
+  if (!skillText) return null;
+  const agentId = trajectories[0].agentId;
+  const projectName = trajectories[0].projectName;
+  const skillId = await storeBehavior({
+    agentId,
+    content: skillText,
+    domain: "skill",
+    projectName
+  });
+  const dbClient = getClient();
+  for (const t of trajectories) {
+    await dbClient.execute({
+      sql: "UPDATE trajectories SET skill_id = ? WHERE id = ?",
+      args: [skillId, t.id]
+    });
+  }
+  process.stderr.write(
+    `[skill-learning] Skill extracted from ${trajectories.length} trajectories \u2192 behavior ${skillId}
+`
+  );
+  return skillId;
+}
+async function captureAndLearn(opts) {
+  try {
+    const config = await loadConfig();
+    if (!config.skillLearning) return;
+    const { trajectoryId, similarCount, similar } = await captureTrajectory({
+      ...opts,
+      skillThreshold: config.skillThreshold
+    });
+    if (!trajectoryId) return;
+    if (similarCount >= config.skillThreshold) {
+      const unprocessed = similar.filter((t) => !t.skillId);
+      if (unprocessed.length >= config.skillThreshold) {
+        extractSkill(unprocessed, config.skillModel).catch((err) => {
+          process.stderr.write(
+            `[skill-learning] Extraction failed: ${err instanceof Error ? err.message : String(err)}
+`
+          );
+        });
+      }
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[skill-learning] captureAndLearn failed: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
+async function sweepTrajectories(threshold, model) {
+  const config = await loadConfig();
+  if (!config.skillLearning) return { clustersProcessed: 0, skillsExtracted: 0 };
+  const t = threshold ?? config.skillThreshold;
+  const client = getClient();
+  const result = await client.execute({
+    sql: `SELECT 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 ?? config.skillModel);
+      if (skillId) skillsExtracted++;
+    }
+  }
+  return { clustersProcessed, skillsExtracted };
+}
+function editDistance(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(
+        dp[i - 1][j] + 1,
+        dp[i][j - 1] + 1,
+        dp[i - 1][j - 1] + cost
+      );
+    }
+  }
+  return dp[m][n];
+}
+var DEFAULT_SKILL_THRESHOLD;
+var init_skill_learning = __esm({
+  "src/lib/skill-learning.ts"() {
+    "use strict";
+    init_database();
+    init_behaviors();
+    init_config();
+    DEFAULT_SKILL_THRESHOLD = 3;
+  }
+});
+
+// src/lib/tasks.ts
+var tasks_exports = {};
+__export(tasks_exports, {
+  cleanupOrphanedReviews: () => cleanupOrphanedReviews,
+  countNewPendingReviewsSince: () => countNewPendingReviewsSince,
+  countPendingReviews: () => countPendingReviews,
+  createTask: () => createTask,
+  createTaskCore: () => createTaskCore,
+  deleteTask: () => deleteTask,
+  deleteTaskCore: () => deleteTaskCore,
+  ensureArchitectureDoc: () => ensureArchitectureDoc,
+  ensureGitignoreExe: () => ensureGitignoreExe,
+  getReviewChecklist: () => getReviewChecklist,
+  listPendingReviews: () => listPendingReviews,
+  listTasks: () => listTasks,
+  resolveTask: () => resolveTask,
+  slugify: () => slugify,
+  updateTask: () => updateTask,
+  updateTaskStatus: () => updateTaskStatus,
+  writeCheckpoint: () => writeCheckpoint
+});
+import path14 from "path";
+import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, unlinkSync as unlinkSync6 } from "fs";
+async function createTask(input2) {
+  const result = await createTaskCore(input2);
+  if (!input2.skipDispatch && result.status !== "blocked" && !process.env.VITEST) {
+    dispatchTaskToEmployee({
+      assignedTo: input2.assignedTo,
+      title: input2.title,
+      priority: input2.priority,
+      taskFile: result.taskFile,
+      initialStatus: result.status,
+      projectName: input2.projectName
+    });
+  }
+  return result;
+}
+async function updateTask(input2) {
+  const { row, taskFile, now, taskId } = await updateTaskStatus(input2);
+  try {
+    const agent = String(row.assigned_to);
+    const cacheDir = path14.join(EXE_AI_DIR, "session-cache");
+    const cachePath = path14.join(cacheDir, `current-task-${agent}.json`);
+    if (input2.status === "in_progress") {
+      mkdirSync5(cacheDir, { recursive: true });
+      writeFileSync6(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
+    } else if (input2.status === "done" || input2.status === "blocked" || input2.status === "cancelled") {
+      try {
+        unlinkSync6(cachePath);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  if (input2.status === "done") {
+    await cleanupReviewFile(row, taskFile, input2.baseDir);
+  }
+  if (input2.status === "done" || input2.status === "cancelled") {
+    try {
+      const client = getClient();
+      const taskTitle = String(row.title);
+      const escaped = taskTitle.replace(/%/g, "\\%").replace(/_/g, "\\_");
+      await client.execute({
+        sql: `UPDATE tasks SET status = 'cancelled', updated_at = ?
+              WHERE title LIKE ? ESCAPE '\\' AND status IN ('open', 'in_progress')`,
+        args: [now, `%left '${escaped}' as in\\_progress%`]
+      });
+    } catch {
+    }
+    const assignedAgent = String(row.assigned_to);
+    if (!isCoordinatorName(assignedAgent)) {
+      try {
+        const draftClient = getClient();
+        if (input2.status === "done") {
+          await draftClient.execute({
+            sql: `UPDATE memories SET draft = 0 WHERE agent_id = ? AND draft = 1`,
+            args: [assignedAgent]
+          });
+        } else if (input2.status === "cancelled") {
+          await draftClient.execute({
+            sql: `DELETE FROM memories WHERE agent_id = ? AND draft = 1`,
+            args: [assignedAgent]
+          });
+        }
+      } catch {
+      }
+    }
+    try {
+      const client = getClient();
+      const cascaded = await client.execute({
+        sql: `UPDATE tasks SET status = 'done', updated_at = ?
+              WHERE parent_task_id = ? AND status = 'needs_review'`,
+        args: [now, taskId]
+      });
+      if (cascaded.rowsAffected > 0) {
+        process.stderr.write(
+          `[cascade] Closed ${cascaded.rowsAffected} orphaned review task(s) for parent ${taskId}
+`
+        );
+      }
+    } catch {
+    }
+  }
+  const isTerminal = input2.status === "done" || input2.status === "needs_review";
+  if (isTerminal) {
+    const isCoordinator = isCoordinatorName(String(row.assigned_to));
+    if (!isCoordinator) {
+      notifyTaskDone();
+    }
+    await markTaskNotificationsRead(taskFile);
+    if (input2.status === "done") {
+      try {
+        await cascadeUnblock(taskId, input2.baseDir, now);
+      } catch {
+      }
+      orgBus.emit({
+        type: "task_completed",
+        taskId,
+        employee: String(row.assigned_to),
+        result: input2.result ?? "",
+        timestamp: now
+      });
+      if (row.parent_task_id) {
+        try {
+          await checkSubtaskCompletion(String(row.parent_task_id), String(row.project_name));
+        } catch {
+        }
+      }
+    }
+  }
+  if (input2.status === "done" && !isCoordinatorName(String(row.assigned_to)) && !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 && !isCoordinatorName(String(row.assigned_to))) {
+    try {
+      nextTask = await findNextTask(String(row.assigned_to));
+    } catch {
+    }
+  }
+  return {
+    id: String(row.id),
+    title: String(row.title),
+    assignedTo: String(row.assigned_to),
+    assignedBy: String(row.assigned_by),
+    projectName: String(row.project_name),
+    priority: String(row.priority),
+    status: input2.status,
+    taskFile,
+    createdAt: String(row.created_at),
+    updatedAt: now,
+    budgetTokens: row.budget_tokens !== void 0 && row.budget_tokens !== null ? Number(row.budget_tokens) : null,
+    budgetFallbackModel: row.budget_fallback_model !== void 0 && row.budget_fallback_model !== null ? String(row.budget_fallback_model) : null,
+    tokensUsed: Number(row.tokens_used ?? 0),
+    tokensWarnedAt: row.tokens_warned_at !== void 0 && row.tokens_warned_at !== null ? Number(row.tokens_warned_at) : null,
+    nextTask
+  };
+}
+async function deleteTask(taskId, baseDir) {
+  const client = getClient();
+  const { taskFile, assignedTo, assignedBy, taskSlug } = await deleteTaskCore(taskId, baseDir);
+  const coordinatorName = getCoordinatorName();
+  const reviewer = assignedBy || coordinatorName;
+  const reviewSlug = `review-${assignedTo}-${taskSlug}`;
+  const reviewFile = `exe/${reviewer}/${reviewSlug}.md`;
+  const legacyReviewFile = `exe/${coordinatorName}/${reviewSlug}.md`;
+  await client.execute({
+    sql: "DELETE FROM tasks WHERE task_file = ? OR task_file = ? OR task_file = ?",
+    args: [reviewFile, legacyReviewFile, `exe/exe/${reviewSlug}.md`]
+  });
+  await markAsReadByTaskFile(taskFile);
+  await markAsReadByTaskFile(reviewFile);
+}
+var init_tasks = __esm({
+  "src/lib/tasks.ts"() {
+    "use strict";
+    init_database();
+    init_config();
+    init_notifications();
+    init_state_bus();
+    init_employees();
+    init_tasks_crud();
+    init_tasks_review();
+    init_tasks_crud();
+    init_tasks_chain();
+    init_tasks_review();
+    init_tasks_notify();
+  }
+});
+
+// src/lib/capacity-monitor.ts
+var capacity_monitor_exports = {};
+__export(capacity_monitor_exports, {
+  CTX_FLOOR_PERCENT: () => CTX_FLOOR_PERCENT,
+  _resetLastRelaunchCache: () => _resetLastRelaunchCache,
+  _resetPendingCapacityKills: () => _resetPendingCapacityKills,
+  confirmCapacityKill: () => confirmCapacityKill,
+  createOrRefreshResumeTask: () => createOrRefreshResumeTask,
+  extractContextPercent: () => extractContextPercent,
+  isAtCapacity: () => isAtCapacity,
+  isWithinRelaunchCooldown: () => isWithinRelaunchCooldown,
+  pollCapacityDead: () => pollCapacityDead
+});
+function resumeTaskTitle(agentId) {
+  return `${RESUME_TITLE_PREFIX} ${agentId} hit context capacity \u2014 continue open tasks`;
+}
+function buildResumeContext(agentId, openTasks) {
+  const taskList = openTasks.map(
+    (r, i) => `${i + 1}. [${String(r.priority).toUpperCase()}] ${String(r.title)} (${String(r.task_file)})`
+  ).join("\n");
+  return [
+    "## Context",
+    "",
+    `${agentId} hit context capacity and was auto-relaunched by the capacity monitor.`,
+    "Call recall_my_memory first \u2014 search for 'CONTEXT CHECKPOINT'. Pick up where the previous session stopped.",
+    "",
+    `You have ${openTasks.length} open task(s). Work through them in priority order:`,
+    "",
+    taskList,
+    "",
+    "Read each task file and chain through them. Build and commit after each one."
+  ].join("\n");
+}
+function filterPaneContent(paneOutput) {
+  return paneOutput.split("\n").filter((line) => {
+    if (CONTENT_LINE_PREFIX.test(line)) return false;
+    for (const marker of CONTENT_LINE_MARKERS) {
+      if (line.includes(marker)) return false;
+    }
+    for (const re of SOURCE_CODE_MARKERS) {
+      if (re.test(line)) return false;
+    }
+    return true;
+  }).join("\n");
+}
+function extractContextPercent(paneOutput) {
+  const match = paneOutput.match(CC_CONTEXT_BAR_RE);
+  if (!match) return null;
+  const parsed = Number.parseInt(match[2], 10);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function isAtCapacity(paneOutput) {
+  const filtered = filterPaneContent(paneOutput);
+  return CAPACITY_PATTERNS.some((p) => p.test(filtered));
+}
+function confirmCapacityKill(agentId, now = Date.now()) {
+  const pendingSince = _pendingCapacityKill.get(agentId);
+  if (pendingSince === void 0) {
+    _pendingCapacityKill.set(agentId, now);
+    return false;
+  }
+  if (now - pendingSince > CONFIRMATION_WINDOW_MS) {
+    _pendingCapacityKill.set(agentId, now);
+    return false;
+  }
+  _pendingCapacityKill.delete(agentId);
+  return true;
+}
+function _resetPendingCapacityKills() {
+  _pendingCapacityKill.clear();
+}
+function _resetLastRelaunchCache() {
+  _lastRelaunch.clear();
+}
+async function lastResumeCreatedAtMs(agentId) {
+  const client = getClient();
+  const cmScope = sessionScopeFilter(null);
+  const result = await client.execute({
+    sql: `SELECT MAX(created_at) AS last_created_at
+          FROM tasks
+          WHERE assigned_to = ? AND title LIKE ?${cmScope.sql}`,
+    args: [agentId, `${RESUME_TITLE_PREFIX} %`, ...cmScope.args]
+  });
+  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 rdScope = sessionScopeFilter(null);
+  const existing = await client.execute({
+    sql: `SELECT id FROM tasks
+          WHERE assigned_to = ?
+            AND title LIKE ?
+            AND status IN (${RESUME_ACTIVE_STATUSES.map(() => "?").join(", ")})${rdScope.sql}
+          ORDER BY created_at DESC
+          LIMIT 1`,
+    args: [agentId, RESUME_TITLE_LIKE_PATTERN, ...RESUME_ACTIVE_STATUSES, ...rdScope.args]
+  });
+  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" && !isCoordinatorName(s.agentId)
+  );
+  if (registered.length === 0) return [];
+  let liveSessions;
+  try {
+    liveSessions = transport.listSessions();
+  } catch {
+    return [];
+  }
+  for (const entry of registered) {
+    const { windowName, agentId, projectDir } = entry;
+    if (!liveSessions.includes(windowName)) continue;
+    if (await isWithinRelaunchCooldown(agentId)) continue;
+    let pane;
+    try {
+      pane = transport.capturePane(windowName, 15);
+    } catch {
+      continue;
+    }
+    if (!isAtCapacity(pane)) continue;
+    const ctxPct = extractContextPercent(pane);
+    if (ctxPct !== null && ctxPct < CTX_FLOOR_PERCENT) {
+      process.stderr.write(
+        `[capacity-monitor] ctx-floor: ${agentId} at ${ctxPct}% in ${windowName} \u2014 below ${CTX_FLOOR_PERCENT}%. Skipping capacity kill (likely self-referential content or false positive).
+`
+      );
+      continue;
+    }
+    if (!confirmCapacityKill(agentId)) {
+      process.stderr.write(
+        `[capacity-monitor] ${agentId} matched capacity pattern once in ${windowName}. Awaiting confirmation on next tick.
+`
+      );
+      continue;
+    }
+    const verify = await verifyPaneAtCapacity(windowName);
+    if (!verify.atCapacity) {
+      process.stderr.write(
+        `[capacity-monitor] verifyPaneAtCapacity rejected kill for ${agentId} in ${windowName} (reason: ${verify.reason}). Skipping.
+`
+      );
+      void recordSessionKill({
+        sessionName: windowName,
+        agentId,
+        reason: "capacity_false_positive_blocked"
+      });
+      continue;
+    }
+    process.stderr.write(
+      `[capacity-monitor] Detected ${agentId} at capacity in session ${windowName} (confirmed). Auto-relaunching.
+`
+    );
+    try {
+      transport.kill(windowName);
+      void recordSessionKill({
+        sessionName: windowName,
+        agentId,
+        reason: "capacity"
+      });
+      const client = getClient();
+      const rlScope = sessionScopeFilter(null);
+      const openTasks = await client.execute({
+        sql: `SELECT id, title, priority, task_file, status
+              FROM tasks
+              WHERE assigned_to = ? AND status IN ('open', 'in_progress')${rlScope.sql}
+              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, ...rlScope.args]
+      });
+      if (openTasks.rows.length === 0) {
+        process.stderr.write(
+          `[capacity-monitor] ${agentId} has no open tasks \u2014 skipping relaunch.
+`
+        );
+        continue;
+      }
+      const { created } = await createOrRefreshResumeTask(
+        agentId,
+        projectDir,
+        openTasks.rows
+      );
+      if (created) {
+        await writeNotification({
+          agentId: "system",
+          agentRole: "daemon",
+          event: "capacity_relaunch",
+          project: projectDir.split("/").pop() ?? "unknown",
+          summary: `${agentId} hit context capacity. Auto-relaunched with ${openTasks.rows.length} open task(s).`
+        });
+      }
+      _lastRelaunch.set(agentId, Date.now());
+      if (created) relaunched.push(agentId);
+    } catch (err) {
+      process.stderr.write(
+        `[capacity-monitor] Failed to relaunch ${agentId}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  return relaunched;
+}
+var CAPACITY_PATTERNS, CONTENT_LINE_PREFIX, CONTENT_LINE_MARKERS, SOURCE_CODE_MARKERS, RELAUNCH_COOLDOWN_MS, _lastRelaunch, RESUME_TITLE_PREFIX, RESUME_TITLE_LIKE_PATTERN, RESUME_ACTIVE_STATUSES, CONFIRMATION_WINDOW_MS, _pendingCapacityKill, CC_CONTEXT_BAR_RE, CTX_FLOOR_PERCENT;
+var init_capacity_monitor = __esm({
+  "src/lib/capacity-monitor.ts"() {
+    "use strict";
+    init_session_registry();
+    init_transport();
+    init_notifications();
+    init_database();
+    init_session_kill_telemetry();
+    init_tmux_routing();
+    init_task_scope();
+    init_employees();
+    CAPACITY_PATTERNS = [
+      /conversation is too long/i,
+      /maximum context length/i,
+      /context window.*(?:limit|exceed|full)/i,
+      /reached.*(?:token|context).*limit/i
+    ];
+    CONTENT_LINE_PREFIX = /^[\s>#\-*[]/;
+    CONTENT_LINE_MARKERS = [
+      "RESUME:",
+      "intercom",
+      "capacity-monitor",
+      "CAPACITY_PATTERNS",
+      "isAtCapacity",
+      "CONTENT_LINE_MARKERS",
+      "pollCapacityDead",
+      "confirmCapacityKill",
+      "session_kills",
+      "capacity-monitor.test"
+    ];
+    SOURCE_CODE_MARKERS = [
+      /["'`/].*(?:maximum context length|conversation is too long)/i,
+      /(?:maximum context length|conversation is too long).*["'`/]/i
+    ];
+    RELAUNCH_COOLDOWN_MS = 5 * 60 * 1e3;
+    _lastRelaunch = /* @__PURE__ */ new Map();
+    RESUME_TITLE_PREFIX = "RESUME:";
+    RESUME_TITLE_LIKE_PATTERN = `${RESUME_TITLE_PREFIX} % hit context capacity%`;
+    RESUME_ACTIVE_STATUSES = ["open", "in_progress"];
+    CONFIRMATION_WINDOW_MS = 3 * 60 * 1e3;
+    _pendingCapacityKill = /* @__PURE__ */ new Map();
+    CC_CONTEXT_BAR_RE = /([\u2588\u2591\u2592\u2593]{10})\s+(\d+)%/;
+    CTX_FLOOR_PERCENT = 50;
+  }
+});
+
+// src/lib/tmux-routing.ts
+var tmux_routing_exports = {};
+__export(tmux_routing_exports, {
+  acquireSpawnLock: () => acquireSpawnLock2,
+  employeeSessionName: () => employeeSessionName,
+  ensureEmployee: () => ensureEmployee,
+  extractRootExe: () => extractRootExe,
+  findFreeInstance: () => findFreeInstance,
+  getDispatchedBy: () => getDispatchedBy,
+  getMySession: () => getMySession,
+  getParentExe: () => getParentExe,
+  getSessionState: () => getSessionState,
+  isEmployeeAlive: () => isEmployeeAlive,
+  isExeSession: () => isExeSession,
+  isSessionBusy: () => isSessionBusy,
+  notifyParentExe: () => notifyParentExe,
+  parseParentExe: () => parseParentExe,
+  registerParentExe: () => registerParentExe,
+  releaseSpawnLock: () => releaseSpawnLock2,
+  resolveExeSession: () => resolveExeSession,
+  sendIntercom: () => sendIntercom,
+  spawnEmployee: () => spawnEmployee,
+  verifyPaneAtCapacity: () => verifyPaneAtCapacity
+});
+import { execFileSync as execFileSync2, execSync as execSync7 } from "child_process";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync7, mkdirSync as mkdirSync6, existsSync as existsSync11, appendFileSync } from "fs";
+import path15 from "path";
+import os7 from "os";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { unlinkSync as unlinkSync7 } from "fs";
+function spawnLockPath(sessionName) {
+  return path15.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function acquireSpawnLock2(sessionName) {
+  if (!existsSync11(SPAWN_LOCK_DIR)) {
+    mkdirSync6(SPAWN_LOCK_DIR, { recursive: true });
+  }
+  const lockFile = spawnLockPath(sessionName);
+  if (existsSync11(lockFile)) {
+    try {
+      const lock = JSON.parse(readFileSync11(lockFile, "utf8"));
+      const age = Date.now() - lock.timestamp;
+      if (isProcessAlive(lock.pid) && age < 6e4) {
+        return false;
+      }
+    } catch {
+    }
+  }
+  writeFileSync7(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
+  return true;
+}
+function releaseSpawnLock2(sessionName) {
+  try {
+    unlinkSync7(spawnLockPath(sessionName));
+  } catch {
+  }
+}
+function resolveBehaviorsExporterScript() {
+  try {
+    const thisFile = fileURLToPath2(import.meta.url);
+    const scriptPath = path15.join(
+      path15.dirname(thisFile),
+      "..",
+      "bin",
+      "exe-export-behaviors.js"
+    );
+    return existsSync11(scriptPath) ? scriptPath : null;
+  } catch {
+    return null;
+  }
+}
+function exportBehaviorsSync(agentId, projectName, sessionKey) {
+  const script = resolveBehaviorsExporterScript();
+  if (!script) return null;
+  try {
+    const output = execFileSync2(
+      process.execPath,
+      [script, agentId, projectName, sessionKey],
+      { encoding: "utf-8", timeout: BEHAVIORS_EXPORT_TIMEOUT_MS }
+    ).trim();
+    return output.length > 0 ? output : null;
+  } catch (err) {
+    process.stderr.write(
+      `[tmux-routing] behaviors export failed for ${agentId}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return null;
+  }
+}
+function getMySession() {
+  return getTransport().getMySession();
+}
+function isRootSession(name) {
+  return name.length > 0 && !name.includes("-");
+}
+function employeeSessionName(employee, exeSession, instance) {
+  if (!isRootSession(exeSession)) {
+    const root = extractRootExe(exeSession);
+    if (root) {
+      process.stderr.write(
+        `[tmux-routing] WARN: exeSession="${exeSession}" is not a root session, using "${root}" instead
+`
+      );
+      exeSession = root;
+    } else {
+      throw new Error(
+        `Invalid coordinator session "${exeSession}" \u2014 contains a dash but no recognizable root session. Pass a root session name.`
+      );
+    }
+  }
+  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}-{rootSession} or {agent}{instance}-{rootSession}`
+    );
+  }
+  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) {
+  if (!name) return null;
+  if (!name.includes("-")) return name;
   const parts = name.split("-").filter(Boolean);
   return parts.length > 0 ? parts[parts.length - 1] : null;
 }
+function registerParentExe(sessionKey, parentExe, dispatchedBy) {
+  if (!existsSync11(SESSION_CACHE)) {
+    mkdirSync6(SESSION_CACHE, { recursive: true });
+  }
+  const rootExe = extractRootExe(parentExe) ?? parentExe;
+  const filePath = path15.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
+  writeFileSync7(filePath, JSON.stringify({
+    parentExe: rootExe,
+    dispatchedBy: dispatchedBy || rootExe,
+    registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+  }));
+}
 function getParentExe(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync7(path8.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    const data = JSON.parse(readFileSync11(path15.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
     return data.parentExe || null;
   } catch {
     return null;
   }
 }
+function getDispatchedBy(sessionKey) {
+  try {
+    const data = JSON.parse(readFileSync11(
+      path15.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;
@@ -1476,7 +4516,455 @@ function resolveExeSession() {
   }
   return extractRootExe(mySession) ?? mySession;
 }
-var SPAWN_LOCK_DIR, SESSION_CACHE, INTERCOM_LOG2, DEBOUNCE_FILE, DEBOUNCE_CLEANUP_AGE_MS;
+function isEmployeeAlive(sessionName) {
+  return getTransport().isAlive(sessionName);
+}
+function findFreeInstance(employeeName, exeSession, maxInstances = 10, isAlive = isEmployeeAlive) {
+  const base = employeeSessionName(employeeName, exeSession);
+  if (!isAlive(base) && acquireSpawnLock2(base)) return 0;
+  for (let i = 2; i <= maxInstances; i++) {
+    const candidate = employeeSessionName(employeeName, exeSession, i);
+    if (!isAlive(candidate) && acquireSpawnLock2(candidate)) return i;
+  }
+  return null;
+}
+async function verifyPaneAtCapacity(sessionName) {
+  const transport = getTransport();
+  if (!transport.isAlive(sessionName)) {
+    return { atCapacity: false, reason: `session ${sessionName} is not alive` };
+  }
+  let pane;
+  try {
+    pane = transport.capturePane(sessionName, VERIFY_PANE_LINES);
+  } catch (err) {
+    return {
+      atCapacity: false,
+      reason: `capture-pane failed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const { isAtCapacity: isAtCapacity2 } = await Promise.resolve().then(() => (init_capacity_monitor(), capacity_monitor_exports));
+  if (!isAtCapacity2(pane)) {
+    return {
+      atCapacity: false,
+      reason: `last ${VERIFY_PANE_LINES} lines show normal work, no capacity banner`
+    };
+  }
+  return {
+    atCapacity: true,
+    reason: "capacity banner matched in recent pane output"
+  };
+}
+function readDebounceState() {
+  try {
+    if (!existsSync11(DEBOUNCE_FILE)) return {};
+    return JSON.parse(readFileSync11(DEBOUNCE_FILE, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeDebounceState(state) {
+  try {
+    if (!existsSync11(SESSION_CACHE)) mkdirSync6(SESSION_CACHE, { recursive: true });
+    writeFileSync7(DEBOUNCE_FILE, JSON.stringify(state));
+  } catch {
+  }
+}
+function isDebounced(targetSession) {
+  const state = readDebounceState();
+  const lastSent = state[targetSession] ?? 0;
+  return Date.now() - lastSent < INTERCOM_DEBOUNCE_MS;
+}
+function recordDebounce(targetSession) {
+  const state = readDebounceState();
+  state[targetSession] = Date.now();
+  const cutoff = Date.now() - DEBOUNCE_CLEANUP_AGE_MS;
+  for (const key of Object.keys(state)) {
+    if ((state[key] ?? 0) < cutoff) delete state[key];
+  }
+  writeDebounceState(state);
+}
+function logIntercom(msg) {
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
+`;
+  process.stderr.write(`[intercom] ${msg}
+`);
+  try {
+    appendFileSync(INTERCOM_LOG2, line);
+  } catch {
+  }
+}
+function getSessionState(sessionName) {
+  const transport = getTransport();
+  if (!transport.isAlive(sessionName)) return "offline";
+  try {
+    const pane = transport.capturePane(sessionName, 5);
+    if (!pane.includes("\u276F") && !pane.includes("Claude Code") && !BUSY_PATTERN.test(pane) && !/Running…/.test(pane)) {
+      if (/\$\s*$/.test(pane) || /% $/.test(pane.trimEnd())) {
+        return "no_claude";
+      }
+    }
+    if (/Running…/.test(pane)) return "tool";
+    if (BUSY_PATTERN.test(pane)) return "thinking";
+    return "idle";
+  } catch {
+    return "offline";
+  }
+}
+function isSessionBusy(sessionName) {
+  const state = getSessionState(sessionName);
+  return state === "thinking" || state === "tool";
+}
+function isExeSession(sessionName) {
+  const matchesBaseWithInstance = (baseName) => sessionName === baseName || sessionName.startsWith(baseName) && /^\d+$/.test(sessionName.slice(baseName.length));
+  const coordinatorName = getCoordinatorName();
+  return matchesBaseWithInstance(coordinatorName) || matchesBaseWithInstance("exe");
+}
+function sendIntercom(targetSession) {
+  const transport = getTransport();
+  if (isExeSession(targetSession)) {
+    logIntercom(`SKIP_COORDINATOR \u2192 ${targetSession} (coordinator sessions use prompt-submit hook)`);
+    return "skipped_exe";
+  }
+  if (isDebounced(targetSession)) {
+    logIntercom(`DEBOUNCE \u2192 ${targetSession} (cross-process file debounce)`);
+    return "debounced";
+  }
+  try {
+    const sessions = transport.listSessions();
+    if (!sessions.includes(targetSession)) {
+      logIntercom(`SKIP \u2192 ${targetSession} (session not found)`);
+      return "failed";
+    }
+    const sessionState = getSessionState(targetSession);
+    if (sessionState === "no_claude") {
+      queueIntercom(targetSession, "claude not running in session");
+      recordDebounce(targetSession);
+      logIntercom(`QUEUED \u2192 ${targetSession} (no claude process \u2014 raw shell detected)`);
+      return "queued";
+    }
+    if (sessionState === "thinking" || sessionState === "tool") {
+      queueIntercom(targetSession, "session busy at send time");
+      recordDebounce(targetSession);
+      logIntercom(`QUEUED \u2192 ${targetSession} (session busy, will retry from queue)`);
+      return "queued";
+    }
+    if (transport.isPaneInCopyMode(targetSession)) {
+      logIntercom(`COPY_MODE \u2192 ${targetSession} (exiting copy mode first)`);
+      transport.sendKeys(targetSession, "q");
+    }
+    transport.sendKeys(targetSession, "/exe-intercom");
+    recordDebounce(targetSession);
+    logIntercom(`DELIVERED \u2192 ${targetSession} (fire-and-forget)`);
+    return "delivered";
+  } catch {
+    logIntercom(`FAIL \u2192 ${targetSession}`);
+    return "failed";
+  }
+}
+function notifyParentExe(sessionKey) {
+  const target = getDispatchedBy(sessionKey);
+  if (!target) {
+    process.stderr.write(`[intercom] notifyParentExe: no dispatcher found for key ${sessionKey}
+`);
+    return false;
+  }
+  process.stderr.write(`[intercom] notifyParentExe \u2192 ${target}
+`);
+  const result = sendIntercom(target);
+  if (result === "failed") {
+    const rootExe = resolveExeSession();
+    if (rootExe && rootExe !== target) {
+      process.stderr.write(`[intercom] notifyParentExe: dispatcher ${target} dead, falling back to root coordinator session ${rootExe}
+`);
+      const fallback = sendIntercom(rootExe);
+      return fallback !== "failed";
+    }
+    return false;
+  }
+  return true;
+}
+function ensureEmployee(employeeName, exeSession, projectDir, opts) {
+  if (isCoordinatorName(employeeName)) {
+    return { status: "failed", sessionName: "", error: "The COO is not a dispatchable employee" };
+  }
+  try {
+    assertEmployeeLimitSync();
+  } catch (err) {
+    if (err instanceof PlanLimitError) {
+      return { status: "failed", sessionName: "", error: err.message };
+    }
+  }
+  if (employeeName.includes("-")) {
+    const bare = employeeName.split("-")[0].replace(/\d+$/, "");
+    return {
+      status: "failed",
+      sessionName: "",
+      error: `Error: pass employee name ('${bare}'), not session name ('${employeeName}')`
+    };
+  }
+  if (!isRootSession(exeSession)) {
+    const root = extractRootExe(exeSession);
+    if (root) {
+      process.stderr.write(
+        `[ensureEmployee] WARN: caller passed exeSession="${exeSession}" (not a root session). Auto-correcting to "${root}".
+`
+      );
+      exeSession = root;
+    } else {
+      return {
+        status: "failed",
+        sessionName: "",
+        error: `Invalid coordinator session "${exeSession}" \u2014 contains a dash but no recognizable root session. Pass a root session name.`
+      };
+    }
+  }
+  let effectiveInstance = opts?.instance;
+  if (effectiveInstance === void 0 && opts?.autoInstance) {
+    const free = findFreeInstance(
+      employeeName,
+      exeSession,
+      opts.maxAutoInstances ?? 10
+    );
+    if (free === null) {
+      return {
+        status: "failed",
+        sessionName: employeeSessionName(employeeName, exeSession),
+        error: `All ${opts.maxAutoInstances ?? 10} instances of ${employeeName} are alive \u2014 cap reached`
+      };
+    }
+    effectiveInstance = free === 0 ? void 0 : free;
+  }
+  const sessionName = employeeSessionName(employeeName, exeSession, effectiveInstance);
+  if (isEmployeeAlive(sessionName)) {
+    const result2 = sendIntercom(sessionName);
+    if (result2 === "acknowledged" || result2 === "skipped_exe" || result2 === "debounced" || result2 === "queued") {
+      return { status: "intercom_sent", sessionName };
+    }
+    if (result2 === "delivered") {
+      return { status: "intercom_unprocessed", sessionName };
+    }
+    return { status: "failed", sessionName, error: "intercom delivery failed" };
+  }
+  const spawnOpts = { ...opts, instance: effectiveInstance };
+  const result = spawnEmployee(employeeName, exeSession, projectDir, spawnOpts);
+  if (result.error) {
+    return { status: "failed", sessionName, error: result.error };
+  }
+  return { status: "spawned", sessionName };
+}
+function spawnEmployee(employeeName, exeSession, projectDir, opts) {
+  const transport = getTransport();
+  const sessionName = employeeSessionName(employeeName, exeSession, opts?.instance);
+  const instanceLabel = opts?.instance != null && opts.instance > 0 ? `${employeeName}${opts.instance}` : employeeName;
+  const logDir = path15.join(os7.homedir(), ".exe-os", "session-logs");
+  const logFile = path15.join(logDir, `${instanceLabel}-${Date.now()}.log`);
+  if (!existsSync11(logDir)) {
+    mkdirSync6(logDir, { recursive: true });
+  }
+  transport.kill(sessionName);
+  let cleanupSuffix = "";
+  try {
+    const thisFile = fileURLToPath2(import.meta.url);
+    const cleanupScript = path15.join(path15.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
+    if (existsSync11(cleanupScript)) {
+      cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession}"`;
+    }
+  } catch {
+  }
+  try {
+    const claudeJsonPath = path15.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;
+    writeFileSync7(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+  } catch {
+  }
+  try {
+    const settingsDir = path15.join(os7.homedir(), ".claude", "projects");
+    const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
+    const projSettingsDir = path15.join(settingsDir, normalizedKey);
+    const settingsPath = path15.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;
+      mkdirSync6(projSettingsDir, { recursive: true });
+      writeFileSync7(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 = path15.join(
+      os7.homedir(),
+      ".exe-os",
+      "identity",
+      `${employeeName}.md`
+    );
+    _resetCcAgentSupportCache();
+    const hasAgentFlag = claudeSupportsAgentFlag();
+    if (hasAgentFlag) {
+      identityFlag = ` --agent ${employeeName}`;
+    } else if (existsSync11(identityPath)) {
+      identityFlag = ` --append-system-prompt-file ${identityPath}`;
+      legacyFallbackWarned = true;
+    }
+    const behaviorsFile = exportBehaviorsSync(
+      employeeName,
+      path15.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 = path15.join(os7.homedir(), ".exe-os", "session-cache");
+    mkdirSync6(ctxDir, { recursive: true });
+    const ctxFile = path15.join(ctxDir, `session-context-${sessionName}.md`);
+    const ctxContent = [
+      `## Session Context`,
+      `You are running in tmux session: ${sessionName}.`,
+      `Your parent coordinator session is ${exeSession}.`,
+      `Your employees (if any) use the -${exeSession} suffix.`
+    ].join("\n");
+    writeFileSync7(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}`;
+      }
+    }
+  }
+  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 = path15.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
+    writeFileSync7(dispatchInfo, JSON.stringify({
+      dispatchedBy: mySession,
+      rootExe: exeSession,
+      provider: useBinSymlink ? ccProvider : useExeAgent ? opts.provider : "anthropic",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+  } catch {
+  }
+  let booted = false;
+  for (let i = 0; i < 30; i++) {
+    try {
+      execSync7("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 {
+    }
+  }
+  registerSession({
+    windowName: sessionName,
+    agentId: employeeName,
+    projectDir: spawnCwd,
+    parentExe: exeSession,
+    pid: 0,
+    registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  releaseSpawnLock2(sessionName);
+  return { sessionName };
+}
+var SPAWN_LOCK_DIR, SESSION_CACHE, BEHAVIORS_EXPORT_TIMEOUT_MS, VALID_SESSION_NAME, VERIFY_PANE_LINES, INTERCOM_DEBOUNCE_MS, INTERCOM_LOG2, DEBOUNCE_FILE, DEBOUNCE_CLEANUP_AGE_MS, BUSY_PATTERN;
 var init_tmux_routing = __esm({
   "src/lib/tmux-routing.ts"() {
     "use strict";
@@ -1489,11 +4977,16 @@ var init_tmux_routing = __esm({
     init_intercom_queue();
     init_plan_limits();
     init_employees();
-    SPAWN_LOCK_DIR = path8.join(os5.homedir(), ".exe-os", "spawn-locks");
-    SESSION_CACHE = path8.join(os5.homedir(), ".exe-os", "session-cache");
-    INTERCOM_LOG2 = path8.join(os5.homedir(), ".exe-os", "intercom.log");
-    DEBOUNCE_FILE = path8.join(SESSION_CACHE, "intercom-debounce.json");
+    SPAWN_LOCK_DIR = path15.join(os7.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path15.join(os7.homedir(), ".exe-os", "session-cache");
+    BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
+    VALID_SESSION_NAME = /^[a-z]+\d*-[a-zA-Z0-9_]+$/;
+    VERIFY_PANE_LINES = 200;
+    INTERCOM_DEBOUNCE_MS = 3e4;
+    INTERCOM_LOG2 = path15.join(os7.homedir(), ".exe-os", "intercom.log");
+    DEBOUNCE_FILE = path15.join(SESSION_CACHE, "intercom-debounce.json");
     DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
+    BUSY_PATTERN = /[✻✽✶✳·].*…|Running…/;
   }
 });
 
@@ -1531,15 +5024,15 @@ var init_memory = __esm({
 });
 
 // src/lib/keychain.ts
-import { readFile as readFile3, writeFile as writeFile3, unlink, mkdir as mkdir3, chmod as chmod2 } from "fs/promises";
-import { existsSync as existsSync7 } from "fs";
-import path9 from "path";
-import os6 from "os";
+import { readFile as readFile4, writeFile as writeFile5, unlink, mkdir as mkdir4, chmod as chmod2 } from "fs/promises";
+import { existsSync as existsSync12 } from "fs";
+import path16 from "path";
+import os8 from "os";
 function getKeyDir() {
-  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path9.join(os6.homedir(), ".exe-os");
+  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path16.join(os8.homedir(), ".exe-os");
 }
 function getKeyPath() {
-  return path9.join(getKeyDir(), "master.key");
+  return path16.join(getKeyDir(), "master.key");
 }
 async function tryKeytar() {
   try {
@@ -1560,77 +5053,30 @@ async function getMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (!existsSync7(keyPath)) {
+  if (!existsSync12(keyPath)) {
+    process.stderr.write(
+      `[keychain] Key not found at ${keyPath} (HOME=${os8.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
+`
+    );
     return null;
   }
   try {
-    const content = await readFile3(keyPath, "utf-8");
+    const content = await readFile4(keyPath, "utf-8");
     return Buffer.from(content.trim(), "base64");
-  } catch {
-    return null;
-  }
-}
-var SERVICE, ACCOUNT;
-var init_keychain = __esm({
-  "src/lib/keychain.ts"() {
-    "use strict";
-    SERVICE = "exe-mem";
-    ACCOUNT = "master-key";
-  }
-});
-
-// 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();
+  } catch (err) {
+    process.stderr.write(
+      `[keychain] Key read failed at ${keyPath}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return null;
+  }
+}
+var SERVICE, ACCOUNT;
+var init_keychain = __esm({
+  "src/lib/keychain.ts"() {
+    "use strict";
+    SERVICE = "exe-mem";
+    ACCOUNT = "master-key";
   }
 });
 
@@ -1647,13 +5093,13 @@ __export(shard_manager_exports, {
   listShards: () => listShards,
   shardExists: () => shardExists
 });
-import path10 from "path";
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readdirSync as readdirSync2 } from "fs";
+import path17 from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync7, readdirSync as readdirSync4 } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
   _encryptionKey = encryptionKey;
-  if (!existsSync8(SHARDS_DIR)) {
-    mkdirSync5(SHARDS_DIR, { recursive: true });
+  if (!existsSync13(SHARDS_DIR)) {
+    mkdirSync7(SHARDS_DIR, { recursive: true });
   }
   _shardingEnabled = true;
 }
@@ -1673,7 +5119,7 @@ function getShardClient(projectName) {
   }
   const cached = _shards.get(safeName);
   if (cached) return cached;
-  const dbPath = path10.join(SHARDS_DIR, `${safeName}.db`);
+  const dbPath = path17.join(SHARDS_DIR, `${safeName}.db`);
   const client = createClient2({
     url: `file:${dbPath}`,
     encryptionKey: _encryptionKey
@@ -1683,11 +5129,11 @@ function getShardClient(projectName) {
 }
 function shardExists(projectName) {
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return existsSync8(path10.join(SHARDS_DIR, `${safeName}.db`));
+  return existsSync13(path17.join(SHARDS_DIR, `${safeName}.db`));
 }
 function listShards() {
-  if (!existsSync8(SHARDS_DIR)) return [];
-  return readdirSync2(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
+  if (!existsSync13(SHARDS_DIR)) return [];
+  return readdirSync4(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function ensureShardSchema(client) {
   await client.execute("PRAGMA journal_mode = WAL");
@@ -1872,7 +5318,7 @@ var init_shard_manager = __esm({
   "src/lib/shard-manager.ts"() {
     "use strict";
     init_config();
-    SHARDS_DIR = path10.join(EXE_AI_DIR, "shards");
+    SHARDS_DIR = path17.join(EXE_AI_DIR, "shards");
     _shards = /* @__PURE__ */ new Map();
     _encryptionKey = null;
     _shardingEnabled = false;
@@ -1997,7 +5443,7 @@ __export(global_procedures_exports, {
   loadGlobalProcedures: () => loadGlobalProcedures,
   storeGlobalProcedure: () => storeGlobalProcedure
 });
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 async function loadGlobalProcedures() {
   const client = getClient();
   const result = await client.execute({
@@ -2026,7 +5472,7 @@ ${sections.join("\n\n")}
 `;
 }
 async function storeGlobalProcedure(input2) {
-  const id = randomUUID2();
+  const id = randomUUID3();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const client = getClient();
   await client.execute({
@@ -2077,6 +5523,7 @@ __export(store_exports, {
   vectorToBlob: () => vectorToBlob,
   writeMemory: () => writeMemory
 });
+import { createHash } from "crypto";
 function isBusyError2(err) {
   if (err instanceof Error) {
     const msg = err.message.toLowerCase();
@@ -2150,12 +5597,52 @@ function classifyTier(record) {
   if (["store_memory", "manual"].includes(record.tool_name ?? "") && (record.importance ?? 0) >= 5) return 2;
   return 3;
 }
+function inferFilePaths(record) {
+  if (!["Read", "Write", "Edit"].includes(record.tool_name)) return null;
+  const firstLine = record.raw_text.split("\n")[0] ?? "";
+  const match = firstLine.match(/(\/[\w./-]+\.\w+)/);
+  return match ? JSON.stringify([match[1]]) : null;
+}
+function inferCommitHash(record) {
+  if (record.tool_name !== "Bash") return null;
+  const match = record.raw_text.match(/\b([a-f0-9]{7,40})\b/);
+  return match ? match[1] : null;
+}
+function inferLanguageType(record) {
+  const text = record.raw_text;
+  if (!text || text.length < 10) return null;
+  const trimmed = text.trimStart();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) return "json";
+  if (/\b(SELECT|INSERT|UPDATE|DELETE|CREATE TABLE|ALTER TABLE)\b/i.test(text)) return "sql";
+  if (/\b(function |const |import |export |class |def |async |=>)\b/.test(text)) return "code";
+  if (trimmed.startsWith("#") || trimmed.startsWith("*")) return "prose";
+  return "mixed";
+}
+function inferDomain(record) {
+  const proj = (record.project_name ?? "").toLowerCase();
+  if (proj.includes("marketing") || proj.includes("content")) return "marketing";
+  if (proj.includes("crm") || proj.includes("customer")) return "customer";
+  return null;
+}
 async function writeMemory(record) {
   if (record.vector !== null && record.vector.length !== EMBEDDING_DIM) {
     throw new Error(
       `Expected ${EMBEDDING_DIM}-dim vector, got ${record.vector.length}`
     );
   }
+  const contentHash = createHash("md5").update(record.raw_text).digest("hex");
+  if (_pendingRecords.some((r) => r.content_hash === contentHash && r.agent_id === record.agent_id)) {
+    return;
+  }
+  try {
+    const client = getClient();
+    const existing = await client.execute({
+      sql: "SELECT id FROM memories WHERE content_hash = ? AND agent_id = ? LIMIT 1",
+      args: [contentHash, record.agent_id]
+    });
+    if (existing.rows.length > 0) return;
+  } catch {
+  }
   const dbRow = {
     id: record.id,
     agent_id: record.agent_id,
@@ -2185,7 +5672,23 @@ async function writeMemory(record) {
     supersedes_id: record.supersedes_id ?? null,
     draft: record.draft ? 1 : 0,
     memory_type: record.memory_type ?? "raw",
-    trajectory: record.trajectory ? JSON.stringify(record.trajectory) : null
+    trajectory: record.trajectory ? JSON.stringify(record.trajectory) : null,
+    content_hash: contentHash,
+    intent: record.intent ?? null,
+    outcome: record.outcome ?? null,
+    domain: record.domain ?? inferDomain(record),
+    referenced_entities: record.referenced_entities ?? null,
+    retrieval_count: record.retrieval_count ?? 0,
+    chain_position: record.chain_position ?? null,
+    review_status: record.review_status ?? null,
+    context_window_pct: record.context_window_pct ?? null,
+    file_paths: record.file_paths ?? inferFilePaths(record),
+    commit_hash: record.commit_hash ?? inferCommitHash(record),
+    duration_ms: record.duration_ms ?? null,
+    token_cost: record.token_cost ?? null,
+    audience: record.audience ?? null,
+    language_type: record.language_type ?? inferLanguageType(record),
+    parent_memory_id: record.parent_memory_id ?? null
   };
   _pendingRecords.push(dbRow);
   orgBus.emit({
@@ -2243,80 +5746,85 @@ async function flushBatch() {
       const draft = row.draft ? 1 : 0;
       const memoryType = row.memory_type ?? "raw";
       const trajectory = row.trajectory ?? null;
-      return {
-        sql: hasVector ? `INSERT OR IGNORE INTO memories
-              (id, agent_id, agent_role, session_id, timestamp,
-               tool_name, project_name,
-               has_error, raw_text, vector, version, task_id, importance, status,
-               confidence, last_accessed,
-               workspace_id, document_id, user_id, char_offset, page_number,
-               source_path, source_type, tier, supersedes_id, draft, memory_type, trajectory)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)` : `INSERT OR IGNORE INTO memories
-              (id, agent_id, agent_role, session_id, timestamp,
+      const contentHash = row.content_hash ?? null;
+      const intent = row.intent ?? null;
+      const outcome = row.outcome ?? null;
+      const domain = row.domain ?? null;
+      const referencedEntities = row.referenced_entities ?? null;
+      const retrievalCount = row.retrieval_count ?? 0;
+      const chainPosition = row.chain_position ?? null;
+      const reviewStatus = row.review_status ?? null;
+      const contextWindowPct = row.context_window_pct ?? null;
+      const filePaths = row.file_paths ?? null;
+      const commitHash = row.commit_hash ?? null;
+      const durationMs = row.duration_ms ?? null;
+      const tokenCost = row.token_cost ?? null;
+      const audience = row.audience ?? null;
+      const languageType = row.language_type ?? null;
+      const parentMemoryId = row.parent_memory_id ?? null;
+      const cols = `id, agent_id, agent_role, session_id, timestamp,
                tool_name, project_name,
                has_error, raw_text, vector, version, task_id, importance, status,
                confidence, last_accessed,
                workspace_id, document_id, user_id, char_offset, page_number,
-               source_path, source_type, tier, supersedes_id, draft, memory_type, trajectory)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-        args: hasVector ? [
-          row.id,
-          row.agent_id,
-          row.agent_role,
-          row.session_id,
-          row.timestamp,
-          row.tool_name,
-          row.project_name,
-          row.has_error,
-          row.raw_text,
-          vectorToBlob(row.vector),
-          row.version,
-          taskId,
-          importance,
-          status,
-          confidence,
-          lastAccessed,
-          workspaceId,
-          documentId,
-          userId,
-          charOffset,
-          pageNumber,
-          sourcePath,
-          sourceType,
-          tier,
-          supersedesId,
-          draft,
-          memoryType,
-          trajectory
-        ] : [
-          row.id,
-          row.agent_id,
-          row.agent_role,
-          row.session_id,
-          row.timestamp,
-          row.tool_name,
-          row.project_name,
-          row.has_error,
-          row.raw_text,
-          row.version,
-          taskId,
-          importance,
-          status,
-          confidence,
-          lastAccessed,
-          workspaceId,
-          documentId,
-          userId,
-          charOffset,
-          pageNumber,
-          sourcePath,
-          sourceType,
-          tier,
-          supersedesId,
-          draft,
-          memoryType,
-          trajectory
-        ]
+               source_path, source_type, tier, supersedes_id, draft, memory_type, trajectory, content_hash,
+               intent, outcome, domain, referenced_entities, retrieval_count,
+               chain_position, review_status, context_window_pct, file_paths, commit_hash,
+               duration_ms, token_cost, audience, language_type, parent_memory_id`;
+      const metaArgs = [
+        intent,
+        outcome,
+        domain,
+        referencedEntities,
+        retrievalCount,
+        chainPosition,
+        reviewStatus,
+        contextWindowPct,
+        filePaths,
+        commitHash,
+        durationMs,
+        tokenCost,
+        audience,
+        languageType,
+        parentMemoryId
+      ];
+      const baseArgs = [
+        row.id,
+        row.agent_id,
+        row.agent_role,
+        row.session_id,
+        row.timestamp,
+        row.tool_name,
+        row.project_name,
+        row.has_error,
+        row.raw_text
+      ];
+      const sharedArgs = [
+        row.version,
+        taskId,
+        importance,
+        status,
+        confidence,
+        lastAccessed,
+        workspaceId,
+        documentId,
+        userId,
+        charOffset,
+        pageNumber,
+        sourcePath,
+        sourceType,
+        tier,
+        supersedesId,
+        draft,
+        memoryType,
+        trajectory,
+        contentHash
+      ];
+      return {
+        sql: hasVector ? `INSERT OR IGNORE INTO memories (${cols})
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)` : `INSERT OR IGNORE INTO memories (${cols})
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        args: hasVector ? [...baseArgs, vectorToBlob(row.vector), ...sharedArgs, ...metaArgs] : [...baseArgs, ...sharedArgs, ...metaArgs]
       };
     };
     const globalClient = getClient();
@@ -2566,238 +6074,221 @@ var init_store = __esm({
   }
 });
 
-// src/lib/notifications.ts
-var notifications_exports = {};
-__export(notifications_exports, {
-  cleanupOldNotifications: () => cleanupOldNotifications,
-  formatNotifications: () => formatNotifications,
-  markAsRead: () => markAsRead,
-  markAsReadByTaskFile: () => markAsReadByTaskFile,
-  markDoneTaskNotificationsAsRead: () => markDoneTaskNotificationsAsRead,
-  migrateJsonNotifications: () => migrateJsonNotifications,
-  readUnreadNotifications: () => readUnreadNotifications,
-  writeNotification: () => writeNotification
+// src/lib/git-task-sweep.ts
+var git_task_sweep_exports = {};
+__export(git_task_sweep_exports, {
+  extractKeywords: () => extractKeywords,
+  findBestMatch: () => findBestMatch,
+  getRecentCommits: () => getRecentCommits,
+  matchScore: () => matchScore,
+  sweepTasks: () => sweepTasks
 });
-import crypto from "crypto";
-import path11 from "path";
-import os7 from "os";
-import {
-  readFileSync as readFileSync8,
-  readdirSync as readdirSync3,
-  unlinkSync as unlinkSync3,
-  existsSync as existsSync9,
-  rmdirSync
-} from "fs";
-async function writeNotification(notification) {
-  try {
-    const client = getClient();
-    const id = crypto.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)}
-`);
-  }
+import { execSync as execSync8 } from "child_process";
+function extractKeywords(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length >= 3 && !STOP_WORDS.has(w));
 }
-async function readUnreadNotifications(agentFilter) {
-  try {
-    const client = getClient();
-    const conditions = ["read = 0"];
-    const args = [];
-    if (agentFilter) {
-      conditions.push("agent_id = ?");
-      args.push(agentFilter);
+function matchScore(task, commitMessage, changedFiles) {
+  if (task.id.length >= 8 && commitMessage.includes(task.id)) {
+    return EXACT_UUID_SCORE;
+  }
+  let score = 0;
+  const titleWords = extractKeywords(task.title);
+  const commitWords = new Set(extractKeywords(commitMessage));
+  const overlap = titleWords.filter((w) => commitWords.has(w));
+  if (overlap.length >= MIN_KEYWORD_OVERLAP) {
+    score += TITLE_KEYWORD_SCORE;
+  }
+  if (task.context && changedFiles.length > 0) {
+    const contextLower = task.context.toLowerCase();
+    const hasFileMatch = changedFiles.some(
+      (f) => contextLower.includes(f.toLowerCase())
+    );
+    if (hasFileMatch) {
+      score += FILE_PATH_SCORE;
     }
-    const result = await client.execute({
-      sql: `SELECT id, agent_id, agent_role, event, project, summary, task_file, created_at
-            FROM notifications
-            WHERE ${conditions.join(" AND ")}
-            ORDER BY created_at ASC`,
-      args
-    });
-    return result.rows.map((r) => ({
-      id: String(r.id),
-      agentId: String(r.agent_id),
-      agentRole: String(r.agent_role),
-      event: String(r.event),
-      project: String(r.project),
-      summary: String(r.summary),
-      taskFile: r.task_file ? String(r.task_file) : void 0,
-      timestamp: String(r.created_at),
-      read: false
-    }));
-  } catch {
-    return [];
   }
+  return score;
 }
-async function markAsRead(ids) {
-  if (ids.length === 0) return;
+function getRecentCommits(limit = DEFAULT_COMMIT_LIMIT) {
   try {
-    const client = getClient();
-    const placeholders = ids.map(() => "?").join(", ");
-    await client.execute({
-      sql: `UPDATE notifications SET read = 1 WHERE id IN (${placeholders})`,
-      args: ids
-    });
+    const SEPARATOR = "<<SEP>>";
+    const output = execSync8(
+      `git log --format="%h${SEPARATOR}%s${SEPARATOR}%aI" --name-only -n ${limit} -z`,
+      { encoding: "utf8", timeout: 1e4 }
+    );
+    const entries = output.split("\0").filter(Boolean);
+    const commits = [];
+    let current = null;
+    for (const entry of entries) {
+      if (entry.includes(SEPARATOR)) {
+        const lines = entry.split("\n");
+        const headerLine = lines[0];
+        const parts = headerLine.split(SEPARATOR);
+        if (parts.length >= 3) {
+          if (current) commits.push(current);
+          current = {
+            hash: parts[0],
+            message: parts[1],
+            files: lines.slice(1).filter(Boolean),
+            date: new Date(parts[2])
+          };
+        }
+      } else if (current) {
+        const files = entry.split("\n").filter(Boolean);
+        current.files.push(...files);
+      }
+    }
+    if (current) commits.push(current);
+    return commits;
   } catch {
+    return [];
   }
 }
-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]
-    });
-  } catch {
-  }
+function isStale(updatedAt, staleMinutes) {
+  const updated = new Date(updatedAt).getTime();
+  const threshold = Date.now() - staleMinutes * 6e4;
+  return updated < threshold;
 }
-async function cleanupOldNotifications(daysOld = CLEANUP_DAYS) {
-  try {
-    const client = getClient();
-    const cutoff = new Date(
-      Date.now() - daysOld * 24 * 60 * 60 * 1e3
-    ).toISOString();
-    const result = await client.execute({
-      sql: "DELETE FROM notifications WHERE created_at < ?",
-      args: [cutoff]
-    });
-    return result.rowsAffected;
-  } catch {
-    return 0;
+function findBestMatch(task, commits) {
+  let best = null;
+  for (const commit of commits) {
+    const score = matchScore(task, commit.message, commit.files);
+    if (score >= AUTO_ESCALATE_THRESHOLD && (!best || score > best.score)) {
+      best = { commit, score };
+    }
   }
+  return best;
 }
-async function markDoneTaskNotificationsAsRead() {
+async function sweepTasks(projectName, options = {}) {
+  const commitLimit = options.commitLimit ?? DEFAULT_COMMIT_LIMIT;
+  const staleMinutes = options.staleMinutes ?? DEFAULT_STALE_MINUTES;
+  const dryRun = options.dryRun ?? false;
+  const result = { escalated: [], unchanged: 0, errors: [] };
+  const commits = getRecentCommits(commitLimit);
+  if (commits.length === 0) {
+    result.errors.push("No git commits found (not a git repo or empty history)");
+    return result;
+  }
+  let tasks;
   try {
-    const client = getClient();
-    const result = await client.execute({
-      sql: `UPDATE notifications SET read = 1
-            WHERE read = 0
-              AND task_file IS NOT NULL
-              AND task_file IN (
-                SELECT task_file FROM tasks WHERE status = 'done'
-              )`,
-      args: []
+    const { initStore: initStore2 } = await Promise.resolve().then(() => (init_store(), store_exports));
+    await initStore2();
+    const { getClient: getClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
+    const client = getClient2();
+    const conditions = ["status = 'in_progress'"];
+    const args = [];
+    if (projectName) {
+      conditions.push("project_name = ?");
+      args.push(projectName);
+    }
+    const swScope = sessionScopeFilter();
+    if (swScope.sql) {
+      conditions.push("(session_scope IS NULL OR session_scope = ?)");
+      args.push(...swScope.args);
+    }
+    const queryResult = await client.execute({
+      sql: `SELECT id, title, assigned_to, project_name, status, updated_at, context
+            FROM tasks WHERE ${conditions.join(" AND ")}
+            ORDER BY updated_at ASC`,
+      args
     });
-    return result.rowsAffected;
-  } catch {
-    return 0;
+    tasks = queryResult.rows.map((r) => ({
+      id: String(r.id),
+      title: String(r.title),
+      assignedTo: String(r.assigned_to),
+      projectName: String(r.project_name),
+      status: String(r.status),
+      updatedAt: String(r.updated_at),
+      context: r.context ? String(r.context) : void 0
+    }));
+  } catch (err) {
+    result.errors.push(`DB query failed: ${err instanceof Error ? err.message : String(err)}`);
+    return result;
   }
-}
-function formatNotifications(notifications) {
-  if (notifications.length === 0) return "";
-  const grouped = /* @__PURE__ */ new Map();
-  for (const n of notifications) {
-    const key = `${n.agentId}|${n.agentRole}`;
-    if (!grouped.has(key)) grouped.set(key, []);
-    grouped.get(key).push(n);
+  if (tasks.length === 0) {
+    return result;
   }
-  const lines = [];
-  lines.push(`## Notifications (${notifications.length} unread)
-`);
-  for (const [key, items] of grouped) {
-    const [agentId, agentRole] = key.split("|");
-    lines.push(`**${agentId}** (${agentRole}):`);
-    for (const item of items) {
-      const ago = formatTimeAgo(item.timestamp);
-      const icon = eventIcon(item.event);
-      lines.push(`- ${icon} ${item.summary} (${item.project}) \u2014 ${ago}`);
+  for (const task of tasks) {
+    if (!isStale(task.updatedAt, staleMinutes)) {
+      result.unchanged++;
+      continue;
     }
-    lines.push("");
-  }
-  return lines.join("\n");
-}
-async function migrateJsonNotifications() {
-  const base = process.env.EXE_OS_DIR || process.env.EXE_MEM_DIR || path11.join(os7.homedir(), ".exe-os");
-  const notifDir = path11.join(base, "notifications");
-  if (!existsSync9(notifDir)) return 0;
-  let migrated = 0;
-  try {
-    const files = readdirSync3(notifDir).filter((f) => f.endsWith(".json"));
-    if (files.length === 0) return 0;
-    const client = getClient();
-    for (const file of files) {
+    const match = findBestMatch(task, commits);
+    if (!match) {
+      result.unchanged++;
+      continue;
+    }
+    if (!dryRun) {
       try {
-        const filePath = path11.join(notifDir, file);
-        const data = JSON.parse(readFileSync8(filePath, "utf8"));
-        await client.execute({
-          sql: `INSERT OR IGNORE INTO notifications (id, agent_id, agent_role, event, project, summary, task_file, read, created_at)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-          args: [
-            crypto.randomUUID(),
-            data.agentId ?? "unknown",
-            data.agentRole ?? "unknown",
-            data.event ?? "session_summary",
-            data.project ?? "unknown",
-            data.summary ?? "",
-            data.taskFile ?? null,
-            data.read ? 1 : 0,
-            data.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
-          ]
+        const { updateTaskStatus: updateTaskStatus2 } = await Promise.resolve().then(() => (init_tasks_crud(), tasks_crud_exports));
+        await updateTaskStatus2({
+          taskId: task.id,
+          status: "needs_review",
+          result: `Auto-escalated by git-sweep: matching commit ${match.commit.hash} found (score: ${match.score.toFixed(2)})`
         });
-        unlinkSync3(filePath);
-        migrated++;
-      } catch {
-      }
-    }
-    try {
-      const remaining = readdirSync3(notifDir);
-      if (remaining.length === 0) {
-        rmdirSync(notifDir);
+      } catch (err) {
+        result.errors.push(
+          `Failed to escalate task ${task.id}: ${err instanceof Error ? err.message : String(err)}`
+        );
+        continue;
       }
-    } catch {
     }
-  } catch {
-  }
-  return migrated;
-}
-function eventIcon(event) {
-  switch (event) {
-    case "task_complete":
-      return "Completed:";
-    case "task_needs_fix":
-      return "Needs fix:";
-    case "session_summary":
-      return "Session:";
-    case "error_spike":
-      return "Errors:";
-    case "orphan_task":
-      return "Orphan:";
-    case "subtasks_complete":
-      return "Subtasks done:";
-    case "capacity_relaunch":
-      return "Relaunched:";
+    result.escalated.push({
+      taskId: task.id,
+      title: task.title,
+      matchedCommit: match.commit.hash,
+      score: match.score
+    });
+    process.stderr.write(
+      `[git-sweep] ${dryRun ? "WOULD escalate" : "Escalated"} task ${task.id} \u2192 commit ${match.commit.hash} (score: ${match.score.toFixed(2)})
+`
+    );
   }
+  return result;
 }
-function formatTimeAgo(timestamp) {
-  const diffMs = Date.now() - new Date(timestamp).getTime();
-  const mins = Math.floor(diffMs / 6e4);
-  if (mins < 1) return "just now";
-  if (mins < 60) return `${mins}m ago`;
-  const hours = Math.floor(mins / 60);
-  if (hours < 24) return `${hours}h ago`;
-  const days = Math.floor(hours / 24);
-  return `${days}d ago`;
-}
-var CLEANUP_DAYS;
-var init_notifications = __esm({
-  "src/lib/notifications.ts"() {
+var DEFAULT_COMMIT_LIMIT, DEFAULT_STALE_MINUTES, AUTO_ESCALATE_THRESHOLD, EXACT_UUID_SCORE, TITLE_KEYWORD_SCORE, FILE_PATH_SCORE, MIN_KEYWORD_OVERLAP, STOP_WORDS;
+var init_git_task_sweep = __esm({
+  "src/lib/git-task-sweep.ts"() {
     "use strict";
-    init_database();
-    CLEANUP_DAYS = 7;
+    init_task_scope();
+    DEFAULT_COMMIT_LIMIT = 50;
+    DEFAULT_STALE_MINUTES = 10;
+    AUTO_ESCALATE_THRESHOLD = 0.6;
+    EXACT_UUID_SCORE = 1;
+    TITLE_KEYWORD_SCORE = 0.5;
+    FILE_PATH_SCORE = 0.3;
+    MIN_KEYWORD_OVERLAP = 3;
+    STOP_WORDS = /* @__PURE__ */ new Set([
+      "a",
+      "an",
+      "the",
+      "and",
+      "or",
+      "but",
+      "in",
+      "on",
+      "at",
+      "to",
+      "for",
+      "of",
+      "with",
+      "by",
+      "from",
+      "is",
+      "it",
+      "as",
+      "be",
+      "was",
+      "are",
+      "this",
+      "that",
+      "not",
+      "no",
+      "if",
+      "so",
+      "do",
+      "up"
+    ]);
   }
 });
 
@@ -2938,7 +6429,7 @@ process.stdin.on("end", async () => {
         await initStore2();
         const { writeMemory: writeMemory2, flushBatch: flushBatch2 } = await Promise.resolve().then(() => (init_store(), store_exports));
         const { getClient: getClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
-        const { randomUUID: randomUUID3 } = await import("crypto");
+        const { randomUUID: randomUUID4 } = await import("crypto");
         const client = getClient2();
         const seScope = sessionScopeFilter();
         const orphanResult = await client.execute({
@@ -2948,7 +6439,7 @@ process.stdin.on("end", async () => {
         const orphanInfo = orphanResult.rows.length > 0 ? `
 Orphaned tasks at session end: ${orphanResult.rows.map((r) => `"${String(r.title)}" (${String(r.status)})`).join(", ")}` : "";
         await writeMemory2({
-          id: randomUUID3(),
+          id: randomUUID4(),
           agent_id: agent.agentId,
           agent_role: agent.agentRole,
           session_id: data.session_id,
@@ -2968,15 +6459,57 @@ Orphaned tasks at session end: ${orphanResult.rows.map((r) => `"${String(r.title
               `[session-end] WARNING: ${agent.agentId} ended with ${inProgress.length} in_progress task(s): ${titles}
 `
             );
+            let commits = [];
+            try {
+              const { getRecentCommits: getRecentCommits2 } = await Promise.resolve().then(() => (init_git_task_sweep(), git_task_sweep_exports));
+              commits = getRecentCommits2(30);
+            } catch {
+            }
+            const autoClosed = [];
+            const leftInProgress = [];
             for (const row of inProgress) {
+              const title = String(row.title);
               try {
-                await client.execute({
-                  sql: "UPDATE tasks SET status = 'blocked', updated_at = ? WHERE title = ? AND assigned_to = ? AND status = 'in_progress'",
-                  args: [(/* @__PURE__ */ new Date()).toISOString(), String(row.title), agent.agentId]
-                });
+                if (commits.length > 0) {
+                  const { findBestMatch: findBestMatch2 } = await Promise.resolve().then(() => (init_git_task_sweep(), git_task_sweep_exports));
+                  let context;
+                  try {
+                    const ctxResult = await client.execute({
+                      sql: "SELECT id, context FROM tasks WHERE title = ? AND assigned_to = ? AND status = 'in_progress' LIMIT 1",
+                      args: [title, agent.agentId]
+                    });
+                    if (ctxResult.rows.length > 0) {
+                      context = ctxResult.rows[0].context ? String(ctxResult.rows[0].context) : void 0;
+                    }
+                  } catch {
+                  }
+                  const taskForMatch = { id: "", title, context };
+                  const match = findBestMatch2(taskForMatch, commits);
+                  if (match) {
+                    await client.execute({
+                      sql: "UPDATE tasks SET status = 'done', result = ?, updated_at = ? WHERE title = ? AND assigned_to = ? AND status = 'in_progress'",
+                      args: [
+                        `Auto-closed: session ended but matching commit ${match.commit.hash} found (score: ${match.score.toFixed(2)}). Message: "${match.commit.message}"`,
+                        (/* @__PURE__ */ new Date()).toISOString(),
+                        title,
+                        agent.agentId
+                      ]
+                    });
+                    autoClosed.push(`"${title}" \u2192 commit ${match.commit.hash}`);
+                    continue;
+                  }
+                }
+                leftInProgress.push(`"${title}"`);
               } catch {
               }
             }
+            const parts = [];
+            if (autoClosed.length > 0) {
+              parts.push(`Auto-closed (work committed): ${autoClosed.join(", ")}`);
+            }
+            if (leftInProgress.length > 0) {
+              parts.push(`Left in_progress (no matching commits, needs triage): ${leftInProgress.join(", ")}`);
+            }
             try {
               const { writeNotification: writeNotification2 } = await Promise.resolve().then(() => (init_notifications(), notifications_exports));
               await writeNotification2({
@@ -2984,10 +6517,18 @@ Orphaned tasks at session end: ${orphanResult.rows.map((r) => `"${String(r.title
                 agentRole: agent.agentRole,
                 event: "orphan_task",
                 project: process.env.EXE_PROJECT_NAME ?? "unknown",
-                summary: `${agent.agentId} session ended with ${inProgress.length} in_progress task(s): ${titles}. Tasks marked blocked.`
+                summary: `${agent.agentId} session ended with ${inProgress.length} in_progress task(s). ${parts.join(". ")}`
               });
             } catch {
             }
+            if (autoClosed.length > 0) {
+              process.stderr.write(`[session-end] Auto-closed ${autoClosed.length} task(s) with matching commits
+`);
+            }
+            if (leftInProgress.length > 0) {
+              process.stderr.write(`[session-end] Left ${leftInProgress.length} task(s) as in_progress for coordinator triage
+`);
+            }
           }
         }
       } catch {