@askexenow/exe-os 0.9.322 → 0.9.324

package/dist/{chunk-XLNF3CIO.js → chunk-QGOMYIVT.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-2I23RPSI.js";
 import {
   listBackups
-} from "./chunk-WXRVHXVP.js";
+} from "./chunk-7577GDDG.js";
 import {
   getEmotionalBaseline,
   renderEmotionalBaselineSection
@@ -26,7 +26,7 @@ import {
 } from "./chunk-SHIICYJW.js";
 
 // src/lib/database.ts
-import { chmodSync, existsSync as existsSync3, statSync, copyFileSync, unlinkSync as unlinkSync2, openSync, closeSync, mkdirSync as mkdirSync2, renameSync as renameSync2 } from "fs";
+import { chmodSync, existsSync as existsSync3, statSync, copyFileSync, unlinkSync as unlinkSync2, openSync, closeSync, mkdirSync as mkdirSync2, renameSync as renameSync2, readFileSync as readFileSync3, writeSync, fsyncSync, fstatSync } from "fs";
 import { createClient } from "@libsql/client";
 import { homedir, totalmem } from "os";
 import { join } from "path";
@@ -1119,7 +1119,7 @@ async function migrateReflectionDedup(client) {
     "ALTER TABLE memory_reflections ADD COLUMN dedup_key TEXT",
     "migration add memory_reflections.dedup_key"
   );
-  const { reflectionDedupKey } = await import("./memory-reflection-AYPJRPU7.js");
+  const { reflectionDedupKey } = await import("./memory-reflection-LANCFYK2.js");
   const keyForRow = (row) => {
     let sources = [];
     try {
@@ -1199,44 +1199,135 @@ var _checkpointInProgress = false;
 var _daemonClient = null;
 var _adapterClient = null;
 var _lockFd = null;
-var DB_LOCK_PATH = join(homedir(), ".exe-os", "db.lock");
-function acquireDbLock() {
-  mkdirSync2(join(homedir(), ".exe-os"), { recursive: true });
+var _lockIdentity = null;
+function dbLockPath() {
+  return process.env.EXE_DB_LOCK_PATH ?? join(homedir(), ".exe-os", "db.lock");
+}
+function dbLockWaitMs() {
+  const raw = Number(process.env.EXE_DB_LOCK_WAIT_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : 15e3;
+}
+var DB_LOCK_STALE_MS = 6e4;
+var DbLockHeldError = class extends Error {
+  constructor(holderPid, waitedMs) {
+    super(
+      `[database] db.lock is held by a live process${holderPid ? ` (pid ${holderPid})` : ""} after waiting ${waitedMs}ms \u2014 refusing to open the database with a second writer. Retry once the other exe-os process finishes initializing.`
+    );
+    this.name = "DbLockHeldError";
+  }
+};
+function readLockHolderPid(lockPath) {
+  try {
+    const pid = parseInt(readFileSync3(lockPath, "utf8").trim(), 10);
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function pidIsAlive(pid) {
   try {
-    _lockFd = openSync(DB_LOCK_PATH, "wx");
+    process.kill(pid, 0);
+    return true;
   } catch (err) {
-    if (err && typeof err === "object" && "code" in err && err.code === "EEXIST") {
+    return err.code === "EPERM";
+  }
+}
+function tryTakeLock(lockPath) {
+  _lockFd = openSync(lockPath, "wx");
+  try {
+    writeSync(_lockFd, `${process.pid}
+`);
+    fsyncSync(_lockFd);
+    const st = fstatSync(_lockFd);
+    _lockIdentity = { path: lockPath, dev: st.dev, ino: st.ino };
+  } catch (e) {
+    logCatchDebug("lock pid write", e);
+  }
+}
+async function acquireDbLock(options = {}) {
+  const lockPath = dbLockPath();
+  const waitMs = options.waitMs ?? dbLockWaitMs();
+  const role = options.role ?? (process.env.EXE_IS_DAEMON === "1" ? "daemon" : "cli");
+  const exit = options.exit ?? ((code) => process.exit(code));
+  const isAlive = options.isPidAlive ?? pidIsAlive;
+  mkdirSync2(join(lockPath, ".."), { recursive: true });
+  const start = Date.now();
+  let backoffMs = options.initialBackoffMs ?? 100;
+  let warned = false;
+  for (; ; ) {
+    try {
+      tryTakeLock(lockPath);
+      return;
+    } catch (err) {
+      if (!(err && typeof err === "object" && "code" in err && err.code === "EEXIST")) {
+        throw err;
+      }
+    }
+    const holderPid = readLockHolderPid(lockPath);
+    let stale = false;
+    if (holderPid !== null) {
+      stale = !isAlive(holderPid);
+    } else {
       try {
-        const lockStat = statSync(DB_LOCK_PATH);
-        if (Date.now() - lockStat.mtimeMs > 6e4) {
-          unlinkSync2(DB_LOCK_PATH);
-          _lockFd = openSync(DB_LOCK_PATH, "wx");
-          return;
-        }
+        stale = Date.now() - statSync(lockPath).mtimeMs > DB_LOCK_STALE_MS;
       } catch (e) {
         logCatchDebug("stale lock check", e);
+        continue;
       }
+    }
+    if (stale) {
       process.stderr.write(
-        "[database] WARN: Another process holds db.lock \u2014 waiting briefly then proceeding.\n"
+        `[database] db.lock is stale (holder ${holderPid !== null ? `pid ${holderPid} is dead` : "unknown, lock older than 60s"}) \u2014 breaking lock.
+`
+      );
+      try {
+        unlinkSync2(lockPath);
+      } catch (e) {
+        logCatchDebug("stale lock unlink", e);
+      }
+      continue;
+    }
+    const waited = Date.now() - start;
+    if (waited >= waitMs) {
+      if (role === "daemon") {
+        process.stderr.write(
+          `[database] FATAL: db.lock held by live pid ${holderPid ?? "?"} after ${waited}ms \u2014 another exe-os process is writing this database. Exiting to preserve the single-writer guarantee; launchd will relaunch this daemon.
+`
+        );
+        return exit(1);
+      }
+      throw new DbLockHeldError(holderPid, waited);
+    }
+    if (!warned) {
+      warned = true;
+      process.stderr.write(
+        `[database] db.lock held by ${holderPid ? `pid ${holderPid}` : "another process"} \u2014 retrying with backoff for up to ${waitMs}ms.
+`
       );
-      return;
     }
-    throw err;
+    await new Promise((resolve) => setTimeout(resolve, Math.min(backoffMs, waitMs - waited)));
+    backoffMs = Math.min(backoffMs * 2, 1e3);
   }
 }
 function releaseDbLock() {
   if (_lockFd !== null) {
+    const identity = _lockIdentity;
     try {
       closeSync(_lockFd);
     } catch (e) {
       logCatchDebug("lock close", e);
     }
     _lockFd = null;
-  }
-  try {
-    unlinkSync2(DB_LOCK_PATH);
-  } catch (e) {
-    logCatchDebug("lock unlink", e);
+    _lockIdentity = null;
+    try {
+      const lockPath = identity?.path ?? dbLockPath();
+      const st = statSync(lockPath);
+      if (!identity || st.dev === identity.dev && st.ino === identity.ino) {
+        unlinkSync2(lockPath);
+      }
+    } catch (e) {
+      logCatchDebug("lock unlink", e);
+    }
   }
 }
 var CORRUPTION_ERROR_RE = /malformed|disk image|sqlite_corrupt|database is corrupt|corrupt(ed)? (database|page|index)|btree/i;
@@ -1368,7 +1459,7 @@ async function _attemptBackupRestore(config) {
       } catch {
       }
       try {
-        const { pruneCorruptQuarantine } = await import("./db-backup-ITRADB2J.js");
+        const { pruneCorruptQuarantine } = await import("./db-backup-XLID57KW.js");
         pruneCorruptQuarantine();
       } catch {
       }
@@ -1479,7 +1570,7 @@ async function optimizeFtsIndexes(client = getRawClient(), pages = FTS_MERGE_PAG
 var initTurso = initDatabase;
 async function initDatabase(config) {
   assertValidDbPath(config?.dbPath, "initDatabase");
-  acquireDbLock();
+  await acquireDbLock();
   if (existsSync3(config.dbPath)) {
     const dbStat = statSync(config.dbPath);
     if (dbStat.size === 0) {
@@ -3669,6 +3760,10 @@ async function disposeDatabase() {
 }
 
 export {
+  dbLockWaitMs,
+  DbLockHeldError,
+  acquireDbLock,
+  releaseDbLock,
   WAL_ESCALATION_THRESHOLD_BYTES,
   checkpointWalIfLarge,
   runWalCheckpoint,

package/dist/{chunk-HIOO7DZ2.js → chunk-QQFZ32WS.js}

@@ -1,24 +1,24 @@
 import {
   recordSessionKill
-} from "./chunk-G5TP2D2U.js";
+} from "./chunk-EWDTTTZP.js";
 import {
   sessionScopeFilter,
   verifyPaneAtCapacity,
   writeNotification
-} from "./chunk-PLBDXCYZ.js";
+} from "./chunk-KUJGADX6.js";
 import {
   listSessions
-} from "./chunk-ABGDTMKC.js";
+} from "./chunk-JRD7ARQ6.js";
 import {
   getTransport
 } from "./chunk-RMOBQ6A5.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-HV5CUDOE.js";
+} from "./chunk-F6TJIWN5.js";
 import {
   getClient,
   isCoordinatorName
-} from "./chunk-XLNF3CIO.js";
+} from "./chunk-QGOMYIVT.js";
 
 // src/lib/capacity-monitor.ts
 var CAPACITY_PATTERNS = [

package/dist/{chunk-KL5WYWS3.js → chunk-SOXUF34Y.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-CLAYNAXC.js";
 import {
   buildClaudeHttpMcpEntry
-} from "./chunk-HKSJSW2V.js";
+} from "./chunk-2E2NKFXK.js";
 import {
   EXE_HOOKS,
   isLegacyHomeDirHookCommand,
@@ -11,7 +11,7 @@ import {
 } from "./chunk-L3TB7CC3.js";
 import {
   ensureAllAgentSymlinks
-} from "./chunk-HWC5W34K.js";
+} from "./chunk-7PLMYXPG.js";
 import {
   MCP_LEGACY_KEY,
   MCP_PRIMARY_KEY

package/dist/{chunk-6XM6PZXQ.js → chunk-SPO2RLOB.js}

@@ -1,7 +1,7 @@
 import {
   checkLicense,
   loadLicense
-} from "./chunk-VY7345RO.js";
+} from "./chunk-BMSAJ2IH.js";
 
 // src/lib/license-gate.ts
 var _cachedLicense = null;

package/dist/{chunk-ROMB2HH4.js → chunk-T3XHH5FE.js}

@@ -1,7 +1,7 @@
 import {
   formatDegradations,
   getRetrievalHealth
-} from "./chunk-QTEHH4LG.js";
+} from "./chunk-24WPWCD6.js";
 import {
   buildRestartReport,
   formatRestartReport
@@ -16,7 +16,7 @@ import {
 } from "./chunk-OTVEIJUQ.js";
 import {
   offloadReadIfMain
-} from "./chunk-XLNF3CIO.js";
+} from "./chunk-QGOMYIVT.js";
 import {
   isMainModule
 } from "./chunk-6Y4B3QF6.js";
@@ -654,7 +654,7 @@ async function auditKeyHealth() {
 }
 async function auditOutbox() {
   try {
-    const { getOutboxStatus } = await import("./support-outbox-QPQQK7F7.js");
+    const { getOutboxStatus } = await import("./support-outbox-MGUVVGHT.js");
     return await getOutboxStatus();
   } catch {
     return {
@@ -959,7 +959,7 @@ function formatReport(report, flags) {
   return lines.join("\n");
 }
 async function fixNullVectors() {
-  const { tryAcquireWorkerSlot, registerWorkerPid } = await import("./worker-gate-WJS2MFNA.js");
+  const { tryAcquireWorkerSlot, registerWorkerPid } = await import("./worker-gate-YA35VMAN.js");
   if (!tryAcquireWorkerSlot()) {
     process.stderr.write("[exe-doctor] Worker gate full \u2014 waiting for existing backfill workers to finish\n");
     await new Promise((r) => setTimeout(r, 5e3));
@@ -1144,7 +1144,7 @@ async function main(argv = process.argv.slice(2)) {
     console.log(formatRestartReport(restartReport));
     return emptyAuditReport();
   }
-  const { fastDbInit } = await import("./fast-db-init-TLYUWCDE.js");
+  const { fastDbInit } = await import("./fast-db-init-O6A3TK3F.js");
   const client = await fastDbInit();
   const report = await runAudit(client, flags);
   console.log(formatReport(report, flags));
@@ -1155,7 +1155,7 @@ ${mode} Applying repairs...
 `);
     if (!flags.dryRun) {
       try {
-        const { createBackup } = await import("./db-backup-ITRADB2J.js");
+        const { createBackup } = await import("./db-backup-XLID57KW.js");
         const backupPath = await createBackup("pre-fix");
         if (backupPath) {
           console.log(`  Backup created: ${backupPath.split("/").pop()}`);

package/dist/{chunk-6SXJZHRJ.js → chunk-TA3A4UQL.js}

@@ -1,6 +1,6 @@
 import {
   listReminders
-} from "./chunk-EVUXF2G4.js";
+} from "./chunk-W5GBB23I.js";
 
 // src/mcp/tools/list-reminders.ts
 import { z } from "zod";

package/dist/{chunk-XP53WEXP.js → chunk-TGVKQ3QB.js}

@@ -1,9 +1,9 @@
 import {
   updateTask
-} from "./chunk-7SDS5VCL.js";
+} from "./chunk-ZDNJ3TSB.js";
 import {
   TASK_ALREADY_CLAIMED_PREFIX
-} from "./chunk-PLBDXCYZ.js";
+} from "./chunk-KUJGADX6.js";
 
 // src/mcp/tools/update-task.ts
 import { z } from "zod";
@@ -40,7 +40,7 @@ function registerUpdateTask(server) {
       let callerAgentId;
       let callerSession;
       try {
-        const { getActiveAgent: getAgent } = await import("./active-agent-SHM4QSRJ.js");
+        const { getActiveAgent: getAgent } = await import("./active-agent-IUVRZOSF.js");
         callerAgentId = getAgent().agentId;
         const { getAgentContext } = await import("./agent-context-AZTTMUHP.js");
         callerSession = getAgentContext()?.sessionHint || process.env.EXE_SESSION_NAME || process.env.EXE_SESSION || void 0;

package/dist/{chunk-XC7C3GQ2.js → chunk-TNS6U2K7.js}

@@ -7,27 +7,35 @@ import {
 } from "./chunk-PROQW3NL.js";
 import {
   vectorToBlob
-} from "./chunk-H2SD2EA7.js";
+} from "./chunk-KLDQFOFY.js";
 import {
   extractKeywords,
   keywordsToString
 } from "./chunk-CHCA3ZM2.js";
 import {
   isCoordinatorName
-} from "./chunk-XLNF3CIO.js";
+} from "./chunk-QGOMYIVT.js";
 
 // src/lib/consolidation.ts
 import { randomUUID } from "crypto";
+async function readOffLoop(client, sql, args) {
+  if (process.env.EXE_IS_DAEMON === "1") {
+    const { offloadReadQuery } = await import("./lib/database.js");
+    return offloadReadQuery(sql, args);
+  }
+  return client.execute({ sql, args });
+}
 async function selectUnconsolidated(client, limit = 200) {
-  const result = await client.execute({
-    sql: `SELECT id, agent_id, project_name, tool_name, raw_text, timestamp, memory_type, session_scope
+  const result = await readOffLoop(
+    client,
+    `SELECT id, agent_id, project_name, tool_name, raw_text, timestamp, memory_type, session_scope
           FROM memories
           WHERE consolidated = 0
             AND COALESCE(memory_type, 'raw') != 'procedure'
           ORDER BY timestamp DESC
           LIMIT ?`,
-    args: [limit]
-  });
+    [limit]
+  );
   return result.rows.map((row) => ({
     id: row.id,
     agent_id: row.agent_id,
@@ -324,9 +332,10 @@ async function runConsolidation(client, options) {
   let memoriesConsolidated = 0;
   let clustersFailed = 0;
   let attemptedSynthesis = 0;
-  for (const cluster of clusters) {
-    if (clustersProcessed >= options.maxCalls) break;
-    if (cluster.memories.length < 3) continue;
+  const { runBudgetedSweep } = await import("./sweep-budget-WB2FKPYN.js");
+  await runBudgetedSweep(clusters, async (cluster) => {
+    if (clustersProcessed >= options.maxCalls) return false;
+    if (cluster.memories.length < 3) return;
     try {
       const isCoordinator = isCoordinatorName(cluster.agentId);
       const agentRole = roleMap[cluster.agentId];
@@ -336,7 +345,7 @@ async function runConsolidation(client, options) {
       const synthesis = await consolidateCluster(cluster, options.model, agentRole);
       if (!synthesis.trim()) {
         if (dedupCount > 0) clustersProcessed++;
-        continue;
+        return;
       }
       const result = await storeConsolidation(client, cluster, synthesis, options.embedFn);
       if (isCoordinator && options.wikiConfig) {
@@ -369,7 +378,7 @@ async function runConsolidation(client, options) {
 `
       );
     }
-  }
+  }, { label: "consolidation" });
   if (attemptedSynthesis > 0 && clustersFailed >= attemptedSynthesis) {
     throw new Error(
       `[consolidation] All ${clustersFailed} synthesis cluster(s) failed \u2014 consolidation is non-functional. Check ANTHROPIC_API_KEY/ANTHROPIC_AUTH_TOKEN and consolidationModel (${options.model}).`
@@ -427,13 +436,14 @@ function cosineSimilarity(a, b) {
   return denom === 0 ? 0 : dot / denom;
 }
 async function isUserIdle(client, idleMinutes = 30) {
-  const result = await client.execute({
-    sql: `SELECT MAX(timestamp) as last_activity
+  const result = await readOffLoop(
+    client,
+    `SELECT MAX(timestamp) as last_activity
           FROM memories
           WHERE tool_name != 'consolidation'
             AND timestamp >= datetime('now', '-1 day')`,
-    args: []
-  });
+    []
+  );
   const lastActivity = result.rows[0]?.last_activity;
   if (!lastActivity) return true;
   const lastMs = new Date(lastActivity).getTime();
@@ -441,12 +451,13 @@ async function isUserIdle(client, idleMinutes = 30) {
   return now - lastMs >= idleMinutes * 60 * 1e3;
 }
 async function countUnconsolidated(client) {
-  const result = await client.execute({
-    sql: `SELECT COUNT(*) as cnt FROM memories
+  const result = await readOffLoop(
+    client,
+    `SELECT COUNT(*) as cnt FROM memories
           WHERE consolidated = 0
             AND COALESCE(memory_type, 'raw') != 'procedure'`,
-    args: []
-  });
+    []
+  );
   return Number(result.rows[0]?.cnt ?? 0);
 }
 var INTERCOM_NOISE_PATTERNS = [

package/dist/{chunk-JXEMAB4M.js → chunk-UAIMI7CK.js}

@@ -1,7 +1,7 @@
 import {
   getCurrentSessionScope,
   strictSessionScopeFilter
-} from "./chunk-PLBDXCYZ.js";
+} from "./chunk-KUJGADX6.js";
 import {
   getProjectName
 } from "./chunk-OPU3NYOO.js";

package/dist/{chunk-YIFZZYQD.js → chunk-UBYAKNRF.js}

@@ -777,9 +777,9 @@ async function runSetupWizard(opts = {}) {
         rtChoice = await askOrEnv("Choose your AI runtime [1]: ", "EXE_RUNTIME", "1");
       }
       const rtMap = {
-        "1": { runtime: "claude", defaultModel: "claude-sonnet-4" },
+        "1": { runtime: "claude", defaultModel: "claude-sonnet-4.6" },
         "2": { runtime: "codex", defaultModel: "o3" },
-        "3": { runtime: "opencode", defaultModel: "anthropic/claude-sonnet-4" }
+        "3": { runtime: "opencode", defaultModel: "anthropic/claude-sonnet-4-6" }
       };
       const selected = rtMap[rtChoice.trim()] ?? rtMap["1"];
       const chosenModel = selected.defaultModel;