evil-omo 3.17.0 → 3.17.4

package/dist/cli/index.js

@@ -4915,6 +4915,42 @@ var init_command_executor = __esm(() => {
 });
 
 // src/shared/contains-path.ts
+import { existsSync, realpathSync } from "fs";
+import { basename, dirname, isAbsolute, join, normalize, relative, resolve } from "path";
+function findNearestExistingAncestor(resolvedPath) {
+  let candidatePath = resolvedPath;
+  while (!existsSync(candidatePath)) {
+    const parentPath = dirname(candidatePath);
+    if (parentPath === candidatePath) {
+      return candidatePath;
+    }
+    candidatePath = parentPath;
+  }
+  return candidatePath;
+}
+function toCanonicalPath(pathToNormalize) {
+  const resolvedPath = resolve(pathToNormalize);
+  if (existsSync(resolvedPath)) {
+    try {
+      return normalize(realpathSync.native(resolvedPath));
+    } catch {
+      return normalize(resolvedPath);
+    }
+  }
+  const nearestExistingAncestor = findNearestExistingAncestor(resolvedPath);
+  const canonicalAncestor = existsSync(nearestExistingAncestor) ? realpathSync.native(nearestExistingAncestor) : nearestExistingAncestor;
+  const relativePathFromAncestor = relative(nearestExistingAncestor, resolvedPath);
+  return normalize(join(canonicalAncestor, relativePathFromAncestor || basename(resolvedPath)));
+}
+function containsPath(rootPath, candidatePath) {
+  const canonicalRootPath = toCanonicalPath(rootPath);
+  const canonicalCandidatePath = toCanonicalPath(candidatePath);
+  const relativePath = relative(canonicalRootPath, canonicalCandidatePath);
+  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute(relativePath);
+}
+function isWithinProject(candidatePath, projectRoot) {
+  return containsPath(projectRoot, candidatePath);
+}
 var init_contains_path = () => {};
 
 // node_modules/jsonc-parser/lib/esm/impl/scanner.js
@@ -5782,8 +5818,8 @@ var init_main = __esm(() => {
 });
 
 // src/shared/jsonc-parser.ts
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { join as join2 } from "path";
 function stripBom(content) {
   return content.charCodeAt(0) === 65279 ? content.slice(1) : content;
 }
@@ -5803,17 +5839,17 @@ function parseJsonc(content) {
 function detectConfigFile(basePath) {
   const jsoncPath = `${basePath}.jsonc`;
   const jsonPath = `${basePath}.json`;
-  if (existsSync(jsoncPath)) {
+  if (existsSync2(jsoncPath)) {
     return { format: "jsonc", path: jsoncPath };
   }
-  if (existsSync(jsonPath)) {
+  if (existsSync2(jsonPath)) {
     return { format: "json", path: jsonPath };
   }
   return { format: "none", path: jsonPath };
 }
 function detectPluginConfigFile(dir) {
-  const canonicalResult = detectConfigFile(join(dir, CONFIG_BASENAME));
-  const legacyResult = detectConfigFile(join(dir, LEGACY_CONFIG_BASENAME));
+  const canonicalResult = detectConfigFile(join2(dir, CONFIG_BASENAME));
+  const legacyResult = detectConfigFile(join2(dir, LEGACY_CONFIG_BASENAME));
   if (canonicalResult.format !== "none") {
     return {
       ...canonicalResult,
@@ -5823,7 +5859,7 @@ function detectPluginConfigFile(dir) {
   if (legacyResult.format !== "none") {
     return legacyResult;
   }
-  return { format: "none", path: join(dir, `${CONFIG_BASENAME}.json`) };
+  return { format: "none", path: join2(dir, `${CONFIG_BASENAME}.json`) };
 }
 var init_jsonc_parser = __esm(() => {
   init_main();
@@ -5932,13 +5968,13 @@ var init_pattern_matcher = __esm(() => {
   regexCache = new Map;
 });
 // src/shared/file-utils.ts
-import { lstatSync, realpathSync } from "fs";
+import { lstatSync, realpathSync as realpathSync2 } from "fs";
 function normalizeDarwinRealpath(filePath) {
   return filePath.startsWith("/private/var/") ? filePath.slice("/private".length) : filePath;
 }
 function resolveSymlink(filePath) {
   try {
-    return normalizeDarwinRealpath(realpathSync(filePath));
+    return normalizeDarwinRealpath(realpathSync2(filePath));
   } catch {
     return filePath;
   }
@@ -5950,7 +5986,7 @@ var init_context_limit_resolver = () => {};
 
 // src/shared/normalize-sdk-response.ts
 function normalizeSDKResponse(response, fallback, options) {
-  if (response === null || response === undefined) {
+  if (response == null) {
     return fallback;
   }
   if (Array.isArray(response)) {
@@ -5958,7 +5994,7 @@ function normalizeSDKResponse(response, fallback, options) {
   }
   if (typeof response === "object" && "data" in response) {
     const data = response.data;
-    if (data !== null && data !== undefined) {
+    if (data != null) {
       return data;
     }
     if (options?.preferResponseOnMissingData === true) {
@@ -6050,20 +6086,26 @@ var init_agent_names = __esm(() => {
     omo: "sisyphus",
     OmO: "sisyphus",
     Sisyphus: "sisyphus",
+    "Sisyphus (Ultraworker)": "sisyphus",
     sisyphus: "sisyphus",
+    "Hephaestus (Deep Agent)": "hephaestus",
     "OmO-Plan": "prometheus",
     "omo-plan": "prometheus",
     "Planner-Sisyphus": "prometheus",
     "planner-sisyphus": "prometheus",
     "Prometheus - Plan Builder": "prometheus",
+    "Prometheus (Plan Builder)": "prometheus",
     prometheus: "prometheus",
     "orchestrator-sisyphus": "atlas",
     Atlas: "atlas",
+    "Atlas (Plan Executor)": "atlas",
     atlas: "atlas",
     "plan-consultant": "metis",
     "Metis - Plan Consultant": "metis",
+    "Metis (Plan Consultant)": "metis",
     metis: "metis",
     "Momus - Plan Critic": "momus",
+    "Momus (Plan Critic)": "momus",
     momus: "momus",
     "Sisyphus-Junior": "sisyphus-junior",
     "sisyphus-junior": "sisyphus-junior",
@@ -6161,7 +6203,7 @@ var init_model_versions = __esm(() => {
 var init_agent_category = () => {};
 
 // src/shared/write-file-atomically.ts
-import { closeSync, fsyncSync, openSync, renameSync, writeFileSync } from "fs";
+import { closeSync, fsyncSync, openSync, renameSync, unlinkSync, writeFileSync } from "fs";
 function writeFileAtomically(filePath, content) {
   const tempPath = `${filePath}.tmp`;
   writeFileSync(tempPath, content, "utf-8");
@@ -6171,7 +6213,18 @@ function writeFileAtomically(filePath, content) {
   } finally {
     closeSync(tempFileDescriptor);
   }
-  renameSync(tempPath, filePath);
+  try {
+    renameSync(tempPath, filePath);
+  } catch (error) {
+    const isWindows = process.platform === "win32";
+    const isPermissionError = error instanceof Error && (error.message.includes("EPERM") || error.message.includes("EACCES"));
+    if (isWindows && isPermissionError) {
+      unlinkSync(filePath);
+      renameSync(tempPath, filePath);
+    } else {
+      throw error;
+    }
+  }
 }
 var init_write_file_atomically = () => {};
 
@@ -6319,20 +6372,28 @@ function migrateConfigFile(configPath, rawConfig) {
     }
   }
   if (needsWrite) {
+    let finalConfig = JSON.parse(JSON.stringify(copy));
+    const newContent = JSON.stringify(finalConfig, null, 2) + `
+`;
+    let existingContent;
+    try {
+      existingContent = fs3.readFileSync(configPath, "utf-8");
+    } catch {}
+    const contentChanged = existingContent !== newContent;
     const timestamp2 = new Date().toISOString().replace(/[:.]/g, "-");
     const backupPath = `${configPath}.bak.${timestamp2}`;
     let backupSucceeded = false;
-    try {
-      fs3.copyFileSync(configPath, backupPath);
-      backupSucceeded = true;
-    } catch {
-      backupSucceeded = false;
+    if (contentChanged) {
+      try {
+        fs3.copyFileSync(configPath, backupPath);
+        backupSucceeded = true;
+      } catch {
+        backupSucceeded = false;
+      }
     }
     let writeSucceeded = false;
-    let finalConfig = JSON.parse(JSON.stringify(copy));
     try {
-      writeFileAtomically(configPath, JSON.stringify(finalConfig, null, 2) + `
-`);
+      writeFileAtomically(configPath, newContent);
       writeSucceeded = true;
     } catch (err) {
       log(`Failed to write migrated config to ${configPath}:`, err);
@@ -6384,9 +6445,9 @@ var init_migration = __esm(() => {
 });
 
 // src/shared/opencode-config-dir.ts
-import { existsSync as existsSync3, realpathSync as realpathSync2 } from "fs";
+import { existsSync as existsSync4, realpathSync as realpathSync3 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join4, resolve, win32 } from "path";
+import { join as join5, resolve as resolve2, win32 } from "path";
 function isDevBuild(version) {
   if (!version)
     return false;
@@ -6396,24 +6457,24 @@ function getTauriConfigDir(identifier) {
   const platform = process.platform;
   switch (platform) {
     case "darwin":
-      return join4(homedir2(), "Library", "Application Support", identifier);
+      return join5(homedir2(), "Library", "Application Support", identifier);
     case "win32": {
-      const appData = process.env.APPDATA || join4(homedir2(), "AppData", "Roaming");
+      const appData = process.env.APPDATA || join5(homedir2(), "AppData", "Roaming");
       return win32.join(appData, identifier);
     }
     case "linux":
     default: {
-      const xdgConfig = process.env.XDG_CONFIG_HOME || join4(homedir2(), ".config");
-      return join4(xdgConfig, identifier);
+      const xdgConfig = process.env.XDG_CONFIG_HOME || join5(homedir2(), ".config");
+      return join5(xdgConfig, identifier);
     }
   }
 }
 function resolveConfigPath(pathValue) {
-  const resolvedPath = resolve(pathValue);
-  if (!existsSync3(resolvedPath))
+  const resolvedPath = resolve2(pathValue);
+  if (!existsSync4(resolvedPath))
     return resolvedPath;
   try {
-    return realpathSync2(resolvedPath);
+    return realpathSync3(resolvedPath);
   } catch {
     return resolvedPath;
   }
@@ -6423,8 +6484,8 @@ function getCliConfigDir() {
   if (envConfigDir) {
     return resolveConfigPath(envConfigDir);
   }
-  const xdgConfig = process.env.XDG_CONFIG_HOME || join4(homedir2(), ".config");
-  return resolveConfigPath(join4(xdgConfig, "opencode"));
+  const xdgConfig = process.env.XDG_CONFIG_HOME || join5(homedir2(), ".config");
+  return resolveConfigPath(join5(xdgConfig, "opencode"));
 }
 function getOpenCodeConfigDir(options) {
   const { binary: binary2, version, checkExisting = true } = options;
@@ -6436,9 +6497,9 @@ function getOpenCodeConfigDir(options) {
   const tauriDir = process.platform === "win32" ? win32.isAbsolute(tauriDirBase) ? win32.normalize(tauriDirBase) : win32.resolve(tauriDirBase) : resolveConfigPath(tauriDirBase);
   if (checkExisting) {
     const legacyDir = getCliConfigDir();
-    const legacyConfig = join4(legacyDir, "opencode.json");
-    const legacyConfigC = join4(legacyDir, "opencode.jsonc");
-    if (existsSync3(legacyConfig) || existsSync3(legacyConfigC)) {
+    const legacyConfig = join5(legacyDir, "opencode.json");
+    const legacyConfigC = join5(legacyDir, "opencode.jsonc");
+    if (existsSync4(legacyConfig) || existsSync4(legacyConfigC)) {
       return legacyDir;
     }
   }
@@ -6448,10 +6509,10 @@ function getOpenCodeConfigPaths(options) {
   const configDir = getOpenCodeConfigDir(options);
   return {
     configDir,
-    configJson: join4(configDir, "opencode.json"),
-    configJsonc: join4(configDir, "opencode.jsonc"),
-    packageJson: join4(configDir, "package.json"),
-    omoConfig: join4(configDir, `${CONFIG_BASENAME}.json`)
+    configJson: join5(configDir, "opencode.json"),
+    configJsonc: join5(configDir, "opencode.jsonc"),
+    packageJson: join5(configDir, "package.json"),
+    omoConfig: join5(configDir, `${CONFIG_BASENAME}.json`)
   };
 }
 var TAURI_APP_IDENTIFIER = "ai.opencode.desktop", TAURI_APP_IDENTIFIER_DEV = "ai.opencode.desktop.dev";
@@ -6459,6 +6520,25 @@ var init_opencode_config_dir = __esm(() => {
   init_plugin_identity();
 });
 
+// src/shared/resolve-agent-definition-paths.ts
+import { homedir as homedir3 } from "os";
+import { isAbsolute as isAbsolute2, resolve as resolve3 } from "path";
+function resolveAgentDefinitionPaths(paths, baseDir, containmentDir) {
+  return paths.flatMap((p) => {
+    const expanded = p.startsWith("~/") ? p.replace(/^~\//, `${homedir3()}/`) : p;
+    const resolved = isAbsolute2(expanded) ? expanded : resolve3(baseDir, expanded);
+    if (containmentDir !== null && !isWithinProject(resolved, containmentDir)) {
+      log(`agent_definitions path rejected (outside project boundary): ${p} -> ${resolved}`);
+      return [];
+    }
+    return [resolved];
+  });
+}
+var init_resolve_agent_definition_paths = __esm(() => {
+  init_contains_path();
+  init_logger();
+});
+
 // src/shared/opencode-version.ts
 import { execSync } from "child_process";
 function parseVersion(version) {
@@ -6510,8 +6590,8 @@ var init_opencode_version = __esm(() => {
 });
 
 // src/shared/opencode-storage-detection.ts
-import { existsSync as existsSync4 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { join as join6 } from "path";
 function isSqliteBackend() {
   if (cachedResult === true)
     return true;
@@ -6519,8 +6599,8 @@ function isSqliteBackend() {
     return false;
   const check = () => {
     const versionOk = isOpenCodeVersionAtLeast(OPENCODE_SQLITE_VERSION);
-    const dbPath = join5(getDataDir(), "opencode", "opencode.db");
-    return versionOk && existsSync4(dbPath);
+    const dbPath = join6(getDataDir(), "opencode", "opencode.db");
+    return versionOk && existsSync5(dbPath);
   };
   if (cachedResult === FALSE_PENDING_RETRY) {
     const result2 = check();
@@ -6587,11 +6667,94 @@ var init_zip_extractor = __esm(() => {
 });
 
 // src/shared/binary-downloader.ts
+import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync3, unlinkSync as unlinkSync2 } from "fs";
+import * as path4 from "path";
+function getCachedBinaryPath(cacheDir, binaryName) {
+  const binaryPath = path4.join(cacheDir, binaryName);
+  return existsSync6(binaryPath) ? binaryPath : null;
+}
 var init_binary_downloader = __esm(() => {
   init_archive_entry_validator();
   init_zip_extractor();
 });
 
+// src/shared/agent-display-names.ts
+function stripInvisibleAgentCharacters(agentName) {
+  return agentName.replace(INVISIBLE_AGENT_CHARACTERS_REGEX, "");
+}
+function stripAgentListSortPrefix(agentName) {
+  return stripInvisibleAgentCharacters(agentName);
+}
+function getAgentRuntimeName(configKey) {
+  const displayName = getAgentDisplayName(configKey);
+  const prefix = AGENT_LIST_SORT_PREFIXES[configKey.toLowerCase()];
+  return prefix ? `${prefix}${displayName}` : displayName;
+}
+function getAgentDisplayName(configKey) {
+  const exactMatch = AGENT_DISPLAY_NAMES[configKey];
+  if (exactMatch !== undefined)
+    return exactMatch;
+  const lowerKey = configKey.toLowerCase();
+  for (const [k, v] of Object.entries(AGENT_DISPLAY_NAMES)) {
+    if (k.toLowerCase() === lowerKey)
+      return v;
+  }
+  return configKey;
+}
+function resolveKnownAgentConfigKey(agentName) {
+  const lower = stripAgentListSortPrefix(agentName).trim().toLowerCase();
+  const reversed = REVERSE_DISPLAY_NAMES[lower];
+  if (reversed !== undefined)
+    return reversed;
+  const legacy = LEGACY_DISPLAY_NAMES[lower];
+  if (legacy !== undefined)
+    return legacy;
+  if (AGENT_DISPLAY_NAMES[lower] !== undefined)
+    return lower;
+  return;
+}
+function getAgentConfigKey(agentName) {
+  const lower = stripAgentListSortPrefix(agentName).trim().toLowerCase();
+  return resolveKnownAgentConfigKey(agentName) ?? lower;
+}
+var AGENT_DISPLAY_NAMES, AGENT_LIST_SORT_PREFIXES, INVISIBLE_AGENT_CHARACTERS_REGEX, REVERSE_DISPLAY_NAMES, LEGACY_DISPLAY_NAMES;
+var init_agent_display_names = __esm(() => {
+  AGENT_DISPLAY_NAMES = {
+    sisyphus: "Sisyphus - Ultraworker",
+    hephaestus: "Hephaestus - Deep Agent",
+    prometheus: "Prometheus - Plan Builder",
+    atlas: "Atlas - Plan Executor",
+    "sisyphus-junior": "Sisyphus-Junior",
+    metis: "Metis - Plan Consultant",
+    momus: "Momus - Plan Critic",
+    athena: "Athena - Council",
+    "athena-junior": "Athena-Junior - Council",
+    oracle: "oracle",
+    librarian: "librarian",
+    explore: "explore",
+    "multimodal-looker": "multimodal-looker",
+    "council-member": "council-member"
+  };
+  AGENT_LIST_SORT_PREFIXES = {
+    sisyphus: "\u200B",
+    hephaestus: "\u200B\u200B",
+    prometheus: "\u200B\u200B\u200B",
+    atlas: "\u200B\u200B\u200B\u200B"
+  };
+  INVISIBLE_AGENT_CHARACTERS_REGEX = /[\u200B\u200C\u200D\uFEFF]/g;
+  REVERSE_DISPLAY_NAMES = Object.fromEntries(Object.entries(AGENT_DISPLAY_NAMES).map(([key, displayName]) => [displayName.toLowerCase(), key]));
+  LEGACY_DISPLAY_NAMES = {
+    "sisyphus (ultraworker)": "sisyphus",
+    "hephaestus (deep agent)": "hephaestus",
+    "prometheus (plan builder)": "prometheus",
+    "atlas (plan executor)": "atlas",
+    "metis (plan consultant)": "metis",
+    "momus (plan critic)": "momus",
+    "athena (council)": "athena",
+    "athena-junior (council)": "athena-junior"
+  };
+});
+
 // src/shared/model-requirements.ts
 var AGENT_MODEL_REQUIREMENTS, CATEGORY_MODEL_REQUIREMENTS;
 var init_model_requirements = __esm(() => {
@@ -6599,11 +6762,11 @@ var init_model_requirements = __esm(() => {
     sisyphus: {
       fallbackChain: [
         {
-          providers: ["anthropic", "github-copilot", "opencode"],
+          providers: ["anthropic", "github-copilot", "opencode", "vercel"],
           model: "claude-opus-4-6",
           variant: "max"
         },
-        { providers: ["opencode-go"], model: "kimi-k2.5" },
+        { providers: ["opencode-go", "vercel"], model: "kimi-k2.5" },
         { providers: ["kimi-for-coding"], model: "k2p5" },
         {
           providers: [
@@ -6612,12 +6775,13 @@ var init_model_requirements = __esm(() => {
             "moonshotai-cn",
             "firmware",
             "ollama-cloud",
-            "aihubmix"
+            "aihubmix",
+            "vercel"
           ],
           model: "kimi-k2.5"
         },
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.4", variant: "medium" },
-        { providers: ["zai-coding-plan", "opencode"], model: "glm-5" },
+        { providers: ["openai", "github-copilot", "opencode", "vercel"], model: "gpt-5.4", variant: "medium" },
+        { providers: ["zai-coding-plan", "opencode", "vercel"], model: "glm-5" },
         { providers: ["opencode"], model: "big-pickle" }
       ],
       requiresAnyModel: true
@@ -6625,73 +6789,73 @@ var init_model_requirements = __esm(() => {
     hephaestus: {
       fallbackChain: [
         {
-          providers: ["openai", "github-copilot", "venice", "opencode"],
+          providers: ["openai", "github-copilot", "venice", "opencode", "vercel"],
           model: "gpt-5.4",
           variant: "medium"
         }
       ],
-      requiresProvider: ["openai", "github-copilot", "venice", "opencode"]
+      requiresProvider: ["openai", "github-copilot", "venice", "opencode", "vercel"]
     },
     oracle: {
       fallbackChain: [
         {
-          providers: ["openai", "github-copilot", "opencode"],
+          providers: ["openai", "github-copilot", "opencode", "vercel"],
           model: "gpt-5.4",
           variant: "high"
         },
         {
-          providers: ["google", "github-copilot", "opencode"],
+          providers: ["google", "github-copilot", "opencode", "vercel"],
           model: "gemini-3.1-pro",
           variant: "high"
         },
         {
-          providers: ["anthropic", "github-copilot", "opencode"],
+          providers: ["anthropic", "github-copilot", "opencode", "vercel"],
           model: "claude-opus-4-6",
           variant: "max"
         },
-        { providers: ["opencode-go"], model: "glm-5" }
+        { providers: ["opencode-go", "vercel"], model: "glm-5" }
       ]
     },
     librarian: {
       fallbackChain: [
-        { providers: ["opencode-go"], model: "minimax-m2.7" },
-        { providers: ["opencode"], model: "minimax-m2.7-highspeed" },
-        { providers: ["anthropic", "opencode"], model: "claude-haiku-4-5" },
-        { providers: ["opencode"], model: "gpt-5-nano" }
+        { providers: ["opencode-go", "vercel"], model: "minimax-m2.7" },
+        { providers: ["opencode", "vercel"], model: "minimax-m2.7-highspeed" },
+        { providers: ["anthropic", "opencode", "vercel"], model: "claude-haiku-4-5" },
+        { providers: ["opencode", "vercel"], model: "gpt-5-nano" }
       ]
     },
     explore: {
       fallbackChain: [
-        { providers: ["github-copilot", "xai"], model: "grok-code-fast-1" },
-        { providers: ["opencode-go"], model: "minimax-m2.7-highspeed" },
-        { providers: ["opencode"], model: "minimax-m2.7" },
-        { providers: ["anthropic", "opencode"], model: "claude-haiku-4-5" },
-        { providers: ["opencode"], model: "gpt-5-nano" }
+        { providers: ["github-copilot", "xai", "vercel"], model: "grok-code-fast-1" },
+        { providers: ["opencode-go", "vercel"], model: "minimax-m2.7-highspeed" },
+        { providers: ["opencode", "vercel"], model: "minimax-m2.7" },
+        { providers: ["anthropic", "opencode", "vercel"], model: "claude-haiku-4-5" },
+        { providers: ["opencode", "vercel"], model: "gpt-5-nano" }
       ]
     },
     "multimodal-looker": {
       fallbackChain: [
-        { providers: ["openai", "opencode"], model: "gpt-5.4", variant: "medium" },
-        { providers: ["opencode-go"], model: "kimi-k2.5" },
-        { providers: ["zai-coding-plan"], model: "glm-4.6v" },
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5-nano" }
+        { providers: ["openai", "opencode", "vercel"], model: "gpt-5.4", variant: "medium" },
+        { providers: ["opencode-go", "vercel"], model: "kimi-k2.5" },
+        { providers: ["zai-coding-plan", "vercel"], model: "glm-4.6v" },
+        { providers: ["openai", "github-copilot", "opencode", "vercel"], model: "gpt-5-nano" }
       ]
     },
     prometheus: {
       fallbackChain: [
         {
-          providers: ["anthropic", "github-copilot", "opencode"],
+          providers: ["anthropic", "github-copilot", "opencode", "vercel"],
           model: "claude-opus-4-6",
           variant: "max"
         },
         {
-          providers: ["openai", "github-copilot", "opencode"],
+          providers: ["openai", "github-copilot", "opencode", "vercel"],
           model: "gpt-5.4",
           variant: "high"
         },
-        { providers: ["opencode-go"], model: "glm-5" },
+        { providers: ["opencode-go", "vercel"], model: "glm-5" },
         {
-          providers: ["google", "github-copilot", "opencode"],
+          providers: ["google", "github-copilot", "opencode", "vercel"],
           model: "gemini-3.1-pro"
         }
       ]
@@ -6699,61 +6863,61 @@ var init_model_requirements = __esm(() => {
     metis: {
       fallbackChain: [
         {
-          providers: ["anthropic", "github-copilot", "opencode"],
+          providers: ["anthropic", "github-copilot", "opencode", "vercel"],
           model: "claude-opus-4-6",
           variant: "max"
         },
         {
-          providers: ["openai", "github-copilot", "opencode"],
+          providers: ["openai", "github-copilot", "opencode", "vercel"],
           model: "gpt-5.4",
           variant: "high"
         },
-        { providers: ["opencode-go"], model: "glm-5" },
+        { providers: ["opencode-go", "vercel"], model: "glm-5" },
         { providers: ["kimi-for-coding"], model: "k2p5" }
       ]
     },
     momus: {
       fallbackChain: [
         {
-          providers: ["openai", "github-copilot", "opencode"],
+          providers: ["openai", "github-copilot", "opencode", "vercel"],
           model: "gpt-5.4",
           variant: "xhigh"
         },
         {
-          providers: ["anthropic", "github-copilot", "opencode"],
+          providers: ["anthropic", "github-copilot", "opencode", "vercel"],
           model: "claude-opus-4-6",
           variant: "max"
         },
         {
-          providers: ["google", "github-copilot", "opencode"],
+          providers: ["google", "github-copilot", "opencode", "vercel"],
           model: "gemini-3.1-pro",
           variant: "high"
         },
-        { providers: ["opencode-go"], model: "glm-5" }
+        { providers: ["opencode-go", "vercel"], model: "glm-5" }
       ]
     },
     atlas: {
       fallbackChain: [
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-sonnet-4-6" },
-        { providers: ["opencode-go"], model: "kimi-k2.5" },
+        { providers: ["anthropic", "github-copilot", "opencode", "vercel"], model: "claude-sonnet-4-6" },
+        { providers: ["opencode-go", "vercel"], model: "kimi-k2.5" },
         {
-          providers: ["openai", "github-copilot", "opencode"],
+          providers: ["openai", "github-copilot", "opencode", "vercel"],
           model: "gpt-5.4",
           variant: "medium"
         },
-        { providers: ["opencode-go"], model: "minimax-m2.7" }
+        { providers: ["opencode-go", "vercel"], model: "minimax-m2.7" }
       ]
     },
     "sisyphus-junior": {
       fallbackChain: [
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-sonnet-4-6" },
-        { providers: ["opencode-go"], model: "kimi-k2.5" },
+        { providers: ["anthropic", "github-copilot", "opencode", "vercel"], model: "claude-sonnet-4-6" },
+        { providers: ["opencode-go", "vercel"], model: "kimi-k2.5" },
         {
-          providers: ["openai", "github-copilot", "opencode"],
+          providers: ["openai", "github-copilot", "opencode", "vercel"],
           model: "gpt-5.4",
           variant: "medium"
         },
-        { providers: ["opencode-go"], model: "minimax-m2.7" },
+        { providers: ["opencode-go", "vercel"], model: "minimax-m2.7" },
         { providers: ["opencode"], model: "big-pickle" }
       ]
     }
@@ -6762,54 +6926,54 @@ var init_model_requirements = __esm(() => {
     "visual-engineering": {
       fallbackChain: [
         {
-          providers: ["google", "github-copilot", "opencode"],
+          providers: ["google", "github-copilot", "opencode", "vercel"],
           model: "gemini-3.1-pro",
           variant: "high"
         },
-        { providers: ["zai-coding-plan", "opencode"], model: "glm-5" },
+        { providers: ["zai-coding-plan", "opencode", "vercel"], model: "glm-5" },
         {
-          providers: ["anthropic", "github-copilot", "opencode"],
+          providers: ["anthropic", "github-copilot", "opencode", "vercel"],
           model: "claude-opus-4-6",
           variant: "max"
         },
-        { providers: ["opencode-go"], model: "glm-5" },
+        { providers: ["opencode-go", "vercel"], model: "glm-5" },
         { providers: ["kimi-for-coding"], model: "k2p5" }
       ]
     },
     ultrabrain: {
       fallbackChain: [
         {
-          providers: ["openai", "opencode"],
+          providers: ["openai", "opencode", "vercel"],
           model: "gpt-5.4",
           variant: "xhigh"
         },
         {
-          providers: ["google", "github-copilot", "opencode"],
+          providers: ["google", "github-copilot", "opencode", "vercel"],
           model: "gemini-3.1-pro",
           variant: "high"
         },
         {
-          providers: ["anthropic", "github-copilot", "opencode"],
+          providers: ["anthropic", "github-copilot", "opencode", "vercel"],
           model: "claude-opus-4-6",
           variant: "max"
         },
-        { providers: ["opencode-go"], model: "glm-5" }
+        { providers: ["opencode-go", "vercel"], model: "glm-5" }
       ]
     },
     deep: {
       fallbackChain: [
         {
-          providers: ["openai", "github-copilot", "venice", "opencode"],
+          providers: ["openai", "github-copilot", "venice", "opencode", "vercel"],
           model: "gpt-5.4",
           variant: "medium"
         },
         {
-          providers: ["anthropic", "github-copilot", "opencode"],
+          providers: ["anthropic", "github-copilot", "opencode", "vercel"],
           model: "claude-opus-4-6",
           variant: "max"
         },
         {
-          providers: ["google", "github-copilot", "opencode"],
+          providers: ["google", "github-copilot", "opencode", "vercel"],
           model: "gemini-3.1-pro",
           variant: "high"
         }
@@ -6818,72 +6982,72 @@ var init_model_requirements = __esm(() => {
     artistry: {
       fallbackChain: [
         {
-          providers: ["google", "github-copilot", "opencode"],
+          providers: ["google", "github-copilot", "opencode", "vercel"],
           model: "gemini-3.1-pro",
           variant: "high"
         },
         {
-          providers: ["anthropic", "github-copilot", "opencode"],
+          providers: ["anthropic", "github-copilot", "opencode", "vercel"],
           model: "claude-opus-4-6",
           variant: "max"
         },
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.4" }
+        { providers: ["openai", "github-copilot", "opencode", "vercel"], model: "gpt-5.4" }
       ],
       requiresModel: "gemini-3.1-pro"
     },
     quick: {
       fallbackChain: [
         {
-          providers: ["openai", "github-copilot", "opencode"],
+          providers: ["openai", "github-copilot", "opencode", "vercel"],
           model: "gpt-5.4-mini"
         },
         {
-          providers: ["anthropic", "github-copilot", "opencode"],
+          providers: ["anthropic", "github-copilot", "opencode", "vercel"],
           model: "claude-haiku-4-5"
         },
         {
-          providers: ["google", "github-copilot", "opencode"],
+          providers: ["google", "github-copilot", "opencode", "vercel"],
           model: "gemini-3-flash"
         },
-        { providers: ["opencode-go"], model: "minimax-m2.7" },
-        { providers: ["opencode"], model: "gpt-5-nano" }
+        { providers: ["opencode-go", "vercel"], model: "minimax-m2.7" },
+        { providers: ["opencode", "vercel"], model: "gpt-5-nano" }
       ]
     },
     "unspecified-low": {
       fallbackChain: [
         {
-          providers: ["anthropic", "github-copilot", "opencode"],
+          providers: ["anthropic", "github-copilot", "opencode", "vercel"],
           model: "claude-sonnet-4-6"
         },
         {
-          providers: ["openai", "opencode"],
+          providers: ["openai", "opencode", "vercel"],
           model: "gpt-5.3-codex",
           variant: "medium"
         },
-        { providers: ["opencode-go"], model: "kimi-k2.5" },
+        { providers: ["opencode-go", "vercel"], model: "kimi-k2.5" },
         {
-          providers: ["google", "github-copilot", "opencode"],
+          providers: ["google", "github-copilot", "opencode", "vercel"],
           model: "gemini-3-flash"
         },
-        { providers: ["opencode-go"], model: "minimax-m2.7" }
+        { providers: ["opencode-go", "vercel"], model: "minimax-m2.7" }
       ]
     },
     "unspecified-high": {
       fallbackChain: [
         {
-          providers: ["anthropic", "github-copilot", "opencode"],
+          providers: ["anthropic", "github-copilot", "opencode", "vercel"],
           model: "claude-opus-4-6",
           variant: "max"
         },
         {
-          providers: ["openai", "github-copilot", "opencode"],
+          providers: ["openai", "github-copilot", "opencode", "vercel"],
           model: "gpt-5.4",
           variant: "high"
         },
-        { providers: ["zai-coding-plan", "opencode"], model: "glm-5" },
+        { providers: ["zai-coding-plan", "opencode", "vercel"], model: "glm-5" },
         { providers: ["kimi-for-coding"], model: "k2p5" },
-        { providers: ["opencode-go"], model: "glm-5" },
-        { providers: ["opencode"], model: "kimi-k2.5" },
+        { providers: ["opencode-go", "vercel"], model: "glm-5" },
+        { providers: ["opencode", "vercel"], model: "kimi-k2.5" },
         {
           providers: [
             "opencode",
@@ -6891,7 +7055,8 @@ var init_model_requirements = __esm(() => {
             "moonshotai-cn",
             "firmware",
             "ollama-cloud",
-            "aihubmix"
+            "aihubmix",
+            "vercel"
           ],
           model: "kimi-k2.5"
         }
@@ -6900,15 +7065,15 @@ var init_model_requirements = __esm(() => {
     writing: {
       fallbackChain: [
         {
-          providers: ["google", "github-copilot", "opencode"],
+          providers: ["google", "github-copilot", "opencode", "vercel"],
           model: "gemini-3-flash"
         },
-        { providers: ["opencode-go"], model: "kimi-k2.5" },
+        { providers: ["opencode-go", "vercel"], model: "kimi-k2.5" },
         {
-          providers: ["anthropic", "github-copilot", "opencode"],
+          providers: ["anthropic", "github-copilot", "opencode", "vercel"],
           model: "claude-sonnet-4-6"
         },
-        { providers: ["opencode-go"], model: "minimax-m2.7" }
+        { providers: ["opencode-go", "vercel"], model: "minimax-m2.7" }
       ]
     }
   };
@@ -6916,6 +7081,7 @@ var init_model_requirements = __esm(() => {
 
 // src/shared/agent-variant.ts
 var init_agent_variant = __esm(() => {
+  init_agent_display_names();
   init_model_requirements();
 });
 
@@ -6934,6 +7100,9 @@ function detectShellType() {
     }
     return "unix";
   }
+  if (process.env.MSYSTEM) {
+    return "unix";
+  }
   if (process.env.PSModulePath) {
     return "powershell";
   }
@@ -6944,7 +7113,9 @@ function detectShellType() {
 var init_system_directive = () => {};
 
 // src/shared/agent-tool-restrictions.ts
-var init_agent_tool_restrictions = () => {};
+var init_agent_tool_restrictions = __esm(() => {
+  init_agent_display_names();
+});
 
 // src/shared/model-normalization.ts
 function normalizeModelID(modelID) {
@@ -6952,20 +7123,20 @@ function normalizeModelID(modelID) {
 }
 
 // src/shared/json-file-cache-store.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { join as join8 } from "path";
 function toLogLabel(cacheLabel) {
   return cacheLabel.toLowerCase();
 }
 function createJsonFileCacheStore(options) {
   let memoryValue;
   function getCacheFilePath() {
-    return join6(options.getCacheDir(), options.filename);
+    return join8(options.getCacheDir(), options.filename);
   }
   function ensureCacheDir() {
     const cacheDir = options.getCacheDir();
-    if (!existsSync5(cacheDir)) {
-      mkdirSync3(cacheDir, { recursive: true });
+    if (!existsSync7(cacheDir)) {
+      mkdirSync4(cacheDir, { recursive: true });
     }
   }
   function read() {
@@ -6973,13 +7144,13 @@ function createJsonFileCacheStore(options) {
       return memoryValue;
     }
     const cacheFile = getCacheFilePath();
-    if (!existsSync5(cacheFile)) {
+    if (!existsSync7(cacheFile)) {
       memoryValue = null;
       log(`[${options.logPrefix}] ${options.cacheLabel} file not found`, { cacheFile });
       return null;
     }
     try {
-      const content = readFileSync3(cacheFile, "utf-8");
+      const content = readFileSync4(cacheFile, "utf-8");
       const value = JSON.parse(content);
       memoryValue = value;
       log(`[${options.logPrefix}] Read ${toLogLabel(options.cacheLabel)}`, options.describe(value));
@@ -6993,7 +7164,7 @@ function createJsonFileCacheStore(options) {
     }
   }
   function has() {
-    return existsSync5(getCacheFilePath());
+    return existsSync7(getCacheFilePath());
   }
   function write(value) {
     ensureCacheDir();
@@ -7162,14 +7333,14 @@ var init_connected_providers_cache = __esm(() => {
 });
 
 // src/shared/model-availability.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
+import { join as join9 } from "path";
 function isModelCacheAvailable() {
   if (hasProviderModelsCache()) {
     return true;
   }
-  const cacheFile = join7(getOpenCodeCacheDir(), "models.json");
-  return existsSync6(cacheFile);
+  const cacheFile = join9(getOpenCodeCacheDir(), "models.json");
+  return existsSync8(cacheFile);
 }
 var init_model_availability = __esm(() => {
   init_logger();
@@ -7178,21 +7349,14 @@ var init_model_availability = __esm(() => {
 });
 
 // src/shared/provider-model-id-transform.ts
-function transformModelForProvider(provider, model) {
-  if (provider === "github-copilot") {
-    return model.replace("claude-opus-4-6", "claude-opus-4.6").replace("claude-sonnet-4-6", "claude-sonnet-4.6").replace("claude-sonnet-4-5", "claude-sonnet-4.5").replace("claude-haiku-4-5", "claude-haiku-4.5").replace("claude-sonnet-4", "claude-sonnet-4").replace(/gemini-3\.1-pro(?!-)/g, "gemini-3.1-pro-preview").replace(/gemini-3-flash(?!-)/g, "gemini-3-flash-preview");
-  }
-  if (provider === "google") {
-    return model.replace(/gemini-3\.1-pro(?!-)/g, "gemini-3.1-pro-preview").replace(/gemini-3-flash(?!-)/g, "gemini-3-flash-preview");
-  }
-  return model;
-}
+var init_provider_model_id_transform = () => {};
 
 // src/shared/model-resolution-pipeline.ts
 var init_model_resolution_pipeline = __esm(() => {
   init_logger();
   init_connected_providers_cache();
   init_model_availability();
+  init_provider_model_id_transform();
 });
 
 // src/shared/known-variants.ts
@@ -48465,19 +48629,19 @@ var init_constants = __esm(() => {
 });
 
 // src/shared/opencode-storage-paths.ts
-import { join as join8 } from "path";
+import { join as join10 } from "path";
 var OPENCODE_STORAGE, MESSAGE_STORAGE, PART_STORAGE, SESSION_STORAGE;
 var init_opencode_storage_paths = __esm(() => {
   init_data_path();
   OPENCODE_STORAGE = getOpenCodeStorageDir();
-  MESSAGE_STORAGE = join8(OPENCODE_STORAGE, "message");
-  PART_STORAGE = join8(OPENCODE_STORAGE, "part");
-  SESSION_STORAGE = join8(OPENCODE_STORAGE, "session");
+  MESSAGE_STORAGE = join10(OPENCODE_STORAGE, "message");
+  PART_STORAGE = join10(OPENCODE_STORAGE, "part");
+  SESSION_STORAGE = join10(OPENCODE_STORAGE, "session");
 });
 
 // src/shared/compaction-marker.ts
-import { existsSync as existsSync7, readdirSync, readFileSync as readFileSync5 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync9, readdirSync, readFileSync as readFileSync6 } from "fs";
+import { join as join11 } from "path";
 function isCompactionPart(part) {
   return typeof part === "object" && part !== null && part.type === "compaction";
 }
@@ -48491,20 +48655,20 @@ function isCompactionMessage(message) {
   return isCompactionAgent(message.info?.agent ?? message.agent) || hasCompactionPart(message.parts);
 }
 function getCompactionPartStorageDir(messageID) {
-  return join9(PART_STORAGE, messageID);
+  return join11(PART_STORAGE, messageID);
 }
 function hasCompactionPartInStorage(messageID) {
   if (!messageID) {
     return false;
   }
   const partDir = getCompactionPartStorageDir(messageID);
-  if (!existsSync7(partDir)) {
+  if (!existsSync9(partDir)) {
     return false;
   }
   try {
     return readdirSync(partDir).filter((fileName) => fileName.endsWith(".json")).some((fileName) => {
       try {
-        const content = readFileSync5(join9(partDir, fileName), "utf-8");
+        const content = readFileSync6(join11(partDir, fileName), "utf-8");
         return isCompactionPart(JSON.parse(content));
       } catch {
         return false;
@@ -48537,23 +48701,23 @@ var init_hook_message_injector = __esm(() => {
 });
 
 // src/shared/opencode-message-dir.ts
-import { existsSync as existsSync8, readdirSync as readdirSync2 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync2 } from "fs";
+import { join as join12 } from "path";
 function getMessageDir(sessionID) {
   if (!sessionID.startsWith("ses_"))
     return null;
   if (/[/\\]|\.\./.test(sessionID))
     return null;
-  if (!existsSync8(MESSAGE_STORAGE))
+  if (!existsSync10(MESSAGE_STORAGE))
     return null;
-  const directPath = join10(MESSAGE_STORAGE, sessionID);
-  if (existsSync8(directPath)) {
+  const directPath = join12(MESSAGE_STORAGE, sessionID);
+  if (existsSync10(directPath)) {
     return directPath;
   }
   try {
     for (const dir of readdirSync2(MESSAGE_STORAGE)) {
-      const sessionPath = join10(MESSAGE_STORAGE, dir, sessionID);
-      if (existsSync8(sessionPath)) {
+      const sessionPath = join12(MESSAGE_STORAGE, dir, sessionID);
+      if (existsSync10(sessionPath)) {
         return sessionPath;
       }
     }
@@ -48568,68 +48732,6 @@ var init_opencode_message_dir = __esm(() => {
   init_logger();
 });
 
-// src/shared/agent-display-names.ts
-function stripInvisibleAgentCharacters(agentName) {
-  return agentName.replace(INVISIBLE_AGENT_CHARACTERS_REGEX, "");
-}
-function stripAgentListSortPrefix(agentName) {
-  return stripInvisibleAgentCharacters(agentName);
-}
-function getAgentDisplayName(configKey) {
-  const exactMatch = AGENT_DISPLAY_NAMES[configKey];
-  if (exactMatch !== undefined)
-    return exactMatch;
-  const lowerKey = configKey.toLowerCase();
-  for (const [k, v] of Object.entries(AGENT_DISPLAY_NAMES)) {
-    if (k.toLowerCase() === lowerKey)
-      return v;
-  }
-  return configKey;
-}
-function getAgentConfigKey(agentName) {
-  const lower = stripAgentListSortPrefix(agentName).trim().toLowerCase();
-  const reversed = REVERSE_DISPLAY_NAMES[lower];
-  if (reversed !== undefined)
-    return reversed;
-  const legacy = LEGACY_DISPLAY_NAMES[lower];
-  if (legacy !== undefined)
-    return legacy;
-  if (AGENT_DISPLAY_NAMES[lower] !== undefined)
-    return lower;
-  return lower;
-}
-var AGENT_DISPLAY_NAMES, INVISIBLE_AGENT_CHARACTERS_REGEX, REVERSE_DISPLAY_NAMES, LEGACY_DISPLAY_NAMES;
-var init_agent_display_names = __esm(() => {
-  AGENT_DISPLAY_NAMES = {
-    sisyphus: "Sisyphus - Ultraworker",
-    hephaestus: "Hephaestus - Deep Agent",
-    prometheus: "Prometheus - Plan Builder",
-    atlas: "Atlas - Plan Executor",
-    "sisyphus-junior": "Sisyphus-Junior",
-    metis: "Metis - Plan Consultant",
-    momus: "Momus - Plan Critic",
-    athena: "Athena - Council",
-    "athena-junior": "Athena-Junior - Council",
-    oracle: "oracle",
-    librarian: "librarian",
-    explore: "explore",
-    "multimodal-looker": "multimodal-looker",
-    "council-member": "council-member"
-  };
-  INVISIBLE_AGENT_CHARACTERS_REGEX = /[\u200B\u200C\u200D\uFEFF]/g;
-  REVERSE_DISPLAY_NAMES = Object.fromEntries(Object.entries(AGENT_DISPLAY_NAMES).map(([key, displayName]) => [displayName.toLowerCase(), key]));
-  LEGACY_DISPLAY_NAMES = {
-    "sisyphus (ultraworker)": "sisyphus",
-    "hephaestus (deep agent)": "hephaestus",
-    "prometheus (plan builder)": "prometheus",
-    "atlas (plan executor)": "atlas",
-    "metis (plan consultant)": "metis",
-    "momus (plan critic)": "momus",
-    "athena (council)": "athena",
-    "athena-junior (council)": "athena-junior"
-  };
-});
-
 // src/shared/session-utils.ts
 var init_session_utils = __esm(() => {
   init_hook_message_injector();
@@ -48716,6 +48818,12 @@ var init_model_suggestion_retry = __esm(() => {
 var init_opencode_server_auth = __esm(() => {
   init_logger();
 });
+
+// src/shared/opencode-provider-auth.ts
+var init_opencode_provider_auth = __esm(() => {
+  init_data_path();
+  init_logger();
+});
 // src/shared/opencode-http-api.ts
 var init_opencode_http_api = __esm(() => {
   init_opencode_server_auth();
@@ -48966,6 +49074,7 @@ var init_shared = __esm(() => {
   init_jsonc_parser();
   init_migration();
   init_opencode_config_dir();
+  init_resolve_agent_definition_paths();
   init_opencode_version();
   init_opencode_storage_detection();
   init_external_plugin_detector();
@@ -48990,6 +49099,7 @@ var init_shared = __esm(() => {
   init_tmux();
   init_model_suggestion_retry();
   init_opencode_server_auth();
+  init_opencode_provider_auth();
   init_opencode_http_api();
   init_port_utils();
   init_git_worktree();
@@ -49084,18 +49194,18 @@ var init_plugin_name_with_version = __esm(() => {
 });
 
 // src/cli/config-manager/backup-config.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync9, mkdirSync as mkdirSync4 } from "fs";
-import { dirname as dirname2 } from "path";
+import { copyFileSync as copyFileSync2, existsSync as existsSync11, mkdirSync as mkdirSync5 } from "fs";
+import { dirname as dirname3 } from "path";
 function backupConfigFile(configPath) {
-  if (!existsSync9(configPath)) {
+  if (!existsSync11(configPath)) {
     return { success: true };
   }
   const timestamp2 = new Date().toISOString().replace(/[:.]/g, "-");
   const backupPath = `${configPath}.backup-${timestamp2}`;
   try {
-    const dir = dirname2(backupPath);
-    if (!existsSync9(dir)) {
-      mkdirSync4(dir, { recursive: true });
+    const dir = dirname3(backupPath);
+    if (!existsSync11(dir)) {
+      mkdirSync5(dir, { recursive: true });
     }
     copyFileSync2(configPath, backupPath);
     return { success: true, backupPath };
@@ -49109,11 +49219,11 @@ function backupConfigFile(configPath) {
 var init_backup_config = () => {};
 
 // src/cli/config-manager/ensure-config-directory-exists.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync5 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync6 } from "fs";
 function ensureConfigDirectoryExists() {
   const configDir = getConfigDir();
-  if (!existsSync10(configDir)) {
-    mkdirSync5(configDir, { recursive: true });
+  if (!existsSync12(configDir)) {
+    mkdirSync6(configDir, { recursive: true });
   }
 }
 var init_ensure_config_directory_exists = __esm(() => {
@@ -49150,14 +49260,14 @@ function formatErrorWithSuggestion(err, context) {
 }
 
 // src/cli/config-manager/opencode-config-format.ts
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 function detectConfigFormat() {
   const configJsonc = getConfigJsonc();
   const configJson = getConfigJson();
-  if (existsSync11(configJsonc)) {
+  if (existsSync13(configJsonc)) {
     return { format: "jsonc", path: configJsonc };
   }
-  if (existsSync11(configJson)) {
+  if (existsSync13(configJson)) {
     return { format: "json", path: configJson };
   }
   return { format: "none", path: configJson };
@@ -49167,33 +49277,33 @@ var init_opencode_config_format = __esm(() => {
 });
 
 // src/cli/config-manager/parse-opencode-config-file.ts
-import { readFileSync as readFileSync6, statSync } from "fs";
+import { readFileSync as readFileSync7, statSync } from "fs";
 function isEmptyOrWhitespace(content) {
   return content.trim().length === 0;
 }
-function parseOpenCodeConfigFileWithError(path4) {
+function parseOpenCodeConfigFileWithError(path5) {
   try {
-    const stat = statSync(path4);
+    const stat = statSync(path5);
     if (stat.size === 0) {
-      return { config: null, error: `Config file is empty: ${path4}. Delete it or add valid JSON content.` };
+      return { config: null, error: `Config file is empty: ${path5}. Delete it or add valid JSON content.` };
     }
-    const content = readFileSync6(path4, "utf-8");
+    const content = readFileSync7(path5, "utf-8");
     if (isEmptyOrWhitespace(content)) {
-      return { config: null, error: `Config file contains only whitespace: ${path4}. Delete it or add valid JSON content.` };
+      return { config: null, error: `Config file contains only whitespace: ${path5}. Delete it or add valid JSON content.` };
     }
     const config = parseJsonc(content);
-    if (config === null || config === undefined) {
-      return { config: null, error: `Config file parsed to null/undefined: ${path4}. Ensure it contains valid JSON.` };
+    if (config == null) {
+      return { config: null, error: `Config file parsed to null/undefined: ${path5}. Ensure it contains valid JSON.` };
     }
     if (typeof config !== "object" || Array.isArray(config)) {
       return {
         config: null,
-        error: `Config file must contain a JSON object, not ${Array.isArray(config) ? "an array" : typeof config}: ${path4}`
+        error: `Config file must contain a JSON object, not ${Array.isArray(config) ? "an array" : typeof config}: ${path5}`
       };
     }
     return { config };
   } catch (err) {
-    return { config: null, error: formatErrorWithSuggestion(err, `parse config file ${path4}`) };
+    return { config: null, error: formatErrorWithSuggestion(err, `parse config file ${path5}`) };
   }
 }
 var init_parse_opencode_config_file = __esm(() => {
@@ -49283,7 +49393,7 @@ function extractVersionFromPluginEntry(entry) {
 }
 
 // src/cli/config-manager/add-plugin-to-opencode-config.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "fs";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
 async function addPluginToOpenCodeConfig(currentVersion) {
   try {
     ensureConfigDirectoryExists();
@@ -49294,20 +49404,20 @@ async function addPluginToOpenCodeConfig(currentVersion) {
       error: formatErrorWithSuggestion(err, "create config directory")
     };
   }
-  const { format: format2, path: path4 } = detectConfigFormat();
+  const { format: format2, path: path5 } = detectConfigFormat();
   const pluginEntry = await getPluginNameWithVersion(currentVersion, PLUGIN_NAME);
   try {
     if (format2 === "none") {
       const config2 = { plugin: [pluginEntry] };
-      writeFileSync3(path4, JSON.stringify(config2, null, 2) + `
+      writeFileSync3(path5, JSON.stringify(config2, null, 2) + `
 `);
-      return { success: true, configPath: path4 };
+      return { success: true, configPath: path5 };
     }
-    const parseResult = parseOpenCodeConfigFileWithError(path4);
+    const parseResult = parseOpenCodeConfigFileWithError(path5);
     if (!parseResult.config) {
       return {
         success: false,
-        configPath: path4,
+        configPath: path5,
         error: parseResult.error ?? "Failed to parse config file"
       };
     }
@@ -49323,28 +49433,24 @@ async function addPluginToOpenCodeConfig(currentVersion) {
       if (!compatibility.canUpgrade) {
         return {
           success: false,
-          configPath: path4,
+          configPath: path5,
           error: compatibility.reason ?? "Version compatibility check failed"
         };
       }
-      const backupResult = backupConfigFile(path4);
+      const backupResult = backupConfigFile(path5);
       if (!backupResult.success) {
         return {
           success: false,
-          configPath: path4,
+          configPath: path5,
           error: `Failed to create backup: ${backupResult.error}`
         };
       }
     }
     const normalizedPlugins = [...otherPlugins];
-    if (canonicalEntries.length > 0 || legacyEntries.length > 0) {
-      normalizedPlugins.push(pluginEntry);
-    } else {
-      normalizedPlugins.push(pluginEntry);
-    }
+    normalizedPlugins.push(pluginEntry);
     config.plugin = normalizedPlugins;
     if (format2 === "jsonc") {
-      const content = readFileSync7(path4, "utf-8");
+      const content = readFileSync8(path5, "utf-8");
       const pluginArrayRegex = /((?:"plugin"|plugin)\s*:\s*)\[([\s\S]*?)\]/;
       const match = content.match(pluginArrayRegex);
       if (match) {
@@ -49353,21 +49459,21 @@ async function addPluginToOpenCodeConfig(currentVersion) {
         const newContent = content.replace(pluginArrayRegex, `$1[
     ${formattedPlugins}
   ]`);
-        writeFileSync3(path4, newContent);
+        writeFileSync3(path5, newContent);
       } else {
         const newContent = content.replace(/(\{)/, `$1
   "plugin": ["${pluginEntry}"],`);
-        writeFileSync3(path4, newContent);
+        writeFileSync3(path5, newContent);
       }
     } else {
-      writeFileSync3(path4, JSON.stringify(config, null, 2) + `
+      writeFileSync3(path5, JSON.stringify(config, null, 2) + `
 `);
     }
-    return { success: true, configPath: path4 };
+    return { success: true, configPath: path5 };
   } catch (err) {
     return {
       success: false,
-      configPath: path4,
+      configPath: path5,
       error: formatErrorWithSuggestion(err, "update opencode config")
     };
   }
@@ -49434,6 +49540,7 @@ function toProviderAvailability(config) {
     zai: config.hasZaiCodingPlan,
     kimiForCoding: config.hasKimiForCoding,
     opencodeGo: config.hasOpencodeGo,
+    vercelAiGateway: config.hasVercelAiGateway,
     isMaxPlan: config.isMax20
   };
 }
@@ -49446,20 +49553,74 @@ function isProviderAvailable(provider, availability) {
     opencode: availability.opencodeZen,
     "zai-coding-plan": availability.zai,
     "kimi-for-coding": availability.kimiForCoding,
-    "opencode-go": availability.opencodeGo
+    "opencode-go": availability.opencodeGo,
+    vercel: availability.vercelAiGateway
   };
   return mapping[provider] ?? false;
 }
 
 // src/cli/provider-model-id-transform.ts
-var init_provider_model_id_transform = () => {};
+function inferSubProvider(model) {
+  if (model.startsWith("claude-"))
+    return "anthropic";
+  if (model.startsWith("gpt-"))
+    return "openai";
+  if (model.startsWith("gemini-"))
+    return "google";
+  if (model.startsWith("grok-"))
+    return "xai";
+  if (model.startsWith("minimax-"))
+    return "minimax";
+  if (model.startsWith("kimi-"))
+    return "moonshotai";
+  if (model.startsWith("glm-"))
+    return "zai";
+  return;
+}
+function claudeVersionDot(model) {
+  return model.replace(CLAUDE_VERSION_DOT, "claude-$1-$2.$3");
+}
+function applyGatewayTransforms(model) {
+  return claudeVersionDot(model).replace(GEMINI_31_PRO_PREVIEW, "gemini-3.1-pro-preview");
+}
+function transformModelForProvider2(provider, model) {
+  if (provider === "vercel") {
+    const slashIndex = model.indexOf("/");
+    if (slashIndex !== -1) {
+      const subProvider2 = model.substring(0, slashIndex);
+      const subModel = model.substring(slashIndex + 1);
+      return `${subProvider2}/${applyGatewayTransforms(subModel)}`;
+    }
+    const subProvider = inferSubProvider(model);
+    if (subProvider) {
+      return `${subProvider}/${applyGatewayTransforms(model)}`;
+    }
+    return model;
+  }
+  if (provider === "github-copilot") {
+    return claudeVersionDot(model).replace(GEMINI_31_PRO_PREVIEW, "gemini-3.1-pro-preview").replace(GEMINI_3_FLASH_PREVIEW, "gemini-3-flash-preview");
+  }
+  if (provider === "google") {
+    return model.replace(GEMINI_31_PRO_PREVIEW, "gemini-3.1-pro-preview").replace(GEMINI_3_FLASH_PREVIEW, "gemini-3-flash-preview");
+  }
+  if (provider === "anthropic") {
+    return model;
+  }
+  return model;
+}
+var CLAUDE_VERSION_DOT, GEMINI_31_PRO_PREVIEW, GEMINI_3_FLASH_PREVIEW;
+var init_provider_model_id_transform2 = __esm(() => {
+  CLAUDE_VERSION_DOT = /claude-(\w+)-(\d+)-(\d+)/g;
+  GEMINI_31_PRO_PREVIEW = /gemini-3\.1-pro(?!-)/g;
+  GEMINI_3_FLASH_PREVIEW = /gemini-3-flash(?!-)/g;
+});
 
 // src/cli/fallback-chain-resolution.ts
 function resolveModelFromChain(fallbackChain, availability) {
   for (const entry of fallbackChain) {
     for (const provider of entry.providers) {
       if (isProviderAvailable(provider, availability)) {
-        const transformedModel = transformModelForProvider(provider, entry.model);
+        const transformedModel = transformModelForProvider2(provider, entry.model);
         return {
           model: `${provider}/${transformedModel}`,
           variant: entry.variant
@@ -49486,13 +49647,13 @@ function isRequiredProviderAvailable(requiredProviders, availability) {
 }
 var init_fallback_chain_resolution = __esm(() => {
   init_model_fallback_requirements();
-  init_provider_model_id_transform();
+  init_provider_model_id_transform2();
 });
 
 // src/cli/model-fallback.ts
 function toFallbackModelObject(entry, provider) {
   return {
-    model: `${provider}/${transformModelForProvider(provider, entry.model)}`,
+    model: `${provider}/${transformModelForProvider2(provider, entry.model)}`,
     ...entry.variant ? { variant: entry.variant } : {},
     ...entry.reasoningEffort ? { reasoningEffort: entry.reasoningEffort } : {},
     ...entry.temperature !== undefined ? { temperature: entry.temperature } : {},
@@ -49533,7 +49694,7 @@ function attachAllFallbackModels(config, fallbackChain, availability) {
 }
 function generateModelConfig(config) {
   const avail = toProviderAvailability(config);
-  const hasAnyProvider = avail.native.claude || avail.native.openai || avail.native.gemini || avail.opencodeZen || avail.copilot || avail.zai || avail.kimiForCoding || avail.opencodeGo;
+  const hasAnyProvider = avail.native.claude || avail.native.openai || avail.native.gemini || avail.opencodeZen || avail.copilot || avail.zai || avail.kimiForCoding || avail.opencodeGo || avail.vercelAiGateway;
   if (!hasAnyProvider) {
     return {
       $schema: SCHEMA_URL,
@@ -49550,6 +49711,8 @@ function generateModelConfig(config) {
         agentConfig = { model: "opencode-go/minimax-m2.7" };
       } else if (avail.zai) {
         agentConfig = { model: ZAI_MODEL };
+      } else if (avail.vercelAiGateway) {
+        agentConfig = { model: "vercel/minimax/minimax-m2.7" };
       }
       if (agentConfig) {
         agents[role] = attachAllFallbackModels(agentConfig, req.fallbackChain, avail);
@@ -49566,6 +49729,8 @@ function generateModelConfig(config) {
         agentConfig = { model: "opencode-go/minimax-m2.7" };
       } else if (avail.copilot) {
         agentConfig = { model: "github-copilot/gpt-5-mini" };
+      } else if (avail.vercelAiGateway) {
+        agentConfig = { model: "vercel/minimax/minimax-m2.7-highspeed" };
       } else {
         agentConfig = { model: "opencode/gpt-5-nano" };
       }
@@ -49629,7 +49794,7 @@ var init_model_fallback = __esm(() => {
   init_model_fallback_requirements();
   init_openai_only_model_catalog();
   init_fallback_chain_resolution();
-  init_provider_model_id_transform();
+  init_provider_model_id_transform2();
 });
 
 // src/cli/config-manager/generate-omo-config.ts
@@ -49641,12 +49806,12 @@ var init_generate_omo_config = __esm(() => {
 });
 
 // src/shared/migrate-legacy-config-file.ts
-import { existsSync as existsSync12, readFileSync as readFileSync8, renameSync as renameSync2, rmSync } from "fs";
-import { join as join11, dirname as dirname3, basename } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync9, renameSync as renameSync2, rmSync } from "fs";
+import { join as join13, dirname as dirname4, basename as basename2 } from "path";
 function buildCanonicalPath(legacyPath) {
-  const dir = dirname3(legacyPath);
-  const ext = basename(legacyPath).includes(".jsonc") ? ".jsonc" : ".json";
-  return join11(dir, `${CONFIG_BASENAME}${ext}`);
+  const dir = dirname4(legacyPath);
+  const ext = basename2(legacyPath).includes(".jsonc") ? ".jsonc" : ".json";
+  return join13(dir, `${CONFIG_BASENAME}${ext}`);
 }
 function archiveLegacyConfigFile(legacyPath) {
   const backupPath = `${legacyPath}.bak`;
@@ -49678,15 +49843,15 @@ function archiveLegacyConfigFile(legacyPath) {
   }
 }
 function migrateLegacyConfigFile(legacyPath) {
-  if (!existsSync12(legacyPath))
+  if (!existsSync14(legacyPath))
     return false;
-  if (!basename(legacyPath).startsWith(LEGACY_CONFIG_BASENAME))
+  if (!basename2(legacyPath).startsWith(LEGACY_CONFIG_BASENAME))
     return false;
   const canonicalPath = buildCanonicalPath(legacyPath);
-  if (existsSync12(canonicalPath))
+  if (existsSync14(canonicalPath))
     return false;
   try {
-    const content = readFileSync8(legacyPath, "utf-8");
+    const content = readFileSync9(legacyPath, "utf-8");
     writeFileAtomically(canonicalPath, content);
     const archivedLegacyConfig = archiveLegacyConfigFile(legacyPath);
     log("[migrateLegacyConfigFile] Migrated legacy config to canonical path", {
@@ -49694,7 +49859,7 @@ function migrateLegacyConfigFile(legacyPath) {
       to: canonicalPath,
       archivedLegacyConfig
     });
-    return archivedLegacyConfig;
+    return true;
   } catch (error) {
     log("[migrateLegacyConfigFile] Failed to migrate legacy config file", { legacyPath, error });
     return false;
@@ -49724,8 +49889,8 @@ function deepMergeRecord(target, source) {
 }
 
 // src/cli/config-manager/write-omo-config.ts
-import { existsSync as existsSync13, readFileSync as readFileSync9, statSync as statSync2, writeFileSync as writeFileSync4 } from "fs";
-import { basename as basename2, dirname as dirname4, extname, join as join12 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync10, statSync as statSync2, writeFileSync as writeFileSync4 } from "fs";
+import { basename as basename3, dirname as dirname5, extname, join as join14 } from "path";
 function isEmptyOrWhitespace2(content) {
   return content.trim().length === 0;
 }
@@ -49740,12 +49905,12 @@ function writeOmoConfig(installConfig) {
     };
   }
   const detectedConfigPath = getOmoConfigPath();
-  const canonicalConfigPath = join12(dirname4(detectedConfigPath), `${CONFIG_BASENAME}${extname(detectedConfigPath) || ".json"}`);
-  const shouldMigrateLegacyPath = basename2(detectedConfigPath).startsWith(LEGACY_CONFIG_BASENAME);
-  const omoConfigPath = shouldMigrateLegacyPath ? migrateLegacyConfigFile(detectedConfigPath) || existsSync13(canonicalConfigPath) ? canonicalConfigPath : detectedConfigPath : detectedConfigPath;
+  const canonicalConfigPath = join14(dirname5(detectedConfigPath), `${CONFIG_BASENAME}${extname(detectedConfigPath) || ".json"}`);
+  const shouldMigrateLegacyPath = basename3(detectedConfigPath).startsWith(LEGACY_CONFIG_BASENAME);
+  const omoConfigPath = shouldMigrateLegacyPath ? migrateLegacyConfigFile(detectedConfigPath) || existsSync15(canonicalConfigPath) ? canonicalConfigPath : detectedConfigPath : detectedConfigPath;
   try {
     const newConfig = generateOmoConfig(installConfig);
-    if (existsSync13(omoConfigPath)) {
+    if (existsSync15(omoConfigPath)) {
       const backupResult = backupConfigFile(omoConfigPath);
       if (!backupResult.success) {
         return {
@@ -49756,7 +49921,7 @@ function writeOmoConfig(installConfig) {
       }
       try {
         const stat = statSync2(omoConfigPath);
-        const content = readFileSync9(omoConfigPath, "utf-8");
+        const content = readFileSync10(omoConfigPath, "utf-8");
         if (stat.size === 0 || isEmptyOrWhitespace2(content)) {
           writeFileSync4(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
 `);
@@ -49815,8 +49980,8 @@ function toReadableStream(stream) {
 function wrapNodeProcess(proc) {
   let resolveExited;
   let exitCode = null;
-  const exited = new Promise((resolve2) => {
-    resolveExited = resolve2;
+  const exited = new Promise((resolve4) => {
+    resolveExited = resolve4;
   });
   proc.on("exit", (code) => {
     exitCode = code ?? 1;
@@ -49899,20 +50064,21 @@ var init_opencode_binary = __esm(() => {
 });
 
 // src/cli/config-manager/detect-current-config.ts
-import { existsSync as existsSync14, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync11 } from "fs";
 function detectProvidersFromOmoConfig() {
   const omoConfigPath = getOmoConfigPath();
-  if (!existsSync14(omoConfigPath)) {
+  if (!existsSync16(omoConfigPath)) {
     return {
       hasOpenAI: true,
       hasOpencodeZen: true,
       hasZaiCodingPlan: false,
       hasKimiForCoding: false,
-      hasOpencodeGo: false
+      hasOpencodeGo: false,
+      hasVercelAiGateway: false
     };
   }
   try {
-    const content = readFileSync10(omoConfigPath, "utf-8");
+    const content = readFileSync11(omoConfigPath, "utf-8");
     const omoConfig = parseJsonc(content);
     if (!omoConfig || typeof omoConfig !== "object") {
       return {
@@ -49920,7 +50086,8 @@ function detectProvidersFromOmoConfig() {
         hasOpencodeZen: true,
         hasZaiCodingPlan: false,
         hasKimiForCoding: false,
-        hasOpencodeGo: false
+        hasOpencodeGo: false,
+        hasVercelAiGateway: false
       };
     }
     const configStr = JSON.stringify(omoConfig);
@@ -49929,14 +50096,16 @@ function detectProvidersFromOmoConfig() {
     const hasZaiCodingPlan = configStr.includes('"zai-coding-plan/');
     const hasKimiForCoding = configStr.includes('"kimi-for-coding/');
     const hasOpencodeGo = configStr.includes('"opencode-go/');
-    return { hasOpenAI, hasOpencodeZen, hasZaiCodingPlan, hasKimiForCoding, hasOpencodeGo };
+    const hasVercelAiGateway = configStr.includes('"vercel/');
+    return { hasOpenAI, hasOpencodeZen, hasZaiCodingPlan, hasKimiForCoding, hasOpencodeGo, hasVercelAiGateway };
   } catch {
     return {
       hasOpenAI: true,
       hasOpencodeZen: true,
       hasZaiCodingPlan: false,
       hasKimiForCoding: false,
-      hasOpencodeGo: false
+      hasOpencodeGo: false,
+      hasVercelAiGateway: false
     };
   }
 }
@@ -49958,13 +50127,14 @@ function detectCurrentConfig() {
     hasOpencodeZen: true,
     hasZaiCodingPlan: false,
     hasKimiForCoding: false,
-    hasOpencodeGo: false
+    hasOpencodeGo: false,
+    hasVercelAiGateway: false
   };
-  const { format: format2, path: path4 } = detectConfigFormat();
+  const { format: format2, path: path5 } = detectConfigFormat();
   if (format2 === "none") {
     return result;
   }
-  const parseResult = parseOpenCodeConfigFileWithError(path4);
+  const parseResult = parseOpenCodeConfigFileWithError(path5);
   if (!parseResult.config) {
     return result;
   }
@@ -49980,12 +50150,13 @@ function detectCurrentConfig() {
   }
   const providers = openCodeConfig.provider;
   result.hasGemini = providers ? "google" in providers : false;
-  const { hasOpenAI, hasOpencodeZen, hasZaiCodingPlan, hasKimiForCoding, hasOpencodeGo } = detectProvidersFromOmoConfig();
+  const { hasOpenAI, hasOpencodeZen, hasZaiCodingPlan, hasKimiForCoding, hasOpencodeGo, hasVercelAiGateway } = detectProvidersFromOmoConfig();
   result.hasOpenAI = hasOpenAI;
   result.hasOpencodeZen = hasOpencodeZen;
   result.hasZaiCodingPlan = hasZaiCodingPlan;
   result.hasKimiForCoding = hasKimiForCoding;
   result.hasOpencodeGo = hasOpencodeGo;
+  result.hasVercelAiGateway = hasVercelAiGateway;
   return result;
 }
 var init_detect_current_config = __esm(() => {
@@ -49996,10 +50167,10 @@ var init_detect_current_config = __esm(() => {
 });
 
 // src/cli/config-manager/bun-install.ts
-import { existsSync as existsSync15 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync17 } from "fs";
+import { join as join15 } from "path";
 function getDefaultWorkspaceDir() {
-  return join13(getOpenCodeCacheDir(), "packages");
+  return join15(getOpenCodeCacheDir(), "packages");
 }
 function readProcessOutput(stream) {
   if (!stream) {
@@ -50025,7 +50196,7 @@ async function runBunInstallWithDetails(options) {
   const outputMode = options?.outputMode ?? "pipe";
   const cacheDir = options?.workspaceDir ?? getDefaultWorkspaceDir();
   const packageJsonPath = `${cacheDir}/package.json`;
-  if (!existsSync15(packageJsonPath)) {
+  if (!existsSync17(packageJsonPath)) {
     return {
       success: false,
       error: `Workspace not initialized: ${packageJsonPath} not found. OpenCode should create this on first run.`
@@ -50039,8 +50210,8 @@ async function runBunInstallWithDetails(options) {
     });
     const outputPromise = Promise.all([readProcessOutput(proc.stdout), readProcessOutput(proc.stderr)]).then(([stdout, stderr]) => ({ stdout, stderr }));
     let timeoutId;
-    const timeoutPromise = new Promise((resolve2) => {
-      timeoutId = setTimeout(() => resolve2("timeout"), BUN_INSTALL_TIMEOUT_MS);
+    const timeoutPromise = new Promise((resolve4) => {
+      timeoutId = setTimeout(() => resolve4("timeout"), BUN_INSTALL_TIMEOUT_MS);
     });
     const exitPromise = proc.exited.then(() => "completed");
     const result = await Promise.race([exitPromise, timeoutPromise]);
@@ -50167,7 +50338,7 @@ var require_windows = __commonJS((exports2, module) => {
   module.exports = isexe;
   isexe.sync = sync;
   var fs5 = __require("fs");
-  function checkPathExt(path5, options) {
+  function checkPathExt(path6, options) {
     var pathext = options.pathExt !== undefined ? options.pathExt : process.env.PATHEXT;
     if (!pathext) {
       return true;
@@ -50178,25 +50349,25 @@ var require_windows = __commonJS((exports2, module) => {
     }
     for (var i2 = 0;i2 < pathext.length; i2++) {
       var p2 = pathext[i2].toLowerCase();
-      if (p2 && path5.substr(-p2.length).toLowerCase() === p2) {
+      if (p2 && path6.substr(-p2.length).toLowerCase() === p2) {
         return true;
       }
     }
     return false;
   }
-  function checkStat(stat, path5, options) {
+  function checkStat(stat, path6, options) {
     if (!stat.isSymbolicLink() && !stat.isFile()) {
       return false;
     }
-    return checkPathExt(path5, options);
+    return checkPathExt(path6, options);
   }
-  function isexe(path5, options, cb) {
-    fs5.stat(path5, function(er, stat) {
-      cb(er, er ? false : checkStat(stat, path5, options));
+  function isexe(path6, options, cb) {
+    fs5.stat(path6, function(er, stat) {
+      cb(er, er ? false : checkStat(stat, path6, options));
     });
   }
-  function sync(path5, options) {
-    return checkStat(fs5.statSync(path5), path5, options);
+  function sync(path6, options) {
+    return checkStat(fs5.statSync(path6), path6, options);
   }
 });
 
@@ -50205,13 +50376,13 @@ var require_mode = __commonJS((exports2, module) => {
   module.exports = isexe;
   isexe.sync = sync;
   var fs5 = __require("fs");
-  function isexe(path5, options, cb) {
-    fs5.stat(path5, function(er, stat) {
+  function isexe(path6, options, cb) {
+    fs5.stat(path6, function(er, stat) {
       cb(er, er ? false : checkStat(stat, options));
     });
   }
-  function sync(path5, options) {
-    return checkStat(fs5.statSync(path5), options);
+  function sync(path6, options) {
+    return checkStat(fs5.statSync(path6), options);
   }
   function checkStat(stat, options) {
     return stat.isFile() && checkMode(stat, options);
@@ -50242,7 +50413,7 @@ var require_isexe = __commonJS((exports2, module) => {
   }
   module.exports = isexe;
   isexe.sync = sync;
-  function isexe(path5, options, cb) {
+  function isexe(path6, options, cb) {
     if (typeof options === "function") {
       cb = options;
       options = {};
@@ -50251,17 +50422,17 @@ var require_isexe = __commonJS((exports2, module) => {
       if (typeof Promise !== "function") {
         throw new TypeError("callback not provided");
       }
-      return new Promise(function(resolve2, reject) {
-        isexe(path5, options || {}, function(er, is) {
+      return new Promise(function(resolve4, reject) {
+        isexe(path6, options || {}, function(er, is) {
           if (er) {
             reject(er);
           } else {
-            resolve2(is);
+            resolve4(is);
           }
         });
       });
     }
-    core3(path5, options || {}, function(er, is) {
+    core3(path6, options || {}, function(er, is) {
       if (er) {
         if (er.code === "EACCES" || options && options.ignoreErrors) {
           er = null;
@@ -50271,9 +50442,9 @@ var require_isexe = __commonJS((exports2, module) => {
       cb(er, is);
     });
   }
-  function sync(path5, options) {
+  function sync(path6, options) {
     try {
-      return core3.sync(path5, options || {});
+      return core3.sync(path6, options || {});
     } catch (er) {
       if (options && options.ignoreErrors || er.code === "EACCES") {
         return false;
@@ -50287,7 +50458,7 @@ var require_isexe = __commonJS((exports2, module) => {
 // node_modules/which/which.js
 var require_which = __commonJS((exports2, module) => {
   var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-  var path5 = __require("path");
+  var path6 = __require("path");
   var COLON = isWindows ? ";" : ":";
   var isexe = require_isexe();
   var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -50318,27 +50489,27 @@ var require_which = __commonJS((exports2, module) => {
       opt = {};
     const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
     const found = [];
-    const step = (i2) => new Promise((resolve2, reject) => {
+    const step = (i2) => new Promise((resolve4, reject) => {
       if (i2 === pathEnv.length)
-        return opt.all && found.length ? resolve2(found) : reject(getNotFoundError(cmd));
+        return opt.all && found.length ? resolve4(found) : reject(getNotFoundError(cmd));
       const ppRaw = pathEnv[i2];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-      const pCmd = path5.join(pathPart, cmd);
+      const pCmd = path6.join(pathPart, cmd);
       const p2 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-      resolve2(subStep(p2, i2, 0));
+      resolve4(subStep(p2, i2, 0));
     });
-    const subStep = (p2, i2, ii) => new Promise((resolve2, reject) => {
+    const subStep = (p2, i2, ii) => new Promise((resolve4, reject) => {
       if (ii === pathExt.length)
-        return resolve2(step(i2 + 1));
+        return resolve4(step(i2 + 1));
       const ext = pathExt[ii];
       isexe(p2 + ext, { pathExt: pathExtExe }, (er, is) => {
         if (!er && is) {
           if (opt.all)
             found.push(p2 + ext);
           else
-            return resolve2(p2 + ext);
+            return resolve4(p2 + ext);
         }
-        return resolve2(subStep(p2, i2, ii + 1));
+        return resolve4(subStep(p2, i2, ii + 1));
       });
     });
     return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -50350,7 +50521,7 @@ var require_which = __commonJS((exports2, module) => {
     for (let i2 = 0;i2 < pathEnv.length; i2++) {
       const ppRaw = pathEnv[i2];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-      const pCmd = path5.join(pathPart, cmd);
+      const pCmd = path6.join(pathPart, cmd);
       const p2 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
       for (let j2 = 0;j2 < pathExt.length; j2++) {
         const cur = p2 + pathExt[j2];
@@ -50391,7 +50562,7 @@ var require_path_key = __commonJS((exports2, module) => {
 
 // node_modules/cross-spawn/lib/util/resolveCommand.js
 var require_resolveCommand = __commonJS((exports2, module) => {
-  var path5 = __require("path");
+  var path6 = __require("path");
   var which = require_which();
   var getPathKey = require_path_key();
   function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -50408,7 +50579,7 @@ var require_resolveCommand = __commonJS((exports2, module) => {
     try {
       resolved = which.sync(parsed.command, {
         path: env[getPathKey({ env })],
-        pathExt: withoutPathExt ? path5.delimiter : undefined
+        pathExt: withoutPathExt ? path6.delimiter : undefined
       });
     } catch (e2) {} finally {
       if (shouldSwitchCwd) {
@@ -50416,7 +50587,7 @@ var require_resolveCommand = __commonJS((exports2, module) => {
       }
     }
     if (resolved) {
-      resolved = path5.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+      resolved = path6.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
     }
     return resolved;
   }
@@ -50461,8 +50632,8 @@ var require_shebang_command = __commonJS((exports2, module) => {
     if (!match) {
       return null;
     }
-    const [path5, argument] = match[0].replace(/#! ?/, "").split(" ");
-    const binary2 = path5.split("/").pop();
+    const [path6, argument] = match[0].replace(/#! ?/, "").split(" ");
+    const binary2 = path6.split("/").pop();
     if (binary2 === "env") {
       return argument;
     }
@@ -50490,7 +50661,7 @@ var require_readShebang = __commonJS((exports2, module) => {
 
 // node_modules/cross-spawn/lib/parse.js
 var require_parse = __commonJS((exports2, module) => {
-  var path5 = __require("path");
+  var path6 = __require("path");
   var resolveCommand = require_resolveCommand();
   var escape = require_escape();
   var readShebang = require_readShebang();
@@ -50515,7 +50686,7 @@ var require_parse = __commonJS((exports2, module) => {
     const needsShell = !isExecutableRegExp.test(commandFile);
     if (parsed.options.forceShell || needsShell) {
       const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-      parsed.command = path5.normalize(parsed.command);
+      parsed.command = path6.normalize(parsed.command);
       parsed.command = escape.command(parsed.command);
       parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
       const shellCommand = [parsed.command].concat(parsed.args).join(" ");
@@ -50619,21 +50790,21 @@ var require_cross_spawn = __commonJS((exports2, module) => {
 });
 
 // src/hooks/auto-update-checker/constants.ts
-import * as path5 from "path";
+import * as path6 from "path";
 import * as os4 from "os";
 function getWindowsAppdataDir() {
   if (process.platform !== "win32")
     return null;
-  return process.env.APPDATA ?? path5.join(os4.homedir(), "AppData", "Roaming");
+  return process.env.APPDATA ?? path6.join(os4.homedir(), "AppData", "Roaming");
 }
 function getUserConfigDir() {
   return getOpenCodeConfigDir({ binary: "opencode" });
 }
 function getUserOpencodeConfig() {
-  return path5.join(getUserConfigDir(), "opencode.json");
+  return path6.join(getUserConfigDir(), "opencode.json");
 }
 function getUserOpencodeConfigJsonc() {
-  return path5.join(getUserConfigDir(), "opencode.jsonc");
+  return path6.join(getUserConfigDir(), "opencode.jsonc");
 }
 var PACKAGE_NAME2, ACCEPTED_PACKAGE_NAMES2, NPM_REGISTRY_URL, NPM_FETCH_TIMEOUT = 5000, CACHE_ROOT_DIR, CACHE_DIR, VERSION_FILE, INSTALLED_PACKAGE_JSON, INSTALLED_PACKAGE_JSON_CANDIDATES;
 var init_constants3 = __esm(() => {
@@ -50644,30 +50815,30 @@ var init_constants3 = __esm(() => {
   ACCEPTED_PACKAGE_NAMES2 = ACCEPTED_PACKAGE_NAMES;
   NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME2}/dist-tags`;
   CACHE_ROOT_DIR = getOpenCodeCacheDir();
-  CACHE_DIR = path5.join(CACHE_ROOT_DIR, "packages");
-  VERSION_FILE = path5.join(CACHE_ROOT_DIR, "version");
-  INSTALLED_PACKAGE_JSON = path5.join(CACHE_DIR, "node_modules", PACKAGE_NAME2, "package.json");
-  INSTALLED_PACKAGE_JSON_CANDIDATES = ACCEPTED_PACKAGE_NAMES2.map((name) => path5.join(CACHE_DIR, "node_modules", name, "package.json"));
+  CACHE_DIR = path6.join(CACHE_ROOT_DIR, "packages");
+  VERSION_FILE = path6.join(CACHE_ROOT_DIR, "version");
+  INSTALLED_PACKAGE_JSON = path6.join(CACHE_DIR, "node_modules", PACKAGE_NAME2, "package.json");
+  INSTALLED_PACKAGE_JSON_CANDIDATES = ACCEPTED_PACKAGE_NAMES2.map((name) => path6.join(CACHE_DIR, "node_modules", name, "package.json"));
 });
 
 // src/hooks/auto-update-checker/checker/config-paths.ts
 import * as os5 from "os";
-import * as path6 from "path";
+import * as path7 from "path";
 function getConfigPaths(directory) {
   const userConfigDir = getUserConfigDir();
   const paths = [
-    path6.join(directory, ".opencode", "opencode.json"),
-    path6.join(directory, ".opencode", "opencode.jsonc"),
+    path7.join(directory, ".opencode", "opencode.json"),
+    path7.join(directory, ".opencode", "opencode.jsonc"),
     getUserOpencodeConfig(),
     getUserOpencodeConfigJsonc()
   ];
   if (process.platform === "win32") {
-    const crossPlatformDir = path6.join(os5.homedir(), ".config");
+    const crossPlatformDir = path7.join(os5.homedir(), ".config");
     const appdataDir = getWindowsAppdataDir();
     if (appdataDir) {
       const alternateDir = userConfigDir === crossPlatformDir ? appdataDir : crossPlatformDir;
-      const alternateConfig = path6.join(alternateDir, "opencode", "opencode.json");
-      const alternateConfigJsonc = path6.join(alternateDir, "opencode", "opencode.jsonc");
+      const alternateConfig = path7.join(alternateDir, "opencode", "opencode.json");
+      const alternateConfigJsonc = path7.join(alternateDir, "opencode", "opencode.jsonc");
       if (!paths.includes(alternateConfig)) {
         paths.push(alternateConfig);
       }
@@ -50725,13 +50896,13 @@ var init_local_dev_path = __esm(() => {
 
 // src/hooks/auto-update-checker/checker/package-json-locator.ts
 import * as fs6 from "fs";
-import * as path7 from "path";
+import * as path8 from "path";
 function findPackageJsonUp(startPath) {
   try {
     const stat = fs6.statSync(startPath);
-    let dir = stat.isDirectory() ? startPath : path7.dirname(startPath);
+    let dir = stat.isDirectory() ? startPath : path8.dirname(startPath);
     for (let i2 = 0;i2 < 10; i2++) {
-      const pkgPath = path7.join(dir, "package.json");
+      const pkgPath = path8.join(dir, "package.json");
       if (fs6.existsSync(pkgPath)) {
         try {
           const content = fs6.readFileSync(pkgPath, "utf-8");
@@ -50740,7 +50911,7 @@ function findPackageJsonUp(startPath) {
             return pkgPath;
         } catch {}
       }
-      const parent = path7.dirname(dir);
+      const parent = path8.dirname(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -50815,7 +50986,7 @@ var init_plugin_entry = __esm(() => {
 
 // src/hooks/auto-update-checker/checker/cached-version.ts
 import * as fs9 from "fs";
-import * as path8 from "path";
+import * as path9 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function readPackageVersion(packageJsonPath) {
   const content = fs9.readFileSync(packageJsonPath, "utf-8");
@@ -50831,7 +51002,7 @@ function getCachedVersion() {
     } catch {}
   }
   try {
-    const currentDir = path8.dirname(fileURLToPath2(import.meta.url));
+    const currentDir = path9.dirname(fileURLToPath2(import.meta.url));
     const pkgPath = findPackageJsonUp(currentDir);
     if (pkgPath) {
       return readPackageVersion(pkgPath);
@@ -50840,7 +51011,7 @@ function getCachedVersion() {
     log("[auto-update-checker] Failed to resolve version from current directory:", err);
   }
   try {
-    const execDir = path8.dirname(fs9.realpathSync(process.execPath));
+    const execDir = path9.dirname(fs9.realpathSync(process.execPath));
     const pkgPath = findPackageJsonUp(execDir);
     if (pkgPath) {
       return readPackageVersion(pkgPath);
@@ -50983,7 +51154,7 @@ var init_check_for_update = __esm(() => {
 // src/hooks/auto-update-checker/checker/sync-package-json.ts
 import * as crypto from "crypto";
 import * as fs10 from "fs";
-import * as path9 from "path";
+import * as path10 from "path";
 function safeUnlink(filePath) {
   try {
     fs10.unlinkSync(filePath);
@@ -51000,7 +51171,7 @@ function getIntentVersion(pluginInfo) {
 function writeCachePackageJson(cachePackageJsonPath, pkgJson) {
   const tmpPath = `${cachePackageJsonPath}.${crypto.randomUUID()}`;
   try {
-    fs10.mkdirSync(path9.dirname(cachePackageJsonPath), { recursive: true });
+    fs10.mkdirSync(path10.dirname(cachePackageJsonPath), { recursive: true });
     fs10.writeFileSync(tmpPath, JSON.stringify(pkgJson, null, 2));
     fs10.renameSync(tmpPath, cachePackageJsonPath);
     return { synced: true, error: null };
@@ -51011,7 +51182,7 @@ function writeCachePackageJson(cachePackageJsonPath, pkgJson) {
   }
 }
 function syncCachePackageJsonToIntent(pluginInfo) {
-  const cachePackageJsonPath = path9.join(CACHE_DIR, "package.json");
+  const cachePackageJsonPath = path10.join(CACHE_DIR, "package.json");
   const intentVersion = getIntentVersion(pluginInfo);
   if (!fs10.existsSync(cachePackageJsonPath)) {
     log("[auto-update-checker] Cache package.json missing, creating workspace package.json", { intentVersion });
@@ -51087,7 +51258,7 @@ var init_checker = __esm(() => {
 
 // src/hooks/auto-update-checker/cache.ts
 import * as fs11 from "fs";
-import * as path10 from "path";
+import * as path11 from "path";
 function stripTrailingCommas(json3) {
   return json3.replace(/,(\s*[}\]])/g, "$1");
 }
@@ -51116,8 +51287,8 @@ function deleteBinaryBunLock(lockPath) {
   }
 }
 function removeFromBunLock(packageName) {
-  const textLockPath = path10.join(CACHE_DIR, "bun.lock");
-  const binaryLockPath = path10.join(CACHE_DIR, "bun.lockb");
+  const textLockPath = path11.join(CACHE_DIR, "bun.lock");
+  const binaryLockPath = path11.join(CACHE_DIR, "bun.lockb");
   if (fs11.existsSync(textLockPath)) {
     return removeFromTextBunLock(textLockPath, packageName);
   }
@@ -51130,8 +51301,8 @@ function invalidatePackage(packageName = PACKAGE_NAME2) {
   try {
     const userConfigDir = getUserConfigDir();
     const pkgDirs = [
-      path10.join(userConfigDir, "node_modules", packageName),
-      path10.join(CACHE_DIR, "node_modules", packageName)
+      path11.join(userConfigDir, "node_modules", packageName),
+      path11.join(CACHE_DIR, "node_modules", packageName)
     ];
     let packageRemoved = false;
     let lockRemoved = false;
@@ -51191,8 +51362,8 @@ var init_update_toasts = __esm(() => {
 });
 
 // src/hooks/auto-update-checker/hook/background-update-check.ts
-import { existsSync as existsSync27 } from "fs";
-import { join as join26 } from "path";
+import { existsSync as existsSync29 } from "fs";
+import { join as join28 } from "path";
 function getCacheWorkspaceDir(deps) {
   return deps.join(deps.getOpenCodeCacheDir(), "packages");
 }
@@ -51310,8 +51481,8 @@ var init_background_update_check = __esm(() => {
   init_checker();
   init_update_toasts();
   defaultDeps = {
-    existsSync: existsSync27,
-    join: join26,
+    existsSync: existsSync29,
+    join: join28,
     runBunInstallWithDetails,
     log,
     getOpenCodeCacheDir,
@@ -51464,7 +51635,7 @@ async function showSpinnerToast(ctx, version3, message) {
         duration: frameInterval + 50
       }
     }).catch(() => {});
-    await new Promise((resolve2) => setTimeout(resolve2, frameInterval));
+    await new Promise((resolve4) => setTimeout(resolve4, frameInterval));
   }
 }
 var SISYPHUS_SPINNER;
@@ -51604,7 +51775,7 @@ var {
 // package.json
 var package_default = {
   name: "evil-omo",
-  version: "3.17.0",
+  version: "3.17.4",
   description: "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   main: "./dist/index.js",
   types: "dist/index.d.ts",
@@ -51683,17 +51854,17 @@ var package_default = {
     typescript: "^5.7.3"
   },
   optionalDependencies: {
-    "evil-omo-darwin-arm64": "3.17.0",
-    "evil-omo-darwin-x64": "3.17.0",
-    "evil-omo-darwin-x64-baseline": "3.17.0",
-    "evil-omo-linux-x64": "3.17.0",
-    "evil-omo-linux-x64-baseline": "3.17.0",
-    "evil-omo-linux-arm64": "3.17.0",
-    "evil-omo-linux-x64-musl": "3.17.0",
-    "evil-omo-linux-x64-musl-baseline": "3.17.0",
-    "evil-omo-linux-arm64-musl": "3.17.0",
-    "evil-omo-windows-x64": "3.17.0",
-    "evil-omo-windows-x64-baseline": "3.17.0"
+    "evil-omo-darwin-arm64": "3.17.4",
+    "evil-omo-darwin-x64": "3.17.4",
+    "evil-omo-darwin-x64-baseline": "3.17.4",
+    "evil-omo-linux-x64": "3.17.4",
+    "evil-omo-linux-x64-baseline": "3.17.4",
+    "evil-omo-linux-arm64": "3.17.4",
+    "evil-omo-linux-x64-musl": "3.17.4",
+    "evil-omo-linux-x64-musl-baseline": "3.17.4",
+    "evil-omo-linux-arm64-musl": "3.17.4",
+    "evil-omo-windows-x64": "3.17.4",
+    "evil-omo-windows-x64-baseline": "3.17.4"
   },
   overrides: {},
   trustedDependencies: [
@@ -51738,6 +51909,7 @@ function formatConfigSummary(config) {
   lines.push(formatProvider("OpenCode Zen", config.hasOpencodeZen, "opencode/ models"));
   lines.push(formatProvider("Z.ai Coding Plan", config.hasZaiCodingPlan, "Librarian/Multimodal"));
   lines.push(formatProvider("Kimi For Coding", config.hasKimiForCoding, "Sisyphus/Prometheus fallback"));
+  lines.push(formatProvider("Vercel AI Gateway", config.hasVercelAiGateway, "universal proxy"));
   lines.push("");
   lines.push(import_picocolors.default.dim("\u2500".repeat(40)));
   lines.push("");
@@ -51821,6 +51993,9 @@ function validateNonTuiArgs(args) {
   if (args.kimiForCoding !== undefined && !["no", "yes"].includes(args.kimiForCoding)) {
     errors.push(`Invalid --kimi-for-coding value: ${args.kimiForCoding} (expected: no, yes)`);
   }
+  if (args.vercelAiGateway !== undefined && !["no", "yes"].includes(args.vercelAiGateway)) {
+    errors.push(`Invalid --vercel-ai-gateway value: ${args.vercelAiGateway} (expected: no, yes)`);
+  }
   return { valid: errors.length === 0, errors };
 }
 function argsToConfig(args) {
@@ -51833,7 +52008,8 @@ function argsToConfig(args) {
     hasOpencodeZen: args.opencodeZen === "yes",
     hasZaiCodingPlan: args.zaiCodingPlan === "yes",
     hasKimiForCoding: args.kimiForCoding === "yes",
-    hasOpencodeGo: args.opencodeGo === "yes"
+    hasOpencodeGo: args.opencodeGo === "yes",
+    hasVercelAiGateway: args.vercelAiGateway === "yes"
   };
 }
 function detectedToInitialValues(detected) {
@@ -51849,7 +52025,8 @@ function detectedToInitialValues(detected) {
     opencodeZen: detected.hasOpencodeZen ? "yes" : "no",
     zaiCodingPlan: detected.hasZaiCodingPlan ? "yes" : "no",
     kimiForCoding: detected.hasKimiForCoding ? "yes" : "no",
-    opencodeGo: detected.hasOpencodeGo ? "yes" : "no"
+    opencodeGo: detected.hasOpencodeGo ? "yes" : "no",
+    vercelAiGateway: detected.hasVercelAiGateway ? "yes" : "no"
   };
 }
 
@@ -51908,7 +52085,7 @@ import os3 from "os";
 import { createHash } from "crypto";
 
 // node_modules/posthog-node/dist/extensions/error-tracking/modifiers/module.node.mjs
-import { dirname as dirname5, posix, sep } from "path";
+import { dirname as dirname6, posix, sep } from "path";
 function createModulerModifier() {
   const getModuleFromFileName = createGetModuleFromFilename();
   return async (frames) => {
@@ -51917,7 +52094,7 @@ function createModulerModifier() {
     return frames;
   };
 }
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname5(process.argv[1]) : process.cwd(), isWindows = sep === "\\") {
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname6(process.argv[1]) : process.cwd(), isWindows = sep === "\\") {
   const normalizedBase = isWindows ? normalizeWindowsPath(basePath) : basePath;
   return (filename) => {
     if (!filename)
@@ -51939,8 +52116,8 @@ function createGetModuleFromFilename(basePath = process.argv[1] ? dirname5(proce
     return decodedFile;
   };
 }
-function normalizeWindowsPath(path4) {
-  return path4.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
+function normalizeWindowsPath(path5) {
+  return path5.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
 }
 
 // node_modules/@posthog/core/dist/featureFlagUtils.mjs
@@ -54255,15 +54432,15 @@ async function addSourceContext(frames) {
   LRU_FILE_CONTENTS_CACHE.reduce();
   return frames;
 }
-function getContextLinesFromFile(path4, ranges, output) {
-  return new Promise((resolve2) => {
-    const stream = createReadStream(path4);
+function getContextLinesFromFile(path5, ranges, output) {
+  return new Promise((resolve4) => {
+    const stream = createReadStream(path5);
     const lineReaded = createInterface({
       input: stream
     });
     function destroyStreamAndResolve() {
       stream.destroy();
-      resolve2();
+      resolve4();
     }
     let lineNumber = 0;
     let currentRangeIndex = 0;
@@ -54273,7 +54450,7 @@ function getContextLinesFromFile(path4, ranges, output) {
     let rangeStart = range[0];
     let rangeEnd = range[1];
     function onStreamError() {
-      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path4, 1);
+      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path5, 1);
       lineReaded.close();
       lineReaded.removeAllListeners();
       destroyStreamAndResolve();
@@ -54341,8 +54518,8 @@ function clearLineContext(frame) {
   delete frame.context_line;
   delete frame.post_context;
 }
-function shouldSkipContextLinesForFile(path4) {
-  return path4.startsWith("node:") || path4.endsWith(".min.js") || path4.endsWith(".min.cjs") || path4.endsWith(".min.mjs") || path4.startsWith("data:");
+function shouldSkipContextLinesForFile(path5) {
+  return path5.startsWith("node:") || path5.endsWith(".min.js") || path5.endsWith(".min.cjs") || path5.endsWith(".min.mjs") || path5.startsWith("data:");
 }
 function shouldSkipContextLinesForFrame(frame) {
   if (frame.lineno !== undefined && frame.lineno > MAX_CONTEXTLINES_LINENO)
@@ -55503,9 +55680,9 @@ class PostHogBackendClient extends PostHogCoreStateless {
     if (this.disabled || this.optedOut)
       return;
     if (!this._waitUntilCycle) {
-      let resolve2;
+      let resolve4;
       const promise = new Promise((r) => {
-        resolve2 = r;
+        resolve4 = r;
       });
       try {
         waitUntil(promise);
@@ -55513,7 +55690,7 @@ class PostHogBackendClient extends PostHogCoreStateless {
         return;
       }
       this._waitUntilCycle = {
-        resolve: resolve2,
+        resolve: resolve4,
         startedAt: Date.now(),
         timer: undefined
       };
@@ -55539,11 +55716,11 @@ class PostHogBackendClient extends PostHogCoreStateless {
     return cycle?.resolve;
   }
   async resolveWaitUntilFlush() {
-    const resolve2 = this._consumeWaitUntilCycle();
+    const resolve4 = this._consumeWaitUntilCycle();
     try {
       await super.flush();
     } catch {} finally {
-      resolve2?.();
+      resolve4?.();
     }
   }
   getPersistedProperty(key) {
@@ -55643,15 +55820,15 @@ class PostHogBackendClient extends PostHogCoreStateless {
       return true;
     if (this.featureFlagsPoller === undefined)
       return false;
-    return new Promise((resolve2) => {
+    return new Promise((resolve4) => {
       const timeout = setTimeout(() => {
         cleanup();
-        resolve2(false);
+        resolve4(false);
       }, timeoutMs);
       const cleanup = this._events.on("localEvaluationFlagsLoaded", (count) => {
         clearTimeout(timeout);
         cleanup();
-        resolve2(count > 0);
+        resolve4(count > 0);
       });
     });
   }
@@ -55995,13 +56172,13 @@ class PostHogBackendClient extends PostHogCoreStateless {
     this.context?.enter(data, options);
   }
   async _shutdown(shutdownTimeoutMs) {
-    const resolve2 = this._consumeWaitUntilCycle();
+    const resolve4 = this._consumeWaitUntilCycle();
     await this.featureFlagsPoller?.stopPoller(shutdownTimeoutMs);
     this.errorTracking.shutdown();
     try {
       return await super._shutdown(shutdownTimeoutMs);
     } finally {
-      resolve2?.();
+      resolve4?.();
     }
   }
   async _requestRemoteConfigPayload(flagKey) {
@@ -56355,11 +56532,11 @@ init_data_path();
 init_logger();
 init_plugin_identity();
 init_write_file_atomically();
-import { existsSync as existsSync16, mkdirSync as mkdirSync6, readFileSync as readFileSync11 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync7, readFileSync as readFileSync12 } from "fs";
+import { join as join16 } from "path";
 var POSTHOG_ACTIVITY_STATE_FILE = "posthog-activity.json";
 function getPostHogActivityStateFilePath() {
-  return join14(getDataDir(), CACHE_DIR_NAME, POSTHOG_ACTIVITY_STATE_FILE);
+  return join16(getDataDir(), CACHE_DIR_NAME, POSTHOG_ACTIVITY_STATE_FILE);
 }
 function getUtcDayString(date) {
   return date.toISOString().slice(0, 10);
@@ -56372,11 +56549,11 @@ function isPostHogActivityState(value) {
 }
 function readPostHogActivityState() {
   const stateFilePath = getPostHogActivityStateFilePath();
-  if (!existsSync16(stateFilePath)) {
+  if (!existsSync18(stateFilePath)) {
     return {};
   }
   try {
-    const content = readFileSync11(stateFilePath, "utf-8");
+    const content = readFileSync12(stateFilePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!isPostHogActivityState(parsed)) {
       return {};
@@ -56393,7 +56570,7 @@ function readPostHogActivityState() {
 function writePostHogActivityState(nextState) {
   const stateFilePath = getPostHogActivityStateFilePath();
   try {
-    mkdirSync6(join14(getDataDir(), CACHE_DIR_NAME), { recursive: true });
+    mkdirSync7(join16(getDataDir(), CACHE_DIR_NAME), { recursive: true });
     writeFileAtomically(stateFilePath, `${JSON.stringify(nextState, null, 2)}
 `);
   } catch (error) {
@@ -56465,17 +56642,36 @@ function getSharedProperties(source) {
     plugin_name: PLUGIN_NAME,
     package_version: package_default.version,
     runtime: "bun",
-    source
+    runtime_version: process.versions.bun ?? process.version,
+    source,
+    $os: os3.platform(),
+    $os_version: os3.release(),
+    os_arch: os3.arch(),
+    os_type: os3.type(),
+    cpu_count: os3.cpus().length,
+    cpu_model: os3.cpus()[0]?.model,
+    total_memory_gb: Math.round(os3.totalmem() / 1024 / 1024 / 1024),
+    locale: Intl.DateTimeFormat().resolvedOptions().locale,
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    shell: process.env.SHELL,
+    ci: Boolean(process.env.CI),
+    terminal: process.env.TERM_PROGRAM
   };
 }
 function createPostHogClient(source, options) {
   if (shouldDisablePostHog() || !hasPostHogApiKey()) {
     return NO_OP_POSTHOG;
   }
-  const configuredClient = new PostHog(getPostHogApiKey(), {
-    ...options,
-    host: getPostHogHost()
-  });
+  let configuredClient;
+  try {
+    configuredClient = new PostHog(getPostHogApiKey(), {
+      ...options,
+      host: getPostHogHost(),
+      disableGeoip: false
+    });
+  } catch {
+    return NO_OP_POSTHOG;
+  }
   const sharedProperties = getSharedProperties(source);
   return {
     capture: (message) => {
@@ -56526,7 +56722,7 @@ function getPostHogDistinctId() {
 }
 function createCliPostHog() {
   return createPostHogClient("cli", {
-    enableExceptionAutocapture: true,
+    enableExceptionAutocapture: false,
     flushAt: 1,
     flushInterval: 0
   });
@@ -56608,7 +56804,7 @@ async function runCliInstaller(args, version2) {
   if (!config.hasClaude) {
     printInfo("Note: Sisyphus agent performs best with Claude Opus 4.5+. " + "Other models work but may have reduced orchestration quality.");
   }
-  if (!config.hasClaude && !config.hasOpenAI && !config.hasGemini && !config.hasCopilot && !config.hasOpencodeZen) {
+  if (!config.hasClaude && !config.hasOpenAI && !config.hasGemini && !config.hasCopilot && !config.hasOpencodeZen && !config.hasVercelAiGateway) {
     printWarning("No model providers configured. Using opencode/big-pickle as fallback.");
   }
   console.log(`${SYMBOLS.star} ${import_picocolors3.default.bold(import_picocolors3.default.green(isUpdate ? "Configuration updated!" : "Installation complete!"))}`);
@@ -57335,6 +57531,16 @@ async function promptInstallConfig(detected) {
   });
   if (!opencodeGo)
     return null;
+  const vercelAiGateway = await selectOrCancel({
+    message: "Do you have a Vercel AI Gateway API key?",
+    options: [
+      { value: "no", label: "No", hint: "Will use other configured providers" },
+      { value: "yes", label: "Yes", hint: "Universal proxy for OpenAI, Anthropic, Google, etc." }
+    ],
+    initialValue: initial.vercelAiGateway
+  });
+  if (!vercelAiGateway)
+    return null;
   return {
     hasClaude: claude !== "no",
     isMax20: claude === "max20",
@@ -57344,7 +57550,8 @@ async function promptInstallConfig(detected) {
     hasOpencodeZen: opencodeZen === "yes",
     hasZaiCodingPlan: zaiCodingPlan === "yes",
     hasKimiForCoding: kimiForCoding === "yes",
-    hasOpencodeGo: opencodeGo === "yes"
+    hasOpencodeGo: opencodeGo === "yes",
+    hasVercelAiGateway: vercelAiGateway === "yes"
   };
 }
 
@@ -57401,7 +57608,7 @@ async function runTuiInstaller(args, version2) {
     M2.info(`${import_picocolors5.default.bold("Note:")} Sisyphus agent performs best with Claude Opus 4.5+.
 ` + `Other models work but may have reduced orchestration quality.`);
   }
-  if (!config.hasClaude && !config.hasOpenAI && !config.hasGemini && !config.hasCopilot && !config.hasOpencodeZen) {
+  if (!config.hasClaude && !config.hasOpenAI && !config.hasGemini && !config.hasCopilot && !config.hasOpencodeZen && !config.hasVercelAiGateway) {
     M2.warn("No model providers configured. Using opencode/big-pickle as fallback.");
   }
   Me(formatConfigSummary(config), isUpdate ? "Updated Configuration" : "Installation Complete");
@@ -57627,10 +57834,10 @@ function formatToolHeader(toolName, input) {
     };
   }
   if (toolName === "list") {
-    const path4 = str2(input.path);
+    const path5 = str2(input.path);
     return {
       icon: "\u2192",
-      title: path4 ? `List ${path4}` : "List"
+      title: path5 ? `List ${path5}` : "List"
     };
   }
   if (toolName === "read") {
@@ -58139,7 +58346,7 @@ async function processEvents(ctx, stream, state) {
 }
 // src/plugin-config.ts
 import * as fs4 from "fs";
-import * as path4 from "path";
+import * as path5 from "path";
 
 // node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -58906,10 +59113,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema2) {
   return mergeDefs(schema2._zod.def);
 }
-function getElementAtPath(obj, path4) {
-  if (!path4)
+function getElementAtPath(obj, path5) {
+  if (!path5)
     return obj;
-  return path4.reduce((acc, key) => acc?.[key], obj);
+  return path5.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -59290,11 +59497,11 @@ function aborted(x2, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path4, issues) {
+function prefixIssues(path5, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path4);
+    iss.path.unshift(path5);
     return iss;
   });
 }
@@ -59477,7 +59684,7 @@ function formatError2(error, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error2, path4 = []) => {
+  const processError = (error2, path5 = []) => {
     var _a, _b;
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -59487,7 +59694,7 @@ function treeifyError(error, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path4, ...issue2.path];
+        const fullpath = [...path5, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -59519,8 +59726,8 @@ function treeifyError(error, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path4 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path4) {
+  const path5 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path5) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -71267,13 +71474,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path4 = ref.slice(1).split("/").filter(Boolean);
-  if (path4.length === 0) {
+  const path5 = ref.slice(1).split("/").filter(Boolean);
+  if (path5.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path4[0] === defsKey) {
-    const key = path4[1];
+  if (path5[0] === defsKey) {
+    const key = path5[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -72053,6 +72260,10 @@ var OpenClawConfigSchema = exports_external.object({
   hooks: exports_external.record(exports_external.string(), OpenClawHookSchema).default({}),
   replyListener: OpenClawReplyListenerConfigSchema.optional()
 });
+// src/config/schema/agent-definitions.ts
+var AgentDefinitionPathSchema = exports_external.string().min(1);
+var AgentDefinitionsConfigSchema = exports_external.array(AgentDefinitionPathSchema).optional();
+
 // src/config/schema/ralph-loop.ts
 var RalphLoopConfigSchema = exports_external.object({
   enabled: exports_external.boolean().default(false),
@@ -72166,9 +72377,10 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
   $schema: exports_external.string().optional(),
   new_task_system_enabled: exports_external.boolean().optional(),
   default_run_agent: exports_external.string().optional(),
+  agent_definitions: AgentDefinitionsConfigSchema,
   disabled_mcps: exports_external.array(AnyMcpNameSchema).optional(),
   disabled_agents: StringListSchema.optional(),
-  disabled_skills: StringListSchema.optional(),
+  disabled_skills: exports_external.array(BuiltinSkillNameSchema).optional(),
   disabled_hooks: StringListSchema.optional(),
   disabled_commands: exports_external.array(BuiltinCommandNameSchema).optional(),
   disabled_tools: StringListSchema.optional(),
@@ -72189,7 +72401,11 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
   model_capabilities: ModelCapabilitiesConfigSchema.optional(),
   openclaw: OpenClawConfigSchema.optional(),
   babysitting: BabysittingConfigSchema.optional(),
-  git_master: GitMasterConfigSchema.optional(),
+  git_master: GitMasterConfigSchema.default({
+    commit_footer: true,
+    include_co_authored_by: true,
+    git_env_prefix: "GIT_MASTER=1"
+  }),
   browser_automation_engine: BrowserAutomationConfigSchema.optional(),
   websearch: WebsearchConfigSchema.optional(),
   tmux: TmuxConfigSchema.optional(),
@@ -72202,6 +72418,22 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
 init_shared();
 init_migrate_legacy_config_file();
 init_plugin_identity();
+function loadExplicitGitMasterOverrides(configPath) {
+  try {
+    if (!fs4.existsSync(configPath)) {
+      return;
+    }
+    const content = fs4.readFileSync(configPath, "utf-8");
+    const rawConfig = parseJsonc(content);
+    const gitMaster = rawConfig.git_master;
+    if (gitMaster && typeof gitMaster === "object" && !Array.isArray(gitMaster)) {
+      return gitMaster;
+    }
+  } catch {
+    return;
+  }
+  return;
+}
 var PARTIAL_STRING_ARRAY_KEYS = new Set([
   "disabled_mcps",
   "disabled_agents",
@@ -72209,7 +72441,8 @@ var PARTIAL_STRING_ARRAY_KEYS = new Set([
   "disabled_hooks",
   "disabled_commands",
   "disabled_tools",
-  "mcp_env_allowlist"
+  "mcp_env_allowlist",
+  "agent_definitions"
 ]);
 function parseConfigPartially(rawConfig) {
   const fullResult = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
@@ -72281,6 +72514,12 @@ function mergeConfigs(base, override) {
     ...override,
     agents: deepMerge(base.agents, override.agents),
     categories: deepMerge(base.categories, override.categories),
+    agent_definitions: [
+      ...new Set([
+        ...base.agent_definitions ?? [],
+        ...override.agent_definitions ?? []
+      ])
+    ],
     disabled_agents: [
       ...new Set([
         ...base.disabled_agents ?? [],
@@ -72329,42 +72568,61 @@ function mergeConfigs(base, override) {
 function loadPluginConfig(directory, ctx) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   const userDetected = detectPluginConfigFile(configDir);
-  let userConfigPath = userDetected.format !== "none" ? userDetected.path : path4.join(configDir, `${CONFIG_BASENAME}.json`);
+  let userConfigPath = userDetected.format !== "none" ? userDetected.path : path5.join(configDir, `${CONFIG_BASENAME}.json`);
   if (userDetected.legacyPath) {
     log("Canonical plugin config detected alongside legacy config. Remove the legacy file to avoid confusion.", {
       canonicalPath: userDetected.path,
       legacyPath: userDetected.legacyPath
     });
   }
-  if (userDetected.format !== "none" && path4.basename(userDetected.path).startsWith(LEGACY_CONFIG_BASENAME)) {
+  if (userDetected.format !== "none" && path5.basename(userDetected.path).startsWith(LEGACY_CONFIG_BASENAME)) {
     const migrated = migrateLegacyConfigFile(userDetected.path);
-    const canonicalPath = path4.join(path4.dirname(userDetected.path), `${CONFIG_BASENAME}${path4.extname(userDetected.path)}`);
+    const canonicalPath = path5.join(path5.dirname(userDetected.path), `${CONFIG_BASENAME}${path5.extname(userDetected.path)}`);
     if (migrated || fs4.existsSync(canonicalPath)) {
       userConfigPath = canonicalPath;
     }
   }
-  const projectBasePath = path4.join(directory, ".opencode");
+  const projectBasePath = path5.join(directory, ".opencode");
   const projectDetected = detectPluginConfigFile(projectBasePath);
-  let projectConfigPath = projectDetected.format !== "none" ? projectDetected.path : path4.join(projectBasePath, `${CONFIG_BASENAME}.json`);
+  let projectConfigPath = projectDetected.format !== "none" ? projectDetected.path : path5.join(projectBasePath, `${CONFIG_BASENAME}.json`);
   if (projectDetected.legacyPath) {
     log("Canonical plugin config detected alongside legacy config. Remove the legacy file to avoid confusion.", {
       canonicalPath: projectDetected.path,
       legacyPath: projectDetected.legacyPath
     });
   }
-  if (projectDetected.format !== "none" && path4.basename(projectDetected.path).startsWith(LEGACY_CONFIG_BASENAME)) {
+  if (projectDetected.format !== "none" && path5.basename(projectDetected.path).startsWith(LEGACY_CONFIG_BASENAME)) {
     const projectMigrated = migrateLegacyConfigFile(projectDetected.path);
-    const canonicalProjectPath = path4.join(path4.dirname(projectDetected.path), `${CONFIG_BASENAME}${path4.extname(projectDetected.path)}`);
+    const canonicalProjectPath = path5.join(path5.dirname(projectDetected.path), `${CONFIG_BASENAME}${path5.extname(projectDetected.path)}`);
     if (projectMigrated || fs4.existsSync(canonicalProjectPath)) {
       projectConfigPath = canonicalProjectPath;
     }
   }
   const userConfig = loadConfigFromPath(userConfigPath, ctx);
+  const userGitMasterOverrides = loadExplicitGitMasterOverrides(userConfigPath);
+  if (userConfig?.agent_definitions) {
+    userConfig.agent_definitions = resolveAgentDefinitionPaths(userConfig.agent_definitions, configDir, null);
+  }
   let config2 = userConfig ?? OhMyOpenCodeConfigSchema.parse({});
+  const defaultGitMaster = OhMyOpenCodeConfigSchema.parse({}).git_master;
   const projectConfig = loadConfigFromPath(projectConfigPath, ctx);
+  const projectGitMasterOverrides = loadExplicitGitMasterOverrides(projectConfigPath);
+  if (projectConfig?.agent_definitions) {
+    projectConfig.agent_definitions = resolveAgentDefinitionPaths(projectConfig.agent_definitions, projectBasePath, directory);
+  }
   if (projectConfig) {
     config2 = mergeConfigs(config2, projectConfig);
   }
+  if (userGitMasterOverrides || projectGitMasterOverrides) {
+    config2 = {
+      ...config2,
+      git_master: {
+        ...defaultGitMaster,
+        ...userGitMasterOverrides ?? {},
+        ...projectGitMasterOverrides ?? {}
+      }
+    };
+  }
   config2 = {
     ...config2,
     mcp_env_allowlist: userConfig?.mcp_env_allowlist ?? []
@@ -72381,7 +72639,7 @@ function loadPluginConfig(directory, ctx) {
 // node_modules/@opencode-ai/sdk/dist/gen/core/serverSentEvents.gen.js
 var createSseClient = ({ onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url: url2, ...options }) => {
   let lastEventId;
-  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms)));
+  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve4) => setTimeout(resolve4, ms)));
   const createStream = async function* () {
     let retryDelay = sseDefaultRetryDelay ?? 3000;
     let attempt = 0;
@@ -72612,7 +72870,7 @@ var serializeObjectParam = ({ allowReserved, explode, name, style, value, valueO
 
 // node_modules/@opencode-ai/sdk/dist/gen/core/utils.gen.js
 var PATH_PARAM_RE = /\{[^{}]+\}/g;
-var defaultPathSerializer = ({ path: path5, url: _url2 }) => {
+var defaultPathSerializer = ({ path: path6, url: _url2 }) => {
   let url2 = _url2;
   const matches = _url2.match(PATH_PARAM_RE);
   if (matches) {
@@ -72631,7 +72889,7 @@ var defaultPathSerializer = ({ path: path5, url: _url2 }) => {
         name = name.substring(1);
         style = "matrix";
       }
-      const value = path5[name];
+      const value = path6[name];
       if (value === undefined || value === null) {
         continue;
       }
@@ -72662,11 +72920,11 @@ var defaultPathSerializer = ({ path: path5, url: _url2 }) => {
   }
   return url2;
 };
-var getUrl = ({ baseUrl, path: path5, query, querySerializer, url: _url2 }) => {
+var getUrl = ({ baseUrl, path: path6, query, querySerializer, url: _url2 }) => {
   const pathUrl = _url2.startsWith("/") ? _url2 : `/${_url2}`;
   let url2 = (baseUrl ?? "") + pathUrl;
-  if (path5) {
-    url2 = defaultPathSerializer({ path: path5, url: url2 });
+  if (path6) {
+    url2 = defaultPathSerializer({ path: path6, url: url2 });
   }
   let search = query ? querySerializer(query) : "";
   if (search.startsWith("?")) {
@@ -73816,7 +74074,7 @@ async function createOpencodeServer(options) {
     }
   });
   let clear = () => {};
-  const url2 = await new Promise((resolve2, reject) => {
+  const url2 = await new Promise((resolve4, reject) => {
     const id = setTimeout(() => {
       clear();
       stop(proc);
@@ -73842,7 +74100,7 @@ async function createOpencodeServer(options) {
           }
           clearTimeout(id);
           resolved = true;
-          resolve2(match[1]);
+          resolve4(match[1]);
           return;
         }
       }
@@ -73896,7 +74154,7 @@ var import_picocolors10 = __toESM(require_picocolors(), 1);
 
 // src/cli/run/opencode-binary-resolver.ts
 init_spawn_with_windows_hide();
-import { delimiter, dirname as dirname7, join as join16 } from "path";
+import { delimiter, dirname as dirname8, join as join18 } from "path";
 var OPENCODE_COMMANDS = ["opencode", "opencode-desktop"];
 var WINDOWS_SUFFIXES = ["", ".exe", ".cmd", ".bat", ".ps1"];
 function getCommandCandidates(platform) {
@@ -73919,7 +74177,7 @@ function collectCandidateBinaryPaths(pathEnv, which = Bun.which, platform = proc
   }
   for (const entry of (pathEnv ?? "").split(delimiter).filter(Boolean)) {
     for (const command of commandCandidates) {
-      addCandidate(join16(entry, command));
+      addCandidate(join18(entry, command));
     }
   }
   return candidates;
@@ -73946,7 +74204,7 @@ async function findWorkingOpencodeBinary(pathEnv = process.env.PATH, probe = can
   return null;
 }
 function buildPathWithBinaryFirst(pathEnv, binaryPath) {
-  const preferredDir = dirname7(binaryPath);
+  const preferredDir = dirname8(binaryPath);
   const existing = (pathEnv ?? "").split(delimiter).filter((entry) => entry.length > 0 && entry !== preferredDir);
   return [preferredDir, ...existing].join(delimiter);
 }
@@ -74084,7 +74342,7 @@ async function resolveSession(options) {
       if (attempt < SESSION_CREATE_MAX_RETRIES) {
         const delay = SESSION_CREATE_RETRY_DELAY_MS * attempt;
         console.log(import_picocolors11.default.dim(`  Retrying in ${delay}ms...`));
-        await new Promise((resolve2) => setTimeout(resolve2, delay));
+        await new Promise((resolve4) => setTimeout(resolve4, delay));
       }
       continue;
     }
@@ -74095,7 +74353,7 @@ async function resolveSession(options) {
     if (attempt < SESSION_CREATE_MAX_RETRIES) {
       const delay = SESSION_CREATE_RETRY_DELAY_MS * attempt;
       console.log(import_picocolors11.default.dim(`  Retrying in ${delay}ms...`));
-      await new Promise((resolve2) => setTimeout(resolve2, delay));
+      await new Promise((resolve4) => setTimeout(resolve4, delay));
     }
   }
   throw new Error("Failed to create session after all retries");
@@ -74224,10 +74482,11 @@ var normalizeAgentName = (agent) => {
     return;
   const configKey = getAgentConfigKey(trimmed);
   const displayName = getAgentDisplayName(configKey);
+  const runtimeName = getAgentRuntimeName(configKey);
   const isKnownAgent = displayName !== configKey;
   return {
     configKey,
-    resolvedName: isKnownAgent ? displayName : trimmed
+    resolvedName: isKnownAgent ? runtimeName : trimmed
   };
 };
 var isAgentDisabled = (agentConfigKey, config2) => {
@@ -74251,18 +74510,19 @@ var resolveRunAgent = (options, pluginConfig, env = process.env) => {
   const configAgent = normalizeAgentName(pluginConfig.default_run_agent);
   const resolved = cliAgent ?? envAgent ?? configAgent ?? {
     configKey: DEFAULT_AGENT,
-    resolvedName: getAgentDisplayName(DEFAULT_AGENT)
+    resolvedName: getAgentRuntimeName(DEFAULT_AGENT)
   };
   if (isAgentDisabled(resolved.configKey, pluginConfig)) {
     const fallback = pickFallbackAgent(pluginConfig);
-    const fallbackName = getAgentDisplayName(fallback);
+    const fallbackDisplayName = getAgentDisplayName(fallback);
+    const fallbackRuntimeName = getAgentRuntimeName(fallback);
     const fallbackDisabled = isAgentDisabled(fallback, pluginConfig);
     if (fallbackDisabled) {
-      console.log(import_picocolors12.default.yellow(`Requested agent "${resolved.resolvedName}" is disabled and no enabled core agent was found. Proceeding with "${fallbackName}".`));
-      return fallbackName;
+      console.log(import_picocolors12.default.yellow(`Requested agent "${resolved.resolvedName}" is disabled and no enabled core agent was found. Proceeding with "${fallbackDisplayName}".`));
+      return fallbackRuntimeName;
     }
-    console.log(import_picocolors12.default.yellow(`Requested agent "${resolved.resolvedName}" is disabled. Falling back to "${fallbackName}".`));
-    return fallbackName;
+    console.log(import_picocolors12.default.yellow(`Requested agent "${resolved.resolvedName}" is disabled. Falling back to "${fallbackDisplayName}".`));
+    return fallbackRuntimeName;
   }
   return resolved.resolvedName;
 };
@@ -74304,19 +74564,19 @@ var BOULDER_STATE_PATH = `${BOULDER_DIR}/${BOULDER_FILE}`;
 var NOTEPAD_DIR = "notepads";
 var NOTEPAD_BASE_PATH = `${BOULDER_DIR}/${NOTEPAD_DIR}`;
 // src/features/boulder-state/storage.ts
-import { existsSync as existsSync18, readFileSync as readFileSync13, writeFileSync as writeFileSync5, mkdirSync as mkdirSync7, readdirSync as readdirSync3 } from "fs";
-import { dirname as dirname8, join as join17, basename as basename4 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync14, writeFileSync as writeFileSync5, mkdirSync as mkdirSync8, readdirSync as readdirSync3 } from "fs";
+import { dirname as dirname9, join as join19, basename as basename5 } from "path";
 var RESERVED_KEYS = new Set(["__proto__", "prototype", "constructor"]);
 function getBoulderFilePath(directory) {
-  return join17(directory, BOULDER_DIR, BOULDER_FILE);
+  return join19(directory, BOULDER_DIR, BOULDER_FILE);
 }
 function readBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
-  if (!existsSync18(filePath)) {
+  if (!existsSync20(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync13(filePath, "utf-8");
+    const content = readFileSync14(filePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       return null;
@@ -74349,11 +74609,11 @@ var CHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[[xX]\]\s*(.+)$/;
 var TODO_TASK_PATTERN = /^\d+\.\s+/;
 var FINAL_WAVE_TASK_PATTERN = /^F\d+\.\s+/i;
 function getPlanProgress(planPath) {
-  if (!existsSync18(planPath)) {
+  if (!existsSync20(planPath)) {
     return { total: 0, completed: 0, isComplete: true };
   }
   try {
-    const content = readFileSync13(planPath, "utf-8");
+    const content = readFileSync14(planPath, "utf-8");
     const lines = content.split(/\r?\n/);
     const hasStructuredSections = lines.some((line) => TODO_HEADING_PATTERN.test(line) || FINAL_VERIFICATION_HEADING_PATTERN.test(line));
     if (hasStructuredSections) {
@@ -74425,17 +74685,17 @@ function getSessionAgent(sessionID) {
 // src/features/run-continuation-state/constants.ts
 var CONTINUATION_MARKER_DIR = ".sisyphus/run-continuation";
 // src/features/run-continuation-state/storage.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync8, readFileSync as readFileSync14, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync9, readFileSync as readFileSync15, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
+import { join as join20 } from "path";
 function getMarkerPath(directory, sessionID) {
-  return join18(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
+  return join20(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
 }
 function readContinuationMarker(directory, sessionID) {
   const markerPath = getMarkerPath(directory, sessionID);
-  if (!existsSync19(markerPath))
+  if (!existsSync21(markerPath))
     return null;
   try {
-    const raw = readFileSync14(markerPath, "utf-8");
+    const raw = readFileSync15(markerPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
       return null;
@@ -74496,8 +74756,8 @@ async function isSessionInBoulderLineage(input) {
 // src/hooks/atlas/session-last-agent.ts
 init_shared();
 init_compaction_marker();
-import { readFileSync as readFileSync15, readdirSync as readdirSync4 } from "fs";
-import { join as join19 } from "path";
+import { readFileSync as readFileSync16, readdirSync as readdirSync4 } from "fs";
+import { join as join21 } from "path";
 var defaultSessionLastAgentDeps = {
   getMessageDir,
   isSqliteBackend,
@@ -74545,7 +74805,7 @@ async function getLastAgentFromSession(sessionID, client3, deps = {}) {
   try {
     const messages = readdirSync4(messageDir).filter((fileName) => fileName.endsWith(".json")).map((fileName) => {
       try {
-        const content = readFileSync15(join19(messageDir, fileName), "utf-8");
+        const content = readFileSync16(join21(messageDir, fileName), "utf-8");
         const parsed = JSON.parse(content);
         return {
           fileName,
@@ -74578,8 +74838,8 @@ init_agent_display_names();
 
 // src/hooks/ralph-loop/storage.ts
 init_frontmatter();
-import { existsSync as existsSync20, readFileSync as readFileSync16, writeFileSync as writeFileSync7, unlinkSync, mkdirSync as mkdirSync9 } from "fs";
-import { dirname as dirname9, join as join20 } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync17, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, mkdirSync as mkdirSync10 } from "fs";
+import { dirname as dirname10, join as join22 } from "path";
 
 // src/hooks/ralph-loop/constants.ts
 var DEFAULT_STATE_FILE = ".sisyphus/ralph-loop.local.md";
@@ -74588,15 +74848,15 @@ var DEFAULT_COMPLETION_PROMISE = "DONE";
 
 // src/hooks/ralph-loop/storage.ts
 function getStateFilePath(directory, customPath) {
-  return customPath ? join20(directory, customPath) : join20(directory, DEFAULT_STATE_FILE);
+  return customPath ? join22(directory, customPath) : join22(directory, DEFAULT_STATE_FILE);
 }
 function readState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
-  if (!existsSync20(filePath)) {
+  if (!existsSync22(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync16(filePath, "utf-8");
+    const content = readFileSync17(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     const active = data.active;
     const iteration = data.iteration;
@@ -74805,7 +75065,7 @@ async function pollForCompletion(ctx, eventState, abortController, options = {})
   let secondaryTimeoutChecked = false;
   const pollStartTimestamp = Date.now();
   while (!abortController.signal.aborted) {
-    await new Promise((resolve2) => setTimeout(resolve2, pollIntervalMs));
+    await new Promise((resolve4) => setTimeout(resolve4, pollIntervalMs));
     if (abortController.signal.aborted) {
       return 130;
     }
@@ -74912,6 +75172,9 @@ async function getMainSessionStatus(ctx) {
       query: { directory: ctx.directory }
     });
     const statuses = normalizeSDKResponse(statusesRes, {});
+    if (!(ctx.sessionID in statuses)) {
+      return "idle";
+    }
     const status = statuses[ctx.sessionID]?.type;
     if (status === "idle" || status === "busy" || status === "retry") {
       return status;
@@ -75033,7 +75296,7 @@ var EVENT_PROCESSOR_SHUTDOWN_TIMEOUT_MS = 2000;
 async function waitForEventProcessorShutdown(eventProcessor, timeoutMs = EVENT_PROCESSOR_SHUTDOWN_TIMEOUT_MS) {
   const completed = await Promise.race([
     eventProcessor.then(() => true),
-    new Promise((resolve2) => setTimeout(() => resolve2(false), timeoutMs))
+    new Promise((resolve4) => setTimeout(() => resolve4(false), timeoutMs))
   ]);
 }
 async function run(options) {
@@ -75361,30 +75624,61 @@ async function getLocalVersion(options = {}) {
   }
 }
 // src/cli/doctor/checks/system.ts
-import { existsSync as existsSync31, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync33, readFileSync as readFileSync27 } from "fs";
 
 // src/cli/doctor/checks/system-binary.ts
+import { existsSync as existsSync30 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join29 } from "path";
+
+// src/cli/doctor/spawn-with-timeout.ts
 init_spawn_with_windows_hide();
-import { existsSync as existsSync28 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join27 } from "path";
+var DEFAULT_SPAWN_TIMEOUT_MS = 1e4;
+async function spawnWithTimeout(command, options, timeoutMs = DEFAULT_SPAWN_TIMEOUT_MS) {
+  let proc;
+  try {
+    proc = spawnWithWindowsHide(command, options);
+  } catch {
+    return { stdout: "", stderr: "", exitCode: 1, timedOut: false };
+  }
+  let timer;
+  const timeoutPromise = new Promise((resolve4) => {
+    timer = setTimeout(() => resolve4("timeout"), timeoutMs);
+  });
+  const processPromise = (async () => {
+    await proc.exited;
+    return "done";
+  })();
+  const race = await Promise.race([processPromise, timeoutPromise]);
+  if (race === "timeout") {
+    proc.kill("SIGTERM");
+    await proc.exited.catch(() => {});
+    return { stdout: "", stderr: "", exitCode: 1, timedOut: true };
+  }
+  clearTimeout(timer);
+  const stdout = proc.stdout ? await new Response(proc.stdout).text() : "";
+  const stderr = proc.stderr ? await new Response(proc.stderr).text() : "";
+  return { stdout, stderr, exitCode: proc.exitCode ?? 1, timedOut: false };
+}
+
+// src/cli/doctor/checks/system-binary.ts
 function getDesktopAppPaths(platform) {
-  const home = homedir5();
+  const home = homedir6();
   switch (platform) {
     case "darwin":
       return [
         "/Applications/OpenCode.app/Contents/MacOS/OpenCode",
-        join27(home, "Applications", "OpenCode.app", "Contents", "MacOS", "OpenCode")
+        join29(home, "Applications", "OpenCode.app", "Contents", "MacOS", "OpenCode")
       ];
     case "win32": {
       const programFiles = process.env.ProgramFiles;
       const localAppData = process.env.LOCALAPPDATA;
       const paths = [];
       if (programFiles) {
-        paths.push(join27(programFiles, "OpenCode", "OpenCode.exe"));
+        paths.push(join29(programFiles, "OpenCode", "OpenCode.exe"));
       }
       if (localAppData) {
-        paths.push(join27(localAppData, "OpenCode", "OpenCode.exe"));
+        paths.push(join29(localAppData, "OpenCode", "OpenCode.exe"));
       }
       return paths;
     }
@@ -75392,8 +75686,8 @@ function getDesktopAppPaths(platform) {
       return [
         "/usr/bin/opencode",
         "/usr/lib/opencode/opencode",
-        join27(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
-        join27(home, "Applications", "opencode-desktop-linux-aarch64.AppImage")
+        join29(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
+        join29(home, "Applications", "opencode-desktop-linux-aarch64.AppImage")
       ];
     default:
       return [];
@@ -75405,7 +75699,7 @@ function buildVersionCommand(binaryPath, platform) {
   }
   return [binaryPath, "--version"];
 }
-function findDesktopBinary(platform = process.platform, checkExists = existsSync28) {
+function findDesktopBinary(platform = process.platform, checkExists = existsSync30) {
   for (const desktopPath of getDesktopAppPaths(platform)) {
     if (checkExists(desktopPath)) {
       return { binary: "opencode", path: desktopPath };
@@ -75415,9 +75709,9 @@ function findDesktopBinary(platform = process.platform, checkExists = existsSync
 }
 async function findOpenCodeBinary() {
   for (const binary2 of OPENCODE_BINARIES2) {
-    const path11 = Bun.which(binary2);
-    if (path11) {
-      return { binary: binary2, path: path11 };
+    const path12 = Bun.which(binary2);
+    if (path12) {
+      return { binary: binary2, path: path12 };
     }
   }
   return findDesktopBinary();
@@ -75425,12 +75719,10 @@ async function findOpenCodeBinary() {
 async function getOpenCodeVersion3(binaryPath, platform = process.platform) {
   try {
     const command = buildVersionCommand(binaryPath, platform);
-    const processResult = spawnWithWindowsHide(command, { stdout: "pipe", stderr: "pipe" });
-    const output = await new Response(processResult.stdout).text();
-    await processResult.exited;
-    if (processResult.exitCode !== 0)
+    const result = await spawnWithTimeout(command, { stdout: "pipe", stderr: "pipe" });
+    if (result.timedOut || result.exitCode !== 0)
       return null;
-    return output.trim() || null;
+    return result.stdout.trim() || null;
   } catch {
     return null;
   }
@@ -75453,12 +75745,12 @@ function compareVersions3(current, minimum) {
 
 // src/cli/doctor/checks/system-plugin.ts
 init_shared();
-import { existsSync as existsSync29, readFileSync as readFileSync24 } from "fs";
+import { existsSync as existsSync31, readFileSync as readFileSync25 } from "fs";
 function detectConfigPath() {
   const paths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
-  if (existsSync29(paths.configJsonc))
+  if (existsSync31(paths.configJsonc))
     return paths.configJsonc;
-  if (existsSync29(paths.configJson))
+  if (existsSync31(paths.configJson))
     return paths.configJson;
   return null;
 }
@@ -75504,7 +75796,7 @@ function getPluginInfo() {
     };
   }
   try {
-    const content = readFileSync24(configPath, "utf-8");
+    const content = readFileSync25(configPath, "utf-8");
     const parsedConfig = parseJsonc(content);
     const pluginEntry = findPluginEntry2(parsedConfig.plugin ?? []);
     if (!pluginEntry) {
@@ -75542,37 +75834,37 @@ function getPluginInfo() {
 init_file_utils();
 init_checker();
 init_auto_update_checker();
-import { existsSync as existsSync30, readFileSync as readFileSync25 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join28 } from "path";
+import { existsSync as existsSync32, readFileSync as readFileSync26 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join30 } from "path";
 init_shared();
 function getPlatformDefaultCacheDir(platform = process.platform) {
   if (platform === "darwin")
-    return join28(homedir6(), "Library", "Caches");
+    return join30(homedir7(), "Library", "Caches");
   if (platform === "win32")
-    return process.env.LOCALAPPDATA ?? join28(homedir6(), "AppData", "Local");
-  return join28(homedir6(), ".cache");
+    return process.env.LOCALAPPDATA ?? join30(homedir7(), "AppData", "Local");
+  return join30(homedir7(), ".cache");
 }
 function resolveOpenCodeCacheDir() {
   const xdgCacheHome = process.env.XDG_CACHE_HOME;
   if (xdgCacheHome)
-    return join28(xdgCacheHome, "opencode");
+    return join30(xdgCacheHome, "opencode");
   const fromShared = getOpenCodeCacheDir();
-  const platformDefault = join28(getPlatformDefaultCacheDir(), "opencode");
-  if (existsSync30(fromShared) || !existsSync30(platformDefault))
+  const platformDefault = join30(getPlatformDefaultCacheDir(), "opencode");
+  if (existsSync32(fromShared) || !existsSync32(platformDefault))
     return fromShared;
   return platformDefault;
 }
 function resolveExistingDir(dirPath) {
-  if (!existsSync30(dirPath))
+  if (!existsSync32(dirPath))
     return dirPath;
   return resolveSymlink(dirPath);
 }
 function readPackageJson(filePath) {
-  if (!existsSync30(filePath))
+  if (!existsSync32(filePath))
     return null;
   try {
-    const content = readFileSync25(filePath, "utf-8");
+    const content = readFileSync26(filePath, "utf-8");
     return parseJsonc(content);
   } catch {
     return null;
@@ -75587,11 +75879,11 @@ function normalizeVersion(value) {
 function createPackageCandidates(rootDir) {
   return ACCEPTED_PACKAGE_NAMES.map((packageName) => ({
     packageName,
-    installedPackagePath: join28(rootDir, "node_modules", packageName, "package.json")
+    installedPackagePath: join30(rootDir, "node_modules", packageName, "package.json")
   }));
 }
 function selectInstalledPackage(candidate) {
-  return candidate.packageCandidates.find((packageCandidate) => existsSync30(packageCandidate.installedPackagePath)) ?? candidate.packageCandidates[0];
+  return candidate.packageCandidates.find((packageCandidate) => existsSync32(packageCandidate.installedPackagePath)) ?? candidate.packageCandidates[0];
 }
 function getExpectedVersion(cachePackage, packageName) {
   return normalizeVersion(cachePackage?.dependencies?.[packageName]) ?? normalizeVersion(cachePackage?.dependencies?.[PACKAGE_NAME]);
@@ -75603,16 +75895,16 @@ function getLoadedPluginVersion() {
   const candidates = [
     {
       cacheDir: configDir,
-      cachePackagePath: join28(configDir, "package.json"),
+      cachePackagePath: join30(configDir, "package.json"),
       packageCandidates: createPackageCandidates(configDir)
     },
     {
       cacheDir,
-      cachePackagePath: join28(cacheDir, "package.json"),
+      cachePackagePath: join30(cacheDir, "package.json"),
       packageCandidates: createPackageCandidates(cacheDir)
     }
   ];
-  const selectedCandidate = candidates.find((candidate) => candidate.packageCandidates.some((packageCandidate) => existsSync30(packageCandidate.installedPackagePath))) ?? candidates[0];
+  const selectedCandidate = candidates.find((candidate) => candidate.packageCandidates.some((packageCandidate) => existsSync32(packageCandidate.installedPackagePath))) ?? candidates[0];
   const { cacheDir: selectedDir, cachePackagePath } = selectedCandidate;
   const selectedPackage = selectInstalledPackage(selectedCandidate);
   const installedPackagePath = selectedPackage.installedPackagePath;
@@ -75651,10 +75943,10 @@ var defaultDeps3 = {
 function isConfigValid(configPath) {
   if (!configPath)
     return true;
-  if (!existsSync31(configPath))
+  if (!existsSync33(configPath))
     return false;
   try {
-    parseJsonc(readFileSync26(configPath, "utf-8"));
+    parseJsonc(readFileSync27(configPath, "utf-8"));
     return true;
   } catch {
     return false;
@@ -75776,32 +76068,32 @@ async function checkSystem(deps = defaultDeps3) {
 }
 
 // src/cli/doctor/checks/config.ts
-import { readFileSync as readFileSync29 } from "fs";
-import { join as join32 } from "path";
+import { readFileSync as readFileSync30 } from "fs";
+import { join as join34 } from "path";
 init_shared();
 
 // src/cli/doctor/checks/model-resolution-cache.ts
 init_shared();
-import { existsSync as existsSync32, readFileSync as readFileSync27 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join29 } from "path";
+import { existsSync as existsSync34, readFileSync as readFileSync28 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join31 } from "path";
 function getUserConfigDir2() {
   const xdgConfig = process.env.XDG_CONFIG_HOME;
   if (xdgConfig)
-    return join29(xdgConfig, "opencode");
-  return join29(homedir7(), ".config", "opencode");
+    return join31(xdgConfig, "opencode");
+  return join31(homedir8(), ".config", "opencode");
 }
 function loadCustomProviderNames() {
   const configDir = getUserConfigDir2();
   const candidatePaths = [
-    join29(configDir, "opencode.json"),
-    join29(configDir, "opencode.jsonc")
+    join31(configDir, "opencode.json"),
+    join31(configDir, "opencode.jsonc")
   ];
   for (const configPath of candidatePaths) {
-    if (!existsSync32(configPath))
+    if (!existsSync34(configPath))
       continue;
     try {
-      const content = readFileSync27(configPath, "utf-8");
+      const content = readFileSync28(configPath, "utf-8");
       const data = parseJsonc(content);
       if (data?.provider && typeof data.provider === "object") {
         return Object.keys(data.provider);
@@ -75811,16 +76103,16 @@ function loadCustomProviderNames() {
   return [];
 }
 function loadAvailableModelsFromCache() {
-  const cacheFile = join29(getOpenCodeCacheDir(), "models.json");
+  const cacheFile = join31(getOpenCodeCacheDir(), "models.json");
   const customProviders = loadCustomProviderNames();
-  if (!existsSync32(cacheFile)) {
+  if (!existsSync34(cacheFile)) {
     if (customProviders.length > 0) {
       return { providers: customProviders, modelCount: 0, cacheExists: true };
     }
     return { providers: [], modelCount: 0, cacheExists: false };
   }
   try {
-    const content = readFileSync27(cacheFile, "utf-8");
+    const content = readFileSync28(cacheFile, "utf-8");
     const data = parseJsonc(content);
     const cacheProviders = Object.keys(data);
     let modelCount = 0;
@@ -75843,14 +76135,14 @@ init_model_capabilities();
 
 // src/cli/doctor/checks/model-resolution-config.ts
 init_shared();
-import { readFileSync as readFileSync28 } from "fs";
-import { join as join30 } from "path";
-var PROJECT_CONFIG_DIR = join30(process.cwd(), ".opencode");
+import { readFileSync as readFileSync29 } from "fs";
+import { join as join32 } from "path";
+var PROJECT_CONFIG_DIR = join32(process.cwd(), ".opencode");
 function loadOmoConfig() {
   const projectDetected = detectPluginConfigFile(PROJECT_CONFIG_DIR);
   if (projectDetected.format !== "none") {
     try {
-      const content = readFileSync28(projectDetected.path, "utf-8");
+      const content = readFileSync29(projectDetected.path, "utf-8");
       return parseJsonc(content);
     } catch {
       return null;
@@ -75860,7 +76152,7 @@ function loadOmoConfig() {
   const userDetected = detectPluginConfigFile(userConfigDir);
   if (userDetected.format !== "none") {
     try {
-      const content = readFileSync28(userDetected.path, "utf-8");
+      const content = readFileSync29(userDetected.path, "utf-8");
       return parseJsonc(content);
     } catch {
       return null;
@@ -75871,7 +76163,7 @@ function loadOmoConfig() {
 
 // src/cli/doctor/checks/model-resolution-details.ts
 init_shared();
-import { join as join31 } from "path";
+import { join as join33 } from "path";
 
 // src/cli/doctor/checks/model-resolution-variant.ts
 function formatModelWithVariant(model, variant) {
@@ -75913,7 +76205,7 @@ function formatCapabilityResolutionLabel(mode) {
 }
 function buildModelResolutionDetails(options) {
   const details = [];
-  const cacheFile = join31(getOpenCodeCacheDir(), "models.json");
+  const cacheFile = join33(getOpenCodeCacheDir(), "models.json");
   details.push("\u2550\u2550\u2550 Available Models (from cache) \u2550\u2550\u2550");
   details.push("");
   if (options.available.cacheExists) {
@@ -76068,7 +76360,7 @@ async function checkModels() {
 }
 
 // src/cli/doctor/checks/config.ts
-var PROJECT_CONFIG_DIR2 = join32(process.cwd(), ".opencode");
+var PROJECT_CONFIG_DIR2 = join34(process.cwd(), ".opencode");
 function findConfigPath() {
   const projectConfig = detectPluginConfigFile(PROJECT_CONFIG_DIR2);
   if (projectConfig.format !== "none")
@@ -76085,7 +76377,7 @@ function validateConfig() {
     return { exists: false, path: null, valid: true, config: null, errors: [] };
   }
   try {
-    const content = readFileSync29(configPath, "utf-8");
+    const content = readFileSync30(configPath, "utf-8");
     const rawConfig = parseJsonc(content);
     const schemaResult = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
     if (!schemaResult.success) {
@@ -76188,30 +76480,55 @@ async function checkConfig() {
 }
 
 // src/cli/doctor/checks/dependencies.ts
-init_spawn_with_windows_hide();
-import { existsSync as existsSync33 } from "fs";
+import { existsSync as existsSync35 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname13, join as join33 } from "path";
+import { dirname as dirname14, join as join36 } from "path";
+
+// src/hooks/comment-checker/downloader.ts
+import { join as join35 } from "path";
+import { homedir as homedir9, tmpdir as tmpdir3 } from "os";
+init_binary_downloader();
+init_logger();
+init_plugin_identity();
+var DEBUG = process.env.COMMENT_CHECKER_DEBUG === "1";
+var DEBUG_FILE = join35(tmpdir3(), "comment-checker-debug.log");
+function getCacheDir2() {
+  if (process.platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
+    const base2 = localAppData || join35(homedir9(), "AppData", "Local");
+    return join35(base2, CACHE_DIR_NAME, "bin");
+  }
+  const xdgCache = process.env.XDG_CACHE_HOME;
+  const base = xdgCache || join35(homedir9(), ".cache");
+  return join35(base, CACHE_DIR_NAME, "bin");
+}
+function getBinaryName() {
+  return process.platform === "win32" ? "comment-checker.exe" : "comment-checker";
+}
+function getCachedBinaryPath2() {
+  return getCachedBinaryPath(getCacheDir2(), getBinaryName());
+}
+
+// src/cli/doctor/checks/dependencies.ts
 async function checkBinaryExists(binary2) {
   try {
-    const path11 = Bun.which(binary2);
-    if (path11) {
-      return { exists: true, path: path11 };
+    const path12 = Bun.which(binary2);
+    if (path12) {
+      return { exists: true, path: path12 };
     }
   } catch {}
   return { exists: false, path: null };
 }
 async function getBinaryVersion(binary2) {
   try {
-    const proc = spawnWithWindowsHide([binary2, "--version"], { stdout: "pipe", stderr: "pipe" });
-    const output = await new Response(proc.stdout).text();
-    await proc.exited;
-    if (proc.exitCode === 0) {
-      return output.trim().split(`
-`)[0];
-    }
-  } catch {}
-  return null;
+    const result = await spawnWithTimeout([binary2, "--version"], { stdout: "pipe", stderr: "pipe" });
+    if (result.timedOut || result.exitCode !== 0)
+      return null;
+    return result.stdout.trim().split(`
+`)[0] ?? null;
+  } catch {
+    return null;
+  }
 }
 async function checkAstGrepCli() {
   const binaryCheck = await checkBinaryExists("sg");
@@ -76247,15 +76564,15 @@ async function checkAstGrepNapi() {
       path: null
     };
   } catch {
-    const { existsSync: existsSync34 } = await import("fs");
-    const { join: join34 } = await import("path");
-    const { homedir: homedir8 } = await import("os");
+    const { existsSync: existsSync36 } = await import("fs");
+    const { join: join37 } = await import("path");
+    const { homedir: homedir10 } = await import("os");
     const pathsToCheck = [
-      join34(homedir8(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
-      join34(process.cwd(), "node_modules", "@ast-grep", "napi")
+      join37(homedir10(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
+      join37(process.cwd(), "node_modules", "@ast-grep", "napi")
     ];
     for (const napiPath of pathsToCheck) {
-      if (existsSync34(napiPath)) {
+      if (existsSync36(napiPath)) {
         return {
           name: "AST-Grep NAPI",
           required: false,
@@ -76280,13 +76597,24 @@ function findCommentCheckerPackageBinary() {
   try {
     const require2 = createRequire(import.meta.url);
     const pkgPath = require2.resolve("@code-yeongyu/comment-checker/package.json");
-    const binaryPath = join33(dirname13(pkgPath), "bin", binaryName);
-    if (existsSync33(binaryPath))
+    const binaryPath = join36(dirname14(pkgPath), "bin", binaryName);
+    if (existsSync35(binaryPath))
       return binaryPath;
   } catch {}
   return null;
 }
 async function checkCommentChecker() {
+  const cachedPath = getCachedBinaryPath2();
+  if (cachedPath) {
+    const version4 = await getBinaryVersion(cachedPath);
+    return {
+      name: "Comment Checker",
+      required: false,
+      installed: true,
+      version: version4,
+      path: cachedPath
+    };
+  }
   const binaryCheck = await checkBinaryExists("comment-checker");
   const resolvedPath = binaryCheck.exists ? binaryCheck.path : findCommentCheckerPackageBinary();
   if (!resolvedPath) {
@@ -76310,7 +76638,6 @@ async function checkCommentChecker() {
 }
 
 // src/cli/doctor/checks/tools-gh.ts
-init_spawn_with_windows_hide();
 async function checkBinaryExists2(binary2) {
   try {
     const binaryPath = Bun.which(binary2);
@@ -76321,13 +76648,11 @@ async function checkBinaryExists2(binary2) {
 }
 async function getGhVersion() {
   try {
-    const processResult = spawnWithWindowsHide(["gh", "--version"], { stdout: "pipe", stderr: "pipe" });
-    const output = await new Response(processResult.stdout).text();
-    await processResult.exited;
-    if (processResult.exitCode !== 0)
+    const result = await spawnWithTimeout(["gh", "--version"], { stdout: "pipe", stderr: "pipe" });
+    if (result.timedOut || result.exitCode !== 0)
       return null;
-    const matchedVersion = output.match(/gh version (\S+)/);
-    return matchedVersion?.[1] ?? output.trim().split(`
+    const matchedVersion = result.stdout.match(/gh version (\S+)/);
+    return matchedVersion?.[1] ?? result.stdout.trim().split(`
 `)[0] ?? null;
   } catch {
     return null;
@@ -76335,16 +76660,12 @@ async function getGhVersion() {
 }
 async function getGhAuthStatus() {
   try {
-    const processResult = spawnWithWindowsHide(["gh", "auth", "status"], {
-      stdout: "pipe",
-      stderr: "pipe",
-      env: { ...process.env, GH_NO_UPDATE_NOTIFIER: "1" }
-    });
-    const stdout = await new Response(processResult.stdout).text();
-    const stderr = await new Response(processResult.stderr).text();
-    await processResult.exited;
-    const output = stderr || stdout;
-    if (processResult.exitCode === 0) {
+    const result = await spawnWithTimeout(["gh", "auth", "status"], { stdout: "pipe", stderr: "pipe", env: { ...process.env, GH_NO_UPDATE_NOTIFIER: "1" } });
+    if (result.timedOut) {
+      return { authenticated: false, username: null, scopes: [], error: "gh auth status timed out" };
+    }
+    const output = result.stderr || result.stdout;
+    if (result.exitCode === 0) {
       const usernameMatch = output.match(/Logged in to github\.com account (\S+)/);
       const scopesMatch = output.match(/Token scopes?:\s*(.+)/i);
       return {
@@ -76438,15 +76759,15 @@ var BUILTIN_SERVERS = {
   "kotlin-ls": { command: ["kotlin-lsp"], extensions: [".kt", ".kts"] }
 };
 // src/tools/lsp/server-config-loader.ts
-import { existsSync as existsSync34, readFileSync as readFileSync30 } from "fs";
-import { join as join34 } from "path";
+import { existsSync as existsSync36, readFileSync as readFileSync31 } from "fs";
+import { join as join37 } from "path";
 init_shared();
 init_jsonc_parser();
-function loadJsonFile(path11) {
-  if (!existsSync34(path11))
+function loadJsonFile(path12) {
+  if (!existsSync36(path12))
     return null;
   try {
-    return parseJsonc(readFileSync30(path11, "utf-8"));
+    return parseJsonc(readFileSync31(path12, "utf-8"));
   } catch {
     return null;
   }
@@ -76455,9 +76776,9 @@ function getConfigPaths2() {
   const cwd = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   return {
-    project: detectPluginConfigFile(join34(cwd, ".opencode")).path,
+    project: detectPluginConfigFile(join37(cwd, ".opencode")).path,
     user: detectPluginConfigFile(configDir).path,
-    opencode: detectConfigFile(join34(configDir, "opencode")).path
+    opencode: detectConfigFile(join37(configDir, "opencode")).path
   };
 }
 function loadAllConfigs() {
@@ -76526,21 +76847,21 @@ function getMergedServers() {
 }
 
 // src/tools/lsp/server-installation.ts
-import { existsSync as existsSync35 } from "fs";
-import { delimiter as delimiter2, join as join36 } from "path";
+import { existsSync as existsSync37 } from "fs";
+import { delimiter as delimiter2, join as join39 } from "path";
 
 // src/tools/lsp/server-path-bases.ts
 init_shared();
-import { join as join35 } from "path";
+import { join as join38 } from "path";
 function getLspServerAdditionalPathBases(workingDirectory) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join35(getDataDir(), "opencode");
+  const dataDir = join38(getDataDir(), "opencode");
   return [
-    join35(workingDirectory, "node_modules", ".bin"),
-    join35(configDir, "bin"),
-    join35(configDir, "node_modules", ".bin"),
-    join35(dataDir, "bin"),
-    join35(dataDir, "bin", "node_modules", ".bin")
+    join38(workingDirectory, "node_modules", ".bin"),
+    join38(configDir, "bin"),
+    join38(configDir, "node_modules", ".bin"),
+    join38(dataDir, "bin"),
+    join38(dataDir, "bin", "node_modules", ".bin")
   ];
 }
 
@@ -76550,7 +76871,7 @@ function isServerInstalled(command) {
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync35(cmd))
+    if (existsSync37(cmd))
       return true;
   }
   const isWindows = process.platform === "win32";
@@ -76571,14 +76892,14 @@ function isServerInstalled(command) {
   const paths = pathEnv.split(delimiter2);
   for (const p2 of paths) {
     for (const suffix of exts) {
-      if (existsSync35(join36(p2, cmd + suffix))) {
+      if (existsSync37(join39(p2, cmd + suffix))) {
         return true;
       }
     }
   }
   for (const base of getLspServerAdditionalPathBases(process.cwd())) {
     for (const suffix of exts) {
-      if (existsSync35(join36(base, cmd + suffix))) {
+      if (existsSync37(join39(base, cmd + suffix))) {
         return true;
       }
     }
@@ -76640,24 +76961,24 @@ function getInstalledLspServers() {
 
 // src/cli/doctor/checks/tools-mcp.ts
 init_shared();
-import { existsSync as existsSync36, readFileSync as readFileSync31 } from "fs";
-import { homedir as homedir8 } from "os";
-import { join as join37 } from "path";
+import { existsSync as existsSync38, readFileSync as readFileSync32 } from "fs";
+import { homedir as homedir10 } from "os";
+import { join as join40 } from "path";
 var BUILTIN_MCP_SERVERS = ["context7", "grep_app"];
 function getMcpConfigPaths() {
   return [
-    join37(homedir8(), ".claude", ".mcp.json"),
-    join37(process.cwd(), ".mcp.json"),
-    join37(process.cwd(), ".claude", ".mcp.json")
+    join40(homedir10(), ".claude", ".mcp.json"),
+    join40(process.cwd(), ".mcp.json"),
+    join40(process.cwd(), ".claude", ".mcp.json")
   ];
 }
 function loadUserMcpConfig() {
   const servers = {};
   for (const configPath of getMcpConfigPaths()) {
-    if (!existsSync36(configPath))
+    if (!existsSync38(configPath))
       continue;
     try {
-      const content = readFileSync31(configPath, "utf-8");
+      const content = readFileSync32(configPath, "utf-8");
       const config2 = parseJsonc(content);
       if (config2.mcpServers) {
         Object.assign(servers, config2.mcpServers);
@@ -77017,6 +77338,14 @@ function formatJsonOutput2(result) {
 }
 
 // src/cli/doctor/runner.ts
+var DOCTOR_TIMEOUT_MS = 30000;
+
+class DoctorTimeoutError extends Error {
+  constructor() {
+    super("Doctor timed out");
+    this.name = "DoctorTimeoutError";
+  }
+}
 async function runCheck(check2) {
   const start = performance.now();
   try {
@@ -77046,14 +77375,49 @@ function calculateSummary(results, duration3) {
 function determineExitCode(results) {
   return results.some((r2) => r2.status === "fail") ? EXIT_CODES.FAILURE : EXIT_CODES.SUCCESS;
 }
+function buildTimeoutResult(start, options) {
+  const timeoutResult = {
+    results: [{ name: "Timeout", status: "fail", message: "Doctor timed out after 30s", issues: [{ title: "Doctor timeout", description: "Checks did not complete within 30s. A subprocess may be hanging.", severity: "error" }] }],
+    systemInfo: { opencodeVersion: null, opencodePath: null, pluginVersion: null, loadedVersion: null, bunVersion: null, configPath: null, configValid: false, isLocalDev: false },
+    tools: { lspServers: [], astGrepCli: false, astGrepNapi: false, commentChecker: false, ghCli: { installed: false, authenticated: false, username: null }, mcpBuiltin: [], mcpUser: [] },
+    summary: { total: 1, passed: 0, failed: 1, warnings: 0, skipped: 0, duration: Math.round(performance.now() - start) },
+    exitCode: EXIT_CODES.FAILURE
+  };
+  if (options.json) {
+    console.log(formatJsonOutput2(timeoutResult));
+  } else {
+    console.error(`
+Doctor timed out after 30s. A subprocess may be hanging.`);
+    console.error(`Try running with --verbose to identify the stuck check.
+`);
+  }
+  return timeoutResult;
+}
 async function runDoctor(options) {
   const start = performance.now();
   const allChecks = getAllCheckDefinitions();
-  const [results, systemInfo, tools] = await Promise.all([
+  const checksPromise = Promise.all([
     Promise.all(allChecks.map(runCheck)),
     gatherSystemInfo(),
     gatherToolsSummary()
   ]);
+  let timer;
+  const timeoutPromise = new Promise((_3, reject) => {
+    timer = setTimeout(() => reject(new DoctorTimeoutError), DOCTOR_TIMEOUT_MS);
+  });
+  let results;
+  let systemInfo;
+  let tools;
+  try {
+    [results, systemInfo, tools] = await Promise.race([checksPromise, timeoutPromise]);
+  } catch (error48) {
+    clearTimeout(timer);
+    if (error48 instanceof DoctorTimeoutError) {
+      return buildTimeoutResult(start, options);
+    }
+    throw error48;
+  }
+  clearTimeout(timer);
   const duration3 = performance.now() - start;
   const summary = calculateSummary(results, duration3);
   const exitCode = determineExitCode(results);
@@ -77112,11 +77476,11 @@ async function refreshModelCapabilities(options, deps = {}) {
 
 // src/features/mcp-oauth/storage.ts
 init_shared();
-import { chmodSync, existsSync as existsSync37, mkdirSync as mkdirSync11, readFileSync as readFileSync32, renameSync as renameSync4, unlinkSync as unlinkSync4, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname14, join as join38 } from "path";
+import { chmodSync as chmodSync2, existsSync as existsSync39, mkdirSync as mkdirSync12, readFileSync as readFileSync33, renameSync as renameSync4, unlinkSync as unlinkSync6, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname15, join as join41 } from "path";
 var STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStoragePath() {
-  return join38(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
+  return join41(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
 }
 function normalizeHost(serverHost) {
   let host = serverHost.trim();
@@ -77153,11 +77517,11 @@ function buildKey(serverHost, resource) {
 }
 function readStore() {
   const filePath = getMcpOauthStoragePath();
-  if (!existsSync37(filePath)) {
+  if (!existsSync39(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync32(filePath, "utf-8");
+    const content = readFileSync33(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -77166,13 +77530,13 @@ function readStore() {
 function writeStore(store2) {
   const filePath = getMcpOauthStoragePath();
   try {
-    const dir = dirname14(filePath);
-    if (!existsSync37(dir)) {
-      mkdirSync11(dir, { recursive: true });
+    const dir = dirname15(filePath);
+    if (!existsSync39(dir)) {
+      mkdirSync12(dir, { recursive: true });
     }
     const tempPath = `${filePath}.tmp.${Date.now()}`;
     writeFileSync10(tempPath, JSON.stringify(store2, null, 2), { encoding: "utf-8", mode: 384 });
-    chmodSync(tempPath, 384);
+    chmodSync2(tempPath, 384);
     renameSync4(tempPath, filePath);
     return true;
   } catch {
@@ -77204,8 +77568,8 @@ function deleteToken(serverHost, resource) {
   if (Object.keys(store2).length === 0) {
     try {
       const filePath = getMcpOauthStoragePath();
-      if (existsSync37(filePath)) {
-        unlinkSync4(filePath);
+      if (existsSync39(filePath)) {
+        unlinkSync6(filePath);
       }
       return true;
     } catch {
@@ -77424,7 +77788,7 @@ function buildAuthorizationUrl(authorizationEndpoint, options) {
 }
 var CALLBACK_TIMEOUT_MS = 5 * 60 * 1000;
 function startCallbackServer(port) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     let timeoutId;
     const server2 = createServer((request, response) => {
       clearTimeout(timeoutId);
@@ -77450,7 +77814,7 @@ function startCallbackServer(port) {
       response.writeHead(200, { "content-type": "text/html" });
       response.end("<html><body><h1>Authorization successful. You can close this tab.</h1></body></html>");
       server2.close();
-      resolve2({ code, state: state2 });
+      resolve4({ code, state: state2 });
     });
     timeoutId = setTimeout(() => {
       server2.close();
@@ -77787,20 +78151,21 @@ function createMcpOAuthCommand() {
 var VERSION2 = package_default.version;
 var program2 = new Command;
 program2.name("evil-omo").description("The ultimate OpenCode plugin - multi-model orchestration, LSP tools, and more").version(VERSION2, "-v, --version", "Show version number").enablePositionalOptions();
-program2.command("install").description("Install and configure evil-omo with interactive setup").option("--no-tui", "Run in non-interactive mode (requires all options)").option("--claude <value>", "Claude subscription: no, yes, max20").option("--openai <value>", "OpenAI/ChatGPT subscription: no, yes (default: no)").option("--gemini <value>", "Gemini integration: no, yes").option("--copilot <value>", "GitHub Copilot subscription: no, yes").option("--opencode-zen <value>", "OpenCode Zen access: no, yes (default: no)").option("--zai-coding-plan <value>", "Z.ai Coding Plan subscription: no, yes (default: no)").option("--kimi-for-coding <value>", "Kimi For Coding subscription: no, yes (default: no)").option("--opencode-go <value>", "OpenCode Go subscription: no, yes (default: no)").option("--skip-auth", "Skip authentication setup hints").addHelpText("after", `
+program2.command("install").description("Install and configure evil-omo with interactive setup").option("--no-tui", "Run in non-interactive mode (requires all options)").option("--claude <value>", "Claude subscription: no, yes, max20").option("--openai <value>", "OpenAI/ChatGPT subscription: no, yes (default: no)").option("--gemini <value>", "Gemini integration: no, yes").option("--copilot <value>", "GitHub Copilot subscription: no, yes").option("--opencode-zen <value>", "OpenCode Zen access: no, yes (default: no)").option("--zai-coding-plan <value>", "Z.ai Coding Plan subscription: no, yes (default: no)").option("--kimi-for-coding <value>", "Kimi For Coding subscription: no, yes (default: no)").option("--opencode-go <value>", "OpenCode Go subscription: no, yes (default: no)").option("--vercel-ai-gateway <value>", "Vercel AI Gateway: no, yes (default: no)").option("--skip-auth", "Skip authentication setup hints").addHelpText("after", `
 Examples:
   $ bunx evil-omo install
   $ bunx evil-omo install --no-tui --claude=max20 --openai=yes --gemini=yes --copilot=no
   $ bunx evil-omo install --no-tui --claude=no --gemini=no --copilot=yes --opencode-zen=yes
 
-Model Providers (Priority: Native > Copilot > OpenCode Zen > Z.ai > Kimi):
+Model Providers (Priority: Native > Copilot > OpenCode Zen > Z.ai > Kimi > Vercel):
   Claude        Native anthropic/ models (Opus, Sonnet, Haiku)
   OpenAI        Native openai/ models (GPT-5.4 for Oracle)
   Gemini        Native google/ models (Gemini 3.1 Pro, Flash)
   Copilot       github-copilot/ models (fallback)
   OpenCode Zen  opencode/ models (opencode/claude-opus-4-6, etc.)
-   Z.ai          zai-coding-plan/glm-5 (visual-engineering fallback)
+  Z.ai          zai-coding-plan/glm-5 (visual-engineering fallback)
   Kimi          kimi-for-coding/k2p5 (Sisyphus/Prometheus fallback)
+  Vercel        vercel/ models (universal proxy, always last fallback)
 `).action(async (options) => {
   const args = {
     tui: options.tui !== false,
@@ -77812,6 +78177,7 @@ Model Providers (Priority: Native > Copilot > OpenCode Zen > Z.ai > Kimi):
     zaiCodingPlan: options.zaiCodingPlan,
     kimiForCoding: options.kimiForCoding,
     opencodeGo: options.opencodeGo,
+    vercelAiGateway: options.vercelAiGateway,
     skipAuth: options.skipAuth ?? false
   };
   const exitCode = await install(args);