@askexenow/exe-os 0.8.83 → 0.8.86

package/dist/bin/setup.js

@@ -294,12 +294,20 @@ async function getMasterKey() {
   }
   const keyPath = getKeyPath();
   if (!existsSync2(keyPath)) {
+    process.stderr.write(
+      `[keychain] Key not found at ${keyPath} (HOME=${os2.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
+`
+    );
     return null;
   }
   try {
     const content = await readFile2(keyPath, "utf-8");
     return Buffer.from(content.trim(), "base64");
-  } catch {
+  } catch (err) {
+    process.stderr.write(
+      `[keychain] Key read failed at ${keyPath}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
     return null;
   }
 }
@@ -399,10 +407,12 @@ function handleData(chunk) {
     if (!line) continue;
     try {
       const response = JSON.parse(line);
-      const entry = _pending.get(response.id);
+      const id = response.id;
+      if (!id) continue;
+      const entry = _pending.get(id);
       if (entry) {
         clearTimeout(entry.timer);
-        _pending.delete(response.id);
+        _pending.delete(id);
         entry.resolve(response);
       }
     } catch {
@@ -573,6 +583,9 @@ async function connectEmbedDaemon() {
   return false;
 }
 function sendRequest(texts, priority) {
+  return sendDaemonRequest({ texts, priority });
+}
+function sendDaemonRequest(payload, timeoutMs = REQUEST_TIMEOUT_MS) {
   return new Promise((resolve) => {
     if (!_socket || !_connected) {
       resolve({ error: "Not connected" });
@@ -582,10 +595,10 @@ function sendRequest(texts, priority) {
     const timer = setTimeout(() => {
       _pending.delete(id);
       resolve({ error: "Request timeout" });
-    }, REQUEST_TIMEOUT_MS);
+    }, timeoutMs);
     _pending.set(id, { resolve, timer });
     try {
-      _socket.write(JSON.stringify({ id, texts, priority }) + "\n");
+      _socket.write(JSON.stringify({ id, ...payload }) + "\n");
     } catch {
       clearTimeout(timer);
       _pending.delete(id);
@@ -595,30 +608,11 @@ function sendRequest(texts, priority) {
 }
 async function pingDaemon() {
   if (!_socket || !_connected) return null;
-  return new Promise((resolve) => {
-    const id = randomUUID();
-    const timer = setTimeout(() => {
-      _pending.delete(id);
-      resolve(null);
-    }, 5e3);
-    _pending.set(id, {
-      resolve: (data) => {
-        if (data.health) {
-          resolve(data.health);
-        } else {
-          resolve(null);
-        }
-      },
-      timer
-    });
-    try {
-      _socket.write(JSON.stringify({ id, type: "health" }) + "\n");
-    } catch {
-      clearTimeout(timer);
-      _pending.delete(id);
-      resolve(null);
-    }
-  });
+  const response = await sendDaemonRequest({ type: "health" }, 5e3);
+  if (response.health) {
+    return response.health;
+  }
+  return null;
 }
 function killAndRespawnDaemon() {
   process.stderr.write("[exed-client] Killing daemon for restart...\n");
@@ -703,6 +697,9 @@ function disconnectClient() {
     entry.resolve({ error: "Client disconnected" });
   }
 }
+function isClientConnected() {
+  return _connected;
+}
 var SOCKET_PATH, PID_PATH, SPAWN_LOCK_PATH, SPAWN_LOCK_STALE_MS, CONNECT_TIMEOUT_MS, REQUEST_TIMEOUT_MS, _socket, _connected, _buffer, _requestCount, HEALTH_CHECK_INTERVAL, _pending, MAX_BUFFER;
 var init_exe_daemon_client = __esm({
   "src/lib/exe-daemon-client.ts"() {
@@ -761,10 +758,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: existsSync11 } = await import("fs");
-  const path11 = await import("path");
-  const modelPath = path11.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
-  if (!existsSync11(modelPath)) {
+  const { existsSync: existsSync12 } = await import("fs");
+  const path12 = await import("path");
+  const modelPath = path12.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
+  if (!existsSync12(modelPath)) {
     throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
   }
   const llama = await llamaCpp.getLlama();
@@ -1300,6 +1297,7 @@ __export(employees_exports, {
   DEFAULT_COORDINATOR_TEMPLATE_NAME: () => DEFAULT_COORDINATOR_TEMPLATE_NAME,
   EMPLOYEES_PATH: () => EMPLOYEES_PATH,
   addEmployee: () => addEmployee,
+  baseAgentName: () => baseAgentName,
   canCoordinate: () => canCoordinate,
   getCoordinatorEmployee: () => getCoordinatorEmployee,
   getCoordinatorName: () => getCoordinatorName,
@@ -1396,6 +1394,14 @@ function hasRole(agentName, role) {
   const emp = getEmployee(employees, agentName);
   return emp ? emp.role.toLowerCase() === role.toLowerCase() : false;
 }
+function baseAgentName(name, employees) {
+  const match = name.match(/^([a-zA-Z]+)\d+$/);
+  if (!match) return name;
+  const base = match[1];
+  const roster = employees ?? loadEmployeesSync();
+  if (getEmployee(roster, base)) return base;
+  return name;
+}
 function isMultiInstance(agentName, employees) {
   const roster = employees ?? loadEmployeesSync();
   const emp = getEmployee(roster, agentName);
@@ -1491,6 +1497,205 @@ var init_employees = __esm({
   }
 });
 
+// src/lib/daemon-protocol.ts
+function serializeValue(v) {
+  if (v === null || v === void 0) return null;
+  if (typeof v === "bigint") return Number(v);
+  if (typeof v === "boolean") return v ? 1 : 0;
+  if (v instanceof Uint8Array) {
+    return { __blob: Buffer.from(v).toString("base64") };
+  }
+  if (ArrayBuffer.isView(v)) {
+    return { __blob: Buffer.from(v.buffer, v.byteOffset, v.byteLength).toString("base64") };
+  }
+  if (v instanceof ArrayBuffer) {
+    return { __blob: Buffer.from(v).toString("base64") };
+  }
+  if (typeof v === "string" || typeof v === "number") return v;
+  return String(v);
+}
+function deserializeValue(v) {
+  if (v === null) return null;
+  if (typeof v === "object" && v !== null && "__blob" in v) {
+    const buf = Buffer.from(v.__blob, "base64");
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+  }
+  return v;
+}
+function deserializeResultSet(srs) {
+  const rows = srs.rows.map((obj) => {
+    const values = srs.columns.map(
+      (col) => deserializeValue(obj[col] ?? null)
+    );
+    const row = values;
+    for (let i = 0; i < srs.columns.length; i++) {
+      const col = srs.columns[i];
+      if (col !== void 0) {
+        row[col] = values[i] ?? null;
+      }
+    }
+    Object.defineProperty(row, "length", {
+      value: values.length,
+      enumerable: false
+    });
+    return row;
+  });
+  return {
+    columns: srs.columns,
+    columnTypes: srs.columnTypes ?? [],
+    rows,
+    rowsAffected: srs.rowsAffected,
+    lastInsertRowid: srs.lastInsertRowid != null ? BigInt(srs.lastInsertRowid) : void 0,
+    toJSON: () => ({
+      columns: srs.columns,
+      columnTypes: srs.columnTypes ?? [],
+      rows: srs.rows,
+      rowsAffected: srs.rowsAffected,
+      lastInsertRowid: srs.lastInsertRowid
+    })
+  };
+}
+var init_daemon_protocol = __esm({
+  "src/lib/daemon-protocol.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/db-daemon-client.ts
+var db_daemon_client_exports = {};
+__export(db_daemon_client_exports, {
+  createDaemonDbClient: () => createDaemonDbClient,
+  initDaemonDbClient: () => initDaemonDbClient
+});
+function normalizeStatement(stmt) {
+  if (typeof stmt === "string") {
+    return { sql: stmt, args: [] };
+  }
+  const sql = stmt.sql;
+  let args2 = [];
+  if (Array.isArray(stmt.args)) {
+    args2 = stmt.args.map((v) => serializeValue(v));
+  } else if (stmt.args && typeof stmt.args === "object") {
+    const named = {};
+    for (const [key, val] of Object.entries(stmt.args)) {
+      named[key] = serializeValue(val);
+    }
+    return { sql, args: named };
+  }
+  return { sql, args: args2 };
+}
+function createDaemonDbClient(fallbackClient) {
+  let _useDaemon = false;
+  const client = {
+    async execute(stmt) {
+      if (!_useDaemon || !isClientConnected()) {
+        return fallbackClient.execute(stmt);
+      }
+      const { sql, args: args2 } = normalizeStatement(stmt);
+      const response = await sendDaemonRequest({
+        type: "db-execute",
+        sql,
+        args: args2
+      });
+      if (response.error) {
+        const errMsg = String(response.error);
+        if (errMsg === "Not connected" || errMsg === "Request timeout" || errMsg === "Write failed") {
+          process.stderr.write(`[db-daemon] Transport error (${errMsg}), falling back to direct
+`);
+          return fallbackClient.execute(stmt);
+        }
+        throw new Error(errMsg);
+      }
+      if (response.db) {
+        return deserializeResultSet(response.db);
+      }
+      process.stderr.write("[db-daemon] Unexpected response shape, falling back to direct\n");
+      return fallbackClient.execute(stmt);
+    },
+    async batch(stmts, mode) {
+      if (!_useDaemon || !isClientConnected()) {
+        return fallbackClient.batch(stmts, mode);
+      }
+      const statements = stmts.map(normalizeStatement);
+      const response = await sendDaemonRequest({
+        type: "db-batch",
+        statements,
+        mode: mode ?? "deferred"
+      });
+      if (response.error) {
+        const errMsg = String(response.error);
+        if (errMsg === "Not connected" || errMsg === "Request timeout" || errMsg === "Write failed") {
+          process.stderr.write(`[db-daemon] Batch transport error (${errMsg}), falling back to direct
+`);
+          return fallbackClient.batch(stmts, mode);
+        }
+        throw new Error(errMsg);
+      }
+      const batchResults = response["db-batch"];
+      if (batchResults) {
+        return batchResults.map(deserializeResultSet);
+      }
+      process.stderr.write("[db-daemon] Unexpected batch response shape, falling back to direct\n");
+      return fallbackClient.batch(stmts, mode);
+    },
+    // Transaction support — delegate to fallback (transactions need direct connection)
+    async transaction(mode) {
+      return fallbackClient.transaction(mode);
+    },
+    // executeMultiple — delegate to fallback (used only for schema migrations)
+    async executeMultiple(sql) {
+      return fallbackClient.executeMultiple(sql);
+    },
+    // migrate — delegate to fallback
+    async migrate(stmts) {
+      return fallbackClient.migrate(stmts);
+    },
+    // Sync mode — delegate to fallback
+    sync() {
+      return fallbackClient.sync();
+    },
+    close() {
+      _useDaemon = false;
+    },
+    get closed() {
+      return fallbackClient.closed;
+    },
+    get protocol() {
+      return fallbackClient.protocol;
+    }
+  };
+  return {
+    ...client,
+    /** Enable daemon routing (call after confirming daemon is connected) */
+    _enableDaemon() {
+      _useDaemon = true;
+    },
+    /** Check if daemon routing is active */
+    _isDaemonActive() {
+      return _useDaemon && isClientConnected();
+    }
+  };
+}
+async function initDaemonDbClient(fallbackClient) {
+  if (process.env.EXE_IS_DAEMON === "1") return null;
+  const connected = await connectEmbedDaemon();
+  if (!connected) {
+    process.stderr.write("[db-daemon] Daemon unavailable \u2014 using direct SQLite\n");
+    return null;
+  }
+  const client = createDaemonDbClient(fallbackClient);
+  client._enableDaemon();
+  process.stderr.write("[db-daemon] DB routing through daemon (single-writer)\n");
+  return client;
+}
+var init_db_daemon_client = __esm({
+  "src/lib/db-daemon-client.ts"() {
+    "use strict";
+    init_exe_daemon_client();
+    init_daemon_protocol();
+  }
+});
+
 // src/lib/database.ts
 var database_exports = {};
 __export(database_exports, {
@@ -1499,6 +1704,7 @@ __export(database_exports, {
   ensureSchema: () => ensureSchema,
   getClient: () => getClient,
   getRawClient: () => getRawClient,
+  initDaemonClient: () => initDaemonClient,
   initDatabase: () => initDatabase,
   initTurso: () => initTurso,
   isInitialized: () => isInitialized
@@ -1526,8 +1732,27 @@ function getClient() {
   if (!_resilientClient) {
     throw new Error("Database client not initialized. Call initDatabase() first.");
   }
+  if (process.env.EXE_IS_DAEMON === "1") {
+    return _resilientClient;
+  }
+  if (_daemonClient && _daemonClient._isDaemonActive()) {
+    return _daemonClient;
+  }
   return _resilientClient;
 }
+async function initDaemonClient() {
+  if (process.env.EXE_IS_DAEMON === "1") return;
+  if (!_resilientClient) return;
+  try {
+    const { initDaemonDbClient: initDaemonDbClient2 } = await Promise.resolve().then(() => (init_db_daemon_client(), db_daemon_client_exports));
+    _daemonClient = await initDaemonDbClient2(_resilientClient);
+  } catch (err) {
+    process.stderr.write(
+      `[database] Daemon client init failed (non-fatal): ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
 function getRawClient() {
   if (!_client) {
     throw new Error("Database client not initialized. Call initDatabase() first.");
@@ -2014,6 +2239,12 @@ async function ensureSchema() {
     } catch {
     }
   }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_content_hash ON memories(content_hash, agent_id)`
+    );
+  } catch {
+  }
   await client.executeMultiple(`
     CREATE TABLE IF NOT EXISTS entities (
       id TEXT PRIMARY KEY,
@@ -2066,7 +2297,30 @@ async function ensureSchema() {
       entity_id TEXT NOT NULL,
       PRIMARY KEY (hyperedge_id, entity_id)
     );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS entities_fts USING fts5(
+      name,
+      content=entities,
+      content_rowid=rowid
+    );
+
+    CREATE TRIGGER IF NOT EXISTS entities_fts_ai AFTER INSERT ON entities BEGIN
+      INSERT INTO entities_fts(rowid, name) VALUES (new.rowid, new.name);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS entities_fts_ad AFTER DELETE ON entities BEGIN
+      INSERT INTO entities_fts(entities_fts, rowid, name) VALUES('delete', old.rowid, old.name);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS entities_fts_au AFTER UPDATE ON entities BEGIN
+      INSERT INTO entities_fts(entities_fts, rowid, name) VALUES('delete', old.rowid, old.name);
+      INSERT INTO entities_fts(rowid, name) VALUES (new.rowid, new.name);
+    END;
   `);
+  try {
+    await client.execute("INSERT INTO entities_fts(entities_fts) VALUES('rebuild')");
+  } catch {
+  }
   await client.executeMultiple(`
     CREATE TABLE IF NOT EXISTS entity_aliases (
       alias TEXT NOT NULL PRIMARY KEY,
@@ -2247,6 +2501,33 @@ async function ensureSchema() {
     CREATE INDEX IF NOT EXISTS idx_conversations_channel
       ON conversations(channel_id);
   `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS session_agent_map (
+      session_uuid TEXT PRIMARY KEY,
+      agent_id TEXT NOT NULL,
+      session_name TEXT,
+      task_id TEXT,
+      project_name TEXT,
+      started_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_session_agent_map_agent
+      ON session_agent_map(agent_id);
+  `);
+  try {
+    const mapCount = await client.execute({ sql: `SELECT COUNT(*) as cnt FROM session_agent_map`, args: [] });
+    if (Number(mapCount.rows[0]?.cnt ?? 0) === 0) {
+      await client.execute({
+        sql: `INSERT OR IGNORE INTO session_agent_map (session_uuid, agent_id, session_name, started_at)
+              SELECT session_id, agent_id, '', MIN(timestamp)
+              FROM memories
+              WHERE session_id IS NOT NULL AND session_id != '' AND agent_id IS NOT NULL AND agent_id != ''
+              GROUP BY session_id, agent_id`,
+        args: []
+      });
+    }
+  } catch {
+  }
   try {
     await client.execute({
       sql: `ALTER TABLE tasks ADD COLUMN budget_tokens INTEGER`,
@@ -2380,15 +2661,41 @@ async function ensureSchema() {
     });
   } catch {
   }
+  for (const col of [
+    "ALTER TABLE memories ADD COLUMN intent TEXT",
+    "ALTER TABLE memories ADD COLUMN outcome TEXT",
+    "ALTER TABLE memories ADD COLUMN domain TEXT",
+    "ALTER TABLE memories ADD COLUMN referenced_entities TEXT",
+    "ALTER TABLE memories ADD COLUMN retrieval_count INTEGER DEFAULT 0",
+    "ALTER TABLE memories ADD COLUMN chain_position TEXT",
+    "ALTER TABLE memories ADD COLUMN review_status TEXT",
+    "ALTER TABLE memories ADD COLUMN context_window_pct INTEGER",
+    "ALTER TABLE memories ADD COLUMN file_paths TEXT",
+    "ALTER TABLE memories ADD COLUMN commit_hash TEXT",
+    "ALTER TABLE memories ADD COLUMN duration_ms INTEGER",
+    "ALTER TABLE memories ADD COLUMN token_cost REAL",
+    "ALTER TABLE memories ADD COLUMN audience TEXT",
+    "ALTER TABLE memories ADD COLUMN language_type TEXT",
+    "ALTER TABLE memories ADD COLUMN parent_memory_id TEXT"
+  ]) {
+    try {
+      await client.execute(col);
+    } catch {
+    }
+  }
 }
 async function disposeDatabase() {
+  if (_daemonClient) {
+    _daemonClient.close();
+    _daemonClient = null;
+  }
   if (_client) {
     _client.close();
     _client = null;
     _resilientClient = null;
   }
 }
-var _client, _resilientClient, initTurso, disposeTurso;
+var _client, _resilientClient, _daemonClient, initTurso, disposeTurso;
 var init_database = __esm({
   "src/lib/database.ts"() {
     "use strict";
@@ -2396,6 +2703,7 @@ var init_database = __esm({
     init_employees();
     _client = null;
     _resilientClient = null;
+    _daemonClient = null;
     initTurso = initDatabase;
     disposeTurso = disposeDatabase;
   }
@@ -2421,6 +2729,232 @@ var init_compress = __esm({
   }
 });
 
+// src/lib/crdt-sync.ts
+var crdt_sync_exports = {};
+__export(crdt_sync_exports, {
+  _setStatePath: () => _setStatePath,
+  applyRemoteUpdate: () => applyRemoteUpdate,
+  destroyCrdtDoc: () => destroyCrdtDoc,
+  getDiffUpdate: () => getDiffUpdate,
+  getFullState: () => getFullState,
+  getStateVector: () => getStateVector,
+  importExistingBehaviors: () => importExistingBehaviors,
+  importExistingMemories: () => importExistingMemories,
+  initCrdtDoc: () => initCrdtDoc,
+  isCrdtSyncEnabled: () => isCrdtSyncEnabled,
+  onUpdate: () => onUpdate,
+  readAllBehaviors: () => readAllBehaviors,
+  readAllMemories: () => readAllMemories,
+  rebuildFromDb: () => rebuildFromDb
+});
+import * as Y from "yjs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync7, mkdirSync as mkdirSync2, unlinkSync as unlinkSync4 } from "fs";
+import path7 from "path";
+import { homedir } from "os";
+function getStatePath() {
+  return _statePathOverride ?? DEFAULT_STATE_PATH;
+}
+function _setStatePath(p) {
+  _statePathOverride = p;
+}
+function initCrdtDoc() {
+  if (doc) return doc;
+  doc = new Y.Doc();
+  const sp = getStatePath();
+  if (existsSync7(sp)) {
+    try {
+      const state = readFileSync5(sp);
+      Y.applyUpdate(doc, new Uint8Array(state));
+    } catch {
+      console.warn("[crdt-sync] WARN: corrupted state file, rebuilding from DB");
+      try {
+        unlinkSync4(sp);
+      } catch {
+      }
+      rebuildFromDb().catch((err) => {
+        console.warn("[crdt-sync] rebuild from DB failed:", err);
+      });
+    }
+  }
+  doc.on("update", () => {
+    persistState();
+  });
+  return doc;
+}
+function getMemoriesMap() {
+  const d = initCrdtDoc();
+  return d.getMap("memories");
+}
+function getBehaviorsMap() {
+  const d = initCrdtDoc();
+  return d.getMap("behaviors");
+}
+function applyRemoteUpdate(update) {
+  const d = initCrdtDoc();
+  Y.applyUpdate(d, update);
+}
+function getFullState() {
+  const d = initCrdtDoc();
+  return Y.encodeStateAsUpdate(d);
+}
+function getDiffUpdate(remoteStateVector) {
+  const d = initCrdtDoc();
+  return Y.encodeStateAsUpdate(d, remoteStateVector);
+}
+function getStateVector() {
+  const d = initCrdtDoc();
+  return Y.encodeStateVector(d);
+}
+function importExistingMemories(memories) {
+  const map = getMemoriesMap();
+  const d = initCrdtDoc();
+  let imported = 0;
+  d.transact(() => {
+    for (const mem of memories) {
+      if (!mem.id) continue;
+      if (map.has(mem.id)) continue;
+      const entry = new Y.Map();
+      entry.set("id", mem.id);
+      entry.set("agent_id", mem.agent_id ?? null);
+      entry.set("agent_role", mem.agent_role ?? null);
+      entry.set("session_id", mem.session_id ?? null);
+      entry.set("timestamp", mem.timestamp ?? null);
+      entry.set("tool_name", mem.tool_name ?? null);
+      entry.set("project_name", mem.project_name ?? null);
+      entry.set("has_error", mem.has_error ?? 0);
+      entry.set("raw_text", mem.raw_text ?? "");
+      entry.set("version", mem.version ?? 0);
+      entry.set("author_device_id", mem.author_device_id ?? null);
+      entry.set("scope", mem.scope ?? "business");
+      map.set(mem.id, entry);
+      imported++;
+    }
+  });
+  return imported;
+}
+function importExistingBehaviors(behaviors) {
+  const map = getBehaviorsMap();
+  const d = initCrdtDoc();
+  let imported = 0;
+  d.transact(() => {
+    for (const beh of behaviors) {
+      if (!beh.id) continue;
+      if (map.has(beh.id)) continue;
+      const entry = new Y.Map();
+      entry.set("id", beh.id);
+      entry.set("agent_id", beh.agent_id ?? null);
+      entry.set("project_name", beh.project_name ?? null);
+      entry.set("domain", beh.domain ?? null);
+      entry.set("content", beh.content ?? null);
+      entry.set("active", beh.active ?? 1);
+      entry.set("priority", beh.priority ?? "p1");
+      entry.set("created_at", beh.created_at ?? null);
+      entry.set("updated_at", beh.updated_at ?? null);
+      map.set(beh.id, entry);
+      imported++;
+    }
+  });
+  return imported;
+}
+function readAllMemories() {
+  const map = getMemoriesMap();
+  const records = [];
+  map.forEach((entry, id) => {
+    records.push({
+      id,
+      agent_id: entry.get("agent_id"),
+      agent_role: entry.get("agent_role"),
+      session_id: entry.get("session_id"),
+      timestamp: entry.get("timestamp"),
+      tool_name: entry.get("tool_name"),
+      project_name: entry.get("project_name"),
+      has_error: entry.get("has_error"),
+      raw_text: entry.get("raw_text"),
+      version: entry.get("version"),
+      author_device_id: entry.get("author_device_id"),
+      scope: entry.get("scope")
+    });
+  });
+  return records;
+}
+function readAllBehaviors() {
+  const map = getBehaviorsMap();
+  const records = [];
+  map.forEach((entry, id) => {
+    records.push({
+      id,
+      agent_id: entry.get("agent_id"),
+      project_name: entry.get("project_name"),
+      domain: entry.get("domain"),
+      content: entry.get("content"),
+      active: entry.get("active"),
+      priority: entry.get("priority"),
+      created_at: entry.get("created_at"),
+      updated_at: entry.get("updated_at")
+    });
+  });
+  return records;
+}
+function onUpdate(callback) {
+  const d = initCrdtDoc();
+  const handler = (update) => callback(update);
+  d.on("update", handler);
+  return () => d.off("update", handler);
+}
+function persistState() {
+  if (!doc) return;
+  try {
+    const sp = getStatePath();
+    const dir = path7.dirname(sp);
+    if (!existsSync7(dir)) mkdirSync2(dir, { recursive: true });
+    const state = Y.encodeStateAsUpdate(doc);
+    writeFileSync3(sp, Buffer.from(state));
+  } catch {
+  }
+}
+function isCrdtSyncEnabled() {
+  return process.env.EXE_CRDT_SYNC !== "0";
+}
+async function rebuildFromDb() {
+  const { getClient: getClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
+  const client = getClient2();
+  const result = await client.execute(
+    "SELECT id, agent_id, agent_role, session_id, timestamp, tool_name, project_name, has_error, raw_text, version, author_device_id, scope FROM memories"
+  );
+  const memories = result.rows.map((row) => ({
+    id: String(row.id),
+    agent_id: row.agent_id,
+    agent_role: row.agent_role,
+    session_id: row.session_id,
+    timestamp: row.timestamp,
+    tool_name: row.tool_name,
+    project_name: row.project_name,
+    has_error: row.has_error,
+    raw_text: row.raw_text,
+    version: row.version,
+    author_device_id: row.author_device_id,
+    scope: row.scope
+  }));
+  const count = importExistingMemories(memories);
+  persistState();
+  return count;
+}
+function destroyCrdtDoc() {
+  if (doc) {
+    doc.destroy();
+    doc = null;
+  }
+}
+var DEFAULT_STATE_PATH, _statePathOverride, doc;
+var init_crdt_sync = __esm({
+  "src/lib/crdt-sync.ts"() {
+    "use strict";
+    DEFAULT_STATE_PATH = path7.join(homedir(), ".exe-os", "crdt-state.bin");
+    _statePathOverride = null;
+    doc = null;
+  }
+});
+
 // src/lib/cloud-sync.ts
 var cloud_sync_exports = {};
 __export(cloud_sync_exports, {
@@ -2449,16 +2983,16 @@ __export(cloud_sync_exports, {
   mergeRosterFromRemote: () => mergeRosterFromRemote,
   recordRosterDeletion: () => recordRosterDeletion
 });
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync7, readdirSync, mkdirSync as mkdirSync2, appendFileSync, unlinkSync as unlinkSync4, openSync as openSync2, closeSync as closeSync2 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync8, readdirSync, mkdirSync as mkdirSync3, appendFileSync, unlinkSync as unlinkSync5, openSync as openSync2, closeSync as closeSync2 } from "fs";
 import crypto2 from "crypto";
-import path7 from "path";
-import { homedir } from "os";
+import path8 from "path";
+import { homedir as homedir2 } from "os";
 function sqlSafe(v) {
   return v === void 0 ? null : v;
 }
 function logError(msg) {
   try {
-    const logPath = path7.join(homedir(), ".exe-os", "workers.log");
+    const logPath = path8.join(homedir2(), ".exe-os", "workers.log");
     appendFileSync(logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
 `);
   } catch {
@@ -2468,18 +3002,18 @@ async function withRosterLock(fn) {
   try {
     const fd = openSync2(ROSTER_LOCK_PATH, "wx");
     closeSync2(fd);
-    writeFileSync3(ROSTER_LOCK_PATH, String(Date.now()));
+    writeFileSync4(ROSTER_LOCK_PATH, String(Date.now()));
   } catch (err) {
     if (err.code === "EEXIST") {
       try {
-        const ts = parseInt(readFileSync5(ROSTER_LOCK_PATH, "utf-8"), 10);
+        const ts = parseInt(readFileSync6(ROSTER_LOCK_PATH, "utf-8"), 10);
         if (Date.now() - ts < LOCK_STALE_MS) {
           throw new Error("Roster merge already in progress \u2014 another sync is running");
         }
-        unlinkSync4(ROSTER_LOCK_PATH);
+        unlinkSync5(ROSTER_LOCK_PATH);
         const fd = openSync2(ROSTER_LOCK_PATH, "wx");
         closeSync2(fd);
-        writeFileSync3(ROSTER_LOCK_PATH, String(Date.now()));
+        writeFileSync4(ROSTER_LOCK_PATH, String(Date.now()));
       } catch (retryErr) {
         if (retryErr instanceof Error && retryErr.message.includes("already in progress")) throw retryErr;
         throw new Error("Roster merge already in progress \u2014 another sync is running");
@@ -2492,7 +3026,7 @@ async function withRosterLock(fn) {
     return await fn();
   } finally {
     try {
-      unlinkSync4(ROSTER_LOCK_PATH);
+      unlinkSync5(ROSTER_LOCK_PATH);
     } catch {
     }
   }
@@ -2637,29 +3171,75 @@ async function cloudSync(config) {
   const pullResult = await cloudPull(lastPullVersion, config);
   let pulled = 0;
   if (pullResult.records.length > 0) {
-    const stmts = pullResult.records.map((rec) => ({
-      sql: `INSERT OR REPLACE INTO memories
-            (id, agent_id, agent_role, session_id, timestamp,
-             tool_name, project_name, has_error, raw_text, version,
-             author_device_id, scope)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-      args: [
-        sqlSafe(rec.id),
-        sqlSafe(rec.agent_id),
-        sqlSafe(rec.agent_role),
-        sqlSafe(rec.session_id),
-        sqlSafe(rec.timestamp),
-        sqlSafe(rec.tool_name),
-        sqlSafe(rec.project_name),
-        sqlSafe(rec.has_error ?? 0),
-        sqlSafe(rec.raw_text ?? ""),
-        sqlSafe(rec.version ?? 0),
-        sqlSafe(rec.author_device_id),
-        sqlSafe(rec.scope ?? "business")
-      ]
-    }));
-    await client.batch(stmts, "write");
-    pulled = pullResult.records.length;
+    if (isCrdtSyncEnabled()) {
+      const { initCrdtDoc: initCrdtDoc2, importExistingMemories: importExistingMemories2, readAllMemories: readAllMemories2 } = await Promise.resolve().then(() => (init_crdt_sync(), crdt_sync_exports));
+      initCrdtDoc2();
+      importExistingMemories2(
+        pullResult.records.map((rec) => ({
+          id: String(rec.id ?? ""),
+          agent_id: rec.agent_id,
+          agent_role: rec.agent_role,
+          session_id: rec.session_id,
+          timestamp: rec.timestamp,
+          tool_name: rec.tool_name,
+          project_name: rec.project_name,
+          has_error: rec.has_error ?? 0,
+          raw_text: rec.raw_text ?? "",
+          version: rec.version ?? 0,
+          author_device_id: rec.author_device_id,
+          scope: rec.scope ?? "business"
+        }))
+      );
+      const pulledIds = new Set(pullResult.records.map((r) => String(r.id ?? "")));
+      const merged = readAllMemories2().filter((rec) => pulledIds.has(rec.id));
+      const stmts = merged.map((rec) => ({
+        sql: `INSERT OR REPLACE INTO memories
+              (id, agent_id, agent_role, session_id, timestamp,
+               tool_name, project_name, has_error, raw_text, version,
+               author_device_id, scope)
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        args: [
+          sqlSafe(rec.id),
+          sqlSafe(rec.agent_id),
+          sqlSafe(rec.agent_role),
+          sqlSafe(rec.session_id),
+          sqlSafe(rec.timestamp),
+          sqlSafe(rec.tool_name),
+          sqlSafe(rec.project_name),
+          sqlSafe(rec.has_error ?? 0),
+          sqlSafe(rec.raw_text ?? ""),
+          sqlSafe(rec.version ?? 0),
+          sqlSafe(rec.author_device_id),
+          sqlSafe(rec.scope ?? "business")
+        ]
+      }));
+      if (stmts.length > 0) await client.batch(stmts, "write");
+      pulled = pullResult.records.length;
+    } else {
+      const stmts = pullResult.records.map((rec) => ({
+        sql: `INSERT OR REPLACE INTO memories
+              (id, agent_id, agent_role, session_id, timestamp,
+               tool_name, project_name, has_error, raw_text, version,
+               author_device_id, scope)
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        args: [
+          sqlSafe(rec.id),
+          sqlSafe(rec.agent_id),
+          sqlSafe(rec.agent_role),
+          sqlSafe(rec.session_id),
+          sqlSafe(rec.timestamp),
+          sqlSafe(rec.tool_name),
+          sqlSafe(rec.project_name),
+          sqlSafe(rec.has_error ?? 0),
+          sqlSafe(rec.raw_text ?? ""),
+          sqlSafe(rec.version ?? 0),
+          sqlSafe(rec.author_device_id),
+          sqlSafe(rec.scope ?? "business")
+        ]
+      }));
+      await client.batch(stmts, "write");
+      pulled = pullResult.records.length;
+    }
   }
   if (pullResult.maxVersion > lastPullVersion) {
     await client.execute({
@@ -2807,8 +3387,8 @@ async function cloudSync(config) {
   try {
     const employees = await loadEmployees();
     rosterResult.employees = employees.length;
-    const idDir = path7.join(EXE_AI_DIR, "identity");
-    if (existsSync7(idDir)) {
+    const idDir = path8.join(EXE_AI_DIR, "identity");
+    if (existsSync8(idDir)) {
       rosterResult.identities = readdirSync(idDir).filter((f) => f.endsWith(".md")).length;
     }
   } catch {
@@ -2829,55 +3409,63 @@ async function cloudSync(config) {
 function recordRosterDeletion(name) {
   let deletions = [];
   try {
-    if (existsSync7(ROSTER_DELETIONS_PATH)) {
-      deletions = JSON.parse(readFileSync5(ROSTER_DELETIONS_PATH, "utf-8"));
+    if (existsSync8(ROSTER_DELETIONS_PATH)) {
+      deletions = JSON.parse(readFileSync6(ROSTER_DELETIONS_PATH, "utf-8"));
     }
   } catch {
   }
   if (!deletions.includes(name)) deletions.push(name);
-  writeFileSync3(ROSTER_DELETIONS_PATH, JSON.stringify(deletions));
+  writeFileSync4(ROSTER_DELETIONS_PATH, JSON.stringify(deletions));
 }
 function consumeRosterDeletions() {
   try {
-    if (!existsSync7(ROSTER_DELETIONS_PATH)) return [];
-    const deletions = JSON.parse(readFileSync5(ROSTER_DELETIONS_PATH, "utf-8"));
-    writeFileSync3(ROSTER_DELETIONS_PATH, "[]");
+    if (!existsSync8(ROSTER_DELETIONS_PATH)) return [];
+    const deletions = JSON.parse(readFileSync6(ROSTER_DELETIONS_PATH, "utf-8"));
+    writeFileSync4(ROSTER_DELETIONS_PATH, "[]");
     return deletions;
   } catch {
     return [];
   }
 }
 function buildRosterBlob(paths) {
-  const rosterPath = paths?.rosterPath ?? path7.join(EXE_AI_DIR, "exe-employees.json");
-  const identityDir = paths?.identityDir ?? path7.join(EXE_AI_DIR, "identity");
-  const configPath = paths?.configPath ?? path7.join(EXE_AI_DIR, "config.json");
+  const rosterPath = paths?.rosterPath ?? path8.join(EXE_AI_DIR, "exe-employees.json");
+  const identityDir = paths?.identityDir ?? path8.join(EXE_AI_DIR, "identity");
+  const configPath = paths?.configPath ?? path8.join(EXE_AI_DIR, "config.json");
   let roster = [];
-  if (existsSync7(rosterPath)) {
+  if (existsSync8(rosterPath)) {
     try {
-      roster = JSON.parse(readFileSync5(rosterPath, "utf-8"));
+      roster = JSON.parse(readFileSync6(rosterPath, "utf-8"));
     } catch {
     }
   }
   const identities = {};
-  if (existsSync7(identityDir)) {
+  if (existsSync8(identityDir)) {
     for (const file of readdirSync(identityDir).filter((f) => f.endsWith(".md"))) {
       try {
-        identities[file] = readFileSync5(path7.join(identityDir, file), "utf-8");
+        identities[file] = readFileSync6(path8.join(identityDir, file), "utf-8");
       } catch {
       }
     }
   }
   let config;
-  if (existsSync7(configPath)) {
+  if (existsSync8(configPath)) {
     try {
-      config = JSON.parse(readFileSync5(configPath, "utf-8"));
+      config = JSON.parse(readFileSync6(configPath, "utf-8"));
+    } catch {
+    }
+  }
+  let agentConfig;
+  const agentConfigPath = path8.join(EXE_AI_DIR, "agent-config.json");
+  if (existsSync8(agentConfigPath)) {
+    try {
+      agentConfig = JSON.parse(readFileSync6(agentConfigPath, "utf-8"));
     } catch {
     }
   }
   const deletedNames = consumeRosterDeletions();
-  const content = JSON.stringify({ roster, identities, config, deletedNames });
+  const content = JSON.stringify({ roster, identities, config, agentConfig, deletedNames });
   const hash = crypto2.createHash("sha256").update(content).digest("hex").slice(0, 16);
-  return { roster, identities, config, deletedNames, version: hash };
+  return { roster, identities, config, agentConfig, deletedNames, version: hash };
 }
 async function cloudPushRoster(config) {
   assertSecureEndpoint(config.endpoint);
@@ -2946,23 +3534,23 @@ async function cloudPullRoster(config) {
   }
 }
 function mergeConfig(remoteConfig, configPath) {
-  const cfgPath = configPath ?? path7.join(EXE_AI_DIR, "config.json");
+  const cfgPath = configPath ?? path8.join(EXE_AI_DIR, "config.json");
   let local = {};
-  if (existsSync7(cfgPath)) {
+  if (existsSync8(cfgPath)) {
     try {
-      local = JSON.parse(readFileSync5(cfgPath, "utf-8"));
+      local = JSON.parse(readFileSync6(cfgPath, "utf-8"));
     } catch {
     }
   }
   const merged = { ...remoteConfig, ...local };
-  const dir = path7.dirname(cfgPath);
-  if (!existsSync7(dir)) mkdirSync2(dir, { recursive: true });
-  writeFileSync3(cfgPath, JSON.stringify(merged, null, 2), "utf-8");
+  const dir = path8.dirname(cfgPath);
+  if (!existsSync8(dir)) mkdirSync3(dir, { recursive: true });
+  writeFileSync4(cfgPath, JSON.stringify(merged, null, 2), "utf-8");
 }
 async function mergeRosterFromRemote(remote, paths) {
   return withRosterLock(async () => {
     const rosterPath = paths?.rosterPath ?? void 0;
-    const identityDir = paths?.identityDir ?? path7.join(EXE_AI_DIR, "identity");
+    const identityDir = paths?.identityDir ?? path8.join(EXE_AI_DIR, "identity");
     const localEmployees = await loadEmployees(rosterPath);
     const localNames = new Set(localEmployees.map((e) => e.name));
     let added = 0;
@@ -2983,15 +3571,15 @@ async function mergeRosterFromRemote(remote, paths) {
       ) ?? lookupKey;
       const remoteIdentity = remote.identities[matchedKey];
       if (remoteIdentity) {
-        if (!existsSync7(identityDir)) mkdirSync2(identityDir, { recursive: true });
-        const idPath = path7.join(identityDir, `${remoteEmp.name}.md`);
+        if (!existsSync8(identityDir)) mkdirSync3(identityDir, { recursive: true });
+        const idPath = path8.join(identityDir, `${remoteEmp.name}.md`);
         let localIdentity = null;
         try {
-          localIdentity = existsSync7(idPath) ? readFileSync5(idPath, "utf-8") : null;
+          localIdentity = existsSync8(idPath) ? readFileSync6(idPath, "utf-8") : null;
         } catch {
         }
         if (localIdentity !== remoteIdentity) {
-          writeFileSync3(idPath, remoteIdentity, "utf-8");
+          writeFileSync4(idPath, remoteIdentity, "utf-8");
           identitiesUpdated++;
         }
       }
@@ -3015,6 +3603,21 @@ async function mergeRosterFromRemote(remote, paths) {
       } catch {
       }
     }
+    if (remote.agentConfig && Object.keys(remote.agentConfig).length > 0) {
+      try {
+        const agentConfigPath = path8.join(EXE_AI_DIR, "agent-config.json");
+        let local = {};
+        if (existsSync8(agentConfigPath)) {
+          try {
+            local = JSON.parse(readFileSync6(agentConfigPath, "utf-8"));
+          } catch {
+          }
+        }
+        const merged = { ...remote.agentConfig, ...local };
+        writeFileSync4(agentConfigPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+      } catch {
+      }
+    }
     return { added, identitiesUpdated };
   });
 }
@@ -3444,13 +4047,14 @@ var init_cloud_sync = __esm({
     init_compress();
     init_license();
     init_config();
+    init_crdt_sync();
     init_employees();
     LOCALHOST_PATTERNS = /^(localhost|127\.0\.0\.1|\[::1\])$/i;
     FETCH_TIMEOUT_MS = 3e4;
     PUSH_BATCH_SIZE = 5e3;
-    ROSTER_LOCK_PATH = path7.join(EXE_AI_DIR, "roster-merge.lock");
+    ROSTER_LOCK_PATH = path8.join(EXE_AI_DIR, "roster-merge.lock");
     LOCK_STALE_MS = 3e4;
-    ROSTER_DELETIONS_PATH = path7.join(EXE_AI_DIR, "roster-deletions.json");
+    ROSTER_DELETIONS_PATH = path8.join(EXE_AI_DIR, "roster-deletions.json");
   }
 });
 
@@ -4215,17 +4819,17 @@ __export(identity_exports, {
   listIdentities: () => listIdentities,
   updateIdentity: () => updateIdentity
 });
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
 import { readdirSync as readdirSync2 } from "fs";
-import path8 from "path";
+import path9 from "path";
 import { createHash as createHash2 } from "crypto";
 function ensureDir() {
-  if (!existsSync8(IDENTITY_DIR)) {
-    mkdirSync3(IDENTITY_DIR, { recursive: true });
+  if (!existsSync9(IDENTITY_DIR)) {
+    mkdirSync4(IDENTITY_DIR, { recursive: true });
   }
 }
 function identityPath(agentId) {
-  return path8.join(IDENTITY_DIR, `${agentId}.md`);
+  return path9.join(IDENTITY_DIR, `${agentId}.md`);
 }
 function parseFrontmatter(raw) {
   const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
@@ -4266,8 +4870,8 @@ function contentHash(content) {
 }
 function getIdentity(agentId) {
   const filePath = identityPath(agentId);
-  if (!existsSync8(filePath)) return null;
-  const raw = readFileSync6(filePath, "utf-8");
+  if (!existsSync9(filePath)) return null;
+  const raw = readFileSync7(filePath, "utf-8");
   const { frontmatter, body } = parseFrontmatter(raw);
   return {
     agentId,
@@ -4281,7 +4885,7 @@ async function updateIdentity(agentId, content, updatedBy) {
   ensureDir();
   const filePath = identityPath(agentId);
   const hash = contentHash(content);
-  writeFileSync4(filePath, content, "utf-8");
+  writeFileSync5(filePath, content, "utf-8");
   try {
     const client = getClient();
     await client.execute({
@@ -4337,7 +4941,7 @@ var init_identity = __esm({
     "use strict";
     init_config();
     init_database();
-    IDENTITY_DIR = path8.join(EXE_AI_DIR, "identity");
+    IDENTITY_DIR = path9.join(EXE_AI_DIR, "identity");
   }
 });
 
@@ -4877,36 +5481,36 @@ __export(session_wrappers_exports, {
   generateSessionWrappers: () => generateSessionWrappers
 });
 import {
-  existsSync as existsSync9,
-  readFileSync as readFileSync7,
-  writeFileSync as writeFileSync5,
-  mkdirSync as mkdirSync4,
+  existsSync as existsSync10,
+  readFileSync as readFileSync8,
+  writeFileSync as writeFileSync6,
+  mkdirSync as mkdirSync5,
   chmodSync,
   readdirSync as readdirSync3,
-  unlinkSync as unlinkSync5
+  unlinkSync as unlinkSync6
 } from "fs";
-import path9 from "path";
-import { homedir as homedir2 } from "os";
+import path10 from "path";
+import { homedir as homedir3 } from "os";
 function generateSessionWrappers(packageRoot, homeDir) {
-  const home = homeDir ?? homedir2();
-  const binDir = path9.join(home, ".exe-os", "bin");
-  const rosterPath = path9.join(home, ".exe-os", "exe-employees.json");
-  mkdirSync4(binDir, { recursive: true });
-  const exeStartDst = path9.join(binDir, "exe-start");
+  const home = homeDir ?? homedir3();
+  const binDir = path10.join(home, ".exe-os", "bin");
+  const rosterPath = path10.join(home, ".exe-os", "exe-employees.json");
+  mkdirSync5(binDir, { recursive: true });
+  const exeStartDst = path10.join(binDir, "exe-start");
   const candidates = [
-    path9.join(packageRoot, "dist", "bin", "exe-start.sh"),
-    path9.join(packageRoot, "src", "bin", "exe-start.sh")
+    path10.join(packageRoot, "dist", "bin", "exe-start.sh"),
+    path10.join(packageRoot, "src", "bin", "exe-start.sh")
   ];
   for (const src of candidates) {
-    if (existsSync9(src)) {
-      writeFileSync5(exeStartDst, readFileSync7(src));
+    if (existsSync10(src)) {
+      writeFileSync6(exeStartDst, readFileSync8(src));
       chmodSync(exeStartDst, 493);
       break;
     }
   }
   let employees = [];
   try {
-    employees = JSON.parse(readFileSync7(rosterPath, "utf8"));
+    employees = JSON.parse(readFileSync8(rosterPath, "utf8"));
   } catch {
     return { created: 0, pathConfigured: false };
   }
@@ -4916,11 +5520,11 @@ function generateSessionWrappers(packageRoot, homeDir) {
   try {
     for (const f of readdirSync3(binDir)) {
       if (f === "exe-start") continue;
-      const fPath = path9.join(binDir, f);
+      const fPath = path10.join(binDir, f);
       try {
-        const content = readFileSync7(fPath, "utf8");
+        const content = readFileSync8(fPath, "utf8");
         if (content.includes("exe-start")) {
-          unlinkSync5(fPath);
+          unlinkSync6(fPath);
         }
       } catch {
       }
@@ -4933,8 +5537,30 @@ exec "${exeStartDst}" "$0" "$@"
 `;
   for (const emp of employees) {
     for (let n = 1; n <= MAX_N; n++) {
-      const wrapperPath = path9.join(binDir, `${emp.name}${n}`);
-      writeFileSync5(wrapperPath, wrapperContent);
+      const wrapperPath = path10.join(binDir, `${emp.name}${n}`);
+      writeFileSync6(wrapperPath, wrapperContent);
+      chmodSync(wrapperPath, 493);
+      created++;
+    }
+  }
+  const codexLauncherCandidates = [
+    path10.join(packageRoot, "dist", "bin", "exe-start-codex.js"),
+    path10.join(packageRoot, "src", "bin", "exe-start-codex.ts")
+  ];
+  let codexLauncher = null;
+  for (const c of codexLauncherCandidates) {
+    if (existsSync10(c)) {
+      codexLauncher = c;
+      break;
+    }
+  }
+  if (codexLauncher) {
+    for (const emp of employees) {
+      const wrapperPath = path10.join(binDir, `${emp.name}-codex`);
+      const content = `#!/bin/bash
+exec node "${codexLauncher}" --agent ${emp.name} "$@"
+`;
+      writeFileSync6(wrapperPath, content);
       chmodSync(wrapperPath, 493);
       created++;
     }
@@ -4953,24 +5579,24 @@ export PATH="${binDir}:$PATH"
   const shell = process.env.SHELL ?? "/bin/bash";
   const profilePaths = [];
   if (shell.includes("zsh")) {
-    profilePaths.push(path9.join(home, ".zshrc"));
+    profilePaths.push(path10.join(home, ".zshrc"));
   } else if (shell.includes("bash")) {
-    profilePaths.push(path9.join(home, ".bashrc"));
-    profilePaths.push(path9.join(home, ".bash_profile"));
+    profilePaths.push(path10.join(home, ".bashrc"));
+    profilePaths.push(path10.join(home, ".bash_profile"));
   } else {
-    profilePaths.push(path9.join(home, ".profile"));
+    profilePaths.push(path10.join(home, ".profile"));
   }
   for (const profilePath of profilePaths) {
     try {
       let content = "";
       try {
-        content = readFileSync7(profilePath, "utf8");
+        content = readFileSync8(profilePath, "utf8");
       } catch {
       }
       if (content.includes(".exe-os/bin")) {
         return false;
       }
-      writeFileSync5(profilePath, content + exportLine);
+      writeFileSync6(profilePath, content + exportLine);
       return true;
     } catch {
       continue;
@@ -4990,9 +5616,9 @@ var init_session_wrappers = __esm({
 init_config();
 init_keychain();
 import crypto3 from "crypto";
-import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync6, unlinkSync as unlinkSync6 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync7, unlinkSync as unlinkSync7 } from "fs";
 import os4 from "os";
-import path10 from "path";
+import path11 from "path";
 import { createInterface } from "readline";
 
 // src/lib/model-downloader.ts
@@ -5084,36 +5710,36 @@ async function fileHash(filePath) {
 
 // src/lib/setup-wizard.ts
 function findPackageRoot2() {
-  let dir = path10.dirname(new URL(import.meta.url).pathname);
-  const root = path10.parse(dir).root;
+  let dir = path11.dirname(new URL(import.meta.url).pathname);
+  const root = path11.parse(dir).root;
   while (dir !== root) {
-    const pkgPath = path10.join(dir, "package.json");
-    if (existsSync10(pkgPath)) {
+    const pkgPath = path11.join(dir, "package.json");
+    if (existsSync11(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
         if (pkg.name === "@askexenow/exe-os" || pkg.name === "exe-os") return dir;
       } catch {
       }
     }
-    dir = path10.dirname(dir);
+    dir = path11.dirname(dir);
   }
   return null;
 }
-var SETUP_STATE_PATH = path10.join(os4.homedir(), ".exe-os", "setup-state.json");
+var SETUP_STATE_PATH = path11.join(os4.homedir(), ".exe-os", "setup-state.json");
 function loadSetupState() {
   try {
-    return JSON.parse(readFileSync8(SETUP_STATE_PATH, "utf8"));
+    return JSON.parse(readFileSync9(SETUP_STATE_PATH, "utf8"));
   } catch {
     return { completedSteps: [], startedAt: (/* @__PURE__ */ new Date()).toISOString() };
   }
 }
 function saveSetupState(state) {
-  mkdirSync5(path10.dirname(SETUP_STATE_PATH), { recursive: true });
-  writeFileSync6(SETUP_STATE_PATH, JSON.stringify(state, null, 2));
+  mkdirSync6(path11.dirname(SETUP_STATE_PATH), { recursive: true });
+  writeFileSync7(SETUP_STATE_PATH, JSON.stringify(state, null, 2));
 }
 function clearSetupState() {
   try {
-    unlinkSync6(SETUP_STATE_PATH);
+    unlinkSync7(SETUP_STATE_PATH);
   } catch {
   }
 }
@@ -5207,7 +5833,7 @@ async function runSetupWizard(opts = {}) {
     if (state.completedSteps.length > 0) {
       log(`Resuming setup from step ${Math.max(...state.completedSteps) + 1}...`);
     }
-    if (existsSync10(LEGACY_LANCE_PATH)) {
+    if (existsSync11(LEGACY_LANCE_PATH)) {
       log("\u26A0 Found v1.0 LanceDB at ~/.exe-os/local.lance");
       log("  v1.1 uses libSQL (SQLite). Your existing memories are not automatically migrated.");
       log("  The old directory will not be modified or deleted.");
@@ -5355,10 +5981,10 @@ async function runSetupWizard(opts = {}) {
       await saveConfig(config);
       log("");
       try {
-        const claudeJsonPath = path10.join(os4.homedir(), ".claude.json");
+        const claudeJsonPath = path11.join(os4.homedir(), ".claude.json");
         let claudeJson = {};
         try {
-          claudeJson = JSON.parse(readFileSync8(claudeJsonPath, "utf8"));
+          claudeJson = JSON.parse(readFileSync9(claudeJsonPath, "utf8"));
         } catch {
         }
         if (!claudeJson.projects) claudeJson.projects = {};
@@ -5367,7 +5993,7 @@ async function runSetupWizard(opts = {}) {
           if (!projects[dir]) projects[dir] = {};
           projects[dir].hasTrustDialogAccepted = true;
         }
-        writeFileSync6(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+        writeFileSync7(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
       } catch {
       }
       state.completedSteps.push(5);
@@ -5406,7 +6032,7 @@ async function runSetupWizard(opts = {}) {
       let missingIdentities = [];
       for (const emp of roster) {
         const idPath = identityPath2(emp.name);
-        if (!existsSync10(idPath)) {
+        if (!existsSync11(idPath)) {
           missingIdentities.push(emp.name);
         }
       }
@@ -5438,7 +6064,7 @@ async function runSetupWizard(opts = {}) {
           }
           missingIdentities = [];
           for (const emp of roster) {
-            if (!existsSync10(identityPath2(emp.name))) {
+            if (!existsSync11(identityPath2(emp.name))) {
               missingIdentities.push(emp.name);
             }
           }
@@ -5469,11 +6095,12 @@ async function runSetupWizard(opts = {}) {
       saveSetupState(state);
       log("");
     } else if (!state.completedSteps.includes(6)) {
-      log("=== Your Team ===");
+      log("=== Your First Hire ===");
       log("");
-      log("Every install starts with a COO \u2014 your right-hand operator.");
-      log("They hold the big picture: priorities, progress, and blockers.");
-      log("You talk to them. They coordinate everyone else.");
+      log("Until now, you talked to one agent at a time.");
+      log("Your COO changes that. You talk to them \u2014 they coordinate");
+      log("your entire team. Engineers, marketers, specialists, all working");
+      log("in parallel while you focus on what matters.");
       log("");
       const cooNameInput = await ask(rl, "Name your COO (default: exe): ");
       cooName = (cooNameInput || "exe").toLowerCase();
@@ -5494,9 +6121,9 @@ async function runSetupWizard(opts = {}) {
       const cooIdentityContent = getIdentityTemplate("coo");
       if (cooIdentityContent) {
         const cooIdPath = identityPath2(cooName);
-        mkdirSync5(path10.dirname(cooIdPath), { recursive: true });
+        mkdirSync6(path11.dirname(cooIdPath), { recursive: true });
         const replaced = cooIdentityContent.replace(/agent_id:\s*exe/g, `agent_id: ${cooName}`).replace(/\$\{agent_id\}/g, cooName);
-        writeFileSync6(cooIdPath, replaced, "utf-8");
+        writeFileSync7(cooIdPath, replaced, "utf-8");
       }
       registerBinSymlinks2(cooName);
       createdEmployees.push({ name: cooName, role: "COO" });
@@ -5510,134 +6137,123 @@ async function runSetupWizard(opts = {}) {
     }
     log("");
     if (!state.completedSteps.includes(7)) {
-      log("=== Meet Your Specialists ===");
-      log("");
-      log("Your COO coordinates specialists. Here's who you can hire:");
-      log("");
-      log("  CTO (default: yoshi)");
-      log("  Your head of engineering. Architecture, code reviews, tech decisions.");
-      log("  Manages your projects and delegates to engineers when there's parallel work.");
-      log("");
-      log("  CMO (default: mari)");
-      log("  Design, brand, content, SEO. Builds your visual identity, writes");
-      log("  your copy, and gets you found online. Delegates to content specialists.");
-      log("");
-      log("Why separate roles instead of one AI that does everything?");
-      log("");
-      log("Memory saturates. One agent juggling architecture decisions AND landing page");
-      log("copy AND CI/CD AND social media loses context on all of them. Competing");
-      log("priorities \u2014 should I fix the auth bug or write the blog post? When you split");
-      log("responsibilities, each specialist stays sharp because they stay focused.");
-      log("Your COO connects them so nothing falls through the cracks.");
-      log("");
-      log("This is how real companies scale \u2014 you're just doing it with AI");
-      log("instead of headcount.");
-      log("");
-      await ask(rl, "Press Enter to continue. ");
-      state.completedSteps.push(7);
-      saveSetupState(state);
-    } else {
-      log("Step 7 already complete \u2014 skipping.");
-    }
-    if (!state.completedSteps.includes(8)) {
-      let employees = await loadEmployees2(EMPLOYEES_PATH2).catch(() => []);
       let license;
       try {
         license = await checkLicense2();
       } catch {
         license = { valid: true, plan: "free", email: "", expiresAt: null, deviceLimit: 1, employeeLimit: 2, memoryLimit: 1e3 };
       }
-      if (license.plan === "free") {
-        log("Your plan: Free \u2014 1 employee (your COO)");
-        log("");
-        log("The CTO and CMO are available on Solopreneur ($97/mo) \u2014 full engineering");
-        log("and marketing team, unlimited tasks, priority support.");
-        log("Get your key at https://askexe.com, then paste it here.");
-        log("");
-        const licenseInput = await ask(rl, "License key (or press Enter to skip): ");
-        if (licenseInput.startsWith("exe_sk_")) {
+      let isLicensed = license.valid && license.plan !== "free";
+      if (!isLicensed) {
+        let licenseInput = await ask(rl, "Do you have an Exe OS license key? (press Enter to skip for free plan): ");
+        if (licenseInput && !licenseInput.startsWith("exe_sk_")) {
+          log("That doesn't look like a license key (should start with exe_sk_).");
+          licenseInput = await ask(rl, "Try again (or press Enter to skip): ");
+        }
+        if (licenseInput && licenseInput.startsWith("exe_sk_")) {
           saveLicense2(licenseInput);
           mirrorLicenseKey2(licenseInput);
           try {
-            license = await validateLicense2(licenseInput);
+            const result = await validateLicense2(licenseInput);
+            if (result.valid && result.plan !== "free") {
+              isLicensed = true;
+              const planName = result.plan === "pro" ? "Solopreneur" : result.plan.charAt(0).toUpperCase() + result.plan.slice(1);
+              log(`License activated. Plan: ${planName}`);
+            } else if (!result.valid) {
+              log("That license key is invalid or expired.");
+              log("Get a new key at askexe.com.");
+            } else {
+              log("Key saved for cloud sync, but specialists require a paid plan.");
+              log("Upgrade at askexe.com when you're ready.");
+            }
           } catch {
-            log("Couldn't reach the license server \u2014 your key has been saved.");
-            log("Run exe-os --activate <key> anytime to finish activation.");
+            isLicensed = true;
+            log("Couldn't reach the license server \u2014 key saved, specialists enabled.");
           }
-        } else if (!licenseInput) {
-          log("You can activate anytime with: exe-os --activate <key>");
-        } else {
-          log("That doesn't look like a license key (should start with exe_sk_).");
-          log("You can activate anytime with: exe-os --activate <key>");
         }
       }
-      if (license.plan !== "free") {
-        const planName = license.plan === "pro" ? "Solopreneur" : license.plan.charAt(0).toUpperCase() + license.plan.slice(1);
-        log(`Your plan: ${planName} (up to ${license.employeeLimit} employees)`);
+      if (!isLicensed) {
         log("");
-        const createCto = await ask(rl, "Create your CTO? (Y/n): ");
-        if (createCto.toLowerCase() !== "n") {
-          const ctoTemplate = getTemplateByRole2("CTO");
-          const ctoDefault = ctoTemplate?.name ?? "cto";
-          const ctoNameInput = await ask(rl, `Name your CTO (default: ${ctoDefault}): `);
-          const ctoName = (ctoNameInput || ctoDefault).toLowerCase();
-          if (!employees.some((e) => e.name === ctoName)) {
-            const { personalizePrompt: personalizeCto } = await Promise.resolve().then(() => (init_employee_templates(), employee_templates_exports));
-            const ctoEmployee = {
-              name: ctoName,
-              role: "CTO",
-              systemPrompt: personalizeCto(ctoTemplate?.systemPrompt ?? "", ctoDefault, ctoName),
-              createdAt: (/* @__PURE__ */ new Date()).toISOString()
-            };
-            employees = addEmployee2(employees, ctoEmployee);
-            await saveEmployees2(employees, EMPLOYEES_PATH2);
-          }
-          const ctoIdentityContent = getIdentityTemplate("cto");
-          if (ctoIdentityContent) {
-            const ctoIdPath = identityPath2(ctoName);
-            mkdirSync5(path10.dirname(ctoIdPath), { recursive: true });
-            const replaced = ctoIdentityContent.replace(/agent_id:\s*\w+/g, `agent_id: ${ctoName}`).replace(/\$\{agent_id\}/g, ctoName);
-            writeFileSync6(ctoIdPath, replaced, "utf-8");
-          }
-          registerBinSymlinks2(ctoName);
-          createdEmployees.push({ name: ctoName, role: "CTO" });
-          log(`Created ${ctoName} (CTO)`);
-        }
-        const createCmo = await ask(rl, "Create your CMO? (Y/n): ");
-        if (createCmo.toLowerCase() !== "n") {
-          const cmoTemplate = getTemplateByRole2("CMO");
-          const cmoDefault = cmoTemplate?.name ?? "cmo";
-          const cmoNameInput = await ask(rl, `Name your CMO (default: ${cmoDefault}): `);
-          const cmoName = (cmoNameInput || cmoDefault).toLowerCase();
-          if (!employees.some((e) => e.name === cmoName)) {
-            const { personalizePrompt: personalizeCmo } = await Promise.resolve().then(() => (init_employee_templates(), employee_templates_exports));
-            const cmoEmployee = {
-              name: cmoName,
-              role: "CMO",
-              systemPrompt: personalizeCmo(cmoTemplate?.systemPrompt ?? "", cmoDefault, cmoName),
-              createdAt: (/* @__PURE__ */ new Date()).toISOString()
-            };
-            employees = addEmployee2(employees, cmoEmployee);
-            await saveEmployees2(employees, EMPLOYEES_PATH2);
-          }
-          const cmoIdentityContent = getIdentityTemplate("cmo");
-          if (cmoIdentityContent) {
-            const cmoIdPath = identityPath2(cmoName);
-            mkdirSync5(path10.dirname(cmoIdPath), { recursive: true });
-            const replaced = cmoIdentityContent.replace(/agent_id:\s*\w+/g, `agent_id: ${cmoName}`).replace(/\$\{agent_id\}/g, cmoName);
-            writeFileSync6(cmoIdPath, replaced, "utf-8");
-          }
-          registerBinSymlinks2(cmoName);
-          createdEmployees.push({ name: cmoName, role: "CMO" });
-          log(`Created ${cmoName} (CMO)`);
-        }
+        log("You're all set. Your COO handles everything from here.");
+        log("When you're ready for specialists, add a license key at askexe.com.");
         log("");
+        log(`Type your COO's name to start: /${cooName}`);
+        state.completedSteps.push(7, 8);
+        saveSetupState(state);
+      } else {
+        state.completedSteps.push(7);
+        saveSetupState(state);
+      }
+    } else {
+      log("Step 7 already complete \u2014 skipping.");
+    }
+    if (!state.completedSteps.includes(8)) {
+      let employees = await loadEmployees2(EMPLOYEES_PATH2).catch(() => []);
+      log("=== Hire Your Team ===");
+      log("");
+      log("Your COO coordinates specialists. Each one stays focused on");
+      log("their domain \u2014 no context switching, no competing priorities.");
+      log("");
+      const ctoTemplate = getTemplateByRole2("CTO");
+      const ctoDefault = ctoTemplate?.name ?? "yoshi";
+      log(`  CTO \u2014 engineering, architecture, code reviews (default: ${ctoDefault})`);
+      const cmoTemplate = getTemplateByRole2("CMO");
+      const cmoDefault = cmoTemplate?.name ?? "mari";
+      log(`  CMO \u2014 design, brand, content, marketing (default: ${cmoDefault})`);
+      log("");
+      const ctoNameInput = await ask(rl, `Name your CTO (default: ${ctoDefault}): `);
+      const ctoName = (ctoNameInput || ctoDefault).toLowerCase();
+      if (!employees.some((e) => e.name === ctoName)) {
+        const { personalizePrompt: personalizeCto } = await Promise.resolve().then(() => (init_employee_templates(), employee_templates_exports));
+        const ctoEmployee = {
+          name: ctoName,
+          role: "CTO",
+          systemPrompt: personalizeCto(ctoTemplate?.systemPrompt ?? "", ctoDefault, ctoName),
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        employees = addEmployee2(employees, ctoEmployee);
+        await saveEmployees2(employees, EMPLOYEES_PATH2);
+      }
+      const ctoIdentityContent = getIdentityTemplate("cto");
+      if (ctoIdentityContent) {
+        const ctoIdPath = identityPath2(ctoName);
+        mkdirSync6(path11.dirname(ctoIdPath), { recursive: true });
+        const replaced = ctoIdentityContent.replace(/agent_id:\s*\w+/g, `agent_id: ${ctoName}`).replace(/\$\{agent_id\}/g, ctoName);
+        writeFileSync7(ctoIdPath, replaced, "utf-8");
+      }
+      registerBinSymlinks2(ctoName);
+      createdEmployees.push({ name: ctoName, role: "CTO" });
+      log(`Created ${ctoName} (CTO)`);
+      const cmoNameInput = await ask(rl, `Name your CMO (default: ${cmoDefault}): `);
+      const cmoName = (cmoNameInput || cmoDefault).toLowerCase();
+      if (!employees.some((e) => e.name === cmoName)) {
+        const { personalizePrompt: personalizeCmo } = await Promise.resolve().then(() => (init_employee_templates(), employee_templates_exports));
+        const cmoEmployee = {
+          name: cmoName,
+          role: "CMO",
+          systemPrompt: personalizeCmo(cmoTemplate?.systemPrompt ?? "", cmoDefault, cmoName),
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        employees = addEmployee2(employees, cmoEmployee);
+        await saveEmployees2(employees, EMPLOYEES_PATH2);
+      }
+      const cmoIdentityContent = getIdentityTemplate("cmo");
+      if (cmoIdentityContent) {
+        const cmoIdPath = identityPath2(cmoName);
+        mkdirSync6(path11.dirname(cmoIdPath), { recursive: true });
+        const replaced = cmoIdentityContent.replace(/agent_id:\s*\w+/g, `agent_id: ${cmoName}`).replace(/\$\{agent_id\}/g, cmoName);
+        writeFileSync7(cmoIdPath, replaced, "utf-8");
       }
+      registerBinSymlinks2(cmoName);
+      createdEmployees.push({ name: cmoName, role: "CMO" });
+      log(`Created ${cmoName} (CMO)`);
+      log("");
       state.completedSteps.push(8);
       saveSetupState(state);
     } else {
       log("Step 8 already complete \u2014 skipping.");
     }
+    let pathJustConfigured = false;
     if (!pairingRosterPulled) {
       try {
         const { generateSessionWrappers: generateSessionWrappers2 } = await Promise.resolve().then(() => (init_session_wrappers(), session_wrappers_exports));
@@ -5647,6 +6263,11 @@ async function runSetupWizard(opts = {}) {
           if (wrapResult.created > 0) {
             log(`Session shortcuts generated (${cooName}1, ${cooName}2, ...)`);
           }
+          if (wrapResult.pathConfigured) {
+            const binDir = path11.join(os4.homedir(), ".exe-os", "bin");
+            process.env.PATH = `${binDir}:${process.env.PATH ?? ""}`;
+            pathJustConfigured = true;
+          }
         }
       } catch {
       }
@@ -5679,12 +6300,35 @@ async function runSetupWizard(opts = {}) {
     if (createdEmployees.length > 0) {
       log("Team: " + createdEmployees.map((e) => `${e.name} (${e.role})`).join(", "));
     }
+    let version = "";
+    const pkgRoot2 = findPackageRoot2();
+    if (pkgRoot2) {
+      try {
+        version = JSON.parse(readFileSync9(path11.join(pkgRoot2, "package.json"), "utf-8")).version;
+      } catch {
+      }
+    }
+    const W = 27;
+    const center = (s) => {
+      const pad = W - s.length;
+      return " ".repeat(Math.floor(pad / 2)) + s + " ".repeat(Math.ceil(pad / 2));
+    };
+    log("");
+    log(`  ${"\u2554" + "\u2550".repeat(W) + "\u2557"}`);
+    log(`  ${"\u2551" + center("e x e   O S") + "\u2551"}`);
+    if (version) log(`  ${"\u2551" + center(`v${version}`) + "\u2551"}`);
+    log(`  ${"\u255A" + "\u2550".repeat(W) + "\u255D"}`);
     log("");
     log("=== Next Steps ===");
     log("");
-    log("  1. Restart your terminal (or run: source ~/.zshrc)");
-    log(`  2. cd into a project folder:  cd ~/my-project`);
-    log(`  3. Launch your COO:           ${cooName}1`);
+    log(`  cd into a project folder:  cd ~/my-project`);
+    log(`  Launch your COO:           ${cooName}1`);
+    if (pathJustConfigured) {
+      const shell = process.env.SHELL ?? "/bin/zsh";
+      const rcFile = shell.includes("bash") ? "~/.bashrc" : "~/.zshrc";
+      log("");
+      log(`  (Run \`source ${rcFile}\` first, or open a new terminal)`);
+    }
     log("");
   } finally {
     rl.close();