@askexenow/exe-os 0.9.322 → 0.9.324

package/dist/{chunk-LCZ55G5G.js → chunk-HZ5J2GFE.js}

@@ -1,10 +1,10 @@
 import {
   isCrdtSyncEnabled
-} from "./chunk-72LWCZTJ.js";
+} from "./chunk-RXS2LBKE.js";
 import {
   GHOST_BEHAVIOR_SQL,
   isGhostBehaviorRow
-} from "./chunk-FANIBYUO.js";
+} from "./chunk-WF3J6GJZ.js";
 import {
   decryptSyncBlob,
   encryptSyncBlob,
@@ -13,16 +13,16 @@ import {
 } from "./chunk-LO6L5ADL.js";
 import {
   retryOnDaemonTransportError
-} from "./chunk-2GBGIXKH.js";
+} from "./chunk-PV7IG4V6.js";
 import {
   getClient,
   loadEmployees,
   registerBinSymlinks,
   saveEmployees
-} from "./chunk-XLNF3CIO.js";
+} from "./chunk-QGOMYIVT.js";
 import {
   loadDeviceId
-} from "./chunk-VY7345RO.js";
+} from "./chunk-BMSAJ2IH.js";
 import {
   EXE_AI_DIR
 } from "./chunk-7Y5UDEVM.js";
@@ -385,7 +385,16 @@ async function cloudPush(records, maxVersion, config) {
       logError("[cloud-sync] PUSH VERSION CONFLICT \u2014 re-pull required before next push");
       return false;
     }
-    return resp.ok;
+    if (!resp.ok) {
+      let body = "";
+      try {
+        body = (await resp.text()).slice(0, 500);
+      } catch {
+      }
+      logError(`[cloud-sync] PUSH FAILED: HTTP ${resp.status}${body ? ` \u2014 ${body}` : ""}`);
+      return false;
+    }
+    return true;
   } catch (err) {
     logError(`[cloud-sync] PUSH FAILED: ${err instanceof Error ? err.message : String(err)}`);
     return false;
@@ -522,6 +531,119 @@ function defaultOnProgress(stage, detail) {
   const msg = detail ? `[cloud-sync] ${stage}: ${detail}` : `[cloud-sync] ${stage}`;
   process.stderr.write(msg + "\n");
 }
+function finiteVersion(value, fallback = 0) {
+  const n = Number(value ?? fallback);
+  return Number.isFinite(n) ? n : fallback;
+}
+async function writeLastCloudPushVersion(client, version) {
+  await client.execute({
+    sql: "INSERT INTO sync_meta (key, value) VALUES ('last_cloud_push_version', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value",
+    args: [String(Math.max(0, version))]
+  });
+}
+async function cloudPushPendingMemories(client, config, options) {
+  let pushed = 0;
+  let errors = 0;
+  let safeCursor = Math.max(0, finiteVersion(options.lastPushVersion, 0));
+  let scanVersion = safeCursor;
+  let scanRowid = Number.MAX_SAFE_INTEGER;
+  try {
+    const maxRes = await client.execute(
+      "SELECT MAX(version) AS v FROM memories WHERE (scope IS NULL OR scope != 'personal')"
+    );
+    const localMaxVersion = finiteVersion(maxRes.rows[0]?.v, 0);
+    if (safeCursor > localMaxVersion) {
+      logError(
+        `[cloud-sync] last_cloud_push_version (${safeCursor}) is ahead of local max memory version (${localMaxVersion}); resetting memory push cursor to 0. This can happen after DB restore.`
+      );
+      await writeLastCloudPushVersion(client, 0);
+      safeCursor = 0;
+      scanVersion = 0;
+      scanRowid = Number.MAX_SAFE_INTEGER;
+    }
+  } catch (err) {
+    process.stderr.write(`[cloud-sync] memory push cursor reconcile failed: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+  const nowMs = Date.now();
+  const pushCooldownActive = safeCursor > 0 && safeCursor === _lastSyncPushVersion && nowMs - _lastSyncPushTimestamp < SYNC_COOLDOWN_MS;
+  if (pushCooldownActive) {
+    return { pushed: 0, errors: 0, finalCursor: safeCursor };
+  }
+  for (; ; ) {
+    const recordsResult = await client.execute({
+      sql: `SELECT rowid AS __rid, id, agent_id, agent_role, session_id, timestamp,
+                   tool_name, project_name, has_error, raw_text, version,
+                   author_device_id, scope, session_scope
+            FROM memories
+            WHERE (version > ? OR (version = ? AND rowid > ?))
+              AND (scope IS NULL OR scope != 'personal')
+            ORDER BY version ASC, rowid ASC
+            LIMIT ?`,
+      args: [scanVersion, scanVersion, scanRowid, PUSH_BATCH_SIZE + 1]
+    });
+    if (recordsResult.rows.length === 0) break;
+    const pageRows = recordsResult.rows;
+    const hasExtra = pageRows.length > PUSH_BATCH_SIZE;
+    const rowsToPush = hasExtra ? pageRows.slice(0, PUSH_BATCH_SIZE) : pageRows;
+    const extraRow = hasExtra ? pageRows[PUSH_BATCH_SIZE] : void 0;
+    const records = rowsToPush.map((row) => ({
+      id: row.id,
+      agent_id: row.agent_id,
+      agent_role: row.agent_role,
+      session_id: row.session_id,
+      timestamp: row.timestamp,
+      tool_name: row.tool_name,
+      project_name: row.project_name,
+      has_error: row.has_error,
+      raw_text: row.raw_text,
+      version: row.version,
+      author_device_id: row.author_device_id,
+      scope: row.scope,
+      session_scope: row.session_scope
+    }));
+    const lastRow = rowsToPush[rowsToPush.length - 1];
+    const maxVersion = finiteVersion(lastRow.version, scanVersion);
+    let pushOk = await cloudPush(records, maxVersion, config);
+    if (!pushOk) {
+      errors++;
+      logError(`[cloud-sync] memory push batch failed at version=${maxVersion}; retrying once after pull`);
+      await cloudPull(options.lastPullVersion, config);
+      pushOk = await cloudPush(records, maxVersion, config);
+      if (!pushOk) {
+        errors++;
+        logError(`[cloud-sync] memory push batch failed permanently at version=${maxVersion}; cursor remains ${safeCursor}`);
+        break;
+      }
+    }
+    try {
+      await pushToPostgres(records);
+    } catch (e) {
+      process.stderr.write("[cloud-sync] Postgres push of local records failed: " + (e instanceof Error ? e.message : String(e)) + "\n");
+    }
+    pushed += records.length;
+    scanVersion = maxVersion;
+    scanRowid = finiteVersion(lastRow.__rid, scanRowid);
+    const extraVersion = extraRow ? finiteVersion(extraRow.version, maxVersion) : void 0;
+    let nextSafeCursor = maxVersion;
+    if (hasExtra && extraVersion === maxVersion) {
+      const completedVersions = rowsToPush.map((row) => finiteVersion(row.version, scanVersion)).filter((v) => v < maxVersion);
+      nextSafeCursor = completedVersions.length > 0 ? Math.max(...completedVersions, safeCursor) : safeCursor;
+    }
+    if (nextSafeCursor > safeCursor) {
+      await writeLastCloudPushVersion(client, nextSafeCursor);
+      safeCursor = nextSafeCursor;
+      _lastSyncPushVersion = nextSafeCursor;
+      _lastSyncPushTimestamp = Date.now();
+    }
+    if (!hasExtra) break;
+    await new Promise((resolve) => setImmediate(resolve));
+  }
+  if (pushed > 0 && errors > 0) {
+    logError(`[cloud-sync] memory push completed partially: pushed=${pushed}, errors=${errors}, cursor=${safeCursor}`);
+  }
+  return { pushed, errors, finalCursor: safeCursor };
+}
 async function cloudSync(config, options) {
   const onProgress = options?.onProgress ?? defaultOnProgress;
   if (_cloudSyncInProgress) {
@@ -584,7 +706,7 @@ async function cloudSync(config, options) {
     let pulled = 0;
     if (pullResult.records.length > 0) {
       if (shouldUseCrdtMergeForCloudSync()) {
-        const { initCrdtDoc, importExistingMemories, readAllMemories } = await import("./crdt-sync-BO76VVRX.js");
+        const { initCrdtDoc, importExistingMemories, readAllMemories } = await import("./crdt-sync-MXHPR6V6.js");
         initCrdtDoc();
         importExistingMemories(
           pullResult.records.map((rec) => ({
@@ -788,64 +910,11 @@ async function cloudSync(config, options) {
       "SELECT value FROM sync_meta WHERE key = 'last_cloud_push_version'"
     );
     const lastPushVersion = pushMeta.rows.length > 0 ? Number(pushMeta.rows[0].value) : 0;
-    let pushed = 0;
-    let batchCursor = lastPushVersion;
-    const nowMs = Date.now();
-    const pushCooldownActive = lastPushVersion > 0 && lastPushVersion === _lastSyncPushVersion && nowMs - _lastSyncPushTimestamp < SYNC_COOLDOWN_MS;
-    if (pushCooldownActive) {
-    } else {
-      while (true) {
-        const recordsResult = await client.execute({
-          sql: `SELECT id, agent_id, agent_role, session_id, timestamp,
-                   tool_name, project_name, has_error, raw_text, version,
-                   author_device_id, scope, session_scope
-            FROM memories
-            WHERE version > ?
-              AND (scope IS NULL OR scope != 'personal')
-            ORDER BY version ASC
-            LIMIT ?`,
-          args: [batchCursor, PUSH_BATCH_SIZE]
-        });
-        if (recordsResult.rows.length === 0) break;
-        const records = recordsResult.rows.map((row) => ({
-          id: row.id,
-          agent_id: row.agent_id,
-          agent_role: row.agent_role,
-          session_id: row.session_id,
-          timestamp: row.timestamp,
-          tool_name: row.tool_name,
-          project_name: row.project_name,
-          has_error: row.has_error,
-          raw_text: row.raw_text,
-          version: row.version,
-          author_device_id: row.author_device_id,
-          scope: row.scope,
-          session_scope: row.session_scope
-        }));
-        const maxVersion = Number(records[records.length - 1].version);
-        let pushOk = await cloudPush(records, maxVersion, config);
-        if (!pushOk) {
-          await cloudPull(lastPullVersion, config);
-          pushOk = await cloudPush(records, maxVersion, config);
-          if (!pushOk) break;
-        }
-        try {
-          await pushToPostgres(records);
-        } catch (e) {
-          process.stderr.write("[cloud-sync] Postgres push of local records failed: " + (e instanceof Error ? e.message : String(e)) + "\n");
-        }
-        await client.execute({
-          sql: "INSERT INTO sync_meta (key, value) VALUES ('last_cloud_push_version', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value",
-          args: [String(maxVersion)]
-        });
-        pushed += records.length;
-        batchCursor = maxVersion;
-        _lastSyncPushVersion = maxVersion;
-        _lastSyncPushTimestamp = Date.now();
-        if (recordsResult.rows.length < PUSH_BATCH_SIZE) break;
-        await new Promise((resolve) => setImmediate(resolve));
-      }
-    }
+    const memoryPush = await cloudPushPendingMemories(client, config, {
+      lastPushVersion,
+      lastPullVersion
+    });
+    const pushed = memoryPush.pushed;
     onProgress("Cloud sync", "merging roster...");
     try {
       await cloudPushRoster(config);
@@ -1023,7 +1092,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-ITRADB2J.js");
+      const { getLatestBackup } = await import("./db-backup-XLID57KW.js");
       const latestBackup = getLatestBackup();
       if (latestBackup) {
         const backupSize = statSync(latestBackup).size;
@@ -2405,6 +2474,7 @@ export {
   getCloudRelinkRequired,
   clearCloudRelinkRequired,
   markCloudReuploadRequired,
+  cloudPushPendingMemories,
   cloudSync,
   recordRosterDeletion,
   buildRosterBlob,

package/dist/{chunk-EOPSIIEH.js → chunk-ID3V4BWS.js}

@@ -9,7 +9,7 @@ import {
   getCoordinatorEmployee,
   getEmployee,
   loadEmployeesSync
-} from "./chunk-XLNF3CIO.js";
+} from "./chunk-QGOMYIVT.js";
 import {
   EXE_AI_DIR
 } from "./chunk-7Y5UDEVM.js";

package/dist/{chunk-ABGDTMKC.js → chunk-JRD7ARQ6.js}

@@ -1,6 +1,6 @@
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-HV5CUDOE.js";
+} from "./chunk-F6TJIWN5.js";
 import {
   atomicWriteJsonSync
 } from "./chunk-SHIICYJW.js";
@@ -299,6 +299,63 @@ function cleanupDeadSessions(liveTmuxOverride) {
     releaseRegistryLock();
   }
 }
+function isCoordinatorRootName(sessionName) {
+  if (sessionName.includes("-")) return false;
+  const coordName = getCoordinatorNameCached();
+  const escaped = coordName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`^${escaped}\\d*$`, "i").test(sessionName);
+}
+function reapOrphanedCoordinatorSessions(deps) {
+  const result = { orphaned: [], deregistered: [], killed: [] };
+  if (!deps.liveTmux || deps.liveTmux.length === 0) return result;
+  const liveSet = new Set(deps.liveTmux.filter(Boolean));
+  for (const session of deps.liveTmux) {
+    if (!liveSet.has(session)) continue;
+    if (!isCoordinatorRootName(session)) continue;
+    if (deps.paneHasLiveAgent(session)) continue;
+    result.orphaned.push(session);
+  }
+  if (result.orphaned.length === 0) return result;
+  if (acquireRegistryLock()) {
+    try {
+      const sessions = readSessionsUncached();
+      const orphanSet = new Set(result.orphaned);
+      const survivors = sessions.filter((s) => {
+        if (orphanSet.has(s.windowName)) {
+          result.deregistered.push(s.windowName);
+          return false;
+        }
+        return true;
+      });
+      if (result.deregistered.length > 0) writeSessions(survivors);
+    } finally {
+      releaseRegistryLock();
+    }
+  }
+  if (deps.killTmux) {
+    for (const session of result.orphaned) {
+      try {
+        deps.killTmux(session);
+        result.killed.push(session);
+      } catch {
+      }
+    }
+  }
+  if (result.orphaned.length > 0) {
+    recordOrchestrationEventBestEffort({
+      eventType: "registry.coordinator_orphan_reaped",
+      source: "session-registry.reapOrphanedCoordinatorSessions",
+      severity: "warn",
+      attempt: result.orphaned.length,
+      payload: {
+        orphaned: result.orphaned.slice(0, 10),
+        deregistered: result.deregistered.length,
+        killed: result.killed.length
+      }
+    });
+  }
+  return result;
+}
 function looksLikeExeOsSession(sessionName) {
   const coordName = getCoordinatorNameCached();
   const escaped = coordName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -327,5 +384,6 @@ export {
   pruneStaleSessions,
   checkSessionRegistryConsistency,
   deregisterSession,
-  cleanupDeadSessions
+  cleanupDeadSessions,
+  reapOrphanedCoordinatorSessions
 };

package/dist/{chunk-7FBPLVHM.js → chunk-KADUJ7PE.js}

@@ -1,9 +1,9 @@
-import {
-  computeDaemonHeapCapMb
-} from "./chunk-CMDC5D7S.js";
 import {
   resolveEmbeddingsEnabled
 } from "./chunk-KWOAM7TA.js";
+import {
+  computeDaemonHeapCapMb
+} from "./chunk-NLEW62VC.js";
 import {
   isMainModule
 } from "./chunk-6Y4B3QF6.js";

package/dist/{chunk-KLG53B63.js → chunk-KJOQLNX2.js}

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