lody 0.79.0 → 0.79.2

package/dist/chunks/{review-viewer--d2HZGpO.js → review-viewer-BJIn--4M.js}

@@ -76,7 +76,7 @@ let __tla = Promise.all([
     }
   })()
 ]).then(async () => {
-  const reviewViewerVersion = "0.79.0";
+  const reviewViewerVersion = "0.79.2";
   const reviewViewerSha256 = "41b6ffd0acff2c355e190b604776a89138f9598a1772d09390a6d5af514e71bb";
   const reviewViewerFileName = "standalone.html";
   const DEFAULT_CDN_BASES = [

package/dist/index.js

@@ -23229,7 +23229,7 @@ ${context2.authorReply.trim()}
         const line3 = buffer2.slice(0, newlineIndex).trim();
         buffer2 = buffer2.slice(newlineIndex + 1);
         if (line3) {
-          if (line3.length > options.maxBufferBytes) {
+          if (options.maxBufferBytes !== void 0 && line3.length > options.maxBufferBytes) {
             options.onOverflow?.();
           } else {
             options.onLine(line3);
@@ -23237,7 +23237,7 @@ ${context2.authorReply.trim()}
         }
         newlineIndex = buffer2.indexOf("\n");
       }
-      if (buffer2.length > options.maxBufferBytes) {
+      if (options.maxBufferBytes !== void 0 && buffer2.length > options.maxBufferBytes) {
         buffer2 = "";
         discardingOversizedLine = true;
         options.onOverflow?.();
@@ -24638,7 +24638,7 @@ ${peerId}`;
   const getSessionIdFromRoomId = (roomId) => isSessionDocRoomId(roomId) ? roomId.slice(SESSION_DOC_PREFIX.length) : null;
   const isMachineDocRoomId = (roomId) => roomId.startsWith(MACHINE_DOC_PREFIX);
   const name$1 = "@lody/cli-cloud";
-  const version$7 = "0.79.0";
+  const version$7 = "0.79.2";
   const type$2 = "module";
   const scripts = {
     "dev": "node dev.mjs",
@@ -129597,16 +129597,18 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
         return "The machine is at critical memory pressure \u2014 macOS is reclaiming memory and terminating processes to keep up. The turn was not started; free memory and retry.";
       }
       const mb = (bytes) => `${Math.round(bytes / 1024 / 1024)}MB`;
+      if (result.effectiveAvailableCommitBytes !== void 0 && result.commitThresholdBytes !== void 0) {
+        return `The machine has run out of committable memory: ${mb(result.availableCommitBytes ?? 0)} below the commit limit plus ${mb(result.commitGrowthBytes ?? 0)} the page file can still grow, against a safety margin of ${mb(result.commitThresholdBytes)}. The turn was not started; close some programs, or raise the page file maximum, and retry.`;
+      }
       const availableMb = mb(result.availableMemoryBytes);
       const marginMb = mb(result.thresholdBytes);
-      const commitText = result.availableCommitBytes !== void 0 && (result.pressureReason === "commit" || result.pressureReason === "physical_and_commit") && result.commitThresholdBytes !== void 0 ? ` Commit headroom is ${mb(result.availableCommitBytes)} (safety margin: ${mb(result.commitThresholdBytes)}).` : "";
       const cgroup = result.cgroup;
       if (cgroup) {
         const hostText = result.hostAvailableBytes !== void 0 ? `host available ${mb(result.hostAvailableBytes)}, ` : "";
         const stallText = cgroup.psiSomeAvg10 !== null ? `stalled ${cgroup.psiSomeAvg10}% of the last 10s on reclaim` : "PSI unavailable; hard headroom is below the floor";
-        return `The machine is under memory pressure and ${stallText}. cgroup ${cgroup.path}: ${mb(cgroup.currentBytes)} of ${mb(cgroup.maxBytes)} used, ${mb(cgroup.hardHeadroomBytes)} unused plus ${mb(cgroup.reclaimableBytes)} reclaimable cache/slab; ${hostText}safety margin ${marginMb}. The turn was not started; free memory and retry.${commitText}`;
+        return `The machine is under memory pressure and ${stallText}. cgroup ${cgroup.path}: ${mb(cgroup.currentBytes)} of ${mb(cgroup.maxBytes)} used, ${mb(cgroup.hardHeadroomBytes)} unused plus ${mb(cgroup.reclaimableBytes)} reclaimable cache/slab; ${hostText}safety margin ${marginMb}. The turn was not started; free memory and retry.`;
       }
-      return `The machine is under memory pressure (${availableMb} available, safety margin ${marginMb}). The turn was not started; free memory and retry.${commitText}`;
+      return `The machine is under memory pressure (${availableMb} available, safety margin ${marginMb}). The turn was not started; free memory and retry.`;
     }
     recordKnownChatFailureAndHaltEffect(options) {
       return this.tryPromise(() => this.recordKnownChatFailure(options)).pipe(flatMap$2(() => fail(new SessionTurnHalted({
@@ -165465,6 +165467,9 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
             this.logger.error(`[${sessionId}] Backfill gave up for ${fileId}; block stays local (pending on other devices)`);
             return;
           }
+          if (this.sessionFileBackfillStopped || !this.remoteBackfillEnabled) {
+            return;
+          }
           await delay$1(sessionFileBackfillDelayMs(attempt));
         }
       }
@@ -167177,16 +167182,20 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
     }
   }
   const execFileAsync = promisify$1(execFile$1);
-  const MEMORY_PROBE_TIMEOUT_MS = 1e3;
+  const DARWIN_MEMORY_PROBE_TIMEOUT_MS = 1e3;
+  const WINDOWS_MEMORY_PROBE_TIMEOUT_MS = 5e3;
+  const WINDOWS_MEMORY_CACHE_TTL_MS = 3e4;
+  const MIB$2 = 1024 * 1024;
+  const GIB$1 = 1024 * MIB$2;
   const DARWIN_PRESSURE_NORMAL = 1;
   const DARWIN_PRESSURE_WARNING = 2;
   const DARWIN_PRESSURE_CRITICAL = 4;
-  async function getMemoryPressureSnapshot() {
+  async function getMemoryPressureSnapshot(options = {}) {
     const [windowsStatus, darwinPressureLevel] = await Promise.all([
-      getWindowsMemoryStatus(),
+      getWindowsMemoryStatus(options.force === true),
       getDarwinMemoryPressureLevel()
     ]);
-    const systemAvailable = await getSystemAvailableMemoryBytes(windowsStatus);
+    const systemAvailable = await getSystemAvailableMemoryBytes();
     const cgroup = readCgroupMemoryState();
     const availableMemoryBytes = cgroup !== null ? Math.min(systemAvailable, cgroup.hardHeadroomBytes + cgroup.reclaimableBytes) : systemAvailable;
     const effectiveMemoryLimitBytes = getEffectiveMemoryLimitBytes();
@@ -167203,7 +167212,13 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
       ...windowsStatus ? {
         availableCommitBytes: windowsStatus.availableCommitBytes,
         commitLimitBytes: windowsStatus.commitLimitBytes,
-        committedBytes: windowsStatus.committedBytes
+        committedBytes: windowsStatus.committedBytes,
+        ...windowsStatus.commitGrowthBytes !== null ? {
+          commitGrowthBytes: windowsStatus.commitGrowthBytes
+        } : {},
+        ...windowsStatus.effectiveAvailableCommitBytes !== void 0 ? {
+          effectiveAvailableCommitBytes: windowsStatus.effectiveAvailableCommitBytes
+        } : {}
       } : {}
     };
   }
@@ -167215,10 +167230,7 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
     }
     return totalMem;
   }
-  async function getSystemAvailableMemoryBytes(windowsStatus) {
-    if (windowsStatus) {
-      return Math.max(windowsStatus.availableBytes, os__default$1.freemem());
-    }
+  async function getSystemAvailableMemoryBytes() {
     const darwinAvailable = await getDarwinAvailableMemoryBytes();
     if (darwinAvailable !== null) {
       return darwinAvailable;
@@ -167226,26 +167238,38 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
     return getSystemAvailableMemoryBytesSync();
   }
   function getSystemAvailableMemoryBytesSync() {
-    try {
-      const meminfo = readFileSync$1("/proc/meminfo", "utf8");
-      const match5 = meminfo.match(/MemAvailable:\s+(\d+)/);
-      if (match5?.[1]) {
-        return parseInt(match5[1], 10) * 1024;
+    if (process.platform === "linux") {
+      try {
+        const meminfo = readFileSync$1("/proc/meminfo", "utf8");
+        const match5 = meminfo.match(/MemAvailable:\s+(\d+)/);
+        if (match5?.[1]) {
+          return parseInt(match5[1], 10) * 1024;
+        }
+      } catch {
       }
-    } catch {
     }
     return os__default$1.freemem();
   }
-  async function getWindowsMemoryStatus() {
-    if (process.platform !== "win32") {
-      return null;
-    }
+  async function probeWindowsMemoryStatus() {
+    const script = [
+      '$ErrorActionPreference = "SilentlyContinue"',
+      "$perf = Get-CimInstance -ClassName Win32_PerfFormattedData_PerfOS_Memory",
+      "$os = Get-CimInstance -ClassName Win32_OperatingSystem",
+      "$cs = Get-CimInstance -ClassName Win32_ComputerSystem",
+      "$usage = @(Get-CimInstance -ClassName Win32_PageFileUsage)",
+      "$setting = @(Get-CimInstance -ClassName Win32_PageFileSetting)",
+      '$disks = @(Get-CimInstance -ClassName Win32_LogicalDisk -Filter "DriveType=3")',
+      "$out = @{ CommitLimit = $perf.CommitLimit }",
+      "$out.CommittedBytes = $perf.CommittedBytes",
+      "$out.TotalVirtualMemorySize = $os.TotalVirtualMemorySize",
+      "$out.FreeVirtualMemory = $os.FreeVirtualMemory",
+      "$out.AutomaticManagedPagefile = [bool]$cs.AutomaticManagedPagefile",
+      "$out.PageFiles = @($usage | Select-Object Name, AllocatedBaseSize)",
+      "$out.PageFileSettings = @($setting | Select-Object Name, MaximumSize)",
+      "$out.Volumes = @($disks | Select-Object DeviceID, FreeSpace, Size)",
+      "$out | ConvertTo-Json -Compress -Depth 4"
+    ].join("; ");
     try {
-      const script = `
-$mem = Get-CimInstance -ClassName Win32_PerfFormattedData_PerfOS_Memory |
-  Select-Object AvailableBytes, CommitLimit, CommittedBytes
-$mem | ConvertTo-Json -Compress
-`;
       const { stdout } = await execFileAsync("powershell.exe", [
         "-NoProfile",
         "-NonInteractive",
@@ -167255,32 +167279,178 @@ $mem | ConvertTo-Json -Compress
         script
       ], {
         encoding: "utf8",
-        timeout: MEMORY_PROBE_TIMEOUT_MS,
+        timeout: WINDOWS_MEMORY_PROBE_TIMEOUT_MS,
         windowsHide: true
       });
-      return parseWindowsMemoryStatus(String(stdout ?? ""));
+      return parseWindowsMemoryStatus(String(stdout ?? ""), os__default$1.totalmem());
     } catch {
       return null;
     }
   }
-  function parseWindowsMemoryStatus(rawJson) {
+  let windowsMemoryCache = null;
+  let windowsMemoryProbeInFlight = null;
+  async function getWindowsMemoryStatus(force) {
+    if (process.platform !== "win32") {
+      return null;
+    }
+    const cached2 = windowsMemoryCache;
+    if (!force && cached2 !== null && Date.now() - cached2.sampledAtMs < WINDOWS_MEMORY_CACHE_TTL_MS) {
+      return cached2.status;
+    }
+    if (windowsMemoryProbeInFlight !== null) {
+      return await windowsMemoryProbeInFlight;
+    }
+    const probe = probeWindowsMemoryStatus().then((status) => {
+      windowsMemoryCache = {
+        status,
+        sampledAtMs: Date.now()
+      };
+      return status;
+    });
+    windowsMemoryProbeInFlight = probe;
     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 await probe;
+    } finally {
+      if (windowsMemoryProbeInFlight === probe) {
+        windowsMemoryProbeInFlight = null;
       }
-      return {
-        availableBytes,
-        commitLimitBytes,
-        committedBytes,
-        availableCommitBytes: Math.max(0, commitLimitBytes - committedBytes)
-      };
+    }
+  }
+  function parseWindowsMemoryStatus(rawJson, totalPhysicalBytes) {
+    let parsed;
+    try {
+      const value = JSON.parse(rawJson);
+      if (typeof value !== "object" || value === null) return null;
+      parsed = value;
     } catch {
       return null;
     }
+    const commit = readWindowsCommitTotals(parsed);
+    if (commit === null) return null;
+    const config2 = {
+      automaticManagedPagefile: parsed.AutomaticManagedPagefile === true,
+      pageFiles: readCimRows(parsed.PageFiles).flatMap((row) => {
+        const name2 = readNonEmptyString(row.Name);
+        const allocatedBytes = readMegabytes(row.AllocatedBaseSize);
+        return name2 !== null && allocatedBytes !== null ? [
+          {
+            name: name2,
+            allocatedBytes
+          }
+        ] : [];
+      }),
+      pageFileSettings: readCimRows(parsed.PageFileSettings).flatMap((row) => {
+        const name2 = readNonEmptyString(row.Name);
+        const maximumBytes = readMegabytes(row.MaximumSize);
+        return name2 !== null && maximumBytes !== null ? [
+          {
+            name: name2,
+            maximumBytes
+          }
+        ] : [];
+      }),
+      volumes: readCimRows(parsed.Volumes).flatMap((row) => {
+        const name2 = readNonEmptyString(row.DeviceID);
+        const freeBytes = readNumber(row.FreeSpace);
+        const sizeBytes = readNumber(row.Size);
+        return name2 !== null && freeBytes !== null && sizeBytes !== null ? [
+          {
+            name: name2,
+            freeBytes,
+            sizeBytes
+          }
+        ] : [];
+      })
+    };
+    const commitGrowthBytes = computeWindowsCommitGrowthBytes(config2, {
+      totalPhysicalBytes,
+      commitLimitBytes: commit.commitLimitBytes
+    });
+    return {
+      commitLimitBytes: commit.commitLimitBytes,
+      committedBytes: commit.committedBytes,
+      availableCommitBytes: commit.availableCommitBytes,
+      commitGrowthBytes,
+      ...commitGrowthBytes !== null ? {
+        effectiveAvailableCommitBytes: commit.availableCommitBytes + commitGrowthBytes
+      } : {}
+    };
+  }
+  function readWindowsCommitTotals(parsed) {
+    const perfLimit = readNumber(parsed.CommitLimit);
+    const perfCommitted = readNumber(parsed.CommittedBytes);
+    if (perfLimit !== null && perfLimit > 0 && perfCommitted !== null) {
+      return {
+        commitLimitBytes: perfLimit,
+        committedBytes: Math.min(perfCommitted, perfLimit),
+        availableCommitBytes: Math.max(0, perfLimit - perfCommitted)
+      };
+    }
+    const osLimit = readKilobytes(parsed.TotalVirtualMemorySize);
+    const osFree = readKilobytes(parsed.FreeVirtualMemory);
+    if (osLimit !== null && osLimit > 0 && osFree !== null) {
+      const available = Math.min(osFree, osLimit);
+      return {
+        commitLimitBytes: osLimit,
+        committedBytes: osLimit - available,
+        availableCommitBytes: available
+      };
+    }
+    return null;
+  }
+  function computeWindowsCommitGrowthBytes(config2, inputs) {
+    const { totalPhysicalBytes, commitLimitBytes } = inputs;
+    const volumeByKey = new Map(config2.volumes.map((volume) => [
+      volumeKey(volume.name),
+      volume
+    ]));
+    const maximumByName = new Map(config2.pageFileSettings.map((setting) => [
+      setting.name.toLowerCase(),
+      setting.maximumBytes
+    ]));
+    if (config2.pageFiles.length === 0) {
+      if (commitLimitBytes > totalPhysicalBytes + EMPTY_PAGE_FILE_TOLERANCE_BYTES) return null;
+      if (!config2.automaticManagedPagefile) return 0;
+      return config2.volumes.reduce((largest, volume) => Math.max(largest, Math.min(systemManagedMaxBytes(totalPhysicalBytes, volume.sizeBytes), volume.freeBytes)), 0);
+    }
+    let growthBytes = 0;
+    for (const pageFile of config2.pageFiles) {
+      const volume = volumeByKey.get(volumeKey(pageFile.name));
+      if (volume === void 0) return null;
+      const configuredMaximum = config2.automaticManagedPagefile ? 0 : maximumByName.get(pageFile.name.toLowerCase()) ?? 0;
+      const maximumBytes = configuredMaximum > 0 ? configuredMaximum : systemManagedMaxBytes(totalPhysicalBytes, volume.sizeBytes);
+      growthBytes += Math.min(Math.max(0, maximumBytes - pageFile.allocatedBytes), volume.freeBytes);
+    }
+    return growthBytes;
+  }
+  const EMPTY_PAGE_FILE_TOLERANCE_BYTES = 64 * MIB$2;
+  function systemManagedMaxBytes(totalPhysicalBytes, volumeSizeBytes) {
+    return Math.min(Math.max(3 * totalPhysicalBytes, 4 * GIB$1), Math.floor(volumeSizeBytes / 8));
+  }
+  function volumeKey(name2) {
+    return name2.slice(0, 2).toUpperCase();
+  }
+  function readCimRows(value) {
+    const rows = Array.isArray(value) ? value : [
+      value
+    ];
+    return rows.filter((row) => typeof row === "object" && row !== null);
+  }
+  function readNumber(value) {
+    if (typeof value !== "number" && typeof value !== "string") return null;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+  }
+  function readKilobytes(value) {
+    const parsed = readNumber(value);
+    return parsed === null ? null : parsed * 1024;
+  }
+  function readMegabytes(value) {
+    const parsed = readNumber(value);
+    return parsed === null ? null : parsed * MIB$2;
+  }
+  function readNonEmptyString(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
   }
   async function getDarwinMemoryPressureLevel() {
     if (process.platform !== "darwin") {
@@ -167292,7 +167462,7 @@ $mem | ConvertTo-Json -Compress
         "kern.memorystatus_vm_pressure_level"
       ], {
         encoding: "utf8",
-        timeout: MEMORY_PROBE_TIMEOUT_MS
+        timeout: DARWIN_MEMORY_PROBE_TIMEOUT_MS
       });
       return parseDarwinPressureLevel(String(stdout ?? ""));
     } catch {
@@ -167317,7 +167487,7 @@ $mem | ConvertTo-Json -Compress
     try {
       const { stdout } = await execFileAsync("vm_stat", [], {
         encoding: "utf8",
-        timeout: MEMORY_PROBE_TIMEOUT_MS
+        timeout: DARWIN_MEMORY_PROBE_TIMEOUT_MS
       });
       const parsed = parseDarwinAvailableMemoryBytes(String(stdout ?? ""));
       if (parsed !== null) {
@@ -167499,6 +167669,24 @@ $mem | ConvertTo-Json -Compress
   function getWindowsCommitThresholdBytes(memoryThresholdBytes) {
     return Math.max(WINDOWS_COMMIT_THRESHOLD_FLOOR_BYTES, Math.min(WINDOWS_COMMIT_THRESHOLD_CEILING_BYTES, memoryThresholdBytes));
   }
+  function evaluateWindowsMemoryPressure(snapshot, thresholds2) {
+    const physicalLow = snapshot.availableMemoryBytes < thresholds2.thresholdBytes;
+    const commitLow = snapshot.availableCommitBytes !== void 0 && snapshot.availableCommitBytes < thresholds2.commitThresholdBytes;
+    const commitExhausted = snapshot.effectiveAvailableCommitBytes !== void 0 && snapshot.effectiveAvailableCommitBytes < thresholds2.commitThresholdBytes;
+    if (commitExhausted) {
+      return {
+        evict: true,
+        block: true,
+        reason: physicalLow ? "physical_and_commit" : "commit"
+      };
+    }
+    const reason = physicalLow && commitLow ? "physical_and_commit" : physicalLow ? "physical" : commitLow ? "commit" : null;
+    return {
+      evict: reason !== null,
+      block: false,
+      reason
+    };
+  }
   function evaluateMemoryPressure(snapshot, thresholds2) {
     if (thresholds2.platform === "darwin") {
       if (snapshot.memoryPressureLevel === DARWIN_PRESSURE_CRITICAL) {
@@ -167521,7 +167709,9 @@ $mem | ConvertTo-Json -Compress
         reason: null
       };
     }
-    const commitPressure = snapshot.availableCommitBytes !== void 0 && snapshot.availableCommitBytes < thresholds2.commitThresholdBytes;
+    if (thresholds2.platform === "win32") {
+      return evaluateWindowsMemoryPressure(snapshot, thresholds2);
+    }
     const cgroup = snapshot.cgroup;
     if (cgroup) {
       const hostLow = snapshot.hostAvailableBytes !== void 0 && snapshot.hostAvailableBytes < thresholds2.thresholdBytes;
@@ -167541,13 +167731,6 @@ $mem | ConvertTo-Json -Compress
           reason: "cgroup_low_headroom"
         };
       }
-      if (commitPressure) {
-        return {
-          evict: true,
-          block: true,
-          reason: "commit"
-        };
-      }
       return {
         evict: false,
         block: false,
@@ -167555,7 +167738,7 @@ $mem | ConvertTo-Json -Compress
       };
     }
     const physicalPressure = snapshot.availableMemoryBytes < thresholds2.thresholdBytes;
-    const reason = physicalPressure && commitPressure ? "physical_and_commit" : physicalPressure ? "physical" : commitPressure ? "commit" : null;
+    const reason = physicalPressure ? "physical" : null;
     return {
       evict: reason !== null,
       block: reason !== null,
@@ -167574,7 +167757,7 @@ $mem | ConvertTo-Json -Compress
         this.deps.logger.debug("[GC] Session GC is disabled");
         return;
       }
-      const pressureSignal = this.platform === "darwin" ? "kern.memorystatus_vm_pressure_level" : `available<${Math.round(this.config.memoryThresholdBytes / 1024 / 1024)}MB`;
+      const pressureSignal = this.platform === "darwin" ? "kern.memorystatus_vm_pressure_level" : this.platform === "win32" ? `commit+pagefile-growth<${Math.round(getWindowsCommitThresholdBytes(this.config.memoryThresholdBytes) / 1024 / 1024)}MB` : `available<${Math.round(this.config.memoryThresholdBytes / 1024 / 1024)}MB`;
       this.deps.logger.debug(`[GC] Starting session GC (interval=${this.config.sweepIntervalMs}ms, idleTimeout=${this.config.idleTimeoutMs}ms, pressureSignal=${pressureSignal}, maxEvictionsPerCall=${this.config.maxEvictionsPerCall})`);
       this.sweepInterval = setInterval(() => void this.sweep(), this.config.sweepIntervalMs);
     }
@@ -167715,7 +167898,13 @@ $mem | ConvertTo-Json -Compress
           availableCommitBytes: snapshot.availableCommitBytes,
           commitThresholdBytes,
           commitLimitBytes: snapshot.commitLimitBytes,
-          committedBytes: snapshot.committedBytes
+          committedBytes: snapshot.committedBytes,
+          ...snapshot.commitGrowthBytes !== void 0 ? {
+            commitGrowthBytes: snapshot.commitGrowthBytes
+          } : {},
+          ...snapshot.effectiveAvailableCommitBytes !== void 0 ? {
+            effectiveAvailableCommitBytes: snapshot.effectiveAvailableCommitBytes
+          } : {}
         } : {}
       };
     }
@@ -167729,12 +167918,13 @@ $mem | ConvertTo-Json -Compress
       if (snapshot.memoryPressureLevel !== void 0) {
         return `kernel pressure level ${snapshot.memoryPressureLevel}`;
       }
+      const mb = (bytes) => Math.round(bytes / 1024 / 1024);
       const cgroup = snapshot.cgroup;
       if (cgroup) {
-        const mb = (bytes) => Math.round(bytes / 1024 / 1024);
         return `cgroup ${cgroup.path}: hard headroom ${mb(cgroup.hardHeadroomBytes)}MB + reclaimable ${mb(cgroup.reclaimableBytes)}MB (of ${mb(cgroup.stat.activeFileBytes)}MB active file cache not counted), host available ${snapshot.hostAvailableBytes !== void 0 ? mb(snapshot.hostAvailableBytes) : "?"}MB, PSI some avg10 ${cgroup.psiSomeAvg10 ?? "?"}, threshold ${mb(thresholdBytes)}MB`;
       }
-      const commitText = snapshot.availableCommitBytes !== void 0 ? `, commit headroom ${Math.round(snapshot.availableCommitBytes / 1024 / 1024)}MB (threshold: ${Math.round(commitThresholdBytes / 1024 / 1024)}MB)` : "";
+      const growthText = snapshot.commitGrowthBytes !== void 0 ? `${mb(snapshot.commitGrowthBytes)}MB page file growth` : "page file growth unknown";
+      const commitText = snapshot.availableCommitBytes !== void 0 ? `, commit headroom ${mb(snapshot.availableCommitBytes)}MB + ${growthText} (threshold: ${mb(commitThresholdBytes)}MB)` : "";
       return `${Math.round(snapshot.availableMemoryBytes / 1024 / 1024)}MB available (threshold: ${Math.round(thresholdBytes / 1024 / 1024)}MB)${commitText}`;
     }
     async getIdleCandidates() {
@@ -178621,7 +178811,7 @@ export PATH=${toSingleQuotedShellString(ghShimBinDir)}:"$PATH"
           }
           roomMessageChain = roomMessageChain.then(() => handleMessage(config2, connection2, touchedEngines, message)).catch((error2) => logMessageHandlingError(config2.logger, error2));
         },
-        maxBufferBytes: LOCAL_LORO_DATA_PLANE_MAX_FRAME_BYTES,
+        maxBufferBytes: config2.maxFrameBytes ?? LOCAL_LORO_DATA_PLANE_MAX_FRAME_BYTES,
         onOverflow: () => {
           connection2.send({
             type: "error",
@@ -179281,7 +179471,9 @@ export PATH=${toSingleQuotedShellString(ghShimBinDir)}:"$PATH"
   class MemoryPressureSampler {
     constructor(logger2, options = {}) {
       this.logger = logger2;
-      this.probe = options.probe ?? getMemoryPressureSnapshot;
+      this.probe = options.probe ?? ((force) => getMemoryPressureSnapshot({
+        force
+      }));
       this.now = options.now ?? (() => performance.now());
       this.sampleIntervalMs = options.sampleIntervalMs ?? platformSampleIntervalMs();
       this.maxStaleMs = options.maxStaleMs ?? this.sampleIntervalMs * 3;
@@ -179295,11 +179487,11 @@ export PATH=${toSingleQuotedShellString(ghShimBinDir)}:"$PATH"
     timer = null;
     start() {
       if (this.timer) return;
-      void this.refresh().catch((error2) => {
+      void this.sample(false).catch((error2) => {
         this.logger.debug(`Initial memory pressure sample failed: ${formatErrorMessage(error2)}`);
       });
       this.timer = setInterval(() => {
-        void this.refresh().catch((error2) => {
+        void this.sample(false).catch((error2) => {
           this.logger.debug(`Memory pressure sample failed: ${formatErrorMessage(error2)}`);
         });
       }, this.sampleIntervalMs);
@@ -179313,33 +179505,41 @@ export PATH=${toSingleQuotedShellString(ghShimBinDir)}:"$PATH"
     async getLatest() {
       const cached2 = this.cached;
       if (!cached2) {
-        return await this.refresh();
+        return await this.sample(false);
       }
       const ageMs = Math.max(0, this.now() - cached2.sampledAtMs);
       if (ageMs >= this.sampleIntervalMs) {
-        void this.refresh().catch((error2) => {
+        void this.sample(false).catch((error2) => {
           this.logger.debug(`Memory pressure refresh failed: ${formatErrorMessage(error2)}`);
         });
       }
       if (ageMs <= this.maxStaleMs) {
         return cached2.snapshot;
       }
-      return await this.refresh();
+      return await this.sample(false);
     }
     async refresh() {
-      if (this.inFlight) {
-        return await this.inFlight;
+      return await this.sample(true);
+    }
+    async sample(force) {
+      const inFlight = this.inFlight;
+      if (inFlight !== null && (!force || inFlight.forced)) {
+        return await inFlight.promise;
       }
-      const operation = this.probe().then((snapshot) => {
+      const promise2 = this.probe(force).then((snapshot) => {
         this.cached = {
           snapshot,
           sampledAtMs: this.now()
         };
         return snapshot;
       });
+      const operation = {
+        promise: promise2,
+        forced: force
+      };
       this.inFlight = operation;
       try {
-        return await operation;
+        return await promise2;
       } finally {
         if (this.inFlight === operation) {
           this.inFlight = null;
@@ -213716,7 +213916,7 @@ ${page}${helpTipBottom}${choiceDescription}${ansiEscapes.cursorHide}`;
       data = createReviewBundleSnapshot(bundle);
     }
     const { injectReviewSnapshot } = await import("./chunks/index-VoI6Ds2-.js");
-    const { resolveReviewViewerTemplate } = await import("./chunks/review-viewer--d2HZGpO.js").then(async (m) => {
+    const { resolveReviewViewerTemplate } = await import("./chunks/review-viewer-BJIn--4M.js").then(async (m) => {
       await m.__tla;
       return m;
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lody",
-  "version": "0.79.0",
+  "version": "0.79.2",
   "description": "Lody Agent CLI tool for managing remote command execution",
   "type": "module",
   "main": "dist/index.js",