oh-my-opencode 3.17.0 → 3.17.2

package/dist/cli/index.js

@@ -5036,7 +5036,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)) {
@@ -5044,7 +5044,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) {
@@ -6049,20 +6049,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",
@@ -6160,7 +6166,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");
@@ -6170,7 +6176,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 = () => {};
 
@@ -6591,6 +6608,12 @@ var init_zip_extractor = __esm(() => {
 });
 
 // src/shared/binary-downloader.ts
+import { chmodSync, existsSync as existsSync5, mkdirSync as mkdirSync3, unlinkSync as unlinkSync2 } from "fs";
+import * as path4 from "path";
+function getCachedBinaryPath(cacheDir, binaryName) {
+  const binaryPath = path4.join(cacheDir, binaryName);
+  return existsSync5(binaryPath) ? binaryPath : null;
+}
 var init_binary_downloader = __esm(() => {
   init_archive_entry_validator();
   init_zip_extractor();
@@ -6603,11 +6626,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: [
@@ -6616,12 +6639,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
@@ -6629,73 +6653,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"
         }
       ]
@@ -6703,61 +6727,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" }
       ]
     }
@@ -6766,54 +6790,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"
         }
@@ -6822,72 +6846,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",
@@ -6895,7 +6919,8 @@ var init_model_requirements = __esm(() => {
             "moonshotai-cn",
             "firmware",
             "ollama-cloud",
-            "aihubmix"
+            "aihubmix",
+            "vercel"
           ],
           model: "kimi-k2.5"
         }
@@ -6904,15 +6929,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" }
       ]
     }
   };
@@ -6956,20 +6981,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 existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join7 } from "path";
 function toLogLabel(cacheLabel) {
   return cacheLabel.toLowerCase();
 }
 function createJsonFileCacheStore(options) {
   let memoryValue;
   function getCacheFilePath() {
-    return join6(options.getCacheDir(), options.filename);
+    return join7(options.getCacheDir(), options.filename);
   }
   function ensureCacheDir() {
     const cacheDir = options.getCacheDir();
-    if (!existsSync5(cacheDir)) {
-      mkdirSync3(cacheDir, { recursive: true });
+    if (!existsSync6(cacheDir)) {
+      mkdirSync4(cacheDir, { recursive: true });
     }
   }
   function read() {
@@ -6977,7 +7002,7 @@ function createJsonFileCacheStore(options) {
       return memoryValue;
     }
     const cacheFile = getCacheFilePath();
-    if (!existsSync5(cacheFile)) {
+    if (!existsSync6(cacheFile)) {
       memoryValue = null;
       log(`[${options.logPrefix}] ${options.cacheLabel} file not found`, { cacheFile });
       return null;
@@ -6997,7 +7022,7 @@ function createJsonFileCacheStore(options) {
     }
   }
   function has() {
-    return existsSync5(getCacheFilePath());
+    return existsSync6(getCacheFilePath());
   }
   function write(value) {
     ensureCacheDir();
@@ -7166,14 +7191,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 existsSync7, readFileSync as readFileSync4 } from "fs";
+import { join as join8 } from "path";
 function isModelCacheAvailable() {
   if (hasProviderModelsCache()) {
     return true;
   }
-  const cacheFile = join7(getOpenCodeCacheDir(), "models.json");
-  return existsSync6(cacheFile);
+  const cacheFile = join8(getOpenCodeCacheDir(), "models.json");
+  return existsSync7(cacheFile);
 }
 var init_model_availability = __esm(() => {
   init_logger();
@@ -7182,21 +7207,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
@@ -48469,19 +48487,19 @@ var init_constants = __esm(() => {
 });
 
 // src/shared/opencode-storage-paths.ts
-import { join as join8 } from "path";
+import { join as join9 } 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 = join9(OPENCODE_STORAGE, "message");
+  PART_STORAGE = join9(OPENCODE_STORAGE, "part");
+  SESSION_STORAGE = join9(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 existsSync8, readdirSync, readFileSync as readFileSync5 } from "fs";
+import { join as join10 } from "path";
 function isCompactionPart(part) {
   return typeof part === "object" && part !== null && part.type === "compaction";
 }
@@ -48495,20 +48513,20 @@ function isCompactionMessage(message) {
   return isCompactionAgent(message.info?.agent ?? message.agent) || hasCompactionPart(message.parts);
 }
 function getCompactionPartStorageDir(messageID) {
-  return join9(PART_STORAGE, messageID);
+  return join10(PART_STORAGE, messageID);
 }
 function hasCompactionPartInStorage(messageID) {
   if (!messageID) {
     return false;
   }
   const partDir = getCompactionPartStorageDir(messageID);
-  if (!existsSync7(partDir)) {
+  if (!existsSync8(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 = readFileSync5(join10(partDir, fileName), "utf-8");
         return isCompactionPart(JSON.parse(content));
       } catch {
         return false;
@@ -48541,23 +48559,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 existsSync9, readdirSync as readdirSync2 } from "fs";
+import { join as join11 } from "path";
 function getMessageDir(sessionID) {
   if (!sessionID.startsWith("ses_"))
     return null;
   if (/[/\\]|\.\./.test(sessionID))
     return null;
-  if (!existsSync8(MESSAGE_STORAGE))
+  if (!existsSync9(MESSAGE_STORAGE))
     return null;
-  const directPath = join10(MESSAGE_STORAGE, sessionID);
-  if (existsSync8(directPath)) {
+  const directPath = join11(MESSAGE_STORAGE, sessionID);
+  if (existsSync9(directPath)) {
     return directPath;
   }
   try {
     for (const dir of readdirSync2(MESSAGE_STORAGE)) {
-      const sessionPath = join10(MESSAGE_STORAGE, dir, sessionID);
-      if (existsSync8(sessionPath)) {
+      const sessionPath = join11(MESSAGE_STORAGE, dir, sessionID);
+      if (existsSync9(sessionPath)) {
         return sessionPath;
       }
     }
@@ -48590,7 +48608,7 @@ function getAgentDisplayName(configKey) {
   }
   return configKey;
 }
-function getAgentConfigKey(agentName) {
+function resolveKnownAgentConfigKey(agentName) {
   const lower = stripAgentListSortPrefix(agentName).trim().toLowerCase();
   const reversed = REVERSE_DISPLAY_NAMES[lower];
   if (reversed !== undefined)
@@ -48600,7 +48618,11 @@ function getAgentConfigKey(agentName) {
     return legacy;
   if (AGENT_DISPLAY_NAMES[lower] !== undefined)
     return lower;
-  return lower;
+  return;
+}
+function getAgentConfigKey(agentName) {
+  const lower = stripAgentListSortPrefix(agentName).trim().toLowerCase();
+  return resolveKnownAgentConfigKey(agentName) ?? lower;
 }
 var AGENT_DISPLAY_NAMES, INVISIBLE_AGENT_CHARACTERS_REGEX, REVERSE_DISPLAY_NAMES, LEGACY_DISPLAY_NAMES;
 var init_agent_display_names = __esm(() => {
@@ -49088,18 +49110,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 { copyFileSync as copyFileSync2, existsSync as existsSync10, mkdirSync as mkdirSync5 } from "fs";
 import { dirname as dirname2 } from "path";
 function backupConfigFile(configPath) {
-  if (!existsSync9(configPath)) {
+  if (!existsSync10(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 });
+    if (!existsSync10(dir)) {
+      mkdirSync5(dir, { recursive: true });
     }
     copyFileSync2(configPath, backupPath);
     return { success: true, backupPath };
@@ -49113,11 +49135,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 existsSync11, mkdirSync as mkdirSync6 } from "fs";
 function ensureConfigDirectoryExists() {
   const configDir = getConfigDir();
-  if (!existsSync10(configDir)) {
-    mkdirSync5(configDir, { recursive: true });
+  if (!existsSync11(configDir)) {
+    mkdirSync6(configDir, { recursive: true });
   }
 }
 var init_ensure_config_directory_exists = __esm(() => {
@@ -49154,14 +49176,14 @@ function formatErrorWithSuggestion(err, context) {
 }
 
 // src/cli/config-manager/opencode-config-format.ts
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 function detectConfigFormat() {
   const configJsonc = getConfigJsonc();
   const configJson = getConfigJson();
-  if (existsSync11(configJsonc)) {
+  if (existsSync12(configJsonc)) {
     return { format: "jsonc", path: configJsonc };
   }
-  if (existsSync11(configJson)) {
+  if (existsSync12(configJson)) {
     return { format: "json", path: configJson };
   }
   return { format: "none", path: configJson };
@@ -49175,29 +49197,29 @@ import { readFileSync as readFileSync6, 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 = readFileSync6(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(() => {
@@ -49298,20 +49320,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"
       };
     }
@@ -49327,28 +49349,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 = readFileSync7(path5, "utf-8");
       const pluginArrayRegex = /((?:"plugin"|plugin)\s*:\s*)\[([\s\S]*?)\]/;
       const match = content.match(pluginArrayRegex);
       if (match) {
@@ -49357,21 +49375,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")
     };
   }
@@ -49438,6 +49456,7 @@ function toProviderAvailability(config) {
     zai: config.hasZaiCodingPlan,
     kimiForCoding: config.hasKimiForCoding,
     opencodeGo: config.hasOpencodeGo,
+    vercelAiGateway: config.hasVercelAiGateway,
     isMaxPlan: config.isMax20
   };
 }
@@ -49450,20 +49469,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 claudeVersionDot(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
@@ -49490,13 +49563,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 } : {},
@@ -49537,7 +49610,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,
@@ -49554,6 +49627,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);
@@ -49570,6 +49645,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" };
       }
@@ -49633,7 +49710,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
@@ -49645,12 +49722,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 existsSync13, readFileSync as readFileSync8, renameSync as renameSync2, rmSync } from "fs";
+import { join as join12, dirname as dirname3, basename } from "path";
 function buildCanonicalPath(legacyPath) {
   const dir = dirname3(legacyPath);
   const ext = basename(legacyPath).includes(".jsonc") ? ".jsonc" : ".json";
-  return join11(dir, `${CONFIG_BASENAME}${ext}`);
+  return join12(dir, `${CONFIG_BASENAME}${ext}`);
 }
 function archiveLegacyConfigFile(legacyPath) {
   const backupPath = `${legacyPath}.bak`;
@@ -49682,12 +49759,12 @@ function archiveLegacyConfigFile(legacyPath) {
   }
 }
 function migrateLegacyConfigFile(legacyPath) {
-  if (!existsSync12(legacyPath))
+  if (!existsSync13(legacyPath))
     return false;
   if (!basename(legacyPath).startsWith(LEGACY_CONFIG_BASENAME))
     return false;
   const canonicalPath = buildCanonicalPath(legacyPath);
-  if (existsSync12(canonicalPath))
+  if (existsSync13(canonicalPath))
     return false;
   try {
     const content = readFileSync8(legacyPath, "utf-8");
@@ -49698,7 +49775,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;
@@ -49728,8 +49805,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 existsSync14, readFileSync as readFileSync9, statSync as statSync2, writeFileSync as writeFileSync4 } from "fs";
+import { basename as basename2, dirname as dirname4, extname, join as join13 } from "path";
 function isEmptyOrWhitespace2(content) {
   return content.trim().length === 0;
 }
@@ -49744,12 +49821,12 @@ function writeOmoConfig(installConfig) {
     };
   }
   const detectedConfigPath = getOmoConfigPath();
-  const canonicalConfigPath = join12(dirname4(detectedConfigPath), `${CONFIG_BASENAME}${extname(detectedConfigPath) || ".json"}`);
+  const canonicalConfigPath = join13(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 omoConfigPath = shouldMigrateLegacyPath ? migrateLegacyConfigFile(detectedConfigPath) || existsSync14(canonicalConfigPath) ? canonicalConfigPath : detectedConfigPath : detectedConfigPath;
   try {
     const newConfig = generateOmoConfig(installConfig);
-    if (existsSync13(omoConfigPath)) {
+    if (existsSync14(omoConfigPath)) {
       const backupResult = backupConfigFile(omoConfigPath);
       if (!backupResult.success) {
         return {
@@ -49903,16 +49980,17 @@ 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 existsSync15, readFileSync as readFileSync10 } from "fs";
 function detectProvidersFromOmoConfig() {
   const omoConfigPath = getOmoConfigPath();
-  if (!existsSync14(omoConfigPath)) {
+  if (!existsSync15(omoConfigPath)) {
     return {
       hasOpenAI: true,
       hasOpencodeZen: true,
       hasZaiCodingPlan: false,
       hasKimiForCoding: false,
-      hasOpencodeGo: false
+      hasOpencodeGo: false,
+      hasVercelAiGateway: false
     };
   }
   try {
@@ -49924,7 +50002,8 @@ function detectProvidersFromOmoConfig() {
         hasOpencodeZen: true,
         hasZaiCodingPlan: false,
         hasKimiForCoding: false,
-        hasOpencodeGo: false
+        hasOpencodeGo: false,
+        hasVercelAiGateway: false
       };
     }
     const configStr = JSON.stringify(omoConfig);
@@ -49933,14 +50012,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
     };
   }
 }
@@ -49962,13 +50043,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;
   }
@@ -49984,12 +50066,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(() => {
@@ -50000,10 +50083,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 existsSync16 } from "fs";
+import { join as join14 } from "path";
 function getDefaultWorkspaceDir() {
-  return join13(getOpenCodeCacheDir(), "packages");
+  return join14(getOpenCodeCacheDir(), "packages");
 }
 function readProcessOutput(stream) {
   if (!stream) {
@@ -50029,7 +50112,7 @@ async function runBunInstallWithDetails(options) {
   const outputMode = options?.outputMode ?? "pipe";
   const cacheDir = options?.workspaceDir ?? getDefaultWorkspaceDir();
   const packageJsonPath = `${cacheDir}/package.json`;
-  if (!existsSync15(packageJsonPath)) {
+  if (!existsSync16(packageJsonPath)) {
     return {
       success: false,
       error: `Workspace not initialized: ${packageJsonPath} not found. OpenCode should create this on first run.`
@@ -50171,7 +50254,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;
@@ -50182,25 +50265,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);
   }
 });
 
@@ -50209,13 +50292,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);
@@ -50246,7 +50329,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 = {};
@@ -50256,7 +50339,7 @@ var require_isexe = __commonJS((exports2, module) => {
         throw new TypeError("callback not provided");
       }
       return new Promise(function(resolve2, reject) {
-        isexe(path5, options || {}, function(er, is) {
+        isexe(path6, options || {}, function(er, is) {
           if (er) {
             reject(er);
           } else {
@@ -50265,7 +50348,7 @@ var require_isexe = __commonJS((exports2, module) => {
         });
       });
     }
-    core3(path5, options || {}, function(er, is) {
+    core3(path6, options || {}, function(er, is) {
       if (er) {
         if (er.code === "EACCES" || options && options.ignoreErrors) {
           er = null;
@@ -50275,9 +50358,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;
@@ -50291,7 +50374,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" });
@@ -50327,7 +50410,7 @@ var require_which = __commonJS((exports2, module) => {
         return opt.all && found.length ? resolve2(found) : reject(getNotFoundError(cmd));
       const ppRaw = pathEnv[i2];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-      const pCmd = 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));
     });
@@ -50354,7 +50437,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];
@@ -50395,7 +50478,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) {
@@ -50412,7 +50495,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) {
@@ -50420,7 +50503,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;
   }
@@ -50465,8 +50548,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;
     }
@@ -50494,7 +50577,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();
@@ -50519,7 +50602,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(" ");
@@ -50623,21 +50706,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(() => {
@@ -50648,30 +50731,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);
       }
@@ -50729,13 +50812,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");
@@ -50744,7 +50827,7 @@ function findPackageJsonUp(startPath) {
             return pkgPath;
         } catch {}
       }
-      const parent = path7.dirname(dir);
+      const parent = path8.dirname(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -50819,7 +50902,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");
@@ -50835,7 +50918,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);
@@ -50844,7 +50927,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);
@@ -50987,7 +51070,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);
@@ -51004,7 +51087,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 };
@@ -51015,7 +51098,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 });
@@ -51091,7 +51174,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");
 }
@@ -51120,8 +51203,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);
   }
@@ -51134,8 +51217,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;
@@ -51195,8 +51278,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 existsSync28 } from "fs";
+import { join as join27 } from "path";
 function getCacheWorkspaceDir(deps) {
   return deps.join(deps.getOpenCodeCacheDir(), "packages");
 }
@@ -51314,8 +51397,8 @@ var init_background_update_check = __esm(() => {
   init_checker();
   init_update_toasts();
   defaultDeps = {
-    existsSync: existsSync27,
-    join: join26,
+    existsSync: existsSync28,
+    join: join27,
     runBunInstallWithDetails,
     log,
     getOpenCodeCacheDir,
@@ -51608,7 +51691,7 @@ var {
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "3.17.0",
+  version: "3.17.2",
   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",
@@ -51687,17 +51770,17 @@ var package_default = {
     typescript: "^5.7.3"
   },
   optionalDependencies: {
-    "oh-my-opencode-darwin-arm64": "3.17.0",
-    "oh-my-opencode-darwin-x64": "3.17.0",
-    "oh-my-opencode-darwin-x64-baseline": "3.17.0",
-    "oh-my-opencode-linux-arm64": "3.17.0",
-    "oh-my-opencode-linux-arm64-musl": "3.17.0",
-    "oh-my-opencode-linux-x64": "3.17.0",
-    "oh-my-opencode-linux-x64-baseline": "3.17.0",
-    "oh-my-opencode-linux-x64-musl": "3.17.0",
-    "oh-my-opencode-linux-x64-musl-baseline": "3.17.0",
-    "oh-my-opencode-windows-x64": "3.17.0",
-    "oh-my-opencode-windows-x64-baseline": "3.17.0"
+    "oh-my-opencode-darwin-arm64": "3.17.2",
+    "oh-my-opencode-darwin-x64": "3.17.2",
+    "oh-my-opencode-darwin-x64-baseline": "3.17.2",
+    "oh-my-opencode-linux-arm64": "3.17.2",
+    "oh-my-opencode-linux-arm64-musl": "3.17.2",
+    "oh-my-opencode-linux-x64": "3.17.2",
+    "oh-my-opencode-linux-x64-baseline": "3.17.2",
+    "oh-my-opencode-linux-x64-musl": "3.17.2",
+    "oh-my-opencode-linux-x64-musl-baseline": "3.17.2",
+    "oh-my-opencode-windows-x64": "3.17.2",
+    "oh-my-opencode-windows-x64-baseline": "3.17.2"
   },
   overrides: {},
   trustedDependencies: [
@@ -51742,6 +51825,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("");
@@ -51825,6 +51909,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) {
@@ -51837,7 +51924,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) {
@@ -51853,7 +51941,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"
   };
 }
 
@@ -51943,8 +52032,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
@@ -54259,9 +54348,9 @@ async function addSourceContext(frames) {
   LRU_FILE_CONTENTS_CACHE.reduce();
   return frames;
 }
-function getContextLinesFromFile(path4, ranges, output) {
+function getContextLinesFromFile(path5, ranges, output) {
   return new Promise((resolve2) => {
-    const stream = createReadStream(path4);
+    const stream = createReadStream(path5);
     const lineReaded = createInterface({
       input: stream
     });
@@ -54277,7 +54366,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();
@@ -54345,8 +54434,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)
@@ -56359,11 +56448,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 existsSync17, mkdirSync as mkdirSync7, readFileSync as readFileSync11 } from "fs";
+import { join as join15 } from "path";
 var POSTHOG_ACTIVITY_STATE_FILE = "posthog-activity.json";
 function getPostHogActivityStateFilePath() {
-  return join14(getDataDir(), CACHE_DIR_NAME, POSTHOG_ACTIVITY_STATE_FILE);
+  return join15(getDataDir(), CACHE_DIR_NAME, POSTHOG_ACTIVITY_STATE_FILE);
 }
 function getUtcDayString(date) {
   return date.toISOString().slice(0, 10);
@@ -56376,7 +56465,7 @@ function isPostHogActivityState(value) {
 }
 function readPostHogActivityState() {
   const stateFilePath = getPostHogActivityStateFilePath();
-  if (!existsSync16(stateFilePath)) {
+  if (!existsSync17(stateFilePath)) {
     return {};
   }
   try {
@@ -56397,7 +56486,7 @@ function readPostHogActivityState() {
 function writePostHogActivityState(nextState) {
   const stateFilePath = getPostHogActivityStateFilePath();
   try {
-    mkdirSync6(join14(getDataDir(), CACHE_DIR_NAME), { recursive: true });
+    mkdirSync7(join15(getDataDir(), CACHE_DIR_NAME), { recursive: true });
     writeFileAtomically(stateFilePath, `${JSON.stringify(nextState, null, 2)}
 `);
   } catch (error) {
@@ -56469,17 +56558,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) => {
@@ -56612,7 +56720,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!"))}`);
@@ -57339,6 +57447,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",
@@ -57348,7 +57466,8 @@ async function promptInstallConfig(detected) {
     hasOpencodeZen: opencodeZen === "yes",
     hasZaiCodingPlan: zaiCodingPlan === "yes",
     hasKimiForCoding: kimiForCoding === "yes",
-    hasOpencodeGo: opencodeGo === "yes"
+    hasOpencodeGo: opencodeGo === "yes",
+    hasVercelAiGateway: vercelAiGateway === "yes"
   };
 }
 
@@ -57405,7 +57524,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");
@@ -57631,10 +57750,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") {
@@ -58143,7 +58262,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 = {};
@@ -58910,10 +59029,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);
@@ -59294,11 +59413,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;
   });
 }
@@ -59481,7 +59600,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) {
@@ -59491,7 +59610,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;
@@ -59523,8 +59642,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")
@@ -71271,13 +71390,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}`);
     }
@@ -72210,6 +72329,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",
@@ -72337,42 +72472,55 @@ 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);
   let config2 = userConfig ?? OhMyOpenCodeConfigSchema.parse({});
+  const defaultGitMaster = OhMyOpenCodeConfigSchema.parse({}).git_master;
   const projectConfig = loadConfigFromPath(projectConfigPath, ctx);
+  const projectGitMasterOverrides = loadExplicitGitMasterOverrides(projectConfigPath);
   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 ?? []
@@ -72620,7 +72768,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) {
@@ -72639,7 +72787,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;
       }
@@ -72670,11 +72818,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("?")) {
@@ -73904,7 +74052,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 dirname7, join as join17 } from "path";
 var OPENCODE_COMMANDS = ["opencode", "opencode-desktop"];
 var WINDOWS_SUFFIXES = ["", ".exe", ".cmd", ".bat", ".ps1"];
 function getCommandCandidates(platform) {
@@ -73927,7 +74075,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(join17(entry, command));
     }
   }
   return candidates;
@@ -74312,15 +74460,15 @@ 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 existsSync19, readFileSync as readFileSync13, writeFileSync as writeFileSync5, mkdirSync as mkdirSync8, readdirSync as readdirSync3 } from "fs";
+import { dirname as dirname8, join as join18, basename as basename4 } from "path";
 var RESERVED_KEYS = new Set(["__proto__", "prototype", "constructor"]);
 function getBoulderFilePath(directory) {
-  return join17(directory, BOULDER_DIR, BOULDER_FILE);
+  return join18(directory, BOULDER_DIR, BOULDER_FILE);
 }
 function readBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
-  if (!existsSync18(filePath)) {
+  if (!existsSync19(filePath)) {
     return null;
   }
   try {
@@ -74357,7 +74505,7 @@ 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 (!existsSync19(planPath)) {
     return { total: 0, completed: 0, isComplete: true };
   }
   try {
@@ -74433,14 +74581,14 @@ 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 existsSync20, mkdirSync as mkdirSync9, readFileSync as readFileSync14, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
+import { join as join19 } from "path";
 function getMarkerPath(directory, sessionID) {
-  return join18(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
+  return join19(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
 }
 function readContinuationMarker(directory, sessionID) {
   const markerPath = getMarkerPath(directory, sessionID);
-  if (!existsSync19(markerPath))
+  if (!existsSync20(markerPath))
     return null;
   try {
     const raw = readFileSync14(markerPath, "utf-8");
@@ -74505,7 +74653,7 @@ async function isSessionInBoulderLineage(input) {
 init_shared();
 init_compaction_marker();
 import { readFileSync as readFileSync15, readdirSync as readdirSync4 } from "fs";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 var defaultSessionLastAgentDeps = {
   getMessageDir,
   isSqliteBackend,
@@ -74553,7 +74701,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 = readFileSync15(join20(messageDir, fileName), "utf-8");
         const parsed = JSON.parse(content);
         return {
           fileName,
@@ -74586,8 +74734,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 existsSync21, readFileSync as readFileSync16, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, mkdirSync as mkdirSync10 } from "fs";
+import { dirname as dirname9, join as join21 } from "path";
 
 // src/hooks/ralph-loop/constants.ts
 var DEFAULT_STATE_FILE = ".sisyphus/ralph-loop.local.md";
@@ -74596,11 +74744,11 @@ 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 ? join21(directory, customPath) : join21(directory, DEFAULT_STATE_FILE);
 }
 function readState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
-  if (!existsSync20(filePath)) {
+  if (!existsSync21(filePath)) {
     return null;
   }
   try {
@@ -74920,6 +75068,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;
@@ -75369,30 +75520,61 @@ async function getLocalVersion(options = {}) {
   }
 }
 // src/cli/doctor/checks/system.ts
-import { existsSync as existsSync31, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync32, readFileSync as readFileSync26 } from "fs";
 
 // src/cli/doctor/checks/system-binary.ts
-init_spawn_with_windows_hide();
-import { existsSync as existsSync28 } from "fs";
+import { existsSync as existsSync29 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
+
+// src/cli/doctor/spawn-with-timeout.ts
+init_spawn_with_windows_hide();
+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((resolve2) => {
+    timer = setTimeout(() => resolve2("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();
   switch (platform) {
     case "darwin":
       return [
         "/Applications/OpenCode.app/Contents/MacOS/OpenCode",
-        join27(home, "Applications", "OpenCode.app", "Contents", "MacOS", "OpenCode")
+        join28(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(join28(programFiles, "OpenCode", "OpenCode.exe"));
       }
       if (localAppData) {
-        paths.push(join27(localAppData, "OpenCode", "OpenCode.exe"));
+        paths.push(join28(localAppData, "OpenCode", "OpenCode.exe"));
       }
       return paths;
     }
@@ -75400,8 +75582,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")
+        join28(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
+        join28(home, "Applications", "opencode-desktop-linux-aarch64.AppImage")
       ];
     default:
       return [];
@@ -75413,7 +75595,7 @@ function buildVersionCommand(binaryPath, platform) {
   }
   return [binaryPath, "--version"];
 }
-function findDesktopBinary(platform = process.platform, checkExists = existsSync28) {
+function findDesktopBinary(platform = process.platform, checkExists = existsSync29) {
   for (const desktopPath of getDesktopAppPaths(platform)) {
     if (checkExists(desktopPath)) {
       return { binary: "opencode", path: desktopPath };
@@ -75423,9 +75605,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();
@@ -75433,12 +75615,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;
   }
@@ -75461,12 +75641,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 existsSync30, readFileSync as readFileSync24 } from "fs";
 function detectConfigPath() {
   const paths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
-  if (existsSync29(paths.configJsonc))
+  if (existsSync30(paths.configJsonc))
     return paths.configJsonc;
-  if (existsSync29(paths.configJson))
+  if (existsSync30(paths.configJson))
     return paths.configJson;
   return null;
 }
@@ -75550,34 +75730,34 @@ function getPluginInfo() {
 init_file_utils();
 init_checker();
 init_auto_update_checker();
-import { existsSync as existsSync30, readFileSync as readFileSync25 } from "fs";
+import { existsSync as existsSync31, readFileSync as readFileSync25 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 init_shared();
 function getPlatformDefaultCacheDir(platform = process.platform) {
   if (platform === "darwin")
-    return join28(homedir6(), "Library", "Caches");
+    return join29(homedir6(), "Library", "Caches");
   if (platform === "win32")
-    return process.env.LOCALAPPDATA ?? join28(homedir6(), "AppData", "Local");
-  return join28(homedir6(), ".cache");
+    return process.env.LOCALAPPDATA ?? join29(homedir6(), "AppData", "Local");
+  return join29(homedir6(), ".cache");
 }
 function resolveOpenCodeCacheDir() {
   const xdgCacheHome = process.env.XDG_CACHE_HOME;
   if (xdgCacheHome)
-    return join28(xdgCacheHome, "opencode");
+    return join29(xdgCacheHome, "opencode");
   const fromShared = getOpenCodeCacheDir();
-  const platformDefault = join28(getPlatformDefaultCacheDir(), "opencode");
-  if (existsSync30(fromShared) || !existsSync30(platformDefault))
+  const platformDefault = join29(getPlatformDefaultCacheDir(), "opencode");
+  if (existsSync31(fromShared) || !existsSync31(platformDefault))
     return fromShared;
   return platformDefault;
 }
 function resolveExistingDir(dirPath) {
-  if (!existsSync30(dirPath))
+  if (!existsSync31(dirPath))
     return dirPath;
   return resolveSymlink(dirPath);
 }
 function readPackageJson(filePath) {
-  if (!existsSync30(filePath))
+  if (!existsSync31(filePath))
     return null;
   try {
     const content = readFileSync25(filePath, "utf-8");
@@ -75595,11 +75775,11 @@ function normalizeVersion(value) {
 function createPackageCandidates(rootDir) {
   return ACCEPTED_PACKAGE_NAMES.map((packageName) => ({
     packageName,
-    installedPackagePath: join28(rootDir, "node_modules", packageName, "package.json")
+    installedPackagePath: join29(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) => existsSync31(packageCandidate.installedPackagePath)) ?? candidate.packageCandidates[0];
 }
 function getExpectedVersion(cachePackage, packageName) {
   return normalizeVersion(cachePackage?.dependencies?.[packageName]) ?? normalizeVersion(cachePackage?.dependencies?.[PACKAGE_NAME]);
@@ -75611,16 +75791,16 @@ function getLoadedPluginVersion() {
   const candidates = [
     {
       cacheDir: configDir,
-      cachePackagePath: join28(configDir, "package.json"),
+      cachePackagePath: join29(configDir, "package.json"),
       packageCandidates: createPackageCandidates(configDir)
     },
     {
       cacheDir,
-      cachePackagePath: join28(cacheDir, "package.json"),
+      cachePackagePath: join29(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) => existsSync31(packageCandidate.installedPackagePath))) ?? candidates[0];
   const { cacheDir: selectedDir, cachePackagePath } = selectedCandidate;
   const selectedPackage = selectInstalledPackage(selectedCandidate);
   const installedPackagePath = selectedPackage.installedPackagePath;
@@ -75659,7 +75839,7 @@ var defaultDeps3 = {
 function isConfigValid(configPath) {
   if (!configPath)
     return true;
-  if (!existsSync31(configPath))
+  if (!existsSync32(configPath))
     return false;
   try {
     parseJsonc(readFileSync26(configPath, "utf-8"));
@@ -75785,28 +75965,28 @@ async function checkSystem(deps = defaultDeps3) {
 
 // src/cli/doctor/checks/config.ts
 import { readFileSync as readFileSync29 } from "fs";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 init_shared();
 
 // src/cli/doctor/checks/model-resolution-cache.ts
 init_shared();
-import { existsSync as existsSync32, readFileSync as readFileSync27 } from "fs";
+import { existsSync as existsSync33, readFileSync as readFileSync27 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 function getUserConfigDir2() {
   const xdgConfig = process.env.XDG_CONFIG_HOME;
   if (xdgConfig)
-    return join29(xdgConfig, "opencode");
-  return join29(homedir7(), ".config", "opencode");
+    return join30(xdgConfig, "opencode");
+  return join30(homedir7(), ".config", "opencode");
 }
 function loadCustomProviderNames() {
   const configDir = getUserConfigDir2();
   const candidatePaths = [
-    join29(configDir, "opencode.json"),
-    join29(configDir, "opencode.jsonc")
+    join30(configDir, "opencode.json"),
+    join30(configDir, "opencode.jsonc")
   ];
   for (const configPath of candidatePaths) {
-    if (!existsSync32(configPath))
+    if (!existsSync33(configPath))
       continue;
     try {
       const content = readFileSync27(configPath, "utf-8");
@@ -75819,9 +75999,9 @@ function loadCustomProviderNames() {
   return [];
 }
 function loadAvailableModelsFromCache() {
-  const cacheFile = join29(getOpenCodeCacheDir(), "models.json");
+  const cacheFile = join30(getOpenCodeCacheDir(), "models.json");
   const customProviders = loadCustomProviderNames();
-  if (!existsSync32(cacheFile)) {
+  if (!existsSync33(cacheFile)) {
     if (customProviders.length > 0) {
       return { providers: customProviders, modelCount: 0, cacheExists: true };
     }
@@ -75852,8 +76032,8 @@ 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 { join as join31 } from "path";
+var PROJECT_CONFIG_DIR = join31(process.cwd(), ".opencode");
 function loadOmoConfig() {
   const projectDetected = detectPluginConfigFile(PROJECT_CONFIG_DIR);
   if (projectDetected.format !== "none") {
@@ -75879,7 +76059,7 @@ function loadOmoConfig() {
 
 // src/cli/doctor/checks/model-resolution-details.ts
 init_shared();
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 
 // src/cli/doctor/checks/model-resolution-variant.ts
 function formatModelWithVariant(model, variant) {
@@ -75921,7 +76101,7 @@ function formatCapabilityResolutionLabel(mode) {
 }
 function buildModelResolutionDetails(options) {
   const details = [];
-  const cacheFile = join31(getOpenCodeCacheDir(), "models.json");
+  const cacheFile = join32(getOpenCodeCacheDir(), "models.json");
   details.push("\u2550\u2550\u2550 Available Models (from cache) \u2550\u2550\u2550");
   details.push("");
   if (options.available.cacheExists) {
@@ -76076,7 +76256,7 @@ async function checkModels() {
 }
 
 // src/cli/doctor/checks/config.ts
-var PROJECT_CONFIG_DIR2 = join32(process.cwd(), ".opencode");
+var PROJECT_CONFIG_DIR2 = join33(process.cwd(), ".opencode");
 function findConfigPath() {
   const projectConfig = detectPluginConfigFile(PROJECT_CONFIG_DIR2);
   if (projectConfig.format !== "none")
@@ -76196,30 +76376,55 @@ async function checkConfig() {
 }
 
 // src/cli/doctor/checks/dependencies.ts
-init_spawn_with_windows_hide();
-import { existsSync as existsSync33 } from "fs";
+import { existsSync as existsSync34 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname13, join as join33 } from "path";
+import { dirname as dirname13, join as join35 } from "path";
+
+// src/hooks/comment-checker/downloader.ts
+import { join as join34 } from "path";
+import { homedir as homedir8, tmpdir as tmpdir3 } from "os";
+init_binary_downloader();
+init_logger();
+init_plugin_identity();
+var DEBUG = process.env.COMMENT_CHECKER_DEBUG === "1";
+var DEBUG_FILE = join34(tmpdir3(), "comment-checker-debug.log");
+function getCacheDir2() {
+  if (process.platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
+    const base2 = localAppData || join34(homedir8(), "AppData", "Local");
+    return join34(base2, CACHE_DIR_NAME, "bin");
+  }
+  const xdgCache = process.env.XDG_CACHE_HOME;
+  const base = xdgCache || join34(homedir8(), ".cache");
+  return join34(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");
@@ -76255,15 +76460,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: existsSync35 } = await import("fs");
+    const { join: join36 } = await import("path");
+    const { homedir: homedir9 } = await import("os");
     const pathsToCheck = [
-      join34(homedir8(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
-      join34(process.cwd(), "node_modules", "@ast-grep", "napi")
+      join36(homedir9(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
+      join36(process.cwd(), "node_modules", "@ast-grep", "napi")
     ];
     for (const napiPath of pathsToCheck) {
-      if (existsSync34(napiPath)) {
+      if (existsSync35(napiPath)) {
         return {
           name: "AST-Grep NAPI",
           required: false,
@@ -76288,13 +76493,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 = join35(dirname13(pkgPath), "bin", binaryName);
+    if (existsSync34(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) {
@@ -76318,7 +76534,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);
@@ -76329,13 +76544,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;
@@ -76343,16 +76556,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 {
@@ -76446,15 +76655,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 existsSync35, readFileSync as readFileSync30 } from "fs";
+import { join as join36 } from "path";
 init_shared();
 init_jsonc_parser();
-function loadJsonFile(path11) {
-  if (!existsSync34(path11))
+function loadJsonFile(path12) {
+  if (!existsSync35(path12))
     return null;
   try {
-    return parseJsonc(readFileSync30(path11, "utf-8"));
+    return parseJsonc(readFileSync30(path12, "utf-8"));
   } catch {
     return null;
   }
@@ -76463,9 +76672,9 @@ function getConfigPaths2() {
   const cwd = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   return {
-    project: detectPluginConfigFile(join34(cwd, ".opencode")).path,
+    project: detectPluginConfigFile(join36(cwd, ".opencode")).path,
     user: detectPluginConfigFile(configDir).path,
-    opencode: detectConfigFile(join34(configDir, "opencode")).path
+    opencode: detectConfigFile(join36(configDir, "opencode")).path
   };
 }
 function loadAllConfigs() {
@@ -76534,21 +76743,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 existsSync36 } from "fs";
+import { delimiter as delimiter2, join as join38 } from "path";
 
 // src/tools/lsp/server-path-bases.ts
 init_shared();
-import { join as join35 } from "path";
+import { join as join37 } from "path";
 function getLspServerAdditionalPathBases(workingDirectory) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join35(getDataDir(), "opencode");
+  const dataDir = join37(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")
+    join37(workingDirectory, "node_modules", ".bin"),
+    join37(configDir, "bin"),
+    join37(configDir, "node_modules", ".bin"),
+    join37(dataDir, "bin"),
+    join37(dataDir, "bin", "node_modules", ".bin")
   ];
 }
 
@@ -76558,7 +76767,7 @@ function isServerInstalled(command) {
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync35(cmd))
+    if (existsSync36(cmd))
       return true;
   }
   const isWindows = process.platform === "win32";
@@ -76579,14 +76788,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 (existsSync36(join38(p2, cmd + suffix))) {
         return true;
       }
     }
   }
   for (const base of getLspServerAdditionalPathBases(process.cwd())) {
     for (const suffix of exts) {
-      if (existsSync35(join36(base, cmd + suffix))) {
+      if (existsSync36(join38(base, cmd + suffix))) {
         return true;
       }
     }
@@ -76648,21 +76857,21 @@ 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 existsSync37, readFileSync as readFileSync31 } from "fs";
+import { homedir as homedir9 } from "os";
+import { join as join39 } 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")
+    join39(homedir9(), ".claude", ".mcp.json"),
+    join39(process.cwd(), ".mcp.json"),
+    join39(process.cwd(), ".claude", ".mcp.json")
   ];
 }
 function loadUserMcpConfig() {
   const servers = {};
   for (const configPath of getMcpConfigPaths()) {
-    if (!existsSync36(configPath))
+    if (!existsSync37(configPath))
       continue;
     try {
       const content = readFileSync31(configPath, "utf-8");
@@ -77025,6 +77234,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 {
@@ -77054,14 +77271,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);
@@ -77120,11 +77372,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 existsSync38, mkdirSync as mkdirSync12, readFileSync as readFileSync32, renameSync as renameSync4, unlinkSync as unlinkSync6, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname14, join as join40 } from "path";
 var STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStoragePath() {
-  return join38(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
+  return join40(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
 }
 function normalizeHost(serverHost) {
   let host = serverHost.trim();
@@ -77161,7 +77413,7 @@ function buildKey(serverHost, resource) {
 }
 function readStore() {
   const filePath = getMcpOauthStoragePath();
-  if (!existsSync37(filePath)) {
+  if (!existsSync38(filePath)) {
     return null;
   }
   try {
@@ -77175,12 +77427,12 @@ function writeStore(store2) {
   const filePath = getMcpOauthStoragePath();
   try {
     const dir = dirname14(filePath);
-    if (!existsSync37(dir)) {
-      mkdirSync11(dir, { recursive: true });
+    if (!existsSync38(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 {
@@ -77212,8 +77464,8 @@ function deleteToken(serverHost, resource) {
   if (Object.keys(store2).length === 0) {
     try {
       const filePath = getMcpOauthStoragePath();
-      if (existsSync37(filePath)) {
-        unlinkSync4(filePath);
+      if (existsSync38(filePath)) {
+        unlinkSync6(filePath);
       }
       return true;
     } catch {
@@ -77795,20 +78047,21 @@ function createMcpOAuthCommand() {
 var VERSION2 = package_default.version;
 var program2 = new Command;
 program2.name("oh-my-opencode").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 oh-my-opencode 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 oh-my-opencode 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 oh-my-opencode install
   $ bunx oh-my-opencode install --no-tui --claude=max20 --openai=yes --gemini=yes --copilot=no
   $ bunx oh-my-opencode 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,
@@ -77820,6 +78073,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);