oh-my-opencode 3.17.2 → 3.17.4

package/dist/cli/index.js

@@ -4915,6 +4915,42 @@ var init_command_executor = __esm(() => {
 });
 
 // src/shared/contains-path.ts
+import { existsSync, realpathSync } from "fs";
+import { basename, dirname, isAbsolute, join, normalize, relative, resolve } from "path";
+function findNearestExistingAncestor(resolvedPath) {
+  let candidatePath = resolvedPath;
+  while (!existsSync(candidatePath)) {
+    const parentPath = dirname(candidatePath);
+    if (parentPath === candidatePath) {
+      return candidatePath;
+    }
+    candidatePath = parentPath;
+  }
+  return candidatePath;
+}
+function toCanonicalPath(pathToNormalize) {
+  const resolvedPath = resolve(pathToNormalize);
+  if (existsSync(resolvedPath)) {
+    try {
+      return normalize(realpathSync.native(resolvedPath));
+    } catch {
+      return normalize(resolvedPath);
+    }
+  }
+  const nearestExistingAncestor = findNearestExistingAncestor(resolvedPath);
+  const canonicalAncestor = existsSync(nearestExistingAncestor) ? realpathSync.native(nearestExistingAncestor) : nearestExistingAncestor;
+  const relativePathFromAncestor = relative(nearestExistingAncestor, resolvedPath);
+  return normalize(join(canonicalAncestor, relativePathFromAncestor || basename(resolvedPath)));
+}
+function containsPath(rootPath, candidatePath) {
+  const canonicalRootPath = toCanonicalPath(rootPath);
+  const canonicalCandidatePath = toCanonicalPath(candidatePath);
+  const relativePath = relative(canonicalRootPath, canonicalCandidatePath);
+  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute(relativePath);
+}
+function isWithinProject(candidatePath, projectRoot) {
+  return containsPath(projectRoot, candidatePath);
+}
 var init_contains_path = () => {};
 
 // src/shared/plugin-identity.ts
@@ -5018,13 +5054,13 @@ var init_pattern_matcher = __esm(() => {
   regexCache = new Map;
 });
 // src/shared/file-utils.ts
-import { lstatSync, realpathSync } from "fs";
+import { lstatSync, realpathSync as realpathSync2 } from "fs";
 function normalizeDarwinRealpath(filePath) {
   return filePath.startsWith("/private/var/") ? filePath.slice("/private".length) : filePath;
 }
 function resolveSymlink(filePath) {
   try {
-    return normalizeDarwinRealpath(realpathSync(filePath));
+    return normalizeDarwinRealpath(realpathSync2(filePath));
   } catch {
     return filePath;
   }
@@ -5982,8 +6018,8 @@ var init_main = __esm(() => {
 });
 
 // src/shared/jsonc-parser.ts
-import { existsSync, readFileSync } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { join as join4 } from "path";
 function stripBom(content) {
   return content.charCodeAt(0) === 65279 ? content.slice(1) : content;
 }
@@ -6003,17 +6039,17 @@ function parseJsonc(content) {
 function detectConfigFile(basePath) {
   const jsoncPath = `${basePath}.jsonc`;
   const jsonPath = `${basePath}.json`;
-  if (existsSync(jsoncPath)) {
+  if (existsSync2(jsoncPath)) {
     return { format: "jsonc", path: jsoncPath };
   }
-  if (existsSync(jsonPath)) {
+  if (existsSync2(jsonPath)) {
     return { format: "json", path: jsonPath };
   }
   return { format: "none", path: jsonPath };
 }
 function detectPluginConfigFile(dir) {
-  const canonicalResult = detectConfigFile(join3(dir, CONFIG_BASENAME));
-  const legacyResult = detectConfigFile(join3(dir, LEGACY_CONFIG_BASENAME));
+  const canonicalResult = detectConfigFile(join4(dir, CONFIG_BASENAME));
+  const legacyResult = detectConfigFile(join4(dir, LEGACY_CONFIG_BASENAME));
   if (canonicalResult.format !== "none") {
     return {
       ...canonicalResult,
@@ -6023,7 +6059,7 @@ function detectPluginConfigFile(dir) {
   if (legacyResult.format !== "none") {
     return legacyResult;
   }
-  return { format: "none", path: join3(dir, `${CONFIG_BASENAME}.json`) };
+  return { format: "none", path: join4(dir, `${CONFIG_BASENAME}.json`) };
 }
 var init_jsonc_parser = __esm(() => {
   init_main();
@@ -6335,20 +6371,28 @@ function migrateConfigFile(configPath, rawConfig) {
     }
   }
   if (needsWrite) {
+    let finalConfig = JSON.parse(JSON.stringify(copy));
+    const newContent = JSON.stringify(finalConfig, null, 2) + `
+`;
+    let existingContent;
+    try {
+      existingContent = fs3.readFileSync(configPath, "utf-8");
+    } catch {}
+    const contentChanged = existingContent !== newContent;
     const timestamp2 = new Date().toISOString().replace(/[:.]/g, "-");
     const backupPath = `${configPath}.bak.${timestamp2}`;
     let backupSucceeded = false;
-    try {
-      fs3.copyFileSync(configPath, backupPath);
-      backupSucceeded = true;
-    } catch {
-      backupSucceeded = false;
+    if (contentChanged) {
+      try {
+        fs3.copyFileSync(configPath, backupPath);
+        backupSucceeded = true;
+      } catch {
+        backupSucceeded = false;
+      }
     }
     let writeSucceeded = false;
-    let finalConfig = JSON.parse(JSON.stringify(copy));
     try {
-      writeFileAtomically(configPath, JSON.stringify(finalConfig, null, 2) + `
-`);
+      writeFileAtomically(configPath, newContent);
       writeSucceeded = true;
     } catch (err) {
       log(`Failed to write migrated config to ${configPath}:`, err);
@@ -6400,9 +6444,9 @@ var init_migration = __esm(() => {
 });
 
 // src/shared/opencode-config-dir.ts
-import { existsSync as existsSync3, realpathSync as realpathSync2 } from "fs";
+import { existsSync as existsSync4, realpathSync as realpathSync3 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join4, resolve, win32 } from "path";
+import { join as join5, resolve as resolve2, win32 } from "path";
 function isDevBuild(version) {
   if (!version)
     return false;
@@ -6412,24 +6456,24 @@ function getTauriConfigDir(identifier) {
   const platform = process.platform;
   switch (platform) {
     case "darwin":
-      return join4(homedir2(), "Library", "Application Support", identifier);
+      return join5(homedir2(), "Library", "Application Support", identifier);
     case "win32": {
-      const appData = process.env.APPDATA || join4(homedir2(), "AppData", "Roaming");
+      const appData = process.env.APPDATA || join5(homedir2(), "AppData", "Roaming");
       return win32.join(appData, identifier);
     }
     case "linux":
     default: {
-      const xdgConfig = process.env.XDG_CONFIG_HOME || join4(homedir2(), ".config");
-      return join4(xdgConfig, identifier);
+      const xdgConfig = process.env.XDG_CONFIG_HOME || join5(homedir2(), ".config");
+      return join5(xdgConfig, identifier);
     }
   }
 }
 function resolveConfigPath(pathValue) {
-  const resolvedPath = resolve(pathValue);
-  if (!existsSync3(resolvedPath))
+  const resolvedPath = resolve2(pathValue);
+  if (!existsSync4(resolvedPath))
     return resolvedPath;
   try {
-    return realpathSync2(resolvedPath);
+    return realpathSync3(resolvedPath);
   } catch {
     return resolvedPath;
   }
@@ -6439,8 +6483,8 @@ function getCliConfigDir() {
   if (envConfigDir) {
     return resolveConfigPath(envConfigDir);
   }
-  const xdgConfig = process.env.XDG_CONFIG_HOME || join4(homedir2(), ".config");
-  return resolveConfigPath(join4(xdgConfig, "opencode"));
+  const xdgConfig = process.env.XDG_CONFIG_HOME || join5(homedir2(), ".config");
+  return resolveConfigPath(join5(xdgConfig, "opencode"));
 }
 function getOpenCodeConfigDir(options) {
   const { binary: binary2, version, checkExisting = true } = options;
@@ -6452,9 +6496,9 @@ function getOpenCodeConfigDir(options) {
   const tauriDir = process.platform === "win32" ? win32.isAbsolute(tauriDirBase) ? win32.normalize(tauriDirBase) : win32.resolve(tauriDirBase) : resolveConfigPath(tauriDirBase);
   if (checkExisting) {
     const legacyDir = getCliConfigDir();
-    const legacyConfig = join4(legacyDir, "opencode.json");
-    const legacyConfigC = join4(legacyDir, "opencode.jsonc");
-    if (existsSync3(legacyConfig) || existsSync3(legacyConfigC)) {
+    const legacyConfig = join5(legacyDir, "opencode.json");
+    const legacyConfigC = join5(legacyDir, "opencode.jsonc");
+    if (existsSync4(legacyConfig) || existsSync4(legacyConfigC)) {
       return legacyDir;
     }
   }
@@ -6464,10 +6508,10 @@ function getOpenCodeConfigPaths(options) {
   const configDir = getOpenCodeConfigDir(options);
   return {
     configDir,
-    configJson: join4(configDir, "opencode.json"),
-    configJsonc: join4(configDir, "opencode.jsonc"),
-    packageJson: join4(configDir, "package.json"),
-    omoConfig: join4(configDir, `${CONFIG_BASENAME}.json`)
+    configJson: join5(configDir, "opencode.json"),
+    configJsonc: join5(configDir, "opencode.jsonc"),
+    packageJson: join5(configDir, "package.json"),
+    omoConfig: join5(configDir, `${CONFIG_BASENAME}.json`)
   };
 }
 var TAURI_APP_IDENTIFIER = "ai.opencode.desktop", TAURI_APP_IDENTIFIER_DEV = "ai.opencode.desktop.dev";
@@ -6475,6 +6519,25 @@ var init_opencode_config_dir = __esm(() => {
   init_plugin_identity();
 });
 
+// src/shared/resolve-agent-definition-paths.ts
+import { homedir as homedir3 } from "os";
+import { isAbsolute as isAbsolute2, resolve as resolve3 } from "path";
+function resolveAgentDefinitionPaths(paths, baseDir, containmentDir) {
+  return paths.flatMap((p) => {
+    const expanded = p.startsWith("~/") ? p.replace(/^~\//, `${homedir3()}/`) : p;
+    const resolved = isAbsolute2(expanded) ? expanded : resolve3(baseDir, expanded);
+    if (containmentDir !== null && !isWithinProject(resolved, containmentDir)) {
+      log(`agent_definitions path rejected (outside project boundary): ${p} -> ${resolved}`);
+      return [];
+    }
+    return [resolved];
+  });
+}
+var init_resolve_agent_definition_paths = __esm(() => {
+  init_contains_path();
+  init_logger();
+});
+
 // src/shared/opencode-version.ts
 import { execSync } from "child_process";
 function parseVersion(version) {
@@ -6526,8 +6589,8 @@ var init_opencode_version = __esm(() => {
 });
 
 // src/shared/opencode-storage-detection.ts
-import { existsSync as existsSync4 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { join as join6 } from "path";
 function isSqliteBackend() {
   if (cachedResult === true)
     return true;
@@ -6535,8 +6598,8 @@ function isSqliteBackend() {
     return false;
   const check = () => {
     const versionOk = isOpenCodeVersionAtLeast(OPENCODE_SQLITE_VERSION);
-    const dbPath = join5(getDataDir(), "opencode", "opencode.db");
-    return versionOk && existsSync4(dbPath);
+    const dbPath = join6(getDataDir(), "opencode", "opencode.db");
+    return versionOk && existsSync5(dbPath);
   };
   if (cachedResult === FALSE_PENDING_RETRY) {
     const result2 = check();
@@ -6608,17 +6671,94 @@ var init_zip_extractor = __esm(() => {
 });
 
 // src/shared/binary-downloader.ts
-import { chmodSync, existsSync as existsSync5, mkdirSync as mkdirSync3, unlinkSync as unlinkSync2 } from "fs";
+import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync3, unlinkSync as unlinkSync2 } from "fs";
 import * as path4 from "path";
 function getCachedBinaryPath(cacheDir, binaryName) {
   const binaryPath = path4.join(cacheDir, binaryName);
-  return existsSync5(binaryPath) ? binaryPath : null;
+  return existsSync6(binaryPath) ? binaryPath : null;
 }
 var init_binary_downloader = __esm(() => {
   init_archive_entry_validator();
   init_zip_extractor();
 });
 
+// src/shared/agent-display-names.ts
+function stripInvisibleAgentCharacters(agentName) {
+  return agentName.replace(INVISIBLE_AGENT_CHARACTERS_REGEX, "");
+}
+function stripAgentListSortPrefix(agentName) {
+  return stripInvisibleAgentCharacters(agentName);
+}
+function getAgentRuntimeName(configKey) {
+  const displayName = getAgentDisplayName(configKey);
+  const prefix = AGENT_LIST_SORT_PREFIXES[configKey.toLowerCase()];
+  return prefix ? `${prefix}${displayName}` : displayName;
+}
+function getAgentDisplayName(configKey) {
+  const exactMatch = AGENT_DISPLAY_NAMES[configKey];
+  if (exactMatch !== undefined)
+    return exactMatch;
+  const lowerKey = configKey.toLowerCase();
+  for (const [k, v] of Object.entries(AGENT_DISPLAY_NAMES)) {
+    if (k.toLowerCase() === lowerKey)
+      return v;
+  }
+  return configKey;
+}
+function resolveKnownAgentConfigKey(agentName) {
+  const lower = stripAgentListSortPrefix(agentName).trim().toLowerCase();
+  const reversed = REVERSE_DISPLAY_NAMES[lower];
+  if (reversed !== undefined)
+    return reversed;
+  const legacy = LEGACY_DISPLAY_NAMES[lower];
+  if (legacy !== undefined)
+    return legacy;
+  if (AGENT_DISPLAY_NAMES[lower] !== undefined)
+    return lower;
+  return;
+}
+function getAgentConfigKey(agentName) {
+  const lower = stripAgentListSortPrefix(agentName).trim().toLowerCase();
+  return resolveKnownAgentConfigKey(agentName) ?? lower;
+}
+var AGENT_DISPLAY_NAMES, AGENT_LIST_SORT_PREFIXES, INVISIBLE_AGENT_CHARACTERS_REGEX, REVERSE_DISPLAY_NAMES, LEGACY_DISPLAY_NAMES;
+var init_agent_display_names = __esm(() => {
+  AGENT_DISPLAY_NAMES = {
+    sisyphus: "Sisyphus - Ultraworker",
+    hephaestus: "Hephaestus - Deep Agent",
+    prometheus: "Prometheus - Plan Builder",
+    atlas: "Atlas - Plan Executor",
+    "sisyphus-junior": "Sisyphus-Junior",
+    metis: "Metis - Plan Consultant",
+    momus: "Momus - Plan Critic",
+    athena: "Athena - Council",
+    "athena-junior": "Athena-Junior - Council",
+    oracle: "oracle",
+    librarian: "librarian",
+    explore: "explore",
+    "multimodal-looker": "multimodal-looker",
+    "council-member": "council-member"
+  };
+  AGENT_LIST_SORT_PREFIXES = {
+    sisyphus: "\u200B",
+    hephaestus: "\u200B\u200B",
+    prometheus: "\u200B\u200B\u200B",
+    atlas: "\u200B\u200B\u200B\u200B"
+  };
+  INVISIBLE_AGENT_CHARACTERS_REGEX = /[\u200B\u200C\u200D\uFEFF]/g;
+  REVERSE_DISPLAY_NAMES = Object.fromEntries(Object.entries(AGENT_DISPLAY_NAMES).map(([key, displayName]) => [displayName.toLowerCase(), key]));
+  LEGACY_DISPLAY_NAMES = {
+    "sisyphus (ultraworker)": "sisyphus",
+    "hephaestus (deep agent)": "hephaestus",
+    "prometheus (plan builder)": "prometheus",
+    "atlas (plan executor)": "atlas",
+    "metis (plan consultant)": "metis",
+    "momus (plan critic)": "momus",
+    "athena (council)": "athena",
+    "athena-junior (council)": "athena-junior"
+  };
+});
+
 // src/shared/model-requirements.ts
 var AGENT_MODEL_REQUIREMENTS, CATEGORY_MODEL_REQUIREMENTS;
 var init_model_requirements = __esm(() => {
@@ -6945,6 +7085,7 @@ var init_model_requirements = __esm(() => {
 
 // src/shared/agent-variant.ts
 var init_agent_variant = __esm(() => {
+  init_agent_display_names();
   init_model_requirements();
 });
 
@@ -6963,6 +7104,9 @@ function detectShellType() {
     }
     return "unix";
   }
+  if (process.env.MSYSTEM) {
+    return "unix";
+  }
   if (process.env.PSModulePath) {
     return "powershell";
   }
@@ -6973,7 +7117,9 @@ function detectShellType() {
 var init_system_directive = () => {};
 
 // src/shared/agent-tool-restrictions.ts
-var init_agent_tool_restrictions = () => {};
+var init_agent_tool_restrictions = __esm(() => {
+  init_agent_display_names();
+});
 
 // src/shared/model-normalization.ts
 function normalizeModelID(modelID) {
@@ -6981,19 +7127,19 @@ function normalizeModelID(modelID) {
 }
 
 // src/shared/json-file-cache-store.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { join as join8 } from "path";
 function toLogLabel(cacheLabel) {
   return cacheLabel.toLowerCase();
 }
 function createJsonFileCacheStore(options) {
   let memoryValue;
   function getCacheFilePath() {
-    return join7(options.getCacheDir(), options.filename);
+    return join8(options.getCacheDir(), options.filename);
   }
   function ensureCacheDir() {
     const cacheDir = options.getCacheDir();
-    if (!existsSync6(cacheDir)) {
+    if (!existsSync7(cacheDir)) {
       mkdirSync4(cacheDir, { recursive: true });
     }
   }
@@ -7002,13 +7148,13 @@ function createJsonFileCacheStore(options) {
       return memoryValue;
     }
     const cacheFile = getCacheFilePath();
-    if (!existsSync6(cacheFile)) {
+    if (!existsSync7(cacheFile)) {
       memoryValue = null;
       log(`[${options.logPrefix}] ${options.cacheLabel} file not found`, { cacheFile });
       return null;
     }
     try {
-      const content = readFileSync3(cacheFile, "utf-8");
+      const content = readFileSync4(cacheFile, "utf-8");
       const value = JSON.parse(content);
       memoryValue = value;
       log(`[${options.logPrefix}] Read ${toLogLabel(options.cacheLabel)}`, options.describe(value));
@@ -7022,7 +7168,7 @@ function createJsonFileCacheStore(options) {
     }
   }
   function has() {
-    return existsSync6(getCacheFilePath());
+    return existsSync7(getCacheFilePath());
   }
   function write(value) {
     ensureCacheDir();
@@ -7191,14 +7337,14 @@ var init_connected_providers_cache = __esm(() => {
 });
 
 // src/shared/model-availability.ts
-import { existsSync as existsSync7, readFileSync as readFileSync4 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
+import { join as join9 } from "path";
 function isModelCacheAvailable() {
   if (hasProviderModelsCache()) {
     return true;
   }
-  const cacheFile = join8(getOpenCodeCacheDir(), "models.json");
-  return existsSync7(cacheFile);
+  const cacheFile = join9(getOpenCodeCacheDir(), "models.json");
+  return existsSync8(cacheFile);
 }
 var init_model_availability = __esm(() => {
   init_logger();
@@ -48487,19 +48633,19 @@ var init_constants = __esm(() => {
 });
 
 // src/shared/opencode-storage-paths.ts
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 var OPENCODE_STORAGE, MESSAGE_STORAGE, PART_STORAGE, SESSION_STORAGE;
 var init_opencode_storage_paths = __esm(() => {
   init_data_path();
   OPENCODE_STORAGE = getOpenCodeStorageDir();
-  MESSAGE_STORAGE = join9(OPENCODE_STORAGE, "message");
-  PART_STORAGE = join9(OPENCODE_STORAGE, "part");
-  SESSION_STORAGE = join9(OPENCODE_STORAGE, "session");
+  MESSAGE_STORAGE = join10(OPENCODE_STORAGE, "message");
+  PART_STORAGE = join10(OPENCODE_STORAGE, "part");
+  SESSION_STORAGE = join10(OPENCODE_STORAGE, "session");
 });
 
 // src/shared/compaction-marker.ts
-import { existsSync as existsSync8, readdirSync, readFileSync as readFileSync5 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync9, readdirSync, readFileSync as readFileSync6 } from "fs";
+import { join as join11 } from "path";
 function isCompactionPart(part) {
   return typeof part === "object" && part !== null && part.type === "compaction";
 }
@@ -48513,20 +48659,20 @@ function isCompactionMessage(message) {
   return isCompactionAgent(message.info?.agent ?? message.agent) || hasCompactionPart(message.parts);
 }
 function getCompactionPartStorageDir(messageID) {
-  return join10(PART_STORAGE, messageID);
+  return join11(PART_STORAGE, messageID);
 }
 function hasCompactionPartInStorage(messageID) {
   if (!messageID) {
     return false;
   }
   const partDir = getCompactionPartStorageDir(messageID);
-  if (!existsSync8(partDir)) {
+  if (!existsSync9(partDir)) {
     return false;
   }
   try {
     return readdirSync(partDir).filter((fileName) => fileName.endsWith(".json")).some((fileName) => {
       try {
-        const content = readFileSync5(join10(partDir, fileName), "utf-8");
+        const content = readFileSync6(join11(partDir, fileName), "utf-8");
         return isCompactionPart(JSON.parse(content));
       } catch {
         return false;
@@ -48559,23 +48705,23 @@ var init_hook_message_injector = __esm(() => {
 });
 
 // src/shared/opencode-message-dir.ts
-import { existsSync as existsSync9, readdirSync as readdirSync2 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync2 } from "fs";
+import { join as join12 } from "path";
 function getMessageDir(sessionID) {
   if (!sessionID.startsWith("ses_"))
     return null;
   if (/[/\\]|\.\./.test(sessionID))
     return null;
-  if (!existsSync9(MESSAGE_STORAGE))
+  if (!existsSync10(MESSAGE_STORAGE))
     return null;
-  const directPath = join11(MESSAGE_STORAGE, sessionID);
-  if (existsSync9(directPath)) {
+  const directPath = join12(MESSAGE_STORAGE, sessionID);
+  if (existsSync10(directPath)) {
     return directPath;
   }
   try {
     for (const dir of readdirSync2(MESSAGE_STORAGE)) {
-      const sessionPath = join11(MESSAGE_STORAGE, dir, sessionID);
-      if (existsSync9(sessionPath)) {
+      const sessionPath = join12(MESSAGE_STORAGE, dir, sessionID);
+      if (existsSync10(sessionPath)) {
         return sessionPath;
       }
     }
@@ -48590,72 +48736,6 @@ var init_opencode_message_dir = __esm(() => {
   init_logger();
 });
 
-// src/shared/agent-display-names.ts
-function stripInvisibleAgentCharacters(agentName) {
-  return agentName.replace(INVISIBLE_AGENT_CHARACTERS_REGEX, "");
-}
-function stripAgentListSortPrefix(agentName) {
-  return stripInvisibleAgentCharacters(agentName);
-}
-function getAgentDisplayName(configKey) {
-  const exactMatch = AGENT_DISPLAY_NAMES[configKey];
-  if (exactMatch !== undefined)
-    return exactMatch;
-  const lowerKey = configKey.toLowerCase();
-  for (const [k, v] of Object.entries(AGENT_DISPLAY_NAMES)) {
-    if (k.toLowerCase() === lowerKey)
-      return v;
-  }
-  return configKey;
-}
-function resolveKnownAgentConfigKey(agentName) {
-  const lower = stripAgentListSortPrefix(agentName).trim().toLowerCase();
-  const reversed = REVERSE_DISPLAY_NAMES[lower];
-  if (reversed !== undefined)
-    return reversed;
-  const legacy = LEGACY_DISPLAY_NAMES[lower];
-  if (legacy !== undefined)
-    return legacy;
-  if (AGENT_DISPLAY_NAMES[lower] !== undefined)
-    return lower;
-  return;
-}
-function getAgentConfigKey(agentName) {
-  const lower = stripAgentListSortPrefix(agentName).trim().toLowerCase();
-  return resolveKnownAgentConfigKey(agentName) ?? lower;
-}
-var AGENT_DISPLAY_NAMES, INVISIBLE_AGENT_CHARACTERS_REGEX, REVERSE_DISPLAY_NAMES, LEGACY_DISPLAY_NAMES;
-var init_agent_display_names = __esm(() => {
-  AGENT_DISPLAY_NAMES = {
-    sisyphus: "Sisyphus - Ultraworker",
-    hephaestus: "Hephaestus - Deep Agent",
-    prometheus: "Prometheus - Plan Builder",
-    atlas: "Atlas - Plan Executor",
-    "sisyphus-junior": "Sisyphus-Junior",
-    metis: "Metis - Plan Consultant",
-    momus: "Momus - Plan Critic",
-    athena: "Athena - Council",
-    "athena-junior": "Athena-Junior - Council",
-    oracle: "oracle",
-    librarian: "librarian",
-    explore: "explore",
-    "multimodal-looker": "multimodal-looker",
-    "council-member": "council-member"
-  };
-  INVISIBLE_AGENT_CHARACTERS_REGEX = /[\u200B\u200C\u200D\uFEFF]/g;
-  REVERSE_DISPLAY_NAMES = Object.fromEntries(Object.entries(AGENT_DISPLAY_NAMES).map(([key, displayName]) => [displayName.toLowerCase(), key]));
-  LEGACY_DISPLAY_NAMES = {
-    "sisyphus (ultraworker)": "sisyphus",
-    "hephaestus (deep agent)": "hephaestus",
-    "prometheus (plan builder)": "prometheus",
-    "atlas (plan executor)": "atlas",
-    "metis (plan consultant)": "metis",
-    "momus (plan critic)": "momus",
-    "athena (council)": "athena",
-    "athena-junior (council)": "athena-junior"
-  };
-});
-
 // src/shared/session-utils.ts
 var init_session_utils = __esm(() => {
   init_hook_message_injector();
@@ -48742,6 +48822,12 @@ var init_model_suggestion_retry = __esm(() => {
 var init_opencode_server_auth = __esm(() => {
   init_logger();
 });
+
+// src/shared/opencode-provider-auth.ts
+var init_opencode_provider_auth = __esm(() => {
+  init_data_path();
+  init_logger();
+});
 // src/shared/opencode-http-api.ts
 var init_opencode_http_api = __esm(() => {
   init_opencode_server_auth();
@@ -48992,6 +49078,7 @@ var init_shared = __esm(() => {
   init_jsonc_parser();
   init_migration();
   init_opencode_config_dir();
+  init_resolve_agent_definition_paths();
   init_opencode_version();
   init_opencode_storage_detection();
   init_external_plugin_detector();
@@ -49016,6 +49103,7 @@ var init_shared = __esm(() => {
   init_tmux();
   init_model_suggestion_retry();
   init_opencode_server_auth();
+  init_opencode_provider_auth();
   init_opencode_http_api();
   init_port_utils();
   init_git_worktree();
@@ -49110,17 +49198,17 @@ var init_plugin_name_with_version = __esm(() => {
 });
 
 // src/cli/config-manager/backup-config.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync10, mkdirSync as mkdirSync5 } from "fs";
-import { dirname as dirname2 } from "path";
+import { copyFileSync as copyFileSync2, existsSync as existsSync11, mkdirSync as mkdirSync5 } from "fs";
+import { dirname as dirname3 } from "path";
 function backupConfigFile(configPath) {
-  if (!existsSync10(configPath)) {
+  if (!existsSync11(configPath)) {
     return { success: true };
   }
   const timestamp2 = new Date().toISOString().replace(/[:.]/g, "-");
   const backupPath = `${configPath}.backup-${timestamp2}`;
   try {
-    const dir = dirname2(backupPath);
-    if (!existsSync10(dir)) {
+    const dir = dirname3(backupPath);
+    if (!existsSync11(dir)) {
       mkdirSync5(dir, { recursive: true });
     }
     copyFileSync2(configPath, backupPath);
@@ -49135,10 +49223,10 @@ function backupConfigFile(configPath) {
 var init_backup_config = () => {};
 
 // src/cli/config-manager/ensure-config-directory-exists.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync6 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync6 } from "fs";
 function ensureConfigDirectoryExists() {
   const configDir = getConfigDir();
-  if (!existsSync11(configDir)) {
+  if (!existsSync12(configDir)) {
     mkdirSync6(configDir, { recursive: true });
   }
 }
@@ -49176,14 +49264,14 @@ function formatErrorWithSuggestion(err, context) {
 }
 
 // src/cli/config-manager/opencode-config-format.ts
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 function detectConfigFormat() {
   const configJsonc = getConfigJsonc();
   const configJson = getConfigJson();
-  if (existsSync12(configJsonc)) {
+  if (existsSync13(configJsonc)) {
     return { format: "jsonc", path: configJsonc };
   }
-  if (existsSync12(configJson)) {
+  if (existsSync13(configJson)) {
     return { format: "json", path: configJson };
   }
   return { format: "none", path: configJson };
@@ -49193,7 +49281,7 @@ var init_opencode_config_format = __esm(() => {
 });
 
 // src/cli/config-manager/parse-opencode-config-file.ts
-import { readFileSync as readFileSync6, statSync } from "fs";
+import { readFileSync as readFileSync7, statSync } from "fs";
 function isEmptyOrWhitespace(content) {
   return content.trim().length === 0;
 }
@@ -49203,7 +49291,7 @@ function parseOpenCodeConfigFileWithError(path5) {
     if (stat.size === 0) {
       return { config: null, error: `Config file is empty: ${path5}. Delete it or add valid JSON content.` };
     }
-    const content = readFileSync6(path5, "utf-8");
+    const content = readFileSync7(path5, "utf-8");
     if (isEmptyOrWhitespace(content)) {
       return { config: null, error: `Config file contains only whitespace: ${path5}. Delete it or add valid JSON content.` };
     }
@@ -49309,7 +49397,7 @@ function extractVersionFromPluginEntry(entry) {
 }
 
 // src/cli/config-manager/add-plugin-to-opencode-config.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "fs";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
 async function addPluginToOpenCodeConfig(currentVersion) {
   try {
     ensureConfigDirectoryExists();
@@ -49366,7 +49454,7 @@ async function addPluginToOpenCodeConfig(currentVersion) {
     normalizedPlugins.push(pluginEntry);
     config.plugin = normalizedPlugins;
     if (format2 === "jsonc") {
-      const content = readFileSync7(path5, "utf-8");
+      const content = readFileSync8(path5, "utf-8");
       const pluginArrayRegex = /((?:"plugin"|plugin)\s*:\s*)\[([\s\S]*?)\]/;
       const match = content.match(pluginArrayRegex);
       if (match) {
@@ -49520,7 +49608,7 @@ function transformModelForProvider2(provider, model) {
     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;
   }
   return model;
 }
@@ -49722,12 +49810,12 @@ var init_generate_omo_config = __esm(() => {
 });
 
 // src/shared/migrate-legacy-config-file.ts
-import { existsSync as existsSync13, readFileSync as readFileSync8, renameSync as renameSync2, rmSync } from "fs";
-import { join as join12, dirname as dirname3, basename } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync9, renameSync as renameSync2, rmSync } from "fs";
+import { join as join13, dirname as dirname4, basename as basename2 } from "path";
 function buildCanonicalPath(legacyPath) {
-  const dir = dirname3(legacyPath);
-  const ext = basename(legacyPath).includes(".jsonc") ? ".jsonc" : ".json";
-  return join12(dir, `${CONFIG_BASENAME}${ext}`);
+  const dir = dirname4(legacyPath);
+  const ext = basename2(legacyPath).includes(".jsonc") ? ".jsonc" : ".json";
+  return join13(dir, `${CONFIG_BASENAME}${ext}`);
 }
 function archiveLegacyConfigFile(legacyPath) {
   const backupPath = `${legacyPath}.bak`;
@@ -49759,15 +49847,15 @@ function archiveLegacyConfigFile(legacyPath) {
   }
 }
 function migrateLegacyConfigFile(legacyPath) {
-  if (!existsSync13(legacyPath))
+  if (!existsSync14(legacyPath))
     return false;
-  if (!basename(legacyPath).startsWith(LEGACY_CONFIG_BASENAME))
+  if (!basename2(legacyPath).startsWith(LEGACY_CONFIG_BASENAME))
     return false;
   const canonicalPath = buildCanonicalPath(legacyPath);
-  if (existsSync13(canonicalPath))
+  if (existsSync14(canonicalPath))
     return false;
   try {
-    const content = readFileSync8(legacyPath, "utf-8");
+    const content = readFileSync9(legacyPath, "utf-8");
     writeFileAtomically(canonicalPath, content);
     const archivedLegacyConfig = archiveLegacyConfigFile(legacyPath);
     log("[migrateLegacyConfigFile] Migrated legacy config to canonical path", {
@@ -49805,8 +49893,8 @@ function deepMergeRecord(target, source) {
 }
 
 // src/cli/config-manager/write-omo-config.ts
-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";
+import { existsSync as existsSync15, readFileSync as readFileSync10, statSync as statSync2, writeFileSync as writeFileSync4 } from "fs";
+import { basename as basename3, dirname as dirname5, extname, join as join14 } from "path";
 function isEmptyOrWhitespace2(content) {
   return content.trim().length === 0;
 }
@@ -49821,12 +49909,12 @@ function writeOmoConfig(installConfig) {
     };
   }
   const detectedConfigPath = getOmoConfigPath();
-  const canonicalConfigPath = join13(dirname4(detectedConfigPath), `${CONFIG_BASENAME}${extname(detectedConfigPath) || ".json"}`);
-  const shouldMigrateLegacyPath = basename2(detectedConfigPath).startsWith(LEGACY_CONFIG_BASENAME);
-  const omoConfigPath = shouldMigrateLegacyPath ? migrateLegacyConfigFile(detectedConfigPath) || existsSync14(canonicalConfigPath) ? canonicalConfigPath : detectedConfigPath : detectedConfigPath;
+  const canonicalConfigPath = join14(dirname5(detectedConfigPath), `${CONFIG_BASENAME}${extname(detectedConfigPath) || ".json"}`);
+  const shouldMigrateLegacyPath = basename3(detectedConfigPath).startsWith(LEGACY_CONFIG_BASENAME);
+  const omoConfigPath = shouldMigrateLegacyPath ? migrateLegacyConfigFile(detectedConfigPath) || existsSync15(canonicalConfigPath) ? canonicalConfigPath : detectedConfigPath : detectedConfigPath;
   try {
     const newConfig = generateOmoConfig(installConfig);
-    if (existsSync14(omoConfigPath)) {
+    if (existsSync15(omoConfigPath)) {
       const backupResult = backupConfigFile(omoConfigPath);
       if (!backupResult.success) {
         return {
@@ -49837,7 +49925,7 @@ function writeOmoConfig(installConfig) {
       }
       try {
         const stat = statSync2(omoConfigPath);
-        const content = readFileSync9(omoConfigPath, "utf-8");
+        const content = readFileSync10(omoConfigPath, "utf-8");
         if (stat.size === 0 || isEmptyOrWhitespace2(content)) {
           writeFileSync4(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
 `);
@@ -49896,8 +49984,8 @@ function toReadableStream(stream) {
 function wrapNodeProcess(proc) {
   let resolveExited;
   let exitCode = null;
-  const exited = new Promise((resolve2) => {
-    resolveExited = resolve2;
+  const exited = new Promise((resolve4) => {
+    resolveExited = resolve4;
   });
   proc.on("exit", (code) => {
     exitCode = code ?? 1;
@@ -49980,10 +50068,10 @@ var init_opencode_binary = __esm(() => {
 });
 
 // src/cli/config-manager/detect-current-config.ts
-import { existsSync as existsSync15, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync11 } from "fs";
 function detectProvidersFromOmoConfig() {
   const omoConfigPath = getOmoConfigPath();
-  if (!existsSync15(omoConfigPath)) {
+  if (!existsSync16(omoConfigPath)) {
     return {
       hasOpenAI: true,
       hasOpencodeZen: true,
@@ -49994,7 +50082,7 @@ function detectProvidersFromOmoConfig() {
     };
   }
   try {
-    const content = readFileSync10(omoConfigPath, "utf-8");
+    const content = readFileSync11(omoConfigPath, "utf-8");
     const omoConfig = parseJsonc(content);
     if (!omoConfig || typeof omoConfig !== "object") {
       return {
@@ -50083,10 +50171,10 @@ var init_detect_current_config = __esm(() => {
 });
 
 // src/cli/config-manager/bun-install.ts
-import { existsSync as existsSync16 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync17 } from "fs";
+import { join as join15 } from "path";
 function getDefaultWorkspaceDir() {
-  return join14(getOpenCodeCacheDir(), "packages");
+  return join15(getOpenCodeCacheDir(), "packages");
 }
 function readProcessOutput(stream) {
   if (!stream) {
@@ -50112,7 +50200,7 @@ async function runBunInstallWithDetails(options) {
   const outputMode = options?.outputMode ?? "pipe";
   const cacheDir = options?.workspaceDir ?? getDefaultWorkspaceDir();
   const packageJsonPath = `${cacheDir}/package.json`;
-  if (!existsSync16(packageJsonPath)) {
+  if (!existsSync17(packageJsonPath)) {
     return {
       success: false,
       error: `Workspace not initialized: ${packageJsonPath} not found. OpenCode should create this on first run.`
@@ -50126,8 +50214,8 @@ async function runBunInstallWithDetails(options) {
     });
     const outputPromise = Promise.all([readProcessOutput(proc.stdout), readProcessOutput(proc.stderr)]).then(([stdout, stderr]) => ({ stdout, stderr }));
     let timeoutId;
-    const timeoutPromise = new Promise((resolve2) => {
-      timeoutId = setTimeout(() => resolve2("timeout"), BUN_INSTALL_TIMEOUT_MS);
+    const timeoutPromise = new Promise((resolve4) => {
+      timeoutId = setTimeout(() => resolve4("timeout"), BUN_INSTALL_TIMEOUT_MS);
     });
     const exitPromise = proc.exited.then(() => "completed");
     const result = await Promise.race([exitPromise, timeoutPromise]);
@@ -50338,12 +50426,12 @@ var require_isexe = __commonJS((exports2, module) => {
       if (typeof Promise !== "function") {
         throw new TypeError("callback not provided");
       }
-      return new Promise(function(resolve2, reject) {
+      return new Promise(function(resolve4, reject) {
         isexe(path6, options || {}, function(er, is) {
           if (er) {
             reject(er);
           } else {
-            resolve2(is);
+            resolve4(is);
           }
         });
       });
@@ -50405,27 +50493,27 @@ var require_which = __commonJS((exports2, module) => {
       opt = {};
     const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
     const found = [];
-    const step = (i2) => new Promise((resolve2, reject) => {
+    const step = (i2) => new Promise((resolve4, reject) => {
       if (i2 === pathEnv.length)
-        return opt.all && found.length ? resolve2(found) : reject(getNotFoundError(cmd));
+        return opt.all && found.length ? resolve4(found) : reject(getNotFoundError(cmd));
       const ppRaw = pathEnv[i2];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
       const pCmd = path6.join(pathPart, cmd);
       const p2 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-      resolve2(subStep(p2, i2, 0));
+      resolve4(subStep(p2, i2, 0));
     });
-    const subStep = (p2, i2, ii) => new Promise((resolve2, reject) => {
+    const subStep = (p2, i2, ii) => new Promise((resolve4, reject) => {
       if (ii === pathExt.length)
-        return resolve2(step(i2 + 1));
+        return resolve4(step(i2 + 1));
       const ext = pathExt[ii];
       isexe(p2 + ext, { pathExt: pathExtExe }, (er, is) => {
         if (!er && is) {
           if (opt.all)
             found.push(p2 + ext);
           else
-            return resolve2(p2 + ext);
+            return resolve4(p2 + ext);
         }
-        return resolve2(subStep(p2, i2, ii + 1));
+        return resolve4(subStep(p2, i2, ii + 1));
       });
     });
     return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -51278,8 +51366,8 @@ var init_update_toasts = __esm(() => {
 });
 
 // src/hooks/auto-update-checker/hook/background-update-check.ts
-import { existsSync as existsSync28 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync29 } from "fs";
+import { join as join28 } from "path";
 function getCacheWorkspaceDir(deps) {
   return deps.join(deps.getOpenCodeCacheDir(), "packages");
 }
@@ -51397,8 +51485,8 @@ var init_background_update_check = __esm(() => {
   init_checker();
   init_update_toasts();
   defaultDeps = {
-    existsSync: existsSync28,
-    join: join27,
+    existsSync: existsSync29,
+    join: join28,
     runBunInstallWithDetails,
     log,
     getOpenCodeCacheDir,
@@ -51551,7 +51639,7 @@ async function showSpinnerToast(ctx, version3, message) {
         duration: frameInterval + 50
       }
     }).catch(() => {});
-    await new Promise((resolve2) => setTimeout(resolve2, frameInterval));
+    await new Promise((resolve4) => setTimeout(resolve4, frameInterval));
   }
 }
 var SISYPHUS_SPINNER;
@@ -51691,7 +51779,7 @@ var {
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "3.17.2",
+  version: "3.17.4",
   description: "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   main: "./dist/index.js",
   types: "dist/index.d.ts",
@@ -51770,17 +51858,17 @@ var package_default = {
     typescript: "^5.7.3"
   },
   optionalDependencies: {
-    "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"
+    "oh-my-opencode-darwin-arm64": "3.17.4",
+    "oh-my-opencode-darwin-x64": "3.17.4",
+    "oh-my-opencode-darwin-x64-baseline": "3.17.4",
+    "oh-my-opencode-linux-arm64": "3.17.4",
+    "oh-my-opencode-linux-arm64-musl": "3.17.4",
+    "oh-my-opencode-linux-x64": "3.17.4",
+    "oh-my-opencode-linux-x64-baseline": "3.17.4",
+    "oh-my-opencode-linux-x64-musl": "3.17.4",
+    "oh-my-opencode-linux-x64-musl-baseline": "3.17.4",
+    "oh-my-opencode-windows-x64": "3.17.4",
+    "oh-my-opencode-windows-x64-baseline": "3.17.4"
   },
   overrides: {},
   trustedDependencies: [
@@ -52001,7 +52089,7 @@ import os3 from "os";
 import { createHash } from "crypto";
 
 // node_modules/posthog-node/dist/extensions/error-tracking/modifiers/module.node.mjs
-import { dirname as dirname5, posix, sep } from "path";
+import { dirname as dirname6, posix, sep } from "path";
 function createModulerModifier() {
   const getModuleFromFileName = createGetModuleFromFilename();
   return async (frames) => {
@@ -52010,7 +52098,7 @@ function createModulerModifier() {
     return frames;
   };
 }
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname5(process.argv[1]) : process.cwd(), isWindows = sep === "\\") {
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname6(process.argv[1]) : process.cwd(), isWindows = sep === "\\") {
   const normalizedBase = isWindows ? normalizeWindowsPath(basePath) : basePath;
   return (filename) => {
     if (!filename)
@@ -54349,14 +54437,14 @@ async function addSourceContext(frames) {
   return frames;
 }
 function getContextLinesFromFile(path5, ranges, output) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve4) => {
     const stream = createReadStream(path5);
     const lineReaded = createInterface({
       input: stream
     });
     function destroyStreamAndResolve() {
       stream.destroy();
-      resolve2();
+      resolve4();
     }
     let lineNumber = 0;
     let currentRangeIndex = 0;
@@ -55596,9 +55684,9 @@ class PostHogBackendClient extends PostHogCoreStateless {
     if (this.disabled || this.optedOut)
       return;
     if (!this._waitUntilCycle) {
-      let resolve2;
+      let resolve4;
       const promise = new Promise((r) => {
-        resolve2 = r;
+        resolve4 = r;
       });
       try {
         waitUntil(promise);
@@ -55606,7 +55694,7 @@ class PostHogBackendClient extends PostHogCoreStateless {
         return;
       }
       this._waitUntilCycle = {
-        resolve: resolve2,
+        resolve: resolve4,
         startedAt: Date.now(),
         timer: undefined
       };
@@ -55632,11 +55720,11 @@ class PostHogBackendClient extends PostHogCoreStateless {
     return cycle?.resolve;
   }
   async resolveWaitUntilFlush() {
-    const resolve2 = this._consumeWaitUntilCycle();
+    const resolve4 = this._consumeWaitUntilCycle();
     try {
       await super.flush();
     } catch {} finally {
-      resolve2?.();
+      resolve4?.();
     }
   }
   getPersistedProperty(key) {
@@ -55736,15 +55824,15 @@ class PostHogBackendClient extends PostHogCoreStateless {
       return true;
     if (this.featureFlagsPoller === undefined)
       return false;
-    return new Promise((resolve2) => {
+    return new Promise((resolve4) => {
       const timeout = setTimeout(() => {
         cleanup();
-        resolve2(false);
+        resolve4(false);
       }, timeoutMs);
       const cleanup = this._events.on("localEvaluationFlagsLoaded", (count) => {
         clearTimeout(timeout);
         cleanup();
-        resolve2(count > 0);
+        resolve4(count > 0);
       });
     });
   }
@@ -56088,13 +56176,13 @@ class PostHogBackendClient extends PostHogCoreStateless {
     this.context?.enter(data, options);
   }
   async _shutdown(shutdownTimeoutMs) {
-    const resolve2 = this._consumeWaitUntilCycle();
+    const resolve4 = this._consumeWaitUntilCycle();
     await this.featureFlagsPoller?.stopPoller(shutdownTimeoutMs);
     this.errorTracking.shutdown();
     try {
       return await super._shutdown(shutdownTimeoutMs);
     } finally {
-      resolve2?.();
+      resolve4?.();
     }
   }
   async _requestRemoteConfigPayload(flagKey) {
@@ -56448,11 +56536,11 @@ init_data_path();
 init_logger();
 init_plugin_identity();
 init_write_file_atomically();
-import { existsSync as existsSync17, mkdirSync as mkdirSync7, readFileSync as readFileSync11 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync7, readFileSync as readFileSync12 } from "fs";
+import { join as join16 } from "path";
 var POSTHOG_ACTIVITY_STATE_FILE = "posthog-activity.json";
 function getPostHogActivityStateFilePath() {
-  return join15(getDataDir(), CACHE_DIR_NAME, POSTHOG_ACTIVITY_STATE_FILE);
+  return join16(getDataDir(), CACHE_DIR_NAME, POSTHOG_ACTIVITY_STATE_FILE);
 }
 function getUtcDayString(date) {
   return date.toISOString().slice(0, 10);
@@ -56465,11 +56553,11 @@ function isPostHogActivityState(value) {
 }
 function readPostHogActivityState() {
   const stateFilePath = getPostHogActivityStateFilePath();
-  if (!existsSync17(stateFilePath)) {
+  if (!existsSync18(stateFilePath)) {
     return {};
   }
   try {
-    const content = readFileSync11(stateFilePath, "utf-8");
+    const content = readFileSync12(stateFilePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!isPostHogActivityState(parsed)) {
       return {};
@@ -56486,7 +56574,7 @@ function readPostHogActivityState() {
 function writePostHogActivityState(nextState) {
   const stateFilePath = getPostHogActivityStateFilePath();
   try {
-    mkdirSync7(join15(getDataDir(), CACHE_DIR_NAME), { recursive: true });
+    mkdirSync7(join16(getDataDir(), CACHE_DIR_NAME), { recursive: true });
     writeFileAtomically(stateFilePath, `${JSON.stringify(nextState, null, 2)}
 `);
   } catch (error) {
@@ -56638,7 +56726,7 @@ function getPostHogDistinctId() {
 }
 function createCliPostHog() {
   return createPostHogClient("cli", {
-    enableExceptionAutocapture: true,
+    enableExceptionAutocapture: false,
     flushAt: 1,
     flushInterval: 0
   });
@@ -72148,6 +72236,10 @@ var NotificationConfigSchema = exports_external.object({
 var McpNameSchema = exports_external.enum(["websearch", "context7", "grep_app"]);
 var AnyMcpNameSchema = exports_external.string().min(1);
 
+// src/config/schema/agent-definitions.ts
+var AgentDefinitionPathSchema = exports_external.string().min(1);
+var AgentDefinitionsConfigSchema = exports_external.array(AgentDefinitionPathSchema).optional();
+
 // src/config/schema/openclaw.ts
 var OpenClawGatewaySchema = exports_external.object({
   type: exports_external.enum(["http", "command"]).default("http"),
@@ -72289,6 +72381,7 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
   $schema: exports_external.string().optional(),
   new_task_system_enabled: exports_external.boolean().optional(),
   default_run_agent: exports_external.string().optional(),
+  agent_definitions: AgentDefinitionsConfigSchema,
   disabled_mcps: exports_external.array(AnyMcpNameSchema).optional(),
   disabled_agents: exports_external.array(exports_external.string()).optional(),
   disabled_skills: exports_external.array(BuiltinSkillNameSchema).optional(),
@@ -72352,7 +72445,8 @@ var PARTIAL_STRING_ARRAY_KEYS = new Set([
   "disabled_hooks",
   "disabled_commands",
   "disabled_tools",
-  "mcp_env_allowlist"
+  "mcp_env_allowlist",
+  "agent_definitions"
 ]);
 function parseConfigPartially(rawConfig) {
   const fullResult = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
@@ -72424,6 +72518,12 @@ function mergeConfigs(base, override) {
     ...override,
     agents: deepMerge(base.agents, override.agents),
     categories: deepMerge(base.categories, override.categories),
+    agent_definitions: [
+      ...new Set([
+        ...base.agent_definitions ?? [],
+        ...override.agent_definitions ?? []
+      ])
+    ],
     disabled_agents: [
       ...new Set([
         ...base.disabled_agents ?? [],
@@ -72504,10 +72604,16 @@ function loadPluginConfig(directory, ctx) {
   }
   const userConfig = loadConfigFromPath(userConfigPath, ctx);
   const userGitMasterOverrides = loadExplicitGitMasterOverrides(userConfigPath);
+  if (userConfig?.agent_definitions) {
+    userConfig.agent_definitions = resolveAgentDefinitionPaths(userConfig.agent_definitions, configDir, null);
+  }
   let config2 = userConfig ?? OhMyOpenCodeConfigSchema.parse({});
   const defaultGitMaster = OhMyOpenCodeConfigSchema.parse({}).git_master;
   const projectConfig = loadConfigFromPath(projectConfigPath, ctx);
   const projectGitMasterOverrides = loadExplicitGitMasterOverrides(projectConfigPath);
+  if (projectConfig?.agent_definitions) {
+    projectConfig.agent_definitions = resolveAgentDefinitionPaths(projectConfig.agent_definitions, projectBasePath, directory);
+  }
   if (projectConfig) {
     config2 = mergeConfigs(config2, projectConfig);
   }
@@ -72537,7 +72643,7 @@ function loadPluginConfig(directory, ctx) {
 // node_modules/@opencode-ai/sdk/dist/gen/core/serverSentEvents.gen.js
 var createSseClient = ({ onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url: url2, ...options }) => {
   let lastEventId;
-  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms)));
+  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve4) => setTimeout(resolve4, ms)));
   const createStream = async function* () {
     let retryDelay = sseDefaultRetryDelay ?? 3000;
     let attempt = 0;
@@ -73972,7 +74078,7 @@ async function createOpencodeServer(options) {
     }
   });
   let clear = () => {};
-  const url2 = await new Promise((resolve2, reject) => {
+  const url2 = await new Promise((resolve4, reject) => {
     const id = setTimeout(() => {
       clear();
       stop(proc);
@@ -73998,7 +74104,7 @@ async function createOpencodeServer(options) {
           }
           clearTimeout(id);
           resolved = true;
-          resolve2(match[1]);
+          resolve4(match[1]);
           return;
         }
       }
@@ -74052,7 +74158,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 join17 } from "path";
+import { delimiter, dirname as dirname8, join as join18 } from "path";
 var OPENCODE_COMMANDS = ["opencode", "opencode-desktop"];
 var WINDOWS_SUFFIXES = ["", ".exe", ".cmd", ".bat", ".ps1"];
 function getCommandCandidates(platform) {
@@ -74075,7 +74181,7 @@ function collectCandidateBinaryPaths(pathEnv, which = Bun.which, platform = proc
   }
   for (const entry of (pathEnv ?? "").split(delimiter).filter(Boolean)) {
     for (const command of commandCandidates) {
-      addCandidate(join17(entry, command));
+      addCandidate(join18(entry, command));
     }
   }
   return candidates;
@@ -74102,7 +74208,7 @@ async function findWorkingOpencodeBinary(pathEnv = process.env.PATH, probe = can
   return null;
 }
 function buildPathWithBinaryFirst(pathEnv, binaryPath) {
-  const preferredDir = dirname7(binaryPath);
+  const preferredDir = dirname8(binaryPath);
   const existing = (pathEnv ?? "").split(delimiter).filter((entry) => entry.length > 0 && entry !== preferredDir);
   return [preferredDir, ...existing].join(delimiter);
 }
@@ -74240,7 +74346,7 @@ async function resolveSession(options) {
       if (attempt < SESSION_CREATE_MAX_RETRIES) {
         const delay = SESSION_CREATE_RETRY_DELAY_MS * attempt;
         console.log(import_picocolors11.default.dim(`  Retrying in ${delay}ms...`));
-        await new Promise((resolve2) => setTimeout(resolve2, delay));
+        await new Promise((resolve4) => setTimeout(resolve4, delay));
       }
       continue;
     }
@@ -74251,7 +74357,7 @@ async function resolveSession(options) {
     if (attempt < SESSION_CREATE_MAX_RETRIES) {
       const delay = SESSION_CREATE_RETRY_DELAY_MS * attempt;
       console.log(import_picocolors11.default.dim(`  Retrying in ${delay}ms...`));
-      await new Promise((resolve2) => setTimeout(resolve2, delay));
+      await new Promise((resolve4) => setTimeout(resolve4, delay));
     }
   }
   throw new Error("Failed to create session after all retries");
@@ -74380,10 +74486,11 @@ var normalizeAgentName = (agent) => {
     return;
   const configKey = getAgentConfigKey(trimmed);
   const displayName = getAgentDisplayName(configKey);
+  const runtimeName = getAgentRuntimeName(configKey);
   const isKnownAgent = displayName !== configKey;
   return {
     configKey,
-    resolvedName: isKnownAgent ? displayName : trimmed
+    resolvedName: isKnownAgent ? runtimeName : trimmed
   };
 };
 var isAgentDisabled = (agentConfigKey, config2) => {
@@ -74407,18 +74514,19 @@ var resolveRunAgent = (options, pluginConfig, env = process.env) => {
   const configAgent = normalizeAgentName(pluginConfig.default_run_agent);
   const resolved = cliAgent ?? envAgent ?? configAgent ?? {
     configKey: DEFAULT_AGENT,
-    resolvedName: getAgentDisplayName(DEFAULT_AGENT)
+    resolvedName: getAgentRuntimeName(DEFAULT_AGENT)
   };
   if (isAgentDisabled(resolved.configKey, pluginConfig)) {
     const fallback = pickFallbackAgent(pluginConfig);
-    const fallbackName = getAgentDisplayName(fallback);
+    const fallbackDisplayName = getAgentDisplayName(fallback);
+    const fallbackRuntimeName = getAgentRuntimeName(fallback);
     const fallbackDisabled = isAgentDisabled(fallback, pluginConfig);
     if (fallbackDisabled) {
-      console.log(import_picocolors12.default.yellow(`Requested agent "${resolved.resolvedName}" is disabled and no enabled core agent was found. Proceeding with "${fallbackName}".`));
-      return fallbackName;
+      console.log(import_picocolors12.default.yellow(`Requested agent "${resolved.resolvedName}" is disabled and no enabled core agent was found. Proceeding with "${fallbackDisplayName}".`));
+      return fallbackRuntimeName;
     }
-    console.log(import_picocolors12.default.yellow(`Requested agent "${resolved.resolvedName}" is disabled. Falling back to "${fallbackName}".`));
-    return fallbackName;
+    console.log(import_picocolors12.default.yellow(`Requested agent "${resolved.resolvedName}" is disabled. Falling back to "${fallbackDisplayName}".`));
+    return fallbackRuntimeName;
   }
   return resolved.resolvedName;
 };
@@ -74460,19 +74568,19 @@ var BOULDER_STATE_PATH = `${BOULDER_DIR}/${BOULDER_FILE}`;
 var NOTEPAD_DIR = "notepads";
 var NOTEPAD_BASE_PATH = `${BOULDER_DIR}/${NOTEPAD_DIR}`;
 // src/features/boulder-state/storage.ts
-import { existsSync as 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";
+import { existsSync as existsSync20, readFileSync as readFileSync14, writeFileSync as writeFileSync5, mkdirSync as mkdirSync8, readdirSync as readdirSync3 } from "fs";
+import { dirname as dirname9, join as join19, basename as basename5 } from "path";
 var RESERVED_KEYS = new Set(["__proto__", "prototype", "constructor"]);
 function getBoulderFilePath(directory) {
-  return join18(directory, BOULDER_DIR, BOULDER_FILE);
+  return join19(directory, BOULDER_DIR, BOULDER_FILE);
 }
 function readBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
-  if (!existsSync19(filePath)) {
+  if (!existsSync20(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync13(filePath, "utf-8");
+    const content = readFileSync14(filePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       return null;
@@ -74505,11 +74613,11 @@ var CHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[[xX]\]\s*(.+)$/;
 var TODO_TASK_PATTERN = /^\d+\.\s+/;
 var FINAL_WAVE_TASK_PATTERN = /^F\d+\.\s+/i;
 function getPlanProgress(planPath) {
-  if (!existsSync19(planPath)) {
+  if (!existsSync20(planPath)) {
     return { total: 0, completed: 0, isComplete: true };
   }
   try {
-    const content = readFileSync13(planPath, "utf-8");
+    const content = readFileSync14(planPath, "utf-8");
     const lines = content.split(/\r?\n/);
     const hasStructuredSections = lines.some((line) => TODO_HEADING_PATTERN.test(line) || FINAL_VERIFICATION_HEADING_PATTERN.test(line));
     if (hasStructuredSections) {
@@ -74581,17 +74689,17 @@ function getSessionAgent(sessionID) {
 // src/features/run-continuation-state/constants.ts
 var CONTINUATION_MARKER_DIR = ".sisyphus/run-continuation";
 // src/features/run-continuation-state/storage.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync9, readFileSync as readFileSync14, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync9, readFileSync as readFileSync15, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
+import { join as join20 } from "path";
 function getMarkerPath(directory, sessionID) {
-  return join19(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
+  return join20(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
 }
 function readContinuationMarker(directory, sessionID) {
   const markerPath = getMarkerPath(directory, sessionID);
-  if (!existsSync20(markerPath))
+  if (!existsSync21(markerPath))
     return null;
   try {
-    const raw = readFileSync14(markerPath, "utf-8");
+    const raw = readFileSync15(markerPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
       return null;
@@ -74652,8 +74760,8 @@ async function isSessionInBoulderLineage(input) {
 // src/hooks/atlas/session-last-agent.ts
 init_shared();
 init_compaction_marker();
-import { readFileSync as readFileSync15, readdirSync as readdirSync4 } from "fs";
-import { join as join20 } from "path";
+import { readFileSync as readFileSync16, readdirSync as readdirSync4 } from "fs";
+import { join as join21 } from "path";
 var defaultSessionLastAgentDeps = {
   getMessageDir,
   isSqliteBackend,
@@ -74701,7 +74809,7 @@ async function getLastAgentFromSession(sessionID, client3, deps = {}) {
   try {
     const messages = readdirSync4(messageDir).filter((fileName) => fileName.endsWith(".json")).map((fileName) => {
       try {
-        const content = readFileSync15(join20(messageDir, fileName), "utf-8");
+        const content = readFileSync16(join21(messageDir, fileName), "utf-8");
         const parsed = JSON.parse(content);
         return {
           fileName,
@@ -74734,8 +74842,8 @@ init_agent_display_names();
 
 // src/hooks/ralph-loop/storage.ts
 init_frontmatter();
-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";
+import { existsSync as existsSync22, readFileSync as readFileSync17, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, mkdirSync as mkdirSync10 } from "fs";
+import { dirname as dirname10, join as join22 } from "path";
 
 // src/hooks/ralph-loop/constants.ts
 var DEFAULT_STATE_FILE = ".sisyphus/ralph-loop.local.md";
@@ -74744,15 +74852,15 @@ var DEFAULT_COMPLETION_PROMISE = "DONE";
 
 // src/hooks/ralph-loop/storage.ts
 function getStateFilePath(directory, customPath) {
-  return customPath ? join21(directory, customPath) : join21(directory, DEFAULT_STATE_FILE);
+  return customPath ? join22(directory, customPath) : join22(directory, DEFAULT_STATE_FILE);
 }
 function readState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
-  if (!existsSync21(filePath)) {
+  if (!existsSync22(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync16(filePath, "utf-8");
+    const content = readFileSync17(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     const active = data.active;
     const iteration = data.iteration;
@@ -74961,7 +75069,7 @@ async function pollForCompletion(ctx, eventState, abortController, options = {})
   let secondaryTimeoutChecked = false;
   const pollStartTimestamp = Date.now();
   while (!abortController.signal.aborted) {
-    await new Promise((resolve2) => setTimeout(resolve2, pollIntervalMs));
+    await new Promise((resolve4) => setTimeout(resolve4, pollIntervalMs));
     if (abortController.signal.aborted) {
       return 130;
     }
@@ -75192,7 +75300,7 @@ var EVENT_PROCESSOR_SHUTDOWN_TIMEOUT_MS = 2000;
 async function waitForEventProcessorShutdown(eventProcessor, timeoutMs = EVENT_PROCESSOR_SHUTDOWN_TIMEOUT_MS) {
   const completed = await Promise.race([
     eventProcessor.then(() => true),
-    new Promise((resolve2) => setTimeout(() => resolve2(false), timeoutMs))
+    new Promise((resolve4) => setTimeout(() => resolve4(false), timeoutMs))
   ]);
 }
 async function run(options) {
@@ -75520,12 +75628,12 @@ async function getLocalVersion(options = {}) {
   }
 }
 // src/cli/doctor/checks/system.ts
-import { existsSync as existsSync32, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync33, readFileSync as readFileSync27 } from "fs";
 
 // src/cli/doctor/checks/system-binary.ts
-import { existsSync as existsSync29 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join28 } from "path";
+import { existsSync as existsSync30 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join29 } from "path";
 
 // src/cli/doctor/spawn-with-timeout.ts
 init_spawn_with_windows_hide();
@@ -75538,8 +75646,8 @@ async function spawnWithTimeout(command, options, timeoutMs = DEFAULT_SPAWN_TIME
     return { stdout: "", stderr: "", exitCode: 1, timedOut: false };
   }
   let timer;
-  const timeoutPromise = new Promise((resolve2) => {
-    timer = setTimeout(() => resolve2("timeout"), timeoutMs);
+  const timeoutPromise = new Promise((resolve4) => {
+    timer = setTimeout(() => resolve4("timeout"), timeoutMs);
   });
   const processPromise = (async () => {
     await proc.exited;
@@ -75559,22 +75667,22 @@ async function spawnWithTimeout(command, options, timeoutMs = DEFAULT_SPAWN_TIME
 
 // src/cli/doctor/checks/system-binary.ts
 function getDesktopAppPaths(platform) {
-  const home = homedir5();
+  const home = homedir6();
   switch (platform) {
     case "darwin":
       return [
         "/Applications/OpenCode.app/Contents/MacOS/OpenCode",
-        join28(home, "Applications", "OpenCode.app", "Contents", "MacOS", "OpenCode")
+        join29(home, "Applications", "OpenCode.app", "Contents", "MacOS", "OpenCode")
       ];
     case "win32": {
       const programFiles = process.env.ProgramFiles;
       const localAppData = process.env.LOCALAPPDATA;
       const paths = [];
       if (programFiles) {
-        paths.push(join28(programFiles, "OpenCode", "OpenCode.exe"));
+        paths.push(join29(programFiles, "OpenCode", "OpenCode.exe"));
       }
       if (localAppData) {
-        paths.push(join28(localAppData, "OpenCode", "OpenCode.exe"));
+        paths.push(join29(localAppData, "OpenCode", "OpenCode.exe"));
       }
       return paths;
     }
@@ -75582,8 +75690,8 @@ function getDesktopAppPaths(platform) {
       return [
         "/usr/bin/opencode",
         "/usr/lib/opencode/opencode",
-        join28(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
-        join28(home, "Applications", "opencode-desktop-linux-aarch64.AppImage")
+        join29(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
+        join29(home, "Applications", "opencode-desktop-linux-aarch64.AppImage")
       ];
     default:
       return [];
@@ -75595,7 +75703,7 @@ function buildVersionCommand(binaryPath, platform) {
   }
   return [binaryPath, "--version"];
 }
-function findDesktopBinary(platform = process.platform, checkExists = existsSync29) {
+function findDesktopBinary(platform = process.platform, checkExists = existsSync30) {
   for (const desktopPath of getDesktopAppPaths(platform)) {
     if (checkExists(desktopPath)) {
       return { binary: "opencode", path: desktopPath };
@@ -75641,12 +75749,12 @@ function compareVersions3(current, minimum) {
 
 // src/cli/doctor/checks/system-plugin.ts
 init_shared();
-import { existsSync as existsSync30, readFileSync as readFileSync24 } from "fs";
+import { existsSync as existsSync31, readFileSync as readFileSync25 } from "fs";
 function detectConfigPath() {
   const paths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
-  if (existsSync30(paths.configJsonc))
+  if (existsSync31(paths.configJsonc))
     return paths.configJsonc;
-  if (existsSync30(paths.configJson))
+  if (existsSync31(paths.configJson))
     return paths.configJson;
   return null;
 }
@@ -75692,7 +75800,7 @@ function getPluginInfo() {
     };
   }
   try {
-    const content = readFileSync24(configPath, "utf-8");
+    const content = readFileSync25(configPath, "utf-8");
     const parsedConfig = parseJsonc(content);
     const pluginEntry = findPluginEntry2(parsedConfig.plugin ?? []);
     if (!pluginEntry) {
@@ -75730,37 +75838,37 @@ function getPluginInfo() {
 init_file_utils();
 init_checker();
 init_auto_update_checker();
-import { existsSync as existsSync31, readFileSync as readFileSync25 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join29 } from "path";
+import { existsSync as existsSync32, readFileSync as readFileSync26 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join30 } from "path";
 init_shared();
 function getPlatformDefaultCacheDir(platform = process.platform) {
   if (platform === "darwin")
-    return join29(homedir6(), "Library", "Caches");
+    return join30(homedir7(), "Library", "Caches");
   if (platform === "win32")
-    return process.env.LOCALAPPDATA ?? join29(homedir6(), "AppData", "Local");
-  return join29(homedir6(), ".cache");
+    return process.env.LOCALAPPDATA ?? join30(homedir7(), "AppData", "Local");
+  return join30(homedir7(), ".cache");
 }
 function resolveOpenCodeCacheDir() {
   const xdgCacheHome = process.env.XDG_CACHE_HOME;
   if (xdgCacheHome)
-    return join29(xdgCacheHome, "opencode");
+    return join30(xdgCacheHome, "opencode");
   const fromShared = getOpenCodeCacheDir();
-  const platformDefault = join29(getPlatformDefaultCacheDir(), "opencode");
-  if (existsSync31(fromShared) || !existsSync31(platformDefault))
+  const platformDefault = join30(getPlatformDefaultCacheDir(), "opencode");
+  if (existsSync32(fromShared) || !existsSync32(platformDefault))
     return fromShared;
   return platformDefault;
 }
 function resolveExistingDir(dirPath) {
-  if (!existsSync31(dirPath))
+  if (!existsSync32(dirPath))
     return dirPath;
   return resolveSymlink(dirPath);
 }
 function readPackageJson(filePath) {
-  if (!existsSync31(filePath))
+  if (!existsSync32(filePath))
     return null;
   try {
-    const content = readFileSync25(filePath, "utf-8");
+    const content = readFileSync26(filePath, "utf-8");
     return parseJsonc(content);
   } catch {
     return null;
@@ -75775,11 +75883,11 @@ function normalizeVersion(value) {
 function createPackageCandidates(rootDir) {
   return ACCEPTED_PACKAGE_NAMES.map((packageName) => ({
     packageName,
-    installedPackagePath: join29(rootDir, "node_modules", packageName, "package.json")
+    installedPackagePath: join30(rootDir, "node_modules", packageName, "package.json")
   }));
 }
 function selectInstalledPackage(candidate) {
-  return candidate.packageCandidates.find((packageCandidate) => existsSync31(packageCandidate.installedPackagePath)) ?? candidate.packageCandidates[0];
+  return candidate.packageCandidates.find((packageCandidate) => existsSync32(packageCandidate.installedPackagePath)) ?? candidate.packageCandidates[0];
 }
 function getExpectedVersion(cachePackage, packageName) {
   return normalizeVersion(cachePackage?.dependencies?.[packageName]) ?? normalizeVersion(cachePackage?.dependencies?.[PACKAGE_NAME]);
@@ -75791,16 +75899,16 @@ function getLoadedPluginVersion() {
   const candidates = [
     {
       cacheDir: configDir,
-      cachePackagePath: join29(configDir, "package.json"),
+      cachePackagePath: join30(configDir, "package.json"),
       packageCandidates: createPackageCandidates(configDir)
     },
     {
       cacheDir,
-      cachePackagePath: join29(cacheDir, "package.json"),
+      cachePackagePath: join30(cacheDir, "package.json"),
       packageCandidates: createPackageCandidates(cacheDir)
     }
   ];
-  const selectedCandidate = candidates.find((candidate) => candidate.packageCandidates.some((packageCandidate) => existsSync31(packageCandidate.installedPackagePath))) ?? candidates[0];
+  const selectedCandidate = candidates.find((candidate) => candidate.packageCandidates.some((packageCandidate) => existsSync32(packageCandidate.installedPackagePath))) ?? candidates[0];
   const { cacheDir: selectedDir, cachePackagePath } = selectedCandidate;
   const selectedPackage = selectInstalledPackage(selectedCandidate);
   const installedPackagePath = selectedPackage.installedPackagePath;
@@ -75839,10 +75947,10 @@ var defaultDeps3 = {
 function isConfigValid(configPath) {
   if (!configPath)
     return true;
-  if (!existsSync32(configPath))
+  if (!existsSync33(configPath))
     return false;
   try {
-    parseJsonc(readFileSync26(configPath, "utf-8"));
+    parseJsonc(readFileSync27(configPath, "utf-8"));
     return true;
   } catch {
     return false;
@@ -75964,32 +76072,32 @@ async function checkSystem(deps = defaultDeps3) {
 }
 
 // src/cli/doctor/checks/config.ts
-import { readFileSync as readFileSync29 } from "fs";
-import { join as join33 } from "path";
+import { readFileSync as readFileSync30 } from "fs";
+import { join as join34 } from "path";
 init_shared();
 
 // src/cli/doctor/checks/model-resolution-cache.ts
 init_shared();
-import { existsSync as existsSync33, readFileSync as readFileSync27 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join30 } from "path";
+import { existsSync as existsSync34, readFileSync as readFileSync28 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join31 } from "path";
 function getUserConfigDir2() {
   const xdgConfig = process.env.XDG_CONFIG_HOME;
   if (xdgConfig)
-    return join30(xdgConfig, "opencode");
-  return join30(homedir7(), ".config", "opencode");
+    return join31(xdgConfig, "opencode");
+  return join31(homedir8(), ".config", "opencode");
 }
 function loadCustomProviderNames() {
   const configDir = getUserConfigDir2();
   const candidatePaths = [
-    join30(configDir, "opencode.json"),
-    join30(configDir, "opencode.jsonc")
+    join31(configDir, "opencode.json"),
+    join31(configDir, "opencode.jsonc")
   ];
   for (const configPath of candidatePaths) {
-    if (!existsSync33(configPath))
+    if (!existsSync34(configPath))
       continue;
     try {
-      const content = readFileSync27(configPath, "utf-8");
+      const content = readFileSync28(configPath, "utf-8");
       const data = parseJsonc(content);
       if (data?.provider && typeof data.provider === "object") {
         return Object.keys(data.provider);
@@ -75999,16 +76107,16 @@ function loadCustomProviderNames() {
   return [];
 }
 function loadAvailableModelsFromCache() {
-  const cacheFile = join30(getOpenCodeCacheDir(), "models.json");
+  const cacheFile = join31(getOpenCodeCacheDir(), "models.json");
   const customProviders = loadCustomProviderNames();
-  if (!existsSync33(cacheFile)) {
+  if (!existsSync34(cacheFile)) {
     if (customProviders.length > 0) {
       return { providers: customProviders, modelCount: 0, cacheExists: true };
     }
     return { providers: [], modelCount: 0, cacheExists: false };
   }
   try {
-    const content = readFileSync27(cacheFile, "utf-8");
+    const content = readFileSync28(cacheFile, "utf-8");
     const data = parseJsonc(content);
     const cacheProviders = Object.keys(data);
     let modelCount = 0;
@@ -76031,14 +76139,14 @@ init_model_capabilities();
 
 // src/cli/doctor/checks/model-resolution-config.ts
 init_shared();
-import { readFileSync as readFileSync28 } from "fs";
-import { join as join31 } from "path";
-var PROJECT_CONFIG_DIR = join31(process.cwd(), ".opencode");
+import { readFileSync as readFileSync29 } from "fs";
+import { join as join32 } from "path";
+var PROJECT_CONFIG_DIR = join32(process.cwd(), ".opencode");
 function loadOmoConfig() {
   const projectDetected = detectPluginConfigFile(PROJECT_CONFIG_DIR);
   if (projectDetected.format !== "none") {
     try {
-      const content = readFileSync28(projectDetected.path, "utf-8");
+      const content = readFileSync29(projectDetected.path, "utf-8");
       return parseJsonc(content);
     } catch {
       return null;
@@ -76048,7 +76156,7 @@ function loadOmoConfig() {
   const userDetected = detectPluginConfigFile(userConfigDir);
   if (userDetected.format !== "none") {
     try {
-      const content = readFileSync28(userDetected.path, "utf-8");
+      const content = readFileSync29(userDetected.path, "utf-8");
       return parseJsonc(content);
     } catch {
       return null;
@@ -76059,7 +76167,7 @@ function loadOmoConfig() {
 
 // src/cli/doctor/checks/model-resolution-details.ts
 init_shared();
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 
 // src/cli/doctor/checks/model-resolution-variant.ts
 function formatModelWithVariant(model, variant) {
@@ -76101,7 +76209,7 @@ function formatCapabilityResolutionLabel(mode) {
 }
 function buildModelResolutionDetails(options) {
   const details = [];
-  const cacheFile = join32(getOpenCodeCacheDir(), "models.json");
+  const cacheFile = join33(getOpenCodeCacheDir(), "models.json");
   details.push("\u2550\u2550\u2550 Available Models (from cache) \u2550\u2550\u2550");
   details.push("");
   if (options.available.cacheExists) {
@@ -76256,7 +76364,7 @@ async function checkModels() {
 }
 
 // src/cli/doctor/checks/config.ts
-var PROJECT_CONFIG_DIR2 = join33(process.cwd(), ".opencode");
+var PROJECT_CONFIG_DIR2 = join34(process.cwd(), ".opencode");
 function findConfigPath() {
   const projectConfig = detectPluginConfigFile(PROJECT_CONFIG_DIR2);
   if (projectConfig.format !== "none")
@@ -76273,7 +76381,7 @@ function validateConfig() {
     return { exists: false, path: null, valid: true, config: null, errors: [] };
   }
   try {
-    const content = readFileSync29(configPath, "utf-8");
+    const content = readFileSync30(configPath, "utf-8");
     const rawConfig = parseJsonc(content);
     const schemaResult = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
     if (!schemaResult.success) {
@@ -76376,27 +76484,27 @@ async function checkConfig() {
 }
 
 // src/cli/doctor/checks/dependencies.ts
-import { existsSync as existsSync34 } from "fs";
+import { existsSync as existsSync35 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname13, join as join35 } from "path";
+import { dirname as dirname14, join as join36 } from "path";
 
 // src/hooks/comment-checker/downloader.ts
-import { join as join34 } from "path";
-import { homedir as homedir8, tmpdir as tmpdir3 } from "os";
+import { join as join35 } from "path";
+import { homedir as homedir9, tmpdir as tmpdir3 } from "os";
 init_binary_downloader();
 init_logger();
 init_plugin_identity();
 var DEBUG = process.env.COMMENT_CHECKER_DEBUG === "1";
-var DEBUG_FILE = join34(tmpdir3(), "comment-checker-debug.log");
+var DEBUG_FILE = join35(tmpdir3(), "comment-checker-debug.log");
 function getCacheDir2() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join34(homedir8(), "AppData", "Local");
-    return join34(base2, CACHE_DIR_NAME, "bin");
+    const base2 = localAppData || join35(homedir9(), "AppData", "Local");
+    return join35(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");
+  const base = xdgCache || join35(homedir9(), ".cache");
+  return join35(base, CACHE_DIR_NAME, "bin");
 }
 function getBinaryName() {
   return process.platform === "win32" ? "comment-checker.exe" : "comment-checker";
@@ -76460,15 +76568,15 @@ async function checkAstGrepNapi() {
       path: null
     };
   } catch {
-    const { existsSync: existsSync35 } = await import("fs");
-    const { join: join36 } = await import("path");
-    const { homedir: homedir9 } = await import("os");
+    const { existsSync: existsSync36 } = await import("fs");
+    const { join: join37 } = await import("path");
+    const { homedir: homedir10 } = await import("os");
     const pathsToCheck = [
-      join36(homedir9(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
-      join36(process.cwd(), "node_modules", "@ast-grep", "napi")
+      join37(homedir10(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
+      join37(process.cwd(), "node_modules", "@ast-grep", "napi")
     ];
     for (const napiPath of pathsToCheck) {
-      if (existsSync35(napiPath)) {
+      if (existsSync36(napiPath)) {
         return {
           name: "AST-Grep NAPI",
           required: false,
@@ -76493,8 +76601,8 @@ function findCommentCheckerPackageBinary() {
   try {
     const require2 = createRequire(import.meta.url);
     const pkgPath = require2.resolve("@code-yeongyu/comment-checker/package.json");
-    const binaryPath = join35(dirname13(pkgPath), "bin", binaryName);
-    if (existsSync34(binaryPath))
+    const binaryPath = join36(dirname14(pkgPath), "bin", binaryName);
+    if (existsSync35(binaryPath))
       return binaryPath;
   } catch {}
   return null;
@@ -76655,15 +76763,15 @@ var BUILTIN_SERVERS = {
   "kotlin-ls": { command: ["kotlin-lsp"], extensions: [".kt", ".kts"] }
 };
 // src/tools/lsp/server-config-loader.ts
-import { existsSync as existsSync35, readFileSync as readFileSync30 } from "fs";
-import { join as join36 } from "path";
+import { existsSync as existsSync36, readFileSync as readFileSync31 } from "fs";
+import { join as join37 } from "path";
 init_shared();
 init_jsonc_parser();
 function loadJsonFile(path12) {
-  if (!existsSync35(path12))
+  if (!existsSync36(path12))
     return null;
   try {
-    return parseJsonc(readFileSync30(path12, "utf-8"));
+    return parseJsonc(readFileSync31(path12, "utf-8"));
   } catch {
     return null;
   }
@@ -76672,9 +76780,9 @@ function getConfigPaths2() {
   const cwd = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   return {
-    project: detectPluginConfigFile(join36(cwd, ".opencode")).path,
+    project: detectPluginConfigFile(join37(cwd, ".opencode")).path,
     user: detectPluginConfigFile(configDir).path,
-    opencode: detectConfigFile(join36(configDir, "opencode")).path
+    opencode: detectConfigFile(join37(configDir, "opencode")).path
   };
 }
 function loadAllConfigs() {
@@ -76743,21 +76851,21 @@ function getMergedServers() {
 }
 
 // src/tools/lsp/server-installation.ts
-import { existsSync as existsSync36 } from "fs";
-import { delimiter as delimiter2, join as join38 } from "path";
+import { existsSync as existsSync37 } from "fs";
+import { delimiter as delimiter2, join as join39 } from "path";
 
 // src/tools/lsp/server-path-bases.ts
 init_shared();
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 function getLspServerAdditionalPathBases(workingDirectory) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join37(getDataDir(), "opencode");
+  const dataDir = join38(getDataDir(), "opencode");
   return [
-    join37(workingDirectory, "node_modules", ".bin"),
-    join37(configDir, "bin"),
-    join37(configDir, "node_modules", ".bin"),
-    join37(dataDir, "bin"),
-    join37(dataDir, "bin", "node_modules", ".bin")
+    join38(workingDirectory, "node_modules", ".bin"),
+    join38(configDir, "bin"),
+    join38(configDir, "node_modules", ".bin"),
+    join38(dataDir, "bin"),
+    join38(dataDir, "bin", "node_modules", ".bin")
   ];
 }
 
@@ -76767,7 +76875,7 @@ function isServerInstalled(command) {
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync36(cmd))
+    if (existsSync37(cmd))
       return true;
   }
   const isWindows = process.platform === "win32";
@@ -76788,14 +76896,14 @@ function isServerInstalled(command) {
   const paths = pathEnv.split(delimiter2);
   for (const p2 of paths) {
     for (const suffix of exts) {
-      if (existsSync36(join38(p2, cmd + suffix))) {
+      if (existsSync37(join39(p2, cmd + suffix))) {
         return true;
       }
     }
   }
   for (const base of getLspServerAdditionalPathBases(process.cwd())) {
     for (const suffix of exts) {
-      if (existsSync36(join38(base, cmd + suffix))) {
+      if (existsSync37(join39(base, cmd + suffix))) {
         return true;
       }
     }
@@ -76857,24 +76965,24 @@ function getInstalledLspServers() {
 
 // src/cli/doctor/checks/tools-mcp.ts
 init_shared();
-import { existsSync as existsSync37, readFileSync as readFileSync31 } from "fs";
-import { homedir as homedir9 } from "os";
-import { join as join39 } from "path";
+import { existsSync as existsSync38, readFileSync as readFileSync32 } from "fs";
+import { homedir as homedir10 } from "os";
+import { join as join40 } from "path";
 var BUILTIN_MCP_SERVERS = ["context7", "grep_app"];
 function getMcpConfigPaths() {
   return [
-    join39(homedir9(), ".claude", ".mcp.json"),
-    join39(process.cwd(), ".mcp.json"),
-    join39(process.cwd(), ".claude", ".mcp.json")
+    join40(homedir10(), ".claude", ".mcp.json"),
+    join40(process.cwd(), ".mcp.json"),
+    join40(process.cwd(), ".claude", ".mcp.json")
   ];
 }
 function loadUserMcpConfig() {
   const servers = {};
   for (const configPath of getMcpConfigPaths()) {
-    if (!existsSync37(configPath))
+    if (!existsSync38(configPath))
       continue;
     try {
-      const content = readFileSync31(configPath, "utf-8");
+      const content = readFileSync32(configPath, "utf-8");
       const config2 = parseJsonc(content);
       if (config2.mcpServers) {
         Object.assign(servers, config2.mcpServers);
@@ -77372,11 +77480,11 @@ async function refreshModelCapabilities(options, deps = {}) {
 
 // src/features/mcp-oauth/storage.ts
 init_shared();
-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";
+import { chmodSync as chmodSync2, existsSync as existsSync39, mkdirSync as mkdirSync12, readFileSync as readFileSync33, renameSync as renameSync4, unlinkSync as unlinkSync6, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname15, join as join41 } from "path";
 var STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStoragePath() {
-  return join40(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
+  return join41(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
 }
 function normalizeHost(serverHost) {
   let host = serverHost.trim();
@@ -77413,11 +77521,11 @@ function buildKey(serverHost, resource) {
 }
 function readStore() {
   const filePath = getMcpOauthStoragePath();
-  if (!existsSync38(filePath)) {
+  if (!existsSync39(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync32(filePath, "utf-8");
+    const content = readFileSync33(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -77426,8 +77534,8 @@ function readStore() {
 function writeStore(store2) {
   const filePath = getMcpOauthStoragePath();
   try {
-    const dir = dirname14(filePath);
-    if (!existsSync38(dir)) {
+    const dir = dirname15(filePath);
+    if (!existsSync39(dir)) {
       mkdirSync12(dir, { recursive: true });
     }
     const tempPath = `${filePath}.tmp.${Date.now()}`;
@@ -77464,7 +77572,7 @@ function deleteToken(serverHost, resource) {
   if (Object.keys(store2).length === 0) {
     try {
       const filePath = getMcpOauthStoragePath();
-      if (existsSync38(filePath)) {
+      if (existsSync39(filePath)) {
         unlinkSync6(filePath);
       }
       return true;
@@ -77684,7 +77792,7 @@ function buildAuthorizationUrl(authorizationEndpoint, options) {
 }
 var CALLBACK_TIMEOUT_MS = 5 * 60 * 1000;
 function startCallbackServer(port) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     let timeoutId;
     const server2 = createServer((request, response) => {
       clearTimeout(timeoutId);
@@ -77710,7 +77818,7 @@ function startCallbackServer(port) {
       response.writeHead(200, { "content-type": "text/html" });
       response.end("<html><body><h1>Authorization successful. You can close this tab.</h1></body></html>");
       server2.close();
-      resolve2({ code, state: state2 });
+      resolve4({ code, state: state2 });
     });
     timeoutId = setTimeout(() => {
       server2.close();