@askexenow/exe-os 0.9.302 → 0.9.310

package/dist/{chunk-35U72CD2.js → chunk-KSMITUGY.js}

@@ -1,9 +1,9 @@
 import {
   updateTask
-} from "./chunk-GSWGOGP5.js";
+} from "./chunk-EOS7VPVT.js";
 import {
   TASK_ALREADY_CLAIMED_PREFIX
-} from "./chunk-OVKNFTCL.js";
+} from "./chunk-HED6D5KR.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-GGQAP4QE.js");
+        const { getActiveAgent: getAgent } = await import("./active-agent-S5T2YMOR.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-D6UICP3C.js → chunk-LMX7UKGX.js}

@@ -1,17 +1,68 @@
 import {
-  getClient
-} from "./chunk-P3SIFDES.js";
+  isExeSession
+} from "./chunk-HED6D5KR.js";
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-OR3TAZL3.js";
+import {
+  getClient,
+  isCoordinatorName
+} from "./chunk-SCYWCWKY.js";
+import {
+  isDaemonAlive
+} from "./chunk-7HLWBYH7.js";
 
 // src/lib/session-kill-telemetry.ts
 import crypto from "crypto";
-import { appendFileSync } from "fs";
+import { appendFileSync, statSync } from "fs";
 import path from "path";
 import os from "os";
 var KILL_FILE_LOG = path.join(os.homedir(), ".exe-os", "logs", "session-kills.jsonl");
+var EVENT_LOOP_BLOCKED_MARKER = path.join(
+  os.homedir(),
+  ".exe-os",
+  "session-cache",
+  "event-loop-blocked.marker"
+);
+function isDaemonAlive2() {
+  const { alive } = isDaemonAlive();
+  if (!alive) return false;
+  try {
+    const st = statSync(EVENT_LOOP_BLOCKED_MARKER);
+    if (Date.now() - st.mtimeMs < 6e4) return false;
+  } catch {
+  }
+  return true;
+}
+var CPU_STARVATION_LOAD_RATIO = 0.8;
 var TOKENS_PER_IDLE_MINUTE = 50;
+function classifyRole(sessionName, agentId) {
+  return isExeSession(sessionName) || isCoordinatorName(agentId) ? "coordinator" : "worker";
+}
+function captureLoadAtDeath() {
+  const load1 = os.loadavg()[0] ?? 0;
+  const cpus = Math.max(1, os.cpus().length);
+  return { load1, cpus, loadRatio: load1 / cpus };
+}
+function classifyDeathCause(reason, loadRatio, daemonReady) {
+  if (loadRatio >= CPU_STARVATION_LOAD_RATIO) return "cpu_starvation";
+  if (!daemonReady) return "daemon_loss";
+  if (reason) return reason;
+  return "unknown";
+}
 async function recordSessionKill(input) {
   const killedAt = (/* @__PURE__ */ new Date()).toISOString();
   const id = crypto.randomUUID();
+  let role = "worker";
+  let loadAtDeath = null;
+  let cause = input.reason;
+  try {
+    role = classifyRole(input.sessionName, input.agentId);
+    loadAtDeath = captureLoadAtDeath();
+    cause = classifyDeathCause(input.reason, loadAtDeath.loadRatio, isDaemonAlive2());
+  } catch {
+    cause = input.reason;
+  }
   try {
     const logEntry = JSON.stringify({
       id,
@@ -19,6 +70,9 @@ async function recordSessionKill(input) {
       session: input.sessionName,
       agent: input.agentId,
       reason: input.reason,
+      role,
+      cause,
+      loadAtDeath,
       ticksIdle: input.ticksIdle ?? null,
       tokensSaved: input.estimatedTokensSaved ?? null
     });
@@ -29,6 +83,25 @@ async function recordSessionKill(input) {
 `
     );
   }
+  try {
+    recordOrchestrationEventBestEffort({
+      eventType: "session.died",
+      source: "session-kill-telemetry",
+      severity: cause === "cpu_starvation" && role === "coordinator" ? "error" : "warn",
+      agentId: input.agentId,
+      tmuxSession: input.sessionName,
+      result: cause,
+      payload: {
+        role,
+        cause,
+        reason: input.reason,
+        load1: loadAtDeath?.load1 ?? null,
+        cpus: loadAtDeath?.cpus ?? null,
+        loadRatio: loadAtDeath?.loadRatio ?? null
+      }
+    });
+  } catch {
+  }
   try {
     const client = getClient();
     await client.execute({
@@ -111,7 +184,12 @@ async function sumTokensSavedSince(sinceISO) {
 }
 
 export {
+  isDaemonAlive2 as isDaemonAlive,
+  CPU_STARVATION_LOAD_RATIO,
   TOKENS_PER_IDLE_MINUTE,
+  classifyRole,
+  captureLoadAtDeath,
+  classifyDeathCause,
   recordSessionKill,
   countKillsSince,
   IDLE_KILL_STREAK_META_KEY,

package/dist/{chunk-7ZWC5HVG.js → chunk-MTIJ2NXY.js}

@@ -1,7 +1,7 @@
 import {
   getGitRoot,
   isWorktreeDirty
-} from "./chunk-YNALY3SX.js";
+} from "./chunk-RZJ6DXVE.js";
 
 // src/lib/worktree-sweep.ts
 import { execFileSync } from "child_process";

package/dist/{chunk-KVHPBQV4.js → chunk-NCC3F6GM.js}

@@ -4,7 +4,7 @@ import {
 import {
   isClientConnected,
   sendDaemonRequest
-} from "./chunk-TCJEFW5V.js";
+} from "./chunk-PPXQE7AS.js";
 
 // src/lib/memory-queue-client.ts
 async function writeMemoryViaDaemon(entry) {

package/dist/{chunk-AYMSIV7X.js → chunk-NIZQ3CIS.js}

@@ -1,6 +1,6 @@
 import {
   loadEmployees
-} from "./chunk-P3SIFDES.js";
+} from "./chunk-SCYWCWKY.js";
 
 // src/lib/agent-symlinks.ts
 import os from "os";

package/dist/{chunk-LTI2DLHY.js → chunk-OBJXZII2.js}

@@ -3,13 +3,13 @@ import {
 } from "./chunk-VUH67PT4.js";
 import {
   isGhostBehaviorRow
-} from "./chunk-N76VTMMF.js";
+} from "./chunk-PMEOSD6S.js";
 import {
   getClient,
   getIdentity,
   listIdentities,
   updateIdentity
-} from "./chunk-P3SIFDES.js";
+} from "./chunk-SCYWCWKY.js";
 import {
   atomicWriteJsonSync
 } from "./chunk-65DBIEM2.js";

package/dist/{chunk-WHOT5NZ7.js → chunk-OR3TAZL3.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-P3SIFDES.js";
+} from "./chunk-SCYWCWKY.js";
 
 // src/lib/orchestration-events.ts
 import crypto from "crypto";
@@ -42,6 +42,8 @@ var ORCHESTRATION_COUNTER_KEYS = [
   "tmuxNudgeCompleted",
   "tmuxSpawnAttempted",
   "tmuxSpawnCompleted",
+  "tmuxSpawnFailed",
+  "spawnFailureByCause",
   "consistencyMismatches",
   "consistencyRepaired",
   "fileRowsResynced",
@@ -251,6 +253,8 @@ async function getOrchestrationMetrics(input = {}) {
     tmuxNudgeCompleted: 0,
     tmuxSpawnAttempted: 0,
     tmuxSpawnCompleted: 0,
+    tmuxSpawnFailed: 0,
+    spawnFailureByCause: {},
     consistencyMismatches: 0,
     consistencyRepaired: 0,
     fileRowsResynced: 0,
@@ -311,7 +315,14 @@ async function getOrchestrationMetrics(input = {}) {
       if (String(row.result ?? "") === "debounced") counts.duplicateNudges++;
     }
     if (type === "tmux.spawn.attempted") counts.tmuxSpawnAttempted++;
-    if (type === "tmux.spawn.completed") counts.tmuxSpawnCompleted++;
+    if (type === "tmux.spawn.completed") {
+      counts.tmuxSpawnCompleted++;
+      if (String(row.result ?? "") === "failed") {
+        counts.tmuxSpawnFailed++;
+        const code = String(row.error_code ?? "unknown") || "unknown";
+        counts.spawnFailureByCause[code] = (counts.spawnFailureByCause[code] ?? 0) + 1;
+      }
+    }
     if (type === "consistency.mismatch") counts.consistencyMismatches++;
     if (type === "consistency.repaired") counts.consistencyRepaired++;
     if (type === "task_file.resynced") counts.fileRowsResynced++;
@@ -529,6 +540,7 @@ function formatOrchestrationMetrics(metrics) {
     `- worker instances selected: ${metrics.counts.workerInstancesSelected}`,
     `- tmux spawn attempted: ${metrics.counts.tmuxSpawnAttempted}`,
     `- tmux spawn completed: ${metrics.counts.tmuxSpawnCompleted}`,
+    `- tmux spawn FAILED: ${metrics.counts.tmuxSpawnFailed}${metrics.counts.tmuxSpawnFailed > 0 ? ` (${Object.entries(metrics.counts.spawnFailureByCause).map(([cause, n]) => `${cause}=${n}`).join(" ")})` : ""}`,
     `- worktrees created: ${metrics.counts.worktreeCreated}`,
     `- worktrees reused: ${metrics.counts.worktreeReused}`,
     `- worktrees failed: ${metrics.counts.worktreeFailed}`,

package/dist/{chunk-RQUHAXMM.js → chunk-PHFPIUWU.js}

@@ -54,6 +54,8 @@ function resolveHookSearchEnabled(env, config, sentinelPath = EMBEDDINGS_SENTINE
 }
 
 export {
+  EMBEDDINGS_SENTINEL_PATH,
+  readSentinel,
   resolveEmbeddingsEnabled,
   setEmbeddingsEnabled,
   resolveHookSearchEnabled

package/dist/{chunk-N76VTMMF.js → chunk-PMEOSD6S.js}

@@ -1,12 +1,12 @@
 import {
   vectorToSqlLiteral
-} from "./chunk-Y5ASPRP7.js";
+} from "./chunk-WBJXJ2R4.js";
 import {
   blobToVector
 } from "./chunk-OTVEIJUQ.js";
 import {
   getClient
-} from "./chunk-P3SIFDES.js";
+} from "./chunk-SCYWCWKY.js";
 
 // src/lib/behaviors.ts
 import crypto from "crypto";

package/dist/{chunk-TCJEFW5V.js → chunk-PPXQE7AS.js}

@@ -1,13 +1,13 @@
 import {
   ensureDaemonToken,
   readDaemonToken
-} from "./chunk-PHOQAVTK.js";
+} from "./chunk-RQ7OVXUZ.js";
+import {
+  requestRestart
+} from "./chunk-RVXWGPD3.js";
 import {
   computeDaemonHeapCapMb
 } from "./chunk-7XGDTKHX.js";
-import {
-  requestRestart
-} from "./chunk-7L2EV3XX.js";
 import {
   EXE_AI_DIR
 } from "./chunk-DFIOOK5R.js";

package/dist/{chunk-KHZQVLNZ.js → chunk-QE7UVQDP.js}

@@ -1,9 +1,52 @@
 // src/bin/fast-db-init.ts
+function makeNoopClient() {
+  const emptyResult = {
+    columns: [],
+    columnTypes: [],
+    rows: [],
+    rowsAffected: 0,
+    lastInsertRowid: void 0,
+    toJSON() {
+      return {};
+    }
+  };
+  return {
+    async execute() {
+      return emptyResult;
+    },
+    async batch(stmts) {
+      return stmts.map(() => emptyResult);
+    },
+    async transaction() {
+      throw new Error("Transactions not supported in daemon-down no-op mode");
+    },
+    async executeMultiple() {
+    },
+    async migrate() {
+      return [];
+    },
+    sync() {
+      return Promise.resolve(void 0);
+    },
+    close() {
+    },
+    get closed() {
+      return false;
+    },
+    get protocol() {
+      return "file";
+    }
+  };
+}
 async function fastDbInit(opts) {
   const { isInitialized, getClient, setExternalClient } = await import("./lib/database.js");
   if (isInitialized()) {
     return getClient();
   }
+  if (opts?.daemonOnly) {
+    const { isDaemonReady } = await import("./daemon-ready-signal-3L2MJT7C.js");
+    if (!isDaemonReady()) return makeNoopClient();
+  }
   const forceDirect = process.env.EXE_DB_DIRECT === "1" || process.env.EXE_DB_READONLY === "1" || process.env.EXE_SKIP_DAEMON === "1";
   if (!forceDirect) {
     try {
@@ -71,6 +114,9 @@ async function fastDbInit(opts) {
     } catch {
     }
   }
+  if (opts?.daemonOnly) {
+    return makeNoopClient();
+  }
   if (opts?.socketOnly) {
     throw new Error("Daemon socket unavailable and socketOnly=true \u2014 skipping slow DB fallback");
   }

package/dist/{chunk-SXJACGQ5.js → chunk-QEGXNJGR.js}

@@ -1,13 +1,13 @@
 import {
   deactivateBehavior
-} from "./chunk-N76VTMMF.js";
+} from "./chunk-PMEOSD6S.js";
 import {
   getActiveAgent
-} from "./chunk-LE7CDIOA.js";
+} from "./chunk-BUOMSIXH.js";
 import {
   canCoordinate,
   getClient
-} from "./chunk-P3SIFDES.js";
+} from "./chunk-SCYWCWKY.js";
 
 // src/mcp/tools/deactivate-behavior.ts
 import { z } from "zod";
@@ -24,7 +24,7 @@ function registerDeactivateBehavior(server) {
     async ({ behavior_id }) => {
       const caller = getActiveAgent();
       try {
-        const { StewardGate } = await import("./steward-gate-YGU4VXPP.js");
+        const { StewardGate } = await import("./steward-gate-6NWRDLX2.js");
         const steward = new StewardGate();
         const gateDecision = await steward.checkAuthority(caller.agentId || "unknown", "deactivate_behavior", behavior_id);
         if (!gateDecision.allowed) {

package/dist/{chunk-W3E4VEEJ.js → chunk-RPBTYQKJ.js}

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

package/dist/chunk-RQ7OVXUZ.js

@@ -0,0 +1,81 @@
+import {
+  EXE_AI_DIR
+} from "./chunk-DFIOOK5R.js";
+import {
+  enforcePrivateFileSync,
+  ensurePrivateDirSync
+} from "./chunk-65DBIEM2.js";
+
+// src/lib/daemon-auth.ts
+import crypto from "crypto";
+import path from "path";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+var DAEMON_TOKEN_PATH = path.join(EXE_AI_DIR, "exed.token");
+function normalizeToken(token) {
+  if (!token) return null;
+  const trimmed = token.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function readDaemonToken() {
+  try {
+    if (!existsSync(DAEMON_TOKEN_PATH)) return null;
+    return normalizeToken(readFileSync(DAEMON_TOKEN_PATH, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function ensureDaemonToken(seed) {
+  const existing = readDaemonToken();
+  if (existing) return existing;
+  const token = normalizeToken(seed) ?? crypto.randomBytes(32).toString("hex");
+  ensurePrivateDirSync(EXE_AI_DIR);
+  writeFileSync(DAEMON_TOKEN_PATH, `${token}
+`, "utf8");
+  enforcePrivateFileSync(DAEMON_TOKEN_PATH);
+  return token;
+}
+function isUnclaimedAgentId(agentId) {
+  if (!agentId || agentId === "default") return true;
+  if (/^\$\{[^}]*\}$/.test(agentId)) return true;
+  return false;
+}
+function shouldEnforceSessionIdentity(env = process.env) {
+  const v = (env.EXE_ENFORCE_SESSION_IDENTITY ?? "").trim().toLowerCase();
+  return v === "1" || v === "true" || v === "yes" || v === "on";
+}
+function reconcileSessionAgentIdentity(boundAgentId, claimedAgentId, enforce = false) {
+  const bound = normalizeToken(boundAgentId ?? null);
+  if (!bound) {
+    return {
+      effectiveAgentId: claimedAgentId,
+      impersonationDetected: false,
+      reject: false,
+      claimedAgentId,
+      boundAgentId: claimedAgentId
+    };
+  }
+  if (isUnclaimedAgentId(claimedAgentId) || claimedAgentId === bound) {
+    return {
+      effectiveAgentId: bound,
+      impersonationDetected: false,
+      reject: false,
+      claimedAgentId,
+      boundAgentId: bound
+    };
+  }
+  return {
+    effectiveAgentId: bound,
+    impersonationDetected: true,
+    reject: enforce,
+    claimedAgentId,
+    boundAgentId: bound
+  };
+}
+
+export {
+  DAEMON_TOKEN_PATH,
+  readDaemonToken,
+  ensureDaemonToken,
+  shouldEnforceSessionIdentity,
+  reconcileSessionAgentIdentity
+};

package/dist/{chunk-7L2EV3XX.js → chunk-RVXWGPD3.js}

@@ -295,15 +295,48 @@ function cleanWorkerPidFiles() {
   } catch {
   }
 }
-function updateMcpVersionMarker() {
+async function updateMcpVersionMarker(opts) {
   try {
-    writeFileSync(MCP_VERSION_PATH, `deploy-${Date.now()}`);
-    process.stderr.write("[restart-orchestrator] MCP version marker updated \u2014 servers will hot-reload within 10s\n");
-    logRestart({ event: "mcp_marker_updated" });
+    let surfaceHash = opts?.surfaceHash;
+    if (surfaceHash === void 0) {
+      surfaceHash = await computeMcpSurfaceHash();
+    }
+    const { buildMcpVersionMarker } = await import("./mcp-tool-surface-CSPFXL3F.js");
+    const marker = buildMcpVersionMarker(surfaceHash ?? null);
+    let current = null;
+    try {
+      current = existsSync(MCP_VERSION_PATH) ? readFileSync(MCP_VERSION_PATH, "utf8").trim() : null;
+    } catch {
+    }
+    if (current === marker) {
+      process.stderr.write(
+        "[restart-orchestrator] MCP tool surface unchanged \u2014 marker NOT updated, no hot-reload\n"
+      );
+      logRestart({ event: "mcp_marker_unchanged", marker });
+      return;
+    }
+    writeFileSync(MCP_VERSION_PATH, marker);
+    const surfaceMode = surfaceHash ? "surface-hash" : "timestamp-fallback";
+    process.stderr.write(
+      `[restart-orchestrator] MCP version marker updated (${surfaceMode}) \u2014 servers will hot-reload within 10s
+`
+    );
+    logRestart({ event: "mcp_marker_updated", mode: surfaceMode });
   } catch {
   }
 }
-function requestDeployRestart(reason) {
+async function computeMcpSurfaceHash() {
+  try {
+    const [{ computeToolSurfaceHash }, { registerAllTools }] = await Promise.all([
+      import("./mcp-tool-surface-CSPFXL3F.js"),
+      import("./mcp/register-tools.js")
+    ]);
+    return computeToolSurfaceHash((server) => registerAllTools(server));
+  } catch {
+    return null;
+  }
+}
+async function requestDeployRestart(reason) {
   const deployReason = reason ?? "deploy";
   if (!acquireLock()) {
     process.stderr.write("[restart-orchestrator] Lock held \u2014 waiting briefly for deploy\n");
@@ -340,7 +373,7 @@ function requestDeployRestart(reason) {
     }
     const orphansKilled = killOrphanedDaemons();
     const backfillKilled = killOrphanedBackfill();
-    updateMcpVersionMarker();
+    await updateMcpVersionMarker();
     cleanWorkerPidFiles();
     try {
       unlinkSync(SOCKET_PATH);

package/dist/{chunk-YNALY3SX.js → chunk-RZJ6DXVE.js}

@@ -1,6 +1,6 @@
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-WHOT5NZ7.js";
+} from "./chunk-OR3TAZL3.js";
 
 // src/lib/worktree.ts
 import { execSync } from "child_process";

package/dist/{chunk-P3SIFDES.js → chunk-SCYWCWKY.js}

@@ -3,11 +3,14 @@ import {
 } from "./chunk-2I23RPSI.js";
 import {
   listBackups
-} from "./chunk-BGOMFGSW.js";
+} from "./chunk-GWPICNSO.js";
 import {
   getEmotionalBaseline,
   renderEmotionalBaselineSection
 } from "./chunk-PNQDP3OA.js";
+import {
+  logDaemonHealth
+} from "./chunk-VQRTO7IS.js";
 import {
   isDaemonAlive
 } from "./chunk-7HLWBYH7.js";
@@ -1116,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-UKKTGZYR.js");
+  const { reflectionDedupKey } = await import("./memory-reflection-PXF6YFDU.js");
   const keyForRow = (row) => {
     let sources = [];
     try {
@@ -1365,7 +1368,7 @@ async function _attemptBackupRestore(config) {
       } catch {
       }
       try {
-        const { pruneCorruptQuarantine } = await import("./db-backup-VZHSFUVA.js");
+        const { pruneCorruptQuarantine } = await import("./db-backup-EORG4LBO.js");
         pruneCorruptQuarantine();
       } catch {
       }
@@ -1637,7 +1640,7 @@ async function sweepExpiredSoftDeletedMemories(client, options = {}) {
   const purgeArchived = archDays !== void 0;
   const BATCH_SIZE = 2e3;
   const MAX_BATCHES = 500;
-  const { cleanupCardsForMemories, cleanupGraphLinksForMemories } = await import("./graph-rag-3RZN7JR3.js");
+  const { cleanupCardsForMemories, cleanupGraphLinksForMemories } = await import("./graph-rag-HITZZ63L.js");
   const softCutoff = `-${softDays} days`;
   const selectArgsBase = [softCutoff];
   let predicate = `status = 'deleted' AND COALESCE(deleted_at, timestamp) < datetime('now', ?)`;
@@ -1713,6 +1716,15 @@ function getClient() {
       process.stderr.write(
         "[database] WARN: daemon unavailable \u2014 using direct SQLite (single-writer CLI mode).\n"
       );
+      logDaemonHealth({
+        event: "direct_sqlite_fallback",
+        pid: process.pid,
+        message: "CLI opened encrypted DB directly \u2014 daemon unavailable",
+        data: {
+          hook: process.env.EXE_HOOK_NAME ?? null,
+          mcpMode: process.env.EXE_MCP_MODE === "1"
+        }
+      });
     }
     return _resilientClient;
   }

package/dist/{chunk-7I43GVER.js → chunk-SOT23KWW.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-P3SIFDES.js";
+} from "./chunk-SCYWCWKY.js";
 
 // src/lib/pipeline-router.ts
 import crypto from "crypto";
@@ -140,8 +140,8 @@ Agent response: ${agentResponse}` : ""
 }
 async function sinkEntityExtraction(msg, agentResponse, agentName) {
   try {
-    const { extractFromConversation } = await import("./conversation-entity-extractor-KXJSHRGJ.js");
-    const { storeExtraction } = await import("./graph-rag-3RZN7JR3.js");
+    const { extractFromConversation } = await import("./conversation-entity-extractor-KYOBXNID.js");
+    const { storeExtraction } = await import("./graph-rag-HITZZ63L.js");
     if ((msg.text?.length ?? 0) < 20) return false;
     if (msg.isHistorical) return false;
     const extraction = await extractFromConversation(msg, agentResponse, agentName);

package/dist/{chunk-T62GAN7I.js → chunk-SPOXL7HF.js}

@@ -1,10 +1,10 @@
 import {
   isCrdtSyncEnabled
-} from "./chunk-FKFVNV7X.js";
+} from "./chunk-K4BKJJ4F.js";
 import {
   GHOST_BEHAVIOR_SQL,
   isGhostBehaviorRow
-} from "./chunk-N76VTMMF.js";
+} from "./chunk-PMEOSD6S.js";
 import {
   decryptSyncBlob,
   encryptSyncBlob,
@@ -13,16 +13,16 @@ import {
 } from "./chunk-LO6L5ADL.js";
 import {
   retryOnDaemonTransportError
-} from "./chunk-MY36XDUK.js";
+} from "./chunk-DNFU56ZS.js";
 import {
   getClient,
   loadEmployees,
   registerBinSymlinks,
   saveEmployees
-} from "./chunk-P3SIFDES.js";
+} from "./chunk-SCYWCWKY.js";
 import {
   loadDeviceId
-} from "./chunk-VME3UH4D.js";
+} from "./chunk-JV225JBX.js";
 import {
   EXE_AI_DIR
 } from "./chunk-DFIOOK5R.js";
@@ -584,7 +584,7 @@ async function cloudSync(config, options) {
     let pulled = 0;
     if (pullResult.records.length > 0) {
       if (shouldUseCrdtMergeForCloudSync()) {
-        const { initCrdtDoc, importExistingMemories, readAllMemories } = await import("./crdt-sync-K2G3C6XY.js");
+        const { initCrdtDoc, importExistingMemories, readAllMemories } = await import("./crdt-sync-ZFIFL2QM.js");
         initCrdtDoc();
         importExistingMemories(
           pullResult.records.map((rec) => ({
@@ -1023,7 +1023,7 @@ async function cloudSync(config, options) {
     }
     const totalMemories = await countRows("SELECT COUNT(*) as cnt FROM memories WHERE status = 'active' OR status IS NULL");
     try {
-      const { getLatestBackup } = await import("./db-backup-VZHSFUVA.js");
+      const { getLatestBackup } = await import("./db-backup-EORG4LBO.js");
       const latestBackup = getLatestBackup();
       if (latestBackup) {
         const backupSize = statSync(latestBackup).size;