@askexenow/exe-os 0.8.32 → 0.8.36

package/dist/bin/exe-forget.js

@@ -22,12 +22,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}`
@@ -36,17 +92,24 @@ async function initDatabase(config) {
     opts.encryptionKey = config.encryptionKey;
   }
   _client = createClient(opts);
+  _resilientClient = wrapWithRetry(_client);
 }
 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 {
@@ -835,11 +898,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;
   }
 });
@@ -1140,7 +1205,7 @@ function listShards() {
 }
 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 {

package/dist/bin/exe-gateway.js

@@ -281,12 +281,68 @@ var init_crm_bridge = __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(config2) {
   if (_client) {
     _client.close();
     _client = null;
+    _resilientClient = null;
   }
   const opts = {
     url: `file:${config2.dbPath}`
@@ -295,17 +351,24 @@ async function initDatabase(config2) {
     opts.encryptionKey = config2.encryptionKey;
   }
   _client = createClient(opts);
+  _resilientClient = wrapWithRetry(_client);
 }
 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 {
@@ -1098,13 +1161,16 @@ async function disposeDatabase() {
   if (_client) {
     _client.close();
     _client = null;
+    _resilientClient = null;
   }
 }
-var _client, initTurso, disposeTurso;
+var _client, _resilientClient, initTurso, disposeTurso;
 var init_database = __esm({
   "src/lib/database.ts"() {
     "use strict";
+    init_db_retry();
     _client = null;
+    _resilientClient = null;
     initTurso = initDatabase;
     disposeTurso = disposeDatabase;
   }
@@ -1539,11 +1605,11 @@ async function connectEmbedDaemon() {
     }
   }
   const start = Date.now();
-  let delay = 100;
+  let delay2 = 100;
   while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-    await new Promise((r) => setTimeout(r, delay));
+    await new Promise((r) => setTimeout(r, delay2));
     if (await connectToSocket()) return true;
-    delay = Math.min(delay * 2, 3e3);
+    delay2 = Math.min(delay2 * 2, 3e3);
   }
   return false;
 }
@@ -1635,11 +1701,11 @@ async function embedViaClient(text, priority = "high") {
 `);
       killAndRespawnDaemon();
       const start = Date.now();
-      let delay = 200;
+      let delay2 = 200;
       while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-        await new Promise((r) => setTimeout(r, delay));
+        await new Promise((r) => setTimeout(r, delay2));
         if (await connectToSocket()) break;
-        delay = Math.min(delay * 2, 3e3);
+        delay2 = Math.min(delay2 * 2, 3e3);
       }
       if (!_connected) return null;
     }
@@ -1651,11 +1717,11 @@ async function embedViaClient(text, priority = "high") {
 `);
     killAndRespawnDaemon();
     const start = Date.now();
-    let delay = 200;
+    let delay2 = 200;
     while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-      await new Promise((r) => setTimeout(r, delay));
+      await new Promise((r) => setTimeout(r, delay2));
       if (await connectToSocket()) break;
-      delay = Math.min(delay * 2, 3e3);
+      delay2 = Math.min(delay2 * 2, 3e3);
     }
     if (!_connected) return null;
     const retry = await sendRequest([text], priority);
@@ -1873,7 +1939,7 @@ function listShards() {
 }
 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 {
@@ -4510,25 +4576,43 @@ var init_intercom_queue = __esm({
 
 // src/lib/employees.ts
 import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { existsSync as existsSync8, symlinkSync, readlinkSync } from "fs";
+import { existsSync as existsSync8, symlinkSync, readlinkSync, readFileSync as readFileSync7 } from "fs";
 import { execSync as execSync3 } from "child_process";
 import path9 from "path";
-var EMPLOYEES_PATH;
+function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
+  if (!existsSync8(employeesPath)) return [];
+  try {
+    return JSON.parse(readFileSync7(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());
+}
+var EMPLOYEES_PATH, MULTI_INSTANCE_ROLES;
 var init_employees = __esm({
   "src/lib/employees.ts"() {
     "use strict";
     init_config();
     EMPLOYEES_PATH = path9.join(EXE_AI_DIR, "exe-employees.json");
+    MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["principal engineer", "content production specialist", "staff code reviewer"]);
   }
 });
 
 // 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();
@@ -4567,7 +4651,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;
     }
@@ -4602,7 +4686,7 @@ var init_plan_limits = __esm({
 
 // src/lib/tmux-routing.ts
 import { execFileSync as execFileSync2, execSync as execSync4 } from "child_process";
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync4, mkdirSync as mkdirSync6, existsSync as existsSync10, appendFileSync } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync4, mkdirSync as mkdirSync6, existsSync as existsSync10, appendFileSync } from "fs";
 import path11 from "path";
 import os4 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -4651,7 +4735,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;
@@ -4659,7 +4743,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"
     ));
@@ -4696,7 +4780,7 @@ function findFreeInstance(employeeName, exeSession, maxInstances = 10, isAlive =
 function readDebounceState() {
   try {
     if (!existsSync10(DEBOUNCE_FILE)) return {};
-    return JSON.parse(readFileSync8(DEBOUNCE_FILE, "utf8"));
+    return JSON.parse(readFileSync9(DEBOUNCE_FILE, "utf8"));
   } catch {
     return {};
   }
@@ -4892,7 +4976,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     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 = {};
@@ -4910,7 +4994,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 ?? {};
@@ -5237,7 +5321,7 @@ async function deliverLocalMessage(messageId) {
     return true;
   } catch {
     const newRetryCount = msg.retryCount + 1;
-    if (newRetryCount >= MAX_RETRIES) {
+    if (newRetryCount >= MAX_RETRIES2) {
       await markFailed(messageId, "session unavailable after 10 retries");
     } else {
       await client.execute({
@@ -5326,7 +5410,7 @@ async function retryPendingMessages() {
     sql: `SELECT * FROM messages
           WHERE status = 'pending' AND retry_count < ?
           ORDER BY id`,
-    args: [MAX_RETRIES]
+    args: [MAX_RETRIES2]
   });
   let delivered = 0;
   for (const row of result.rows) {
@@ -5339,13 +5423,13 @@ async function retryPendingMessages() {
   }
   return delivered;
 }
-var MAX_RETRIES, _wsClientSend;
+var MAX_RETRIES2, _wsClientSend;
 var init_messaging = __esm({
   "src/lib/messaging.ts"() {
     "use strict";
     init_database();
     init_tmux_routing();
-    MAX_RETRIES = 10;
+    MAX_RETRIES2 = 10;
     _wsClientSend = null;
   }
 });
@@ -5355,7 +5439,7 @@ import crypto4 from "crypto";
 import path12 from "path";
 import os5 from "os";
 import {
-  readFileSync as readFileSync9,
+  readFileSync as readFileSync10,
   readdirSync,
   unlinkSync as unlinkSync2,
   existsSync as existsSync11,
@@ -5407,7 +5491,7 @@ import crypto5 from "crypto";
 import path13 from "path";
 import { execSync as execSync5 } 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);
@@ -5784,7 +5868,7 @@ async function ensureGitignoreExe(baseDir) {
   const gitignorePath = path13.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 {
@@ -6160,7 +6244,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(
@@ -6195,6 +6279,7 @@ var init_tasks_notify = __esm({
     init_session_key();
     init_notifications();
     init_transport();
+    init_employees();
   }
 });
 
@@ -6666,7 +6751,7 @@ var init_tasks = __esm({
 });
 
 // src/automation/trigger-engine.ts
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync6, existsSync as existsSync14, mkdirSync as mkdirSync8 } from "fs";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync6, existsSync as existsSync14, mkdirSync as mkdirSync8 } from "fs";
 import { randomUUID as randomUUID7 } from "crypto";
 import path18 from "path";
 import os6 from "os";
@@ -6724,7 +6809,7 @@ function evaluateConditions(conditions, record) {
 function loadTriggers(project) {
   if (!existsSync14(TRIGGERS_PATH)) return [];
   try {
-    const raw = readFileSync11(TRIGGERS_PATH, "utf-8");
+    const raw = readFileSync12(TRIGGERS_PATH, "utf-8");
     const all = JSON.parse(raw);
     if (!Array.isArray(all)) return [];
     if (project) {
@@ -7020,7 +7105,7 @@ var init_crm_webhook = __esm({
 });
 
 // src/bin/exe-gateway.ts
-import { existsSync as existsSync15, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync13 } from "fs";
 import path19 from "path";
 import os7 from "os";
 
@@ -7857,7 +7942,7 @@ function loadConfig2() {
     return {};
   }
   try {
-    const raw = readFileSync12(CONFIG_PATH3, "utf-8");
+    const raw = readFileSync13(CONFIG_PATH3, "utf-8");
     return JSON.parse(raw);
   } catch (err) {
     console.error(

package/dist/bin/exe-heartbeat.js

@@ -15,12 +15,68 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// 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}`
@@ -29,17 +85,24 @@ async function initDatabase(config) {
     opts.encryptionKey = config.encryptionKey;
   }
   _client = createClient(opts);
+  _resilientClient = wrapWithRetry(_client);
 }
 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 {
@@ -828,11 +891,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;
   }
 });
@@ -1103,7 +1168,7 @@ function listShards() {
 }
 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 {
@@ -1289,7 +1354,7 @@ var init_shard_manager = __esm({
 
 // src/lib/employees.ts
 import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { existsSync as existsSync4, symlinkSync, readlinkSync } from "fs";
+import { existsSync as existsSync4, symlinkSync, readlinkSync, readFileSync as readFileSync2 } from "fs";
 import { execSync } from "child_process";
 import path4 from "path";
 var EMPLOYEES_PATH;
@@ -1306,7 +1371,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,
@@ -1324,7 +1389,7 @@ import crypto3 from "crypto";
 import path6 from "path";
 import { execSync as execSync2 } from "child_process";
 import { mkdir as mkdir4, writeFile as writeFile4, appendFile } from "fs/promises";
-import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
 var init_tasks_crud = __esm({
   "src/lib/tasks-crud.ts"() {
     "use strict";
@@ -1388,7 +1453,7 @@ var init_provider_table = __esm({
 });
 
 // src/lib/intercom-queue.ts
-import { readFileSync as readFileSync4, writeFileSync, renameSync as renameSync2, existsSync as existsSync7, mkdirSync as mkdirSync2 } from "fs";
+import { readFileSync as readFileSync5, writeFileSync, renameSync as renameSync2, existsSync as existsSync7, mkdirSync as mkdirSync2 } from "fs";
 import path8 from "path";
 import os4 from "os";
 var QUEUE_PATH, TTL_MS, INTERCOM_LOG;
@@ -1402,7 +1467,7 @@ var init_intercom_queue = __esm({
 });
 
 // src/lib/license.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync2, existsSync as existsSync8, mkdirSync as mkdirSync3 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync2, existsSync as existsSync8, mkdirSync as mkdirSync3 } from "fs";
 import { randomUUID } from "crypto";
 import path9 from "path";
 import { jwtVerify, importSPKI } from "jose";
@@ -1418,7 +1483,7 @@ var init_license = __esm({
 });
 
 // src/lib/plan-limits.ts
-import { readFileSync as readFileSync6, existsSync as existsSync9 } from "fs";
+import { readFileSync as readFileSync7, existsSync as existsSync9 } from "fs";
 import path10 from "path";
 var CACHE_PATH2;
 var init_plan_limits = __esm({
@@ -1483,7 +1548,7 @@ var init_tasks_review = __esm({
 
 // src/bin/exe-heartbeat.ts
 import { createHash } from "crypto";
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "fs";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "fs";
 import os6 from "os";
 import path13 from "path";
 
@@ -1622,7 +1687,7 @@ function getMarkerPath() {
 var UNREAD_MESSAGE_STATUSES = ["pending", "delivered"];
 function readMarker() {
   try {
-    const raw = readFileSync7(getMarkerPath(), "utf8");
+    const raw = readFileSync8(getMarkerPath(), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.lastFiredAt !== "string" || typeof parsed.lastSurfaceHash !== "string") {
       return null;
@@ -1740,7 +1805,6 @@ async function runHeartbeat() {
   writeMarker({ lastFiredAt: new Date(now).toISOString(), lastSurfaceHash: hash });
   try {
     const client = getClient();
-    await client.execute({ sql: "PRAGMA busy_timeout = 5000", args: [] });
     await client.execute({
       sql: `UPDATE messages SET status = 'acknowledged', processed_at = datetime('now')
             WHERE target_agent = 'exe' AND status IN ('pending', 'delivered')`,