lody 0.77.2 → 0.78.0

package/dist/index.js

@@ -60,10 +60,11 @@ import require$$1$5, { Worker as Worker$1 } from "node:worker_threads";
 import require$$1$6, { fileURLToPath, pathToFileURL } from "node:url";
 import require$$1$7 from "node:console";
 import require$$1$8 from "node:dns";
-import { C as CodeCollabV2OpenTextRequestSchema, a as CodeCollabV2RefreshTextRequestSchema, b as CodeCollabV2SaveTextRequestSchema, c as CodeCollabV2OpenCurrentDiffRequestSchema, d as CodeCollabV2OpenAllChangesDiffRequestSchema, e as CodeCollabV2OpenTurnDiffRequestSchema, f as CodeCollabV2InitDirectoryRequestSchema, g as CodeCollabV2OpenTextOkSchema, h as CodeCollabV2RefreshTextResponseSchema, i as CodeCollabV2SaveTextResponseSchema, j as CodeCollabV2OpenCurrentDiffResponseSchema, k as CodeCollabV2OpenAllChangesDiffResponseSchema, l as CodeCollabV2OpenTurnDiffResponseSchema, m as CodeCollabV2InitDirectoryOkSchema, n as CodeCollabV2LspUnsupportedSchema, o as CodeCollabV2ErrorSchema, p as CodeCollabV2RpcContentEnvelopeSchema, q as deriveCodeCollabV2ContentKeyId, r as CodeCollabV2ErrorCodeSchema, s as CodeCollabV2RpcResponseSchema, t as deriveCodeCollabV2ContentKeyBytes, u as readCodeCollabFileIndexSignalFromFlock, w as writeCodeCollabFileIndexSignalToFlock, v as writeCodeCollabFileIndexToFlock, x as buildCodeCollabFileIndexState, y as CODE_COLLAB_V2_TEXT_LIMITS, z as CODE_COLLAB_V2_ALL_CHANGES_DIFF_LIMITS, A as computeAllChanges, B as codeCollabFileIndexStatesEqual, D as scanGitDirectoryEntries, E as closeDirectoryQuietly } from "./chunks/directory-handle-BBQKxZ5F.js";
+import { C as CodeCollabV2OpenTextRequestSchema, a as CodeCollabV2RefreshTextRequestSchema, b as CodeCollabV2SaveTextRequestSchema, c as CodeCollabV2OpenCurrentDiffRequestSchema, d as CodeCollabV2OpenAllChangesDiffRequestSchema, e as CodeCollabV2OpenTurnDiffRequestSchema, f as CodeCollabV2InitDirectoryRequestSchema, g as CodeCollabV2OpenTextOkSchema, h as CodeCollabV2RefreshTextResponseSchema, i as CodeCollabV2SaveTextResponseSchema, j as CodeCollabV2OpenCurrentDiffResponseSchema, k as CodeCollabV2OpenAllChangesDiffResponseSchema, l as CodeCollabV2OpenTurnDiffResponseSchema, m as CodeCollabV2InitDirectoryOkSchema, n as CodeCollabV2LspUnsupportedSchema, o as CodeCollabV2ErrorSchema, p as CodeCollabV2RpcContentEnvelopeSchema, q as deriveCodeCollabV2ContentKeyId, r as CodeCollabV2ErrorCodeSchema, s as CodeCollabV2RpcResponseSchema, t as deriveCodeCollabV2ContentKeyBytes, u as readCodeCollabFileIndexSignalFromFlock, w as writeCodeCollabFileIndexSignalToFlock, v as writeCodeCollabFileIndexToFlock, x as buildCodeCollabFileIndexState, y as CODE_COLLAB_V2_TEXT_LIMITS, z as CODE_COLLAB_V2_ALL_CHANGES_DIFF_LIMITS, A as computeAllChanges, B as codeCollabFileIndexStatesEqual, D as scanGitDirectoryEntries, E as closeDirectoryQuietly } from "./chunks/directory-handle-OPjjCl3O.js";
 import { C as ClientSideConnection, P as PROTOCOL_VERSION, p as packageJson, n as ndJsonStream } from "./chunks/package-qnDHmQq4.js";
 import { StringDecoder } from "node:string_decoder";
 import { pipeline, finished } from "node:stream/promises";
+import { r as runtimeManifest } from "./chunks/runtime-manifest-Fr5DEH54.js";
 import { AsyncLocalStorage as AsyncLocalStorage$1 } from "async_hooks";
 import { createRequire } from "module";
 import { c as computeLineCounts, a as countTextLines } from "./chunks/diff-line-counts-bmGB_T-n.js";
@@ -2292,7 +2293,7 @@ Upgrade Node, then re-run: npx lody@latest`;
       return frames;
     };
   }
-  const version$8 = "5.38.8";
+  const version$9 = "5.38.8";
   const FeatureFlagError = {
     ERRORS_WHILE_COMPUTING: "errors_while_computing_flags",
     FLAG_MISSING: "flag_missing",
@@ -3470,7 +3471,7 @@ Upgrade Node, then re-run: npx lody@latest`;
       return this.options.fetch ? this.options.fetch(url, options) : fetch(url, options);
     }
     getLibraryVersion() {
-      return version$8;
+      return version$9;
     }
     getCustomUserAgent() {
       return `${this.getLibraryId()}/${this.getLibraryVersion()}`;
@@ -4319,7 +4320,7 @@ Upgrade Node, then re-run: npx lody@latest`;
     throw new Error(`Unrecognized ${PLATFORM_ENV_VAR} value: ${JSON.stringify(raw2)} (expected "local" or "cloud")`);
   }
   const name$2 = "lody";
-  const version$7 = "0.76.0";
+  const version$8 = "0.76.0";
   const normalizeRuntimeEnv = (value) => {
     switch (value?.toLowerCase()) {
       case "dev":
@@ -4568,6 +4569,11 @@ Upgrade Node, then re-run: npx lody@latest`;
       agentType: "kimi",
       displayName: "Kimi Code"
     },
+    {
+      runtimeName: "grok-build",
+      agentType: "grok",
+      displayName: "Grok"
+    },
     {
       runtimeName: "claude-code",
       agentType: "claude",
@@ -4585,7 +4591,7 @@ Upgrade Node, then re-run: npx lody@latest`;
       return false;
     }
     const record2 = value;
-    return (record2.codexPath === void 0 || typeof record2.codexPath === "string") && (record2.claudeCodeExecutable === void 0 || typeof record2.claudeCodeExecutable === "string") && (record2.kimiPath === void 0 || typeof record2.kimiPath === "string");
+    return (record2.codexPath === void 0 || typeof record2.codexPath === "string") && (record2.claudeCodeExecutable === void 0 || typeof record2.claudeCodeExecutable === "string") && (record2.kimiPath === void 0 || typeof record2.kimiPath === "string") && (record2.grokPath === void 0 || typeof record2.grokPath === "string");
   };
   const hasBuiltinRuntimeOverrideValues = (runtimeOverrides) => !!runtimeOverrides && Object.values(runtimeOverrides).some((value) => typeof value === "string" && value.trim().length > 0);
   const getBuiltinRuntimeOverrideSourceVersionSuffix = (runtimeOverrides) => hasBuiltinRuntimeOverrideValues(runtimeOverrides) ? `+override:${JSON.stringify(runtimeOverrides)}` : "";
@@ -4619,6 +4625,7 @@ Upgrade Node, then re-run: npx lody@latest`;
   const CODEX_AUTO_REVIEW_MODE_ID = "agent-auto-review";
   const BUILTIN_DEFAULT_MODE_IDS = {
     kimi: "auto",
+    grok: "agent",
     claude: "auto",
     codex: CODEX_AUTO_REVIEW_MODE_ID
   };
@@ -11243,6 +11250,7 @@ Requirements:
   const WorktreeCleanupScriptConfigSchema = WorktreeSetupScriptConfigSchema;
   _enum$1([
     "kimi",
+    "grok",
     "claude",
     "codex"
   ]);
@@ -11258,7 +11266,8 @@ Requirements:
   const BuiltinRuntimeOverridesSchema = object$1({
     codexPath: string$1().optional(),
     claudeCodeExecutable: string$1().optional(),
-    kimiPath: string$1().optional()
+    kimiPath: string$1().optional(),
+    grokPath: string$1().optional()
   }).strict();
   const AcpConfigOptionValueSchema = union$7([
     string$1(),
@@ -14248,32 +14257,16 @@ Requirements:
         }
       }
     },
-    {
-      id: "grok-build",
-      name: "Grok Build",
-      version: "1.0.0",
-      description: "xAI's coding agent and CLI",
-      icon: "https://cdn.agentclientprotocol.com/registry/v1/latest/grok-build.svg",
-      distribution: {
-        npx: {
-          package: "@xai-official/grok@1.0.0",
-          args: [
-            "agent",
-            "stdio"
-          ]
-        }
-      }
-    },
     {
       id: "harn",
       name: "Harn",
-      version: "0.10.69",
+      version: "0.10.70",
       description: "Harn runs .harn agent pipelines as a native ACP coding agent over stdio.",
       icon: "https://cdn.agentclientprotocol.com/registry/v1/latest/harn.svg",
       distribution: {
         binary: {
           "darwin-aarch64": {
-            archive: "https://github.com/burin-labs/harn/releases/download/v0.10.69/harn-aarch64-apple-darwin.tar.gz",
+            archive: "https://github.com/burin-labs/harn/releases/download/v0.10.70/harn-aarch64-apple-darwin.tar.gz",
             cmd: "./harn",
             args: [
               "serve",
@@ -14281,7 +14274,7 @@ Requirements:
             ]
           },
           "darwin-x86_64": {
-            archive: "https://github.com/burin-labs/harn/releases/download/v0.10.69/harn-x86_64-apple-darwin.tar.gz",
+            archive: "https://github.com/burin-labs/harn/releases/download/v0.10.70/harn-x86_64-apple-darwin.tar.gz",
             cmd: "./harn",
             args: [
               "serve",
@@ -14289,7 +14282,7 @@ Requirements:
             ]
           },
           "linux-aarch64": {
-            archive: "https://github.com/burin-labs/harn/releases/download/v0.10.69/harn-aarch64-unknown-linux-gnu.tar.gz",
+            archive: "https://github.com/burin-labs/harn/releases/download/v0.10.70/harn-aarch64-unknown-linux-gnu.tar.gz",
             cmd: "./harn",
             args: [
               "serve",
@@ -14297,7 +14290,7 @@ Requirements:
             ]
           },
           "linux-x86_64": {
-            archive: "https://github.com/burin-labs/harn/releases/download/v0.10.69/harn-x86_64-unknown-linux-gnu.tar.gz",
+            archive: "https://github.com/burin-labs/harn/releases/download/v0.10.70/harn-x86_64-unknown-linux-gnu.tar.gz",
             cmd: "./harn",
             args: [
               "serve",
@@ -14305,7 +14298,7 @@ Requirements:
             ]
           },
           "windows-x86_64": {
-            archive: "https://github.com/burin-labs/harn/releases/download/v0.10.69/harn-x86_64-pc-windows-msvc.zip",
+            archive: "https://github.com/burin-labs/harn/releases/download/v0.10.70/harn-x86_64-pc-windows-msvc.zip",
             cmd: "harn.exe",
             args: [
               "serve",
@@ -23210,10 +23203,18 @@ ${context2.authorReply.trim()}
     const exhaustive = room;
     throw new Error(`Unsupported local data-plane room: ${String(exhaustive)}`);
   }
+  function createUtf8StreamDecoder() {
+    const decoder2 = new TextDecoder("utf-8");
+    return (chunk) => decoder2.decode(chunk, {
+      stream: true
+    });
+  }
   function createJsonLineSplitter(options) {
+    const decodeChunk = createUtf8StreamDecoder();
     let buffer2 = "";
     let discardingOversizedLine = false;
-    return (chunk) => {
+    return (input2) => {
+      let chunk = typeof input2 === "string" ? input2 : decodeChunk(input2);
       if (discardingOversizedLine) {
         const newlineIndex2 = chunk.indexOf("\n");
         if (newlineIndex2 < 0) {
@@ -24594,6 +24595,7 @@ ${peerId}`;
   };
   const SUPPORTED_CLI_TYPES = [
     "kimi",
+    "grok",
     "claude",
     "codex"
   ];
@@ -24636,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$6 = "0.77.2";
+  const version$7 = "0.78.0";
   const type$2 = "module";
   const scripts = {
     "dev": "node dev.mjs",
@@ -24653,7 +24655,7 @@ ${peerId}`;
   };
   const pkg = {
     name: name$1,
-    version: version$6,
+    version: version$7,
     "private": true,
     type: type$2,
     scripts,
@@ -24789,7 +24791,7 @@ ${peerId}`;
   }
   const runtimeEnv = getRuntimeEnv();
   const apiKey = resolveApiKey();
-  const release = `${name$2}@${version$7}`;
+  const release = `${name$2}@${version$8}`;
   const distinctId = resolveDistinctId();
   const errorReportingEnabled = runtimeEnv !== "dev" && !!apiKey;
   let client$1 = null;
@@ -24801,9 +24803,9 @@ ${peerId}`;
   }
   const baseExceptionProps = {
     $lib: "lody-cli",
-    $lib_version: version$7,
+    $lib_version: version$8,
     platform: "cli",
-    app_version: version$7,
+    app_version: version$8,
     env: runtimeEnv,
     release,
     machine_id: distinctId
@@ -30413,9 +30415,9 @@ ${originalIndentation}`;
     })(common$2);
     return common$2;
   }
-  const version$5 = "3.19.0";
+  const version$6 = "3.19.0";
   const require$$2$3 = {
-    version: version$5
+    version: version$6
   };
   var transports = {};
   var winstonTransport = {
@@ -111070,6 +111072,17 @@ ${incoming}`).output;
     isCodexAgent() {
       return this.options.agentConfig?.agentType === "codex";
     }
+    getGrokClientIdentifier() {
+      return this.options.agentConfig?.cliType === "builtin" && this.options.agentConfig.agentType === "grok" ? `lody:${this.options.sessionId}` : void 0;
+    }
+    getGrokSessionMeta() {
+      const clientIdentifier = this.getGrokClientIdentifier();
+      return clientIdentifier ? {
+        _meta: {
+          clientIdentifier
+        }
+      } : {};
+    }
     isCurrentAcpSession(acpSessionId) {
       return this.acpSessionId !== null && acpSessionId === this.acpSessionId;
     }
@@ -111087,6 +111100,8 @@ ${incoming}`).output;
     async startSession(stream2, workdir, resumeSessionId, timeoutOptions = {}, startupAbort, resolveSessionStart, forkSessionId, forkSessionTurnId) {
       const connection2 = new ClientSideConnection(() => this, stream2);
       this.connection = connection2;
+      const grokClientIdentifier = this.getGrokClientIdentifier();
+      const grokSessionMeta = this.getGrokSessionMeta();
       this.logger.debug(`[${this.options.sessionId}] Starting ACP client (workdir=${workdir} resumeSessionId=${resumeSessionId ?? "none"} forkSessionId=${forkSessionId ?? "none"})`);
       if (resumeSessionId && forkSessionId) {
         throw new Error("[ACP_SESSION_START_INVALID] resumeSessionId and forkSessionId are exclusive");
@@ -111117,6 +111132,11 @@ ${incoming}`).output;
       try {
         initResponse = await withTimeout$2(withAbort(connection2.initialize({
           protocolVersion: PROTOCOL_VERSION,
+          ...grokClientIdentifier ? {
+            _meta: {
+              clientIdentifier: grokClientIdentifier
+            }
+          } : {},
           clientCapabilities: {
             terminal: this.terminalEnabled,
             plan: {},
@@ -111307,7 +111327,8 @@ ${incoming}`).output;
           const loadResponse = await withTimeout$2(withAbort(connection2.loadSession({
             sessionId: resumeSessionId,
             cwd: workdir,
-            mcpServers
+            mcpServers,
+            ...grokSessionMeta
           }), startupAbort), this.logger, "connection.loadSession", this.options.sessionId, ACP_LOAD_SESSION_TIMEOUT_MS);
           const loadDurationMs = performance$1.now() - loadStart;
           sessionResponse = {
@@ -111348,7 +111369,8 @@ ${incoming}`).output;
           const resumeResponse = await withTimeout$2(withAbort(connection2.resumeSession({
             sessionId: resumeSessionId,
             cwd: workdir,
-            mcpServers
+            mcpServers,
+            ...grokSessionMeta
           }), startupAbort), this.logger, "connection.resumeSession", this.options.sessionId, ACP_RESUME_SESSION_TIMEOUT_MS);
           const resumeDurationMs = performance$1.now() - resumeStart;
           sessionResponse = {
@@ -111387,7 +111409,8 @@ ${incoming}`).output;
         try {
           sessionResponse = await withTimeout$2(withAbort(connection2.newSession({
             cwd: workdir,
-            mcpServers
+            mcpServers,
+            ...grokSessionMeta
           }), startupAbort), this.logger, "connection.newSession", this.options.sessionId, ACP_NEW_SESSION_TIMEOUT_MS);
         } catch (error2) {
           if (isAcpAuthenticationRequired(error2)) {
@@ -111453,7 +111476,8 @@ ${incoming}`).output;
         try {
           return await withTimeout$2(connection2.newSession({
             cwd: workdir,
-            mcpServers
+            mcpServers,
+            ...this.getGrokSessionMeta()
           }), this.logger, "connection.newSession.editAndResend", this.options.sessionId, timeoutMs);
         } catch (error2) {
           throw new Error(`[ACP_SESSION_PREPARE_FAILED] ${formatErrorMessage(error2)}`, {
@@ -121105,14 +121129,18 @@ ${error2.message}` : execaMessage;
       highWaterMark
     }));
   }
-  const version$4 = "1.4.0";
+  const version$5 = "1.4.0";
   const dependencies$1 = {
     "@openai/codex": "^0.147.0"
   };
   const codexPackageJson = {
-    version: version$4,
+    version: version$5,
     dependencies: dependencies$1
   };
+  const version$4 = "0.1.0";
+  const grokPackageJson = {
+    version: version$4
+  };
   const version$3 = "2.1.220";
   const platforms = {
     "darwin-arm64": {
@@ -121263,10 +121291,13 @@ ${error2.message}` : execaMessage;
   const CLAUDE_ACP_ADAPTER_VERSION = packageJson.version;
   const CLAUDE_CODE_RUNTIME_VERSION = claudeSdkManifestJson.version;
   const KIMI_CODE_VERSION = kimiCodePackageJson.version;
+  const GROK_ACP_ADAPTER_VERSION = grokPackageJson.version;
+  const GROK_BUILD_RUNTIME_VERSION = runtimeManifest.officialRuntime.version;
   const KIMI_CODE_MIN_NODE_VERSION = resolveMinimumNodeVersion("@moonshot-ai/kimi-code", kimiCodePackageJson.engines.node);
   const BUILTIN_CODEX_CAPABILITY_SOURCE_VERSION = `builtin-codex-acp:${CODEX_ACP_ADAPTER_VERSION}+codex:${CODEX_RUNTIME_VERSION}`;
   const BUILTIN_CLAUDE_CAPABILITY_SOURCE_VERSION = `builtin-claude-acp:${CLAUDE_ACP_ADAPTER_VERSION}+agent-sdk:${CLAUDE_AGENT_SDK_VERSION}+claude-code:${CLAUDE_CODE_RUNTIME_VERSION}`;
   const BUILTIN_KIMI_CAPABILITY_SOURCE_VERSION = `builtin-kimi:${KIMI_CODE_VERSION}`;
+  const BUILTIN_GROK_CAPABILITY_SOURCE_VERSION = `builtin-grok-acp:${GROK_ACP_ADAPTER_VERSION}+official-grok:${GROK_BUILD_RUNTIME_VERSION}`;
   const RUNTIMES = {
     codex: {
       name: "codex",
@@ -121416,6 +121447,66 @@ ${error2.message}` : execaMessage;
           cmd: "package/dist/main.mjs"
         }
       }
+    },
+    "grok-build": {
+      name: "grok-build",
+      version: GROK_BUILD_RUNTIME_VERSION,
+      platforms: {
+        "darwin-arm64": {
+          fileName: `xai-official-grok-darwin-arm64-${GROK_BUILD_RUNTIME_VERSION}.tar.zst`,
+          sha256: "63aa0a0a95e7a555a372f1a501dcf59151376d7e4d900e24e1c591ff6cc8f818",
+          size: 46222120,
+          compression: "zstd",
+          cmd: "grok",
+          executableSha256: "13c7f4f0b9abb00bf38216302ea4bab31f03e13555e3576620eca1de572a8d21",
+          executableSize: 131817232
+        },
+        "darwin-x64": {
+          fileName: `xai-official-grok-darwin-x64-${GROK_BUILD_RUNTIME_VERSION}.tar.zst`,
+          sha256: "7bf0af43ba1f3dc8e860e7f887b75966ece7bb6102cc7a3b2fb5af275f757c8a",
+          size: 50590131,
+          compression: "zstd",
+          cmd: "grok",
+          executableSha256: "a82210a961deac9f0cb72ec6c334196abf76a587be4593bc59db2deab85ee6dc",
+          executableSize: 147358e3
+        },
+        "linux-arm64": {
+          fileName: `xai-official-grok-linux-arm64-${GROK_BUILD_RUNTIME_VERSION}.tar.zst`,
+          sha256: "c888d404ad218caa251cbdbbd0da5836c807957be5a83fd8ab21b69de93469d9",
+          size: 49704069,
+          compression: "zstd",
+          cmd: "grok",
+          executableSha256: "bb7c51116564a2219f6a49850815060f416918ac407f1f2ba82c53c0b0d4383f",
+          executableSize: 133745832
+        },
+        "linux-x64": {
+          fileName: `xai-official-grok-linux-x64-${GROK_BUILD_RUNTIME_VERSION}.tar.zst`,
+          sha256: "7d0bb4309e634e0ecb63403f35fa468120f5ecf2173feb6518371be1633ecd99",
+          size: 53264623,
+          compression: "zstd",
+          cmd: "grok",
+          executableSha256: "28dbc967a5843dae2374b6834dadbab95354e685c7e5c8dc750b92a4e5fc7c3e",
+          executableSize: 163676672
+        },
+        "win32-arm64": {
+          fileName: `xai-official-grok-win32-arm64-${GROK_BUILD_RUNTIME_VERSION}.tar.zst`,
+          sha256: "c821de276cb1fa835567bd6c5589709e6ba29182d6b0c9ad7c160cc3df91145c",
+          size: 45241480,
+          compression: "zstd",
+          cmd: "grok.exe",
+          executableSha256: "9d41447b6eee77cfb7359b7f50935ae64b4e7b7e7ef56c40e6d203f5660317e1",
+          executableSize: 121471488
+        },
+        "win32-x64": {
+          fileName: `xai-official-grok-win32-x64-${GROK_BUILD_RUNTIME_VERSION}.tar.zst`,
+          sha256: "5d66d3e0c1e54b050c76b77dfc1dadefbf3e909459a31b4361d8307a671c179c",
+          size: 48124303,
+          compression: "zstd",
+          cmd: "grok.exe",
+          executableSha256: "d546dbc995c2ce9ba97c044d6af6b53f8c11c414a6355bf006802d07c572f406",
+          executableSize: 139903488
+        }
+      }
     }
   };
   function sanitizeSegment(segment) {
@@ -122144,6 +122235,9 @@ ${error2.message}` : execaMessage;
         if (input2.agentType === "kimi") {
           return `${BUILTIN_KIMI_CAPABILITY_SOURCE_VERSION}${runtimeOverrideSuffix}`;
         }
+        if (input2.agentType === "grok") {
+          return `${BUILTIN_GROK_CAPABILITY_SOURCE_VERSION}${runtimeOverrideSuffix}`;
+        }
       }
       return `builtin:${input2.agentType}:unknown`;
     }
@@ -122328,6 +122422,24 @@ ${error2.message}` : execaMessage;
         }
       };
     }
+    if (input2.agentType === "grok") {
+      const overridePath2 = trimRuntimeOverride(input2.runtimeOverrides?.grokPath);
+      const grokPath = overridePath2 ?? await getManagedAgentRuntimeManager().ensureRuntime("grok-build", {
+        onProgress: input2.onManagedRuntimeProgress,
+        signal: input2.signal
+      });
+      return {
+        command: process.execPath,
+        args: [
+          ...resolveCliAdapterEntry("grok-acp"),
+          ...input2.extraArgs ?? []
+        ],
+        env: {
+          GROK_PATH: grokPath,
+          GROK_DISABLE_AUTOUPDATER: "1"
+        }
+      };
+    }
     const overridePath = trimRuntimeOverride(input2.runtimeOverrides?.claudeCodeExecutable);
     const claudePath = overridePath ?? await getManagedAgentRuntimeManager().ensureRuntime("claude-code", {
       onProgress: input2.onManagedRuntimeProgress,
@@ -122375,6 +122487,24 @@ ${error2.message}` : execaMessage;
         ]
       };
     }
+    if (input2.agentType === "grok") {
+      if (input2.action === "status") return null;
+      const overridePath2 = trimRuntimeOverride(input2.runtimeOverrides?.grokPath);
+      const grokPath = overridePath2 ?? await getManagedAgentRuntimeManager().ensureRuntime("grok-build", {
+        onProgress: input2.onManagedRuntimeProgress,
+        signal: input2.signal
+      });
+      return {
+        command: grokPath,
+        args: [
+          "login",
+          "--device-auth"
+        ],
+        env: {
+          GROK_DISABLE_AUTOUPDATER: "1"
+        }
+      };
+    }
     const overridePath = trimRuntimeOverride(input2.runtimeOverrides?.claudeCodeExecutable);
     const claudePath = overridePath ?? await getManagedAgentRuntimeManager().ensureRuntime("claude-code", {
       onProgress: input2.onManagedRuntimeProgress,
@@ -123696,6 +123826,9 @@ enabled = false
     if (agentType === "codex") {
       return url.hostname === "auth.openai.com" && (url.pathname.startsWith("/codex/device") || url.pathname.startsWith("/oauth/authorize"));
     }
+    if (agentType === "grok") {
+      return hasDomain(url.hostname, "accounts.x.ai") && (url.pathname.startsWith("/oauth2/device") || url.pathname.startsWith("/device"));
+    }
     return hasDomain(url.hostname, "kimi.com") && url.pathname.startsWith("/code/authorize_device");
   }
   function findAuthorizationUrl(agentType, output) {
@@ -123765,6 +123898,18 @@ enabled = false
         ]
       }
     ],
+    grok: [
+      {
+        id: "xai-device-login",
+        name: "xAI",
+        description: "Sign in with an xAI account",
+        type: "terminal",
+        args: [
+          "login",
+          "--device-auth"
+        ]
+      }
+    ],
     claude: [
       {
         id: "claude-ai-login",
@@ -123811,7 +123956,7 @@ enabled = false
         status: "unknown"
       };
     }
-    if (options.agentType === "kimi" || options.agentType === "codex") {
+    if (options.agentType === "kimi" || options.agentType === "grok" || options.agentType === "codex") {
       return {
         status: "unknown"
       };
@@ -129381,10 +129526,20 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       this.captureStatusChanged(options.sessionId, "idle", void 0, "turn_failed");
     }
     formatMemoryPressureFailureMessage(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). The turn was not started; free memory and retry.${commitText}`;
+      if (result.pressureReason === "darwin_pressure_critical") {
+        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`;
+      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 (${availableMb} available, safety margin ${marginMb}). The turn was not started; free memory and retry.${commitText}`;
     }
     recordKnownChatFailureAndHaltEffect(options) {
       return this.tryPromise(() => this.recordKnownChatFailure(options)).pipe(flatMap$2(() => fail(new SessionTurnHalted({
@@ -146288,7 +146443,8 @@ ${edit.newString}` : edit.newString;
   }
   const LEGACY_BUILTIN_AGENT_TYPES = /* @__PURE__ */ new Set([
     "claude",
-    "codex"
+    "codex",
+    "grok"
   ]);
   function inferAgentConfigCliType(agentType) {
     const normalized = normalizeCliValue(agentType)?.toLowerCase();
@@ -166940,15 +167096,28 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
   }
   const execFileAsync = promisify$1(execFile$1);
   const MEMORY_PROBE_TIMEOUT_MS = 1e3;
+  const DARWIN_PRESSURE_NORMAL = 1;
+  const DARWIN_PRESSURE_WARNING = 2;
+  const DARWIN_PRESSURE_CRITICAL = 4;
   async function getMemoryPressureSnapshot() {
-    const windowsStatus = await getWindowsMemoryStatus();
+    const [windowsStatus, darwinPressureLevel] = await Promise.all([
+      getWindowsMemoryStatus(),
+      getDarwinMemoryPressureLevel()
+    ]);
     const systemAvailable = await getSystemAvailableMemoryBytes(windowsStatus);
-    const cgroupAvailable = getCgroupAvailableMemoryBytes();
-    const availableMemoryBytes = cgroupAvailable !== null ? Math.min(systemAvailable, cgroupAvailable) : systemAvailable;
+    const cgroup = readCgroupMemoryState();
+    const availableMemoryBytes = cgroup !== null ? Math.min(systemAvailable, cgroup.hardHeadroomBytes + cgroup.reclaimableBytes) : systemAvailable;
     const effectiveMemoryLimitBytes = getEffectiveMemoryLimitBytes();
     return {
       availableMemoryBytes,
       effectiveMemoryLimitBytes,
+      ...darwinPressureLevel !== null ? {
+        memoryPressureLevel: darwinPressureLevel
+      } : {},
+      ...cgroup !== null ? {
+        cgroup,
+        hostAvailableBytes: systemAvailable
+      } : {},
       ...windowsStatus ? {
         availableCommitBytes: windowsStatus.availableCommitBytes,
         commitLimitBytes: windowsStatus.commitLimitBytes,
@@ -166958,7 +167127,7 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
   }
   function getEffectiveMemoryLimitBytes() {
     const totalMem = os__default$1.totalmem();
-    const cgroupMax = getCgroupMemoryMaxBytes();
+    const cgroupMax = findTightestCgroupLimit()?.maxBytes ?? null;
     if (cgroupMax !== null) {
       return Math.min(totalMem, cgroupMax);
     }
@@ -167031,6 +167200,34 @@ $mem | ConvertTo-Json -Compress
       return null;
     }
   }
+  async function getDarwinMemoryPressureLevel() {
+    if (process.platform !== "darwin") {
+      return null;
+    }
+    try {
+      const { stdout } = await execFileAsync("sysctl", [
+        "-n",
+        "kern.memorystatus_vm_pressure_level"
+      ], {
+        encoding: "utf8",
+        timeout: MEMORY_PROBE_TIMEOUT_MS
+      });
+      return parseDarwinPressureLevel(String(stdout ?? ""));
+    } catch {
+      return null;
+    }
+  }
+  function parseDarwinPressureLevel(raw2) {
+    const trimmed2 = raw2.trim();
+    if (!/^\d+$/.test(trimmed2)) {
+      return null;
+    }
+    const value = Number.parseInt(trimmed2, 10);
+    if (value === DARWIN_PRESSURE_NORMAL || value === DARWIN_PRESSURE_WARNING || value === DARWIN_PRESSURE_CRITICAL) {
+      return value;
+    }
+    return null;
+  }
   async function getDarwinAvailableMemoryBytes() {
     if (process.platform !== "darwin") {
       return null;
@@ -167078,23 +167275,20 @@ $mem | ConvertTo-Json -Compress
     const availablePages = freePages + speculativePages + purgeablePages + reclaimableCachedPages;
     return availablePages * pageSize;
   }
-  function getCgroupMemoryMaxBytes() {
+  function findTightestCgroupLimit() {
     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 raw2 = readFileSafe(memMaxPath);
-        if (raw2 !== null) {
-          const trimmed2 = raw2.trim();
-          if (trimmed2 !== "max") {
-            const value = parseInt(trimmed2, 10);
-            if (Number.isFinite(value) && value > 0) {
-              tightest = tightest === null ? value : Math.min(tightest, value);
-            }
-          }
+        const prefix = `/sys/fs/cgroup${current2 === "/" ? "" : current2}`;
+        const value = parseCgroupLimit(readFileSafe(`${prefix}/memory.max`));
+        if (value !== null && (tightest === null || value < tightest.maxBytes)) {
+          tightest = {
+            prefix,
+            maxBytes: value
+          };
         }
         if (current2 === "/" || current2 === "") break;
         const parent = current2.substring(0, current2.lastIndexOf("/")) || "/";
@@ -167106,42 +167300,72 @@ $mem | ConvertTo-Json -Compress
       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 raw2 = readFileSafe(`${prefix}/memory.max`);
-        if (raw2 !== null) {
-          const trimmed2 = raw2.trim();
-          if (trimmed2 !== "max") {
-            const value = parseInt(trimmed2, 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;
+  function parseCgroupLimit(raw2) {
+    if (raw2 === null) return null;
+    const trimmed2 = raw2.trim();
+    if (trimmed2 === "max") return null;
+    const value = parseInt(trimmed2, 10);
+    return Number.isFinite(value) && value > 0 ? value : null;
+  }
+  function readCgroupMemoryState() {
+    const limit2 = findTightestCgroupLimit();
+    if (limit2 === null) return null;
+    const currentRaw = readFileSafe(`${limit2.prefix}/memory.current`);
+    if (currentRaw === null) return null;
+    const currentBytes = parseInt(currentRaw.trim(), 10);
+    if (!Number.isFinite(currentBytes)) return null;
+    const stat2 = parseCgroupMemoryStat(readFileSafe(`${limit2.prefix}/memory.stat`) ?? "");
+    return {
+      path: limit2.prefix,
+      maxBytes: limit2.maxBytes,
+      highBytes: parseCgroupLimit(readFileSafe(`${limit2.prefix}/memory.high`)),
+      currentBytes,
+      hardHeadroomBytes: Math.max(0, limit2.maxBytes - currentBytes),
+      reclaimableBytes: computeCgroupReclaimableBytes(stat2),
+      stat: stat2,
+      psiSomeAvg10: parseCgroupPressureSomeAvg10(readFileSafe(`${limit2.prefix}/memory.pressure`) ?? ""),
+      events: parseCgroupMemoryEvents(readFileSafe(`${limit2.prefix}/memory.events`) ?? "")
+    };
+  }
+  function parseCgroupMemoryStat(raw2) {
+    const values = /* @__PURE__ */ new Map();
+    for (const line3 of raw2.split("\n")) {
+      const match5 = line3.trim().match(/^([a-z_]+)\s+(\d+)$/);
+      if (match5?.[1] && match5[2]) {
+        values.set(match5[1], parseInt(match5[2], 10));
       }
-      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;
     }
+    return {
+      inactiveFileBytes: values.get("inactive_file") ?? 0,
+      activeFileBytes: values.get("active_file") ?? 0,
+      slabReclaimableBytes: values.get("slab_reclaimable") ?? 0,
+      dirtyBytes: (values.get("file_dirty") ?? 0) + (values.get("file_writeback") ?? 0)
+    };
+  }
+  function computeCgroupReclaimableBytes(stat2) {
+    const cleanInactiveFile = Math.max(0, stat2.inactiveFileBytes - stat2.dirtyBytes);
+    return cleanInactiveFile + Math.floor(stat2.slabReclaimableBytes / 2);
+  }
+  function parseCgroupPressureSomeAvg10(raw2) {
+    const match5 = raw2.match(/^some\s+avg10=([\d.]+)/m);
+    if (!match5?.[1]) return null;
+    const value = Number.parseFloat(match5[1]);
+    return Number.isFinite(value) ? value : null;
+  }
+  function parseCgroupMemoryEvents(raw2) {
+    const read = (key2) => {
+      const match5 = raw2.match(new RegExp(`^${key2}\\s+(\\d+)$`, "m"));
+      if (!match5?.[1]) return null;
+      const value = parseInt(match5[1], 10);
+      return Number.isFinite(value) ? value : null;
+    };
+    const high = read("high");
+    const max2 = read("max");
+    if (high === null || max2 === null) return null;
+    return {
+      high,
+      max: max2
+    };
   }
   function readSelfCgroupPath() {
     try {
@@ -167170,6 +167394,11 @@ $mem | ConvertTo-Json -Compress
   const GIB = 1024 * 1024 * 1024;
   const WINDOWS_COMMIT_THRESHOLD_FLOOR_BYTES = 512 * 1024 * 1024;
   const WINDOWS_COMMIT_THRESHOLD_CEILING_BYTES = 2 * GIB;
+  const DEFAULT_MAX_EVICTIONS_PER_CALL = 3;
+  const DEFAULT_PRESSURE_RECHECK_ATTEMPTS = 2;
+  const DEFAULT_PRESSURE_RECHECK_DELAY_MS = 500;
+  const DEFAULT_PSI_STALL_AVG10 = 10;
+  const DEFAULT_CGROUP_HARD_FLOOR_BYTES = 128 * 1024 * 1024;
   function defaultMemoryThresholdBytes() {
     const tenPercent = Math.floor(getEffectiveMemoryLimitBytes() * 0.1);
     return Math.max(GIB, Math.min(4 * GIB, tenPercent));
@@ -167179,16 +167408,83 @@ $mem | ConvertTo-Json -Compress
       idleTimeoutMs: readEnvNumber$1("LODY_SESSION_GC_IDLE_TIMEOUT_MS", 20 * 60 * 1e3),
       sweepIntervalMs: readEnvNumber$1("LODY_SESSION_GC_SWEEP_INTERVAL_MS", 60 * 1e3),
       enabled: process.env.LODY_SESSION_GC_ENABLED !== "false",
-      memoryThresholdBytes: readEnvNumber$1("LODY_SESSION_GC_MEMORY_THRESHOLD_BYTES", defaultMemoryThresholdBytes())
+      memoryThresholdBytes: readEnvNumber$1("LODY_SESSION_GC_MEMORY_THRESHOLD_BYTES", defaultMemoryThresholdBytes()),
+      maxEvictionsPerCall: readEnvNumber$1("LODY_SESSION_GC_MAX_EVICTIONS_PER_CALL", DEFAULT_MAX_EVICTIONS_PER_CALL),
+      pressureRecheckAttempts: readEnvNumber$1("LODY_SESSION_GC_PRESSURE_RECHECK_ATTEMPTS", DEFAULT_PRESSURE_RECHECK_ATTEMPTS),
+      pressureRecheckDelayMs: readEnvNumber$1("LODY_SESSION_GC_PRESSURE_RECHECK_DELAY_MS", DEFAULT_PRESSURE_RECHECK_DELAY_MS)
     };
   }
   function getWindowsCommitThresholdBytes(memoryThresholdBytes) {
     return Math.max(WINDOWS_COMMIT_THRESHOLD_FLOOR_BYTES, Math.min(WINDOWS_COMMIT_THRESHOLD_CEILING_BYTES, memoryThresholdBytes));
   }
+  function evaluateMemoryPressure(snapshot, thresholds2) {
+    if (thresholds2.platform === "darwin") {
+      if (snapshot.memoryPressureLevel === DARWIN_PRESSURE_CRITICAL) {
+        return {
+          evict: true,
+          block: true,
+          reason: "darwin_pressure_critical"
+        };
+      }
+      if (snapshot.memoryPressureLevel === DARWIN_PRESSURE_WARNING) {
+        return {
+          evict: true,
+          block: false,
+          reason: "darwin_pressure_warning"
+        };
+      }
+      return {
+        evict: false,
+        block: false,
+        reason: null
+      };
+    }
+    const commitPressure = snapshot.availableCommitBytes !== void 0 && snapshot.availableCommitBytes < thresholds2.commitThresholdBytes;
+    const cgroup = snapshot.cgroup;
+    if (cgroup) {
+      const hostLow = snapshot.hostAvailableBytes !== void 0 && snapshot.hostAvailableBytes < thresholds2.thresholdBytes;
+      const cgroupLow = cgroup.hardHeadroomBytes + cgroup.reclaimableBytes < thresholds2.thresholdBytes;
+      const stalled = cgroup.psiSomeAvg10 !== null ? cgroup.psiSomeAvg10 >= thresholds2.psiStallAvg10 : cgroup.hardHeadroomBytes < thresholds2.cgroupHardFloorBytes;
+      if (hostLow || cgroupLow && stalled) {
+        return {
+          evict: true,
+          block: true,
+          reason: stalled ? "cgroup_stalled" : "physical"
+        };
+      }
+      if (cgroupLow) {
+        return {
+          evict: true,
+          block: false,
+          reason: "cgroup_low_headroom"
+        };
+      }
+      if (commitPressure) {
+        return {
+          evict: true,
+          block: true,
+          reason: "commit"
+        };
+      }
+      return {
+        evict: false,
+        block: false,
+        reason: null
+      };
+    }
+    const physicalPressure = snapshot.availableMemoryBytes < thresholds2.thresholdBytes;
+    const reason = physicalPressure && commitPressure ? "physical_and_commit" : physicalPressure ? "physical" : commitPressure ? "commit" : null;
+    return {
+      evict: reason !== null,
+      block: reason !== null,
+      reason
+    };
+  }
   class SessionGCManager {
-    constructor(config2, deps) {
+    constructor(config2, deps, platform2 = process.platform) {
       this.config = config2;
       this.deps = deps;
+      this.platform = platform2;
     }
     sweepInterval = null;
     start() {
@@ -167196,7 +167492,8 @@ $mem | ConvertTo-Json -Compress
         this.deps.logger.debug("[GC] Session GC is disabled");
         return;
       }
-      this.deps.logger.debug(`[GC] Starting session GC (interval=${this.config.sweepIntervalMs}ms, idleTimeout=${this.config.idleTimeoutMs}ms, memoryThreshold=${Math.round(this.config.memoryThresholdBytes / 1024 / 1024)}MB)`);
+      const pressureSignal = this.platform === "darwin" ? "kern.memorystatus_vm_pressure_level" : `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);
     }
     stop() {
@@ -167236,48 +167533,39 @@ $mem | ConvertTo-Json -Compress
     async evictForMemoryPressure(excludeSessionId) {
       const thresholdBytes = this.config.memoryThresholdBytes;
       const commitThresholdBytes = getWindowsCommitThresholdBytes(thresholdBytes);
+      const thresholds2 = {
+        platform: this.platform,
+        thresholdBytes,
+        commitThresholdBytes,
+        psiStallAvg10: DEFAULT_PSI_STALL_AVG10,
+        cgroupHardFloorBytes: DEFAULT_CGROUP_HARD_FLOOR_BYTES
+      };
       let memorySnapshot = await this.deps.memoryPressure.getLatest();
-      let availableMemory = memorySnapshot.availableMemoryBytes;
-      let pressureReason = this.getPressureReason(memorySnapshot, thresholdBytes, commitThresholdBytes);
-      if (!this.config.enabled) {
-        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
-          } : {}
-        };
-      }
-      if (pressureReason === null) {
-        return {
-          availableMemoryBytes: availableMemory,
+      let verdict = evaluateMemoryPressure(memorySnapshot, thresholds2);
+      if (this.config.enabled && verdict.evict) {
+        memorySnapshot = await this.deps.memoryPressure.refresh();
+        verdict = evaluateMemoryPressure(memorySnapshot, thresholds2);
+      }
+      if (!this.config.enabled || !verdict.evict) {
+        return this.buildEvictionResult({
+          snapshot: memorySnapshot,
           thresholdBytes,
+          commitThresholdBytes,
           hadMemoryPressure: false,
-          stillUnderPressure: false,
-          evictedSessionIds: [],
-          pressureReason: null,
-          ...memorySnapshot.availableCommitBytes !== void 0 ? {
-            availableCommitBytes: memorySnapshot.availableCommitBytes,
-            commitThresholdBytes,
-            commitLimitBytes: memorySnapshot.commitLimitBytes,
-            committedBytes: memorySnapshot.committedBytes
-          } : {}
-        };
+          verdict: this.config.enabled ? verdict : {
+            evict: false,
+            block: false,
+            reason: null
+          },
+          evictedSessionIds: []
+        });
       }
-      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}`);
+      this.deps.logger.debug(`[GC] Memory pressure detected (${verdict.reason}): ${this.describeMemoryState(memorySnapshot, thresholdBytes, commitThresholdBytes)}`);
       const sessions = this.getSessionsWithIdleTime();
       sessions.sort((a, b) => b.idleMs - a.idleMs);
       const evictedSessionIds = [];
       for (const { sessionId, idleMs } of sessions) {
-        if (pressureReason === null) {
+        if (!verdict.evict || evictedSessionIds.length >= this.config.maxEvictionsPerCall) {
           break;
         }
         if (excludeSessionId && sessionId === excludeSessionId) {
@@ -167294,46 +167582,78 @@ $mem | ConvertTo-Json -Compress
           await this.deps.cleanSession(sessionId);
           evictedSessionIds.push(sessionId);
           memorySnapshot = await this.deps.memoryPressure.refresh();
-          availableMemory = memorySnapshot.availableMemoryBytes;
-          pressureReason = this.getPressureReason(memorySnapshot, thresholdBytes, commitThresholdBytes);
+          verdict = evaluateMemoryPressure(memorySnapshot, thresholds2);
         } catch (error2) {
           this.deps.logger.error(`[GC] Failed to evict session ${sessionId}: ${formatErrorMessage(error2)}`);
         }
       }
-      const stillUnderPressure = pressureReason !== null;
+      for (let attempt = 0; verdict.block && attempt < this.config.pressureRecheckAttempts; attempt++) {
+        await this.sleep(this.config.pressureRecheckDelayMs);
+        memorySnapshot = await this.deps.memoryPressure.refresh();
+        verdict = evaluateMemoryPressure(memorySnapshot, thresholds2);
+        if (!verdict.block) {
+          this.deps.logger.debug(`[GC] Memory pressure cleared on recheck ${attempt + 1}: ${this.describeMemoryState(memorySnapshot, thresholdBytes, commitThresholdBytes)}`);
+        }
+      }
+      const availableMemory = memorySnapshot.availableMemoryBytes;
+      const stillUnderPressure = verdict.block;
       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,
+      return this.buildEvictionResult({
+        snapshot: memorySnapshot,
         thresholdBytes,
+        commitThresholdBytes,
         hadMemoryPressure: true,
-        stillUnderPressure,
-        evictedSessionIds,
-        pressureReason,
-        ...memorySnapshot.availableCommitBytes !== void 0 ? {
-          availableCommitBytes: memorySnapshot.availableCommitBytes,
+        verdict,
+        evictedSessionIds
+      });
+    }
+    buildEvictionResult(options) {
+      const { snapshot, thresholdBytes, commitThresholdBytes, verdict } = options;
+      return {
+        availableMemoryBytes: snapshot.availableMemoryBytes,
+        thresholdBytes,
+        hadMemoryPressure: options.hadMemoryPressure,
+        stillUnderPressure: verdict.block,
+        evictedSessionIds: options.evictedSessionIds,
+        pressureReason: verdict.reason,
+        ...snapshot.memoryPressureLevel !== void 0 ? {
+          memoryPressureLevel: snapshot.memoryPressureLevel
+        } : {},
+        ...snapshot.cgroup !== void 0 ? {
+          cgroup: snapshot.cgroup
+        } : {},
+        ...snapshot.hostAvailableBytes !== void 0 ? {
+          hostAvailableBytes: snapshot.hostAvailableBytes
+        } : {},
+        ...snapshot.availableCommitBytes !== void 0 ? {
+          availableCommitBytes: snapshot.availableCommitBytes,
           commitThresholdBytes,
-          commitLimitBytes: memorySnapshot.commitLimitBytes,
-          committedBytes: memorySnapshot.committedBytes
+          commitLimitBytes: snapshot.commitLimitBytes,
+          committedBytes: snapshot.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";
+    sleep(ms2) {
+      if (this.deps.sleep) return this.deps.sleep(ms2);
+      return new Promise((resolve2) => {
+        setTimeout(resolve2, ms2).unref?.();
+      });
+    }
+    describeMemoryState(snapshot, thresholdBytes, commitThresholdBytes) {
+      if (snapshot.memoryPressureLevel !== void 0) {
+        return `kernel pressure level ${snapshot.memoryPressureLevel}`;
       }
-      if (commitPressure) {
-        return "commit";
+      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`;
       }
-      return null;
+      const commitText = snapshot.availableCommitBytes !== void 0 ? `, commit headroom ${Math.round(snapshot.availableCommitBytes / 1024 / 1024)}MB (threshold: ${Math.round(commitThresholdBytes / 1024 / 1024)}MB)` : "";
+      return `${Math.round(snapshot.availableMemoryBytes / 1024 / 1024)}MB available (threshold: ${Math.round(thresholdBytes / 1024 / 1024)}MB)${commitText}`;
     }
     async getIdleCandidates() {
       const sessions = this.getSessionsWithIdleTime();
@@ -178064,13 +178384,14 @@ export PATH=${toSingleQuotedShellString(ghShimBinDir)}:"$PATH"
     await removeStaleUnixSocket(socketPath, "local_terminal_socket_in_use");
     const server = net.createServer((socket) => {
       let buffer2 = "";
+      const decodeChunk = createUtf8StreamDecoder();
       const state2 = createTerminalSocketState();
       activeClientSockets$1.add(socket);
       const unsubscribe = config2.terminalPtyService.onEvent((event) => {
         publishTerminalEvent(socket, state2, event);
       });
       socket.on("data", (chunk) => {
-        buffer2 += chunk.toString("utf8");
+        buffer2 += decodeChunk(chunk);
         if (buffer2.length > MAX_BUFFER_BYTES) {
           send(socket, {
             type: "error",
@@ -178228,7 +178549,7 @@ export PATH=${toSingleQuotedShellString(ghShimBinDir)}:"$PATH"
           });
         }
       });
-      socket.on("data", (chunk) => splitLines(chunk.toString("utf8")));
+      socket.on("data", (chunk) => splitLines(chunk));
       socket.setTimeout(CONNECTION_IDLE_TIMEOUT_MS, () => {
         config2.logger.debug(`[loro-data-plane] connection ${connectionId} idle; dropping`);
         socket.destroy();
@@ -185404,10 +185725,11 @@ Shutting down gracefully${reason}...`);
   function logCliDetectionResults(logger2, availability) {
     logger2.debug("Local agent auth detection results:");
     logger2.debug(`kimi: ${availability.kimi || "not found"}`);
+    logger2.debug(`grok: ${availability.grok || "not found"}`);
     logger2.debug(`claude: ${availability.claude || "not found"}`);
     logger2.debug(`codex: ${availability.codex || "not found"}`);
   }
-  const startCommand = new Command("start").description("Start agent service in native mode").option("--machine-name <name>", "Machine name to register (defaults to hostname)").option("--cli-types <types...>", "Specify CLI types to register: `kimi`, `claude`, or `codex`", (value, previous) => {
+  const startCommand = new Command("start").description("Start agent service in native mode").option("--machine-name <name>", "Machine name to register (defaults to hostname)").option("--cli-types <types...>", "Specify CLI types to register: `kimi`, `grok`, `claude`, or `codex`", (value, previous) => {
     if (!previous) {
       return [
         value
@@ -185435,7 +185757,7 @@ Shutting down gracefully${reason}...`);
     });
     scrubLocalSupervisorCapabilityEnv();
     await traceAsync(logger2, "startup.process_resource_profile", void 0, async () => normalizeCurrentProcessResourceProfile(logger2));
-    for (const diagnostic of getRuntimeDiagnostics(version$7)) {
+    for (const diagnostic of getRuntimeDiagnostics(version$8)) {
       logger2.info(diagnostic);
     }
     if (options.heartbeatLog) {
@@ -185498,6 +185820,7 @@ Shutting down gracefully${reason}...`);
     const cliDetectionStartedAt = Date.now();
     const cliAvailability = {
       kimi: "managed-runtime",
+      grok: "managed-runtime",
       claude: checkClaude(),
       codex: checkCodex()
     };
@@ -185505,6 +185828,7 @@ Shutting down gracefully${reason}...`);
     logCliDetectionResults(logger2, cliAvailability);
     captureAgentServiceEvent("agent_service_cli_detection", {
       kimi_available: true,
+      grok_available: true,
       claude_available: Boolean(cliAvailability.claude),
       codex_available: Boolean(cliAvailability.codex)
     });
@@ -185515,7 +185839,7 @@ Shutting down gracefully${reason}...`);
       availability: cliAvailability
     });
     if (cliSelection.invalid.length > 0) {
-      logger2.error(`Unknown CLI types: ${cliSelection.invalid.join(", ")}. Supported values: kimi, claude, codex.`);
+      logger2.error(`Unknown CLI types: ${cliSelection.invalid.join(", ")}. Supported values: kimi, grok, claude, codex.`);
       process.exit(1);
     }
     if (cliSelection.missing.length > 0) {
@@ -213310,7 +213634,7 @@ ${page}${helpTipBottom}${choiceDescription}${ansiEscapes.cursorHide}`;
       data = createReviewBundleSnapshot(bundle);
     }
     const { injectReviewSnapshot } = await import("./chunks/index-VoI6Ds2-.js");
-    const { resolveReviewViewerTemplate } = await import("./chunks/review-viewer-C1f8pVKg.js").then(async (m) => {
+    const { resolveReviewViewerTemplate } = await import("./chunks/review-viewer-Bgp2Thsg.js").then(async (m) => {
       await m.__tla;
       return m;
     });
@@ -214508,6 +214832,76 @@ ${result.stdout ?? ""}`;
       return null;
     }
   }
+  function planDaemonAuthPreflight(input2) {
+    const { existingAuth, validation: validation2, interactive } = input2;
+    const login = (reason) => interactive ? {
+      action: "login",
+      reason
+    } : {
+      action: "abort",
+      reason: "login_required_non_interactive",
+      message: reason === "credentials_rejected" ? "This machine is no longer signed in to Lody." : "This machine is not connected to Lody yet."
+    };
+    if (!existingAuth || !validation2) {
+      return login("missing_credentials");
+    }
+    if (validation2.valid) {
+      return {
+        action: "proceed",
+        user: validation2.user
+      };
+    }
+    if (isTokenValidationUnavailable(validation2)) {
+      return {
+        action: "abort",
+        reason: "backend_unreachable",
+        message: validation2.error ?? validation2.reason
+      };
+    }
+    return login("credentials_rejected");
+  }
+  async function ensureDaemonBackendAuth(options) {
+    const { authClient, logger: logger2, machineName } = options;
+    const interactive = options.interactive ?? process.stdout.isTTY === true;
+    const existingAuth = authClient.getAuthInfo();
+    logger2.info("Checking the connection to Lody\u2026");
+    const validation2 = existingAuth ? await authClient.validateToken(existingAuth.token) : null;
+    const plan = planDaemonAuthPreflight({
+      existingAuth,
+      validation: validation2,
+      interactive
+    });
+    if (plan.action === "abort") {
+      return {
+        status: "failed",
+        reason: plan.reason,
+        message: plan.reason === "backend_unreachable" ? `Could not reach Lody to verify this machine's credentials: ${plan.message}` : plan.message
+      };
+    }
+    if (plan.action === "proceed") {
+      logger2.success(`${chalk.green("\u2713")} Connected as ${chalk.cyan(plan.user.name || plan.user.email)}`);
+      return {
+        status: "authenticated",
+        user: plan.user
+      };
+    }
+    logger2.info(plan.reason === "credentials_rejected" ? "This machine is no longer signed in to Lody. Sign in again to connect it." : "This machine is not connected to Lody yet. Sign in to connect it.");
+    const loginResult = await performLogin(authClient, logger2, {
+      machineName
+    });
+    if (!loginResult.success) {
+      return {
+        status: "failed",
+        reason: "login_failed",
+        message: `Login failed: ${loginResult.error}`
+      };
+    }
+    logger2.success(`${chalk.green("\u2713")} Connected as ${chalk.cyan(loginResult.user.name || loginResult.user.email)}`);
+    return {
+      status: "authenticated",
+      user: loginResult.user
+    };
+  }
   function buildDaemonStartPassthroughArgs(options, unknownArgs) {
     const sanitized = [];
     for (let index = 0; index < unknownArgs.length; index += 1) {
@@ -214661,6 +215055,20 @@ ${result.stdout ?? ""}`;
       }
     }
   }
+  function daemonAuthFailureHint(reason) {
+    switch (reason) {
+      case "backend_unreachable":
+        return `Retry once the connection is back, or start anyway with ${chalk.yellow("--skip-auth-check")}.`;
+      case "login_required_non_interactive":
+        return `Run ${chalk.yellow("lody login")} from a terminal, or pass ${chalk.yellow("--auth <cli_token>")}.`;
+      case "login_failed":
+        return `Run ${chalk.yellow("lody login")} and retry.`;
+      default: {
+        const unreachable = reason;
+        return unreachable;
+      }
+    }
+  }
   function printStartTips() {
     console.log(`Use ${chalk.yellow("lody daemon status")} to check status`);
     console.log(`Use ${chalk.yellow("lody daemon stop")} to stop`);
@@ -214681,7 +215089,7 @@ ${result.stdout ?? ""}`;
     }
     return false;
   }
-  const daemonCommand = new Command("daemon").description("Run lody as a background daemon service").addCommand(new Command("start").description("Start lody daemon in the background").option("--auth <credential>", "Connect with a CLI API key or machine connection token").option("--machine-name <name>", "Machine name to register (defaults to hostname)").allowUnknownOption(true).action(async (options, cmd) => {
+  const daemonCommand = new Command("daemon").description("Run lody as a background daemon service").addCommand(new Command("start").description("Start lody daemon in the background").option("--auth <credential>", "Connect with a CLI API key or machine connection token").option("--machine-name <name>", "Machine name to register (defaults to hostname)").option("--skip-auth-check", "Skip the backend connectivity and sign-in check before entering daemon mode").allowUnknownOption(true).action(async (options, cmd) => {
     const readiness = await checkDaemonStartReadiness();
     if (await reportDaemonStartBlocked(readiness, {
       restart: false
@@ -214689,20 +215097,46 @@ ${result.stdout ?? ""}`;
       return;
     }
     const passthroughArgs = buildDaemonStartPassthroughArgs(options, cmd.args);
-    if (options.auth) {
+    const platformKind = getCliPlatformKind();
+    if (platformKind === "local" && options.auth) {
+      console.error("--auth is not available on the local platform.");
+      await exitDaemonCommand(1);
+      return;
+    }
+    if (platformKind === "cloud" && (options.auth || !options.skipAuthCheck)) {
       createHybridLogger({
         level: "info"
       });
       const logger2 = getLogger("daemon");
       const authClient = new AuthClient(logger2);
-      const loginResult = await performLoginWithAuthCredential(authClient, logger2, {
-        credential: options.auth,
-        machineName: options.machineName
-      });
-      if (!loginResult.success) {
-        console.error(loginResult.error);
-        await exitDaemonCommand(1);
-        return;
+      if (options.auth) {
+        const loginResult = await performLoginWithAuthCredential(authClient, logger2, {
+          credential: options.auth,
+          machineName: options.machineName
+        });
+        if (!loginResult.success) {
+          captureDaemonEvent("daemon_start_failed", {
+            reason_code: "auth_credential"
+          });
+          console.error(loginResult.error);
+          await exitDaemonCommand(1);
+          return;
+        }
+      } else {
+        const preflight = await ensureDaemonBackendAuth({
+          authClient,
+          logger: logger2,
+          machineName: options.machineName
+        });
+        if (preflight.status === "failed") {
+          captureDaemonEvent("daemon_start_failed", {
+            reason_code: preflight.reason
+          });
+          console.error(preflight.message);
+          console.error(daemonAuthFailureHint(preflight.reason));
+          await exitDaemonCommand(1);
+          return;
+        }
       }
     }
     captureDaemonEvent("daemon_start_requested");
@@ -214886,9 +215320,9 @@ ${result.stdout ?? ""}`;
     const passthroughArgs = cmd.args;
     captureDaemonEvent("daemon_restart_requested");
     const runningProbeHealth = await fetchLocalProbeHealth();
-    const versionMismatchHealth = runningProbeHealth && runningProbeHealth.cliVersion !== version$7 ? runningProbeHealth : null;
+    const versionMismatchHealth = runningProbeHealth && runningProbeHealth.cliVersion !== version$8 ? runningProbeHealth : null;
     if (versionMismatchHealth) {
-      console.log(`Running daemon uses lody v${versionMismatchHealth.cliVersion}; current CLI is v${version$7}. Restarting with current CLI.`);
+      console.log(`Running daemon uses lody v${versionMismatchHealth.cliVersion}; current CLI is v${version$8}. Restarting with current CLI.`);
     }
     const stopResult = await stopDaemonProcess();
     captureDaemonEvent("daemon_stop_result", {
@@ -215095,7 +215529,7 @@ ${result.stdout ?? ""}`;
     });
     logger2.info(`Daemon watchdog started (PID ${process.pid})`);
     await normalizeCurrentProcessResourceProfile(logger2);
-    for (const diagnostic of getRuntimeDiagnostics(version$7)) {
+    for (const diagnostic of getRuntimeDiagnostics(version$8)) {
       logger2.info(diagnostic);
     }
     const passthroughArgs = cmd.args;
@@ -233492,7 +233926,7 @@ ${result.stdout ?? ""}`;
           cliToken: auth.token,
           source: "mcp",
           feedback: args2.feedback,
-          cliVersion: version$7
+          cliVersion: version$8
         }));
       } catch (error2) {
         return mcpErrorResult(error2);
@@ -234214,7 +234648,7 @@ ${lines2.join("\n")}` : ""}${suffix}`);
         cliToken: auth.token,
         source: "cli",
         feedback,
-        cliVersion: version$7
+        cliVersion: version$8
       });
       if (options.json) {
         printJson(result);
@@ -234298,7 +234732,7 @@ ${lines2.join("\n")}` : ""}${suffix}`);
     logger: getLogger("http-transport")
   });
   program = new Command();
-  program.name("lody").description("Lody Agent CLI tool for managing remote command execution").version(version$7, "-v, --version", "display version number").enablePositionalOptions();
+  program.name("lody").description("Lody Agent CLI tool for managing remote command execution").version(version$8, "-v, --version", "display version number").enablePositionalOptions();
   program.addCommand(loginCommand);
   program.addCommand(logoutCommand);
   program.addCommand(startCommand);