@askexenow/exe-os 0.8.33 → 0.8.36

package/dist/bin/exe-launch-agent.js

@@ -262,7 +262,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 {
@@ -452,13 +452,18 @@ __export(employees_exports, {
   EMPLOYEES_PATH: () => EMPLOYEES_PATH,
   addEmployee: () => addEmployee,
   getEmployee: () => getEmployee,
+  getEmployeeByRole: () => getEmployeeByRole,
+  getEmployeeNamesByRole: () => getEmployeeNamesByRole,
+  hasRole: () => hasRole,
+  isMultiInstance: () => isMultiInstance,
   loadEmployees: () => loadEmployees,
+  loadEmployeesSync: () => loadEmployeesSync,
   registerBinSymlinks: () => registerBinSymlinks,
   saveEmployees: () => saveEmployees,
   validateEmployeeName: () => validateEmployeeName
 });
 import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { existsSync as existsSync5, symlinkSync, readlinkSync } from "fs";
+import { existsSync as existsSync5, symlinkSync, readlinkSync, readFileSync as readFileSync2 } from "fs";
 import { execSync as execSync2 } from "child_process";
 import path5 from "path";
 function validateEmployeeName(name) {
@@ -491,9 +496,36 @@ async function saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
   await mkdir3(path5.dirname(employeesPath), { recursive: true });
   await writeFile3(employeesPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
 }
+function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
+  if (!existsSync5(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 getEmployeeByRole(employees, role) {
+  const lower = role.toLowerCase();
+  return employees.find((e) => e.role.toLowerCase() === lower);
+}
+function getEmployeeNamesByRole(employees, role) {
+  const lower = role.toLowerCase();
+  return employees.filter((e) => e.role.toLowerCase() === lower).map((e) => e.name);
+}
+function hasRole(agentName, role) {
+  const employees = loadEmployeesSync();
+  const emp = getEmployee(employees, agentName);
+  return emp ? emp.role.toLowerCase() === role.toLowerCase() : false;
+}
+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 addEmployee(employees, employee) {
   const normalized = { ...employee, name: employee.name.toLowerCase() };
   if (employees.some((e) => e.name.toLowerCase() === normalized.name)) {
@@ -536,12 +568,13 @@ function registerBinSymlinks(name) {
   }
   return { created, skipped, errors };
 }
-var EMPLOYEES_PATH;
+var EMPLOYEES_PATH, MULTI_INSTANCE_ROLES;
 var init_employees = __esm({
   "src/lib/employees.ts"() {
     "use strict";
     init_config();
     EMPLOYEES_PATH = path5.join(EXE_AI_DIR, "exe-employees.json");
+    MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["principal engineer", "content production specialist", "staff code reviewer"]);
   }
 });
 
@@ -1026,6 +1059,32 @@ When you analyze a repo:
 Every analysis must answer: "Should we build this? If yes, how hard? If no, why not?"
 
 Maintain a clear separation between experimental (for evaluation) and production-ready (for shipping). Never recommend something you haven't read the source code for.`
+      },
+      bob: {
+        name: "bob",
+        role: "Staff Code Reviewer",
+        systemPrompt: `You are bob, the Staff Code Reviewer and System Auditor. You are the last line of defense before code ships to customers. You catch what developers miss \u2014 not just code bugs, but systemic patterns that make entire feature categories break. You report to the COO.
+
+Your core job: audit code, find bugs, verify fixes, and ensure customer-readiness. Every audit answers: "Would this break for a customer who customized their setup?"
+
+The 7 Audit Patterns (MANDATORY \u2014 apply to EVERY audit):
+1. "Works on dev, breaks on user install" \u2014 verify scoped paths, npm resolution, dependencies
+2. "Two code paths, one untested" \u2014 binary symlink vs /exe-call, CLI vs MCP \u2014 verify BOTH
+3. "Case sensitivity kills non-technical users" \u2014 normalize all user inputs
+4. "Hardcoded names leak into user-facing content" \u2014 grep for employee names in runtime logic
+5. "Installer doesn't self-heal on update" \u2014 npm update must auto-fix stale hooks/paths
+6. "Data written but invisible to the agent" \u2014 verify query path retrieves stored data
+7. "Partial fixes that miss inline references" \u2014 before/after grep count is mandatory
+
+Audit method:
+1. Read the actual source code \u2014 not summaries
+2. Send to Codex MCP for initial sweep
+3. Validate against ARCHITECTURE.md
+4. Trace full identity chain with a CUSTOM-NAMED employee (e.g., "jarvis" as CTO)
+5. Count matches before and after any claimed fix
+6. Write structured report with PASS/FAIL per item
+
+After an audit, fix the findings yourself if you can. Don't hand off when you have the context.`
       }
     };
     CLIENT_COO_TEMPLATE = `---
@@ -1181,7 +1240,7 @@ __export(active_agent_exports, {
   getAllActiveAgents: () => getAllActiveAgents,
   writeActiveAgent: () => writeActiveAgent
 });
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, unlinkSync as unlinkSync2, readdirSync as readdirSync2 } from "fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, unlinkSync as unlinkSync2, readdirSync as readdirSync2 } from "fs";
 import { execSync as execSync4 } from "child_process";
 import path6 from "path";
 function getMarkerPath() {
@@ -1206,7 +1265,7 @@ function clearActiveAgent() {
 function getActiveAgent() {
   try {
     const markerPath = getMarkerPath();
-    const raw = readFileSync2(markerPath, "utf8");
+    const raw = readFileSync3(markerPath, "utf8");
     const data = JSON.parse(raw);
     if (data.agentId) {
       if (data.startedAt) {
@@ -1259,7 +1318,7 @@ function getAllActiveAgents() {
       const key = file.slice("active-agent-".length, -".json".length);
       if (key === "undefined") continue;
       try {
-        const raw = readFileSync2(path6.join(CACHE_DIR, file), "utf8");
+        const raw = readFileSync3(path6.join(CACHE_DIR, file), "utf8");
         const data = JSON.parse(raw);
         if (!data.agentId) continue;
         if (data.startedAt) {
@@ -1311,17 +1370,70 @@ var init_active_agent = __esm({
 // src/bin/exe-launch-agent.ts
 import os3 from "os";
 import path7 from "path";
-import { existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, readdirSync as readdirSync3 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, readdirSync as readdirSync3 } from "fs";
 import { spawnSync } from "child_process";
 
 // src/lib/database.ts
 import { createClient } from "@libsql/client";
+
+// src/lib/db-retry.ts
+var MAX_RETRIES = 3;
+var BASE_DELAY_MS = 200;
+var MAX_JITTER_MS = 300;
+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);
+    }
+  });
+}
+
+// src/lib/database.ts
 var _client = null;
+var _resilientClient = null;
 var initTurso = initDatabase;
 async function initDatabase(config) {
   if (_client) {
     _client.close();
     _client = null;
+    _resilientClient = null;
   }
   const opts = {
     url: `file:${config.dbPath}`
@@ -1330,17 +1442,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 {
@@ -2134,6 +2253,7 @@ async function disposeDatabase() {
   if (_client) {
     _client.close();
     _client = null;
+    _resilientClient = null;
   }
 }
 
@@ -2512,7 +2632,13 @@ var PROVIDER_TABLE = {
 var DEFAULT_PROVIDER = "default";
 
 // src/bin/exe-launch-agent.ts
-var BUILTIN_AGENTS = ["exe", "yoshi", "tom", "mari", "sasha"];
+function getKnownAgents() {
+  try {
+    return loadEmployeesSync().map((e) => e.name);
+  } catch {
+    return ["exe"];
+  }
+}
 function parseBasename(basename) {
   const idx = basename.indexOf("-");
   if (idx === -1) return { agent: basename, provider: DEFAULT_PROVIDER };
@@ -2538,7 +2664,8 @@ function resolveAgent(argv) {
   return { agent, provider: DEFAULT_PROVIDER, passthrough };
 }
 async function isKnownAgent(agent) {
-  if (BUILTIN_AGENTS.includes(agent)) return true;
+  const knownAgents = getKnownAgents();
+  if (knownAgents.some((a) => a.toLowerCase() === agent.toLowerCase())) return true;
   try {
     const employees = await loadEmployees();
     return employees.some((e) => e.name.toLowerCase() === agent.toLowerCase());
@@ -2560,7 +2687,7 @@ function buildLaunchPlan(agent, behaviorsPath, passthrough, _hasAgentFlag, _prov
   const effectiveIdPath = existsSync6(idPath) ? idPath : existsSync6(ccAgentPath) ? ccAgentPath : null;
   if (effectiveIdPath) {
     try {
-      const identity = readFileSync3(effectiveIdPath, "utf-8");
+      const identity = readFileSync4(effectiveIdPath, "utf-8");
       args.push("--system-prompt", identity);
     } catch {
       args.push("--append-system-prompt-file", effectiveIdPath);
@@ -2695,7 +2822,7 @@ async function main() {
       if (sourceFile) {
         try {
           mkdirSync4(ccAgentDir, { recursive: true });
-          let content = readFileSync3(sourceFile, "utf-8");
+          let content = readFileSync4(sourceFile, "utf-8");
           content = content.replace(/\$\{agent_id\}/g, agent);
           writeFileSync3(ccAgentFile, content, "utf-8");
           process.stderr.write(