@opentig/cli 0.1.8 → 0.2.0

package/dist/server.mjs

@@ -1,17 +1,17 @@
 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";
@@ -6872,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) {
@@ -6939,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,
@@ -6964,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);
@@ -6983,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 };
   }
@@ -7008,49 +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", "grok", "gh"]);
 const ALIASES = {
   codex: ["codex"],
   claude: ["claude"],
-  // Current v2 uses opencode; older distributions also provide opencode2.
   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();
+  settingsKey = "";
+  generation = 0;
+  invalidate() {
+    this.generation++;
+    this.cache.clear();
+    this.environment.invalidate();
+  }
   async resolve(name, forceRefresh = false) {
     return (await this.resolveAll(name, forceRefresh))[0] ?? null;
   }
   async resolveAll(name, forceRefresh = false) {
-    if (!ALLOWED.has(name)) return [];
-    if (!forceRefresh && this.cache.has(name)) return [...this.cache.get(name)];
-    const resolved = [];
-    for (const alias of ALIASES[name] ?? [name]) {
-      const executable = await findOnPath(alias);
-      if (executable && !resolved.includes(executable)) resolved.push(executable);
-    }
-    this.cache.set(name, resolved);
-    return [...resolved];
-  }
-}
-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 {
+    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) {
@@ -12216,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) {
@@ -12468,9 +12746,53 @@ 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$1 = { id: "default", label: "Default (CLI)" };
 function grokUsage(envelope) {
   if (!envelope || typeof envelope !== "object") return { ...EMPTY_AI_USAGE };
   const record2 = envelope;
@@ -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$1], 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$1], 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 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 {
@@ -12832,16 +13156,15 @@ class GrokProvider {
   async status(forceRefresh = false) {
     const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
     const base = { id: this.id, label: "Grok Build", checkedAt, models: [DEFAULT_MODEL] };
-    const executable = await this.resolver.resolve("grok", forceRefresh);
-    if (!executable) return { ...base, installed: false, availability: "error", authStatus: "unknown", message: "Install the official Grok Build CLI and run grok login." };
     return this.withEnvironment(async (options) => {
-      const version2 = await this.runner.run(executable, ["--version"], options);
-      const versionText = version2.stdout.trim();
-      const installed = { ...base, installed: true, version: versionText };
-      if (version2.exitCode !== 0 || !isSupportedGrokVersion(versionText)) return { ...installed, availability: "error", authStatus: "unknown", message: UNSUPPORTED };
+      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 this.runner.run(executable, ["models"], 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 {
@@ -12857,15 +13180,12 @@ class GrokProvider {
     });
   }
   async generate(input) {
-    const executable = await this.resolver.resolve("grok");
-    if (!executable) throw failure("AI_CLI_NOT_FOUND", "Grok Build is not installed.");
     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 version2 = await this.runner.run(executable, ["--version"], controlled);
-        if (version2.exitCode !== 0 || !isSupportedGrokVersion(version2.stdout)) throw failure("AI_PROCESS_FAILED", UNSUPPORTED);
+        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 });
@@ -12891,7 +13211,7 @@ class GrokProvider {
           "--no-memory"
         ];
         if (input.model !== "default") args.push("--model", input.model);
-        const result = await this.runner.run(executable, args, { ...controlled, timeoutMs: AI_PROVIDER_TIMEOUT_MS });
+        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) };
@@ -12903,9 +13223,9 @@ class GrokProvider {
     }
   }
   async checkControls(executable, options) {
-    const help = await this.runner.run(executable, ["--help"], 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 this.runner.run(executable, ["inspect", "--json"], options);
+    const result = await runCandidate(this.runner, executable, ["inspect", "--json"], options);
     let report;
     try {
       report = JSON.parse(result.stdout);
@@ -13015,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 });
@@ -13221,13 +13542,14 @@ class OpenCodeProvider {
   async status(forceRefresh = false) {
     const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
     const detected = await this.detect(forceRefresh);
-    if (!detected) return { id: this.id, label: "OpenCode", availability: "error", installed: false, authStatus: "unknown", message: "Install OpenCode 2 to use this harness.", models: [DEFAULT_MODEL$1], checkedAt };
-    const { executable, version: version2, compatible } = detected;
-    const cliName = openCodeCliName(executable);
-    if (!compatible) return { id: this.id, label: "OpenCode", availability: "error", installed: true, authStatus: "unknown", message: UNSUPPORTED_MESSAGE, cliName, version: version2, models: [DEFAULT_MODEL$1], checkedAt };
+    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([
-      this.runner.run(executable, ["auth", "list", "--format", "json", "--standalone"]),
-      this.runner.run(executable, ["models", "--standalone"], { timeoutMs: 3e4 })
+      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$1];
     let authStatus = parseOpenCodeAuthList(auth.stdout, auth.exitCode);
@@ -13237,6 +13559,7 @@ class OpenCodeProvider {
       id: this.id,
       label: "OpenCode",
       availability: models.length > 1 ? confirmed ? "ready" : "warning" : authStatus === "unauthenticated" ? "error" : "warning",
+      ...detectionFields(detected),
       installed: true,
       authStatus,
       cliName,
@@ -13248,9 +13571,7 @@ class OpenCodeProvider {
   }
   async generate(input) {
     const detected = await this.detect(false, input.signal);
-    if (!detected) throw new AiOperationError({ code: "AI_CLI_NOT_FOUND", operation: "opencode-generate", harness: this.id, message: "OpenCode is not installed." });
-    if (!detected.compatible) throw new AiOperationError({ code: "AI_PROCESS_FAILED", operation: "opencode-generate", harness: this.id, message: UNSUPPORTED_MESSAGE });
-    const executable = detected.executable;
+    const executable = requireCandidate(detected, this.id);
     const timeoutSignal = AbortSignal.timeout(AI_PROVIDER_TIMEOUT_MS);
     const boundedInput = { ...input, signal: AbortSignal.any([input.signal, timeoutSignal]) };
     try {
@@ -13263,7 +13584,7 @@ class OpenCodeProvider {
     }
   }
   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 });
     });
@@ -13286,21 +13607,7 @@ ${input.prompt}`, model: input.model, cwd: input.repositoryPath, signal: input.s
     }
   }
   async detect(forceRefresh = false, signal) {
-    const candidates = await this.resolver.resolveAll("opencode", forceRefresh);
-    let first = null;
-    for (const executable of candidates) {
-      try {
-        const result = await this.runner.run(executable, ["--version"], signal ? { signal } : {});
-        const version2 = result.stdout.trim() || result.stderr.trim();
-        const detected = { executable, version: version2, compatible: result.exitCode === 0 && isOpenCodeV2Version(version2) };
-        if (detected.compatible) return detected;
-        first ??= detected;
-      } catch (error) {
-        if (signal?.aborted) throw error;
-        first ??= { executable, version: "", compatible: false };
-      }
-    }
-    return first;
+    return selectCli(this.resolver, this.runner, this.id, { forceRefresh, compatible: isOpenCodeV2Version, runOptions: signal ? { signal } : {} });
   }
   close() {
     for (const server of this.servers) server.close();
@@ -13589,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 {
@@ -13599,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;
@@ -13616,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();
@@ -16652,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 }
@@ -16764,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 };
@@ -16788,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);
@@ -16796,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 } : {}
@@ -17263,6 +17587,7 @@ const defaults = {
     monoFont: "jetbrains-mono",
     commitMessageHarness: "codex",
     commitMessageModels: { codex: "default", claude: "default", opencode: "default", grok: "default" },
+    aiExecutablePaths: {},
     shortcutOverrides: {},
     doubleControlShortcutEnabled: true,
     remoteFetchIntervalSeconds: DEFAULT_REMOTE_FETCH_INTERVAL_SECONDS
@@ -17342,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 };
@@ -17471,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);
@@ -17599,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(
@@ -17706,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;
@@ -17824,7 +18177,7 @@ 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),
@@ -17834,7 +18187,7 @@ async function createOpenTigRuntime(options) {
   ];
   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;
@@ -18314,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 = {}) {
@@ -18673,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) => {
@@ -18692,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);
@@ -18730,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(