lody 0.45.0 → 0.46.0

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.45.0";
+  const version$4 = "0.46.0";
   const description = "Lody Agent CLI tool for managing remote command execution";
   const type = "module";
   const main$3 = "dist/index.js";
@@ -36864,7 +36864,7 @@ Mongoose Error Code: ${error2.code}` : ""}`
   };
   const optionalDependencies = {
     "acp-extension-claude": "0.30.0",
-    "acp-extension-codex": "0.11.2"
+    "acp-extension-codex": "0.12.0"
   };
   const devDependencies = {
     "@agentclientprotocol/sdk": "catalog:",
@@ -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",
@@ -81990,6 +81991,59 @@ ${tailedOutput}` : null;
     gatewayBaseUrl: string$2().url().optional()
   });
   const LORO_STREAMS_TOKEN_REFRESH_SKEW_MS = 3e4;
+  const LORO_STREAMS_TOKEN_STORAGE_KEY_PREFIX = "lody:loroStreamsToken";
+  function getTokenStorageKey(workspaceId) {
+    return `${LORO_STREAMS_TOKEN_STORAGE_KEY_PREFIX}:${workspaceId}`;
+  }
+  function getLocalStorage() {
+    try {
+      const storage = globalThis.localStorage;
+      if (storage && typeof storage.getItem === "function" && typeof storage.setItem === "function" && typeof storage.removeItem === "function") {
+        return storage;
+      }
+    } catch {
+    }
+    return void 0;
+  }
+  function readCachedTokenFromStorage(workspaceId) {
+    const storage = getLocalStorage();
+    if (!storage) return null;
+    try {
+      const raw = storage.getItem(getTokenStorageKey(workspaceId));
+      if (!raw) return null;
+      const parsed = JSON.parse(raw);
+      if (typeof parsed === "object" && parsed !== null && "token" in parsed && typeof parsed.token === "string" && "expiresAtMs" in parsed && typeof parsed.expiresAtMs === "number") {
+        const result = {
+          token: parsed.token,
+          expiresAtMs: parsed.expiresAtMs
+        };
+        const gatewayBaseUrl = parsed.gatewayBaseUrl;
+        if (typeof gatewayBaseUrl === "string") {
+          result.gatewayBaseUrl = gatewayBaseUrl;
+        }
+        return result;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  function writeCachedTokenToStorage(workspaceId, token2) {
+    const storage = getLocalStorage();
+    if (!storage) return;
+    try {
+      storage.setItem(getTokenStorageKey(workspaceId), JSON.stringify(token2));
+    } catch {
+    }
+  }
+  function clearCachedTokenFromStorage(workspaceId) {
+    const storage = getLocalStorage();
+    if (!storage) return;
+    try {
+      storage.removeItem(getTokenStorageKey(workspaceId));
+    } catch {
+    }
+  }
   const buildLoroStreamsTokenEndpoint = (baseUrl) => `${baseUrl.replace(/\/+$/g, "")}/api/loro-streams/token`;
   class LoroStreamsTokenAuthError extends Error {
     constructor(message, status, detail) {
@@ -82002,7 +82056,7 @@ ${tailedOutput}` : null;
   function createLoroStreamsTokenProvider(options) {
     const fetchImpl = options.fetchImpl ?? fetch;
     const refreshSkewMs = options.refreshSkewMs ?? LORO_STREAMS_TOKEN_REFRESH_SKEW_MS;
-    let cached2 = null;
+    let cached2 = readCachedTokenFromStorage(options.workspaceId);
     let inFlight = null;
     let generation = 0;
     const resolveAuthToken = async () => {
@@ -82049,6 +82103,7 @@ ${tailedOutput}` : null;
         inFlight = fetchToken().then((nextToken) => {
           if (generation === fetchGeneration) {
             cached2 = nextToken;
+            writeCachedTokenToStorage(options.workspaceId, nextToken);
           }
           return nextToken;
         }).finally(() => {
@@ -82063,6 +82118,7 @@ ${tailedOutput}` : null;
       cached2 = null;
       inFlight = null;
       generation++;
+      clearCachedTokenFromStorage(options.workspaceId);
     };
     return {
       getToken: async () => {
@@ -89037,8 +89093,20 @@ ${val.stack}`;
       const patchObject = patch2;
       for (const key2 of Object.keys(patchObject)) {
         const rawValue = patchObject[key2];
-        if (rawValue === void 0) continue;
-        if (jsonEquals(base ? base[key2] : void 0, rawValue)) continue;
+        const hadKey = base ? key2 in base : false;
+        if (rawValue === void 0) {
+          if (!hadKey) continue;
+          this.metaFlock.delete([
+            "m",
+            docId,
+            key2
+          ]);
+          delete next[key2];
+          outPatch[key2] = null;
+          changed = true;
+          continue;
+        }
+        if (jsonEquals(hadKey ? base[key2] : void 0, rawValue)) continue;
         this.metaFlock.put([
           "m",
           docId,
@@ -91144,7 +91212,7 @@ ${val.stack}`;
         live: "sse"
       });
       const controller = new AbortController();
-      const signal = mergeAbortSignals(input2.signal, controller.signal);
+      const signal = mergeAbortSignals$2(input2.signal, controller.signal);
       try {
         const response = await this.http.fetchAuthorized(requestUrl, {
           method: "GET",
@@ -91647,7 +91715,7 @@ ${val.stack}`;
       }
     };
   }
-  function mergeAbortSignals(...signals2) {
+  function mergeAbortSignals$2(...signals2) {
     const active2 = signals2.filter((signal) => signal != null);
     if (active2.length === 0) return;
     if (active2.length === 1) return active2[0];
@@ -91666,84 +91734,6 @@ ${val.stack}`;
     }
     return controller.signal;
   }
-  function composeBeforeRemoteCursorSaveHooks(...hooks2) {
-    const active2 = hooks2.filter((hook) => hook != null);
-    if (active2.length === 0) return;
-    return async (context2) => {
-      for (const hook of active2) await hook(context2);
-    };
-  }
-  async function persistRemoteCursor(input2) {
-    const next = {
-      ...input2.cursor,
-      updatedAtMs: (input2.now ?? Date.now)()
-    };
-    if (input2.beforeRemoteCursorSave != null) await input2.beforeRemoteCursorSave({
-      cursor: next,
-      source: input2.source
-    });
-    await input2.remoteCursorStore.save(next);
-    return next;
-  }
-  function key(streamUrl) {
-    return streamUrl;
-  }
-  function cloneJsonValue(value) {
-    return structuredClone(value);
-  }
-  function cloneRemoteCursor(cursor) {
-    return {
-      ...cursor,
-      serverLowerBoundVersion: cloneJsonValue(cursor.serverLowerBoundVersion)
-    };
-  }
-  var InMemoryRemoteCursorStore = class {
-    data = /* @__PURE__ */ new Map();
-    async load(streamUrl) {
-      const value = this.data.get(key(streamUrl));
-      return value == null ? null : cloneRemoteCursor(value);
-    }
-    async save(cursor) {
-      this.data.set(key(cursor.streamUrl), cloneRemoteCursor(cursor));
-    }
-    async delete(streamUrl) {
-      this.data.delete(key(streamUrl));
-    }
-  };
-  function createInitialRemoteCursor(input2) {
-    return {
-      streamUrl: input2.streamUrl,
-      nextOffset: input2.nextOffset,
-      serverLowerBoundVersion: cloneJsonValue(input2.serverLowerBoundVersion),
-      updatedAtMs: Date.now()
-    };
-  }
-  const DEFAULT_RECONNECT_CONFIG = {
-    delays: [
-      0,
-      500,
-      1e3,
-      2e3,
-      4e3,
-      8e3,
-      15e3
-    ],
-    jitterFraction: 0.2,
-    maxAttempts: Infinity,
-    connectTimeoutMs: 1e4,
-    pollTimeoutMs: 3e4,
-    liveInactivityTimeoutMs: 45e3
-  };
-  function applyJitter(baseMs, fraction) {
-    if (baseMs === 0) return 0;
-    const jitter = baseMs * fraction * (2 * Math.random() - 1);
-    return Math.max(0, Math.round(baseMs + jitter));
-  }
-  function computeRetryDelay(attempt, config2 = DEFAULT_RECONNECT_CONFIG) {
-    const { delays, jitterFraction } = config2;
-    const base = delays[Math.min(attempt, delays.length - 1)];
-    return applyJitter(base, jitterFraction);
-  }
   const DEFAULT_COMPACT_THRESHOLD = 64;
   const DEFAULT_MIN_CAPACITY = 16;
   var Deque = class {
@@ -91863,6 +91853,32 @@ ${val.stack}`;
       this.tail = length2;
     }
   };
+  const DEFAULT_RECONNECT_CONFIG = {
+    delays: [
+      0,
+      500,
+      1e3,
+      2e3,
+      4e3,
+      8e3,
+      15e3
+    ],
+    jitterFraction: 0.2,
+    maxAttempts: Infinity,
+    connectTimeoutMs: 1e4,
+    pollTimeoutMs: 3e4,
+    liveInactivityTimeoutMs: 45e3
+  };
+  function applyJitter(baseMs, fraction) {
+    if (baseMs === 0) return 0;
+    const jitter = baseMs * fraction * (2 * Math.random() - 1);
+    return Math.max(0, Math.round(baseMs + jitter));
+  }
+  function computeRetryDelay(attempt, config2 = DEFAULT_RECONNECT_CONFIG) {
+    const { delays, jitterFraction } = config2;
+    const base = delays[Math.min(attempt, delays.length - 1)];
+    return applyJitter(base, jitterFraction);
+  }
   const BINARY_CONTENT_TYPE = "application/octet-stream";
   function encodeItems(items) {
     const total = items.reduce((sum, item) => sum + 4 + item.byteLength, 0);
@@ -92305,6 +92321,25 @@ stream:${scope2.streamId}`;
       });
     });
   }
+  function mergeAbortSignals(...signals2) {
+    const active2 = signals2.filter((signal) => signal != null);
+    if (active2.length === 0) return;
+    if (active2.length === 1) return active2[0];
+    if (typeof AbortSignal.any === "function") return AbortSignal.any(active2);
+    const controller = new AbortController();
+    for (const signal of active2) {
+      if (signal.aborted) {
+        controller.abort(signal.reason);
+        break;
+      }
+      signal.addEventListener("abort", () => {
+        controller.abort(signal.reason);
+      }, {
+        once: true
+      });
+    }
+    return controller.signal;
+  }
   function classifyFetchError(err2) {
     const message = err2 instanceof Error ? err2.message : String(err2);
     const status = err2 instanceof HttpError ? err2.status : void 0;
@@ -92508,7 +92543,10 @@ stream:${scope2.streamId}`;
     streamUrl;
     adapter;
     client;
+    fetchImpl;
+    authProvider;
     reconnectConfig;
+    authRefreshInFlight;
     constructor(options) {
       this.streamUrl = options.streamUrl;
       this.adapter = options.adapter;
@@ -92524,6 +92562,8 @@ stream:${scope2.streamId}`;
           pollTimeoutMs: options.reconnectConfig.pollTimeoutMs
         }
       });
+      this.fetchImpl = options.fetchImpl;
+      this.authProvider = options.authProvider;
       this.reconnectConfig = options.reconnectConfig;
     }
     async createStreamRequest() {
@@ -92625,6 +92665,166 @@ stream:${scope2.streamId}`;
       };
       throw this.toTransportFailure(error2);
     }
+    async appendItems(updates) {
+      const result = await this.client.append({
+        part: {
+          contentType: BINARY_CONTENT_TYPE,
+          body: encodeItems(updates)
+        }
+      });
+      if (result.ok) return result.result.nextOffset;
+      throw this.toTransportFailure(result.result);
+    }
+    async appendEphemeralUpdate(update2, signal) {
+      if (update2.byteLength === 0) return;
+      const response = await this.fetchAuthorized(this.streamUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": BINARY_CONTENT_TYPE
+        },
+        body: update2,
+        signal
+      }, this.reconnectConfig.connectTimeoutMs, "connect");
+      if (response.status === 200 || response.status === 204) return;
+      throw await this.responseToEphemeralFailure(response, "ephemeral append");
+    }
+    async readEphemeralSse(onBootstrap, onData, signal) {
+      const requestUrl = this.ephemeralReadEndpoint();
+      const response = await this.fetchAuthorized(requestUrl, {
+        method: "GET",
+        headers: {
+          Accept: "text/event-stream"
+        },
+        signal
+      }, this.reconnectConfig.connectTimeoutMs, "connect");
+      if (response.status === 404) return {
+        kind: "not-found"
+      };
+      if (!response.ok) {
+        if (response.status === 400) {
+          const message = await response.text();
+          if (isSseUnsupportedErrorText(message)) return {
+            kind: "unsupported"
+          };
+          throw new HttpError(message.length > 0 ? `ephemeral live read failed: ${message}` : "ephemeral live read failed", response.status);
+        }
+        throw await this.responseToEphemeralFailure(response, "ephemeral live read");
+      }
+      if (response.body == null) throw new ProtocolError("ephemeral sse response missing body");
+      if (!(response.headers.get("Content-Type") ?? "").toLowerCase().includes("text/event-stream")) throw new ProtocolError("ephemeral sse response must use text/event-stream content type");
+      const dataEncoding = response.headers.get("Stream-SSE-Data-Encoding") ?? void 0;
+      const consume = async () => {
+        let sawBootstrap = false;
+        for await (const event of readSseEvents(response.body)) {
+          if (!sawBootstrap) {
+            if (event.event !== "bootstrap") throw new ProtocolError(`ephemeral sse must start with bootstrap, got '${event.event}'`);
+            await onBootstrap(decodeSsePayload(event.data, dataEncoding));
+            sawBootstrap = true;
+            continue;
+          }
+          if (event.event === "data") {
+            await onData(decodeSsePayload(event.data, dataEncoding));
+            continue;
+          }
+          throw new ProtocolError(`unexpected ephemeral sse event '${event.event}'`);
+        }
+        if (!sawBootstrap) throw new ProtocolError("ephemeral sse ended before bootstrap");
+        return {
+          kind: "ok"
+        };
+      };
+      let abortHandler;
+      const abortRace = signal != null && !signal.aborted ? new Promise((_2, reject) => {
+        abortHandler = () => {
+          response.body?.cancel().catch(() => {
+          });
+          reject(signal.reason ?? new DOMException("The operation was aborted.", "AbortError"));
+        };
+        signal.addEventListener("abort", abortHandler, {
+          once: true
+        });
+      }) : null;
+      try {
+        if (signal?.aborted) {
+          await response.body.cancel().catch(() => {
+          });
+          throw signal.reason ?? new DOMException("The operation was aborted.", "AbortError");
+        }
+        return abortRace == null ? await consume() : await Promise.race([
+          consume(),
+          abortRace
+        ]);
+      } finally {
+        if (abortHandler != null && signal != null) signal.removeEventListener("abort", abortHandler);
+      }
+    }
+    async fetchAuthorized(input2, init2, timeoutMs, phase) {
+      const firstToken = await this.resolveToken({
+        reason: "request"
+      });
+      const firstResponse = await this.fetchWithTimeout(input2, {
+        ...init2,
+        headers: this.attachAuthorization(init2.headers, firstToken)
+      }, timeoutMs, phase);
+      if (this.authProvider == null || firstResponse.status !== 401 && firstResponse.status !== 403) return firstResponse;
+      await firstResponse.body?.cancel().catch(() => {
+      });
+      const refreshedToken = await this.refreshTokenAfterFailure(firstResponse.status, firstToken);
+      return this.fetchWithTimeout(input2, {
+        ...init2,
+        headers: this.attachAuthorization(init2.headers, refreshedToken)
+      }, timeoutMs, phase);
+    }
+    async fetchWithTimeout(input2, init2, timeoutMs, phase) {
+      const controller = new AbortController();
+      const signal = mergeAbortSignals(init2.signal, controller.signal);
+      const timer2 = setTimeout(() => {
+        controller.abort(new TimeoutError(phase, timeoutMs));
+      }, timeoutMs);
+      try {
+        return await this.fetchImpl(input2, {
+          ...init2,
+          signal
+        });
+      } catch (error2) {
+        if (controller.signal.aborted && controller.signal.reason instanceof TimeoutError) throw controller.signal.reason;
+        throw error2;
+      } finally {
+        clearTimeout(timer2);
+      }
+    }
+    async resolveToken(context2) {
+      return await this.authProvider?.(context2);
+    }
+    async refreshTokenAfterFailure(status, previousToken) {
+      if (this.authProvider == null) return;
+      if (this.authRefreshInFlight == null) this.authRefreshInFlight = this.resolveToken({
+        reason: "unauthorized",
+        status,
+        previousToken
+      }).finally(() => {
+        this.authRefreshInFlight = void 0;
+      });
+      return await this.authRefreshInFlight;
+    }
+    attachAuthorization(base, token2) {
+      const headers = new Headers(base);
+      if (token2 == null || token2.length === 0) {
+        headers.delete("Authorization");
+        return headers;
+      }
+      headers.set("Authorization", `Bearer ${token2}`);
+      return headers;
+    }
+    async responseToEphemeralFailure(response, context2) {
+      const message = await response.text().catch(() => "");
+      return new HttpError(message.length > 0 ? `${context2} failed: ${message}` : `${context2} failed with status ${response.status}`, response.status);
+    }
+    ephemeralReadEndpoint() {
+      const target = new URL(this.streamUrl);
+      target.searchParams.set("live", "sse");
+      return target.toString();
+    }
     toTransportFailure(error2) {
       switch (error2.code) {
         case "bad_request":
@@ -92766,6 +92966,58 @@ stream:${scope2.streamId}`;
       };
     }
   };
+  function composeBeforeRemoteCursorSaveHooks(...hooks2) {
+    const active2 = hooks2.filter((hook) => hook != null);
+    if (active2.length === 0) return;
+    return async (context2) => {
+      for (const hook of active2) await hook(context2);
+    };
+  }
+  async function persistRemoteCursor(input2) {
+    const next = {
+      ...input2.cursor,
+      updatedAtMs: (input2.now ?? Date.now)()
+    };
+    if (input2.beforeRemoteCursorSave != null) await input2.beforeRemoteCursorSave({
+      cursor: next,
+      source: input2.source
+    });
+    await input2.remoteCursorStore.save(next);
+    return next;
+  }
+  function key(streamUrl) {
+    return streamUrl;
+  }
+  function cloneJsonValue(value) {
+    return structuredClone(value);
+  }
+  function cloneRemoteCursor(cursor) {
+    return {
+      ...cursor,
+      serverLowerBoundVersion: cloneJsonValue(cursor.serverLowerBoundVersion)
+    };
+  }
+  var InMemoryRemoteCursorStore = class {
+    data = /* @__PURE__ */ new Map();
+    async load(streamUrl) {
+      const value = this.data.get(key(streamUrl));
+      return value == null ? null : cloneRemoteCursor(value);
+    }
+    async save(cursor) {
+      this.data.set(key(cursor.streamUrl), cloneRemoteCursor(cursor));
+    }
+    async delete(streamUrl) {
+      this.data.delete(key(streamUrl));
+    }
+  };
+  function createInitialRemoteCursor(input2) {
+    return {
+      streamUrl: input2.streamUrl,
+      nextOffset: input2.nextOffset,
+      serverLowerBoundVersion: cloneJsonValue(input2.serverLowerBoundVersion),
+      updatedAtMs: Date.now()
+    };
+  }
   var TransportCursorManager = class {
     adapter;
     decodeSnapshot;
@@ -93023,6 +93275,8 @@ stream:${scope2.streamId}`;
     producerId = createProducerId();
     producerEpoch = 0;
     nextProducerSeq = 0;
+    frozenLocalAppend;
+    committedPendingCount;
     pendingWriteOnly = new Deque();
     writeOnlyCursor;
     unsubscribeWriteOnlyLocal;
@@ -93202,6 +93456,8 @@ stream:${scope2.streamId}`;
               await this.remoteCursorStore.delete?.(this.streamUrl);
               this.producerEpoch = 0;
               this.nextProducerSeq = 0;
+              this.frozenLocalAppend = void 0;
+              this.committedPendingCount = void 0;
               return deleted;
             })
           }
@@ -93242,15 +93498,17 @@ stream:${scope2.streamId}`;
               localVersion: this.writeOnlyCursor.serverLowerBoundVersion
             }
           };
-          const nextCursor = await this.appendLocalBatch(this.writeOnlyCursor, drained.batch, false);
-          for (let i2 = 0; i2 < drained.count; i2 += 1) this.pendingWriteOnly.popFront();
-          this.writeOnlyCursor = nextCursor;
+          const appended = await this.appendLocalBatchRemote(this.writeOnlyCursor, drained.batch, drained.count, "write-only");
+          const committedCount = appended.pendingCount ?? drained.count;
+          for (let i2 = 0; i2 < committedCount; i2 += 1) this.pendingWriteOnly.popFront();
+          this.writeOnlyCursor = appended.cursor;
+          this.commitProducerAck(appended.producerAck);
           return {
             ok: true,
             value: {
               appended: true,
-              nextOffset: nextCursor.nextOffset,
-              localVersion: nextCursor.serverLowerBoundVersion
+              nextOffset: appended.cursor.nextOffset,
+              localVersion: appended.cursor.serverLowerBoundVersion
             }
           };
         } catch (error2) {
@@ -93425,7 +93683,7 @@ stream:${scope2.streamId}`;
       }
     }
     async syncOnce() {
-      let cursor = (await this.resolveInitialRemoteState()).cursor;
+      let cursor = (await this.finalizeDirectLocalAppendIfNeeded(await this.resolveInitialRemoteState())).cursor;
       const localBatch = this.exportUpdates(cursor.serverLowerBoundVersion);
       if (localBatch.batch != null) {
         cursor = await this.appendLocalBatch(cursor, localBatch.batch);
@@ -93434,7 +93692,7 @@ stream:${scope2.streamId}`;
       return cursor;
     }
     async performInitialJoinSync(preferredLiveMode) {
-      const initial = await this.resolveInitialRemoteState();
+      const initial = await this.finalizeDirectLocalAppendIfNeeded(await this.resolveInitialRemoteState());
       let cursor = initial.cursor;
       let localExportRefVersion = cursor.serverLowerBoundVersion;
       let streamCursor = initial.streamCursor;
@@ -93534,17 +93792,52 @@ stream:${scope2.streamId}`;
         };
       }
     }
-    async appendLocalBatch(cursor, batch, persist = true) {
-      let producerSession = {
-        producerId: this.producerId,
-        producerEpoch: this.producerEpoch,
-        nextProducerSeq: this.nextProducerSeq
+    async appendLocalBatch(cursor, batch, pendingCount) {
+      const source = pendingCount == null ? "direct" : "pending";
+      const committed = await this.appendLocalBatchDurably(cursor, batch, pendingCount, source);
+      this.committedPendingCount = committed.pendingCount;
+      return committed.cursor;
+    }
+    async appendLocalBatchDurably(cursor, batch, pendingCount, source = pendingCount == null ? "direct" : "pending") {
+      const frozen = await this.getOrCreateFrozenLocalAppend(cursor, batch, pendingCount, source);
+      const appended = await this.appendFrozenLocalBatchRemote(frozen);
+      const saved = await this.saveRemoteCursor(appended.cursor, "local");
+      this.commitProducerAck(appended.producerAck);
+      return {
+        cursor: saved,
+        pendingCount: frozen.pendingCount
       };
+    }
+    async appendLocalBatchRemote(cursor, batch, pendingCount, source = pendingCount == null ? "direct" : "pending") {
+      const frozen = await this.getOrCreateFrozenLocalAppend(cursor, batch, pendingCount, source);
+      return {
+        ...await this.appendFrozenLocalBatchRemote(frozen),
+        pendingCount: frozen.pendingCount
+      };
+    }
+    async getOrCreateFrozenLocalAppend(cursor, batch, pendingCount, source = pendingCount == null ? "direct" : "pending") {
+      const existing = this.frozenLocalAppend;
+      if (existing != null) {
+        if (existing.source !== source) throw new Error(`${existing.source} local append must be finalized before ${source} append`);
+        return existing;
+      }
+      const frozen = {
+        source,
+        baseCursor: cursor,
+        batch,
+        pendingCount,
+        wireUpdates: this.encodeUpdateItems == null ? batch.updates : await this.encodeUpdateItems(batch.updates),
+        producerSession: this.createCurrentProducerSession()
+      };
+      this.frozenLocalAppend = frozen;
+      return frozen;
+    }
+    async appendFrozenLocalBatchRemote(frozen) {
+      if (frozen.acknowledged != null) return frozen.acknowledged;
       for (let attempt = 0; attempt < 3; attempt += 1) {
         let result;
         try {
-          const wireUpdates = this.encodeUpdateItems == null ? batch.updates : await this.encodeUpdateItems(batch.updates);
-          result = await this.client.appendUpdates(wireUpdates, producerSession);
+          result = await this.client.appendUpdates(frozen.wireUpdates, frozen.producerSession);
         } catch (error2) {
           if (isStreamNotFoundError(error2) && this.createStreamIfMissing) {
             await this.ensureStreamExists();
@@ -93553,30 +93846,66 @@ stream:${scope2.streamId}`;
           throw error2;
         }
         if (result.kind === "ok") {
-          this.producerEpoch = result.ackEpoch;
-          this.nextProducerSeq = result.ackSeq + 1;
-          const next = {
-            ...cursor,
-            nextOffset: result.nextOffset,
-            serverLowerBoundVersion: this.adapter.mergeVersions(cursor.serverLowerBoundVersion, batch.version)
+          const appended = {
+            cursor: {
+              ...frozen.baseCursor,
+              nextOffset: result.nextOffset,
+              serverLowerBoundVersion: this.adapter.mergeVersions(frozen.baseCursor.serverLowerBoundVersion, frozen.batch.version)
+            },
+            producerAck: {
+              epoch: result.ackEpoch,
+              seq: result.ackSeq
+            }
           };
-          return persist ? await this.saveRemoteCursor(next, "local") : next;
+          frozen.acknowledged = appended;
+          return appended;
         }
         if (result.kind === "seq-gap") {
-          producerSession = {
-            ...producerSession,
+          frozen.producerSession = {
+            ...frozen.producerSession,
             nextProducerSeq: result.expectedSeq
           };
           continue;
         }
-        producerSession = {
-          ...producerSession,
+        frozen.producerSession = {
+          ...frozen.producerSession,
           producerEpoch: result.serverEpoch + 1,
           nextProducerSeq: 0
         };
       }
       throw new Error("append retry budget exhausted");
     }
+    async finalizeDirectLocalAppendIfNeeded(state2) {
+      const frozen = this.frozenLocalAppend;
+      if (frozen == null || frozen.pendingCount != null) return state2;
+      const appended = await this.appendFrozenLocalBatchRemote(frozen);
+      const saved = await this.saveRemoteCursor(appended.cursor, "local");
+      this.commitProducerAck(appended.producerAck);
+      return await this.catchup(saved, void 0, state2.streamCursor);
+    }
+    createCurrentProducerSession() {
+      return {
+        producerId: this.producerId,
+        producerEpoch: this.producerEpoch,
+        nextProducerSeq: this.nextProducerSeq
+      };
+    }
+    commitProducerAck(ack) {
+      this.producerEpoch = ack.epoch;
+      this.nextProducerSeq = ack.seq + 1;
+      this.frozenLocalAppend = void 0;
+    }
+    abandonFrozenLocalAppend(frozen) {
+      if (this.frozenLocalAppend !== frozen) return;
+      this.frozenLocalAppend = void 0;
+      this.producerEpoch = Math.max(this.producerEpoch, frozen.producerSession.producerEpoch + 1);
+      this.nextProducerSeq = 0;
+    }
+    consumeCommittedPendingCount() {
+      const count2 = this.committedPendingCount;
+      this.committedPendingCount = void 0;
+      return count2;
+    }
     async ensureStreamExists() {
       try {
         await this.client.createStreamRequest();
@@ -93621,9 +93950,17 @@ stream:${scope2.streamId}`;
       const inferredRemote = await this.bootstrapState(bootstrapCursor, {
         cursorManager
       });
-      const localBatch = this.exportUpdates(inferredRemote.cursor.serverLowerBoundVersion);
-      if (localBatch.batch != null) await this.appendLocalBatch(inferredRemote.cursor, localBatch.batch, false);
-      return await this.bootstrapState(bootstrapCursor);
+      let pendingAppend;
+      if (this.frozenLocalAppend != null) {
+        if (this.frozenLocalAppend.pendingCount != null) throw new Error("pending local append must be finalized by pending flush");
+        pendingAppend = await this.appendFrozenLocalBatchRemote(this.frozenLocalAppend);
+      } else {
+        const localBatch = this.exportUpdates(inferredRemote.cursor.serverLowerBoundVersion);
+        if (localBatch.batch != null) pendingAppend = await this.appendLocalBatchRemote(inferredRemote.cursor, localBatch.batch);
+      }
+      const result = await this.bootstrapState(bootstrapCursor);
+      if (pendingAppend != null) this.commitProducerAck(pendingAppend.producerAck);
+      return result;
     }
     async recoverFromGoneWithLocalBootstrap(cursor) {
       const isolatedCursorManager = await this.createIsolatedCursorManager();
@@ -93641,9 +93978,17 @@ stream:${scope2.streamId}`;
         });
         await this.adapter.applySnapshot(preservedLocalSnapshot);
         restoredLocalSnapshot = true;
-        const localBatch = this.exportUpdates(inferredRemote.cursor.serverLowerBoundVersion);
-        if (localBatch.batch != null) await this.appendLocalBatch(inferredRemote.cursor, localBatch.batch, false);
-        return await this.bootstrapState(bootstrapCursor);
+        let pendingAppend;
+        if (this.frozenLocalAppend != null) {
+          if (this.frozenLocalAppend.pendingCount != null) throw new Error("pending local append must be finalized by pending flush");
+          pendingAppend = await this.appendFrozenLocalBatchRemote(this.frozenLocalAppend);
+        } else {
+          const localBatch = this.exportUpdates(inferredRemote.cursor.serverLowerBoundVersion);
+          if (localBatch.batch != null) pendingAppend = await this.appendLocalBatchRemote(inferredRemote.cursor, localBatch.batch);
+        }
+        const result = await this.bootstrapState(bootstrapCursor);
+        if (pendingAppend != null) this.commitProducerAck(pendingAppend.producerAck);
+        return result;
       } catch (error2) {
         if (!restoredLocalSnapshot) await this.adapter.applySnapshot(preservedLocalSnapshot);
         throw error2;
@@ -93855,7 +94200,6 @@ stream:${scope2.streamId}`;
       let mergedVersion = first2.version;
       const allUpdates = Array.from(first2.updates);
       let count2 = 1;
-      await this.measureAppendBodyByteLength(allUpdates);
       while (count2 < pendingLocal.length) {
         const next = pendingLocal.at(count2);
         const candidateUpdates = [
@@ -93894,9 +94238,10 @@ stream:${scope2.streamId}`;
           if (drained == null) return;
           let attempts = 0;
           while (!state2.closed) try {
-            state2.cursor = await this.enqueueExclusive(async () => this.appendLocalBatch(state2.cursor, drained.batch));
-            for (let i2 = 0; i2 < drained.count; i2 += 1) state2.pendingLocal.popFront();
-            this.notifySyncWaiters(state2, drained.count);
+            state2.cursor = await this.enqueueExclusive(async () => this.appendLocalBatch(state2.cursor, drained.batch, drained.count));
+            const committedCount = this.consumeCommittedPendingCount() ?? drained.count;
+            for (let i2 = 0; i2 < committedCount; i2 += 1) state2.pendingLocal.popFront();
+            this.notifySyncWaiters(state2, committedCount);
             this.setWriteSubStatus(state2, "ok");
             this.snapshotManager.schedule(state2);
             break;
@@ -93986,6 +94331,8 @@ stream:${scope2.streamId}`;
       return updates.reduce((sum, update2) => sum + 4 + update2.byteLength, 0);
     }
     disableWriteOnlyMode(reason) {
+      const frozen = this.frozenLocalAppend;
+      if (frozen?.source === "write-only") this.abandonFrozenLocalAppend(frozen);
       if (this.writeOnlyDisabledReason != null) return;
       this.writeOnlyDisabledReason = reason;
       this.pendingWriteOnly.clear();
@@ -112230,6 +112577,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 +113779,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;
     }
@@ -113879,6 +114232,34 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
     async waitForRemoteSync() {
       await this.remoteSyncReady;
     }
+    async ensureDocRoomJoined() {
+      if (this.destroyed) {
+        return;
+      }
+      if (!this.docSub) {
+        this.remoteSyncReady = this.startDocRoomSync();
+      }
+      await this.remoteSyncReady;
+    }
+    getDocRoomStatus() {
+      return this.docSub?.status;
+    }
+    onDocRoomStatusChange(listener) {
+      return this.docSub?.onStatusChange(listener) ?? (() => {
+      });
+    }
+    async rejoinDocRoom() {
+      if (this.destroyed) {
+        return;
+      }
+      if (!this.docSub) {
+        await this.ensureDocRoomJoined();
+        return;
+      }
+      if (this.docSub.rejoin) {
+        await this.docSub.rejoin();
+      }
+    }
     async initOffline(initialState) {
       this.destroyed = false;
       this.handle = await this.repo.openPersistedDoc(this.roomId);
@@ -116891,7 +117272,7 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
     },
     codex: {
       packageName: "acp-extension-codex",
-      version: "0.11.2",
+      version: "0.12.0",
       binName: "acp-extension-codex",
       args: [
         "-c",
@@ -120182,6 +120563,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") {
@@ -120202,6 +120798,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) {
@@ -120237,6 +120834,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,
@@ -120419,10 +121056,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,
@@ -120446,7 +121092,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);
@@ -120782,8 +121428,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) {
@@ -120832,34 +121477,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) {
@@ -120953,15 +121595,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);
@@ -121298,7 +121943,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;
@@ -121311,6 +121956,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;
@@ -121334,12 +121983,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,
@@ -121360,6 +122003,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);
       }
@@ -121853,9 +122501,6 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
     watchedSessions = /* @__PURE__ */ new Map();
     sessionCheckChains = /* @__PURE__ */ new Map();
     cancelCheckChains = /* @__PURE__ */ new Map();
-    dispatchRetryTimers = /* @__PURE__ */ new Map();
-    dispatchRetryAttempts = /* @__PURE__ */ new Map();
-    dispatchRetryStartedAt = /* @__PURE__ */ new Map();
     cancelSeenTurn = /* @__PURE__ */ new Map();
     metadataWatchHandle = null;
     userResolver;
@@ -121899,15 +122544,9 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       for (const watched of this.watchedSessions.values()) {
         watched.unsubscribe();
       }
-      for (const timer2 of this.dispatchRetryTimers.values()) {
-        clearTimeout(timer2);
-      }
       this.watchedSessions.clear();
       this.sessionCheckChains.clear();
       this.cancelCheckChains.clear();
-      this.dispatchRetryTimers.clear();
-      this.dispatchRetryAttempts.clear();
-      this.dispatchRetryStartedAt.clear();
       this.cancelSeenTurn.clear();
       this.userResolver.clear();
       this.started = false;
@@ -121983,14 +122622,15 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       }));
     }
     async reconcileSessionWatch(sessionId) {
-      const meta = await this.readSessionMeta(sessionId);
+      const roomId = getSessionRoomId(sessionId);
+      const record2 = await this.deps.workspaceDocument.repo.getDocMeta(roomId);
+      const meta = isLoroRepoDocDeleted(record2) ? void 0 : record2?.meta;
       const isOwned = meta?.machineId === this.deps.machineId && !meta?.isArchived;
       if (!isOwned) {
         const watched = this.watchedSessions.get(sessionId);
         watched?.unsubscribe();
         this.watchedSessions.delete(sessionId);
         this.cancelCheckChains.delete(sessionId);
-        this.clearDispatchRetry(sessionId);
         this.cancelSeenTurn.delete(sessionId);
         return;
       }
@@ -122001,7 +122641,6 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
           this.watchedSessions.delete(sessionId);
           this.deps.logger.debug(`[${sessionId}] Unwatching idle session (no pending work)`);
         }
-        this.clearDispatchRetry(sessionId);
         return;
       }
       if (!this.watchedSessions.has(sessionId)) {
@@ -122018,11 +122657,6 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       this.enqueueCancelCheck(sessionId);
       this.enqueueSessionCheck(sessionId);
     }
-    async readSessionMeta(sessionId) {
-      const roomId = getSessionRoomId(sessionId);
-      const record2 = await this.deps.workspaceDocument.repo.getDocMeta(roomId);
-      return isLoroRepoDocDeleted(record2) ? void 0 : record2?.meta;
-    }
     sessionNeedsActiveWatch(meta) {
       const statusType = meta.status?.type;
       if (statusType === "running" || statusType === "initializing" || statusType === "requestPermission") {
@@ -122037,155 +122671,11 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       if (meta.lastCanceledTurn && meta.lastCanceledTurn !== this.cancelSeenTurn.get(meta.id)) {
         return true;
       }
-      if (this.isDispatchRecoveryUnhealthy(meta)) {
-        return false;
-      }
       if (!meta.lastHandledUserMsgId) {
         return true;
       }
       return false;
     }
-    static RECOVERABLE_DISPATCH_RETRY_INITIAL_DELAY_MS = 1e3;
-    static RECOVERABLE_DISPATCH_RETRY_MAX_DELAY_MS = 6e4;
-    static RECOVERABLE_DISPATCH_RETRY_MAX_ELAPSED_MS = 5 * 6e4;
-    static DISPATCH_RECOVERY_UNHEALTHY_CODE = "dispatch_recovery_unhealthy";
-    hasRecoverableDispatchSignal(meta) {
-      const statusType = meta.status?.type;
-      if (statusType === "running" || statusType === "initializing" || statusType === "requestPermission") {
-        return true;
-      }
-      if (meta.processingUserMsgId) {
-        return true;
-      }
-      return !!meta.latestUserMsgId && meta.latestUserMsgId !== meta.lastHandledUserMsgId;
-    }
-    isDispatchRecoveryUnhealthy(meta) {
-      return meta.dispatchError?.code === SessionDispatchWatcher.DISPATCH_RECOVERY_UNHEALTHY_CODE;
-    }
-    clearDispatchRetry(sessionId) {
-      const timer2 = this.dispatchRetryTimers.get(sessionId);
-      if (timer2) {
-        clearTimeout(timer2);
-        this.dispatchRetryTimers.delete(sessionId);
-      }
-      this.dispatchRetryAttempts.delete(sessionId);
-      this.dispatchRetryStartedAt.delete(sessionId);
-    }
-    scheduleRecoverableDispatchRetry(sessionId, meta) {
-      if (!this.hasRecoverableDispatchSignal(meta)) {
-        this.clearDispatchRetry(sessionId);
-        return;
-      }
-      if (this.dispatchRetryTimers.has(sessionId)) {
-        return;
-      }
-      const startedAt = this.dispatchRetryStartedAt.get(sessionId) ?? Date.now();
-      this.dispatchRetryStartedAt.set(sessionId, startedAt);
-      const elapsedMs = Date.now() - startedAt;
-      if (elapsedMs >= SessionDispatchWatcher.RECOVERABLE_DISPATCH_RETRY_MAX_ELAPSED_MS) {
-        void this.markDispatchRecoveryUnhealthy(sessionId, meta, elapsedMs).catch((error2) => {
-          this.deps.logger.error(`[${sessionId}] Failed to mark dispatch recovery unhealthy: ${formatErrorMessage(error2)}`);
-        });
-        return;
-      }
-      const attempt = this.dispatchRetryAttempts.get(sessionId) ?? 0;
-      const delayMs = this.calculateRecoverableDispatchRetryDelay(attempt);
-      const attemptNumber = attempt + 1;
-      this.dispatchRetryAttempts.set(sessionId, attemptNumber);
-      this.deps.logger.debug(`[${sessionId}] Dispatch metadata is present but no user turn is visible; rebuilding session doc watch in ${delayMs}ms (attempt=${attemptNumber}, elapsedMs=${elapsedMs})`);
-      const timer2 = setTimeout(() => {
-        this.dispatchRetryTimers.delete(sessionId);
-        if (!this.started) {
-          return;
-        }
-        this.refreshSessionDocWatch(sessionId, `recoverable-dispatch-missing-turn:${attemptNumber}`).catch((error2) => {
-          void this.handleDispatchRetryRefreshFailure(sessionId, meta, error2);
-        });
-      }, delayMs);
-      const maybeUnrefTimer = timer2;
-      maybeUnrefTimer.unref?.();
-      this.dispatchRetryTimers.set(sessionId, timer2);
-    }
-    calculateRecoverableDispatchRetryDelay(attempt) {
-      const exponentialDelayMs = Math.min(SessionDispatchWatcher.RECOVERABLE_DISPATCH_RETRY_INITIAL_DELAY_MS * 2 ** attempt, SessionDispatchWatcher.RECOVERABLE_DISPATCH_RETRY_MAX_DELAY_MS);
-      const halfDelayMs = exponentialDelayMs / 2;
-      return Math.floor(halfDelayMs + Math.random() * halfDelayMs);
-    }
-    async handleDispatchRetryRefreshFailure(sessionId, previousMeta, error2) {
-      this.deps.logger.error(`[${sessionId}] Failed to refresh session doc watch for dispatch retry: ${formatErrorMessage(error2)}`);
-      if (!this.started) {
-        return;
-      }
-      let meta = previousMeta;
-      try {
-        const freshMeta = await this.readSessionMeta(sessionId);
-        if (!freshMeta) {
-          this.clearDispatchRetry(sessionId);
-          return;
-        }
-        meta = freshMeta;
-      } catch (metaError) {
-        this.deps.logger.debug(`[${sessionId}] Failed to read fresh metadata after dispatch retry refresh failure; using previous retry signal: ${formatErrorMessage(metaError)}`);
-      }
-      if (!this.started) {
-        return;
-      }
-      if (meta.machineId !== this.deps.machineId || meta.isArchived) {
-        this.clearDispatchRetry(sessionId);
-        return;
-      }
-      this.scheduleRecoverableDispatchRetry(sessionId, meta);
-    }
-    async markDispatchRecoveryUnhealthy(sessionId, previousMeta, elapsedMs) {
-      this.clearDispatchRetry(sessionId);
-      if (!this.started) {
-        return;
-      }
-      let meta = previousMeta;
-      try {
-        const freshMeta = await this.readSessionMeta(sessionId);
-        if (!freshMeta) {
-          return;
-        }
-        meta = freshMeta;
-      } catch (error2) {
-        this.deps.logger.debug(`[${sessionId}] Failed to read fresh metadata before marking dispatch recovery unhealthy; using previous retry signal: ${formatErrorMessage(error2)}`);
-      }
-      if (!this.hasRecoverableDispatchSignal(meta) || meta.machineId !== this.deps.machineId || meta.isArchived) {
-        return;
-      }
-      this.deps.logger.warn(`[${sessionId}] Dispatch recovery could not find a user turn after ${elapsedMs}ms; marking recovery unhealthy`);
-      await this.deps.workspaceDocument.repo.upsertDocMeta?.(getSessionRoomId(sessionId), {
-        status: SessionStatusFactory.idle(),
-        latestUserMsgId: void 0,
-        processingUserMsgId: void 0,
-        dispatchError: {
-          code: SessionDispatchWatcher.DISPATCH_RECOVERY_UNHEALTHY_CODE,
-          message: "Dispatch recovery could not reconnect to this session after 5 minutes. Send a new message to retry.",
-          at: getServerNow()
-        }
-      });
-      const watched = this.watchedSessions.get(sessionId);
-      watched?.unsubscribe();
-      this.watchedSessions.delete(sessionId);
-      this.sessionCheckChains.delete(sessionId);
-      await this.deps.workspaceDocument.cleanSessionDoc(sessionId, {
-        preserveStatus: true
-      });
-    }
-    async refreshSessionDocWatch(sessionId, reason) {
-      const watched = this.watchedSessions.get(sessionId);
-      watched?.unsubscribe();
-      this.watchedSessions.delete(sessionId);
-      this.deps.logger.debug(`[${sessionId}] Refreshing session doc watch (${reason})`);
-      await this.deps.workspaceDocument.cleanSessionDoc(sessionId, {
-        preserveStatus: true
-      });
-      if (!this.started) {
-        return;
-      }
-      await this.reconcileSessionWatch(sessionId);
-    }
     async maybeHandleSession(sessionId) {
       const sessionDoc = await this.deps.workspaceDocument.getOrCreateSessionDoc(sessionId);
       const meta = await sessionDoc.getMetaState();
@@ -122208,10 +122698,11 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       }
       const nextUserTurn = await this.findOrAwaitDispatchableTurn(sessionId, sessionDoc, meta);
       if (!nextUserTurn) {
-        this.scheduleRecoverableDispatchRetry(sessionId, meta);
+        if (this.hasPendingUserTurnSignal(meta)) {
+          await this.markMissingUserTurnRecovery(sessionId, meta);
+        }
         return;
       }
-      this.clearDispatchRetry(sessionId);
       const freshMeta = await sessionDoc.getMetaState();
       if (!freshMeta) {
         return;
@@ -122275,12 +122766,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());
     }
@@ -122407,6 +122893,26 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
     }
     static REALTIME_WAIT_TIMEOUT_MS = 3e4;
     static REMOTE_SYNC_TIMEOUT_MS = 15e3;
+    static HISTORY_SYNC_WAIT_TIMEOUT_MS = 5 * 6e4;
+    static HISTORY_RECONNECT_JITTER_MIN_MS = 500;
+    static HISTORY_RECONNECT_JITTER_MAX_MS = 1500;
+    static setUnrefTimeout(callback, delayMs) {
+      const timer2 = setTimeout(callback, delayMs);
+      if (typeof timer2 === "object" && "unref" in timer2) {
+        timer2.unref();
+      }
+      return timer2;
+    }
+    static sleep(delayMs) {
+      return new Promise((resolve2) => {
+        SessionDispatchWatcher.setUnrefTimeout(resolve2, delayMs);
+      });
+    }
+    static getReconnectJitterMs() {
+      const min2 = SessionDispatchWatcher.HISTORY_RECONNECT_JITTER_MIN_MS;
+      const max2 = SessionDispatchWatcher.HISTORY_RECONNECT_JITTER_MAX_MS;
+      return min2 + Math.floor(Math.random() * (max2 - min2 + 1));
+    }
     async findOrAwaitDispatchableTurn(sessionId, sessionDoc, meta) {
       const history = await sessionDoc.getHistory();
       let turn = findNextDispatchableUserTurn(history, meta);
@@ -122417,9 +122923,12 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       if (turn) {
         return turn;
       }
+      if (this.hasPendingUserTurnSignal(meta)) {
+        return await this.waitForPendingUserTurnHistorySync(sessionId, sessionDoc, meta);
+      }
       await Promise.race([
         sessionDoc.waitForRemoteSync(),
-        new Promise((resolve2) => setTimeout(resolve2, SessionDispatchWatcher.REMOTE_SYNC_TIMEOUT_MS))
+        new Promise((resolve2) => SessionDispatchWatcher.setUnrefTimeout(resolve2, SessionDispatchWatcher.REMOTE_SYNC_TIMEOUT_MS))
       ]);
       turn = await this.checkHistoryAndQueue(sessionDoc, meta);
       if (turn) {
@@ -122429,6 +122938,138 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       turn = await this.waitForDispatchableTurnFromMirror(sessionId, sessionDoc, meta);
       return turn;
     }
+    hasPendingUserTurnSignal(meta) {
+      if (meta.processingUserMsgId) {
+        return true;
+      }
+      return Boolean(meta.latestUserMsgId && meta.latestUserMsgId !== meta.lastHandledUserMsgId);
+    }
+    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`);
+      try {
+        await sessionDoc.ensureDocRoomJoined();
+      } catch (error2) {
+        this.deps.logger.debug(`[${sessionId}] Failed to ensure session history room is joined before waiting: ${formatErrorMessage(error2)}`);
+      }
+      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;
+      }
+      return await new Promise((resolve2) => {
+        let settled = false;
+        let reconnectAttempted = false;
+        let unsubscribeMirror;
+        let unsubscribeStatus;
+        const cleanup = () => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          clearTimeout(timer2);
+          unsubscribeMirror?.();
+          unsubscribeStatus?.();
+        };
+        const checkForTurn = () => {
+          if (settled) {
+            return;
+          }
+          void this.checkHistoryAndQueue(sessionDoc, freshMeta).then((turn) => {
+            if (settled || !turn) {
+              return;
+            }
+            cleanup();
+            this.deps.logger.debug(`[${sessionId}] Found dispatchable turn after waiting for history CRDT sync`);
+            resolve2(turn);
+          }).catch((error2) => {
+            if (settled) {
+              return;
+            }
+            this.deps.logger.debug(`[${sessionId}] Error checking history during history sync wait: ${formatErrorMessage(error2)}`);
+          });
+        };
+        const attemptReconnectOnce = (reason) => {
+          if (settled || reconnectAttempted) {
+            return;
+          }
+          reconnectAttempted = true;
+          void (async () => {
+            const jitterMs = SessionDispatchWatcher.getReconnectJitterMs();
+            this.deps.logger.debug(`[${sessionId}] Session history room ${reason}; attempting one rejoin in ${jitterMs}ms`);
+            await SessionDispatchWatcher.sleep(jitterMs);
+            if (settled) {
+              return;
+            }
+            try {
+              await sessionDoc.rejoinDocRoom();
+            } catch (error2) {
+              this.deps.logger.debug(`[${sessionId}] Session history room rejoin failed: ${formatErrorMessage(error2)}`);
+            }
+            checkForTurn();
+          })();
+        };
+        const handleRoomStatus = (status) => {
+          if (settled || !status) {
+            return;
+          }
+          if (status === "disconnected" || status === "error") {
+            attemptReconnectOnce(status);
+          }
+        };
+        const timer2 = SessionDispatchWatcher.setUnrefTimeout(() => {
+          cleanup();
+          this.deps.logger.warn(`[${sessionId}] User turn did not arrive in history after ${SessionDispatchWatcher.HISTORY_SYNC_WAIT_TIMEOUT_MS / 1e3}s; entering dispatch recovery`);
+          resolve2(null);
+        }, SessionDispatchWatcher.HISTORY_SYNC_WAIT_TIMEOUT_MS);
+        unsubscribeMirror = sessionDoc.mirror?.subscribe(checkForTurn);
+        if (!unsubscribeMirror) {
+          this.deps.logger.debug(`[${sessionId}] Session mirror is unavailable during history sync wait`);
+        }
+        unsubscribeStatus = sessionDoc.onDocRoomStatusChange(handleRoomStatus);
+        const currentStatus = sessionDoc.getDocRoomStatus();
+        if (currentStatus) {
+          handleRoomStatus(currentStatus);
+        } else {
+          attemptReconnectOnce("has no active subscription");
+        }
+      });
+    }
+    async markMissingUserTurnRecovery(sessionId, previousMeta) {
+      const roomId = getSessionRoomId(sessionId);
+      let meta = previousMeta;
+      try {
+        const record2 = await this.deps.workspaceDocument.repo.getDocMeta(roomId);
+        if (!isLoroRepoDocDeleted(record2) && record2?.meta) {
+          meta = record2.meta;
+        }
+      } catch (error2) {
+        this.deps.logger.debug(`[${sessionId}] Failed to refresh metadata before dispatch recovery: ${formatErrorMessage(error2)}`);
+      }
+      if (meta.machineId !== this.deps.machineId || meta.isArchived || !this.hasPendingUserTurnSignal(meta)) {
+        return;
+      }
+      const pendingUserMsgId = meta.processingUserMsgId ?? meta.latestUserMsgId ?? meta.lastHandledUserMsgId;
+      const recoveryPatch = {
+        status: SessionStatusFactory.idle(),
+        processingUserMsgId: void 0
+      };
+      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);
+      await this.deps.workspaceDocument.cleanSessionDoc(sessionId, {
+        preserveStatus: true
+      });
+    }
     async waitForDispatchableTurnFromMirror(sessionId, sessionDoc, meta) {
       return new Promise((resolve2) => {
         let settled = false;
@@ -122437,7 +123078,7 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
           clearTimeout(timer2);
           unsubscribe2?.();
         };
-        const timer2 = setTimeout(() => {
+        const timer2 = SessionDispatchWatcher.setUnrefTimeout(() => {
           if (settled) return;
           cleanup();
           this.deps.logger.debug(`[${sessionId}] No dispatchable turn found after ${SessionDispatchWatcher.REALTIME_WAIT_TIMEOUT_MS / 1e3}s timeout`);
@@ -123168,8 +123809,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;
@@ -125181,6 +125828,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);
     }
@@ -125537,116 +126194,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;
@@ -125654,6 +126201,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));
@@ -125666,6 +126215,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;
@@ -125689,7 +126241,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;
       }
@@ -125697,7 +126249,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;
         }
@@ -125715,19 +126267,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) {
@@ -125736,30 +126319,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);
@@ -125787,20 +126403,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);
@@ -125928,6 +126547,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(),
@@ -125936,8 +126556,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() {
@@ -133135,6 +133763,9 @@ export PATH=${toSingleQuotedShellString(ghShimBinDir)}:"$PATH"
     isControlPlaneReady() {
       return this.documentManager.isTransportConnected();
     }
+    isControlPlaneRecovering() {
+      return this.documentManager.isTransportRecovering();
+    }
     getActiveSessionCount() {
       return this.runtime.getActiveSessionCount();
     }
@@ -134964,23 +135595,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({
@@ -167263,10 +167897,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 = [];
@@ -167327,6 +167969,7 @@ ${result.stderr}`;
     probeFailureThreshold;
     minRetryMs;
     maxRetryMs;
+    retryRandom;
     failureWindow;
     triggered = false;
     inFlight = false;
@@ -167358,6 +168001,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() {
@@ -167437,6 +168081,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;
@@ -167457,7 +168104,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) {
@@ -167514,7 +168163,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;