@opentig/cli 0.1.7 → 0.2.0

package/dist/server.mjs

@@ -1,24 +1,21 @@
 import { fileURLToPath, pathToFileURL } from "node:url";
 import path, { extname, delimiter, resolve, join, isAbsolute, dirname } from "node:path";
 import { randomUUID, randomBytes, createHash, createHmac, timingSafeEqual } from "node:crypto";
-import { access, mkdir, open, rename, chmod, rm, appendFile, readFile, mkdtemp, writeFile, lstat, readdir, realpath, stat, cp } from "node:fs/promises";
+import { stat, access, realpath, mkdir, open, rename, chmod, rm, appendFile, readFile, mkdtemp, writeFile, lstat, readdir, cp } from "node:fs/promises";
+import os, { constants, homedir, networkInterfaces } from "node:os";
 import { ChildProcess, execFile, spawnSync, spawn } from "node:child_process";
 import { StringDecoder } from "node:string_decoder";
 import { debuglog, stripVTControlCharacters, inspect, promisify, callbackify, aborted as aborted$1 } from "node:util";
 import process$3, { platform, hrtime, execPath, execArgv } from "node:process";
 import tty from "node:tty";
 import { setTimeout as setTimeout$1, scheduler, setImmediate } from "node:timers/promises";
-import os, { constants, homedir, networkInterfaces } from "node:os";
 import { once, addAbortListener, EventEmitter, on, setMaxListeners } from "node:events";
 import { serialize } from "node:v8";
-import fs, { openSync, readSync, closeSync, statSync, readFileSync, appendFileSync, writeFileSync, createWriteStream, createReadStream, watch } from "node:fs";
+import fs, { openSync, readSync, closeSync, statSync, readFileSync, appendFileSync, writeFileSync, createWriteStream, createReadStream, constants as constants$1, watch } from "node:fs";
 import { Buffer as Buffer$1 } from "node:buffer";
 import { Transform, getDefaultHighWaterMark, Duplex, Writable, Readable, PassThrough } from "node:stream";
 import { finished } from "node:stream/promises";
 import path$1 from "node:path/win32";
-import require$$0$2 from "child_process";
-import require$$0$1 from "path";
-import require$$0 from "fs";
 import { createServer, isIP } from "node:net";
 import { createServer as createServer$1 } from "node:http";
 import WebSocket, { WebSocketServer } from "ws";
@@ -769,7 +766,7 @@ const handleCommand = (filePath, rawArguments, rawOptions) => {
     verboseInfo
   };
 };
-function pathKey$2(options = {}) {
+function pathKey$1(options = {}) {
   const {
     env = process.env,
     platform: platform2 = process.platform
@@ -798,7 +795,7 @@ function traversePathUp(startPath) {
 }
 const npmRunPath = ({
   cwd = process$3.cwd(),
-  path: pathOption = process$3.env[pathKey$2()],
+  path: pathOption = process$3.env[pathKey$1()],
   preferLocal = true,
   execPath: execPath2 = process$3.execPath,
   addExecPath = true
@@ -830,7 +827,7 @@ const applyExecPath = (result, pathParts, execPath2, cwdPath) => {
 };
 const npmRunPathEnv = ({ env = process$3.env, ...options } = {}) => {
   env = { ...env };
-  const pathName = pathKey$2({ env });
+  const pathName = pathKey$1({ env });
   options.path = env[pathName];
   env[pathName] = npmRunPath(options);
   return env;
@@ -5262,7 +5259,7 @@ if (process.platform === "linux") {
 }
 const processOk = (process2) => !!process2 && typeof process2 === "object" && typeof process2.removeListener === "function" && typeof process2.emit === "function" && typeof process2.reallyExit === "function" && typeof process2.listeners === "function" && typeof process2.kill === "function" && typeof process2.pid === "number" && typeof process2.on === "function";
 const kExitEmitter = /* @__PURE__ */ Symbol.for("signal-exit emitter");
-const global$1 = globalThis;
+const global = globalThis;
 const ObjectDefineProperty = Object.defineProperty.bind(Object);
 class Emitter {
   emitted = {
@@ -5276,10 +5273,10 @@ class Emitter {
   count = 0;
   id = Math.random();
   constructor() {
-    if (global$1[kExitEmitter]) {
-      return global$1[kExitEmitter];
+    if (global[kExitEmitter]) {
+      return global[kExitEmitter];
     }
-    ObjectDefineProperty(global$1, kExitEmitter, {
+    ObjectDefineProperty(global, kExitEmitter, {
       value: this,
       writable: false,
       enumerable: false,
@@ -6875,6 +6872,153 @@ createExeca(() => ({ isSync: true }));
 createExeca(mapNode);
 createExeca(mapScriptAsync, {}, deepScriptOptions, setScriptSync);
 getIpcExport();
+const LOCATION_KEYS = ["PATH", "CODEX_INSTALL_DIR", "GROK_BIN_DIR", "BUN_INSTALL", "PNPM_HOME", "VOLTA_HOME", "NPM_CONFIG_PREFIX", "npm_config_prefix", "NVM_BIN", "FNM_MULTISHELL_PATH", "ASDF_DATA_DIR", "MISE_DATA_DIR", "XDG_DATA_HOME", "APPDATA", "LOCALAPPDATA"];
+function currentCliHost() {
+  let shell;
+  try {
+    shell = os.userInfo().shell ?? void 0;
+  } catch {
+  }
+  return { platform: process.platform, home: os.homedir(), env: cleanEnvironment(process.env), shell: process.env.SHELL || shell };
+}
+function cleanEnvironment(input, platform2 = process.platform) {
+  const result = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (value !== void 0) result[platform2 === "win32" && key.toUpperCase() === "PATH" ? "PATH" : key] = value;
+  }
+  return result;
+}
+function pathDirectories(value, platform2) {
+  const p = platform2 === "win32" ? path.win32 : path.posix;
+  const seen = /* @__PURE__ */ new Set();
+  return (value ?? "").split(platform2 === "win32" ? ";" : ":").map((item) => item.replace(/^"(.*)"$/, "$1")).filter((item) => {
+    if (!p.isAbsolute(item)) return false;
+    const key = platform2 === "win32" ? p.normalize(item).toLowerCase() : p.normalize(item);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+class CliEnvironment {
+  constructor(host = currentCliHost(), read = readUserEnvironment) {
+    this.host = host;
+    this.read = read;
+  }
+  host;
+  read;
+  cached;
+  pending;
+  generation = 0;
+  invalidate() {
+    this.generation++;
+    this.cached = void 0;
+    this.pending = void 0;
+  }
+  async get(force = false) {
+    const env = cleanEnvironment(this.host.env, this.host.platform);
+    const inheritedPath = pathDirectories(env.PATH, this.host.platform);
+    if (this.pending) return this.pending;
+    if (!force && this.cached && Date.now() - this.cached.at < 3e4) return this.cached.value;
+    const generation = this.generation;
+    const pending = (async () => {
+      let locations = {};
+      let warning;
+      try {
+        locations = await this.read(this.host);
+      } catch {
+        warning = "Could not refresh the user environment. Using the inherited environment and known installation locations. Check your shell configuration or set an executable path.";
+      }
+      const refreshedPath = pathDirectories(locations.PATH, this.host.platform);
+      const value = { env: { ...env, ...locations }, inheritedPath, refreshedPath, ...warning ? { warning } : {} };
+      if (generation === this.generation) this.cached = { at: Date.now(), value };
+      return value;
+    })();
+    this.pending = pending;
+    try {
+      return await pending;
+    } finally {
+      if (this.pending === pending) this.pending = void 0;
+    }
+  }
+}
+async function readUserEnvironment(host) {
+  const options = {
+    cwd: host.home,
+    env: host.env,
+    extendEnv: false,
+    input: "",
+    timeout: 5e3,
+    maxBuffer: 128 * 1024,
+    cleanup: true,
+    killDescendants: true,
+    windowsHide: true,
+    reject: false,
+    stripFinalNewline: false
+  };
+  if (host.platform === "win32") {
+    const root = host.env.SystemRoot || host.env.SYSTEMROOT;
+    if (!root || !path.win32.isAbsolute(root)) throw new Error("SystemRoot unavailable");
+    const shell2 = path.win32.join(root, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+    const script = '$ErrorActionPreference="Stop"; $r=@{}; foreach($scope in @("Machine","User")){ $r[$scope]=[Environment]::GetEnvironmentVariables($scope) }; ConvertTo-Json -InputObject $r -Compress';
+    const result = await execa(shell2, ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", script], options);
+    if (result.exitCode !== 0 || result.timedOut || result.isMaxBuffer) throw new Error("Environment query failed");
+    return windowsLocations(JSON.parse(result.stdout), host.env);
+  }
+  const shell = host.shell;
+  if (!shell || !path.posix.isAbsolute(shell)) throw new Error("User shell unavailable");
+  const kind = path.posix.basename(shell);
+  if (!["bash", "zsh", "fish"].includes(kind)) throw new Error("Unsupported user shell");
+  const started = Date.now();
+  const modes = kind === "bash" ? ["-lic", "-ic"] : ["-lic"];
+  let merged = {};
+  let succeeded = false;
+  for (const mode of modes) {
+    const timeout = 5e3 - (Date.now() - started);
+    if (timeout <= 0) break;
+    const script = LOCATION_KEYS.map((key) => kind === "fish" ? `printf '\\0OPENTIG_ENV_${key}\\0%s\\0' (string join ':' -- $${key})` : `printf '\\0OPENTIG_ENV_${key}\\0%s\\0' "$${key}"`).join("; ");
+    const result = await execa(shell, [mode, script], { ...options, timeout });
+    if (result.exitCode !== 0 || result.timedOut || result.isMaxBuffer) continue;
+    const locations = parseShellLocations(result.stdout);
+    if (!locations.PATH) continue;
+    succeeded = true;
+    merged = { ...merged, ...locations, PATH: [locations.PATH, merged.PATH].filter(Boolean).join(":") };
+  }
+  if (!succeeded) throw new Error("Shell environment query failed");
+  return merged;
+}
+function parseShellLocations(output) {
+  const locations = {};
+  for (const key of LOCATION_KEYS) {
+    const marker = `\0OPENTIG_ENV_${key}\0`;
+    const start = output.lastIndexOf(marker);
+    if (start < 0) continue;
+    const end = output.indexOf("\0", start + marker.length);
+    if (end < 0) continue;
+    const value = output.slice(start + marker.length, end);
+    if (value && !/[\r\n]/.test(value)) locations[key] = value;
+  }
+  return locations;
+}
+function windowsLocations(raw, inherited) {
+  const data = raw;
+  if (!data || typeof data !== "object" || !data.Machine || !data.User) throw new Error("Invalid environment response");
+  const upper = (input) => Object.fromEntries(Object.entries(input).filter(([, v]) => typeof v === "string").map(([k, v]) => [k.toUpperCase(), v]));
+  const machine = upper(data.Machine), user = upper(data.User);
+  const variables = { ...upper(inherited), ...machine, ...user };
+  const expand = (input) => {
+    let value = input;
+    for (let i2 = 0; i2 < 10; i2++) {
+      const next = value.replace(/%([^%]+)%/g, (match, key) => variables[key.toUpperCase()] ?? match);
+      if (next === value) break;
+      value = next;
+    }
+    return value;
+  };
+  const result = {};
+  for (const key of LOCATION_KEYS) if (key !== "PATH" && variables[key.toUpperCase()]) result[key] = expand(variables[key.toUpperCase()]);
+  result.PATH = [machine.PATH, user.PATH].filter((value) => !!value).map(expand).join(";");
+  return result;
+}
 class GitOperationError extends Error {
   detail;
   constructor(detail) {
@@ -6942,17 +7086,18 @@ class CliProcessRunner {
   async run(command2, args, options = {}) {
     const timeoutMs = options.timeoutMs ?? 15e3;
     const maxOutputBytes = options.maxOutputBytes ?? 2 * 1024 * 1024;
-    const environment = Object.fromEntries(
+    const environment = cleanEnvironment(Object.fromEntries(
       Object.entries({ ...process.env, ...options.env }).filter((entry) => entry[1] !== void 0)
-    );
+    ));
     for (const key of options.removeEnv ?? []) delete environment[key];
     if (this.closePromise || options.signal?.aborted) throw cancelled();
     const lifecycle = new AbortController();
     this.active.add(lifecycle);
     const signal = options.signal ? AbortSignal.any([options.signal, lifecycle.signal]) : lifecycle.signal;
-    const resolvedCommand = resolveProcessCommand(command2, options.cwd ?? process.cwd(), environment);
+    let resolvedCommand;
     let result;
     try {
+      resolvedCommand = resolveProcessCommand(command2, options.cwd ?? process.cwd(), environment);
       result = await execa(resolvedCommand.file, args, {
         ...options.cwd ? { cwd: options.cwd } : {},
         cancelSignal: signal,
@@ -6967,9 +7112,9 @@ class CliProcessRunner {
         input: options.stdin ?? "",
         stripFinalNewline: false,
         reject: false
-      }).catch(() => {
+      }).catch((error) => {
         if (signal.aborted) throw cancelled();
-        throw processFailed();
+        throw processFailed(error);
       });
     } finally {
       this.active.delete(lifecycle);
@@ -6986,7 +7131,7 @@ class CliProcessRunner {
       throw new AiOperationError({ code: "AI_CONTEXT_TOO_LARGE", operation: "ai-process", message: "The AI tool produced too much output." });
     }
     if (result.exitCode === void 0 || !resolvedCommand.found) {
-      throw processFailed();
+      throw processFailed(result);
     }
     return { exitCode: result.exitCode, stdout: result.stdout, stderr: result.stderr };
   }
@@ -7011,45 +7156,143 @@ class CliProcessRunner {
 function cancelled() {
   return new AiOperationError({ code: "AI_CANCELLED", operation: "ai-process", message: "Generation canceled." });
 }
-function processFailed() {
-  return new AiOperationError({ code: "AI_PROCESS_FAILED", operation: "ai-process", message: "Could not start the AI tool." });
+class CliLaunchError extends AiOperationError {
+  constructor(reason) {
+    super({ code: "AI_PROCESS_FAILED", operation: "ai-process", message: "Could not start the AI tool." });
+    this.reason = reason;
+  }
+  reason;
+}
+function processFailed(error) {
+  const code = error && typeof error === "object" && "code" in error ? error.code : void 0;
+  return new CliLaunchError(code === "ENOENT" ? "missing" : code === "EACCES" || code === "EPERM" ? "permission" : code === "ENOEXEC" ? "format" : "unknown");
 }
-const ALLOWED = /* @__PURE__ */ new Set(["codex", "claude", "opencode", "gh"]);
 const ALIASES = {
   codex: ["codex"],
   claude: ["claude"],
-  // OpenCode 2 installs as opencode2 and does not replace OpenCode 1's opencode binary.
   opencode: ["opencode", "opencode2"],
+  grok: ["grok"],
   gh: ["gh"]
 };
 class CliResolver {
+  constructor(environment = new CliEnvironment(), preferences = () => ({ aiExecutablePaths: {} })) {
+    this.environment = environment;
+    this.preferences = preferences;
+  }
+  environment;
+  preferences;
   cache = /* @__PURE__ */ new Map();
-  async resolve(name, forceRefresh = false) {
-    if (!ALLOWED.has(name)) return null;
-    if (!forceRefresh && this.cache.has(name)) return this.cache.get(name) ?? null;
-    let resolved = null;
-    for (const alias of ALIASES[name] ?? [name]) {
-      resolved = await findOnPath(alias);
-      if (resolved) break;
-    }
-    this.cache.set(name, resolved);
-    return resolved;
+  settingsKey = "";
+  generation = 0;
+  invalidate() {
+    this.generation++;
+    this.cache.clear();
+    this.environment.invalidate();
   }
-}
-async function findOnPath(name) {
-  const directories = (process.env.PATH ?? "").split(path.delimiter).filter(Boolean);
-  const extensions = process.platform === "win32" ? [".exe", ".cmd", ".bat"] : [""];
-  for (const extension of extensions) {
-    for (const directory of directories) {
-      const candidate = path.resolve(directory.replace(/^"|"$/g, ""), `${name}${extension}`);
-      try {
-        await access(candidate);
-        return candidate;
-      } catch {
+  async resolve(name, forceRefresh = false) {
+    return (await this.resolveAll(name, forceRefresh))[0] ?? null;
+  }
+  async resolveAll(name, forceRefresh = false) {
+    return (await this.discover(name, forceRefresh)).filter((item) => !item.problem).map((item) => item.executable);
+  }
+  async discover(name, forceRefresh = false) {
+    if (!Object.hasOwn(ALIASES, name)) return [];
+    const preferences = this.preferences();
+    const settingsKey = JSON.stringify(preferences.aiExecutablePaths);
+    if (settingsKey !== this.settingsKey) {
+      this.settingsKey = settingsKey;
+      this.invalidate();
+    }
+    const key = name;
+    if (forceRefresh) {
+      this.generation++;
+      this.cache.delete(key);
+    }
+    const generation = this.generation;
+    const cached2 = this.cache.get(key);
+    if (!forceRefresh && cached2 && Date.now() - cached2.at < 3e4) {
+      if ((await Promise.all(cached2.candidates.map((item) => this.problem(item.executable)))).every((problem, index) => problem === cached2.candidates[index]?.problem)) {
+        return structuredClone(cached2.candidates);
+      }
+    }
+    const snapshot = await this.environment.get(forceRefresh);
+    const host = this.environment.host;
+    const p = host.platform === "win32" ? path.win32 : path.posix;
+    const known = knownCliDirectories(name, host.home, host.platform, snapshot.env);
+    const allKnown = [...new Set(Object.keys(ALIASES).flatMap((id) => knownCliDirectories(id, host.home, host.platform, snapshot.env)))];
+    const runtimePath = host.platform === "win32" ? [...snapshot.inheritedPath, ...snapshot.refreshedPath] : [...snapshot.refreshedPath, ...snapshot.inheritedPath];
+    const env = { ...snapshot.env, PATH: pathDirectories([...runtimePath, ...allKnown].join(p.delimiter), host.platform).join(p.delimiter) };
+    if (host.env.XDG_DATA_HOME === void 0) delete env.XDG_DATA_HOME;
+    else env.XDG_DATA_HOME = host.env.XDG_DATA_HOME;
+    const configured = name === "gh" ? void 0 : preferences.aiExecutablePaths[name];
+    const candidates = [];
+    const seen = /* @__PURE__ */ new Set();
+    const add = async (executable, alias, source) => {
+      const problem = await this.problem(executable);
+      if (problem === "not-found" && source !== "configured") return;
+      const canonical = await realpath(executable).catch(() => executable);
+      const identity2 = host.platform === "win32" ? canonical.toLowerCase() : canonical;
+      if (seen.has(identity2)) return;
+      seen.add(identity2);
+      candidates.push({ executable, alias, source, env, ...problem ? { problem } : {}, ...snapshot.warning ? { warning: snapshot.warning } : {} });
+    };
+    if (configured) {
+      await add(configured, p.basename(configured), "configured");
+    } else {
+      for (const [directories, source] of [[snapshot.inheritedPath, "process-path"], [snapshot.refreshedPath, "user-path"], [known, "known-location"]]) {
+        for (const directory of directories) {
+          for (const alias of ALIASES[name]) {
+            for (const extension of executableExtensions(host.platform, snapshot.env)) await add(p.join(directory, `${alias}${extension}`), alias, source);
+          }
+        }
       }
     }
+    if (generation === this.generation) this.cache.set(key, { at: Date.now(), candidates });
+    return structuredClone(candidates);
   }
-  return null;
+  async warning() {
+    return (await this.environment.get()).warning;
+  }
+  async problem(executable) {
+    try {
+      if (!(await stat(executable)).isFile()) return "not-executable";
+      if (this.environment.host.platform === "win32") {
+        if (![".exe", ".com", ".cmd", ".bat"].includes(path.win32.extname(executable).toLowerCase())) return "not-executable";
+      } else await access(executable, constants$1.X_OK);
+      return void 0;
+    } catch (error) {
+      return error.code === "EACCES" ? "not-executable" : "not-found";
+    }
+  }
+}
+function executableExtensions(platform2, env) {
+  if (platform2 !== "win32") return [""];
+  const value = Object.entries(env).find(([key]) => key.toUpperCase() === "PATHEXT")?.[1] ?? ".COM;.EXE;.BAT;.CMD";
+  return [...new Set(value.split(";").map((item) => item.toLowerCase()).filter((item) => [".exe", ".com", ".cmd", ".bat"].includes(item)))];
+}
+function knownCliDirectories(name, home, platform2, env) {
+  const p = platform2 === "win32" ? path.win32 : path.posix;
+  const dirs = [p.join(home, ".local", "bin")];
+  if (name === "opencode") dirs.push(p.join(home, ".opencode", "bin"));
+  if (name === "grok") dirs.push(env.GROK_BIN_DIR, p.join(home, ".grok", "bin"));
+  if (name === "codex") dirs.push(env.CODEX_INSTALL_DIR);
+  dirs.push(env.PNPM_HOME, env.NVM_BIN, p.join(env.BUN_INSTALL || p.join(home, ".bun"), "bin"));
+  if (env.FNM_MULTISHELL_PATH) dirs.push(platform2 === "win32" ? env.FNM_MULTISHELL_PATH : p.join(env.FNM_MULTISHELL_PATH, "bin"));
+  const prefix = env.npm_config_prefix || env.NPM_CONFIG_PREFIX;
+  if (prefix) dirs.push(platform2 === "win32" ? prefix : p.join(prefix, "bin"));
+  if (platform2 === "win32") {
+    if (env.APPDATA) dirs.push(p.join(env.APPDATA, "npm"));
+    if (env.LOCALAPPDATA) {
+      dirs.push(p.join(env.LOCALAPPDATA, "Volta", "bin"), p.join(env.LOCALAPPDATA, "pnpm"), p.join(env.LOCALAPPDATA, "Microsoft", "WinGet", "Links"));
+      if (name === "codex") dirs.push(p.join(env.LOCALAPPDATA, "Programs", "OpenAI", "Codex", "bin"));
+    }
+    if (env.VOLTA_HOME) dirs.push(p.join(env.VOLTA_HOME, "bin"));
+  } else {
+    dirs.push(p.join(env.VOLTA_HOME || p.join(home, ".volta"), "bin"), p.join(home, ".npm-global", "bin"), p.join(home, ".yarn", "bin"));
+    dirs.push(p.join(env.XDG_DATA_HOME || p.join(home, ".local", "share"), "pnpm"));
+    dirs.push("/usr/local/bin", "/usr/bin", "/bin", platform2 === "darwin" ? "/opt/homebrew/bin" : "/home/linuxbrew/.linuxbrew/bin");
+  }
+  return [...new Set(dirs.filter((item) => !!item && p.isAbsolute(item)))];
 }
 var _a$1;
 function $constructor(name, initializer2, params) {
@@ -7286,7 +7529,7 @@ const NUMBER_FORMAT_RANGES = {
   float32: [-34028234663852886e22, 34028234663852886e22],
   float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
 };
-function pick$1(schema, mask) {
+function pick(schema, mask) {
   const currDef = schema._zod.def;
   const checks = currDef.checks;
   const hasChecks = checks && checks.length > 0;
@@ -11529,7 +11772,7 @@ const ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
       return merge(this, other);
     },
     pick(mask) {
-      return pick$1(this, mask);
+      return pick(this, mask);
     },
     omit(mask) {
       return omit(this, mask);
@@ -11854,7 +12097,7 @@ const EMPTY_AI_USAGE = {
 };
 const OPERATIONS = ["commit-message", "pull-request-draft"];
 const STATUSES = ["success", "failed", "cancelled"];
-const HARNESSES = ["codex", "claude", "opencode"];
+const HARNESSES = ["codex", "claude", "opencode", "grok"];
 const MAX_TEXT$1 = 200;
 const MAX_ERROR_TEXT = 400;
 const aiUsageRecordSchema = looseObject({
@@ -12134,7 +12377,7 @@ function parseGeneratedParts(value) {
   const parsed = generatedPartsSchema.safeParse(value);
   if (!parsed.success || `${parsed.data.subject}
 
-${parsed.data.body}`.length > 1e4) throw invalidOutput$3();
+${parsed.data.body}`.length > 1e4) throw invalidOutput$4();
   return parsed.data;
 }
 function parseCommitSplitProposal(value, stagedPaths) {
@@ -12194,14 +12437,14 @@ function parseJsonPayload(raw) {
         if (nested instanceof AiOperationError) throw nested;
       }
     }
-    throw invalidOutput$3();
+    throw invalidOutput$4();
   }
 }
 function asRecord(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) throw invalidOutput$3();
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw invalidOutput$4();
   return value;
 }
-function invalidOutput$3() {
+function invalidOutput$4() {
   return new AiOperationError({ code: "AI_INVALID_OUTPUT", operation: "ai-parse-output", message: "The AI returned a message with an invalid format.", retryable: true });
 }
 function hasControlCharacters$6(value, allowWhitespace) {
@@ -12215,22 +12458,58 @@ function cleanText(value, maxLength) {
   const text2 = value.trim();
   return !text2 || text2.length > maxLength || hasControlCharacters$6(text2, true) ? null : text2;
 }
+const DEFAULT_MODEL$1 = { id: "default", label: "Default (CLI)" };
 class CommitMessageService {
-  constructor(operations, providers, log) {
+  constructor(operations, providers, log, invalidateDiscovery) {
     this.operations = operations;
     this.log = log;
+    this.invalidateDiscovery = invalidateDiscovery;
     for (const provider of providers) this.providers.set(provider.id, provider);
   }
   operations;
   log;
+  invalidateDiscovery;
   providers = /* @__PURE__ */ new Map();
   active = /* @__PURE__ */ new Map();
   statusCache = null;
+  statusGeneration = 0;
+  pendingStatus;
+  invalidateStatuses() {
+    this.statusGeneration++;
+    this.statusCache = null;
+    this.pendingStatus = void 0;
+    this.invalidateDiscovery?.();
+  }
   async statuses(forceRefresh = false) {
     if (!forceRefresh && this.statusCache && Date.now() - this.statusCache.at < 3e4) return this.statusCache.value;
-    const value = await Promise.all([...this.providers.values()].map((provider) => provider.status(forceRefresh)));
-    this.statusCache = { at: Date.now(), value };
-    return value;
+    if (this.pendingStatus && (!forceRefresh || this.pendingStatus.force)) return this.pendingStatus.promise;
+    const generation = ++this.statusGeneration;
+    const promise = Promise.all([...this.providers.values()].map(async (provider) => {
+      try {
+        return await provider.status(forceRefresh);
+      } catch {
+        return {
+          id: provider.id,
+          label: { codex: "Codex", claude: "Claude Code", opencode: "OpenCode", grok: "Grok Build" }[provider.id],
+          installed: false,
+          availability: "error",
+          authStatus: "unknown",
+          installationStatus: "inspection-failed",
+          message: "Could not inspect this CLI. Check again or review its executable path.",
+          models: [DEFAULT_MODEL$1],
+          checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+    })).then((value) => {
+      if (generation === this.statusGeneration) this.statusCache = { at: Date.now(), value };
+      return value;
+    });
+    this.pendingStatus = { force: forceRefresh, promise };
+    try {
+      return await promise;
+    } finally {
+      if (this.pendingStatus?.promise === promise) this.pendingStatus = void 0;
+    }
   }
   async generate(input, externalSignal) {
     if (this.active.has(input.requestId) || [...this.active.values()].some((entry) => entry.repositoryId === input.repositoryId) || this.active.size >= 3) {
@@ -12293,7 +12572,7 @@ ${parts.body}` : parts.subject,
         splitBlockedReason: context.splitBlockedReason
       };
     } catch (error) {
-      const failure = failureLogFields(error);
+      const failure2 = failureLogFields(error);
       recordSafely(this.log, {
         operation: "commit-message",
         harness: input.harness,
@@ -12301,10 +12580,10 @@ ${parts.body}` : parts.subject,
         repositoryId: input.repositoryId,
         // A cancellation is a decision, not a failure; merging the two would
         // poison any reliability figure taken from this log.
-        status: failure.status,
+        status: failure2.status,
         durationMs: Date.now() - startedAt,
-        errorCode: failure.errorCode,
-        errorMessage: failure.errorMessage,
+        errorCode: failure2.errorCode,
+        errorMessage: failure2.errorMessage,
         usage,
         stagedFileCount,
         contextTruncated,
@@ -12375,10 +12654,10 @@ ${context.patch}`;
 }
 function parsePullRequestDraft(value) {
   const parsed = pullRequestDraftSchema.safeParse(value);
-  if (!parsed.success) throw invalidOutput$2();
+  if (!parsed.success) throw invalidOutput$3();
   return parsed.data;
 }
-function invalidOutput$2() {
+function invalidOutput$3() {
   return new AiOperationError({ code: "AI_INVALID_OUTPUT", operation: "ai-parse-pr-draft", message: "The AI returned a pull request draft with an invalid format.", retryable: true });
 }
 function hasControlCharacters$5(value, allowWhitespace) {
@@ -12428,8 +12707,8 @@ class PullRequestDraftService {
       this.record(input, "success", null, null, usage, contextTruncated, Date.now() - startedAt);
       return { ...parts, harness: input.harness, model: input.model, contextWasTruncated: context.truncated };
     } catch (error) {
-      const failure = failureLogFields(error);
-      this.record(input, failure.status, failure.errorCode, failure.errorMessage, usage, contextTruncated, Date.now() - startedAt);
+      const failure2 = failureLogFields(error);
+      this.record(input, failure2.status, failure2.errorCode, failure2.errorMessage, usage, contextTruncated, Date.now() - startedAt);
       throw error;
     } finally {
       this.active.delete(input.requestId);
@@ -12467,9 +12746,66 @@ function throwIfCancelled(signal, harness) {
   if (!signal?.aborted) return;
   throw new AiOperationError({ code: "AI_CANCELLED", operation: "ai-pr-draft", harness, message: "Generation canceled." });
 }
+function runCandidate(runner, candidate, args, options = {}) {
+  return runner.run(candidate.executable, args, { ...options, env: { ...candidate.env, ...options.env } });
+}
+async function selectCli(resolver, runner, name, options = {}) {
+  let first;
+  const candidates = await resolver.discover(name, options.forceRefresh);
+  for (const candidate of candidates) {
+    if (options.runOptions?.signal?.aborted) throw new AiOperationError({ code: "AI_CANCELLED", operation: "cli-discovery", message: "Generation canceled." });
+    if (candidate.problem) {
+      first ??= { candidate, state: candidate.problem };
+      continue;
+    }
+    try {
+      const result = await runCandidate(runner, candidate, ["--version"], options.runOptions);
+      const raw = result.stdout.trim() || result.stderr.trim();
+      const version2 = (raw.split(/\r?\n/)[0] ?? "").slice(0, 200);
+      if (result.exitCode !== 0 || !version2) {
+        first ??= { candidate, state: "not-executable" };
+        continue;
+      }
+      if (options.compatible && !options.compatible(raw)) {
+        first ??= { candidate, version: version2, state: "incompatible" };
+        continue;
+      }
+      return { candidate, version: version2, state: "available", warning: candidate.warning };
+    } catch (error) {
+      if (options.runOptions?.signal?.aborted) throw error;
+      first ??= { candidate, state: "not-executable" };
+    }
+  }
+  const warning = await resolver.warning();
+  return first ? { ...first, warning } : { state: warning ? "inspection-failed" : "not-found", warning };
+}
+function detectionFields(detected) {
+  return { installationStatus: detected.state, ...detected.candidate ? { executablePath: detected.candidate.executable, executableSource: detected.candidate.source } : {}, ...detected.warning ? { discoveryWarning: detected.warning } : {} };
+}
+function detectionFailure(detected, base, unsupported) {
+  if (detected.state === "available") return null;
+  const message = detected.state === "not-found" ? detected.candidate?.source === "configured" ? "The configured executable was not found. Correct the path or reset it to Automatic." : `Install ${base.label} and check again, or set its executable path.` : detected.state === "incompatible" ? unsupported ?? "The installed CLI version is not supported." : detected.state === "inspection-failed" ? "Could not inspect the CLI installation. Check again or set its executable path." : "The CLI was found but could not run. Check executable permissions, runtime dependencies, and system compatibility.";
+  return { ...base, ...detectionFields(detected), installed: !!detected.candidate && detected.state !== "not-found", availability: "error", authStatus: "unknown", ...detected.version ? { version: detected.version } : {}, message };
+}
+function requireCandidate(detected, name) {
+  if (detected.state !== "available" || !detected.candidate) throw new AiOperationError({ code: detected.state === "not-found" ? "AI_CLI_NOT_FOUND" : "AI_PROCESS_FAILED", operation: "cli-discovery", message: `${name} could not be started. Check its status in Settings → AI assistance.` });
+  return detected.candidate;
+}
 const AI_PROVIDER_TIMEOUT_MS = 9 * 6e4;
 const AI_SERVER_TIMEOUT_MS = AI_PROVIDER_TIMEOUT_MS + 3e4;
-const DEFAULT_MODEL = { id: "default", label: "Default (CLI)" };
+function grokUsage(envelope) {
+  if (!envelope || typeof envelope !== "object") return { ...EMPTY_AI_USAGE };
+  const record2 = envelope;
+  const usage = record2.usage && typeof record2.usage === "object" ? record2.usage : {};
+  return {
+    inputTokens: count(usage.input_tokens),
+    outputTokens: count(usage.output_tokens),
+    reasoningTokens: count(usage.reasoning_tokens),
+    cacheReadTokens: count(usage.cache_read_input_tokens),
+    cacheWriteTokens: count(usage.cache_creation_input_tokens),
+    costUsd: count(record2.total_cost_usd, true)
+  };
+}
 function claudeUsage(envelope) {
   if (!envelope || typeof envelope !== "object") return { ...EMPTY_AI_USAGE };
   const record2 = envelope;
@@ -12507,20 +12843,6 @@ function codexUsage(stdout) {
     costUsd: null
   };
 }
-function openCodeUsage(info) {
-  if (!info || typeof info !== "object") return { ...EMPTY_AI_USAGE };
-  const record2 = info;
-  const tokens = record2.tokens ?? {};
-  const cache = tokens.cache ?? {};
-  return {
-    inputTokens: count(tokens.input),
-    outputTokens: count(tokens.output),
-    reasoningTokens: count(tokens.reasoning),
-    cacheReadTokens: count(cache.read),
-    cacheWriteTokens: count(cache.write),
-    costUsd: count(record2.cost, true)
-  };
-}
 function count(value, fractional = false) {
   if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return null;
   return fractional ? value : Math.round(value);
@@ -12569,7 +12891,7 @@ ${diagnostic ?? ""}`.toLowerCase();
   });
 }
 function label(harness) {
-  return harness === "codex" ? "Codex" : harness === "claude" ? "Claude Code" : "OpenCode";
+  return harness === "codex" ? "Codex" : harness === "claude" ? "Claude Code" : harness === "grok" ? "Grok Build" : "OpenCode";
 }
 function stripAnsi(value) {
   return value.replace(new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g"), "");
@@ -12663,7 +12985,7 @@ function flattenWhitespace(value) {
   }
   return flattened.replace(/ {2,}/g, " ").trim();
 }
-const MODELS = [DEFAULT_MODEL, { id: "sonnet", label: "Sonnet" }, { id: "opus", label: "Opus" }, { id: "haiku", label: "Haiku" }];
+const MODELS = [DEFAULT_MODEL$1, { id: "sonnet", label: "Sonnet" }, { id: "opus", label: "Opus" }, { id: "haiku", label: "Haiku" }];
 class ClaudeProvider {
   constructor(resolver, runner) {
     this.resolver = resolver;
@@ -12674,10 +12996,11 @@ class ClaudeProvider {
   id = "claude";
   async status(forceRefresh = false) {
     const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const executable = await this.resolver.resolve("claude", forceRefresh);
-    if (!executable) return { id: this.id, label: "Claude Code", availability: "error", installed: false, authStatus: "unknown", message: "Install Claude Code to use this harness.", models: MODELS, checkedAt };
-    const version2 = await this.runner.run(executable, ["--version"]);
-    const auth = await this.runner.run(executable, ["auth", "status", "--json"]);
+    const detected = await selectCli(this.resolver, this.runner, "claude", { forceRefresh });
+    const failure2 = detectionFailure(detected, { id: this.id, label: "Claude Code", models: MODELS, checkedAt });
+    if (failure2) return failure2;
+    const executable = requireCandidate(detected, this.id);
+    const auth = await runCandidate(this.runner, executable, ["auth", "status", "--json"]);
     let loggedIn;
     try {
       loggedIn = auth.exitCode === 0 && JSON.parse(auth.stdout).loggedIn === true;
@@ -12685,23 +13008,23 @@ class ClaudeProvider {
       loggedIn = false;
     }
     return {
+      ...detectionFields(detected),
       id: this.id,
       label: "Claude Code",
       availability: loggedIn ? "ready" : "error",
       installed: true,
       authStatus: loggedIn ? "authenticated" : "unauthenticated",
-      version: version2.stdout.trim() || version2.stderr.trim(),
+      version: detected.version ?? "",
       ...!loggedIn ? { message: "Run claude auth login." } : {},
       models: MODELS,
       checkedAt
     };
   }
   async generate(input) {
-    const executable = await this.resolver.resolve("claude");
-    if (!executable) throw new AiOperationError({ code: "AI_CLI_NOT_FOUND", operation: "claude-generate", harness: this.id, message: "Claude Code is not installed." });
+    const executable = requireCandidate(await selectCli(this.resolver, this.runner, "claude", { runOptions: { signal: input.signal } }), this.id);
     const args = ["-p", "--output-format", "json", "--json-schema", JSON.stringify(input.schema), "--tools", "", "--no-session-persistence", "--safe-mode"];
     if (input.model !== "default") args.push("--model", input.model);
-    const result = await this.runner.run(executable, args, { cwd: input.repositoryPath, stdin: input.prompt, timeoutMs: AI_PROVIDER_TIMEOUT_MS, signal: input.signal, removeEnv: ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"] });
+    const result = await runCandidate(this.runner, executable, args, { cwd: input.repositoryPath, stdin: input.prompt, timeoutMs: AI_PROVIDER_TIMEOUT_MS, signal: input.signal, removeEnv: ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"] });
     requireSuccess(result, this.id, "claude-generate");
     try {
       const envelope = JSON.parse(result.stdout);
@@ -12724,31 +13047,32 @@ class CodexProvider {
   id = "codex";
   async status(forceRefresh = false) {
     const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const executable = await this.resolver.resolve("codex", forceRefresh);
-    if (!executable) return { id: this.id, label: "Codex", availability: "error", installed: false, authStatus: "unknown", message: "Install Codex CLI to use this harness.", models: [DEFAULT_MODEL], checkedAt };
-    const version2 = await this.runner.run(executable, ["--version"]);
-    const login = await this.runner.run(executable, ["login", "status"]);
+    const detected = await selectCli(this.resolver, this.runner, "codex", { forceRefresh });
+    const failure2 = detectionFailure(detected, { id: this.id, label: "Codex", models: [DEFAULT_MODEL$1], checkedAt });
+    if (failure2) return failure2;
+    const executable = requireCandidate(detected, this.id);
+    const login = await runCandidate(this.runner, executable, ["login", "status"]);
     if (login.exitCode !== 0 || !/logged in/i.test(`${login.stdout}
 ${login.stderr}`)) {
-      return { id: this.id, label: "Codex", availability: "error", installed: true, authStatus: "unauthenticated", version: version2.stdout.trim() || version2.stderr.trim(), message: "Run codex login.", models: [DEFAULT_MODEL], checkedAt };
+      return { ...detectionFields(detected), id: this.id, label: "Codex", availability: "error", installed: true, authStatus: "unauthenticated", version: detected.version ?? "", message: "Run codex login.", models: [DEFAULT_MODEL$1], checkedAt };
     }
-    const catalog = await this.runner.run(executable, ["debug", "models", "--bundled"]);
-    const models = catalog.exitCode === 0 ? parseCodexModels(catalog.stdout) : [DEFAULT_MODEL];
+    const catalog = await runCandidate(this.runner, executable, ["debug", "models", "--bundled"]);
+    const models = catalog.exitCode === 0 ? parseCodexModels(catalog.stdout) : [DEFAULT_MODEL$1];
     return {
+      ...detectionFields(detected),
       id: this.id,
       label: "Codex",
       availability: models.length > 1 ? "ready" : "warning",
       installed: true,
       authStatus: "authenticated",
-      version: version2.stdout.trim() || version2.stderr.trim(),
+      version: detected.version ?? "",
       ...models.length > 1 ? {} : { message: "Available; the model catalog could not be verified." },
       models,
       checkedAt
     };
   }
   async generate(input) {
-    const executable = await this.resolver.resolve("codex");
-    if (!executable) throw new AiOperationError({ code: "AI_CLI_NOT_FOUND", operation: "codex-generate", harness: this.id, message: "Codex is not installed." });
+    const executable = requireCandidate(await selectCli(this.resolver, this.runner, "codex", { runOptions: { signal: input.signal } }), this.id);
     const temporary = await mkdtemp(path.join(os.tmpdir(), "opentig-codex-"));
     const schemaPath = path.join(temporary, "schema.json");
     const outputPath = path.join(temporary, "output.json");
@@ -12757,7 +13081,7 @@ ${login.stderr}`)) {
       const args = ["exec", "--json", "--ephemeral", "--skip-git-repo-check", "-s", "read-only"];
       if (input.model !== "default") args.push("--model", input.model);
       args.push("--config", 'model_reasoning_effort="low"', "--output-schema", schemaPath, "--output-last-message", outputPath, "-");
-      const result = await this.runner.run(executable, args, { cwd: input.repositoryPath, stdin: input.prompt, timeoutMs: AI_PROVIDER_TIMEOUT_MS, signal: input.signal, removeEnv: ["OPENAI_API_KEY"] });
+      const result = await runCandidate(this.runner, executable, args, { cwd: input.repositoryPath, stdin: input.prompt, timeoutMs: AI_PROVIDER_TIMEOUT_MS, signal: input.signal, removeEnv: ["OPENAI_API_KEY"] });
       requireSuccess(result, this.id, "codex-generate");
       return { output: parseJsonPayload(await readFile(outputPath, "utf8")), usage: codexUsage(result.stdout) };
     } finally {
@@ -12769,2254 +13093,219 @@ function parseCodexModels(raw) {
   try {
     const parsed = JSON.parse(raw);
     const options = (parsed.models ?? []).filter((item) => typeof item.slug === "string" && item.visibility !== "hidden").map((item) => ({ id: item.slug, label: typeof item.display_name === "string" ? item.display_name : item.slug }));
-    return [DEFAULT_MODEL, ...options];
+    return [DEFAULT_MODEL$1, ...options];
   } catch {
-    return [DEFAULT_MODEL];
-  }
-}
-const createSseClient = ({ onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) => {
-  let lastEventId;
-  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms)));
-  const createStream = async function* () {
-    let retryDelay = sseDefaultRetryDelay ?? 3e3;
-    let attempt = 0;
-    const signal = options.signal ?? new AbortController().signal;
-    while (true) {
-      if (signal.aborted)
-        break;
-      attempt++;
-      const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
-      if (lastEventId !== void 0) {
-        headers.set("Last-Event-ID", lastEventId);
-      }
-      try {
-        const response = await fetch(url, { ...options, headers, signal });
-        if (!response.ok)
-          throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
-        if (!response.body)
-          throw new Error("No body in SSE response");
-        const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
-        let buffer = "";
-        const abortHandler = () => {
-          try {
-            void reader.cancel();
-          } catch {
-          }
-        };
-        signal.addEventListener("abort", abortHandler);
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-              break;
-            buffer += value;
-            const chunks = buffer.split("\n\n");
-            buffer = chunks.pop() ?? "";
-            for (const chunk of chunks) {
-              const lines = chunk.split("\n");
-              const dataLines = [];
-              let eventName;
-              for (const line of lines) {
-                if (line.startsWith("data:")) {
-                  dataLines.push(line.replace(/^data:\s*/, ""));
-                } else if (line.startsWith("event:")) {
-                  eventName = line.replace(/^event:\s*/, "");
-                } else if (line.startsWith("id:")) {
-                  lastEventId = line.replace(/^id:\s*/, "");
-                } else if (line.startsWith("retry:")) {
-                  const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10);
-                  if (!Number.isNaN(parsed)) {
-                    retryDelay = parsed;
-                  }
-                }
-              }
-              let data;
-              let parsedJson = false;
-              if (dataLines.length) {
-                const rawData = dataLines.join("\n");
-                try {
-                  data = JSON.parse(rawData);
-                  parsedJson = true;
-                } catch {
-                  data = rawData;
-                }
-              }
-              if (parsedJson) {
-                if (responseValidator) {
-                  await responseValidator(data);
-                }
-                if (responseTransformer) {
-                  data = await responseTransformer(data);
-                }
-              }
-              onSseEvent?.({
-                data,
-                event: eventName,
-                id: lastEventId,
-                retry: retryDelay
-              });
-              if (dataLines.length) {
-                yield data;
-              }
-            }
-          }
-        } finally {
-          signal.removeEventListener("abort", abortHandler);
-          reader.releaseLock();
-        }
-        break;
-      } catch (error) {
-        onSseError?.(error);
-        if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) {
-          break;
-        }
-        const backoff = Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 3e4);
-        await sleep(backoff);
-      }
-    }
-  };
-  const stream = createStream();
-  return { stream };
-};
-const getAuthToken = async (auth, callback) => {
-  const token = typeof callback === "function" ? await callback(auth) : callback;
-  if (!token) {
-    return;
-  }
-  if (auth.scheme === "bearer") {
-    return `Bearer ${token}`;
-  }
-  if (auth.scheme === "basic") {
-    return `Basic ${btoa(token)}`;
-  }
-  return token;
-};
-const jsonBodySerializer = {
-  bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value)
-};
-const separatorArrayExplode = (style) => {
-  switch (style) {
-    case "label":
-      return ".";
-    case "matrix":
-      return ";";
-    case "simple":
-      return ",";
-    default:
-      return "&";
-  }
-};
-const separatorArrayNoExplode = (style) => {
-  switch (style) {
-    case "form":
-      return ",";
-    case "pipeDelimited":
-      return "|";
-    case "spaceDelimited":
-      return "%20";
-    default:
-      return ",";
-  }
-};
-const separatorObjectExplode = (style) => {
-  switch (style) {
-    case "label":
-      return ".";
-    case "matrix":
-      return ";";
-    case "simple":
-      return ",";
-    default:
-      return "&";
-  }
-};
-const serializeArrayParam = ({ allowReserved, explode, name, style, value }) => {
-  if (!explode) {
-    const joinedValues2 = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
-    switch (style) {
-      case "label":
-        return `.${joinedValues2}`;
-      case "matrix":
-        return `;${name}=${joinedValues2}`;
-      case "simple":
-        return joinedValues2;
-      default:
-        return `${name}=${joinedValues2}`;
-    }
-  }
-  const separator = separatorArrayExplode(style);
-  const joinedValues = value.map((v) => {
-    if (style === "label" || style === "simple") {
-      return allowReserved ? v : encodeURIComponent(v);
-    }
-    return serializePrimitiveParam({
-      allowReserved,
-      name,
-      value: v
-    });
-  }).join(separator);
-  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
-};
-const serializePrimitiveParam = ({ allowReserved, name, value }) => {
-  if (value === void 0 || value === null) {
-    return "";
-  }
-  if (typeof value === "object") {
-    throw new Error("Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.");
-  }
-  return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
-};
-const serializeObjectParam = ({ allowReserved, explode, name, style, value, valueOnly }) => {
-  if (value instanceof Date) {
-    return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+    return [DEFAULT_MODEL$1];
   }
-  if (style !== "deepObject" && !explode) {
-    let values = [];
-    Object.entries(value).forEach(([key, v]) => {
-      values = [...values, key, allowReserved ? v : encodeURIComponent(v)];
-    });
-    const joinedValues2 = values.join(",");
-    switch (style) {
-      case "form":
-        return `${name}=${joinedValues2}`;
-      case "label":
-        return `.${joinedValues2}`;
-      case "matrix":
-        return `;${name}=${joinedValues2}`;
-      default:
-        return joinedValues2;
-    }
-  }
-  const separator = separatorObjectExplode(style);
-  const joinedValues = Object.entries(value).map(([key, v]) => serializePrimitiveParam({
-    allowReserved,
-    name: style === "deepObject" ? `${name}[${key}]` : key,
-    value: v
-  })).join(separator);
-  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
-};
-const PATH_PARAM_RE = /\{[^{}]+\}/g;
-const defaultPathSerializer = ({ path: path2, url: _url2 }) => {
-  let url = _url2;
-  const matches = _url2.match(PATH_PARAM_RE);
-  if (matches) {
-    for (const match of matches) {
-      let explode = false;
-      let name = match.substring(1, match.length - 1);
-      let style = "simple";
-      if (name.endsWith("*")) {
-        explode = true;
-        name = name.substring(0, name.length - 1);
-      }
-      if (name.startsWith(".")) {
-        name = name.substring(1);
-        style = "label";
-      } else if (name.startsWith(";")) {
-        name = name.substring(1);
-        style = "matrix";
-      }
-      const value = path2[name];
-      if (value === void 0 || value === null) {
-        continue;
-      }
-      if (Array.isArray(value)) {
-        url = url.replace(match, serializeArrayParam({ explode, name, style, value }));
-        continue;
-      }
-      if (typeof value === "object") {
-        url = url.replace(match, serializeObjectParam({
-          explode,
-          name,
-          style,
-          value,
-          valueOnly: true
-        }));
-        continue;
-      }
-      if (style === "matrix") {
-        url = url.replace(match, `;${serializePrimitiveParam({
-          name,
-          value
-        })}`);
-        continue;
-      }
-      const replaceValue = encodeURIComponent(style === "label" ? `.${value}` : value);
-      url = url.replace(match, replaceValue);
-    }
+}
+function isSupportedGrokVersion(raw) {
+  const match = /^grok (\d+)\.(\d+)\.(\d+)\b/i.exec(stripAnsi(raw).trim());
+  return !!match && Number(match[1]) === 1 && (Number(match[2]) > 0 || Number(match[3]) >= 46);
+}
+function parseGrokModels(raw) {
+  const text2 = stripAnsi(raw);
+  const authStatus = /You are not authenticated\./.test(text2) ? "unauthenticated" : /You are logged in with |You are using XAI_API_KEY\.|is using its own API key\.|authenticated via deployment key/.test(text2) ? "authenticated" : "unknown";
+  const models = [{ id: "default", label: "Default (Grok)" }];
+  const seen = /* @__PURE__ */ new Set(["default"]);
+  const catalog = text2.split("Available models:")[1] ?? "";
+  for (const line of catalog.split(/\r?\n/)) {
+    const match = /^\s+[*-]\s+([^\s]+?)(?:\s+\(default\))?\s*$/.exec(line);
+    const id = match?.[1];
+    if (id && id.length <= 200 && /^[\w.:/#-]+$/.test(id) && !seen.has(id)) {
+      seen.add(id);
+      models.push({ id, label: id });
+    }
+  }
+  return { authStatus, models };
+}
+function parseGrokOutput(raw) {
+  let envelope;
+  try {
+    envelope = parseJsonPayload(stripAnsi(raw));
+  } catch {
+    throw invalidOutput$2();
   }
-  return url;
-};
-const getUrl = ({ baseUrl, path: path2, query, querySerializer, url: _url2 }) => {
-  const pathUrl = _url2.startsWith("/") ? _url2 : `/${_url2}`;
-  let url = (baseUrl ?? "") + pathUrl;
-  if (path2) {
-    url = defaultPathSerializer({ path: path2, url });
+  if (envelope.type === "error" || envelope.structuredOutputError || envelope.stopReason !== "end_turn") throw invalidOutput$2();
+  const structured = envelope.structuredOutput;
+  if (structured !== void 0) {
+    if (!structured || typeof structured !== "object" || Array.isArray(structured)) throw invalidOutput$2();
+    return { envelope, output: structured };
   }
-  let search = query ? querySerializer(query) : "";
-  if (search.startsWith("?")) {
-    search = search.substring(1);
+  if (typeof envelope.text !== "string") throw invalidOutput$2();
+  try {
+    return { envelope, output: parseJsonPayload(envelope.text) };
+  } catch {
+    throw invalidOutput$2();
   }
-  if (search) {
-    url += `?${search}`;
+}
+function invalidOutput$2() {
+  return new AiOperationError({ code: "AI_INVALID_OUTPUT", operation: "grok-generate", harness: "grok", message: "Grok returned an incomplete or invalid structured response.", retryable: true });
+}
+const DEFAULT_MODEL = { id: "default", label: "Default (Grok)" };
+const UNSUPPORTED = "Grok Build 1.0.46 or later in the 1.x series is required, with headless JSON and tool controls.";
+const CONFIG = "[cli]\nauto_update = false\n[subagents]\nenabled = false\n[managed_mcps]\nenabled = false\ngateway_tools_enabled = false\n[memory]\nenabled = false\n[features]\nmanaged_config = false\ntitle_refresh = false\nturn_summary = false\n";
+const REQUIRED_FLAGS = ["--prompt-file", "--json-schema", "--output-format", "--tools", "--disallowed-tools", "--deny", "--disable-web-search", "--max-turns", "--permission-mode", "--verbatim"];
+class GrokProvider {
+  constructor(resolver, runner) {
+    this.resolver = resolver;
+    this.runner = runner;
   }
-  return url;
-};
-const createQuerySerializer = ({ allowReserved, array: array2, object: object2 } = {}) => {
-  const querySerializer = (queryParams) => {
-    const search = [];
-    if (queryParams && typeof queryParams === "object") {
-      for (const name in queryParams) {
-        const value = queryParams[name];
-        if (value === void 0 || value === null) {
-          continue;
-        }
-        if (Array.isArray(value)) {
-          const serializedArray = serializeArrayParam({
-            allowReserved,
-            explode: true,
-            name,
-            style: "form",
-            value,
-            ...array2
-          });
-          if (serializedArray)
-            search.push(serializedArray);
-        } else if (typeof value === "object") {
-          const serializedObject = serializeObjectParam({
-            allowReserved,
-            explode: true,
-            name,
-            style: "deepObject",
-            value,
-            ...object2
-          });
-          if (serializedObject)
-            search.push(serializedObject);
-        } else {
-          const serializedPrimitive = serializePrimitiveParam({
-            allowReserved,
-            name,
-            value
-          });
-          if (serializedPrimitive)
-            search.push(serializedPrimitive);
-        }
+  resolver;
+  runner;
+  id = "grok";
+  async status(forceRefresh = false) {
+    const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const base = { id: this.id, label: "Grok Build", checkedAt, models: [DEFAULT_MODEL] };
+    return this.withEnvironment(async (options) => {
+      const detected = await selectCli(this.resolver, this.runner, this.id, { forceRefresh, compatible: isSupportedGrokVersion, runOptions: options });
+      const failure2 = detectionFailure(detected, base, UNSUPPORTED);
+      if (failure2) return failure2;
+      const executable = requireCandidate(detected, this.id);
+      const installed = { ...base, ...detectionFields(detected), installed: true, version: detected.version ?? "" };
+      try {
+        await this.checkControls(executable, options);
+        const result = await runCandidate(this.runner, executable, ["models"], options);
+        if (result.exitCode !== 0) return { ...installed, availability: "warning", authStatus: "unknown", message: "Could not check Grok authentication or models. Check again or run grok models in a terminal." };
+        const { authStatus, models } = parseGrokModels(result.stdout);
+        return {
+          ...installed,
+          models,
+          authStatus,
+          availability: authStatus === "unauthenticated" ? "error" : authStatus === "authenticated" && models.length > 1 ? "ready" : "warning",
+          ...authStatus === "unauthenticated" ? { message: "Run grok login, or provide XAI_API_KEY to the OpenTig process." } : authStatus === "unknown" ? { message: "Could not confirm Grok authentication." } : {}
+        };
+      } catch (error) {
+        return { ...installed, availability: "error", authStatus: "unknown", message: error instanceof AiOperationError ? error.message : "Could not verify Grok execution controls." };
       }
-    }
-    return search.join("&");
-  };
-  return querySerializer;
-};
-const getParseAs = (contentType) => {
-  if (!contentType) {
-    return "stream";
-  }
-  const cleanContent = contentType.split(";")[0]?.trim();
-  if (!cleanContent) {
-    return;
-  }
-  if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) {
-    return "json";
-  }
-  if (cleanContent === "multipart/form-data") {
-    return "formData";
-  }
-  if (["application/", "audio/", "image/", "video/"].some((type) => cleanContent.startsWith(type))) {
-    return "blob";
-  }
-  if (cleanContent.startsWith("text/")) {
-    return "text";
-  }
-  return;
-};
-const checkForExistence = (options, name) => {
-  if (!name) {
-    return false;
-  }
-  if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) {
-    return true;
+    });
   }
-  return false;
-};
-const setAuthParams = async ({ security, ...options }) => {
-  for (const auth of security) {
-    if (checkForExistence(options, auth.name)) {
-      continue;
-    }
-    const token = await getAuthToken(auth, options.auth);
-    if (!token) {
-      continue;
-    }
-    const name = auth.name ?? "Authorization";
-    switch (auth.in) {
-      case "query":
-        if (!options.query) {
-          options.query = {};
-        }
-        options.query[name] = token;
-        break;
-      case "cookie":
-        options.headers.append("Cookie", `${name}=${token}`);
-        break;
-      case "header":
-      default:
-        options.headers.set(name, token);
-        break;
-    }
-  }
-};
-const buildUrl = (options) => getUrl({
-  baseUrl: options.baseUrl,
-  path: options.path,
-  query: options.query,
-  querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
-  url: options.url
-});
-const mergeConfigs = (a2, b) => {
-  const config2 = { ...a2, ...b };
-  if (config2.baseUrl?.endsWith("/")) {
-    config2.baseUrl = config2.baseUrl.substring(0, config2.baseUrl.length - 1);
-  }
-  config2.headers = mergeHeaders(a2.headers, b.headers);
-  return config2;
-};
-const mergeHeaders = (...headers) => {
-  const mergedHeaders = new Headers();
-  for (const header of headers) {
-    if (!header || typeof header !== "object") {
-      continue;
-    }
-    const iterator = header instanceof Headers ? header.entries() : Object.entries(header);
-    for (const [key, value] of iterator) {
-      if (value === null) {
-        mergedHeaders.delete(key);
-      } else if (Array.isArray(value)) {
-        for (const v of value) {
-          mergedHeaders.append(key, v);
-        }
-      } else if (value !== void 0) {
-        mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : value);
-      }
+  async generate(input) {
+    const timeout = AbortSignal.timeout(AI_PROVIDER_TIMEOUT_MS);
+    const signal = AbortSignal.any([input.signal, timeout]);
+    try {
+      return await this.withEnvironment(async (options) => {
+        const controlled = { ...options, signal };
+        const executable = requireCandidate(await selectCli(this.resolver, this.runner, this.id, { compatible: isSupportedGrokVersion, runOptions: controlled }), this.id);
+        await this.checkControls(executable, controlled);
+        const promptFile = path.join(options.cwd, "prompt.txt");
+        await writeFile(promptFile, input.prompt, { encoding: "utf8", mode: 384 });
+        const args = [
+          "--prompt-file",
+          promptFile,
+          "--output-format",
+          "json",
+          "--json-schema",
+          JSON.stringify(input.schema),
+          "--verbatim",
+          "--tools",
+          "read_file",
+          "--disallowed-tools",
+          "read_file,search_tool,use_tool,Agent",
+          "--deny",
+          "MCPTool",
+          "--disable-web-search",
+          "--max-turns",
+          "1",
+          "--permission-mode",
+          "dontAsk",
+          "--no-memory"
+        ];
+        if (input.model !== "default") args.push("--model", input.model);
+        const result = await runCandidate(this.runner, executable, args, { ...controlled, timeoutMs: AI_PROVIDER_TIMEOUT_MS });
+        requireGrokSuccess(result);
+        const parsed = parseGrokOutput(result.stdout);
+        return { output: parsed.output, usage: grokUsage(parsed.envelope) };
+      });
+    } catch (error) {
+      if (input.signal.aborted) throw failure("AI_CANCELLED", "Generation canceled.");
+      if (timeout.aborted) throw failure("AI_TIMEOUT", "Generation took too long.");
+      throw error;
     }
   }
-  return mergedHeaders;
-};
-class Interceptors {
-  _fns;
-  constructor() {
-    this._fns = [];
-  }
-  clear() {
-    this._fns = [];
-  }
-  getInterceptorIndex(id) {
-    if (typeof id === "number") {
-      return this._fns[id] ? id : -1;
-    } else {
-      return this._fns.indexOf(id);
+  async checkControls(executable, options) {
+    const help = await runCandidate(this.runner, executable, ["--help"], options);
+    if (help.exitCode !== 0 || REQUIRED_FLAGS.some((flag2) => !help.stdout.includes(flag2))) throw failure("AI_PROCESS_FAILED", UNSUPPORTED);
+    const result = await runCandidate(this.runner, executable, ["inspect", "--json"], options);
+    let report;
+    try {
+      report = JSON.parse(result.stdout);
+    } catch {
+      throw failure("AI_PROCESS_FAILED", "Could not verify the isolated Grok configuration.");
     }
-  }
-  exists(id) {
-    const index = this.getInterceptorIndex(id);
-    return !!this._fns[index];
-  }
-  eject(id) {
-    const index = this.getInterceptorIndex(id);
-    if (this._fns[index]) {
-      this._fns[index] = null;
+    const surfaces = ["hooks", "plugins", "mcpServers", "projectInstructions"];
+    if (result.exitCode !== 0 || !report || surfaces.some((key) => !Array.isArray(report[key]) || report[key].length > 0)) {
+      throw failure("AI_PROCESS_FAILED", "Grok configuration includes hooks, plugins, MCP servers or instructions. OpenTig requires an isolated text-only configuration.");
     }
   }
-  update(id, fn) {
-    const index = this.getInterceptorIndex(id);
-    if (this._fns[index]) {
-      this._fns[index] = fn;
-      return id;
-    } else {
-      return false;
+  async withEnvironment(run) {
+    const temporary = await mkdtemp(path.join(os.tmpdir(), "opentig-grok-"));
+    const userGrokHome = process.env.GROK_HOME || path.join(os.homedir(), ".grok");
+    const authPath = path.resolve(process.env.GROK_AUTH_PATH || path.join(userGrokHome, "auth.json"));
+    const privateGrokHome = path.join(temporary, ".grok");
+    try {
+      await mkdir(privateGrokHome, { mode: 448 });
+      await writeFile(path.join(privateGrokHome, "config.toml"), CONFIG, { encoding: "utf8", mode: 384 });
+      const env = {
+        HOME: temporary,
+        USERPROFILE: temporary,
+        GROK_HOME: privateGrokHome,
+        GROK_AUTH_PATH: authPath,
+        XDG_CONFIG_HOME: path.join(temporary, "config"),
+        XDG_DATA_HOME: path.join(temporary, "data"),
+        XDG_CACHE_HOME: path.join(temporary, "cache"),
+        GROK_SUBAGENTS: "0",
+        GROK_MANAGED_MCPS_ENABLED: "0",
+        GROK_MANAGED_MCP_GATEWAY_TOOLS_ENABLED: "0",
+        GROK_TITLE_REFRESH: "0"
+      };
+      const preserved = /* @__PURE__ */ new Set([...Object.keys(env), "GROK_AUTH", "GROK_CODE_XAI_API_KEY"]);
+      const removeEnv = Object.keys(process.env).filter((key) => key.startsWith("GROK_") && !preserved.has(key));
+      return await run({ cwd: temporary, env, removeEnv });
+    } finally {
+      await rm(temporary, { recursive: true, force: true, maxRetries: 3 });
     }
   }
-  use(fn) {
-    this._fns = [...this._fns, fn];
-    return this._fns.length - 1;
-  }
 }
-const createInterceptors = () => ({
-  error: new Interceptors(),
-  request: new Interceptors(),
-  response: new Interceptors()
-});
-const defaultQuerySerializer = createQuerySerializer({
-  allowReserved: false,
-  array: {
-    explode: true,
-    style: "form"
-  },
-  object: {
-    explode: true,
-    style: "deepObject"
-  }
-});
-const defaultHeaders = {
-  "Content-Type": "application/json"
-};
-const createConfig = (override = {}) => ({
-  ...jsonBodySerializer,
-  headers: defaultHeaders,
-  parseAs: "auto",
-  querySerializer: defaultQuerySerializer,
-  ...override
-});
-const createClient = (config2 = {}) => {
-  let _config = mergeConfigs(createConfig(), config2);
-  const getConfig = () => ({ ..._config });
-  const setConfig = (config3) => {
-    _config = mergeConfigs(_config, config3);
-    return getConfig();
-  };
-  const interceptors = createInterceptors();
-  const beforeRequest = async (options) => {
-    const opts = {
-      ..._config,
-      ...options,
-      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
-      headers: mergeHeaders(_config.headers, options.headers),
-      serializedBody: void 0
-    };
-    if (opts.security) {
-      await setAuthParams({
-        ...opts,
-        security: opts.security
-      });
-    }
-    if (opts.requestValidator) {
-      await opts.requestValidator(opts);
-    }
-    if (opts.body && opts.bodySerializer) {
-      opts.serializedBody = opts.bodySerializer(opts.body);
-    }
-    if (opts.serializedBody === void 0 || opts.serializedBody === "") {
-      opts.headers.delete("Content-Type");
-    }
-    const url = buildUrl(opts);
-    return { opts, url };
-  };
-  const request = async (options) => {
-    const { opts, url } = await beforeRequest(options);
-    const requestInit = {
-      redirect: "follow",
-      ...opts,
-      body: opts.serializedBody
-    };
-    let request2 = new Request(url, requestInit);
-    for (const fn of interceptors.request._fns) {
-      if (fn) {
-        request2 = await fn(request2, opts);
-      }
-    }
-    const _fetch = opts.fetch;
-    let response = await _fetch(request2);
-    for (const fn of interceptors.response._fns) {
-      if (fn) {
-        response = await fn(response, request2, opts);
-      }
-    }
-    const result = {
-      request: request2,
-      response
-    };
-    if (response.ok) {
-      if (response.status === 204 || response.headers.get("Content-Length") === "0") {
-        return opts.responseStyle === "data" ? {} : {
-          data: {},
-          ...result
-        };
-      }
-      const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
-      let data;
-      switch (parseAs) {
-        case "arrayBuffer":
-        case "blob":
-        case "formData":
-        case "json":
-        case "text":
-          data = await response[parseAs]();
-          break;
-        case "stream":
-          return opts.responseStyle === "data" ? response.body : {
-            data: response.body,
-            ...result
-          };
-      }
-      if (parseAs === "json") {
-        if (opts.responseValidator) {
-          await opts.responseValidator(data);
-        }
-        if (opts.responseTransformer) {
-          data = await opts.responseTransformer(data);
-        }
-      }
-      return opts.responseStyle === "data" ? data : {
-        data,
-        ...result
-      };
-    }
-    const textError = await response.text();
-    let jsonError;
-    try {
-      jsonError = JSON.parse(textError);
-    } catch {
-    }
-    const error = jsonError ?? textError;
-    let finalError = error;
-    for (const fn of interceptors.error._fns) {
-      if (fn) {
-        finalError = await fn(error, response, request2, opts);
-      }
-    }
-    finalError = finalError || {};
-    if (opts.throwOnError) {
-      throw finalError;
-    }
-    return opts.responseStyle === "data" ? void 0 : {
-      error: finalError,
-      ...result
-    };
-  };
-  const makeMethod = (method) => {
-    const fn = (options) => request({ ...options, method });
-    fn.sse = async (options) => {
-      const { opts, url } = await beforeRequest(options);
-      return createSseClient({
-        ...opts,
-        body: opts.body,
-        headers: opts.headers,
-        method,
-        url
-      });
-    };
-    return fn;
-  };
-  return {
-    buildUrl,
-    connect: makeMethod("CONNECT"),
-    delete: makeMethod("DELETE"),
-    get: makeMethod("GET"),
-    getConfig,
-    head: makeMethod("HEAD"),
-    interceptors,
-    options: makeMethod("OPTIONS"),
-    patch: makeMethod("PATCH"),
-    post: makeMethod("POST"),
-    put: makeMethod("PUT"),
-    request,
-    setConfig,
-    trace: makeMethod("TRACE")
-  };
-};
-const client = createClient(createConfig({
-  baseUrl: "http://localhost:4096"
-}));
-class _HeyApiClient {
-  _client = client;
-  constructor(args) {
-    if (args?.client) {
-      this._client = args.client;
-    }
-  }
-}
-class Global extends _HeyApiClient {
-  /**
-   * Get events
-   */
-  event(options) {
-    return (options?.client ?? this._client).get.sse({
-      url: "/global/event",
-      ...options
-    });
-  }
-}
-class Project extends _HeyApiClient {
-  /**
-   * List all projects
-   */
-  list(options) {
-    return (options?.client ?? this._client).get({
-      url: "/project",
-      ...options
-    });
-  }
-  /**
-   * Get the current project
-   */
-  current(options) {
-    return (options?.client ?? this._client).get({
-      url: "/project/current",
-      ...options
-    });
-  }
-}
-class Pty extends _HeyApiClient {
-  /**
-   * List all PTY sessions
-   */
-  list(options) {
-    return (options?.client ?? this._client).get({
-      url: "/pty",
-      ...options
-    });
-  }
-  /**
-   * Create a new PTY session
-   */
-  create(options) {
-    return (options?.client ?? this._client).post({
-      url: "/pty",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers
-      }
-    });
-  }
-  /**
-   * Remove a PTY session
-   */
-  remove(options) {
-    return (options.client ?? this._client).delete({
-      url: "/pty/{id}",
-      ...options
-    });
-  }
-  /**
-   * Get PTY session info
-   */
-  get(options) {
-    return (options.client ?? this._client).get({
-      url: "/pty/{id}",
-      ...options
-    });
-  }
-  /**
-   * Update PTY session
-   */
-  update(options) {
-    return (options.client ?? this._client).put({
-      url: "/pty/{id}",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  /**
-   * Connect to a PTY session
-   */
-  connect(options) {
-    return (options.client ?? this._client).get({
-      url: "/pty/{id}/connect",
-      ...options
-    });
-  }
-}
-class Config extends _HeyApiClient {
-  /**
-   * Get config info
-   */
-  get(options) {
-    return (options?.client ?? this._client).get({
-      url: "/config",
-      ...options
-    });
-  }
-  /**
-   * Update config
-   */
-  update(options) {
-    return (options?.client ?? this._client).patch({
-      url: "/config",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers
-      }
-    });
-  }
-  /**
-   * List all providers
-   */
-  providers(options) {
-    return (options?.client ?? this._client).get({
-      url: "/config/providers",
-      ...options
-    });
-  }
-}
-class Tool extends _HeyApiClient {
-  /**
-   * List all tool IDs (including built-in and dynamically registered)
-   */
-  ids(options) {
-    return (options?.client ?? this._client).get({
-      url: "/experimental/tool/ids",
-      ...options
-    });
-  }
-  /**
-   * List tools with JSON schema parameters for a provider/model
-   */
-  list(options) {
-    return (options.client ?? this._client).get({
-      url: "/experimental/tool",
-      ...options
-    });
-  }
-}
-class Instance extends _HeyApiClient {
-  /**
-   * Dispose the current instance
-   */
-  dispose(options) {
-    return (options?.client ?? this._client).post({
-      url: "/instance/dispose",
-      ...options
-    });
-  }
-}
-class Path extends _HeyApiClient {
-  /**
-   * Get the current path
-   */
-  get(options) {
-    return (options?.client ?? this._client).get({
-      url: "/path",
-      ...options
-    });
-  }
-}
-class Vcs extends _HeyApiClient {
-  /**
-   * Get VCS info for the current instance
-   */
-  get(options) {
-    return (options?.client ?? this._client).get({
-      url: "/vcs",
-      ...options
-    });
-  }
-}
-class Session extends _HeyApiClient {
-  /**
-   * List all sessions
-   */
-  list(options) {
-    return (options?.client ?? this._client).get({
-      url: "/session",
-      ...options
-    });
-  }
-  /**
-   * Create a new session
-   */
-  create(options) {
-    return (options?.client ?? this._client).post({
-      url: "/session",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers
-      }
-    });
-  }
-  /**
-   * Get session status
-   */
-  status(options) {
-    return (options?.client ?? this._client).get({
-      url: "/session/status",
-      ...options
-    });
-  }
-  /**
-   * Delete a session and all its data
-   */
-  delete(options) {
-    return (options.client ?? this._client).delete({
-      url: "/session/{id}",
-      ...options
-    });
-  }
-  /**
-   * Get session
-   */
-  get(options) {
-    return (options.client ?? this._client).get({
-      url: "/session/{id}",
-      ...options
-    });
-  }
-  /**
-   * Update session properties
-   */
-  update(options) {
-    return (options.client ?? this._client).patch({
-      url: "/session/{id}",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  /**
-   * Get a session's children
-   */
-  children(options) {
-    return (options.client ?? this._client).get({
-      url: "/session/{id}/children",
-      ...options
-    });
-  }
-  /**
-   * Get the todo list for a session
-   */
-  todo(options) {
-    return (options.client ?? this._client).get({
-      url: "/session/{id}/todo",
-      ...options
-    });
-  }
-  /**
-   * Analyze the app and create an AGENTS.md file
-   */
-  init(options) {
-    return (options.client ?? this._client).post({
-      url: "/session/{id}/init",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  /**
-   * Fork an existing session at a specific message
-   */
-  fork(options) {
-    return (options.client ?? this._client).post({
-      url: "/session/{id}/fork",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  /**
-   * Abort a session
-   */
-  abort(options) {
-    return (options.client ?? this._client).post({
-      url: "/session/{id}/abort",
-      ...options
-    });
-  }
-  /**
-   * Unshare the session
-   */
-  unshare(options) {
-    return (options.client ?? this._client).delete({
-      url: "/session/{id}/share",
-      ...options
-    });
-  }
-  /**
-   * Share a session
-   */
-  share(options) {
-    return (options.client ?? this._client).post({
-      url: "/session/{id}/share",
-      ...options
-    });
-  }
-  /**
-   * Get the diff for this session
-   */
-  diff(options) {
-    return (options.client ?? this._client).get({
-      url: "/session/{id}/diff",
-      ...options
-    });
-  }
-  /**
-   * Summarize the session
-   */
-  summarize(options) {
-    return (options.client ?? this._client).post({
-      url: "/session/{id}/summarize",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  /**
-   * List messages for a session
-   */
-  messages(options) {
-    return (options.client ?? this._client).get({
-      url: "/session/{id}/message",
-      ...options
-    });
-  }
-  /**
-   * Create and send a new message to a session
-   */
-  prompt(options) {
-    return (options.client ?? this._client).post({
-      url: "/session/{id}/message",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  /**
-   * Get a message from a session
-   */
-  message(options) {
-    return (options.client ?? this._client).get({
-      url: "/session/{id}/message/{messageID}",
-      ...options
-    });
-  }
-  /**
-   * Create and send a new message to a session, start if needed and return immediately
-   */
-  promptAsync(options) {
-    return (options.client ?? this._client).post({
-      url: "/session/{id}/prompt_async",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  /**
-   * Send a new command to a session
-   */
-  command(options) {
-    return (options.client ?? this._client).post({
-      url: "/session/{id}/command",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  /**
-   * Run a shell command
-   */
-  shell(options) {
-    return (options.client ?? this._client).post({
-      url: "/session/{id}/shell",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  /**
-   * Revert a message
-   */
-  revert(options) {
-    return (options.client ?? this._client).post({
-      url: "/session/{id}/revert",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  /**
-   * Restore all reverted messages
-   */
-  unrevert(options) {
-    return (options.client ?? this._client).post({
-      url: "/session/{id}/unrevert",
-      ...options
-    });
-  }
-}
-class Command extends _HeyApiClient {
-  /**
-   * List all commands
-   */
-  list(options) {
-    return (options?.client ?? this._client).get({
-      url: "/command",
-      ...options
-    });
-  }
-}
-class Oauth extends _HeyApiClient {
-  /**
-   * Authorize a provider using OAuth
-   */
-  authorize(options) {
-    return (options.client ?? this._client).post({
-      url: "/provider/{id}/oauth/authorize",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  /**
-   * Handle OAuth callback for a provider
-   */
-  callback(options) {
-    return (options.client ?? this._client).post({
-      url: "/provider/{id}/oauth/callback",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-}
-class Provider extends _HeyApiClient {
-  /**
-   * List all providers
-   */
-  list(options) {
-    return (options?.client ?? this._client).get({
-      url: "/provider",
-      ...options
-    });
-  }
-  /**
-   * Get provider authentication methods
-   */
-  auth(options) {
-    return (options?.client ?? this._client).get({
-      url: "/provider/auth",
-      ...options
-    });
-  }
-  oauth = new Oauth({ client: this._client });
-}
-class Find extends _HeyApiClient {
-  /**
-   * Find text in files
-   */
-  text(options) {
-    return (options.client ?? this._client).get({
-      url: "/find",
-      ...options
-    });
-  }
-  /**
-   * Find files
-   */
-  files(options) {
-    return (options.client ?? this._client).get({
-      url: "/find/file",
-      ...options
-    });
-  }
-  /**
-   * Find workspace symbols
-   */
-  symbols(options) {
-    return (options.client ?? this._client).get({
-      url: "/find/symbol",
-      ...options
-    });
-  }
-}
-class File extends _HeyApiClient {
-  /**
-   * List files and directories
-   */
-  list(options) {
-    return (options.client ?? this._client).get({
-      url: "/file",
-      ...options
-    });
-  }
-  /**
-   * Read a file
-   */
-  read(options) {
-    return (options.client ?? this._client).get({
-      url: "/file/content",
-      ...options
-    });
-  }
-  /**
-   * Get file status
-   */
-  status(options) {
-    return (options?.client ?? this._client).get({
-      url: "/file/status",
-      ...options
-    });
-  }
-}
-class App extends _HeyApiClient {
-  /**
-   * Write a log entry to the server logs
-   */
-  log(options) {
-    return (options?.client ?? this._client).post({
-      url: "/log",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers
-      }
-    });
-  }
-  /**
-   * List all agents
-   */
-  agents(options) {
-    return (options?.client ?? this._client).get({
-      url: "/agent",
-      ...options
-    });
-  }
-}
-class Auth extends _HeyApiClient {
-  /**
-   * Remove OAuth credentials for an MCP server
-   */
-  remove(options) {
-    return (options.client ?? this._client).delete({
-      url: "/mcp/{name}/auth",
-      ...options
-    });
-  }
-  /**
-   * Start OAuth authentication flow for an MCP server
-   */
-  start(options) {
-    return (options.client ?? this._client).post({
-      url: "/mcp/{name}/auth",
-      ...options
-    });
-  }
-  /**
-   * Complete OAuth authentication with authorization code
-   */
-  callback(options) {
-    return (options.client ?? this._client).post({
-      url: "/mcp/{name}/auth/callback",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  /**
-   * Start OAuth flow and wait for callback (opens browser)
-   */
-  authenticate(options) {
-    return (options.client ?? this._client).post({
-      url: "/mcp/{name}/auth/authenticate",
-      ...options
-    });
-  }
-  /**
-   * Set authentication credentials
-   */
-  set(options) {
-    return (options.client ?? this._client).put({
-      url: "/auth/{id}",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-}
-class Mcp extends _HeyApiClient {
-  /**
-   * Get MCP server status
-   */
-  status(options) {
-    return (options?.client ?? this._client).get({
-      url: "/mcp",
-      ...options
-    });
-  }
-  /**
-   * Add MCP server dynamically
-   */
-  add(options) {
-    return (options?.client ?? this._client).post({
-      url: "/mcp",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers
-      }
-    });
-  }
-  /**
-   * Connect an MCP server
-   */
-  connect(options) {
-    return (options.client ?? this._client).post({
-      url: "/mcp/{name}/connect",
-      ...options
-    });
-  }
-  /**
-   * Disconnect an MCP server
-   */
-  disconnect(options) {
-    return (options.client ?? this._client).post({
-      url: "/mcp/{name}/disconnect",
-      ...options
-    });
-  }
-  auth = new Auth({ client: this._client });
-}
-class Lsp extends _HeyApiClient {
-  /**
-   * Get LSP server status
-   */
-  status(options) {
-    return (options?.client ?? this._client).get({
-      url: "/lsp",
-      ...options
-    });
-  }
-}
-class Formatter extends _HeyApiClient {
-  /**
-   * Get formatter status
-   */
-  status(options) {
-    return (options?.client ?? this._client).get({
-      url: "/formatter",
-      ...options
-    });
-  }
-}
-class Control extends _HeyApiClient {
-  /**
-   * Get the next TUI request from the queue
-   */
-  next(options) {
-    return (options?.client ?? this._client).get({
-      url: "/tui/control/next",
-      ...options
-    });
-  }
-  /**
-   * Submit a response to the TUI request queue
-   */
-  response(options) {
-    return (options?.client ?? this._client).post({
-      url: "/tui/control/response",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers
-      }
-    });
-  }
-}
-class Tui extends _HeyApiClient {
-  /**
-   * Append prompt to the TUI
-   */
-  appendPrompt(options) {
-    return (options?.client ?? this._client).post({
-      url: "/tui/append-prompt",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers
-      }
-    });
-  }
-  /**
-   * Open the help dialog
-   */
-  openHelp(options) {
-    return (options?.client ?? this._client).post({
-      url: "/tui/open-help",
-      ...options
-    });
-  }
-  /**
-   * Open the session dialog
-   */
-  openSessions(options) {
-    return (options?.client ?? this._client).post({
-      url: "/tui/open-sessions",
-      ...options
-    });
-  }
-  /**
-   * Open the theme dialog
-   */
-  openThemes(options) {
-    return (options?.client ?? this._client).post({
-      url: "/tui/open-themes",
-      ...options
-    });
-  }
-  /**
-   * Open the model dialog
-   */
-  openModels(options) {
-    return (options?.client ?? this._client).post({
-      url: "/tui/open-models",
-      ...options
-    });
-  }
-  /**
-   * Submit the prompt
-   */
-  submitPrompt(options) {
-    return (options?.client ?? this._client).post({
-      url: "/tui/submit-prompt",
-      ...options
-    });
-  }
-  /**
-   * Clear the prompt
-   */
-  clearPrompt(options) {
-    return (options?.client ?? this._client).post({
-      url: "/tui/clear-prompt",
-      ...options
-    });
-  }
-  /**
-   * Execute a TUI command (e.g. agent_cycle)
-   */
-  executeCommand(options) {
-    return (options?.client ?? this._client).post({
-      url: "/tui/execute-command",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers
-      }
-    });
-  }
-  /**
-   * Show a toast notification in the TUI
-   */
-  showToast(options) {
-    return (options?.client ?? this._client).post({
-      url: "/tui/show-toast",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers
-      }
-    });
-  }
-  /**
-   * Publish a TUI event
-   */
-  publish(options) {
-    return (options?.client ?? this._client).post({
-      url: "/tui/publish",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers
-      }
-    });
-  }
-  control = new Control({ client: this._client });
-}
-class Event extends _HeyApiClient {
-  /**
-   * Get events
-   */
-  subscribe(options) {
-    return (options?.client ?? this._client).get.sse({
-      url: "/event",
-      ...options
-    });
-  }
-}
-class OpencodeClient extends _HeyApiClient {
-  /**
-   * Respond to a permission request
-   */
-  postSessionIdPermissionsPermissionId(options) {
-    return (options.client ?? this._client).post({
-      url: "/session/{id}/permissions/{permissionID}",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  global = new Global({ client: this._client });
-  project = new Project({ client: this._client });
-  pty = new Pty({ client: this._client });
-  config = new Config({ client: this._client });
-  tool = new Tool({ client: this._client });
-  instance = new Instance({ client: this._client });
-  path = new Path({ client: this._client });
-  vcs = new Vcs({ client: this._client });
-  session = new Session({ client: this._client });
-  command = new Command({ client: this._client });
-  provider = new Provider({ client: this._client });
-  find = new Find({ client: this._client });
-  file = new File({ client: this._client });
-  app = new App({ client: this._client });
-  mcp = new Mcp({ client: this._client });
-  lsp = new Lsp({ client: this._client });
-  formatter = new Formatter({ client: this._client });
-  tui = new Tui({ client: this._client });
-  auth = new Auth({ client: this._client });
-  event = new Event({ client: this._client });
-}
-function wrapClientError(error, response, request, opts) {
-  if (!opts?.throwOnError)
-    return error;
-  if (error instanceof Error)
-    return error;
-  if (typeof error === "object" && error !== null && Object.keys(error).length > 0) {
-    const obj = error;
-    const message = typeof obj.data?.message === "string" && obj.data.message || typeof obj.message === "string" && obj.message || typeof obj.name === "string" && obj.name || describe(request, response);
-    return new Error(message, { cause: { body: error, status: response?.status } });
-  }
-  if (typeof error === "string" && error.length > 0) {
-    return new Error(error, { cause: { body: error, status: response?.status } });
-  }
-  const reason = response ? "(empty response body)" : "network error (no response)";
-  return new Error(`opencode server ${describe(request, response)}: ${reason}`, {
-    cause: { body: error, status: response?.status }
-  });
-}
-function describe(request, response) {
-  const method = request?.method ?? "?";
-  const url = request?.url ?? "?";
-  const status = response?.status;
-  const statusText = response?.statusText;
-  return `${method} ${url}${status ? " → " + status : ""}${statusText ? " " + statusText : ""}`;
-}
-function pick(value, fallback) {
-  if (!value)
-    return;
-  if (!fallback)
-    return value;
-  if (value === fallback)
-    return fallback;
-  if (value === encodeURIComponent(fallback))
-    return fallback;
-  return value;
-}
-function rewrite(request, directory) {
-  if (request.method !== "GET" && request.method !== "HEAD")
-    return request;
-  const value = pick(request.headers.get("x-opencode-directory"), directory);
-  if (!value)
-    return request;
-  const url = new URL(request.url);
-  if (!url.searchParams.has("directory")) {
-    url.searchParams.set("directory", value);
-  }
-  const next = new Request(url, request);
-  next.headers.delete("x-opencode-directory");
-  return next;
-}
-function createOpencodeClient(config2) {
-  if (!config2?.fetch) {
-    const customFetch = (req) => {
-      req.timeout = false;
-      return fetch(req);
-    };
-    config2 = {
-      ...config2,
-      fetch: customFetch
-    };
-  }
-  if (config2?.directory) {
-    config2.headers = {
-      ...config2.headers,
-      "x-opencode-directory": encodeURIComponent(config2.directory)
-    };
-  }
-  const client2 = createClient(config2);
-  client2.interceptors.request.use((request) => rewrite(request, config2?.directory));
-  client2.interceptors.error.use(wrapClientError);
-  return new OpencodeClient({ client: client2 });
-}
-var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
-function getDefaultExportFromCjs(x) {
-  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
-}
-var crossSpawn = { exports: {} };
-var windows;
-var hasRequiredWindows;
-function requireWindows() {
-  if (hasRequiredWindows) return windows;
-  hasRequiredWindows = 1;
-  windows = isexe;
-  isexe.sync = sync;
-  var fs2 = require$$0;
-  function checkPathExt(path2, options) {
-    var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
-    if (!pathext) {
-      return true;
-    }
-    pathext = pathext.split(";");
-    if (pathext.indexOf("") !== -1) {
-      return true;
-    }
-    for (var i2 = 0; i2 < pathext.length; i2++) {
-      var p = pathext[i2].toLowerCase();
-      if (p && path2.substr(-p.length).toLowerCase() === p) {
-        return true;
-      }
-    }
-    return false;
-  }
-  function checkStat(stat2, path2, options) {
-    if (!stat2.isSymbolicLink() && !stat2.isFile()) {
-      return false;
-    }
-    return checkPathExt(path2, options);
-  }
-  function isexe(path2, options, cb) {
-    fs2.stat(path2, function(er, stat2) {
-      cb(er, er ? false : checkStat(stat2, path2, options));
-    });
-  }
-  function sync(path2, options) {
-    return checkStat(fs2.statSync(path2), path2, options);
-  }
-  return windows;
-}
-var mode;
-var hasRequiredMode;
-function requireMode() {
-  if (hasRequiredMode) return mode;
-  hasRequiredMode = 1;
-  mode = isexe;
-  isexe.sync = sync;
-  var fs2 = require$$0;
-  function isexe(path2, options, cb) {
-    fs2.stat(path2, function(er, stat2) {
-      cb(er, er ? false : checkStat(stat2, options));
-    });
-  }
-  function sync(path2, options) {
-    return checkStat(fs2.statSync(path2), options);
-  }
-  function checkStat(stat2, options) {
-    return stat2.isFile() && checkMode(stat2, options);
-  }
-  function checkMode(stat2, options) {
-    var mod = stat2.mode;
-    var uid = stat2.uid;
-    var gid = stat2.gid;
-    var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
-    var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
-    var u2 = parseInt("100", 8);
-    var g = parseInt("010", 8);
-    var o2 = parseInt("001", 8);
-    var ug = u2 | g;
-    var ret = mod & o2 || mod & g && gid === myGid || mod & u2 && uid === myUid || mod & ug && myUid === 0;
-    return ret;
-  }
-  return mode;
-}
-var isexe_1;
-var hasRequiredIsexe;
-function requireIsexe() {
-  if (hasRequiredIsexe) return isexe_1;
-  hasRequiredIsexe = 1;
-  var core;
-  if (process.platform === "win32" || commonjsGlobal.TESTING_WINDOWS) {
-    core = requireWindows();
-  } else {
-    core = requireMode();
-  }
-  isexe_1 = isexe;
-  isexe.sync = sync;
-  function isexe(path2, options, cb) {
-    if (typeof options === "function") {
-      cb = options;
-      options = {};
-    }
-    if (!cb) {
-      if (typeof Promise !== "function") {
-        throw new TypeError("callback not provided");
-      }
-      return new Promise(function(resolve2, reject) {
-        isexe(path2, options || {}, function(er, is) {
-          if (er) {
-            reject(er);
-          } else {
-            resolve2(is);
-          }
-        });
-      });
-    }
-    core(path2, options || {}, function(er, is) {
-      if (er) {
-        if (er.code === "EACCES" || options && options.ignoreErrors) {
-          er = null;
-          is = false;
-        }
-      }
-      cb(er, is);
-    });
-  }
-  function sync(path2, options) {
-    try {
-      return core.sync(path2, options || {});
-    } catch (er) {
-      if (options && options.ignoreErrors || er.code === "EACCES") {
-        return false;
-      } else {
-        throw er;
-      }
-    }
-  }
-  return isexe_1;
-}
-var which_1;
-var hasRequiredWhich;
-function requireWhich() {
-  if (hasRequiredWhich) return which_1;
-  hasRequiredWhich = 1;
-  const isWindows2 = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-  const path2 = require$$0$1;
-  const COLON = isWindows2 ? ";" : ":";
-  const isexe = requireIsexe();
-  const getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
-  const getPathInfo = (cmd, opt) => {
-    const colon = opt.colon || COLON;
-    const pathEnv = cmd.match(/\//) || isWindows2 && cmd.match(/\\/) ? [""] : [
-      // windows always checks the cwd first
-      ...isWindows2 ? [process.cwd()] : [],
-      ...(opt.path || process.env.PATH || /* istanbul ignore next: very unusual */
-      "").split(colon)
-    ];
-    const pathExtExe = isWindows2 ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
-    const pathExt = isWindows2 ? pathExtExe.split(colon) : [""];
-    if (isWindows2) {
-      if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
-        pathExt.unshift("");
-    }
-    return {
-      pathEnv,
-      pathExt,
-      pathExtExe
-    };
-  };
-  const which = (cmd, opt, cb) => {
-    if (typeof opt === "function") {
-      cb = opt;
-      opt = {};
-    }
-    if (!opt)
-      opt = {};
-    const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
-    const found = [];
-    const step = (i2) => new Promise((resolve2, reject) => {
-      if (i2 === pathEnv.length)
-        return opt.all && found.length ? resolve2(found) : reject(getNotFoundError(cmd));
-      const ppRaw = pathEnv[i2];
-      const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-      const pCmd = path2.join(pathPart, cmd);
-      const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-      resolve2(subStep(p, i2, 0));
-    });
-    const subStep = (p, i2, ii) => new Promise((resolve2, reject) => {
-      if (ii === pathExt.length)
-        return resolve2(step(i2 + 1));
-      const ext = pathExt[ii];
-      isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
-        if (!er && is) {
-          if (opt.all)
-            found.push(p + ext);
-          else
-            return resolve2(p + ext);
-        }
-        return resolve2(subStep(p, i2, ii + 1));
-      });
-    });
-    return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
-  };
-  const whichSync = (cmd, opt) => {
-    opt = opt || {};
-    const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
-    const found = [];
-    for (let i2 = 0; i2 < pathEnv.length; i2++) {
-      const ppRaw = pathEnv[i2];
-      const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-      const pCmd = path2.join(pathPart, cmd);
-      const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-      for (let j = 0; j < pathExt.length; j++) {
-        const cur = p + pathExt[j];
-        try {
-          const is = isexe.sync(cur, { pathExt: pathExtExe });
-          if (is) {
-            if (opt.all)
-              found.push(cur);
-            else
-              return cur;
-          }
-        } catch (ex) {
-        }
-      }
-    }
-    if (opt.all && found.length)
-      return found;
-    if (opt.nothrow)
-      return null;
-    throw getNotFoundError(cmd);
-  };
-  which_1 = which;
-  which.sync = whichSync;
-  return which_1;
-}
-var pathKey$1 = { exports: {} };
-var hasRequiredPathKey;
-function requirePathKey() {
-  if (hasRequiredPathKey) return pathKey$1.exports;
-  hasRequiredPathKey = 1;
-  const pathKey2 = (options = {}) => {
-    const environment = options.env || process.env;
-    const platform2 = options.platform || process.platform;
-    if (platform2 !== "win32") {
-      return "PATH";
-    }
-    return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
-  };
-  pathKey$1.exports = pathKey2;
-  pathKey$1.exports.default = pathKey2;
-  return pathKey$1.exports;
-}
-var resolveCommand_1;
-var hasRequiredResolveCommand;
-function requireResolveCommand() {
-  if (hasRequiredResolveCommand) return resolveCommand_1;
-  hasRequiredResolveCommand = 1;
-  const path2 = require$$0$1;
-  const which = requireWhich();
-  const getPathKey = requirePathKey();
-  function resolveCommandAttempt(parsed, withoutPathExt) {
-    const env = parsed.options.env || process.env;
-    const cwd = process.cwd();
-    const hasCustomCwd = parsed.options.cwd != null;
-    const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
-    if (shouldSwitchCwd) {
-      try {
-        process.chdir(parsed.options.cwd);
-      } catch (err) {
-      }
-    }
-    let resolved;
-    try {
-      resolved = which.sync(parsed.command, {
-        path: env[getPathKey({ env })],
-        pathExt: withoutPathExt ? path2.delimiter : void 0
-      });
-    } catch (e) {
-    } finally {
-      if (shouldSwitchCwd) {
-        process.chdir(cwd);
-      }
-    }
-    if (resolved) {
-      resolved = path2.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
-    }
-    return resolved;
-  }
-  function resolveCommand(parsed) {
-    return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
-  }
-  resolveCommand_1 = resolveCommand;
-  return resolveCommand_1;
-}
-var _escape = {};
-var hasRequired_escape;
-function require_escape() {
-  if (hasRequired_escape) return _escape;
-  hasRequired_escape = 1;
-  const metaCharsRegExp2 = /([()\][%!^"`<>&|;, *?])/g;
-  function escapeCommand(arg) {
-    arg = arg.replace(metaCharsRegExp2, "^$1");
-    return arg;
-  }
-  function escapeArgument2(arg, doubleEscapeMetaChars) {
-    arg = `${arg}`;
-    arg = arg.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
-    arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
-    arg = `"${arg}"`;
-    arg = arg.replace(metaCharsRegExp2, "^$1");
-    if (doubleEscapeMetaChars) {
-      arg = arg.replace(metaCharsRegExp2, "^$1");
-    }
-    return arg;
-  }
-  _escape.command = escapeCommand;
-  _escape.argument = escapeArgument2;
-  return _escape;
-}
-var shebangRegex;
-var hasRequiredShebangRegex;
-function requireShebangRegex() {
-  if (hasRequiredShebangRegex) return shebangRegex;
-  hasRequiredShebangRegex = 1;
-  shebangRegex = /^#!(.*)/;
-  return shebangRegex;
-}
-var shebangCommand;
-var hasRequiredShebangCommand;
-function requireShebangCommand() {
-  if (hasRequiredShebangCommand) return shebangCommand;
-  hasRequiredShebangCommand = 1;
-  const shebangRegex2 = requireShebangRegex();
-  shebangCommand = (string2 = "") => {
-    const match = string2.match(shebangRegex2);
-    if (!match) {
-      return null;
-    }
-    const [path2, argument] = match[0].replace(/#! ?/, "").split(" ");
-    const binary = path2.split("/").pop();
-    if (binary === "env") {
-      return argument;
-    }
-    return argument ? `${binary} ${argument}` : binary;
-  };
-  return shebangCommand;
-}
-var readShebang_1;
-var hasRequiredReadShebang;
-function requireReadShebang() {
-  if (hasRequiredReadShebang) return readShebang_1;
-  hasRequiredReadShebang = 1;
-  const fs2 = require$$0;
-  const shebangCommand2 = requireShebangCommand();
-  function readShebang2(command2) {
-    const size = 150;
-    const buffer = Buffer.alloc(size);
-    let fd;
-    try {
-      fd = fs2.openSync(command2, "r");
-      fs2.readSync(fd, buffer, 0, size, 0);
-      fs2.closeSync(fd);
-    } catch (e) {
-    }
-    return shebangCommand2(buffer.toString());
-  }
-  readShebang_1 = readShebang2;
-  return readShebang_1;
-}
-var parse_1;
-var hasRequiredParse;
-function requireParse() {
-  if (hasRequiredParse) return parse_1;
-  hasRequiredParse = 1;
-  const path2 = require$$0$1;
-  const resolveCommand = requireResolveCommand();
-  const escape = require_escape();
-  const readShebang2 = requireReadShebang();
-  const isWin = process.platform === "win32";
-  const isExecutableRegExp = /\.(?:com|exe)$/i;
-  const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
-  function detectShebang(parsed) {
-    parsed.file = resolveCommand(parsed);
-    const shebang = parsed.file && readShebang2(parsed.file);
-    if (shebang) {
-      parsed.args.unshift(parsed.file);
-      parsed.command = shebang;
-      return resolveCommand(parsed);
-    }
-    return parsed.file;
-  }
-  function parseNonShell(parsed) {
-    if (!isWin) {
-      return parsed;
-    }
-    const commandFile = detectShebang(parsed);
-    const needsShell = !isExecutableRegExp.test(commandFile);
-    if (parsed.options.forceShell || needsShell) {
-      const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-      parsed.command = path2.normalize(parsed.command);
-      parsed.command = escape.command(parsed.command);
-      parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
-      const shellCommand = [parsed.command].concat(parsed.args).join(" ");
-      parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
-      parsed.command = process.env.comspec || "cmd.exe";
-      parsed.options.windowsVerbatimArguments = true;
-    }
-    return parsed;
-  }
-  function parse2(command2, args, options) {
-    if (args && !Array.isArray(args)) {
-      options = args;
-      args = null;
-    }
-    args = args ? args.slice(0) : [];
-    options = Object.assign({}, options);
-    const parsed = {
-      command: command2,
-      args,
-      options,
-      file: void 0,
-      original: {
-        command: command2,
-        args
-      }
-    };
-    return options.shell ? parsed : parseNonShell(parsed);
-  }
-  parse_1 = parse2;
-  return parse_1;
-}
-var enoent;
-var hasRequiredEnoent;
-function requireEnoent() {
-  if (hasRequiredEnoent) return enoent;
-  hasRequiredEnoent = 1;
-  const isWin = process.platform === "win32";
-  function notFoundError(original, syscall) {
-    return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
-      code: "ENOENT",
-      errno: "ENOENT",
-      syscall: `${syscall} ${original.command}`,
-      path: original.command,
-      spawnargs: original.args
-    });
-  }
-  function hookChildProcess(cp2, parsed) {
-    if (!isWin) {
-      return;
-    }
-    const originalEmit = cp2.emit;
-    cp2.emit = function(name, arg1) {
-      if (name === "exit") {
-        const err = verifyENOENT(arg1, parsed);
-        if (err) {
-          return originalEmit.call(cp2, "error", err);
-        }
-      }
-      return originalEmit.apply(cp2, arguments);
-    };
-  }
-  function verifyENOENT(status, parsed) {
-    if (isWin && status === 1 && !parsed.file) {
-      return notFoundError(parsed.original, "spawn");
-    }
-    return null;
-  }
-  function verifyENOENTSync(status, parsed) {
-    if (isWin && status === 1 && !parsed.file) {
-      return notFoundError(parsed.original, "spawnSync");
-    }
-    return null;
-  }
-  enoent = {
-    hookChildProcess,
-    verifyENOENT,
-    verifyENOENTSync,
-    notFoundError
-  };
-  return enoent;
-}
-var hasRequiredCrossSpawn;
-function requireCrossSpawn() {
-  if (hasRequiredCrossSpawn) return crossSpawn.exports;
-  hasRequiredCrossSpawn = 1;
-  const cp2 = require$$0$2;
-  const parse2 = requireParse();
-  const enoent2 = requireEnoent();
-  function spawn2(command2, args, options) {
-    const parsed = parse2(command2, args, options);
-    const spawned = cp2.spawn(parsed.command, parsed.args, parsed.options);
-    enoent2.hookChildProcess(spawned, parsed);
-    return spawned;
-  }
-  function spawnSync2(command2, args, options) {
-    const parsed = parse2(command2, args, options);
-    const result = cp2.spawnSync(parsed.command, parsed.args, parsed.options);
-    result.error = result.error || enoent2.verifyENOENTSync(result.status, parsed);
-    return result;
-  }
-  crossSpawn.exports = spawn2;
-  crossSpawn.exports.spawn = spawn2;
-  crossSpawn.exports.sync = spawnSync2;
-  crossSpawn.exports._parse = parse2;
-  crossSpawn.exports._enoent = enoent2;
-  return crossSpawn.exports;
-}
-var crossSpawnExports = requireCrossSpawn();
-const launch = /* @__PURE__ */ getDefaultExportFromCjs(crossSpawnExports);
-function stop(proc) {
-  if (proc.exitCode !== null || proc.signalCode !== null)
-    return;
-  if (process.platform === "win32" && proc.pid) {
-    const out = spawnSync("taskkill", ["/pid", String(proc.pid), "/T", "/F"], { windowsHide: true });
-    if (!out.error && out.status === 0)
-      return;
-  }
-  proc.kill();
-}
-function bindAbort$1(proc, signal, onAbort) {
-  if (!signal)
-    return () => {
-    };
-  const abort = () => {
-    clear();
-    stop(proc);
-    onAbort?.();
-  };
-  const clear = () => {
-    signal.removeEventListener("abort", abort);
-    proc.off("exit", clear);
-    proc.off("error", clear);
-  };
-  signal.addEventListener("abort", abort, { once: true });
-  proc.on("exit", clear);
-  proc.on("error", clear);
-  if (signal.aborted)
-    abort();
-  return clear;
-}
-async function createOpencodeServer(options) {
-  options = Object.assign({
-    hostname: "127.0.0.1",
-    port: 4096,
-    timeout: 5e3
-  }, options ?? {});
-  const args = [`serve`, `--hostname=${options.hostname}`, `--port=${options.port}`];
-  if (options.config?.logLevel)
-    args.push(`--log-level=${options.config.logLevel}`);
-  const proc = launch(`opencode`, args, {
-    env: {
-      ...process.env,
-      OPENCODE_CONFIG_CONTENT: JSON.stringify(options.config ?? {})
-    }
-  });
-  let clear = () => {
-  };
-  const url = await new Promise((resolve2, reject) => {
-    const id = setTimeout(() => {
-      clear();
-      stop(proc);
-      reject(new Error(`Timeout waiting for server to start after ${options.timeout}ms`));
-    }, options.timeout);
-    let output = "";
-    let resolved = false;
-    proc.stdout?.on("data", (chunk) => {
-      if (resolved)
-        return;
-      output += chunk.toString();
-      const lines = output.split("\n");
-      for (const line of lines) {
-        if (line.startsWith("opencode server listening")) {
-          const match = line.match(/on\s+(https?:\/\/[^\s]+)/);
-          if (!match) {
-            clear();
-            stop(proc);
-            clearTimeout(id);
-            reject(new Error(`Failed to parse server url from output: ${line}`));
-            return;
-          }
-          clearTimeout(id);
-          resolved = true;
-          resolve2(match[1]);
-          return;
-        }
-      }
-    });
-    proc.stderr?.on("data", (chunk) => {
-      output += chunk.toString();
-    });
-    proc.on("exit", (code) => {
-      clearTimeout(id);
-      let msg = `Server exited with code ${code}`;
-      if (output.trim()) {
-        msg += `
-Server output: ${output}`;
-      }
-      reject(new Error(msg));
-    });
-    proc.on("error", (error) => {
-      clearTimeout(id);
-      reject(error);
-    });
-    clear = bindAbort$1(proc, options.signal, () => {
-      clearTimeout(id);
-      reject(options.signal?.reason);
-    });
-  });
-  return {
-    url,
-    close() {
-      clear();
-      stop(proc);
-    }
-  };
-}
-function openCodeCliName(executable) {
-  return path.parse(executable).name.toLowerCase() === "opencode2" ? "opencode2" : "opencode";
-}
-function isOpenCodeV2(executable) {
-  return openCodeCliName(executable) === "opencode2";
-}
-function openCodeLoginCommand(cliName) {
-  return cliName === "opencode2" ? "opencode2 auth login" : "opencode auth login";
-}
-function parseOpenCodeAuthList(raw, exitCode) {
-  if (exitCode !== 0) return "unknown";
-  const text2 = stripAnsi(raw);
-  if (/no authenticated/i.test(text2)) return "unauthenticated";
-  if (/credential/i.test(text2)) return "authenticated";
-  const lines = text2.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-  if (lines.some((line) => /^[A-Za-z0-9._-]+$/.test(line) && !/^(providers?|credentials?|integrations?)$/i.test(line))) {
-    return "authenticated";
+function requireGrokSuccess(result) {
+  if (result.exitCode === 0) return;
+  const diagnostic = `${result.stdout}
+${result.stderr}`.toLowerCase();
+  if (/not authenticated|not logged|login required|unauth|authentication|sign in/.test(diagnostic)) throw failure("AI_AUTH_REQUIRED", "Sign in with grok login to generate content.");
+  if (/rate.?limit|quota|usage limit|too many requests|credit/.test(diagnostic)) throw failure("AI_RATE_LIMITED", "Grok rejected the request because of a usage limit.");
+  if (/model.*(not found|unavailable|invalid|access|not supported)|unknown model/.test(diagnostic)) throw failure("AI_MODEL_UNAVAILABLE", "The selected Grok model is unavailable.");
+  throw failure("AI_PROCESS_FAILED", "Grok could not generate content.");
+}
+function failure(code, message) {
+  return new AiOperationError({ code, operation: "grok-generate", harness: "grok", message });
+}
+function openCodeCliName(executable) {
+  return path.parse(executable).name.toLowerCase() === "opencode2" ? "opencode2" : "opencode";
+}
+function isOpenCodeV2Version(raw) {
+  return /^(?:opencode2?\s+)?v?2\.\d+\.\d+(?:[-+][\w.-]+)?$/.test(stripAnsi(raw).trim());
+}
+function openCodeLoginCommand(cliName) {
+  return cliName === "opencode2" ? "opencode2 auth login" : "opencode auth login";
+}
+function parseOpenCodeAuthList(raw, exitCode) {
+  if (exitCode !== 0) return "unknown";
+  try {
+    const integrations = JSON.parse(stripAnsi(raw).trim());
+    if (!Array.isArray(integrations) || integrations.some((item) => !item || typeof item !== "object" || !Array.isArray(item.connections))) return "unknown";
+    return integrations.some((item) => item.connections.length > 0) ? "authenticated" : "unauthenticated";
+  } catch {
   }
   return "unknown";
 }
 function parseOpenCodeModels(raw) {
   const seen = /* @__PURE__ */ new Set();
-  const models = stripAnsi(raw).split(/\r?\n/).map((line) => line.trim()).filter((line) => /^[A-Za-z0-9._-]+\/[A-Za-z0-9._:/-]+$/.test(line) && !seen.has(line) && seen.add(line)).map((id) => ({ id, label: id }));
-  return [DEFAULT_MODEL, ...models];
-}
-function parseOpenCodeV1Model(value) {
-  const slash = value.indexOf("/");
-  if (slash <= 0 || slash === value.length - 1) throw invalidModel();
-  return { providerID: value.slice(0, slash), modelID: value.slice(slash + 1) };
+  const models = stripAnsi(raw).split(/\r?\n/).map((line) => line.trim()).filter((line) => /^[A-Za-z0-9._-]+\/[A-Za-z0-9._:/-]+(?:#[A-Za-z0-9._-]+)?$/.test(line) && !seen.has(line) && seen.add(line)).map((id) => ({ id, label: id }));
+  return [DEFAULT_MODEL$1, ...models];
 }
 function parseOpenCodeV2ModelRef(value) {
-  const parsed = parseOpenCodeV1Model(value);
-  const hash = parsed.modelID.lastIndexOf("#");
-  if (hash > 0 && hash < parsed.modelID.length - 1) {
-    return { providerID: parsed.providerID, id: parsed.modelID.slice(0, hash), variant: parsed.modelID.slice(hash + 1) };
-  }
-  return { providerID: parsed.providerID, id: parsed.modelID };
+  const match = /^([^/#\s]+)\/([^#\s]+)(?:#([^#\s]+))?$/.exec(value);
+  if (!match?.[1] || !match[2]) throw invalidModel();
+  return { providerID: match[1], id: match[2], ...match[3] ? { variant: match[3] } : {} };
 }
 function parseOpenCodeV2GenerateText(payload) {
   if (!payload || typeof payload !== "object") throw invalidOutput$1();
@@ -15046,13 +13335,14 @@ async function startOpenCodeV2Server(options) {
   const timeoutMs = options.timeoutMs;
   const password = randomBytes(24).toString("base64url");
   const port = await freePort();
-  const environment = Object.fromEntries(
+  const environment = cleanEnvironment(Object.fromEntries(
     Object.entries({
       ...process.env,
+      ...options.env,
       OPENCODE_SERVER_USERNAME: SERVER_USERNAME,
       OPENCODE_SERVER_PASSWORD: password
     }).filter((entry) => entry[1] !== void 0)
-  );
+  ));
   const resolved = resolveProcessCommand(options.executable, options.cwd ?? process.cwd(), environment);
   if (!resolved.found) {
     throw new AiOperationError({ code: "AI_PROCESS_FAILED", operation: "opencode-server", harness: "opencode", message: "Could not start the local OpenCode server.", retryable: true });
@@ -15070,12 +13360,12 @@ async function startOpenCodeV2Server(options) {
   });
   void subprocess.catch(() => void 0);
   let settled = false;
-  const stop2 = () => {
+  const stop = () => {
     if (settled) return;
     settled = true;
     stopProcess(subprocess);
   };
-  const unbind = bindAbort(options.signal, stop2);
+  const unbind = bindAbort(options.signal, stop);
   try {
     const url = await waitForListenUrl(subprocess, timeoutMs, options.signal);
     return {
@@ -15083,12 +13373,12 @@ async function startOpenCodeV2Server(options) {
       password,
       close() {
         unbind();
-        stop2();
+        stop();
       }
     };
   } catch (error) {
     unbind();
-    stop2();
+    stop();
     if (options.signal?.aborted) {
       throw new AiOperationError({ code: "AI_CANCELLED", operation: "opencode-server", harness: "opencode", message: "Generation canceled." });
     }
@@ -15101,8 +13391,9 @@ async function generateOpenCodeV2Text(server, input) {
   const created = await v2Request(server, "/api/session", {
     method: "POST",
     body: {
-      title: "OpenTig commit message",
+      title: "OpenTig text generation",
       location: { directory: input.cwd },
+      permissions: [{ action: "*", resource: "*", effect: "deny" }],
       ...model ? { model } : {}
     },
     signal
@@ -15155,7 +13446,7 @@ function throwIfV2Failed(status, payload, signal) {
   if (status === 401 || /not logged|login required|unauth|authentication|sign in/.test(raw)) {
     throw new AiOperationError({ code: "AI_AUTH_REQUIRED", operation: "opencode-generate", harness: "opencode", message: "Sign in to OpenCode to generate the message." });
   }
-  if (/rate.?limit|quota|usage limit|too many requests|credit/.test(raw)) {
+  if (status === 429 || /rate.?limit|quota|usage limit|too many requests|credit/.test(raw)) {
     throw new AiOperationError({ code: "AI_RATE_LIMITED", operation: "opencode-generate", harness: "opencode", message: "OpenCode rejected the request because of a usage limit.", retryable: true });
   }
   if (/model.*(not found|unavailable|invalid|access)|unknown model|no model specified/.test(raw)) {
@@ -15238,7 +13529,7 @@ function freePort() {
     server.on("error", reject);
   });
 }
-const DISABLED_TOOLS = { bash: false, edit: false, write: false, read: false, glob: false, grep: false, webfetch: false, websearch: false, task: false };
+const UNSUPPORTED_MESSAGE = "OpenCode 2.x is required. Upgrade the installed CLI; OpenCode 1 and legacy beta builds are not supported.";
 class OpenCodeProvider {
   constructor(resolver, runner) {
     this.resolver = resolver;
@@ -15250,40 +13541,41 @@ class OpenCodeProvider {
   servers = /* @__PURE__ */ new Set();
   async status(forceRefresh = false) {
     const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const executable = await this.resolver.resolve("opencode", forceRefresh);
-    if (!executable) return { id: this.id, label: "OpenCode", availability: "error", installed: false, authStatus: "unknown", message: "Install OpenCode to use this harness.", models: [DEFAULT_MODEL], checkedAt };
-    const cliName = openCodeCliName(executable);
-    const catalogArgs = cliName === "opencode2" ? ["models", "--standalone"] : ["models"];
-    const [version2, auth, catalog] = await Promise.all([
-      this.runner.run(executable, ["--version"]),
-      this.runner.run(executable, ["auth", "list"]),
-      this.runner.run(executable, catalogArgs, cliName === "opencode2" ? { timeoutMs: 3e4 } : {})
+    const detected = await this.detect(forceRefresh);
+    const failure2 = detectionFailure(detected, { id: this.id, label: "OpenCode", models: [DEFAULT_MODEL$1], checkedAt }, UNSUPPORTED_MESSAGE);
+    if (failure2) return failure2;
+    const executable = requireCandidate(detected, this.id);
+    const version2 = detected.version ?? "";
+    const cliName = openCodeCliName(executable.executable);
+    const [auth, catalog] = await Promise.all([
+      runCandidate(this.runner, executable, ["auth", "list", "--format", "json", "--standalone"]),
+      runCandidate(this.runner, executable, ["models", "--standalone"], { timeoutMs: 3e4 })
     ]);
-    const models = catalog.exitCode === 0 ? parseOpenCodeModels(catalog.stdout) : [DEFAULT_MODEL];
-    let authStatus = parseOpenCodeAuthList(`${auth.stdout}
-${auth.stderr}`, auth.exitCode);
+    const models = catalog.exitCode === 0 ? parseOpenCodeModels(catalog.stdout) : [DEFAULT_MODEL$1];
+    let authStatus = parseOpenCodeAuthList(auth.stdout, auth.exitCode);
     if (authStatus === "unauthenticated" && models.length > 1) authStatus = "unknown";
     const confirmed = authStatus === "authenticated";
     return {
       id: this.id,
       label: "OpenCode",
       availability: models.length > 1 ? confirmed ? "ready" : "warning" : authStatus === "unauthenticated" ? "error" : "warning",
+      ...detectionFields(detected),
       installed: true,
       authStatus,
       cliName,
-      version: version2.stdout.trim() || version2.stderr.trim(),
+      version: version2,
       models,
       checkedAt,
       ...authStatus === "unauthenticated" ? { message: `Run ${openCodeLoginCommand(cliName)}.` } : !confirmed ? { message: "Could not confirm authentication for the selected provider." } : {}
     };
   }
   async generate(input) {
-    const executable = await this.resolver.resolve("opencode");
-    if (!executable) throw new AiOperationError({ code: "AI_CLI_NOT_FOUND", operation: "opencode-generate", harness: this.id, message: "OpenCode is not installed." });
+    const detected = await this.detect(false, input.signal);
+    const executable = requireCandidate(detected, this.id);
     const timeoutSignal = AbortSignal.timeout(AI_PROVIDER_TIMEOUT_MS);
     const boundedInput = { ...input, signal: AbortSignal.any([input.signal, timeoutSignal]) };
     try {
-      return await (isOpenCodeV2(executable) ? this.generateV2(executable, boundedInput) : this.generateV1(boundedInput));
+      return await this.generateV2(executable, boundedInput);
     } catch (error) {
       if (timeoutSignal.aborted && !input.signal.aborted) {
         throw new AiOperationError({ code: "AI_TIMEOUT", operation: "opencode-generate", harness: this.id, message: "Generation took too long.", retryable: true });
@@ -15292,13 +13584,16 @@ ${auth.stderr}`, auth.exitCode);
     }
   }
   async generateV2(executable, input) {
-    const server = await startOpenCodeV2Server({ executable, cwd: input.repositoryPath, timeoutMs: 15e3, signal: input.signal }).catch((error) => {
+    const server = await startOpenCodeV2Server({ executable: executable.executable, env: executable.env, cwd: input.repositoryPath, timeoutMs: 15e3, signal: input.signal }).catch((error) => {
       if (error instanceof AiOperationError) throw error;
       throw new AiOperationError({ code: "AI_PROCESS_FAILED", operation: "opencode-server", harness: this.id, message: "Could not start the local OpenCode server.", retryable: true });
     });
     this.servers.add(server);
     try {
-      const text2 = await generateOpenCodeV2Text(server, { prompt: input.prompt, model: input.model, cwd: input.repositoryPath, signal: input.signal });
+      const text2 = await generateOpenCodeV2Text(server, { prompt: `Reply with a single JSON object satisfying this JSON Schema:
+${JSON.stringify(input.schema)}
+
+${input.prompt}`, model: input.model, cwd: input.repositoryPath, signal: input.signal });
       return { output: parseJsonPayload(text2), usage: { ...EMPTY_AI_USAGE } };
     } catch (error) {
       if (input.signal.aborted) throw new AiOperationError({ code: "AI_CANCELLED", operation: "opencode-generate", harness: this.id, message: "Generation canceled." });
@@ -15311,53 +13606,8 @@ ${auth.stderr}`, auth.exitCode);
       this.servers.delete(server);
     }
   }
-  async generateV1(input) {
-    const server = await createOpencodeServer({
-      hostname: "127.0.0.1",
-      port: 0,
-      timeout: 15e3,
-      signal: input.signal,
-      config: { share: "disabled", autoupdate: false, plugin: [], instructions: [], tools: DISABLED_TOOLS, permission: { edit: "deny", bash: "deny", webfetch: "deny", external_directory: "deny" } }
-    }).catch(() => {
-      throw new AiOperationError({ code: "AI_PROCESS_FAILED", operation: "opencode-server", harness: this.id, message: "Could not start the local OpenCode server.", retryable: true });
-    });
-    this.servers.add(server);
-    const client2 = createOpencodeClient({ baseUrl: server.url, directory: input.repositoryPath });
-    let sessionId = null;
-    try {
-      const created = await client2.session.create({ body: { title: "OpenTig commit message" }, query: { directory: input.repositoryPath } });
-      if (!created.data?.id) throw new Error("missing session");
-      sessionId = created.data.id;
-      const model = input.model === "default" ? void 0 : parseOpenCodeV1Model(input.model);
-      const response = await client2.session.prompt({
-        path: { id: sessionId },
-        query: { directory: input.repositoryPath },
-        body: {
-          parts: [{ type: "text", text: input.prompt }],
-          tools: DISABLED_TOOLS,
-          // The server API takes no schema, unlike the Codex and Claude CLIs, so
-          // the only way to hold this harness to the contract is the system
-          // prompt. Without it the model answers in whatever shape it likes.
-          system: `Reply with a single JSON object and nothing else. It must satisfy this JSON Schema:
-${JSON.stringify(input.schema)}`,
-          ...model ? { model } : {}
-        }
-      });
-      const infoError = response.data?.info && "error" in response.data.info ? response.data.info.error : void 0;
-      if (infoError) throw new Error("provider rejected request");
-      const text2 = (response.data?.parts ?? []).filter((part) => part.type === "text" && "text" in part && typeof part.text === "string").map((part) => part.text).join("").trim();
-      return { output: parseJsonPayload(text2), usage: openCodeUsage(response.data?.info) };
-    } catch (error) {
-      if (input.signal?.aborted) throw new AiOperationError({ code: "AI_CANCELLED", operation: "opencode-generate", harness: this.id, message: "Generation canceled." });
-      if (error instanceof AiOperationError) throw error;
-      const synthetic = { exitCode: 1, stdout: "", stderr: error instanceof Error ? error.message : "" };
-      requireSuccess(synthetic, this.id, "opencode-generate");
-      throw error;
-    } finally {
-      if (sessionId) await client2.session.delete({ path: { id: sessionId }, query: { directory: input.repositoryPath } }).catch(() => void 0);
-      server.close();
-      this.servers.delete(server);
-    }
+  async detect(forceRefresh = false, signal) {
+    return selectCli(this.resolver, this.runner, this.id, { forceRefresh, compatible: isOpenCodeV2Version, runOptions: signal ? { signal } : {} });
   }
   close() {
     for (const server of this.servers) server.close();
@@ -15646,7 +13896,7 @@ class FileService {
   // UI pulls its children through here instead of paying for them at startup.
   async listDirectory(repositoryId, relativePath) {
     const repository = this.repositories.get(repositoryId);
-    const directory = this.repositories.resolvePath(repositoryId, relativePath);
+    const directory = relativePath === "" ? repository.path : this.repositories.resolvePath(repositoryId, relativePath);
     const parent = normalizeGitPath(relativePath).replace(/\/+$/, "");
     let dirents;
     try {
@@ -15656,13 +13906,12 @@ class FileService {
       if (code === "ENOENT" || code === "ENOTDIR") return [];
       throw error;
     }
-    const ignored = (await this.findIgnoredDirectories(repository.path, [parent])).has(parent);
     const entries = [];
     for (const dirent of dirents) {
       if (dirent.name === ".git") continue;
       const entryPath = parent ? `${parent}/${dirent.name}` : dirent.name;
       if (dirent.isDirectory() && !dirent.isSymbolicLink()) {
-        entries.push({ path: entryPath, name: dirent.name, type: "directory", ...ignored ? { ignored: true } : {}, children: [] });
+        entries.push({ path: entryPath, name: dirent.name, type: "directory", children: [] });
         continue;
       }
       if (!dirent.isFile() && !dirent.isSymbolicLink()) continue;
@@ -15673,15 +13922,25 @@ class FileService {
           name: dirent.name,
           type: "file",
           size: metadata.size,
-          mtimeMs: metadata.mtimeMs,
-          ...ignored ? { ignored: true } : {}
+          mtimeMs: metadata.mtimeMs
         });
       } catch (error) {
         const code = error.code;
         if (code !== "ENOENT" && code !== "ENOTDIR") throw error;
       }
     }
-    return entries.sort((a2, b) => a2.type === b.type ? a2.name.localeCompare(b.name) : a2.type === "directory" ? -1 : 1);
+    const ignoredChildren = await this.findIgnoredDirectories(repository.path, entries.map((entry) => entry.path));
+    const ignoredFolders = entries.filter((entry) => entry.type === "directory" && ignoredChildren.has(entry.path));
+    if (ignoredFolders.length > 0) {
+      const tracked = await this.git.run(repository.path, ["ls-files", "-z", "--", ...ignoredFolders.map((entry) => entry.path)], {
+        operation: "list-tracked-folder-children",
+        readOnly: true,
+        maxOutputBytes: 64 * 1024 * 1024
+      });
+      const ancestors = directoryAncestors(tracked.stdout.toString("utf8").split("\0").filter(Boolean).map(normalizeGitPath));
+      for (const folder of ignoredFolders) if (ancestors.has(folder.path)) ignoredChildren.delete(folder.path);
+    }
+    return entries.map((entry) => ignoredChildren.has(entry.path) ? { ...entry, ignored: true } : entry).sort((a2, b) => a2.type === b.type ? a2.name.localeCompare(b.name) : a2.type === "directory" ? -1 : 1);
   }
   async findIgnoredDirectories(repositoryPath, directories) {
     const ignored = /* @__PURE__ */ new Set();
@@ -18709,6 +16968,12 @@ class GitHubService {
     const operation = "gh-pr-for-branch";
     const { repository, nameWithOwner } = await this.requireGitHub(repositoryId, operation);
     const branch = validateRef(branchName, operation);
+    const openResult = await this.runGh(
+      ["pr", "list", "-R", nameWithOwner, "--head", branch, "--state", "open", "--json", PR_SUMMARY_FIELDS, "--limit", "10"],
+      { cwd: repository.path, operation, timeoutMs: NETWORK_TIMEOUT_MS, maxOutputBytes: 1024 * 1024 }
+    );
+    const openPull = sortPullRequestsNewestFirst(parsePullRequestList(openResult.stdout)).find((pull) => pull.state === "OPEN");
+    if (openPull) return openPull;
     const result = await this.runGh(
       ["pr", "list", "-R", nameWithOwner, "--head", branch, "--state", "all", "--json", PR_SUMMARY_FIELDS, "--limit", "10"],
       { cwd: repository.path, operation, timeoutMs: NETWORK_TIMEOUT_MS, maxOutputBytes: 1024 * 1024 }
@@ -18821,12 +17086,13 @@ class GitHubService {
   }
   async checkStatus(forceRefresh) {
     const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const executable = await this.resolver.resolve("gh", forceRefresh);
+    const detected = await selectCli(this.resolver, this.runner, "gh", { forceRefresh, runOptions: { cwd: os.tmpdir(), env: { ...GH_ENV } } });
+    const executable = detected.candidate;
     if (!executable) {
       return { installed: false, availability: "error", authStatus: "unknown", message: "Install GitHub CLI (cli.github.com) to work with pull requests.", checkedAt };
     }
-    const version2 = await this.run(executable, ["--version"], { cwd: os.tmpdir(), operation: "gh-version" });
-    const versionLabel = (version2.stdout.split(/\r?\n/, 1)[0] ?? "").trim() || version2.stderr.trim();
+    if (detected.state !== "available") return { installed: true, availability: "error", authStatus: "unknown", message: "GitHub CLI was found but could not run. Check its installation and dependencies.", checkedAt };
+    const versionLabel = detected.version ?? "";
     const auth = await this.run(executable, ["auth", "status", "--hostname", "github.com", "--active"], { cwd: os.tmpdir(), operation: "gh-auth-status" });
     if (auth.exitCode !== 0) {
       return { installed: true, availability: "error", authStatus: "unauthenticated", version: versionLabel, message: "Run gh auth login.", checkedAt };
@@ -18845,7 +17111,8 @@ class GitHubService {
     return { repository, nameWithOwner: info.nameWithOwner };
   }
   async runGh(args, options) {
-    const executable = await this.resolver.resolve("gh");
+    const detected = await selectCli(this.resolver, this.runner, "gh", { runOptions: { cwd: options.cwd, env: { ...GH_ENV } } });
+    const executable = detected.state === "available" ? detected.candidate : void 0;
     if (!executable) throw new GhOperationError({ code: "GH_CLI_NOT_FOUND", operation: options.operation, message: "GitHub CLI is not installed." });
     const result = await this.run(executable, args, options);
     if (result.exitCode !== 0) throw classifyFailure(result, options.operation);
@@ -18853,9 +17120,9 @@ class GitHubService {
   }
   async run(executable, args, options) {
     try {
-      return await this.runner.run(executable, args, {
+      return await this.runner.run(executable.executable, args, {
         cwd: options.cwd,
-        env: { ...GH_ENV },
+        env: { ...executable.env, ...GH_ENV },
         ...options.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {},
         ...options.maxOutputBytes !== void 0 ? { maxOutputBytes: options.maxOutputBytes } : {},
         ...options.stdin !== void 0 ? { stdin: options.stdin } : {}
@@ -19319,7 +17586,8 @@ const defaults = {
     uiFont: "plus-jakarta-sans",
     monoFont: "jetbrains-mono",
     commitMessageHarness: "codex",
-    commitMessageModels: { codex: "default", claude: "default", opencode: "default" },
+    commitMessageModels: { codex: "default", claude: "default", opencode: "default", grok: "default" },
+    aiExecutablePaths: {},
     shortcutOverrides: {},
     doubleControlShortcutEnabled: true,
     remoteFetchIntervalSeconds: DEFAULT_REMOTE_FETCH_INTERVAL_SECONDS
@@ -19399,7 +17667,7 @@ class SettingsStore {
     return this.data.activeRepositoryId;
   }
   get preferences() {
-    return { ...this.data.preferences, commitMessageModels: { ...this.data.preferences.commitMessageModels }, shortcutOverrides: { ...this.data.preferences.shortcutOverrides } };
+    return { ...this.data.preferences, aiExecutablePaths: { ...this.data.preferences.aiExecutablePaths }, commitMessageModels: { ...this.data.preferences.commitMessageModels }, shortcutOverrides: { ...this.data.preferences.shortcutOverrides } };
   }
   get windowBounds() {
     return { ...this.data.windowBounds };
@@ -19528,6 +17796,8 @@ class SettingsStore {
     next.monoFont = isMonoFont(next.monoFont) ? next.monoFont : "jetbrains-mono";
     next.commitMessageHarness = isHarness(next.commitMessageHarness) ? next.commitMessageHarness : "codex";
     next.commitMessageModels = modelPreferences(next.commitMessageModels);
+    next.aiExecutablePaths = executablePaths(next.aiExecutablePaths, true);
+    delete next.aiShellEnvironment;
     next.shortcutOverrides = sanitizeShortcutOverrides(next.shortcutOverrides);
     next.doubleControlShortcutEnabled = typeof next.doubleControlShortcutEnabled === "boolean" ? next.doubleControlShortcutEnabled : this.defaultDoubleControlShortcutEnabled;
     next.remoteFetchIntervalSeconds = normalizeRemoteFetchIntervalSeconds(next.remoteFetchIntervalSeconds);
@@ -19656,6 +17926,7 @@ function validate(value, defaultDoubleControlShortcutEnabled) {
     monoFont: isMonoFont(parsedPreferences.data.monoFont) ? parsedPreferences.data.monoFont : "jetbrains-mono",
     commitMessageHarness: isHarness(parsedPreferences.data.commitMessageHarness) ? parsedPreferences.data.commitMessageHarness : "codex",
     commitMessageModels: modelPreferences(parsedPreferences.data.commitMessageModels),
+    aiExecutablePaths: executablePaths(parsedPreferences.data.aiExecutablePaths),
     shortcutOverrides: sanitizeShortcutOverrides(parsedPreferences.data.shortcutOverrides),
     doubleControlShortcutEnabled: typeof parsedPreferences.data.doubleControlShortcutEnabled === "boolean" ? parsedPreferences.data.doubleControlShortcutEnabled : defaultDoubleControlShortcutEnabled,
     remoteFetchIntervalSeconds: normalizeRemoteFetchIntervalSeconds(
@@ -19726,7 +17997,7 @@ function projectError(message) {
   return new GitOperationError({ code: "INVALID_ARGUMENT", operation: "repository-projects", message });
 }
 function isHarness(value) {
-  return value === "codex" || value === "claude" || value === "opencode";
+  return value === "codex" || value === "claude" || value === "opencode" || value === "grok";
 }
 function normalizeUiFont(value) {
   if (value === "cabinet-grotesk" || value === "satoshi") return "plus-jakarta-sans";
@@ -19741,9 +18012,9 @@ function normalizeSidebarWidth(value) {
   return Math.max(300, Math.min(680, width));
 }
 function modelPreferences(value) {
-  const result = { codex: "default", claude: "default", opencode: "default" };
+  const result = { codex: "default", claude: "default", opencode: "default", grok: "default" };
   if (!value || typeof value !== "object") return result;
-  for (const harness of ["codex", "claude", "opencode"]) {
+  for (const harness of ["codex", "claude", "opencode", "grok"]) {
     const model = value[harness];
     if (typeof model === "string" && model.length > 0 && model.length <= 200 && !hasControlCharacters$1(model)) result[harness] = model;
   }
@@ -19763,6 +18034,31 @@ function normalizeRecent(item) {
     repositoryName: typeof item.repositoryName === "string" && item.repositoryName ? item.repositoryName : path.basename(path.dirname(commonDir))
   };
 }
+function executablePaths(value, strict = false, platform2 = process.platform, home = os.homedir()) {
+  const result = {};
+  const invalid2 = () => {
+    if (strict) throw projectError("CLI executable paths must be absolute paths on the backend host, without arguments or control characters.");
+  };
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    invalid2();
+    return result;
+  }
+  const p = platform2 === "win32" ? path.win32 : path.posix;
+  for (const [key, raw] of Object.entries(value)) {
+    if (!isHarness(key) || typeof raw !== "string") {
+      invalid2();
+      continue;
+    }
+    if (!raw.trim()) continue;
+    const expanded = raw.startsWith("~/") ? p.join(home, raw.slice(2)) : raw;
+    if (raw.length > 4096 || hasControlCharacters$1(raw) || !p.isAbsolute(expanded) || platform2 === "win32" && !/^(?:[a-z]:[\\/]|\\\\)/i.test(expanded)) {
+      invalid2();
+      continue;
+    }
+    result[key] = expanded;
+  }
+  return result;
+}
 class SystemTrash {
   available;
   operation;
@@ -19881,16 +18177,17 @@ async function createOpenTigRuntime(options) {
   const fileHistory = new FileOperationHistory(files, trash);
   const search = new SearchService(git, repositories, files, fileHistory);
   const operations = new GitRepositoryOperations(git, repositories, files);
-  const cliResolver = new CliResolver();
+  const cliResolver = new CliResolver(void 0, () => settings.preferences);
   const cliRunner = new CliProcessRunner();
   const providers = [
     new CodexProvider(cliResolver, cliRunner),
     new ClaudeProvider(cliResolver, cliRunner),
-    new OpenCodeProvider(cliResolver, cliRunner)
+    new OpenCodeProvider(cliResolver, cliRunner),
+    new GrokProvider(cliResolver, cliRunner)
   ];
   const aiLog = new AiLogStore(options.aiLogPath);
   await aiLog.load();
-  const ai = new CommitMessageService(operations, providers, aiLog);
+  const ai = new CommitMessageService(operations, providers, aiLog, () => cliResolver.invalidate());
   const prDrafts = new PullRequestDraftService(operations, providers, aiLog);
   const github = new GitHubService(cliResolver, cliRunner, git, repositories);
   let runtime = null;
@@ -20370,22 +18667,66 @@ function mimeTypeOf(relativePath, bytes) {
   if (fromPath === "image/svg+xml") return fromPath;
   return detectRasterImageMime(bytes) ?? fromPath;
 }
-async function browseServerDirectories(requestedPath) {
-  const input = requestedPath ?? homedir();
-  const expanded = input === "~" ? homedir() : /^~[/\\]/.test(input) ? join(homedir(), input.slice(2)) : input;
-  if (!isAbsolute(expanded)) throw new Error("Enter an absolute folder path on the server.");
+async function browseServerDirectories(requestedPath, git = new GitProcess()) {
+  const home = homedir();
+  const input = requestedPath ?? home;
+  const expanded = input === "~" ? home : /^~[/\\]/.test(input) ? join(home, input.slice(2)) : input;
+  if (!isAbsolute(expanded)) throw new Error("Enter an absolute folder path.");
   const path2 = resolve(expanded);
-  const entries = await readdir(path2, { withFileTypes: true });
+  let entries;
+  try {
+    entries = await readdir(path2, { withFileTypes: true });
+  } catch (error) {
+    const code = error.code;
+    if (code === "EACCES" || code === "EPERM") throw new Error("You do not have permission to browse this folder.", { cause: error });
+    if (code === "ENOENT") throw new Error("That folder was not found. Check the path and try again.", { cause: error });
+    if (code === "ENOTDIR") throw new Error("This path points to a file. Choose a folder instead.", { cause: error });
+    throw new Error("Could not read this folder. Try another location.", { cause: error });
+  }
   const directories = [];
-  for (const entry of entries) {
-    const entryPath = join(path2, entry.name);
-    if (entry.isDirectory() || entry.isSymbolicLink() && await stat(entryPath).then((value) => value.isDirectory(), () => false)) {
-      directories.push({ name: entry.name, path: entryPath });
+  let index = 0;
+  await Promise.all(Array.from({ length: Math.min(6, entries.length) }, async () => {
+    while (index < entries.length) {
+      const entry = entries[index++];
+      const entryPath = join(path2, entry.name);
+      if (entry.isDirectory() || entry.isSymbolicLink() && await stat(entryPath).then((value) => value.isDirectory(), () => false)) {
+        directories.push({ name: entry.name, path: entryPath, repository: await inspectRepository(entryPath, git) });
+      }
     }
-  }
+  }));
   directories.sort((a2, b) => a2.name.localeCompare(b.name, void 0, { numeric: true, sensitivity: "base" }));
+  const locations = [{ name: "Home", path: home, kind: "home" }];
+  for (const [name, kind] of [["Documents", "documents"], ["Downloads", "downloads"]]) {
+    const location = join(home, name);
+    if (await stat(location).then((value) => value.isDirectory(), () => false)) locations.push({ name, path: location, kind });
+  }
   const parentPath = dirname(path2);
-  return { path: path2, parentPath: parentPath === path2 ? null : parentPath, directories };
+  return { path: path2, parentPath: parentPath === path2 ? null : parentPath, repository: await inspectRepository(path2, git), locations, directories };
+}
+async function inspectRepository(path2, git) {
+  if (!await stat(join(path2, ".git")).then((value) => value.isDirectory() || value.isFile(), () => false)) return null;
+  try {
+    const result = await git.run(path2, ["rev-parse", "--is-inside-work-tree", "--absolute-git-dir"], {
+      operation: "browse-repository",
+      readOnly: true,
+      timeoutMs: 2e3,
+      maxOutputBytes: 32768
+    });
+    const [inside, gitDir] = result.stdout.toString("utf8").trim().split(/\r?\n/);
+    if (inside !== "true" || !gitDir || !isAbsolute(gitDir)) return null;
+    const headFile = await open(join(gitDir, "HEAD"), "r");
+    let head;
+    try {
+      const buffer = Buffer.alloc(4096);
+      const { bytesRead } = await headFile.read(buffer, 0, buffer.length, 0);
+      head = buffer.subarray(0, bytesRead).toString("utf8").trim();
+    } finally {
+      await headFile.close();
+    }
+    return { branch: head.startsWith("ref: refs/heads/") ? head.slice("ref: refs/heads/".length) : null };
+  } catch {
+    return null;
+  }
 }
 const requestRecordSchema = looseObject({});
 function boundedStringSchema(maxLength, options = {}) {
@@ -20408,7 +18749,7 @@ const searchOptionsSchema = object({
   includeIgnored: unknown().optional()
 });
 const openFileTabSchema = object({ path: unknown(), pinned: boolean() });
-const aiHarnessSchema = _enum(["codex", "claude", "opencode"]);
+const aiHarnessSchema = _enum(["codex", "claude", "opencode", "grok"]);
 const pullRequestStateSchema = _enum(["OPEN", "CLOSED", "MERGED"]);
 function stringArg(value, operation, maxLength = 32768) {
   const parsed = boundedStringSchema(maxLength, { controls: false }).safeParse(value);
@@ -20729,6 +19070,7 @@ function registerServerCommands(registry2, services, host) {
   });
   handle(IPC.preferences, "preferences", async (partial2) => {
     const preferences = await services.settings.setPreferences(partial2 ?? {});
+    if (partial2 && typeof partial2 === "object" && "aiExecutablePaths" in partial2) services.ai.invalidateStatuses();
     return preferences;
   });
   handle(IPC.filesTreeStateUpdate, "files-tree-state", (repositoryId, expandedPaths) => {
@@ -20748,7 +19090,8 @@ function registerServerCommands(registry2, services, host) {
     context
   ));
   handle(IPC.repositoryBrowseDirectories, "browse-directories", (path2) => browseServerDirectories(
-    path2 === void 0 ? void 0 : stringArg(path2, "browse-directories", 32768)
+    path2 === void 0 ? void 0 : stringArg(path2, "browse-directories", 32768),
+    services.git
   ));
   handleWithContext(IPC.repositoryOpenRecent, "open-recent", async (context, id) => {
     const repositoryId = stringArg(id, "open-recent", 64);
@@ -20786,7 +19129,7 @@ function registerServerCommands(registry2, services, host) {
   ));
   handle(IPC.repositoryDirectoryEntries, "directory-entries", (id, directoryPath) => services.files.listDirectory(
     stringArg(id, "directory-entries", 64),
-    stringArg(directoryPath, "directory-entries")
+    directoryPath === "" ? "" : stringArg(directoryPath, "directory-entries")
   ));
   handle(IPC.repositoryReadFile, "read-file", (id, filePath, allowLarge) => services.files.read(stringArg(id, "read-file", 64), stringArg(filePath, "read-file"), allowLarge === true));
   handle(IPC.repositoryReadImage, "read-image", (id, filePath) => services.files.readImage(
@@ -22098,12 +20441,12 @@ class OpenTigWebSocketTransport {
   upgradeHandler;
   closePromise = null;
   get connectedSessionCount() {
-    return new Set([...this.clients.values()].map((client2) => client2.sessionId)).size;
+    return new Set([...this.clients.values()].map((client) => client.sessionId)).size;
   }
   connectionCount(sessionId) {
     let count2 = 0;
-    for (const client2 of this.clients.values()) {
-      if (client2.sessionId === sessionId) count2 += 1;
+    for (const client of this.clients.values()) {
+      if (client.sessionId === sessionId) count2 += 1;
     }
     return count2;
   }
@@ -22149,7 +20492,7 @@ class OpenTigWebSocketTransport {
     socket.on("close", () => {
       for (const controller of state.requests.values()) controller.abort();
       this.clients.delete(socket);
-      if (![...this.clients.values()].some((client2) => client2.sessionId === sessionId)) {
+      if (![...this.clients.values()].some((client) => client.sessionId === sessionId)) {
         this.options.registry.clearSession(sessionId);
       }
     });