@opentig/cli 0.1.8 → 0.2.1

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 { randomUUID, randomBytes, createHmac, createHash, timingSafeEqual } from "node:crypto";
+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";
@@ -19,6 +19,9 @@ import path$1 from "node:path/win32";
 import { createServer, isIP } from "node:net";
 import { createServer as createServer$1 } from "node:http";
 import WebSocket, { WebSocketServer } from "ws";
+function aiExecutablePathsKey(paths) {
+  return JSON.stringify(["codex", "claude", "opencode", "grok"].map((id) => paths[id] ?? ""));
+}
 function isPlainObject$1(value) {
   if (typeof value !== "object" || value === null) {
     return false;
@@ -5709,7 +5712,7 @@ const createReadable = ({ subprocess, concurrentStreams, encoding }, { from, bin
   const binary = binaryOption || BINARY_ENCODINGS.has(encoding);
   const { subprocessStdout, waitReadableDestroy } = getSubprocessStdout(subprocess, from, concurrentStreams);
   const { readableEncoding, readableObjectMode, readableHighWaterMark } = getReadableOptions(subprocessStdout, binary);
-  const { read, onStdoutDataDone } = getReadableMethods({
+  const { read: read2, onStdoutDataDone } = getReadableMethods({
     subprocessStdout,
     subprocess,
     binary,
@@ -5717,7 +5720,7 @@ const createReadable = ({ subprocess, concurrentStreams, encoding }, { from, bin
     preserveNewlines
   });
   const readable2 = new Readable({
-    read,
+    read: read2,
     destroy: callbackify(onReadableDestroy.bind(void 0, { subprocessStdout, subprocess, waitReadableDestroy })),
     highWaterMark: readableHighWaterMark,
     objectMode: readableObjectMode,
@@ -6555,7 +6558,7 @@ const createDuplex = ({ subprocess, concurrentStreams, encoding }, { from, to, b
   const { subprocessStdout, waitReadableDestroy } = getSubprocessStdout(subprocess, from, concurrentStreams);
   const { subprocessStdin, waitWritableFinal, waitWritableDestroy } = getSubprocessStdin(subprocess, to, concurrentStreams);
   const { readableEncoding, readableObjectMode, readableHighWaterMark } = getReadableOptions(subprocessStdout, binary);
-  const { read, onStdoutDataDone } = getReadableMethods({
+  const { read: read2, onStdoutDataDone } = getReadableMethods({
     subprocessStdout,
     subprocess,
     binary,
@@ -6563,7 +6566,7 @@ const createDuplex = ({ subprocess, concurrentStreams, encoding }, { from, to, b
     preserveNewlines
   });
   const duplex2 = new Duplex({
-    read,
+    read: read2,
     ...getWritableMethods(subprocessStdin, subprocess, waitWritableFinal),
     destroy: callbackify(onDuplexDestroy.bind(void 0, {
       subprocessStdout,
@@ -6872,6 +6875,154 @@ 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(), read2 = readUserEnvironment) {
+    this.host = host;
+    this.read = read2;
+  }
+  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: host.platform === "win32" ? 15e3 : 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.timedOut) throw new Error("Environment query timed out");
+    if (result.exitCode !== 0 || 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 +7090,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 +7116,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 +7135,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 +7160,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) {
@@ -7287,14 +7533,14 @@ const NUMBER_FORMAT_RANGES = {
   float32: [-34028234663852886e22, 34028234663852886e22],
   float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
 };
-function pick(schema, mask) {
-  const currDef = schema._zod.def;
+function pick(schema2, mask) {
+  const currDef = schema2._zod.def;
   const checks = currDef.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
     throw new Error(".pick() cannot be used on object schemas containing refinements");
   }
-  const def = mergeDefs(schema._zod.def, {
+  const def = mergeDefs(schema2._zod.def, {
     get shape() {
       const newShape = {};
       for (const key in mask) {
@@ -7310,18 +7556,18 @@ function pick(schema, mask) {
     },
     checks: []
   });
-  return clone(schema, def);
+  return clone(schema2, def);
 }
-function omit(schema, mask) {
-  const currDef = schema._zod.def;
+function omit(schema2, mask) {
+  const currDef = schema2._zod.def;
   const checks = currDef.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
     throw new Error(".omit() cannot be used on object schemas containing refinements");
   }
-  const def = mergeDefs(schema._zod.def, {
+  const def = mergeDefs(schema2._zod.def, {
     get shape() {
-      const newShape = { ...schema._zod.def.shape };
+      const newShape = { ...schema2._zod.def.shape };
       for (const key in mask) {
         if (!(key in currDef.shape)) {
           throw new Error(`Unrecognized key: "${key}"`);
@@ -7335,43 +7581,43 @@ function omit(schema, mask) {
     },
     checks: []
   });
-  return clone(schema, def);
+  return clone(schema2, def);
 }
-function extend(schema, shape) {
+function extend(schema2, shape) {
   if (!isPlainObject(shape)) {
     throw new Error("Invalid input to extend: expected a plain object");
   }
-  const checks = schema._zod.def.checks;
+  const checks = schema2._zod.def.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
-    const existingShape = schema._zod.def.shape;
+    const existingShape = schema2._zod.def.shape;
     for (const key in shape) {
       if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) {
         throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
       }
     }
   }
-  const def = mergeDefs(schema._zod.def, {
+  const def = mergeDefs(schema2._zod.def, {
     get shape() {
-      const _shape = { ...schema._zod.def.shape, ...shape };
+      const _shape = { ...schema2._zod.def.shape, ...shape };
       assignProp(this, "shape", _shape);
       return _shape;
     }
   });
-  return clone(schema, def);
+  return clone(schema2, def);
 }
-function safeExtend(schema, shape) {
+function safeExtend(schema2, shape) {
   if (!isPlainObject(shape)) {
     throw new Error("Invalid input to safeExtend: expected a plain object");
   }
-  const def = mergeDefs(schema._zod.def, {
+  const def = mergeDefs(schema2._zod.def, {
     get shape() {
-      const _shape = { ...schema._zod.def.shape, ...shape };
+      const _shape = { ...schema2._zod.def.shape, ...shape };
       assignProp(this, "shape", _shape);
       return _shape;
     }
   });
-  return clone(schema, def);
+  return clone(schema2, def);
 }
 function merge(a2, b) {
   if (a2._zod.def.checks?.length) {
@@ -7390,16 +7636,16 @@ function merge(a2, b) {
   });
   return clone(a2, def);
 }
-function partial(Class, schema, mask) {
-  const currDef = schema._zod.def;
+function partial(Class, schema2, mask) {
+  const currDef = schema2._zod.def;
   const checks = currDef.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
     throw new Error(".partial() cannot be used on object schemas containing refinements");
   }
-  const def = mergeDefs(schema._zod.def, {
+  const def = mergeDefs(schema2._zod.def, {
     get shape() {
-      const oldShape = schema._zod.def.shape;
+      const oldShape = schema2._zod.def.shape;
       const shape = { ...oldShape };
       if (mask) {
         for (const key in mask) {
@@ -7426,12 +7672,12 @@ function partial(Class, schema, mask) {
     },
     checks: []
   });
-  return clone(schema, def);
+  return clone(schema2, def);
 }
-function required(Class, schema, mask) {
-  const def = mergeDefs(schema._zod.def, {
+function required(Class, schema2, mask) {
+  const def = mergeDefs(schema2._zod.def, {
     get shape() {
-      const oldShape = schema._zod.def.shape;
+      const oldShape = schema2._zod.def.shape;
       const shape = { ...oldShape };
       if (mask) {
         for (const key in mask) {
@@ -7457,7 +7703,7 @@ function required(Class, schema, mask) {
       return shape;
     }
   });
-  return clone(schema, def);
+  return clone(schema2, def);
 }
 function aborted(x, startIndex = 0) {
   if (x.aborted === true)
@@ -7586,9 +7832,9 @@ function formatError(error, mapper = (issue2) => issue2.message) {
   processError(error);
   return fieldErrors;
 }
-const _parse = (_Err) => (schema, value, _ctx, _params) => {
+const _parse = (_Err) => (schema2, value, _ctx, _params) => {
   const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-  const result = schema._zod.run({ value, issues: [] }, ctx);
+  const result = schema2._zod.run({ value, issues: [] }, ctx);
   if (result instanceof Promise) {
     throw new $ZodAsyncError();
   }
@@ -7599,9 +7845,9 @@ const _parse = (_Err) => (schema, value, _ctx, _params) => {
   }
   return result.value;
 };
-const _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
+const _parseAsync = (_Err) => async (schema2, value, _ctx, params) => {
   const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
-  let result = schema._zod.run({ value, issues: [] }, ctx);
+  let result = schema2._zod.run({ value, issues: [] }, ctx);
   if (result instanceof Promise)
     result = await result;
   if (result.issues.length) {
@@ -7611,9 +7857,9 @@ const _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
   }
   return result.value;
 };
-const _safeParse = (_Err) => (schema, value, _ctx) => {
+const _safeParse = (_Err) => (schema2, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-  const result = schema._zod.run({ value, issues: [] }, ctx);
+  const result = schema2._zod.run({ value, issues: [] }, ctx);
   if (result instanceof Promise) {
     throw new $ZodAsyncError();
   }
@@ -7623,9 +7869,9 @@ const _safeParse = (_Err) => (schema, value, _ctx) => {
   } : { success: true, data: result.value };
 };
 const safeParse$1 = /* @__PURE__ */ _safeParse($ZodRealError);
-const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
+const _safeParseAsync = (_Err) => async (schema2, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
-  let result = schema._zod.run({ value, issues: [] }, ctx);
+  let result = schema2._zod.run({ value, issues: [] }, ctx);
   if (result instanceof Promise)
     result = await result;
   return result.issues.length ? {
@@ -7634,33 +7880,33 @@ const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
   } : { success: true, data: result.value };
 };
 const safeParseAsync$1 = /* @__PURE__ */ _safeParseAsync($ZodRealError);
-const _encode = (_Err) => (schema, value, _ctx) => {
+const _encode = (_Err) => (schema2, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-  return _parse(_Err)(schema, value, ctx);
+  return _parse(_Err)(schema2, value, ctx);
 };
-const _decode = (_Err) => (schema, value, _ctx) => {
-  return _parse(_Err)(schema, value, _ctx);
+const _decode = (_Err) => (schema2, value, _ctx) => {
+  return _parse(_Err)(schema2, value, _ctx);
 };
-const _encodeAsync = (_Err) => async (schema, value, _ctx) => {
+const _encodeAsync = (_Err) => async (schema2, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-  return _parseAsync(_Err)(schema, value, ctx);
+  return _parseAsync(_Err)(schema2, value, ctx);
 };
-const _decodeAsync = (_Err) => async (schema, value, _ctx) => {
-  return _parseAsync(_Err)(schema, value, _ctx);
+const _decodeAsync = (_Err) => async (schema2, value, _ctx) => {
+  return _parseAsync(_Err)(schema2, value, _ctx);
 };
-const _safeEncode = (_Err) => (schema, value, _ctx) => {
+const _safeEncode = (_Err) => (schema2, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-  return _safeParse(_Err)(schema, value, ctx);
+  return _safeParse(_Err)(schema2, value, ctx);
 };
-const _safeDecode = (_Err) => (schema, value, _ctx) => {
-  return _safeParse(_Err)(schema, value, _ctx);
+const _safeDecode = (_Err) => (schema2, value, _ctx) => {
+  return _safeParse(_Err)(schema2, value, _ctx);
 };
-const _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
+const _safeEncodeAsync = (_Err) => async (schema2, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-  return _safeParseAsync(_Err)(schema, value, ctx);
+  return _safeParseAsync(_Err)(schema2, value, ctx);
 };
-const _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
-  return _safeParseAsync(_Err)(schema, value, _ctx);
+const _safeDecodeAsync = (_Err) => async (schema2, value, _ctx) => {
+  return _safeParseAsync(_Err)(schema2, value, _ctx);
 };
 const cuid = /^[cC][0-9a-z]{6,}$/;
 const cuid2 = /^[0-9a-z]+$/;
@@ -8830,9 +9076,9 @@ const $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def)
     for (const key of normalized.keys) {
       const id = ids[key];
       const k = esc(key);
-      const schema = shape[key];
-      const isOptionalIn = schema?._zod?.optin === "optional";
-      const isOptionalOut = schema?._zod?.optout === "optional";
+      const schema2 = shape[key];
+      const isOptionalIn = schema2?._zod?.optin === "optional";
+      const isOptionalOut = schema2?._zod?.optout === "optional";
       doc.write(`const ${id} = ${parseStr(key)};`);
       if (isOptionalIn && isOptionalOut) {
         doc.write(`
@@ -9001,6 +9247,73 @@ const $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
     });
   };
 });
+const $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnion", (inst, def) => {
+  def.inclusive = false;
+  $ZodUnion.init(inst, def);
+  const _super = inst._zod.parse;
+  defineLazy(inst._zod, "propValues", () => {
+    const propValues = {};
+    for (const option of def.options) {
+      const pv = option._zod.propValues;
+      if (!pv || Object.keys(pv).length === 0)
+        throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
+      for (const [k, v] of Object.entries(pv)) {
+        if (!propValues[k])
+          propValues[k] = /* @__PURE__ */ new Set();
+        for (const val of v) {
+          propValues[k].add(val);
+        }
+      }
+    }
+    return propValues;
+  });
+  const disc = cached(() => {
+    const opts = def.options;
+    const map = /* @__PURE__ */ new Map();
+    for (const o2 of opts) {
+      const values = o2._zod.propValues?.[def.discriminator];
+      if (!values || values.size === 0)
+        throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o2)}"`);
+      for (const v of values) {
+        if (map.has(v)) {
+          throw new Error(`Duplicate discriminator value "${String(v)}"`);
+        }
+        map.set(v, o2);
+      }
+    }
+    return map;
+  });
+  inst._zod.parse = (payload, ctx) => {
+    const input = payload.value;
+    if (!isObject(input)) {
+      payload.issues.push({
+        code: "invalid_type",
+        expected: "object",
+        input,
+        inst
+      });
+      return payload;
+    }
+    const opt = disc.value.get(input?.[def.discriminator]);
+    if (opt) {
+      return opt._zod.run(payload, ctx);
+    }
+    if (def.unionFallback || ctx.direction === "backward") {
+      return _super(payload, ctx);
+    }
+    payload.issues.push({
+      code: "invalid_union",
+      errors: [],
+      note: "No matching discriminator",
+      discriminator: def.discriminator,
+      options: Array.from(disc.value.keys()),
+      input,
+      path: [def.discriminator],
+      inst
+    });
+    return payload;
+  };
+});
 const $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.parse = (payload, ctx) => {
@@ -9245,6 +9558,28 @@ const $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
     return payload;
   };
 });
+const $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => {
+  $ZodType.init(inst, def);
+  if (def.values.length === 0) {
+    throw new Error("Cannot create literal schema with no valid values");
+  }
+  const values = new Set(def.values);
+  inst._zod.values = values;
+  inst._zod.pattern = new RegExp(`^(${def.values.map((o2) => typeof o2 === "string" ? escapeRegex(o2) : o2 ? escapeRegex(o2.toString()) : String(o2)).join("|")})$`);
+  inst._zod.parse = (payload, _ctx) => {
+    const input = payload.value;
+    if (values.has(input)) {
+      return payload;
+    }
+    payload.issues.push({
+      code: "invalid_value",
+      values: def.values,
+      input,
+      inst
+    });
+    return payload;
+  };
+});
 const $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.optin = "optional";
@@ -9519,11 +9854,11 @@ class $ZodRegistry {
     this._map = /* @__PURE__ */ new WeakMap();
     this._idmap = /* @__PURE__ */ new Map();
   }
-  add(schema, ..._meta) {
+  add(schema2, ..._meta) {
     const meta = _meta[0];
-    this._map.set(schema, meta);
+    this._map.set(schema2, meta);
     if (meta && typeof meta === "object" && "id" in meta) {
-      this._idmap.set(meta.id, schema);
+      this._idmap.set(meta.id, schema2);
     }
     return this;
   }
@@ -9532,26 +9867,26 @@ class $ZodRegistry {
     this._idmap = /* @__PURE__ */ new Map();
     return this;
   }
-  remove(schema) {
-    const meta = this._map.get(schema);
+  remove(schema2) {
+    const meta = this._map.get(schema2);
     if (meta && typeof meta === "object" && "id" in meta) {
       this._idmap.delete(meta.id);
     }
-    this._map.delete(schema);
+    this._map.delete(schema2);
     return this;
   }
-  get(schema) {
-    const p = schema._zod.parent;
+  get(schema2) {
+    const p = schema2._zod.parent;
     if (p) {
       const pm = { ...this.get(p) ?? {} };
       delete pm.id;
-      const f = { ...pm, ...this._map.get(schema) };
+      const f = { ...pm, ...this._map.get(schema2) };
       return Object.keys(f).length ? f : void 0;
     }
-    return this._map.get(schema);
+    return this._map.get(schema2);
   }
-  has(schema) {
-    return this._map.has(schema);
+  has(schema2) {
+    return this._map.has(schema2);
   }
 }
 function registry() {
@@ -10028,13 +10363,13 @@ function _array(Class, element, params) {
 }
 // @__NO_SIDE_EFFECTS__
 function _refine(Class, fn, _params) {
-  const schema = new Class({
+  const schema2 = new Class({
     type: "custom",
     check: "custom",
     fn,
     ...normalizeParams(_params)
   });
-  return schema;
+  return schema2;
 }
 // @__NO_SIDE_EFFECTS__
 function _superRefine(fn, params) {
@@ -10087,40 +10422,40 @@ function initializeContext(params) {
     external: params?.external ?? void 0
   };
 }
-function process$1(schema, ctx, _params = { path: [], schemaPath: [] }) {
+function process$1(schema2, ctx, _params = { path: [], schemaPath: [] }) {
   var _a2;
-  const def = schema._zod.def;
-  const seen = ctx.seen.get(schema);
+  const def = schema2._zod.def;
+  const seen = ctx.seen.get(schema2);
   if (seen) {
     seen.count++;
-    const isCycle = _params.schemaPath.includes(schema);
+    const isCycle = _params.schemaPath.includes(schema2);
     if (isCycle) {
       seen.cycle = _params.path;
     }
     return seen.schema;
   }
   const result = { schema: {}, count: 1, cycle: void 0, path: _params.path };
-  ctx.seen.set(schema, result);
-  const overrideSchema = schema._zod.toJSONSchema?.();
+  ctx.seen.set(schema2, result);
+  const overrideSchema = schema2._zod.toJSONSchema?.();
   if (overrideSchema) {
     result.schema = overrideSchema;
   } else {
     const params = {
       ..._params,
-      schemaPath: [..._params.schemaPath, schema],
+      schemaPath: [..._params.schemaPath, schema2],
       path: _params.path
     };
-    if (schema._zod.processJSONSchema) {
-      schema._zod.processJSONSchema(ctx, result.schema, params);
+    if (schema2._zod.processJSONSchema) {
+      schema2._zod.processJSONSchema(ctx, result.schema, params);
     } else {
       const _json = result.schema;
       const processor = ctx.processors[def.type];
       if (!processor) {
         throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
       }
-      processor(schema, ctx, _json, params);
+      processor(schema2, ctx, _json, params);
     }
-    const parent = schema._zod.parent;
+    const parent = schema2._zod.parent;
     if (parent) {
       if (!result.ref)
         result.ref = parent;
@@ -10128,21 +10463,21 @@ function process$1(schema, ctx, _params = { path: [], schemaPath: [] }) {
       ctx.seen.get(parent).isParent = true;
     }
   }
-  const meta = ctx.metadataRegistry.get(schema);
+  const meta = ctx.metadataRegistry.get(schema2);
   if (meta)
     Object.assign(result.schema, meta);
-  if (ctx.io === "input" && isTransforming(schema)) {
+  if (ctx.io === "input" && isTransforming(schema2)) {
     delete result.schema.examples;
     delete result.schema.default;
   }
   if (ctx.io === "input" && "_prefault" in result.schema)
     (_a2 = result.schema).default ?? (_a2.default = result.schema._prefault);
   delete result.schema._prefault;
-  const _result = ctx.seen.get(schema);
+  const _result = ctx.seen.get(schema2);
   return _result.schema;
 }
-function extractDefs(ctx, schema) {
-  const root = ctx.seen.get(schema);
+function extractDefs(ctx, schema2) {
+  const root = ctx.seen.get(schema2);
   if (!root)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   const idToSchema = /* @__PURE__ */ new Map();
@@ -10185,11 +10520,11 @@ function extractDefs(ctx, schema) {
     seen.def = { ...seen.schema };
     if (defId)
       seen.defId = defId;
-    const schema2 = seen.schema;
-    for (const key in schema2) {
-      delete schema2[key];
+    const schema3 = seen.schema;
+    for (const key in schema3) {
+      delete schema3[key];
     }
-    schema2.$ref = ref;
+    schema3.$ref = ref;
   };
   if (ctx.cycles === "throw") {
     for (const entry of ctx.seen.entries()) {
@@ -10203,13 +10538,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   }
   for (const entry of ctx.seen.entries()) {
     const seen = entry[1];
-    if (schema === entry[0]) {
+    if (schema2 === entry[0]) {
       extractToDef(entry);
       continue;
     }
     if (ctx.external) {
       const ext = ctx.external.registry.get(entry[0])?.id;
-      if (schema !== entry[0] && ext) {
+      if (schema2 !== entry[0] && ext) {
         extractToDef(entry);
         continue;
       }
@@ -10231,16 +10566,16 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
   }
 }
-function finalize(ctx, schema) {
-  const root = ctx.seen.get(schema);
+function finalize(ctx, schema2) {
+  const root = ctx.seen.get(schema2);
   if (!root)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   const flattenRef = (zodSchema) => {
     const seen = ctx.seen.get(zodSchema);
     if (seen.ref === null)
       return;
-    const schema2 = seen.def ?? seen.schema;
-    const _cached = { ...schema2 };
+    const schema3 = seen.def ?? seen.schema;
+    const _cached = { ...schema3 };
     const ref = seen.ref;
     seen.ref = null;
     if (ref) {
@@ -10248,28 +10583,28 @@ function finalize(ctx, schema) {
       const refSeen = ctx.seen.get(ref);
       const refSchema = refSeen.schema;
       if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
-        schema2.allOf = schema2.allOf ?? [];
-        schema2.allOf.push(refSchema);
+        schema3.allOf = schema3.allOf ?? [];
+        schema3.allOf.push(refSchema);
       } else {
-        Object.assign(schema2, refSchema);
+        Object.assign(schema3, refSchema);
       }
-      Object.assign(schema2, _cached);
+      Object.assign(schema3, _cached);
       const isParentRef = zodSchema._zod.parent === ref;
       if (isParentRef) {
-        for (const key in schema2) {
+        for (const key in schema3) {
           if (key === "$ref" || key === "allOf")
             continue;
           if (!(key in _cached)) {
-            delete schema2[key];
+            delete schema3[key];
           }
         }
       }
       if (refSchema.$ref && refSeen.def) {
-        for (const key in schema2) {
+        for (const key in schema3) {
           if (key === "$ref" || key === "allOf")
             continue;
-          if (key in refSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(refSeen.def[key])) {
-            delete schema2[key];
+          if (key in refSeen.def && JSON.stringify(schema3[key]) === JSON.stringify(refSeen.def[key])) {
+            delete schema3[key];
           }
         }
       }
@@ -10279,13 +10614,13 @@ function finalize(ctx, schema) {
       flattenRef(parent);
       const parentSeen = ctx.seen.get(parent);
       if (parentSeen?.schema.$ref) {
-        schema2.$ref = parentSeen.schema.$ref;
+        schema3.$ref = parentSeen.schema.$ref;
         if (parentSeen.def) {
-          for (const key in schema2) {
+          for (const key in schema3) {
             if (key === "$ref" || key === "allOf")
               continue;
-            if (key in parentSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(parentSeen.def[key])) {
-              delete schema2[key];
+            if (key in parentSeen.def && JSON.stringify(schema3[key]) === JSON.stringify(parentSeen.def[key])) {
+              delete schema3[key];
             }
           }
         }
@@ -10293,7 +10628,7 @@ function finalize(ctx, schema) {
     }
     ctx.override({
       zodSchema,
-      jsonSchema: schema2,
+      jsonSchema: schema3,
       path: seen.path ?? []
     });
   };
@@ -10310,13 +10645,13 @@ function finalize(ctx, schema) {
   } else if (ctx.target === "openapi-3.0") ;
   else ;
   if (ctx.external?.uri) {
-    const id = ctx.external.registry.get(schema)?.id;
+    const id = ctx.external.registry.get(schema2)?.id;
     if (!id)
       throw new Error("Schema is missing an `id` property");
     result.$id = ctx.external.uri(id);
   }
   Object.assign(result, root.def ?? root.schema);
-  const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
+  const rootMetaId = ctx.metadataRegistry.get(schema2)?.id;
   if (rootMetaId !== void 0 && result.id === rootMetaId)
     delete result.id;
   const defs = ctx.external?.defs ?? {};
@@ -10342,10 +10677,10 @@ function finalize(ctx, schema) {
     const finalized = JSON.parse(JSON.stringify(result));
     Object.defineProperty(finalized, "~standard", {
       value: {
-        ...schema["~standard"],
+        ...schema2["~standard"],
         jsonSchema: {
-          input: createStandardJSONSchemaMethod(schema, "input", ctx.processors),
-          output: createStandardJSONSchemaMethod(schema, "output", ctx.processors)
+          input: createStandardJSONSchemaMethod(schema2, "input", ctx.processors),
+          output: createStandardJSONSchemaMethod(schema2, "output", ctx.processors)
         }
       },
       enumerable: false,
@@ -10409,18 +10744,18 @@ function isTransforming(_schema, _ctx) {
   }
   return false;
 }
-const createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
+const createToJSONSchemaMethod = (schema2, processors = {}) => (params) => {
   const ctx = initializeContext({ ...params, processors });
-  process$1(schema, ctx);
-  extractDefs(ctx, schema);
-  return finalize(ctx, schema);
+  process$1(schema2, ctx);
+  extractDefs(ctx, schema2);
+  return finalize(ctx, schema2);
 };
-const createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
+const createStandardJSONSchemaMethod = (schema2, io, processors = {}) => (params) => {
   const { libraryOptions, target } = params ?? {};
   const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
-  process$1(schema, ctx);
-  extractDefs(ctx, schema);
-  return finalize(ctx, schema);
+  process$1(schema2, ctx);
+  extractDefs(ctx, schema2);
+  return finalize(ctx, schema2);
 };
 const formatMap = {
   guid: "uuid",
@@ -10430,10 +10765,10 @@ const formatMap = {
   regex: ""
   // do not set
 };
-const stringProcessor = (schema, ctx, _json, _params) => {
+const stringProcessor = (schema2, ctx, _json, _params) => {
   const json2 = _json;
   json2.type = "string";
-  const { minimum, maximum, format: format2, patterns, contentEncoding } = schema._zod.bag;
+  const { minimum, maximum, format: format2, patterns, contentEncoding } = schema2._zod.bag;
   if (typeof minimum === "number")
     json2.minLength = minimum;
   if (typeof maximum === "number")
@@ -10462,9 +10797,9 @@ const stringProcessor = (schema, ctx, _json, _params) => {
     }
   }
 };
-const numberProcessor = (schema, ctx, _json, _params) => {
+const numberProcessor = (schema2, ctx, _json, _params) => {
   const json2 = _json;
-  const { minimum, maximum, format: format2, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
+  const { minimum, maximum, format: format2, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema2._zod.bag;
   if (typeof format2 === "string" && format2.includes("int"))
     json2.type = "integer";
   else
@@ -10539,8 +10874,8 @@ const dateProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("Date cannot be represented in JSON Schema");
   }
 };
-const enumProcessor = (schema, _ctx, json2, _params) => {
-  const def = schema._zod.def;
+const enumProcessor = (schema2, _ctx, json2, _params) => {
+  const def = schema2._zod.def;
   const values = getEnumValues(def.entries);
   if (values.every((v) => typeof v === "number"))
     json2.type = "number";
@@ -10548,8 +10883,8 @@ const enumProcessor = (schema, _ctx, json2, _params) => {
     json2.type = "string";
   json2.enum = values;
 };
-const literalProcessor = (schema, ctx, json2, _params) => {
-  const def = schema._zod.def;
+const literalProcessor = (schema2, ctx, json2, _params) => {
+  const def = schema2._zod.def;
   const vals = [];
   for (const val of def.values) {
     if (val === void 0) {
@@ -10592,22 +10927,22 @@ const nanProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("NaN cannot be represented in JSON Schema");
   }
 };
-const templateLiteralProcessor = (schema, _ctx, json2, _params) => {
+const templateLiteralProcessor = (schema2, _ctx, json2, _params) => {
   const _json = json2;
-  const pattern = schema._zod.pattern;
+  const pattern = schema2._zod.pattern;
   if (!pattern)
     throw new Error("Pattern not found in template literal");
   _json.type = "string";
   _json.pattern = pattern.source;
 };
-const fileProcessor = (schema, _ctx, json2, _params) => {
+const fileProcessor = (schema2, _ctx, json2, _params) => {
   const _json = json2;
   const file = {
     type: "string",
     format: "binary",
     contentEncoding: "binary"
   };
-  const { minimum, maximum, mime } = schema._zod.bag;
+  const { minimum, maximum, mime } = schema2._zod.bag;
   if (minimum !== void 0)
     file.minLength = minimum;
   if (maximum !== void 0)
@@ -10652,10 +10987,10 @@ const setProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("Set cannot be represented in JSON Schema");
   }
 };
-const arrayProcessor = (schema, ctx, _json, params) => {
+const arrayProcessor = (schema2, ctx, _json, params) => {
   const json2 = _json;
-  const def = schema._zod.def;
-  const { minimum, maximum } = schema._zod.bag;
+  const def = schema2._zod.def;
+  const { minimum, maximum } = schema2._zod.bag;
   if (typeof minimum === "number")
     json2.minItems = minimum;
   if (typeof maximum === "number")
@@ -10666,9 +11001,9 @@ const arrayProcessor = (schema, ctx, _json, params) => {
     path: [...params.path, "items"]
   });
 };
-const objectProcessor = (schema, ctx, _json, params) => {
+const objectProcessor = (schema2, ctx, _json, params) => {
   const json2 = _json;
-  const def = schema._zod.def;
+  const def = schema2._zod.def;
   json2.type = "object";
   json2.properties = {};
   const shape = def.shape;
@@ -10702,8 +11037,8 @@ const objectProcessor = (schema, ctx, _json, params) => {
     });
   }
 };
-const unionProcessor = (schema, ctx, json2, params) => {
-  const def = schema._zod.def;
+const unionProcessor = (schema2, ctx, json2, params) => {
+  const def = schema2._zod.def;
   const isExclusive = def.inclusive === false;
   const options = def.options.map((x, i2) => process$1(x, ctx, {
     ...params,
@@ -10715,8 +11050,8 @@ const unionProcessor = (schema, ctx, json2, params) => {
     json2.anyOf = options;
   }
 };
-const intersectionProcessor = (schema, ctx, json2, params) => {
-  const def = schema._zod.def;
+const intersectionProcessor = (schema2, ctx, json2, params) => {
+  const def = schema2._zod.def;
   const a2 = process$1(def.left, ctx, {
     ...params,
     path: [...params.path, "allOf", 0]
@@ -10732,9 +11067,9 @@ const intersectionProcessor = (schema, ctx, json2, params) => {
   ];
   json2.allOf = allOf;
 };
-const tupleProcessor = (schema, ctx, _json, params) => {
+const tupleProcessor = (schema2, ctx, _json, params) => {
   const json2 = _json;
-  const def = schema._zod.def;
+  const def = schema2._zod.def;
   json2.type = "array";
   const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
   const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
@@ -10768,15 +11103,15 @@ const tupleProcessor = (schema, ctx, _json, params) => {
       json2.additionalItems = rest;
     }
   }
-  const { minimum, maximum } = schema._zod.bag;
+  const { minimum, maximum } = schema2._zod.bag;
   if (typeof minimum === "number")
     json2.minItems = minimum;
   if (typeof maximum === "number")
     json2.maxItems = maximum;
 };
-const recordProcessor = (schema, ctx, _json, params) => {
+const recordProcessor = (schema2, ctx, _json, params) => {
   const json2 = _json;
-  const def = schema._zod.def;
+  const def = schema2._zod.def;
   json2.type = "object";
   const keyType = def.keyType;
   const keyBag = keyType._zod.bag;
@@ -10810,10 +11145,10 @@ const recordProcessor = (schema, ctx, _json, params) => {
     }
   }
 };
-const nullableProcessor = (schema, ctx, json2, params) => {
-  const def = schema._zod.def;
+const nullableProcessor = (schema2, ctx, json2, params) => {
+  const def = schema2._zod.def;
   const inner = process$1(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   if (ctx.target === "openapi-3.0") {
     seen.ref = def.innerType;
     json2.nullable = true;
@@ -10821,31 +11156,31 @@ const nullableProcessor = (schema, ctx, json2, params) => {
     json2.anyOf = [inner, { type: "null" }];
   }
 };
-const nonoptionalProcessor = (schema, ctx, _json, params) => {
-  const def = schema._zod.def;
+const nonoptionalProcessor = (schema2, ctx, _json, params) => {
+  const def = schema2._zod.def;
   process$1(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
 };
-const defaultProcessor = (schema, ctx, json2, params) => {
-  const def = schema._zod.def;
+const defaultProcessor = (schema2, ctx, json2, params) => {
+  const def = schema2._zod.def;
   process$1(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
   json2.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
-const prefaultProcessor = (schema, ctx, json2, params) => {
-  const def = schema._zod.def;
+const prefaultProcessor = (schema2, ctx, json2, params) => {
+  const def = schema2._zod.def;
   process$1(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
   if (ctx.io === "input")
     json2._prefault = JSON.parse(JSON.stringify(def.defaultValue));
 };
-const catchProcessor = (schema, ctx, json2, params) => {
-  const def = schema._zod.def;
+const catchProcessor = (schema2, ctx, json2, params) => {
+  const def = schema2._zod.def;
   process$1(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
   let catchValue;
   try {
@@ -10855,37 +11190,37 @@ const catchProcessor = (schema, ctx, json2, params) => {
   }
   json2.default = catchValue;
 };
-const pipeProcessor = (schema, ctx, _json, params) => {
-  const def = schema._zod.def;
+const pipeProcessor = (schema2, ctx, _json, params) => {
+  const def = schema2._zod.def;
   const inIsTransform = def.in._zod.traits.has("$ZodTransform");
   const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out;
   process$1(innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = innerType;
 };
-const readonlyProcessor = (schema, ctx, json2, params) => {
-  const def = schema._zod.def;
+const readonlyProcessor = (schema2, ctx, json2, params) => {
+  const def = schema2._zod.def;
   process$1(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
   json2.readOnly = true;
 };
-const promiseProcessor = (schema, ctx, _json, params) => {
-  const def = schema._zod.def;
+const promiseProcessor = (schema2, ctx, _json, params) => {
+  const def = schema2._zod.def;
   process$1(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
 };
-const optionalProcessor = (schema, ctx, _json, params) => {
-  const def = schema._zod.def;
+const optionalProcessor = (schema2, ctx, _json, params) => {
+  const def = schema2._zod.def;
   process$1(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
 };
-const lazyProcessor = (schema, ctx, _json, params) => {
-  const innerType = schema._zod.innerType;
+const lazyProcessor = (schema2, ctx, _json, params) => {
+  const innerType = schema2._zod.innerType;
   process$1(innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = innerType;
 };
 const allProcessors = {
@@ -10935,8 +11270,8 @@ function toJSONSchema(input, params) {
     const ctx2 = initializeContext({ ...params, processors: allProcessors });
     const defs = {};
     for (const entry of registry2._idmap.entries()) {
-      const [_, schema] = entry;
-      process$1(schema, ctx2);
+      const [_, schema2] = entry;
+      process$1(schema2, ctx2);
     }
     const schemas = {};
     const external = {
@@ -10946,9 +11281,9 @@ function toJSONSchema(input, params) {
     };
     ctx2.external = external;
     for (const entry of registry2._idmap.entries()) {
-      const [key, schema] = entry;
-      extractDefs(ctx2, schema);
-      schemas[key] = finalize(ctx2, schema);
+      const [key, schema2] = entry;
+      extractDefs(ctx2, schema2);
+      schemas[key] = finalize(ctx2, schema2);
     }
     if (Object.keys(defs).length > 0) {
       const defsSegment = ctx2.target === "draft-2020-12" ? "$defs" : "definitions";
@@ -11572,6 +11907,18 @@ function union(options, params) {
     ...normalizeParams(params)
   });
 }
+const ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("ZodDiscriminatedUnion", (inst, def) => {
+  ZodUnion.init(inst, def);
+  $ZodDiscriminatedUnion.init(inst, def);
+});
+function discriminatedUnion(discriminator, options, params) {
+  return new ZodDiscriminatedUnion({
+    type: "union",
+    options,
+    discriminator,
+    ...normalizeParams(params)
+  });
+}
 const ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
   $ZodIntersection.init(inst, def);
   ZodType.init(inst, def);
@@ -11653,6 +12000,27 @@ function _enum(values, params) {
     ...normalizeParams(params)
   });
 }
+const ZodLiteral = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
+  $ZodLiteral.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json2, params) => literalProcessor(inst, ctx, json2);
+  inst.values = new Set(def.values);
+  Object.defineProperty(inst, "value", {
+    get() {
+      if (def.values.length > 1) {
+        throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
+      }
+      return def.values[0];
+    }
+  });
+});
+function literal(value, params) {
+  return new ZodLiteral({
+    type: "literal",
+    values: Array.isArray(value) ? value : [value],
+    ...normalizeParams(params)
+  });
+}
 const ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
   $ZodTransform.init(inst, def);
   ZodType.init(inst, def);
@@ -12216,22 +12584,78 @@ 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, statusPersistence) {
     this.operations = operations;
     this.log = log;
+    this.invalidateDiscovery = invalidateDiscovery;
+    this.statusPersistence = statusPersistence;
     for (const provider of providers) this.providers.set(provider.id, provider);
   }
   operations;
   log;
+  invalidateDiscovery;
+  statusPersistence;
   providers = /* @__PURE__ */ new Map();
   active = /* @__PURE__ */ new Map();
   statusCache = null;
+  statusInvalidated = false;
+  statusGeneration = 0;
+  pendingStatus;
+  invalidateStatuses() {
+    this.statusGeneration++;
+    this.statusCache = null;
+    this.statusInvalidated = true;
+    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;
+    const key = this.statusPersistence?.key() ?? "";
+    if (!forceRefresh && this.statusCache?.key === key) return this.statusCache.value;
+    if (this.pendingStatus?.key === key && (!forceRefresh || this.pendingStatus.force)) return this.pendingStatus.promise;
+    const generation = ++this.statusGeneration;
+    const promise = (async () => {
+      if (!forceRefresh && !this.statusInvalidated && this.statusPersistence) {
+        const saved = await this.statusPersistence.store.load(key).catch(() => null);
+        if (saved?.length === this.providers.size && saved.every((status) => this.providers.has(status.id))) {
+          if (generation === this.statusGeneration) this.statusCache = { key, value: saved };
+          return saved;
+        }
+      }
+      const value = await Promise.all([...this.providers.values()].map(async (provider) => {
+        try {
+          return { ...await provider.status(forceRefresh), checkedAt: (/* @__PURE__ */ new Date()).toISOString() };
+        } 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()
+          };
+        }
+      }));
+      if (generation === this.statusGeneration) {
+        this.statusCache = { key, value };
+        this.statusInvalidated = false;
+        try {
+          await this.statusPersistence?.store.save(key, value);
+        } catch {
+        }
+      }
+      return value;
+    })();
+    this.pendingStatus = { force: forceRefresh, key, 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 +12892,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;
@@ -12574,8 +13042,8 @@ function label(harness) {
 function stripAnsi(value) {
   return value.replace(new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g"), "");
 }
-function toCodexOutputSchema(schema) {
-  return strictify(structuredClone(schema));
+function toCodexOutputSchema(schema2) {
+  return strictify(structuredClone(schema2));
 }
 function strictify(value) {
   if (!value || typeof value !== "object") return value;
@@ -12674,10 +13142,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 +13154,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 +13193,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"]);
-    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 };
-    }
-    const catalog = await this.runner.run(executable, ["debug", "models", "--bundled"]);
+    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 login2 = await runCandidate(this.runner, executable, ["login", "status"]);
+    if (login2.exitCode !== 0 || !/logged in/i.test(`${login2.stdout}
+${login2.stderr}`)) {
+      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 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 +13227,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 +13302,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 +13326,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 +13357,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 +13369,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 +13481,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,15 +13688,15 @@ 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 [auth, catalog] = await Promise.all([
-      this.runner.run(executable, ["auth", "list", "--format", "json", "--standalone"]),
-      this.runner.run(executable, ["models", "--standalone"], { timeoutMs: 3e4 })
+    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, models] = await Promise.all([
+      runCandidate(this.runner, executable, ["auth", "list", "--format", "json", "--standalone"]),
+      this.loadModels(executable)
     ]);
-    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";
@@ -13237,20 +13704,30 @@ class OpenCodeProvider {
       id: this.id,
       label: "OpenCode",
       availability: models.length > 1 ? confirmed ? "ready" : "warning" : authStatus === "unauthenticated" ? "error" : "warning",
+      ...detectionFields(detected),
       installed: true,
       authStatus,
       cliName,
       version: version2,
       models,
       checkedAt,
-      ...authStatus === "unauthenticated" ? { message: `Run ${openCodeLoginCommand(cliName)}.` } : !confirmed ? { message: "Could not confirm authentication for the selected provider." } : {}
+      ...authStatus === "unauthenticated" ? { message: `Run ${openCodeLoginCommand(cliName)}.` } : models.length === 1 ? { message: `Could not load the OpenCode model catalog. Check again or verify that ${cliName} models lists your models in a terminal.` } : !confirmed ? { message: "Could not confirm authentication for the selected provider." } : {}
     };
   }
+  async loadModels(executable) {
+    for (const args of [["models", "--standalone"], ["models"]]) {
+      try {
+        const catalog = await runCandidate(this.runner, executable, args, { timeoutMs: 3e4 });
+        const models = catalog.exitCode === 0 ? parseOpenCodeModels(catalog.stdout) : [DEFAULT_MODEL$1];
+        if (models.length > 1) return models;
+      } catch {
+      }
+    }
+    return [DEFAULT_MODEL$1];
+  }
   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 +13740,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 +13763,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 +14052,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 +14062,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 +14078,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();
@@ -14824,74 +15296,403 @@ function parseWorktrees(buffer) {
   if (current) worktrees.push(current);
   return worktrees;
 }
-const AI_PATCH_BUDGET = 4e5;
-const AI_SUMMARY_BUDGET = 24e3;
-class GitRepositoryOperations {
-  constructor(git, repositories, files) {
+const commitAuthorshipInputSchema = object({
+  name: string().trim().min(1).max(120).regex(/^[^<>]+$/).refine(noControls),
+  email: string().trim().max(254).regex(/^[^\s<>@]+@[^\s<>@]+$/).refine(noControls),
+  expectedRevision: string().regex(/^[a-f0-9]{64}$/)
+});
+function noControls(value) {
+  return [...value].every((character) => character.charCodeAt(0) >= 32 && character.charCodeAt(0) !== 127);
+}
+const environmentKeys = ["GIT_AUTHOR_NAME", "GIT_AUTHOR_EMAIL", "GIT_COMMITTER_NAME", "GIT_COMMITTER_EMAIL", "EMAIL"];
+const identityPattern = "^(user|author|committer)\\.(name|email)$";
+class GitCommitAuthorship {
+  constructor(git, repositories) {
     this.git = git;
     this.repositories = repositories;
-    this.files = files;
   }
   git;
   repositories;
-  files;
-  knownOids = /* @__PURE__ */ new Map();
-  async diff(request) {
-    const repository = this.repositories.get(request.repositoryId);
-    const paths = this.repositories.validatePaths(request.repositoryId, [request.path]);
-    const tracked = (await this.git.run(
-      repository.path,
-      ["--literal-pathspecs", "ls-files", "-z", "--", ...paths],
-      { operation: "diff-tracked-check", readOnly: true, maxOutputBytes: 1024 * 1024 }
-    )).stdout.length > 0;
-    if (request.kind === "unstaged" && !tracked) return this.untrackedDiff(request.repositoryId, request.path);
-    const args = ["--literal-pathspecs", "diff"];
-    if (request.kind === "staged") args.push("--cached");
-    args.push("--no-color", "--no-ext-diff", "--unified=3", "--", ...paths);
-    const output = await this.git.run(repository.path, args, { operation: `diff-${request.kind}`, readOnly: true, maxOutputBytes: 32 * 1024 * 1024 });
-    return makeDiffResult(request.path, output.stdout);
+  revisionKey = randomBytes(32);
+  async get(repositoryId) {
+    const repository = this.repositories.get(repositoryId);
+    return this.git.runWriteTask(repository.path, () => this.read(repositoryId), repository.commonDir);
   }
-  async commitDiff(repositoryId, oid) {
-    this.assertKnownOid(repositoryId, oid);
+  async set(repositoryId, input) {
+    const parsed = commitAuthorshipInputSchema.safeParse(input);
+    if (!parsed.success) throw invalid$1("Enter a valid name, email and reviewed identity.");
+    const { name, email: email2, expectedRevision } = parsed.data;
     const repository = this.repositories.get(repositoryId);
-    const output = await this.git.run(repository.path, ["show", "--format=", "--no-color", "--no-ext-diff", oid, "--"], { operation: "commit-diff", readOnly: true, maxOutputBytes: 32 * 1024 * 1024 });
-    return makeDiffResult(oid, output.stdout);
+    const configPath = path.join(repository.commonDir, "config");
+    const lockPath = `${configPath}.lock`;
+    return this.git.runWriteTask(repository.path, async (run) => {
+      const current = await this.read(repositoryId);
+      if (!current.editable) throw invalid$1(current.blockers.join(" "));
+      if (current.revision !== expectedRevision) throw invalid$1("Git identity or repository settings changed. Reopen the editor and review them again.");
+      let locked = false;
+      try {
+        const file = await open(lockPath, "wx", 384);
+        locked = true;
+        try {
+          await file.writeFile(await readFile(configPath));
+        } finally {
+          await file.close();
+        }
+        const reviewed = await this.read(repositoryId);
+        if (!reviewed.editable || reviewed.revision !== expectedRevision) throw invalid$1("Git settings changed before saving. Reopen the editor and review them again.");
+        const mode = (await lstat(configPath)).mode & 511;
+        await run(["config", "--file", lockPath, "--replace-all", "--", "user.name", name], { operation: "commit-authorship-set" });
+        await run(["config", "--file", lockPath, "--replace-all", "--", "user.email", email2], { operation: "commit-authorship-set" });
+        const candidate = await this.identities(repository.path, ["-c", `include.path=${lockPath}`]);
+        if (candidate.author?.name !== name || candidate.author.email !== email2 || candidate.committer?.name !== name || candidate.committer.email !== email2) {
+          throw invalid$1("An included Git setting overrides this identity. Edit that setting outside OpenTig before applying a repository identity.");
+        }
+        const latest = await this.read(repositoryId);
+        if (!latest.editable || latest.revision !== expectedRevision) throw invalid$1("Git settings changed while saving. Reopen the editor and review them again.");
+        await chmod(lockPath, mode);
+        await rename(lockPath, configPath);
+        locked = false;
+      } catch (error) {
+        if (error.code === "EEXIST") {
+          throw invalid$1("Another Git process is editing repository settings. Wait for it to finish and try again.");
+        }
+        throw error;
+      } finally {
+        if (locked) await rm(lockPath, { force: true });
+      }
+      return this.read(repositoryId);
+    }, repository.commonDir);
   }
-  async commitFiles(repositoryId, oid) {
-    this.assertKnownOid(repositoryId, oid);
+  async read(repositoryId) {
     const repository = this.repositories.get(repositoryId);
-    const common2 = ["show", "--format=", "--no-color", "--no-ext-diff", "-M", "-z"];
-    const [nameStatus, numstat] = await Promise.all([
-      this.git.run(repository.path, [...common2, "--name-status", oid, "--"], { operation: "commit-files", readOnly: true, maxOutputBytes: 8 * 1024 * 1024 }),
-      this.git.run(repository.path, [...common2, "--numstat", oid, "--"], { operation: "commit-files", readOnly: true, maxOutputBytes: 8 * 1024 * 1024 })
+    const configPath = path.join(repository.commonDir, "config");
+    const [entries, identities, config2, info] = await Promise.all([
+      this.config(repository.path),
+      this.identities(repository.path),
+      readFile(configPath),
+      lstat(configPath)
     ]);
-    return parseCommitFiles(nameStatus.stdout.toString("utf8"), numstat.stdout.toString("utf8"));
+    const environment = environmentKeys.filter((key) => process.env[key] !== void 0);
+    const custom = entries.some((entry) => entry.key.startsWith("author.") || entry.key.startsWith("committer."));
+    const worktree = entries.some((entry) => entry.scope === "worktree");
+    const command2 = entries.some((entry) => entry.scope === "command");
+    const blockers = [];
+    if (environment.length) blockers.push("Backend environment variables override Git identity. Manage them outside OpenTig before editing repository authorship.");
+    if (custom) blockers.push("Git author.* or committer.* settings override user.name/email. Manage those settings outside OpenTig first.");
+    if (worktree) blockers.push("This worktree has its own identity. Manage its worktree settings outside OpenTig first.");
+    if (command2) blockers.push("Backend command configuration overrides Git identity. Manage it outside OpenTig first.");
+    if (!info.isFile() || info.nlink !== 1) blockers.push("The repository config is linked or shared. Edit it outside OpenTig to avoid changing another repository.");
+    const scopes = ["user.name", "user.email"].map((key) => entries.filter((entry) => entry.key === key).at(-1)?.scope ?? "inferred");
+    const source = environment.length || command2 ? "environment" : custom ? "custom" : worktree ? "worktree" : !identities.author ? "unset" : scopes[0] !== scopes[1] ? "mixed" : scopes[0] === "local" || scopes[0] === "global" || scopes[0] === "system" ? scopes[0] : "inferred";
+    const revision2 = createHmac("sha256", this.revisionKey).update(repository.path).update(config2).update(JSON.stringify({ entries, identities, environment, mode: info.mode, linked: info.nlink, blockers })).digest("hex");
+    return { ...identities, source, editable: blockers.length === 0, blockers, revision: revision2 };
+  }
+  async config(cwd) {
+    try {
+      const output = await this.git.run(cwd, ["config", "--null", "--show-scope", "--get-regexp", identityPattern], { operation: "commit-authorship-read", readOnly: true });
+      const fields = output.stdout.toString("utf8").split("\0");
+      const entries = [];
+      for (let index = 0; index + 1 < fields.length; index += 2) {
+        const field = fields[index + 1];
+        const separator = field.indexOf("\n");
+        if (separator >= 0) entries.push({ scope: fields[index], key: field.slice(0, separator), value: field.slice(separator + 1) });
+      }
+      return entries;
+    } catch (error) {
+      if (error instanceof GitOperationError && error.detail.exitCode === 1) return [];
+      throw error;
+    }
   }
-  async commitFileDiff(repositoryId, oid, filePath, oldPath) {
-    this.assertKnownOid(repositoryId, oid);
-    const repository = this.repositories.get(repositoryId);
-    const paths = this.repositories.validatePaths(repositoryId, oldPath ? [filePath, oldPath] : [filePath]);
-    const output = await this.git.run(
-      repository.path,
-      ["--literal-pathspecs", "show", "--format=", "--no-color", "--no-ext-diff", "-M", oid, "--", ...paths],
-      { operation: "commit-file-diff", readOnly: true, maxOutputBytes: 32 * 1024 * 1024 }
-    );
-    return makeDiffResult(filePath, output.stdout);
+  async identities(cwd, prefix = []) {
+    const [author, committer] = await Promise.all(["GIT_AUTHOR_IDENT", "GIT_COMMITTER_IDENT"].map(async (variable) => {
+      try {
+        const output = await this.git.run(cwd, [...prefix, "var", variable], { operation: "commit-authorship-read", readOnly: true });
+        const match = /^(.*?) <([^<>]*)> \d+ [+-]\d{4}$/.exec(output.stdout.toString("utf8").trim());
+        if (!match) throw invalid$1("Git returned an unreadable commit identity.");
+        return { name: match[1], email: match[2] };
+      } catch (error) {
+        if (error instanceof GitOperationError && error.detail.exitCode === 128 && /identity unknown|unable to auto-detect|empty ident|no email was given|no name was given/i.test(error.detail.stderr ?? "")) return null;
+        throw error;
+      }
+    }));
+    return { author, committer };
   }
-  async stage(repositoryId, paths) {
-    await this.ensureWritable(repositoryId);
-    const repository = this.repositories.get(repositoryId);
-    const valid = this.repositories.validatePaths(repositoryId, paths);
-    await this.git.runWrite(repository.path, ["--literal-pathspecs", "add", "-A", "--", ...valid], { operation: "stage" });
-    return { ok: true };
+}
+function invalid$1(message) {
+  return new GitOperationError({ code: "INVALID_ARGUMENT", operation: "commit-authorship-set", message });
+}
+const read = { operation: "remote-branches", readOnly: true, maxOutputBytes: 4 * 1024 * 1024 };
+const network = { ...read, timeoutMs: 6e4 };
+class GitRemoteBranches {
+  constructor(git, repositories) {
+    this.git = git;
+    this.repositories = repositories;
   }
-  async stageAll(repositoryId) {
-    await this.ensureWritable(repositoryId);
-    const repository = this.repositories.get(repositoryId);
-    await this.git.runWrite(repository.path, ["add", "-A", "--", "."], { operation: "stage-all" });
-    return { ok: true };
+  git;
+  repositories;
+  reader(root) {
+    return (args, options) => this.git.run(root, args, options);
   }
-  async unstage(repositoryId, paths) {
+  async remotes(run) {
+    const names = (await run(["remote"], read)).stdout.toString("utf8").trim().split(/\r?\n/).filter(Boolean);
+    return Promise.all(names.map(async (name) => ({ name, refspecs: (await this.config(run, `remote.${name}.fetch`)).split(/\r?\n/).filter(Boolean) })));
+  }
+  async config(run, key) {
+    try {
+      return (await run(["config", "--get-all", key], read)).stdout.toString("utf8").trim();
+    } catch (error) {
+      if (error instanceof GitOperationError && error.detail.exitCode === 1) return "";
+      throw error;
+    }
+  }
+  mappings(fullName, remotes) {
+    return remotes.flatMap((remote) => remote.refspecs.flatMap((spec) => {
+      if (spec.startsWith("^")) return [];
+      const [source, destination] = spec.replace(/^\+/, "").split(":");
+      if (!source?.startsWith("refs/heads/") || !destination?.startsWith("refs/remotes/")) return [];
+      const match = refspecMatch(destination, fullName);
+      if (match === null) return [];
+      const sourceRef = source.replace("*", match);
+      if (remote.refspecs.some((excluded) => excluded.startsWith("^") && refspecMatch(excluded.slice(1), sourceRef) !== null)) return [];
+      return [{ remote: remote.name, sourceRef }];
+    }));
+  }
+  async snapshotBranches(repositoryId, branches) {
+    const root = this.repositories.get(repositoryId).path;
+    const run = this.reader(root);
+    const remotes = await this.remotes(run);
+    const aliases = new Set((await run(["for-each-ref", "--format=%(refname)%09%(symref)", "refs/remotes"], read)).stdout.toString("utf8").split(/\r?\n/).filter((line) => line.split("	")[1]).map((line) => line.split("	")[0]));
+    return { remotes: remotes.map((remote) => remote.name), branches: branches.filter((branch) => !aliases.has(branch.fullName)).map((branch) => {
+      if (!branch.remote) return branch;
+      const mappings = this.mappings(branch.fullName, remotes);
+      if (mappings.length !== 1) return branch;
+      return { ...branch, remoteName: mappings[0].remote, remoteBranchName: mappings[0].sourceRef.slice("refs/heads/".length) };
+    }) };
+  }
+  async target(fullName, run) {
+    const branches = parseRefs((await run(["for-each-ref", `--format=${REF_FORMAT}`, "refs/remotes"], read)).stdout);
+    const branch = branches.find((item) => item.fullName === fullName);
+    if (!branch) return null;
+    const aliases = (await run(["for-each-ref", "--format=%(refname)%09%(symref)", fullName], read)).stdout.toString("utf8").split(/\r?\n/).some((line) => line.split("	")[0] === fullName && Boolean(line.split("	")[1]));
+    const mappings = this.mappings(fullName, await this.remotes(run));
+    if (aliases || mappings.length !== 1) throw new GitOperationError({
+      code: "INVALID_ARGUMENT",
+      operation: "remote-branch",
+      message: "This reference does not map to one configured remote branch. Check the remote fetch settings."
+    });
+    return { branch, ...mappings[0], branchName: mappings[0].sourceRef.slice("refs/heads/".length) };
+  }
+  async destination(target, run) {
+    const fetchUrls = (await run(["remote", "get-url", "--all", "--", target.remote], read)).stdout.toString("utf8").trim().split(/\r?\n/);
+    const pushUrls = (await run(["remote", "get-url", "--push", "--all", "--", target.remote], read)).stdout.toString("utf8").trim().split(/\r?\n/);
+    const id = createHash("sha256").update(JSON.stringify([target.remote, target.sourceRef, fetchUrls, pushUrls])).digest("hex");
+    const blocked = fetchUrls.length !== 1 || pushUrls.length !== 1 || fetchUrls[0] !== pushUrls[0] ? "Fetch and push destinations differ or have multiple URLs. Manage remote deletion outside OpenTig." : null;
+    return { id, blocked, url: fetchUrls[0] };
+  }
+  async advertised(target, run, url) {
+    const lines = (await run(["ls-remote", "--symref", "--", url, "HEAD", target.sourceRef], network)).stdout.toString("utf8").split(/\r?\n/);
+    const defaultRef = lines.find((line) => line.startsWith("ref: refs/heads/") && line.endsWith("	HEAD"))?.split("	")[0]?.slice(5) ?? null;
+    const oid = lines.find((line) => line.split("	")[1] === target.sourceRef)?.split("	")[0] ?? null;
+    return { defaultRef, oid };
+  }
+  async details(repositoryId, fullName) {
+    const run = this.reader(this.repositories.get(repositoryId).path);
+    const target = await this.target(fullName, run);
+    if (!target) throw new GitOperationError({ code: "INVALID_ARGUMENT", operation: "remote-branch-details", message: "The remote reference no longer exists. Fetch branches again." });
+    const destination = await this.destination(target, run);
+    let blocked = destination.blocked;
+    let defaultRef = null;
+    let remoteState = "unchecked";
+    if (!blocked) {
+      try {
+        const state = await this.advertised(target, run, destination.url);
+        defaultRef = state.defaultRef;
+        remoteState = !state.oid ? "missing" : state.oid === target.branch.oid ? "current" : "changed";
+        blocked = !state.oid ? "The branch no longer exists on the remote. Fetch to remove the obsolete reference." : state.oid !== target.branch.oid ? "The remote branch changed since the last fetch. Fetch before deleting." : !state.defaultRef ? "The remote does not identify its default branch. Deletion is unavailable here." : state.defaultRef === target.sourceRef ? "This is the remote’s default branch and cannot be deleted here." : null;
+      } catch {
+        blocked = "Could not check the remote. Fetch again or check your connection and Git permissions.";
+      }
+    }
+    const upstreams = (await run(["for-each-ref", "--format=%(refname)%00%(refname:short)%00%(upstream)%00%(worktreepath)", "refs/heads"], read)).stdout.toString("utf8");
+    const localBranches = upstreams.split(/\r?\n/).map((line) => line.split("\0")).filter((fields) => fields[2] === fullName).map(([ref, name, , worktreePath]) => ({ fullName: ref, name, worktreePath: worktreePath || null }));
+    return {
+      ...target.branch,
+      remote: target.remote,
+      branchName: target.branchName,
+      localBranches,
+      defaultBranch: defaultRef?.slice("refs/heads/".length) ?? null,
+      remoteState,
+      destinationId: destination.id,
+      deletionBlockedReason: blocked
+    };
+  }
+  async create(request) {
+    const repository = this.repositories.get(request.repositoryId);
+    return this.git.runWriteTask(repository.path, async (run) => {
+      const target = await this.target(request.fullName, run);
+      if (!target) return { status: "missing" };
+      if (target.branch.oid !== request.expectedOid) return { status: "stale" };
+      if (request.localName.startsWith("-")) throw new GitOperationError({ code: "INVALID_ARGUMENT", operation: "create-tracking-branch", message: "Invalid local branch name." });
+      await run(["check-ref-format", `refs/heads/${request.localName}`], read);
+      const localRef = `refs/heads/${request.localName}`;
+      const existing = (await run(["for-each-ref", "--format=%(refname)", "refs/heads"], read)).stdout.toString("utf8").trim().split(/\r?\n/);
+      if (existing.includes(localRef)) return { status: "exists" };
+      await run(["branch", "--track", "--", request.localName, target.branch.fullName], { operation: "create-tracking-branch" });
+      return { status: "created", fullName: localRef };
+    }, repository.commonDir);
+  }
+  async delete(request) {
+    const repository = this.repositories.get(request.repositoryId);
+    return this.git.runWriteTask(repository.path, async (run) => {
+      const target = await this.target(request.fullName, run);
+      if (!target) return { status: "missing" };
+      if (target.branch.oid !== request.expectedOid) return { status: "stale" };
+      const destination = await this.destination(target, run);
+      if (destination.id !== request.destinationId) return { status: "destination-changed" };
+      if (destination.blocked) return { status: "rejected", message: destination.blocked };
+      try {
+        const state = await this.advertised(target, run, destination.url);
+        if (!state.oid) return { status: "missing" };
+        if (!state.defaultRef) return { status: "rejected", message: "Could not identify the remote default branch. Nothing was deleted." };
+        if (state.defaultRef === target.sourceRef) return { status: "default" };
+        if (state.oid !== request.expectedOid) return { status: "stale" };
+        await run(
+          [
+            "-c",
+            `remote.${target.remote}.mirror=false`,
+            "push",
+            "--porcelain",
+            "--no-follow-tags",
+            `--force-with-lease=${target.sourceRef}:${request.expectedOid}`,
+            "--",
+            destination.url,
+            `:${target.sourceRef}`
+          ],
+          { operation: "delete-remote-branch", timeoutMs: 12e4, maxOutputBytes: 4 * 1024 * 1024 }
+        );
+        return { status: "deleted" };
+      } catch {
+        return { status: "rejected", message: "Git refused the remote deletion. Check permissions or branch protection, fetch, and try again. No local branch or worktree was removed." };
+      }
+    }, repository.commonDir);
+  }
+  async fetch(repositoryId) {
+    const repository = this.repositories.get(repositoryId);
+    try {
+      await this.git.runWriteTask(repository.path, async (run) => {
+        for (const remote of await this.remotes(run)) {
+          const specs = remote.refspecs.filter((spec) => spec.startsWith("^refs/heads/") || /^\+?refs\/heads\/[^:]+:refs\/remotes\//.test(spec));
+          if (!specs.some((spec) => !spec.startsWith("^"))) continue;
+          await run(
+            ["-c", "fetch.pruneTags=false", "fetch", "--prune", "--no-prune-tags", "--no-tags", "--no-recurse-submodules", "--", remote.name, ...specs],
+            { operation: "fetch-branches", timeoutMs: 12e4, maxOutputBytes: 4 * 1024 * 1024 }
+          );
+        }
+      }, repository.commonDir);
+    } catch {
+      return { status: "failed", message: "Could not fetch all remote branches. Check your connection and Git credentials, then fetch again." };
+    }
+    const status = await this.repositories.status(repositoryId, false);
+    return { status: "success", ahead: status.ahead, behind: status.behind };
+  }
+}
+function refspecMatch(pattern, ref) {
+  const star = pattern.indexOf("*");
+  if (star < 0) return pattern === ref ? "" : null;
+  const prefix = pattern.slice(0, star);
+  const suffix = pattern.slice(star + 1);
+  return ref.startsWith(prefix) && ref.endsWith(suffix) && ref.length >= prefix.length + suffix.length ? ref.slice(prefix.length, suffix ? -suffix.length : void 0) : null;
+}
+const AI_PATCH_BUDGET = 4e5;
+const AI_SUMMARY_BUDGET = 24e3;
+class GitRepositoryOperations {
+  constructor(git, repositories, files) {
+    this.git = git;
+    this.repositories = repositories;
+    this.files = files;
+    this.authorship = new GitCommitAuthorship(git, repositories);
+    this.remoteBranches = new GitRemoteBranches(git, repositories);
+  }
+  git;
+  repositories;
+  files;
+  knownOids = /* @__PURE__ */ new Map();
+  authorship;
+  remoteBranches;
+  remoteBranchDetails(repositoryId, fullName) {
+    return this.remoteBranches.details(repositoryId, fullName);
+  }
+  createTrackingBranch(request) {
+    return this.remoteBranches.create(request);
+  }
+  deleteRemoteBranch(request) {
+    return this.remoteBranches.delete(request);
+  }
+  fetchBranches(repositoryId) {
+    return this.remoteBranches.fetch(repositoryId);
+  }
+  getCommitAuthorship(repositoryId) {
+    return this.authorship.get(repositoryId);
+  }
+  setCommitAuthorship(repositoryId, input) {
+    return this.authorship.set(repositoryId, input);
+  }
+  async diff(request) {
+    const repository = this.repositories.get(request.repositoryId);
+    const paths = this.repositories.validatePaths(request.repositoryId, [request.path]);
+    const tracked = (await this.git.run(
+      repository.path,
+      ["--literal-pathspecs", "ls-files", "-z", "--", ...paths],
+      { operation: "diff-tracked-check", readOnly: true, maxOutputBytes: 1024 * 1024 }
+    )).stdout.length > 0;
+    if (request.kind === "unstaged" && !tracked) return this.untrackedDiff(request.repositoryId, request.path);
+    const args = ["--literal-pathspecs", "diff"];
+    if (request.kind === "staged") args.push("--cached");
+    args.push("--no-color", "--no-ext-diff", "--unified=3", "--", ...paths);
+    const output = await this.git.run(repository.path, args, { operation: `diff-${request.kind}`, readOnly: true, maxOutputBytes: 32 * 1024 * 1024 });
+    return makeDiffResult(request.path, output.stdout);
+  }
+  async commitDiff(repositoryId, oid) {
+    this.assertKnownOid(repositoryId, oid);
+    const repository = this.repositories.get(repositoryId);
+    const output = await this.git.run(repository.path, ["show", "--format=", "--no-color", "--no-ext-diff", oid, "--"], { operation: "commit-diff", readOnly: true, maxOutputBytes: 32 * 1024 * 1024 });
+    return makeDiffResult(oid, output.stdout);
+  }
+  async commitFiles(repositoryId, oid) {
+    this.assertKnownOid(repositoryId, oid);
+    const repository = this.repositories.get(repositoryId);
+    const common2 = ["show", "--format=", "--no-color", "--no-ext-diff", "-M", "-z"];
+    const [nameStatus, numstat] = await Promise.all([
+      this.git.run(repository.path, [...common2, "--name-status", oid, "--"], { operation: "commit-files", readOnly: true, maxOutputBytes: 8 * 1024 * 1024 }),
+      this.git.run(repository.path, [...common2, "--numstat", oid, "--"], { operation: "commit-files", readOnly: true, maxOutputBytes: 8 * 1024 * 1024 })
+    ]);
+    return parseCommitFiles(nameStatus.stdout.toString("utf8"), numstat.stdout.toString("utf8"));
+  }
+  async commitFileDiff(repositoryId, oid, filePath, oldPath) {
+    this.assertKnownOid(repositoryId, oid);
+    const repository = this.repositories.get(repositoryId);
+    const paths = this.repositories.validatePaths(repositoryId, oldPath ? [filePath, oldPath] : [filePath]);
+    const output = await this.git.run(
+      repository.path,
+      ["--literal-pathspecs", "show", "--format=", "--no-color", "--no-ext-diff", "-M", oid, "--", ...paths],
+      { operation: "commit-file-diff", readOnly: true, maxOutputBytes: 32 * 1024 * 1024 }
+    );
+    return makeDiffResult(filePath, output.stdout);
+  }
+  async stage(repositoryId, paths) {
+    await this.ensureWritable(repositoryId);
+    const repository = this.repositories.get(repositoryId);
+    const valid = this.repositories.validatePaths(repositoryId, paths);
+    await this.git.runWrite(repository.path, ["--literal-pathspecs", "add", "-A", "--", ...valid], { operation: "stage" });
+    return { ok: true };
+  }
+  async stageAll(repositoryId) {
+    await this.ensureWritable(repositoryId);
+    const repository = this.repositories.get(repositoryId);
+    await this.git.runWrite(repository.path, ["add", "-A", "--", "."], { operation: "stage-all" });
+    return { ok: true };
+  }
+  async unstage(repositoryId, paths) {
     await this.ensureWritable(repositoryId);
     const repository = this.repositories.get(repositoryId);
     const valid = this.repositories.validatePaths(repositoryId, paths);
@@ -15420,15 +16221,16 @@ ${base}
     return this.repositories.openPath(worktree.path);
   }
   /**
-   * Cheap enumeration for the local refs manager. Deliberately runs no status
+   * Cheap enumeration for the refs manager. Deliberately runs no status
    * scan per worktree so ordinary refreshes stay as fast as the selectors.
    */
   async localRefsSnapshot(repositoryId) {
     const repository = this.repositories.get(repositoryId);
     const [branches, worktrees] = await Promise.all([this.branches(repositoryId), this.worktrees(repositoryId)]);
-    const locals = branches.filter((branch) => !branch.remote).sort(compareBranches);
+    const managed = await this.remoteBranches.snapshotBranches(repositoryId, branches);
     return {
-      branches: locals,
+      branches: managed.branches.sort(compareBranches),
+      remotes: managed.remotes,
       worktrees: await Promise.all(worktrees.map(async (worktree) => ({ ...worktree, current: await samePath(worktree.path, repository.path) })))
     };
   }
@@ -16376,6 +17178,421 @@ function revision(bytes) {
 function invalidReplacement(message) {
   return new GitOperationError({ code: "INVALID_ARGUMENT", operation: "replace-search", message });
 }
+const githubAccountSelectionSchema = discriminatedUnion("mode", [
+  object({ mode: literal("auto") }),
+  object({ mode: literal("account"), host: literal("github.com"), login: string().regex(/^[A-Za-z0-9](?:[A-Za-z0-9-]{0,37}[A-Za-z0-9])?$/) })
+]);
+const AUTOMATIC_GITHUB_ACCOUNT = { mode: "auto" };
+function githubRepositoryKey(commonDir, platform2 = process.platform) {
+  const key = commonDir.replace(/\\/g, "/").replace(/\/+$/, "");
+  return platform2 === "win32" ? key.toLowerCase() : key;
+}
+const OWNER_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?$/;
+const REPO_PATTERN = /^[A-Za-z0-9._-]+$/;
+function parseGitHubRemote(url) {
+  const trimmed = url.trim();
+  if (!trimmed) return null;
+  let rest = null;
+  const https = /^https?:\/\/(?:[^@/\s]+@)?github\.com\/(.+)$/i.exec(trimmed);
+  const ssh = /^ssh:\/\/(?:[^@/\s]+@)?github\.com(?::\d+)?\/(.+)$/i.exec(trimmed);
+  const scp = /^(?:[^@\s]+)@github\.com:(.+)$/i.exec(trimmed);
+  const git = /^git:\/\/github\.com\/(.+)$/i.exec(trimmed);
+  if (https) rest = https[1] ?? null;
+  else if (ssh) rest = ssh[1] ?? null;
+  else if (scp) rest = scp[1] ?? null;
+  else if (git) rest = git[1] ?? null;
+  if (!rest) return null;
+  const segments = rest.replace(/\/+$/, "").split("/");
+  if (segments.length !== 2) return null;
+  const owner = segments[0] ?? "";
+  const repo = (segments[1] ?? "").replace(/\.git$/i, "");
+  if (!OWNER_PATTERN.test(owner) || !repo || repo === "." || repo === ".." || !REPO_PATTERN.test(repo)) return null;
+  return { nameWithOwner: `${owner}/${repo}` };
+}
+function parseSshRemote(url) {
+  const trimmed = url.trim();
+  const ssh = /^ssh:\/\/(?:(\w[\w.-]*)@)?([A-Za-z0-9][A-Za-z0-9._-]*)(?::(\d+))?\/(.+)$/i.exec(trimmed);
+  const scp = /^(?:(\w[\w.-]*)@)?([A-Za-z0-9][A-Za-z0-9._-]*):(.+)$/.exec(trimmed);
+  const match = ssh ?? scp;
+  if (!match) return null;
+  const parsed = parseGitHubRemote(`https://github.com/${ssh ? match[4] : match[3]}`);
+  if (!parsed) return null;
+  return { destination: `${match[1] ? `${match[1]}@` : ""}${match[2]}`, port: ssh ? match[3] ?? null : null, ...parsed };
+}
+const GITHUB_LOGIN = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,37}[A-Za-z0-9])?$/;
+function parseGitHubAuthStatus(raw) {
+  const input = JSON.parse(raw);
+  if (!input || typeof input !== "object" || !("hosts" in input) || !input.hosts || typeof input.hosts !== "object") throw new Error("Invalid gh status");
+  const entries = input.hosts["github.com"] ?? [];
+  if (!Array.isArray(entries) || entries.length > 100) throw new Error("Invalid gh accounts");
+  const accounts = [];
+  for (const entry of entries) {
+    if (!entry || typeof entry !== "object" || typeof entry.login !== "string" || !GITHUB_LOGIN.test(entry.login)) continue;
+    accounts.push({
+      host: "github.com",
+      login: entry.login,
+      active: entry.active === true,
+      state: entry.state === "success" ? "authenticated" : entry.state === "error" ? "invalid" : "unknown",
+      storage: entry.tokenSource === "keyring" ? "keyring" : typeof entry.tokenSource === "string" && (entry.tokenSource === "oauth_token" || /(?:^|[/\\])hosts\.yml$/.test(entry.tokenSource)) ? "file" : "unknown",
+      ...typeof entry.scopes === "string" && /^[A-Za-z0-9_:, -]{0,500}$/.test(entry.scopes) ? { scopes: entry.scopes } : {}
+    });
+  }
+  return { accounts, activeLogin: accounts.find((account) => account.active)?.login ?? null };
+}
+const GH_ENV = { GH_HOST: "github.com", GH_PROMPT_DISABLED: "1", GH_NO_UPDATE_NOTIFIER: "1", GH_PAGER: "cat", NO_COLOR: "1" };
+const GH_PRIVATE_ENV = ["GITHUB_TOKEN", "GH_DEBUG", "DEBUG"];
+async function identifySshAccount(remote, runner) {
+  const ssh = parseSshRemote(remote);
+  if (!ssh) return null;
+  try {
+    const config2 = await runner.run("ssh", ["-G", ...ssh.port ? ["-p", ssh.port] : [], "--", ssh.destination], {
+      cwd: os.homedir(),
+      timeoutMs: 5e3,
+      maxOutputBytes: 64 * 1024
+    });
+    const hostname = config2.stdout.split(/\r?\n/).find((line) => /^hostname\s/i.test(line))?.trim().split(/\s+/)[1];
+    if (config2.exitCode !== 0 || hostname?.toLowerCase() !== "github.com") return null;
+    const result = await runner.run("ssh", [
+      "-T",
+      "-o",
+      "BatchMode=yes",
+      "-o",
+      "StrictHostKeyChecking=yes",
+      "-o",
+      "ConnectTimeout=5",
+      "-o",
+      "ConnectionAttempts=1",
+      "-o",
+      "RemoteCommand=none",
+      "-o",
+      "UpdateHostKeys=no",
+      ...ssh.port ? ["-p", ssh.port] : [],
+      "--",
+      ssh.destination
+    ], { cwd: os.homedir(), timeoutMs: 1e4, maxOutputBytes: 64 * 1024 });
+    if (result.exitCode !== 0 && result.exitCode !== 1) return null;
+    const login2 = /^Hi ([A-Za-z0-9-]+)! You've successfully authenticated, but GitHub does not provide shell access\.\s*$/m.exec(`${result.stdout}
+${result.stderr}`)?.[1];
+    return login2 && GITHUB_LOGIN.test(login2) ? login2 : null;
+  } catch {
+    return null;
+  }
+}
+async function accountAuthentication(login2, executable, runner, operation) {
+  try {
+    const result = await runner.run(executable.executable, ["auth", "token", "--hostname", "github.com", ...login2 ? ["--user", login2] : []], {
+      cwd: os.homedir(),
+      env: { ...executable.env, ...GH_ENV },
+      removeEnv: login2 ? ["GH_TOKEN", ...GH_PRIVATE_ENV] : ["GH_DEBUG", "DEBUG"],
+      timeoutMs: 1e4,
+      maxOutputBytes: 8 * 1024
+    });
+    const token = result.stdout.trim();
+    if (result.exitCode === 0 && /^[A-Za-z0-9_]{20,4096}$/.test(token)) return { env: { GH_TOKEN: token }, removeEnv: GH_PRIVATE_ENV };
+    if (/unknown flag.*user/i.test(result.stderr)) throw new GhOperationError({
+      code: "GH_CLI_INCOMPATIBLE",
+      operation,
+      message: "Update GitHub CLI to a version supporting multiple accounts and auth token --user."
+    });
+  } catch (error) {
+    if (error instanceof GhOperationError) throw error;
+  }
+  throw new GhOperationError({
+    code: login2 ? "GH_ACCOUNT_MISSING" : "GH_AUTH_REQUIRED",
+    operation,
+    message: login2 ? `GitHub CLI has no usable saved credentials for @${login2}. Sign in as ${login2} on the backend host and check Settings → GitHub again. SSH and GitHub CLI authentication are separate.` : "GitHub CLI has no usable credentials. Sign in on the backend host and check Settings → GitHub again."
+  });
+}
+function redactCommandToken(value, auth) {
+  const token = auth.env?.GH_TOKEN;
+  return token ? value.split(token).join("[redacted]") : value;
+}
+const CACHE_MS = 6e4;
+const emptyStatus = () => ({
+  installationStatus: "unchecked",
+  accounts: [],
+  activeLogin: null,
+  environment: { present: false, login: null, state: "unknown" },
+  checkedAt: null
+});
+class GitHubAccountsService {
+  constructor(resolver, runner, git, settings, store, changed = () => void 0) {
+    this.resolver = resolver;
+    this.runner = runner;
+    this.git = git;
+    this.settings = settings;
+    this.store = store;
+    this.changed = changed;
+  }
+  resolver;
+  runner;
+  git;
+  settings;
+  store;
+  changed;
+  inventory = null;
+  loading = null;
+  checking = null;
+  detection = null;
+  revision = 0;
+  get authRevision() {
+    return this.revision;
+  }
+  contexts = /* @__PURE__ */ new Map();
+  ssh = /* @__PURE__ */ new Map();
+  identities = /* @__PURE__ */ new Map();
+  status(force = false) {
+    if (force) {
+      this.checking ??= this.check().finally(() => {
+        this.checking = null;
+      });
+      return this.checking.then((value) => structuredClone(value));
+    }
+    this.loading ??= (async () => {
+      this.inventory ??= await this.store?.load() ?? emptyStatus();
+      return this.inventory;
+    })();
+    return this.loading.then(() => structuredClone(this.inventory ?? emptyStatus()));
+  }
+  selection(repository) {
+    return this.settings?.githubAccount(repository.commonDir) ?? { ...AUTOMATIC_GITHUB_ACCOUNT };
+  }
+  context(repository, remote, nameWithOwner) {
+    const cached2 = this.contexts.get(repository.id);
+    if (cached2?.remote === remote && cached2.value.revision === this.revision) return structuredClone(cached2.value);
+    const selection = this.selection(repository);
+    return {
+      selection,
+      nameWithOwner,
+      login: selection.mode === "account" ? selection.login : null,
+      source: selection.mode === "account" ? "explicit" : null,
+      state: "unchecked",
+      checkedAt: null,
+      revision: this.revision
+    };
+  }
+  async setSelection(repository, selection) {
+    if (!this.settings) throw new Error("GitHub account settings are unavailable.");
+    await this.settings.setGitHubAccount(repository.commonDir, selection);
+    this.invalidate();
+  }
+  invalidate() {
+    this.revision++;
+    this.contexts.clear();
+    this.ssh.clear();
+    this.identities.clear();
+    this.changed();
+  }
+  refreshAuthentication() {
+    this.ssh.clear();
+    this.identities.clear();
+  }
+  async detect(force = false) {
+    if (force || !this.detection || Date.now() - this.detection.at > CACHE_MS) {
+      this.detection = { at: Date.now(), promise: selectCli(this.resolver, this.runner, "gh", {
+        forceRefresh: force,
+        runOptions: { cwd: os.homedir(), env: { ...GH_ENV }, removeEnv: ["GH_DEBUG", "DEBUG"] }
+      }) };
+    }
+    return this.detection.promise;
+  }
+  async authenticate(repository, remote, nameWithOwner, operation) {
+    const revision2 = this.revision;
+    const selection = this.selection(repository);
+    let login2 = selection.mode === "account" ? selection.login : null;
+    let source = selection.mode === "account" ? "explicit" : null;
+    try {
+      const detection = await this.detect();
+      if (detection.state !== "available" || !detection.candidate) throw new GhOperationError({
+        code: detection.state === "not-found" ? "GH_CLI_NOT_FOUND" : "GH_PROCESS_FAILED",
+        operation,
+        message: detection.state === "not-found" ? "GitHub CLI is not installed on the backend host." : "GitHub CLI could not run. Check Settings → GitHub."
+      });
+      const executable = detection.candidate;
+      if (selection.mode === "auto" && parseSshRemote(remote)) {
+        const override = executable.env.GIT_SSH_COMMAND || executable.env.GIT_SSH || process.env.GIT_SSH_COMMAND || process.env.GIT_SSH;
+        const configured = await this.git.run(repository.path, ["config", "--default", "", "--get", "core.sshCommand"], {
+          operation: "github-ssh-configuration",
+          readOnly: true,
+          maxOutputBytes: 8 * 1024
+        });
+        if (override || configured.stdout.toString("utf8").trim()) throw new GhOperationError({
+          code: "GH_ACCOUNT_UNRESOLVED",
+          operation,
+          message: "This repository uses a custom SSH command. Choose an explicit account in Settings → GitHub."
+        });
+        const key = `${repository.path}\0${remote}`;
+        let cached2 = this.ssh.get(key);
+        if (!cached2 || Date.now() - cached2.at > CACHE_MS) {
+          cached2 = { at: Date.now(), promise: identifySshAccount(remote, this.runner) };
+          this.ssh.set(key, cached2);
+        }
+        login2 = await cached2.promise;
+        source = "ssh";
+        if (!login2) throw new GhOperationError({
+          code: "GH_ACCOUNT_UNRESOLVED",
+          operation,
+          message: "SSH could not verify a GitHub user account. Check again or choose an explicit account in Settings → GitHub. Deploy keys do not identify user accounts."
+        });
+      }
+      if (!source) source = executable.env.GH_TOKEN || executable.env.GITHUB_TOKEN || process.env.GH_TOKEN || process.env.GITHUB_TOKEN ? "environment" : "global";
+      const auth = await accountAuthentication(login2, executable, this.runner, operation);
+      const verified = await this.identity(executable, auth, operation);
+      if (login2 && login2.toLowerCase() !== verified.toLowerCase()) throw new GhOperationError({
+        code: "GH_AUTH_REQUIRED",
+        operation,
+        message: `The saved credentials for @${login2} authenticate a different account. Authenticate @${login2} again and check Settings → GitHub.`
+      });
+      login2 = verified;
+      const context = { selection, nameWithOwner, login: login2, source, state: "ready", checkedAt: (/* @__PURE__ */ new Date()).toISOString(), revision: revision2 };
+      if (revision2 === this.revision) {
+        const previous = this.contexts.get(repository.id)?.value;
+        if (previous?.state === "ready" && (previous.login?.toLowerCase() !== login2.toLowerCase() || previous.source !== source)) {
+          this.invalidate();
+          context.revision = this.revision;
+        }
+        this.contexts.set(repository.id, { remote, value: context });
+      }
+      return { auth, executable, context };
+    } catch (error) {
+      const message = error instanceof GhOperationError ? error.message : "Could not inspect GitHub authentication. Check Settings → GitHub again.";
+      if (revision2 === this.revision) this.contexts.set(repository.id, { remote, value: {
+        selection,
+        nameWithOwner,
+        login: login2,
+        source,
+        state: "error",
+        checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        message,
+        revision: revision2
+      } });
+      if (error instanceof GhOperationError) throw error;
+      throw new GhOperationError({ code: "GH_PROCESS_FAILED", operation, message, retryable: true });
+    }
+  }
+  identity(executable, auth, operation) {
+    const fingerprint = createHash("sha256").update(auth.env?.GH_TOKEN ?? "").digest("hex");
+    let cached2 = this.identities.get(fingerprint);
+    if (!cached2 || Date.now() - cached2.at > CACHE_MS) {
+      const promise = (async () => {
+        const result = await this.runner.run(executable.executable, ["api", "user", "--jq", ".login"], {
+          cwd: os.homedir(),
+          env: { ...executable.env, ...GH_ENV, ...auth.env },
+          ...auth.removeEnv ? { removeEnv: auth.removeEnv } : {},
+          timeoutMs: 15e3,
+          maxOutputBytes: 8 * 1024
+        });
+        const login2 = result.stdout.trim();
+        if (result.exitCode === 0 && GITHUB_LOGIN.test(login2)) return login2;
+        const invalid2 = /401|bad credentials|requires authentication/i.test(result.stderr);
+        throw new GhOperationError({
+          code: invalid2 ? "GH_AUTH_REQUIRED" : "GH_PROCESS_FAILED",
+          operation,
+          message: invalid2 ? "GitHub rejected these credentials. They may be expired or revoked. Authenticate this account again and check Settings → GitHub." : "Could not verify this GitHub account. Check your connection and try again.",
+          retryable: !invalid2
+        });
+      })();
+      cached2 = { at: Date.now(), promise };
+      this.identities.set(fingerprint, cached2);
+      void promise.catch(() => {
+        if (this.identities.get(fingerprint)?.promise === promise) this.identities.delete(fingerprint);
+      });
+    }
+    return cached2.promise;
+  }
+  async check() {
+    await this.status();
+    this.refreshAuthentication();
+    const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const detection = await this.detect(true);
+    const result = {
+      ...emptyStatus(),
+      installationStatus: detection.state,
+      checkedAt,
+      ...detection.version ? { version: detection.version } : {}
+    };
+    if (detection.state === "available" && detection.candidate) {
+      const executable = detection.candidate;
+      try {
+        const status = await this.runner.run(executable.executable, ["auth", "status", "--hostname", "github.com", "--json", "hosts"], {
+          cwd: os.homedir(),
+          env: { ...executable.env, ...GH_ENV },
+          removeEnv: ["GH_TOKEN", ...GH_PRIVATE_ENV],
+          timeoutMs: 6e4,
+          maxOutputBytes: 256 * 1024
+        });
+        if (status.exitCode !== 0) {
+          if (/unknown flag.*json/i.test(status.stderr)) result.installationStatus = "incompatible";
+          throw new Error("Status failed");
+        }
+        Object.assign(result, parseGitHubAuthStatus(status.stdout));
+        const envToken = executable.env.GH_TOKEN || executable.env.GITHUB_TOKEN || process.env.GH_TOKEN || process.env.GITHUB_TOKEN;
+        if (envToken) {
+          result.environment.present = true;
+          try {
+            const auth = await accountAuthentication(null, executable, this.runner, "gh-auth-status");
+            result.environment.login = await this.identity(executable, auth, "gh-auth-status");
+            result.environment.state = "authenticated";
+          } catch (error) {
+            result.environment.state = error instanceof GhOperationError && error.detail.code === "GH_AUTH_REQUIRED" ? "invalid" : "unknown";
+          }
+        }
+      } catch {
+        result.message = result.installationStatus === "incompatible" ? "Update GitHub CLI to a version supporting auth status --json and multiple accounts." : "Could not check the saved GitHub accounts. Check your connection and CLI configuration, then try again.";
+        result.accounts = this.inventory?.accounts.map((account) => ({ ...account, state: "unknown" })) ?? [];
+        result.activeLogin = this.inventory?.activeLogin ?? null;
+      }
+    } else result.message = detection.state === "not-found" ? "Install GitHub CLI on the backend host." : "GitHub CLI was found but could not run. Check its installation and dependencies.";
+    this.inventory = result;
+    try {
+      await this.store?.save(result);
+    } finally {
+      this.invalidate();
+    }
+    return result;
+  }
+}
+const authState = _enum(["authenticated", "invalid", "unknown"]);
+const login = string().regex(/^[A-Za-z0-9](?:[A-Za-z0-9-]{0,37}[A-Za-z0-9])?$/);
+const schema = object({
+  installationStatus: _enum(["unchecked", "available", "not-found", "not-executable", "incompatible", "inspection-failed"]),
+  version: string().max(200).optional(),
+  accounts: array(object({
+    host: literal("github.com"),
+    login,
+    active: boolean(),
+    state: authState,
+    storage: _enum(["keyring", "file", "unknown"]),
+    scopes: string().max(500).optional()
+  })).max(100),
+  activeLogin: login.nullable(),
+  environment: object({ present: boolean(), login: login.nullable(), state: authState }),
+  checkedAt: string().datetime().nullable(),
+  message: string().max(500).optional()
+});
+class GitHubStatusStore {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  filePath;
+  pending = Promise.resolve();
+  async load() {
+    await this.pending;
+    try {
+      if ((await stat(this.filePath)).size > 256 * 1024) return null;
+      const parsed = schema.safeParse(JSON.parse(await readFile(this.filePath, "utf8")));
+      return parsed.success ? parsed.data : null;
+    } catch {
+      return null;
+    }
+  }
+  save(value) {
+    const snapshot = JSON.stringify(schema.parse(value));
+    const write = this.pending.then(() => writeFileAtomically(this.filePath, snapshot, { parseJson: true }));
+    this.pending = write.catch(() => void 0);
+    return write;
+  }
+}
 const positive = number().int().positive().safe();
 const membershipSchema = object({
   stack: object({ number: positive, size: positive, baseRefName: string().min(1) }).nullable(),
@@ -16443,28 +17660,6 @@ function parsePullRequestStack(raw, prNumber, listing = false) {
     }))
   };
 }
-const OWNER_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?$/;
-const REPO_PATTERN = /^[A-Za-z0-9._-]+$/;
-function parseGitHubRemote(url) {
-  const trimmed = url.trim();
-  if (!trimmed) return null;
-  let rest = null;
-  const https = /^https?:\/\/(?:[^@/\s]+@)?github\.com\/(.+)$/i.exec(trimmed);
-  const ssh = /^ssh:\/\/(?:[^@/\s]+@)?github\.com(?::\d+)?\/(.+)$/i.exec(trimmed);
-  const scp = /^(?:[^@\s]+)@github\.com:(.+)$/i.exec(trimmed);
-  const git = /^git:\/\/github\.com\/(.+)$/i.exec(trimmed);
-  if (https) rest = https[1] ?? null;
-  else if (ssh) rest = ssh[1] ?? null;
-  else if (scp) rest = scp[1] ?? null;
-  else if (git) rest = git[1] ?? null;
-  if (!rest) return null;
-  const segments = rest.replace(/\/+$/, "").split("/");
-  if (segments.length !== 2) return null;
-  const owner = segments[0] ?? "";
-  const repo = (segments[1] ?? "").replace(/\.git$/i, "");
-  if (!OWNER_PATTERN.test(owner) || !repo || repo === "." || repo === ".." || !REPO_PATTERN.test(repo)) return null;
-  return { nameWithOwner: `${owner}/${repo}` };
-}
 const PR_SUMMARY_FIELDS = "number,title,state,isDraft,author,headRefName,baseRefName,updatedAt,url,reviewDecision,additions,deletions,statusCheckRollup";
 const PR_DETAIL_FIELDS = `${PR_SUMMARY_FIELDS},body,changedFiles,labels,commits`;
 const tolerantRecordSchema = looseObject({});
@@ -16560,14 +17755,14 @@ function parseCommits(value) {
     if (typeof record2.oid !== "string" || !record2.oid) return [];
     const authors = Array.isArray(record2.authors) ? record2.authors : [];
     const authorRecord = authors.map((author) => tolerantRecordSchema.safeParse(author)).find((author) => author.success)?.data;
-    const login = typeof authorRecord?.login === "string" ? authorRecord.login : null;
-    const name = typeof authorRecord?.name === "string" && authorRecord.name ? authorRecord.name : login ?? "unknown";
+    const login2 = typeof authorRecord?.login === "string" ? authorRecord.login : null;
+    const name = typeof authorRecord?.name === "string" && authorRecord.name ? authorRecord.name : login2 ?? "unknown";
     return [{
       oid: record2.oid,
       messageHeadline: typeof record2.messageHeadline === "string" ? record2.messageHeadline : "",
       authoredAt: typeof record2.authoredDate === "string" ? record2.authoredDate : "",
       author: name,
-      authorAvatarUrl: login ? avatarUrl(login, login.endsWith("[bot]")) : null
+      authorAvatarUrl: login2 ? avatarUrl(login2, login2.endsWith("[bot]")) : null
     }];
   });
 }
@@ -16586,11 +17781,11 @@ function parseChecksState(value) {
   }
   return pending ? "PENDING" : "PASSING";
 }
-function avatarUrl(login, isBot) {
-  if (!login || login === "unknown") return null;
-  if (login === "app/dependabot" || login === "dependabot[bot]") return "https://avatars.githubusercontent.com/in/29110?s=40&v=4";
-  const botName = login.startsWith("app/") ? login.slice(4) : login.replace(/\[bot\]$/i, "");
-  const path2 = isBot || login.startsWith("app/") ? botName : login;
+function avatarUrl(login2, isBot) {
+  if (!login2 || login2 === "unknown") return null;
+  if (login2 === "app/dependabot" || login2 === "dependabot[bot]") return "https://avatars.githubusercontent.com/in/29110?s=40&v=4";
+  const botName = login2.startsWith("app/") ? login2.slice(4) : login2.replace(/\[bot\]$/i, "");
+  const path2 = isBot || login2.startsWith("app/") ? botName : login2;
   return `https://github.com/${encodeURIComponent(path2)}.png?size=40`;
 }
 function parseJson(raw, operation) {
@@ -16610,64 +17805,112 @@ function validTimestamp(value) {
 function invalidOutput(operation) {
   return new GhOperationError({ code: "GH_INVALID_OUTPUT", operation, message: "GitHub CLI returned an unexpected response." });
 }
-const GH_ENV = { GH_PROMPT_DISABLED: "1", GH_NO_UPDATE_NOTIFIER: "1", GH_PAGER: "cat", NO_COLOR: "1" };
 const NETWORK_TIMEOUT_MS = 6e4;
 class GitHubService {
-  constructor(resolver, runner, git, repositories) {
-    this.resolver = resolver;
+  constructor(resolver, runner, git, repositories, accounts) {
     this.runner = runner;
     this.git = git;
     this.repositories = repositories;
+    this.accounts = accounts ?? new GitHubAccountsService(resolver, runner, git);
   }
-  resolver;
   runner;
   git;
   repositories;
-  statusCache = null;
+  accounts;
   async status(forceRefresh = false) {
-    if (!forceRefresh && this.statusCache && Date.now() - this.statusCache.at < 3e4) return this.statusCache.value;
-    const value = await this.checkStatus(forceRefresh);
-    this.statusCache = { at: Date.now(), value };
-    return value;
+    if (forceRefresh) this.accounts.refreshAuthentication();
+    const detected = await this.accounts.detect(forceRefresh);
+    return {
+      installed: !!detected.candidate,
+      availability: detected.state === "available" ? "ready" : "error",
+      authStatus: "unknown",
+      ...detected.version ? { version: detected.version } : {},
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async repositoryAccount(repositoryId, forceRefresh = false) {
+    const repository = this.repositories.get(repositoryId);
+    const info = await this.repositoryInfo(repositoryId);
+    const remote = await this.remote(repositoryId);
+    if (forceRefresh && info.nameWithOwner) {
+      this.accounts.refreshAuthentication();
+      try {
+        await this.accounts.authenticate(repository, remote, info.nameWithOwner, "gh-repository-account");
+      } catch {
+      }
+    }
+    return this.accounts.context(repository, remote, info.nameWithOwner);
+  }
+  async setRepositoryAccount(repositoryId, selection) {
+    await this.accounts.setSelection(this.repositories.get(repositoryId), selection);
+    return this.repositoryAccount(repositoryId);
+  }
+  async remote(repositoryId) {
+    const repository = this.repositories.get(repositoryId);
+    try {
+      const output = await this.git.run(repository.path, ["config", "--get", "remote.origin.url"], { operation: "github-remote-url", readOnly: true, maxOutputBytes: 64 * 1024 });
+      return output.stdout.toString("utf8").trim();
+    } catch {
+      return "";
+    }
   }
   async repositoryInfo(repositoryId) {
     const repository = this.repositories.get(repositoryId);
     try {
       const output = await this.git.run(repository.path, ["config", "--get", "remote.origin.url"], { operation: "github-remote-url", readOnly: true, maxOutputBytes: 64 * 1024 });
-      const parsed = parseGitHubRemote(output.stdout.toString("utf8"));
+      const url = output.stdout.toString("utf8");
+      let parsed = parseGitHubRemote(url);
+      if (!parsed) {
+        const ssh = parseSshRemote(url);
+        if (ssh) {
+          const config2 = await this.runner.run("ssh", ["-G", ...ssh.port ? ["-p", ssh.port] : [], "--", ssh.destination], {
+            cwd: os.homedir(),
+            timeoutMs: 5e3,
+            maxOutputBytes: 64 * 1024
+          });
+          const hostname = config2.stdout.split(/\r?\n/).find((line) => /^hostname\s/i.test(line))?.trim().split(/\s+/)[1];
+          if (config2.exitCode === 0 && hostname?.toLowerCase() === "github.com") parsed = { nameWithOwner: ssh.nameWithOwner };
+        }
+      }
       return parsed ? { isGitHub: true, nameWithOwner: parsed.nameWithOwner } : { isGitHub: false, nameWithOwner: null };
     } catch {
       return { isGitHub: false, nameWithOwner: null };
     }
   }
   async listPullRequests(repositoryId, states) {
-    const { repository, nameWithOwner } = await this.requireGitHub(repositoryId, "gh-pr-list");
+    const { repository, nameWithOwner, auth, executable } = await this.requireGitHub(repositoryId, "gh-pr-list");
     const results = await Promise.all(states.map((state) => this.runGh(
       ["pr", "list", "-R", nameWithOwner, "--state", state.toLowerCase(), "--json", PR_SUMMARY_FIELDS, "--limit", "50"],
-      { cwd: repository.path, operation: "gh-pr-list", timeoutMs: NETWORK_TIMEOUT_MS, maxOutputBytes: 4 * 1024 * 1024 }
+      { auth, executable, cwd: repository.path, operation: "gh-pr-list", timeoutMs: NETWORK_TIMEOUT_MS, maxOutputBytes: 4 * 1024 * 1024 }
     )));
-    return this.withStackMembership(repository.path, nameWithOwner, selectPullRequestsNewestFirst(results.flatMap((result) => parsePullRequestList(result.stdout)), states));
+    return this.withStackMembership(repository.path, nameWithOwner, auth, executable, selectPullRequestsNewestFirst(results.flatMap((result) => parsePullRequestList(result.stdout)), states));
   }
   async findPullRequestForBranch(repositoryId, branchName) {
     const operation = "gh-pr-for-branch";
-    const { repository, nameWithOwner } = await this.requireGitHub(repositoryId, operation);
+    const { repository, nameWithOwner, auth, executable } = 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"],
+      { auth, executable, 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 }
+      { auth, executable, cwd: repository.path, operation, timeoutMs: NETWORK_TIMEOUT_MS, maxOutputBytes: 1024 * 1024 }
     );
     return sortPullRequestsNewestFirst(parsePullRequestList(result.stdout))[0] ?? null;
   }
   async getPullRequest(repositoryId, prNumber) {
-    const { repository, nameWithOwner } = await this.requireGitHub(repositoryId, "gh-pr-view");
+    const { repository, nameWithOwner, auth, executable } = await this.requireGitHub(repositoryId, "gh-pr-view");
     const result = await this.runGh(
       ["pr", "view", String(prNumber), "-R", nameWithOwner, "--json", PR_DETAIL_FIELDS],
-      { cwd: repository.path, operation: "gh-pr-view", timeoutMs: NETWORK_TIMEOUT_MS, maxOutputBytes: 4 * 1024 * 1024 }
+      { auth, executable, cwd: repository.path, operation: "gh-pr-view", timeoutMs: NETWORK_TIMEOUT_MS, maxOutputBytes: 4 * 1024 * 1024 }
     );
     const details = parsePullRequestDetails(result.stdout);
-    return (await this.withStackMembership(repository.path, nameWithOwner, [details]))[0];
+    return (await this.withStackMembership(repository.path, nameWithOwner, auth, executable, [details]))[0];
   }
-  async withStackMembership(cwd, nameWithOwner, pulls) {
+  async withStackMembership(cwd, nameWithOwner, auth, executable, pulls) {
     const [owner, name] = nameWithOwner.split("/");
     const enriched = [];
     for (let start = 0; start < pulls.length; start += 25) {
@@ -16675,6 +17918,8 @@ class GitHubService {
       try {
         const numbers = batch.map((pr) => pr.number);
         const result = await this.runGh(["api", "graphql", "-f", `owner=${owner}`, "-f", `name=${name}`, "-f", `query=${stackMembershipQuery(numbers)}`], {
+          auth,
+          executable,
           cwd,
           operation: "gh-pr-stack-membership",
           timeoutMs: 1e4,
@@ -16693,28 +17938,28 @@ class GitHubService {
   }
   async getPullRequestStack(repositoryId, prNumber) {
     const operation = "gh-pr-stack";
-    const { repository, nameWithOwner } = await this.requireGitHub(repositoryId, operation);
-    const options = { cwd: repository.path, operation, timeoutMs: NETWORK_TIMEOUT_MS, maxOutputBytes: 4 * 1024 * 1024 };
-    const read = async (endpoint) => this.runGh(["api", endpoint], options);
+    const { repository, nameWithOwner, auth, executable } = await this.requireGitHub(repositoryId, operation);
+    const options = { auth, executable, cwd: repository.path, operation, timeoutMs: NETWORK_TIMEOUT_MS, maxOutputBytes: 4 * 1024 * 1024 };
+    const read2 = async (endpoint) => this.runGh(["api", endpoint], options);
     let listing;
     try {
-      listing = await read(`repos/${nameWithOwner}/stacks?pull_request=${prNumber}`);
+      listing = await read2(`repos/${nameWithOwner}/stacks?pull_request=${prNumber}`);
     } catch (error) {
       if (error instanceof GhOperationError && error.detail.code === "GH_PROCESS_FAILED" && /HTTP 404/.test(error.message)) return null;
       throw error;
     }
     const stack = parsePullRequestStack(listing.stdout, prNumber, true);
     if (!stack) return null;
-    const details = await read(`repos/${nameWithOwner}/stacks/${stack.number}`);
+    const details = await read2(`repos/${nameWithOwner}/stacks/${stack.number}`);
     const complete = parsePullRequestStack(details.stdout, prNumber);
     if (complete?.number !== stack.number) throw new GhOperationError({ code: "GH_INVALID_OUTPUT", operation, message: "The stack changed while loading. Refresh to try again." });
     return complete;
   }
   async getPullRequestDiff(repositoryId, prNumber) {
-    const { repository, nameWithOwner } = await this.requireGitHub(repositoryId, "gh-pr-diff");
+    const { repository, nameWithOwner, auth, executable } = await this.requireGitHub(repositoryId, "gh-pr-diff");
     const result = await this.runGh(
       ["pr", "diff", String(prNumber), "-R", nameWithOwner],
-      { cwd: repository.path, operation: "gh-pr-diff", timeoutMs: NETWORK_TIMEOUT_MS, maxOutputBytes: 32 * 1024 * 1024 }
+      { auth, executable, cwd: repository.path, operation: "gh-pr-diff", timeoutMs: NETWORK_TIMEOUT_MS, maxOutputBytes: 32 * 1024 * 1024 }
     );
     const patch = result.stdout;
     const binary = /Binary files .* differ|GIT binary patch/.test(patch);
@@ -16722,13 +17967,13 @@ class GitHubService {
   }
   async getPullRequestCommitDiff(repositoryId, oid) {
     const operation = "gh-pr-commit-diff";
-    const { repository, nameWithOwner } = await this.requireGitHub(repositoryId, operation);
+    const { repository, nameWithOwner, auth, executable } = await this.requireGitHub(repositoryId, operation);
     if (!/^[0-9a-f]{40,64}$/i.test(oid)) {
       throw new GhOperationError({ code: "GH_PROCESS_FAILED", operation, message: "The commit is not valid." });
     }
     const result = await this.runGh(
       ["api", `repos/${nameWithOwner}/commits/${oid}`, "--header", "Accept: application/vnd.github.diff"],
-      { cwd: repository.path, operation, timeoutMs: NETWORK_TIMEOUT_MS, maxOutputBytes: 32 * 1024 * 1024 }
+      { auth, executable, cwd: repository.path, operation, timeoutMs: NETWORK_TIMEOUT_MS, maxOutputBytes: 32 * 1024 * 1024 }
     );
     const patch = result.stdout;
     const binary = /Binary files .* differ|GIT binary patch/.test(patch);
@@ -16736,7 +17981,13 @@ class GitHubService {
   }
   async createPullRequest(input) {
     const operation = "gh-pr-create";
-    const { repository, nameWithOwner } = await this.requireGitHub(input.repositoryId, operation);
+    const { repository, nameWithOwner, auth, executable, context } = await this.requireGitHub(input.repositoryId, operation);
+    const verifyAccount = () => {
+      if (input.expectedAccount && (input.expectedAccount.revision !== this.accounts.authRevision || input.expectedAccount.revision !== context.revision || input.expectedAccount.login.toLowerCase() !== context.login?.toLowerCase())) {
+        throw new GhOperationError({ code: "GH_ACCOUNT_UNRESOLVED", operation, message: "The GitHub account changed. Review the current identity before creating the pull request." });
+      }
+    };
+    verifyAccount();
     const status = await this.repositories.status(input.repositoryId, false);
     if (status.detached || status.unborn || !status.branch) {
       throw new GhOperationError({ code: "GH_PROCESS_FAILED", operation, message: "Check out a branch before creating a pull request." });
@@ -16754,7 +18005,8 @@ class GitHubService {
       await writeFile(bodyPath, input.body, { encoding: "utf8", mode: 384 });
       const args = ["pr", "create", "-R", nameWithOwner, "--title", input.title, "--body-file", bodyPath, "--base", base, "--head", head];
       if (input.draft) args.push("--draft");
-      const result = await this.runGh(args, { cwd: repository.path, operation, timeoutMs: 12e4, maxOutputBytes: 1024 * 1024 });
+      verifyAccount();
+      const result = await this.runGh(args, { auth, executable, cwd: repository.path, operation, timeoutMs: 12e4, maxOutputBytes: 1024 * 1024 });
       const created = parseCreatedPullRequestUrl(result.stdout);
       if (!created) throw new GhOperationError({ code: "GH_INVALID_OUTPUT", operation, message: "GitHub CLI did not return the URL of the new pull request." });
       return created;
@@ -16762,49 +18014,32 @@ class GitHubService {
       await rm(temporary, { recursive: true, force: true });
     }
   }
-  async checkStatus(forceRefresh) {
-    const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const executable = await this.resolver.resolve("gh", forceRefresh);
-    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();
-    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 };
-    }
-    return { installed: true, availability: "ready", authStatus: "authenticated", version: versionLabel, checkedAt };
-  }
   async requireGitHub(repositoryId, operation) {
     const repository = this.repositories.get(repositoryId);
     const info = await this.repositoryInfo(repositoryId);
-    if (!info.isGitHub || !info.nameWithOwner) {
-      throw new GhOperationError({ code: "GH_NOT_GITHUB_REPO", operation, message: "The origin remote does not point to a GitHub repository." });
-    }
-    const status = await this.status();
-    if (!status.installed) throw new GhOperationError({ code: "GH_CLI_NOT_FOUND", operation, message: "GitHub CLI is not installed." });
-    if (status.authStatus === "unauthenticated") throw new GhOperationError({ code: "GH_AUTH_REQUIRED", operation, message: "Sign in with gh auth login to continue." });
-    return { repository, nameWithOwner: info.nameWithOwner };
+    if (!info.isGitHub || !info.nameWithOwner) throw new GhOperationError({ code: "GH_NOT_GITHUB_REPO", operation, message: "The origin remote does not point to a GitHub repository." });
+    const remote = await this.remote(repositoryId);
+    const authenticated = await this.accounts.authenticate(repository, remote, info.nameWithOwner, operation);
+    return { repository, nameWithOwner: info.nameWithOwner, ...authenticated };
   }
   async runGh(args, options) {
-    const executable = await this.resolver.resolve("gh");
-    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);
+    const result = await this.run(options.executable, args, options);
+    if (result.exitCode !== 0) throw classifyFailure({ ...result, stdout: redactCommandToken(result.stdout, options.auth), stderr: redactCommandToken(result.stderr, options.auth) }, options.operation);
     return result;
   }
   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.auth?.env },
+        ...options.auth?.removeEnv ? { removeEnv: options.auth.removeEnv } : {},
         ...options.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {},
         ...options.maxOutputBytes !== void 0 ? { maxOutputBytes: options.maxOutputBytes } : {},
         ...options.stdin !== void 0 ? { stdin: options.stdin } : {}
       });
     } catch (error) {
-      throw mapRunnerError(error, options.operation);
+      const mapped = mapRunnerError(error, options.operation);
+      throw new GhOperationError({ ...mapped.detail, message: redactCommandToken(mapped.message, options.auth ?? {}) });
     }
   }
 }
@@ -16828,6 +18063,8 @@ ${result.stdout}`.toLowerCase();
   if (/could not resolve|no such host|connection refused|connection reset|network|dial tcp|tls handshake/.test(raw)) {
     return new GhOperationError({ code: "GH_PROCESS_FAILED", operation, message: "Could not connect to GitHub. Check your network and try again.", exitCode: result.exitCode, retryable: true });
   }
+  if (/403|resource not accessible|insufficient.*scope|saml|sso/.test(raw)) return new GhOperationError({ code: "GH_ACCESS_DENIED", operation, message: "This GitHub account cannot perform the operation. Check repository permissions, token permissions and organisation SSO policies.", exitCode: result.exitCode });
+  if (/404|could not resolve to a repository/.test(raw) && operation !== "gh-pr-stack") return new GhOperationError({ code: "GH_ACCESS_DENIED", operation, message: "The repository was not found or is not accessible with this GitHub account.", exitCode: result.exitCode });
   const detail = firstLine(result.stderr) || firstLine(result.stdout);
   return new GhOperationError({ code: "GH_PROCESS_FAILED", operation, message: detail || "GitHub CLI could not complete the operation.", exitCode: result.exitCode });
 }
@@ -16843,6 +18080,50 @@ function mapRunnerError(error, operation) {
 function firstLine(value) {
   return (value.split(/\r?\n/).map((line) => line.trim()).find(Boolean) ?? "").slice(0, 300);
 }
+const statusSchema = object({
+  id: _enum(["codex", "claude", "opencode", "grok"]),
+  label: string(),
+  availability: _enum(["ready", "warning", "error"]),
+  installed: boolean(),
+  authStatus: _enum(["authenticated", "unauthenticated", "unknown"]),
+  installationStatus: _enum(["available", "not-found", "not-executable", "incompatible", "inspection-failed"]).optional(),
+  executablePath: string().optional(),
+  executableSource: _enum(["configured", "process-path", "user-path", "known-location"]).optional(),
+  discoveryWarning: string().optional(),
+  version: string().optional(),
+  message: string().optional(),
+  cliName: string().optional(),
+  models: array(object({ id: string(), label: string(), description: string().optional() })),
+  checkedAt: string().datetime()
+});
+const cacheSchema = object({
+  version: literal(1),
+  key: string(),
+  statuses: array(statusSchema).min(1).max(4)
+}).refine(({ statuses }) => new Set(statuses.map((status) => status.id)).size === statuses.length);
+class AiStatusStore {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  filePath;
+  pending = Promise.resolve();
+  async load(key) {
+    await this.pending;
+    try {
+      if ((await stat(this.filePath)).size > 4 * 1024 * 1024) return null;
+      const parsed = cacheSchema.safeParse(JSON.parse(await readFile(this.filePath, "utf8")));
+      return parsed.success && parsed.data.key === key ? parsed.data.statuses : null;
+    } catch {
+      return null;
+    }
+  }
+  save(key, statuses) {
+    const snapshot = cacheSchema.parse({ version: 1, key, statuses });
+    const write = this.pending.then(() => writeFileAtomically(this.filePath, JSON.stringify(snapshot), { parseJson: true }));
+    this.pending = write.catch(() => void 0);
+    return write;
+  }
+}
 const MAX_PROBLEM_LOG_ENTRIES = 500;
 const PROBLEM_LOG_COMPACTION_SLACK = 1.25;
 const LEVELS = ["error", "warn"];
@@ -17246,6 +18527,7 @@ function normalizeRemoteFetchIntervalSeconds(value) {
 const SETTINGS_SCHEMA_VERSION = 1;
 const defaults = {
   version: SETTINGS_SCHEMA_VERSION,
+  githubAccounts: {},
   recentRepositories: [],
   repositoryProjects: [],
   filesTreeStates: [],
@@ -17263,6 +18545,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
@@ -17271,6 +18554,7 @@ const defaults = {
 };
 const settingsRecordSchema = looseObject({
   version: unknown().optional(),
+  githubAccounts: unknown().optional(),
   recentRepositories: unknown().optional(),
   repositoryProjects: unknown().optional(),
   filesTreeStates: unknown().optional(),
@@ -17342,11 +18626,30 @@ 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 };
   }
+  githubAccount(commonDir) {
+    return { ...this.data.githubAccounts[githubRepositoryKey(commonDir)] ?? AUTOMATIC_GITHUB_ACCOUNT };
+  }
+  async setGitHubAccount(commonDir, selection) {
+    const parsed = githubAccountSelectionSchema.parse(selection);
+    const key = githubRepositoryKey(commonDir);
+    const previous = this.data.githubAccounts[key];
+    if (parsed.mode === "auto") delete this.data.githubAccounts[key];
+    else this.data.githubAccounts[key] = parsed;
+    try {
+      await this.save();
+    } catch (error) {
+      if (this.data.githubAccounts[key] === (parsed.mode === "auto" ? void 0 : parsed)) {
+        if (previous) this.data.githubAccounts[key] = previous;
+        else delete this.data.githubAccounts[key];
+      }
+      throw error;
+    }
+  }
   async touchRepository(repository) {
     const recent = { ...repository, lastOpenedAt: (/* @__PURE__ */ new Date()).toISOString() };
     this.data.recentRepositories = [recent, ...this.data.recentRepositories.filter((item) => item.id !== repository.id)];
@@ -17362,6 +18665,12 @@ class SettingsStore {
   async relocateRepository(previousId, repository) {
     const previous = this.data.recentRepositories.find((item) => item.id === previousId);
     if (!previous) throw projectError("Unknown repository.");
+    const previousAccountKey = githubRepositoryKey(previous.commonDir);
+    const nextAccountKey = githubRepositoryKey(repository.commonDir);
+    if (previousAccountKey !== nextAccountKey && this.data.githubAccounts[previousAccountKey]) {
+      this.data.githubAccounts[nextAccountKey] ??= this.data.githubAccounts[previousAccountKey];
+      delete this.data.githubAccounts[previousAccountKey];
+    }
     const previousKey = normalizeRepositoryKey(previous.commonDir);
     const nextKey = normalizeRepositoryKey(repository.commonDir);
     const destinationAlreadyAssigned = this.data.repositoryProjects.some((project) => project.repositoryKeys.some((key) => key === nextKey && key !== previousKey));
@@ -17386,6 +18695,9 @@ class SettingsStore {
   async forgetRepository(repositoryKey) {
     const key = normalizeRepositoryKey(repositoryKey);
     const removedIds = new Set(this.data.recentRepositories.filter((item) => normalizeRepositoryKey(item.commonDir) === key).map((item) => item.id));
+    for (const item of this.data.recentRepositories) {
+      if (removedIds.has(item.id)) delete this.data.githubAccounts[githubRepositoryKey(item.commonDir)];
+    }
     this.data.recentRepositories = this.data.recentRepositories.filter((item) => !removedIds.has(item.id));
     this.data.repositoryProjects = this.data.repositoryProjects.map((project) => ({
       ...project,
@@ -17471,6 +18783,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 +18913,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(
@@ -17610,6 +18925,7 @@ function validate(value, defaultDoubleControlShortcutEnabled) {
   const windowBounds = bounds && typeof bounds.width === "number" && Number.isFinite(bounds.width) && typeof bounds.height === "number" && Number.isFinite(bounds.height) ? { width: Math.max(900, bounds.width), height: Math.max(600, bounds.height), ...typeof bounds.x === "number" && Number.isFinite(bounds.x) ? { x: bounds.x } : {}, ...typeof bounds.y === "number" && Number.isFinite(bounds.y) ? { y: bounds.y } : {} } : { ...defaults.windowBounds };
   return {
     version: SETTINGS_SCHEMA_VERSION,
+    githubAccounts: normalizeGitHubAccounts(input.githubAccounts),
     recentRepositories,
     repositoryProjects,
     filesTreeStates,
@@ -17706,6 +19022,41 @@ 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;
+}
+function normalizeGitHubAccounts(value) {
+  const result = /* @__PURE__ */ Object.create(null);
+  if (!value || typeof value !== "object" || Array.isArray(value)) return result;
+  for (const [key, selection] of Object.entries(value).slice(0, 1e3)) {
+    if (!key || key.length > MAX_REPOSITORY_KEY_LENGTH || hasControlCharacters$1(key) || !path.isAbsolute(key)) continue;
+    const parsed = githubAccountSelectionSchema.safeParse(selection);
+    if (parsed.success && parsed.data.mode === "account") result[githubRepositoryKey(key)] = parsed.data;
+  }
+  return result;
+}
 class SystemTrash {
   available;
   operation;
@@ -17776,6 +19127,9 @@ class OpenTigRuntime {
     this.lastNotifiedAt = Date.now();
     this.onEvent({ type: "repository.changed", repositoryId, scope });
   }
+  publishGitHubAccountsChange() {
+    if (!this.closePromise) this.onEvent({ type: "github.accounts-changed" });
+  }
   publishActiveRepositoryChange(repository) {
     if (!this.closePromise) this.onEvent({ type: "repository.active-changed", repository });
   }
@@ -17824,7 +19178,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,10 +19188,21 @@ 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(), {
+    store: new AiStatusStore(path.join(path.dirname(options.settingsPath), "ai-statuses.json")),
+    key: () => aiExecutablePathsKey(settings.preferences.aiExecutablePaths)
+  });
   const prDrafts = new PullRequestDraftService(operations, providers, aiLog);
-  const github = new GitHubService(cliResolver, cliRunner, git, repositories);
   let runtime = null;
+  const githubAccounts = new GitHubAccountsService(
+    cliResolver,
+    cliRunner,
+    git,
+    settings,
+    new GitHubStatusStore(path.join(path.dirname(options.settingsPath), "github-status.json")),
+    () => runtime?.publishGitHubAccountsChange()
+  );
+  const github = new GitHubService(cliResolver, cliRunner, git, repositories, githubAccounts);
   const events = {
     repositoryChanged: (repositoryId, scope) => {
       runtime?.publishRepositoryChange(repositoryId, scope);
@@ -18046,6 +19411,8 @@ const IPC = {
   commitUndoLatest: "commit:undo-latest",
   commitsList: "commits:list",
   commitsFiles: "commits:files",
+  commitAuthorship: "commits:authorship",
+  commitSetAuthorship: "commits:set-authorship",
   branchesList: "refs:branches",
   branchSwitch: "refs:switch",
   worktreesList: "refs:worktrees",
@@ -18058,6 +19425,10 @@ const IPC = {
   worktreeDetails: "refs:worktree-details",
   branchDelete: "refs:delete-branch",
   worktreeRemove: "refs:remove-worktree",
+  remoteBranchDetails: "refs:remote-branch-details",
+  trackingBranchCreate: "refs:create-tracking-branch",
+  remoteBranchDelete: "refs:delete-remote-branch",
+  branchesFetch: "refs:fetch-branches",
   aiStatuses: "ai:statuses",
   aiGenerateCommitMessage: "ai:generate-commit-message",
   aiCancelGeneration: "ai:cancel-generation",
@@ -18066,6 +19437,9 @@ const IPC = {
   diagnosticsList: "diagnostics:list",
   diagnosticsClear: "diagnostics:clear",
   diagnosticsRecord: "diagnostics:record",
+  githubAccountsStatus: "github:accounts-status",
+  githubRepositoryAccount: "github:repository-account",
+  githubSetRepositoryAccount: "github:set-repository-account",
   githubStatus: "github:status",
   githubRepositoryInfo: "github:repository-info",
   githubPrForBranch: "github:pr-for-branch",
@@ -18131,6 +19505,8 @@ const OPEN_TIG_SERVER_COMMANDS = {
   "index.updateConflict": command(IPC.indexUpdateConflict, "update-conflict", true, { maxRequestBytes: CONTENT_MAX_REQUEST_BYTES }),
   "index.resolveConflict": command(IPC.indexResolveConflict, "resolve-conflict", true, { maxRequestBytes: CONTENT_MAX_REQUEST_BYTES }),
   "commits.create": command(IPC.commitCreate, "commit", true),
+  "commits.authorship": command(IPC.commitAuthorship, "commit-authorship-read", false),
+  "commits.setAuthorship": command(IPC.commitSetAuthorship, "commit-authorship-set", true),
   "commits.undoLatest": command(IPC.commitUndoLatest, "undo-latest-commit", true),
   "commits.list": command(IPC.commitsList, "history", false),
   "commits.files": command(IPC.commitsFiles, "commit-files", false),
@@ -18143,6 +19519,10 @@ const OPEN_TIG_SERVER_COMMANDS = {
   "refs.fetch": command(IPC.refsFetch, "fetch", true),
   "refs.localRefsSnapshot": command(IPC.localRefsSnapshot, "local-refs-snapshot", false),
   "refs.branchDetails": command(IPC.branchDetails, "branch-details", false),
+  "refs.remoteBranchDetails": command(IPC.remoteBranchDetails, "remote-branch-details", false, { timeoutMs: 12e4 }),
+  "refs.createTrackingBranch": command(IPC.trackingBranchCreate, "create-tracking-branch", true),
+  "refs.deleteRemoteBranch": command(IPC.remoteBranchDelete, "delete-remote-branch", true, { timeoutMs: 18e4 }),
+  "refs.fetchBranches": command(IPC.branchesFetch, "fetch-branches", true, { timeoutMs: 18e4 }),
   "refs.worktreeDetails": command(IPC.worktreeDetails, "worktree-details", false),
   "refs.deleteBranch": command(IPC.branchDelete, "delete-branch", true),
   "refs.removeWorktree": command(IPC.worktreeRemove, "remove-worktree", true),
@@ -18151,6 +19531,9 @@ const OPEN_TIG_SERVER_COMMANDS = {
   "ai.log": command(IPC.aiLog, "ai-log", false),
   "ai.clearLog": command(IPC.aiClearLog, "ai-clear-log", true),
   "ai.cancelGeneration": command(IPC.aiCancelGeneration, "ai-cancel-generation", true),
+  "github.accountsStatus": command(IPC.githubAccountsStatus, "gh-accounts-status", false, { timeoutMs: 9e4 }),
+  "github.repositoryAccount": command(IPC.githubRepositoryAccount, "gh-repository-account", false, { timeoutMs: 6e4 }),
+  "github.setRepositoryAccount": command(IPC.githubSetRepositoryAccount, "gh-set-repository-account", true),
   "github.status": command(IPC.githubStatus, "gh-status", false),
   "github.repositoryInfo": command(IPC.githubRepositoryInfo, "gh-repository-info", false),
   "github.findPullRequestForBranch": command(IPC.githubPrForBranch, "gh-pr-for-branch", false),
@@ -18314,29 +19697,73 @@ 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 = {}) {
-  let schema = string().max(maxLength).refine((value) => !value.includes("\0"));
-  if (options.empty !== true) schema = schema.min(1);
-  if (options.controls === false) return schema;
-  return schema.refine((value) => ![...value].some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127));
+  let schema2 = string().max(maxLength).refine((value) => !value.includes("\0"));
+  if (options.empty !== true) schema2 = schema2.min(1);
+  if (options.controls === false) return schema2;
+  return schema2.refine((value) => ![...value].some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127));
 }
 const booleanWithDefaultSchema = (fallback) => boolean().optional().default(fallback);
 function parseRecord(value) {
@@ -18487,6 +19914,22 @@ function deleteBranchArg(value, operation) {
     force: booleanArg(request.force, operation)
   };
 }
+function createTrackingBranchArg(value) {
+  const operation = "create-tracking-branch";
+  const request = requestObject(value, operation);
+  return {
+    ...branchDetailsArg(request, operation),
+    expectedOid: oidArg(request.expectedOid, operation),
+    localName: refsString(request.localName, operation, MAX_BRANCH_REF_LENGTH)
+  };
+}
+function deleteRemoteBranchArg(value) {
+  const operation = "delete-remote-branch";
+  const request = requestObject(value, operation);
+  const destinationId = refsString(request.destinationId, operation, 64);
+  if (!/^[0-9a-f]{64}$/.test(destinationId)) throw new GitOperationError({ code: "INVALID_ARGUMENT", operation, message: "Invalid remote destination." });
+  return { ...branchDetailsArg(request, operation), expectedOid: oidArg(request.expectedOid, operation), destinationId };
+}
 function removeWorktreeArg(value, operation) {
   const request = requestObject(value, operation);
   return {
@@ -18584,7 +20027,16 @@ function createPullRequestArg(value) {
   if (typeof input.base !== "string" || !input.base || input.base.length > 300 || input.base.includes("\0")) throw invalidGh(operation);
   if (typeof input.draft !== "boolean") throw invalidGh(operation);
   if (typeof input.repositoryId !== "string" || !input.repositoryId || input.repositoryId.length > 64) throw invalidGh(operation);
-  return { repositoryId: input.repositoryId, title: input.title.trim(), body: input.body, base: input.base, draft: input.draft };
+  const expected = input.expectedAccount;
+  if (expected !== void 0 && (!expected || typeof expected.login !== "string" || !/^[A-Za-z0-9](?:[A-Za-z0-9-]{0,37}[A-Za-z0-9])?$/.test(expected.login) || !Number.isSafeInteger(expected.revision) || expected.revision < 0)) throw invalidGh(operation);
+  return {
+    repositoryId: input.repositoryId,
+    title: input.title.trim(),
+    body: input.body,
+    base: input.base,
+    draft: input.draft,
+    ...expected ? { expectedAccount: { login: expected.login, revision: expected.revision } } : {}
+  };
 }
 function generatePullRequestDraftArg(value) {
   const operation = "ai-pr-draft";
@@ -18672,7 +20124,9 @@ function registerServerCommands(registry2, services, host) {
     };
   });
   handle(IPC.preferences, "preferences", async (partial2) => {
+    const previousPaths = aiExecutablePathsKey(services.settings.preferences.aiExecutablePaths);
     const preferences = await services.settings.setPreferences(partial2 ?? {});
+    if (previousPaths !== aiExecutablePathsKey(preferences.aiExecutablePaths)) services.ai.invalidateStatuses();
     return preferences;
   });
   handle(IPC.filesTreeStateUpdate, "files-tree-state", (repositoryId, expandedPaths) => {
@@ -18692,7 +20146,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 +20185,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(
@@ -18930,6 +20385,17 @@ function registerServerCommands(registry2, services, host) {
     textArg(content, "update-conflict", 8 * 1024 * 1024)
   ));
   handle(IPC.commitCreate, "commit", (id, message) => services.operations.createCommit(stringArg(id, "commit", 64), stringArg(message, "commit", 1e5)));
+  handle(IPC.commitAuthorship, "commit-authorship-read", (id) => services.operations.getCommitAuthorship(stringArg(id, "commit-authorship-read", 64)));
+  handle(IPC.commitSetAuthorship, "commit-authorship-set", async (id, input) => {
+    const repositoryId = stringArg(id, "commit-authorship-set", 64);
+    const parsed = commitAuthorshipInputSchema.safeParse(input);
+    if (!parsed.success) throw new GitOperationError({ code: "INVALID_ARGUMENT", operation: "commit-authorship-set", message: "Enter a valid name, email and reviewed identity." });
+    const result = await services.operations.setCommitAuthorship(repositoryId, parsed.data);
+    const repository = services.repositories.get(repositoryId);
+    const ids = /* @__PURE__ */ new Set([repositoryId, ...services.repositories.recents().filter((item) => item.commonDir === repository.commonDir).map((item) => item.id)]);
+    for (const siblingId of ids) services.events.repositoryChanged(siblingId, "unknown");
+    return result;
+  });
   handle(IPC.commitUndoLatest, "undo-latest-commit", (id, expectedOid) => services.operations.undoLatestCommit(
     stringArg(id, "undo-latest-commit", 64),
     oidArg(expectedOid, "undo-latest-commit")
@@ -18954,6 +20420,13 @@ function registerServerCommands(registry2, services, host) {
     const { repositoryId, fullName } = branchDetailsArg(request, "branch-details");
     return services.operations.branchDetails(repositoryId, fullName);
   });
+  handle(IPC.remoteBranchDetails, "remote-branch-details", (request) => {
+    const { repositoryId, fullName } = branchDetailsArg(request, "remote-branch-details");
+    return services.operations.remoteBranchDetails(repositoryId, fullName);
+  });
+  handle(IPC.trackingBranchCreate, "create-tracking-branch", (request) => services.operations.createTrackingBranch(createTrackingBranchArg(request)));
+  handle(IPC.remoteBranchDelete, "delete-remote-branch", (request) => services.operations.deleteRemoteBranch(deleteRemoteBranchArg(request)));
+  handle(IPC.branchesFetch, "fetch-branches", (id) => services.operations.fetchBranches(stringArg(id, "fetch-branches", 64)));
   handle(IPC.worktreeDetails, "worktree-details", (request) => {
     const { repositoryId, path: path2 } = worktreeDetailsArg(request, "worktree-details");
     return services.operations.worktreeDetails(repositoryId, path2);
@@ -18991,6 +20464,13 @@ function registerServerCommands(registry2, services, host) {
   handle(IPC.aiCancelGeneration, "ai-cancel-generation", (requestId2) => {
     services.ai.cancel(aiString(requestId2, "ai-cancel-generation", 100, true));
   });
+  handle(IPC.githubAccountsStatus, "gh-accounts-status", (forceRefresh) => services.github.accounts.status(booleanArg(forceRefresh, "gh-accounts-status")));
+  handle(IPC.githubRepositoryAccount, "gh-repository-account", (id, forceRefresh) => services.github.repositoryAccount(stringArg(id, "gh-repository-account", 64), booleanArg(forceRefresh, "gh-repository-account")));
+  handle(IPC.githubSetRepositoryAccount, "gh-set-repository-account", (id, selection) => {
+    const parsed = githubAccountSelectionSchema.safeParse(selection);
+    if (!parsed.success) throw new GitOperationError({ code: "INVALID_ARGUMENT", operation: "gh-set-repository-account", message: "Invalid GitHub account selection." });
+    return services.github.setRepositoryAccount(stringArg(id, "gh-set-repository-account", 64), parsed.data);
+  });
   handle(IPC.githubStatus, "gh-status", (forceRefresh) => services.github.status(booleanArg(forceRefresh, "gh-status")));
   handle(IPC.githubRepositoryInfo, "gh-repository-info", (id) => services.github.repositoryInfo(stringArg(id, "gh-repository-info", 64)));
   handle(IPC.githubPrForBranch, "gh-pr-for-branch", (id, branchName) => services.github.findPullRequestForBranch(
@@ -19040,7 +20520,7 @@ function clipboardImageArg(value) {
   if (value instanceof Uint8Array) return value;
   throw new GitOperationError({ code: "INVALID_ARGUMENT", operation: "paste-entries", message: "Invalid clipboard image." });
 }
-const protocolVersion = 1;
+const protocolVersion = 4;
 const protocolMetadata = {
   protocolVersion
 };
@@ -19056,6 +20536,85 @@ function preferredServerPort(profile) {
 }
 const AUTH_DATA_VERSION = 4;
 const BROWSER_SESSION_MAX_AGE_SECONDS = 30 * 24 * 60 * 60;
+async function hasActiveBrowserSessions(directory, now = Date.now) {
+  const { sessions } = await loadSessions(path.join(directory, "sessions.json"));
+  return sessions.some((session) => session.kind !== "desktop" && session.expiresAt !== null && now() < Date.parse(session.expiresAt));
+}
+async function loadSessions(filePath) {
+  try {
+    const parsed = JSON.parse(await readFile(filePath, "utf8"));
+    if (isLegacyAuthData(parsed)) {
+      await chmod(filePath, 384);
+      return {
+        sessions: parsed.sessions.map((session) => ({
+          ...session,
+          kind: "legacy",
+          expiresAt: sessionExpiry("legacy", session.createdAt),
+          clientName: "Legacy browser session",
+          deviceType: "unknown",
+          os: null,
+          browser: null,
+          remoteAddress: null,
+          viaProxy: false,
+          lastConnectedAt: null
+        })),
+        migrated: true
+      };
+    }
+    if (isVersionTwoAuthData(parsed)) {
+      await chmod(filePath, 384);
+      return {
+        sessions: parsed.sessions.map((session) => ({
+          ...session,
+          expiresAt: sessionExpiry(session.kind, session.createdAt),
+          clientName: session.kind === "legacy" ? "Legacy browser session" : session.clientName,
+          deviceType: session.kind === "desktop" ? "desktop" : "unknown",
+          os: null,
+          browser: session.kind === "browser" ? session.clientName : null,
+          viaProxy: false,
+          lastConnectedAt: null
+        })),
+        migrated: true
+      };
+    }
+    if (isVersionThreeAuthData(parsed)) {
+      await chmod(filePath, 384);
+      return {
+        sessions: parsed.sessions.map((session) => ({ ...session, expiresAt: sessionExpiry(session.kind, session.createdAt) })),
+        migrated: true
+      };
+    }
+    if (!isAuthData(parsed)) throw corrupt$1("session data");
+    await chmod(filePath, 384);
+    return { sessions: parsed.sessions.map((session) => ({ ...session })), migrated: false };
+  } catch (error) {
+    if (error.code === "ENOENT") return { sessions: [], migrated: false };
+    if (error instanceof SyntaxError) throw corrupt$1("session data");
+    throw error;
+  }
+}
+function isAuthData(value) {
+  const data = value;
+  return Boolean(data && data.version === AUTH_DATA_VERSION && isVersionThreeAuthData({ ...data, version: 3 }) && data.sessions?.every((session) => session.kind === "desktop" ? session.expiresAt === null : typeof session.expiresAt === "string" && Number.isFinite(Date.parse(session.expiresAt)) && Date.parse(session.expiresAt) > Date.parse(session.createdAt)));
+}
+function isVersionThreeAuthData(value) {
+  const data = value;
+  return Boolean(data && data.version === 3 && Array.isArray(data.sessions) && data.sessions.every((session) => session && typeof session.id === "string" && /^[A-Za-z0-9_-]{24}$/.test(session.id) && typeof session.digest === "string" && /^[A-Za-z0-9_-]{43}$/.test(session.digest) && (session.kind === "desktop" || session.kind === "browser" || session.kind === "legacy") && typeof session.clientName === "string" && session.clientName.length > 0 && session.clientName.length <= 160 && (session.deviceType === "desktop" || session.deviceType === "mobile" || session.deviceType === "tablet" || session.deviceType === "bot" || session.deviceType === "unknown") && (session.os === null || typeof session.os === "string" && session.os.length <= 80) && (session.browser === null || typeof session.browser === "string" && session.browser.length <= 80) && (session.remoteAddress === null || typeof session.remoteAddress === "string" && session.remoteAddress.length <= 128) && typeof session.viaProxy === "boolean" && typeof session.createdAt === "string" && !Number.isNaN(Date.parse(session.createdAt)) && (session.lastConnectedAt === null || typeof session.lastConnectedAt === "string" && !Number.isNaN(Date.parse(session.lastConnectedAt)))));
+}
+function isVersionTwoAuthData(value) {
+  const data = value;
+  return Boolean(data && data.version === 2 && Array.isArray(data.sessions) && data.sessions.every((session) => session && typeof session.id === "string" && /^[A-Za-z0-9_-]{24}$/.test(session.id) && typeof session.digest === "string" && /^[A-Za-z0-9_-]{43}$/.test(session.digest) && (session.kind === "desktop" || session.kind === "browser" || session.kind === "legacy") && typeof session.clientName === "string" && session.clientName.length > 0 && session.clientName.length <= 160 && (session.remoteAddress === null || typeof session.remoteAddress === "string" && session.remoteAddress.length <= 128) && typeof session.createdAt === "string" && !Number.isNaN(Date.parse(session.createdAt))));
+}
+function isLegacyAuthData(value) {
+  const data = value;
+  return Boolean(data && data.version === 1 && Array.isArray(data.sessions) && data.sessions.every((session) => session && typeof session.id === "string" && /^[A-Za-z0-9_-]{24}$/.test(session.id) && typeof session.digest === "string" && /^[A-Za-z0-9_-]{43}$/.test(session.digest) && typeof session.createdAt === "string" && !Number.isNaN(Date.parse(session.createdAt))));
+}
+function corrupt$1(name) {
+  return new Error(`OpenTig authentication ${name} is corrupt.`);
+}
+function sessionExpiry(kind, createdAt) {
+  return kind === "desktop" ? null : new Date(Date.parse(createdAt) + BROWSER_SESSION_MAX_AGE_SECONDS * 1e3).toISOString();
+}
 const SECRET_BYTES = 32;
 const SECRET_FILE = "server-secret";
 const SESSIONS_FILE = "sessions.json";
@@ -19071,6 +20630,10 @@ class PersistentAuthStore {
   now;
   sessions;
   mutationQueue = Promise.resolve();
+  /** Inspect an existing installation without issuing, revoking, or writing sessions. */
+  static async hasActiveBrowserSessions(directory, now = Date.now) {
+    return hasActiveBrowserSessions(directory, now);
+  }
   static async open(directory, now = Date.now) {
     const resolved = path.resolve(directory);
     await mkdir(resolved, { recursive: true, mode: 448 });
@@ -19260,75 +20823,6 @@ async function loadOrCreateSecret(filePath) {
     throw error;
   }
 }
-async function loadSessions(filePath) {
-  try {
-    const parsed = JSON.parse(await readFile(filePath, "utf8"));
-    if (isLegacyAuthData(parsed)) {
-      await chmod(filePath, 384);
-      return {
-        sessions: parsed.sessions.map((session) => ({
-          ...session,
-          kind: "legacy",
-          expiresAt: sessionExpiry("legacy", session.createdAt),
-          clientName: "Legacy browser session",
-          deviceType: "unknown",
-          os: null,
-          browser: null,
-          remoteAddress: null,
-          viaProxy: false,
-          lastConnectedAt: null
-        })),
-        migrated: true
-      };
-    }
-    if (isVersionTwoAuthData(parsed)) {
-      await chmod(filePath, 384);
-      return {
-        sessions: parsed.sessions.map((session) => ({
-          ...session,
-          expiresAt: sessionExpiry(session.kind, session.createdAt),
-          clientName: session.kind === "legacy" ? "Legacy browser session" : session.clientName,
-          deviceType: session.kind === "desktop" ? "desktop" : "unknown",
-          os: null,
-          browser: session.kind === "browser" ? session.clientName : null,
-          viaProxy: false,
-          lastConnectedAt: null
-        })),
-        migrated: true
-      };
-    }
-    if (isVersionThreeAuthData(parsed)) {
-      await chmod(filePath, 384);
-      return {
-        sessions: parsed.sessions.map((session) => ({ ...session, expiresAt: sessionExpiry(session.kind, session.createdAt) })),
-        migrated: true
-      };
-    }
-    if (!isAuthData(parsed)) throw corrupt("session data");
-    await chmod(filePath, 384);
-    return { sessions: parsed.sessions.map((session) => ({ ...session })), migrated: false };
-  } catch (error) {
-    if (error.code === "ENOENT") return { sessions: [], migrated: false };
-    if (error instanceof SyntaxError) throw corrupt("session data");
-    throw error;
-  }
-}
-function isAuthData(value) {
-  const data = value;
-  return Boolean(data && data.version === AUTH_DATA_VERSION && isVersionThreeAuthData({ ...data, version: 3 }) && data.sessions?.every((session) => session.kind === "desktop" ? session.expiresAt === null : typeof session.expiresAt === "string" && Number.isFinite(Date.parse(session.expiresAt)) && Date.parse(session.expiresAt) > Date.parse(session.createdAt)));
-}
-function isVersionThreeAuthData(value) {
-  const data = value;
-  return Boolean(data && data.version === 3 && Array.isArray(data.sessions) && data.sessions.every((session) => session && typeof session.id === "string" && /^[A-Za-z0-9_-]{24}$/.test(session.id) && typeof session.digest === "string" && /^[A-Za-z0-9_-]{43}$/.test(session.digest) && (session.kind === "desktop" || session.kind === "browser" || session.kind === "legacy") && typeof session.clientName === "string" && session.clientName.length > 0 && session.clientName.length <= 160 && (session.deviceType === "desktop" || session.deviceType === "mobile" || session.deviceType === "tablet" || session.deviceType === "bot" || session.deviceType === "unknown") && (session.os === null || typeof session.os === "string" && session.os.length <= 80) && (session.browser === null || typeof session.browser === "string" && session.browser.length <= 80) && (session.remoteAddress === null || typeof session.remoteAddress === "string" && session.remoteAddress.length <= 128) && typeof session.viaProxy === "boolean" && typeof session.createdAt === "string" && !Number.isNaN(Date.parse(session.createdAt)) && (session.lastConnectedAt === null || typeof session.lastConnectedAt === "string" && !Number.isNaN(Date.parse(session.lastConnectedAt)))));
-}
-function isVersionTwoAuthData(value) {
-  const data = value;
-  return Boolean(data && data.version === 2 && Array.isArray(data.sessions) && data.sessions.every((session) => session && typeof session.id === "string" && /^[A-Za-z0-9_-]{24}$/.test(session.id) && typeof session.digest === "string" && /^[A-Za-z0-9_-]{43}$/.test(session.digest) && (session.kind === "desktop" || session.kind === "browser" || session.kind === "legacy") && typeof session.clientName === "string" && session.clientName.length > 0 && session.clientName.length <= 160 && (session.remoteAddress === null || typeof session.remoteAddress === "string" && session.remoteAddress.length <= 128) && typeof session.createdAt === "string" && !Number.isNaN(Date.parse(session.createdAt))));
-}
-function isLegacyAuthData(value) {
-  const data = value;
-  return Boolean(data && data.version === 1 && Array.isArray(data.sessions) && data.sessions.every((session) => session && typeof session.id === "string" && /^[A-Za-z0-9_-]{24}$/.test(session.id) && typeof session.digest === "string" && /^[A-Za-z0-9_-]{43}$/.test(session.digest) && typeof session.createdAt === "string" && !Number.isNaN(Date.parse(session.createdAt))));
-}
 function constantTimeEqual(left, right) {
   const leftBytes = Buffer.from(left);
   const rightBytes = Buffer.from(right);
@@ -19346,17 +20840,15 @@ async function exists(filePath) {
 function corrupt(name) {
   return new Error(`OpenTig authentication ${name} is corrupt.`);
 }
-function sessionExpiry(kind, createdAt) {
-  return kind === "desktop" ? null : new Date(Date.parse(createdAt) + BROWSER_SESSION_MAX_AGE_SECONDS * 1e3).toISOString();
-}
 const DEFAULT_PAIRING_TTL_MS = 5 * 60 * 1e3;
 class OpenTigSessionAuth {
-  constructor(source, store, secureCookies, now, profile) {
+  constructor(source, store, secureCookies, now, profile, browserAccessEnabled) {
     this.source = source;
     this.store = store;
     this.secureCookies = secureCookies;
     this.now = now;
     this.profile = profile;
+    this.browserAccessEnabled = browserAccessEnabled;
   }
   source;
   store;
@@ -19364,15 +20856,30 @@ class OpenTigSessionAuth {
   now;
   profile;
   pairing = null;
+  browserAccessEnabled;
+  browserGeneration = 0;
+  browserQueue = Promise.resolve();
   static async open(options) {
     const store = await PersistentAuthStore.open(options.dataDirectory, options.now);
-    return new OpenTigSessionAuth(options.source, store, options.secureCookies ?? false, options.now ?? Date.now, options.profile ?? "production");
+    return new OpenTigSessionAuth(options.source, store, options.secureCookies ?? false, options.now ?? Date.now, options.profile ?? "production", options.browserAccessEnabled ?? true);
   }
   descriptor() {
     this.dropExpiredPairing();
-    return { authenticationRequired: true, pairingAvailable: this.pairing !== null };
+    return { authenticationRequired: true, pairingAvailable: this.browserAccessEnabled && this.pairing !== null, browserAccessEnabled: this.browserAccessEnabled };
+  }
+  setBrowserAccessEnabled(enabled) {
+    if (!enabled) {
+      this.browserAccessEnabled = false;
+      this.browserGeneration++;
+      this.pairing = null;
+    }
+    const generation = this.browserGeneration;
+    return this.queueBrowserMutation(async () => {
+      this.browserAccessEnabled = enabled && generation === this.browserGeneration;
+    });
   }
   createPairingToken(ttlMs = DEFAULT_PAIRING_TTL_MS) {
+    if (!this.browserAccessEnabled) throw new Error("Web access is disabled.");
     if (!Number.isSafeInteger(ttlMs) || ttlMs < 1e3 || ttlMs > 15 * 60 * 1e3) throw new Error("Invalid pairing token lifetime.");
     const token = randomBytes(32).toString("base64url");
     const expiresAt = this.now() + ttlMs;
@@ -19394,30 +20901,43 @@ class OpenTigSessionAuth {
   async exchangePairingToken(token, metadata, secure = false) {
     this.dropExpiredPairing();
     const pairing = this.pairing;
-    if (!pairing || !isCredential(token) || !this.store.matchesDigest(token, pairing.digest)) return null;
+    if (!this.browserAccessEnabled || !pairing || !isCredential(token) || !this.store.matchesDigest(token, pairing.digest)) return null;
     this.pairing = null;
-    try {
-      return await this.issueCookie({
-        kind: "browser",
-        clientName: metadata?.clientName ?? "Browser",
-        deviceType: metadata?.deviceType ?? "unknown",
-        os: metadata?.os ?? null,
-        browser: metadata?.browser ?? null,
-        remoteAddress: metadata?.remoteAddress ?? null,
-        viaProxy: metadata?.viaProxy ?? false
-      }, secure);
-    } catch (error) {
-      if (this.now() < pairing.expiresAt && !this.pairing) this.pairing = pairing;
-      throw error;
-    }
+    const generation = this.browserGeneration;
+    return this.queueBrowserMutation(async () => {
+      if (!this.browserAccessEnabled || generation !== this.browserGeneration) return null;
+      try {
+        const cookie = await this.issueCookie({
+          kind: "browser",
+          clientName: metadata?.clientName ?? "Browser",
+          deviceType: metadata?.deviceType ?? "unknown",
+          os: metadata?.os ?? null,
+          browser: metadata?.browser ?? null,
+          remoteAddress: metadata?.remoteAddress ?? null,
+          viaProxy: metadata?.viaProxy ?? false
+        }, secure);
+        if (!this.browserAccessEnabled || generation !== this.browserGeneration) {
+          await this.revoke({ cookie });
+          return null;
+        }
+        return cookie;
+      } catch (error) {
+        if (this.browserAccessEnabled && generation === this.browserGeneration && this.now() < pairing.expiresAt && !this.pairing) this.pairing = pairing;
+        throw error;
+      }
+    });
   }
   authenticate(headers) {
     const token = readCookie(headers.cookie, sessionCookieName(this.profile));
-    return token ? this.store.authenticate(token) : null;
+    const sessionId = token ? this.store.authenticate(token) : null;
+    return sessionId && this.hasSession(sessionId) ? sessionId : null;
   }
   async renewBrowserCookie(headers, secure = false) {
+    if (!this.browserAccessEnabled) return null;
+    const generation = this.browserGeneration;
     const token = readCookie(headers.cookie, sessionCookieName(this.profile));
     if (!token || !await this.store.renewBrowserSession(token)) return null;
+    if (!this.browserAccessEnabled || generation !== this.browserGeneration) return null;
     return this.sessionCookie(token, true, secure);
   }
   async revoke(headers) {
@@ -19462,11 +20982,18 @@ class OpenTigSessionAuth {
     };
   }
   hasSession(sessionId) {
-    return this.store.hasSession(sessionId);
+    return this.store.hasSession(sessionId) && (this.browserAccessEnabled || this.sessions().some((session) => session.id === sessionId && session.kind === "desktop"));
   }
   close() {
+    this.browserAccessEnabled = false;
+    this.browserGeneration++;
     this.pairing = null;
-    return this.store.close();
+    return this.browserQueue.then(() => this.store.close());
+  }
+  queueBrowserMutation(operation) {
+    const result = this.browserQueue.then(operation);
+    this.browserQueue = result.then(() => void 0, () => void 0);
+    return result;
   }
   expiredCookie(secure = false) {
     return `${sessionCookieName(this.profile)}=; Path=/; HttpOnly; SameSite=Strict; Max-Age=0${this.secureCookies || secure ? "; Secure" : ""}`;
@@ -19754,6 +21281,7 @@ async function handleRequest(context, request, response) {
       return sendJson(response, 204, null, { "Set-Cookie": cookie });
     }
     if (rawPath === "/api/auth/pair" || rawPath === "/api/auth/desktop") {
+      if (rawPath === "/api/auth/pair" && !context.auth.descriptor().browserAccessEnabled) return sendJson(response, 403, { error: "Web access is disabled.", code: "WEB_ACCESS_DISABLED" });
       const body = await readJsonObject(request, response);
       if (!body) return;
       const secure = requestOriginIsSecure(request);
@@ -19765,6 +21293,7 @@ async function handleRequest(context, request, response) {
       } else {
         cookie = await context.auth.exchangeDesktopSecret(body.secret);
       }
+      if (!cookie && rawPath === "/api/auth/pair" && !context.auth.descriptor().browserAccessEnabled) return sendJson(response, 403, { error: "Web access is disabled.", code: "WEB_ACCESS_DISABLED" });
       if (!cookie) return sendJson(response, 401, { error: "Authentication failed." });
       return sendJson(response, 204, null, { "Set-Cookie": cookie });
     }
@@ -19925,6 +21454,7 @@ async function handleLocalAdminPair(context, request, response) {
   }
   const origin = normalizePublicOrigin(body.publicOrigin);
   if (!origin) return sendJson(response, 400, { error: "Invalid public origin." });
+  if (!context.auth.descriptor().browserAccessEnabled) return sendJson(response, 403, { error: "Web access is disabled.", code: "WEB_ACCESS_DISABLED" });
   const pairing = admin.createPairingToken();
   const url = new URL("/pair", origin);
   url.hash = new URLSearchParams({ token: pairing.token }).toString();
@@ -20057,7 +21587,10 @@ class OpenTigWebSocketTransport {
   revokeSessions(sessionIds) {
     const revoked = new Set(sessionIds);
     for (const [socket, state] of this.clients) {
-      if (revoked.has(state.sessionId)) socket.close(1008, "Session revoked");
+      if (revoked.has(state.sessionId)) {
+        for (const controller of state.requests.values()) controller.abort();
+        socket.close(1008, "Session revoked");
+      }
     }
   }
   close() {
@@ -20100,6 +21633,7 @@ class OpenTigWebSocketTransport {
     socket.on("error", () => this.options.logger("warn", "WebSocket connection failed."));
   }
   async message(socket, state, data, isBinary) {
+    if (!this.options.auth.hasSession(state.sessionId)) return socket.close(1008, "Session expired or revoked");
     if (isBinary) return socket.close(1003, "Text messages only");
     const bytes = rawBytes(data);
     if (bytes.byteLength > FILE_WRITE_FRAME_LIMIT) return socket.close(1009, "Message too large");
@@ -20297,7 +21831,13 @@ class OpenTigServer {
     return this.options.auth.createPairingToken();
   }
   getStatus() {
-    return { connectedSessionCount: this.webSockets.connectedSessionCount };
+    return { connectedSessionCount: this.webSockets.connectedSessionCount, browserAccessEnabled: this.options.auth.descriptor().browserAccessEnabled };
+  }
+  async setBrowserAccessEnabled(enabled) {
+    if (!this.ready) throw new Error("Server is not ready.");
+    const pending = this.options.auth.setBrowserAccessEnabled(enabled);
+    if (!enabled) this.disconnectSessions(this.options.auth.sessions().filter((session) => session.kind !== "desktop").map((session) => session.id));
+    await pending;
   }
   async revokeAllSessions() {
     if (!this.ready) throw new Error("Server is not ready.");
@@ -20355,6 +21895,7 @@ async function runOpenTigServer(config2) {
   let transport = null;
   const auth = await OpenTigSessionAuth.open({
     source: config2.auth,
+    browserAccessEnabled: config2.browserAccessEnabled ?? config2.mode === "web-access",
     ...config2.profile ? { profile: config2.profile } : {},
     dataDirectory: config2.serverDataPath ?? path.join(path.dirname(config2.settingsPath), "server"),
     ...config2.secureCookies === void 0 ? {} : { secureCookies: config2.secureCookies }
@@ -20408,6 +21949,7 @@ async function runOpenTigServer(config2) {
       createPairingLink: () => pairingLink(address.origin, transport.createPairingToken()),
       getStatus: () => transport.getStatus(),
       revokeAllSessions: () => transport.revokeAllSessions(),
+      setBrowserAccessEnabled: (enabled) => transport.setBrowserAccessEnabled(enabled),
       close: () => transport.stop()
     };
   } catch (error) {