evil-omo 3.11.7 → 3.12.2

package/dist/cli/index.js

@@ -5837,10 +5837,10 @@ function detectManagedConfigFile(directory) {
     baseName: CONFIG_BASENAME
   };
 }
-var PLUGIN_NAME = "evil-omo", ALL_PLUGIN_NAMES, CONFIG_BASENAME = "evil-omo", ALL_CONFIG_BASENAMES, LOG_FILENAME = "evil-omo.log", CACHE_DIR_NAME = "evil-omo", SCHEMA_FILENAME = "evil-omo.schema.json";
+var PLUGIN_NAME = "evil-omo", LEGACY_PLUGIN_NAME = "oh-my-opencode", ALL_PLUGIN_NAMES, CONFIG_BASENAME = "evil-omo", ALL_CONFIG_BASENAMES, LOG_FILENAME = "evil-omo.log", CACHE_DIR_NAME = "evil-omo", SCHEMA_FILENAME = "evil-omo.schema.json";
 var init_plugin_identity = __esm(() => {
   init_jsonc_parser();
-  ALL_PLUGIN_NAMES = [PLUGIN_NAME];
+  ALL_PLUGIN_NAMES = [PLUGIN_NAME, LEGACY_PLUGIN_NAME];
   ALL_CONFIG_BASENAMES = [CONFIG_BASENAME];
 });
 
@@ -5903,6 +5903,12 @@ var init_snake_case = __esm(() => {
 
 // src/shared/tool-name.ts
 var init_tool_name = () => {};
+
+// src/shared/pattern-matcher.ts
+var regexCache;
+var init_pattern_matcher = __esm(() => {
+  regexCache = new Map;
+});
 // src/shared/file-utils.ts
 var init_file_utils = () => {};
 
@@ -6660,85 +6666,160 @@ var init_agent_tool_restrictions = () => {};
 // src/shared/connected-providers-cache.ts
 import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync } from "fs";
 import { join as join5 } from "path";
-function getCacheFilePath(filename) {
-  return join5(getOmoOpenCodeCacheDir(), filename);
-}
-function ensureCacheDir() {
-  const cacheDir = getOmoOpenCodeCacheDir();
-  if (!existsSync3(cacheDir)) {
-    mkdirSync(cacheDir, { recursive: true });
+function createConnectedProvidersCacheStore(getCacheDir2 = getOmoOpenCodeCacheDir) {
+  function getCacheFilePath(filename) {
+    return join5(getCacheDir2(), filename);
+  }
+  let memConnected;
+  let memProviderModels;
+  function ensureCacheDir() {
+    const cacheDir = getCacheDir2();
+    if (!existsSync3(cacheDir)) {
+      mkdirSync(cacheDir, { recursive: true });
+    }
+  }
+  function readConnectedProvidersCache() {
+    if (memConnected !== undefined)
+      return memConnected;
+    const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE);
+    if (!existsSync3(cacheFile)) {
+      log("[connected-providers-cache] Cache file not found", { cacheFile });
+      memConnected = null;
+      return null;
+    }
+    try {
+      const content = readFileSync2(cacheFile, "utf-8");
+      const data = JSON.parse(content);
+      log("[connected-providers-cache] Read cache", { count: data.connected.length, updatedAt: data.updatedAt });
+      memConnected = data.connected;
+      return data.connected;
+    } catch (err) {
+      log("[connected-providers-cache] Error reading cache", { error: String(err) });
+      memConnected = null;
+      return null;
+    }
   }
-}
-function writeConnectedProvidersCache(connected) {
-  ensureCacheDir();
-  const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE);
-  const data = {
-    connected,
-    updatedAt: new Date().toISOString()
-  };
-  try {
-    writeFileSync2(cacheFile, JSON.stringify(data, null, 2));
-    log("[connected-providers-cache] Cache written", { count: connected.length });
-  } catch (err) {
-    log("[connected-providers-cache] Error writing cache", { error: String(err) });
+  function hasConnectedProvidersCache() {
+    const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE);
+    return existsSync3(cacheFile);
   }
-}
-function hasProviderModelsCache() {
-  const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
-  return existsSync3(cacheFile);
-}
-function writeProviderModelsCache(data) {
-  ensureCacheDir();
-  const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
-  const cacheData = {
-    ...data,
-    updatedAt: new Date().toISOString()
-  };
-  try {
-    writeFileSync2(cacheFile, JSON.stringify(cacheData, null, 2));
-    log("[connected-providers-cache] Provider-models cache written", {
-      providerCount: Object.keys(data.models).length
-    });
-  } catch (err) {
-    log("[connected-providers-cache] Error writing provider-models cache", { error: String(err) });
+  function writeConnectedProvidersCache(connected) {
+    ensureCacheDir();
+    const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE);
+    const data = {
+      connected,
+      updatedAt: new Date().toISOString()
+    };
+    try {
+      writeFileSync2(cacheFile, JSON.stringify(data, null, 2));
+      memConnected = connected;
+      log("[connected-providers-cache] Cache written", { count: connected.length });
+    } catch (err) {
+      log("[connected-providers-cache] Error writing cache", { error: String(err) });
+    }
   }
-}
-async function updateConnectedProvidersCache(client) {
-  if (!client?.provider?.list) {
-    log("[connected-providers-cache] client.provider.list not available");
-    return;
+  function readProviderModelsCache() {
+    if (memProviderModels !== undefined)
+      return memProviderModels;
+    const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
+    if (!existsSync3(cacheFile)) {
+      log("[connected-providers-cache] Provider-models cache file not found", { cacheFile });
+      memProviderModels = null;
+      return null;
+    }
+    try {
+      const content = readFileSync2(cacheFile, "utf-8");
+      const data = JSON.parse(content);
+      log("[connected-providers-cache] Read provider-models cache", {
+        providerCount: Object.keys(data.models).length,
+        updatedAt: data.updatedAt
+      });
+      memProviderModels = data;
+      return data;
+    } catch (err) {
+      log("[connected-providers-cache] Error reading provider-models cache", { error: String(err) });
+      memProviderModels = null;
+      return null;
+    }
   }
-  try {
-    const result = await client.provider.list();
-    const connected = result.data?.connected ?? [];
-    log("[connected-providers-cache] Fetched connected providers", { count: connected.length, providers: connected });
-    writeConnectedProvidersCache(connected);
-    const modelsByProvider = {};
-    const allProviders = result.data?.all ?? [];
-    for (const provider of allProviders) {
-      if (provider.models) {
-        const modelIds = Object.keys(provider.models);
-        if (modelIds.length > 0) {
-          modelsByProvider[provider.id] = modelIds;
-        }
-      }
-    }
-    log("[connected-providers-cache] Extracted models from provider list", {
-      providerCount: Object.keys(modelsByProvider).length,
-      totalModels: Object.values(modelsByProvider).reduce((sum, ids) => sum + ids.length, 0)
-    });
-    writeProviderModelsCache({
-      models: modelsByProvider,
-      connected
-    });
-  } catch (err) {
-    log("[connected-providers-cache] Error updating cache", { error: String(err) });
+  function hasProviderModelsCache() {
+    const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
+    return existsSync3(cacheFile);
+  }
+  function writeProviderModelsCache(data) {
+    ensureCacheDir();
+    const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
+    const cacheData = {
+      ...data,
+      updatedAt: new Date().toISOString()
+    };
+    try {
+      writeFileSync2(cacheFile, JSON.stringify(cacheData, null, 2));
+      memProviderModels = cacheData;
+      log("[connected-providers-cache] Provider-models cache written", {
+        providerCount: Object.keys(data.models).length
+      });
+    } catch (err) {
+      log("[connected-providers-cache] Error writing provider-models cache", { error: String(err) });
+    }
+  }
+  async function updateConnectedProvidersCache(client) {
+    if (!client?.provider?.list) {
+      log("[connected-providers-cache] client.provider.list not available");
+      return;
+    }
+    try {
+      const result = await client.provider.list();
+      const connected = result.data?.connected ?? [];
+      log("[connected-providers-cache] Fetched connected providers", {
+        count: connected.length,
+        providers: connected
+      });
+      writeConnectedProvidersCache(connected);
+      const modelsByProvider = {};
+      const allProviders = result.data?.all ?? [];
+      for (const provider of allProviders) {
+        if (provider.models) {
+          const modelIds = Object.keys(provider.models);
+          if (modelIds.length > 0) {
+            modelsByProvider[provider.id] = modelIds;
+          }
+        }
+      }
+      log("[connected-providers-cache] Extracted models from provider list", {
+        providerCount: Object.keys(modelsByProvider).length,
+        totalModels: Object.values(modelsByProvider).reduce((sum, ids) => sum + ids.length, 0)
+      });
+      writeProviderModelsCache({
+        models: modelsByProvider,
+        connected
+      });
+    } catch (err) {
+      log("[connected-providers-cache] Error updating cache", { error: String(err) });
+    }
   }
+  return {
+    readConnectedProvidersCache,
+    hasConnectedProvidersCache,
+    readProviderModelsCache,
+    hasProviderModelsCache,
+    writeProviderModelsCache,
+    updateConnectedProvidersCache
+  };
 }
-var CONNECTED_PROVIDERS_CACHE_FILE = "connected-providers.json", PROVIDER_MODELS_CACHE_FILE = "provider-models.json";
+var CONNECTED_PROVIDERS_CACHE_FILE = "connected-providers.json", PROVIDER_MODELS_CACHE_FILE = "provider-models.json", defaultConnectedProvidersCacheStore, readConnectedProvidersCache, hasConnectedProvidersCache, readProviderModelsCache, hasProviderModelsCache, writeProviderModelsCache, updateConnectedProvidersCache;
 var init_connected_providers_cache = __esm(() => {
   init_logger();
   init_data_path();
+  defaultConnectedProvidersCacheStore = createConnectedProvidersCacheStore(() => getOmoOpenCodeCacheDir());
+  ({
+    readConnectedProvidersCache,
+    hasConnectedProvidersCache,
+    readProviderModelsCache,
+    hasProviderModelsCache,
+    writeProviderModelsCache,
+    updateConnectedProvidersCache
+  } = defaultConnectedProvidersCacheStore);
 });
 
 // src/shared/model-availability.ts
@@ -7104,6 +7185,7 @@ var init_shared = __esm(() => {
   init_logger();
   init_snake_case();
   init_tool_name();
+  init_pattern_matcher();
   init_deep_merge();
   init_file_utils();
   init_dynamic_truncator();
@@ -7894,7 +7976,7 @@ function logCapturedOutputOnFailure(outputMode, output) {
 }
 async function runBunInstallWithDetails(options) {
   const outputMode = options?.outputMode ?? "pipe";
-  const cacheDir = getOpenCodeCacheDir();
+  const cacheDir = options?.workspaceDir ?? getOpenCodeCacheDir();
   const packageJsonPath = `${cacheDir}/package.json`;
   if (!existsSync9(packageJsonPath)) {
     return {
@@ -8568,12 +8650,30 @@ var init_update_toasts = __esm(() => {
 });
 
 // src/hooks/auto-update-checker/hook/background-update-check.ts
+import { existsSync as existsSync20 } from "fs";
+import { join as join18 } from "path";
 function getPinnedVersionToastMessage(latestVersion) {
   return `Update available: ${latestVersion} (version pinned, update manually)`;
 }
-async function runBunInstallSafe() {
+function resolveActiveInstallWorkspace() {
+  const configPaths = getOpenCodeConfigPaths({ binary: "opencode" });
+  const cacheDir = getOpenCodeCacheDir();
+  const configInstallPath = join18(configPaths.configDir, "node_modules", PACKAGE_NAME2, "package.json");
+  const cacheInstallPath = join18(cacheDir, "node_modules", PACKAGE_NAME2, "package.json");
+  if (existsSync20(configInstallPath)) {
+    log(`[auto-update-checker] Active workspace: config-dir (${configPaths.configDir})`);
+    return configPaths.configDir;
+  }
+  if (existsSync20(cacheInstallPath)) {
+    log(`[auto-update-checker] Active workspace: cache-dir (${cacheDir})`);
+    return cacheDir;
+  }
+  log(`[auto-update-checker] Active workspace: config-dir (default, no install detected)`);
+  return configPaths.configDir;
+}
+async function runBunInstallSafe(workspaceDir) {
   try {
-    const result = await runBunInstallWithDetails({ outputMode: "pipe" });
+    const result = await runBunInstallWithDetails({ outputMode: "pipe", workspaceDir });
     if (!result.success && result.error) {
       log("[auto-update-checker] bun install error:", result.error);
     }
@@ -8624,7 +8724,8 @@ async function runBackgroundUpdateCheck(ctx, autoUpdate, getToastMessage) {
     return;
   }
   invalidatePackage(PACKAGE_NAME2);
-  const installSuccess = await runBunInstallSafe();
+  const activeWorkspace = resolveActiveInstallWorkspace();
+  const installSuccess = await runBunInstallSafe(activeWorkspace);
   if (installSuccess) {
     await showAutoUpdatedToast(ctx, currentVersion, latestVersion);
     log(`[auto-update-checker] Update installed: ${currentVersion} \u2192 ${latestVersion}`);
@@ -8636,6 +8737,7 @@ async function runBackgroundUpdateCheck(ctx, autoUpdate, getToastMessage) {
 var init_background_update_check = __esm(() => {
   init_config_manager();
   init_logger();
+  init_shared();
   init_cache();
   init_constants3();
   init_checker();
@@ -8865,7 +8967,7 @@ var {
 // package.json
 var package_default = {
   name: "evil-omo",
-  version: "3.11.7",
+  version: "3.12.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",
@@ -8941,17 +9043,17 @@ var package_default = {
     typescript: "^5.7.3"
   },
   optionalDependencies: {
-    "evil-omo-darwin-arm64": "3.11.7",
-    "evil-omo-darwin-x64": "3.11.7",
-    "evil-omo-darwin-x64-baseline": "3.11.7",
-    "evil-omo-linux-x64": "3.11.7",
-    "evil-omo-linux-x64-baseline": "3.11.7",
-    "evil-omo-linux-arm64": "3.11.7",
-    "evil-omo-linux-x64-musl": "3.11.7",
-    "evil-omo-linux-x64-musl-baseline": "3.11.7",
-    "evil-omo-linux-arm64-musl": "3.11.7",
-    "evil-omo-windows-x64": "3.11.7",
-    "evil-omo-windows-x64-baseline": "3.11.7"
+    "evil-omo-darwin-arm64": "3.12.2",
+    "evil-omo-darwin-x64": "3.12.2",
+    "evil-omo-darwin-x64-baseline": "3.12.2",
+    "evil-omo-linux-x64": "3.12.2",
+    "evil-omo-linux-x64-baseline": "3.12.2",
+    "evil-omo-linux-arm64": "3.12.2",
+    "evil-omo-linux-x64-musl": "3.12.2",
+    "evil-omo-linux-x64-musl-baseline": "3.12.2",
+    "evil-omo-linux-arm64-musl": "3.12.2",
+    "evil-omo-windows-x64": "3.12.2",
+    "evil-omo-windows-x64-baseline": "3.12.2"
   },
   overrides: {
     "@opencode-ai/sdk": "^1.2.24"
@@ -10320,24 +10422,24 @@ function writePaddedText(text, atLineStart) {
     return { output: text, atLineStart: text.endsWith(`
 `) };
   }
-  let output = "";
+  const parts = [];
   let lineStart = atLineStart;
   for (let i2 = 0;i2 < text.length; i2++) {
     const ch = text[i2];
     if (lineStart) {
-      output += "  ";
+      parts.push("  ");
       lineStart = false;
     }
     if (ch === `
 `) {
-      output += `  
-`;
+      parts.push(`  
+`);
       lineStart = true;
       continue;
     }
-    output += ch;
+    parts.push(ch);
   }
-  return { output, atLineStart: lineStart };
+  return { output: parts.join(""), atLineStart: lineStart };
 }
 function colorizeWithProfileColor(text, hexColor) {
   if (!hexColor)
@@ -24329,6 +24431,11 @@ var BabysittingConfigSchema = exports_external.object({
   timeout_ms: exports_external.number().default(120000)
 });
 // src/config/schema/background-task.ts
+var CircuitBreakerConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().optional(),
+  maxToolCalls: exports_external.number().int().min(10).optional(),
+  consecutiveThreshold: exports_external.number().int().min(5).optional()
+});
 var BackgroundTaskConfigSchema = exports_external.object({
   defaultConcurrency: exports_external.number().min(1).optional(),
   providerConcurrency: exports_external.record(exports_external.string(), exports_external.number().min(0)).optional(),
@@ -24337,7 +24444,9 @@ var BackgroundTaskConfigSchema = exports_external.object({
   maxDescendants: exports_external.number().int().min(1).optional(),
   staleTimeoutMs: exports_external.number().min(60000).optional(),
   messageStalenessTimeoutMs: exports_external.number().min(60000).optional(),
-  syncPollTimeoutMs: exports_external.number().min(60000).optional()
+  syncPollTimeoutMs: exports_external.number().min(60000).optional(),
+  maxToolCalls: exports_external.number().int().min(10).optional(),
+  circuitBreaker: CircuitBreakerConfigSchema.optional()
 });
 // src/config/schema/browser-automation.ts
 var BrowserAutomationProviderSchema = exports_external.enum([
@@ -24515,7 +24624,8 @@ var HookNameSchema = exports_external.enum([
   "write-existing-file-guard",
   "anthropic-effort",
   "hashline-read-enhancer",
-  "read-image-resizer"
+  "read-image-resizer",
+  "todo-description-override"
 ]);
 // src/config/schema/notification.ts
 var NotificationConfigSchema = exports_external.object({
@@ -27154,9 +27264,9 @@ async function run(options) {
   timestampOutput?.enable();
   const pluginConfig = loadPluginConfig(directory, { command: "run" });
   const resolvedAgent = resolveRunAgent(options, pluginConfig);
-  const resolvedModel = resolveRunModel(options.model);
   const abortController = new AbortController;
   try {
+    const resolvedModel = resolveRunModel(options.model);
     const { client: client3, cleanup: serverCleanup } = await createServerConnection({
       port: options.port,
       attach: options.attach,
@@ -27439,30 +27549,30 @@ var PACKAGE_NAME3 = PLUGIN_NAME;
 var OPENCODE_BINARIES2 = ["opencode", "opencode-desktop"];
 
 // src/cli/doctor/checks/system.ts
-import { existsSync as existsSync23, readFileSync as readFileSync21 } from "fs";
+import { existsSync as existsSync24, readFileSync as readFileSync21 } from "fs";
 
 // src/cli/doctor/checks/system-binary.ts
 init_spawn_with_windows_hide();
-import { existsSync as existsSync20 } from "fs";
+import { existsSync as existsSync21 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 function getDesktopAppPaths(platform) {
   const home = homedir5();
   switch (platform) {
     case "darwin":
       return [
         "/Applications/OpenCode.app/Contents/MacOS/OpenCode",
-        join18(home, "Applications", "OpenCode.app", "Contents", "MacOS", "OpenCode")
+        join19(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(join18(programFiles, "OpenCode", "OpenCode.exe"));
+        paths.push(join19(programFiles, "OpenCode", "OpenCode.exe"));
       }
       if (localAppData) {
-        paths.push(join18(localAppData, "OpenCode", "OpenCode.exe"));
+        paths.push(join19(localAppData, "OpenCode", "OpenCode.exe"));
       }
       return paths;
     }
@@ -27470,8 +27580,8 @@ function getDesktopAppPaths(platform) {
       return [
         "/usr/bin/opencode",
         "/usr/lib/opencode/opencode",
-        join18(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
-        join18(home, "Applications", "opencode-desktop-linux-aarch64.AppImage")
+        join19(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
+        join19(home, "Applications", "opencode-desktop-linux-aarch64.AppImage")
       ];
     default:
       return [];
@@ -27483,7 +27593,7 @@ function buildVersionCommand(binaryPath, platform) {
   }
   return [binaryPath, "--version"];
 }
-function findDesktopBinary(platform = process.platform, checkExists = existsSync20) {
+function findDesktopBinary(platform = process.platform, checkExists = existsSync21) {
   for (const desktopPath of getDesktopAppPaths(platform)) {
     if (checkExists(desktopPath)) {
       return { binary: "opencode", path: desktopPath };
@@ -27530,30 +27640,40 @@ function compareVersions(current, minimum) {
 }
 
 // src/cli/doctor/checks/system-plugin.ts
-import { existsSync as existsSync21, readFileSync as readFileSync19 } from "fs";
 init_shared();
+import { existsSync as existsSync22, readFileSync as readFileSync19 } from "fs";
 function detectConfigPath() {
   const paths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
-  if (existsSync21(paths.configJsonc))
+  if (existsSync22(paths.configJsonc))
     return paths.configJsonc;
-  if (existsSync21(paths.configJson))
+  if (existsSync22(paths.configJson))
     return paths.configJson;
   return null;
 }
 function parsePluginVersion(entry) {
-  if (!entry.startsWith(`${PACKAGE_NAME3}@`))
-    return null;
-  const value = entry.slice(PACKAGE_NAME3.length + 1);
-  if (!value || value === "latest")
-    return null;
-  return value;
+  if (entry.startsWith(`${PLUGIN_NAME}@`)) {
+    const value = entry.slice(PLUGIN_NAME.length + 1);
+    if (!value || value === "latest")
+      return null;
+    return value;
+  }
+  if (entry.startsWith(`${LEGACY_PLUGIN_NAME}@`)) {
+    const value = entry.slice(LEGACY_PLUGIN_NAME.length + 1);
+    if (!value || value === "latest")
+      return null;
+    return value;
+  }
+  return null;
 }
 function findPluginEntry2(entries) {
   for (const entry of entries) {
-    if (entry === PACKAGE_NAME3 || entry.startsWith(`${PACKAGE_NAME3}@`)) {
+    if (entry === PLUGIN_NAME || entry.startsWith(`${PLUGIN_NAME}@`)) {
+      return { entry, isLocalDev: false };
+    }
+    if (entry === LEGACY_PLUGIN_NAME || entry.startsWith(`${LEGACY_PLUGIN_NAME}@`)) {
       return { entry, isLocalDev: false };
     }
-    if (entry.startsWith("file://") && entry.includes(PACKAGE_NAME3)) {
+    if (entry.startsWith("file://") && (entry.includes(PLUGIN_NAME) || entry.includes(LEGACY_PLUGIN_NAME))) {
       return { entry, isLocalDev: true };
     }
   }
@@ -27590,7 +27710,7 @@ function getPluginInfo() {
       registered: true,
       configPath,
       entry: pluginEntry.entry,
-      isPinned: pinnedVersion !== null && /^\d+\.\d+\.\d+/.test(pinnedVersion),
+      isPinned: pinnedVersion !== null && /^\d+\.\d+\.\d+/.test(pinnedVersion ?? ""),
       pinnedVersion,
       isLocalDev: pluginEntry.isLocalDev
     };
@@ -27609,29 +27729,29 @@ function getPluginInfo() {
 // src/cli/doctor/checks/system-loaded-version.ts
 init_checker();
 init_auto_update_checker();
-import { existsSync as existsSync22, readFileSync as readFileSync20 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync20 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 init_shared();
 function getPlatformDefaultCacheDir(platform = process.platform) {
   if (platform === "darwin")
-    return join19(homedir6(), "Library", "Caches");
+    return join20(homedir6(), "Library", "Caches");
   if (platform === "win32")
-    return process.env.LOCALAPPDATA ?? join19(homedir6(), "AppData", "Local");
-  return join19(homedir6(), ".cache");
+    return process.env.LOCALAPPDATA ?? join20(homedir6(), "AppData", "Local");
+  return join20(homedir6(), ".cache");
 }
 function resolveOpenCodeCacheDir() {
   const xdgCacheHome = process.env.XDG_CACHE_HOME;
   if (xdgCacheHome)
-    return join19(xdgCacheHome, "opencode");
+    return join20(xdgCacheHome, "opencode");
   const fromShared = getOpenCodeCacheDir();
-  const platformDefault = join19(getPlatformDefaultCacheDir(), "opencode");
-  if (existsSync22(fromShared) || !existsSync22(platformDefault))
+  const platformDefault = join20(getPlatformDefaultCacheDir(), "opencode");
+  if (existsSync23(fromShared) || !existsSync23(platformDefault))
     return fromShared;
   return platformDefault;
 }
 function readPackageJson(filePath) {
-  if (!existsSync22(filePath))
+  if (!existsSync23(filePath))
     return null;
   try {
     const content = readFileSync20(filePath, "utf-8");
@@ -27653,15 +27773,15 @@ function getLoadedPluginVersion() {
     {
       cacheDir: configPaths.configDir,
       cachePackagePath: configPaths.packageJson,
-      installedPackagePath: join19(configPaths.configDir, "node_modules", PACKAGE_NAME3, "package.json")
+      installedPackagePath: join20(configPaths.configDir, "node_modules", PACKAGE_NAME3, "package.json")
     },
     {
       cacheDir,
-      cachePackagePath: join19(cacheDir, "package.json"),
-      installedPackagePath: join19(cacheDir, "node_modules", PACKAGE_NAME3, "package.json")
+      cachePackagePath: join20(cacheDir, "package.json"),
+      installedPackagePath: join20(cacheDir, "node_modules", PACKAGE_NAME3, "package.json")
     }
   ];
-  const selectedCandidate = candidates.find((candidate) => existsSync22(candidate.installedPackagePath)) ?? candidates[0];
+  const selectedCandidate = candidates.find((candidate) => existsSync23(candidate.installedPackagePath)) ?? candidates[0];
   const { cacheDir: selectedDir, cachePackagePath, installedPackagePath } = selectedCandidate;
   const cachePackage = readPackageJson(cachePackagePath);
   const installedPackage = readPackageJson(installedPackagePath);
@@ -27688,7 +27808,7 @@ init_shared();
 function isConfigValid(configPath) {
   if (!configPath)
     return true;
-  if (!existsSync23(configPath))
+  if (!existsSync24(configPath))
     return false;
   try {
     parseJsonc(readFileSync21(configPath, "utf-8"));
@@ -27795,24 +27915,24 @@ async function checkSystem() {
 
 // src/cli/doctor/checks/config.ts
 import { readFileSync as readFileSync24 } from "fs";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 init_shared();
 init_plugin_identity();
 
 // src/cli/doctor/checks/model-resolution-cache.ts
 init_shared();
-import { existsSync as existsSync24, readFileSync as readFileSync22 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync22 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 function getOpenCodeCacheDir2() {
   const xdgCache = process.env.XDG_CACHE_HOME;
   if (xdgCache)
-    return join20(xdgCache, "opencode");
-  return join20(homedir7(), ".cache", "opencode");
+    return join21(xdgCache, "opencode");
+  return join21(homedir7(), ".cache", "opencode");
 }
 function loadAvailableModelsFromCache() {
-  const cacheFile = join20(getOpenCodeCacheDir2(), "models.json");
-  if (!existsSync24(cacheFile)) {
+  const cacheFile = join21(getOpenCodeCacheDir2(), "models.json");
+  if (!existsSync25(cacheFile)) {
     return { providers: [], modelCount: 0, cacheExists: false };
   }
   try {
@@ -27839,9 +27959,9 @@ init_model_requirements();
 init_shared();
 init_plugin_identity();
 import { readFileSync as readFileSync23 } from "fs";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 var USER_CONFIG_DIR2 = getOpenCodeConfigPaths({ binary: "opencode", version: null }).configDir;
-var PROJECT_CONFIG_DIR = join21(process.cwd(), ".opencode");
+var PROJECT_CONFIG_DIR = join22(process.cwd(), ".opencode");
 function loadOmoConfig() {
   const projectDetected = detectManagedConfigFile(PROJECT_CONFIG_DIR);
   if (projectDetected.format !== "none") {
@@ -27866,7 +27986,7 @@ function loadOmoConfig() {
 
 // src/cli/doctor/checks/model-resolution-details.ts
 init_shared();
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 
 // src/cli/doctor/checks/model-resolution-variant.ts
 function formatModelWithVariant(model, variant) {
@@ -27905,7 +28025,7 @@ function getCategoryEffectiveVariant(categoryName, requirement, config2) {
 // src/cli/doctor/checks/model-resolution-details.ts
 function buildModelResolutionDetails(options) {
   const details = [];
-  const cacheFile = join22(getOpenCodeCacheDir(), "models.json");
+  const cacheFile = join23(getOpenCodeCacheDir(), "models.json");
   details.push("\u2550\u2550\u2550 Available Models (from cache) \u2550\u2550\u2550");
   details.push("");
   if (options.available.cacheExists) {
@@ -28018,7 +28138,7 @@ async function checkModels() {
 
 // src/cli/doctor/checks/config.ts
 function findConfigPath() {
-  const projectConfig = detectManagedConfigFile(join23(process.cwd(), ".opencode"));
+  const projectConfig = detectManagedConfigFile(join24(process.cwd(), ".opencode"));
   if (projectConfig.format !== "none")
     return projectConfig.path;
   const userConfig = detectManagedConfigFile(getOpenCodeConfigDir({ binary: "opencode" }));
@@ -28136,9 +28256,9 @@ async function checkConfig() {
 
 // src/cli/doctor/checks/dependencies.ts
 init_spawn_with_windows_hide();
-import { existsSync as existsSync25 } from "fs";
+import { existsSync as existsSync26 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname6, join as join24 } from "path";
+import { dirname as dirname6, join as join25 } from "path";
 async function checkBinaryExists(binary2) {
   try {
     const path10 = Bun.which(binary2);
@@ -28194,15 +28314,15 @@ async function checkAstGrepNapi() {
       path: null
     };
   } catch {
-    const { existsSync: existsSync26 } = await import("fs");
-    const { join: join25 } = await import("path");
+    const { existsSync: existsSync27 } = await import("fs");
+    const { join: join26 } = await import("path");
     const { homedir: homedir8 } = await import("os");
     const pathsToCheck = [
-      join25(homedir8(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
-      join25(process.cwd(), "node_modules", "@ast-grep", "napi")
+      join26(homedir8(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
+      join26(process.cwd(), "node_modules", "@ast-grep", "napi")
     ];
     for (const napiPath of pathsToCheck) {
-      if (existsSync26(napiPath)) {
+      if (existsSync27(napiPath)) {
         return {
           name: "AST-Grep NAPI",
           required: false,
@@ -28227,8 +28347,8 @@ function findCommentCheckerPackageBinary() {
   try {
     const require2 = createRequire(import.meta.url);
     const pkgPath = require2.resolve("@code-yeongyu/comment-checker/package.json");
-    const binaryPath = join24(dirname6(pkgPath), "bin", binaryName);
-    if (existsSync25(binaryPath))
+    const binaryPath = join25(dirname6(pkgPath), "bin", binaryName);
+    if (existsSync26(binaryPath))
       return binaryPath;
   } catch {}
   return null;
@@ -28385,13 +28505,13 @@ var BUILTIN_SERVERS = {
   "kotlin-ls": { command: ["kotlin-lsp"], extensions: [".kt", ".kts"] }
 };
 // src/tools/lsp/server-config-loader.ts
-import { existsSync as existsSync26, readFileSync as readFileSync25 } from "fs";
-import { join as join25 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync25 } from "fs";
+import { join as join26 } from "path";
 init_shared();
 init_jsonc_parser();
 init_plugin_identity();
 function loadJsonFile(path10) {
-  if (!existsSync26(path10))
+  if (!existsSync27(path10))
     return null;
   try {
     return parseJsonc(readFileSync25(path10, "utf-8"));
@@ -28403,9 +28523,9 @@ function getConfigPaths2() {
   const cwd = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   return {
-    project: detectManagedConfigFile(join25(cwd, ".opencode")).path,
+    project: detectManagedConfigFile(join26(cwd, ".opencode")).path,
     user: detectManagedConfigFile(configDir).path,
-    opencode: detectConfigFile(join25(configDir, "opencode")).path
+    opencode: detectConfigFile(join26(configDir, "opencode")).path
   };
 }
 function loadAllConfigs() {
@@ -28474,21 +28594,21 @@ function getMergedServers() {
 }
 
 // src/tools/lsp/server-installation.ts
-import { existsSync as existsSync27 } from "fs";
-import { delimiter as delimiter2, join as join27 } from "path";
+import { existsSync as existsSync28 } from "fs";
+import { delimiter as delimiter2, join as join28 } from "path";
 
 // src/tools/lsp/server-path-bases.ts
 init_shared();
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 function getLspServerAdditionalPathBases(workingDirectory) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join26(getDataDir(), "opencode");
+  const dataDir = join27(getDataDir(), "opencode");
   return [
-    join26(workingDirectory, "node_modules", ".bin"),
-    join26(configDir, "bin"),
-    join26(configDir, "node_modules", ".bin"),
-    join26(dataDir, "bin"),
-    join26(dataDir, "bin", "node_modules", ".bin")
+    join27(workingDirectory, "node_modules", ".bin"),
+    join27(configDir, "bin"),
+    join27(configDir, "node_modules", ".bin"),
+    join27(dataDir, "bin"),
+    join27(dataDir, "bin", "node_modules", ".bin")
   ];
 }
 
@@ -28498,7 +28618,7 @@ function isServerInstalled(command) {
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync27(cmd))
+    if (existsSync28(cmd))
       return true;
   }
   const isWindows = process.platform === "win32";
@@ -28519,14 +28639,14 @@ function isServerInstalled(command) {
   const paths = pathEnv.split(delimiter2);
   for (const p2 of paths) {
     for (const suffix of exts) {
-      if (existsSync27(join27(p2, cmd + suffix))) {
+      if (existsSync28(join28(p2, cmd + suffix))) {
         return true;
       }
     }
   }
   for (const base of getLspServerAdditionalPathBases(process.cwd())) {
     for (const suffix of exts) {
-      if (existsSync27(join27(base, cmd + suffix))) {
+      if (existsSync28(join28(base, cmd + suffix))) {
         return true;
       }
     }
@@ -28588,21 +28708,21 @@ function getInstalledLspServers() {
 
 // src/cli/doctor/checks/tools-mcp.ts
 init_shared();
-import { existsSync as existsSync28, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync29, readFileSync as readFileSync26 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 var BUILTIN_MCP_SERVERS = ["context7", "grep_app"];
 function getMcpConfigPaths() {
   return [
-    join28(homedir8(), ".claude", ".mcp.json"),
-    join28(process.cwd(), ".mcp.json"),
-    join28(process.cwd(), ".claude", ".mcp.json")
+    join29(homedir8(), ".claude", ".mcp.json"),
+    join29(process.cwd(), ".mcp.json"),
+    join29(process.cwd(), ".claude", ".mcp.json")
   ];
 }
 function loadUserMcpConfig() {
   const servers = {};
   for (const configPath of getMcpConfigPaths()) {
-    if (!existsSync28(configPath))
+    if (!existsSync29(configPath))
       continue;
     try {
       const content = readFileSync26(configPath, "utf-8");
@@ -29028,11 +29148,11 @@ async function doctor(options = { mode: "default" }) {
 
 // src/features/mcp-oauth/storage.ts
 init_shared();
-import { chmodSync, existsSync as existsSync29, mkdirSync as mkdirSync6, readFileSync as readFileSync27, unlinkSync as unlinkSync4, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname7, join as join29 } from "path";
+import { chmodSync, existsSync as existsSync30, mkdirSync as mkdirSync6, readFileSync as readFileSync27, unlinkSync as unlinkSync4, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname7, join as join30 } from "path";
 var STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStoragePath() {
-  return join29(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
+  return join30(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
 }
 function normalizeHost(serverHost) {
   let host = serverHost.trim();
@@ -29069,7 +29189,7 @@ function buildKey(serverHost, resource) {
 }
 function readStore() {
   const filePath = getMcpOauthStoragePath();
-  if (!existsSync29(filePath)) {
+  if (!existsSync30(filePath)) {
     return null;
   }
   try {
@@ -29083,7 +29203,7 @@ function writeStore(store2) {
   const filePath = getMcpOauthStoragePath();
   try {
     const dir = dirname7(filePath);
-    if (!existsSync29(dir)) {
+    if (!existsSync30(dir)) {
       mkdirSync6(dir, { recursive: true });
     }
     writeFileSync10(filePath, JSON.stringify(store2, null, 2), { encoding: "utf-8", mode: 384 });
@@ -29118,7 +29238,7 @@ function deleteToken(serverHost, resource) {
   if (Object.keys(store2).length === 0) {
     try {
       const filePath = getMcpOauthStoragePath();
-      if (existsSync29(filePath)) {
+      if (existsSync30(filePath)) {
         unlinkSync4(filePath);
       }
       return true;