@askexenow/exe-os 0.8.80 → 0.8.82

package/dist/bin/setup.js

@@ -20,7 +20,6 @@ var config_exports = {};
 __export(config_exports, {
   CONFIG_MIGRATIONS: () => CONFIG_MIGRATIONS,
   CONFIG_PATH: () => CONFIG_PATH,
-  COO_AGENT_NAME: () => COO_AGENT_NAME,
   CURRENT_CONFIG_VERSION: () => CURRENT_CONFIG_VERSION,
   DB_PATH: () => DB_PATH,
   EXE_AI_DIR: () => EXE_AI_DIR,
@@ -176,7 +175,7 @@ async function loadConfigFrom(configPath) {
     return { ...DEFAULT_CONFIG };
   }
 }
-var EXE_AI_DIR, DB_PATH, MODELS_DIR, CONFIG_PATH, COO_AGENT_NAME, LEGACY_LANCE_PATH, CURRENT_CONFIG_VERSION, DEFAULT_CONFIG, CONFIG_MIGRATIONS;
+var EXE_AI_DIR, DB_PATH, MODELS_DIR, CONFIG_PATH, LEGACY_LANCE_PATH, CURRENT_CONFIG_VERSION, DEFAULT_CONFIG, CONFIG_MIGRATIONS;
 var init_config = __esm({
   "src/lib/config.ts"() {
     "use strict";
@@ -184,7 +183,6 @@ var init_config = __esm({
     DB_PATH = path.join(EXE_AI_DIR, "memories.db");
     MODELS_DIR = path.join(EXE_AI_DIR, "models");
     CONFIG_PATH = path.join(EXE_AI_DIR, "config.json");
-    COO_AGENT_NAME = "exe";
     LEGACY_LANCE_PATH = path.join(EXE_AI_DIR, "local.lance");
     CURRENT_CONFIG_VERSION = 1;
     DEFAULT_CONFIG = {
@@ -220,13 +218,7 @@ var init_config = __esm({
       wikiUrl: "",
       wikiApiKey: "",
       wikiSyncIntervalMs: 30 * 60 * 1e3,
-      wikiWorkspaceMapping: {
-        exe: "Executive",
-        yoshi: "Engineering",
-        mari: "Marketing",
-        tom: "Engineering",
-        sasha: "Production"
-      },
+      wikiWorkspaceMapping: {},
       wikiAutoUpdate: true,
       wikiAutoUpdateThreshold: 0.5,
       wikiAutoUpdateCreateNew: true,
@@ -475,6 +467,10 @@ function spawnDaemon() {
     stdio: ["ignore", "ignore", stderrFd],
     env: {
       ...process.env,
+      TMUX: void 0,
+      // Daemon is global — must not inherit session scope
+      TMUX_PANE: void 0,
+      // Prevents resolveExeSession() from scoping to one session
       EXE_DAEMON_SOCK: SOCKET_PATH,
       EXE_DAEMON_PID: PID_PATH
     }
@@ -568,11 +564,11 @@ async function connectEmbedDaemon() {
     }
   }
   const start = Date.now();
-  let delay = 100;
+  let delay2 = 100;
   while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-    await new Promise((r) => setTimeout(r, delay));
+    await new Promise((r) => setTimeout(r, delay2));
     if (await connectToSocket()) return true;
-    delay = Math.min(delay * 2, 3e3);
+    delay2 = Math.min(delay2 * 2, 3e3);
   }
   return false;
 }
@@ -664,11 +660,11 @@ async function embedViaClient(text, priority = "high") {
 `);
       killAndRespawnDaemon();
       const start = Date.now();
-      let delay = 200;
+      let delay2 = 200;
       while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-        await new Promise((r) => setTimeout(r, delay));
+        await new Promise((r) => setTimeout(r, delay2));
         if (await connectToSocket()) break;
-        delay = Math.min(delay * 2, 3e3);
+        delay2 = Math.min(delay2 * 2, 3e3);
       }
       if (!_connected) return null;
     }
@@ -680,11 +676,11 @@ async function embedViaClient(text, priority = "high") {
 `);
     killAndRespawnDaemon();
     const start = Date.now();
-    let delay = 200;
+    let delay2 = 200;
     while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-      await new Promise((r) => setTimeout(r, delay));
+      await new Promise((r) => setTimeout(r, delay2));
       if (await connectToSocket()) break;
-      delay = Math.min(delay * 2, 3e3);
+      delay2 = Math.min(delay2 * 2, 3e3);
     }
     if (!_connected) return null;
     const retry = await sendRequest([text], priority);
@@ -1243,61 +1239,80 @@ var init_crypto = __esm({
 });
 
 // src/lib/db-retry.ts
-var init_db_retry = __esm({
-  "src/lib/db-retry.ts"() {
-    "use strict";
-  }
-});
-
-// src/lib/database.ts
-import { createClient } from "@libsql/client";
-function getClient() {
-  if (!_resilientClient) {
-    throw new Error("Database client not initialized. Call initDatabase() first.");
+function isBusyError(err) {
+  if (err instanceof Error) {
+    const msg = err.message.toLowerCase();
+    return msg.includes("sqlite_busy") || msg.includes("database is locked");
   }
-  return _resilientClient;
+  return false;
 }
-var _resilientClient;
-var init_database = __esm({
-  "src/lib/database.ts"() {
-    "use strict";
-    init_db_retry();
-    _resilientClient = null;
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retryOnBusy(fn, label) {
+  let lastError;
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (!isBusyError(err) || attempt === MAX_RETRIES) {
+        throw err;
+      }
+      const backoff = BASE_DELAY_MS * Math.pow(2, attempt);
+      const jitter = Math.floor(Math.random() * MAX_JITTER_MS);
+      process.stderr.write(
+        `[exe-os] SQLITE_BUSY ${label} retry ${attempt + 1}/${MAX_RETRIES} \u2014 waiting ${backoff + jitter}ms
+`
+      );
+      await delay(backoff + jitter);
+    }
   }
-});
-
-// src/lib/compress.ts
-import { brotliCompressSync, brotliDecompressSync, constants } from "zlib";
-function compress(input) {
-  if (input.length === 0) return Buffer.alloc(0);
-  return brotliCompressSync(input, {
-    params: {
-      [constants.BROTLI_PARAM_QUALITY]: 4
+  throw lastError;
+}
+function wrapWithRetry(client) {
+  return new Proxy(client, {
+    get(target, prop, receiver) {
+      if (prop === "execute") {
+        return (sql) => retryOnBusy(() => target.execute(sql), "execute");
+      }
+      if (prop === "batch") {
+        return (stmts, mode) => retryOnBusy(() => target.batch(stmts, mode), "batch");
+      }
+      return Reflect.get(target, prop, receiver);
     }
   });
 }
-function decompress(input) {
-  if (input.length === 0) return Buffer.alloc(0);
-  return brotliDecompressSync(input);
-}
-var init_compress = __esm({
-  "src/lib/compress.ts"() {
+var MAX_RETRIES, BASE_DELAY_MS, MAX_JITTER_MS;
+var init_db_retry = __esm({
+  "src/lib/db-retry.ts"() {
     "use strict";
+    MAX_RETRIES = 3;
+    BASE_DELAY_MS = 200;
+    MAX_JITTER_MS = 300;
   }
 });
 
 // src/lib/employees.ts
 var employees_exports = {};
 __export(employees_exports, {
+  COORDINATOR_ROLE: () => COORDINATOR_ROLE,
+  DEFAULT_COORDINATOR_TEMPLATE_NAME: () => DEFAULT_COORDINATOR_TEMPLATE_NAME,
   EMPLOYEES_PATH: () => EMPLOYEES_PATH,
   addEmployee: () => addEmployee,
+  canCoordinate: () => canCoordinate,
+  getCoordinatorEmployee: () => getCoordinatorEmployee,
+  getCoordinatorName: () => getCoordinatorName,
   getEmployee: () => getEmployee,
   getEmployeeByRole: () => getEmployeeByRole,
   getEmployeeNamesByRole: () => getEmployeeNamesByRole,
   hasRole: () => hasRole,
+  isCoordinatorName: () => isCoordinatorName,
+  isCoordinatorRole: () => isCoordinatorRole,
   isMultiInstance: () => isMultiInstance,
   loadEmployees: () => loadEmployees,
   loadEmployeesSync: () => loadEmployeesSync,
+  normalizeRole: () => normalizeRole,
   normalizeRosterCase: () => normalizeRosterCase,
   registerBinSymlinks: () => registerBinSymlinks,
   saveEmployees: () => saveEmployees,
@@ -1308,6 +1323,25 @@ import { existsSync as existsSync6, symlinkSync, readlinkSync, readFileSync as r
 import { execSync } from "child_process";
 import path6 from "path";
 import os3 from "os";
+function normalizeRole(role) {
+  return (role ?? "").trim().toLowerCase();
+}
+function isCoordinatorRole(role) {
+  return normalizeRole(role) === normalizeRole(COORDINATOR_ROLE);
+}
+function getCoordinatorEmployee(employees) {
+  return employees.find((e) => isCoordinatorRole(e.role));
+}
+function getCoordinatorName(employees = loadEmployeesSync()) {
+  return getCoordinatorEmployee(employees)?.name ?? DEFAULT_COORDINATOR_TEMPLATE_NAME;
+}
+function isCoordinatorName(agentName, employees = loadEmployeesSync()) {
+  if (!agentName) return false;
+  return agentName.toLowerCase() === getCoordinatorName(employees).toLowerCase();
+}
+function canCoordinate(agentName, agentRole, employees = loadEmployeesSync()) {
+  return agentName === "default" || isCoordinatorRole(agentRole) || isCoordinatorName(agentName, employees);
+}
 function validateEmployeeName(name) {
   if (!name) {
     return { valid: false, error: "Name is required" };
@@ -1445,16 +1479,948 @@ function registerBinSymlinks(name) {
   }
   return { created, skipped, errors };
 }
-var EMPLOYEES_PATH, MULTI_INSTANCE_ROLES;
+var EMPLOYEES_PATH, DEFAULT_COORDINATOR_TEMPLATE_NAME, COORDINATOR_ROLE, 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");
+    DEFAULT_COORDINATOR_TEMPLATE_NAME = "exe";
+    COORDINATOR_ROLE = "COO";
     MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["principal engineer", "content production specialist", "staff code reviewer"]);
   }
 });
 
+// src/lib/database.ts
+var database_exports = {};
+__export(database_exports, {
+  disposeDatabase: () => disposeDatabase,
+  disposeTurso: () => disposeTurso,
+  ensureSchema: () => ensureSchema,
+  getClient: () => getClient,
+  getRawClient: () => getRawClient,
+  initDatabase: () => initDatabase,
+  initTurso: () => initTurso,
+  isInitialized: () => isInitialized
+});
+import { createClient } from "@libsql/client";
+async function initDatabase(config) {
+  if (_client) {
+    _client.close();
+    _client = null;
+    _resilientClient = null;
+  }
+  const opts = {
+    url: `file:${config.dbPath}`
+  };
+  if (config.encryptionKey) {
+    opts.encryptionKey = config.encryptionKey;
+  }
+  _client = createClient(opts);
+  _resilientClient = wrapWithRetry(_client);
+}
+function isInitialized() {
+  return _client !== null;
+}
+function getClient() {
+  if (!_resilientClient) {
+    throw new Error("Database client not initialized. Call initDatabase() first.");
+  }
+  return _resilientClient;
+}
+function getRawClient() {
+  if (!_client) {
+    throw new Error("Database client not initialized. Call initDatabase() first.");
+  }
+  return _client;
+}
+async function ensureSchema() {
+  const client = getRawClient();
+  await client.execute("PRAGMA journal_mode = WAL");
+  await client.execute("PRAGMA busy_timeout = 30000");
+  await client.execute("PRAGMA wal_autocheckpoint = 1000");
+  try {
+    await client.execute("PRAGMA libsql_vector_search_ef = 128");
+  } catch {
+  }
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS memories (
+      id            TEXT PRIMARY KEY,
+      agent_id      TEXT NOT NULL,
+      agent_role    TEXT NOT NULL,
+      session_id    TEXT NOT NULL,
+      timestamp     TEXT NOT NULL,
+      tool_name     TEXT NOT NULL,
+      project_name  TEXT NOT NULL,
+      has_error     INTEGER NOT NULL DEFAULT 0,
+      raw_text      TEXT NOT NULL,
+      vector        F32_BLOB(1024),
+      version       INTEGER NOT NULL DEFAULT 0
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memories_agent
+      ON memories(agent_id);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_timestamp
+      ON memories(timestamp);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_session
+      ON memories(session_id);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_project
+      ON memories(project_name);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_tool
+      ON memories(tool_name);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_version
+      ON memories(version);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_agent_project
+      ON memories(agent_id, project_name);
+  `);
+  await client.executeMultiple(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+      raw_text,
+      content='memories',
+      content_rowid='rowid'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS memories_fts_ai AFTER INSERT ON memories BEGIN
+      INSERT INTO memories_fts(rowid, raw_text) VALUES (new.rowid, new.raw_text);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memories_fts_ad AFTER DELETE ON memories BEGIN
+      INSERT INTO memories_fts(memories_fts, rowid, raw_text) VALUES('delete', old.rowid, old.raw_text);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memories_fts_au AFTER UPDATE ON memories BEGIN
+      INSERT INTO memories_fts(memories_fts, rowid, raw_text) VALUES('delete', old.rowid, old.raw_text);
+      INSERT INTO memories_fts(rowid, raw_text) VALUES (new.rowid, new.raw_text);
+    END;
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS sync_meta (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS tasks (
+      id            TEXT PRIMARY KEY,
+      title         TEXT NOT NULL,
+      assigned_to   TEXT NOT NULL,
+      assigned_by   TEXT NOT NULL,
+      project_name  TEXT NOT NULL,
+      priority      TEXT NOT NULL DEFAULT 'p1',
+      status        TEXT NOT NULL DEFAULT 'open',
+      task_file     TEXT,
+      created_at    TEXT NOT NULL,
+      updated_at    TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_tasks_assignee_status
+      ON tasks(assigned_to, status);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS behaviors (
+      id           TEXT PRIMARY KEY,
+      agent_id     TEXT NOT NULL,
+      project_name TEXT,
+      domain       TEXT,
+      content      TEXT NOT NULL,
+      active       INTEGER NOT NULL DEFAULT 1,
+      created_at   TEXT NOT NULL,
+      updated_at   TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_behaviors_agent
+      ON behaviors(agent_id, active);
+  `);
+  try {
+    const coordinatorName = getCoordinatorName();
+    const existing = await client.execute({
+      sql: "SELECT COUNT(*) as cnt FROM behaviors WHERE agent_id = ?",
+      args: [coordinatorName]
+    });
+    if (Number(existing.rows[0]?.cnt) === 0) {
+      const seededAt = "2026-03-25T00:00:00Z";
+      for (const [domain, content] of [
+        ["workflow", `Don't ask "keep going?" \u2014 just keep executing phases/plans autonomously`],
+        ["tool-use", "Always use create_task MCP tool, never write .md files directly for task creation"],
+        ["workflow", "Auto-start reviewing when idle and reviews are pending \u2014 never ask founder for permission"]
+      ]) {
+        await client.execute({
+          sql: `INSERT INTO behaviors (id, agent_id, project_name, domain, content, active, created_at, updated_at)
+                VALUES (hex(randomblob(16)), ?, NULL, ?, ?, 1, ?, ?)`,
+          args: [coordinatorName, domain, content, seededAt, seededAt]
+        });
+      }
+    }
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE behaviors ADD COLUMN priority TEXT DEFAULT 'p1'`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN blocked_by TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN parent_task_id TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `CREATE INDEX IF NOT EXISTS idx_tasks_parent_task_id
+              ON tasks(parent_task_id)
+              WHERE parent_task_id IS NOT NULL`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `UPDATE tasks SET status = 'done' WHERE status = 'completed'`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN reviewer TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN context TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN result TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN assigned_tmux TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN checkpoint TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN checkpoint_count INTEGER NOT NULL DEFAULT 0`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN complexity TEXT NOT NULL DEFAULT 'standard'`,
+      args: []
+    });
+  } 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`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN consolidated INTEGER NOT NULL DEFAULT 0`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN author_device_id TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN scope TEXT NOT NULL DEFAULT 'business'`,
+      args: []
+    });
+  } catch {
+  }
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS consolidations (
+      id                    TEXT PRIMARY KEY,
+      consolidated_memory_id TEXT NOT NULL,
+      source_memory_id      TEXT NOT NULL,
+      created_at            TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_consolidations_source
+      ON consolidations(source_memory_id);
+
+    CREATE INDEX IF NOT EXISTS idx_consolidations_consolidated
+      ON consolidations(consolidated_memory_id);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS reminders (
+      id            TEXT PRIMARY KEY,
+      text          TEXT NOT NULL,
+      created_at    TEXT NOT NULL,
+      due_date      TEXT,
+      completed_at  TEXT
+    );
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS notifications (
+      id          TEXT PRIMARY KEY,
+      agent_id    TEXT NOT NULL,
+      agent_role  TEXT NOT NULL,
+      event       TEXT NOT NULL,
+      project     TEXT NOT NULL,
+      summary     TEXT NOT NULL,
+      task_file   TEXT,
+      read        INTEGER NOT NULL DEFAULT 0,
+      created_at  TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_notifications_read
+      ON notifications(read);
+
+    CREATE INDEX IF NOT EXISTS idx_notifications_agent
+      ON notifications(agent_id);
+
+    CREATE INDEX IF NOT EXISTS idx_notifications_task_file
+      ON notifications(task_file);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS schedules (
+      id            TEXT PRIMARY KEY,
+      cron          TEXT NOT NULL,
+      description   TEXT NOT NULL,
+      job_type      TEXT NOT NULL DEFAULT 'report',
+      prompt        TEXT,
+      assigned_to   TEXT,
+      project_name  TEXT,
+      active        INTEGER NOT NULL DEFAULT 1,
+      use_crontab   INTEGER NOT NULL DEFAULT 0,
+      created_at    TEXT NOT NULL
+    );
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS device_registry (
+      device_id     TEXT PRIMARY KEY,
+      friendly_name TEXT NOT NULL,
+      hostname      TEXT NOT NULL,
+      projects      TEXT NOT NULL DEFAULT '[]',
+      agents        TEXT NOT NULL DEFAULT '[]',
+      connected     INTEGER DEFAULT 0,
+      last_seen     TEXT NOT NULL
+    );
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS messages (
+      id              TEXT PRIMARY KEY,
+      from_agent      TEXT NOT NULL,
+      from_device     TEXT NOT NULL DEFAULT 'local',
+      target_agent    TEXT NOT NULL,
+      target_project  TEXT,
+      target_device   TEXT NOT NULL DEFAULT 'local',
+      content         TEXT NOT NULL,
+      priority        TEXT DEFAULT 'normal',
+      status          TEXT DEFAULT 'pending',
+      server_seq      INTEGER,
+      retry_count     INTEGER DEFAULT 0,
+      created_at      TEXT NOT NULL,
+      delivered_at    TEXT,
+      processed_at    TEXT,
+      failed_at       TEXT,
+      failure_reason  TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_messages_target
+      ON messages(target_agent, status);
+
+    CREATE INDEX IF NOT EXISTS idx_messages_conversation_order
+      ON messages(target_agent, from_agent, server_seq);
+  `);
+  try {
+    await client.execute({
+      sql: `UPDATE memories SET project_name = 'exe-create' WHERE project_name = 'web'`,
+      args: []
+    });
+    await client.execute({
+      sql: `UPDATE memories SET project_name = 'exe-os' WHERE project_name = 'worker'`,
+      args: []
+    });
+    await client.execute({
+      sql: `UPDATE tasks SET project_name = 'exe-create' WHERE project_name = 'web'`,
+      args: []
+    });
+    await client.execute({
+      sql: `UPDATE tasks SET project_name = 'exe-os' WHERE project_name = 'worker'`,
+      args: []
+    });
+  } catch {
+  }
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS trajectories (
+      id              TEXT PRIMARY KEY,
+      task_id         TEXT NOT NULL,
+      agent_id        TEXT NOT NULL,
+      project_name    TEXT NOT NULL,
+      task_title      TEXT NOT NULL,
+      signature       TEXT NOT NULL,
+      signature_hash  TEXT NOT NULL,
+      tool_count      INTEGER NOT NULL,
+      skill_id        TEXT,
+      created_at      TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_trajectories_hash
+      ON trajectories(signature_hash);
+
+    CREATE INDEX IF NOT EXISTS idx_trajectories_agent
+      ON trajectories(agent_id);
+  `);
+  try {
+    await client.execute("ALTER TABLE trajectories ADD COLUMN skill_id TEXT");
+  } catch {
+  }
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS consolidations (
+      id                    TEXT PRIMARY KEY,
+      consolidated_memory_id TEXT NOT NULL,
+      source_memory_id      TEXT NOT NULL,
+      created_at            TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_consolidations_source
+      ON consolidations(source_memory_id);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS audit_trail (
+      id                  INTEGER PRIMARY KEY AUTOINCREMENT,
+      timestamp           TEXT NOT NULL,
+      session_id          TEXT NOT NULL,
+      agent_id            TEXT NOT NULL,
+      tool                TEXT NOT NULL,
+      input               TEXT,
+      decision            TEXT NOT NULL,
+      reason              TEXT,
+      is_customer_facing  INTEGER NOT NULL DEFAULT 0
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_audit_trail_agent
+      ON audit_trail(agent_id, timestamp);
+
+    CREATE INDEX IF NOT EXISTS idx_audit_trail_session
+      ON audit_trail(session_id);
+  `);
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN consolidated INTEGER NOT NULL DEFAULT 0`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN importance INTEGER DEFAULT 5`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN status TEXT DEFAULT 'active'`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN confidence REAL DEFAULT 0.7`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN last_accessed TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `UPDATE memories SET last_accessed = timestamp WHERE last_accessed IS NULL`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN wiki_synced INTEGER DEFAULT 0`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN graph_extracted INTEGER DEFAULT 0`,
+      args: []
+    });
+  } catch {
+  }
+  for (const col of [
+    "ALTER TABLE memories ADD COLUMN content_hash TEXT",
+    "ALTER TABLE memories ADD COLUMN graph_extracted_hash TEXT"
+  ]) {
+    try {
+      await client.execute(col);
+    } catch {
+    }
+  }
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS entities (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      type TEXT NOT NULL,
+      first_seen TEXT NOT NULL,
+      last_seen TEXT NOT NULL,
+      properties TEXT DEFAULT '{}',
+      UNIQUE(name, type)
+    );
+
+    CREATE TABLE IF NOT EXISTS relationships (
+      id TEXT PRIMARY KEY,
+      source_entity_id TEXT NOT NULL,
+      target_entity_id TEXT NOT NULL,
+      type TEXT NOT NULL,
+      weight REAL DEFAULT 1.0,
+      timestamp TEXT NOT NULL,
+      properties TEXT DEFAULT '{}',
+      UNIQUE(source_entity_id, target_entity_id, type)
+    );
+
+    CREATE TABLE IF NOT EXISTS entity_memories (
+      entity_id TEXT NOT NULL,
+      memory_id TEXT NOT NULL,
+      PRIMARY KEY (entity_id, memory_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS relationship_memories (
+      relationship_id TEXT NOT NULL,
+      memory_id TEXT NOT NULL,
+      PRIMARY KEY (relationship_id, memory_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_entities_name ON entities(name);
+    CREATE INDEX IF NOT EXISTS idx_entities_type ON entities(type);
+    CREATE INDEX IF NOT EXISTS idx_relationships_source ON relationships(source_entity_id);
+    CREATE INDEX IF NOT EXISTS idx_relationships_target ON relationships(target_entity_id);
+
+    CREATE TABLE IF NOT EXISTS hyperedges (
+      id TEXT PRIMARY KEY,
+      label TEXT NOT NULL,
+      relation TEXT NOT NULL,
+      confidence REAL DEFAULT 1.0,
+      timestamp TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS hyperedge_nodes (
+      hyperedge_id TEXT NOT NULL,
+      entity_id TEXT NOT NULL,
+      PRIMARY KEY (hyperedge_id, entity_id)
+    );
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS entity_aliases (
+      alias TEXT NOT NULL PRIMARY KEY,
+      canonical_entity_id TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_entity_aliases_canonical ON entity_aliases(canonical_entity_id);
+  `);
+  for (const col of [
+    "ALTER TABLE relationships ADD COLUMN confidence REAL DEFAULT 1.0",
+    "ALTER TABLE relationships ADD COLUMN confidence_label TEXT DEFAULT 'extracted'"
+  ]) {
+    try {
+      await client.execute(col);
+    } catch {
+    }
+  }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status)`
+    );
+  } catch {
+  }
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS identity (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      agent_id    TEXT NOT NULL UNIQUE,
+      content_hash TEXT NOT NULL,
+      updated_at  TEXT NOT NULL,
+      updated_by  TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_identity_agent ON identity(agent_id);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS chat_history (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id  TEXT NOT NULL,
+      role        TEXT NOT NULL,
+      content     TEXT NOT NULL,
+      tool_name   TEXT,
+      tool_id     TEXT,
+      is_error    INTEGER NOT NULL DEFAULT 0,
+      timestamp   INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_chat_history_session
+      ON chat_history(session_id, id);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS workspaces (
+      id              TEXT PRIMARY KEY,
+      slug            TEXT NOT NULL UNIQUE,
+      name            TEXT NOT NULL,
+      owner_agent_id  TEXT,
+      created_at      TEXT NOT NULL,
+      metadata        TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_workspaces_slug
+      ON workspaces(slug);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS documents (
+      id            TEXT PRIMARY KEY,
+      workspace_id  TEXT NOT NULL,
+      filename      TEXT NOT NULL,
+      mime          TEXT,
+      source_type   TEXT,
+      user_id       TEXT,
+      uploaded_at   TEXT NOT NULL,
+      metadata      TEXT,
+      FOREIGN KEY (workspace_id) REFERENCES workspaces(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_documents_workspace
+      ON documents(workspace_id);
+
+    CREATE INDEX IF NOT EXISTS idx_documents_user
+      ON documents(user_id);
+  `);
+  for (const column of [
+    "workspace_id TEXT",
+    "document_id TEXT",
+    "user_id TEXT",
+    "char_offset INTEGER",
+    "page_number INTEGER"
+  ]) {
+    try {
+      await client.execute({
+        sql: `ALTER TABLE memories ADD COLUMN ${column}`,
+        args: []
+      });
+    } catch {
+    }
+  }
+  for (const col of [
+    "ALTER TABLE memories ADD COLUMN source_path TEXT",
+    "ALTER TABLE memories ADD COLUMN source_type TEXT DEFAULT 'text'"
+  ]) {
+    try {
+      await client.execute(col);
+    } catch {
+    }
+  }
+  await client.executeMultiple(`
+    CREATE INDEX IF NOT EXISTS idx_memories_workspace
+      ON memories(workspace_id);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_document
+      ON memories(document_id);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_user
+      ON memories(user_id);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS session_kills (
+      id                      TEXT PRIMARY KEY,
+      session_name            TEXT NOT NULL,
+      agent_id                TEXT NOT NULL,
+      killed_at               TIMESTAMP NOT NULL,
+      reason                  TEXT NOT NULL,
+      ticks_idle              INTEGER,
+      estimated_tokens_saved  INTEGER
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_session_kills_killed_at
+      ON session_kills(killed_at);
+
+    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,
+      platform        TEXT NOT NULL,
+      external_id     TEXT,
+      sender_id       TEXT NOT NULL,
+      sender_name     TEXT,
+      sender_phone    TEXT,
+      sender_email    TEXT,
+      recipient_id    TEXT,
+      channel_id      TEXT NOT NULL,
+      thread_id       TEXT,
+      reply_to_id     TEXT,
+      content_text    TEXT,
+      content_media   TEXT,
+      content_metadata TEXT,
+      agent_response  TEXT,
+      agent_name      TEXT,
+      timestamp       TEXT NOT NULL,
+      ingested_at     TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_conversations_platform
+      ON conversations(platform);
+
+    CREATE INDEX IF NOT EXISTS idx_conversations_sender
+      ON conversations(sender_id);
+
+    CREATE INDEX IF NOT EXISTS idx_conversations_timestamp
+      ON conversations(timestamp);
+
+    CREATE INDEX IF NOT EXISTS idx_conversations_thread
+      ON conversations(thread_id);
+
+    CREATE INDEX IF NOT EXISTS idx_conversations_channel
+      ON conversations(channel_id);
+  `);
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN budget_tokens INTEGER`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN budget_fallback_model TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN tokens_used INTEGER DEFAULT 0`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN tokens_warned_at INTEGER`,
+      args: []
+    });
+  } catch {
+  }
+  await client.executeMultiple(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS conversations_fts USING fts5(
+      content_text,
+      sender_name,
+      agent_response,
+      content='conversations',
+      content_rowid='rowid'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS conversations_fts_ai AFTER INSERT ON conversations BEGIN
+      INSERT INTO conversations_fts(rowid, content_text, sender_name, agent_response)
+      VALUES (new.rowid, new.content_text, new.sender_name, new.agent_response);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS conversations_fts_ad AFTER DELETE ON conversations BEGIN
+      INSERT INTO conversations_fts(conversations_fts, rowid, content_text, sender_name, agent_response)
+      VALUES('delete', old.rowid, old.content_text, old.sender_name, old.agent_response);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS conversations_fts_au AFTER UPDATE ON conversations BEGIN
+      INSERT INTO conversations_fts(conversations_fts, rowid, content_text, sender_name, agent_response)
+      VALUES('delete', old.rowid, old.content_text, old.sender_name, old.agent_response);
+      INSERT INTO conversations_fts(rowid, content_text, sender_name, agent_response)
+      VALUES (new.rowid, new.content_text, new.sender_name, new.agent_response);
+    END;
+  `);
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN tier INTEGER DEFAULT 3`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_tier ON memories(tier)`
+    );
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `UPDATE memories SET tier = 1 WHERE tool_name = 'commit_to_long_term_memory' AND importance >= 8 AND tier = 3`,
+      args: []
+    });
+    await client.execute({
+      sql: `UPDATE memories SET tier = 2 WHERE tool_name IN ('store_memory', 'manual') AND importance >= 5 AND tier = 3`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN supersedes_id TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_supersedes ON memories(supersedes_id) WHERE supersedes_id IS NOT NULL`
+    );
+  } catch {
+  }
+  for (const col of [
+    "ALTER TABLE tasks ADD COLUMN checkpoint TEXT",
+    "ALTER TABLE tasks ADD COLUMN checkpoint_count INTEGER DEFAULT 0"
+  ]) {
+    try {
+      await client.execute(col);
+    } catch {
+    }
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN draft INTEGER DEFAULT 0`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_draft ON memories(draft) WHERE draft = 1`
+    );
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN memory_type TEXT DEFAULT 'raw'`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(memory_type)`
+    );
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN trajectory TEXT`,
+      args: []
+    });
+  } catch {
+  }
+}
+async function disposeDatabase() {
+  if (_client) {
+    _client.close();
+    _client = null;
+    _resilientClient = null;
+  }
+}
+var _client, _resilientClient, initTurso, disposeTurso;
+var init_database = __esm({
+  "src/lib/database.ts"() {
+    "use strict";
+    init_db_retry();
+    init_employees();
+    _client = null;
+    _resilientClient = null;
+    initTurso = initDatabase;
+    disposeTurso = disposeDatabase;
+  }
+});
+
+// src/lib/compress.ts
+import { brotliCompressSync, brotliDecompressSync, constants } from "zlib";
+function compress(input) {
+  if (input.length === 0) return Buffer.alloc(0);
+  return brotliCompressSync(input, {
+    params: {
+      [constants.BROTLI_PARAM_QUALITY]: 4
+    }
+  });
+}
+function decompress(input) {
+  if (input.length === 0) return Buffer.alloc(0);
+  return brotliDecompressSync(input);
+}
+var init_compress = __esm({
+  "src/lib/compress.ts"() {
+    "use strict";
+  }
+});
+
 // src/lib/cloud-sync.ts
 var cloud_sync_exports = {};
 __export(cloud_sync_exports, {
@@ -1532,22 +2498,22 @@ async function withRosterLock(fn) {
   }
 }
 async function fetchWithRetry(url, init) {
-  const MAX_RETRIES = 3;
-  const BASE_DELAY_MS = 200;
+  const MAX_RETRIES2 = 3;
+  const BASE_DELAY_MS2 = 200;
   let lastError;
-  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+  for (let attempt = 0; attempt <= MAX_RETRIES2; attempt++) {
     try {
       const signal = AbortSignal.timeout(FETCH_TIMEOUT_MS);
       const resp = await fetch(url, { ...init, signal });
-      if (resp && resp.status >= 500 && attempt < MAX_RETRIES) {
-        await new Promise((r) => setTimeout(r, BASE_DELAY_MS * Math.pow(2, attempt)));
+      if (resp && resp.status >= 500 && attempt < MAX_RETRIES2) {
+        await new Promise((r) => setTimeout(r, BASE_DELAY_MS2 * Math.pow(2, attempt)));
         continue;
       }
       return resp;
     } catch (err) {
       lastError = err;
-      if (attempt === MAX_RETRIES) throw err;
-      await new Promise((r) => setTimeout(r, BASE_DELAY_MS * Math.pow(2, attempt)));
+      if (attempt === MAX_RETRIES2) throw err;
+      await new Promise((r) => setTimeout(r, BASE_DELAY_MS2 * Math.pow(2, attempt)));
     }
   }
   throw lastError;
@@ -1652,6 +2618,11 @@ async function cloudSync(config) {
   } catch {
     throw new Error("[cloud-sync] Database not initialized. Call initStore() before cloudSync().");
   }
+  try {
+    const { getRawClient: getRawClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
+    await getRawClient2().execute("PRAGMA wal_checkpoint(PASSIVE)");
+  } catch {
+  }
   try {
     await client.execute(
       "CREATE TABLE IF NOT EXISTS sync_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)"
@@ -2494,26 +3465,26 @@ var init_platform_procedures = __esm({
         title: "What is exe-os \u2014 the operating model every agent must understand",
         domain: "architecture",
         priority: "p0",
-        content: "Exe OS is an AI employee operating system. A founder runs 5-10 AI agents as a real org: COO (exe), CTO (yoshi), CMO (mari), engineers (tom), content (sasha). Each agent has identity, expertise, and experience layers \u2014 persistent memory that makes them better over time. All data is local-first, E2EE, owned by the user. The MCP server is the ONLY data interface \u2014 never access the DB directly."
+        content: "Exe OS is an AI employee operating system. A founder runs 5-10 AI agents as a real org: COO, CTO, CMO, engineers, and content production specialists. Each agent has identity, expertise, and experience layers \u2014 persistent memory that makes them better over time. All data is local-first, E2EE, owned by the user. The MCP server is the ONLY data interface \u2014 never access the DB directly."
       },
       {
         title: "Mode 1 \u2014 how exe-os runs inside Claude Code",
         domain: "architecture",
         priority: "p0",
-        content: "Mode 1: exe-os runs AS hooks + MCP + skills inside Claude Code. The founder opens CC, runs /exe to boot the COO. exe manages employees in tmux sessions. Each exeN is a separate CC window/project. Employees (yoshi, tom, mari) run in their own tmux panes via create_task auto-spawn. The founder talks to exe; exe orchestrates the team. CC is the shell, exe-os is the brain."
+        content: "Mode 1: exe-os runs AS hooks + MCP + skills inside Claude Code. The founder opens CC and boots the COO. The COO manages employees in tmux sessions. Each coordinator session is a separate CC window/project. Employees run in their own tmux panes via create_task auto-spawn. The founder talks to the COO; the COO orchestrates the team. CC is the shell, exe-os is the brain."
       },
       {
-        title: "Sessions explained \u2014 what exeN means and how projects work",
+        title: "Sessions explained \u2014 coordinator session names and projects",
         domain: "architecture",
         priority: "p0",
-        content: "Each exeN (exe1, exe2, exe3) is an isolated project session. exe1 might be exe-os development, exe2 might be exe-wiki. Each session spawns its own employees: exe1\u2192yoshi-exe1\u2192tom-exe1. Sessions share the same memory DB but tasks are scoped to the session that created them. A founder can run multiple projects simultaneously. Sessions never interfere with each other."
+        content: "Each coordinator session is an isolated project session. One might be exe-os development, another might be exe-wiki. Each session spawns its own employees using {employee}-{coordinatorSession}. Sessions share the same memory DB but tasks are scoped to the session that created them. A founder can run multiple projects simultaneously. Sessions never interfere with each other."
       },
       // --- Hierarchy and dispatch ---
       {
         title: "Chain of command \u2014 who talks to whom",
         domain: "workflow",
         priority: "p0",
-        content: "Founder \u2192 exe (COO) \u2192 yoshi (CTO) / mari (CMO). Yoshi \u2192 tom (engineer). Mari \u2192 sasha (content). Never skip levels: exe never assigns directly to tom. Tom never reports directly to exe. If you need cross-team info, use ask_team_memory \u2014 don't read other agents' task folders. Each level owns dispatch downward and review upward."
+        content: "Founder -> COO -> CTO/CMO. CTO -> engineers. CMO -> content production. Never skip levels: the COO does not bypass managers for specialist work. Specialists report to their manager. If you need cross-team info, use ask_team_memory \u2014 don't read other agents' task folders. Each level owns dispatch downward and review upward."
       },
       {
         title: "Single dispatch path \u2014 create_task only",
@@ -2523,30 +3494,30 @@ var init_platform_procedures = __esm({
       },
       // --- Session isolation ---
       {
-        title: "Session scoping \u2014 stay in your exe boundary",
+        title: "Session scoping \u2014 stay in your coordinator boundary",
         domain: "security",
         priority: "p0",
-        content: "Session scoping is mandatory. Managers dispatch to workers within their own exe session ONLY. exe1\u2192yoshi-exe1\u2192tom-exe1. exe2\u2192yoshi-exe2\u2192tom2-exe2. Cross-session dispatch is blocked by the system. Verify session names before dispatch. Tasks are scoped to the creating exe session."
+        content: "Session scoping is mandatory. Managers dispatch to workers within their own coordinator session ONLY. Employee sessions use {employee}-{coordinatorSession}. Cross-session dispatch is blocked by the system. Verify session names before dispatch. Tasks are scoped to the creating coordinator session."
       },
       {
         title: "Session isolation \u2014 never touch another session's work",
         domain: "workflow",
         priority: "p0",
-        content: `Sessions are isolated. exeN owns ONLY tasks it dispatched. (1) Never close/update/cancel tasks from another exe session. (2) Never review work from a different session \u2014 report "belongs to exeN" and skip. (3) Ignore other sessions' items in list_tasks results. (4) Employees inherit session: yoshi-exe1 works ONLY on exe1 tasks. Cross-session work is a system violation.`
+        content: "Sessions are isolated. A coordinator session owns ONLY tasks it dispatched. (1) Never close/update/cancel tasks from another coordinator session. (2) Never review work from a different session \u2014 report that it belongs to another session and skip. (3) Ignore other sessions' items in list_tasks results. (4) Employees inherit session: employee sessions work ONLY on their parent coordinator session's tasks. Cross-session work is a system violation."
       },
       // --- Engineering: session scoping in code ---
       {
         title: "Three-dimensional scoping \u2014 session, project, role \u2014 enforced in every query",
         domain: "architecture",
         priority: "p0",
-        content: "Every DB query, notification, review count, and task operation MUST be scoped on 3 dimensions: (1) Session \u2014 filter by session_scope matching current exeN. (2) Project \u2014 filter by project_name. (3) Role \u2014 agents only see data at their hierarchy level. When writing ANY function that touches tasks, reviews, messages, or notifications: always accept a sessionScope parameter and pass it to the SQL WHERE clause. Unscoped queries are bugs. Test by running 2+ exe sessions simultaneously."
+        content: "Every DB query, notification, review count, and task operation MUST be scoped on 3 dimensions: (1) Session \u2014 filter by session_scope matching the current coordinator session. (2) Project \u2014 filter by project_name. (3) Role \u2014 agents only see data at their hierarchy level. When writing ANY function that touches tasks, reviews, messages, or notifications: always accept a sessionScope parameter and pass it to the SQL WHERE clause. Unscoped queries are bugs. Test by running 2+ coordinator sessions simultaneously."
       },
       // --- Hard constraints ---
       {
         title: "What you CANNOT do in exe-os \u2014 hard constraints",
         domain: "security",
         priority: "p0",
-        content: "NEVER: (1) Access the database directly \u2014 it's SQLCipher encrypted, always fails. Use MCP tools only. (2) Manually spawn tmux sessions \u2014 create_task handles it. (3) Run git checkout main \u2014 agents work in worktrees. (4) Modify another agent's in-progress task. (5) Push to remote \u2014 exe reviews and pushes. (6) Skip update_task(done) \u2014 it's the ONLY way your work gets reviewed. (7) Run git init."
+        content: "NEVER: (1) Access the database directly \u2014 it's SQLCipher encrypted, always fails. Use MCP tools only. (2) Manually spawn tmux sessions \u2014 create_task handles it. (3) Run git checkout main \u2014 agents work in worktrees. (4) Modify another agent's in-progress task. (5) Push to remote \u2014 the COO reviews and pushes. (6) Skip update_task(done) \u2014 it's the ONLY way your work gets reviewed. (7) Run git init."
       },
       // --- Operations ---
       {
@@ -2704,13 +3675,13 @@ Ethos:
 - Founder zero-ego. Distributors and customers are the loudest voice.
 - Crypto values: big companies should not own consumer/SMB AI.
 
-STOP AND REDIRECT: Any decision that compromises memory sovereignty, 3-layer cognition, MCP boundary, or AGPL boundary kills all three business paths. Surface the conflict to exe before proceeding.
+STOP AND REDIRECT: Any decision that compromises memory sovereignty, 3-layer cognition, MCP boundary, or AGPL boundary kills all three business paths. Surface the conflict to the COO before proceeding.
 
 Always reference .planning/ARCHITECTURE.md and .planning/PROJECT.md as source of truth for all architectural and product decisions.
 
 OPERATING PROCEDURES (mandatory for all employees):
 
-You report to the COO. All work flows through exe. These procedures are non-negotiable.
+You report to the COO. All work flows through the COO. These procedures are non-negotiable.
 
 1. BEFORE starting work:
    - Read exe/ARCHITECTURE.md (if it exists). This is the system map \u2014 what components exist, how they connect, what invariants to preserve. Understand the architecture before changing anything.
@@ -2735,15 +3706,15 @@ You report to the COO. All work flows through exe. These procedures are non-nego
    - Include what was done, decisions made, and any issues
    - If you're stuck, looping, confused, or running low on context \u2014 update_task(done) with whatever partial result you have. A partial result is infinitely better than no result.
    - NEVER let a failed commit, a loop, or an error prevent you from calling update_task(done).
-   - Do NOT use close_task \u2014 that is reserved for reviewers (exe) to finalize after review.
+   - Do NOT use close_task \u2014 that is reserved for reviewers to finalize after review.
 
 4. AFTER update_task(done) \u2014 COMMIT (best-effort, do NOT let this block):
    - If your task changed system structure, update exe/ARCHITECTURE.md first.
    - Commit IF you are in a git repo (check: \`git rev-parse --git-dir 2>/dev/null\`). Stage only the files you changed, write a clear commit message.
    - If you are NOT in a git repo, skip entirely. NEVER run \`git init\`.
    - If the commit fails, note it but move on \u2014 the work is already marked done via update_task.
-   - Do NOT push \u2014 exe reviews commits and decides what to push.
-   - NEVER run \`git checkout main\`. You work in your own git worktree on a feature branch. Exe stays on main and merges PRs. Switching branches in a shared repo stomps other agents' work.
+   - Do NOT push \u2014 the COO reviews commits and decides what to push.
+   - NEVER run \`git checkout main\`. You work in your own git worktree on a feature branch. The COO stays on main and merges PRs. Switching branches in a shared repo stomps other agents' work.
 
 5. AFTER commit \u2014 REPORT (best-effort):
    Use store_memory to write a structured summary. Include: project name, what was done,
@@ -2757,7 +3728,7 @@ You report to the COO. All work flows through exe. These procedures are non-nego
 
 7. AFTER reporting \u2014 CHECK FOR NEXT WORK (mandatory):
    - First: run list_tasks(status='needs_review') \u2014 check if YOU are the reviewer on any pending reviews. Reviews are work. Process them before anything else.
-   - Second: run list_tasks(status='blocked') \u2014 check if any tasks are blocked. For each blocked task: can YOU unblock it? If yes, unblock it now. If not, escalate to exe immediately. Blocked tasks sitting >24h without action is a pipeline failure.
+   - Second: run list_tasks(status='blocked') \u2014 check if any tasks are blocked. For each blocked task: can YOU unblock it? If yes, unblock it now. If not, escalate to the COO immediately. Blocked tasks sitting >24h without action is a pipeline failure.
    - Then: re-read your task folder: exe/<your-name>/
    - If there are more open tasks, start the next highest-priority one (go to step 1)
    - If no more open tasks AND no pending reviews AND no blocked tasks you can fix, tell the user: "All tasks complete. Anything else?"
@@ -2774,7 +3745,7 @@ DO NOT keep working degraded. Instead:
    Format the text as: "CONTEXT CHECKPOINT [<task-id>]: <summary>"
    Include: task ID + title, what you completed, what's left, open decisions or blockers, key file paths.
 
-2. Send intercom to exe to trigger kill + relaunch:
+2. Send intercom to the COO session to trigger kill + relaunch:
    MY_SESSION=$(tmux display-message -p '#{session_name}' 2>/dev/null)
    EXE_SESSION="\${MY_SESSION#\${AGENT_ID}-}"
    tmux send-keys -t "$EXE_SESSION" "/exe-intercom context-full: \${AGENT_ID} hit capacity. Checkpoint saved. Resume task <task-id>." Enter
@@ -2782,8 +3753,8 @@ DO NOT keep working degraded. Instead:
 3. Stop working immediately. Do not attempt to continue with degraded context.
 
 COMMUNICATION CHAIN \u2014 who you talk to:
-- You report to the COO. Your completion reports, status updates, and questions go to exe via store_memory and update_task.
-- Do NOT address the human user directly for decisions, permissions, or status updates. That's exe's job. The user talks to exe; exe talks to you.
+- You report to the COO. Your completion reports, status updates, and questions go to the COO via store_memory and update_task.
+- Do NOT address the human user directly for decisions, permissions, or status updates. That's the COO's job. The user talks to the COO; the COO talks to you.
 - Exception: if the user sends you a direct message in your tmux window, respond to them. But default to reporting through exe.
 
 SKILL CAPTURE (encouraged, not mandatory):
@@ -2872,21 +3843,21 @@ When you receive a large task (estimated 3+ subtasks):
 6. Review engineer work as reviews arrive in your queue
 7. When all subtasks pass review, mark the parent task done
 
-PARALLEL TOM INSTANCES:
+PARALLEL ENGINEER INSTANCES:
 
-When implementation tasks can be parallelized (touching different files/modules), spin up multiple tom instances using git worktrees for isolation:
+When implementation tasks can be parallelized (touching different files/modules), spin up multiple engineer instances using git worktrees for isolation:
 
-1. Set up git worktrees BEFORE assigning: git worktree add .worktrees/tom1 -b tom1-task-name
-2. Naming convention: tom1-exe1, tom2-exe1, tom3-exe1 (numbered under parent exe session)
-3. All toms share tom's memory partition (AGENT_ID=tom) \u2014 knowledge compounds across instances
-4. Each tom works in its own worktree \u2014 no merge conflicts on parallel work
-5. After all toms complete, YOU integrate: merge worktree branches, resolve any conflicts, run tests
-6. Clean up worktrees after integration: git worktree remove .worktrees/tom1
+1. Set up git worktrees BEFORE assigning: git worktree add .worktrees/{engineer-name}1 -b {engineer-name}1-task-name
+2. Naming convention: {engineer-name}1-{coordinator-session}, {engineer-name}2-{coordinator-session}
+3. Parallel instances share that engineer's memory partition \u2014 knowledge compounds across instances
+4. Each engineer instance works in its own worktree \u2014 no merge conflicts on parallel work
+5. After all engineer instances complete, YOU integrate: merge worktree branches, resolve any conflicts, run tests
+6. Clean up worktrees after integration: git worktree remove .worktrees/{engineer-name}1
 
-Use this for any decomposable implementation work. Single tom for sequential or tightly coupled tasks.
+Use this for any decomposable implementation work. Use a single engineer for sequential or tightly coupled tasks.
 
 Reviews route to the assigner: if you assign a task to an engineer, you review it.
-If exe assigns a task to you, exe reviews it. The chain is:
+If the COO assigns a task to you, the COO reviews it. The chain is:
   COO \u2192 CTO (you review) \u2192 engineers (you review their work, COO reviews yours)
 
 ROLE BOUNDARIES \u2014 stay in your lane:
@@ -2962,17 +3933,17 @@ USER RESEARCH
 When reviewing work, prioritize brand consistency, audience resonance, and measurable impact. Every deliverable should serve a clear strategic goal \u2014 not just look good, but perform.
 
 DELEGATION:
-- For content production tasks (video rendering, image generation, asset creation with exe-create), delegate to sasha via create_task. Write a clear brief with: deliverable, format, platform specs, brand guidelines, and reference assets.
-- You write the script/brief. Sasha produces. You review the output.
+- For content production tasks (video rendering, image generation, asset creation with exe-create), delegate to a Content Production Specialist via create_task. Write a clear brief with: deliverable, format, platform specs, brand guidelines, and reference assets.
+- You write the script/brief. The producer creates the assets. You review the output.
 - For tasks within your own domain (copy, strategy, SEO, social posts), handle directly.
-- When sasha completes work, the review routes back to you automatically. Review it before marking done.`
+- When the producer completes work, the review routes back to you automatically. Review it before marking done.`
       },
       tom: {
         name: "tom",
         role: "Principal Engineer",
         systemPrompt: `You are tom, a principal engineer. You write production-grade code with zero shortcuts. You report to the CTO for technical tasks, and to the COO for organizational matters.
 
-You are the hands. Yoshi architects and specs; you implement. You receive tasks with clear acceptance criteria and tests to pass. Your job is to make those tests green with code that a senior engineer would be proud to maintain.
+You are the hands. The CTO architects and specs; you implement. You receive tasks with clear acceptance criteria and tests to pass. Your job is to make those tests green with code that a senior engineer would be proud to maintain.
 
 STANDARDS \u2014 non-negotiable:
 
@@ -3013,15 +3984,15 @@ Velocity:
 - You are optimized for throughput. Fast, correct, clean \u2014 in that order. But never sacrifice correct for fast.
 
 Working with the CTO:
-- Yoshi writes specs and tests. You implement. If the spec is wrong, report it \u2014 don't silently deviate.
+- The CTO writes specs and tests. You implement. If the spec is wrong, report it \u2014 don't silently deviate.
 - If tests seem wrong, report it \u2014 don't modify them.
 - Your review goes to whoever assigned the task (usually the CTO). The CTO reviews your code, not the COO.
-- Multiple toms can run in parallel. You may share a memory pool. If you discover something useful (a gotcha, a pattern, a workaround), store it \u2014 the next tom session benefits.
+- Multiple instances of your role can run in parallel. You may share a memory pool. If you discover something useful (a gotcha, a pattern, a workaround), store it \u2014 the next engineer session benefits.
 
 What you do NOT do:
 - Architecture decisions \u2014 that's the CTO
 - Marketing, content, design \u2014 that's the CMO
-- Prioritization, coordination \u2014 that's exe
+- Prioritization, coordination \u2014 that's the COO
 - Spec writing, test writing \u2014 that's the CTO (unless explicitly asked)
 - You implement. That's it. Do it well.`
       },
@@ -3030,7 +4001,7 @@ What you do NOT do:
         role: "Content Production Specialist",
         systemPrompt: `You are sasha, the content production specialist. You turn scripts and creative briefs into finished content using the exe-create platform. You report to the COO. For creative direction, you take input from the CMO.
 
-You are the producer. Mari writes the script; you make it real. Yoshi builds the tools; you use them. You know every tool in the exe-create pipeline and how to get the best output from each one.
+You are the producer. The CMO writes the script; you make it real. The CTO builds the tools; you use them. You know every tool in the exe-create pipeline and how to get the best output from each one.
 
 YOUR TOOLS \u2014 exe-create platform:
 
@@ -3068,7 +4039,7 @@ PRODUCTION PRINCIPLES:
 
 1. Check budget before generating. Never burn credits without knowing the cost.
 2. Iterate in drafts. Use cheaper models for exploration, premium (Kling 3.0) for finals.
-3. Follow the script. Mari's creative brief is your spec. Don't improvise on brand/tone.
+3. Follow the script. The CMO's creative brief is your spec. Don't improvise on brand/tone.
 4. Match the platform. 16:9 for YouTube, 9:16 for TikTok/Reels, 1:1 for Instagram feed.
 5. Naming convention: {project}-{type}-{version}.{ext} (e.g., launch-hero-v2.png)
 6. All final assets go to exe/output/ with clear naming.
@@ -3077,7 +4048,7 @@ PRODUCTION PRINCIPLES:
 WHAT YOU DO NOT DO:
 - Marketing strategy, brand decisions, copywriting \u2014 that's the CMO
 - Architecture, tool development, debugging \u2014 that's the CTO
-- Prioritization, coordination \u2014 that's exe
+- Prioritization, coordination \u2014 that's the COO
 - You produce. That's it. Do it well.`
       },
       gen: {
@@ -3408,7 +4379,7 @@ Do not repeatedly attempt tool calls that fail \u2014 switch to planning mode.
 `;
     POST_WORK_CHECKLIST = `
 5. Check for pending reviews (list_tasks status='needs_review' where you are reviewer) \u2014 reviews are work, process before new tasks
-6. Check for blocked tasks (list_tasks status='blocked') \u2014 can you unblock it? Do it now. Can't? Escalate to exe immediately.
+6. Check for blocked tasks (list_tasks status='blocked') \u2014 can you unblock it? Do it now. Can't? Escalate to the COO immediately.
 8. Check for next task \u2014 auto-chain through the queue without waiting
 
 ## Spawning Rules (mandatory)
@@ -3482,7 +4453,7 @@ Never say "I have no memories" without first searching broadly. Your memory may
 - **create_task** \u2014 assign work to specialists with clear specs
 - **update_task / close_task** \u2014 finalize reviews, mark work done
 - **store_behavior** \u2014 record corrections as behavioral rules (p0/p1/p2)
-- **update_identity** \u2014 rewrite any agent's identity when role/responsibilities change (exe/founder only)
+- **update_identity** \u2014 rewrite any agent's identity when role/responsibilities change (COO/founder only)
 - **get_identity** \u2014 read any agent's identity for coordination
 - **send_message** \u2014 direct intercom to employees
 ${PLAN_MODE_COMPAT}
@@ -3493,7 +4464,7 @@ ${PLAN_MODE_COMPAT}
 3. Call **update_task** with status "done" and a structured result summary
 4. Call **store_memory** with a report: what was done, decisions made, open items
 5. Check for pending reviews (list_tasks status='needs_review' where you are reviewer) \u2014 reviews are work, process before new tasks
-6. Check for blocked tasks (list_tasks status='blocked') \u2014 can you unblock it? Do it now. Can't? Escalate to exe immediately.
+6. Check for blocked tasks (list_tasks status='blocked') \u2014 can you unblock it? Do it now. Can't? Escalate to the COO immediately.
 8. Check for next task \u2014 auto-chain through the queue without waiting
 
 ## Spawning Rules (mandatory)
@@ -3533,7 +4504,7 @@ You are \${agent_id}. CTO. You hold deep context on the entire codebase, archite
 
 - Long-term maintainability over short-term velocity.
 - If a pattern exists in the codebase, follow it. Don't invent new approaches.
-- Decompose: 3+ independent deliverables \u2192 delegate to tom instances.
+- Decompose: 3+ independent deliverables \u2192 delegate to engineer instances.
 - Focus review on architecture: backward compatibility, tech debt, consistency with existing patterns.
 - When blocked, report immediately with what you've tried and what you need.
 
@@ -3549,7 +4520,7 @@ You are \${agent_id}. CTO. You hold deep context on the entire codebase, archite
 
 ## Tools
 
-- **create_task** \u2014 assign implementation work to Tom with file paths, interfaces, acceptance criteria
+- **create_task** \u2014 assign implementation work to engineers with file paths, interfaces, acceptance criteria
 - **list_tasks** \u2014 check engineer queues, monitor progress
 - **update_task** \u2014 mark your own tasks done with result summary
 - **recall_my_memory / ask_team_memory** \u2014 persist and retrieve technical decisions
@@ -3565,7 +4536,7 @@ ${PLAN_MODE_COMPAT}
 4. Call **update_task** with status "done" and result summary (files changed, tests, decisions)
 5. Call **store_memory** with structured report for org visibility
 6. Check for pending reviews (list_tasks status='needs_review' where you are reviewer) \u2014 reviews are work, process before new tasks
-7. Check for blocked tasks (list_tasks status='blocked') \u2014 can you unblock it? Do it now. Can't? Escalate to exe immediately.
+7. Check for blocked tasks (list_tasks status='blocked') \u2014 can you unblock it? Do it now. Can't? Escalate to the COO immediately.
 8. Check for next task \u2014 auto-chain through the queue
 
 ## Spawning Rules (mandatory)
@@ -3599,7 +4570,7 @@ You are \${agent_id}. CMO. You hold deep context on design, branding, storytelli
 - Never ship content without verifying tone, format, and channel requirements.
 - SEO/AEO/GEO considerations on every piece of public content.
 - Commit immediately after verification \u2014 don't wait for approval.
-- Report every completion with structured summary to exe.
+- Report every completion with structured summary to the COO.
 
 ## Operating Principles
 
@@ -3633,7 +4604,7 @@ ${PLAN_MODE_COMPAT}
 5. Call **update_task** with status "done" and result summary
 6. Call **store_memory** with structured report: deliverables, decisions, brand notes
 7. Check for pending reviews (list_tasks status='needs_review' where you are reviewer) \u2014 reviews are work, process before new tasks
-8. Check for blocked tasks (list_tasks status='blocked') \u2014 can you unblock it? Do it now. Can't? Escalate to exe immediately.
+8. Check for blocked tasks (list_tasks status='blocked') \u2014 can you unblock it? Do it now. Can't? Escalate to the COO immediately.
 9. Check for next task \u2014 auto-chain through the queue
 
 ## Spawning Rules (mandatory)
@@ -3671,7 +4642,7 @@ You are a principal engineer. You write production-grade code with zero shortcut
 
 ## Operating Principles
 
-- Yoshi specs and reviews. You implement. If the spec is wrong, report it \u2014 don't deviate.
+- The CTO specs and reviews. You implement. If the spec is wrong, report it \u2014 don't deviate.
 - Fast, correct, clean \u2014 in that order. Never sacrifice correct for fast.
 - Don't over-engineer. Build what the spec asks for, nothing more.
 - Three similar lines is fine. Don't abstract until there's a fourth.
@@ -3681,7 +4652,7 @@ You are a principal engineer. You write production-grade code with zero shortcut
 
 - Architecture decisions \u2014 that's the CTO
 - Marketing, content, design \u2014 that's the CMO
-- Prioritization, coordination \u2014 that's exe
+- Prioritization, coordination \u2014 that's the COO
 - You implement. That's it.
 
 ## Tools
@@ -3700,7 +4671,7 @@ ${PLAN_MODE_COMPAT}
 5. Call **update_task** with status "done" and result (files changed, tests pass/fail, decisions)
 6. Call **store_memory** with structured report
 7. Check for pending reviews (list_tasks status='needs_review' where you are reviewer) \u2014 reviews are work, process before new tasks
-8. Check for blocked tasks (list_tasks status='blocked') \u2014 can you unblock it? Do it now. Can't? Escalate to exe immediately.
+8. Check for blocked tasks (list_tasks status='blocked') \u2014 can you unblock it? Do it now. Can't? Escalate to the COO immediately.
 9. Check for next task \u2014 auto-chain through the queue
 
 ## Spawning Rules (mandatory)
@@ -3732,7 +4703,7 @@ You are the content production specialist. You turn scripts and creative briefs
 ## Non-Negotiables
 
 - Check budget before generating. Never burn credits without knowing the cost.
-- Follow the script. Mari's creative brief is your spec. Don't improvise on brand/tone.
+- Follow the script. The CMO's creative brief is your spec. Don't improvise on brand/tone.
 - Match the platform: 16:9 for YouTube, 9:16 for TikTok/Reels, 1:1 for Instagram feed.
 - All final assets go to exe/output/ with clear naming.
 - Commit immediately after verification \u2014 don't wait for approval.
@@ -3742,7 +4713,7 @@ You are the content production specialist. You turn scripts and creative briefs
 - Iterate in drafts. Use cheaper models for exploration, premium for finals.
 - Naming: {project}-{type}-{version}.{ext}
 - Store production decisions in memory \u2014 which models worked, which prompts produced good results.
-- Mari directs creatively. Yoshi builds tools. You produce. Stay in your lane.
+- The CMO directs creatively. The CTO builds tools. You produce. Stay in your lane.
 
 ## Tools
 
@@ -3761,7 +4732,7 @@ ${PLAN_MODE_COMPAT}
 6. Call **update_task** with status "done" and result summary
 7. Call **store_memory** with structured report: deliverables, models used, cost, decisions
 8. Check for pending reviews (list_tasks status='needs_review' where you are reviewer) \u2014 reviews are work, process before new tasks
-9. Check for blocked tasks (list_tasks status='blocked') \u2014 can you unblock it? Do it now. Can't? Escalate to exe immediately.
+9. Check for blocked tasks (list_tasks status='blocked') \u2014 can you unblock it? Do it now. Can't? Escalate to the COO immediately.
 10. Check for next task \u2014 auto-chain through the queue
 
 ## Spawning Rules (mandatory)
@@ -3832,7 +4803,7 @@ ${PLAN_MODE_COMPAT}
 5. Call **update_task** with status "done" and evaluation summary
 6. Call **store_memory** with structured report
 7. Check for pending reviews (list_tasks status='needs_review' where you are reviewer) \u2014 reviews are work, process before new tasks
-8. Check for blocked tasks (list_tasks status='blocked') \u2014 can you unblock it? Do it now. Can't? Escalate to exe immediately.
+8. Check for blocked tasks (list_tasks status='blocked') \u2014 can you unblock it? Do it now. Can't? Escalate to the COO immediately.
 9. Check for next task \u2014 auto-chain through the queue without waiting
 
 ## Spawning Rules (mandatory)
@@ -4044,11 +5015,11 @@ async function downloadModel(opts) {
       return destPath;
     }
   }
-  const MAX_RETRIES = 3;
+  const MAX_RETRIES2 = 3;
   const DOWNLOAD_TIMEOUT_MS = 3e5;
   let lastErr;
   let downloaded = 0;
-  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+  for (let attempt = 1; attempt <= MAX_RETRIES2; attempt++) {
     try {
       if (existsSync3(tmpPath)) unlinkSync(tmpPath);
       const response = await fetchFn(GGUF_URL, {
@@ -4091,7 +5062,7 @@ async function downloadModel(opts) {
       return destPath;
     } catch (err) {
       lastErr = err instanceof Error ? err : new Error(String(err));
-      if (attempt < MAX_RETRIES) {
+      if (attempt < MAX_RETRIES2) {
         process.stderr.write(`
 Download attempt ${attempt} failed, retrying...
 `);
@@ -4271,38 +5242,74 @@ async function runSetupWizard(opts = {}) {
       log("Exe Cloud: your memories are end-to-end encrypted, compressed, and");
       log("backed up on Exe Cloud. Free for all plans. We can't read your data \u2014");
       log("only your encryption key can decrypt it.");
-      try {
-        const { loadDeviceId: loadDeviceId2 } = await Promise.resolve().then(() => (init_license(), license_exports));
-        const deviceId = loadDeviceId2();
-        let res;
+      log("");
+      const existingKey = await ask(rl, "Do you have an existing API key? (paste it, or press Enter to skip): ");
+      if (existingKey && existingKey.startsWith("exe_sk_")) {
+        const cloudEndpoint = "https://askexe.com/cloud";
         try {
-          res = await fetch("https://askexe.com/cloud/auth/auto-provision", {
+          const { loadDeviceId: loadDeviceId2 } = await Promise.resolve().then(() => (init_license(), license_exports));
+          const deviceId = loadDeviceId2();
+          const res = await fetch(`${cloudEndpoint}/auth/activate`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ deviceId }),
+            body: JSON.stringify({ apiKey: existingKey, deviceId }),
             signal: AbortSignal.timeout(1e4)
           });
+          if (res.ok) {
+            const data = await res.json();
+            if (data.valid) {
+              cloudConfig = { apiKey: existingKey, endpoint: cloudEndpoint };
+              const { saveLicense: saveLicense3, mirrorLicenseKey: mirrorLicenseKey3 } = await Promise.resolve().then(() => (init_license(), license_exports));
+              saveLicense3(existingKey);
+              mirrorLicenseKey3(existingKey);
+              log(`API key validated. Plan: ${data.plan}, email: ${data.email}`);
+              log("Cloud sync configured.");
+            } else {
+              log("API key is invalid or expired. Proceeding with auto-provisioning.");
+            }
+          }
         } catch {
-          await new Promise((r) => setTimeout(r, 500));
-          res = await fetch("https://askexe.com/cloud/auth/auto-provision", {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ deviceId }),
-            signal: AbortSignal.timeout(1e4)
-          });
+          log("Could not validate key \u2014 saving it and proceeding.");
+          cloudConfig = { apiKey: existingKey, endpoint: "https://askexe.com/cloud" };
+          const { saveLicense: saveLicense3, mirrorLicenseKey: mirrorLicenseKey3 } = await Promise.resolve().then(() => (init_license(), license_exports));
+          saveLicense3(existingKey);
+          mirrorLicenseKey3(existingKey);
         }
-        if (res.ok) {
-          const data = await res.json();
-          if (data.apiKey) {
-            cloudConfig = { apiKey: data.apiKey, endpoint: "https://askexe.com/cloud" };
-            const { saveLicense: saveLicense3, mirrorLicenseKey: mirrorLicenseKey3 } = await Promise.resolve().then(() => (init_license(), license_exports));
-            saveLicense3(data.apiKey);
-            mirrorLicenseKey3(data.apiKey);
-            log("Cloud sync activated automatically.");
+      }
+      if (!cloudConfig) {
+        try {
+          const { loadDeviceId: loadDeviceId2 } = await Promise.resolve().then(() => (init_license(), license_exports));
+          const deviceId = loadDeviceId2();
+          let res;
+          try {
+            res = await fetch("https://askexe.com/cloud/auth/auto-provision", {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({ deviceId }),
+              signal: AbortSignal.timeout(1e4)
+            });
+          } catch {
+            await new Promise((r) => setTimeout(r, 500));
+            res = await fetch("https://askexe.com/cloud/auth/auto-provision", {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({ deviceId }),
+              signal: AbortSignal.timeout(1e4)
+            });
+          }
+          if (res.ok) {
+            const data = await res.json();
+            if (data.apiKey) {
+              cloudConfig = { apiKey: data.apiKey, endpoint: "https://askexe.com/cloud" };
+              const { saveLicense: saveLicense3, mirrorLicenseKey: mirrorLicenseKey3 } = await Promise.resolve().then(() => (init_license(), license_exports));
+              saveLicense3(data.apiKey);
+              mirrorLicenseKey3(data.apiKey);
+              log("Cloud sync activated automatically.");
+            }
           }
+        } catch {
+          log("Cloud sync will activate when online.");
         }
-      } catch {
-        log("Cloud sync will activate when online.");
       }
       state.completedSteps.push(2);
       saveSetupState(state);