@askexenow/exe-os 0.8.33 → 0.8.37

package/dist/bin/exe-boot.js

@@ -271,7 +271,7 @@ var init_config = __esm({
 
 // src/lib/employees.ts
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync2, symlinkSync, readlinkSync } from "fs";
+import { existsSync as existsSync2, symlinkSync, readlinkSync, readFileSync as readFileSync2 } from "fs";
 import { execSync } from "child_process";
 import path2 from "path";
 async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
@@ -289,12 +289,65 @@ async function saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
   await mkdir2(path2.dirname(employeesPath), { recursive: true });
   await writeFile2(employeesPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
 }
-var EMPLOYEES_PATH;
+function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
+  if (!existsSync2(employeesPath)) return [];
+  try {
+    return JSON.parse(readFileSync2(employeesPath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function getEmployee(employees, name) {
+  return employees.find((e) => e.name.toLowerCase() === name.toLowerCase());
+}
+function isMultiInstance(agentName, employees) {
+  const roster = employees ?? loadEmployeesSync();
+  const emp = getEmployee(roster, agentName);
+  if (!emp) return false;
+  return MULTI_INSTANCE_ROLES.has(emp.role.toLowerCase());
+}
+function registerBinSymlinks(name) {
+  const created = [];
+  const skipped = [];
+  const errors = [];
+  let exeBinPath;
+  try {
+    exeBinPath = execSync("which exe", { encoding: "utf-8" }).trim();
+  } catch {
+    errors.push("Could not find 'exe' in PATH");
+    return { created, skipped, errors };
+  }
+  const binDir = path2.dirname(exeBinPath);
+  let target;
+  try {
+    target = readlinkSync(exeBinPath);
+  } catch {
+    errors.push("Could not read 'exe' symlink");
+    return { created, skipped, errors };
+  }
+  for (const suffix of ["", "-opencode"]) {
+    const linkName = `${name}${suffix}`;
+    const linkPath = path2.join(binDir, linkName);
+    if (existsSync2(linkPath)) {
+      skipped.push(linkName);
+      continue;
+    }
+    try {
+      symlinkSync(target, linkPath);
+      created.push(linkName);
+    } catch (err) {
+      errors.push(`${linkName}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return { created, skipped, errors };
+}
+var EMPLOYEES_PATH, MULTI_INSTANCE_ROLES;
 var init_employees = __esm({
   "src/lib/employees.ts"() {
     "use strict";
     init_config();
     EMPLOYEES_PATH = path2.join(EXE_AI_DIR, "exe-employees.json");
+    MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["principal engineer", "content production specialist", "staff code reviewer"]);
   }
 });
 
@@ -305,12 +358,68 @@ var init_memory = __esm({
   }
 });
 
+// src/lib/db-retry.ts
+function isBusyError(err) {
+  if (err instanceof Error) {
+    const msg = err.message.toLowerCase();
+    return msg.includes("sqlite_busy") || msg.includes("database is locked");
+  }
+  return false;
+}
+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);
+    }
+  }
+  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) => retryOnBusy(() => target.batch(stmts), "batch");
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+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/database.ts
 import { createClient } from "@libsql/client";
 async function initDatabase(config) {
   if (_client) {
     _client.close();
     _client = null;
+    _resilientClient = null;
   }
   const opts = {
     url: `file:${config.dbPath}`
@@ -319,20 +428,27 @@ async function initDatabase(config) {
     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 = getClient();
+  const client = getRawClient();
   await client.execute("PRAGMA journal_mode = WAL");
-  await client.execute("PRAGMA busy_timeout = 5000");
+  await client.execute("PRAGMA busy_timeout = 30000");
   try {
     await client.execute("PRAGMA libsql_vector_search_ef = 128");
   } catch {
@@ -1121,11 +1237,13 @@ async function ensureSchema() {
     }
   }
 }
-var _client, initTurso;
+var _client, _resilientClient, initTurso;
 var init_database = __esm({
   "src/lib/database.ts"() {
     "use strict";
+    init_db_retry();
     _client = null;
+    _resilientClient = null;
     initTurso = initDatabase;
   }
 });
@@ -1329,12 +1447,12 @@ function shardExists(projectName) {
 }
 function listShards() {
   if (!existsSync4(SHARDS_DIR)) return [];
-  const { readdirSync: readdirSync6 } = __require("fs");
-  return readdirSync6(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
+  const { readdirSync: readdirSync7 } = __require("fs");
+  return readdirSync7(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function ensureShardSchema(client) {
   await client.execute("PRAGMA journal_mode = WAL");
-  await client.execute("PRAGMA busy_timeout = 5000");
+  await client.execute("PRAGMA busy_timeout = 30000");
   try {
     await client.execute("PRAGMA libsql_vector_search_ef = 128");
   } catch {
@@ -1579,7 +1697,7 @@ import crypto2 from "crypto";
 import path5 from "path";
 import os2 from "os";
 import {
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync3,
   readdirSync,
   unlinkSync,
   existsSync as existsSync5,
@@ -1706,7 +1824,7 @@ async function migrateJsonNotifications() {
     for (const file of files) {
       try {
         const filePath = path5.join(notifDir, file);
-        const data = JSON.parse(readFileSync2(filePath, "utf8"));
+        const data = JSON.parse(readFileSync3(filePath, "utf8"));
         await client.execute({
           sql: `INSERT OR IGNORE INTO notifications (id, agent_id, agent_role, event, project, summary, task_file, read, created_at)
                 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
@@ -1789,7 +1907,7 @@ __export(session_registry_exports, {
   pruneStaleSessions: () => pruneStaleSessions,
   registerSession: () => registerSession
 });
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync6 } from "fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync6 } from "fs";
 import { execSync as execSync4 } from "child_process";
 import path7 from "path";
 import os3 from "os";
@@ -1809,7 +1927,7 @@ function registerSession(entry) {
 }
 function listSessions() {
   try {
-    const raw = readFileSync4(REGISTRY_PATH, "utf8");
+    const raw = readFileSync5(REGISTRY_PATH, "utf8");
     return JSON.parse(raw);
   } catch {
     return [];
@@ -2023,7 +2141,7 @@ var init_provider_table = __esm({
 });
 
 // src/lib/intercom-queue.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, renameSync as renameSync2, existsSync as existsSync7, mkdirSync as mkdirSync4 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync3, renameSync as renameSync2, existsSync as existsSync7, mkdirSync as mkdirSync4 } from "fs";
 import path8 from "path";
 import os4 from "os";
 function ensureDir() {
@@ -2033,7 +2151,7 @@ function ensureDir() {
 function readQueue() {
   try {
     if (!existsSync7(QUEUE_PATH)) return [];
-    return JSON.parse(readFileSync5(QUEUE_PATH, "utf8"));
+    return JSON.parse(readFileSync6(QUEUE_PATH, "utf8"));
   } catch {
     return [];
   }
@@ -2086,7 +2204,7 @@ __export(license_exports, {
   saveLicense: () => saveLicense,
   validateLicense: () => validateLicense
 });
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync8, mkdirSync as mkdirSync5 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, existsSync as existsSync8, mkdirSync as mkdirSync5 } from "fs";
 import { randomUUID } from "crypto";
 import path9 from "path";
 import { jwtVerify, importSPKI } from "jose";
@@ -2094,14 +2212,14 @@ function loadDeviceId() {
   const deviceJsonPath = path9.join(EXE_AI_DIR, "device.json");
   try {
     if (existsSync8(deviceJsonPath)) {
-      const data = JSON.parse(readFileSync6(deviceJsonPath, "utf8"));
+      const data = JSON.parse(readFileSync7(deviceJsonPath, "utf8"));
       if (data.deviceId) return data.deviceId;
     }
   } catch {
   }
   try {
     if (existsSync8(DEVICE_ID_PATH)) {
-      const id2 = readFileSync6(DEVICE_ID_PATH, "utf8").trim();
+      const id2 = readFileSync7(DEVICE_ID_PATH, "utf8").trim();
       if (id2) return id2;
     }
   } catch {
@@ -2114,7 +2232,7 @@ function loadDeviceId() {
 function loadLicense() {
   try {
     if (!existsSync8(LICENSE_PATH)) return null;
-    return readFileSync6(LICENSE_PATH, "utf8").trim();
+    return readFileSync7(LICENSE_PATH, "utf8").trim();
   } catch {
     return null;
   }
@@ -2148,7 +2266,7 @@ async function verifyLicenseJwt(token) {
 async function getCachedLicense() {
   try {
     if (!existsSync8(CACHE_PATH)) return null;
-    const raw = JSON.parse(readFileSync6(CACHE_PATH, "utf8"));
+    const raw = JSON.parse(readFileSync7(CACHE_PATH, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return null;
     return await verifyLicenseJwt(raw.token);
   } catch {
@@ -2158,7 +2276,7 @@ async function getCachedLicense() {
 function readCachedToken() {
   try {
     if (!existsSync8(CACHE_PATH)) return null;
-    const raw = JSON.parse(readFileSync6(CACHE_PATH, "utf8"));
+    const raw = JSON.parse(readFileSync7(CACHE_PATH, "utf8"));
     return typeof raw.token === "string" ? raw.token : null;
   } catch {
     return null;
@@ -2370,12 +2488,12 @@ MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeHztAMOpR/ZMh+rWuOASjEZ54CGY
 });
 
 // src/lib/plan-limits.ts
-import { readFileSync as readFileSync7, existsSync as existsSync9 } from "fs";
+import { readFileSync as readFileSync8, existsSync as existsSync9 } from "fs";
 import path10 from "path";
 function getLicenseSync() {
   try {
     if (!existsSync9(CACHE_PATH2)) return freeLicense();
-    const raw = JSON.parse(readFileSync7(CACHE_PATH2, "utf8"));
+    const raw = JSON.parse(readFileSync8(CACHE_PATH2, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return freeLicense();
     const parts = raw.token.split(".");
     if (parts.length !== 3) return freeLicense();
@@ -2414,7 +2532,7 @@ function assertEmployeeLimitSync(rosterPath) {
   let count = 0;
   try {
     if (existsSync9(filePath)) {
-      const raw = readFileSync7(filePath, "utf8");
+      const raw = readFileSync8(filePath, "utf8");
       const employees = JSON.parse(raw);
       count = Array.isArray(employees) ? employees.length : 0;
     }
@@ -2457,10 +2575,46 @@ var init_plan_limits = __esm({
 
 // src/lib/tmux-routing.ts
 import { execFileSync as execFileSync2, execSync as execSync6 } from "child_process";
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6, existsSync as existsSync10, appendFileSync } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6, existsSync as existsSync10, appendFileSync } from "fs";
 import path11 from "path";
 import os5 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
+import { unlinkSync as unlinkSync3 } from "fs";
+function spawnLockPath(sessionName) {
+  return path11.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function acquireSpawnLock(sessionName) {
+  if (!existsSync10(SPAWN_LOCK_DIR)) {
+    mkdirSync6(SPAWN_LOCK_DIR, { recursive: true });
+  }
+  const lockFile = spawnLockPath(sessionName);
+  if (existsSync10(lockFile)) {
+    try {
+      const lock = JSON.parse(readFileSync9(lockFile, "utf8"));
+      const age = Date.now() - lock.timestamp;
+      if (isProcessAlive(lock.pid) && age < 6e4) {
+        return false;
+      }
+    } catch {
+    }
+  }
+  writeFileSync5(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
+  return true;
+}
+function releaseSpawnLock(sessionName) {
+  try {
+    unlinkSync3(spawnLockPath(sessionName));
+  } catch {
+  }
+}
 function resolveBehaviorsExporterScript() {
   try {
     const thisFile = fileURLToPath2(import.meta.url);
@@ -2506,7 +2660,7 @@ function extractRootExe(name) {
 }
 function getParentExe(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync8(path11.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    const data = JSON.parse(readFileSync9(path11.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
     return data.parentExe || null;
   } catch {
     return null;
@@ -2514,7 +2668,7 @@ function getParentExe(sessionKey) {
 }
 function getDispatchedBy(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync8(
+    const data = JSON.parse(readFileSync9(
       path11.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
       "utf8"
     ));
@@ -2541,17 +2695,17 @@ function isEmployeeAlive(sessionName) {
 }
 function findFreeInstance(employeeName, exeSession, maxInstances = 10, isAlive = isEmployeeAlive) {
   const base = employeeSessionName(employeeName, exeSession);
-  if (!isAlive(base)) return 0;
+  if (!isAlive(base) && acquireSpawnLock(base)) return 0;
   for (let i = 2; i <= maxInstances; i++) {
     const candidate = employeeSessionName(employeeName, exeSession, i);
-    if (!isAlive(candidate)) return i;
+    if (!isAlive(candidate) && acquireSpawnLock(candidate)) return i;
   }
   return null;
 }
 function readDebounceState() {
   try {
     if (!existsSync10(DEBOUNCE_FILE)) return {};
-    return JSON.parse(readFileSync8(DEBOUNCE_FILE, "utf8"));
+    return JSON.parse(readFileSync9(DEBOUNCE_FILE, "utf8"));
   } catch {
     return {};
   }
@@ -2747,7 +2901,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const claudeJsonPath = path11.join(os5.homedir(), ".claude.json");
     let claudeJson = {};
     try {
-      claudeJson = JSON.parse(readFileSync8(claudeJsonPath, "utf8"));
+      claudeJson = JSON.parse(readFileSync9(claudeJsonPath, "utf8"));
     } catch {
     }
     if (!claudeJson.projects) claudeJson.projects = {};
@@ -2765,7 +2919,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const settingsPath = path11.join(projSettingsDir, "settings.json");
     let settings = {};
     try {
-      settings = JSON.parse(readFileSync8(settingsPath, "utf8"));
+      settings = JSON.parse(readFileSync9(settingsPath, "utf8"));
     } catch {
     }
     const perms = settings.permissions ?? {};
@@ -2878,6 +3032,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     command: spawnCommand
   });
   if (spawnResult.error) {
+    releaseSpawnLock(sessionName);
     return { sessionName, error: `tmux new-session failed: ${spawnResult.error}` };
   }
   transport.pipeLog(sessionName, logFile);
@@ -2915,6 +3070,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     }
   }
   if (!booted) {
+    releaseSpawnLock(sessionName);
     return { sessionName, error: `${useExeAgent ? "exe-agent" : "claude"} did not boot within 15s` };
   }
   if (!useExeAgent) {
@@ -2931,9 +3087,10 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     pid: 0,
     registeredAt: (/* @__PURE__ */ new Date()).toISOString()
   });
+  releaseSpawnLock(sessionName);
   return { sessionName };
 }
-var SESSION_CACHE, BEHAVIORS_EXPORT_TIMEOUT_MS, INTERCOM_DEBOUNCE_MS, INTERCOM_LOG2, DEBOUNCE_FILE, DEBOUNCE_CLEANUP_AGE_MS, BUSY_PATTERN;
+var SPAWN_LOCK_DIR, SESSION_CACHE, BEHAVIORS_EXPORT_TIMEOUT_MS, INTERCOM_DEBOUNCE_MS, INTERCOM_LOG2, DEBOUNCE_FILE, DEBOUNCE_CLEANUP_AGE_MS, BUSY_PATTERN;
 var init_tmux_routing = __esm({
   "src/lib/tmux-routing.ts"() {
     "use strict";
@@ -2945,6 +3102,7 @@ var init_tmux_routing = __esm({
     init_provider_table();
     init_intercom_queue();
     init_plan_limits();
+    SPAWN_LOCK_DIR = path11.join(os5.homedir(), ".exe-os", "spawn-locks");
     SESSION_CACHE = path11.join(os5.homedir(), ".exe-os", "session-cache");
     BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
     INTERCOM_DEBOUNCE_MS = 3e4;
@@ -2966,7 +3124,7 @@ __export(task_scanner_exports, {
   formatText: () => formatText,
   scanAgentTasks: () => scanAgentTasks
 });
-import { readdirSync as readdirSync3, readFileSync as readFileSync9, existsSync as existsSync11, statSync } from "fs";
+import { readdirSync as readdirSync3, readFileSync as readFileSync10, existsSync as existsSync11, statSync } from "fs";
 import { execSync as execSync7 } from "child_process";
 import path12 from "path";
 function getProjectRoot() {
@@ -2992,7 +3150,7 @@ function scanAgentTasks(agentId) {
     total = files.length;
     for (const f of files) {
       try {
-        const content = readFileSync9(path12.join(taskDir, f), "utf8");
+        const content = readFileSync10(path12.join(taskDir, f), "utf8");
         const statusMatch = content.match(STATUS_RE);
         const status = statusMatch ? statusMatch[1].toLowerCase() : null;
         if (status === "done") {
@@ -3146,7 +3304,7 @@ import crypto3 from "crypto";
 import path14 from "path";
 import { execSync as execSync9 } from "child_process";
 import { mkdir as mkdir4, writeFile as writeFile4, appendFile } from "fs/promises";
-import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync11 } from "fs";
 async function writeCheckpoint(input) {
   const client = getClient();
   const row = await resolveTask(client, input.taskId);
@@ -3523,7 +3681,7 @@ async function ensureGitignoreExe(baseDir) {
   const gitignorePath = path14.join(baseDir, ".gitignore");
   try {
     if (existsSync12(gitignorePath)) {
-      const content = readFileSync10(gitignorePath, "utf-8");
+      const content = readFileSync11(gitignorePath, "utf-8");
       if (/^\/?exe\/?$/m.test(content)) return;
       await appendFile(gitignorePath, "\n# Employee task assignments (private)\n/exe/\n");
     } else {
@@ -3544,7 +3702,7 @@ var init_tasks_crud = __esm({
 
 // src/lib/tasks-review.ts
 import path15 from "path";
-import { existsSync as existsSync13, readdirSync as readdirSync4, unlinkSync as unlinkSync3 } from "fs";
+import { existsSync as existsSync13, readdirSync as readdirSync4, unlinkSync as unlinkSync4 } from "fs";
 async function countPendingReviews() {
   const client = getClient();
   const result = await client.execute({
@@ -3668,7 +3826,7 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
     if (existsSync13(cacheDir)) {
       for (const f of readdirSync4(cacheDir)) {
         if (f.startsWith("review-notified-")) {
-          unlinkSync3(path15.join(cacheDir, f));
+          unlinkSync4(path15.join(cacheDir, f));
         }
       }
     }
@@ -3857,7 +4015,7 @@ async function dispatchTaskToEmployee(input) {
     } else {
       const projectDir = input.projectDir ?? process.cwd();
       const result = ensureEmployee(input.assignedTo, exeSession, projectDir, {
-        autoInstance: input.assignedTo === "tom" || input.assignedTo === "sasha"
+        autoInstance: isMultiInstance(input.assignedTo)
       });
       if (result.status === "failed") {
         process.stderr.write(
@@ -3892,6 +4050,7 @@ var init_tasks_notify = __esm({
     init_session_key();
     init_notifications();
     init_transport();
+    init_employees();
   }
 });
 
@@ -4226,7 +4385,7 @@ __export(tasks_exports, {
   writeCheckpoint: () => writeCheckpoint
 });
 import path17 from "path";
-import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync7, unlinkSync as unlinkSync4 } from "fs";
+import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync7, unlinkSync as unlinkSync5 } from "fs";
 async function createTask(input) {
   const result = await createTaskCore(input);
   if (!input.skipDispatch && result.status !== "blocked" && !process.env.VITEST) {
@@ -4252,7 +4411,7 @@ async function updateTask(input) {
       writeFileSync6(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
     } else if (input.status === "done" || input.status === "blocked" || input.status === "cancelled") {
       try {
-        unlinkSync4(cachePath);
+        unlinkSync5(cachePath);
       } catch {
       }
     }
@@ -4548,10 +4707,49 @@ var init_compress = __esm({
 // src/lib/cloud-sync.ts
 var cloud_sync_exports = {};
 __export(cloud_sync_exports, {
+  buildRosterBlob: () => buildRosterBlob,
   cloudPull: () => cloudPull,
+  cloudPullBehaviors: () => cloudPullBehaviors,
+  cloudPullBlob: () => cloudPullBlob,
+  cloudPullConversations: () => cloudPullConversations,
+  cloudPullDocuments: () => cloudPullDocuments,
+  cloudPullGraphRAG: () => cloudPullGraphRAG,
+  cloudPullRoster: () => cloudPullRoster,
+  cloudPullTasks: () => cloudPullTasks,
   cloudPush: () => cloudPush,
-  cloudSync: () => cloudSync
+  cloudPushBehaviors: () => cloudPushBehaviors,
+  cloudPushBlob: () => cloudPushBlob,
+  cloudPushConversations: () => cloudPushConversations,
+  cloudPushDocuments: () => cloudPushDocuments,
+  cloudPushGraphRAG: () => cloudPushGraphRAG,
+  cloudPushRoster: () => cloudPushRoster,
+  cloudPushTasks: () => cloudPushTasks,
+  cloudSync: () => cloudSync,
+  mergeConfig: () => mergeConfig,
+  mergeRosterFromRemote: () => mergeRosterFromRemote
 });
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync7, existsSync as existsSync14, readdirSync as readdirSync5, mkdirSync as mkdirSync8, appendFileSync as appendFileSync2 } from "fs";
+import path18 from "path";
+import { homedir } from "os";
+function logError(msg) {
+  try {
+    const logPath = path18.join(homedir(), ".exe-os", "workers.log");
+    appendFileSync2(logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
+`);
+  } catch {
+  }
+}
+async function fetchWithRetry(url, init) {
+  const attempt = async () => {
+    const signal = AbortSignal.timeout(FETCH_TIMEOUT_MS);
+    return fetch(url, { ...init, signal });
+  };
+  const resp = await attempt();
+  if (resp.status >= 500) {
+    return attempt();
+  }
+  return resp;
+}
 function assertSecureEndpoint(endpoint) {
   if (endpoint.startsWith("https://")) return;
   if (endpoint.startsWith("http://")) {
@@ -4573,7 +4771,7 @@ async function cloudPush(records, maxVersion, config) {
     const json = JSON.stringify(records);
     const compressed = compress(Buffer.from(json, "utf8"));
     const blob = encryptSyncBlob(compressed);
-    const resp = await fetch(`${config.endpoint}/sync/push`, {
+    const resp = await fetchWithRetry(`${config.endpoint}/sync/push`, {
       method: "POST",
       headers: {
         Authorization: `Bearer ${config.apiKey}`,
@@ -4584,15 +4782,14 @@ async function cloudPush(records, maxVersion, config) {
     });
     return resp.ok;
   } catch (err) {
-    process.stderr.write(`[cloud-sync] PUSH FAILED: ${err instanceof Error ? err.message : String(err)}
-`);
+    logError(`[cloud-sync] PUSH FAILED: ${err instanceof Error ? err.message : String(err)}`);
     return false;
   }
 }
 async function cloudPull(sinceVersion, config) {
   assertSecureEndpoint(config.endpoint);
   try {
-    const response = await fetch(`${config.endpoint}/sync/pull`, {
+    const response = await fetchWithRetry(`${config.endpoint}/sync/pull`, {
       method: "POST",
       headers: {
         Authorization: `Bearer ${config.apiKey}`,
@@ -4616,8 +4813,7 @@ async function cloudPull(sinceVersion, config) {
     }
     return { records: allRecords, maxVersion: data.max_version ?? sinceVersion };
   } catch (err) {
-    process.stderr.write(`[cloud-sync] PULL FAILED: ${err instanceof Error ? err.message : String(err)}
-`);
+    logError(`[cloud-sync] PULL FAILED: ${err instanceof Error ? err.message : String(err)}`);
     return { records: [], maxVersion: sinceVersion };
   }
 }
@@ -4706,9 +4902,604 @@ async function cloudSync(config) {
       pushed = records.length;
     }
   }
-  return { pushed, pulled };
+  try {
+    await cloudPushRoster(config);
+  } catch (err) {
+    logError(`[cloud-sync] Roster push: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  try {
+    await cloudPullRoster(config);
+  } catch (err) {
+    logError(`[cloud-sync] Roster pull: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  let behaviorsResult = { pushed: false, pulled: 0 };
+  try {
+    behaviorsResult.pushed = await cloudPushBehaviors(config);
+  } catch (err) {
+    logError(`[cloud-sync] Behaviors push: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  try {
+    const pullResult2 = await cloudPullBehaviors(config);
+    behaviorsResult.pulled = pullResult2.pulled;
+  } catch (err) {
+    logError(`[cloud-sync] Behaviors pull: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  let graphragResult = { pushed: false, pulled: 0 };
+  try {
+    graphragResult.pushed = await cloudPushGraphRAG(config);
+  } catch (err) {
+    logError(`[cloud-sync] GraphRAG push: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  try {
+    const pullResult2 = await cloudPullGraphRAG(config);
+    graphragResult.pulled = pullResult2.pulled;
+  } catch (err) {
+    logError(`[cloud-sync] GraphRAG pull: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  let tasksResult = { pushed: false, pulled: 0 };
+  try {
+    tasksResult.pushed = await cloudPushTasks(config);
+  } catch (err) {
+    logError(`[cloud-sync] Tasks push: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  try {
+    const pullResult2 = await cloudPullTasks(config);
+    tasksResult.pulled = pullResult2.pulled;
+  } catch (err) {
+    logError(`[cloud-sync] Tasks pull: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  let conversationsResult = { pushed: false, pulled: 0 };
+  try {
+    conversationsResult.pushed = await cloudPushConversations(config);
+  } catch (err) {
+    logError(`[cloud-sync] Conversations push: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  try {
+    const pullResult2 = await cloudPullConversations(config);
+    conversationsResult.pulled = pullResult2.pulled;
+  } catch (err) {
+    logError(`[cloud-sync] Conversations pull: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  let documentsResult = { pushed: false, pulled: 0 };
+  try {
+    documentsResult.pushed = await cloudPushDocuments(config);
+  } catch (err) {
+    logError(`[cloud-sync] Documents push: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  try {
+    const pullResult2 = await cloudPullDocuments(config);
+    documentsResult.pulled = pullResult2.pulled;
+  } catch (err) {
+    logError(`[cloud-sync] Documents pull: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  return {
+    pushed,
+    pulled,
+    behaviors: behaviorsResult,
+    graphrag: graphragResult,
+    tasks: tasksResult,
+    conversations: conversationsResult,
+    documents: documentsResult
+  };
+}
+function buildRosterBlob(paths) {
+  const rosterPath = paths?.rosterPath ?? path18.join(EXE_AI_DIR, "exe-employees.json");
+  const identityDir = paths?.identityDir ?? path18.join(EXE_AI_DIR, "identity");
+  const configPath = paths?.configPath ?? path18.join(EXE_AI_DIR, "config.json");
+  let roster = [];
+  if (existsSync14(rosterPath)) {
+    try {
+      roster = JSON.parse(readFileSync12(rosterPath, "utf-8"));
+    } catch {
+    }
+  }
+  const identities = {};
+  if (existsSync14(identityDir)) {
+    for (const file of readdirSync5(identityDir).filter((f) => f.endsWith(".md"))) {
+      try {
+        identities[file] = readFileSync12(path18.join(identityDir, file), "utf-8");
+      } catch {
+      }
+    }
+  }
+  let config;
+  if (existsSync14(configPath)) {
+    try {
+      config = JSON.parse(readFileSync12(configPath, "utf-8"));
+    } catch {
+    }
+  }
+  const content = JSON.stringify({ roster, identities, config });
+  const hash = Buffer.from(content).length;
+  return { roster, identities, config, version: hash };
+}
+async function cloudPushRoster(config) {
+  assertSecureEndpoint(config.endpoint);
+  const blob = buildRosterBlob();
+  if (blob.roster.length === 0) return true;
+  try {
+    const client = getClient();
+    const meta = await client.execute(
+      "SELECT value FROM sync_meta WHERE key = 'last_roster_push_version'"
+    );
+    const lastVersion = meta.rows.length > 0 ? Number(meta.rows[0].value) : 0;
+    if (blob.version === lastVersion) return true;
+  } catch {
+  }
+  try {
+    const json = JSON.stringify(blob);
+    const compressed = compress(Buffer.from(json, "utf8"));
+    const encrypted = encryptSyncBlob(compressed);
+    const resp = await fetchWithRetry(`${config.endpoint}/sync/push-roster`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        "Content-Type": "application/json",
+        "X-Device-Id": loadDeviceId()
+      },
+      body: JSON.stringify({ blob: encrypted })
+    });
+    if (resp.ok) {
+      try {
+        const client = getClient();
+        await client.execute({
+          sql: "INSERT OR REPLACE INTO sync_meta (key, value) VALUES ('last_roster_push_version', ?)",
+          args: [String(blob.version)]
+        });
+      } catch {
+      }
+    }
+    return resp.ok;
+  } catch (err) {
+    process.stderr.write(`[cloud-sync] ROSTER PUSH FAILED: ${err instanceof Error ? err.message : String(err)}
+`);
+    return false;
+  }
+}
+async function cloudPullRoster(config) {
+  assertSecureEndpoint(config.endpoint);
+  try {
+    const resp = await fetchWithRetry(`${config.endpoint}/sync/pull-roster`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        "X-Device-Id": loadDeviceId()
+      }
+    });
+    if (!resp.ok) return { added: 0 };
+    const data = await resp.json();
+    if (!data.blob) return { added: 0 };
+    const compressed = decryptSyncBlob(data.blob);
+    const json = decompress(compressed).toString("utf8");
+    const remote = JSON.parse(json);
+    return mergeRosterFromRemote(remote);
+  } catch (err) {
+    process.stderr.write(`[cloud-sync] ROSTER PULL FAILED: ${err instanceof Error ? err.message : String(err)}
+`);
+    return { added: 0 };
+  }
+}
+function mergeConfig(remoteConfig, configPath) {
+  const cfgPath = configPath ?? path18.join(EXE_AI_DIR, "config.json");
+  let local = {};
+  if (existsSync14(cfgPath)) {
+    try {
+      local = JSON.parse(readFileSync12(cfgPath, "utf-8"));
+    } catch {
+    }
+  }
+  const merged = { ...remoteConfig, ...local };
+  const dir = path18.dirname(cfgPath);
+  if (!existsSync14(dir)) mkdirSync8(dir, { recursive: true });
+  writeFileSync7(cfgPath, JSON.stringify(merged, null, 2), "utf-8");
+}
+async function mergeRosterFromRemote(remote, paths) {
+  const rosterPath = paths?.rosterPath ?? void 0;
+  const identityDir = paths?.identityDir ?? path18.join(EXE_AI_DIR, "identity");
+  const localEmployees = await loadEmployees(rosterPath);
+  const localNames = new Set(localEmployees.map((e) => e.name));
+  let added = 0;
+  for (const remoteEmp of remote.roster) {
+    if (localNames.has(remoteEmp.name)) continue;
+    localEmployees.push(remoteEmp);
+    localNames.add(remoteEmp.name);
+    added++;
+    if (remote.identities[`${remoteEmp.name}.md`]) {
+      if (!existsSync14(identityDir)) mkdirSync8(identityDir, { recursive: true });
+      const idPath = path18.join(identityDir, `${remoteEmp.name}.md`);
+      if (!existsSync14(idPath)) {
+        writeFileSync7(idPath, remote.identities[`${remoteEmp.name}.md`], "utf-8");
+      }
+    }
+    try {
+      registerBinSymlinks(remoteEmp.name);
+    } catch {
+    }
+  }
+  if (added > 0) {
+    await saveEmployees(localEmployees, rosterPath);
+  }
+  if (remote.config && Object.keys(remote.config).length > 0) {
+    try {
+      mergeConfig(remote.config, paths?.configPath);
+    } catch {
+    }
+  }
+  return { added };
+}
+async function cloudPushBlob(route, data, metaKey, config) {
+  if (data.length === 0) return { ok: true };
+  assertSecureEndpoint(config.endpoint);
+  const json = JSON.stringify(data);
+  const version = Buffer.from(json).length;
+  try {
+    const client = getClient();
+    const meta = await client.execute({
+      sql: "SELECT value FROM sync_meta WHERE key = ?",
+      args: [metaKey]
+    });
+    const lastVersion = meta.rows.length > 0 ? Number(meta.rows[0].value) : 0;
+    if (version === lastVersion) return { ok: true };
+  } catch {
+  }
+  try {
+    const compressed = compress(Buffer.from(json, "utf8"));
+    const encrypted = encryptSyncBlob(compressed);
+    const resp = await fetchWithRetry(`${config.endpoint}${route}`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        "Content-Type": "application/json",
+        "X-Device-Id": loadDeviceId()
+      },
+      body: JSON.stringify({ blob: encrypted })
+    });
+    if (resp.ok) {
+      try {
+        const client = getClient();
+        await client.execute({
+          sql: "INSERT OR REPLACE INTO sync_meta (key, value) VALUES (?, ?)",
+          args: [metaKey, String(version)]
+        });
+      } catch {
+      }
+    }
+    return { ok: resp.ok };
+  } catch (err) {
+    logError(`[cloud-sync] PUSH ${route}: ${err instanceof Error ? err.message : String(err)}`);
+    return { ok: false };
+  }
+}
+async function cloudPullBlob(route, config) {
+  assertSecureEndpoint(config.endpoint);
+  try {
+    const resp = await fetchWithRetry(`${config.endpoint}${route}`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        "X-Device-Id": loadDeviceId()
+      }
+    });
+    if (!resp.ok) return null;
+    const data = await resp.json();
+    if (!data.blob) return null;
+    const compressed = decryptSyncBlob(data.blob);
+    const json = decompress(compressed).toString("utf8");
+    return JSON.parse(json);
+  } catch (err) {
+    logError(`[cloud-sync] PULL ${route}: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
+async function cloudPushBehaviors(config) {
+  const client = getClient();
+  const result = await client.execute("SELECT * FROM behaviors");
+  const rows = result.rows;
+  const { ok } = await cloudPushBlob(
+    "/sync/push-behaviors",
+    rows,
+    "last_behaviors_push_version",
+    config
+  );
+  return ok;
+}
+async function cloudPullBehaviors(config) {
+  const remoteBehaviors = await cloudPullBlob(
+    "/sync/pull-behaviors",
+    config
+  );
+  if (!remoteBehaviors || remoteBehaviors.length === 0) return { pulled: 0 };
+  const client = getClient();
+  let pulled = 0;
+  for (const behavior of remoteBehaviors) {
+    const existing = await client.execute({
+      sql: `SELECT COUNT(*) as cnt FROM behaviors
+            WHERE agent_id = ? AND content = ?`,
+      args: [behavior.agent_id, behavior.content]
+    });
+    if (Number(existing.rows[0]?.cnt) > 0) continue;
+    await client.execute({
+      sql: `INSERT OR IGNORE INTO behaviors
+            (id, agent_id, project_name, domain, content, active, priority, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        behavior.id,
+        behavior.agent_id,
+        behavior.project_name ?? null,
+        behavior.domain ?? null,
+        behavior.content,
+        behavior.active,
+        behavior.priority ?? "p1",
+        behavior.created_at,
+        behavior.updated_at
+      ]
+    });
+    pulled++;
+  }
+  return { pulled };
 }
-var LOCALHOST_PATTERNS;
+async function cloudPushGraphRAG(config) {
+  const client = getClient();
+  const [entities, relationships, aliases, entityMems, relMems, hyperedges, hyperedgeNodes] = await Promise.all([
+    client.execute("SELECT * FROM entities"),
+    client.execute("SELECT * FROM relationships"),
+    client.execute("SELECT * FROM entity_aliases"),
+    client.execute("SELECT * FROM entity_memories"),
+    client.execute("SELECT * FROM relationship_memories"),
+    client.execute("SELECT * FROM hyperedges"),
+    client.execute("SELECT * FROM hyperedge_nodes")
+  ]);
+  const blob = {
+    entities: entities.rows,
+    relationships: relationships.rows,
+    entity_aliases: aliases.rows,
+    entity_memories: entityMems.rows,
+    relationship_memories: relMems.rows,
+    hyperedges: hyperedges.rows,
+    hyperedge_nodes: hyperedgeNodes.rows
+  };
+  const { ok } = await cloudPushBlob(
+    "/sync/push-graphrag",
+    [blob],
+    "last_graphrag_push_version",
+    config
+  );
+  return ok;
+}
+async function cloudPullGraphRAG(config) {
+  const data = await cloudPullBlob(
+    "/sync/pull-graphrag",
+    config
+  );
+  if (!data || data.length === 0) return { pulled: 0 };
+  const blob = data[0];
+  const client = getClient();
+  let pulled = 0;
+  if (blob.entities.length > 0) {
+    const stmts = blob.entities.map((e) => ({
+      sql: `INSERT OR IGNORE INTO entities (id, name, type, first_seen, last_seen, properties)
+            VALUES (?, ?, ?, ?, ?, ?)`,
+      args: [e.id, e.name, e.type, e.first_seen, e.last_seen, e.properties ?? "{}"]
+    }));
+    await client.batch(stmts, "write");
+    pulled += stmts.length;
+  }
+  if (blob.relationships.length > 0) {
+    const stmts = blob.relationships.map((r) => ({
+      sql: `INSERT OR IGNORE INTO relationships
+            (id, source_entity_id, target_entity_id, type, weight, timestamp, properties, confidence, confidence_label)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        r.id,
+        r.source_entity_id,
+        r.target_entity_id,
+        r.type,
+        r.weight ?? 1,
+        r.timestamp,
+        r.properties ?? "{}",
+        r.confidence ?? 1,
+        r.confidence_label ?? "extracted"
+      ]
+    }));
+    await client.batch(stmts, "write");
+    pulled += stmts.length;
+  }
+  if (blob.entity_aliases.length > 0) {
+    const stmts = blob.entity_aliases.map((a) => ({
+      sql: `INSERT OR IGNORE INTO entity_aliases (alias, canonical_entity_id) VALUES (?, ?)`,
+      args: [a.alias, a.canonical_entity_id]
+    }));
+    await client.batch(stmts, "write");
+    pulled += stmts.length;
+  }
+  if (blob.entity_memories.length > 0) {
+    const stmts = blob.entity_memories.map((em) => ({
+      sql: `INSERT OR IGNORE INTO entity_memories (entity_id, memory_id) VALUES (?, ?)`,
+      args: [em.entity_id, em.memory_id]
+    }));
+    await client.batch(stmts, "write");
+    pulled += stmts.length;
+  }
+  if (blob.relationship_memories.length > 0) {
+    const stmts = blob.relationship_memories.map((rm) => ({
+      sql: `INSERT OR IGNORE INTO relationship_memories (relationship_id, memory_id) VALUES (?, ?)`,
+      args: [rm.relationship_id, rm.memory_id]
+    }));
+    await client.batch(stmts, "write");
+    pulled += stmts.length;
+  }
+  if (blob.hyperedges.length > 0) {
+    const stmts = blob.hyperedges.map((h) => ({
+      sql: `INSERT OR IGNORE INTO hyperedges (id, label, relation, confidence, timestamp)
+            VALUES (?, ?, ?, ?, ?)`,
+      args: [h.id, h.label, h.relation, h.confidence ?? 1, h.timestamp]
+    }));
+    await client.batch(stmts, "write");
+    pulled += stmts.length;
+  }
+  if (blob.hyperedge_nodes.length > 0) {
+    const stmts = blob.hyperedge_nodes.map((hn) => ({
+      sql: `INSERT OR IGNORE INTO hyperedge_nodes (hyperedge_id, entity_id) VALUES (?, ?)`,
+      args: [hn.hyperedge_id, hn.entity_id]
+    }));
+    await client.batch(stmts, "write");
+    pulled += stmts.length;
+  }
+  return { pulled };
+}
+async function cloudPushTasks(config) {
+  const client = getClient();
+  const result = await client.execute("SELECT * FROM tasks");
+  const rows = result.rows;
+  const { ok } = await cloudPushBlob(
+    "/sync/push-tasks",
+    rows,
+    "last_tasks_push_version",
+    config
+  );
+  return ok;
+}
+async function cloudPullTasks(config) {
+  const remoteTasks = await cloudPullBlob(
+    "/sync/pull-tasks",
+    config
+  );
+  if (!remoteTasks || remoteTasks.length === 0) return { pulled: 0 };
+  const client = getClient();
+  const stmts = remoteTasks.map((t) => ({
+    sql: `INSERT OR IGNORE INTO tasks
+          (id, title, assigned_to, assigned_by, project_name, priority, status, task_file, created_at, updated_at,
+           blocked_by, parent_task_id, budget_tokens, budget_fallback_model, tokens_used, tokens_warned_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    args: [
+      t.id,
+      t.title,
+      t.assigned_to,
+      t.assigned_by,
+      t.project_name,
+      t.priority ?? "p1",
+      t.status ?? "open",
+      t.task_file ?? null,
+      t.created_at,
+      t.updated_at,
+      t.blocked_by ?? null,
+      t.parent_task_id ?? null,
+      t.budget_tokens ?? null,
+      t.budget_fallback_model ?? null,
+      t.tokens_used ?? 0,
+      t.tokens_warned_at ?? null
+    ]
+  }));
+  await client.batch(stmts, "write");
+  return { pulled: remoteTasks.length };
+}
+async function cloudPushConversations(config) {
+  const client = getClient();
+  const result = await client.execute("SELECT * FROM conversations");
+  const rows = result.rows;
+  const { ok } = await cloudPushBlob(
+    "/sync/push-conversations",
+    rows,
+    "last_conversations_push_version",
+    config
+  );
+  return ok;
+}
+async function cloudPullConversations(config) {
+  const remoteConvos = await cloudPullBlob(
+    "/sync/pull-conversations",
+    config
+  );
+  if (!remoteConvos || remoteConvos.length === 0) return { pulled: 0 };
+  const client = getClient();
+  const stmts = remoteConvos.map((c) => ({
+    sql: `INSERT OR IGNORE INTO conversations
+          (id, platform, external_id, sender_id, sender_name, sender_phone, sender_email,
+           recipient_id, channel_id, thread_id, reply_to_id, content_text, content_media,
+           content_metadata, agent_response, agent_name, timestamp, ingested_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    args: [
+      c.id,
+      c.platform,
+      c.external_id ?? null,
+      c.sender_id,
+      c.sender_name ?? null,
+      c.sender_phone ?? null,
+      c.sender_email ?? null,
+      c.recipient_id ?? null,
+      c.channel_id,
+      c.thread_id ?? null,
+      c.reply_to_id ?? null,
+      c.content_text ?? null,
+      c.content_media ?? null,
+      c.content_metadata ?? null,
+      c.agent_response ?? null,
+      c.agent_name ?? null,
+      c.timestamp,
+      c.ingested_at
+    ]
+  }));
+  await client.batch(stmts, "write");
+  return { pulled: remoteConvos.length };
+}
+async function cloudPushDocuments(config) {
+  const client = getClient();
+  const [workspaces, documents] = await Promise.all([
+    client.execute("SELECT * FROM workspaces"),
+    client.execute("SELECT * FROM documents")
+  ]);
+  const blob = {
+    workspaces: workspaces.rows,
+    documents: documents.rows
+  };
+  const { ok } = await cloudPushBlob(
+    "/sync/push-documents",
+    [blob],
+    "last_documents_push_version",
+    config
+  );
+  return ok;
+}
+async function cloudPullDocuments(config) {
+  const data = await cloudPullBlob(
+    "/sync/pull-documents",
+    config
+  );
+  if (!data || data.length === 0) return { pulled: 0 };
+  const blob = data[0];
+  const client = getClient();
+  let pulled = 0;
+  if (blob.workspaces.length > 0) {
+    const stmts = blob.workspaces.map((w) => ({
+      sql: `INSERT OR IGNORE INTO workspaces (id, slug, name, owner_agent_id, created_at, metadata)
+            VALUES (?, ?, ?, ?, ?, ?)`,
+      args: [w.id, w.slug, w.name, w.owner_agent_id ?? null, w.created_at, w.metadata ?? null]
+    }));
+    await client.batch(stmts, "write");
+    pulled += stmts.length;
+  }
+  if (blob.documents.length > 0) {
+    const stmts = blob.documents.map((d) => ({
+      sql: `INSERT OR IGNORE INTO documents
+            (id, workspace_id, filename, mime, source_type, user_id, uploaded_at, metadata)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        d.id,
+        d.workspace_id,
+        d.filename,
+        d.mime ?? null,
+        d.source_type ?? null,
+        d.user_id ?? null,
+        d.uploaded_at,
+        d.metadata ?? null
+      ]
+    }));
+    await client.batch(stmts, "write");
+    pulled += stmts.length;
+  }
+  return { pulled };
+}
+var LOCALHOST_PATTERNS, FETCH_TIMEOUT_MS;
 var init_cloud_sync = __esm({
   "src/lib/cloud-sync.ts"() {
     "use strict";
@@ -4717,7 +5508,10 @@ var init_cloud_sync = __esm({
     init_compress();
     init_plan_limits();
     init_license();
+    init_config();
+    init_employees();
     LOCALHOST_PATTERNS = /^(localhost|127\.0\.0\.1|\[::1\])$/i;
+    FETCH_TIMEOUT_MS = 3e4;
   }
 });
 
@@ -4899,9 +5693,9 @@ var init_schedules = __esm({
 
 // src/bin/exe-boot.ts
 init_employees();
-import path18 from "path";
+import path19 from "path";
 import { mkdir as mkdir5, writeFile as writeFile6 } from "fs/promises";
-import { existsSync as existsSync14, readFileSync as readFileSync11, readdirSync as readdirSync5, unlinkSync as unlinkSync5 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync13, readdirSync as readdirSync6, unlinkSync as unlinkSync6 } from "fs";
 import os6 from "os";
 
 // src/lib/employee-templates.ts
@@ -4955,8 +5749,22 @@ function boxMid(w) {
 function boxBot(w) {
   return `\u2514${"\u2500".repeat(w)}\u2518`;
 }
+function truncateToWidth(str, maxW) {
+  if (displayWidth(str) <= maxW) return str;
+  let w = 0;
+  let i = 0;
+  for (const ch of str) {
+    const cw = ch.codePointAt(0) > 255 ? 2 : 1;
+    if (w + cw + 1 > maxW) break;
+    w += cw;
+    i += ch.length;
+  }
+  return str.slice(0, i) + "\u2026";
+}
 function boxRow(content, w) {
-  return `\u2502 ${padRight(content, w - 2)} \u2502`;
+  const maxContent = w - 2;
+  const truncated = truncateToWidth(content, maxContent);
+  return `\u2502 ${padRight(truncated, maxContent)} \u2502`;
 }
 function formatUptime(seconds) {
   if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;
@@ -4966,6 +5774,9 @@ async function generateStatusBrief(employees, data, _activeAgentIds) {
   const now = /* @__PURE__ */ new Date();
   const dateStr = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")} ${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}`;
   const sessionTag = data.exeSession ? ` [${data.exeSession}]` : "";
+  if (data.embedding && data.embedding.totalMemories < 5 && data.globalTasks.length === 0 && (data.projects?.length ?? 0) === 0) {
+    return buildFirstBootBrief(employees, dateStr, sessionTag);
+  }
   const sections = [];
   sections.push([` EXE STATUS BRIEF \u2014 ${dateStr}${sessionTag}`]);
   const reminderLines = buildReminders(data);
@@ -4975,6 +5786,8 @@ async function generateStatusBrief(employees, data, _activeAgentIds) {
   sections.push(buildProjects(data));
   sections.push(buildTeam(employees, data));
   sections.push(buildHealth(data));
+  const termCols = process.stdout.columns || 80;
+  const maxInnerW = termCols - 2;
   let maxW = 0;
   for (const sec of sections) {
     for (const line of sec) {
@@ -4982,7 +5795,7 @@ async function generateStatusBrief(employees, data, _activeAgentIds) {
       if (w > maxW) maxW = w;
     }
   }
-  const innerW = maxW + 4;
+  const innerW = Math.min(maxW + 4, maxInnerW);
   const out = [];
   out.push("[VERBATIM OUTPUT \u2014 do not reformat]");
   for (let i = 0; i < sections.length; i++) {
@@ -4994,6 +5807,39 @@ async function generateStatusBrief(employees, data, _activeAgentIds) {
   out.push(boxBot(innerW));
   return out.join("\n");
 }
+function buildFirstBootBrief(employees, dateStr, sessionTag) {
+  const termCols = process.stdout.columns || 80;
+  const maxInnerW = termCols - 2;
+  const lines = [];
+  lines.push(` WELCOME TO EXE OS \u2014 ${dateStr}${sessionTag}`);
+  const bodyLines = [];
+  bodyLines.push(" \u{1F44B} First time? Here's your team:");
+  bodyLines.push("");
+  for (const emp of employees) {
+    const emoji = EMPLOYEE_EMOJIS[emp.name] ?? "\u{1F464}";
+    const role = emp.role ? ` (${emp.role})` : "";
+    bodyLines.push(`  ${emoji} ${emp.name}${role}`);
+  }
+  bodyLines.push("");
+  bodyLines.push(" \u{1F4A1} Quick start:");
+  bodyLines.push("  \u2022 Run `exe-os backfill-conversations` to import Claude Code history");
+  bodyLines.push("  \u2022 Say `/exe` to launch your COO with a full status brief");
+  bodyLines.push("  \u2022 Say `/exe-team` to manage your team");
+  let maxW = 0;
+  for (const line of [...lines, ...bodyLines]) {
+    const w = displayWidth(line);
+    if (w > maxW) maxW = w;
+  }
+  const innerW = Math.min(maxW + 4, maxInnerW);
+  const out = [];
+  out.push("[VERBATIM OUTPUT \u2014 do not reformat]");
+  out.push(boxTop(innerW));
+  for (const line of lines) out.push(boxRow(line, innerW));
+  out.push(boxMid(innerW));
+  for (const line of bodyLines) out.push(boxRow(line, innerW));
+  out.push(boxBot(innerW));
+  return out.join("\n");
+}
 function buildReminders(data) {
   if (!data.reminders || data.reminders.length === 0) return [];
   const lines = [];
@@ -5061,7 +5907,10 @@ function buildProjects(data) {
       idle.push(p);
     }
   }
-  for (const p of active) {
+  const MAX_SHOWN_PROJECTS = 6;
+  const shown = active.slice(0, MAX_SHOWN_PROJECTS);
+  const hidden = active.length - shown.length;
+  for (const p of shown) {
     const blocked = p.blockedCount ?? 0;
     const statusEmoji = blocked > 0 ? "\u{1F534}" : "\u{1F7E2}";
     const sessionStr = p.sessionName ? ` (${p.sessionName})` : p.isCurrent ? " (current)" : "";
@@ -5083,7 +5932,9 @@ function buildProjects(data) {
     if (blocked > 0) {
       lines.push(`    Blocked: ${blocked}`);
     }
-    lines.push("");
+  }
+  if (hidden > 0) {
+    lines.push(`  ... and ${hidden} more project${hidden === 1 ? "" : "s"}`);
   }
   if (idle.length > 0) {
     const idleNames = idle.map((p) => p.projectName);
@@ -5143,7 +5994,8 @@ function buildHealth(data) {
       }
     }
   }
-  lines.push(`  \u2601\uFE0F  Cloud: ${data.cloudConnected ? "\u{1F7E2}" : "not configured"}`);
+  const cloudLabel = data.cloudConnected ? "\u{1F7E2} synced" : data.cloudConnected === false && data.plan && data.plan !== "free" ? "\u{1F534} offline" : "not configured";
+  lines.push(`  \u2601\uFE0F  Cloud: ${cloudLabel}`);
   if (data.sessionsKilledToday !== void 0) {
     lines.push(`  \u{1F480} Sessions killed today: ${data.sessionsKilledToday}`);
   }
@@ -5182,7 +6034,7 @@ init_notifications();
 
 // src/adapters/claude/active-agent.ts
 init_config();
-import { readFileSync as readFileSync3, writeFileSync, mkdirSync as mkdirSync2, unlinkSync as unlinkSync2, readdirSync as readdirSync2 } from "fs";
+import { readFileSync as readFileSync4, writeFileSync, mkdirSync as mkdirSync2, unlinkSync as unlinkSync2, readdirSync as readdirSync2 } from "fs";
 import { execSync as execSync3 } from "child_process";
 import path6 from "path";
 
@@ -5292,18 +6144,18 @@ async function boot(options) {
     } catch {
     }
     try {
-      const { readdirSync: readdirSync6, readFileSync: readFs } = await import("fs");
+      const { readdirSync: readdirSync7, readFileSync: readFs } = await import("fs");
       const { STATUS_RE: STATUS_RE2, PRIORITY_RE: PRIORITY_RE2, TITLE_RE: TITLE_RE2 } = await Promise.resolve().then(() => (init_task_scanner(), task_scanner_exports));
       const { getProjectName: getProjectName2 } = await Promise.resolve().then(() => (init_project_name(), project_name_exports));
       const exeDir = "exe";
-      const entries = readdirSync6(exeDir, { withFileTypes: true });
+      const entries = readdirSync7(exeDir, { withFileTypes: true });
       const employeeDirs = entries.filter((e) => e.isDirectory() && !["output", "research"].includes(e.name));
       for (const dir of employeeDirs) {
         const employee = dir.name;
-        const taskDir = path18.join(exeDir, employee);
+        const taskDir = path19.join(exeDir, employee);
         let files;
         try {
-          files = readdirSync6(taskDir).filter((f) => f.endsWith(".md"));
+          files = readdirSync7(taskDir).filter((f) => f.endsWith(".md"));
         } catch {
           continue;
         }
@@ -5311,7 +6163,7 @@ async function boot(options) {
           const taskFilePath = `exe/${employee}/${file}`;
           let content;
           try {
-            content = readFs(path18.join(taskDir, file), "utf8");
+            content = readFs(path19.join(taskDir, file), "utf8");
           } catch {
             continue;
           }
@@ -5395,12 +6247,12 @@ async function boot(options) {
     } catch {
     }
     try {
-      const exeExeDir = path18.join(process.cwd(), "exe", "exe");
-      if (existsSync14(exeExeDir)) {
-        for (const f of readdirSync5(exeExeDir)) {
+      const exeExeDir = path19.join(process.cwd(), "exe", "exe");
+      if (existsSync15(exeExeDir)) {
+        for (const f of readdirSync6(exeExeDir)) {
           if (f.startsWith("review-") && f.endsWith(".md")) {
             try {
-              unlinkSync5(path18.join(exeExeDir, f));
+              unlinkSync6(path19.join(exeExeDir, f));
             } catch {
             }
           }
@@ -5444,12 +6296,12 @@ async function boot(options) {
           });
           const taskFile = String(r.task_file);
           try {
-            const filePath = path18.join(process.cwd(), taskFile);
-            if (existsSync14(filePath)) {
-              let content = readFileSync11(filePath, "utf8");
+            const filePath = path19.join(process.cwd(), taskFile);
+            if (existsSync15(filePath)) {
+              let content = readFileSync13(filePath, "utf8");
               content = content.replace(/\*\*Status:\*\* needs_review/, "**Status:** done");
-              const { writeFileSync: writeFileSync7 } = await import("fs");
-              writeFileSync7(filePath, content);
+              const { writeFileSync: writeFileSync8 } = await import("fs");
+              writeFileSync8(filePath, content);
             }
           } catch {
           }
@@ -5909,19 +6761,19 @@ async function boot(options) {
     })()
   ]);
   try {
-    const configPath = path18.join(
-      process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path18.join(os6.homedir(), ".exe-os"),
+    const configPath = path19.join(
+      process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path19.join(os6.homedir(), ".exe-os"),
       "config.json"
     );
-    if (existsSync14(configPath)) {
-      const raw = JSON.parse(readFileSync11(configPath, "utf8"));
+    if (existsSync15(configPath)) {
+      const raw = JSON.parse(readFileSync13(configPath, "utf8"));
       briefData.cloudConnected = !!(raw.cloud || raw.turso);
     }
   } catch {
   }
   try {
-    const backfillFlagPath = path18.join(EXE_AI_DIR, "session-cache", "needs-backfill");
-    const isBackfillNeeded = () => existsSync14(backfillFlagPath);
+    const backfillFlagPath = path19.join(EXE_AI_DIR, "session-cache", "needs-backfill");
+    const isBackfillNeeded = () => existsSync15(backfillFlagPath);
     const coverageResult = await client.execute({
       sql: `SELECT COUNT(*) as total,
                    SUM(CASE WHEN vector IS NOT NULL THEN 1 ELSE 0 END) as with_vectors
@@ -5943,8 +6795,8 @@ async function boot(options) {
     let daemonRunning = false;
     let daemonUptime;
     let daemonRequestsServed;
-    const socketPath = path18.join(EXE_AI_DIR, "exed.sock");
-    if (existsSync14(socketPath)) {
+    const socketPath = path19.join(EXE_AI_DIR, "exed.sock");
+    if (existsSync15(socketPath)) {
       try {
         const net = await import("net");
         const health = await new Promise((resolve) => {
@@ -5986,10 +6838,10 @@ async function boot(options) {
       }
     }
     if (!daemonRunning) {
-      const pidPath = path18.join(EXE_AI_DIR, "exed.pid");
-      if (existsSync14(pidPath)) {
+      const pidPath = path19.join(EXE_AI_DIR, "exed.pid");
+      if (existsSync15(pidPath)) {
         try {
-          const pid = parseInt(readFileSync11(pidPath, "utf8").trim(), 10);
+          const pid = parseInt(readFileSync13(pidPath, "utf8").trim(), 10);
           if (pid > 0) {
             process.kill(pid, 0);
             daemonRunning = true;
@@ -6000,10 +6852,10 @@ async function boot(options) {
     }
     if (nullCount === 0) {
       try {
-        const flagPath = path18.join(EXE_AI_DIR, "session-cache", "needs-backfill");
-        if (existsSync14(flagPath)) {
-          const { unlinkSync: unlinkSync6 } = await import("fs");
-          unlinkSync6(flagPath);
+        const flagPath = path19.join(EXE_AI_DIR, "session-cache", "needs-backfill");
+        if (existsSync15(flagPath)) {
+          const { unlinkSync: unlinkSync7 } = await import("fs");
+          unlinkSync7(flagPath);
         }
       } catch {
       }
@@ -6023,10 +6875,10 @@ async function boot(options) {
         const { spawn } = await import("child_process");
         const { fileURLToPath: fileURLToPath3 } = await import("url");
         const thisFile = fileURLToPath3(import.meta.url);
-        const backfillPath = path18.resolve(path18.dirname(thisFile), "backfill-vectors.js");
-        if (existsSync14(backfillPath)) {
+        const backfillPath = path19.resolve(path19.dirname(thisFile), "backfill-vectors.js");
+        if (existsSync15(backfillPath)) {
           const { openSync, closeSync } = await import("fs");
-          const workerLogPath = path18.join(EXE_AI_DIR, "workers.log");
+          const workerLogPath = path19.join(EXE_AI_DIR, "workers.log");
           let stderrFd = "ignore";
           try {
             stderrFd = openSync(workerLogPath, "a");
@@ -6054,8 +6906,8 @@ async function boot(options) {
     const criticalBinaries = ["backfill-vectors.js", "scan-tasks.js"];
     const missing = [];
     for (const bin of criticalBinaries) {
-      const binPath = path18.resolve(path18.dirname(thisFile), bin);
-      if (!existsSync14(binPath)) {
+      const binPath = path19.resolve(path19.dirname(thisFile), bin);
+      if (!existsSync15(binPath)) {
         missing.push(`dist/bin/${bin}`);
       }
     }
@@ -6085,7 +6937,7 @@ async function boot(options) {
     return;
   }
   const exeEmployee = employees.find((e) => e.name === "exe") ?? DEFAULT_EXE;
-  const sessionDir = path18.join(EXE_AI_DIR, "sessions", "exe");
+  const sessionDir = path19.join(EXE_AI_DIR, "sessions", "exe");
   await mkdir5(sessionDir, { recursive: true });
   const claudeMdContent = `${exeEmployee.systemPrompt}
 
@@ -6094,7 +6946,7 @@ async function boot(options) {
 # Status Brief
 
 ${brief}`;
-  await writeFile6(path18.join(sessionDir, "CLAUDE.md"), claudeMdContent, "utf-8");
+  await writeFile6(path19.join(sessionDir, "CLAUDE.md"), claudeMdContent, "utf-8");
   const unread = await readUnreadNotifications();
   if (unread.length > 0) {
     console.log(`\u{1F4EC} ${unread.length} unread notification${unread.length === 1 ? "" : "s"}`);
@@ -6103,12 +6955,12 @@ ${brief}`;
   await cleanupOldNotifications();
   console.log(brief);
   try {
-    const configPath2 = path18.join(
-      process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path18.join(os6.homedir(), ".exe-os"),
+    const configPath2 = path19.join(
+      process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path19.join(os6.homedir(), ".exe-os"),
       "config.json"
     );
-    if (existsSync14(configPath2)) {
-      const rawCfg = JSON.parse(readFileSync11(configPath2, "utf8"));
+    if (existsSync15(configPath2)) {
+      const rawCfg = JSON.parse(readFileSync13(configPath2, "utf8"));
       const cloudCfg = rawCfg.cloud;
       if (cloudCfg?.apiKey) {
         const { initSyncCrypto: initSyncCrypto2, isSyncCryptoInitialized: isSyncCryptoInitialized2 } = await Promise.resolve().then(() => (init_crypto(), crypto_exports));
@@ -6118,9 +6970,7 @@ ${brief}`;
           if (mk) initSyncCrypto2(mk);
         }
         const { cloudSync: cloudSync2 } = await Promise.resolve().then(() => (init_cloud_sync(), cloud_sync_exports));
-        cloudSync2({ apiKey: cloudCfg.apiKey, endpoint: cloudCfg.endpoint ?? "" }).catch((err) => {
-          process.stderr.write(`[boot] cloud sync failed: ${err instanceof Error ? err.message : String(err)}
-`);
+        cloudSync2({ apiKey: cloudCfg.apiKey, endpoint: cloudCfg.endpoint ?? "" }).catch(() => {
         });
       }
     }