@askexenow/exe-os 0.8.41 → 0.8.43

package/dist/bin/exe-session-cleanup.js

@@ -322,6 +322,13 @@ async function ensureSchema() {
     });
   } catch {
   }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN session_scope TEXT`,
+      args: []
+    });
+  } catch {
+  }
   try {
     await client.execute({
       sql: `ALTER TABLE memories ADD COLUMN task_id TEXT`,
@@ -768,6 +775,18 @@ async function ensureSchema() {
     CREATE INDEX IF NOT EXISTS idx_session_kills_agent
       ON session_kills(agent_id);
   `);
+  await client.execute(`
+    CREATE TABLE IF NOT EXISTS global_procedures (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      priority TEXT NOT NULL DEFAULT 'p0',
+      domain TEXT,
+      active INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    )
+  `);
   await client.executeMultiple(`
     CREATE TABLE IF NOT EXISTS conversations (
       id              TEXT PRIMARY KEY,
@@ -1165,6 +1184,61 @@ var init_config = __esm({
   }
 });
 
+// src/lib/state-bus.ts
+var StateBus, orgBus;
+var init_state_bus = __esm({
+  "src/lib/state-bus.ts"() {
+    "use strict";
+    StateBus = class {
+      handlers = /* @__PURE__ */ new Map();
+      globalHandlers = /* @__PURE__ */ new Set();
+      /** Emit an event to all subscribers */
+      emit(event) {
+        const typeHandlers = this.handlers.get(event.type);
+        if (typeHandlers) {
+          for (const handler of typeHandlers) {
+            try {
+              handler(event);
+            } catch {
+            }
+          }
+        }
+        for (const handler of this.globalHandlers) {
+          try {
+            handler(event);
+          } catch {
+          }
+        }
+      }
+      /** Subscribe to a specific event type */
+      on(type, handler) {
+        if (!this.handlers.has(type)) {
+          this.handlers.set(type, /* @__PURE__ */ new Set());
+        }
+        this.handlers.get(type).add(handler);
+      }
+      /** Subscribe to ALL events */
+      onAny(handler) {
+        this.globalHandlers.add(handler);
+      }
+      /** Unsubscribe from a specific event type */
+      off(type, handler) {
+        this.handlers.get(type)?.delete(handler);
+      }
+      /** Unsubscribe from ALL events */
+      offAny(handler) {
+        this.globalHandlers.delete(handler);
+      }
+      /** Remove all listeners */
+      clear() {
+        this.handlers.clear();
+        this.globalHandlers.clear();
+      }
+    };
+    orgBus = new StateBus();
+  }
+});
+
 // src/lib/shard-manager.ts
 var shard_manager_exports = {};
 __export(shard_manager_exports, {
@@ -1406,6 +1480,71 @@ var init_shard_manager = __esm({
   }
 });
 
+// src/lib/global-procedures.ts
+var global_procedures_exports = {};
+__export(global_procedures_exports, {
+  deactivateGlobalProcedure: () => deactivateGlobalProcedure,
+  getGlobalProceduresBlock: () => getGlobalProceduresBlock,
+  loadGlobalProcedures: () => loadGlobalProcedures,
+  storeGlobalProcedure: () => storeGlobalProcedure
+});
+import { randomUUID } from "crypto";
+async function loadGlobalProcedures() {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT * FROM global_procedures WHERE active = 1 ORDER BY priority ASC, created_at ASC",
+    args: []
+  });
+  const procedures = result.rows;
+  if (procedures.length > 0) {
+    _cache = procedures.map((p) => `### ${p.title}
+${p.content}`).join("\n\n");
+  } else {
+    _cache = "";
+  }
+  _cacheLoaded = true;
+  return procedures;
+}
+function getGlobalProceduresBlock() {
+  if (!_cacheLoaded) return "";
+  if (!_cache) return "";
+  return `## Organization-Wide Procedures (MANDATORY \u2014 supersedes all other rules)
+
+${_cache}
+`;
+}
+async function storeGlobalProcedure(input) {
+  const id = randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const client = getClient();
+  await client.execute({
+    sql: `INSERT INTO global_procedures (id, title, content, priority, domain, active, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, 1, ?, ?)`,
+    args: [id, input.title, input.content, input.priority ?? "p0", input.domain ?? null, now, now]
+  });
+  await loadGlobalProcedures();
+  return id;
+}
+async function deactivateGlobalProcedure(id) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const client = getClient();
+  const result = await client.execute({
+    sql: "UPDATE global_procedures SET active = 0, updated_at = ? WHERE id = ?",
+    args: [now, id]
+  });
+  await loadGlobalProcedures();
+  return result.rowsAffected > 0;
+}
+var _cache, _cacheLoaded;
+var init_global_procedures = __esm({
+  "src/lib/global-procedures.ts"() {
+    "use strict";
+    init_database();
+    _cache = "";
+    _cacheLoaded = false;
+  }
+});
+
 // src/lib/project-name.ts
 import { execSync } from "child_process";
 import path4 from "path";
@@ -1451,7 +1590,7 @@ var init_project_name = __esm({
 // src/lib/exe-daemon-client.ts
 import net from "net";
 import { spawn } from "child_process";
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import { existsSync as existsSync4, unlinkSync, readFileSync as readFileSync2, openSync, closeSync, statSync } from "fs";
 import path5 from "path";
 import { fileURLToPath } from "url";
@@ -1643,7 +1782,7 @@ function sendRequest(texts, priority) {
       resolve({ error: "Not connected" });
       return;
     }
-    const id = randomUUID();
+    const id = randomUUID2();
     const timer = setTimeout(() => {
       _pending.delete(id);
       resolve({ error: "Request timeout" });
@@ -1661,7 +1800,7 @@ function sendRequest(texts, priority) {
 async function pingDaemon() {
   if (!_socket || !_connected) return null;
   return new Promise((resolve) => {
-    const id = randomUUID();
+    const id = randomUUID2();
     const timer = setTimeout(() => {
       _pending.delete(id);
       resolve(null);
@@ -1826,10 +1965,10 @@ async function disposeEmbedder() {
 async function embedDirect(text) {
   const llamaCpp = await import("node-llama-cpp");
   const { MODELS_DIR: MODELS_DIR2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-  const { existsSync: existsSync14 } = await import("fs");
-  const path16 = await import("path");
-  const modelPath = path16.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
-  if (!existsSync14(modelPath)) {
+  const { existsSync: existsSync15 } = await import("fs");
+  const path18 = await import("path");
+  const modelPath = path18.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
+  if (!existsSync15(modelPath)) {
     throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
   }
   const llama = await llamaCpp.getLlama();
@@ -1873,15 +2012,30 @@ async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
     return [];
   }
 }
+function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
+  if (!existsSync5(employeesPath)) return [];
+  try {
+    return JSON.parse(readFileSync3(employeesPath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
 function getEmployee(employees, name) {
   return employees.find((e) => e.name.toLowerCase() === name.toLowerCase());
 }
-var EMPLOYEES_PATH;
+function isMultiInstance(agentName2, employees) {
+  const roster = employees ?? loadEmployeesSync();
+  const emp = getEmployee(roster, agentName2);
+  if (!emp) return false;
+  return MULTI_INSTANCE_ROLES.has(emp.role.toLowerCase());
+}
+var EMPLOYEES_PATH, MULTI_INSTANCE_ROLES;
 var init_employees = __esm({
   "src/lib/employees.ts"() {
     "use strict";
     init_config();
     EMPLOYEES_PATH = path6.join(EXE_AI_DIR, "exe-employees.json");
+    MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["principal engineer", "content production specialist", "staff code reviewer"]);
   }
 });
 
@@ -1920,6 +2074,16 @@ async function writeNotification(notification) {
 `);
   }
 }
+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 {
+  }
+}
 var init_notifications = __esm({
   "src/lib/notifications.ts"() {
     "use strict";
@@ -1927,254 +2091,66 @@ var init_notifications = __esm({
   }
 });
 
-// src/lib/tasks-crud.ts
-import crypto3 from "crypto";
+// src/lib/session-registry.ts
+import { readFileSync as readFileSync5, writeFileSync, mkdirSync as mkdirSync2, existsSync as existsSync7 } from "fs";
 import path8 from "path";
-import { execSync as execSync3 } from "child_process";
-import { mkdir as mkdir4, writeFile as writeFile4, appendFile } from "fs/promises";
-import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
-function extractParentFromContext(contextBody) {
-  if (!contextBody) return null;
-  const match = contextBody.match(
-    /Parent task:\s*([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i
-  );
-  return match ? match[1].toLowerCase() : null;
-}
-function slugify(title) {
-  return title.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
-}
-async function resolveTask(client, identifier) {
-  let result = await client.execute({
-    sql: "SELECT * FROM tasks WHERE id = ?",
-    args: [identifier]
-  });
-  if (result.rows.length === 1) return result.rows[0];
-  result = await client.execute({
-    sql: "SELECT * FROM tasks WHERE task_file LIKE ?",
-    args: [`%${identifier}%`]
-  });
-  if (result.rows.length === 1) return result.rows[0];
-  if (result.rows.length > 1) {
-    const exact = result.rows.filter(
-      (r) => String(r.task_file).endsWith(`/${identifier}.md`)
-    );
-    if (exact.length === 1) return exact[0];
-    const candidates = exact.length > 1 ? exact : result.rows;
-    const active = candidates.filter(
-      (r) => !["done", "cancelled"].includes(String(r.status))
-    );
-    if (active.length === 1) return active[0];
-    const matches = (active.length > 1 ? active : candidates).map((r) => `${String(r.task_file)} (${String(r.status)}, ${String(r.id)})`).join(", ");
-    throw new Error(
-      `Multiple tasks match "${identifier}": ${matches}. Use a UUID to disambiguate.`
-    );
-  }
-  result = await client.execute({
-    sql: "SELECT * FROM tasks WHERE title LIKE ?",
-    args: [`%${identifier}%`]
-  });
-  if (result.rows.length === 1) return result.rows[0];
-  if (result.rows.length > 1) {
-    const active = result.rows.filter(
-      (r) => !["done", "cancelled"].includes(String(r.status))
-    );
-    if (active.length === 1) return active[0];
-    const matches = (active.length > 1 ? active : result.rows).map((r) => `"${String(r.title)}" (${String(r.status)}, ${String(r.id)})`).join(", ");
-    throw new Error(
-      `Multiple tasks match "${identifier}": ${matches}. Use a UUID to disambiguate.`
-    );
+import os4 from "os";
+function registerSession(entry) {
+  const dir = path8.dirname(REGISTRY_PATH);
+  if (!existsSync7(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);
   }
-  throw new Error(`Task not found: ${identifier}`);
+  writeFileSync(REGISTRY_PATH, JSON.stringify(sessions, null, 2));
 }
-async function createTaskCore(input) {
-  const client = getClient();
-  const id = crypto3.randomUUID();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const slug = slugify(input.title);
-  const taskFile = input.taskFile ?? `exe/${input.assignedTo}/${slug}.md`;
-  let blockedById = null;
-  const initialStatus = input.blockedBy ? "blocked" : "open";
-  if (input.blockedBy) {
-    const blocker = await resolveTask(client, input.blockedBy);
-    blockedById = String(blocker.id);
+function listSessions() {
+  try {
+    const raw = readFileSync5(REGISTRY_PATH, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return [];
   }
-  let parentTaskId = null;
-  let parentRef = input.parentTaskId;
-  if (!parentRef) {
-    const extracted = extractParentFromContext(input.context);
-    if (extracted) {
-      parentRef = extracted;
-      process.stderr.write(
-        "[create_task] auto-populated parent_task_id from context body \u2014 dispatchers should pass parent_task_id explicitly\n"
-      );
-    }
+}
+var REGISTRY_PATH;
+var init_session_registry = __esm({
+  "src/lib/session-registry.ts"() {
+    "use strict";
+    REGISTRY_PATH = path8.join(os4.homedir(), ".exe-os", "session-registry.json");
   }
-  if (parentRef) {
+});
+
+// src/lib/session-key.ts
+import { execSync as execSync3 } from "child_process";
+function getSessionKey() {
+  if (_cached2) return _cached2;
+  let pid = process.ppid;
+  for (let i = 0; i < 10; i++) {
     try {
-      const parent = await resolveTask(client, parentRef);
-      parentTaskId = String(parent.id);
-    } catch (err) {
-      if (!input.parentTaskId) {
-        throw new Error(
-          `create_task: parent reference "${parentRef}" in context body does not resolve to an existing task`
-        );
+      const info = execSync3(`ps -p ${pid} -o ppid=,comm=`, {
+        encoding: "utf8",
+        timeout: 2e3
+      }).trim();
+      const match = info.match(/^\s*(\d+)\s+(.+)$/);
+      if (!match) break;
+      const [, ppid, cmd] = match;
+      if (cmd === "claude" || cmd.endsWith("/claude")) {
+        _cached2 = String(pid);
+        return _cached2;
       }
-      throw err;
-    }
-  }
-  let warning;
-  const dupCheck = await client.execute({
-    sql: "SELECT id FROM tasks WHERE title = ? AND assigned_to = ? AND status IN ('open', 'in_progress', 'blocked')",
-    args: [input.title, input.assignedTo]
-  });
-  if (dupCheck.rows.length > 0) {
-    warning = `similar active task already exists (${String(dupCheck.rows[0].id)}). Created new task anyway.`;
-  }
-  if (input.baseDir) {
-    try {
-      await mkdir4(path8.join(input.baseDir, "exe", "output"), { recursive: true });
-      await mkdir4(path8.join(input.baseDir, "exe", "research"), { recursive: true });
-      await ensureArchitectureDoc(input.baseDir, input.projectName);
-      await ensureGitignoreExe(input.baseDir);
+      pid = parseInt(ppid, 10);
+      if (pid <= 1) break;
     } catch {
+      break;
     }
   }
-  const complexity = input.complexity ?? "standard";
-  await client.execute({
-    sql: `INSERT INTO tasks (id, title, assigned_to, assigned_by, project_name, priority, status, task_file, blocked_by, parent_task_id, reviewer, context, complexity, budget_tokens, budget_fallback_model, tokens_used, tokens_warned_at, created_at, updated_at)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    args: [
-      id,
-      input.title,
-      input.assignedTo,
-      input.assignedBy,
-      input.projectName,
-      input.priority,
-      initialStatus,
-      taskFile,
-      blockedById,
-      parentTaskId,
-      input.reviewer ?? null,
-      input.context,
-      complexity,
-      input.budgetTokens ?? null,
-      input.budgetFallbackModel ?? null,
-      0,
-      null,
-      now,
-      now
-    ]
-  });
-  return {
-    id,
-    title: input.title,
-    assignedTo: input.assignedTo,
-    assignedBy: input.assignedBy,
-    projectName: input.projectName,
-    priority: input.priority,
-    status: initialStatus,
-    taskFile,
-    createdAt: now,
-    updatedAt: now,
-    warning,
-    budgetTokens: input.budgetTokens ?? null,
-    budgetFallbackModel: input.budgetFallbackModel ?? null,
-    tokensUsed: 0,
-    tokensWarnedAt: null
-  };
-}
-async function ensureArchitectureDoc(baseDir, projectName) {
-  const archPath = path8.join(baseDir, "exe", "ARCHITECTURE.md");
-  try {
-    if (existsSync7(archPath)) return;
-    const template = [
-      `# ${projectName} \u2014 System Architecture`,
-      "",
-      "> Employees: read this before every task. Update it when you change system structure.",
-      `> Last updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`,
-      "",
-      "## Overview",
-      "",
-      "<!-- Describe what this system does, its main components, and how they connect. -->",
-      "",
-      "## Key Components",
-      "",
-      "<!-- List the major modules, services, or subsystems. -->",
-      "",
-      "## Data Flow",
-      "",
-      "<!-- How does data move through the system? What writes where? -->",
-      "",
-      "## Invariants",
-      "",
-      "<!-- Rules that must never be violated. What breaks if these are wrong? -->",
-      "",
-      "## Dependencies",
-      "",
-      "<!-- What depends on what? If I change X, what else is affected? -->",
-      ""
-    ].join("\n");
-    await writeFile4(archPath, template, "utf-8");
-  } catch {
-  }
-}
-async function ensureGitignoreExe(baseDir) {
-  const gitignorePath = path8.join(baseDir, ".gitignore");
-  try {
-    if (existsSync7(gitignorePath)) {
-      const content = readFileSync5(gitignorePath, "utf-8");
-      if (/^\/?exe\/?$/m.test(content)) return;
-      await appendFile(gitignorePath, "\n# Employee task assignments (private)\n/exe/\n");
-    } else {
-      await writeFile4(gitignorePath, "# Employee task assignments (private)\n/exe/\n", "utf-8");
-    }
-  } catch {
-  }
-}
-var init_tasks_crud = __esm({
-  "src/lib/tasks-crud.ts"() {
-    "use strict";
-    init_database();
-  }
-});
-
-// src/lib/session-registry.ts
-import path9 from "path";
-import os4 from "os";
-var REGISTRY_PATH;
-var init_session_registry = __esm({
-  "src/lib/session-registry.ts"() {
-    "use strict";
-    REGISTRY_PATH = path9.join(os4.homedir(), ".exe-os", "session-registry.json");
-  }
-});
-
-// src/lib/session-key.ts
-import { execSync as execSync4 } from "child_process";
-function getSessionKey() {
-  if (_cached2) return _cached2;
-  let pid = process.ppid;
-  for (let i = 0; i < 10; i++) {
-    try {
-      const info = execSync4(`ps -p ${pid} -o ppid=,comm=`, {
-        encoding: "utf8",
-        timeout: 2e3
-      }).trim();
-      const match = info.match(/^\s*(\d+)\s+(.+)$/);
-      if (!match) break;
-      const [, ppid, cmd] = match;
-      if (cmd === "claude" || cmd.endsWith("/claude")) {
-        _cached2 = String(pid);
-        return _cached2;
-      }
-      pid = parseInt(ppid, 10);
-      if (pid <= 1) break;
-    } catch {
-      break;
-    }
-  }
-  _cached2 = process.env.CLAUDE_CODE_SSE_PORT ?? String(process.ppid);
-  return _cached2;
+  _cached2 = process.env.CLAUDE_CODE_SSE_PORT ?? String(process.ppid);
+  return _cached2;
 }
 var _cached2;
 var init_session_key = __esm({
@@ -2292,14 +2268,41 @@ var init_transport = __esm({
 });
 
 // src/lib/cc-agent-support.ts
-import { execSync as execSync5 } from "child_process";
+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"() {
@@ -2314,19 +2317,36 @@ 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 readFileSync6, writeFileSync, renameSync as renameSync2, existsSync as existsSync8, mkdirSync as mkdirSync2 } from "fs";
-import path10 from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync2, renameSync as renameSync2, existsSync as existsSync8, mkdirSync as mkdirSync3 } from "fs";
+import path9 from "path";
 import os5 from "os";
 function ensureDir() {
-  const dir = path10.dirname(QUEUE_PATH);
-  if (!existsSync8(dir)) mkdirSync2(dir, { recursive: true });
+  const dir = path9.dirname(QUEUE_PATH);
+  if (!existsSync8(dir)) mkdirSync3(dir, { recursive: true });
 }
 function readQueue() {
   try {
@@ -2339,7 +2359,7 @@ function readQueue() {
 function writeQueue(queue) {
   ensureDir();
   const tmp = `${QUEUE_PATH}.tmp`;
-  writeFileSync(tmp, JSON.stringify(queue, null, 2));
+  writeFileSync2(tmp, JSON.stringify(queue, null, 2));
   renameSync2(tmp, QUEUE_PATH);
 }
 function queueIntercom(targetSession, reason) {
@@ -2363,176 +2383,2189 @@ var QUEUE_PATH, TTL_MS, INTERCOM_LOG;
 var init_intercom_queue = __esm({
   "src/lib/intercom-queue.ts"() {
     "use strict";
-    QUEUE_PATH = path10.join(os5.homedir(), ".exe-os", "intercom-queue.json");
+    QUEUE_PATH = path9.join(os5.homedir(), ".exe-os", "intercom-queue.json");
     TTL_MS = 60 * 60 * 1e3;
-    INTERCOM_LOG = path10.join(os5.homedir(), ".exe-os", "intercom.log");
+    INTERCOM_LOG = path9.join(os5.homedir(), ".exe-os", "intercom.log");
   }
 });
 
 // src/lib/license.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync2, existsSync as existsSync9, mkdirSync as mkdirSync3 } from "fs";
-import { randomUUID as randomUUID2 } from "crypto";
-import path11 from "path";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync3, existsSync as existsSync9, mkdirSync as mkdirSync4 } from "fs";
+import { randomUUID as randomUUID3 } from "crypto";
+import path10 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 = path11.join(EXE_AI_DIR, "license.key");
-    CACHE_PATH = path11.join(EXE_AI_DIR, "license-cache.json");
-    DEVICE_ID_PATH = path11.join(EXE_AI_DIR, "device-id");
+    LICENSE_PATH = path10.join(EXE_AI_DIR, "license.key");
+    CACHE_PATH = path10.join(EXE_AI_DIR, "license-cache.json");
+    DEVICE_ID_PATH = path10.join(EXE_AI_DIR, "device-id");
+    PLAN_LIMITS = {
+      free: { devices: 1, employees: 1, memories: 5e3 },
+      pro: { devices: 2, 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 readFileSync8, existsSync as existsSync10 } from "fs";
+import path11 from "path";
+function getLicenseSync() {
+  try {
+    if (!existsSync10(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 (existsSync10(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";
+    init_database();
+    init_employees();
+    init_license();
+    init_config();
+    PlanLimitError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "PlanLimitError";
+      }
+    };
+    CACHE_PATH2 = path11.join(EXE_AI_DIR, "license-cache.json");
+  }
+});
+
+// src/lib/session-kill-telemetry.ts
+import crypto3 from "crypto";
+async function recordSessionKill(input) {
+  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: [
+        crypto3.randomUUID(),
+        input.sessionName,
+        input.agentId,
+        (/* @__PURE__ */ new Date()).toISOString(),
+        input.reason,
+        input.ticksIdle ?? null,
+        input.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/tasks-chain.ts
+import path12 from "path";
+import { readFile as readFile4, 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 unblockedRows = await client.execute({
+      sql: `SELECT task_file FROM tasks WHERE blocked_by IS NULL AND updated_at = ?`,
+      args: [now]
+    });
+    for (const ur of unblockedRows.rows) {
+      try {
+        const ubFile = path12.join(baseDir, String(ur.task_file));
+        let ubContent = await readFile4(ubFile, "utf-8");
+        ubContent = ubContent.replace(/\*\*Status:\*\* blocked/, "**Status:** open");
+        ubContent = ubContent.replace(/\n\*\*Blocked by:\*\*.*\n/, "\n");
+        await writeFile4(ubFile, ubContent, "utf-8");
+      } catch {
+      }
+    }
+  }
+}
+async function findNextTask(assignedTo) {
+  const client = getClient();
+  const nextResult = await client.execute({
+    sql: `SELECT title, task_file, priority FROM tasks
+          WHERE assigned_to = ? AND status = 'open'
+          ORDER BY priority ASC, created_at ASC
+          LIMIT 1`,
+    args: [assignedTo]
+  });
+  if (nextResult.rows.length === 1) {
+    const nr = nextResult.rows[0];
+    return {
+      title: String(nr.title),
+      priority: String(nr.priority),
+      taskFile: String(nr.task_file)
+    };
+  }
+  return void 0;
+}
+async function checkSubtaskCompletion(parentTaskId, projectName) {
+  const client = getClient();
+  const remaining = await client.execute({
+    sql: `SELECT COUNT(*) as cnt FROM tasks
+          WHERE parent_task_id = ? AND status NOT IN ('done', 'cancelled')`,
+    args: [parentTaskId]
+  });
+  const cnt = Number(remaining.rows[0]?.cnt ?? 1);
+  if (cnt === 0) {
+    const parentRow = await client.execute({
+      sql: `SELECT assigned_to, title, task_file, project_name FROM tasks WHERE id = ?`,
+      args: [parentTaskId]
+    });
+    if (parentRow.rows.length === 1) {
+      const pr = parentRow.rows[0];
+      const parentProject = pr.project_name == null ? projectName : String(pr.project_name);
+      await writeNotification({
+        agentId: String(pr.assigned_to),
+        agentRole: "system",
+        event: "subtasks_complete",
+        project: parentProject,
+        summary: `All subtasks complete for "${String(pr.title)}" \u2014 ready for rollup review`,
+        taskFile: String(pr.task_file)
+      });
+    }
+  }
+}
+var init_tasks_chain = __esm({
+  "src/lib/tasks-chain.ts"() {
+    "use strict";
+    init_database();
+    init_notifications();
+  }
+});
+
+// src/lib/session-scope.ts
+var session_scope_exports = {};
+__export(session_scope_exports, {
+  assertSessionScope: () => assertSessionScope,
+  findSessionForProject: () => findSessionForProject,
+  getSessionProject: () => getSessionProject
+});
+function getSessionProject(sessionName) {
+  const sessions = listSessions();
+  const entry = sessions.find((s) => s.windowName === sessionName);
+  if (!entry) return null;
+  const parts = entry.projectDir.split("/").filter(Boolean);
+  return parts[parts.length - 1] ?? null;
+}
+function findSessionForProject(projectName) {
+  const sessions = listSessions();
+  for (const s of sessions) {
+    const proj = s.projectDir.split("/").filter(Boolean).pop();
+    if (proj === projectName && s.agentId === "exe") return s;
+  }
+  return null;
+}
+function assertSessionScope(actionType, targetProject) {
+  try {
+    const currentProject = getProjectName();
+    const exeSession2 = resolveExeSession();
+    if (!exeSession2) {
+      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();
+  }
+});
+
+// src/lib/tasks-notify.ts
+async function dispatchTaskToEmployee(input) {
+  if (input.assignedTo === "exe") return { dispatched: "skipped" };
+  let crossProject = false;
+  if (input.projectName) {
+    try {
+      const { assertSessionScope: assertSessionScope2 } = (init_session_scope(), __toCommonJS(session_scope_exports));
+      const check = assertSessionScope2("dispatch_task", input.projectName);
+      if (check.reason === "cross_session_denied") {
+        crossProject = true;
+        return { dispatched: "skipped", crossProject: true };
+      }
+    } catch {
+    }
+  }
+  try {
+    const transport = getTransport();
+    const exeSession2 = resolveExeSession();
+    if (!exeSession2) return { dispatched: "session_missing" };
+    const sessionName = employeeSessionName(input.assignedTo, exeSession2);
+    if (transport.isAlive(sessionName)) {
+      const result = sendIntercom(sessionName);
+      const dispatched = result === "acknowledged" || result === "debounced" || result === "queued" ? "verified" : result === "delivered" ? "sent_unverified" : "session_dead";
+      return { dispatched, session: sessionName, crossProject };
+    } else {
+      const projectDir = input.projectDir ?? process.cwd();
+      const result = ensureEmployee(input.assignedTo, exeSession2, projectDir, {
+        autoInstance: isMultiInstance(input.assignedTo)
+      });
+      if (result.status === "failed") {
+        process.stderr.write(
+          `[dispatch] Failed to spawn ${input.assignedTo}: ${result.error}
+`
+        );
+        return { dispatched: "session_missing" };
+      }
+      return { dispatched: "spawned", session: result.sessionName, crossProject };
+    }
+  } 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 path13 from "path";
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, unlinkSync as unlinkSync3 } from "fs";
+async function createTask(input) {
+  const result = await createTaskCore(input);
+  if (!input.skipDispatch && result.status !== "blocked" && !process.env.VITEST) {
+    dispatchTaskToEmployee({
+      assignedTo: input.assignedTo,
+      title: input.title,
+      priority: input.priority,
+      taskFile: result.taskFile,
+      initialStatus: result.status,
+      projectName: input.projectName
+    });
+  }
+  return result;
+}
+async function updateTask(input) {
+  const { row, taskFile, now, taskId } = await updateTaskStatus(input);
+  try {
+    const agent = String(row.assigned_to);
+    const cacheDir = path13.join(EXE_AI_DIR, "session-cache");
+    const cachePath = path13.join(cacheDir, `current-task-${agent}.json`);
+    if (input.status === "in_progress") {
+      mkdirSync5(cacheDir, { recursive: true });
+      writeFileSync4(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
+    } else if (input.status === "done" || input.status === "blocked" || input.status === "cancelled") {
+      try {
+        unlinkSync3(cachePath);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  if (input.status === "done") {
+    await cleanupReviewFile(row, taskFile, input.baseDir);
+  }
+  if (input.status === "done" || input.status === "cancelled") {
+    try {
+      const client = getClient();
+      const taskTitle = String(row.title);
+      const escaped = taskTitle.replace(/%/g, "\\%").replace(/_/g, "\\_");
+      await client.execute({
+        sql: `UPDATE tasks SET status = 'cancelled', updated_at = ?
+              WHERE title LIKE ? ESCAPE '\\' AND status IN ('open', 'in_progress')`,
+        args: [now, `%left '${escaped}' as in\\_progress%`]
+      });
+    } catch {
+    }
+    try {
+      const client = getClient();
+      const cascaded = await client.execute({
+        sql: `UPDATE tasks SET status = 'done', updated_at = ?
+              WHERE parent_task_id = ? AND status = 'needs_review'`,
+        args: [now, taskId]
+      });
+      if (cascaded.rowsAffected > 0) {
+        process.stderr.write(
+          `[cascade] Closed ${cascaded.rowsAffected} orphaned review task(s) for parent ${taskId}
+`
+        );
+      }
+    } catch {
+    }
+  }
+  const isTerminal = input.status === "done" || input.status === "needs_review";
+  if (isTerminal) {
+    const isExe = String(row.assigned_to) === "exe";
+    if (!isExe) {
+      notifyTaskDone();
+    }
+    await markTaskNotificationsRead(taskFile);
+    if (input.status === "done") {
+      try {
+        await cascadeUnblock(taskId, input.baseDir, now);
+      } catch {
+      }
+      orgBus.emit({
+        type: "task_completed",
+        taskId,
+        employee: String(row.assigned_to),
+        result: input.result ?? "",
+        timestamp: now
+      });
+      if (row.parent_task_id) {
+        try {
+          await checkSubtaskCompletion(String(row.parent_task_id), String(row.project_name));
+        } catch {
+        }
+      }
+    }
+  }
+  if (input.status === "done" && String(row.assigned_to) !== "exe" && !process.env.VITEST) {
+    Promise.resolve().then(() => (init_skill_learning(), skill_learning_exports)).then(
+      ({ captureAndLearn: captureAndLearn2 }) => captureAndLearn2({
+        taskId,
+        agentId: String(row.assigned_to),
+        projectName: String(row.project_name),
+        taskTitle: String(row.title)
+      })
+    ).catch((err) => {
+      process.stderr.write(
+        `[updateTask] skill learning failed: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    });
+  }
+  let nextTask;
+  if (isTerminal && String(row.assigned_to) !== "exe") {
+    try {
+      nextTask = await findNextTask(String(row.assigned_to));
+    } catch {
+    }
+  }
+  return {
+    id: String(row.id),
+    title: String(row.title),
+    assignedTo: String(row.assigned_to),
+    assignedBy: String(row.assigned_by),
+    projectName: String(row.project_name),
+    priority: String(row.priority),
+    status: input.status,
+    taskFile,
+    createdAt: String(row.created_at),
+    updatedAt: now,
+    budgetTokens: row.budget_tokens !== void 0 && row.budget_tokens !== null ? Number(row.budget_tokens) : null,
+    budgetFallbackModel: row.budget_fallback_model !== void 0 && row.budget_fallback_model !== null ? String(row.budget_fallback_model) : null,
+    tokensUsed: Number(row.tokens_used ?? 0),
+    tokensWarnedAt: row.tokens_warned_at !== void 0 && row.tokens_warned_at !== null ? Number(row.tokens_warned_at) : null,
+    nextTask
+  };
+}
+async function deleteTask(taskId, baseDir) {
+  const client = getClient();
+  const { taskFile, assignedTo, assignedBy, taskSlug } = await deleteTaskCore(taskId, baseDir);
+  const reviewer = assignedBy || "exe";
+  const reviewSlug = `review-${assignedTo}-${taskSlug}`;
+  const reviewFile = `exe/${reviewer}/${reviewSlug}.md`;
+  await client.execute({
+    sql: "DELETE FROM tasks WHERE task_file = ? OR task_file = ?",
+    args: [reviewFile, `exe/exe/${reviewSlug}.md`]
+  });
+  await markAsReadByTaskFile(taskFile);
+  await markAsReadByTaskFile(reviewFile);
+}
+var init_tasks = __esm({
+  "src/lib/tasks.ts"() {
+    "use strict";
+    init_database();
+    init_config();
+    init_notifications();
+    init_state_bus();
+    init_tasks_crud();
+    init_tasks_review();
+    init_tasks_crud();
+    init_tasks_chain();
+    init_tasks_review();
+    init_tasks_notify();
+  }
+});
+
+// src/lib/capacity-monitor.ts
+var capacity_monitor_exports = {};
+__export(capacity_monitor_exports, {
+  CTX_FLOOR_PERCENT: () => CTX_FLOOR_PERCENT,
+  _resetLastRelaunchCache: () => _resetLastRelaunchCache,
+  _resetPendingCapacityKills: () => _resetPendingCapacityKills,
+  confirmCapacityKill: () => confirmCapacityKill,
+  createOrRefreshResumeTask: () => createOrRefreshResumeTask,
+  extractContextPercent: () => extractContextPercent,
+  isAtCapacity: () => isAtCapacity,
+  isWithinRelaunchCooldown: () => isWithinRelaunchCooldown,
+  pollCapacityDead: () => pollCapacityDead
+});
+function resumeTaskTitle(agentId) {
+  return `${RESUME_TITLE_PREFIX} ${agentId} hit context capacity \u2014 continue open tasks`;
+}
+function buildResumeContext(agentId, openTasks) {
+  const taskList = openTasks.map(
+    (r, i) => `${i + 1}. [${String(r.priority).toUpperCase()}] ${String(r.title)} (${String(r.task_file)})`
+  ).join("\n");
+  return [
+    "## Context",
+    "",
+    `${agentId} hit context capacity and was auto-relaunched by the capacity monitor.`,
+    "Call recall_my_memory first \u2014 search for 'CONTEXT CHECKPOINT'. Pick up where the previous session stopped.",
+    "",
+    `You have ${openTasks.length} open task(s). Work through them in priority order:`,
+    "",
+    taskList,
+    "",
+    "Read each task file and chain through them. Build and commit after each one."
+  ].join("\n");
+}
+function filterPaneContent(paneOutput) {
+  return paneOutput.split("\n").filter((line) => {
+    if (CONTENT_LINE_PREFIX.test(line)) return false;
+    for (const marker of CONTENT_LINE_MARKERS) {
+      if (line.includes(marker)) return false;
+    }
+    for (const re of SOURCE_CODE_MARKERS) {
+      if (re.test(line)) return false;
+    }
+    return true;
+  }).join("\n");
+}
+function extractContextPercent(paneOutput) {
+  const match = paneOutput.match(CC_CONTEXT_BAR_RE);
+  if (!match) return null;
+  const parsed = Number.parseInt(match[2], 10);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function isAtCapacity(paneOutput) {
+  const filtered = filterPaneContent(paneOutput);
+  return CAPACITY_PATTERNS.some((p) => p.test(filtered));
+}
+function confirmCapacityKill(agentId, now = Date.now()) {
+  const pendingSince = _pendingCapacityKill.get(agentId);
+  if (pendingSince === void 0) {
+    _pendingCapacityKill.set(agentId, now);
+    return false;
+  }
+  if (now - pendingSince > CONFIRMATION_WINDOW_MS) {
+    _pendingCapacityKill.set(agentId, now);
+    return false;
+  }
+  _pendingCapacityKill.delete(agentId);
+  return true;
+}
+function _resetPendingCapacityKills() {
+  _pendingCapacityKill.clear();
+}
+function _resetLastRelaunchCache() {
+  _lastRelaunch.clear();
+}
+async function lastResumeCreatedAtMs(agentId) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: `SELECT MAX(created_at) AS last_created_at
+          FROM tasks
+          WHERE assigned_to = ? AND title LIKE ?`,
+    args: [agentId, `${RESUME_TITLE_PREFIX} %`]
+  });
+  const raw = result.rows[0]?.last_created_at;
+  if (raw === null || raw === void 0) return null;
+  const parsed = Date.parse(String(raw));
+  return Number.isNaN(parsed) ? null : parsed;
+}
+async function isWithinRelaunchCooldown(agentId, now = Date.now()) {
+  const cached = _lastRelaunch.get(agentId);
+  if (cached !== void 0) return now - cached < RELAUNCH_COOLDOWN_MS;
+  const persisted = await lastResumeCreatedAtMs(agentId);
+  if (persisted === null) return false;
+  if (now - persisted >= RELAUNCH_COOLDOWN_MS) return false;
+  _lastRelaunch.set(agentId, persisted);
+  return true;
+}
+async function createOrRefreshResumeTask(agentId, projectDir, openTasks) {
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const context = buildResumeContext(agentId, openTasks);
+  const existing = await client.execute({
+    sql: `SELECT id FROM tasks
+          WHERE assigned_to = ?
+            AND title LIKE ?
+            AND status IN (${RESUME_ACTIVE_STATUSES.map(() => "?").join(", ")})
+          ORDER BY created_at DESC
+          LIMIT 1`,
+    args: [agentId, RESUME_TITLE_LIKE_PATTERN, ...RESUME_ACTIVE_STATUSES]
+  });
+  if (existing.rows.length > 0) {
+    const taskId = String(existing.rows[0].id);
+    await client.execute({
+      sql: `UPDATE tasks SET context = ?, updated_at = ? WHERE id = ?`,
+      args: [context, now, taskId]
+    });
+    return { created: false, taskId };
+  }
+  const { createTask: createTask2 } = await Promise.resolve().then(() => (init_tasks(), tasks_exports));
+  const task = await createTask2({
+    title: resumeTaskTitle(agentId),
+    assignedTo: agentId,
+    assignedBy: "system",
+    projectName: projectDir.split("/").pop() ?? "unknown",
+    priority: "p0",
+    context,
+    baseDir: projectDir
+  });
+  return { created: true, taskId: task.id };
+}
+async function pollCapacityDead() {
+  const transport = getTransport();
+  const relaunched = [];
+  const registered = listSessions().filter(
+    (s) => s.agentId !== "exe"
+  );
+  if (registered.length === 0) return [];
+  let liveSessions;
+  try {
+    liveSessions = transport.listSessions();
+  } catch {
+    return [];
+  }
+  for (const entry of registered) {
+    const { windowName, agentId, projectDir } = entry;
+    if (!liveSessions.includes(windowName)) continue;
+    if (await isWithinRelaunchCooldown(agentId)) continue;
+    let pane;
+    try {
+      pane = transport.capturePane(windowName, 15);
+    } catch {
+      continue;
+    }
+    if (!isAtCapacity(pane)) continue;
+    const ctxPct = extractContextPercent(pane);
+    if (ctxPct !== null && ctxPct < CTX_FLOOR_PERCENT) {
+      process.stderr.write(
+        `[capacity-monitor] ctx-floor: ${agentId} at ${ctxPct}% in ${windowName} \u2014 below ${CTX_FLOOR_PERCENT}%. Skipping capacity kill (likely self-referential content or false positive).
+`
+      );
+      continue;
+    }
+    if (!confirmCapacityKill(agentId)) {
+      process.stderr.write(
+        `[capacity-monitor] ${agentId} matched capacity pattern once in ${windowName}. Awaiting confirmation on next tick.
+`
+      );
+      continue;
+    }
+    const verify = await verifyPaneAtCapacity(windowName);
+    if (!verify.atCapacity) {
+      process.stderr.write(
+        `[capacity-monitor] verifyPaneAtCapacity rejected kill for ${agentId} in ${windowName} (reason: ${verify.reason}). Skipping.
+`
+      );
+      void recordSessionKill({
+        sessionName: windowName,
+        agentId,
+        reason: "capacity_false_positive_blocked"
+      });
+      continue;
+    }
+    process.stderr.write(
+      `[capacity-monitor] Detected ${agentId} at capacity in session ${windowName} (confirmed). Auto-relaunching.
+`
+    );
+    try {
+      transport.kill(windowName);
+      void recordSessionKill({
+        sessionName: windowName,
+        agentId,
+        reason: "capacity"
+      });
+      const client = getClient();
+      const openTasks = await client.execute({
+        sql: `SELECT id, title, priority, task_file, status
+              FROM tasks
+              WHERE assigned_to = ? AND status IN ('open', 'in_progress')
+              ORDER BY
+                CASE priority WHEN 'p0' THEN 0 WHEN 'p1' THEN 1 WHEN 'p2' THEN 2 ELSE 3 END,
+                created_at ASC
+              LIMIT 10`,
+        args: [agentId]
+      });
+      if (openTasks.rows.length === 0) {
+        process.stderr.write(
+          `[capacity-monitor] ${agentId} has no open tasks \u2014 skipping relaunch.
+`
+        );
+        continue;
+      }
+      const { created } = await createOrRefreshResumeTask(
+        agentId,
+        projectDir,
+        openTasks.rows
+      );
+      if (created) {
+        await writeNotification({
+          agentId: "system",
+          agentRole: "daemon",
+          event: "capacity_relaunch",
+          project: projectDir.split("/").pop() ?? "unknown",
+          summary: `${agentId} hit context capacity. Auto-relaunched with ${openTasks.rows.length} open task(s).`
+        });
+      }
+      _lastRelaunch.set(agentId, Date.now());
+      if (created) relaunched.push(agentId);
+    } catch (err) {
+      process.stderr.write(
+        `[capacity-monitor] Failed to relaunch ${agentId}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  return relaunched;
+}
+var CAPACITY_PATTERNS, CONTENT_LINE_PREFIX, CONTENT_LINE_MARKERS, SOURCE_CODE_MARKERS, RELAUNCH_COOLDOWN_MS, _lastRelaunch, RESUME_TITLE_PREFIX, RESUME_TITLE_LIKE_PATTERN, RESUME_ACTIVE_STATUSES, CONFIRMATION_WINDOW_MS, _pendingCapacityKill, CC_CONTEXT_BAR_RE, CTX_FLOOR_PERCENT;
+var init_capacity_monitor = __esm({
+  "src/lib/capacity-monitor.ts"() {
+    "use strict";
+    init_session_registry();
+    init_transport();
+    init_notifications();
+    init_database();
+    init_session_kill_telemetry();
+    init_tmux_routing();
+    CAPACITY_PATTERNS = [
+      /conversation is too long/i,
+      /maximum context length/i,
+      /context window.*(?:limit|exceed|full)/i,
+      /reached.*(?:token|context).*limit/i
+    ];
+    CONTENT_LINE_PREFIX = /^[\s>#\-*[]/;
+    CONTENT_LINE_MARKERS = [
+      "RESUME:",
+      "intercom",
+      "capacity-monitor",
+      "CAPACITY_PATTERNS",
+      "isAtCapacity",
+      "CONTENT_LINE_MARKERS",
+      "pollCapacityDead",
+      "confirmCapacityKill",
+      "session_kills",
+      "capacity-monitor.test"
+    ];
+    SOURCE_CODE_MARKERS = [
+      /["'`/].*(?:maximum context length|conversation is too long)/i,
+      /(?:maximum context length|conversation is too long).*["'`/]/i
+    ];
+    RELAUNCH_COOLDOWN_MS = 5 * 60 * 1e3;
+    _lastRelaunch = /* @__PURE__ */ new Map();
+    RESUME_TITLE_PREFIX = "RESUME:";
+    RESUME_TITLE_LIKE_PATTERN = `${RESUME_TITLE_PREFIX} % hit context capacity%`;
+    RESUME_ACTIVE_STATUSES = ["open", "in_progress"];
+    CONFIRMATION_WINDOW_MS = 3 * 60 * 1e3;
+    _pendingCapacityKill = /* @__PURE__ */ new Map();
+    CC_CONTEXT_BAR_RE = /([\u2588\u2591\u2592\u2593]{10})\s+(\d+)%/;
+    CTX_FLOOR_PERCENT = 50;
+  }
+});
+
+// src/lib/tmux-routing.ts
+var tmux_routing_exports = {};
+__export(tmux_routing_exports, {
+  acquireSpawnLock: () => acquireSpawnLock2,
+  employeeSessionName: () => employeeSessionName,
+  ensureEmployee: () => ensureEmployee,
+  extractRootExe: () => extractRootExe,
+  findFreeInstance: () => findFreeInstance,
+  getDispatchedBy: () => getDispatchedBy,
+  getMySession: () => getMySession,
+  getParentExe: () => getParentExe,
+  getSessionState: () => getSessionState,
+  isEmployeeAlive: () => isEmployeeAlive,
+  isExeSession: () => isExeSession,
+  isSessionBusy: () => isSessionBusy,
+  notifyParentExe: () => notifyParentExe,
+  parseParentExe: () => parseParentExe,
+  registerParentExe: () => registerParentExe,
+  releaseSpawnLock: () => releaseSpawnLock2,
+  resolveExeSession: () => resolveExeSession,
+  sendIntercom: () => sendIntercom,
+  spawnEmployee: () => spawnEmployee,
+  verifyPaneAtCapacity: () => verifyPaneAtCapacity
+});
+import { execFileSync as execFileSync2, execSync as execSync5 } from "child_process";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6, existsSync as existsSync11, appendFileSync } from "fs";
+import path14 from "path";
+import os6 from "os";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { unlinkSync as unlinkSync4 } from "fs";
+function spawnLockPath(sessionName) {
+  return path14.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(readFileSync9(lockFile, "utf8"));
+      const age = Date.now() - lock.timestamp;
+      if (isProcessAlive(lock.pid) && age < 6e4) {
+        return false;
+      }
+    } catch {
+    }
+  }
+  writeFileSync5(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
+  return true;
+}
+function releaseSpawnLock2(sessionName) {
+  try {
+    unlinkSync4(spawnLockPath(sessionName));
+  } catch {
+  }
+}
+function resolveBehaviorsExporterScript() {
+  try {
+    const thisFile = fileURLToPath2(import.meta.url);
+    const scriptPath = path14.join(
+      path14.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 employeeSessionName(employee, exeSession2, instance) {
+  if (!/^exe\d+$/.test(exeSession2)) {
+    const root = extractRootExe(exeSession2);
+    if (root) {
+      process.stderr.write(
+        `[tmux-routing] WARN: exeSession="${exeSession2}" is not a root exe session, using "${root}" instead
+`
+      );
+      exeSession2 = root;
+    } else {
+      throw new Error(
+        `Invalid exeSession "${exeSession2}" \u2014 must be a root exe session (e.g., "exe1"), not an agent session`
+      );
+    }
+  }
+  const suffix = instance != null && instance > 0 ? String(instance) : "";
+  const name = `${employee}${suffix}-${exeSession2}`;
+  if (!VALID_SESSION_NAME.test(name)) {
+    throw new Error(
+      `Invalid session name "${name}" \u2014 must match {agent}-exe{N} or {agent}{instance}-exe{N}`
+    );
+  }
+  return name;
+}
+function parseParentExe(sessionName, agentId) {
+  const escaped = agentId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const regex = new RegExp(`^${escaped}\\d*-(.+)$`);
+  const match = sessionName.match(regex);
+  return match?.[1] ?? null;
+}
+function extractRootExe(name) {
+  const match = name.match(/(exe\d+)$/);
+  return match?.[1] ?? null;
+}
+function registerParentExe(sessionKey, parentExe, dispatchedBy) {
+  if (!existsSync11(SESSION_CACHE)) {
+    mkdirSync6(SESSION_CACHE, { recursive: true });
+  }
+  const rootExe = extractRootExe(parentExe) ?? parentExe;
+  const filePath = path14.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
+  writeFileSync5(filePath, JSON.stringify({
+    parentExe: rootExe,
+    dispatchedBy: dispatchedBy || rootExe,
+    registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+  }));
+}
+function getParentExe(sessionKey) {
+  try {
+    const data = JSON.parse(readFileSync9(path14.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    return data.parentExe || null;
+  } catch {
+    return null;
+  }
+}
+function getDispatchedBy(sessionKey) {
+  try {
+    const data = JSON.parse(readFileSync9(
+      path14.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
+      "utf8"
+    ));
+    return data.dispatchedBy ?? data.parentExe ?? null;
+  } catch {
+    return null;
+  }
+}
+function resolveExeSession() {
+  const mySession = getMySession();
+  if (!mySession) return null;
+  try {
+    const key = getSessionKey();
+    const parentExe = getParentExe(key);
+    if (parentExe) {
+      return extractRootExe(parentExe) ?? parentExe;
+    }
+  } catch {
+  }
+  return extractRootExe(mySession) ?? mySession;
+}
+function isEmployeeAlive(sessionName) {
+  return getTransport().isAlive(sessionName);
+}
+function findFreeInstance(employeeName, exeSession2, maxInstances = 10, isAlive = isEmployeeAlive) {
+  const base = employeeSessionName(employeeName, exeSession2);
+  if (!isAlive(base) && acquireSpawnLock2(base)) return 0;
+  for (let i = 2; i <= maxInstances; i++) {
+    const candidate = employeeSessionName(employeeName, exeSession2, 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(readFileSync9(DEBOUNCE_FILE, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeDebounceState(state) {
+  try {
+    if (!existsSync11(SESSION_CACHE)) mkdirSync6(SESSION_CACHE, { recursive: true });
+    writeFileSync5(DEBOUNCE_FILE, JSON.stringify(state));
+  } catch {
+  }
+}
+function isDebounced(targetSession) {
+  const state = readDebounceState();
+  const lastSent = state[targetSession] ?? 0;
+  return Date.now() - lastSent < INTERCOM_DEBOUNCE_MS;
+}
+function recordDebounce(targetSession) {
+  const state = readDebounceState();
+  state[targetSession] = Date.now();
+  const cutoff = Date.now() - DEBOUNCE_CLEANUP_AGE_MS;
+  for (const key of Object.keys(state)) {
+    if ((state[key] ?? 0) < cutoff) delete state[key];
+  }
+  writeDebounceState(state);
+}
+function logIntercom(msg) {
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
+`;
+  process.stderr.write(`[intercom] ${msg}
+`);
+  try {
+    appendFileSync(INTERCOM_LOG2, line);
+  } catch {
+  }
+}
+function getSessionState(sessionName) {
+  const transport = getTransport();
+  if (!transport.isAlive(sessionName)) return "offline";
+  try {
+    const pane = transport.capturePane(sessionName, 5);
+    if (!pane.includes("\u276F") && !pane.includes("Claude Code") && !BUSY_PATTERN.test(pane) && !/Running…/.test(pane)) {
+      if (/\$\s*$/.test(pane) || /% $/.test(pane.trimEnd())) {
+        return "no_claude";
+      }
+    }
+    if (/Running…/.test(pane)) return "tool";
+    if (BUSY_PATTERN.test(pane)) return "thinking";
+    return "idle";
+  } catch {
+    return "offline";
+  }
+}
+function isSessionBusy(sessionName) {
+  const state = getSessionState(sessionName);
+  return state === "thinking" || state === "tool";
+}
+function isExeSession(sessionName) {
+  return /^exe\d*$/.test(sessionName);
+}
+function sendIntercom(targetSession) {
+  const transport = getTransport();
+  if (isExeSession(targetSession)) {
+    logIntercom(`SKIP_EXE \u2192 ${targetSession} (exe sessions use prompt-submit hook)`);
+    return "skipped_exe";
+  }
+  if (isDebounced(targetSession)) {
+    logIntercom(`DEBOUNCE \u2192 ${targetSession} (cross-process file debounce)`);
+    return "debounced";
+  }
+  try {
+    const sessions = transport.listSessions();
+    if (!sessions.includes(targetSession)) {
+      logIntercom(`SKIP \u2192 ${targetSession} (session not found)`);
+      return "failed";
+    }
+    const sessionState = getSessionState(targetSession);
+    if (sessionState === "no_claude") {
+      queueIntercom(targetSession, "claude not running in session");
+      recordDebounce(targetSession);
+      logIntercom(`QUEUED \u2192 ${targetSession} (no claude process \u2014 raw shell detected)`);
+      return "queued";
+    }
+    if (sessionState === "thinking" || sessionState === "tool") {
+      queueIntercom(targetSession, "session busy at send time");
+      recordDebounce(targetSession);
+      logIntercom(`QUEUED \u2192 ${targetSession} (session busy, will retry from queue)`);
+      return "queued";
+    }
+    if (transport.isPaneInCopyMode(targetSession)) {
+      logIntercom(`COPY_MODE \u2192 ${targetSession} (exiting copy mode first)`);
+      transport.sendKeys(targetSession, "q");
+    }
+    transport.sendKeys(targetSession, "/exe-intercom");
+    recordDebounce(targetSession);
+    logIntercom(`DELIVERED \u2192 ${targetSession} (fire-and-forget)`);
+    return "delivered";
+  } catch {
+    logIntercom(`FAIL \u2192 ${targetSession}`);
+    return "failed";
+  }
+}
+function notifyParentExe(sessionKey) {
+  const target = getDispatchedBy(sessionKey);
+  if (!target) {
+    process.stderr.write(`[intercom] notifyParentExe: no dispatcher found for key ${sessionKey}
+`);
+    return false;
+  }
+  process.stderr.write(`[intercom] notifyParentExe \u2192 ${target}
+`);
+  const result = sendIntercom(target);
+  if (result === "failed") {
+    const rootExe = resolveExeSession();
+    if (rootExe && rootExe !== target) {
+      process.stderr.write(`[intercom] notifyParentExe: dispatcher ${target} dead, falling back to root exe ${rootExe}
+`);
+      const fallback = sendIntercom(rootExe);
+      return fallback !== "failed";
+    }
+    return false;
+  }
+  return true;
+}
+function ensureEmployee(employeeName, exeSession2, projectDir, opts) {
+  if (employeeName === "exe") {
+    return { status: "failed", sessionName: "", error: "exe is the COO, not a dispatchable employee" };
+  }
+  try {
+    assertEmployeeLimitSync();
+  } catch (err) {
+    if (err instanceof PlanLimitError) {
+      return { status: "failed", sessionName: "", error: err.message };
+    }
+  }
+  if (/-exe\d*$/.test(employeeName)) {
+    const bare = employeeName.replace(/-exe\d*$/, "").replace(/\d+$/, "");
+    return {
+      status: "failed",
+      sessionName: "",
+      error: `Error: pass employee name ('${bare}'), not session name ('${employeeName}')`
+    };
+  }
+  if (!/^exe\d+$/.test(exeSession2)) {
+    const root = extractRootExe(exeSession2);
+    if (root) {
+      process.stderr.write(
+        `[ensureEmployee] WARN: caller passed exeSession="${exeSession2}" (not a root exe). Auto-correcting to "${root}".
+`
+      );
+      exeSession2 = root;
+    } else {
+      return {
+        status: "failed",
+        sessionName: "",
+        error: `Invalid exeSession "${exeSession2}" \u2014 must be a root exe session (e.g., "exe1")`
+      };
+    }
+  }
+  let effectiveInstance = opts?.instance;
+  if (effectiveInstance === void 0 && opts?.autoInstance) {
+    const free = findFreeInstance(
+      employeeName,
+      exeSession2,
+      opts.maxAutoInstances ?? 10
+    );
+    if (free === null) {
+      return {
+        status: "failed",
+        sessionName: employeeSessionName(employeeName, exeSession2),
+        error: `All ${opts.maxAutoInstances ?? 10} instances of ${employeeName} are alive \u2014 cap reached`
+      };
+    }
+    effectiveInstance = free === 0 ? void 0 : free;
+  }
+  const sessionName = employeeSessionName(employeeName, exeSession2, 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, exeSession2, projectDir, spawnOpts);
+  if (result.error) {
+    return { status: "failed", sessionName, error: result.error };
+  }
+  return { status: "spawned", sessionName };
+}
+function spawnEmployee(employeeName, exeSession2, projectDir, opts) {
+  const transport = getTransport();
+  const sessionName = employeeSessionName(employeeName, exeSession2, opts?.instance);
+  const instanceLabel2 = opts?.instance != null && opts.instance > 0 ? `${employeeName}${opts.instance}` : employeeName;
+  const logDir = path14.join(os6.homedir(), ".exe-os", "session-logs");
+  const logFile = path14.join(logDir, `${instanceLabel2}-${Date.now()}.log`);
+  if (!existsSync11(logDir)) {
+    mkdirSync6(logDir, { recursive: true });
+  }
+  transport.kill(sessionName);
+  let cleanupSuffix = "";
+  try {
+    const thisFile = fileURLToPath2(import.meta.url);
+    const cleanupScript = path14.join(path14.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
+    if (existsSync11(cleanupScript)) {
+      cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession2}"`;
+    }
+  } catch {
+  }
+  try {
+    const claudeJsonPath = path14.join(os6.homedir(), ".claude.json");
+    let claudeJson = {};
+    try {
+      claudeJson = JSON.parse(readFileSync9(claudeJsonPath, "utf8"));
+    } catch {
+    }
+    if (!claudeJson.projects) claudeJson.projects = {};
+    const projects = claudeJson.projects;
+    const trustDir = opts?.cwd ?? projectDir;
+    if (!projects[trustDir]) projects[trustDir] = {};
+    projects[trustDir].hasTrustDialogAccepted = true;
+    writeFileSync5(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+  } catch {
+  }
+  try {
+    const settingsDir = path14.join(os6.homedir(), ".claude", "projects");
+    const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
+    const projSettingsDir = path14.join(settingsDir, normalizedKey);
+    const settingsPath = path14.join(projSettingsDir, "settings.json");
+    let settings = {};
+    try {
+      settings = JSON.parse(readFileSync9(settingsPath, "utf8"));
+    } catch {
+    }
+    const perms = settings.permissions ?? {};
+    const allow = perms.allow ?? [];
+    const toolNames = [
+      "recall_my_memory",
+      "store_memory",
+      "create_task",
+      "update_task",
+      "list_tasks",
+      "get_task",
+      "ask_team_memory",
+      "store_behavior",
+      "get_identity",
+      "send_message"
+    ];
+    const requiredTools = expandDualPrefixTools(toolNames);
+    let changed = false;
+    for (const tool of requiredTools) {
+      if (!allow.includes(tool)) {
+        allow.push(tool);
+        changed = true;
+      }
+    }
+    if (changed) {
+      perms.allow = allow;
+      settings.permissions = perms;
+      mkdirSync6(projSettingsDir, { recursive: true });
+      writeFileSync5(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    }
+  } catch {
+  }
+  const spawnCwd = opts?.cwd ?? projectDir;
+  const useExeAgent = !!(opts?.model && opts?.provider);
+  const ccProvider = useExeAgent ? DEFAULT_PROVIDER : detectActiveProvider();
+  const useBinSymlink = ccProvider !== DEFAULT_PROVIDER;
+  let identityFlag = "";
+  let behaviorsFlag = "";
+  let legacyFallbackWarned = false;
+  if (!useExeAgent && !useBinSymlink) {
+    const identityPath = path14.join(
+      os6.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,
+      path14.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 = path14.join(os6.homedir(), ".exe-os", "session-cache");
+    mkdirSync6(ctxDir, { recursive: true });
+    const ctxFile = path14.join(ctxDir, `session-context-${sessionName}.md`);
+    const ctxContent = [
+      `## Session Context`,
+      `You are running in tmux session: ${sessionName}.`,
+      `Your parent exe session is ${exeSession2}.`,
+      `Your employees (if any) use the -${exeSession2} suffix (e.g., tom-${exeSession2}).`
+    ].join("\n");
+    writeFileSync5(ctxFile, ctxContent);
+    sessionContextFlag = ` --append-system-prompt-file ${ctxFile}`;
+  } catch {
+  }
+  let envPrefix = `EXE_SESSION=${exeSession2} 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 = path14.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
+    writeFileSync5(dispatchInfo, JSON.stringify({
+      dispatchedBy: mySession,
+      rootExe: exeSession2,
+      provider: useBinSymlink ? ccProvider : useExeAgent ? opts.provider : "anthropic",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+  } catch {
+  }
+  let booted = false;
+  for (let i = 0; i < 30; i++) {
+    try {
+      execSync5("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: exeSession2,
+    pid: 0,
+    registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  releaseSpawnLock2(sessionName);
+  return { sessionName };
+}
+var SPAWN_LOCK_DIR, SESSION_CACHE, BEHAVIORS_EXPORT_TIMEOUT_MS, VALID_SESSION_NAME, VERIFY_PANE_LINES, INTERCOM_DEBOUNCE_MS, INTERCOM_LOG2, DEBOUNCE_FILE, DEBOUNCE_CLEANUP_AGE_MS, BUSY_PATTERN;
+var init_tmux_routing = __esm({
+  "src/lib/tmux-routing.ts"() {
+    "use strict";
+    init_session_registry();
+    init_session_key();
+    init_transport();
+    init_cc_agent_support();
+    init_mcp_prefix();
+    init_provider_table();
+    init_intercom_queue();
+    init_plan_limits();
+    SPAWN_LOCK_DIR = path14.join(os6.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path14.join(os6.homedir(), ".exe-os", "session-cache");
+    BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
+    VALID_SESSION_NAME = /^[a-z]+-exe\d+$|^[a-z]+\d+-exe\d+$/;
+    VERIFY_PANE_LINES = 200;
+    INTERCOM_DEBOUNCE_MS = 3e4;
+    INTERCOM_LOG2 = path14.join(os6.homedir(), ".exe-os", "intercom.log");
+    DEBOUNCE_FILE = path14.join(SESSION_CACHE, "intercom-debounce.json");
+    DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
+    BUSY_PATTERN = /[✻✽✶✳·].*…|Running…/;
+  }
+});
+
+// src/lib/tasks-crud.ts
+import crypto6 from "crypto";
+import path15 from "path";
+import { execSync as execSync6 } from "child_process";
+import { mkdir as mkdir4, writeFile as writeFile5, appendFile } from "fs/promises";
+import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
+async function writeCheckpoint(input) {
+  const client = getClient();
+  const row = await resolveTask(client, input.taskId);
+  const taskId = String(row.id);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const blockedByIds = [];
+  if (row.blocked_by) {
+    blockedByIds.push(String(row.blocked_by));
+  }
+  const checkpoint = {
+    step: input.step,
+    context_summary: input.contextSummary,
+    files_touched: input.filesTouched ?? [],
+    blocked_by_ids: blockedByIds,
+    last_checkpoint_at: now
+  };
+  const result = await client.execute({
+    sql: `UPDATE tasks SET checkpoint = ?, checkpoint_count = checkpoint_count + 1, updated_at = ? WHERE id = ?`,
+    args: [JSON.stringify(checkpoint), now, taskId]
+  });
+  if (result.rowsAffected === 0) {
+    throw new Error(`Checkpoint write failed: task ${taskId} not found`);
+  }
+  const countResult = await client.execute({
+    sql: "SELECT checkpoint_count FROM tasks WHERE id = ?",
+    args: [taskId]
+  });
+  const checkpointCount = Number(countResult.rows[0]?.checkpoint_count ?? 1);
+  return { checkpointCount };
+}
+function extractParentFromContext(contextBody) {
+  if (!contextBody) return null;
+  const match = contextBody.match(
+    /Parent task:\s*([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i
+  );
+  return match ? match[1].toLowerCase() : null;
+}
+function slugify(title) {
+  return title.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+async function resolveTask(client, identifier) {
+  let result = await client.execute({
+    sql: "SELECT * FROM tasks WHERE id = ?",
+    args: [identifier]
+  });
+  if (result.rows.length === 1) return result.rows[0];
+  result = await client.execute({
+    sql: "SELECT * FROM tasks WHERE task_file LIKE ?",
+    args: [`%${identifier}%`]
+  });
+  if (result.rows.length === 1) return result.rows[0];
+  if (result.rows.length > 1) {
+    const exact = result.rows.filter(
+      (r) => String(r.task_file).endsWith(`/${identifier}.md`)
+    );
+    if (exact.length === 1) return exact[0];
+    const candidates = exact.length > 1 ? exact : result.rows;
+    const active = candidates.filter(
+      (r) => !["done", "cancelled"].includes(String(r.status))
+    );
+    if (active.length === 1) return active[0];
+    const matches = (active.length > 1 ? active : candidates).map((r) => `${String(r.task_file)} (${String(r.status)}, ${String(r.id)})`).join(", ");
+    throw new Error(
+      `Multiple tasks match "${identifier}": ${matches}. Use a UUID to disambiguate.`
+    );
+  }
+  result = await client.execute({
+    sql: "SELECT * FROM tasks WHERE title LIKE ?",
+    args: [`%${identifier}%`]
+  });
+  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(input) {
+  const client = getClient();
+  const id = crypto6.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const slug = slugify(input.title);
+  const taskFile = input.taskFile ?? `exe/${input.assignedTo}/${slug}.md`;
+  let blockedById = null;
+  const initialStatus = input.blockedBy ? "blocked" : "open";
+  if (input.blockedBy) {
+    const blocker = await resolveTask(client, input.blockedBy);
+    blockedById = String(blocker.id);
+  }
+  let parentTaskId = null;
+  let parentRef = input.parentTaskId;
+  if (!parentRef) {
+    const extracted = extractParentFromContext(input.context);
+    if (extracted) {
+      parentRef = extracted;
+      process.stderr.write(
+        "[create_task] auto-populated parent_task_id from context body \u2014 dispatchers should pass parent_task_id explicitly\n"
+      );
+    }
+  }
+  if (parentRef) {
+    try {
+      const parent = await resolveTask(client, parentRef);
+      parentTaskId = String(parent.id);
+    } catch (err) {
+      if (!input.parentTaskId) {
+        throw new Error(
+          `create_task: parent reference "${parentRef}" in context body does not resolve to an existing task`
+        );
+      }
+      throw err;
+    }
   }
-});
-
-// src/lib/plan-limits.ts
-import { readFileSync as readFileSync8, existsSync as existsSync10 } from "fs";
-import path12 from "path";
-var CACHE_PATH2;
-var init_plan_limits = __esm({
-  "src/lib/plan-limits.ts"() {
-    "use strict";
-    init_database();
-    init_employees();
-    init_license();
-    init_config();
-    CACHE_PATH2 = path12.join(EXE_AI_DIR, "license-cache.json");
+  let warning;
+  const dupCheck = await client.execute({
+    sql: "SELECT id FROM tasks WHERE title = ? AND assigned_to = ? AND status IN ('open', 'in_progress', 'blocked')",
+    args: [input.title, input.assignedTo]
+  });
+  if (dupCheck.rows.length > 0) {
+    warning = `similar active task already exists (${String(dupCheck.rows[0].id)}). Created new task anyway.`;
   }
-});
-
-// src/lib/tmux-routing.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, existsSync as existsSync11, appendFileSync } from "fs";
-import path13 from "path";
-import os6 from "os";
-import { fileURLToPath as fileURLToPath2 } from "url";
-function getParentExe(sessionKey) {
+  if (input.baseDir) {
+    try {
+      await mkdir4(path15.join(input.baseDir, "exe", "output"), { recursive: true });
+      await mkdir4(path15.join(input.baseDir, "exe", "research"), { recursive: true });
+      await ensureArchitectureDoc(input.baseDir, input.projectName);
+      await ensureGitignoreExe(input.baseDir);
+    } catch {
+    }
+  }
+  const complexity = input.complexity ?? "standard";
+  let sessionScope = null;
   try {
-    const data = JSON.parse(readFileSync9(path13.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
-    return data.parentExe || null;
+    const { resolveExeSession: resolveExeSession2 } = await Promise.resolve().then(() => (init_tmux_routing(), tmux_routing_exports));
+    sessionScope = resolveExeSession2();
   } catch {
-    return null;
   }
+  await client.execute({
+    sql: `INSERT INTO tasks (id, title, assigned_to, assigned_by, project_name, priority, status, task_file, blocked_by, parent_task_id, reviewer, context, complexity, budget_tokens, budget_fallback_model, tokens_used, tokens_warned_at, session_scope, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    args: [
+      id,
+      input.title,
+      input.assignedTo,
+      input.assignedBy,
+      input.projectName,
+      input.priority,
+      initialStatus,
+      taskFile,
+      blockedById,
+      parentTaskId,
+      input.reviewer ?? null,
+      input.context,
+      complexity,
+      input.budgetTokens ?? null,
+      input.budgetFallbackModel ?? null,
+      0,
+      null,
+      sessionScope,
+      now,
+      now
+    ]
+  });
+  return {
+    id,
+    title: input.title,
+    assignedTo: input.assignedTo,
+    assignedBy: input.assignedBy,
+    projectName: input.projectName,
+    priority: input.priority,
+    status: initialStatus,
+    taskFile,
+    createdAt: now,
+    updatedAt: now,
+    warning,
+    budgetTokens: input.budgetTokens ?? null,
+    budgetFallbackModel: input.budgetFallbackModel ?? null,
+    tokensUsed: 0,
+    tokensWarnedAt: null
+  };
 }
-function readDebounceState() {
+async function listTasks(input) {
+  const client = getClient();
+  const conditions = [];
+  const args = [];
+  if (input.assignedTo) {
+    conditions.push("assigned_to = ?");
+    args.push(input.assignedTo);
+  }
+  if (input.status) {
+    conditions.push("status = ?");
+    args.push(input.status);
+  } else {
+    conditions.push("status IN ('open', 'in_progress', 'blocked')");
+  }
+  if (input.projectName) {
+    conditions.push("project_name = ?");
+    args.push(input.projectName);
+  }
+  if (input.priority) {
+    conditions.push("priority = ?");
+    args.push(input.priority);
+  }
   try {
-    if (!existsSync11(DEBOUNCE_FILE)) return {};
-    return JSON.parse(readFileSync9(DEBOUNCE_FILE, "utf8"));
+    const { resolveExeSession: resolveExeSession2 } = await Promise.resolve().then(() => (init_tmux_routing(), tmux_routing_exports));
+    const session = resolveExeSession2();
+    if (session) {
+      conditions.push("(session_scope IS NULL OR session_scope = ?)");
+      args.push(session);
+    }
   } catch {
-    return {};
   }
+  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 writeDebounceState(state) {
+function checkStaleCompletion(taskContext, taskCreatedAt) {
+  if (!taskContext) return null;
+  if (!DELEGATION_KEYWORDS.test(taskContext)) return null;
   try {
-    if (!existsSync11(SESSION_CACHE)) mkdirSync4(SESSION_CACHE, { recursive: true });
-    writeFileSync3(DEBOUNCE_FILE, JSON.stringify(state));
+    const since = new Date(taskCreatedAt).toISOString();
+    const branch = execSync6(
+      "git rev-parse --abbrev-ref HEAD 2>/dev/null",
+      { encoding: "utf8", timeout: 3e3 }
+    ).trim();
+    const branchArg = branch && branch !== "HEAD" ? branch : "";
+    const commitCount = execSync6(
+      `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;
   }
 }
-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];
+async function updateTaskStatus(input) {
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const row = await resolveTask(client, input.taskId);
+  const taskId = String(row.id);
+  const taskFile = String(row.task_file);
+  if (input.status === "done" && String(row.assigned_by) === "system" && taskFile.includes("review-")) {
+    process.stderr.write(
+      `[updateTask] Review task "${String(row.title)}" being marked done (assigned to ${String(row.assigned_to)})
+`
+    );
   }
-  writeDebounceState(state);
-}
-function logIntercom(msg) {
-  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
-`;
-  process.stderr.write(`[intercom] ${msg}
+  if (input.status === "done") {
+    const existingRow = await client.execute({
+      sql: "SELECT context, created_at FROM tasks WHERE id = ?",
+      args: [taskId]
+    });
+    if (existingRow.rows.length > 0) {
+      const ctx = existingRow.rows[0];
+      const warning = checkStaleCompletion(ctx.context, ctx.created_at);
+      if (warning) {
+        input.result = input.result ? `\u26A0\uFE0F ${warning}
+
+${input.result}` : `\u26A0\uFE0F ${warning}`;
+        process.stderr.write(`[tasks] ${warning} (task: ${taskId})
 `);
+      }
+    }
+  }
+  if (input.status === "in_progress") {
+    const tmuxSession = process.env.TMUX_PANE ?? process.env.MY_TMUX_SESSION ?? "unknown";
+    const claim = await client.execute({
+      sql: `UPDATE tasks
+            SET status = 'in_progress', assigned_tmux = ?, updated_at = ?
+            WHERE id = ? AND status = 'open'`,
+      args: [tmuxSession, now, taskId]
+    });
+    if (claim.rowsAffected === 0) {
+      const current = await client.execute({
+        sql: "SELECT status, assigned_tmux FROM tasks WHERE id = ?",
+        args: [taskId]
+      });
+      const cur = current.rows[0];
+      const status = cur?.status ?? "unknown";
+      const claimedBy = cur?.assigned_tmux ? ` (claimed by ${cur.assigned_tmux})` : "";
+      throw new Error(`${TASK_ALREADY_CLAIMED_PREFIX}: task ${taskId} is ${status}${claimedBy}`);
+    }
+    try {
+      await writeCheckpoint({
+        taskId,
+        step: "claimed",
+        contextSummary: `Task claimed by session. Transitioning open \u2192 in_progress.`
+      });
+    } catch {
+    }
+    return { row, taskFile, now, taskId };
+  }
+  if (input.result) {
+    await client.execute({
+      sql: "UPDATE tasks SET status = ?, result = ?, updated_at = ? WHERE id = ?",
+      args: [input.status, input.result, now, taskId]
+    });
+  } else {
+    await client.execute({
+      sql: "UPDATE tasks SET status = ?, updated_at = ? WHERE id = ?",
+      args: [input.status, now, taskId]
+    });
+  }
   try {
-    appendFileSync(INTERCOM_LOG2, line);
+    await writeCheckpoint({
+      taskId,
+      step: `status_transition:${input.status}`,
+      contextSummary: input.result ? `Transitioned to ${input.status}. Result: ${input.result.slice(0, 500)}` : `Transitioned to ${input.status}.`
+    });
   } catch {
   }
+  return { row, taskFile, now, taskId };
 }
-function getSessionState(sessionName) {
-  const transport = getTransport();
-  if (!transport.isAlive(sessionName)) return "offline";
+async function deleteTaskCore(taskId, _baseDir) {
+  const client = getClient();
+  const row = await resolveTask(client, taskId);
+  const id = String(row.id);
+  const taskFile = String(row.task_file);
+  const assignedTo = String(row.assigned_to);
+  const assignedBy = String(row.assigned_by);
+  await client.execute({ sql: "DELETE FROM tasks WHERE id = ?", args: [id] });
+  const taskSlug = taskFile.split("/").pop()?.replace(".md", "") ?? "";
+  return { taskFile, assignedTo, assignedBy, taskSlug };
+}
+async function ensureArchitectureDoc(baseDir, projectName) {
+  const archPath = path15.join(baseDir, "exe", "ARCHITECTURE.md");
   try {
-    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";
+    if (existsSync12(archPath)) return;
+    const template = [
+      `# ${projectName} \u2014 System Architecture`,
+      "",
+      "> Employees: read this before every task. Update it when you change system structure.",
+      `> Last updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`,
+      "",
+      "## Overview",
+      "",
+      "<!-- Describe what this system does, its main components, and how they connect. -->",
+      "",
+      "## Key Components",
+      "",
+      "<!-- List the major modules, services, or subsystems. -->",
+      "",
+      "## Data Flow",
+      "",
+      "<!-- How does data move through the system? What writes where? -->",
+      "",
+      "## Invariants",
+      "",
+      "<!-- Rules that must never be violated. What breaks if these are wrong? -->",
+      "",
+      "## Dependencies",
+      "",
+      "<!-- What depends on what? If I change X, what else is affected? -->",
+      ""
+    ].join("\n");
+    await writeFile5(archPath, template, "utf-8");
   } catch {
-    return "offline";
   }
 }
-function isExeSession(sessionName) {
-  return /^exe\d*$/.test(sessionName);
-}
-function sendIntercom(targetSession) {
-  const transport = getTransport();
-  if (isExeSession(targetSession)) {
-    logIntercom(`SKIP_EXE \u2192 ${targetSession} (exe sessions use prompt-submit hook)`);
-    return "skipped_exe";
-  }
-  if (isDebounced(targetSession)) {
-    logIntercom(`DEBOUNCE \u2192 ${targetSession} (cross-process file debounce)`);
-    return "debounced";
-  }
+async function ensureGitignoreExe(baseDir) {
+  const gitignorePath = path15.join(baseDir, ".gitignore");
   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");
+    if (existsSync12(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 writeFile5(gitignorePath, "# Employee task assignments (private)\n/exe/\n", "utf-8");
     }
-    transport.sendKeys(targetSession, "/exe-intercom");
-    recordDebounce(targetSession);
-    logIntercom(`DELIVERED \u2192 ${targetSession} (fire-and-forget)`);
-    return "delivered";
   } catch {
-    logIntercom(`FAIL \u2192 ${targetSession}`);
-    return "failed";
   }
 }
-var SPAWN_LOCK_DIR, SESSION_CACHE, INTERCOM_DEBOUNCE_MS, INTERCOM_LOG2, DEBOUNCE_FILE, DEBOUNCE_CLEANUP_AGE_MS, BUSY_PATTERN;
-var init_tmux_routing = __esm({
-  "src/lib/tmux-routing.ts"() {
+var DELEGATION_KEYWORDS, TASK_ALREADY_CLAIMED_PREFIX;
+var init_tasks_crud = __esm({
+  "src/lib/tasks-crud.ts"() {
     "use strict";
-    init_session_registry();
-    init_session_key();
-    init_transport();
-    init_cc_agent_support();
-    init_mcp_prefix();
-    init_provider_table();
-    init_intercom_queue();
-    init_plan_limits();
-    SPAWN_LOCK_DIR = path13.join(os6.homedir(), ".exe-os", "spawn-locks");
-    SESSION_CACHE = path13.join(os6.homedir(), ".exe-os", "session-cache");
-    INTERCOM_DEBOUNCE_MS = 3e4;
-    INTERCOM_LOG2 = path13.join(os6.homedir(), ".exe-os", "intercom.log");
-    DEBOUNCE_FILE = path13.join(SESSION_CACHE, "intercom-debounce.json");
-    DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
-    BUSY_PATTERN = /[✻✽✶✳·].*…|Running…/;
+    init_database();
+    DELEGATION_KEYWORDS = /parallel|delegate|wave|tom\d*-exe/i;
+    TASK_ALREADY_CLAIMED_PREFIX = "TASK_ALREADY_CLAIMED";
   }
 });
 
@@ -2547,8 +4580,8 @@ __export(tasks_review_exports, {
   getReviewChecklist: () => getReviewChecklist,
   listPendingReviews: () => listPendingReviews
 });
-import path14 from "path";
-import { existsSync as existsSync12, readdirSync as readdirSync3, unlinkSync as unlinkSync3 } from "fs";
+import path16 from "path";
+import { existsSync as existsSync13, readdirSync as readdirSync3, unlinkSync as unlinkSync5 } from "fs";
 async function countPendingReviews() {
   const client = getClient();
   const result = await client.execute({
@@ -2711,6 +4744,13 @@ async function createReviewForCompletedTask(row, result, _baseDir, now) {
     skipDispatch: true
   });
   const reviewId = reviewTask.id;
+  orgBus.emit({
+    type: "review_created",
+    reviewId,
+    employee: agent,
+    reviewer,
+    timestamp: now
+  });
   await writeNotification({
     agentId: agent,
     agentRole: String(row.assigned_to),
@@ -2786,11 +4826,11 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
     );
   }
   try {
-    const cacheDir = path14.join(EXE_AI_DIR, "session-cache");
-    if (existsSync12(cacheDir)) {
+    const cacheDir = path16.join(EXE_AI_DIR, "session-cache");
+    if (existsSync13(cacheDir)) {
       for (const f of readdirSync3(cacheDir)) {
         if (f.startsWith("review-notified-")) {
-          unlinkSync3(path14.join(cacheDir, f));
+          unlinkSync5(path16.join(cacheDir, f));
         }
       }
     }
@@ -2807,6 +4847,7 @@ var init_tasks_review = __esm({
     init_tasks_crud();
     init_tmux_routing();
     init_session_key();
+    init_state_bus();
   }
 });
 
@@ -2821,12 +4862,12 @@ __export(worktree_exports, {
   worktreeBranch: () => worktreeBranch,
   worktreePath: () => worktreePath
 });
-import { execSync as execSync6 } from "child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync10, appendFileSync as appendFileSync2, mkdirSync as mkdirSync5, realpathSync } from "fs";
-import path15 from "path";
+import { execSync as execSync7 } from "child_process";
+import { existsSync as existsSync14, readFileSync as readFileSync11, appendFileSync as appendFileSync2, mkdirSync as mkdirSync7, realpathSync } from "fs";
+import path17 from "path";
 function getGitRoot(dir) {
   try {
-    const root = execSync6("git rev-parse --show-toplevel", {
+    const root = execSync7("git rev-parse --show-toplevel", {
       cwd: dir,
       encoding: "utf-8",
       timeout: GIT_TIMEOUT_MS,
@@ -2839,18 +4880,18 @@ function getGitRoot(dir) {
 }
 function getMainRepoRoot(dir) {
   try {
-    const commonDir = execSync6(
+    const commonDir = execSync7(
       "git rev-parse --path-format=absolute --git-common-dir",
       { cwd: dir, encoding: "utf-8", timeout: GIT_TIMEOUT_MS, stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
-    return realpath(path15.dirname(commonDir));
+    return realpath(path17.dirname(commonDir));
   } catch {
     return null;
   }
 }
 function worktreePath(repoRoot, employeeName, instance) {
   const label = instanceLabel(employeeName, instance);
-  return path15.join(repoRoot, ".worktrees", label);
+  return path17.join(repoRoot, ".worktrees", label);
 }
 function worktreeBranch(employeeName, instance) {
   return `${instanceLabel(employeeName, instance)}-work`;
@@ -2863,14 +4904,14 @@ function ensureWorktree(projectDir, employeeName, instance) {
   if (!repoRoot) return null;
   const wtPath = worktreePath(repoRoot, employeeName, instance);
   const branch = worktreeBranch(employeeName, instance);
-  if (existsSync13(path15.join(wtPath, ".git"))) {
+  if (existsSync14(path17.join(wtPath, ".git"))) {
     return wtPath;
   }
-  const worktreesDir = path15.join(repoRoot, ".worktrees");
-  mkdirSync5(worktreesDir, { recursive: true });
+  const worktreesDir = path17.join(repoRoot, ".worktrees");
+  mkdirSync7(worktreesDir, { recursive: true });
   ensureGitignoreEntry(repoRoot, "/.worktrees/");
   try {
-    execSync6("git worktree prune", {
+    execSync7("git worktree prune", {
       cwd: repoRoot,
       encoding: "utf-8",
       timeout: GIT_TIMEOUT_MS,
@@ -2881,14 +4922,14 @@ function ensureWorktree(projectDir, employeeName, instance) {
   const branchExists = branchExistsLocally(repoRoot, branch);
   try {
     if (branchExists) {
-      execSync6(`git worktree add "${wtPath}" "${branch}"`, {
+      execSync7(`git worktree add "${wtPath}" "${branch}"`, {
         cwd: repoRoot,
         encoding: "utf-8",
         timeout: GIT_TIMEOUT_MS,
         stdio: ["pipe", "pipe", "pipe"]
       });
     } else {
-      execSync6(`git worktree add "${wtPath}" -b "${branch}" HEAD`, {
+      execSync7(`git worktree add "${wtPath}" -b "${branch}" HEAD`, {
         cwd: repoRoot,
         encoding: "utf-8",
         timeout: GIT_TIMEOUT_MS,
@@ -2906,7 +4947,7 @@ function ensureWorktree(projectDir, employeeName, instance) {
 }
 function isWorktreeDirty(wtPath) {
   try {
-    const status = execSync6("git status --porcelain", {
+    const status = execSync7("git status --porcelain", {
       cwd: wtPath,
       encoding: "utf-8",
       timeout: GIT_TIMEOUT_MS,
@@ -2922,7 +4963,7 @@ function cleanupWorktree(projectDir, employeeName, instance) {
   if (!repoRoot) return { cleaned: false, reason: "not a git repo" };
   const wtPath = worktreePath(repoRoot, employeeName, instance);
   const branch = worktreeBranch(employeeName, instance);
-  if (!existsSync13(wtPath)) {
+  if (!existsSync14(wtPath)) {
     return { cleaned: false, reason: "worktree does not exist" };
   }
   if (isWorktreeDirty(wtPath)) {
@@ -2936,7 +4977,7 @@ function cleanupWorktree(projectDir, employeeName, instance) {
     return { cleaned: false, reason: `branch ${branch} not merged into ${mainBranch}` };
   }
   try {
-    execSync6(`git worktree remove "${wtPath}"`, {
+    execSync7(`git worktree remove "${wtPath}"`, {
       cwd: repoRoot,
       encoding: "utf-8",
       timeout: GIT_TIMEOUT_MS,
@@ -2949,7 +4990,7 @@ function cleanupWorktree(projectDir, employeeName, instance) {
     };
   }
   try {
-    execSync6(`git branch -d "${branch}"`, {
+    execSync7(`git branch -d "${branch}"`, {
       cwd: repoRoot,
       encoding: "utf-8",
       timeout: GIT_TIMEOUT_MS,
@@ -2961,7 +5002,7 @@ function cleanupWorktree(projectDir, employeeName, instance) {
 }
 function branchExistsLocally(repoRoot, branch) {
   try {
-    execSync6(`git rev-parse --verify "refs/heads/${branch}"`, {
+    execSync7(`git rev-parse --verify "refs/heads/${branch}"`, {
       cwd: repoRoot,
       encoding: "utf-8",
       timeout: GIT_TIMEOUT_MS,
@@ -2980,7 +5021,7 @@ function detectMainBranch(repoRoot) {
 }
 function isBranchMerged(repoRoot, branch, into) {
   try {
-    const merged = execSync6(`git branch --merged "${into}"`, {
+    const merged = execSync7(`git branch --merged "${into}"`, {
       cwd: repoRoot,
       encoding: "utf-8",
       timeout: GIT_TIMEOUT_MS,
@@ -3000,9 +5041,9 @@ function realpath(p) {
 }
 function ensureGitignoreEntry(repoRoot, entry) {
   try {
-    const gitignorePath = path15.join(repoRoot, ".gitignore");
-    if (existsSync13(gitignorePath)) {
-      const content = readFileSync10(gitignorePath, "utf-8");
+    const gitignorePath = path17.join(repoRoot, ".gitignore");
+    if (existsSync14(gitignorePath)) {
+      const content = readFileSync11(gitignorePath, "utf-8");
       if (content.includes(entry)) return;
       appendFileSync2(gitignorePath, `
 # Agent worktrees (exe-os)
@@ -3022,8 +5063,8 @@ var init_worktree = __esm({
 });
 
 // src/bin/exe-session-cleanup.ts
-import crypto4 from "crypto";
-import { execSync as execSync7 } from "child_process";
+import crypto7 from "crypto";
+import { execSync as execSync8 } from "child_process";
 
 // src/lib/store.ts
 init_memory();
@@ -3075,6 +5116,7 @@ async function getMasterKey() {
 
 // src/lib/store.ts
 init_config();
+init_state_bus();
 var INIT_MAX_RETRIES = 3;
 var INIT_RETRY_DELAY_MS = 1e3;
 function isBusyError2(err) {
@@ -3145,6 +5187,11 @@ async function initStore(options) {
     "version-query"
   );
   _nextVersion = (Number(vResult.rows[0]?.max_v) || 0) + 1;
+  try {
+    const { loadGlobalProcedures: loadGlobalProcedures2 } = await Promise.resolve().then(() => (init_global_procedures(), global_procedures_exports));
+    await loadGlobalProcedures2();
+  } catch {
+  }
 }
 function classifyTier(record) {
   if (record.tool_name === "commit_to_long_term_memory" && (record.importance ?? 0) >= 8) return 1;
@@ -3186,6 +5233,12 @@ async function writeMemory(record) {
     supersedes_id: record.supersedes_id ?? null
   };
   _pendingRecords.push(dbRow);
+  orgBus.emit({
+    type: "memory_stored",
+    agentId: record.agent_id,
+    project: record.project_name,
+    timestamp: record.timestamp
+  });
   const MAX_PENDING = 1e3;
   if (_pendingRecords.length > MAX_PENDING) {
     const dropped = _pendingRecords.length - MAX_PENDING;
@@ -3395,7 +5448,7 @@ try {
       } catch {
       }
       await writeMemory({
-        id: crypto4.randomUUID(),
+        id: crypto7.randomUUID(),
         agent_id: agentName,
         agent_role: "employee",
         session_id: `cleanup-${Date.now()}`,
@@ -3477,7 +5530,7 @@ try {
     const taskList = result.rows.map((r) => `"${String(r.title)}"`).join(", ");
     const msg = `session-ended: ${agentName} session terminated unexpectedly. ${count} task(s) marked blocked: ${taskList}`;
     try {
-      execSync7(`tmux send-keys -t ${JSON.stringify(exeSession)} ${JSON.stringify(msg)} Enter`, {
+      execSync8(`tmux send-keys -t ${JSON.stringify(exeSession)} ${JSON.stringify(msg)} Enter`, {
         timeout: 3e3
       });
     } catch {