@askexenow/exe-os 0.8.40 → 0.8.42

package/dist/hooks/summary-worker.js

@@ -330,6 +330,13 @@ async function ensureSchema() {
     });
   } catch {
   }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN session_scope TEXT`,
+      args: []
+    });
+  } catch {
+  }
   try {
     await client.execute({
       sql: `ALTER TABLE memories ADD COLUMN task_id TEXT`,
@@ -776,6 +783,18 @@ async function ensureSchema() {
     CREATE INDEX IF NOT EXISTS idx_session_kills_agent
       ON session_kills(agent_id);
   `);
+  await client.execute(`
+    CREATE TABLE IF NOT EXISTS global_procedures (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      priority TEXT NOT NULL DEFAULT 'p0',
+      domain TEXT,
+      active INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    )
+  `);
   await client.executeMultiple(`
     CREATE TABLE IF NOT EXISTS conversations (
       id              TEXT PRIMARY KEY,
@@ -1085,6 +1104,7 @@ var config_exports = {};
 __export(config_exports, {
   CONFIG_MIGRATIONS: () => CONFIG_MIGRATIONS,
   CONFIG_PATH: () => CONFIG_PATH,
+  COO_AGENT_NAME: () => COO_AGENT_NAME,
   CURRENT_CONFIG_VERSION: () => CURRENT_CONFIG_VERSION,
   DB_PATH: () => DB_PATH,
   EXE_AI_DIR: () => EXE_AI_DIR,
@@ -1240,7 +1260,7 @@ async function loadConfigFrom(configPath) {
     return { ...DEFAULT_CONFIG };
   }
 }
-var EXE_AI_DIR, DB_PATH, MODELS_DIR, CONFIG_PATH, LEGACY_LANCE_PATH, CURRENT_CONFIG_VERSION, DEFAULT_CONFIG, CONFIG_MIGRATIONS;
+var EXE_AI_DIR, DB_PATH, MODELS_DIR, CONFIG_PATH, COO_AGENT_NAME, LEGACY_LANCE_PATH, CURRENT_CONFIG_VERSION, DEFAULT_CONFIG, CONFIG_MIGRATIONS;
 var init_config = __esm({
   "src/lib/config.ts"() {
     "use strict";
@@ -1248,6 +1268,7 @@ var init_config = __esm({
     DB_PATH = path2.join(EXE_AI_DIR, "memories.db");
     MODELS_DIR = path2.join(EXE_AI_DIR, "models");
     CONFIG_PATH = path2.join(EXE_AI_DIR, "config.json");
+    COO_AGENT_NAME = "exe";
     LEGACY_LANCE_PATH = path2.join(EXE_AI_DIR, "local.lance");
     CURRENT_CONFIG_VERSION = 1;
     DEFAULT_CONFIG = {
@@ -1567,6 +1588,71 @@ var init_shard_manager = __esm({
   }
 });
 
+// src/lib/global-procedures.ts
+var global_procedures_exports = {};
+__export(global_procedures_exports, {
+  deactivateGlobalProcedure: () => deactivateGlobalProcedure,
+  getGlobalProceduresBlock: () => getGlobalProceduresBlock,
+  loadGlobalProcedures: () => loadGlobalProcedures,
+  storeGlobalProcedure: () => storeGlobalProcedure
+});
+import { randomUUID } from "crypto";
+async function loadGlobalProcedures() {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT * FROM global_procedures WHERE active = 1 ORDER BY priority ASC, created_at ASC",
+    args: []
+  });
+  const procedures = result.rows;
+  if (procedures.length > 0) {
+    _cache = procedures.map((p) => `### ${p.title}
+${p.content}`).join("\n\n");
+  } else {
+    _cache = "";
+  }
+  _cacheLoaded = true;
+  return procedures;
+}
+function getGlobalProceduresBlock() {
+  if (!_cacheLoaded) return "";
+  if (!_cache) return "";
+  return `## Organization-Wide Procedures (MANDATORY \u2014 supersedes all other rules)
+
+${_cache}
+`;
+}
+async function storeGlobalProcedure(input) {
+  const id = randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const client = getClient();
+  await client.execute({
+    sql: `INSERT INTO global_procedures (id, title, content, priority, domain, active, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, 1, ?, ?)`,
+    args: [id, input.title, input.content, input.priority ?? "p0", input.domain ?? null, now, now]
+  });
+  await loadGlobalProcedures();
+  return id;
+}
+async function deactivateGlobalProcedure(id) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const client = getClient();
+  const result = await client.execute({
+    sql: "UPDATE global_procedures SET active = 0, updated_at = ? WHERE id = ?",
+    args: [now, id]
+  });
+  await loadGlobalProcedures();
+  return result.rowsAffected > 0;
+}
+var _cache, _cacheLoaded;
+var init_global_procedures = __esm({
+  "src/lib/global-procedures.ts"() {
+    "use strict";
+    init_database();
+    _cache = "";
+    _cacheLoaded = false;
+  }
+});
+
 // src/lib/employees.ts
 import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
 import { existsSync as existsSync5, symlinkSync, readlinkSync, readFileSync as readFileSync3 } from "fs";
@@ -1638,7 +1724,7 @@ var init_employees = __esm({
 
 // src/lib/license.ts
 import { readFileSync as readFileSync4, writeFileSync, existsSync as existsSync6, mkdirSync as mkdirSync2 } from "fs";
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import path6 from "path";
 import { jwtVerify, importSPKI } from "jose";
 async function fetchRetry(url, init) {
@@ -1665,7 +1751,7 @@ function loadDeviceId() {
     }
   } catch {
   }
-  const id = randomUUID();
+  const id = randomUUID2();
   mkdirSync2(EXE_AI_DIR, { recursive: true });
   writeFileSync(DEVICE_ID_PATH, id, "utf8");
   return id;
@@ -1947,7 +2033,7 @@ var init_plan_limits = __esm({
 // src/lib/exe-daemon-client.ts
 import net from "net";
 import { spawn } from "child_process";
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import { existsSync as existsSync8, unlinkSync as unlinkSync2, readFileSync as readFileSync6, openSync, closeSync, statSync } from "fs";
 import path8 from "path";
 import { fileURLToPath } from "url";
@@ -2139,7 +2225,7 @@ function sendRequest(texts, priority) {
       resolve({ error: "Not connected" });
       return;
     }
-    const id = randomUUID2();
+    const id = randomUUID3();
     const timer = setTimeout(() => {
       _pending.delete(id);
       resolve({ error: "Request timeout" });
@@ -2157,7 +2243,7 @@ function sendRequest(texts, priority) {
 async function pingDaemon() {
   if (!_socket || !_connected) return null;
   return new Promise((resolve) => {
-    const id = randomUUID2();
+    const id = randomUUID3();
     const timer = setTimeout(() => {
       _pending.delete(id);
       resolve(null);
@@ -2458,7 +2544,8 @@ __export(cloud_sync_exports, {
   mergeRosterFromRemote: () => mergeRosterFromRemote,
   recordRosterDeletion: () => recordRosterDeletion
 });
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync2, existsSync as existsSync9, readdirSync as readdirSync3, mkdirSync as mkdirSync3, appendFileSync, unlinkSync as unlinkSync3 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync2, existsSync as existsSync9, readdirSync as readdirSync3, mkdirSync as mkdirSync3, appendFileSync, unlinkSync as unlinkSync3, openSync as openSync2, closeSync as closeSync2 } from "fs";
+import crypto4 from "crypto";
 import path9 from "path";
 import { homedir } from "os";
 function logError(msg) {
@@ -2470,17 +2557,29 @@ function logError(msg) {
   }
 }
 async function withRosterLock(fn) {
-  if (existsSync9(ROSTER_LOCK_PATH)) {
-    try {
-      const ts = parseInt(readFileSync7(ROSTER_LOCK_PATH, "utf-8"), 10);
-      if (Date.now() - ts < LOCK_STALE_MS) {
+  try {
+    const fd = openSync2(ROSTER_LOCK_PATH, "wx");
+    closeSync2(fd);
+    writeFileSync2(ROSTER_LOCK_PATH, String(Date.now()));
+  } catch (err) {
+    if (err.code === "EEXIST") {
+      try {
+        const ts = parseInt(readFileSync7(ROSTER_LOCK_PATH, "utf-8"), 10);
+        if (Date.now() - ts < LOCK_STALE_MS) {
+          throw new Error("Roster merge already in progress \u2014 another sync is running");
+        }
+        unlinkSync3(ROSTER_LOCK_PATH);
+        const fd = openSync2(ROSTER_LOCK_PATH, "wx");
+        closeSync2(fd);
+        writeFileSync2(ROSTER_LOCK_PATH, String(Date.now()));
+      } catch (retryErr) {
+        if (retryErr instanceof Error && retryErr.message.includes("already in progress")) throw retryErr;
         throw new Error("Roster merge already in progress \u2014 another sync is running");
       }
-    } catch (err) {
-      if (err instanceof Error && err.message.includes("already in progress")) throw err;
+    } else {
+      throw err;
     }
   }
-  writeFileSync2(ROSTER_LOCK_PATH, String(Date.now()));
   try {
     return await fn();
   } finally {
@@ -2498,7 +2597,7 @@ async function fetchWithRetry(url, init) {
     try {
       const signal = AbortSignal.timeout(FETCH_TIMEOUT_MS);
       const resp = await fetch(url, { ...init, signal });
-      if (resp.status >= 500 && attempt < MAX_RETRIES2) {
+      if (resp && resp.status >= 500 && attempt < MAX_RETRIES2) {
         await new Promise((r) => setTimeout(r, BASE_DELAY_MS2 * Math.pow(2, attempt)));
         continue;
       }
@@ -2542,6 +2641,10 @@ async function cloudPush(records, maxVersion, config) {
       },
       body: JSON.stringify({ version: maxVersion, blob })
     });
+    if (resp == null) {
+      logError("[cloud-sync] PUSH FAILED: no response from server");
+      return false;
+    }
     if (resp.status === 409) {
       logError("[cloud-sync] PUSH VERSION CONFLICT \u2014 re-pull required before next push");
       return false;
@@ -2564,6 +2667,10 @@ async function cloudPull(sinceVersion, config) {
       },
       body: JSON.stringify({ since_version: sinceVersion })
     });
+    if (response == null) {
+      logError("[cloud-sync] PULL FAILED: no response from server");
+      return { records: [], maxVersion: sinceVersion };
+    }
     if (!response.ok) return { records: [], maxVersion: sinceVersion };
     const data = await response.json();
     const allRecords = [];
@@ -2802,7 +2909,7 @@ function buildRosterBlob(paths) {
   }
   const deletedNames = consumeRosterDeletions();
   const content = JSON.stringify({ roster, identities, config, deletedNames });
-  const hash = Buffer.from(content).length;
+  const hash = crypto4.createHash("sha256").update(content).digest("hex").slice(0, 16);
   return { roster, identities, config, deletedNames, version: hash };
 }
 async function cloudPushRoster(config) {
@@ -3386,6 +3493,57 @@ init_memory();
 init_database();
 init_keychain();
 init_config();
+
+// src/lib/state-bus.ts
+var StateBus = class {
+  handlers = /* @__PURE__ */ new Map();
+  globalHandlers = /* @__PURE__ */ new Set();
+  /** Emit an event to all subscribers */
+  emit(event) {
+    const typeHandlers = this.handlers.get(event.type);
+    if (typeHandlers) {
+      for (const handler of typeHandlers) {
+        try {
+          handler(event);
+        } catch {
+        }
+      }
+    }
+    for (const handler of this.globalHandlers) {
+      try {
+        handler(event);
+      } catch {
+      }
+    }
+  }
+  /** Subscribe to a specific event type */
+  on(type, handler) {
+    if (!this.handlers.has(type)) {
+      this.handlers.set(type, /* @__PURE__ */ new Set());
+    }
+    this.handlers.get(type).add(handler);
+  }
+  /** Subscribe to ALL events */
+  onAny(handler) {
+    this.globalHandlers.add(handler);
+  }
+  /** Unsubscribe from a specific event type */
+  off(type, handler) {
+    this.handlers.get(type)?.delete(handler);
+  }
+  /** Unsubscribe from ALL events */
+  offAny(handler) {
+    this.globalHandlers.delete(handler);
+  }
+  /** Remove all listeners */
+  clear() {
+    this.handlers.clear();
+    this.globalHandlers.clear();
+  }
+};
+var orgBus = new StateBus();
+
+// src/lib/store.ts
 var INIT_MAX_RETRIES = 3;
 var INIT_RETRY_DELAY_MS = 1e3;
 function isBusyError2(err) {
@@ -3456,6 +3614,11 @@ async function initStore(options) {
     "version-query"
   );
   _nextVersion = (Number(vResult.rows[0]?.max_v) || 0) + 1;
+  try {
+    const { loadGlobalProcedures: loadGlobalProcedures2 } = await Promise.resolve().then(() => (init_global_procedures(), global_procedures_exports));
+    await loadGlobalProcedures2();
+  } catch {
+  }
 }
 function classifyTier(record) {
   if (record.tool_name === "commit_to_long_term_memory" && (record.importance ?? 0) >= 8) return 1;
@@ -3497,6 +3660,12 @@ async function writeMemory(record) {
     supersedes_id: record.supersedes_id ?? null
   };
   _pendingRecords.push(dbRow);
+  orgBus.emit({
+    type: "memory_stored",
+    agentId: record.agent_id,
+    project: record.project_name,
+    timestamp: record.timestamp
+  });
   const MAX_PENDING = 1e3;
   if (_pendingRecords.length > MAX_PENDING) {
     const dropped = _pendingRecords.length - MAX_PENDING;
@@ -3653,7 +3822,7 @@ function vectorToBlob(vector) {
 
 // src/adapters/claude/hooks/summary-worker.ts
 init_database();
-import crypto4 from "crypto";
+import crypto5 from "crypto";
 
 // src/lib/notifications.ts
 init_database();
@@ -3694,7 +3863,7 @@ async function writeNotification(notification) {
 
 // src/adapters/claude/hooks/summary-worker.ts
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync10, mkdirSync as mkdirSync5, openSync as openSync2, closeSync as closeSync2 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, openSync as openSync3, closeSync as closeSync3 } from "fs";
 import path11 from "path";
 async function main() {
   const agentId = process.env.AGENT_ID ?? "default";
@@ -3764,7 +3933,7 @@ async function main() {
     process.exit(0);
   }
   await writeMemory({
-    id: crypto4.randomUUID(),
+    id: crypto5.randomUUID(),
     agent_id: agentId,
     agent_role: agentRole,
     session_id: `auto-summary-${Date.now()}`,
@@ -3829,14 +3998,14 @@ async function main() {
         const { EXE_AI_DIR: exeDir2 } = await Promise.resolve().then(() => (init_config(), config_exports));
         const bLogPath = path11.join(exeDir2, "workers.log");
         mkdirSync5(path11.dirname(bLogPath), { recursive: true });
-        const bLogFd = openSync2(bLogPath, "a");
+        const bLogFd = openSync3(bLogPath, "a");
         const child = spawn2(process.execPath, [backfillPath], {
           detached: true,
           stdio: ["ignore", "ignore", bLogFd]
         });
         child.unref();
         try {
-          closeSync2(bLogFd);
+          closeSync3(bLogFd);
         } catch {
         }
         process.stderr.write("[summary-worker] Spawned backfill job\n");