@askexenow/exe-os 0.9.413 → 0.9.415

package/dist/{chunk-M6AX64J2.js → chunk-QNFR7ZKH.js}

@@ -1,10 +1,10 @@
 import {
   getCurrentSessionScope,
   strictSessionScopeFilter
-} from "./chunk-GM4UEZDE.js";
+} from "./chunk-WEG7URND.js";
 import {
   getProjectName
-} from "./chunk-TVWYMOZ4.js";
+} from "./chunk-O3HLDFKY.js";
 
 // src/lib/session-events.ts
 import { randomUUID } from "crypto";
@@ -59,12 +59,18 @@ function sessionEventsRetentionMode(workerEnabled, workerReady) {
   };
 }
 async function sweepExpiredSessionEvents(client, retentionDays = DEFAULT_SESSION_EVENTS_RETENTION_DAYS) {
+  return (await sweepExpiredSessionEventsBatches(client, retentionDays, SESSION_EVENTS_SWEEP_MAX_BATCHES)).deleted;
+}
+var SESSION_EVENTS_SWEEP_BATCH_SIZE = 500;
+var SESSION_EVENTS_SWEEP_MAX_BATCHES = 200;
+async function sweepExpiredSessionEventsBatches(client, retentionDays = DEFAULT_SESSION_EVENTS_RETENTION_DAYS, maxBatches = SESSION_EVENTS_SWEEP_MAX_BATCHES) {
   const days = Number.isFinite(retentionDays) && retentionDays > 0 ? Math.floor(retentionDays) : DEFAULT_SESSION_EVENTS_RETENTION_DAYS;
+  const batches = Number.isFinite(maxBatches) && maxBatches > 0 ? Math.min(Math.floor(maxBatches), SESSION_EVENTS_SWEEP_MAX_BATCHES) : 1;
   const cutoff = `-${days} days`;
-  const BATCH_SIZE = 500;
-  const MAX_BATCHES = 200;
+  const BATCH_SIZE = SESSION_EVENTS_SWEEP_BATCH_SIZE;
   let total = 0;
-  for (let i = 0; i < MAX_BATCHES; i++) {
+  let drained = false;
+  for (let i = 0; i < batches; i++) {
     const result = await client.execute({
       sql: `DELETE FROM session_events
             WHERE id IN (
@@ -77,10 +83,13 @@ async function sweepExpiredSessionEvents(client, retentionDays = DEFAULT_SESSION
     });
     const affected = Number(result.rowsAffected ?? 0);
     total += affected;
-    if (affected < BATCH_SIZE) break;
-    await new Promise((resolve) => setImmediate(resolve));
+    if (affected < BATCH_SIZE) {
+      drained = true;
+      break;
+    }
+    if (i + 1 < batches) await new Promise((resolve) => setImmediate(resolve));
   }
-  return total;
+  return { deleted: total, drained };
 }
 async function recordSessionEvent(client, input) {
   if (!input.content || input.content.trim().length === 0) return;
@@ -168,6 +177,9 @@ export {
   DEFAULT_SESSION_EVENTS_RETENTION_DAYS,
   sessionEventsRetentionMode,
   sweepExpiredSessionEvents,
+  SESSION_EVENTS_SWEEP_BATCH_SIZE,
+  SESSION_EVENTS_SWEEP_MAX_BATCHES,
+  sweepExpiredSessionEventsBatches,
   recordSessionEvent,
   listRecentSessionEvents
 };

package/dist/{chunk-DWRULKB3.js → chunk-R32D6TBB.js}

@@ -1,12 +1,12 @@
 import {
   sessionScopeFilter
-} from "./chunk-GM4UEZDE.js";
+} from "./chunk-WEG7URND.js";
 import {
   leaseExpiryIso
 } from "./chunk-E23LNUWJ.js";
 import {
   getProjectName
-} from "./chunk-TVWYMOZ4.js";
+} from "./chunk-O3HLDFKY.js";
 
 // src/lib/subagent-observability.ts
 var MAX_RESULT_DIGEST_CHARS = 200;

package/dist/chunk-R3ZU4F7M.js

@@ -0,0 +1,359 @@
+import {
+  isPostgresBackendEnabled
+} from "./chunk-YYB5PMTK.js";
+
+// src/lib/db-write-worker-client.ts
+import { fork } from "child_process";
+import { existsSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { randomUUID } from "crypto";
+var _worker = null;
+var _workerReady = false;
+var _spawnAttempts = 0;
+var MAX_SPAWN_ATTEMPTS = 5;
+var _respawning = false;
+var _killReason = null;
+var _retryAfterExit = false;
+var _readyDeadline = null;
+var _lastSpawnArgs = null;
+var _pending = /* @__PURE__ */ new Map();
+var _queue = [];
+var _inFlightId = null;
+function writeTimeoutMs() {
+  return Number(process.env.EXE_DB_WRITE_WORKER_TIMEOUT_MS) || 6e4;
+}
+function sweepBatchTimeoutMs() {
+  return Number(process.env.EXE_DB_WRITE_WORKER_SWEEP_BATCH_TIMEOUT_MS) || 9e4;
+}
+function respawnReadyTimeoutMs() {
+  return Number(process.env.EXE_DB_WRITE_WORKER_READY_TIMEOUT_MS) || 3e4;
+}
+function memoryWriteBehindSweepBoundMs() {
+  return sweepBatchTimeoutMs() + respawnReadyTimeoutMs() + writeTimeoutMs();
+}
+var SWEEP_MAX_BATCHES_PER_TICK = 200;
+function sweepTickBudgetMs() {
+  return Number(process.env.EXE_DB_WRITE_WORKER_SWEEP_TICK_BUDGET_MS) || 30 * 6e4;
+}
+function buildDbWriteWorkerEnv(dbPath, encryptionKey, source = process.env) {
+  const env = {
+    ...source,
+    EXE_IS_DAEMON: "",
+    EXE_DB_DIRECT: "1",
+    EXE_BOOT_FAST: "1",
+    EXE_DB_NO_CHECKPOINT_TIMER: "1"
+  };
+  if (dbPath) env.EXE_DB_WRITE_WORKER_PATH = dbPath;
+  if (encryptionKey) env.EXE_DB_WRITE_WORKER_KEY = encryptionKey;
+  return env;
+}
+function rejectAllPending(reason) {
+  for (const [id, cb] of _pending) {
+    if (cb.timer) clearTimeout(cb.timer);
+    cb.reject(new Error(reason));
+    _pending.delete(id);
+  }
+  _queue.length = 0;
+  _inFlightId = null;
+}
+function rejectInFlight(reason) {
+  const id = _inFlightId;
+  _inFlightId = null;
+  if (!id) return;
+  const cb = _pending.get(id);
+  if (!cb) return;
+  _pending.delete(id);
+  if (cb.timer) clearTimeout(cb.timer);
+  cb.reject(new Error(reason));
+}
+function clearReadyDeadline() {
+  if (_readyDeadline) clearTimeout(_readyDeadline);
+  _readyDeadline = null;
+}
+function armReadyDeadline(child) {
+  clearReadyDeadline();
+  const ms = respawnReadyTimeoutMs();
+  _readyDeadline = setTimeout(() => {
+    _readyDeadline = null;
+    if (_worker !== child || _workerReady) return;
+    process.stderr.write(
+      `[exed] DB write worker respawn (pid=${child.pid}) not ready after ${ms}ms \u2014 marking it unavailable and retrying the spawn.
+`
+    );
+    _respawning = false;
+    rejectAllPending(`db write worker not available (respawn not ready after ${ms}ms)`);
+    _retryAfterExit = true;
+    try {
+      child.kill("SIGKILL");
+    } catch {
+    }
+  }, ms);
+  _readyDeadline.unref?.();
+}
+function isWriteWorkerEnabled(env = process.env) {
+  return env.EXE_WRITE_WORKER !== "0";
+}
+function resolveDbWriteWorkerPath(selfUrl, exists = existsSync) {
+  let selfDir;
+  try {
+    selfDir = path.dirname(fileURLToPath(selfUrl));
+  } catch {
+    return null;
+  }
+  for (const candidate of [
+    path.join(selfDir, "db-write-worker.js"),
+    path.join(selfDir, "lib", "db-write-worker.js")
+  ]) {
+    if (exists(candidate)) return candidate;
+  }
+  return null;
+}
+function spawnDbWriteWorker(dbPath, encryptionKey, opts) {
+  if (!opts?.forMaintenance && !isWriteWorkerEnabled()) return;
+  if (_worker) return;
+  _lastSpawnArgs = { dbPath, encryptionKey, opts };
+  if (_spawnAttempts >= MAX_SPAWN_ATTEMPTS) return;
+  _spawnAttempts++;
+  const workerPath = process.env.EXE_DB_WRITE_WORKER_BIN ?? resolveDbWriteWorkerPath(import.meta.url);
+  if (!workerPath || !existsSync(workerPath)) {
+    process.stderr.write(
+      `[db-write-worker-client] worker not found (${workerPath ?? "checked ./db-write-worker.js and ./lib/db-write-worker.js next to this module"}) - memory writes will run on the event loop.
+`
+    );
+    return;
+  }
+  const env = buildDbWriteWorkerEnv(dbPath, encryptionKey);
+  if (!isPostgresBackendEnabled(env) && !env.EXE_DB_WRITE_WORKER_PATH) {
+    process.stderr.write("[db-write-worker-client] no SQLite db path for write worker - memory writes will run on the event loop.\n");
+    _spawnAttempts = Math.max(0, _spawnAttempts - 1);
+    return;
+  }
+  try {
+    _worker = fork(workerPath, [], { stdio: ["ignore", "ignore", "inherit", "ipc"], env });
+  } catch (err) {
+    process.stderr.write(`[db-write-worker-client] fork failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    _worker = null;
+    return;
+  }
+  const child = _worker;
+  if (_respawning || _retryAfterExit) armReadyDeadline(child);
+  _retryAfterExit = false;
+  _worker.on("message", (msg) => {
+    if (msg.type === "ready") {
+      if (_worker !== child) return;
+      clearReadyDeadline();
+      _workerReady = !msg.error;
+      _spawnAttempts = 0;
+      process.stderr.write(`[exed] DB write worker ${msg.error ? `failed: ${msg.error}` : `ready (pid=${child.pid})`}
+`);
+      if (_respawning) {
+        _respawning = false;
+        if (!_workerReady) rejectAllPending("db write worker not available (respawn failed)");
+      }
+      pumpQueue();
+      return;
+    }
+    if (_worker !== child) return;
+    if (!msg.id) return;
+    if (msg.id === _inFlightId) _inFlightId = null;
+    const cb = _pending.get(msg.id);
+    if (cb) {
+      _pending.delete(msg.id);
+      if (cb.timer) clearTimeout(cb.timer);
+      if (msg.error) cb.reject(new Error(msg.error));
+      else if (msg.memoryId) cb.resolve({ memoryId: msg.memoryId, version: msg.version, deduped: msg.deduped });
+      else if (typeof msg.deleted === "number") {
+        cb.resolve({ deleted: msg.deleted, archived: msg.archived, purged: msg.purged, mode: msg.mode, drained: msg.drained });
+      } else if (msg.ok) cb.resolve({ ok: true, result: msg.result });
+      else cb.reject(new Error("invalid write-worker response"));
+    }
+    pumpQueue();
+  });
+  _worker.on("error", (err) => {
+    process.stderr.write(`[exed] DB write worker error: ${err.message}
+`);
+    if (_worker !== child) return;
+    _workerReady = false;
+    if (!_respawning) rejectAllPending("write worker crashed");
+  });
+  _worker.on("exit", (code, signal) => {
+    process.stderr.write(`[exed] DB write worker exited (code=${code}, signal=${signal ?? "none"}).
+`);
+    if (_worker !== child) return;
+    clearReadyDeadline();
+    _workerReady = false;
+    _worker = null;
+    const respawnArgs = _lastSpawnArgs;
+    if (_retryAfterExit) {
+      if (respawnArgs) spawnDbWriteWorker(respawnArgs.dbPath, respawnArgs.encryptionKey, respawnArgs.opts);
+      _retryAfterExit = false;
+      return;
+    }
+    if (!_respawning) {
+      rejectAllPending("write worker exited");
+      return;
+    }
+    rejectInFlight(_killReason ?? "db write worker request timed out (worker killed before reporting)");
+    _killReason = null;
+    if (respawnArgs) spawnDbWriteWorker(respawnArgs.dbPath, respawnArgs.encryptionKey, respawnArgs.opts);
+    if (!_worker) {
+      _respawning = false;
+      rejectAllPending("db write worker not available (respawn failed)");
+    }
+  });
+}
+function isDbWriteWorkerReady() {
+  return _worker !== null && (_workerReady || _respawning);
+}
+async function writeMemoryInWorker(payload) {
+  const result = await sendWriteWorkerRequest({ type: "write-memory", ...payload }, "memory-write");
+  if (!result.memoryId) throw new Error("invalid write-worker response");
+  return result;
+}
+async function runSweepBatches(message, opts, onBatch) {
+  const now = opts.now ?? Date.now;
+  const maxBatches = opts.maxBatches ?? SWEEP_MAX_BATCHES_PER_TICK;
+  const budgetMs = opts.budgetMs ?? sweepTickBudgetMs();
+  const started = now();
+  const out = { deleted: 0, batches: 0, drained: false };
+  while (out.batches < maxBatches && now() - started < budgetMs) {
+    let result;
+    try {
+      result = await sendWriteWorkerRequest({ ...message, maxBatches: 1 }, "sweep");
+    } catch (err) {
+      if (out.batches === 0) throw err;
+      out.error = err instanceof Error ? err.message : String(err);
+      return out;
+    }
+    out.batches++;
+    out.deleted += Number(result.deleted ?? 0);
+    onBatch(result);
+    if (result.drained !== false) {
+      out.drained = true;
+      break;
+    }
+  }
+  return out;
+}
+async function sweepSessionEventsRetentionInWorker(retentionDays, opts = {}) {
+  return runSweepBatches({ type: "sweep-session-events-retention", retentionDays }, opts, () => {
+  });
+}
+async function sweepConversationsRetentionInWorker(retentionDays, retentionMode, opts = {}) {
+  let archived = 0;
+  let purged = 0;
+  let mode = "archive";
+  const res = await runSweepBatches(
+    { type: "sweep-conversations-retention", retentionDays, retentionMode },
+    opts,
+    (r) => {
+      archived += Number(r.archived ?? 0);
+      purged += Number(r.purged ?? 0);
+      if (r.mode) mode = String(r.mode);
+    }
+  );
+  return { ...res, archived, purged, mode };
+}
+async function requestMaintenanceWrite(jobId, jobName, kind, payload) {
+  const result = await sendWriteWorkerRequest(
+    { type: "maintenance-job-write", jobId, jobName, kind, payload },
+    "maintenance"
+  );
+  return result.result;
+}
+function sendWriteWorkerRequest(payload, kind) {
+  if (!_worker || !_workerReady && !_respawning) {
+    return Promise.reject(new Error("db write worker not available"));
+  }
+  const id = randomUUID();
+  const timeoutMs = kind === "sweep" ? sweepBatchTimeoutMs() : writeTimeoutMs();
+  return new Promise((resolve, reject) => {
+    _pending.set(id, { kind, message: { id, ...payload }, timeoutMs, resolve, reject, timer: null });
+    _queue.push(id);
+    pumpQueue();
+  });
+}
+function pumpQueue() {
+  while (_inFlightId === null && _queue.length > 0 && _worker && _workerReady) {
+    const id = _queue.shift();
+    const req = _pending.get(id);
+    if (!req) continue;
+    _inFlightId = id;
+    req.timer = setTimeout(() => onRequestTimeout(id), req.timeoutMs);
+    try {
+      _worker.send(req.message);
+    } catch (err) {
+      clearTimeout(req.timer);
+      _pending.delete(id);
+      _inFlightId = null;
+      req.reject(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+}
+function onRequestTimeout(requestId) {
+  const req = _pending.get(requestId);
+  if (!req) return;
+  if (req.kind === "memory-write" || req.kind === "sweep") {
+    abortWorkerAfterTimeout(requestId, req);
+    return;
+  }
+  process.stderr.write(
+    `[exed] DB write worker ${req.kind} request ${requestId.slice(0, 8)} exceeded ${req.timeoutMs}ms \u2014 rejecting it without killing the worker.
+`
+  );
+  _pending.delete(requestId);
+  if (_inFlightId === requestId) _inFlightId = null;
+  req.reject(new Error(`db write worker ${req.kind} request timed out after ${req.timeoutMs}ms (worker not killed)`));
+  pumpQueue();
+}
+function abortWorkerAfterTimeout(requestId, req) {
+  const timeoutMs = req.timeoutMs;
+  const worker = _worker;
+  if (!worker || !_pending.has(requestId) || _respawning) return;
+  process.stderr.write(
+    `[exed] DB write worker ${req.kind} request ${requestId.slice(0, 8)} exceeded ${timeoutMs}ms \u2014 killing the worker so the request cannot commit after it is reported failed; respawning (${_queue.length} queued request(s) kept for the new worker).
+`
+  );
+  _workerReady = false;
+  _respawning = true;
+  _killReason = req.kind === "sweep" ? `db write worker sweep request timed out after ${timeoutMs}ms (worker killed, batch rolled back)` : "db write worker write timed out (worker killed before reporting)";
+  try {
+    worker.kill("SIGKILL");
+  } catch {
+  }
+}
+function _getDbWriteWorkerForTests() {
+  return _worker;
+}
+function disposeDbWriteWorker() {
+  _respawning = false;
+  _retryAfterExit = false;
+  _killReason = null;
+  clearReadyDeadline();
+  rejectAllPending("write worker disposed");
+  if (_worker) {
+    try {
+      _worker.kill("SIGTERM");
+    } catch {
+    }
+    _worker = null;
+  }
+  _workerReady = false;
+}
+
+export {
+  memoryWriteBehindSweepBoundMs,
+  buildDbWriteWorkerEnv,
+  isWriteWorkerEnabled,
+  resolveDbWriteWorkerPath,
+  spawnDbWriteWorker,
+  isDbWriteWorkerReady,
+  writeMemoryInWorker,
+  sweepSessionEventsRetentionInWorker,
+  sweepConversationsRetentionInWorker,
+  requestMaintenanceWrite,
+  _getDbWriteWorkerForTests,
+  disposeDbWriteWorker
+};

package/dist/{chunk-3N24FV22.js → chunk-REMAJEVA.js}

@@ -1,6 +1,6 @@
 import {
   getMasterKey
-} from "./chunk-4J77TCTX.js";
+} from "./chunk-PMGEC42V.js";
 import {
   PRIVATE_DIR_MODE,
   PRIVATE_FILE_MODE,

package/dist/{chunk-7SHU5MOD.js → chunk-RJ7RN5GE.js}

@@ -1,6 +1,6 @@
 import {
   getMasterKey
-} from "./chunk-4J77TCTX.js";
+} from "./chunk-PMGEC42V.js";
 
 // src/lib/monitor-identity.ts
 import crypto from "crypto";

package/dist/{chunk-5BWDUUMH.js → chunk-RMXIDLAZ.js}

@@ -1,21 +1,21 @@
 import {
   cleanupCardsForMemories,
   cleanupGraphLinksForMemories
-} from "./chunk-HTFM7ZDD.js";
+} from "./chunk-LFIDYVYE.js";
 import {
   resolveAnthropicAuth
 } from "./chunk-VGMACSEV.js";
 import {
   buildSystemStateExclusionFilter,
   vectorToBlob
-} from "./chunk-LSHUX7P4.js";
+} from "./chunk-D4RU4Y57.js";
 import {
   extractKeywords,
   keywordsToString
 } from "./chunk-CHCA3ZM2.js";
 import {
   isCoordinatorName
-} from "./chunk-L5JFVK5T.js";
+} from "./chunk-GDZJL5GQ.js";
 
 // src/lib/consolidation.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-PTF5TB6O.js → chunk-RNFYJ7EQ.js}

@@ -1,3 +1,9 @@
+import {
+  TelegramAdapter
+} from "./chunk-Q3V7K4ME.js";
+import {
+  DiscordAdapter
+} from "./chunk-N5RRQOAC.js";
 import {
   SlackAdapter
 } from "./chunk-ORCCI2VV.js";
@@ -7,19 +13,13 @@ import {
 import {
   createCRMWebhookHandler,
   parseTwentyWebhook
-} from "./chunk-RHJOTGEU.js";
+} from "./chunk-5HCHK52F.js";
 import {
   WhatsAppAdapter
-} from "./chunk-3N24FV22.js";
+} from "./chunk-REMAJEVA.js";
 import {
   SignalAdapter
 } from "./chunk-RJT7H2KR.js";
-import {
-  TelegramAdapter
-} from "./chunk-Q3V7K4ME.js";
-import {
-  DiscordAdapter
-} from "./chunk-N5RRQOAC.js";
 import {
   BotRegistry,
   BotRuntime,
@@ -42,7 +42,7 @@ import {
   retryWithBackoff,
   routeMessage,
   validateGatewayConfig
-} from "./chunk-XEAZJXMZ.js";
+} from "./chunk-IM2KTXBB.js";
 import {
   OllamaProvider
 } from "./chunk-FWFFZGSC.js";

package/dist/{chunk-RJIH7JXM.js → chunk-RV4DRCSF.js}

@@ -1,12 +1,12 @@
 import {
   sendMessage
-} from "./chunk-7KPZQ65I.js";
+} from "./chunk-KAJC6L7D.js";
 import {
   getActiveAgent
-} from "./chunk-GL5ZG72X.js";
+} from "./chunk-CTZTOAHJ.js";
 import {
   resolveExeSession
-} from "./chunk-GM4UEZDE.js";
+} from "./chunk-WEG7URND.js";
 import {
   getDispatcherSession
 } from "./chunk-PCV52RYM.js";
@@ -16,7 +16,7 @@ import {
 import {
   getCoordinatorName,
   isCoordinatorName
-} from "./chunk-L5JFVK5T.js";
+} from "./chunk-GDZJL5GQ.js";
 
 // src/mcp/tools/send-message.ts
 import { z } from "zod";

package/dist/{chunk-QOFQY7BJ.js → chunk-RYJTPWKV.js}

@@ -85,7 +85,7 @@ async function getRetrievalHealth() {
     totalMemories = Number(totalRes.rows[0]?.cnt ?? 0);
     memoriesWithVectors = Number(vectorRes.rows[0]?.cnt ?? 0);
     try {
-      const { getGraphStats } = await import("./graph-query-7YA3YNKL.js");
+      const { getGraphStats } = await import("./graph-query-U4WIQNFV.js");
       const stats = await getGraphStats(client);
       entities = stats.entities;
       relationships = stats.relationships;