lody 0.44.2-next.1 → 0.44.4-next.1

package/dist/index.js

@@ -45,13 +45,13 @@ import require$$1$6 from "string_decoder";
 import * as http$2 from "http";
 import http__default from "http";
 import require$$1$7 from "https";
-import require$$0$a, { execSync, exec, execFile as execFile$1 } from "child_process";
+import require$$0$a, { execSync, exec, execFileSync, execFile as execFile$1 } from "child_process";
 import { randomFillSync, randomUUID as randomUUID$1, createHash as createHash$1 } from "node:crypto";
 import require$$0$b from "net";
 import require$$4$3 from "tls";
 import { i as imports, _ as __wbg_set_wasm$1, r as rawWasm, L as LoroDoc, E as EphemeralStoreWasm, U as UndoManager, c as callPendingEvents$3, a as LoroTree, b as LoroText, d as LoroMovableList, e as LoroList, f as LoroMap, g as __vite__initWasm, V as VersionVector, h as decodeImportBlobMeta, __tla as __tla_0 } from "./chunks/loro_wasm_bg-DgxHrrrp.js";
 import * as fs$5 from "fs/promises";
-import fs__default$1, { stat as stat$1, readFile as readFile$1 } from "fs/promises";
+import fs__default$1, { stat as stat$1, readFile as readFile$1, statfs } from "fs/promises";
 import fsPromises, { stat, open } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import require$$2$7 from "assert";
@@ -36820,7 +36820,7 @@ Mongoose Error Code: ${error2.code}` : ""}`
     return client;
   }
   const name = "lody";
-  const version$4 = "0.44.2-next.1";
+  const version$4 = "0.44.4-next.1";
   const description = "Lody Agent CLI tool for managing remote command execution";
   const type = "module";
   const main$3 = "dist/index.js";
@@ -78436,6 +78436,7 @@ Task description:
     "session_init_failed",
     "session_restore_failed",
     "session_not_found",
+    "memory_pressure",
     "acp_not_ready",
     "agent_disconnected",
     "turn_pre_prompt_failed",
@@ -112230,6 +112231,9 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
     isTransportConnected() {
       return this.transportStatus === "connected";
     }
+    isRecovering() {
+      return !this.isCleanedUp && !this.isStreamsHealthy();
+    }
     setTransportStatus(status) {
       this.transportStatus = status;
       if (status === "disconnected") {
@@ -113429,6 +113433,9 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
     isTransportConnected() {
       return this.connectionRecovery.isTransportConnected();
     }
+    isTransportRecovering() {
+      return this.connectionRecovery.isRecovering();
+    }
     getConnectedRoomCount() {
       return this.sessions.size + this.codeSessions.size;
     }
@@ -120210,6 +120217,221 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
     }
     return resolveAgentConfigEnvForSessionResume(repo, options.agentConfigId);
   };
+  function getMemoryPressureSnapshot() {
+    const windowsStatus = getWindowsMemoryStatus();
+    const systemAvailable = getSystemAvailableMemoryBytes(windowsStatus);
+    const cgroupAvailable = getCgroupAvailableMemoryBytes();
+    const availableMemoryBytes = cgroupAvailable !== null ? Math.min(systemAvailable, cgroupAvailable) : systemAvailable;
+    const effectiveMemoryLimitBytes = getEffectiveMemoryLimitBytes();
+    return {
+      availableMemoryBytes,
+      effectiveMemoryLimitBytes,
+      ...windowsStatus ? {
+        availableCommitBytes: windowsStatus.availableCommitBytes,
+        commitLimitBytes: windowsStatus.commitLimitBytes,
+        committedBytes: windowsStatus.committedBytes
+      } : {}
+    };
+  }
+  function getEffectiveMemoryLimitBytes() {
+    const totalMem = os__default.totalmem();
+    const cgroupMax = getCgroupMemoryMaxBytes();
+    if (cgroupMax !== null) {
+      return Math.min(totalMem, cgroupMax);
+    }
+    return totalMem;
+  }
+  function getSystemAvailableMemoryBytes(windowsStatus) {
+    if (windowsStatus) {
+      return Math.max(windowsStatus.availableBytes, os__default.freemem());
+    }
+    const darwinAvailable = getDarwinAvailableMemoryBytes();
+    if (darwinAvailable !== null) {
+      return darwinAvailable;
+    }
+    try {
+      const meminfo = readFileSync("/proc/meminfo", "utf8");
+      const match5 = meminfo.match(/MemAvailable:\s+(\d+)/);
+      if (match5?.[1]) {
+        return parseInt(match5[1], 10) * 1024;
+      }
+    } catch {
+    }
+    return os__default.freemem();
+  }
+  function getWindowsMemoryStatus() {
+    if (process.platform !== "win32") {
+      return null;
+    }
+    try {
+      const script = `
+$mem = Get-CimInstance -ClassName Win32_PerfFormattedData_PerfOS_Memory |
+  Select-Object AvailableBytes, CommitLimit, CommittedBytes
+$mem | ConvertTo-Json -Compress
+`;
+      const output = execFileSync("powershell.exe", [
+        "-NoProfile",
+        "-NonInteractive",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-Command",
+        script
+      ], {
+        encoding: "utf8"
+      });
+      return parseWindowsMemoryStatus(output);
+    } catch {
+      return null;
+    }
+  }
+  function parseWindowsMemoryStatus(rawJson) {
+    try {
+      const parsed = JSON.parse(rawJson);
+      const availableBytes = Number(parsed.AvailableBytes);
+      const commitLimitBytes = Number(parsed.CommitLimit);
+      const committedBytes = Number(parsed.CommittedBytes);
+      if (!Number.isFinite(availableBytes) || availableBytes < 0 || !Number.isFinite(commitLimitBytes) || commitLimitBytes <= 0 || !Number.isFinite(committedBytes) || committedBytes < 0) {
+        return null;
+      }
+      return {
+        availableBytes,
+        commitLimitBytes,
+        committedBytes,
+        availableCommitBytes: Math.max(0, commitLimitBytes - committedBytes)
+      };
+    } catch {
+      return null;
+    }
+  }
+  function getDarwinAvailableMemoryBytes() {
+    if (process.platform !== "darwin") {
+      return null;
+    }
+    try {
+      const vmStatOutput = execFileSync("vm_stat", {
+        encoding: "utf8"
+      });
+      const parsed = parseDarwinAvailableMemoryBytes(vmStatOutput);
+      if (parsed !== null) {
+        return Math.max(parsed, os__default.freemem());
+      }
+    } catch {
+    }
+    return null;
+  }
+  function parseDarwinAvailableMemoryBytes(vmStatOutput) {
+    const pageSizeMatch = vmStatOutput.match(/page size of\s+(\d+)\s+bytes/i);
+    if (!pageSizeMatch?.[1]) {
+      return null;
+    }
+    const pageSize = parseInt(pageSizeMatch[1], 10);
+    if (!Number.isFinite(pageSize) || pageSize <= 0) {
+      return null;
+    }
+    const counters = /* @__PURE__ */ new Map();
+    for (const rawLine of vmStatOutput.split("\n")) {
+      const line3 = rawLine.trim();
+      const match5 = line3.match(/^"?([^":]+?)"?:\s+(\d+)\.?$/);
+      if (!match5?.[1] || !match5[2]) {
+        continue;
+      }
+      counters.set(match5[1].toLowerCase(), parseInt(match5[2], 10));
+    }
+    const freePages = counters.get("pages free") ?? 0;
+    const speculativePages = counters.get("pages speculative") ?? 0;
+    const purgeablePages = counters.get("pages purgeable") ?? 0;
+    const inactivePages = counters.get("pages inactive") ?? 0;
+    const fileBackedPages = counters.get("file-backed pages");
+    if (freePages === 0 && speculativePages === 0 && purgeablePages === 0 && inactivePages === 0) {
+      return null;
+    }
+    const reclaimableCachedPages = fileBackedPages !== void 0 ? Math.min(fileBackedPages, inactivePages) : inactivePages;
+    const availablePages = freePages + speculativePages + purgeablePages + reclaimableCachedPages;
+    return availablePages * pageSize;
+  }
+  function getCgroupMemoryMaxBytes() {
+    try {
+      const cgroupPath = readSelfCgroupPath();
+      if (cgroupPath === null) return null;
+      let tightest = null;
+      let current2 = cgroupPath;
+      for (let depth = 0; depth < 20; depth++) {
+        const memMaxPath = `/sys/fs/cgroup${current2 === "/" ? "" : current2}/memory.max`;
+        const raw = readFileSafe(memMaxPath);
+        if (raw !== null) {
+          const trimmed = raw.trim();
+          if (trimmed !== "max") {
+            const value = parseInt(trimmed, 10);
+            if (Number.isFinite(value) && value > 0) {
+              tightest = tightest === null ? value : Math.min(tightest, value);
+            }
+          }
+        }
+        if (current2 === "/" || current2 === "") break;
+        const parent = current2.substring(0, current2.lastIndexOf("/")) || "/";
+        if (parent === current2) break;
+        current2 = parent;
+      }
+      return tightest;
+    } catch {
+      return null;
+    }
+  }
+  function getCgroupAvailableMemoryBytes() {
+    try {
+      const cgroupPath = readSelfCgroupPath();
+      if (cgroupPath === null) return null;
+      let tightestMax = null;
+      let tightestPath = null;
+      let current2 = cgroupPath;
+      for (let depth = 0; depth < 20; depth++) {
+        const prefix = `/sys/fs/cgroup${current2 === "/" ? "" : current2}`;
+        const raw = readFileSafe(`${prefix}/memory.max`);
+        if (raw !== null) {
+          const trimmed = raw.trim();
+          if (trimmed !== "max") {
+            const value = parseInt(trimmed, 10);
+            if (Number.isFinite(value) && value > 0) {
+              if (tightestMax === null || value < tightestMax) {
+                tightestMax = value;
+                tightestPath = prefix;
+              }
+            }
+          }
+        }
+        if (current2 === "/" || current2 === "") break;
+        const parent = current2.substring(0, current2.lastIndexOf("/")) || "/";
+        if (parent === current2) break;
+        current2 = parent;
+      }
+      if (tightestMax === null || tightestPath === null) return null;
+      const currentRaw = readFileSafe(`${tightestPath}/memory.current`);
+      if (currentRaw === null) return null;
+      const currentUsage = parseInt(currentRaw.trim(), 10);
+      if (!Number.isFinite(currentUsage)) return null;
+      return Math.max(0, tightestMax - currentUsage);
+    } catch {
+      return null;
+    }
+  }
+  function readSelfCgroupPath() {
+    try {
+      const content = readFileSync("/proc/self/cgroup", "utf8");
+      const line3 = content.split("\n").map((l) => l.trim()).find((l) => l.startsWith("0::"));
+      if (!line3) return null;
+      const cgroupPath = line3.slice(3).trim();
+      return cgroupPath || "/";
+    } catch {
+      return null;
+    }
+  }
+  function readFileSafe(filePath) {
+    try {
+      return readFileSync(filePath, "utf8");
+    } catch {
+      return null;
+    }
+  }
   class SessionTurnCancelled extends TaggedError("SessionTurnCancelled") {
   }
   class SessionTurnHalted extends TaggedError("SessionTurnHalted") {
@@ -120230,6 +120452,7 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
     AUTH_REQUIRED: -32e3,
     RESOURCE_NOT_FOUND: -32002
   };
+  const BYTES_PER_GIB = 1024 * 1024 * 1024;
   const shouldRedactEnvKey = (key2) => /token|secret|password|passwd|key/i.test(key2);
   const redactEnvForLog = (env2) => {
     if (!env2) {
@@ -120265,6 +120488,46 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
     canceledTurnBySession = /* @__PURE__ */ new Map();
     currentTurnBySession = /* @__PURE__ */ new Map();
     turnRuntimeBySession = /* @__PURE__ */ new Map();
+    formatGiB(bytes) {
+      if (bytes === null || !Number.isFinite(bytes) || bytes < 0) {
+        return "unavailable";
+      }
+      return `${(bytes / BYTES_PER_GIB).toFixed(1)}GB`;
+    }
+    formatPercent(value) {
+      if (value === null || !Number.isFinite(value) || value < 0) {
+        return "unavailable";
+      }
+      return `${value.toFixed(1)}%`;
+    }
+    async getFreeDiskBytes() {
+      try {
+        const stats = await statfs(os__default.homedir());
+        const bsize = typeof stats.bsize === "bigint" ? Number(stats.bsize) : stats.bsize;
+        const bavail = typeof stats.bavail === "bigint" ? Number(stats.bavail) : stats.bavail;
+        if (!Number.isFinite(bsize) || !Number.isFinite(bavail) || bsize <= 0 || bavail < 0) {
+          return null;
+        }
+        return bsize * bavail;
+      } catch {
+        return null;
+      }
+    }
+    async logTurnStartResources(sessionId, mode2) {
+      try {
+        const memorySnapshot = getMemoryPressureSnapshot();
+        const availableMemoryBytes = memorySnapshot.availableMemoryBytes;
+        const memoryFreePercent = memorySnapshot.effectiveMemoryLimitBytes > 0 ? availableMemoryBytes / memorySnapshot.effectiveMemoryLimitBytes * 100 : null;
+        const [resources, freeDiskBytes] = await Promise.all([
+          this.deps.collectMachineResources().catch(() => null),
+          this.getFreeDiskBytes()
+        ]);
+        const cpuUsagePercent = resources?.cpuUsagePercent ?? null;
+        this.deps.logger.info(`[${sessionId}] Turn start resources (mode=${mode2}): memoryAvailable=${this.formatGiB(availableMemoryBytes)} memoryAvailablePercent=${this.formatPercent(memoryFreePercent)} cpuUsage=${this.formatPercent(cpuUsagePercent)} diskFree=${this.formatGiB(freeDiskBytes)}`);
+      } catch (error2) {
+        this.deps.logger.debug(`[${sessionId}] Failed to log turn start resources: ${formatErrorMessage(error2)}`);
+      }
+    }
     createTurnRuntime(sessionId, turnId, userTurnId, session) {
       return {
         sessionId,
@@ -120447,10 +120710,19 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
     async recordKnownChatFailure(options) {
       await this.deps.recordChatFailure(options.sessionDoc, options.reason, options.message);
       if (options.userTurnId) {
-        await this.setDispatchError(options.sessionId, options.sessionDoc, options.userTurnId, options.code ?? options.reason, options.message);
+        await this.markTurnFailed(options.sessionId, options.sessionDoc, options.userTurnId);
       }
       await options.sessionDoc.setStatus(SessionStatusFactory.idle());
     }
+    formatMemoryPressureWarningMessage(result) {
+      const availableMb = Math.round(result.availableMemoryBytes / 1024 / 1024);
+      const thresholdMb = Math.round(result.thresholdBytes / 1024 / 1024);
+      const commitText = result.availableCommitBytes !== void 0 && (result.pressureReason === "commit" || result.pressureReason === "physical_and_commit") && result.commitThresholdBytes !== void 0 ? ` Commit headroom is ${Math.round(result.availableCommitBytes / 1024 / 1024)}MB (threshold: ${Math.round(result.commitThresholdBytes / 1024 / 1024)}MB).` : "";
+      return `The machine is under memory pressure (${availableMb}MB available, ${thresholdMb}MB required to start a turn). Proceeding anyway because the new turn may be used to free resources.${commitText}`;
+    }
+    warnOnMemoryPressure(sessionId, result) {
+      this.deps.logger.warn(`[${sessionId}] ${this.formatMemoryPressureWarningMessage(result)}`);
+    }
     recordKnownChatFailureAndHaltEffect(options) {
       return this.tryPromise(() => this.recordKnownChatFailure(options)).pipe(flatMap$1(() => fail(new SessionTurnHalted({
         sessionId: options.sessionId,
@@ -120474,7 +120746,7 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       }
       this.deps.logger.error(options.describe(options.error), options.error);
       if (options.userTurnId) {
-        await this.setDispatchError(options.sessionId, options.sessionDoc, options.userTurnId, options.code, formatErrorMessage(options.error));
+        await this.markTurnFailed(options.sessionId, options.sessionDoc, options.userTurnId);
       }
       await this.handleTurnError(options.sessionId, options.sessionDoc, options.error);
       await options.onUnhandledError?.(options.error);
@@ -120810,8 +121082,7 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       await this.setUserTurnStatus(sessionDoc, userTurnId, "processing");
       await this.upsertSessionMeta(sessionId, {
         latestUserMsgId: userTurnId,
-        processingUserMsgId: userTurnId,
-        dispatchError: void 0
+        processingUserMsgId: userTurnId
       });
     }
     async clearDispatchProcessing(sessionId) {
@@ -120860,34 +121131,31 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
         await this.upsertSessionMeta(sessionId, {
           latestUserMsgId: existingMeta?.latestUserMsgId ?? cancelledUserMsgId,
           lastHandledUserMsgId: cancelledUserMsgId,
-          processingUserMsgId: void 0,
-          dispatchError: void 0
+          processingUserMsgId: void 0
         });
         return;
       }
       await this.clearDispatchProcessing(sessionId);
     }
+    resolveLatestUserMsgIdForTerminalTurn(meta, terminalUserTurnId) {
+      return meta?.latestUserMsgId && meta.latestUserMsgId !== terminalUserTurnId ? meta.latestUserMsgId : terminalUserTurnId;
+    }
     async setDispatchHandled(sessionId, sessionDoc, userTurnId) {
+      const existingMeta = await this.getSessionMeta(sessionId);
       await this.setUserTurnStatus(sessionDoc, userTurnId, "handled");
       await this.upsertSessionMeta(sessionId, {
-        latestUserMsgId: userTurnId,
+        latestUserMsgId: this.resolveLatestUserMsgIdForTerminalTurn(existingMeta, userTurnId),
         lastHandledUserMsgId: userTurnId,
-        processingUserMsgId: void 0,
-        dispatchError: void 0
+        processingUserMsgId: void 0
       });
     }
-    async setDispatchError(sessionId, sessionDoc, userTurnId, code2, message) {
+    async markTurnFailed(sessionId, sessionDoc, userTurnId) {
+      const existingMeta = await this.getSessionMeta(sessionId);
       await this.setUserTurnStatus(sessionDoc, userTurnId, "failed");
       await this.upsertSessionMeta(sessionId, {
-        latestUserMsgId: userTurnId,
-        processingUserMsgId: void 0,
-        dispatchError: {
-          code: code2,
-          ...message ? {
-            message
-          } : {},
-          at: getServerNow()
-        }
+        latestUserMsgId: this.resolveLatestUserMsgIdForTerminalTurn(existingMeta, userTurnId),
+        lastHandledUserMsgId: userTurnId,
+        processingUserMsgId: void 0
       });
     }
     resolveGitHubProjectBranch(meta, preferredBranch) {
@@ -120981,15 +121249,18 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
     }
     async continueSession(message) {
       const { sessionId, acpSessionConfig, userId, userName, userEmail, userTurnId } = message;
-      await this.deps.evictForMemoryPressure(sessionId);
+      const memoryPressureResult = await this.deps.evictForMemoryPressure(sessionId);
+      if (memoryPressureResult.stillUnderPressure) {
+        this.warnOnMemoryPressure(sessionId, memoryPressureResult);
+      }
+      await this.logTurnStartResources(sessionId, "continue");
+      const sessionDoc = await this.deps.workspaceDocument.getOrCreateSessionDoc(sessionId);
       this.deps.touchSession(sessionId);
       this.deps.logger.info(`Session chat received: ${sessionId}`);
       this.deps.logger.debug(`[${sessionId}] Received chat request (userTurnId=${userTurnId})`);
       await this.upsertSessionMeta(sessionId, {
-        latestUserMsgId: userTurnId,
-        dispatchError: void 0
+        latestUserMsgId: userTurnId
       });
-      const sessionDoc = await this.deps.workspaceDocument.getOrCreateSessionDoc(sessionId);
       const incomingProjectBranch = message.project?.branch?.trim();
       if (incomingProjectBranch) {
         await sessionDoc.setBaseBranch(incomingProjectBranch);
@@ -121326,7 +121597,7 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       }));
     }
     async startSession(message) {
-      await this.deps.evictForMemoryPressure(message.sessionId);
+      const memoryPressureResult = await this.deps.evictForMemoryPressure(message.sessionId);
       const { sessionId, acpSessionConfig, workspaceId, env: env2 } = message;
       const userTurnId = typeof message.userTurnId === "string" && message.userTurnId.trim() ? message.userTurnId.trim() : void 0;
       const project = message.project;
@@ -121339,6 +121610,10 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       const promptText = agentConfig.prompt ?? "";
       const promptBytes = Buffer.byteLength(promptText, "utf8");
       const promptPreview = promptText.length > 200 ? `${promptText.slice(0, 200)}\u2026` : promptText;
+      if (memoryPressureResult.stillUnderPressure) {
+        this.warnOnMemoryPressure(sessionId, memoryPressureResult);
+      }
+      await this.logTurnStartResources(sessionId, "start");
       const sessionDoc = await this.deps.workspaceDocument.getOrCreateSessionDoc(sessionId);
       const existingMeta = await sessionDoc.getMetaState();
       const fromFeedbackPostId = message.meta?.fromFeedbackPostId?.trim() || existingMeta?.fromFeedbackPostId?.trim() || void 0;
@@ -121362,12 +121637,6 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
         fromFeedbackPostId
       };
       this.deps.logger.debug(`[${sessionId}] session/create summary`, configForLog);
-      if (userTurnId) {
-        await this.upsertSessionMeta(sessionId, {
-          latestUserMsgId: userTurnId,
-          dispatchError: void 0
-        });
-      }
       const sessionConfig = {
         sessionId,
         workspaceId,
@@ -121388,6 +121657,11 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       if (project) {
         await sessionDoc.setProject(project);
       }
+      if (userTurnId) {
+        await this.upsertSessionMeta(sessionId, {
+          latestUserMsgId: userTurnId
+        });
+      }
       if (branch) {
         await sessionDoc.setBaseBranch(branch);
       }
@@ -122051,9 +122325,6 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       if (meta.lastCanceledTurn && meta.lastCanceledTurn !== this.cancelSeenTurn.get(meta.id)) {
         return true;
       }
-      if (meta.dispatchError?.code === SessionDispatchWatcher.DISPATCH_HISTORY_SYNC_TIMEOUT_CODE) {
-        return false;
-      }
       if (!meta.lastHandledUserMsgId) {
         return true;
       }
@@ -122149,12 +122420,7 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       await this.deps.workspaceDocument.repo.upsertDocMeta?.(getSessionRoomId(sessionId), {
         latestUserMsgId: userTurnId,
         lastHandledUserMsgId: userTurnId,
-        processingUserMsgId: void 0,
-        dispatchError: {
-          code: reason === "cli_token_invalid" ? "cli_token_invalid" : "machine_access_denied",
-          message,
-          at: getServerNow()
-        }
+        processingUserMsgId: void 0
       });
       await sessionDoc.setStatus(SessionStatusFactory.idle());
     }
@@ -122284,7 +122550,6 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
     static HISTORY_SYNC_WAIT_TIMEOUT_MS = 5 * 6e4;
     static HISTORY_RECONNECT_JITTER_MIN_MS = 500;
     static HISTORY_RECONNECT_JITTER_MAX_MS = 1500;
-    static DISPATCH_HISTORY_SYNC_TIMEOUT_CODE = "dispatch_recovery_unhealthy";
     static setUnrefTimeout(callback, delayMs) {
       const timer2 = setTimeout(callback, delayMs);
       if (typeof timer2 === "object" && "unref" in timer2) {
@@ -122333,23 +122598,20 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       }
       return Boolean(meta.latestUserMsgId && meta.latestUserMsgId !== meta.lastHandledUserMsgId);
     }
-    async setHistorySyncWaitStatus(sessionId, sessionDoc, detail) {
-      try {
-        await sessionDoc.setStatus(SessionStatusFactory.initializing(void 0, detail));
-      } catch (error2) {
-        this.deps.logger.debug(`[${sessionId}] Failed to set history sync wait status (${detail}): ${formatErrorMessage(error2)}`);
-      }
-    }
     async waitForPendingUserTurnHistorySync(sessionId, sessionDoc, meta) {
       this.deps.logger.debug(`[${sessionId}] Pending user turn metadata is visible but history is missing it; waiting up to ${SessionDispatchWatcher.HISTORY_SYNC_WAIT_TIMEOUT_MS / 1e3}s for history CRDT sync`);
-      let currentWaitDetail = "joining-history";
-      await this.setHistorySyncWaitStatus(sessionId, sessionDoc, currentWaitDetail);
       try {
         await sessionDoc.ensureDocRoomJoined();
       } catch (error2) {
         this.deps.logger.debug(`[${sessionId}] Failed to ensure session history room is joined before waiting: ${formatErrorMessage(error2)}`);
       }
-      const turnAfterJoin = await this.checkHistoryAndQueue(sessionDoc, meta);
+      await sessionDoc.waitUntilSynced();
+      const freshMeta = await sessionDoc.getMetaState() ?? meta;
+      if (!this.hasPendingUserTurnSignal(freshMeta)) {
+        this.deps.logger.debug(`[${sessionId}] Pending user turn pointer cleared during pre-wait sync; exiting wait`);
+        return null;
+      }
+      const turnAfterJoin = await this.checkHistoryAndQueue(sessionDoc, freshMeta);
       if (turnAfterJoin) {
         return turnAfterJoin;
       }
@@ -122367,18 +122629,11 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
           unsubscribeMirror?.();
           unsubscribeStatus?.();
         };
-        const updateWaitStatus = (detail) => {
-          if (currentWaitDetail === detail) {
-            return;
-          }
-          currentWaitDetail = detail;
-          void this.setHistorySyncWaitStatus(sessionId, sessionDoc, detail);
-        };
         const checkForTurn = () => {
           if (settled) {
             return;
           }
-          void this.checkHistoryAndQueue(sessionDoc, meta).then((turn) => {
+          void this.checkHistoryAndQueue(sessionDoc, freshMeta).then((turn) => {
             if (settled || !turn) {
               return;
             }
@@ -122398,7 +122653,6 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
           }
           reconnectAttempted = true;
           void (async () => {
-            updateWaitStatus("reconnecting-history");
             const jitterMs = SessionDispatchWatcher.getReconnectJitterMs();
             this.deps.logger.debug(`[${sessionId}] Session history room ${reason}; attempting one rejoin in ${jitterMs}ms`);
             await SessionDispatchWatcher.sleep(jitterMs);
@@ -122417,14 +122671,6 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
           if (settled || !status) {
             return;
           }
-          if (status === "connecting" || status === "joined") {
-            updateWaitStatus("joining-history");
-            return;
-          }
-          if (status === "reconnecting") {
-            updateWaitStatus("reconnecting-history");
-            return;
-          }
           if (status === "disconnected" || status === "error") {
             attemptReconnectOnce(status);
           }
@@ -122461,16 +122707,15 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       if (meta.machineId !== this.deps.machineId || meta.isArchived || !this.hasPendingUserTurnSignal(meta)) {
         return;
       }
-      await this.deps.workspaceDocument.repo.upsertDocMeta?.(roomId, {
-        status: SessionStatusFactory.idle(),
-        latestUserMsgId: void 0,
-        processingUserMsgId: void 0,
-        dispatchError: {
-          code: SessionDispatchWatcher.DISPATCH_HISTORY_SYNC_TIMEOUT_CODE,
-          message: "Dispatch recovery could not reconnect to this session after 5 minutes. Send a new message to retry.",
-          at: getServerNow()
-        }
-      });
+      const pendingUserMsgId = meta.processingUserMsgId ?? meta.latestUserMsgId ?? meta.lastHandledUserMsgId;
+      const recoveryPatch = {
+        status: SessionStatusFactory.idle()
+      };
+      if (pendingUserMsgId) {
+        recoveryPatch.lastHandledUserMsgId = pendingUserMsgId;
+        recoveryPatch.latestUserMsgId = pendingUserMsgId;
+      }
+      await this.deps.workspaceDocument.repo.upsertDocMeta?.(roomId, recoveryPatch);
       const watched = this.watchedSessions.get(sessionId);
       watched?.unsubscribe();
       this.watchedSessions.delete(sessionId);
@@ -123217,8 +123462,14 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
     permissionRequestStartTimes = /* @__PURE__ */ new Map();
     machineHeartbeatTimer = null;
     static MACHINE_HEARTBEAT_INTERVAL_MS = 2e4;
-    evictForMemoryPressureFn = async () => {
-    };
+    evictForMemoryPressureFn = async () => ({
+      availableMemoryBytes: 0,
+      thresholdBytes: 0,
+      hadMemoryPressure: false,
+      stillUnderPressure: false,
+      evictedSessionIds: [],
+      pressureReason: null
+    });
     executionService;
     sessionDispatchWatcher;
     autoPromptRunner;
@@ -125230,6 +125481,16 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
     hasPendingUpdates(sessionId) {
       return this.store.has(sessionId) && this.store.get(sessionId).acpUpdateBuffer.length > 0;
     }
+    async hasPendingUserWork(sessionId) {
+      const meta = (await this.workspaceDocument.repo.getDocMeta(getSessionRoomId(sessionId)))?.meta;
+      if (!meta) {
+        return false;
+      }
+      if (meta.processingUserMsgId) {
+        return true;
+      }
+      return Boolean(meta.latestUserMsgId && meta.latestUserMsgId !== meta.lastHandledUserMsgId);
+    }
     isArchiveInFlight(sessionId) {
       return this.archiveInFlight.has(sessionId);
     }
@@ -125586,116 +125847,6 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       }
     }
   }
-  function getAvailableMemoryBytes() {
-    const systemAvailable = getSystemAvailableMemoryBytes();
-    const cgroupAvailable = getCgroupAvailableMemoryBytes();
-    if (cgroupAvailable !== null) {
-      return Math.min(systemAvailable, cgroupAvailable);
-    }
-    return systemAvailable;
-  }
-  function getEffectiveMemoryLimitBytes() {
-    const totalMem = os__default.totalmem();
-    const cgroupMax = getCgroupMemoryMaxBytes();
-    if (cgroupMax !== null) {
-      return Math.min(totalMem, cgroupMax);
-    }
-    return totalMem;
-  }
-  function getSystemAvailableMemoryBytes() {
-    try {
-      const meminfo = readFileSync("/proc/meminfo", "utf8");
-      const match5 = meminfo.match(/MemAvailable:\s+(\d+)/);
-      if (match5?.[1]) {
-        return parseInt(match5[1], 10) * 1024;
-      }
-    } catch {
-    }
-    return os__default.freemem();
-  }
-  function getCgroupMemoryMaxBytes() {
-    try {
-      const cgroupPath = readSelfCgroupPath();
-      if (cgroupPath === null) return null;
-      let tightest = null;
-      let current2 = cgroupPath;
-      for (let depth = 0; depth < 20; depth++) {
-        const memMaxPath = `/sys/fs/cgroup${current2 === "/" ? "" : current2}/memory.max`;
-        const raw = readFileSafe(memMaxPath);
-        if (raw !== null) {
-          const trimmed = raw.trim();
-          if (trimmed !== "max") {
-            const value = parseInt(trimmed, 10);
-            if (Number.isFinite(value) && value > 0) {
-              tightest = tightest === null ? value : Math.min(tightest, value);
-            }
-          }
-        }
-        if (current2 === "/" || current2 === "") break;
-        const parent = current2.substring(0, current2.lastIndexOf("/")) || "/";
-        if (parent === current2) break;
-        current2 = parent;
-      }
-      return tightest;
-    } catch {
-      return null;
-    }
-  }
-  function getCgroupAvailableMemoryBytes() {
-    try {
-      const cgroupPath = readSelfCgroupPath();
-      if (cgroupPath === null) return null;
-      let tightestMax = null;
-      let tightestPath = null;
-      let current2 = cgroupPath;
-      for (let depth = 0; depth < 20; depth++) {
-        const prefix = `/sys/fs/cgroup${current2 === "/" ? "" : current2}`;
-        const raw = readFileSafe(`${prefix}/memory.max`);
-        if (raw !== null) {
-          const trimmed = raw.trim();
-          if (trimmed !== "max") {
-            const value = parseInt(trimmed, 10);
-            if (Number.isFinite(value) && value > 0) {
-              if (tightestMax === null || value < tightestMax) {
-                tightestMax = value;
-                tightestPath = prefix;
-              }
-            }
-          }
-        }
-        if (current2 === "/" || current2 === "") break;
-        const parent = current2.substring(0, current2.lastIndexOf("/")) || "/";
-        if (parent === current2) break;
-        current2 = parent;
-      }
-      if (tightestMax === null || tightestPath === null) return null;
-      const currentRaw = readFileSafe(`${tightestPath}/memory.current`);
-      if (currentRaw === null) return null;
-      const currentUsage = parseInt(currentRaw.trim(), 10);
-      if (!Number.isFinite(currentUsage)) return null;
-      return Math.max(0, tightestMax - currentUsage);
-    } catch {
-      return null;
-    }
-  }
-  function readSelfCgroupPath() {
-    try {
-      const content = readFileSync("/proc/self/cgroup", "utf8");
-      const line3 = content.split("\n").map((l) => l.trim()).find((l) => l.startsWith("0::"));
-      if (!line3) return null;
-      const cgroupPath = line3.slice(3).trim();
-      return cgroupPath || "/";
-    } catch {
-      return null;
-    }
-  }
-  function readFileSafe(filePath) {
-    try {
-      return readFileSync(filePath, "utf8");
-    } catch {
-      return null;
-    }
-  }
   function readEnvNumber(key2, fallback2) {
     const raw = process.env[key2];
     if (!raw) return fallback2;
@@ -125703,6 +125854,8 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
     return Number.isFinite(parsed) ? parsed : fallback2;
   }
   const GIB = 1024 * 1024 * 1024;
+  const WINDOWS_COMMIT_THRESHOLD_FLOOR_BYTES = 512 * 1024 * 1024;
+  const WINDOWS_COMMIT_THRESHOLD_CEILING_BYTES = 2 * GIB;
   function defaultMemoryThresholdBytes() {
     const tenPercent = Math.floor(getEffectiveMemoryLimitBytes() * 0.1);
     return Math.max(GIB, Math.min(4 * GIB, tenPercent));
@@ -125715,6 +125868,9 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       memoryThresholdBytes: readEnvNumber("LODY_SESSION_GC_MEMORY_THRESHOLD_BYTES", defaultMemoryThresholdBytes())
     };
   }
+  function getWindowsCommitThresholdBytes(memoryThresholdBytes) {
+    return Math.max(WINDOWS_COMMIT_THRESHOLD_FLOOR_BYTES, Math.min(WINDOWS_COMMIT_THRESHOLD_CEILING_BYTES, memoryThresholdBytes));
+  }
   class SessionGCManager {
     constructor(config2, deps) {
       this.config = config2;
@@ -125738,7 +125894,7 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
     }
     async sweep() {
       const sweepStart = Date.now();
-      const candidates = this.getIdleCandidates();
+      const candidates = await this.getIdleCandidates();
       if (candidates.length === 0) {
         return;
       }
@@ -125746,7 +125902,7 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       let cleaned = 0;
       let skipped = 0;
       for (const { sessionId } of candidates) {
-        if (!this.isStillEligibleForGC(sessionId)) {
+        if (!await this.isStillEligibleForGC(sessionId)) {
           skipped++;
           continue;
         }
@@ -125764,19 +125920,50 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       this.deps.logger.debug(`[GC] Sweep completed: cleaned ${cleaned}/${candidates.length} sessions in ${sweepDuration}ms`);
     }
     async evictForMemoryPressure(excludeSessionId) {
+      const thresholdBytes = this.config.memoryThresholdBytes;
+      const commitThresholdBytes = getWindowsCommitThresholdBytes(thresholdBytes);
+      let memorySnapshot = getMemoryPressureSnapshot();
+      let availableMemory = memorySnapshot.availableMemoryBytes;
+      let pressureReason = this.getPressureReason(memorySnapshot, thresholdBytes, commitThresholdBytes);
       if (!this.config.enabled) {
-        return;
+        return {
+          availableMemoryBytes: availableMemory,
+          thresholdBytes,
+          hadMemoryPressure: false,
+          stillUnderPressure: false,
+          evictedSessionIds: [],
+          pressureReason: null,
+          ...memorySnapshot.availableCommitBytes !== void 0 ? {
+            availableCommitBytes: memorySnapshot.availableCommitBytes,
+            commitThresholdBytes,
+            commitLimitBytes: memorySnapshot.commitLimitBytes,
+            committedBytes: memorySnapshot.committedBytes
+          } : {}
+        };
       }
-      let availableMemory = getAvailableMemoryBytes();
-      if (availableMemory >= this.config.memoryThresholdBytes) {
-        return;
+      if (pressureReason === null) {
+        return {
+          availableMemoryBytes: availableMemory,
+          thresholdBytes,
+          hadMemoryPressure: false,
+          stillUnderPressure: false,
+          evictedSessionIds: [],
+          pressureReason: null,
+          ...memorySnapshot.availableCommitBytes !== void 0 ? {
+            availableCommitBytes: memorySnapshot.availableCommitBytes,
+            commitThresholdBytes,
+            commitLimitBytes: memorySnapshot.commitLimitBytes,
+            committedBytes: memorySnapshot.committedBytes
+          } : {}
+        };
       }
-      this.deps.logger.debug(`[GC] Memory pressure detected: ${Math.round(availableMemory / 1024 / 1024)}MB available (threshold: ${Math.round(this.config.memoryThresholdBytes / 1024 / 1024)}MB)`);
+      const commitText = memorySnapshot.availableCommitBytes !== void 0 ? `, commit headroom ${Math.round(memorySnapshot.availableCommitBytes / 1024 / 1024)}MB (threshold: ${Math.round(commitThresholdBytes / 1024 / 1024)}MB)` : "";
+      this.deps.logger.debug(`[GC] Memory pressure detected: ${Math.round(availableMemory / 1024 / 1024)}MB available (threshold: ${Math.round(thresholdBytes / 1024 / 1024)}MB)${commitText}`);
       const sessions = this.getSessionsWithIdleTime();
       sessions.sort((a, b) => b.idleMs - a.idleMs);
-      let evicted = 0;
+      const evictedSessionIds = [];
       for (const { sessionId, idleMs } of sessions) {
-        if (availableMemory >= this.config.memoryThresholdBytes) {
+        if (pressureReason === null) {
           break;
         }
         if (excludeSessionId && sessionId === excludeSessionId) {
@@ -125785,30 +125972,63 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
         if (idleMs === 0) {
           continue;
         }
-        if (!this.isEligibleForCleanup(sessionId)) {
+        if (!await this.isEligibleForCleanup(sessionId)) {
           continue;
         }
         try {
           this.deps.logger.debug(`[GC] Evicting session ${sessionId} (idle ${Math.round(idleMs / 1e3)}s) due to memory pressure`);
           await this.deps.cleanSession(sessionId);
-          evicted++;
-          availableMemory = getAvailableMemoryBytes();
+          evictedSessionIds.push(sessionId);
+          memorySnapshot = getMemoryPressureSnapshot();
+          availableMemory = memorySnapshot.availableMemoryBytes;
+          pressureReason = this.getPressureReason(memorySnapshot, thresholdBytes, commitThresholdBytes);
         } catch (error2) {
           this.deps.logger.error(`[GC] Failed to evict session ${sessionId}: ${formatErrorMessage(error2)}`);
         }
       }
-      if (evicted > 0) {
-        this.deps.logger.debug(`[GC] Memory pressure eviction complete: evicted ${evicted} sessions, available memory now ${Math.round(availableMemory / 1024 / 1024)}MB`);
+      const stillUnderPressure = pressureReason !== null;
+      if (evictedSessionIds.length > 0) {
+        this.deps.logger.debug(`[GC] Memory pressure eviction complete: evicted ${evictedSessionIds.length} sessions, available memory now ${Math.round(availableMemory / 1024 / 1024)}MB`);
+      } else if (stillUnderPressure) {
+        this.deps.logger.debug("[GC] Memory pressure persists but no idle sessions were eligible for eviction");
+      }
+      return {
+        availableMemoryBytes: availableMemory,
+        thresholdBytes,
+        hadMemoryPressure: true,
+        stillUnderPressure,
+        evictedSessionIds,
+        pressureReason,
+        ...memorySnapshot.availableCommitBytes !== void 0 ? {
+          availableCommitBytes: memorySnapshot.availableCommitBytes,
+          commitThresholdBytes,
+          commitLimitBytes: memorySnapshot.commitLimitBytes,
+          committedBytes: memorySnapshot.committedBytes
+        } : {}
+      };
+    }
+    getPressureReason(snapshot, thresholdBytes, commitThresholdBytes) {
+      const physicalPressure = snapshot.availableMemoryBytes < thresholdBytes;
+      const commitPressure = snapshot.availableCommitBytes !== void 0 && snapshot.availableCommitBytes < commitThresholdBytes;
+      if (physicalPressure && commitPressure) {
+        return "physical_and_commit";
+      }
+      if (physicalPressure) {
+        return "physical";
       }
+      if (commitPressure) {
+        return "commit";
+      }
+      return null;
     }
-    getIdleCandidates() {
+    async getIdleCandidates() {
       const sessions = this.getSessionsWithIdleTime();
       const candidates = [];
       for (const session of sessions) {
         if (session.idleMs < this.config.idleTimeoutMs) {
           continue;
         }
-        if (!this.isEligibleForCleanup(session.sessionId)) {
+        if (!await this.isEligibleForCleanup(session.sessionId)) {
           continue;
         }
         candidates.push(session);
@@ -125836,20 +126056,23 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       }
       return result;
     }
-    isEligibleForCleanup(sessionId) {
+    async isEligibleForCleanup(sessionId) {
       if (this.deps.hasActiveTurn(sessionId)) {
         return false;
       }
       if (this.deps.hasPendingUpdates(sessionId)) {
         return false;
       }
+      if (await this.deps.hasPendingUserWork(sessionId)) {
+        return false;
+      }
       if (this.deps.isArchiveInFlight(sessionId)) {
         return false;
       }
       return true;
     }
-    isStillEligibleForGC(sessionId) {
-      if (!this.isEligibleForCleanup(sessionId)) {
+    async isStillEligibleForGC(sessionId) {
+      if (!await this.isEligibleForCleanup(sessionId)) {
         return false;
       }
       const lastActivity = this.deps.getSessionLastActivity(sessionId);
@@ -125977,6 +126200,7 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
         getSessionLastActivity: (sessionId) => handler.getLastActivity(sessionId),
         hasActiveTurn: (sessionId) => handler.hasActiveTurn(sessionId),
         hasPendingUpdates: (sessionId) => handler.hasPendingUpdates(sessionId),
+        hasPendingUserWork: async (sessionId) => await handler.hasPendingUserWork(sessionId),
         isArchiveInFlight: (sessionId) => handler.isArchiveInFlight(sessionId),
         cleanSession: (sessionId) => handler.cleanSessionForGC(sessionId),
         getSessionIds: () => handler.getTrackedSessionIds(),
@@ -125985,8 +126209,16 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       this.gcManager.start();
       handler.setEvictForMemoryPressure(async (excludeSessionId) => {
         if (this.gcManager) {
-          await this.gcManager.evictForMemoryPressure(excludeSessionId);
+          return await this.gcManager.evictForMemoryPressure(excludeSessionId);
         }
+        return {
+          availableMemoryBytes: 0,
+          thresholdBytes: 0,
+          hadMemoryPressure: false,
+          stillUnderPressure: false,
+          evictedSessionIds: [],
+          pressureReason: null
+        };
       });
     }
     requireSessionManager() {
@@ -133184,6 +133416,9 @@ export PATH=${toSingleQuotedShellString(ghShimBinDir)}:"$PATH"
     isControlPlaneReady() {
       return this.documentManager.isTransportConnected();
     }
+    isControlPlaneRecovering() {
+      return this.documentManager.isTransportRecovering();
+    }
     getActiveSessionCount() {
       return this.runtime.getActiveSessionCount();
     }
@@ -135013,23 +135248,26 @@ export PATH=${toSingleQuotedShellString(ghShimBinDir)}:"$PATH"
     refreshRuntimeState() {
       const desiredCount = this.desiredWorkspaces.size;
       let connectedCount = 0;
+      let reconnectingCount = 0;
       let totalActiveSessions = 0;
       let totalConnectedRooms = 0;
       for (const runtime of this.runtimes.values()) {
         if (runtime.lody.isControlPlaneReady()) {
           connectedCount += 1;
+        } else if (runtime.lody.isControlPlaneRecovering()) {
+          reconnectingCount += 1;
         }
         totalActiveSessions += runtime.lody.getActiveSessionCount();
         totalConnectedRooms += runtime.lody.getConnectedRoomCount();
       }
       this.runtimeStateReporter.setActiveSessionCount(totalActiveSessions);
       this.runtimeStateReporter.setConnectedRoomCount(totalConnectedRooms);
-      const nextConnectivity = desiredCount === 0 ? "online" : connectedCount === 0 ? "offline" : connectedCount < desiredCount ? "reconnecting" : "online";
+      const hasWorkspaceRetry = this.retryTimers.size > 0 || this.startInFlight.size > 0;
+      const nextConnectivity = desiredCount === 0 ? "online" : connectedCount === desiredCount ? "online" : reconnectingCount > 0 || hasWorkspaceRetry ? "reconnecting" : "offline";
       if (this.lastConnectivity !== nextConnectivity) {
         this.lastConnectivity = nextConnectivity;
         this.runtimeStateReporter.setConnectivity(nextConnectivity);
       }
-      const hasWorkspaceRetry = this.retryTimers.size > 0 || this.startInFlight.size > 0;
       if (hasWorkspaceRetry && !this.hasWorkspaceRetryIssue) {
         this.hasWorkspaceRetryIssue = true;
         this.runtimeStateReporter.upsertIssue({
@@ -167312,10 +167550,18 @@ ${entry2.text}`).join("\n\n");
   }
   const DEFAULT_MIN_RETRY_MS$1 = 1e3;
   const DEFAULT_MAX_RETRY_MS$1 = 3e4;
-  function buildRetryDelay(attempt, minMs = DEFAULT_MIN_RETRY_MS$1, maxMs = DEFAULT_MAX_RETRY_MS$1) {
+  const DEFAULT_JITTER_FRACTION = 0.2;
+  function buildRetryDelay(attempt, minMs = DEFAULT_MIN_RETRY_MS$1, maxMs = DEFAULT_MAX_RETRY_MS$1, options = {}) {
     const exponent = Math.max(0, attempt);
-    const delay2 = minMs * 2 ** exponent;
-    return Math.min(delay2, maxMs);
+    const baseDelay = Math.min(minMs * 2 ** exponent, maxMs);
+    const jitterFraction = Math.max(0, options.jitterFraction ?? DEFAULT_JITTER_FRACTION);
+    if (jitterFraction === 0) {
+      return baseDelay;
+    }
+    const random2 = options.random ?? Math.random;
+    const randomValue = Math.min(1, Math.max(0, random2()));
+    const jitterMultiplier = 1 + (randomValue * 2 - 1) * jitterFraction;
+    return Math.min(Math.max(0, Math.round(baseDelay * jitterMultiplier)), maxMs);
   }
   class FailureWindow {
     historyMs = [];
@@ -167376,6 +167622,7 @@ ${result.stderr}`;
     probeFailureThreshold;
     minRetryMs;
     maxRetryMs;
+    retryRandom;
     failureWindow;
     triggered = false;
     inFlight = false;
@@ -167407,6 +167654,7 @@ ${result.stderr}`;
       this.probeFailureThreshold = options.probeFailureThreshold ?? DEFAULT_PROBE_FAILURE_THRESHOLD;
       this.minRetryMs = options.minRetryMs ?? DEFAULT_MIN_RETRY_MS;
       this.maxRetryMs = options.maxRetryMs ?? DEFAULT_MAX_RETRY_MS;
+      this.retryRandom = options.retryRandom ?? Math.random;
       this.failureWindow = new FailureWindow(options.fatalFailureWindowMs ?? DEFAULT_FATAL_FAILURE_WINDOW_MS, options.fatalFailureThreshold ?? DEFAULT_FATAL_FAILURE_THRESHOLD);
     }
     getState() {
@@ -167486,6 +167734,9 @@ ${result.stderr}`;
         this.latestRuntimeState = runtimeState;
         this.probeFailureCount = 0;
         this.probeUnavailable = false;
+        this.clearRetryTimer();
+        this.attempt = 0;
+        this.failureWindow.reset();
         this.lastStateMessage = void 0;
       } else {
         this.probeFailureCount += 1;
@@ -167506,7 +167757,9 @@ ${result.stderr}`;
       } else if (this.fatalReason) {
         phase = "fatal";
       } else if (runtime) {
-        phase = runtime.phase === "fatal" ? "fatal" : runtime.phase;
+        phase = runtime.phase === "fatal" ? "fatal" : runtime.connectivity === "reconnecting" ? "reconnecting" : runtime.phase;
+      } else if (this.retryTimer) {
+        phase = "reconnecting";
       } else if (childRunning) {
         phase = this.probeUnavailable ? "offline" : "starting";
       } else if (this.probeUnavailable && !this.inFlight && !this.retryTimer) {
@@ -167563,7 +167816,9 @@ ${result.stderr}`;
     scheduleRetry(reason, recordFailure = true) {
       if (this.fatalReason) return;
       if (recordFailure && this.recordFailure(reason)) return;
-      const delay2 = buildRetryDelay(this.attempt, this.minRetryMs, this.maxRetryMs);
+      const delay2 = buildRetryDelay(this.attempt, this.minRetryMs, this.maxRetryMs, {
+        random: this.retryRandom
+      });
       this.attempt += 1;
       this.clearRetryTimer();
       this.pendingRetryInMs = delay2;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lody",
-  "version": "0.44.2-next.1",
+  "version": "0.44.4-next.1",
   "description": "Lody Agent CLI tool for managing remote command execution",
   "type": "module",
   "main": "dist/index.js",
@@ -72,11 +72,11 @@
     "winston-transport": "^4.7.1",
     "ws": "^8.18.3",
     "zod": "^4.1.5",
-    "@lody/cli-supervisor": "0.0.1",
     "@lody/convex": "0.0.1",
-    "@lody/loro-streams-rpc": "0.0.1",
     "@lody/shared": "0.0.1",
-    "loro-code": "0.0.1"
+    "loro-code": "0.0.1",
+    "@lody/cli-supervisor": "0.0.1",
+    "@lody/loro-streams-rpc": "0.0.1"
   },
   "files": [
     "dist",