@karlorz/codexhost-cli-win32-x64 0.13.3-6 → 0.13.3-7

package/app/plugins/grok/plugin.mjs

@@ -408,10 +408,13 @@ function usageSessionTitle(value) {
     return void 0;
   if (normalized.length <= MAX_SESSION_TITLE_LENGTH)
     return normalized;
-  const characters = [...normalized];
-  if (characters.length <= MAX_SESSION_TITLE_LENGTH)
-    return normalized;
-  return `${characters.slice(0, MAX_SESSION_TITLE_LENGTH - 1).join("").trimEnd()}…`;
+  let title = "";
+  for (const character of normalized) {
+    if (title.length + character.length >= MAX_SESSION_TITLE_LENGTH)
+      break;
+    title += character;
+  }
+  return `${title.trimEnd()}…`;
 }
 function sessionIdOk(value) {
   return typeof value === "string" && value.length > 0 && value.length <= MAX_SESSION_ID_LENGTH;
@@ -576,7 +579,7 @@ function createGrokUsageStatistics(environment) {
 }
 
 // dist/grok-adapter.js
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 
 // dist/grok-credential-export.js
 import { createHash } from "node:crypto";
@@ -615,7 +618,7 @@ async function readGrokCredentials(environment) {
 }
 
 // dist/grok-adapter.js
-import path16 from "node:path";
+import path18 from "node:path";
 
 // ../../../node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -1383,10 +1386,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path17) {
-  if (!path17)
+function getElementAtPath(obj, path19) {
+  if (!path19)
     return obj;
-  return path17.reduce((acc, key) => acc?.[key], obj);
+  return path19.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1795,11 +1798,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path17, issues) {
+function prefixIssues(path19, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path17);
+    iss.path.unshift(path19);
     return iss;
   });
 }
@@ -1946,16 +1949,16 @@ function flattenError(error53, mapper = (issue2) => issue2.message) {
 }
 function formatError(error53, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error54, path17 = []) => {
+  const processError = (error54, path19 = []) => {
     for (const issue2 of error54.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path17, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path19, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path17, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path17, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
       } else {
-        const fullpath = [...path17, ...issue2.path];
+        const fullpath = [...path19, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1982,17 +1985,17 @@ function formatError(error53, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error53, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error54, path17 = []) => {
+  const processError = (error54, path19 = []) => {
     var _a3, _b;
     for (const issue2 of error54.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path17, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path19, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path17, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path17, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
       } else {
-        const fullpath = [...path17, ...issue2.path];
+        const fullpath = [...path19, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -2024,8 +2027,8 @@ function treeifyError(error53, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path17 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path17) {
+  const path19 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path19) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -14717,13 +14720,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path17 = ref.slice(1).split("/").filter(Boolean);
-  if (path17.length === 0) {
+  const path19 = ref.slice(1).split("/").filter(Boolean);
+  if (path19.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path17[0] === defsKey) {
-    const key = path17[1];
+  if (path19[0] === defsKey) {
+    const key = path19[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -15440,6 +15443,8 @@ var CONSOLE_HOST_METHODS = Object.freeze([
   "codexhost/harness/installation",
   "codexhost/harness/launch-settings/get",
   "codexhost/harness/launch-settings/set",
+  "codexhost/harness/grok-computer-use/get",
+  "codexhost/harness/grok-computer-use/set",
   "codexhost/harness/web-ui/open",
   "codexhost/harness/accounts/sources",
   "codexhost/harness/accounts/list",
@@ -15968,7 +15973,9 @@ var harnessInspectionSchema = external_exports.union([
 var harnessInspectParamsSchema = external_exports.object({
   harnessId: harnessIdSchema,
   cwd: nonBlankTextSchema2.max(16384).optional(),
-  refresh: external_exports.boolean().optional()
+  refresh: external_exports.boolean().optional(),
+  /** `availability` asks only whether the Harness can run; see `InspectHarnessInput.purpose`. */
+  purpose: external_exports.literal("availability").optional()
 }).strict();
 var harnessWebUiOpenParamsSchema = external_exports.object({
   harnessId: harnessIdSchema
@@ -16142,6 +16149,26 @@ var harnessLaunchSettingsSchema = external_exports.object({
   restartRequired: external_exports.boolean()
 }).strict();
 
+// ../../shared-contracts/dist/grok-computer-use.js
+var grokComputerUseGetSchema = external_exports.object({}).strict();
+var grokComputerUseSetSchema = external_exports.object({
+  enabled: external_exports.boolean().optional(),
+  browser: external_exports.boolean().optional()
+}).strict().refine((value) => value.enabled !== void 0 || value.browser !== void 0, {
+  message: "Expected enabled or browser"
+});
+var grokComputerUseSettingsSchema = external_exports.object({
+  enabled: external_exports.boolean(),
+  available: external_exports.boolean(),
+  unavailableReason: external_exports.string().min(1).max(500).optional(),
+  browser: external_exports.boolean().optional(),
+  browserFilesPresent: external_exports.boolean().optional(),
+  browserAvailable: external_exports.boolean().optional(),
+  browserUnavailableReason: external_exports.string().min(1).max(500).optional(),
+  applyFailed: external_exports.boolean().optional(),
+  applyError: external_exports.string().min(1).max(500).optional()
+}).strict();
+
 // ../../shared-contracts/dist/harness-installation.js
 var harnessInstallationParamsSchema = external_exports.object({
   harnessId: harnessIdSchema,
@@ -16588,6 +16615,320 @@ var voiceSettingsStateSchema = external_exports.strictObject({
 // ../../shared-contracts/dist/index.js
 var workspaceContractVersionSchema = external_exports.literal(WORKSPACE_CONTRACT_VERSION);
 
+// ../../harness-plugin-files/dist/grok-computer-use.js
+import { randomUUID } from "node:crypto";
+import { access, mkdir as mkdir2, readFile as readFile3, rename, rm as rm3, writeFile as writeFile2 } from "node:fs/promises";
+import os4 from "node:os";
+import path8 from "node:path";
+
+// ../../harness-plugin-files/dist/grok-computer-use-lock.js
+import { mkdir, rm as rm2 } from "node:fs/promises";
+import path7 from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+async function withGrokComputerUseLock(dataDirectory2, grokHome4, operation) {
+  const locks = [
+    .../* @__PURE__ */ new Set([
+      path7.join(dataDirectory2, ".grok-computer-use.lock"),
+      path7.join(grokHome4, ".codexhost-cua.lock")
+    ])
+  ].sort();
+  const acquired = [];
+  const deadline = Date.now() + 5e3;
+  try {
+    for (const lock of locks) {
+      await mkdir(path7.dirname(lock), { recursive: true, mode: 448 });
+      for (; ; ) {
+        try {
+          await mkdir(lock, { mode: 448 });
+          acquired.push(lock);
+          break;
+        } catch (error53) {
+          if (error53.code !== "EEXIST")
+            throw error53;
+          if (Date.now() >= deadline)
+            throw new Error("Grok Computer Use settings are locked");
+          await delay(25);
+        }
+      }
+    }
+    return await operation();
+  } finally {
+    for (const lock of acquired.reverse())
+      await rm2(lock, { recursive: true });
+  }
+}
+
+// ../../harness-plugin-files/dist/grok-computer-use.js
+var GROK_BROWSER_BINDING_SUPPORTED = false;
+var PREFERENCE_FILE = "grok-computer-use.json";
+var TABLE = "[mcp_servers.cua_repl]";
+var ENV_TABLE = "[mcp_servers.cua_repl.env]";
+var APPLY_FAILED = "Could not apply Grok Computer Use settings to Grok config.";
+var GrokComputerUseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GrokComputerUseError";
+  }
+};
+function dataDirectory(environment) {
+  return environment.CODEXHOST_DATA_DIR ? path8.resolve(environment.CODEXHOST_DATA_DIR) : path8.join(os4.homedir(), ".codexhost");
+}
+function grokHome2(environment) {
+  return environment.GROK_HOME ? path8.resolve(environment.GROK_HOME) : path8.join(environment.HOME ?? os4.homedir(), ".grok");
+}
+function chatgptApp(environment, platform) {
+  if (environment.CODEXHOST_CHATGPT_APP)
+    return path8.resolve(environment.CODEXHOST_CHATGPT_APP);
+  if (platform === "darwin")
+    return "/Applications/ChatGPT.app";
+  return void 0;
+}
+async function isFile(target) {
+  try {
+    await access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isNotFound(error53) {
+  return Boolean(error53 && typeof error53 === "object" && "code" in error53 && error53.code === "ENOENT");
+}
+async function writeAtomically(file2, content) {
+  await mkdir2(path8.dirname(file2), { recursive: true, mode: 448 });
+  const temporary = `${file2}.${randomUUID()}.tmp`;
+  try {
+    await writeFile2(temporary, content, { mode: 384, flag: "wx" });
+    await rename(temporary, file2);
+  } finally {
+    await rm3(temporary, { force: true });
+  }
+}
+function launchPaths(environment, platform) {
+  const app = chatgptApp(environment, platform);
+  if (!app)
+    return void 0;
+  const resources = path8.join(app, "Contents", "Resources");
+  const cuaNode = path8.join(resources, "cua_node");
+  return {
+    node: path8.join(cuaNode, "bin", "node"),
+    cuaRepl: path8.join(cuaNode, "lib", "node_modules", "@oai", "cua-repl", "bin", "cua-repl.mjs"),
+    nodeRepl: path8.join(cuaNode, "bin", "node_repl"),
+    nodeModules: path8.join(cuaNode, "lib", "node_modules"),
+    codexCli: path8.join(resources, "codex-cli", "bin", "codex"),
+    skyApp: path8.join(environment.HOME ?? os4.homedir(), ".codex", "computer-use", "Codex Computer Use.app"),
+    codexHome: path8.join(environment.HOME ?? os4.homedir(), ".codex"),
+    browserDesktop: path8.join(cuaNode, "lib", "node_modules", "@oai", "browser-desktop")
+  };
+}
+async function sharedRuntimePresent(launch) {
+  const present = await Promise.all([launch.node, launch.cuaRepl, launch.nodeRepl].map(isFile));
+  return present.every(Boolean);
+}
+async function computerFilesPresent(launch) {
+  const present = await Promise.all([isFile(launch.skyApp), isFile(launch.codexCli)]);
+  return present.every(Boolean);
+}
+async function browserFilesPresent(launch) {
+  return isFile(path8.join(launch.browserDesktop, "package.json"));
+}
+async function discoverGrokComputerUseLaunch(environment = process.env, platform = process.platform) {
+  const launch = launchPaths(environment, platform);
+  if (!launch || !await sharedRuntimePresent(launch))
+    return void 0;
+  return launch;
+}
+function tableRange(text, header) {
+  const lines = text.split(/\n/);
+  let start = -1;
+  for (let index = 0; index < lines.length; index += 1) {
+    if (lines[index] === header) {
+      start = index;
+      break;
+    }
+  }
+  if (start < 0)
+    return void 0;
+  let end = lines.length;
+  for (let index = start + 1; index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    if (line.startsWith("[") && line.endsWith("]")) {
+      end = index;
+      break;
+    }
+  }
+  return { start, end };
+}
+function removeTables(text, headers) {
+  let current = text;
+  for (const header of headers) {
+    const range = tableRange(current, header);
+    if (!range)
+      continue;
+    const lines = current.split(/\n/);
+    lines.splice(range.start, range.end - range.start);
+    current = lines.join("\n");
+  }
+  return current.replace(/\n{3,}/g, "\n\n");
+}
+function cuaReplEnabledInToml(text) {
+  const range = tableRange(text, TABLE);
+  if (!range)
+    return false;
+  const body = text.split(/\n/).slice(range.start, range.end);
+  for (const line of body) {
+    if (/^enabled\s*=\s*false\b/u.test(line))
+      return false;
+    if (/^enabled\s*=\s*true\b/u.test(line))
+      return true;
+  }
+  return true;
+}
+function inferredSurfaces(text) {
+  if (!cuaReplEnabledInToml(text))
+    return { enabled: false, browser: false };
+  const range = tableRange(text, ENV_TABLE);
+  const body = range ? text.split(/\n/).slice(range.start, range.end).join("\n") : "";
+  const literal2 = /^CUA_REPL_ENABLED_SURFACES\s*=\s*(["'])([^"']*)\1\s*(?:#.*)?$/mu.exec(body);
+  if (!literal2)
+    return { enabled: true, browser: false };
+  const surfaces = new Set(literal2[2]?.split(",").map((surface) => surface.trim()));
+  return { enabled: surfaces.has("computer"), browser: surfaces.has("browser") };
+}
+function stanza(launch, state) {
+  const trusted = `${launch.codexHome}:${launch.nodeModules}`;
+  const services = {};
+  if (state.browser)
+    services.browser = "@oai/browser-desktop/service";
+  if (state.enabled)
+    services.sky = "@oai/sky/service";
+  const surfaces = [state.browser ? "browser" : "", state.enabled ? "computer" : ""].filter(Boolean).join(",");
+  const backends = state.browser ? 'BROWSER_USE_AVAILABLE_BACKENDS = "iab"\n' : "";
+  const active = state.enabled || state.browser;
+  return `${TABLE}
+command = ${JSON.stringify(launch.node)}
+args = [${JSON.stringify(launch.cuaRepl)}]
+enabled = ${active ? "true" : "false"}
+startup_timeout_sec = 120
+
+${ENV_TABLE}
+NODE_REPL_TRUSTED_SERVICES = ${JSON.stringify(JSON.stringify(services))}
+NODE_REPL_TRUSTED_CODE_PATHS = ${JSON.stringify(trusted)}
+NODE_REPL_NODE_PATH = ${JSON.stringify(launch.node)}
+CODEX_HOME = ${JSON.stringify(launch.codexHome)}
+CUA_REPL_NODE_REPL_PATH = ${JSON.stringify(launch.nodeRepl)}
+NODE_REPL_NODE_MODULE_DIRS = ${JSON.stringify(launch.nodeModules)}
+NODE_REPL_NATIVE_PIPE_CONNECT_TIMEOUT_MS = "1000"
+SKY_CUA_SERVICE_PATH = ${JSON.stringify(launch.skyApp)}
+CODEX_CLI_PATH = ${JSON.stringify(launch.codexCli)}
+${backends}CUA_REPL_ENABLED_SURFACES = ${JSON.stringify(surfaces)}
+`;
+}
+async function readPreference(environment) {
+  try {
+    const document = JSON.parse(await readFile3(path8.join(dataDirectory(environment), PREFERENCE_FILE), "utf8"));
+    return {
+      ...typeof document.enabled === "boolean" ? { enabled: document.enabled } : {},
+      ...typeof document.browser === "boolean" ? { browser: document.browser } : {},
+      ...typeof document.applyError === "string" && document.applyError ? { applyError: document.applyError } : {}
+    };
+  } catch (error53) {
+    if (isNotFound(error53))
+      return void 0;
+    throw new GrokComputerUseError("Could not read Grok Computer Use settings");
+  }
+}
+async function writePreference(environment, state) {
+  const document = {
+    ...typeof state.enabled === "boolean" ? { enabled: state.enabled } : {},
+    ...typeof state.browser === "boolean" ? { browser: state.browser } : {},
+    ...state.applyError ? { applyError: state.applyError } : {}
+  };
+  await writeAtomically(path8.join(dataDirectory(environment), PREFERENCE_FILE), `${JSON.stringify(document)}
+`);
+}
+async function readGrokConfig(environment) {
+  try {
+    return await readFile3(path8.join(grokHome2(environment), "config.toml"), "utf8");
+  } catch (error53) {
+    if (isNotFound(error53))
+      return "";
+    throw new GrokComputerUseError("Could not read Grok config");
+  }
+}
+async function writeGrokConfig(environment, text) {
+  await writeAtomically(path8.join(grokHome2(environment), "config.toml"), text.endsWith("\n") ? text : `${text}
+`);
+}
+async function currentState(environment, preference) {
+  const resolved = preference ?? await readPreference(environment);
+  const inferred = resolved?.enabled === void 0 ? inferredSurfaces(await readGrokConfig(environment)) : void 0;
+  return {
+    enabled: resolved?.enabled ?? inferred?.enabled ?? false,
+    browser: resolved ? resolved.browser ?? false : inferred?.browser ?? false,
+    ...resolved?.applyError ? { applyError: resolved.applyError } : {}
+  };
+}
+async function surfaceFiles(launch) {
+  if (!launch)
+    return { computer: false, browser: false };
+  const [computer, browser] = await Promise.all([
+    computerFilesPresent(launch),
+    browserFilesPresent(launch)
+  ]);
+  return { computer, browser };
+}
+async function writeConfigForState(state, launch, files, environment) {
+  const current = await readGrokConfig(environment);
+  const range = tableRange(current, TABLE);
+  const effective = {
+    enabled: state.enabled && files.computer,
+    browser: state.browser && files.browser && GROK_BROWSER_BINDING_SUPPORTED
+  };
+  if (!effective.enabled && !effective.browser && !range)
+    return;
+  if (!launch) {
+    if (!range)
+      return;
+    const lines = current.split(/\n/);
+    const body = lines.slice(range.start, range.end);
+    const replaced = body.map((line) => /^enabled\s*=/u.test(line) ? "enabled = false" : line);
+    if (!replaced.some((line) => /^enabled\s*=/u.test(line))) {
+      replaced.splice(1, 0, "enabled = false");
+    }
+    lines.splice(range.start, range.end - range.start, ...replaced);
+    await writeGrokConfig(environment, lines.join("\n"));
+    return;
+  }
+  const stripped = removeTables(current, [ENV_TABLE, TABLE]).replace(/\s+$/u, "\n");
+  await writeGrokConfig(environment, `${stripped.trimEnd()}
+
+${stanza(launch, effective)}`);
+}
+async function applyGrokComputerUsePreference(environment = process.env, platform = process.platform) {
+  await withGrokComputerUseLock(dataDirectory(environment), grokHome2(environment), async () => {
+    const preference = await readPreference(environment);
+    if (preference === void 0)
+      return;
+    const launch = await discoverGrokComputerUseLaunch(environment, platform);
+    const files = await surfaceFiles(launch);
+    const state = await currentState(environment, preference);
+    try {
+      await writeConfigForState(state, launch, files, environment);
+      if (state.applyError)
+        await writePreference(environment, { enabled: state.enabled, browser: state.browser });
+    } catch (error53) {
+      const applyError = error53 instanceof GrokComputerUseError ? error53.message : APPLY_FAILED;
+      await writePreference(environment, {
+        enabled: state.enabled,
+        browser: state.browser,
+        applyError
+      }).catch(() => void 0);
+      throw error53 instanceof GrokComputerUseError ? error53 : new GrokComputerUseError(APPLY_FAILED);
+    }
+  });
+}
+
 // ../../harness-adapter/dist/approval.js
 function invalidRequest(message) {
   return { code: "invalidRequest", message, retryable: false };
@@ -16915,9 +17256,9 @@ function mergeLiveHarnessCommands(builtIns, idPrefix, live, exclusions = {}) {
 
 // dist/acp-transport.js
 import { spawn, spawnSync } from "node:child_process";
-import { readdir, readFile as readFile3 } from "node:fs/promises";
-import os5 from "node:os";
-import path13 from "node:path";
+import { readdir, readFile as readFile4 } from "node:fs/promises";
+import os6 from "node:os";
+import path15 from "node:path";
 import { Readable, Writable } from "node:stream";
 
 // ../../../node_modules/@agentclientprotocol/sdk/dist/schema/index.js
@@ -21105,8 +21446,8 @@ function parseGrokAvailableCommands(value) {
   });
 }
 function isGrokSkill(command) {
-  const path17 = command.meta?.path;
-  return typeof path17 === "string" && /(^|[\\/])SKILL\.md$/u.test(path17) || typeof command.meta?.qualifiedName === "string";
+  const path19 = command.meta?.path;
+  return typeof path19 === "string" && /(^|[\\/])SKILL\.md$/u.test(path19) || typeof command.meta?.qualifiedName === "string";
 }
 function grokLiveCommands(native) {
   return native.map((command) => ({
@@ -21117,7 +21458,7 @@ function grokLiveCommands(native) {
 }
 
 // dist/command.js
-import path7 from "node:path";
+import path9 from "node:path";
 var GrokExecutableError = class extends Error {
   code = "GROK_NOT_FOUND";
 };
@@ -21146,7 +21487,7 @@ function resolveGrokExecutable(input = {}) {
   });
   if (!resolution)
     throw new GrokExecutableError("Grok CLI is not installed");
-  return targetPath(platform).isAbsolute(resolution.executable) ? resolution.executable : path7.resolve(resolution.executable);
+  return targetPath(platform).isAbsolute(resolution.executable) ? resolution.executable : path9.resolve(resolution.executable);
 }
 function grokInvocation(command, platform = process.platform, modelId) {
   const arguments_ = ["agent", "--no-leader"];
@@ -21159,11 +21500,11 @@ function grokInvocation(command, platform = process.platform, modelId) {
 
 // dist/grok-fork.js
 import { isDeepStrictEqual } from "node:util";
-import path11 from "node:path";
+import path13 from "node:path";
 
 // dist/grok-file-change.js
 import { Buffer as Buffer2 } from "node:buffer";
-import path8 from "node:path";
+import path10 from "node:path";
 
 // ../../../node_modules/diff/libesm/diff/base.js
 var Diff = class {
@@ -21265,16 +21606,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path17, added, removed, oldPosInc, options) {
-    const last = path17.lastComponent;
+  addToPath(path19, added, removed, oldPosInc, options) {
+    const last = path19.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path17.oldPos + oldPosInc,
+        oldPos: path19.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path17.oldPos + oldPosInc,
+        oldPos: path19.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -21587,13 +21928,13 @@ function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function validAbsolutePath(value) {
-  return typeof value === "string" && path8.isAbsolute(value) && value.trim().length > 0 && !value.includes("\0") && !value.includes("\n") && !value.includes("\r");
+  return typeof value === "string" && path10.isAbsolute(value) && value.trim().length > 0 && !value.includes("\0") && !value.includes("\n") && !value.includes("\r");
 }
 function displayPath(nativePath, cwd) {
-  const resolvedCwd = path8.resolve(cwd);
-  const resolvedPath = path8.resolve(nativePath);
-  const relative = path8.relative(resolvedCwd, resolvedPath);
-  const inside = relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path8.sep}`);
+  const resolvedCwd = path10.resolve(cwd);
+  const resolvedPath = path10.resolve(nativePath);
+  const relative = path10.relative(resolvedCwd, resolvedPath);
+  const inside = relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path10.sep}`);
   const selected = inside ? relative : resolvedPath;
   const normalized = selected.replaceAll("\\", "/");
   if (normalized.length === 0 || normalized === ".")
@@ -21654,12 +21995,12 @@ function projectGrokFileChanges(content, cwd, textLimit = DEFAULT_GROK_FILE_CHAN
 }
 
 // dist/grok-generated-image.js
-import path10 from "node:path";
+import path12 from "node:path";
 
 // dist/local-media-markdown.js
 import { existsSync, statSync } from "node:fs";
-import os4 from "node:os";
-import path9 from "node:path";
+import os5 from "node:os";
+import path11 from "node:path";
 var MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
   ".aac",
   ".gif",
@@ -21678,14 +22019,14 @@ var MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
   ".webp"
 ]);
 function grokMediaResolveRoots(cwd, sessionDirectory) {
-  const roots = [path9.resolve(cwd)];
+  const roots = [path11.resolve(cwd)];
   if (sessionDirectory) {
-    const session = path9.resolve(sessionDirectory);
-    roots.push(session, path9.join(session, "videos"), path9.join(session, "images"));
+    const session = path11.resolve(sessionDirectory);
+    roots.push(session, path11.join(session, "videos"), path11.join(session, "images"));
   }
-  const home = process.env.HOME ?? process.env.USERPROFILE ?? os4.homedir();
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? os5.homedir();
   if (home)
-    roots.push(path9.join(home, "Downloads"));
+    roots.push(path11.join(home, "Downloads"));
   return roots;
 }
 function rewriteLocalMediaMarkdown(text, roots, options = {}) {
@@ -21786,7 +22127,7 @@ function parseInlineCode(text, start) {
   return { closed: false, content: text.slice(start + 1), end: text.length };
 }
 function mediaMarkdownImage(absolutePath) {
-  const name = path9.basename(absolutePath).replaceAll("]", "\\]");
+  const name = path11.basename(absolutePath).replaceAll("]", "\\]");
   return `![${name}](${formatMarkdownDestination(absolutePath, false)})`;
 }
 function parseMarkdownImage(text, start) {
@@ -21911,11 +22252,11 @@ function resolveLocalMediaPath(raw, roots, exists = mediaFileExists) {
   if (!hasMediaExtension(stripped))
     return null;
   if (isAbsoluteMediaPath(stripped)) {
-    const absolute = path9.resolve(stripped);
+    const absolute = path11.resolve(stripped);
     return exists(absolute) ? absolute : null;
   }
   for (const root of roots) {
-    const absolute = path9.resolve(root, stripped);
+    const absolute = path11.resolve(root, stripped);
     if (exists(absolute))
       return absolute;
   }
@@ -21937,11 +22278,11 @@ function stripFileUrl(value) {
   }
 }
 function isAbsoluteMediaPath(value) {
-  return path9.isAbsolute(value) || /^[a-zA-Z]:[\\/]/.test(value);
+  return path11.isAbsolute(value) || /^[a-zA-Z]:[\\/]/.test(value);
 }
 function hasMediaExtension(value) {
   const pathname = value.split(/[?#]/, 1)[0] ?? value;
-  return MEDIA_EXTENSIONS.has(path9.extname(pathname).toLowerCase());
+  return MEDIA_EXTENSIONS.has(path11.extname(pathname).toLowerCase());
 }
 function mediaFileExists(absolutePath) {
   try {
@@ -21971,7 +22312,7 @@ function fromNativeRecord(value, exists) {
   const savedPath = stringField(value, "path");
   if (!validAbsolutePath(savedPath))
     return null;
-  const resolved = path10.resolve(savedPath);
+  const resolved = path12.resolve(savedPath);
   if (!exists(resolved))
     return null;
   const filename = stringField(value, "filename");
@@ -23037,11 +23378,11 @@ function parseGrokForkResponse(value) {
 }
 function projectRelativePath(value, cwds) {
   const normalized = value.replaceAll("\\", "/");
-  if (!path11.isAbsolute(value))
+  if (!path13.isAbsolute(value))
     return normalized;
   for (const cwd of cwds) {
-    const relative = path11.relative(path11.resolve(cwd), path11.resolve(value));
-    if (relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path11.sep}`)) {
+    const relative = path13.relative(path13.resolve(cwd), path13.resolve(value));
+    if (relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path13.sep}`)) {
       return relative.replaceAll("\\", "/");
     }
   }
@@ -23106,8 +23447,8 @@ async function forkGrokSession(input) {
       error: error51("sessionNotFound", "Grok Native Session is unavailable")
     };
   }
-  const sourceCwd = path11.resolve(located.cwd);
-  const targetCwd = path11.resolve(input.cwd);
+  const sourceCwd = path13.resolve(located.cwd);
+  const targetCwd = path13.resolve(input.cwd);
   const source = await readSnapshot({ ...input, cwd: sourceCwd }, sourceRef.data.nativeSessionId);
   if (!source.ok)
     return source;
@@ -23290,7 +23631,7 @@ function parseGrokCompactResult(value, cancelled = false) {
 }
 
 // dist/grok-rewind.js
-import path12 from "node:path";
+import path14 from "node:path";
 var GROK_REWIND_EXECUTE_METHOD = "_x.ai/rewind/execute";
 function error52(code, message, retryable = false) {
   return { code, message, retryable };
@@ -23363,8 +23704,8 @@ async function rewindGrokLastTurn(input) {
       error: error52("sessionNotFound", "Grok Native Session is unavailable")
     };
   }
-  const sourceCwd = path12.resolve(located.cwd);
-  const targetCwd = path12.resolve(input.cwd);
+  const sourceCwd = path14.resolve(located.cwd);
+  const targetCwd = path14.resolve(input.cwd);
   if (sourceCwd !== targetCwd) {
     return {
       ok: false,
@@ -23418,6 +23759,195 @@ async function rewindGrokLastTurn(input) {
   return { ok: true, value: { sessionId } };
 }
 
+// dist/grok-elicitation.js
+var GROK_MCP_ELICIT_METHOD = "_x.ai/mcp/elicit";
+var GROK_ELICIT_TITLE_MAX_LENGTH = 150;
+var GROK_ELICIT_DESCRIPTION_MAX_LENGTH = 500;
+var FORM_KEYS = /* @__PURE__ */ new Set([
+  "sessionId",
+  "toolCallId",
+  "serverName",
+  "message",
+  "mode",
+  "requestedSchema",
+  "persist"
+]);
+var URL_KEYS = /* @__PURE__ */ new Set([
+  "sessionId",
+  "toolCallId",
+  "serverName",
+  "message",
+  "mode",
+  "url",
+  "elicitationId"
+]);
+var SCHEMA_KEYS = /* @__PURE__ */ new Set(["type", "properties", "required"]);
+var GROK_CLOCK_ELICIT_FIXTURE = {
+  sessionId: "session-1",
+  toolCallId: "elicit-clock-1",
+  serverName: "cua_repl",
+  message: 'Allow Computer Use to use "Clock"?',
+  mode: "form"
+};
+var GROK_CLOCK_ELICIT_PERSIST_FIXTURE = {
+  ...GROK_CLOCK_ELICIT_FIXTURE,
+  persist: ["session", "always"]
+};
+function isRecord13(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function hasOnlyKeys(record2, allowed) {
+  return Object.keys(record2).every((key) => allowed.has(key));
+}
+function clampText(value, max) {
+  return value.length <= max ? value : value.slice(0, max);
+}
+function parsePersistOffer(value) {
+  if (value === void 0)
+    return void 0;
+  if (!Array.isArray(value) || value.length === 0)
+    return "invalid";
+  let session = false;
+  let always = false;
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of value) {
+    if (typeof item !== "string" || item !== item.trim())
+      return "invalid";
+    if (seen.has(item))
+      return "invalid";
+    seen.add(item);
+    if (item === "session")
+      session = true;
+    else if (item === "always")
+      always = true;
+    else
+      return "invalid";
+  }
+  const out = [];
+  if (session)
+    out.push("session");
+  if (always)
+    out.push("always");
+  return out.length > 0 ? out : "invalid";
+}
+function schemaIsSupportedEmptyObject(schema) {
+  if (!isRecord13(schema) || !hasOnlyKeys(schema, SCHEMA_KEYS) || schema.type !== "object") {
+    return false;
+  }
+  if (schema.properties !== void 0) {
+    if (!isRecord13(schema.properties) || Object.keys(schema.properties).length !== 0)
+      return false;
+  }
+  if (schema.required !== void 0) {
+    if (!Array.isArray(schema.required) || schema.required.length !== 0)
+      return false;
+  }
+  return true;
+}
+function parseGrokMcpElicitParams(params) {
+  if (!isRecord13(params))
+    return { status: "invalid", message: "elicitation params must be an object" };
+  const sessionId = nonEmptyString(params.sessionId);
+  const toolCallId = nonEmptyString(params.toolCallId);
+  const serverName = nonEmptyString(params.serverName);
+  const message = nonEmptyString(params.message);
+  if (!sessionId || !toolCallId || !serverName || !message) {
+    return {
+      status: "invalid",
+      message: "elicitation requires sessionId, toolCallId, serverName, and message"
+    };
+  }
+  if (params.mode === "url") {
+    if (!hasOnlyKeys(params, URL_KEYS)) {
+      return { status: "invalid", message: "URL elicitation contains unreviewed fields" };
+    }
+    if (!nonEmptyString(params.url) || !nonEmptyString(params.elicitationId)) {
+      return { status: "invalid", message: "URL elicitation requires url and elicitationId" };
+    }
+    return { status: "unsupported" };
+  }
+  if (params.mode !== "form") {
+    return { status: "invalid", message: "elicitation mode must be form or url" };
+  }
+  if (!hasOnlyKeys(params, FORM_KEYS)) {
+    return { status: "invalid", message: "form elicitation contains unreviewed fields" };
+  }
+  if (params.requestedSchema !== void 0) {
+    if (!isRecord13(params.requestedSchema)) {
+      return { status: "invalid", message: "requestedSchema must be an object" };
+    }
+    if (!schemaIsSupportedEmptyObject(params.requestedSchema))
+      return { status: "unsupported" };
+  }
+  const persist = parsePersistOffer(params.persist);
+  if (persist === "invalid") {
+    return {
+      status: "invalid",
+      message: "persist must be a unique array of session and/or always"
+    };
+  }
+  return {
+    status: "form",
+    request: {
+      sessionId,
+      toolCallId,
+      serverName,
+      message,
+      mode: "form",
+      ...persist ? { persist } : {}
+    }
+  };
+}
+function grokMcpElicitAccept(persist) {
+  return { outcome: "accept", content: {}, ...persist ? { persist } : {} };
+}
+function grokMcpElicitDecline() {
+  return { outcome: "decline" };
+}
+function grokMcpElicitCancel() {
+  return { outcome: "cancel" };
+}
+function grokMcpElicitResponseForAction(effect) {
+  if (effect === "allowOnce")
+    return grokMcpElicitAccept();
+  if (effect === "allowAlways")
+    return grokMcpElicitAccept("always");
+  if (effect === "deny")
+    return grokMcpElicitDecline();
+  return grokMcpElicitCancel();
+}
+function grokMcpElicitApprovalActions(persist) {
+  const actions = [
+    { id: "allow-once", label: "Allow once", effect: "allowOnce" }
+  ];
+  if (persist?.includes("always")) {
+    actions.push({ id: "allow-always", label: "Always allow", effect: "allowAlways" });
+  }
+  actions.push({ id: "deny", label: "Deny", effect: "deny" });
+  return actions;
+}
+function projectGrokMcpElicitApproval(input) {
+  const title = clampText(`${input.request.serverName}: ${input.request.message}`, GROK_ELICIT_TITLE_MAX_LENGTH);
+  const description = clampText(input.request.message, GROK_ELICIT_DESCRIPTION_MAX_LENGTH);
+  return {
+    type: "approval",
+    interactionId: input.interactionId,
+    turnId: input.turnId,
+    title,
+    description,
+    subject: { type: "nativeAction" },
+    actions: grokMcpElicitApprovalActions(input.request.persist)
+  };
+}
+function grokElicitationResolvedToolCallId(update) {
+  if (!isRecord13(update) || update.sessionUpdate !== "interaction_resolved")
+    return void 0;
+  return nonEmptyString(update.tool_call_id) ?? nonEmptyString(update.toolCallId);
+}
+
 // dist/permission-modes.js
 var nativePermissionModes = /* @__PURE__ */ new Set(["ask", "auto", "always-approve"]);
 var GROK_DEFAULT_PERMISSION_MODE_ID = harnessPermissionModeIdSchema.parse("ask");
@@ -23504,16 +24034,16 @@ var GrokTransportError = class extends Error {
     this.name = "GrokTransportError";
   }
 };
-function isRecord13(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function acpToolName(update, metadata) {
-  if (!isRecord13(update))
+  if (!isRecord14(update))
     return void 0;
   if (typeof update.name === "string" && update.name.length > 0)
     return update.name;
-  const meta3 = isRecord13(update._meta) ? update._meta : metadata;
-  const tool = meta3 && isRecord13(meta3["x.ai/tool"]) ? meta3["x.ai/tool"] : void 0;
+  const meta3 = isRecord14(update._meta) ? update._meta : metadata;
+  const tool = meta3 && isRecord14(meta3["x.ai/tool"]) ? meta3["x.ai/tool"] : void 0;
   return tool && typeof tool.name === "string" && tool.name.length > 0 ? tool.name : void 0;
 }
 function errorText(error53) {
@@ -23569,7 +24099,7 @@ function signalProcessTree(child, signal) {
   try {
     process.kill(-child.pid, signal);
   } catch (error53) {
-    if (!isRecord13(error53) || error53.code !== "ESRCH")
+    if (!isRecord14(error53) || error53.code !== "ESRCH")
       throw error53;
   }
 }
@@ -23612,6 +24142,14 @@ function transportEvent(update, metadata) {
   const subagent = grokSubagentEventFromUpdate(extension);
   if (subagent)
     return subagent;
+  const resolvedToolCallId = grokElicitationResolvedToolCallId(extension);
+  if (resolvedToolCallId) {
+    return {
+      type: "elicitation.resolved",
+      toolCallId: resolvedToolCallId,
+      ...metadata ? { metadata } : {}
+    };
+  }
   switch (update.sessionUpdate) {
     case "user_message_chunk":
     case "agent_message_chunk":
@@ -23659,34 +24197,34 @@ function transportEvent(update, metadata) {
 }
 function grokHomeDir(options) {
   const environment = { ...process.env, ...options.environment };
-  const home = environment.HOME ?? environment.USERPROFILE ?? os5.homedir();
-  return environment.GROK_HOME ?? path13.join(home, ".grok");
+  const home = environment.HOME ?? environment.USERPROFILE ?? os6.homedir();
+  return environment.GROK_HOME ?? path15.join(home, ".grok");
 }
 function grokNativeSessionDirectory(options, sessionId) {
-  return path13.join(grokHomeDir(options), "sessions", encodeURIComponent(path13.resolve(options.cwd)), sessionId);
+  return path15.join(grokHomeDir(options), "sessions", encodeURIComponent(path15.resolve(options.cwd)), sessionId);
 }
 function nativeSessionFile(options, sessionId, fileName) {
-  return path13.join(grokNativeSessionDirectory(options, sessionId), fileName);
+  return path15.join(grokNativeSessionDirectory(options, sessionId), fileName);
 }
 function nativeHistoryPath(options, sessionId) {
   return nativeSessionFile(options, sessionId, "updates.jsonl");
 }
 async function readNativeSignals(options, sessionId) {
   try {
-    return JSON.parse(await readFile3(nativeSessionFile(options, sessionId, "signals.json"), "utf8"));
+    return JSON.parse(await readFile4(nativeSessionFile(options, sessionId, "signals.json"), "utf8"));
   } catch {
     return void 0;
   }
 }
 function isMissingFile(error53) {
-  return isRecord13(error53) && error53.code === "ENOENT";
+  return isRecord14(error53) && error53.code === "ENOENT";
 }
 async function locateGrokNativeSession(options, sessionId) {
   if (sessionId.length === 0)
     return null;
   let entries;
   try {
-    entries = await readdir(path13.join(grokHomeDir(options), "sessions"), { withFileTypes: true });
+    entries = await readdir(path15.join(grokHomeDir(options), "sessions"), { withFileTypes: true });
   } catch (error53) {
     if (isMissingFile(error53))
       return null;
@@ -23700,9 +24238,9 @@ async function locateGrokNativeSession(options, sessionId) {
       continue;
     let summaryRaw;
     try {
-      summaryRaw = await readFile3(path13.join(grokHomeDir(options), "sessions", entry.name, sessionId, "summary.json"), "utf8");
+      summaryRaw = await readFile4(path15.join(grokHomeDir(options), "sessions", entry.name, sessionId, "summary.json"), "utf8");
     } catch (error53) {
-      if (isMissingFile(error53) || isRecord13(error53) && error53.code === "ENOTDIR")
+      if (isMissingFile(error53) || isRecord14(error53) && error53.code === "ENOTDIR")
         continue;
       throw new GrokTransportError("unavailable", "Grok Native Session metadata could not be read", {
         cause: error53
@@ -23714,11 +24252,11 @@ async function locateGrokNativeSession(options, sessionId) {
     } catch {
       continue;
     }
-    if (!isRecord13(parsed))
+    if (!isRecord14(parsed))
       continue;
     const info = parsed.info;
-    const cwd = isRecord13(info) && typeof info.cwd === "string" && info.cwd.length > 0 ? path13.resolve(info.cwd) : path13.resolve(decodeURIComponent(entry.name));
-    const sourceWorkspaceDir = typeof parsed.source_workspace_dir === "string" && parsed.source_workspace_dir.length > 0 ? path13.resolve(parsed.source_workspace_dir) : void 0;
+    const cwd = isRecord14(info) && typeof info.cwd === "string" && info.cwd.length > 0 ? path15.resolve(info.cwd) : path15.resolve(decodeURIComponent(entry.name));
+    const sourceWorkspaceDir = typeof parsed.source_workspace_dir === "string" && parsed.source_workspace_dir.length > 0 ? path15.resolve(parsed.source_workspace_dir) : void 0;
     matches.push({
       cwd,
       ...sourceWorkspaceDir ? { sourceWorkspaceDir } : {}
@@ -23728,7 +24266,7 @@ async function locateGrokNativeSession(options, sessionId) {
 }
 async function readGrokNativeHistory(options, sessionId) {
   try {
-    return parseNativeHistory(await readFile3(nativeHistoryPath({ ...options, cwd: path13.resolve(options.cwd) }, sessionId), "utf8"), sessionId);
+    return parseNativeHistory(await readFile4(nativeHistoryPath({ ...options, cwd: path15.resolve(options.cwd) }, sessionId), "utf8"), sessionId);
   } catch (error53) {
     if (isMissingFile(error53))
       return [];
@@ -23750,12 +24288,12 @@ function parseNativeHistory(contents, sessionId) {
     } catch {
       throw new GrokTransportError("protocolError", "Grok Native history contains invalid JSON");
     }
-    if (!isRecord13(record2) || !isRecord13(record2.params))
+    if (!isRecord14(record2) || !isRecord14(record2.params))
       continue;
     const params = record2.params;
-    if (params.sessionId !== sessionId || !isRecord13(params.update))
+    if (params.sessionId !== sessionId || !isRecord14(params.update))
       continue;
-    const metadata = isRecord13(params._meta) ? params._meta : void 0;
+    const metadata = isRecord14(params._meta) ? params._meta : void 0;
     const event = transportEvent(params.update, metadata);
     if (event)
       events.push(metadata ? { ...event, metadata } : event);
@@ -23817,7 +24355,7 @@ var GrokAcpTransport = class {
     if (!this.#connection)
       throw new GrokTransportError("unavailable", "Grok ACP is unavailable");
     const result = await withTimeout(this.#connection.request("_x.ai/session/usage", { sessionId: this.sessionId }), this.#options.commandTimeoutMs, "Grok Session usage");
-    return isRecord13(result) ? result.usage : void 0;
+    return isRecord14(result) ? result.usage : void 0;
   }
   async readHistory(sessionId, cwd = this.#options.cwd) {
     return readGrokNativeHistory({ ...this.#options, cwd }, sessionId);
@@ -23987,6 +24525,7 @@ var GrokAcpTransport = class {
     const connection = new ClientSideConnection(() => ({
       sessionUpdate: (params) => this.#handleUpdate(params),
       requestPermission: (params) => this.#handlePermission(params),
+      extMethod: (method, params) => this.#handleExtMethod(method, params),
       extNotification: (method, params) => this.#handleExtensionNotification(method, params)
     }), stream);
     this.#connection = connection;
@@ -24007,14 +24546,14 @@ var GrokAcpTransport = class {
     this.#initialize = initialize;
     return initialize;
   }
-  async runTurn(text, onEvent, onPermission) {
+  async runTurn(text, onEvent, onPermission, onElicitation) {
     const connection = this.#connection;
     if (!connection || !this.#sessionId || this.#closed || this.#closing) {
       throw new GrokTransportError("unavailable", "Grok ACP Session is unavailable");
     }
     if (this.#activePrompt)
       throw new Error("Grok ACP Session already has an active Prompt");
-    const active = { onEvent, onPermission };
+    const active = { onEvent, onPermission, onElicitation };
     this.#activePrompt = active;
     try {
       return await connection.prompt({
@@ -24075,7 +24614,7 @@ var GrokAcpTransport = class {
         }
       } : {}
     });
-    if (!isRecord13(response) || !isRecord13(response._meta) || !isRecord13(response._meta.model)) {
+    if (!isRecord14(response) || !isRecord14(response._meta) || !isRecord14(response._meta.model)) {
       throw new GrokTransportError("protocolError", "Grok rejected Model configuration");
     }
     const selected = response._meta.model.Ok;
@@ -24127,7 +24666,7 @@ var GrokAcpTransport = class {
       this.#availableCommands = parseGrokAvailableCommands(update.availableCommands);
       return;
     }
-    const metadata = isRecord13(notification._meta) ? notification._meta : void 0;
+    const metadata = isRecord14(notification._meta) ? notification._meta : void 0;
     const event = transportEvent(notification.update, metadata);
     if (!event)
       return;
@@ -24142,7 +24681,7 @@ var GrokAcpTransport = class {
   #handleExtensionNotification(method, params) {
     if (!isGrokExtensionSessionUpdateMethod(method))
       return;
-    if (typeof params.sessionId !== "string" || !isRecord13(params.update))
+    if (typeof params.sessionId !== "string" || !isRecord14(params.update))
       return;
     this.#handleUpdate(params);
   }
@@ -24152,6 +24691,22 @@ var GrokAcpTransport = class {
     }
     return this.#activePrompt.onPermission({ request: params, options: params.options });
   }
+  async #handleExtMethod(method, params) {
+    if (method !== GROK_MCP_ELICIT_METHOD) {
+      throw RequestError.methodNotFound(method);
+    }
+    const parsed = parseGrokMcpElicitParams(params);
+    if (parsed.status === "invalid") {
+      throw RequestError.invalidParams(void 0, parsed.message);
+    }
+    if (parsed.status === "unsupported" || this.#closed || this.#closing || this.#replay !== null || this.#activeCompact !== null || !this.#activePrompt) {
+      return { ...grokMcpElicitCancel() };
+    }
+    if (parsed.request.sessionId !== this.#sessionId) {
+      return { ...grokMcpElicitCancel() };
+    }
+    return { ...await this.#activePrompt.onElicitation(parsed.request) };
+  }
   #fault(error53) {
     if (this.#closing || this.#closed)
       return;
@@ -24161,8 +24716,8 @@ var GrokAcpTransport = class {
 
 // dist/session-import.js
 import { createReadStream as createReadStream2 } from "node:fs";
-import { opendir as opendir2, readFile as readFile4, stat } from "node:fs/promises";
-import path14 from "node:path";
+import { opendir as opendir2, readFile as readFile5, stat } from "node:fs/promises";
+import path16 from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
 
 // ../../harness-adapter/dist/session-import.js
@@ -24283,11 +24838,11 @@ var SessionImportScope = class {
 // dist/session-import.js
 var MAX_METADATA_BYTES = 4 * 1024 * 1024;
 var SUBAGENT_SESSION_KINDS = /* @__PURE__ */ new Set(["subagent", "subagent_resume"]);
-function isRecord14(value) {
+function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function readJson(file2, signal) {
-  return JSON.parse(await readFile4(file2, { encoding: "utf8", signal }));
+  return JSON.parse(await readFile5(file2, { encoding: "utf8", signal }));
 }
 function processAlive(pid) {
   if (typeof pid !== "number" || !Number.isSafeInteger(pid) || pid <= 0)
@@ -24296,7 +24851,7 @@ function processAlive(pid) {
     process.kill(pid, 0);
     return true;
   } catch (error53) {
-    return isRecord14(error53) && error53.code === "EPERM";
+    return isRecord15(error53) && error53.code === "EPERM";
   }
 }
 async function firstUserText(file2, signal) {
@@ -24313,10 +24868,10 @@ async function firstUserText(file2, signal) {
       } catch {
         continue;
       }
-      const update = isRecord14(entry) && isRecord14(entry.params) ? entry.params.update : null;
-      if (!isRecord14(update) || update.sessionUpdate !== "user_message_chunk")
+      const update = isRecord15(entry) && isRecord15(entry.params) ? entry.params.update : null;
+      if (!isRecord15(update) || update.sessionUpdate !== "user_message_chunk")
         continue;
-      const text = isRecord14(update.content) ? update.content.text : null;
+      const text = isRecord15(update.content) ? update.content.text : null;
       return typeof text === "string" ? text : "";
     }
     return null;
@@ -24383,7 +24938,7 @@ var GrokSessionImport = class {
     const active = /* @__PURE__ */ new Set();
     let entries;
     try {
-      entries = await readJson(path14.join(this.#home(), "active_sessions.json"), signal);
+      entries = await readJson(path16.join(this.#home(), "active_sessions.json"), signal);
     } catch (error53) {
       signal.throwIfAborted();
       if (isStorageAccessError(error53))
@@ -24393,14 +24948,14 @@ var GrokSessionImport = class {
     if (!Array.isArray(entries))
       return active;
     for (const entry of entries) {
-      if (isRecord14(entry) && typeof entry.session_id === "string" && processAlive(entry.pid))
+      if (isRecord15(entry) && typeof entry.session_id === "string" && processAlive(entry.pid))
         active.add(entry.session_id);
     }
     return active;
   }
   /** Session ID to every directory claiming it. Enumerated links are not followed. */
   async #sessionDirectories(signal) {
-    const root = path14.join(this.#home(), "sessions");
+    const root = path16.join(this.#home(), "sessions");
     const found = /* @__PURE__ */ new Map();
     const info = await optionalLstat(root);
     if (!info)
@@ -24411,7 +24966,7 @@ var GrokSessionImport = class {
       signal.throwIfAborted();
       if (!workspace.isDirectory())
         continue;
-      const workspaceDirectory = path14.join(root, workspace.name);
+      const workspaceDirectory = path16.join(root, workspace.name);
       const sessions = await opendir2(workspaceDirectory).catch((error53) => {
         if (isMissingFileError(error53))
           return null;
@@ -24424,7 +24979,7 @@ var GrokSessionImport = class {
         if (!session.isDirectory())
           continue;
         const directories = found.get(session.name) ?? [];
-        directories.push(path14.join(workspaceDirectory, session.name));
+        directories.push(path16.join(workspaceDirectory, session.name));
         found.set(session.name, directories);
       }
     }
@@ -24432,25 +24987,25 @@ var GrokSessionImport = class {
   }
   async #candidate(sessionDirectory, active, signal) {
     signal.throwIfAborted();
-    const nativeSessionId = path14.basename(sessionDirectory);
+    const nativeSessionId = path16.basename(sessionDirectory);
     const files = [
-      path14.join(sessionDirectory, "summary.json"),
-      path14.join(sessionDirectory, "updates.jsonl")
+      path16.join(sessionDirectory, "summary.json"),
+      path16.join(sessionDirectory, "updates.jsonl")
     ];
     return readStableFiles(files, async ([summaryInfo, updates]) => {
       if (!summaryInfo?.isFile() || !updates?.isFile() || summaryInfo.size > MAX_METADATA_BYTES)
         return null;
       try {
         const summary = await readJson(files[0], signal);
-        if (!isRecord14(summary) || !isRecord14(summary.info) || summary.info.id !== nativeSessionId)
+        if (!isRecord15(summary) || !isRecord15(summary.info) || summary.info.id !== nativeSessionId)
           return null;
         if (typeof summary.session_kind === "string" && SUBAGENT_SESSION_KINDS.has(summary.session_kind))
           return null;
         const nativeCwd = summary.info.cwd;
-        if (typeof nativeCwd !== "string" || !path14.isAbsolute(nativeCwd) || nativeCwd.includes("\0"))
+        if (typeof nativeCwd !== "string" || !path16.isAbsolute(nativeCwd) || nativeCwd.includes("\0"))
           return null;
-        const cwd = path14.resolve(nativeCwd);
-        if (encodeURIComponent(cwd) !== path14.basename(path14.dirname(sessionDirectory)))
+        const cwd = path16.resolve(nativeCwd);
+        if (encodeURIComponent(cwd) !== path16.basename(path16.dirname(sessionDirectory)))
           return null;
         if (!(await stat(cwd)).isDirectory())
           return null;
@@ -24669,7 +25224,7 @@ var GrokSubagentLifecycle = class {
 };
 
 // dist/grok-models.js
-function isRecord15(value) {
+function isRecord16(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonBlank(value) {
@@ -24681,7 +25236,7 @@ function thinkingOptions(value) {
   const seen = /* @__PURE__ */ new Set();
   const options = [];
   for (const candidate of value) {
-    if (!isRecord15(candidate) || !nonBlank(candidate.label))
+    if (!isRecord16(candidate) || !nonBlank(candidate.label))
       continue;
     const id = harnessThinkingOptionIdSchema.safeParse(candidate.id ?? candidate.value);
     if (!id.success || seen.has(id.data))
@@ -24692,7 +25247,7 @@ function thinkingOptions(value) {
   return options;
 }
 function parseGrokModelState(value) {
-  if (!isRecord15(value) || !nonBlank(value.currentModelId) || !Array.isArray(value.availableModels)) {
+  if (!isRecord16(value) || !nonBlank(value.currentModelId) || !Array.isArray(value.availableModels)) {
     return null;
   }
   const currentModel = harnessModelRefSchema.safeParse({ id: value.currentModelId });
@@ -24704,12 +25259,12 @@ function parseGrokModelState(value) {
   const models = [];
   let currentThinkingOptionId;
   for (const candidate of value.availableModels) {
-    if (!isRecord15(candidate) || !nonBlank(candidate.modelId) || !nonBlank(candidate.name))
+    if (!isRecord16(candidate) || !nonBlank(candidate.modelId) || !nonBlank(candidate.name))
       continue;
     const ref = harnessModelRefSchema.safeParse({ id: candidate.modelId });
     if (!ref.success)
       continue;
-    const metadata = isRecord15(candidate._meta) ? candidate._meta : {};
+    const metadata = isRecord16(candidate._meta) ? candidate._meta : {};
     const options2 = thinkingOptions(metadata.reasoningEfforts);
     if (Array.isArray(metadata.contextWindows) && metadata.contextWindows.includes(5e5)) {
       defaultContextWindowTokensByModel.set(ref.data.id, 5e5);
@@ -24748,10 +25303,10 @@ function parseGrokModelState(value) {
   };
 }
 function modelStateFromInitialize(response) {
-  return parseGrokModelState(isRecord15(response._meta) ? response._meta.modelState : void 0);
+  return parseGrokModelState(isRecord16(response._meta) ? response._meta.modelState : void 0);
 }
 function modelStateFromSessionResponse(response) {
-  return parseGrokModelState(isRecord15(response) ? response.models : void 0);
+  return parseGrokModelState(isRecord16(response) ? response.models : void 0);
 }
 function stateForGrokModel(modelState, nativeState, model2 = modelState.currentModel, thinkingOptionId = modelState.currentThinkingOptionId, permissionModeId) {
   const selectedModel = model2;
@@ -24770,12 +25325,12 @@ function stateForGrokModel(modelState, nativeState, model2 = modelState.currentM
 }
 
 // dist/grok-credits.js
-import { readFile as readFile5 } from "node:fs/promises";
-import os6 from "node:os";
-import path15 from "node:path";
+import { readFile as readFile6 } from "node:fs/promises";
+import os7 from "node:os";
+import path17 from "node:path";
 var GROK_CREDITS_ENDPOINT = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
 var REQUEST_TIMEOUT_MS = 15e3;
-function isRecord16(value) {
+function isRecord17(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function finitePercent(value) {
@@ -24784,15 +25339,15 @@ function finitePercent(value) {
   return Math.min(100, Math.max(0, value));
 }
 function nonNegativeCentValue(value) {
-  if (!isRecord16(value))
+  if (!isRecord17(value))
     return void 0;
   const amount = value.val === void 0 ? 0 : value.val;
   if (typeof amount !== "number" || !Number.isFinite(amount) || amount < 0)
     return void 0;
   return amount;
 }
-function grokHome2(environment) {
-  return environment.GROK_HOME ?? path15.join(environment.HOME ?? environment.USERPROFILE ?? os6.homedir(), ".grok");
+function grokHome3(environment) {
+  return environment.GROK_HOME ?? path17.join(environment.HOME ?? environment.USERPROFILE ?? os7.homedir(), ".grok");
 }
 function periodTypeFrom(value) {
   if (typeof value !== "string")
@@ -24808,7 +25363,7 @@ function productUsageFrom(value) {
   if (!Array.isArray(value))
     return void 0;
   const products = value.flatMap((entry) => {
-    if (!isRecord16(entry) || typeof entry.product !== "string")
+    if (!isRecord17(entry) || typeof entry.product !== "string")
       return [];
     const usagePercent = finitePercent(entry.usagePercent);
     const labels = {
@@ -24829,10 +25384,10 @@ function productUsageFrom(value) {
   return products.length > 0 ? products : void 0;
 }
 function parseGrokCreditsResponse(value, fetchedAt = (/* @__PURE__ */ new Date()).toISOString()) {
-  if (!isRecord16(value) || !isRecord16(value.config))
+  if (!isRecord17(value) || !isRecord17(value.config))
     return null;
   const config2 = value.config;
-  const period = isRecord16(config2.currentPeriod) ? config2.currentPeriod : void 0;
+  const period = isRecord17(config2.currentPeriod) ? config2.currentPeriod : void 0;
   const periodType = periodTypeFrom(period?.type);
   const resetsAt = (typeof period?.end === "string" && period.end.length > 0 ? period.end : void 0) ?? (typeof config2.billingPeriodEnd === "string" && config2.billingPeriodEnd.length > 0 ? config2.billingPeriodEnd : void 0);
   let usedPercent = finitePercent(config2.creditUsagePercent);
@@ -24859,11 +25414,11 @@ function parseGrokCreditsResponse(value, fetchedAt = (/* @__PURE__ */ new Date()
   };
 }
 function selectAccessToken(auth, now) {
-  if (!isRecord16(auth))
+  if (!isRecord17(auth))
     return null;
-  const entries = Object.entries(auth).filter(([issuer, value]) => (issuer === "https://auth.x.ai" || issuer.startsWith("https://auth.x.ai::")) && isRecord16(value) && typeof value.key === "string" && value.key.length > 0).sort(([left], [right]) => Number(right.startsWith("https://auth.x.ai")) - Number(left.startsWith("https://auth.x.ai")));
+  const entries = Object.entries(auth).filter(([issuer, value]) => (issuer === "https://auth.x.ai" || issuer.startsWith("https://auth.x.ai::")) && isRecord17(value) && typeof value.key === "string" && value.key.length > 0).sort(([left], [right]) => Number(right.startsWith("https://auth.x.ai")) - Number(left.startsWith("https://auth.x.ai")));
   for (const [, value] of entries) {
-    if (!isRecord16(value) || typeof value.key !== "string")
+    if (!isRecord17(value) || typeof value.key !== "string")
       continue;
     if (typeof value.expires_at === "string") {
       const expiresAt = Date.parse(value.expires_at);
@@ -24884,8 +25439,8 @@ async function fetchGrokAccount(input = {}) {
     if ([environment.XAI_API_KEY, environment.GROK_API_KEY, environment.GROK_TOKEN].some((value) => value?.trim()))
       return null;
     const now = input.now ?? /* @__PURE__ */ new Date();
-    const authPath = path15.join(grokHome2(environment), "auth.json");
-    const raw = input.readAuthFile ? await input.readAuthFile(authPath) : await readFile5(authPath, "utf8");
+    const authPath = path17.join(grokHome3(environment), "auth.json");
+    const raw = input.readAuthFile ? await input.readAuthFile(authPath) : await readFile6(authPath, "utf8");
     const token = selectAccessToken(JSON.parse(raw), now);
     if (!token)
       return null;
@@ -24934,7 +25489,7 @@ async function fetchGrokCredits(input = {}) {
 
 // dist/grok-usage.js
 var USD_TICKS_PER_DOLLAR = 1e10;
-function isRecord17(value) {
+function isRecord18(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function optionalToken(value) {
@@ -24951,7 +25506,7 @@ function combineUsage(base, next) {
   return base === null ? next : parseHostUsage({ ...base, ...next });
 }
 function usageFromNative(value) {
-  if (!isRecord17(value))
+  if (!isRecord18(value))
     return null;
   const inputTokens = optionalToken(value.inputTokens);
   const cachedRead = optionalToken(value.cachedReadTokens);
@@ -24975,7 +25530,7 @@ function usageFromNative(value) {
   }
 }
 function usageFromResponse(value) {
-  if (!isRecord17(value))
+  if (!isRecord18(value))
     return null;
   const buckets = [
     value.input_tokens,
@@ -25075,7 +25630,7 @@ var GrokTurnUsage = class {
   }
 };
 function usageFromSignals(value) {
-  if (!isRecord17(value))
+  if (!isRecord18(value))
     return null;
   try {
     return parseHostUsage({
@@ -25095,7 +25650,7 @@ var summedUsageFields = [
   "totalTokens"
 ];
 function nativeCostTicks(value) {
-  if (!isRecord17(value))
+  if (!isRecord18(value))
     return void 0;
   const ticks = value.costUsdTicks;
   if (typeof ticks !== "number" || !Number.isSafeInteger(ticks) || ticks < 0)
@@ -25103,7 +25658,7 @@ function nativeCostTicks(value) {
   return ticks;
 }
 function sessionCostFromNative(value, initialCostUsd) {
-  if (!isRecord17(value))
+  if (!isRecord18(value))
     return void 0;
   if (value.costIsPartial !== void 0 && value.costIsPartial !== false)
     return void 0;
@@ -25132,7 +25687,7 @@ function sessionUsageFromHistory(events) {
       continue;
     const usage = usageFromNative(event.usage);
     const ticks2 = nativeCostTicks(event.usage);
-    const complete = isRecord17(event.usage) && (event.usage.usageIsIncomplete === void 0 || event.usage.usageIsIncomplete === false) && usage?.inputTokens !== void 0 && usage.cachedInputTokens !== void 0 && usage.cachedInputTokens <= usage.inputTokens;
+    const complete = isRecord18(event.usage) && (event.usage.usageIsIncomplete === void 0 || event.usage.usageIsIncomplete === false) && usage?.inputTokens !== void 0 && usage.cachedInputTokens !== void 0 && usage.cachedInputTokens <= usage.inputTokens;
     latestByKey.set(key, { usage, complete, ...ticks2 !== void 0 ? { ticks: ticks2 } : {} });
   }
   if (latestByKey.size === 0)
@@ -25186,7 +25741,7 @@ function usageFromCompact(tokensAfter, contextWindowTokens) {
 function usageFromUpdate(update, metadata, contextWindowTokens) {
   try {
     if (update?.sessionUpdate === "usage_update") {
-      const cost = isRecord17(update.cost) ? update.cost : null;
+      const cost = isRecord18(update.cost) ? update.cost : null;
       return parseHostUsage({
         contextUsedTokens: update.used,
         contextWindowTokens: update.size,
@@ -25436,6 +25991,7 @@ var GrokHarnessSession = class {
       subagents: this.#createSubagents(),
       completedItems: [],
       approvals: /* @__PURE__ */ new Map(),
+      elicitations: /* @__PURE__ */ new Map(),
       cancellationRequested: false,
       beforeNativeTurnKeys: new Set(this.#snapshot.turns.map((turn) => turn.nativeTurnRef.nativeTurnKey)),
       completion,
@@ -25443,7 +25999,7 @@ var GrokHarnessSession = class {
     };
     this.#active = active;
     this.#event({ type: "turn.started", turnId: command.turnId });
-    void this.#transport.runTurn(text, (event) => this.#handleEvent(active, event), (request) => this.#requestPermission(active, request)).then((response) => this.#settleFromHistory(active, terminalOutcome2(response, active.cancellationRequested), response), (error53) => this.#settleFromHistory(active, {
+    void this.#transport.runTurn(text, (event) => this.#handleEvent(active, event), (request) => this.#requestPermission(active, request), (request) => this.#requestElicitation(active, request)).then((response) => this.#settleFromHistory(active, terminalOutcome2(response, active.cancellationRequested), response), (error53) => this.#settleFromHistory(active, {
       status: "failed",
       error: normalizeError(error53, "nativeFailure")
     }));
@@ -25525,6 +26081,7 @@ var GrokHarnessSession = class {
       subagents: this.#createSubagents(),
       completedItems: [],
       approvals: /* @__PURE__ */ new Map(),
+      elicitations: /* @__PURE__ */ new Map(),
       cancellationRequested: false,
       beforeNativeTurnKeys: /* @__PURE__ */ new Set(),
       completion,
@@ -25679,6 +26236,7 @@ var GrokHarnessSession = class {
     for (const approval of active.approvals.values()) {
       approval.resolve({ outcome: { outcome: "cancelled" } });
     }
+    this.#cancelActiveElicitations(active);
     try {
       await this.#transport.cancel();
       return { ok: true, value: { cancellationRequested: true } };
@@ -25688,8 +26246,9 @@ var GrokHarnessSession = class {
   }
   async #respond(command) {
     const active = this.#active;
-    const pending = active?.approvals.get(command.interactionId);
-    if (!active || !pending)
+    const permission = active?.approvals.get(command.interactionId);
+    const elicitation = active?.elicitations.get(command.interactionId);
+    if (!active || !permission && !elicitation)
       return { ok: false, error: invalidState("Grok Approval is not pending") };
     if (command.response.type !== "approval") {
       return {
@@ -25701,10 +26260,30 @@ var GrokHarnessSession = class {
         }
       };
     }
-    const validation = validateHostApprovalResponse(pending.interaction, command.response);
+    const response = command.response;
+    if (elicitation) {
+      const validation2 = validateHostApprovalResponse(elicitation.interaction, response);
+      if (validation2)
+        return { ok: false, error: validation2 };
+      const action = elicitation.interaction.actions.find(({ id }) => id === response.actionId);
+      if (!action)
+        return {
+          ok: false,
+          error: {
+            code: "invalidRequest",
+            message: "Grok Approval action is unavailable",
+            retryable: false
+          }
+        };
+      this.#settleElicitation(active, elicitation, grokMcpElicitResponseForAction(action.effect === "allowOnce" || action.effect === "allowAlways" ? action.effect : "deny"), "responded");
+      return { ok: true, value: { accepted: true } };
+    }
+    if (!permission)
+      return { ok: false, error: invalidState("Grok Approval is not pending") };
+    const validation = validateHostApprovalResponse(permission.interaction, response);
     if (validation)
       return { ok: false, error: validation };
-    const option = pending.options.get(command.response.actionId);
+    const option = permission.options.get(response.actionId);
     if (!option)
       return {
         ok: false,
@@ -25715,7 +26294,7 @@ var GrokHarnessSession = class {
         }
       };
     active.approvals.delete(command.interactionId);
-    pending.resolve({ outcome: { outcome: "selected", optionId: option.optionId } });
+    permission.resolve({ outcome: { outcome: "selected", optionId: option.optionId } });
     this.#event({
       type: "interaction.closed",
       interactionId: command.interactionId,
@@ -25744,10 +26323,57 @@ var GrokHarnessSession = class {
       actions
     };
     return new Promise((resolve) => {
-      active.approvals.set(interactionId, { interaction, options, resolve });
+      active.approvals.set(interactionId, {
+        kind: "permission",
+        interaction,
+        options,
+        resolve
+      });
       this.#channel.emit({ kind: "interaction", interaction });
     });
   }
+  #requestElicitation(active, request) {
+    if (this.#active !== active || this.#phase !== "open" || active.cancellationRequested) {
+      return Promise.resolve(grokMcpElicitCancel());
+    }
+    for (const pending of active.elicitations.values()) {
+      if (pending.nativeToolCallId === request.toolCallId) {
+        return Promise.resolve(grokMcpElicitCancel());
+      }
+    }
+    const interactionId = hostInteractionIdSchema.parse(this.#randomUUID());
+    const interaction = projectGrokMcpElicitApproval({
+      interactionId,
+      turnId: active.command.turnId,
+      request
+    });
+    return new Promise((resolve) => {
+      active.elicitations.set(interactionId, {
+        kind: "elicitation",
+        nativeToolCallId: request.toolCallId,
+        interaction,
+        resolve
+      });
+      this.#channel.emit({ kind: "interaction", interaction });
+    });
+  }
+  #settleElicitation(active, pending, response, reason) {
+    if (!active.elicitations.has(pending.interaction.interactionId))
+      return;
+    active.elicitations.delete(pending.interaction.interactionId);
+    pending.resolve(response);
+    this.#event({
+      type: "interaction.closed",
+      interactionId: pending.interaction.interactionId,
+      turnId: active.command.turnId,
+      reason
+    });
+  }
+  #cancelActiveElicitations(active) {
+    for (const pending of [...active.elicitations.values()]) {
+      this.#settleElicitation(active, pending, grokMcpElicitCancel(), "cancelled");
+    }
+  }
   #handleEvent(active, event) {
     if (this.#active !== active || this.#phase !== "open")
       return;
@@ -25776,6 +26402,12 @@ var GrokHarnessSession = class {
     else if (event.type === "compaction.completed") {
       active.compactionTerminal = event;
       this.#completeCompaction(active, event);
+    } else if (event.type === "elicitation.resolved") {
+      for (const pending of [...active.elicitations.values()]) {
+        if (pending.nativeToolCallId === event.toolCallId) {
+          this.#settleElicitation(active, pending, grokMcpElicitCancel(), "cancelled");
+        }
+      }
     } else if (event.type === "usage" || event.type === "turn.completed")
       return;
   }
@@ -26184,6 +26816,7 @@ var GrokHarnessSession = class {
         reason: "cancelled"
       });
     }
+    this.#cancelActiveElicitations(active);
     this.#active = null;
     if (usage || this.#usage)
       this.#publishUsage({ ...usage, ...active.usage?.metrics() }, active.command.turnId, true);
@@ -26221,6 +26854,7 @@ var GrokHarnessSession = class {
       active.cancellationRequested = true;
       for (const approval of active.approvals.values())
         approval.resolve({ outcome: { outcome: "cancelled" } });
+      this.#cancelActiveElicitations(active);
       await this.#transport.cancel().catch(() => void 0);
       await Promise.race([
         active.completion,
@@ -26312,7 +26946,7 @@ var GrokAdapter = class {
     this.usageStatistics = createGrokUsageStatistics(options.environment ?? process.env);
     this.#toolOutputLimit = options.toolOutputLimit ?? DEFAULT_GROK_TOOL_OUTPUT_LIMIT;
     this.#dependencies = dependencies ?? {
-      randomUUID,
+      randomUUID: randomUUID2,
       createTransport: (transportOptions) => new GrokAcpTransport({ ...options, ...transportOptions })
     };
     this.#fetchCredits = this.#dependencies.fetchCredits ?? ((input) => fetchGrokCredits(input.environment ? { environment: input.environment } : this.#environment ? { environment: this.#environment } : {}));
@@ -26358,7 +26992,7 @@ var GrokAdapter = class {
   async inspect(input = {}) {
     if (this.#closePromise)
       return { status: "unavailable", error: invalidState("Grok Adapter is closed") };
-    const cwd = path16.resolve(input.cwd ?? process.cwd());
+    const cwd = path18.resolve(input.cwd ?? process.cwd());
     if (!input.refresh) {
       const cached2 = this.#inspectionCache.get(cwd);
       if (cached2)
@@ -26420,7 +27054,20 @@ var GrokAdapter = class {
         }
       };
     }
-    const cwd = path16.resolve(input.cwd);
+    try {
+      await applyGrokComputerUsePreference(this.#environment ?? process.env);
+    } catch {
+      console.warn("Could not apply Grok Computer Use settings");
+      return {
+        ok: false,
+        error: {
+          code: "unavailable",
+          message: "Could not apply Grok Computer Use settings. Retry after fixing Grok config.",
+          retryable: true
+        }
+      };
+    }
+    const cwd = path18.resolve(input.cwd);
     const parsedRef = input.kind === "resume" ? nativeSessionRefSchema.safeParse(input.nativeRef) : null;
     if (parsedRef && (!parsedRef.success || parsedRef.data.harnessId !== this.harnessId)) {
       return {