cogpit 2.1.3 → 2.3.0

package/dist/cli.js

@@ -73,7 +73,7 @@ var init_compression = __esm({
 import { StringDecoder } from "node:string_decoder";
 function readJsonBody(req, options = {}) {
   const maxBytes = options.maxBytes ?? DEFAULT_MAX_REQUEST_BODY_BYTES;
-  return new Promise((resolve21, reject) => {
+  return new Promise((resolve22, reject) => {
     let body = "";
     let bytesRead = 0;
     let settled = false;
@@ -97,11 +97,11 @@ function readJsonBody(req, options = {}) {
       settled = true;
       body += decoder.end();
       if (!body.trim() && options.allowEmpty) {
-        resolve21({});
+        resolve22({});
         return;
       }
       try {
-        resolve21(JSON.parse(body));
+        resolve22(JSON.parse(body));
       } catch {
         reject(new HttpBodyError("Invalid JSON body", 400));
       }
@@ -486,8 +486,8 @@ async function mint(device, generation2) {
   if (prev?.generation === generation2 && prev.error && Date.now() - prev.at < MINT_COOLDOWN_MS) {
     throw prev.error;
   }
-  const record2 = { at: Date.now(), generation: generation2 };
-  lastAttempt.set(id, record2);
+  const record4 = { at: Date.now(), generation: generation2 };
+  lastAttempt.set(id, record4);
   const url = `${device.tls ? "https" : "http"}://${device.host}:${device.port}/api/auth/verify`;
   const credential = device.username ? `${device.username}:${device.password ?? ""}` : device.password ?? "";
   let res;
@@ -503,7 +503,7 @@ async function mint(device, generation2) {
       `Could not reach device "${device.name}" at ${device.host}:${device.port}`,
       { cause: err }
     );
-    record2.error = error;
+    record4.error = error;
     if (generationIsCurrent(id, generation2)) {
       setDeviceRuntime(id, { lastProbe: Date.now() });
     }
@@ -511,7 +511,7 @@ async function mint(device, generation2) {
   }
   if (res.status === 401 || res.status === 403) {
     const error = new DeviceAuthError(id, `Device "${device.name}" rejected the password`, res.status);
-    record2.error = error;
+    record4.error = error;
     if (generationIsCurrent(id, generation2)) {
       setDeviceRuntime(id, { authState: "bad-password", lastProbe: Date.now() });
     }
@@ -522,7 +522,7 @@ async function mint(device, generation2) {
       id,
       `Device "${device.name}" returned HTTP ${res.status} while minting a token`
     );
-    record2.error = error;
+    record4.error = error;
     if (generationIsCurrent(id, generation2)) {
       setDeviceRuntime(id, { lastProbe: Date.now() });
     }
@@ -536,7 +536,7 @@ async function mint(device, generation2) {
   }
   if (!body || body.valid === false || typeof body.token !== "string" || !body.token) {
     const error = new DeviceAuthError(id, `Device "${device.name}" did not return a valid token`, res.status);
-    record2.error = error;
+    record4.error = error;
     if (generationIsCurrent(id, generation2)) {
       setDeviceRuntime(id, { authState: "bad-password", lastProbe: Date.now() });
     }
@@ -779,6 +779,7 @@ var init_agent_descriptors = __esm({
           args: ["update"],
           matches: (path) => path.endsWith("/.local/bin/claude") || path.endsWith("/.local/bin/claude.exe") || path.includes("/.local/share/claude/")
         },
+        bundledBySdk: true,
         homeDirName: ".claude",
         homeEnvVar: null,
         installMarker: "projects",
@@ -915,6 +916,7 @@ var init_agent_descriptors = __esm({
         // Codex ships no self-updater; a hand-placed binary has to be replaced by
         // whatever put it there.
         selfUpdate: null,
+        bundledBySdk: false,
         homeDirName: ".codex",
         homeEnvVar: "CODEX_HOME",
         installMarker: "",
@@ -1025,6 +1027,7 @@ var init_agent_descriptors = __esm({
           // only do because the caller passes the realpath in as well.
           matches: (path) => path.endsWith("/.local/bin/copilot") || path === "/usr/local/bin/copilot"
         },
+        bundledBySdk: false,
         homeDirName: ".copilot",
         homeEnvVar: "COPILOT_HOME",
         installMarker: "session-state",
@@ -1161,7 +1164,7 @@ function verifyPassword(password, stored) {
 async function verifyPasswordAsync(password, stored) {
   const scryptHash = parseScryptHash(stored);
   if (!scryptHash) return verifyPassword(password, stored);
-  const candidate = await new Promise((resolve21, reject) => {
+  const candidate = await new Promise((resolve22, reject) => {
     scrypt(
       password,
       Buffer.from(scryptHash.salt, "hex"),
@@ -1172,7 +1175,7 @@ async function verifyPasswordAsync(password, stored) {
         p: SCRYPT_PARALLELISM,
         maxmem: SCRYPT_MAX_MEMORY
       },
-      (error, derivedKey) => error ? reject(error) : resolve21(derivedKey)
+      (error, derivedKey) => error ? reject(error) : resolve22(derivedKey)
     );
   });
   return safeCompareBuffers(candidate, Buffer.from(scryptHash.hash, "hex"));
@@ -1236,6 +1239,9 @@ function hasExtension(binName, extensions) {
 function hasExecutableExtension(fileName, env = process.env) {
   return hasExtension(fileName, pathExtensions({ env }));
 }
+function isDirectlyLaunchable(fileName) {
+  return DIRECT_EXTENSIONS.includes(win32.extname(fileName).toLowerCase());
+}
 function findExecutableOnPath(binName, options = {}) {
   const windows = isWindows(options);
   const path = windows ? win32 : posix;
@@ -1280,7 +1286,7 @@ function resolveAgentCommand(binName, args = [], options = {}) {
   if (!isWindows(options)) return { command: binName, args, spawnOptions: {} };
   const resolved = /[\\/]/.test(binName) ? binName : findExecutableOnPath(binName, options);
   if (!resolved) return { command: binName, args, spawnOptions: {} };
-  if (DIRECT_EXTENSIONS.includes(win32.extname(resolved).toLowerCase())) {
+  if (isDirectlyLaunchable(resolved)) {
     return { command: resolved, args, spawnOptions: {} };
   }
   return throughCmdExe(resolved, args, options);
@@ -1297,6 +1303,38 @@ var init_binaryResolver = __esm({
   }
 });
 
+// ../../shared/contracts/agentExecutable.ts
+function isExecutableSource(value) {
+  return EXECUTABLE_SOURCES.includes(value);
+}
+function parseExecutableChoice(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const { source, path } = value;
+  if (!isExecutableSource(source) || source === "auto") return void 0;
+  if (source === "custom") {
+    return typeof path === "string" && path.trim() ? { source, path: path.trim() } : void 0;
+  }
+  return { source };
+}
+var EXECUTABLE_SOURCES, DEFAULT_EXECUTABLE_CHOICE, DETECTED_EXECUTABLE_SOURCES;
+var init_agentExecutable = __esm({
+  "../../shared/contracts/agentExecutable.ts"() {
+    EXECUTABLE_SOURCES = [
+      "auto",
+      "path",
+      "npm",
+      "bundled",
+      "custom"
+    ];
+    DEFAULT_EXECUTABLE_CHOICE = { source: "auto" };
+    DETECTED_EXECUTABLE_SOURCES = [
+      "path",
+      "npm",
+      "bundled"
+    ];
+  }
+});
+
 // ../../server/config.ts
 import { readFile as readFile2, stat, readdir, chmod as chmod3 } from "node:fs/promises";
 import { join as join2, resolve } from "node:path";
@@ -1405,7 +1443,8 @@ async function loadConfig() {
         networkPassword,
         terminalApp: parsed.terminalApp || void 0,
         editorApp: parsed.editorApp || void 0,
-        useBuiltInEditor: !!parsed.useBuiltInEditor
+        useBuiltInEditor: !!parsed.useBuiltInEditor,
+        agentExecutable: parseExecutableChoice(parsed.agentExecutable)
       };
       return cachedConfig;
     }
@@ -1460,6 +1499,7 @@ var init_config = __esm({
     init_password_utils();
     init_atomicJsonFile();
     init_binaryResolver();
+    init_agentExecutable();
     CONFIG_FILE_MODE = 384;
     __dirname = fileURLToPath(new URL(".", import.meta.url));
     PROJECT_ROOT = resolve(__dirname, "..");
@@ -3959,7 +3999,7 @@ async function createShare(input) {
   const passwordHash = hashPassword(passphrase);
   const share = await commitShareMutation((draft) => {
     const existing = draft.get(input.sessionId);
-    const record2 = {
+    const record4 = {
       sessionId: input.sessionId,
       dirName: input.dirName,
       fileName: input.fileName,
@@ -3968,8 +4008,8 @@ async function createShare(input) {
       // No guest has ever used this passphrase; the UI renders 0 as "never".
       lastAccessAt: 0
     };
-    draft.set(record2.sessionId, record2);
-    return { changed: true, value: toPublicShare(record2) };
+    draft.set(record4.sessionId, record4);
+    return { changed: true, value: toPublicShare(record4) };
   });
   return { share, passphrase };
 }
@@ -4819,6 +4859,8 @@ var init_policy = __esm({
       "project-files": admin("/api/project-files"),
       "project-file": admin("/api/project-file"),
       "git-status": admin("/api/git-status"),
+      "github-actions": admin("/api/github-actions"),
+      "vercel-deployments": admin("/api/vercel-deployments"),
       "project-icon": admin("/api/project-icon"),
       "git-diff": admin("/api/git-diff"),
       mcp: admin("/api/mcp-servers"),
@@ -4847,6 +4889,10 @@ var init_policy = __esm({
       "provider-updates": [
         { prefix: "/api/provider-updates", methods: ["GET"], requires: "authed" },
         { prefix: "/api/provider-updates/run", requires: "admin" }
+      ],
+      // Reports which binary the server spawns; the choice itself is saved through /api/config.
+      "agent-executable": [
+        { prefix: "/api/agent-executable", methods: ["GET"], requires: "authed" }
       ]
     };
     ALL_RULES = Object.values(ROUTE_POLICIES).flat();
@@ -5619,6 +5665,274 @@ var init_subagentWatcher = __esm({
   }
 });
 
+// ../../shared/versions.ts
+function parseVersion(raw) {
+  const match = raw.trim().replace(/^v/i, "").match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/);
+  if (!match) return null;
+  return {
+    parts: [Number(match[1]), Number(match[2]), Number(match[3])],
+    prerelease: match[4] ? match[4].split(".") : []
+  };
+}
+function extractVersion(output) {
+  const match = output.match(/\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/);
+  return match ? match[0] : null;
+}
+function comparePrerelease(a, b) {
+  if (a.length === 0 && b.length === 0) return 0;
+  if (a.length === 0) return 1;
+  if (b.length === 0) return -1;
+  for (let i = 0; i < Math.max(a.length, b.length); i += 1) {
+    const left = a[i];
+    const right = b[i];
+    if (left === void 0) return -1;
+    if (right === void 0) return 1;
+    const leftNumeric = /^\d+$/.test(left);
+    const rightNumeric = /^\d+$/.test(right);
+    if (leftNumeric && rightNumeric) {
+      if (Number(left) !== Number(right)) return Number(left) < Number(right) ? -1 : 1;
+      continue;
+    }
+    if (leftNumeric !== rightNumeric) return leftNumeric ? -1 : 1;
+    if (left !== right) return left < right ? -1 : 1;
+  }
+  return 0;
+}
+function compareVersions(a, b) {
+  const left = parseVersion(a);
+  const right = parseVersion(b);
+  if (!left || !right) return null;
+  for (let i = 0; i < 3; i += 1) {
+    if (left.parts[i] !== right.parts[i]) return left.parts[i] < right.parts[i] ? -1 : 1;
+  }
+  return comparePrerelease(left.prerelease, right.prerelease);
+}
+var init_versions = __esm({
+  "../../shared/versions.ts"() {
+  }
+});
+
+// ../../server/lib/cliProcess.ts
+import { spawn } from "node:child_process";
+function runCli(executable, args, timeoutMs) {
+  return new Promise((resolve22) => {
+    const resolved = resolveAgentCommand(executable, [...args]);
+    const child = spawn(resolved.command, resolved.args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      ...resolved.spawnOptions
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGKILL");
+    }, timeoutMs);
+    const append = (buffer, chunk) => buffer.length >= CLI_OUTPUT_MAX_CHARS ? buffer : buffer + chunk.toString();
+    child.stdout?.on("data", (chunk) => {
+      stdout = append(stdout, chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr = append(stderr, chunk);
+    });
+    child.on("error", () => {
+      clearTimeout(timer);
+      resolve22({ code: null, stdout, stderr, timedOut });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve22({ code, stdout, stderr, timedOut });
+    });
+  });
+}
+async function probeCliVersion(command, versionArgs, timeoutMs = DEFAULT_PROBE_TIMEOUT_MS) {
+  const probe = await runCli(command, versionArgs, timeoutMs);
+  return extractVersion(`${probe.stdout}
+${probe.stderr}`);
+}
+var DEFAULT_PROBE_TIMEOUT_MS, CLI_OUTPUT_MAX_CHARS;
+var init_cliProcess = __esm({
+  "../../server/lib/cliProcess.ts"() {
+    init_versions();
+    init_binaryResolver();
+    DEFAULT_PROBE_TIMEOUT_MS = 5e3;
+    CLI_OUTPUT_MAX_CHARS = 1e4;
+  }
+});
+
+// ../../server/agents/claudeExecutable.ts
+import { execFileSync } from "node:child_process";
+import { readFileSync, statSync as statSync2 } from "node:fs";
+import { createRequire } from "node:module";
+import { posix as posix2, win32 as win322 } from "node:path";
+function realIsFile(path) {
+  try {
+    return statSync2(path).isFile();
+  } catch {
+    return false;
+  }
+}
+function realReadFile(path) {
+  try {
+    return readFileSync(path, "utf-8");
+  } catch {
+    return void 0;
+  }
+}
+function binField(manifest) {
+  let bin;
+  try {
+    bin = JSON.parse(manifest).bin;
+  } catch {
+    return void 0;
+  }
+  if (typeof bin === "string") return bin;
+  if (!bin || typeof bin !== "object") return void 0;
+  const entry = bin[BIN_NAME];
+  return typeof entry === "string" ? entry : void 0;
+}
+function findNpmClaude(options = {}) {
+  const platform2 = options.platform ?? process.platform;
+  const windows = platform2 === "win32";
+  const path = windows ? win322 : posix2;
+  const isFile = options.isFile ?? realIsFile;
+  const readFile22 = options.readFile ?? realReadFile;
+  const shim = findExecutableOnPath(BIN_NAME, { platform: platform2, env: options.env, isExecutable: isFile });
+  if (!shim) return void 0;
+  const shimDir = path.dirname(shim);
+  const packageDirs = [
+    path.join(shimDir, "node_modules", NPM_PACKAGE),
+    path.join(shimDir, "..", "lib", "node_modules", NPM_PACKAGE)
+  ];
+  for (const packageDir of packageDirs) {
+    const manifest = readFile22(path.join(packageDir, "package.json"));
+    if (!manifest) continue;
+    const relative11 = binField(manifest);
+    if (!relative11) continue;
+    const target = path.normalize(path.join(packageDir, relative11));
+    if (windows && !isDirectlyLaunchable(target)) continue;
+    if (isFile(target)) return target;
+  }
+  return void 0;
+}
+function findInstalledClaude() {
+  return findExecutableOnPath(BIN_NAME, { directOnly: true });
+}
+function findBundledClaude(resolveModule2) {
+  try {
+    const platformPkg = `@anthropic-ai/claude-agent-sdk-${process.platform}-${process.arch}`;
+    return resolveModule2(`${platformPkg}/package.json`).replace(/package\.json$/, CLI_BIN_NAME).replace(ASAR_SEGMENT, "$1app.asar.unpacked$2");
+  } catch {
+    return void 0;
+  }
+}
+function discoverClaudeExecutables(resolveModule2, probes = {}) {
+  return {
+    installed: (probes.findOnPath ?? findInstalledClaude)(),
+    npm: (probes.findNpm ?? findNpmClaude)(),
+    bundled: findBundledClaude(resolveModule2)
+  };
+}
+function readCliVersionSync(binPath) {
+  try {
+    const output = execFileSync(binPath, ["--version"], {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const match = output.match(/(\d+)\.(\d+)\.(\d+)/);
+    return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isAtLeast(version, floor) {
+  for (let i = 0; i < 3; i += 1) {
+    if (version[i] !== floor[i]) return version[i] > floor[i];
+  }
+  return true;
+}
+function chooseAutomatically(found, readVersion) {
+  const bundled = found.bundled ? { source: "bundled", path: found.bundled } : void 0;
+  if (!found.installed) return bundled;
+  const installed = { source: "path", path: found.installed };
+  const installedVersion = readVersion(found.installed);
+  if (!installedVersion) return bundled ?? installed;
+  const bundledVersion = bundled ? readVersion(bundled.path) : void 0;
+  if (bundledVersion && !isAtLeast(installedVersion, bundledVersion)) return bundled;
+  return installed;
+}
+function chooseClaudeExecutable(choice, found, readVersion) {
+  switch (choice.source) {
+    case "auto":
+      return chooseAutomatically(found, readVersion);
+    case "custom":
+      return choice.path ? { source: "custom", path: choice.path } : void 0;
+    case "path":
+      return found.installed ? { source: "path", path: found.installed } : void 0;
+    case "npm":
+      return found.npm ? { source: "npm", path: found.npm } : void 0;
+    case "bundled":
+      return found.bundled ? { source: "bundled", path: found.bundled } : void 0;
+  }
+}
+function configuredChoice() {
+  return getConfig()?.agentExecutable ?? DEFAULT_EXECUTABLE_CHOICE;
+}
+function resolveClaudeExecutable() {
+  const choice = configuredChoice();
+  const key2 = JSON.stringify(choice);
+  if (memo?.key !== key2) {
+    memo = {
+      key: key2,
+      resolved: chooseClaudeExecutable(choice, discoverClaudeExecutables(resolveModule), readCliVersionSync)
+    };
+  }
+  return memo.resolved;
+}
+function claudeCliPath() {
+  return resolveClaudeExecutable()?.path;
+}
+async function describeClaudeExecutable() {
+  const choice = configuredChoice();
+  const found = discoverClaudeExecutables(resolveModule);
+  const active = resolveClaudeExecutable();
+  const pathBySource = {
+    path: found.installed,
+    npm: found.npm,
+    bundled: found.bundled
+  };
+  const detected = DETECTED_EXECUTABLE_SOURCES.filter((source) => pathBySource[source] !== void 0).map((source) => ({ source, path: pathBySource[source] }));
+  const paths = /* @__PURE__ */ new Set([...detected.map(({ path }) => path), ...active ? [active.path] : []]);
+  const versions = new Map(
+    await Promise.all(
+      [...paths].map(async (path) => [path, await probeCliVersion(path, ["--version"])])
+    )
+  );
+  return {
+    choice,
+    candidates: detected.map((candidate) => ({
+      ...candidate,
+      version: versions.get(candidate.path) ?? null
+    })),
+    active: active ? { ...active, version: versions.get(active.path) ?? null } : null
+  };
+}
+var BIN_NAME, NPM_PACKAGE, CLI_BIN_NAME, ASAR_SEGMENT, resolveModule, memo;
+var init_claudeExecutable = __esm({
+  "../../server/agents/claudeExecutable.ts"() {
+    init_agentExecutable();
+    init_config();
+    init_binaryResolver();
+    init_cliProcess();
+    BIN_NAME = "claude";
+    NPM_PACKAGE = "@anthropic-ai/claude-code";
+    CLI_BIN_NAME = nativeBinaryName(BIN_NAME);
+    ASAR_SEGMENT = /([\\/])app\.asar([\\/])/;
+    resolveModule = (id) => createRequire(import.meta.url).resolve(id);
+  }
+});
+
 // ../../server/lib/streamBus.ts
 function getOrCreate(sessionId) {
   let state = sessions2.get(sessionId);
@@ -5887,58 +6201,6 @@ var init_streamBus = __esm({
 
 // ../../server/sdk-session.ts
 import { query } from "@anthropic-ai/claude-agent-sdk";
-import { execFileSync } from "node:child_process";
-import { createRequire } from "node:module";
-function findClaudeOnPath() {
-  return findExecutableOnPath("claude", { directOnly: true });
-}
-function readCliVersion(binPath) {
-  try {
-    const output = execFileSync(binPath, ["--version"], {
-      encoding: "utf-8",
-      timeout: 5e3,
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    const match = output.match(/(\d+)\.(\d+)\.(\d+)/);
-    return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function isAtLeast(version, floor) {
-  for (let i = 0; i < 3; i += 1) {
-    if (version[i] !== floor[i]) return version[i] > floor[i];
-  }
-  return true;
-}
-function resolveClaudeCliPath(resolveModule, probes = {}) {
-  const findOnPath = probes.findOnPath ?? findClaudeOnPath;
-  const readVersion = probes.readVersion ?? readCliVersion;
-  let vendored;
-  try {
-    const platformPkg = `@anthropic-ai/claude-agent-sdk-${process.platform}-${process.arch}`;
-    vendored = resolveModule(`${platformPkg}/package.json`).replace(/package\.json$/, CLI_BIN_NAME);
-  } catch {
-    vendored = void 0;
-  }
-  const insideAsar = vendored !== void 0 && ASAR_SEGMENT.test(vendored);
-  const vendoredExecutable = insideAsar ? vendored.replace(ASAR_SEGMENT, "$1app.asar.unpacked$2") : vendored;
-  const fallback = insideAsar ? vendoredExecutable : void 0;
-  const installed = findOnPath();
-  if (!installed) return fallback;
-  const installedVersion = readVersion(installed);
-  if (!installedVersion) return vendoredExecutable ? fallback : installed;
-  const vendoredVersion = vendoredExecutable ? readVersion(vendoredExecutable) : void 0;
-  if (vendoredVersion && !isAtLeast(installedVersion, vendoredVersion)) return fallback;
-  return installed;
-}
-function claudeCliPath() {
-  if (!cliPathProbed) {
-    cliPath = resolveClaudeCliPath((id) => createRequire(import.meta.url).resolve(id));
-    cliPathProbed = true;
-  }
-  return cliPath;
-}
 function streamingEnabled() {
   const raw = process.env.COGPIT_STREAM_PARTIAL;
   if (raw === void 0) return true;
@@ -5956,16 +6218,16 @@ function makeCanUseTool(state) {
   return (toolName, input, options) => {
     if (toolName === "AskUserQuestion") {
       const toolUseId = options.toolUseID;
-      return new Promise((resolve21) => {
+      return new Promise((resolve22) => {
         const pending = {
           input,
           askedAt: Date.now(),
-          resolve: resolve21
+          resolve: resolve22
         };
         state.pendingUserQuestions.set(toolUseId, pending);
         const onAbort = () => {
           if (state.pendingUserQuestions.delete(toolUseId)) {
-            resolve21({ behavior: "deny", message: "Session aborted", interrupt: true });
+            resolve22({ behavior: "deny", message: "Session aborted", interrupt: true });
           }
         };
         options.signal?.addEventListener("abort", onAbort, { once: true });
@@ -5978,7 +6240,7 @@ function makeCanUseTool(state) {
       return Promise.resolve({ behavior: "allow", updatedInput: input });
     }
     const requestId = options.toolUseID;
-    return new Promise((resolve21) => {
+    return new Promise((resolve22) => {
       const pending = {
         requestId,
         toolName,
@@ -5991,12 +6253,12 @@ function makeCanUseTool(state) {
         blockedPath: options.blockedPath,
         suggestions: options.suggestions,
         timestamp: Date.now(),
-        resolve: resolve21
+        resolve: resolve22
       };
       state.pendingPermissions.set(requestId, pending);
       const onAbort = () => {
         if (state.pendingPermissions.delete(requestId)) {
-          resolve21({ behavior: "deny", message: "Session aborted", interrupt: true });
+          resolve22({ behavior: "deny", message: "Session aborted", interrupt: true });
         }
       };
       options.signal?.addEventListener("abort", onAbort, { once: true });
@@ -6073,16 +6335,16 @@ function makeOnElicitation(state) {
       );
       return Promise.resolve({ action: "decline" });
     }
-    return new Promise((resolve21) => {
+    return new Promise((resolve22) => {
       const requestId = options.requestId;
       state.pendingElicitations.set(requestId, {
         request,
         fields: projection.fields,
         askedAt: Date.now(),
-        resolve: resolve21
+        resolve: resolve22
       });
       const onAbort = () => {
-        if (state.pendingElicitations.delete(requestId)) resolve21({ action: "decline" });
+        if (state.pendingElicitations.delete(requestId)) resolve22({ action: "decline" });
       };
       options.signal?.addEventListener("abort", onAbort, { once: true });
     });
@@ -6106,14 +6368,14 @@ function makeOnUserDialog(state) {
     if (!(request.dialogKind in DIALOG_CHOICES)) return Promise.resolve(null);
     const projected = projectUserDialog(request);
     if (!projected) return Promise.resolve({ behavior: "cancelled" });
-    return new Promise((resolve21) => {
+    return new Promise((resolve22) => {
       const requestId = options.requestId;
       state.pendingUserDialogs.set(requestId, {
         dialog: { ...projected, requestId, askedAt: Date.now() },
-        resolve: resolve21
+        resolve: resolve22
       });
       const onAbort = () => {
-        if (state.pendingUserDialogs.delete(requestId)) resolve21({ behavior: "cancelled" });
+        if (state.pendingUserDialogs.delete(requestId)) resolve22({ behavior: "cancelled" });
       };
       options.signal?.addEventListener("abort", onAbort, { once: true });
     });
@@ -6824,15 +7086,12 @@ function cleanupAllSDKSessions() {
   sdkSessions.clear();
   return killed;
 }
-var CLI_BIN_NAME, ASAR_SEGMENT, cliPathProbed, cliPath, sdkSessions, REFUSAL_FALLBACK_DIALOG, DIALOG_CHOICES, SUPPORTED_DIALOG_KINDS, SDKMessageStream, EDIT_TOOL_NAMES;
+var sdkSessions, REFUSAL_FALLBACK_DIALOG, DIALOG_CHOICES, SUPPORTED_DIALOG_KINDS, SDKMessageStream, EDIT_TOOL_NAMES;
 var init_sdk_session = __esm({
   "../../server/sdk-session.ts"() {
     init_subagentWatcher();
-    init_binaryResolver();
+    init_claudeExecutable();
     init_streamBus();
-    CLI_BIN_NAME = nativeBinaryName("claude");
-    ASAR_SEGMENT = /([\\/])app\.asar([\\/])/;
-    cliPathProbed = false;
     sdkSessions = /* @__PURE__ */ new Map();
     REFUSAL_FALLBACK_DIALOG = "refusal_fallback_prompt";
     DIALOG_CHOICES = {
@@ -6845,8 +7104,8 @@ var init_sdk_session = __esm({
       closed = false;
       enqueue(message) {
         if (this.closed) return false;
-        const resolve21 = this.waiting.shift();
-        if (resolve21) resolve21({ value: message, done: false });
+        const resolve22 = this.waiting.shift();
+        if (resolve22) resolve22({ value: message, done: false });
         else this.queued.push(message);
         return true;
       }
@@ -6854,15 +7113,15 @@ var init_sdk_session = __esm({
         if (this.closed) return;
         this.closed = true;
         this.queued.length = 0;
-        for (const resolve21 of this.waiting.splice(0)) {
-          resolve21({ value: void 0, done: true });
+        for (const resolve22 of this.waiting.splice(0)) {
+          resolve22({ value: void 0, done: true });
         }
       }
       next() {
         const message = this.queued.shift();
         if (message) return Promise.resolve({ value: message, done: false });
         if (this.closed) return Promise.resolve({ value: void 0, done: true });
-        return new Promise((resolve21) => this.waiting.push(resolve21));
+        return new Promise((resolve22) => this.waiting.push(resolve22));
       }
       return() {
         this.close();
@@ -6998,8 +7257,8 @@ var init_agent_prompts = __esm({
 function observeExit(proc) {
   let didExit = proc.exitCode !== null && proc.exitCode !== void 0 || proc.signalCode !== null && proc.signalCode !== void 0;
   let resolveExit = () => void 0;
-  const exited = new Promise((resolve21) => {
-    resolveExit = resolve21;
+  const exited = new Promise((resolve22) => {
+    resolveExit = resolve22;
   });
   if (didExit) resolveExit();
   const markExited = () => {
@@ -7025,14 +7284,14 @@ function observeExit(proc) {
 async function waitForExit(observers, timeoutMs, onTimeout = () => void 0) {
   const pending = observers.filter((observer) => !observer.hasExited());
   if (pending.length === 0) return;
-  await new Promise((resolve21) => {
+  await new Promise((resolve22) => {
     const timer = setTimeout(() => {
       onTimeout();
-      resolve21();
+      resolve22();
     }, timeoutMs);
     void Promise.all(pending.map((observer) => observer.exited)).then(() => {
       clearTimeout(timer);
-      resolve21();
+      resolve22();
     });
   });
 }
@@ -7315,7 +7574,7 @@ async function readClaudeSessionMeta(filePath, head) {
   let cwd = "";
   let firstUserMessage = "";
   let lastUserMessage = "";
-  let timestamp = "";
+  let timestamp2 = "";
   let lastTimestamp = "";
   let turnCount = 0;
   let aiTitle = "";
@@ -7354,8 +7613,8 @@ async function readClaudeSessionMeta(filePath, head) {
       if (obj.type === "assistant" && obj.message?.model && !model) {
         model = obj.message.model;
       }
-      if (obj.type === "user" && !obj.isMeta && !timestamp) {
-        timestamp = obj.timestamp || "";
+      if (obj.type === "user" && !obj.isMeta && !timestamp2) {
+        timestamp2 = obj.timestamp || "";
       }
       if (obj.type === "user" && !obj.isMeta) {
         if (obj.timestamp) lastTimestamp = obj.timestamp;
@@ -7450,8 +7709,8 @@ async function readClaudeSessionMeta(filePath, head) {
     cwd,
     firstUserMessage,
     lastUserMessage,
-    timestamp,
-    lastTimestamp: lastTimestamp || timestamp,
+    timestamp: timestamp2,
+    lastTimestamp: lastTimestamp || timestamp2,
     turnCount,
     lineCount: isPartialRead ? Math.round(head.size / (HEAD_BYTES / lines.length)) : lines.length,
     branchedFrom,
@@ -7740,7 +7999,7 @@ var init_sessionStats = __esm({
 });
 
 // ../../shared/session/turnContent.ts
-function appendAssistantText(turn, text, timestamp) {
+function appendAssistantText(turn, text, timestamp2) {
   if (!text) return;
   turn.assistantText.push(text);
   const last = turn.contentBlocks[turn.contentBlocks.length - 1];
@@ -7748,7 +8007,7 @@ function appendAssistantText(turn, text, timestamp) {
     last.text.push(text);
     return;
   }
-  turn.contentBlocks.push({ kind: "text", text: [text], timestamp });
+  turn.contentBlocks.push({ kind: "text", text: [text], timestamp: timestamp2 });
 }
 var init_turnContent = __esm({
   "../../shared/session/turnContent.ts"() {
@@ -8118,7 +8377,7 @@ function resolveCodexPatchPath(filePath, cwd) {
   const relative11 = filePath.replace(/^\.[\\/]/, "");
   return /^[A-Za-z]:[\\/]/.test(cwd) ? `${base}\\${relative11.replace(/\//g, "\\")}` : `${base}/${relative11}`;
 }
-function parseApplyPatch(patchText, callId, timestamp, cwd = "") {
+function parseApplyPatch(patchText, callId, timestamp2, cwd = "") {
   const toolCalls = [];
   const filePattern = /^\*\*\*\s+(Update File|Add File|Delete File):\s*(.+)$/gm;
   const sections = [];
@@ -8161,7 +8420,7 @@ function parseApplyPatch(patchText, callId, timestamp, cwd = "") {
         input: { file_path: filePath, content: newLines.join("\n") },
         result: null,
         isError: false,
-        timestamp
+        timestamp: timestamp2
       });
     } else if (section.action === "Delete File") {
       toolCalls.push({
@@ -8170,7 +8429,7 @@ function parseApplyPatch(patchText, callId, timestamp, cwd = "") {
         input: { file_path: filePath, old_string: oldLines.join("\n"), new_string: "" },
         result: null,
         isError: false,
-        timestamp
+        timestamp: timestamp2
       });
     } else {
       toolCalls.push({
@@ -8184,18 +8443,18 @@ function parseApplyPatch(patchText, callId, timestamp, cwd = "") {
         },
         result: null,
         isError: false,
-        timestamp
+        timestamp: timestamp2
       });
     }
   }
   return toolCalls;
 }
-function parseCodexToolPatches(toolName, rawInput, callId, timestamp, cwd = "") {
+function parseCodexToolPatches(toolName, rawInput, callId, timestamp2, cwd = "") {
   if (toolName === "apply_patch") {
-    return parseApplyPatch(rawInput, callId, timestamp, cwd);
+    return parseApplyPatch(rawInput, callId, timestamp2, cwd);
   }
   return extractApplyPatchInputs(rawInput).flatMap(
-    (patch, patchIndex) => parseApplyPatch(patch, `${callId}:patch-${patchIndex}`, timestamp, cwd)
+    (patch, patchIndex) => parseApplyPatch(patch, `${callId}:patch-${patchIndex}`, timestamp2, cwd)
   );
 }
 function findFailedNestedPatchCallIds(output, wrapperIsError, calls) {
@@ -8320,9 +8579,9 @@ function safeParseLine(line) {
 function isObject2(value) {
   return typeof value === "object" && value !== null;
 }
-function isCodexRecord(record2) {
-  if (!record2 || typeof record2.type !== "string") return false;
-  return record2.type === "session_meta" || record2.type === "turn_context" || record2.type === "event_msg" || record2.type === "response_item" || record2.type === "inter_agent_communication_metadata" || record2.type === "compacted" || record2.type === "world_state";
+function isCodexRecord(record4) {
+  if (!record4 || typeof record4.type !== "string") return false;
+  return record4.type === "session_meta" || record4.type === "turn_context" || record4.type === "event_msg" || record4.type === "response_item" || record4.type === "inter_agent_communication_metadata" || record4.type === "compacted" || record4.type === "world_state";
 }
 function extractMessageText(payload, blockType) {
   const content = payload?.content;
@@ -8439,7 +8698,7 @@ function parseTokenUsage(value) {
     cache_read_input_tokens: cacheRead
   };
 }
-function appendThinking(turn, text, timestamp) {
+function appendThinking(turn, text, timestamp2) {
   if (!text) return;
   const block = { type: "thinking", thinking: text, signature: "" };
   turn.thinking.push(block);
@@ -8448,16 +8707,16 @@ function appendThinking(turn, text, timestamp) {
     last.blocks.push(block);
     return;
   }
-  turn.contentBlocks.push({ kind: "thinking", blocks: [block], timestamp });
+  turn.contentBlocks.push({ kind: "thinking", blocks: [block], timestamp: timestamp2 });
 }
-function appendToolCall(turn, toolCall, timestamp) {
+function appendToolCall(turn, toolCall, timestamp2) {
   turn.toolCalls.push(toolCall);
   const last = turn.contentBlocks[turn.contentBlocks.length - 1];
-  if (last && last.kind === "tool_calls" && last.timestamp === timestamp) {
+  if (last && last.kind === "tool_calls" && last.timestamp === timestamp2) {
     last.toolCalls.push(toolCall);
     return;
   }
-  turn.contentBlocks.push({ kind: "tool_calls", toolCalls: [toolCall], timestamp });
+  turn.contentBlocks.push({ kind: "tool_calls", toolCalls: [toolCall], timestamp: timestamp2 });
 }
 function finalizeTurn(turns, current, lastTimestamp) {
   if (!current) return null;
@@ -8508,37 +8767,37 @@ function parseMcpEventResult(value) {
     isError: ok.isError === true || parsedContent.isError
   };
 }
-function createTurn(turnId, timestamp, model) {
+function createTurn(turnId, timestamp2, model) {
   return {
-    id: turnId ? `${turnId}@${timestamp}` : randomTurnId("codex-turn"),
+    id: turnId ? `${turnId}@${timestamp2}` : randomTurnId("codex-turn"),
     userMessage: null,
     contentBlocks: [],
     thinking: [],
     assistantText: [],
     toolCalls: [],
     subAgentActivity: [],
-    timestamp,
+    timestamp: timestamp2,
     durationMs: null,
     tokenUsage: null,
     model
   };
 }
-function extractPromptFromRecord(record2) {
-  if (record2.type === "event_msg" && isObject2(record2.payload) && record2.payload.type === "user_message" && typeof record2.payload.message === "string") {
-    return normalizePromptText(record2.payload.message);
+function extractPromptFromRecord(record4) {
+  if (record4.type === "event_msg" && isObject2(record4.payload) && record4.payload.type === "user_message" && typeof record4.payload.message === "string") {
+    return normalizePromptText(record4.payload.message);
   }
-  if (record2.type === "response_item" && isObject2(record2.payload) && record2.payload.type === "message" && record2.payload.role === "user") {
-    return normalizePromptText(extractMessageText(record2.payload, "input_text"));
+  if (record4.type === "response_item" && isObject2(record4.payload) && record4.payload.type === "message" && record4.payload.role === "user") {
+    return normalizePromptText(extractMessageText(record4.payload, "input_text"));
   }
   return "";
 }
-function recordOpensTurn(record2, payload) {
-  if (record2.type === "session_meta") return false;
-  if (record2.type === "event_msg" && payload?.type === "task_started") return false;
-  if (record2.type === "response_item" && payload?.type === "message") {
+function recordOpensTurn(record4, payload) {
+  if (record4.type === "session_meta") return false;
+  if (record4.type === "event_msg" && payload?.type === "task_started") return false;
+  if (record4.type === "response_item" && payload?.type === "message") {
     if (payload.role === "developer" || payload.role === "system") return false;
     if (payload.role === "user") {
-      return extractPromptFromRecord(record2) !== "" || extractResponseMessageImages(payload).length > 0 || extractResponseMessageAudio(payload).length > 0;
+      return extractPromptFromRecord(record4) !== "" || extractResponseMessageImages(payload).length > 0 || extractResponseMessageAudio(payload).length > 0;
     }
   }
   return true;
@@ -8552,29 +8811,29 @@ function extractMetadataFromRecords(records) {
   let branchedFrom;
   let firstUserMessage = "";
   let lastUserMessage = "";
-  let timestamp = "";
+  let timestamp2 = "";
   let lastTimestamp = "";
   let turnCount = 0;
   let isSubagent = false;
   let parentSessionId = null;
   let agentPath = "/root";
   let previousPrompt = "";
-  for (const record2 of records) {
-    if (!isObject2(record2.payload)) continue;
-    if (record2.type === "session_meta") {
-      sessionId ||= typeof record2.payload.id === "string" ? record2.payload.id : "";
-      version ||= typeof record2.payload.cli_version === "string" ? record2.payload.cli_version : "";
-      cwd ||= typeof record2.payload.cwd === "string" ? record2.payload.cwd : "";
-      if (!branchedFrom && isObject2(record2.payload.branchedFrom)) {
-        const sourceId = typeof record2.payload.branchedFrom.sessionId === "string" ? record2.payload.branchedFrom.sessionId : "";
+  for (const record4 of records) {
+    if (!isObject2(record4.payload)) continue;
+    if (record4.type === "session_meta") {
+      sessionId ||= typeof record4.payload.id === "string" ? record4.payload.id : "";
+      version ||= typeof record4.payload.cli_version === "string" ? record4.payload.cli_version : "";
+      cwd ||= typeof record4.payload.cwd === "string" ? record4.payload.cwd : "";
+      if (!branchedFrom && isObject2(record4.payload.branchedFrom)) {
+        const sourceId = typeof record4.payload.branchedFrom.sessionId === "string" ? record4.payload.branchedFrom.sessionId : "";
         if (sourceId) {
           branchedFrom = {
             sessionId: sourceId,
-            turnIndex: typeof record2.payload.branchedFrom.turnIndex === "number" ? record2.payload.branchedFrom.turnIndex : null
+            turnIndex: typeof record4.payload.branchedFrom.turnIndex === "number" ? record4.payload.branchedFrom.turnIndex : null
           };
         }
       }
-      const source = isObject2(record2.payload.source) ? record2.payload.source : null;
+      const source = isObject2(record4.payload.source) ? record4.payload.source : null;
       if (source && isObject2(source.subagent)) {
         isSubagent = true;
         const threadSpawn = isObject2(source.subagent.thread_spawn) ? source.subagent.thread_spawn : null;
@@ -8582,27 +8841,27 @@ function extractMetadataFromRecords(records) {
           agentPath = threadSpawn.agent_path;
         }
       }
-      if (typeof record2.payload.forked_from_id === "string" && record2.payload.forked_from_id) {
-        parentSessionId = record2.payload.forked_from_id;
+      if (typeof record4.payload.forked_from_id === "string" && record4.payload.forked_from_id) {
+        parentSessionId = record4.payload.forked_from_id;
       }
-      const git = isObject2(record2.payload.git) ? record2.payload.git : null;
+      const git = isObject2(record4.payload.git) ? record4.payload.git : null;
       gitBranch ||= git && typeof git.branch === "string" ? git.branch : "";
     }
-    if (record2.type === "turn_context") {
-      model ||= typeof record2.payload.model === "string" ? record2.payload.model : "";
-      cwd ||= typeof record2.payload.cwd === "string" ? record2.payload.cwd : "";
+    if (record4.type === "turn_context") {
+      model ||= typeof record4.payload.model === "string" ? record4.payload.model : "";
+      cwd ||= typeof record4.payload.cwd === "string" ? record4.payload.cwd : "";
     }
-    const prompt = extractPromptFromRecord(record2);
+    const prompt = extractPromptFromRecord(record4);
     if (!prompt) continue;
     if (prompt === previousPrompt) continue;
     if (!firstUserMessage) firstUserMessage = prompt;
     lastUserMessage = prompt;
     previousPrompt = prompt;
     turnCount++;
-    if (!timestamp) timestamp = record2.timestamp ?? "";
-    lastTimestamp = record2.timestamp ?? lastTimestamp;
+    if (!timestamp2) timestamp2 = record4.timestamp ?? "";
+    lastTimestamp = record4.timestamp ?? lastTimestamp;
   }
-  if (lastTimestamp === "") lastTimestamp = timestamp;
+  if (lastTimestamp === "") lastTimestamp = timestamp2;
   return {
     sessionId,
     version,
@@ -8614,7 +8873,7 @@ function extractMetadataFromRecords(records) {
     branchedFrom,
     firstUserMessage,
     lastUserMessage,
-    timestamp,
+    timestamp: timestamp2,
     lastTimestamp,
     turnCount,
     isSubagent,
@@ -8727,8 +8986,8 @@ function walkCodexRecords(records, options) {
     pendingTurnStart = null;
     return result;
   }
-  function createActiveTurn(turnId, timestamp, model) {
-    const turn = createTurn(turnId, timestamp, model);
+  function createActiveTurn(turnId, timestamp2, model) {
+    const turn = createTurn(turnId, timestamp2, model);
     pendingTurnStart = pendingContextIndex ?? recordIndex;
     pendingContextIndex = null;
     if (!sawTurnStart) turn.isFragment = true;
@@ -8738,7 +8997,7 @@ function walkCodexRecords(records, options) {
     }
     return turn;
   }
-  function upsertWebSearchCall(targetTurn, id, input, status, timestamp) {
+  function upsertWebSearchCall(targetTurn, id, input, status, timestamp2) {
     const existing = webSearchCalls.get(id);
     if (existing) {
       existing.input = { ...existing.input, ...input };
@@ -8752,39 +9011,39 @@ function walkCodexRecords(records, options) {
       input,
       result: status,
       isError: status === "failed",
-      timestamp
+      timestamp: timestamp2
     };
     webSearchCalls.set(id, toolCall);
-    appendToolCall(targetTurn, toolCall, timestamp);
+    appendToolCall(targetTurn, toolCall, timestamp2);
   }
   for (let index = 0; index < records.length; index++) {
-    const record2 = records[index];
-    if (!isCodexRecord(record2)) continue;
+    const record4 = records[index];
+    if (!isCodexRecord(record4)) continue;
     recordIndex = index;
-    const payload = isObject2(record2.payload) ? record2.payload : void 0;
-    const timestamp = record2.timestamp ?? "";
-    if (record2.type === "compacted") {
+    const payload = isObject2(record4.payload) ? record4.payload : void 0;
+    const timestamp2 = record4.timestamp ?? "";
+    if (record4.type === "compacted") {
       current = commitTurn(current);
       pendingCompaction = "Conversation compacted";
-      lastTurnTimestamp = timestamp;
+      lastTurnTimestamp = timestamp2;
       continue;
     }
-    if (record2.type === "world_state") continue;
-    if (record2.type === "turn_context") {
+    if (record4.type === "world_state") continue;
+    if (record4.type === "turn_context") {
       current = commitTurn(current);
       pendingContextIndex = index;
       currentTurnId = typeof payload?.turn_id === "string" ? payload.turn_id : null;
       currentModel = typeof payload?.model === "string" ? payload.model : currentModel;
-      lastTurnTimestamp = timestamp;
+      lastTurnTimestamp = timestamp2;
       sawTurnStart = true;
       continue;
     }
-    if (record2.type === "event_msg" && payload?.type === "user_message" && typeof payload.message === "string") {
+    if (record4.type === "event_msg" && payload?.type === "user_message" && typeof payload.message === "string") {
       if (current && (current.assistantText.length > 0 || current.toolCalls.length > 0 || current.thinking.length > 0)) {
         current = commitTurn(current);
       }
       sawTurnStart = true;
-      current ??= createActiveTurn(currentTurnId, timestamp, currentModel);
+      current ??= createActiveTurn(currentTurnId, timestamp2, currentModel);
       const localImages = (Array.isArray(payload.local_images) ? payload.local_images : []).filter(
         (p) => typeof p === "string" && p.length > 0
       );
@@ -8799,16 +9058,16 @@ function walkCodexRecords(records, options) {
         localAudio
       );
       current.isFragment = false;
-      current.timestamp = current.timestamp || timestamp;
-      lastTurnTimestamp = timestamp;
+      current.timestamp = current.timestamp || timestamp2;
+      lastTurnTimestamp = timestamp2;
       continue;
     }
-    if (!current && !recordOpensTurn(record2, payload)) continue;
-    current ??= createActiveTurn(currentTurnId, timestamp, currentModel);
+    if (!current && !recordOpensTurn(record4, payload)) continue;
+    current ??= createActiveTurn(currentTurnId, timestamp2, currentModel);
     if (!current.model && currentModel) current.model = currentModel;
-    if (!current.timestamp) current.timestamp = timestamp;
-    if (timestamp) lastTurnTimestamp = timestamp;
-    if (record2.type === "event_msg" && payload?.type === "token_count") {
+    if (!current.timestamp) current.timestamp = timestamp2;
+    if (timestamp2) lastTurnTimestamp = timestamp2;
+    if (record4.type === "event_msg" && payload?.type === "token_count") {
       const info = isObject2(payload.info) ? payload.info : null;
       const lastUsage = info ? parseTokenUsage(info.last_token_usage) : null;
       if (lastUsage) {
@@ -8816,14 +9075,14 @@ function walkCodexRecords(records, options) {
       }
       continue;
     }
-    if (record2.type === "event_msg" && payload?.type === "web_search_end" && typeof payload.call_id === "string") {
+    if (record4.type === "event_msg" && payload?.type === "web_search_end" && typeof payload.call_id === "string") {
       const input = {};
       if (typeof payload.query === "string" && payload.query) input.query = payload.query;
       if (isObject2(payload.action)) input.action = payload.action;
-      upsertWebSearchCall(current, payload.call_id, input, "completed", timestamp);
+      upsertWebSearchCall(current, payload.call_id, input, "completed", timestamp2);
       continue;
     }
-    if (record2.type === "event_msg" && payload?.type === "mcp_tool_call_end" && typeof payload.call_id === "string" && isObject2(payload.invocation)) {
+    if (record4.type === "event_msg" && payload?.type === "mcp_tool_call_end" && typeof payload.call_id === "string" && isObject2(payload.invocation)) {
       const invocation = payload.invocation;
       const server = typeof invocation.server === "string" ? invocation.server : "mcp";
       const tool = typeof invocation.tool === "string" ? invocation.tool : "tool";
@@ -8841,12 +9100,12 @@ function walkCodexRecords(records, options) {
           input,
           result: result.text,
           isError: result.isError,
-          timestamp
-        }, timestamp);
+          timestamp: timestamp2
+        }, timestamp2);
       }
       continue;
     }
-    if (record2.type === "event_msg" && payload?.type === "sub_agent_activity" && typeof payload.agent_thread_id === "string" && typeof payload.agent_path === "string") {
+    if (record4.type === "event_msg" && payload?.type === "sub_agent_activity" && typeof payload.agent_thread_id === "string" && typeof payload.agent_path === "string") {
       const agentId = payload.agent_thread_id;
       const eventId2 = typeof payload.event_id === "string" ? payload.event_id : "";
       const kind = typeof payload.kind === "string" ? payload.kind : "started";
@@ -8870,24 +9129,24 @@ function walkCodexRecords(records, options) {
         message: existing?.message ?? spawnInfo?.message ?? "",
         model: existing?.model ?? spawnInfo?.model ?? null,
         agentType: existing?.agentType ?? spawnInfo?.agentType ?? null,
-        timestamp: existing?.timestamp ?? (timestamp || spawnInfo?.timestamp || ""),
+        timestamp: existing?.timestamp ?? (timestamp2 || spawnInfo?.timestamp || ""),
         parentToolCallId: existing?.parentToolCallId ?? eventId2
       };
       agentRegistry.set(agentId, info);
       agentIdByPath.set(payload.agent_path, agentId);
       if (eventId2 && (kind === "started" || spawnInfo)) agentIdBySpawnCall.set(eventId2, agentId);
       const status = kind === "interrupted" ? "interrupted" : "running";
-      upsertAgentMessage(agentId, current, timestamp, { status });
+      upsertAgentMessage(agentId, current, timestamp2, { status });
       continue;
     }
-    if (record2.type !== "response_item" || !payload) continue;
+    if (record4.type !== "response_item" || !payload) continue;
     if (payload.type === "reasoning") {
       const summary = Array.isArray(payload.summary) ? payload.summary.filter((item) => typeof item === "string").join("\n") : "";
-      appendThinking(current, summary.trim(), timestamp);
+      appendThinking(current, summary.trim(), timestamp2);
       continue;
     }
     if (payload.type === "message" && payload.role === "assistant") {
-      appendAssistantText(current, extractMessageText(payload, "output_text"), timestamp);
+      appendAssistantText(current, extractMessageText(payload, "output_text"), timestamp2);
       continue;
     }
     if (payload.type === "message" && payload.role === "user" && current.userMessage === null) {
@@ -8905,7 +9164,7 @@ function walkCodexRecords(records, options) {
       const input = {};
       if (isObject2(payload.action)) input.action = payload.action;
       const status = typeof payload.status === "string" ? payload.status : "completed";
-      upsertWebSearchCall(current, payload.id, input, status, timestamp);
+      upsertWebSearchCall(current, payload.id, input, status, timestamp2);
       continue;
     }
     if (payload.type === "tool_search_call") {
@@ -8917,10 +9176,10 @@ function walkCodexRecords(records, options) {
           input: isObject2(payload.arguments) ? payload.arguments : {},
           result: null,
           isError: false,
-          timestamp
+          timestamp: timestamp2
         };
         pendingToolCalls.set(callId, toolCall);
-        appendToolCall(current, toolCall, timestamp);
+        appendToolCall(current, toolCall, timestamp2);
       }
       continue;
     }
@@ -8954,7 +9213,7 @@ function walkCodexRecords(records, options) {
           message: "",
           model: null,
           agentType: null,
-          timestamp,
+          timestamp: timestamp2,
           parentToolCallId: ""
         });
         agentIdByPath.set(author, agentId);
@@ -8964,7 +9223,7 @@ function walkCodexRecords(records, options) {
       else if (interAgentMessage.messageType === "ERROR" || interAgentMessage.messageType === "FAILED") status = "failed";
       else if (interAgentMessage.messageType === "INTERRUPTED") status = "interrupted";
       else if (interAgentMessage.messageType === "MESSAGE") status = "running";
-      upsertAgentMessage(agentId, current, timestamp, {
+      upsertAgentMessage(agentId, current, timestamp2, {
         status,
         text: interAgentMessage.text || void 0
       });
@@ -8989,7 +9248,7 @@ function walkCodexRecords(records, options) {
           taskName: typeof parsedInput.task_name === "string" ? parsedInput.task_name : null,
           model: typeof parsedInput.model === "string" ? parsedInput.model : null,
           agentType: typeof parsedInput.agent_type === "string" ? parsedInput.agent_type : null,
-          timestamp
+          timestamp: timestamp2
         });
       }
       const toolCall = {
@@ -8998,10 +9257,10 @@ function walkCodexRecords(records, options) {
         input,
         result: null,
         isError: false,
-        timestamp
+        timestamp: timestamp2
       };
       pendingToolCalls.set(toolCall.id, toolCall);
-      appendToolCall(current, toolCall, timestamp);
+      appendToolCall(current, toolCall, timestamp2);
       continue;
     }
     if (payload.type === "function_call_output" && typeof payload.call_id === "string") {
@@ -9027,13 +9286,13 @@ function walkCodexRecords(records, options) {
               message: existing?.message ?? spawnInfo?.message ?? "",
               model: existing?.model ?? spawnInfo?.model ?? null,
               agentType: existing?.agentType ?? spawnInfo?.agentType ?? null,
-              timestamp: existing?.timestamp ?? spawnInfo?.timestamp ?? timestamp,
+              timestamp: existing?.timestamp ?? spawnInfo?.timestamp ?? timestamp2,
               parentToolCallId: existing?.parentToolCallId ?? toolCall.id
             };
             agentRegistry.set(agentId, info);
             agentIdBySpawnCall.set(toolCall.id, agentId);
             if (info.agentPath) agentIdByPath.set(info.agentPath, agentId);
-            upsertAgentMessage(agentId, current, timestamp, { status: "running" });
+            upsertAgentMessage(agentId, current, timestamp2, { status: "running" });
           }
         } catch {
         }
@@ -9056,11 +9315,11 @@ function walkCodexRecords(records, options) {
                 message: "",
                 model: null,
                 agentType: null,
-                timestamp,
+                timestamp: timestamp2,
                 parentToolCallId: ""
               });
             }
-            upsertAgentMessage(agentId, current, timestamp, {
+            upsertAgentMessage(agentId, current, timestamp2, {
               status: lifecycle,
               text: completedText || failedText || interruptedText || void 0
             });
@@ -9074,7 +9333,7 @@ function walkCodexRecords(records, options) {
       const name = typeof payload.name === "string" ? payload.name : "tool";
       const rawInput = typeof payload.input === "string" ? payload.input : "";
       const callId = payload.call_id;
-      const perFileCalls = rawInput ? parseCodexToolPatches(name, rawInput, callId, timestamp, metadata.cwd) : [];
+      const perFileCalls = rawInput ? parseCodexToolPatches(name, rawInput, callId, timestamp2, metadata.cwd) : [];
       if (name !== "apply_patch") {
         const toolCall = {
           id: callId,
@@ -9082,14 +9341,14 @@ function walkCodexRecords(records, options) {
           input: parseToolInput(rawInput),
           result: null,
           isError: false,
-          timestamp
+          timestamp: timestamp2
         };
         pendingToolCalls.set(toolCall.id, toolCall);
-        appendToolCall(current, toolCall, timestamp);
+        appendToolCall(current, toolCall, timestamp2);
       }
       for (const tc of perFileCalls) {
         pendingToolCalls.set(tc.id, tc);
-        appendToolCall(current, tc, timestamp);
+        appendToolCall(current, tc, timestamp2);
       }
       if (perFileCalls.length > 0) {
         patchCallIds.set(callId, {
@@ -9150,7 +9409,7 @@ function parseCodexSession(jsonlText, options) {
   return session;
 }
 function appendCodexSession(existing, newJsonlText) {
-  const prefix = existing.rawMessages.map((record2) => JSON.stringify(record2)).join("\n");
+  const prefix = existing.rawMessages.map((record4) => JSON.stringify(record4)).join("\n");
   return parseCodexSession(prefix ? `${prefix}
 ${newJsonlText}` : newJsonlText);
 }
@@ -9345,16 +9604,16 @@ async function readCodexSessionIdentity(filePath) {
   let parentSessionId = null;
   let sawSessionMeta = false;
   for (const line of await readHeadLines(filePath, HEAD_BYTES)) {
-    let record2;
+    let record4;
     try {
-      record2 = JSON.parse(line);
+      record4 = JSON.parse(line);
     } catch {
       continue;
     }
-    if (!isRecord2(record2) || !isRecord2(record2.payload)) continue;
-    if (record2.type === "session_meta") {
+    if (!isRecord2(record4) || !isRecord2(record4.payload)) continue;
+    if (record4.type === "session_meta") {
       sawSessionMeta = true;
-      const payload = record2.payload;
+      const payload = record4.payload;
       if (!sessionId && typeof payload.id === "string") sessionId = payload.id;
       if (!cwd && typeof payload.cwd === "string") cwd = payload.cwd;
       if (!parentSessionId && typeof payload.forked_from_id === "string") {
@@ -9364,8 +9623,8 @@ async function readCodexSessionIdentity(filePath) {
       if (source && isRecord2(source.subagent)) isSubagent = true;
       const git = isRecord2(payload.git) ? payload.git : null;
       if (!gitBranch && git && typeof git.branch === "string") gitBranch = git.branch;
-    } else if (record2.type === "turn_context") {
-      if (!cwd && typeof record2.payload.cwd === "string") cwd = record2.payload.cwd;
+    } else if (record4.type === "turn_context") {
+      if (!cwd && typeof record4.payload.cwd === "string") cwd = record4.payload.cwd;
     }
   }
   if (!sawSessionMeta || !cwd) return null;
@@ -9688,8 +9947,8 @@ function extractMetadata(events) {
   for (const event of events) {
     if (!isRootEvent(event)) continue;
     const { data } = event;
-    const timestamp = eventTimestamp(event);
-    if (timestamp) metadata.lastTimestamp = timestamp;
+    const timestamp2 = eventTimestamp(event);
+    if (timestamp2) metadata.lastTimestamp = timestamp2;
     if (event.type === "session.start") {
       metadata.sessionId ||= readString(data.sessionId);
       metadata.version ||= readString(data.copilotVersion) || (typeof data.version === "number" ? String(data.version) : readString(data.version));
@@ -9727,7 +9986,7 @@ function extractMetadata(events) {
     }
     if (event.type !== "user.message") continue;
     metadata.turnCount++;
-    metadata.timestamp ||= timestamp;
+    metadata.timestamp ||= timestamp2;
     const content = readString(data.content).trim();
     if (!content) continue;
     metadata.firstUserMessage ||= content;
@@ -9951,7 +10210,7 @@ function extractToolResult(data) {
   if (result.structuredContent !== void 0) return safeStringify2(result.structuredContent);
   return safeStringify2(result);
 }
-function appendThinking2(turn, text, timestamp, signature) {
+function appendThinking2(turn, text, timestamp2, signature) {
   if (!text || turn.thinking.some((block2) => block2.thinking === text)) return;
   const block = { type: "thinking", thinking: text, signature };
   turn.thinking.push(block);
@@ -9960,21 +10219,21 @@ function appendThinking2(turn, text, timestamp, signature) {
     last.blocks.push(block);
     return;
   }
-  turn.contentBlocks.push({ kind: "thinking", blocks: [block], timestamp });
+  turn.contentBlocks.push({ kind: "thinking", blocks: [block], timestamp: timestamp2 });
 }
-function appendToolCall2(turn, call, timestamp) {
+function appendToolCall2(turn, call, timestamp2) {
   turn.toolCalls.push(call);
   const last = turn.contentBlocks[turn.contentBlocks.length - 1];
   if (last?.kind === "tool_calls") {
     last.toolCalls.push(call);
     return;
   }
-  turn.contentBlocks.push({ kind: "tool_calls", toolCalls: [call], timestamp });
+  turn.contentBlocks.push({ kind: "tool_calls", toolCalls: [call], timestamp: timestamp2 });
 }
-function newToolCall(id, name, input, timestamp) {
-  return { id, name, input, result: null, isError: false, timestamp };
+function newToolCall(id, name, input, timestamp2) {
+  return { id, name, input, result: null, isError: false, timestamp: timestamp2 };
 }
-function toolCallsFromRequests(value, timestamp, isPending) {
+function toolCallsFromRequests(value, timestamp2, isPending) {
   if (!Array.isArray(value)) return [];
   const calls = [];
   for (const request of value) {
@@ -9983,14 +10242,14 @@ function toolCallsFromRequests(value, timestamp, isPending) {
     const rawName = readString(request.name);
     if (!id || !rawName || isPending(id)) continue;
     const name = normalizeToolName(rawName);
-    calls.push(newToolCall(id, name, normalizeToolInput(name, request.arguments), timestamp));
+    calls.push(newToolCall(id, name, normalizeToolInput(name, request.arguments), timestamp2));
   }
   return calls;
 }
-function updateToolCallStart(call, name, input, timestamp) {
+function updateToolCallStart(call, name, input, timestamp2) {
   call.name = name;
   call.input = normalizeToolInput(name, input);
-  call.timestamp = timestamp || call.timestamp;
+  call.timestamp = timestamp2 || call.timestamp;
 }
 function updateToolCallResult(call, data, binaryAssets) {
   call.result = extractToolResult(data);
@@ -9998,7 +10257,7 @@ function updateToolCallResult(call, data, binaryAssets) {
   if (resultImages.length > 0) call.resultImages = resultImages;
   call.isError = data.success === false || data.error !== void 0 && data.error !== null;
 }
-function createTurn2(id, timestamp, userMessage, model, effort, isFragment) {
+function createTurn2(id, timestamp2, userMessage, model, effort, isFragment) {
   return {
     id,
     userMessage,
@@ -10007,7 +10266,7 @@ function createTurn2(id, timestamp, userMessage, model, effort, isFragment) {
     assistantText: [],
     toolCalls: [],
     subAgentActivity: [],
-    timestamp,
+    timestamp: timestamp2,
     durationMs: null,
     tokenUsage: null,
     model,
@@ -10034,8 +10293,8 @@ function parseCopilotSession(jsonlText, options) {
   let sawAssistantUsage = false;
   let sawAssistantDuration = false;
   let shutdownUsage = null;
-  function noteTimestamp(turn, timestamp) {
-    if (timestamp) endTimestamps.set(turn, timestamp);
+  function noteTimestamp(turn, timestamp2) {
+    if (timestamp2) endTimestamps.set(turn, timestamp2);
   }
   function ensureTurn(event) {
     if (!current) {
@@ -10096,7 +10355,7 @@ function parseCopilotSession(jsonlText, options) {
     const message = ensureAgent(event);
     if (!message) return true;
     const { data } = event;
-    const timestamp = eventTimestamp(event);
+    const timestamp2 = eventTimestamp(event);
     if (event.type === "subagent.started" || event.type === "subagent.configured") {
       message.parentToolUseId ||= readString(data.toolCallId) || void 0;
       message.agentName = readString(data.agentDisplayName, data.agentName) || message.agentName;
@@ -10135,7 +10394,7 @@ function parseCopilotSession(jsonlText, options) {
       if (text && !message.text.includes(text)) message.text.push(text);
       for (const call of toolCallsFromRequests(
         data.toolRequests,
-        timestamp,
+        timestamp2,
         (id) => pendingAgentToolCalls.has(id)
       )) {
         message.toolCalls.push(call);
@@ -10155,13 +10414,13 @@ function parseCopilotSession(jsonlText, options) {
       const name = normalizeToolName(rawName);
       const existing = pendingAgentToolCalls.get(callId);
       if (existing) {
-        updateToolCallStart(existing.call, name, data.arguments, timestamp);
+        updateToolCallStart(existing.call, name, data.arguments, timestamp2);
       } else {
         const call = newToolCall(
           callId,
           name,
           normalizeToolInput(name, data.arguments),
-          timestamp
+          timestamp2
         );
         message.toolCalls.push(call);
         pendingAgentToolCalls.set(callId, { call, message });
@@ -10174,7 +10433,7 @@ function parseCopilotSession(jsonlText, options) {
       if (!pending) {
         const rawName = readString(data.toolName) || "Tool";
         const name = normalizeToolName(rawName);
-        const call = newToolCall(callId, name, {}, timestamp);
+        const call = newToolCall(callId, name, {}, timestamp2);
         message.toolCalls.push(call);
         pending = { call, message };
       }
@@ -10187,7 +10446,7 @@ function parseCopilotSession(jsonlText, options) {
   for (const event of events) {
     if (applyAgentEvent(event)) continue;
     const { data } = event;
-    const timestamp = eventTimestamp(event);
+    const timestamp2 = eventTimestamp(event);
     if (event.type === "session.start" || event.type === "session.resume") {
       currentModel = readString(data.selectedModel) || currentModel;
       currentEffort = readString(data.reasoningEffort) || currentEffort;
@@ -10220,13 +10479,13 @@ function parseCopilotSession(jsonlText, options) {
       finalizeCurrent();
       current = createTurn2(
         turnEventId(event),
-        timestamp,
+        timestamp2,
         buildUserContent(data, binaryAssets),
         currentModel,
         currentEffort,
         false
       );
-      noteTimestamp(current, timestamp);
+      noteTimestamp(current, timestamp2);
       continue;
     }
     if (event.type === "assistant.turn_start") {
@@ -10234,7 +10493,7 @@ function parseCopilotSession(jsonlText, options) {
       const turn = ensureTurn(event);
       turn.model = currentModel;
       if (currentEffort) turn.effort = currentEffort;
-      noteTimestamp(turn, timestamp);
+      noteTimestamp(turn, timestamp2);
       continue;
     }
     if (event.type === "assistant.reasoning") {
@@ -10242,10 +10501,10 @@ function parseCopilotSession(jsonlText, options) {
       appendThinking2(
         turn,
         readString(data.content),
-        timestamp,
+        timestamp2,
         readString(data.reasoningId) || eventId(event, "copilot-thinking")
       );
-      noteTimestamp(turn, timestamp);
+      noteTimestamp(turn, timestamp2);
       continue;
     }
     if (event.type === "assistant.message") {
@@ -10256,19 +10515,19 @@ function parseCopilotSession(jsonlText, options) {
       appendThinking2(
         turn,
         readString(data.reasoningText),
-        timestamp,
+        timestamp2,
         eventId(event, "copilot-thinking")
       );
-      appendAssistantText(turn, textFromValue(data.content), timestamp);
+      appendAssistantText(turn, textFromValue(data.content), timestamp2);
       for (const call of toolCallsFromRequests(
         data.toolRequests,
-        timestamp,
+        timestamp2,
         (id) => pendingToolCalls.has(id)
       )) {
-        appendToolCall2(turn, call, timestamp);
+        appendToolCall2(turn, call, timestamp2);
         pendingToolCalls.set(call.id, { call, turn });
       }
-      noteTimestamp(turn, timestamp);
+      noteTimestamp(turn, timestamp2);
       continue;
     }
     if (event.type === "assistant.usage") {
@@ -10283,7 +10542,7 @@ function parseCopilotSession(jsonlText, options) {
       if (currentEffort) turn.effort = currentEffort;
       if (usage) turn.tokenUsage = mergeTokenUsage2(turn.tokenUsage, usage);
       if (duration) apiDurationMs.set(turn, (apiDurationMs.get(turn) ?? 0) + duration);
-      noteTimestamp(turn, timestamp);
+      noteTimestamp(turn, timestamp2);
       continue;
     }
     if (event.type === "tool.execution_start") {
@@ -10295,18 +10554,18 @@ function parseCopilotSession(jsonlText, options) {
       const name = normalizeToolName(rawName);
       const existing = pendingToolCalls.get(callId);
       if (existing) {
-        updateToolCallStart(existing.call, name, data.arguments, timestamp);
+        updateToolCallStart(existing.call, name, data.arguments, timestamp2);
       } else {
         const call = newToolCall(
           callId,
           name,
           normalizeToolInput(name, data.arguments),
-          timestamp
+          timestamp2
         );
-        appendToolCall2(turn, call, timestamp);
+        appendToolCall2(turn, call, timestamp2);
         pendingToolCalls.set(callId, { call, turn });
       }
-      noteTimestamp(turn, timestamp);
+      noteTimestamp(turn, timestamp2);
       continue;
     }
     if (event.type === "tool.execution_complete") {
@@ -10317,13 +10576,13 @@ function parseCopilotSession(jsonlText, options) {
         const turn = ensureTurn(event);
         const rawName = readString(data.toolName) || "Tool";
         const name = normalizeToolName(rawName);
-        const call = newToolCall(callId, name, {}, timestamp);
-        appendToolCall2(turn, call, timestamp);
+        const call = newToolCall(callId, name, {}, timestamp2);
+        appendToolCall2(turn, call, timestamp2);
         pending = { call, turn };
       }
       updateToolCallResult(pending.call, data, binaryAssets);
       pendingToolCalls.delete(callId);
-      noteTimestamp(pending.turn, timestamp);
+      noteTimestamp(pending.turn, timestamp2);
       continue;
     }
     if (event.type === "session.error") {
@@ -10338,13 +10597,13 @@ function parseCopilotSession(jsonlText, options) {
         input,
         result: readString(data.message) || "Copilot session error",
         isError: true,
-        timestamp
-      }, timestamp);
-      noteTimestamp(turn, timestamp);
+        timestamp: timestamp2
+      }, timestamp2);
+      noteTimestamp(turn, timestamp2);
       continue;
     }
     if (event.type === "assistant.turn_end" || event.type === "assistant.idle" || event.type === "session.idle") {
-      if (current) noteTimestamp(current, timestamp);
+      if (current) noteTimestamp(current, timestamp2);
     }
   }
   finalizeCurrent();
@@ -10387,7 +10646,7 @@ function parseCopilotSession(jsonlText, options) {
   };
 }
 function appendCopilotSession(existing, newJsonlText) {
-  const prefix = existing.rawMessages.map((record2) => JSON.stringify(record2)).join("\n");
+  const prefix = existing.rawMessages.map((record4) => JSON.stringify(record4)).join("\n");
   return parseCopilotSession(prefix ? `${prefix}
 ${newJsonlText}` : newJsonlText);
 }
@@ -10495,11 +10754,11 @@ function brandCopilotBranch() {
 function copilotTurnBoundaries(records) {
   const boundaries = [];
   for (let index = 0; index < records.length; index++) {
-    const record2 = records[index];
-    if (record2.type !== "user.message" || typeof record2.agentId === "string") continue;
-    const data = record2.data;
+    const record4 = records[index];
+    if (record4.type !== "user.message" || typeof record4.agentId === "string") continue;
+    const data = record4.data;
     if (!data || typeof data !== "object" || Array.isArray(data)) continue;
-    if (typeof record2.id !== "string" || !record2.id) continue;
+    if (typeof record4.id !== "string" || !record4.id) continue;
     boundaries.push(index);
   }
   return boundaries;
@@ -10556,14 +10815,14 @@ async function readCopilotSessionIdentity(filePath) {
   let cwd = "";
   let gitBranch = "";
   for (const line of await readHeadLines(filePath, HEAD_BYTES)) {
-    let record2;
+    let record4;
     try {
-      record2 = JSON.parse(line);
+      record4 = JSON.parse(line);
     } catch {
       continue;
     }
-    if (!isRecord3(record2) || record2.type !== "session.start" && record2.type !== "session.resume") continue;
-    const data = isRecord3(record2.data) ? record2.data : null;
+    if (!isRecord3(record4) || record4.type !== "session.start" && record4.type !== "session.resume") continue;
+    const data = isRecord3(record4.data) ? record4.data : null;
     if (!data) continue;
     if (typeof data.sessionId === "string" && data.sessionId) sessionId = data.sessionId;
     const context = isRecord3(data.context) ? data.context : null;
@@ -10883,7 +11142,7 @@ function groupPlanModeBlocks(blocks) {
       if (enterIdx !== -1) {
         const enterCall = block.toolCalls[enterIdx];
         const plan = String(enterCall.input.plan ?? "");
-        const timestamp = block.timestamp;
+        const timestamp2 = block.timestamp;
         const before = block.toolCalls.slice(0, enterIdx);
         if (before.length > 0) {
           result.push({ kind: "tool_calls", toolCalls: before, timestamp: block.timestamp });
@@ -10899,7 +11158,7 @@ function groupPlanModeBlocks(blocks) {
           if (exitCall.result !== null) {
             status = exitCall.isError ? "rejected" : "approved";
           }
-          result.push({ kind: "plan_mode", plan, planFilePath, status, toolCalls: embedded, timestamp });
+          result.push({ kind: "plan_mode", plan, planFilePath, status, toolCalls: embedded, timestamp: timestamp2 });
           const after = afterEnterInSameBlock.slice(exitInSameBlock + 1);
           if (after.length > 0) {
             result.push({ kind: "tool_calls", toolCalls: after, timestamp: block.timestamp });
@@ -10925,7 +11184,7 @@ function groupPlanModeBlocks(blocks) {
                   status = exitCall.isError ? "rejected" : "approved";
                 }
                 const tail = next.toolCalls.slice(exitIdx + 1);
-                result.push({ kind: "plan_mode", plan, planFilePath, status, toolCalls: embedded, timestamp });
+                result.push({ kind: "plan_mode", plan, planFilePath, status, toolCalls: embedded, timestamp: timestamp2 });
                 result.push(...passthroughBlocks);
                 if (tail.length > 0) {
                   result.push({ kind: "tool_calls", toolCalls: tail, timestamp: next.timestamp });
@@ -10944,7 +11203,7 @@ function groupPlanModeBlocks(blocks) {
             }
           }
           if (!exitCall) {
-            result.push({ kind: "plan_mode", plan, planFilePath: void 0, status: "pending", toolCalls: embedded, timestamp });
+            result.push({ kind: "plan_mode", plan, planFilePath: void 0, status: "pending", toolCalls: embedded, timestamp: timestamp2 });
             result.push(...passthroughBlocks);
             i = j;
           }
@@ -11926,9 +12185,9 @@ function nonEmpty(value) {
 function stripTaggedBlocks(text) {
   return text.replace(/<[^>]+>[\s\S]*?<\/[^>]+>/g, "").trim();
 }
-function effortFromRecord(record2) {
+function effortFromRecord(record4) {
   for (const kind of AGENT_KINDS) {
-    const effort = READERS[kind].effort(record2);
+    const effort = READERS[kind].effort(record4);
     if (effort) return effort;
   }
   return null;
@@ -11938,15 +12197,15 @@ function userMessageTextFromLine(line) {
     (kind) => READERS[kind].userMessageMarkers.some((marker) => line.includes(marker))
   );
   if (candidates.length === 0) return null;
-  let record2;
+  let record4;
   try {
-    record2 = JSON.parse(line);
+    record4 = JSON.parse(line);
   } catch {
     return null;
   }
-  if (!isRecord4(record2)) return null;
+  if (!isRecord4(record4)) return null;
   for (const kind of candidates) {
-    const text = READERS[kind].userMessageText(record2);
+    const text = READERS[kind].userMessageText(record4);
     if (text !== null) return text;
   }
   return null;
@@ -11958,11 +12217,11 @@ var init_recordReaders = __esm({
     claudeReader = {
       kind: "claude",
       // Every assistant record is tagged with the effort that turn ran at.
-      effort: (record2) => record2.type === "assistant" ? nonEmpty(record2.effort) : null,
+      effort: (record4) => record4.type === "assistant" ? nonEmpty(record4.effort) : null,
       userMessageMarkers: ['"user"'],
-      userMessageText(record2) {
-        if (record2.type !== "user" || record2.isMeta) return null;
-        const content = isRecord4(record2.message) ? record2.message.content : void 0;
+      userMessageText(record4) {
+        if (record4.type !== "user" || record4.isMeta) return null;
+        const content = isRecord4(record4.message) ? record4.message.content : void 0;
         if (typeof content === "string") return stripTaggedBlocks(content);
         if (!Array.isArray(content)) return "";
         let text = "";
@@ -11977,32 +12236,32 @@ var init_recordReaders = __esm({
     codexReader = {
       kind: "codex",
       // Effort is recorded per turn; newer CLI versions moved it under `thread_settings`.
-      effort(record2) {
-        if (record2.type !== "turn_context" || !isRecord4(record2.payload)) return null;
-        const { payload } = record2;
+      effort(record4) {
+        if (record4.type !== "turn_context" || !isRecord4(record4.payload)) return null;
+        const { payload } = record4;
         const direct = nonEmpty(payload.effort);
         if (direct) return direct;
         const settings = isRecord4(payload.thread_settings) ? payload.thread_settings : null;
         return nonEmpty(settings?.reasoning_effort);
       },
       userMessageMarkers: ['"event_msg"'],
-      userMessageText(record2) {
-        if (record2.type !== "event_msg" || !isRecord4(record2.payload)) return null;
-        const { payload } = record2;
+      userMessageText(record4) {
+        if (record4.type !== "event_msg" || !isRecord4(record4.payload)) return null;
+        const { payload } = record4;
         return payload.type === "user_message" && typeof payload.message === "string" ? payload.message.trim() : null;
       }
     };
     copilotReader = {
       kind: "copilot",
-      effort(record2) {
-        if (record2.type !== "session.start" && record2.type !== "session.resume" && record2.type !== "session.model_change" || !isRecord4(record2.data)) return null;
-        return nonEmpty(record2.data.reasoningEffort ?? record2.data.effort);
+      effort(record4) {
+        if (record4.type !== "session.start" && record4.type !== "session.resume" && record4.type !== "session.model_change" || !isRecord4(record4.data)) return null;
+        return nonEmpty(record4.data.reasoningEffort ?? record4.data.effort);
       },
       userMessageMarkers: ['"user.message"'],
-      userMessageText(record2) {
-        if (record2.type !== "user.message") return null;
-        if (typeof record2.agentId === "string" && record2.agentId) return null;
-        const data = isRecord4(record2.data) ? record2.data : null;
+      userMessageText(record4) {
+        if (record4.type !== "user.message") return null;
+        if (typeof record4.agentId === "string" && record4.agentId) return null;
+        const data = isRecord4(record4.data) ? record4.data : null;
         return typeof data?.content === "string" ? data.content.trim() : "";
       }
     };
@@ -12015,16 +12274,16 @@ var init_recordReaders = __esm({
 });
 
 // ../../server/agents/tailRecords.ts
-function isSubagentLifecycle(record2) {
-  return record2.type.startsWith("subagent.") && typeof record2.agentId === "string" && record2.agentId.length > 0;
+function isSubagentLifecycle(record4) {
+  return record4.type.startsWith("subagent.") && typeof record4.agentId === "string" && record4.agentId.length > 0;
 }
-function isSubagentNoise(record2) {
-  return typeof record2.agentId === "string" && record2.agentId.length > 0;
+function isSubagentNoise(record4) {
+  return typeof record4.agentId === "string" && record4.agentId.length > 0;
 }
-function classifyTailRecord(record2) {
+function classifyTailRecord(record4) {
   for (const kind of AGENT_KINDS) {
     const format = TAIL_FORMATS[kind];
-    const verdict = format.classify(record2);
+    const verdict = format.classify(record4);
     if (verdict.kind !== "ignore") return { format, verdict };
   }
   return null;
@@ -12041,31 +12300,31 @@ var init_tailRecords = __esm({
       // Background agent/workflow launches, task notifications and TaskStop calls
       // can all still change a verdict that a turn-ending line looked to settle.
       markers: ["async_launched", "task-notification", '"TaskStop"'],
-      classify(record2) {
-        if (record2.type === "system" && record2.subtype === "terminal_reason") {
-          const reason = record2.reason;
+      classify(record4) {
+        if (record4.type === "system" && record4.subtype === "terminal_reason") {
+          const reason = record4.reason;
           return reason ? { kind: "final", status: { status: "completed", terminalReason: reason } } : IGNORE;
         }
-        if (record2.type === "progress") {
-          const data = record2.data;
+        if (record4.type === "progress") {
+          const data = record4.data;
           if (data?.type !== "hook_progress") return IGNORE;
           const decision = data.decision ?? data.hookSpecificOutput?.permissionDecision;
           return decision === "defer" ? ANSWER : IGNORE;
         }
-        if (record2.type === "attachment") return KEEP;
-        if (record2.type === "assistant" || record2.type === "user" || record2.type === "queue-operation") {
-          const stopReason = record2.message?.stop_reason;
-          if (record2.type === "assistant" && stopReason === "end_turn") {
+        if (record4.type === "attachment") return KEEP;
+        if (record4.type === "assistant" || record4.type === "user" || record4.type === "queue-operation") {
+          const stopReason = record4.message?.stop_reason;
+          if (record4.type === "assistant" && stopReason === "end_turn") {
             return { kind: "turn-end", awaitUserActivity: true };
           }
-          const canDerive = record2.type === "assistant" || record2.type === "user" && !record2.isMeta;
+          const canDerive = record4.type === "assistant" || record4.type === "user" && !record4.isMeta;
           return canDerive ? ANSWER : KEEP;
         }
         return IGNORE;
       },
-      classifyAfterTurnEnd(record2) {
-        if (record2.type !== "user" && record2.type !== "assistant" && record2.type !== "queue-operation" && record2.type !== "attachment") return IGNORE;
-        const isRealUserTurn = record2.type === "user" && !record2.isMeta;
+      classifyAfterTurnEnd(record4) {
+        if (record4.type !== "user" && record4.type !== "assistant" && record4.type !== "queue-operation" && record4.type !== "attachment") return IGNORE;
+        const isRealUserTurn = record4.type === "user" && !record4.isMeta;
         return { kind: "keep", sawUserActivity: isRealUserTurn };
       }
     };
@@ -12084,9 +12343,9 @@ var init_tailRecords = __esm({
         "agent_message",
         "function_call_output"
       ],
-      classify(record2) {
-        if (record2.type === "event_msg") {
-          const payload = record2.payload;
+      classify(record4) {
+        if (record4.type === "event_msg") {
+          const payload = record4.payload;
           switch (payload?.type) {
             case "task_complete":
               return { kind: "turn-end" };
@@ -12098,32 +12357,32 @@ var init_tailRecords = __esm({
               return IGNORE;
           }
         }
-        if (record2.type === "response_item") {
-          const payload = record2.payload;
+        if (record4.type === "response_item") {
+          const payload = record4.payload;
           const decides = payload?.type === "function_call" || payload?.type === "message" && (payload.role === "assistant" || payload.role === "user");
           return decides ? ANSWER : IGNORE;
         }
         return IGNORE;
       },
-      classifyAfterTurnEnd(record2) {
-        return record2.type === "event_msg" || record2.type === "response_item" ? KEEP : IGNORE;
+      classifyAfterTurnEnd(record4) {
+        return record4.type === "event_msg" || record4.type === "response_item" ? KEEP : IGNORE;
       }
     };
     copilotTail = {
       kind: "copilot",
       markers: ['"abort"', '"assistant.message"', '"user.message"', '"subagent.'],
-      classify(record2) {
-        if (isSubagentLifecycle(record2)) return KEEP;
-        const decidable = record2.type === "abort" || record2.type === "user.message" || record2.type.startsWith("assistant.") || record2.type.startsWith("permission.") || record2.type.startsWith("session.") || record2.type.startsWith("tool.") || record2.type.startsWith("user_input.");
-        if (!decidable || isSubagentNoise(record2)) return IGNORE;
-        if (record2.type === "assistant.turn_end") return { kind: "turn-end" };
-        if (record2.type === "session.start" || record2.type === "session.resume") return ANSWER;
+      classify(record4) {
+        if (isSubagentLifecycle(record4)) return KEEP;
+        const decidable = record4.type === "abort" || record4.type === "user.message" || record4.type.startsWith("assistant.") || record4.type.startsWith("permission.") || record4.type.startsWith("session.") || record4.type.startsWith("tool.") || record4.type.startsWith("user_input.");
+        if (!decidable || isSubagentNoise(record4)) return IGNORE;
+        if (record4.type === "assistant.turn_end") return { kind: "turn-end" };
+        if (record4.type === "session.start" || record4.type === "session.resume") return ANSWER;
         return { kind: "answer-if-active" };
       },
-      classifyAfterTurnEnd(record2) {
-        if (isSubagentLifecycle(record2)) return KEEP;
-        if (isSubagentNoise(record2)) return IGNORE;
-        const decides = record2.type === "abort" || record2.type === "assistant.message" || record2.type === "user.message";
+      classifyAfterTurnEnd(record4) {
+        if (isSubagentLifecycle(record4)) return KEEP;
+        if (isSubagentNoise(record4)) return IGNORE;
+        const decides = record4.type === "abort" || record4.type === "assistant.message" || record4.type === "user.message";
         return decides ? ANSWER : IGNORE;
       }
     };
@@ -12178,14 +12437,14 @@ async function readTranscriptEffort(filePath) {
       for (let i = lines.length - 1; i >= 0; i--) {
         const line = lines[i];
         if (!line || !line.includes("effort") && !line.includes("Effort")) continue;
-        let record2;
+        let record4;
         try {
-          record2 = JSON.parse(line);
+          record4 = JSON.parse(line);
         } catch {
           continue;
         }
-        if (typeof record2 !== "object" || record2 === null) continue;
-        const effort = effortFromRecord(record2);
+        if (typeof record4 !== "object" || record4 === null) continue;
+        const effort = effortFromRecord(record4);
         if (effort) return effort;
       }
     }
@@ -12221,14 +12480,14 @@ async function getSessionStatus(filePath) {
           const line = lines[i];
           if (!line) continue;
           if (turnEnded && !isTailCandidate(line, turnEnded)) continue;
-          let record2;
+          let record4;
           try {
-            record2 = JSON.parse(line);
+            record4 = JSON.parse(line);
           } catch {
             continue;
           }
-          if (typeof record2?.type !== "string") continue;
-          const match = turnEnded ? { format: turnEnded, verdict: turnEnded.classifyAfterTurnEnd(record2) } : classifyTailRecord(record2);
+          if (typeof record4?.type !== "string") continue;
+          const match = turnEnded ? { format: turnEnded, verdict: turnEnded.classifyAfterTurnEnd(record4) } : classifyTailRecord(record4);
           if (!match) continue;
           const { verdict } = match;
           switch (verdict.kind) {
@@ -12237,20 +12496,20 @@ async function getSessionStatus(filePath) {
             case "final":
               return verdict.status;
             case "keep":
-              meaningful.unshift(record2);
+              meaningful.unshift(record4);
               if (verdict.sawUserActivity) needUserActivity = false;
               continue;
             case "answer":
-              meaningful.unshift(record2);
+              meaningful.unshift(record4);
               return deriveSessionStatus(meaningful);
             case "answer-if-active": {
-              meaningful.unshift(record2);
+              meaningful.unshift(record4);
               const status = deriveSessionStatus(meaningful);
               if (status.status !== "idle") return status;
               continue;
             }
             case "turn-end":
-              meaningful.unshift(record2);
+              meaningful.unshift(record4);
               turnEnded = match.format;
               needUserActivity = verdict.awaitUserActivity === true;
               continue;
@@ -12352,7 +12611,7 @@ var init_sessionPaths = __esm({
 });
 
 // ../../server/helpers.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 import { homedir as homedir4 } from "node:os";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { createInterface } from "node:readline";
@@ -12395,12 +12654,12 @@ var init_modelCatalog = __esm({
 
 // ../../server/agents/timeout.ts
 function withTimeout(promise, ms, label) {
-  return new Promise((resolve21, reject) => {
+  return new Promise((resolve22, reject) => {
     const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
     promise.then(
       (value) => {
         clearTimeout(timer);
-        resolve21(value);
+        resolve22(value);
       },
       (error) => {
         clearTimeout(timer);
@@ -12525,7 +12784,7 @@ async function fetchClaudeModels() {
 }
 var init_claudeModels = __esm({
   "../../server/agents/claudeModels.ts"() {
-    init_sdk_session();
+    init_claudeExecutable();
     init_modelCatalog();
     init_timeout();
     init_model_names();
@@ -12603,7 +12862,7 @@ async function awaitTranscript(filePath, isSettled) {
       return true;
     } catch {
     }
-    await new Promise((resolve21) => setTimeout(resolve21, TRANSCRIPT_POLL_INTERVAL_MS));
+    await new Promise((resolve22) => setTimeout(resolve22, TRANSCRIPT_POLL_INTERVAL_MS));
   }
   return false;
 }
@@ -12634,7 +12893,7 @@ function startOneShot(req) {
   ]);
   const cleanEnv = { ...process.env };
   delete cleanEnv.CLAUDECODE;
-  const child = spawn(cli.command, cli.args, {
+  const child = spawn2(cli.command, cli.args, {
     cwd: req.cwd,
     env: cleanEnv,
     stdio: ["ignore", "pipe", "pipe"],
@@ -12650,7 +12909,7 @@ function startOneShot(req) {
   child.on("close", () => {
     activeProcesses.delete(sessionId);
   });
-  return new Promise((resolve21, reject) => {
+  return new Promise((resolve22, reject) => {
     let settled = false;
     const fail = (message) => {
       if (settled) return;
@@ -12672,7 +12931,7 @@ function startOneShot(req) {
         await stat7(filePath);
         settled = true;
         clearTimeout(timer);
-        resolve21({ sessionId, dirName: req.dirName, fileName, filePath });
+        resolve22({ sessionId, dirName: req.dirName, fileName, filePath });
       } catch {
         fail(
           stderr.trim() || `${descriptor4.binName} exited with code ${code} before creating session`
@@ -12702,7 +12961,7 @@ function startInteractive(req) {
     worktreeName: req.worktreeName,
     mcpConfig: req.mcpConfig
   });
-  return new Promise((resolve21, reject) => {
+  return new Promise((resolve22, reject) => {
     let settled = false;
     const succeed = async () => {
       if (settled) return;
@@ -12712,7 +12971,7 @@ function startInteractive(req) {
         initialContent = await readFile9(filePath, "utf-8");
       } catch {
       }
-      resolve21({ sessionId, dirName: req.dirName, fileName, filePath, initialContent });
+      resolve22({ sessionId, dirName: req.dirName, fileName, filePath, initialContent });
     };
     const fail = (message) => {
       if (settled) return;
@@ -12795,6 +13054,7 @@ var init_claudeRuntime = __esm({
   "../../server/agents/claudeRuntime.ts"() {
     init_agent_descriptors();
     init_helpers();
+    init_claudeExecutable();
     init_claudeModels();
     init_spawnError();
     init_binaryResolver();
@@ -12852,10 +13112,10 @@ var init_claudeRuntime = __esm({
           mcpConfig: req.mcpConfig
         });
         watchSubagentsFor(state, req.filePath ?? null);
-        const completion = new Promise((resolve21) => {
+        const completion = new Promise((resolve22) => {
           state.onResult = (result) => {
             state.onResult = null;
-            resolve21(turnResultFrom(result));
+            resolve22(turnResultFrom(result));
           };
         });
         return { delivery: "started", completion };
@@ -12941,7 +13201,7 @@ var init_package = __esm({
     package_default = {
       name: "cogpit",
       private: true,
-      version: "2.1.3",
+      version: "2.3.0",
       description: "Control center for Claude Code, OpenAI Codex, and GitHub Copilot CLI sessions",
       license: "MIT",
       author: {
@@ -13051,11 +13311,11 @@ var init_package = __esm({
       overrides: {
         "@babel/core": "7.29.7",
         "@hono/node-server": "1.19.15",
-        "@xmldom/xmldom": "0.8.13",
+        "@xmldom/xmldom": "0.8.15",
         "app-builder-lib": "26.15.3",
         "body-parser": "2.3.0",
         "builder-util-runtime": "9.7.0",
-        "fast-uri": "3.1.5",
+        "fast-uri": "4.1.4",
         flatted: "3.4.2",
         "form-data": "4.0.6",
         hono: "4.13.1",
@@ -13064,7 +13324,7 @@ var init_package = __esm({
         lodash: "4.18.1",
         nanoid: "3.3.18",
         postcss: "8.5.26",
-        qs: "6.15.3",
+        qs: "6.16.0",
         tar: "7.5.21",
         tmp: "0.2.7",
         undici: "7.29.0"
@@ -13169,109 +13429,14 @@ function forwardCodexStreamNotification(notification) {
     // stale overlay behind.
     case "turn/started":
     case "turn/completed":
-    case "thread/closed":
-      clear(threadId);
-      return;
-  }
-}
-var init_codexStreamAdapter = __esm({
-  "../../server/lib/codexStreamAdapter.ts"() {
-    init_streamBus();
-  }
-});
-
-// ../../shared/versions.ts
-function parseVersion(raw) {
-  const match = raw.trim().replace(/^v/i, "").match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/);
-  if (!match) return null;
-  return {
-    parts: [Number(match[1]), Number(match[2]), Number(match[3])],
-    prerelease: match[4] ? match[4].split(".") : []
-  };
-}
-function extractVersion(output) {
-  const match = output.match(/\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/);
-  return match ? match[0] : null;
-}
-function comparePrerelease(a, b) {
-  if (a.length === 0 && b.length === 0) return 0;
-  if (a.length === 0) return 1;
-  if (b.length === 0) return -1;
-  for (let i = 0; i < Math.max(a.length, b.length); i += 1) {
-    const left = a[i];
-    const right = b[i];
-    if (left === void 0) return -1;
-    if (right === void 0) return 1;
-    const leftNumeric = /^\d+$/.test(left);
-    const rightNumeric = /^\d+$/.test(right);
-    if (leftNumeric && rightNumeric) {
-      if (Number(left) !== Number(right)) return Number(left) < Number(right) ? -1 : 1;
-      continue;
-    }
-    if (leftNumeric !== rightNumeric) return leftNumeric ? -1 : 1;
-    if (left !== right) return left < right ? -1 : 1;
-  }
-  return 0;
-}
-function compareVersions(a, b) {
-  const left = parseVersion(a);
-  const right = parseVersion(b);
-  if (!left || !right) return null;
-  for (let i = 0; i < 3; i += 1) {
-    if (left.parts[i] !== right.parts[i]) return left.parts[i] < right.parts[i] ? -1 : 1;
-  }
-  return comparePrerelease(left.prerelease, right.prerelease);
-}
-var init_versions = __esm({
-  "../../shared/versions.ts"() {
-  }
-});
-
-// ../../server/lib/cliProcess.ts
-import { spawn as spawn2 } from "node:child_process";
-function runCli(executable, args, timeoutMs) {
-  return new Promise((resolve21) => {
-    const resolved = resolveAgentCommand(executable, [...args]);
-    const child = spawn2(resolved.command, resolved.args, {
-      stdio: ["ignore", "pipe", "pipe"],
-      ...resolved.spawnOptions
-    });
-    let stdout = "";
-    let stderr = "";
-    let timedOut = false;
-    const timer = setTimeout(() => {
-      timedOut = true;
-      child.kill("SIGKILL");
-    }, timeoutMs);
-    const append = (buffer, chunk) => buffer.length >= CLI_OUTPUT_MAX_CHARS ? buffer : buffer + chunk.toString();
-    child.stdout?.on("data", (chunk) => {
-      stdout = append(stdout, chunk);
-    });
-    child.stderr?.on("data", (chunk) => {
-      stderr = append(stderr, chunk);
-    });
-    child.on("error", () => {
-      clearTimeout(timer);
-      resolve21({ code: null, stdout, stderr, timedOut });
-    });
-    child.on("close", (code) => {
-      clearTimeout(timer);
-      resolve21({ code, stdout, stderr, timedOut });
-    });
-  });
-}
-async function probeCliVersion(command, versionArgs, timeoutMs = DEFAULT_PROBE_TIMEOUT_MS) {
-  const probe = await runCli(command, versionArgs, timeoutMs);
-  return extractVersion(`${probe.stdout}
-${probe.stderr}`);
-}
-var DEFAULT_PROBE_TIMEOUT_MS, CLI_OUTPUT_MAX_CHARS;
-var init_cliProcess = __esm({
-  "../../server/lib/cliProcess.ts"() {
-    init_versions();
-    init_binaryResolver();
-    DEFAULT_PROBE_TIMEOUT_MS = 5e3;
-    CLI_OUTPUT_MAX_CHARS = 1e4;
+    case "thread/closed":
+      clear(threadId);
+      return;
+  }
+}
+var init_codexStreamAdapter = __esm({
+  "../../server/lib/codexStreamAdapter.ts"() {
+    init_streamBus();
   }
 });
 
@@ -13908,7 +14073,7 @@ var init_codexAppServer = __esm({
           );
         }
         const id = this.nextRequestId++;
-        return new Promise((resolve21, reject) => {
+        return new Promise((resolve22, reject) => {
           const timer = timeoutMs > 0 ? this.setTimer(() => {
             const pending = this.pendingRequests.get(id);
             if (!pending) return;
@@ -13921,7 +14086,7 @@ var init_codexAppServer = __esm({
           }, timeoutMs) : null;
           this.pendingRequests.set(id, {
             method,
-            resolve: (result) => resolve21(result),
+            resolve: (result) => resolve22(result),
             reject,
             timer
           });
@@ -13947,12 +14112,12 @@ var init_codexAppServer = __esm({
             new CodexAppServerError("Codex app-server stdin is not writable")
           );
         }
-        return new Promise((resolve21, reject) => {
+        return new Promise((resolve22, reject) => {
           try {
             child.stdin.write(`${JSON.stringify(message)}
 `, (error) => {
               if (error) reject(error);
-              else resolve21();
+              else resolve22();
             });
           } catch (error) {
             reject(error);
@@ -14053,13 +14218,13 @@ var init_codexAppServer = __esm({
         }
       }
       waitForChildClose(closed, timeoutMs) {
-        return new Promise((resolve21) => {
+        return new Promise((resolve22) => {
           let settled = false;
           const finish = (didClose) => {
             if (settled) return;
             settled = true;
             this.clearTimer(timer);
-            resolve21(didClose);
+            resolve22(didClose);
           };
           const timer = this.setTimer(() => finish(false), timeoutMs);
           void closed.then(() => finish(true));
@@ -14068,8 +14233,8 @@ var init_codexAppServer = __esm({
       async terminateChild(child, error) {
         let didClose = false;
         let resolveClose = () => void 0;
-        const closed = new Promise((resolve21) => {
-          resolveClose = resolve21;
+        const closed = new Promise((resolve22) => {
+          resolveClose = resolve22;
         });
         child.on("close", () => {
           didClose = true;
@@ -14429,7 +14594,7 @@ async function waitForNewSession(cwd, knownPaths, startedAt2, timeoutMs = SESSIO
   while (Date.now() < deadline) {
     const match = await findNewestCodexSessionForCwd(cwd, knownPaths, startedAt2);
     if (match) return match;
-    await new Promise((resolve21) => setTimeout(resolve21, SESSION_DISCOVERY_INTERVAL_MS));
+    await new Promise((resolve22) => setTimeout(resolve22, SESSION_DISCOVERY_INTERVAL_MS));
   }
   return null;
 }
@@ -14443,9 +14608,9 @@ function identityFromMetaLine(line) {
     const sessionId = typeof payload.id === "string" ? payload.id : "";
     const timestampText = typeof payload.timestamp === "string" ? payload.timestamp : typeof parsed.timestamp === "string" ? parsed.timestamp : "";
     if (!sessionId || !timestampText) return null;
-    const timestamp = new Date(timestampText);
-    if (Number.isNaN(timestamp.getTime())) return null;
-    const fileName = descriptor5.sessionFile.name(sessionId, timestamp);
+    const timestamp2 = new Date(timestampText);
+    if (Number.isNaN(timestamp2.getTime())) return null;
+    const fileName = descriptor5.sessionFile.name(sessionId, timestamp2);
     return { sessionId, fileName, filePath: join11(sessionsRoot2(), fileName) };
   } catch {
     return null;
@@ -14505,7 +14670,7 @@ async function startLegacy(req, knownPaths) {
     ...args.turnArgs,
     ...args.promptArgs
   ]);
-  const child = spawn(cli.command, cli.args, {
+  const child = spawn2(cli.command, cli.args, {
     cwd: req.cwd,
     env: process.env,
     stdio: ["ignore", "pipe", "pipe"],
@@ -14516,7 +14681,7 @@ async function startLegacy(req, knownPaths) {
   child.stderr?.on("data", (data) => {
     stderr += data.toString();
   });
-  return new Promise((resolve21, reject) => {
+  return new Promise((resolve22, reject) => {
     let settled = false;
     let sessionId = null;
     const discovery = waitForNewSession(req.cwd, knownPaths, startedAt2);
@@ -14534,7 +14699,7 @@ async function startLegacy(req, knownPaths) {
         } catch {
         }
       }
-      resolve21({
+      resolve22({
         sessionId: identity.sessionId,
         dirName: req.dirName,
         fileName: identity.fileName,
@@ -14597,7 +14762,7 @@ async function sendLegacy(sessionId, req) {
     sessionId,
     ...args.promptArgs
   ]);
-  const child = spawn(cli.command, cli.args, {
+  const child = spawn2(cli.command, cli.args, {
     cwd: req.cwd,
     env: process.env,
     stdio: ["ignore", "pipe", "pipe"],
@@ -14611,10 +14776,10 @@ async function sendLegacy(sessionId, req) {
   child.stderr?.on("data", (data) => {
     stderr += data.toString();
   });
-  const completion = new Promise((resolve21) => {
+  const completion = new Promise((resolve22) => {
     session.onResult = (result) => {
       session.onResult = null;
-      resolve21({
+      resolve22({
         isError: result.is_error === true,
         message: result.result
       });
@@ -15652,7 +15817,7 @@ var init_copilotTransport = __esm({
       }
       waitForRequest(request, method, timeoutMs = this.transportTimeoutMs, onTimeout) {
         if (timeoutMs <= 0) return request;
-        return new Promise((resolve21, reject) => {
+        return new Promise((resolve22, reject) => {
           const timer = setTimeout(() => {
             try {
               onTimeout?.();
@@ -15663,7 +15828,7 @@ var init_copilotTransport = __esm({
           request.then(
             (value) => {
               clearTimeout(timer);
-              resolve21(value);
+              resolve22(value);
             },
             (error) => {
               clearTimeout(timer);
@@ -15789,10 +15954,10 @@ var init_copilotTransport = __esm({
           ...typeof params.allowFreeform === "boolean" ? { allowFreeform: params.allowFreeform } : {},
           askedAt: Date.now()
         };
-        return new Promise((resolve21, reject) => {
+        return new Promise((resolve22, reject) => {
           this.pendingUserInputs.set(
             this.pendingInteractionKey(sessionId, requestId),
-            { value, resolve: resolve21, reject }
+            { value, resolve: resolve22, reject }
           );
         });
       }
@@ -15812,10 +15977,10 @@ var init_copilotTransport = __esm({
           recommendedAction: typeof params.recommendedAction === "string" ? params.recommendedAction : actions[0] ?? "interactive",
           askedAt: Date.now()
         };
-        return new Promise((resolve21, reject) => {
+        return new Promise((resolve22, reject) => {
           this.pendingExitPlans.set(
             this.pendingInteractionKey(sessionId, requestId),
-            { value, resolve: resolve21, reject }
+            { value, resolve: resolve22, reject }
           );
         });
       }
@@ -16040,17 +16205,17 @@ function parseJsonRecord(line) {
   }
 }
 function parseClaudeUsageLine(line) {
-  const record2 = parseJsonRecord(line);
-  if (!record2 || record2.type !== "assistant") return null;
-  const message = asRecord3(record2.message);
+  const record4 = parseJsonRecord(line);
+  if (!record4 || record4.type !== "assistant") return null;
+  const message = asRecord3(record4.message);
   const usage = message ? asRecord3(message.usage) : null;
   if (!message || !usage) return null;
-  const timestampMs = parseTimestampMs(record2.timestamp);
+  const timestampMs = parseTimestampMs(record4.timestamp);
   if (timestampMs === null) return null;
   const model = typeof message.model === "string" ? message.model : "";
   if (model.length === 0) return null;
   const messageId = typeof message.id === "string" ? message.id : null;
-  const requestId = typeof record2.requestId === "string" ? record2.requestId : null;
+  const requestId = typeof record4.requestId === "string" ? record4.requestId : null;
   const dedupeKey = messageId === null && requestId === null ? null : `${messageId ?? ""}:${requestId ?? ""}`;
   const cacheCreationTokens = int(usage.cache_creation_input_tokens);
   const byTtl = asRecord3(usage.cache_creation);
@@ -16069,12 +16234,12 @@ function parseClaudeUsageLine(line) {
     reasoningTokens: 0
   };
   if (totalUsageCostTokens(totals) === 0) return null;
-  const cost = record2.costUSD;
+  const cost = record4.costUSD;
   return {
     provider: "claude",
     timestampMs,
     model,
-    sessionId: typeof record2.sessionId === "string" ? record2.sessionId : "",
+    sessionId: typeof record4.sessionId === "string" ? record4.sessionId : "",
     totals,
     reportedCostUsd: typeof cost === "number" && Number.isFinite(cost) ? cost : null,
     dedupeKey
@@ -16096,30 +16261,30 @@ function isForkedSessionMeta(payload) {
   return typeof spawn5?.parent_thread_id === "string";
 }
 function parseCodexUsageLine(line, state) {
-  const record2 = parseJsonRecord(line);
-  if (!record2) return null;
-  const payload = asRecord3(record2.payload);
+  const record4 = parseJsonRecord(line);
+  if (!record4) return null;
+  const payload = asRecord3(record4.payload);
   if (!payload) return null;
-  if (record2.type === "session_meta") {
+  if (record4.type === "session_meta") {
     if (state.sawSessionMeta) return null;
     state.sawSessionMeta = true;
     const id = payload.id ?? payload.session_id;
     if (typeof id === "string") state.sessionId = id;
-    const metaTimestampMs = parseTimestampMs(record2.timestamp);
+    const metaTimestampMs = parseTimestampMs(record4.timestamp);
     if (metaTimestampMs !== null && isForkedSessionMeta(payload)) {
       state.suppressingForkCopies = true;
       state.forkCopyAnchorMs = metaTimestampMs;
     }
     return null;
   }
-  if (record2.type === "turn_context") {
+  if (record4.type === "turn_context") {
     if (typeof payload.model === "string") state.model = payload.model;
     return null;
   }
   if (payload.type !== "token_count") return null;
   const last = asRecord3(asRecord3(payload.info)?.last_token_usage);
   if (!last) return null;
-  const timestampMs = parseTimestampMs(record2.timestamp);
+  const timestampMs = parseTimestampMs(record4.timestamp);
   if (timestampMs === null) return null;
   if (state.model.length === 0) return null;
   const signature = JSON.stringify(last);
@@ -16218,17 +16383,17 @@ function parseCopilotUsageMetrics(value, state, timestampMs) {
   return records;
 }
 function parseCopilotUsageLine(line, state) {
-  const record2 = parseJsonRecord(line);
-  if (!record2 || typeof record2.agentId === "string" && record2.agentId.length > 0) return [];
-  const data = asRecord3(record2.data);
+  const record4 = parseJsonRecord(line);
+  if (!record4 || typeof record4.agentId === "string" && record4.agentId.length > 0) return [];
+  const data = asRecord3(record4.data);
   if (!data) return [];
-  if (record2.type === "session.start") {
+  if (record4.type === "session.start") {
     const sessionId = data.sessionId;
     if (typeof sessionId === "string" && sessionId.length > 0) state.sessionId = sessionId;
     return [];
   }
-  if (record2.type !== "session.shutdown") return [];
-  const timestampMs = parseTimestampMs(record2.timestamp);
+  if (record4.type !== "session.shutdown") return [];
+  const timestampMs = parseTimestampMs(record4.timestamp);
   return timestampMs === null ? [] : parseCopilotUsageMetrics(data, state, timestampMs);
 }
 function createUsageScanner(provider, filePath) {
@@ -16245,8 +16410,8 @@ var init_usageScanners = __esm({
         // object, so a line is either self-contained or of no interest.
         wantsLine: (line) => line.includes('"usage"'),
         accept: (line) => {
-          const record2 = parseClaudeUsageLine(line);
-          return record2 === null ? [] : [record2];
+          const record4 = parseClaudeUsageLine(line);
+          return record4 === null ? [] : [record4];
         }
       }),
       codex: () => {
@@ -16257,8 +16422,8 @@ var init_usageScanners = __esm({
           // at all but still have to reach the reducer.
           wantsLine: (line) => line.includes('"token_count"') || line.includes('"turn_context"') || line.includes('"session_meta"'),
           accept: (line) => {
-            const record2 = parseCodexUsageLine(line, state);
-            return record2 === null ? [] : [record2];
+            const record4 = parseCodexUsageLine(line, state);
+            return record4 === null ? [] : [record4];
           }
         };
       },
@@ -16504,7 +16669,7 @@ var init_copilotRuntime = __esm({
               initialContent = await readFile9(filePath, "utf-8");
               break;
             } catch {
-              await new Promise((resolve21) => setTimeout(resolve21, TRANSCRIPT_POLL_INTERVAL_MS2));
+              await new Promise((resolve22) => setTimeout(resolve22, TRANSCRIPT_POLL_INTERVAL_MS2));
             }
           }
           return { sessionId, dirName: req.dirName, fileName, filePath, initialContent };
@@ -17140,11 +17305,11 @@ function registerRunningProcessesRoute(use) {
     if (url.pathname.split("/").filter(Boolean).length > 0) return next();
     const isWindows2 = process.platform === "win32";
     const nameFilter = allDescriptors().map(windowsProcessNameFilter).join(" or ");
-    const child = isWindows2 ? spawn("powershell", [
+    const child = isWindows2 ? spawn2("powershell", [
       "-NoProfile",
       "-Command",
       `Get-CimInstance Win32_Process -Filter "${nameFilter}" | Select-Object ProcessId, WorkingSetSize, CommandLine | ConvertTo-Json -Compress`
-    ]) : spawn("ps", ["aux"]);
+    ]) : spawn2("ps", ["aux"]);
     let stdout = "";
     let responded = false;
     child.stdout?.on("data", (data) => {
@@ -17507,12 +17672,12 @@ function registerBranchSessionRoute(use) {
           }
         }
         const newSessionId = randomUUID2();
-        const { record: record2, originalId } = format.brandBranch(
+        const { record: record4, originalId } = format.brandBranch(
           JSON.parse(lines[0]),
           newSessionId,
           turnIndex ?? null
         );
-        lines[0] = JSON.stringify(record2);
+        lines[0] = JSON.stringify(record4);
         const target = storeForDirName(dirName).transcriptPath(dirName, newSessionId);
         if (!target) {
           res.statusCode = 500;
@@ -18055,11 +18220,11 @@ import {
   dirname as dirname5,
   isAbsolute as isAbsolute3,
   join as join13,
-  posix as posix2,
+  posix as posix3,
   relative as relative4,
   resolve as resolve9,
   sep as sep5,
-  win32 as win322
+  win32 as win323
 } from "node:path";
 function configuredAgentHomes() {
   return new Set(AGENT_KINDS.map((kind) => agentHomeDir(kind)));
@@ -18168,7 +18333,7 @@ async function resolveConfigBrowserPath(filePath, options = {}) {
 function isSafeConfigName(name) {
   if (!name || name === "." || name === ".." || name.includes("\0")) return false;
   if (name.includes("/") || name.includes("\\")) return false;
-  if (isAbsolute3(name) || posix2.parse(name).root || win322.parse(name).root) return false;
+  if (isAbsolute3(name) || posix3.parse(name).root || win323.parse(name).root) return false;
   return true;
 }
 function isUnderDir(parentDir, dirName) {
@@ -19411,7 +19576,8 @@ function registerConfigRoutes(use) {
         networkPassword: config.networkPassword ? "set" : null,
         terminalApp: config.terminalApp || null,
         editorApp: config.editorApp || null,
-        useBuiltInEditor: config.useBuiltInEditor || false
+        useBuiltInEditor: config.useBuiltInEditor || false,
+        agentExecutable: config.agentExecutable ?? DEFAULT_EXECUTABLE_CHOICE
       } : null));
       return;
     }
@@ -19474,7 +19640,8 @@ function registerConfigRoutes(use) {
             networkPassword: finalPassword,
             terminalApp: parsed.terminalApp || void 0,
             editorApp: parsed.editorApp || void 0,
-            useBuiltInEditor: !!parsed.useBuiltInEditor
+            useBuiltInEditor: !!parsed.useBuiltInEditor,
+            agentExecutable: parseExecutableChoice(parsed.agentExecutable)
           });
           refreshDirs();
           if (currentConfig && resolve11(resolvedClaudeDir) !== resolve11(currentConfig.claudeDir)) {
@@ -19509,12 +19676,13 @@ var init_config2 = __esm({
     init_users();
     init_config();
     init_agent_descriptors();
+    init_agentExecutable();
     init_sessionPersistence();
   }
 });
 
 // ../../server/routes/hello.ts
-import { readFileSync } from "node:fs";
+import { readFileSync as readFileSync2 } from "node:fs";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { hostname } from "node:os";
 import { join as join18 } from "node:path";
@@ -19563,7 +19731,7 @@ var init_hello = __esm({
         join18(__dirname2, "../package.json")
       ]) {
         try {
-          const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+          const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
           if (typeof pkg.version === "string") return pkg.version;
         } catch {
         }
@@ -19676,21 +19844,21 @@ function toPublic(device) {
   return rest;
 }
 function readJsonBody2(req) {
-  return new Promise((resolve21) => {
+  return new Promise((resolve22) => {
     let raw = "";
     req.on("data", (chunk) => {
       raw += chunk.toString();
     });
     req.on("end", () => {
-      if (!raw.trim()) return resolve21({});
+      if (!raw.trim()) return resolve22({});
       try {
         const parsed = JSON.parse(raw);
-        resolve21(parsed && typeof parsed === "object" ? parsed : null);
+        resolve22(parsed && typeof parsed === "object" ? parsed : null);
       } catch {
-        resolve21(null);
+        resolve22(null);
       }
     });
-    req.on("error", () => resolve21(null));
+    req.on("error", () => resolve22(null));
   });
 }
 function handleList(res) {
@@ -20078,9 +20246,9 @@ function terminalCommand(terminal, dirPath) {
   return { cmd: terminal, args: ["--working-directory", dirPath] };
 }
 function whichEditor(name) {
-  return new Promise((resolve21) => {
+  return new Promise((resolve22) => {
     const cmd = platform() === "win32" ? "where" : "which";
-    execFile(cmd, [name], (err) => resolve21(err ? null : name));
+    execFile(cmd, [name], (err) => resolve22(err ? null : name));
   });
 }
 async function resolveEditor(configuredEditor) {
@@ -20094,10 +20262,10 @@ async function resolveEditor(configuredEditor) {
   return null;
 }
 function openWithEditor(editor, args) {
-  return new Promise((resolve21, reject) => {
+  return new Promise((resolve22, reject) => {
     execFile(editor, args, (err) => {
       if (err) reject(err);
-      else resolve21();
+      else resolve22();
     });
   });
 }
@@ -20110,14 +20278,14 @@ function editorOpenArgs(editor, filePath, line, column) {
   return [filePath];
 }
 function getGitHeadContent(filePath) {
-  return new Promise((resolve21, reject) => {
+  return new Promise((resolve22, reject) => {
     execFile(
       "git",
       ["-C", dirname7(filePath), "show", `HEAD:./${basename7(filePath)}`],
       { maxBuffer: 10 * 1024 * 1024 },
       (err, stdout) => {
         if (err) reject(err);
-        else resolve21(stdout);
+        else resolve22(stdout);
       }
     );
   });
@@ -20793,23 +20961,23 @@ function registerFileRoutes(use) {
     req.on("end", async () => {
       try {
         let spawnLines = function(args, cwd) {
-          return new Promise((resolve21) => {
-            const proc = spawn("git", args, { cwd });
+          return new Promise((resolve22) => {
+            const proc = spawn2("git", args, { cwd });
             let out = "";
             proc.stdout.on("data", (d) => out += d.toString());
             proc.on("close", (code) => {
-              if (code !== 0 || !out) return resolve21(0);
-              resolve21(out.split("\n").length);
+              if (code !== 0 || !out) return resolve22(0);
+              resolve22(out.split("\n").length);
             });
-            proc.on("error", () => resolve21(0));
+            proc.on("error", () => resolve22(0));
           });
         }, spawnOutput = function(args, cwd) {
-          return new Promise((resolve21) => {
-            const proc = spawn("git", args, { cwd });
+          return new Promise((resolve22) => {
+            const proc = spawn2("git", args, { cwd });
             let out = "";
             proc.stdout.on("data", (d) => out += d.toString());
-            proc.on("close", () => resolve21(out.trim()));
-            proc.on("error", () => resolve21(""));
+            proc.on("close", () => resolve22(out.trim()));
+            proc.on("error", () => resolve22(""));
           });
         };
         const { files, dirs: dirs2 } = JSON.parse(body);
@@ -20833,18 +21001,18 @@ function registerFileRoutes(use) {
               cwd = cwd.substring(0, cwd.lastIndexOf("/")) || "/";
             }
           }
-          return new Promise((resolve21) => {
-            const proc = spawn("git", ["rev-parse", "--show-toplevel"], { cwd });
+          return new Promise((resolve22) => {
+            const proc = spawn2("git", ["rev-parse", "--show-toplevel"], { cwd });
             let out = "";
             proc.stdout.on("data", (d) => out += d.toString());
             proc.on("close", (code) => {
               const root = code === 0 ? out.trim() : null;
               gitRootCache.set(dir, root);
-              resolve21(root);
+              resolve22(root);
             });
             proc.on("error", () => {
               gitRootCache.set(dir, null);
-              resolve21(null);
+              resolve22(null);
             });
           });
         }
@@ -21079,11 +21247,11 @@ function parseGitStatus(output) {
   const branch = parseBranchHeader(header);
   const files = [];
   for (let index = 0; index < records.length; index += 1) {
-    const record2 = records[index];
-    if (!record2 || record2.length < 3) continue;
-    const indexStatus = record2[0];
-    const workTreeStatus = record2[1];
-    const path = record2.slice(3);
+    const record4 = records[index];
+    if (!record4 || record4.length < 3) continue;
+    const indexStatus = record4[0];
+    const workTreeStatus = record4[1];
+    const path = record4.slice(3);
     const renamedOrCopied = /[RC]/.test(`${indexStatus}${workTreeStatus}`);
     const originalPath = renamedOrCopied ? records[index += 1] || void 0 : void 0;
     files.push({ path, originalPath, indexStatus, workTreeStatus });
@@ -21138,14 +21306,630 @@ var init_git_status = __esm({
   }
 });
 
+// ../../server/routes/github-actions.ts
+import { execFile as execFileCallback2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+function record2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function stringValue(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) ? value : null;
+}
+function nullableDate(value) {
+  return typeof value === "string" && value ? value : null;
+}
+function workflowStatus(value) {
+  return typeof value === "string" && RUN_STATUSES.has(value) ? value : "pending";
+}
+function workflowConclusion(value) {
+  return typeof value === "string" && RUN_CONCLUSIONS.has(value) ? value : null;
+}
+function parseGitHubRemote(remoteUrl) {
+  const trimmed = remoteUrl.trim();
+  let host = "";
+  let pathname = "";
+  try {
+    const parsed = new URL(trimmed);
+    host = parsed.hostname;
+    pathname = parsed.pathname;
+  } catch {
+    const scp = trimmed.match(/^(?:[^@\s]+@)?([^:/\s]+):(.+)$/);
+    if (!scp) return null;
+    host = scp[1];
+    pathname = scp[2];
+  }
+  const parts = pathname.replace(/^\/+/, "").replace(/\.git$/, "").split("/");
+  if (parts.length !== 2 || !GITHUB_HOST.test(host) || host.toLowerCase() !== "github.com" && !host.toLowerCase().startsWith("github.") || !GITHUB_NAME.test(parts[0]) || !GITHUB_NAME.test(parts[1])) {
+    return null;
+  }
+  return { host: host.toLowerCase(), owner: parts[0], name: parts[1] };
+}
+function parseRun(value) {
+  const source = record2(value);
+  if (!source) return null;
+  const id = numberValue(source.id);
+  const url = stringValue(source.html_url);
+  if (id === null || !url.startsWith("https://")) return null;
+  const actor = record2(source.actor);
+  return {
+    id,
+    name: stringValue(source.name, "Workflow"),
+    displayTitle: stringValue(source.display_title, stringValue(source.name, "Workflow run")),
+    status: workflowStatus(source.status),
+    conclusion: workflowConclusion(source.conclusion),
+    url,
+    runNumber: numberValue(source.run_number) ?? 0,
+    event: stringValue(source.event, "workflow"),
+    branch: stringValue(source.head_branch),
+    commitSha: stringValue(source.head_sha),
+    createdAt: stringValue(source.created_at),
+    updatedAt: stringValue(source.updated_at),
+    actor: stringValue(actor?.login)
+  };
+}
+function parseStep(value) {
+  const source = record2(value);
+  if (!source) return null;
+  const number = numberValue(source.number);
+  if (number === null) return null;
+  return {
+    number,
+    name: stringValue(source.name, `Step ${number}`),
+    status: workflowStatus(source.status),
+    conclusion: workflowConclusion(source.conclusion),
+    startedAt: nullableDate(source.started_at),
+    completedAt: nullableDate(source.completed_at)
+  };
+}
+function parseJob(value) {
+  const source = record2(value);
+  if (!source) return null;
+  const id = numberValue(source.id);
+  const url = stringValue(source.html_url);
+  if (id === null || !url.startsWith("https://")) return null;
+  return {
+    id,
+    name: stringValue(source.name, "Job"),
+    status: workflowStatus(source.status),
+    conclusion: workflowConclusion(source.conclusion),
+    url,
+    startedAt: nullableDate(source.started_at),
+    completedAt: nullableDate(source.completed_at),
+    steps: Array.isArray(source.steps) ? source.steps.map(parseStep).filter((step) => step !== null) : []
+  };
+}
+function parseRunsResponse(value) {
+  const source = record2(value);
+  if (!source || !Array.isArray(source.workflow_runs)) {
+    throw new GitHubActionsRouteError(502, "invalid_response", "GitHub returned an invalid workflow response");
+  }
+  return source.workflow_runs.map(parseRun).filter((run2) => run2 !== null);
+}
+function parseJobsResponse(value) {
+  const source = record2(value);
+  if (!source || !Array.isArray(source.jobs)) {
+    throw new GitHubActionsRouteError(502, "invalid_response", "GitHub returned an invalid jobs response");
+  }
+  return source.jobs.map(parseJob).filter((job) => job !== null);
+}
+async function runGitHubApi(repository, endpoint) {
+  try {
+    const result = await execFile3("gh", [
+      "api",
+      endpoint,
+      "--hostname",
+      repository.host,
+      "-H",
+      "Accept: application/vnd.github+json"
+    ], {
+      encoding: "utf-8",
+      env: { ...process.env, GH_PAGER: "cat", NO_COLOR: "1" },
+      maxBuffer: 8 * 1024 * 1024,
+      timeout: 2e4,
+      windowsHide: true
+    });
+    return JSON.parse(result.stdout);
+  } catch (error) {
+    const failure = error;
+    if (failure.code === "ENOENT") {
+      throw new GitHubActionsRouteError(503, "gh_missing", "Install the GitHub CLI to view workflow runs");
+    }
+    const detail = `${failure.message ?? ""}
+${failure.stderr ?? ""}`;
+    if (/auth login|not logged|authentication|oauth token/i.test(detail)) {
+      throw new GitHubActionsRouteError(503, "gh_auth_required", "Sign in with `gh auth login` to view workflow runs");
+    }
+    throw new GitHubActionsRouteError(502, "github_api_failed", "GitHub workflow data is unavailable");
+  }
+}
+async function resolveRepository(cwd, dependencies) {
+  const project = await dependencies.resolveProject(cwd);
+  if (!project.ok) throw new GitHubActionsRouteError(project.status, "no_git_repository", project.error);
+  if (!project.root) {
+    throw new GitHubActionsRouteError(400, "no_git_repository", "This project is not a Git repository");
+  }
+  let remoteUrl = "";
+  try {
+    remoteUrl = (await dependencies.git(project.root, ["remote", "get-url", "origin"])).stdout;
+  } catch {
+    throw new GitHubActionsRouteError(400, "no_github_remote", "This repository has no origin remote");
+  }
+  const repository = parseGitHubRemote(remoteUrl);
+  if (!repository) {
+    throw new GitHubActionsRouteError(400, "no_github_remote", "The origin remote is not a supported GitHub repository");
+  }
+  const branchResult = await dependencies.git(project.root, ["branch", "--show-current"]);
+  return {
+    repository,
+    branch: branchResult.stdout.trim() || null
+  };
+}
+function repositoryName(repository) {
+  return `${repository.owner}/${repository.name}`;
+}
+function repositoryUrl(repository) {
+  return `https://${repository.host}/${repository.owner}/${repository.name}`;
+}
+function sendRouteError2(res, error) {
+  if (error instanceof GitHubActionsRouteError) {
+    sendJson(res, error.status, { error: error.message, code: error.code });
+    return;
+  }
+  sendJson(res, 500, { error: "Unable to load GitHub Actions", code: "github_api_failed" });
+}
+function registerGitHubActionsRoutes(use, dependencies = defaultDependencies) {
+  use("/api/github-actions", async (req, res, next) => {
+    if (req.method !== "GET") return next();
+    const url = new URL(req.url || "", "http://localhost");
+    if (url.pathname !== "/" && url.pathname !== "") return next();
+    const cwd = url.searchParams.get("cwd") ?? "";
+    const requestedLimit = Number(url.searchParams.get("limit") ?? DEFAULT_RUNS);
+    const limit = Number.isInteger(requestedLimit) ? Math.min(MAX_RUNS, Math.max(1, requestedLimit)) : DEFAULT_RUNS;
+    try {
+      const { repository, branch } = await resolveRepository(cwd, dependencies);
+      const endpoint = `repos/${repository.owner}/${repository.name}/actions/runs?per_page=${limit}`;
+      const runs = parseRunsResponse(await dependencies.githubApi(repository, endpoint));
+      const response = {
+        repository: repositoryName(repository),
+        repositoryUrl: repositoryUrl(repository),
+        branch,
+        runs
+      };
+      sendJson(res, 200, response);
+    } catch (error) {
+      sendRouteError2(res, error);
+    }
+  });
+  use("/api/github-actions/jobs", async (req, res, next) => {
+    if (req.method !== "GET") return next();
+    const url = new URL(req.url || "", "http://localhost");
+    if (url.pathname !== "/" && url.pathname !== "") return next();
+    const cwd = url.searchParams.get("cwd") ?? "";
+    const runIdText = url.searchParams.get("runId") ?? "";
+    if (!/^\d+$/.test(runIdText)) {
+      return sendJson(res, 400, { error: "runId must be a positive integer", code: "github_api_failed" });
+    }
+    try {
+      const { repository } = await resolveRepository(cwd, dependencies);
+      const runId = Number(runIdText);
+      const endpoint = `repos/${repository.owner}/${repository.name}/actions/runs/${runId}/jobs?filter=latest&per_page=100`;
+      const jobs = parseJobsResponse(await dependencies.githubApi(repository, endpoint));
+      const response = {
+        repository: repositoryName(repository),
+        runId,
+        jobs
+      };
+      sendJson(res, 200, response);
+    } catch (error) {
+      sendRouteError2(res, error);
+    }
+  });
+}
+var execFile3, MAX_RUNS, DEFAULT_RUNS, GITHUB_NAME, GITHUB_HOST, RUN_STATUSES, RUN_CONCLUSIONS, GitHubActionsRouteError, defaultDependencies;
+var init_github_actions = __esm({
+  "../../server/routes/github-actions.ts"() {
+    init_http();
+    init_gitProject();
+    execFile3 = promisify2(execFileCallback2);
+    MAX_RUNS = 30;
+    DEFAULT_RUNS = 20;
+    GITHUB_NAME = /^[A-Za-z0-9_.-]+$/;
+    GITHUB_HOST = /^[A-Za-z0-9.-]+$/;
+    RUN_STATUSES = /* @__PURE__ */ new Set([
+      "completed",
+      "in_progress",
+      "pending",
+      "queued",
+      "requested",
+      "waiting"
+    ]);
+    RUN_CONCLUSIONS = /* @__PURE__ */ new Set([
+      "action_required",
+      "cancelled",
+      "failure",
+      "neutral",
+      "skipped",
+      "stale",
+      "startup_failure",
+      "success",
+      "timed_out"
+    ]);
+    GitHubActionsRouteError = class extends Error {
+      constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+      }
+    };
+    defaultDependencies = {
+      resolveProject: resolveGitProject,
+      git: runGit,
+      githubApi: runGitHubApi
+    };
+  }
+});
+
+// ../../server/routes/vercel-deployments.ts
+import { execFile as execFileCallback3 } from "node:child_process";
+import { readFile as readFile15, realpath as realpath8, stat as stat13 } from "node:fs/promises";
+import { isAbsolute as isAbsolute8, join as join20, resolve as resolve15 } from "node:path";
+import { promisify as promisify3 } from "node:util";
+function record3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function stringValue2(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function nullableString(value) {
+  return typeof value === "string" && value ? value : null;
+}
+function timestamp(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function firstString2(source, keys) {
+  if (!source) return "";
+  for (const key2 of keys) {
+    const value = stringValue2(source[key2]);
+    if (value) return value;
+  }
+  return "";
+}
+function deploymentState(value) {
+  return typeof value === "string" && DEPLOYMENT_STATES.has(value) ? value : "QUEUED";
+}
+function httpsUrl(value, hostnameOnly = false) {
+  const text = stringValue2(value);
+  if (!text) return null;
+  const candidate = hostnameOnly && !text.includes("://") ? `https://${text}` : text;
+  try {
+    const url = new URL(candidate);
+    return url.protocol === "https:" ? url.toString().replace(/\/$/, "") : null;
+  } catch {
+    return null;
+  }
+}
+function projectUrlFromInspector(value) {
+  if (!value) return null;
+  try {
+    const url = new URL(value);
+    const parts = url.pathname.split("/").filter(Boolean);
+    if (parts.length < 3) return null;
+    url.pathname = `/${parts.slice(0, -1).join("/")}`;
+    url.search = "";
+    url.hash = "";
+    return url.toString().replace(/\/$/, "");
+  } catch {
+    return null;
+  }
+}
+function parseDeployment(value) {
+  const source = record3(value);
+  if (!source) return null;
+  const id = stringValue2(source.uid);
+  const createdAt = timestamp(source.createdAt) ?? timestamp(source.created);
+  if (!DEPLOYMENT_ID.test(id) || createdAt === null) return null;
+  const meta = record3(source.meta);
+  const creator = record3(source.creator);
+  return {
+    id,
+    name: stringValue2(source.name, "Deployment"),
+    url: httpsUrl(source.url, true),
+    inspectorUrl: httpsUrl(source.inspectorUrl),
+    state: deploymentState(source.readyState ?? source.state),
+    target: nullableString(source.target),
+    createdAt,
+    buildingAt: timestamp(source.buildingAt),
+    readyAt: timestamp(source.ready),
+    branch: firstString2(meta, [
+      "githubCommitRef",
+      "gitlabCommitRef",
+      "bitbucketCommitRef",
+      "branchAlias"
+    ]),
+    commitSha: firstString2(meta, [
+      "githubCommitSha",
+      "gitlabCommitSha",
+      "bitbucketCommitSha"
+    ]),
+    commitMessage: firstString2(meta, [
+      "githubCommitMessage",
+      "gitlabCommitMessage",
+      "bitbucketCommitMessage"
+    ]),
+    creator: firstString2(creator, ["username", "githubLogin", "email"]),
+    errorCode: nullableString(source.errorCode),
+    errorMessage: nullableString(source.errorMessage)
+  };
+}
+function parseDeploymentsResponse(value) {
+  const source = record3(value);
+  if (!source || !Array.isArray(source.deployments)) {
+    throw new VercelDeploymentsRouteError(
+      502,
+      "invalid_response",
+      "Vercel returned an invalid deployments response"
+    );
+  }
+  return source.deployments.map(parseDeployment).filter((deployment) => deployment !== null);
+}
+function parseBuildLog(value) {
+  const source = record3(value);
+  if (!source) return null;
+  const createdAt = timestamp(source.created) ?? timestamp(source.date);
+  const text = stringValue2(source.text);
+  if (createdAt === null || !text) return null;
+  return {
+    id: stringValue2(source.id, `${createdAt}-${text}`),
+    createdAt,
+    type: stringValue2(source.type, "stdout"),
+    text
+  };
+}
+function parseBuildLogsResponse(value) {
+  if (!Array.isArray(value)) {
+    throw new VercelDeploymentsRouteError(
+      502,
+      "invalid_response",
+      "Vercel returned an invalid build log response"
+    );
+  }
+  return value.map(parseBuildLog).filter((event) => event !== null).sort((left, right) => left.createdAt - right.createdAt);
+}
+function parseProjectFile(value, root) {
+  const source = record3(value);
+  const projectId = stringValue2(source?.projectId);
+  const teamId = stringValue2(source?.orgId);
+  const projectName = stringValue2(source?.projectName, "Vercel project");
+  if (!VERCEL_ID.test(projectId) || !VERCEL_ID.test(teamId)) {
+    throw new VercelDeploymentsRouteError(
+      400,
+      "vercel_project_unlinked",
+      "This project has an invalid .vercel/project.json link"
+    );
+  }
+  return { root, projectId, projectName, teamId };
+}
+async function resolveLinkedVercelProject(cwd) {
+  if (!isAbsolute8(cwd)) {
+    throw new VercelDeploymentsRouteError(400, "vercel_project_unlinked", "cwd must be an absolute path");
+  }
+  let root;
+  try {
+    root = await realpath8(resolve15(cwd));
+    if (!(await stat13(root)).isDirectory()) throw new Error("not a directory");
+  } catch {
+    throw new VercelDeploymentsRouteError(404, "vercel_project_unlinked", "Project directory not found");
+  }
+  const projectFile = join20(root, ".vercel", "project.json");
+  try {
+    const info = await stat13(projectFile);
+    if (!info.isFile() || info.size > MAX_PROJECT_FILE_BYTES) throw new Error("invalid project file");
+    return parseProjectFile(JSON.parse(await readFile15(projectFile, "utf8")), root);
+  } catch (error) {
+    if (error instanceof VercelDeploymentsRouteError) throw error;
+    const detail = error;
+    if (detail.code === "ENOENT") {
+      throw new VercelDeploymentsRouteError(
+        400,
+        "vercel_project_unlinked",
+        "Link this project with `vercel link` before viewing deployments"
+      );
+    }
+    throw new VercelDeploymentsRouteError(
+      400,
+      "vercel_project_unlinked",
+      "Unable to read this project's .vercel/project.json link"
+    );
+  }
+}
+async function executeVercel(cwd, args) {
+  const cli = resolveAgentCommand("vercel", args);
+  const result = await execFile4(cli.command, cli.args, {
+    cwd,
+    encoding: "utf-8",
+    env: {
+      ...process.env,
+      NO_COLOR: "1",
+      VERCEL_TELEMETRY_DISABLED: "1"
+    },
+    maxBuffer: 16 * 1024 * 1024,
+    timeout: 3e4,
+    windowsHide: true,
+    ...cli.spawnOptions
+  });
+  return { stdout: result.stdout, stderr: result.stderr };
+}
+function parseCliVersion(output) {
+  const match = output.match(/(?:^|\s)(\d+)\.(\d+)\.(\d+)(?:\s|$)/);
+  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+}
+function isVersionAtLeast(actual, minimum) {
+  for (let index = 0; index < minimum.length; index += 1) {
+    if (actual[index] > minimum[index]) return true;
+    if (actual[index] < minimum[index]) return false;
+  }
+  return true;
+}
+function mapVercelFailure(error) {
+  if (error instanceof VercelDeploymentsRouteError) return error;
+  const failure = error;
+  if (failure.code === "ENOENT") {
+    return new VercelDeploymentsRouteError(503, "vercel_missing", "Install Vercel CLI to view deployments");
+  }
+  const detail = `${failure.message ?? ""}
+${failure.stderr ?? ""}
+${failure.stdout ?? ""}`;
+  if (/not authenticated|not logged|log in|login|authentication|invalid token|unauthorized|401/i.test(detail)) {
+    return new VercelDeploymentsRouteError(
+      503,
+      "vercel_auth_required",
+      "Sign in with `vercel login` to view deployments"
+    );
+  }
+  if (/forbidden|access denied|not authorized|permission|403/i.test(detail)) {
+    return new VercelDeploymentsRouteError(
+      403,
+      "vercel_access_denied",
+      "Your Vercel account cannot access this linked project"
+    );
+  }
+  return new VercelDeploymentsRouteError(502, "vercel_api_failed", "Vercel deployment data is unavailable");
+}
+async function runVercelApi(project, endpoint, runCommand = executeVercel) {
+  try {
+    const versionResult = await runCommand(project.root, ["--version"]);
+    const version = parseCliVersion(`${versionResult.stdout}
+${versionResult.stderr}`);
+    if (!version || !isVersionAtLeast(version, MINIMUM_API_CLI_VERSION)) {
+      throw new VercelDeploymentsRouteError(
+        503,
+        "vercel_cli_too_old",
+        "Update Vercel CLI to version 50.5.1 or newer to view deployments safely"
+      );
+    }
+    const result = await runCommand(project.root, [
+      "api",
+      endpoint,
+      "--raw",
+      "--cwd",
+      project.root,
+      "--non-interactive",
+      "--no-color"
+    ]);
+    try {
+      return JSON.parse(result.stdout);
+    } catch {
+      throw new VercelDeploymentsRouteError(
+        502,
+        "invalid_response",
+        "Vercel returned invalid JSON"
+      );
+    }
+  } catch (error) {
+    throw mapVercelFailure(error);
+  }
+}
+function boundedLimit(value, fallback, maximum) {
+  const requested = Number(value ?? fallback);
+  return Number.isInteger(requested) ? Math.min(maximum, Math.max(1, requested)) : fallback;
+}
+function sendRouteError3(res, error) {
+  const detail = mapVercelFailure(error);
+  sendJson(res, detail.status, { error: detail.message, code: detail.code });
+}
+function registerVercelDeploymentRoutes(use, dependencies = defaultDependencies2) {
+  use("/api/vercel-deployments", async (req, res, next) => {
+    if (req.method !== "GET") return next();
+    const url = new URL(req.url || "", "http://localhost");
+    if (url.pathname !== "/" && url.pathname !== "") return next();
+    const limit = boundedLimit(url.searchParams.get("limit"), DEFAULT_DEPLOYMENT_LIMIT, MAX_DEPLOYMENT_LIMIT);
+    try {
+      const project = await dependencies.resolveProject(url.searchParams.get("cwd") ?? "");
+      const endpoint = `/v7/deployments?projectId=${encodeURIComponent(project.projectId)}&teamId=${encodeURIComponent(project.teamId)}&limit=${limit}`;
+      const deployments = parseDeploymentsResponse(await dependencies.vercelApi(project, endpoint));
+      const response = {
+        projectId: project.projectId,
+        projectName: project.projectName,
+        teamId: project.teamId,
+        projectUrl: projectUrlFromInspector(deployments[0]?.inspectorUrl ?? null),
+        deployments
+      };
+      sendJson(res, 200, response);
+    } catch (error) {
+      sendRouteError3(res, error);
+    }
+  });
+  use("/api/vercel-deployments/build-logs", async (req, res, next) => {
+    if (req.method !== "GET") return next();
+    const url = new URL(req.url || "", "http://localhost");
+    if (url.pathname !== "/" && url.pathname !== "") return next();
+    const deploymentId = url.searchParams.get("deploymentId") ?? "";
+    if (!DEPLOYMENT_ID.test(deploymentId)) {
+      return sendJson(res, 400, {
+        error: "deploymentId must be a Vercel deployment ID",
+        code: "vercel_api_failed"
+      });
+    }
+    const limit = boundedLimit(url.searchParams.get("limit"), DEFAULT_LOG_LIMIT, MAX_LOG_LIMIT);
+    try {
+      const project = await dependencies.resolveProject(url.searchParams.get("cwd") ?? "");
+      const endpoint = `/v3/deployments/${deploymentId}/events?teamId=${encodeURIComponent(project.teamId)}&direction=backward&limit=${limit}`;
+      const events = parseBuildLogsResponse(await dependencies.vercelApi(project, endpoint));
+      const response = { deploymentId, events };
+      sendJson(res, 200, response);
+    } catch (error) {
+      sendRouteError3(res, error);
+    }
+  });
+}
+var execFile4, DEFAULT_DEPLOYMENT_LIMIT, MAX_DEPLOYMENT_LIMIT, DEFAULT_LOG_LIMIT, MAX_LOG_LIMIT, MAX_PROJECT_FILE_BYTES, MINIMUM_API_CLI_VERSION, VERCEL_ID, DEPLOYMENT_ID, DEPLOYMENT_STATES, VercelDeploymentsRouteError, defaultDependencies2;
+var init_vercel_deployments = __esm({
+  "../../server/routes/vercel-deployments.ts"() {
+    init_http();
+    init_binaryResolver();
+    execFile4 = promisify3(execFileCallback3);
+    DEFAULT_DEPLOYMENT_LIMIT = 20;
+    MAX_DEPLOYMENT_LIMIT = 30;
+    DEFAULT_LOG_LIMIT = 200;
+    MAX_LOG_LIMIT = 500;
+    MAX_PROJECT_FILE_BYTES = 64 * 1024;
+    MINIMUM_API_CLI_VERSION = [50, 5, 1];
+    VERCEL_ID = /^[A-Za-z0-9_-]+$/;
+    DEPLOYMENT_ID = /^dpl_[A-Za-z0-9]+$/;
+    DEPLOYMENT_STATES = /* @__PURE__ */ new Set([
+      "BLOCKED",
+      "BUILDING",
+      "CANCELED",
+      "ERROR",
+      "INITIALIZING",
+      "QUEUED",
+      "READY"
+    ]);
+    VercelDeploymentsRouteError = class extends Error {
+      constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+      }
+    };
+    defaultDependencies2 = {
+      resolveProject: resolveLinkedVercelProject,
+      vercelApi: runVercelApi
+    };
+  }
+});
+
 // ../../server/lib/projectIcon.ts
-import { realpath as realpath8, stat as stat13 } from "node:fs/promises";
-import { basename as basename9, extname, join as join20, relative as relative8, sep as sep10 } from "node:path";
+import { realpath as realpath9, stat as stat14 } from "node:fs/promises";
+import { basename as basename9, extname, join as join21, relative as relative8, sep as sep10 } from "node:path";
 function namedIconCandidates(root) {
   const name = basename9(root);
   if (!name || name.startsWith(".")) return [];
   return ["public", "assets", "static", "."].flatMap(
-    (dir) => NAMED_ICON_EXTENSIONS.map((ext) => join20(dir, `${name}${ext}`))
+    (dir) => NAMED_ICON_EXTENSIONS.map((ext) => join21(dir, `${name}${ext}`))
   );
 }
 function iconContentType(path) {
@@ -21158,7 +21942,7 @@ function isInside(root, candidate) {
 async function resolveProjectIcon(projectPath) {
   let root;
   try {
-    root = await realpath8(projectPath);
+    root = await realpath9(projectPath);
   } catch {
     return null;
   }
@@ -21168,11 +21952,11 @@ async function resolveProjectIcon(projectPath) {
     ...PROJECT_ICON_CANDIDATES.slice(6)
   ];
   for (const candidate of candidates) {
-    const guess = join20(root, candidate);
+    const guess = join21(root, candidate);
     try {
-      const resolved = await realpath8(guess);
+      const resolved = await realpath9(guess);
       if (!isInside(root, resolved)) continue;
-      const info = await stat13(resolved);
+      const info = await stat14(resolved);
       if (!info.isFile() || info.size === 0 || info.size > MAX_ICON_BYTES) continue;
       if (!iconContentType(resolved)) continue;
       return resolved;
@@ -21230,13 +22014,13 @@ var init_projectIcon = __esm({
 
 // ../../server/routes/project-icon.ts
 import { createReadStream } from "node:fs";
-import { isAbsolute as isAbsolute8 } from "node:path";
+import { isAbsolute as isAbsolute9 } from "node:path";
 function registerProjectIconRoutes(use) {
   use("/api/project-icon", async (req, res, next) => {
     if (req.method !== "GET") return next();
     const url = new URL(req.url || "", "http://localhost");
     const cwd = url.searchParams.get("cwd") ?? "";
-    if (!isAbsolute8(cwd)) {
+    if (!isAbsolute9(cwd)) {
       return sendJson(res, 400, { error: "cwd must be an absolute path" });
     }
     const icon = await resolveProjectIcon(cwd);
@@ -21321,14 +22105,14 @@ var init_local_file = __esm({
 });
 
 // ../../server/routes/mcp.ts
-import { execFile as execFile3 } from "node:child_process";
-import { isAbsolute as isAbsolute9, join as join21 } from "node:path";
-import { readFile as readFile15 } from "node:fs/promises";
+import { execFile as execFile5 } from "node:child_process";
+import { isAbsolute as isAbsolute10, join as join22 } from "node:path";
+import { readFile as readFile16 } from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
 async function readMcpConfigs(cwd) {
   const configs = {};
   try {
-    const raw = await readFile15(join21(homedir7(), ".claude.json"), "utf-8");
+    const raw = await readFile16(join22(homedir7(), ".claude.json"), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.mcpServers && typeof parsed.mcpServers === "object") {
       Object.assign(configs, parsed.mcpServers);
@@ -21346,16 +22130,16 @@ async function readMcpConfigs(cwd) {
   } catch {
   }
   const otherSources = [
-    join21(homedir7(), ".claude", "settings.json"),
+    join22(homedir7(), ".claude", "settings.json"),
     // global settings
-    join21(cwd, ".mcp.json"),
+    join22(cwd, ".mcp.json"),
     // project
-    join21(cwd, ".claude", "settings.local.json")
+    join22(cwd, ".claude", "settings.local.json")
     // project local
   ];
   for (const path of otherSources) {
     try {
-      const raw = await readFile15(path, "utf-8");
+      const raw = await readFile16(path, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.mcpServers && typeof parsed.mcpServers === "object") {
         Object.assign(configs, parsed.mcpServers);
@@ -21398,18 +22182,18 @@ async function getMcpServers(cwd) {
     return { servers: cached.servers, configs: cached.configs };
   }
   const configs = await readMcpConfigs(cwd);
-  return new Promise((resolve21) => {
+  return new Promise((resolve22) => {
     const env = { ...process.env };
     delete env.CLAUDECODE;
     const cli = resolveAgentCommand("claude", ["mcp", "list"]);
-    execFile3(cli.command, cli.args, { cwd, env, timeout: 15e3, ...cli.spawnOptions }, (err, stdout) => {
+    execFile5(cli.command, cli.args, { cwd, env, timeout: 15e3, ...cli.spawnOptions }, (err, stdout) => {
       if (err) {
-        resolve21({ servers: cached?.servers ?? [], configs });
+        resolve22({ servers: cached?.servers ?? [], configs });
         return;
       }
       const servers = parseMcpListOutput(stdout);
       cache.set(cwd, { servers, configs, timestamp: Date.now() });
-      resolve21({ servers, configs });
+      resolve22({ servers, configs });
     });
   });
 }
@@ -21419,7 +22203,7 @@ function registerMcpRoutes(use) {
     const url = new URL(req.url || "", `http://${req.headers.host}`);
     const cwd = url.searchParams.get("cwd");
     const refresh = url.searchParams.get("refresh") === "1";
-    if (!cwd || !isAbsolute9(cwd)) {
+    if (!cwd || !isAbsolute10(cwd)) {
       return sendJson(res, 400, { error: "cwd must be an absolute path" });
     }
     if (refresh) clearMcpCache(cwd);
@@ -21531,7 +22315,7 @@ var init_diff_utils = __esm({
 function isObject9(value) {
   return typeof value === "object" && value !== null;
 }
-function firstString2(...values) {
+function firstString3(...values) {
   return values.find((value) => typeof value === "string") ?? "";
 }
 function truncate(value, length = 140) {
@@ -21778,19 +22562,19 @@ function nativeWebPresentation(input) {
   if (type === "open_page" || type === "openPage") {
     return {
       label: "Open page",
-      summary: firstString2(action?.url, input.query),
+      summary: firstString3(action?.url, input.query),
       styleName: "WebSearch"
     };
   }
   if (type === "find_in_page" || type === "findInPage") {
     return {
       label: "Find on page",
-      summary: [firstString2(action?.pattern), firstString2(action?.url)].filter(Boolean).join(" \xB7 "),
+      summary: [firstString3(action?.pattern), firstString3(action?.url)].filter(Boolean).join(" \xB7 "),
       styleName: "WebSearch"
     };
   }
   const queries = Array.isArray(action?.queries) ? action.queries.filter((query5) => typeof query5 === "string") : [];
-  const query4 = firstString2(action?.query, input.query);
+  const query4 = firstString3(action?.query, input.query);
   return {
     label: "Search web",
     summary: compactValues([query4, ...queries]),
@@ -21798,7 +22582,7 @@ function nativeWebPresentation(input) {
   };
 }
 function schemaFreeSummary(input) {
-  const gist = firstString2(...SCHEMA_FREE_GIST_KEYS.map((key2) => input[key2]));
+  const gist = firstString3(...SCHEMA_FREE_GIST_KEYS.map((key2) => input[key2]));
   if (gist) return truncate(gist);
   for (const [key2, value] of Object.entries(input)) {
     if (!Array.isArray(value)) continue;
@@ -21808,11 +22592,11 @@ function schemaFreeSummary(input) {
   return "";
 }
 function workflowSummary(input) {
-  const description = firstString2(input.description);
+  const description = firstString3(input.description);
   if (description) return truncate(description);
-  const script = firstString2(input.script);
+  const script = firstString3(input.script);
   const metaName = script ? extractJsStringPropertyValues(script, "name")[0] ?? "" : "";
-  return metaName || firstString2(input.scriptPath);
+  return metaName || firstString3(input.scriptPath);
 }
 function firstStringValue(input) {
   const keys = Object.keys(input);
@@ -21889,19 +22673,19 @@ function defaultToolSummary(tc) {
     case "ToolSearch":
       return String(input.query ?? "");
     case "SendMessage": {
-      const recipient = firstString2(input.to, input.recipient);
-      const gist = truncate(firstString2(input.summary, input.message, input.content));
+      const recipient = firstString3(input.to, input.recipient);
+      const gist = truncate(firstString3(input.summary, input.message, input.content));
       return [recipient, gist].filter(Boolean).join(" \xB7 ");
     }
     case "ListAgents":
     case "TaskList":
       return "";
     case "TaskCreate":
-      return truncate(firstString2(input.subject, input.description));
+      return truncate(firstString3(input.subject, input.description));
     case "TaskUpdate": {
       const taskId = String(input.taskId ?? "");
       const blockers = Array.isArray(input.addBlockedBy) ? input.addBlockedBy.filter((id) => typeof id === "string") : [];
-      const change = firstString2(input.status) || (blockers.length > 0 ? `blocked by ${blockers.join(", ")}` : "");
+      const change = firstString3(input.status) || (blockers.length > 0 ? `blocked by ${blockers.join(", ")}` : "");
       return change ? `${taskId} \u2192 ${change}` : taskId;
     }
     case "TaskOutput":
@@ -22201,8 +22985,8 @@ function copilotText(value) {
   if (!Array.isArray(value)) return "";
   return value.flatMap((part) => {
     if (typeof part === "string") return part ? [part] : [];
-    const record2 = asRecord5(part);
-    const text = str(record2.text) || str(record2.content);
+    const record4 = asRecord5(part);
+    const text = str(record4.text) || str(record4.content);
     return text ? [text] : [];
   }).join("\n");
 }
@@ -22534,7 +23318,7 @@ var init_summaryFolds = __esm({
 });
 
 // ../../server/lib/missionControlSummary.ts
-import { open as open7, stat as stat14 } from "node:fs/promises";
+import { open as open7, stat as stat15 } from "node:fs/promises";
 function foldLine(acc, line) {
   const trimmed = line.trim();
   if (!trimmed) return;
@@ -22544,10 +23328,10 @@ function foldLine(acc, line) {
   } catch {
     return;
   }
-  const timestamp = str(entry.timestamp);
-  if (timestamp) {
-    acc.startedAt ??= timestamp;
-    acc.lastEventAt = timestamp;
+  const timestamp2 = str(entry.timestamp);
+  if (timestamp2) {
+    acc.startedAt ??= timestamp2;
+    acc.lastEventAt = timestamp2;
   }
   foldSummaryEntry(acc, entry);
 }
@@ -22609,7 +23393,7 @@ async function readSince(filePath, from, to) {
 async function summarizeSession(sessionId, filePath) {
   let size;
   try {
-    size = (await stat14(filePath)).size;
+    size = (await stat15(filePath)).size;
   } catch {
     return null;
   }
@@ -22766,14 +23550,14 @@ var init_models = __esm({
 });
 
 // ../../server/lib/notificationHistory.ts
-import { mkdir as mkdir5, readFile as readFile16 } from "node:fs/promises";
+import { mkdir as mkdir5, readFile as readFile17 } from "node:fs/promises";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { dirname as dirname9, join as join22 } from "node:path";
+import { dirname as dirname9, join as join23 } from "node:path";
 import { randomUUID as randomUUID4 } from "node:crypto";
 async function load() {
   if (entries) return entries;
-  loadPromise ??= readFile16(NOTIFICATION_HISTORY_FILE, "utf-8").then((raw) => {
+  loadPromise ??= readFile17(NOTIFICATION_HISTORY_FILE, "utf-8").then((raw) => {
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed) ? parsed.filter(isEntry) : [];
   }).catch(() => []).then((loaded2) => {
@@ -22857,7 +23641,7 @@ var NOTIFICATION_HISTORY_FILE, MAX_ENTRIES, PERSIST_DEBOUNCE_MS, entries, loadPr
 var init_notificationHistory = __esm({
   "../../server/lib/notificationHistory.ts"() {
     init_atomicJsonFile();
-    NOTIFICATION_HISTORY_FILE = join22(homedir8(), ".cogpit", "notifications.json");
+    NOTIFICATION_HISTORY_FILE = join23(homedir8(), ".cogpit", "notifications.json");
     MAX_ENTRIES = 200;
     PERSIST_DEBOUNCE_MS = 500;
     entries = null;
@@ -22905,7 +23689,7 @@ var init_notifications = __esm({
 });
 
 // ../../server/lib/systemProcesses.ts
-import { execFile as execFile4 } from "node:child_process";
+import { execFile as execFile6 } from "node:child_process";
 function parseEtimeSeconds(etime) {
   const match = /^(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+)$/.exec(etime.trim());
   if (!match) return 0;
@@ -23026,12 +23810,12 @@ function classifyProcesses(rows, selfPid) {
   }).slice(0, MAX_LISTED_PROCESSES);
 }
 function listSystemProcesses() {
-  return new Promise((resolve21, reject) => {
-    execFile4(
+  return new Promise((resolve22, reject) => {
+    execFile6(
       "ps",
       ["-axo", "pid=,ppid=,pcpu=,rss=,etime=,args="],
       { maxBuffer: 8 * 1024 * 1024 },
-      (error, stdout) => error ? reject(error) : resolve21(stdout)
+      (error, stdout) => error ? reject(error) : resolve22(stdout)
     );
   });
 }
@@ -23065,7 +23849,7 @@ var init_systemProcesses = __esm({
 });
 
 // ../../server/lib/desktopNotify.ts
-import { execFile as execFile5 } from "node:child_process";
+import { execFile as execFile7 } from "node:child_process";
 function parentMessagePort() {
   const { parentPort } = process;
   return parentPort && typeof parentPort.postMessage === "function" ? parentPort : null;
@@ -23078,7 +23862,7 @@ function showNotification(title, body, nav, historyId) {
     return;
   }
   if (process.platform === "darwin") {
-    execFile5(
+    execFile7(
       "osascript",
       ["-e", `display notification "${escapeAppleScript(body)}" with title "${escapeAppleScript(title)}"`],
       // This is the standalone server's only desktop channel, so a silent
@@ -23119,9 +23903,9 @@ var init_notifications2 = __esm({
 });
 
 // ../../server/lib/pushConfig.ts
-import { readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
+import { readFileSync as readFileSync3, statSync as statSync3 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 function warnOnce(message) {
   if (lastWarning === message) return;
   lastWarning = message;
@@ -23132,7 +23916,7 @@ function asString(value) {
 }
 function fileMtime(path) {
   try {
-    return statSync2(path).mtimeMs;
+    return statSync3(path).mtimeMs;
   } catch {
     return null;
   }
@@ -23147,8 +23931,8 @@ function warnIfExposed(path, mode) {
 function readConfigFile(path) {
   let raw;
   try {
-    warnIfExposed(path, statSync2(path).mode);
-    raw = readFileSync2(path, "utf8");
+    warnIfExposed(path, statSync3(path).mode);
+    raw = readFileSync3(path, "utf8");
   } catch (err) {
     const code = err.code;
     if (code !== "ENOENT") warnOnce(`Could not read ${path}: ${code ?? String(err)}`);
@@ -23181,7 +23965,7 @@ function normalizeBaseUrl(value, label) {
   }
   return parsed.toString().replace(/\/+$/, "");
 }
-function resolve15(path) {
+function resolve16(path) {
   const file = readConfigFile(path);
   const topic = asString(process.env.COGPIT_NTFY_TOPIC) ?? asString(file.topic);
   if (!topic) return null;
@@ -23209,14 +23993,14 @@ function getPushConfig(path = PUSH_CONFIG_FILE) {
     process.env.COGPIT_PUBLIC_URL
   ].join("\0");
   if (cache3?.key === key2) return cache3.config;
-  const config = resolve15(path);
+  const config = resolve16(path);
   cache3 = { key: key2, config };
   return config;
 }
 var PUSH_CONFIG_FILE, DEFAULT_NTFY_URL, TOPIC_PATTERN, cache3, lastWarning;
 var init_pushConfig = __esm({
   "../../server/lib/pushConfig.ts"() {
-    PUSH_CONFIG_FILE = join23(homedir9(), ".cogpit", "push.json");
+    PUSH_CONFIG_FILE = join24(homedir9(), ".cogpit", "push.json");
     DEFAULT_NTFY_URL = "https://ntfy.sh";
     TOPIC_PATTERN = /^[-_A-Za-z0-9]{1,64}$/;
     cache3 = null;
@@ -23831,22 +24615,22 @@ async function handleBackgroundTasks(req, res, next) {
     const portAlive = {};
     await Promise.all(
       allPorts.map(
-        (port) => new Promise((resolve21) => {
+        (port) => new Promise((resolve22) => {
           const socket = createConnection({ port, host: "127.0.0.1" });
           socket.setTimeout(500);
           socket.on("connect", () => {
             portAlive[port] = true;
             socket.destroy();
-            resolve21();
+            resolve22();
           });
           socket.on("timeout", () => {
             portAlive[port] = false;
             socket.destroy();
-            resolve21();
+            resolve22();
           });
           socket.on("error", () => {
             portAlive[port] = false;
-            resolve21();
+            resolve22();
           });
         })
       )
@@ -23950,14 +24734,14 @@ var init_backgroundAgents = __esm({
 
 // ../../server/routes/ports/listeningProcesses.ts
 function runCapture(command, args) {
-  return new Promise((resolve21, reject) => {
-    const child = spawn(command, args);
+  return new Promise((resolve22, reject) => {
+    const child = spawn2(command, args);
     let stdout = "";
     child.stdout?.on("data", (data) => {
       stdout += data.toString();
     });
     child.on("error", reject);
-    child.on("close", () => resolve21(stdout));
+    child.on("close", () => resolve22(stdout));
   });
 }
 async function findListeningPids(port) {
@@ -23997,22 +24781,22 @@ function registerPortRoutes(use) {
     const results = {};
     await Promise.all(
       ports.map(
-        (port) => new Promise((resolve21) => {
+        (port) => new Promise((resolve22) => {
           const socket = createConnection({ port, host: "127.0.0.1" });
           socket.setTimeout(500);
           socket.on("connect", () => {
             results[port] = true;
             socket.destroy();
-            resolve21();
+            resolve22();
           });
           socket.on("timeout", () => {
             results[port] = false;
             socket.destroy();
-            resolve21();
+            resolve22();
           });
           socket.on("error", () => {
             results[port] = false;
-            resolve21();
+            resolve22();
           });
         })
       )
@@ -24082,8 +24866,8 @@ var init_ports2 = __esm({
 
 // ../../server/routes/project-file.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { readFile as readFile17, realpath as realpath9, rename as rename3, stat as stat15, unlink as unlink6, writeFile as writeFile6 } from "node:fs/promises";
-import { dirname as dirname10, isAbsolute as isAbsolute10, resolve as resolve16 } from "node:path";
+import { readFile as readFile18, realpath as realpath10, rename as rename3, stat as stat16, unlink as unlink6, writeFile as writeFile6 } from "node:fs/promises";
+import { dirname as dirname10, isAbsolute as isAbsolute11, resolve as resolve17 } from "node:path";
 function readBody(req) {
   return new Promise((resolveBody, reject) => {
     let body = "";
@@ -24101,26 +24885,26 @@ function readBody(req) {
   });
 }
 async function resolveProjectFile(cwd, filePath) {
-  if (!isAbsolute10(cwd)) throw new ProjectFileError(400, "cwd must be an absolute path");
-  if (!filePath || isAbsolute10(filePath) || filePath.includes("\0")) {
+  if (!isAbsolute11(cwd)) throw new ProjectFileError(400, "cwd must be an absolute path");
+  if (!filePath || isAbsolute11(filePath) || filePath.includes("\0")) {
     throw new ProjectFileError(400, "path must be a relative project file");
   }
   let root;
   try {
-    root = await realpath9(resolve16(cwd));
+    root = await realpath10(resolve17(cwd));
   } catch {
     throw new ProjectFileError(404, "Project directory not found");
   }
-  const candidate = resolve16(root, filePath);
+  const candidate = resolve17(root, filePath);
   if (!isWithinDir(root, candidate)) throw new ProjectFileError(403, "File is outside the project");
   let absolutePath;
   try {
-    absolutePath = await realpath9(candidate);
+    absolutePath = await realpath10(candidate);
   } catch {
     throw new ProjectFileError(404, "File not found");
   }
   if (!isWithinDir(root, absolutePath)) throw new ProjectFileError(403, "File is outside the project");
-  const info = await stat15(absolutePath);
+  const info = await stat16(absolutePath);
   if (!info.isFile()) throw new ProjectFileError(400, "Path must point to a file");
   if (info.size > MAX_FILE_BYTES) throw new ProjectFileError(413, "File is larger than 2 MB");
   return { absolutePath, info };
@@ -24140,14 +24924,14 @@ function decodeTextFile(buffer) {
   }
 }
 async function writeAtomically(absolutePath, content, mode, expectedMtimeMs) {
-  const latest = await stat15(absolutePath);
+  const latest = await stat16(absolutePath);
   if (latest.mtimeMs !== expectedMtimeMs) {
     throw new ProjectFileError(409, "File changed on disk. Reload it before saving.");
   }
-  const temporaryPath = resolve16(dirname10(absolutePath), `.${randomUUID5()}.cogpit-save`);
+  const temporaryPath = resolve17(dirname10(absolutePath), `.${randomUUID5()}.cogpit-save`);
   try {
     await writeFile6(temporaryPath, content, { encoding: "utf-8", mode });
-    const beforeRename = await stat15(absolutePath);
+    const beforeRename = await stat16(absolutePath);
     if (beforeRename.mtimeMs !== expectedMtimeMs) {
       throw new ProjectFileError(409, "File changed on disk. Reload it before saving.");
     }
@@ -24164,7 +24948,7 @@ function registerProjectFileContentRoutes(use) {
       const filePath = url.searchParams.get("path") ?? "";
       try {
         const file = await resolveProjectFile(cwd, filePath);
-        const buffer = await readFile17(file.absolutePath);
+        const buffer = await readFile18(file.absolutePath);
         return sendJson(res, 200, {
           content: decodeTextFile(buffer),
           mtimeMs: file.info.mtimeMs,
@@ -24188,7 +24972,7 @@ function registerProjectFileContentRoutes(use) {
           throw new ProjectFileError(409, "File changed on disk. Reload it before saving.");
         }
         await writeAtomically(file.absolutePath, body.content, file.info.mode, body.expectedMtimeMs);
-        const saved = await stat15(file.absolutePath);
+        const saved = await stat16(file.absolutePath);
         return sendJson(res, 200, { ok: true, mtimeMs: saved.mtimeMs, size: saved.size });
       } catch (error) {
         return respondWithError(res, error);
@@ -24238,13 +25022,13 @@ var init_project_files_ranking = __esm({
 });
 
 // ../../server/routes/project-files.ts
-import { execFile as execFileCallback2 } from "node:child_process";
-import { readdir as readdir11, realpath as realpath10, stat as stat16 } from "node:fs/promises";
-import { isAbsolute as isAbsolute11, relative as relative9, resolve as resolve17, sep as sep11 } from "node:path";
-import { promisify as promisify2 } from "node:util";
+import { execFile as execFileCallback4 } from "node:child_process";
+import { readdir as readdir11, realpath as realpath11, stat as stat17 } from "node:fs/promises";
+import { isAbsolute as isAbsolute12, relative as relative9, resolve as resolve18, sep as sep11 } from "node:path";
+import { promisify as promisify4 } from "node:util";
 async function listGitProjectFiles(root) {
   try {
-    const result = await execFile6(
+    const result = await execFile8(
       "git",
       ["ls-files", "--cached", "--others", "--exclude-standard", "-z", "--", "."],
       {
@@ -24280,7 +25064,7 @@ async function listProjectFiles(root, { skipCache = false } = {}) {
     }
     for (const entry of entries3) {
       if (entry.isSymbolicLink()) continue;
-      const absolutePath = resolve17(directory, entry.name);
+      const absolutePath = resolve18(directory, entry.name);
       if (entry.isDirectory()) {
         if (!IGNORED_DIRECTORIES.has(entry.name)) pending.push(absolutePath);
         continue;
@@ -24302,12 +25086,12 @@ function registerProjectFileRoutes(use) {
     const query4 = url.searchParams.get("q") ?? "";
     const limit = Math.min(Math.max(Number(url.searchParams.get("limit")) || 30, 1), 100);
     const skipCache = url.searchParams.get("refresh") === "1";
-    if (!isAbsolute11(cwd)) return sendJson(res, 400, { error: "cwd must be an absolute path" });
-    let root = resolve17(cwd);
+    if (!isAbsolute12(cwd)) return sendJson(res, 400, { error: "cwd must be an absolute path" });
+    let root = resolve18(cwd);
     try {
-      const info = await stat16(root);
+      const info = await stat17(root);
       if (!info.isDirectory()) return sendJson(res, 400, { error: "cwd must be a directory" });
-      root = await realpath10(root);
+      root = await realpath11(root);
       const files = await listProjectFiles(root, { skipCache });
       const ranked = rankProjectFiles(files, query4, limit);
       return sendJson(res, 200, {
@@ -24320,7 +25104,7 @@ function registerProjectFileRoutes(use) {
     }
   });
 }
-var MAX_FILES, CACHE_TTL_MS3, IGNORED_DIRECTORIES, fileCache, execFile6;
+var MAX_FILES, CACHE_TTL_MS3, IGNORED_DIRECTORIES, fileCache, execFile8;
 var init_project_files = __esm({
   "../../server/routes/project-files.ts"() {
     init_http();
@@ -24341,7 +25125,7 @@ var init_project_files = __esm({
       "target"
     ]);
     fileCache = /* @__PURE__ */ new Map();
-    execFile6 = promisify2(execFileCallback2);
+    execFile8 = promisify4(execFileCallback4);
   }
 });
 
@@ -24555,7 +25339,7 @@ function createCollector() {
   return {
     pullRequests,
     add,
-    record(output, command, toolCallId, timestamp) {
+    record(output, command, toolCallId, timestamp2) {
       const match = PR_URL.exec(output);
       if (!match) return;
       add({
@@ -24565,7 +25349,7 @@ function createCollector() {
         title: extractTitle(command),
         isDraft: /(?:^|\s)--draft(?:\s|$)/.test(command),
         toolCallId,
-        timestamp
+        timestamp: timestamp2
       });
     }
   };
@@ -24594,22 +25378,22 @@ function createPullRequestScanner() {
     seenReferences.add(key2);
     references.push(reference);
   }
-  function recordToolCall(id, input, timestamp) {
+  function recordToolCall(id, input, timestamp2) {
     const reference = findPullRequestReference(input);
     if (reference) recordReference(reference);
-    recordCreate(id, input, timestamp);
+    recordCreate(id, input, timestamp2);
   }
-  function recordCreate(id, input, timestamp) {
+  function recordCreate(id, input, timestamp2) {
     if (typeof id !== "string" || !id) return;
     const command = findCreateCommand(input);
-    if (command) openCreates.set(id, { command, timestamp });
+    if (command) openCreates.set(id, { command, timestamp: timestamp2 });
   }
-  function recordPrLink(record2, timestamp) {
-    const url = record2.prUrl;
-    const number = record2.prNumber;
+  function recordPrLink(record4, timestamp2) {
+    const url = record4.prUrl;
+    const number = record4.prNumber;
     if (typeof url !== "string" || !url) return;
     if (typeof number !== "number" || !Number.isInteger(number) || number <= 0) return;
-    const repo = typeof record2.prRepository === "string" ? record2.prRepository : "";
+    const repo = typeof record4.prRepository === "string" ? record4.prRepository : "";
     collector.add({
       url,
       number,
@@ -24617,7 +25401,7 @@ function createPullRequestScanner() {
       title: null,
       isDraft: false,
       toolCallId: "",
-      timestamp
+      timestamp: timestamp2
     });
     recordReference({ number, repo });
   }
@@ -24644,37 +25428,37 @@ function createPullRequestScanner() {
     if (!line.includes(GH_PR_HINT) && !line.includes(URL_HINT) && !line.includes(PR_LINK_HINT)) {
       return;
     }
-    let record2;
+    let record4;
     try {
-      record2 = JSON.parse(line);
+      record4 = JSON.parse(line);
     } catch {
       return;
     }
-    if (!isRecord5(record2)) return;
-    const timestamp = typeof record2.timestamp === "string" ? record2.timestamp : "";
-    if (record2.type === "pr-link") {
-      recordPrLink(record2, timestamp);
+    if (!isRecord5(record4)) return;
+    const timestamp2 = typeof record4.timestamp === "string" ? record4.timestamp : "";
+    if (record4.type === "pr-link") {
+      recordPrLink(record4, timestamp2);
       return;
     }
-    const payload = record2.payload;
+    const payload = record4.payload;
     if (isRecord5(payload)) {
       const type = payload.type;
       if (type === "function_call" || type === "custom_tool_call") {
-        recordToolCall(payload.call_id, parseArgs2(payload.arguments ?? payload.input), timestamp);
+        recordToolCall(payload.call_id, parseArgs2(payload.arguments ?? payload.input), timestamp2);
       } else if (type === "function_call_output" || type === "custom_tool_call_output") {
         recordResult(payload.call_id, payload.output, false);
       }
       return;
     }
-    const data = record2.data;
+    const data = record4.data;
     if (isRecord5(data)) {
-      if (record2.type === "tool.execution_start") {
+      if (record4.type === "tool.execution_start") {
         recordToolCall(
           data.toolCallId,
           parseArgs2(data.arguments ?? data.input),
-          timestamp
+          timestamp2
         );
-      } else if (record2.type === "tool.execution_complete") {
+      } else if (record4.type === "tool.execution_complete") {
         recordResult(
           data.toolCallId,
           data.result ?? data.output ?? data.error,
@@ -24683,12 +25467,12 @@ function createPullRequestScanner() {
       }
       return;
     }
-    const message = record2.message;
+    const message = record4.message;
     if (!isRecord5(message) || !Array.isArray(message.content)) return;
     for (const block of message.content) {
       if (!isRecord5(block)) continue;
       if (block.type === "tool_use" && isRecord5(block.input)) {
-        recordToolCall(block.id, block.input, timestamp);
+        recordToolCall(block.id, block.input, timestamp2);
       } else if (block.type === "tool_result") {
         recordResult(block.tool_use_id, block.content, block.is_error === true);
       }
@@ -24793,15 +25577,15 @@ var init_sessionPrIndex = __esm({
 });
 
 // ../../server/lib/sessionPrSearchIndex.ts
-import { mkdir as mkdir6, readFile as readFile18 } from "node:fs/promises";
-import { join as join24 } from "node:path";
+import { mkdir as mkdir6, readFile as readFile19 } from "node:fs/promises";
+import { join as join25 } from "node:path";
 function isIndexEntry(value) {
   if (typeof value !== "object" || value === null) return false;
   const entry = value;
   return typeof entry.size === "number" && typeof entry.mtimeMs === "number" && Array.isArray(entry.pullRequests) && Array.isArray(entry.references);
 }
 function currentIndexPath() {
-  return join24(dirs.SESSION_CONFIG_DIR, INDEX_FILE);
+  return join25(dirs.SESSION_CONFIG_DIR, INDEX_FILE);
 }
 function resetForPath(indexPath) {
   activeIndexPath = indexPath;
@@ -24818,7 +25602,7 @@ async function loadIndex() {
   if (loaded) return;
   if (loading) return loading;
   const expectedGeneration = generation;
-  const pendingLoad = readFile18(indexPath, "utf-8").then((raw) => {
+  const pendingLoad = readFile19(indexPath, "utf-8").then((raw) => {
     if (expectedGeneration !== generation) return;
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null) return;
@@ -24862,7 +25646,7 @@ async function runQueue(expectedGeneration) {
         await persistIndex(expectedGeneration).catch(() => void 0);
         sincePersist = 0;
       }
-      await new Promise((resolve21) => setImmediate(resolve21));
+      await new Promise((resolve22) => setImmediate(resolve22));
     }
     if (sincePersist > 0) await persistIndex(expectedGeneration).catch(() => void 0);
   } finally {
@@ -25547,6 +26331,19 @@ var init_projects2 = __esm({
   }
 });
 
+// ../../server/agents/executables.ts
+function activeExecutableFor(kind) {
+  return kind === "claude" ? claudeCliPath() : void 0;
+}
+function describeExecutableFor(kind) {
+  return kind === "claude" ? describeClaudeExecutable() : null;
+}
+var init_executables = __esm({
+  "../../server/agents/executables.ts"() {
+    init_claudeExecutable();
+  }
+});
+
 // ../../server/lib/providerUpdates.ts
 import { realpathSync } from "node:fs";
 function deriveStatus(current, latest) {
@@ -25649,8 +26446,8 @@ function buildUpdateCommand(provider, method) {
 function formatCommand(command) {
   return [command.executable, ...command.args].join(" ");
 }
-function resolveBinaryPaths(binName) {
-  const onPath = findExecutableOnPath(binName);
+function resolveBinaryPaths(descriptor7) {
+  const onPath = activeExecutableFor(descriptor7.kind) ?? findExecutableOnPath(descriptor7.binName);
   if (!onPath) return [];
   try {
     const real = realpathSync(onPath);
@@ -25699,7 +26496,7 @@ function fetchLatestVersion(packageName) {
   });
 }
 async function probeProvider(descriptor7) {
-  const paths = resolveBinaryPaths(descriptor7.binName);
+  const paths = resolveBinaryPaths(descriptor7);
   const base = {
     provider: descriptor7.kind,
     displayName: descriptor7.displayName,
@@ -25808,6 +26605,7 @@ var init_providerUpdates = __esm({
   "../../server/lib/providerUpdates.ts"() {
     init_agent_descriptors();
     init_versions();
+    init_executables();
     init_binaryResolver();
     init_cliProcess();
     REGISTRY_TIMEOUT_MS = 4e3;
@@ -25864,12 +26662,38 @@ var init_provider_updates = __esm({
   }
 });
 
+// ../../server/routes/agent-executable.ts
+function registerAgentExecutableRoutes(use) {
+  use("/api/agent-executable", async (req, res, next) => {
+    if (req.method !== "GET") return next();
+    const kind = new URL(req.url || "/", "http://localhost").pathname.slice(1);
+    if (!AGENT_KINDS.includes(kind)) return next();
+    const report = describeExecutableFor(kind);
+    if (!report) {
+      sendJson(res, 404, { error: `${kind} has a single executable; nothing to choose` });
+      return;
+    }
+    try {
+      sendJson(res, 200, await report);
+    } catch (err) {
+      sendJson(res, 500, { error: String(err) });
+    }
+  });
+}
+var init_agent_executable = __esm({
+  "../../server/routes/agent-executable.ts"() {
+    init_agent_descriptors();
+    init_executables();
+    init_http();
+  }
+});
+
 // ../../server/routes/scripts/discovery.ts
-import { readdir as readdir12, readFile as readFile19 } from "node:fs/promises";
-import { join as join25, relative as relative10 } from "node:path";
+import { readdir as readdir12, readFile as readFile20 } from "node:fs/promises";
+import { join as join26, relative as relative10 } from "node:path";
 async function extractScripts(dir, dirLabel) {
   try {
-    const raw = await readFile19(join25(dir, "package.json"), "utf-8");
+    const raw = await readFile20(join26(dir, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     const scripts = pkg.scripts;
     if (!scripts || typeof scripts !== "object") return [];
@@ -25895,7 +26719,7 @@ async function discoverScripts(projectDir) {
     );
     const childResults = await Promise.all(
       childDirs.map(async (entry) => {
-        const childPath = join25(projectDir, entry.name);
+        const childPath = join26(projectDir, entry.name);
         const label = relative10(projectDir, childPath) + "/";
         return extractScripts(childPath, label);
       })
@@ -25942,12 +26766,12 @@ var init_discovery = __esm({
 });
 
 // ../../server/routes/scripts/index.ts
-import { stat as stat17 } from "node:fs/promises";
-import { resolve as resolve18 } from "node:path";
+import { stat as stat18 } from "node:fs/promises";
+import { resolve as resolve19 } from "node:path";
 async function validateDir(dir) {
   try {
-    const resolved = resolve18(dir);
-    const info = await stat17(resolved);
+    const resolved = resolve19(dir);
+    const info = await stat18(resolved);
     return info.isDirectory() ? resolved : null;
   } catch {
     return null;
@@ -26012,7 +26836,7 @@ async function withTranscriptEffort(key2, stored) {
   }
 }
 function collectBody(req) {
-  return new Promise((resolve21, reject) => {
+  return new Promise((resolve22, reject) => {
     let body = "";
     req.on("data", (chunk) => {
       body += chunk.toString();
@@ -26021,7 +26845,7 @@ function collectBody(req) {
         req.destroy();
       }
     });
-    req.on("end", () => resolve21(body));
+    req.on("end", () => resolve22(body));
     req.on("error", reject);
   });
 }
@@ -26081,12 +26905,12 @@ var init_session_config = __esm({
 
 // ../../server/lib/agentTeamIdentity.ts
 import { open as open9, readdir as readdir13 } from "node:fs/promises";
-import { join as join26 } from "node:path";
+import { join as join27 } from "node:path";
 async function matchSubagentToMember(leadSessionId, subagentFileName, members) {
   const entries3 = await readdir13(dirs.PROJECTS_DIR, { withFileTypes: true });
   for (const entry of entries3) {
     if (!entry.isDirectory() || entry.name === "memory") continue;
-    const filePath = join26(
+    const filePath = join27(
       dirs.PROJECTS_DIR,
       entry.name,
       leadSessionId,
@@ -26779,7 +27603,7 @@ function normalizeCopilotFileChangeEvents(jsonlContent) {
       }
     });
   }
-  return records.map((record2) => JSON.stringify(record2)).join("\n");
+  return records.map((record4) => JSON.stringify(record4)).join("\n");
 }
 async function parseSessionFileChanges(jsonlContent, includeContent) {
   if (formatForText(jsonlContent).kind === "copilot") {
@@ -28199,8 +29023,8 @@ var init_paths = __esm({
 });
 
 // ../../server/routes/undo/fileOperations.ts
-import { basename as basename12, dirname as dirname13, isAbsolute as isAbsolute12 } from "node:path";
-import { lstat as lstat6, realpath as realpath11 } from "node:fs/promises";
+import { basename as basename12, dirname as dirname13, isAbsolute as isAbsolute13 } from "node:path";
+import { lstat as lstat6, realpath as realpath12 } from "node:fs/promises";
 function hasTraversalSegment(filePath) {
   return filePath.split(/[\\/]+/).includes("..");
 }
@@ -28211,7 +29035,7 @@ function isForbiddenPath(filePath) {
   return FORBIDDEN_PREFIXES.some((prefix) => isWithinDir(prefix, filePath));
 }
 async function resolveSafeOperationPath(filePath, home, canonicalHome) {
-  if (typeof filePath !== "string" || !isAbsolute12(filePath) || hasTraversalSegment(filePath)) {
+  if (typeof filePath !== "string" || !isAbsolute13(filePath) || hasTraversalSegment(filePath)) {
     return null;
   }
   const resolved = resolve7(filePath);
@@ -28219,12 +29043,12 @@ async function resolveSafeOperationPath(filePath, home, canonicalHome) {
   try {
     const stats = await lstat6(resolved);
     if (stats.isSymbolicLink()) return null;
-    const canonicalTarget = await realpath11(resolved);
+    const canonicalTarget = await realpath12(resolved);
     return isWithinDir(canonicalHome, canonicalTarget) && !isForbiddenPath(canonicalTarget) ? canonicalTarget : null;
   } catch (error) {
     if (!isMissingPathError(error)) return null;
     try {
-      const canonicalParent = await realpath11(dirname13(resolved));
+      const canonicalParent = await realpath12(dirname13(resolved));
       const canonicalTarget = join11(canonicalParent, basename12(resolved));
       return isWithinDir(canonicalHome, canonicalTarget) && !isForbiddenPath(canonicalTarget) ? canonicalTarget : null;
     } catch {
@@ -28272,7 +29096,7 @@ async function prepareFileOperations(operationValues, options = {}) {
   const home = resolve7(homedir4());
   let canonicalHome;
   try {
-    canonicalHome = await realpath11(home);
+    canonicalHome = await realpath12(home);
   } catch {
     throw new UndoOperationError(403, "File operations restricted to home directory");
   }
@@ -28476,7 +29300,7 @@ function applySessionMutation(content, mutation) {
 ` : "";
 }
 async function readBody2(req) {
-  return await new Promise((resolve21, reject) => {
+  return await new Promise((resolve22, reject) => {
     let body = "";
     let bytes = 0;
     let settled = false;
@@ -28495,7 +29319,7 @@ async function readBody2(req) {
     req.on("end", () => {
       if (!settled) {
         settled = true;
-        resolve21(body);
+        resolve22(body);
       }
     });
     req.on("error", (error) => {
@@ -28748,20 +29572,20 @@ var init_aggregate = __esm({
         this.#toDay = makeDayFormatter(options.timeZone);
       }
       /** Folds one record in; returns whether it actually contributed. */
-      add(record2) {
-        if (record2.dedupeKey !== null) {
-          if (this.#seen.has(record2.dedupeKey)) return false;
-          this.#seen.add(record2.dedupeKey);
+      add(record4) {
+        if (record4.dedupeKey !== null) {
+          if (this.#seen.has(record4.dedupeKey)) return false;
+          this.#seen.add(record4.dedupeKey);
         }
-        const day = this.#toDay(record2.timestampMs);
+        const day = this.#toDay(record4.timestampMs);
         if (day < this.#options.sinceDay || day > this.#options.untilDay) return false;
-        const key2 = [day, record2.provider, record2.model].join(KEY_SEPARATOR);
+        const key2 = [day, record4.provider, record4.model].join(KEY_SEPARATOR);
         let bucket = this.#buckets.get(key2);
         if (bucket === void 0) {
           bucket = {
             day,
-            provider: record2.provider,
-            model: record2.model,
+            provider: record4.provider,
+            model: record4.model,
             totals: emptyUsageCostTotals(),
             costUsd: 0,
             cacheSavingsUsd: 0,
@@ -28774,19 +29598,19 @@ var init_aggregate = __esm({
         }
         const priced = priceUsage(
           this.#options.rates,
-          record2.model,
-          record2.totals,
-          record2.reportedCostUsd
+          record4.model,
+          record4.totals,
+          record4.reportedCostUsd
         );
-        bucket.totals = addUsageCostTotals(bucket.totals, record2.totals);
+        bucket.totals = addUsageCostTotals(bucket.totals, record4.totals);
         bucket.costUsd += priced.costUsd;
-        bucket.cacheSavingsUsd += cacheSavingsUsd(this.#options.rates, record2.model, record2.totals);
+        bucket.cacheSavingsUsd += cacheSavingsUsd(this.#options.rates, record4.model, record4.totals);
         bucket.records += 1;
         if (priced.costSource === "unpriced") bucket.unpricedRecords += 1;
         if (priced.costSource === "providerReported") bucket.providerReportedRecords += 1;
-        if (record2.sessionId.length > 0) {
-          bucket.sessions.add(record2.sessionId);
-          this.#sessions.add(record2.sessionId);
+        if (record4.sessionId.length > 0) {
+          bucket.sessions.add(record4.sessionId);
+          this.#sessions.add(record4.sessionId);
         }
         return true;
       }
@@ -28816,8 +29640,8 @@ var init_aggregate = __esm({
 
 // ../../server/lib/usageCost/reader.ts
 import { createReadStream as createReadStream3 } from "node:fs";
-import { readdir as readdir14, stat as stat18 } from "node:fs/promises";
-import { join as join27 } from "node:path";
+import { readdir as readdir14, stat as stat19 } from "node:fs/promises";
+import { join as join28 } from "node:path";
 import { createInterface as createInterface3 } from "node:readline";
 async function listTranscriptFiles(root, sinceMs) {
   const found = [];
@@ -28829,14 +29653,14 @@ async function listTranscriptFiles(root, sinceMs) {
       return;
     }
     for (const entry of entries3) {
-      const child = join27(dir, entry.name);
+      const child = join28(dir, entry.name);
       if (entry.isDirectory()) {
         await walk2(child);
         continue;
       }
       if (!entry.name.endsWith(".jsonl")) continue;
       try {
-        const stats = await stat18(child);
+        const stats = await stat19(child);
         if (stats.mtimeMs >= sinceMs) {
           found.push({ path: child, size: stats.size, mtimeMs: stats.mtimeMs });
         }
@@ -28867,17 +29691,17 @@ async function readTranscriptRecords(filePath, provider) {
 function dedupeWithinFile(records) {
   const slotByKey = /* @__PURE__ */ new Map();
   const kept = [];
-  for (const record2 of records) {
-    if (record2.dedupeKey === null) {
-      kept.push(record2);
+  for (const record4 of records) {
+    if (record4.dedupeKey === null) {
+      kept.push(record4);
       continue;
     }
-    const slot = slotByKey.get(record2.dedupeKey);
+    const slot = slotByKey.get(record4.dedupeKey);
     if (slot === void 0) {
-      slotByKey.set(record2.dedupeKey, kept.push(record2) - 1);
+      slotByKey.set(record4.dedupeKey, kept.push(record4) - 1);
       continue;
     }
-    if (record2.totals.outputTokens > kept[slot].totals.outputTokens) kept[slot] = record2;
+    if (record4.totals.outputTokens > kept[slot].totals.outputTokens) kept[slot] = record4;
   }
   return kept;
 }
@@ -28888,10 +29712,10 @@ var init_reader = __esm({
 });
 
 // ../../server/lib/usageCost/service.ts
-import { readFile as readFile20, writeFile as writeFile7 } from "node:fs/promises";
-import { join as join28 } from "node:path";
+import { readFile as readFile21, writeFile as writeFile7 } from "node:fs/promises";
+import { join as join29 } from "node:path";
 function ratesCachePath() {
-  return join28(getDataRoot(), "usage-model-rates.json");
+  return join29(getDataRoot(), "usage-model-rates.json");
 }
 function ratesFetchedAt() {
   return ratesFetchedAtMs === null ? null : new Date(ratesFetchedAtMs).toISOString();
@@ -28901,7 +29725,7 @@ async function ensureRatesInner() {
   if (ratesFetchedAtMs !== null && now - ratesFetchedAtMs < RATES_TTL_MS) return;
   if (ratesFetchedAtMs === null) {
     try {
-      const raw = JSON.parse(await readFile20(ratesCachePath(), "utf8"));
+      const raw = JSON.parse(await readFile21(ratesCachePath(), "utf8"));
       if (typeof raw.fetchedAtMs === "number") {
         const parsed2 = parseRateTable(raw.document);
         if (parsed2.size > 0) {
@@ -28986,23 +29810,23 @@ async function readUsageCostSummary(input) {
     for (const file of files) {
       const records = await readFileRecords(file, provider);
       scannedFiles += 1;
-      for (const record2 of records) {
-        aggregator.add(record2);
-        if (!liveSessionIds.has(record2.sessionId)) continue;
-        const byModel = durableTotals.get(record2.sessionId) ?? /* @__PURE__ */ new Map();
+      for (const record4 of records) {
+        aggregator.add(record4);
+        if (!liveSessionIds.has(record4.sessionId)) continue;
+        const byModel = durableTotals.get(record4.sessionId) ?? /* @__PURE__ */ new Map();
         byModel.set(
-          record2.model,
+          record4.model,
           addUsageCostTotals(
-            byModel.get(record2.model) ?? emptyUsageCostTotals(),
-            record2.totals
+            byModel.get(record4.model) ?? emptyUsageCostTotals(),
+            record4.totals
           )
         );
-        durableTotals.set(record2.sessionId, byModel);
+        durableTotals.set(record4.sessionId, byModel);
       }
     }
   }
   for (const runtime of runtimes2) {
-    for (const record2 of await runtime.liveUsageRecords(durableTotals)) aggregator.add(record2);
+    for (const record4 of await runtime.liveUsageRecords(durableTotals)) aggregator.add(record4);
   }
   const retentionCutoffMs = startedAtMs - 90 * 24 * 60 * 60 * 1e3;
   for (const [path, entry] of fileCache2) {
@@ -29088,12 +29912,12 @@ async function readKeychainCredentials() {
   if (process.platform !== "darwin") {
     return null;
   }
-  return new Promise((resolve21) => {
+  return new Promise((resolve22) => {
     let resolved = false;
     const done = (value) => {
       if (resolved) return;
       resolved = true;
-      resolve21(value);
+      resolve22(value);
     };
     const child = spawn3("/usr/bin/security", [
       "find-generic-password",
@@ -29729,8 +30553,8 @@ var init_workflows2 = __esm({
 });
 
 // ../../server/routes/worktrees/worktreeIo.ts
-import { execFile as execFile7 } from "node:child_process";
-import { promisify as promisify3 } from "node:util";
+import { execFile as execFile9 } from "node:child_process";
+import { promisify as promisify5 } from "node:util";
 async function runWorktreeCommand(file, args, { cwd, timeoutMs = WORKTREE_COMMAND_TIMEOUT_MS }) {
   const result = await execFileAsync(file, [...args], {
     cwd,
@@ -29769,7 +30593,7 @@ var init_worktreeIo = __esm({
     WORKTREE_COMMAND_MAX_BUFFER = 4 * 1024 * 1024;
     WORKTREE_SCAN_CONCURRENCY = 4;
     SESSION_HEADER_CONCURRENCY = 8;
-    execFileAsync = promisify3(execFile7);
+    execFileAsync = promisify5(execFile9);
     NONINTERACTIVE_ENV = {
       ...process.env,
       GCM_INTERACTIVE: "Never",
@@ -29782,7 +30606,7 @@ var init_worktreeIo = __esm({
 });
 
 // ../../server/routes/worktrees/worktreeUtils.ts
-import { resolve as resolve19, dirname as dirname14 } from "node:path";
+import { resolve as resolve20, dirname as dirname14 } from "node:path";
 function isValidWorktreeName(name) {
   return /^[a-zA-Z0-9._-]+$/.test(name) && name.length <= 40;
 }
@@ -29845,7 +30669,7 @@ async function getMainWorktreeRoot(projectPath) {
     const commonDir = (await runWorktreeCommand("git", ["rev-parse", "--git-common-dir"], {
       cwd: projectPath
     })).trim();
-    return dirname14(resolve19(projectPath, commonDir));
+    return dirname14(resolve20(projectPath, commonDir));
   } catch {
     return null;
   }
@@ -29870,7 +30694,7 @@ var init_worktreeUtils = __esm({
 });
 
 // ../../server/routes/worktrees/worktreeListRoute.ts
-import { stat as stat19 } from "node:fs/promises";
+import { stat as stat20 } from "node:fs/promises";
 async function loadSessionBranches(projectDir) {
   const sessionBranches = /* @__PURE__ */ new Map();
   try {
@@ -29985,7 +30809,7 @@ async function buildWorktreeInfo(worktree, defaultBranch, sessionBranches) {
   }
   let createdAt = "";
   try {
-    createdAt = (await stat19(worktree.path)).birthtime.toISOString();
+    createdAt = (await stat20(worktree.path)).birthtime.toISOString();
   } catch {
   }
   return {
@@ -30046,9 +30870,9 @@ var init_worktreeListRoute = __esm({
 });
 
 // ../../server/routes/worktrees/index.ts
-import { stat as stat20 } from "node:fs/promises";
+import { stat as stat21 } from "node:fs/promises";
 async function readJsonRequestBody(req) {
-  const body = await new Promise((resolve21, reject) => {
+  const body = await new Promise((resolve22, reject) => {
     let data = "";
     let bytesRead = 0;
     let settled = false;
@@ -30065,7 +30889,7 @@ async function readJsonRequestBody(req) {
     req.on("end", () => {
       if (!settled) {
         settled = true;
-        resolve21(data);
+        resolve22(data);
       }
     });
     req.on("error", () => {
@@ -30116,7 +30940,7 @@ async function findStaleWorktrees(worktrees, cutoff) {
           cwd: worktree.path
         });
         if (status.trim()) return null;
-        const worktreeStat = await stat20(worktree.path);
+        const worktreeStat = await stat21(worktree.path);
         return worktreeStat.birthtime.getTime() < cutoff ? worktree : null;
       } catch {
         return null;
@@ -30357,6 +31181,8 @@ var init_api_routes = __esm({
     init_files();
     init_git_diff();
     init_git_status();
+    init_github_actions();
+    init_vercel_deployments();
     init_project_icon();
     init_hello();
     init_local_file();
@@ -30371,6 +31197,7 @@ var init_api_routes = __esm({
     init_project_files();
     init_projects2();
     init_provider_updates();
+    init_agent_executable();
     init_scripts();
     init_session_config();
     init_session_context();
@@ -30425,6 +31252,8 @@ var init_api_routes = __esm({
       apiRoute("project-files", registerProjectFileRoutes),
       apiRoute("project-file", registerProjectFileContentRoutes),
       apiRoute("git-status", registerGitStatusRoutes),
+      apiRoute("github-actions", registerGitHubActionsRoutes),
+      apiRoute("vercel-deployments", registerVercelDeploymentRoutes),
       apiRoute("project-icon", registerProjectIconRoutes),
       apiRoute("git-diff", registerGitDiffRoutes),
       apiRoute("mcp", registerMcpRoutes),
@@ -30438,7 +31267,8 @@ var init_api_routes = __esm({
       apiRoute("models", registerModelRoutes),
       apiRoute("codex-threads", registerCodexThreadRoutes),
       apiRoute("agent-runtime", registerAgentRuntimeRoutes),
-      apiRoute("provider-updates", registerProviderUpdateRoutes)
+      apiRoute("provider-updates", registerProviderUpdateRoutes),
+      apiRoute("agent-executable", registerAgentExecutableRoutes)
     ];
   }
 });
@@ -30854,18 +31684,18 @@ var init_pty_authorization = __esm({
 // ../../server/app-server.ts
 import express from "express";
 import { createServer, request as httpRequest2 } from "node:http";
-import { join as join29 } from "node:path";
+import { join as join30 } from "node:path";
 import { WebSocketServer as WebSocketServer2 } from "ws";
 async function createServerComposition(staticDir, userDataDir, environment) {
   setDataRoot(userDataDir);
-  setConfigPath(join29(userDataDir, "config.local.json"));
+  setConfigPath(join30(userDataDir, "config.local.json"));
   await loadConfig();
   const configEdition = getConfiguredEditionValue();
   initEdition({ shell: environment.mode, configEdition });
   const suppression = describeEditionSuppression(process.env, configEdition, environment.mode);
   if (suppression) console.warn(suppression);
   if (isTeamEdition()) {
-    const teamDir = join29(getDataRoot(), "team");
+    const teamDir = join30(getDataRoot(), "team");
     await initUsersStore(teamDir);
     await initSessionPersistence(teamDir);
     initializeBootstrapToken(userCount());
@@ -30976,7 +31806,7 @@ async function createServerComposition(staticDir, userDataDir, environment) {
       for (const socket of upgradedSockets) socket.destroy();
       upgradedSockets.clear();
       await Promise.all([
-        new Promise((resolve21) => wss.close(() => resolve21())),
+        new Promise((resolve22) => wss.close(() => resolve22())),
         cleanupProcesses(),
         ...allRuntimes().map((runtime) => runtime.shutdown()),
         flushSessionPersistence()
@@ -30988,8 +31818,8 @@ async function createServerComposition(staticDir, userDataDir, environment) {
     void cleanupRuntime();
   });
   const dispose = async () => {
-    const serverClosed = httpServer.listening ? new Promise((resolve21, reject) => {
-      httpServer.close((error) => error ? reject(error) : resolve21());
+    const serverClosed = httpServer.listening ? new Promise((resolve22, reject) => {
+      httpServer.close((error) => error ? reject(error) : resolve22());
     }) : Promise.resolve();
     await cleanupRuntime();
     await serverClosed;
@@ -31036,7 +31866,7 @@ var init_standalone_app_server = __esm({
 // ../../server/lib/portFile.ts
 import { mkdirSync as mkdirSync2, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir as homedir12 } from "node:os";
-import { dirname as dirname15, join as join30 } from "node:path";
+import { dirname as dirname15, join as join31 } from "node:path";
 function writePortFile(port) {
   try {
     mkdirSync2(dirname15(PORT_FILE), { recursive: true });
@@ -31056,7 +31886,7 @@ function removePortFile() {
 var PORT_FILE;
 var init_portFile = __esm({
   "../../server/lib/portFile.ts"() {
-    PORT_FILE = join30(homedir12(), ".cogpit", "port");
+    PORT_FILE = join31(homedir12(), ".cogpit", "port");
   }
 });
 
@@ -31266,8 +32096,8 @@ var init_sessionActivityMonitor = __esm({
 });
 
 // ../../server/lib/standalone-bootstrap.ts
-import { readFileSync as readFileSync3 } from "node:fs";
-function resolveEnvPassword(env = process.env, readFileFn = (p) => readFileSync3(p, "utf-8")) {
+import { readFileSync as readFileSync4 } from "node:fs";
+function resolveEnvPassword(env = process.env, readFileFn = (p) => readFileSync4(p, "utf-8")) {
   const file = env.COGPIT_NETWORK_PASSWORD_FILE;
   if (file && file.length > 0) {
     const trimmed = readFileFn(file).replace(/\r?\n$/, "");
@@ -31305,9 +32135,9 @@ __export(standalone_runtime_exports, {
 });
 import { existsSync, mkdirSync as mkdirSync3 } from "node:fs";
 import { homedir as homedir13 } from "node:os";
-import { join as join31 } from "node:path";
+import { join as join32 } from "node:path";
 function listen(server, port, host) {
-  return new Promise((resolve21, reject) => {
+  return new Promise((resolve22, reject) => {
     const onError = (error) => reject(error);
     server.once("error", onError);
     server.listen(port, host, () => {
@@ -31317,27 +32147,27 @@ function listen(server, port, host) {
         reject(new Error("Cogpit started without a listening address."));
         return;
       }
-      resolve21(address.port);
+      resolve22(address.port);
     });
   });
 }
 async function startStandaloneServer({
   staticDir,
-  dataDir = join31(homedir13(), ".config", "cogpit"),
+  dataDir = join32(homedir13(), ".config", "cogpit"),
   host = "127.0.0.1",
   port = 19384,
   env = process.env,
   publishPort = false
 }) {
   mkdirSync3(dataDir, { recursive: true });
-  const configPath = join31(dataDir, "config.local.json");
+  const configPath = join32(dataDir, "config.local.json");
   setConfigPath(configPath);
   const configExisted = existsSync(configPath);
   await loadConfig();
   let createdConfig;
   if (!configExisted) {
-    const claudeDir = join31(homedir13(), ".claude");
-    if (existsSync(join31(claudeDir, "projects"))) {
+    const claudeDir = join32(homedir13(), ".claude");
+    if (existsSync(join32(claudeDir, "projects"))) {
       await saveConfig({ claudeDir });
       createdConfig = `${configPath} for ${claudeDir}`;
     }
@@ -31410,7 +32240,7 @@ var init_standalone_runtime = __esm({
 // src/index.ts
 import { spawn as spawn4 } from "node:child_process";
 import { homedir as homedir14 } from "node:os";
-import { join as join32, resolve as resolve20 } from "node:path";
+import { join as join33, resolve as resolve21 } from "node:path";
 var SESSION_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/;
 var USAGE = `Cogpit
 
@@ -31477,7 +32307,7 @@ function parseArgs(argv) {
     if (value === "--data-dir") {
       const path = argv[index + 1];
       if (!path) throw new Error("--data-dir requires a directory.");
-      dataDir = resolve20(path);
+      dataDir = resolve21(path);
       index += 1;
       continue;
     }
@@ -31519,8 +32349,8 @@ async function openExternalUrl(url) {
 async function startPackagedServer(options) {
   const { startStandaloneServer: startStandaloneServer2 } = await Promise.resolve().then(() => (init_standalone_runtime(), standalone_runtime_exports));
   return startStandaloneServer2({
-    staticDir: join32(import.meta.dirname, "web"),
-    dataDir: options.dataDir ?? join32(homedir14(), ".config", "cogpit"),
+    staticDir: join33(import.meta.dirname, "web"),
+    dataDir: options.dataDir ?? join33(homedir14(), ".config", "cogpit"),
     host: "127.0.0.1",
     port: options.port,
     publishPort: false
@@ -31536,7 +32366,7 @@ async function waitForShutdownSignal() {
     for (const signal of signals) process.once(signal, done);
   });
 }
-var defaultDependencies = {
+var defaultDependencies3 = {
   fetch,
   openUrl: openExternalUrl,
   startServer: startPackagedServer,
@@ -31563,7 +32393,7 @@ async function verifyServer(server, command, deps) {
   }
 }
 async function run(argv, overrides = {}) {
-  const deps = { ...defaultDependencies, ...overrides };
+  const deps = { ...defaultDependencies3, ...overrides };
   let command;
   try {
     command = parseArgs(argv);