evil-omo 3.14.1 → 3.15.2

package/dist/cli/index.js

@@ -4914,8 +4914,9 @@ var init_command_executor = __esm(() => {
   init_resolve_commands_in_text();
 });
 
-// src/shared/file-reference-resolver.ts
-var init_file_reference_resolver = () => {};
+// src/shared/contains-path.ts
+var init_contains_path = () => {};
+
 // node_modules/jsonc-parser/lib/esm/impl/scanner.js
 function createScanner(text, ignoreTrivia = false) {
   const len = text.length;
@@ -5807,6 +5808,7 @@ function detectConfigFile(basePath) {
 }
 var init_jsonc_parser = __esm(() => {
   init_main();
+  init_plugin_identity();
 });
 
 // src/shared/plugin-identity.ts
@@ -5837,11 +5839,11 @@ function detectManagedConfigFile(directory) {
     baseName: CONFIG_BASENAME
   };
 }
-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 PLUGIN_NAME = "evil-omo", LEGACY_PLUGIN_NAME = "oh-my-opencode", ALL_PLUGIN_NAMES, CONFIG_BASENAME = "evil-omo", LEGACY_CONFIG_BASENAME = "oh-my-opencode", 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, LEGACY_PLUGIN_NAME];
-  ALL_CONFIG_BASENAMES = [CONFIG_BASENAME];
+  ALL_CONFIG_BASENAMES = [CONFIG_BASENAME, LEGACY_CONFIG_BASENAME];
 });
 
 // src/shared/logger.ts
@@ -5862,6 +5864,11 @@ var init_logger = __esm(() => {
   logFile = path.join(os.tmpdir(), LOG_FILENAME);
 });
 
+// src/shared/file-reference-resolver.ts
+var init_file_reference_resolver = __esm(() => {
+  init_contains_path();
+  init_logger();
+});
 // src/shared/deep-merge.ts
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
@@ -5924,15 +5931,7 @@ function resolveSymlink(filePath) {
 var init_file_utils = () => {};
 
 // src/shared/context-limit-resolver.ts
-var ANTHROPIC_NO_HEADER_GA_MODEL_IDS;
-var init_context_limit_resolver = __esm(() => {
-  ANTHROPIC_NO_HEADER_GA_MODEL_IDS = new Set([
-    "claude-opus-4-6",
-    "claude-opus-4.6",
-    "claude-sonnet-4-6",
-    "claude-sonnet-4.6"
-  ]);
-});
+var init_context_limit_resolver = () => {};
 
 // src/shared/normalize-sdk-response.ts
 function normalizeSDKResponse(response, fallback, options) {
@@ -6124,13 +6123,29 @@ var MODEL_VERSION_MAP;
 var init_model_versions = __esm(() => {
   MODEL_VERSION_MAP = {
     "anthropic/claude-opus-4-5": "anthropic/claude-opus-4-6",
-    "anthropic/claude-sonnet-4-5": "anthropic/claude-sonnet-4-6"
+    "anthropic/claude-sonnet-4-5": "anthropic/claude-sonnet-4-6",
+    "openai/gpt-5.3-codex": "openai/gpt-5.4"
   };
 });
 
 // src/shared/migration/agent-category.ts
 var init_agent_category = () => {};
 
+// src/shared/write-file-atomically.ts
+import { closeSync, fsyncSync, openSync, renameSync, writeFileSync } from "fs";
+function writeFileAtomically(filePath, content) {
+  const tempPath = `${filePath}.tmp`;
+  writeFileSync(tempPath, content, "utf-8");
+  const tempFileDescriptor = openSync(tempPath, "r");
+  try {
+    fsyncSync(tempFileDescriptor);
+  } finally {
+    closeSync(tempFileDescriptor);
+  }
+  renameSync(tempPath, filePath);
+}
+var init_write_file_atomically = () => {};
+
 // src/shared/migration/config-migration.ts
 import * as fs2 from "fs";
 function migrateConfigFile(configPath, rawConfig) {
@@ -6219,11 +6234,13 @@ function migrateConfigFile(configPath, rawConfig) {
     try {
       fs2.copyFileSync(configPath, backupPath);
       backupSucceeded = true;
-    } catch {}
+    } catch {
+      backupSucceeded = false;
+    }
     let writeSucceeded = false;
     try {
-      fs2.writeFileSync(configPath, JSON.stringify(copy, null, 2) + `
-`, "utf-8");
+      writeFileAtomically(configPath, JSON.stringify(copy, null, 2) + `
+`);
       writeSucceeded = true;
     } catch (err) {
       log(`Failed to write migrated config to ${configPath}:`, err);
@@ -6244,6 +6261,7 @@ function migrateConfigFile(configPath, rawConfig) {
 }
 var init_config_migration = __esm(() => {
   init_logger();
+  init_write_file_atomically();
   init_agent_names();
   init_hook_names();
   init_model_versions();
@@ -6344,11 +6362,45 @@ var init_external_plugin_detector = __esm(() => {
   init_plugin_identity();
 });
 
+// src/shared/archive-entry-validator.ts
+var init_archive_entry_validator = () => {};
+
+// src/shared/zip-entry-listing/python-zip-entry-listing.ts
+var init_python_zip_entry_listing = () => {};
+
+// src/shared/zip-entry-listing/powershell-zip-entry-listing.ts
+var init_powershell_zip_entry_listing = () => {};
+
+// src/shared/zip-entry-listing/tar-zip-entry-listing.ts
+var init_tar_zip_entry_listing = __esm(() => {
+  init_logger();
+});
+
+// src/shared/zip-entry-listing/read-zip-symlink-target.ts
+var init_read_zip_symlink_target = () => {};
+
+// src/shared/zip-entry-listing/zipinfo-zip-entry-listing.ts
+var init_zipinfo_zip_entry_listing = __esm(() => {
+  init_read_zip_symlink_target();
+});
+
+// src/shared/zip-entry-listing.ts
+var init_zip_entry_listing = __esm(() => {
+  init_python_zip_entry_listing();
+  init_powershell_zip_entry_listing();
+  init_tar_zip_entry_listing();
+  init_zipinfo_zip_entry_listing();
+});
+
 // src/shared/zip-extractor.ts
-var init_zip_extractor = () => {};
+var init_zip_extractor = __esm(() => {
+  init_archive_entry_validator();
+  init_zip_entry_listing();
+});
 
 // src/shared/binary-downloader.ts
 var init_binary_downloader = __esm(() => {
+  init_archive_entry_validator();
   init_zip_extractor();
 });
 
@@ -6415,7 +6467,7 @@ var init_model_requirements = __esm(() => {
     librarian: {
       fallbackChain: [
         { providers: ["opencode-go"], model: "minimax-m2.7" },
-        { providers: ["opencode"], model: "minimax-m2.5" },
+        { providers: ["opencode"], model: "minimax-m2.7-highspeed" },
         { providers: ["anthropic", "opencode"], model: "claude-haiku-4-5" },
         { providers: ["opencode"], model: "gpt-5-nano" }
       ]
@@ -6423,8 +6475,8 @@ var init_model_requirements = __esm(() => {
     explore: {
       fallbackChain: [
         { providers: ["github-copilot", "xai"], model: "grok-code-fast-1" },
-        { providers: ["opencode-go"], model: "minimax-m2.7" },
-        { providers: ["opencode"], model: "minimax-m2.5" },
+        { providers: ["opencode-go"], model: "minimax-m2.7-highspeed" },
+        { providers: ["opencode"], model: "minimax-m2.7" },
         { providers: ["anthropic", "opencode"], model: "claude-haiku-4-5" },
         { providers: ["opencode"], model: "gpt-5-nano" }
       ]
@@ -6559,8 +6611,8 @@ var init_model_requirements = __esm(() => {
     deep: {
       fallbackChain: [
         {
-          providers: ["openai", "opencode"],
-          model: "gpt-5.3-codex",
+          providers: ["openai", "github-copilot", "venice", "opencode"],
+          model: "gpt-5.4",
           variant: "medium"
         },
         {
@@ -6573,8 +6625,7 @@ var init_model_requirements = __esm(() => {
           model: "gemini-3.1-pro",
           variant: "high"
         }
-      ],
-      requiresModel: "gpt-5.3-codex"
+      ]
     },
     artistry: {
       fallbackChain: [
@@ -6685,6 +6736,22 @@ var sessionCursors;
 var init_session_cursor = __esm(() => {
   sessionCursors = new Map;
 });
+
+// src/shared/shell-env.ts
+function detectShellType() {
+  if (process.env.PSModulePath) {
+    return "powershell";
+  }
+  if (process.env.SHELL) {
+    const shell = process.env.SHELL;
+    if (shell.includes("csh") || shell.includes("tcsh")) {
+      return "csh";
+    }
+    return "unix";
+  }
+  return process.platform === "win32" ? "cmd" : "unix";
+}
+
 // src/shared/system-directive.ts
 var init_system_directive = () => {};
 
@@ -6696,108 +6763,122 @@ function normalizeModelID(modelID) {
   return modelID.replace(/\.(\d+)/g, "-$1");
 }
 
-// src/shared/connected-providers-cache.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync } from "fs";
+// src/shared/json-file-cache-store.ts
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 import { join as join5 } from "path";
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
+function toLogLabel(cacheLabel) {
+  return cacheLabel.toLowerCase();
 }
-function createConnectedProvidersCacheStore(getCacheDir2 = getOmoOpenCodeCacheDir) {
-  function getCacheFilePath(filename) {
-    return join5(getCacheDir2(), filename);
+function createJsonFileCacheStore(options) {
+  let memoryValue;
+  function getCacheFilePath() {
+    return join5(options.getCacheDir(), options.filename);
   }
-  let memConnected;
-  let memProviderModels;
   function ensureCacheDir() {
-    const cacheDir = getCacheDir2();
+    const cacheDir = options.getCacheDir();
     if (!existsSync3(cacheDir)) {
       mkdirSync(cacheDir, { recursive: true });
     }
   }
-  function readConnectedProvidersCache() {
-    if (memConnected !== undefined)
-      return memConnected;
-    const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE);
+  function read() {
+    if (memoryValue !== undefined) {
+      return memoryValue;
+    }
+    const cacheFile = getCacheFilePath();
     if (!existsSync3(cacheFile)) {
-      log("[connected-providers-cache] Cache file not found", { cacheFile });
-      memConnected = null;
+      memoryValue = null;
+      log(`[${options.logPrefix}] ${options.cacheLabel} file not found`, { cacheFile });
       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;
+      const value = JSON.parse(content);
+      memoryValue = value;
+      log(`[${options.logPrefix}] Read ${toLogLabel(options.cacheLabel)}`, options.describe(value));
+      return value;
+    } catch (error) {
+      memoryValue = null;
+      log(`[${options.logPrefix}] Error reading ${toLogLabel(options.cacheLabel)}`, {
+        error: String(error)
+      });
       return null;
     }
   }
+  function has() {
+    return existsSync3(getCacheFilePath());
+  }
+  function write(value) {
+    ensureCacheDir();
+    const cacheFile = getCacheFilePath();
+    try {
+      writeFileSync2(cacheFile, options.serialize?.(value) ?? JSON.stringify(value, null, 2));
+      memoryValue = value;
+      log(`[${options.logPrefix}] ${options.cacheLabel} written`, options.describe(value));
+    } catch (error) {
+      log(`[${options.logPrefix}] Error writing ${toLogLabel(options.cacheLabel)}`, {
+        error: String(error)
+      });
+    }
+  }
+  function resetMemory() {
+    memoryValue = undefined;
+  }
+  return {
+    read,
+    has,
+    write,
+    resetMemory
+  };
+}
+var init_json_file_cache_store = __esm(() => {
+  init_logger();
+});
+
+// src/shared/connected-providers-cache.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function createConnectedProvidersCacheStore(getCacheDir2 = getOmoOpenCodeCacheDir) {
+  const connectedProvidersCacheStore = createJsonFileCacheStore({
+    getCacheDir: getCacheDir2,
+    filename: CONNECTED_PROVIDERS_CACHE_FILE,
+    logPrefix: "connected-providers-cache",
+    cacheLabel: "Cache",
+    describe: (value) => ({ count: value.connected.length, updatedAt: value.updatedAt })
+  });
+  const providerModelsCacheStore = createJsonFileCacheStore({
+    getCacheDir: getCacheDir2,
+    filename: PROVIDER_MODELS_CACHE_FILE,
+    logPrefix: "connected-providers-cache",
+    cacheLabel: "Provider-models cache",
+    describe: (value) => ({
+      providerCount: Object.keys(value.models).length,
+      updatedAt: value.updatedAt
+    })
+  });
+  function readConnectedProvidersCache() {
+    return connectedProvidersCacheStore.read()?.connected ?? null;
+  }
   function hasConnectedProvidersCache() {
-    const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE);
-    return existsSync3(cacheFile);
+    return connectedProvidersCacheStore.has();
   }
   function writeConnectedProvidersCache(connected) {
-    ensureCacheDir();
-    const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE);
-    const data = {
+    connectedProvidersCacheStore.write({
       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) });
-    }
+    });
   }
   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;
-    }
+    return providerModelsCacheStore.read();
   }
   function hasProviderModelsCache() {
-    const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
-    return existsSync3(cacheFile);
+    return providerModelsCacheStore.has();
   }
   function writeProviderModelsCache(data) {
-    ensureCacheDir();
-    const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
-    const cacheData = {
+    providerModelsCacheStore.write({
       ...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) {
@@ -6843,13 +6924,18 @@ function createConnectedProvidersCacheStore(getCacheDir2 = getOmoOpenCodeCacheDi
       log("[connected-providers-cache] Error updating cache", { error: String(err) });
     }
   }
+  function _resetMemCacheForTesting() {
+    connectedProvidersCacheStore.resetMemory();
+    providerModelsCacheStore.resetMemory();
+  }
   return {
     readConnectedProvidersCache,
     hasConnectedProvidersCache,
     readProviderModelsCache,
     hasProviderModelsCache,
     writeProviderModelsCache,
-    updateConnectedProvidersCache
+    updateConnectedProvidersCache,
+    _resetMemCacheForTesting
   };
 }
 function findProviderModelMetadata(providerID, modelID, cache = defaultConnectedProvidersCacheStore.readProviderModelsCache()) {
@@ -6864,16 +6950,17 @@ function findProviderModelMetadata(providerID, modelID, cache = defaultConnected
       }
       continue;
     }
-    if (entry?.id === modelID) {
+    if (entry.id === modelID) {
       return entry;
     }
   }
   return;
 }
-var CONNECTED_PROVIDERS_CACHE_FILE = "connected-providers.json", PROVIDER_MODELS_CACHE_FILE = "provider-models.json", defaultConnectedProvidersCacheStore, readConnectedProvidersCache, hasConnectedProvidersCache, readProviderModelsCache, hasProviderModelsCache, writeProviderModelsCache, updateConnectedProvidersCache;
+var CONNECTED_PROVIDERS_CACHE_FILE = "connected-providers.json", PROVIDER_MODELS_CACHE_FILE = "provider-models.json", defaultConnectedProvidersCacheStore, readConnectedProvidersCache, hasConnectedProvidersCache, readProviderModelsCache, hasProviderModelsCache, writeProviderModelsCache, updateConnectedProvidersCache, _resetMemCacheForTesting;
 var init_connected_providers_cache = __esm(() => {
   init_logger();
   init_data_path();
+  init_json_file_cache_store();
   defaultConnectedProvidersCacheStore = createConnectedProvidersCacheStore(() => getOmoOpenCodeCacheDir());
   ({
     readConnectedProvidersCache,
@@ -6881,7 +6968,8 @@ var init_connected_providers_cache = __esm(() => {
     readProviderModelsCache,
     hasProviderModelsCache,
     writeProviderModelsCache,
-    updateConnectedProvidersCache
+    updateConnectedProvidersCache,
+    _resetMemCacheForTesting
   } = defaultConnectedProvidersCacheStore);
 });
 
@@ -19059,7 +19147,7 @@ var init_model_capabilities_generated = __esm(() => {
         family: "gpt-nano",
         reasoning: false,
         temperature: true,
-        toolCall: false,
+        toolCall: true,
         modalities: {
           input: [
             "text",
@@ -19220,7 +19308,7 @@ var init_model_capabilities_generated = __esm(() => {
         family: "gpt-mini",
         reasoning: false,
         temperature: true,
-        toolCall: false,
+        toolCall: true,
         modalities: {
           input: [
             "text",
@@ -47636,53 +47724,62 @@ var init_model_capabilities_generated = __esm(() => {
   };
 });
 
+// src/shared/model-capabilities/bundled-snapshot.ts
+function normalizeSnapshot(snapshot) {
+  return snapshot;
+}
+function getBundledModelCapabilitiesSnapshot() {
+  return bundledModelCapabilitiesSnapshot;
+}
+var bundledModelCapabilitiesSnapshot;
+var init_bundled_snapshot = __esm(() => {
+  init_model_capabilities_generated();
+  bundledModelCapabilitiesSnapshot = normalizeSnapshot(model_capabilities_generated_default);
+});
+
 // src/shared/model-capability-aliases.ts
 function normalizeLookupModelID(modelID) {
   return modelID.trim().toLowerCase();
 }
+function stripProviderPrefixForAliasLookup(normalizedModelID) {
+  const slashIndex = normalizedModelID.indexOf("/");
+  if (slashIndex <= 0 || slashIndex === normalizedModelID.length - 1) {
+    return normalizedModelID;
+  }
+  return normalizedModelID.slice(slashIndex + 1);
+}
 function resolveModelIDAlias(modelID) {
-  const normalizedModelID = normalizeLookupModelID(modelID);
-  const exactRule = EXACT_ALIAS_RULES_BY_MODEL.get(normalizedModelID);
+  const requestedModelID = normalizeLookupModelID(modelID);
+  const aliasLookupModelID = stripProviderPrefixForAliasLookup(requestedModelID);
+  const exactRule = EXACT_ALIAS_RULES_BY_MODEL.get(aliasLookupModelID);
   if (exactRule) {
     return {
-      requestedModelID: normalizedModelID,
+      requestedModelID,
       canonicalModelID: exactRule.canonicalModelID,
       source: "exact-alias",
       ruleID: exactRule.ruleID
     };
   }
   for (const rule of PATTERN_ALIAS_RULES) {
-    if (!rule.match(normalizedModelID)) {
+    if (!rule.match(aliasLookupModelID)) {
       continue;
     }
     return {
-      requestedModelID: normalizedModelID,
-      canonicalModelID: rule.canonicalize(normalizedModelID),
+      requestedModelID,
+      canonicalModelID: rule.canonicalize(aliasLookupModelID),
       source: "pattern-alias",
       ruleID: rule.ruleID
     };
   }
   return {
-    requestedModelID: normalizedModelID,
-    canonicalModelID: normalizedModelID,
+    requestedModelID,
+    canonicalModelID: aliasLookupModelID,
     source: "canonical"
   };
 }
 var EXACT_ALIAS_RULES, EXACT_ALIAS_RULES_BY_MODEL, PATTERN_ALIAS_RULES;
 var init_model_capability_aliases = __esm(() => {
   EXACT_ALIAS_RULES = [
-    {
-      aliasModelID: "gemini-3.1-pro-high",
-      ruleID: "gemini-3.1-pro-tier-alias",
-      canonicalModelID: "gemini-3.1-pro",
-      rationale: "OmO historically encoded Gemini tier selection in the model name instead of variant metadata."
-    },
-    {
-      aliasModelID: "gemini-3.1-pro-low",
-      ruleID: "gemini-3.1-pro-tier-alias",
-      canonicalModelID: "gemini-3.1-pro",
-      rationale: "OmO historically encoded Gemini tier selection in the model name instead of variant metadata."
-    },
     {
       aliasModelID: "gemini-3-pro-high",
       ruleID: "gemini-3-pro-tier-alias",
@@ -47694,16 +47791,23 @@ var init_model_capability_aliases = __esm(() => {
       ruleID: "gemini-3-pro-tier-alias",
       canonicalModelID: "gemini-3-pro-preview",
       rationale: "Legacy Gemini 3 tier suffixes still need to land on the canonical preview model."
+    }
+  ];
+  EXACT_ALIAS_RULES_BY_MODEL = new Map(EXACT_ALIAS_RULES.map((rule) => [rule.aliasModelID, rule]));
+  PATTERN_ALIAS_RULES = [
+    {
+      ruleID: "claude-thinking-legacy-alias",
+      description: "Normalizes the legacy Claude Opus 4.6 thinking suffix to the canonical snapshot ID.",
+      match: (normalizedModelID) => /^claude-opus-4-6-thinking$/.test(normalizedModelID),
+      canonicalize: () => "claude-opus-4-6"
     },
     {
-      aliasModelID: "claude-opus-4-6-thinking",
-      ruleID: "claude-opus-4-6-thinking-legacy-alias",
-      canonicalModelID: "claude-opus-4-6",
-      rationale: "OmO historically used a legacy compatibility suffix before models.dev shipped canonical thinking variants for newer Claude families."
+      ruleID: "gemini-3.1-pro-tier-alias",
+      description: "Normalizes Gemini 3.1 Pro tier suffixes to the canonical snapshot ID.",
+      match: (normalizedModelID) => /^gemini-3\.1-pro-(?:high|low)$/.test(normalizedModelID),
+      canonicalize: () => "gemini-3.1-pro"
     }
   ];
-  EXACT_ALIAS_RULES_BY_MODEL = new Map(EXACT_ALIAS_RULES.map((rule) => [rule.aliasModelID, rule]));
-  PATTERN_ALIAS_RULES = [];
 });
 
 // src/shared/model-capability-heuristics.ts
@@ -47789,13 +47893,10 @@ var init_model_capability_heuristics = __esm(() => {
   ];
 });
 
-// src/shared/model-capabilities.ts
+// src/shared/model-capabilities/runtime-model-readers.ts
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function normalizeLookupModelID2(modelID) {
-  return modelID.trim().toLowerCase();
-}
 function readNumber(value) {
   return typeof value === "number" ? value : undefined;
 }
@@ -47842,32 +47943,13 @@ function normalizeModalities(value) {
     ...output ? { output } : {}
   };
 }
-function normalizeSnapshot(snapshot) {
-  return snapshot;
-}
-function getOverride(modelID) {
-  return MODEL_ID_OVERRIDES[normalizeLookupModelID2(modelID)];
-}
 function readRuntimeModelCapabilities(runtimeModel) {
   return isRecord2(runtimeModel?.capabilities) ? runtimeModel.capabilities : undefined;
 }
-function readRuntimeModelLimitOutput(runtimeModel) {
-  if (!runtimeModel) {
-    return;
-  }
-  const limit = isRecord2(runtimeModel.limit) ? runtimeModel.limit : readRuntimeModelCapabilities(runtimeModel)?.limit;
-  if (!isRecord2(limit)) {
-    return;
-  }
-  return readNumber(limit.output);
-}
 function readRuntimeModelBoolean(runtimeModel, keys) {
-  if (!runtimeModel) {
-    return;
-  }
   const runtimeCapabilities = readRuntimeModelCapabilities(runtimeModel);
   for (const key of keys) {
-    const value = runtimeModel[key];
+    const value = runtimeModel?.[key];
     if (typeof value === "boolean") {
       return value;
     }
@@ -47878,114 +47960,110 @@ function readRuntimeModelBoolean(runtimeModel, keys) {
   }
   return;
 }
-function readRuntimeModelModalities(runtimeModel) {
-  if (!runtimeModel) {
-    return;
-  }
-  const rootModalities = normalizeModalities(runtimeModel.modalities);
-  if (rootModalities) {
-    return rootModalities;
-  }
-  const runtimeCapabilities = readRuntimeModelCapabilities(runtimeModel);
-  if (!runtimeCapabilities) {
-    return;
-  }
-  const nestedModalities = normalizeModalities(runtimeCapabilities.modalities);
-  if (nestedModalities) {
-    return nestedModalities;
-  }
-  const capabilityModalities = normalizeModalities(runtimeCapabilities);
-  if (capabilityModalities) {
-    return capabilityModalities;
-  }
-  return;
+function readRuntimeModel(runtimeModel) {
+  return isRecord2(runtimeModel) ? runtimeModel : undefined;
 }
 function readRuntimeModelVariants(runtimeModel) {
-  if (!runtimeModel) {
-    return;
-  }
-  const rootVariants = normalizeVariantKeys(runtimeModel.variants);
+  const rootVariants = normalizeVariantKeys(runtimeModel?.variants);
   if (rootVariants) {
     return rootVariants;
   }
-  const runtimeCapabilities = readRuntimeModelCapabilities(runtimeModel);
-  if (!runtimeCapabilities) {
-    return;
-  }
-  return normalizeVariantKeys(runtimeCapabilities.variants);
-}
-function readRuntimeModelTopPSupport(runtimeModel) {
-  return readRuntimeModelBoolean(runtimeModel, ["topP", "top_p"]);
+  return normalizeVariantKeys(readRuntimeModelCapabilities(runtimeModel)?.variants);
 }
-function readRuntimeModelToolCallSupport(runtimeModel) {
-  return readRuntimeModelBoolean(runtimeModel, ["toolCall", "tool_call", "toolcall"]);
+function readRuntimeModelModalities(runtimeModel) {
+  const rootModalities = normalizeModalities(runtimeModel?.modalities);
+  if (rootModalities) {
+    return rootModalities;
+  }
+  const runtimeCapabilities = readRuntimeModelCapabilities(runtimeModel);
+  return normalizeModalities(runtimeCapabilities?.modalities) ?? normalizeModalities(runtimeCapabilities);
 }
 function readRuntimeModelReasoningSupport(runtimeModel) {
   return readRuntimeModelBoolean(runtimeModel, ["reasoning"]);
 }
-function readRuntimeModelTemperatureSupport(runtimeModel) {
-  return readRuntimeModelBoolean(runtimeModel, ["temperature"]);
-}
 function readRuntimeModelThinkingSupport(runtimeModel) {
   const capabilityValue = readRuntimeModelReasoningSupport(runtimeModel);
   if (capabilityValue !== undefined) {
     return capabilityValue;
   }
-  const rootThinkingSupport = readRuntimeModelBoolean(runtimeModel, ["thinking", "supportsThinking"]);
-  if (rootThinkingSupport !== undefined) {
-    return rootThinkingSupport;
+  const thinkingSupport = readRuntimeModelBoolean(runtimeModel, ["thinking", "supportsThinking"]);
+  if (thinkingSupport !== undefined) {
+    return thinkingSupport;
   }
   const runtimeCapabilities = readRuntimeModelCapabilities(runtimeModel);
-  if (!runtimeCapabilities) {
-    return;
-  }
   for (const key of ["thinking", "supportsThinking"]) {
-    const value = runtimeCapabilities[key];
+    const value = runtimeCapabilities?.[key];
     if (typeof value === "boolean") {
       return value;
     }
   }
   return;
 }
-function readRuntimeModel(runtimeModel) {
-  return isRecord2(runtimeModel) ? runtimeModel : undefined;
+function readRuntimeModelTemperatureSupport(runtimeModel) {
+  return readRuntimeModelBoolean(runtimeModel, ["temperature"]);
+}
+function readRuntimeModelTopPSupport(runtimeModel) {
+  return readRuntimeModelBoolean(runtimeModel, ["topP", "top_p"]);
+}
+function readRuntimeModelToolCallSupport(runtimeModel) {
+  return readRuntimeModelBoolean(runtimeModel, ["toolCall", "tool_call", "toolcall"]);
+}
+function readRuntimeModelLimitOutput(runtimeModel) {
+  const limit = isRecord2(runtimeModel?.limit) ? runtimeModel.limit : readRuntimeModelCapabilities(runtimeModel)?.limit;
+  if (!isRecord2(limit)) {
+    return;
+  }
+  return readNumber(limit.output);
+}
+
+// src/shared/model-capabilities/get-model-capabilities.ts
+function normalizeLookupModelID2(modelID) {
+  return modelID.trim().toLowerCase();
+}
+function getOverride(modelID) {
+  return MODEL_ID_OVERRIDES[normalizeLookupModelID2(modelID)];
 }
 function getModelCapabilities(input) {
   const canonicalization = resolveModelIDAlias(input.modelID);
-  const requestedModelID = canonicalization.requestedModelID;
-  const canonicalModelID = canonicalization.canonicalModelID;
   const override = getOverride(input.modelID);
   const runtimeModel = readRuntimeModel(input.runtimeModel ?? findProviderModelMetadata(input.providerID, input.modelID));
   const runtimeSnapshot = input.runtimeSnapshot;
-  const bundledSnapshot = input.bundledSnapshot ?? bundledModelCapabilitiesSnapshot;
-  const snapshotEntry = runtimeSnapshot?.models?.[canonicalModelID] ?? bundledSnapshot.models[canonicalModelID];
-  const heuristicFamily = detectHeuristicModelFamily(canonicalModelID);
+  const bundledSnapshot = input.bundledSnapshot ?? getBundledModelCapabilitiesSnapshot();
+  const snapshotEntry = runtimeSnapshot?.models?.[canonicalization.canonicalModelID] ?? bundledSnapshot.models[canonicalization.canonicalModelID];
+  const heuristicFamily = detectHeuristicModelFamily(canonicalization.canonicalModelID);
   const runtimeVariants = readRuntimeModelVariants(runtimeModel);
-  const snapshotSource = runtimeSnapshot?.models?.[canonicalModelID] ? "runtime-snapshot" : bundledSnapshot.models[canonicalModelID] ? "bundled-snapshot" : "none";
+  const runtimeReasoning = readRuntimeModelReasoningSupport(runtimeModel);
+  const runtimeThinking = readRuntimeModelThinkingSupport(runtimeModel);
+  const runtimeTemperature = readRuntimeModelTemperatureSupport(runtimeModel);
+  const runtimeTopP = readRuntimeModelTopPSupport(runtimeModel);
+  const runtimeMaxOutputTokens = readRuntimeModelLimitOutput(runtimeModel);
+  const runtimeToolCall = readRuntimeModelToolCallSupport(runtimeModel);
+  const runtimeModalities = readRuntimeModelModalities(runtimeModel);
+  const snapshotSource = runtimeSnapshot?.models?.[canonicalization.canonicalModelID] ? "runtime-snapshot" : bundledSnapshot.models[canonicalization.canonicalModelID] ? "bundled-snapshot" : "none";
   const familySource = snapshotEntry?.family ? "snapshot" : heuristicFamily?.family ? "heuristic" : "none";
   const variantsSource = runtimeVariants ? "runtime" : override?.variants ? "override" : heuristicFamily?.variants ? "heuristic" : "none";
   const reasoningEffortsSource = override?.reasoningEfforts ? "override" : heuristicFamily?.reasoningEfforts ? "heuristic" : "none";
-  const reasoningSource = readRuntimeModelReasoningSupport(runtimeModel) !== undefined ? "runtime" : snapshotEntry?.reasoning !== undefined ? snapshotSource : "none";
-  const supportsThinkingSource = override?.supportsThinking !== undefined ? "override" : heuristicFamily?.supportsThinking !== undefined ? "heuristic" : readRuntimeModelThinkingSupport(runtimeModel) !== undefined ? "runtime" : snapshotEntry?.reasoning !== undefined ? snapshotSource : "none";
-  const supportsTemperatureSource = readRuntimeModelTemperatureSupport(runtimeModel) !== undefined ? "runtime" : override?.supportsTemperature !== undefined ? "override" : snapshotEntry?.temperature !== undefined ? snapshotSource : "none";
-  const supportsTopPSource = readRuntimeModelTopPSupport(runtimeModel) !== undefined ? "runtime" : override?.supportsTopP !== undefined ? "override" : "none";
-  const maxOutputTokensSource = readRuntimeModelLimitOutput(runtimeModel) !== undefined ? "runtime" : snapshotEntry?.limit?.output !== undefined ? snapshotSource : "none";
-  const toolCallSource = readRuntimeModelToolCallSupport(runtimeModel) !== undefined ? "runtime" : snapshotEntry?.toolCall !== undefined ? snapshotSource : "none";
-  const modalitiesSource = readRuntimeModelModalities(runtimeModel) !== undefined ? "runtime" : snapshotEntry?.modalities !== undefined ? snapshotSource : "none";
+  const reasoningSource = runtimeReasoning === undefined ? snapshotEntry?.reasoning === undefined ? "none" : snapshotSource : "runtime";
+  const supportsThinkingSource = override?.supportsThinking !== undefined ? "override" : heuristicFamily?.supportsThinking !== undefined ? "heuristic" : runtimeThinking !== undefined ? "runtime" : snapshotEntry?.reasoning !== undefined ? snapshotSource : "none";
+  const supportsTemperatureSource = runtimeTemperature !== undefined ? "runtime" : override?.supportsTemperature !== undefined ? "override" : snapshotEntry?.temperature !== undefined ? snapshotSource : "none";
+  const supportsTopPSource = runtimeTopP !== undefined ? "runtime" : override?.supportsTopP !== undefined ? "override" : "none";
+  const maxOutputTokensSource = runtimeMaxOutputTokens !== undefined ? "runtime" : snapshotEntry?.limit?.output !== undefined ? snapshotSource : "none";
+  const toolCallSource = runtimeToolCall !== undefined ? "runtime" : snapshotEntry?.toolCall !== undefined ? snapshotSource : "none";
+  const modalitiesSource = runtimeModalities !== undefined ? "runtime" : snapshotEntry?.modalities !== undefined ? snapshotSource : "none";
   const resolutionMode = snapshotSource !== "none" && canonicalization.source === "canonical" ? "snapshot-backed" : snapshotSource !== "none" ? "alias-backed" : familySource === "heuristic" || variantsSource === "heuristic" || reasoningEffortsSource === "heuristic" ? "heuristic-backed" : "unknown";
   return {
-    requestedModelID,
-    canonicalModelID,
+    requestedModelID: canonicalization.requestedModelID,
+    canonicalModelID: canonicalization.canonicalModelID,
     family: snapshotEntry?.family ?? heuristicFamily?.family,
     variants: runtimeVariants ?? override?.variants ?? heuristicFamily?.variants,
     reasoningEfforts: override?.reasoningEfforts ?? heuristicFamily?.reasoningEfforts,
-    reasoning: readRuntimeModelReasoningSupport(runtimeModel) ?? snapshotEntry?.reasoning,
-    supportsThinking: override?.supportsThinking ?? heuristicFamily?.supportsThinking ?? readRuntimeModelThinkingSupport(runtimeModel) ?? snapshotEntry?.reasoning,
-    supportsTemperature: readRuntimeModelTemperatureSupport(runtimeModel) ?? override?.supportsTemperature ?? snapshotEntry?.temperature,
-    supportsTopP: readRuntimeModelTopPSupport(runtimeModel) ?? override?.supportsTopP,
-    maxOutputTokens: readRuntimeModelLimitOutput(runtimeModel) ?? snapshotEntry?.limit?.output,
-    toolCall: readRuntimeModelToolCallSupport(runtimeModel) ?? snapshotEntry?.toolCall,
-    modalities: readRuntimeModelModalities(runtimeModel) ?? snapshotEntry?.modalities,
+    reasoning: runtimeReasoning ?? snapshotEntry?.reasoning,
+    supportsThinking: override?.supportsThinking ?? heuristicFamily?.supportsThinking ?? runtimeThinking ?? snapshotEntry?.reasoning,
+    supportsTemperature: runtimeTemperature ?? override?.supportsTemperature ?? snapshotEntry?.temperature,
+    supportsTopP: runtimeTopP ?? override?.supportsTopP,
+    maxOutputTokens: runtimeMaxOutputTokens ?? snapshotEntry?.limit?.output,
+    toolCall: runtimeToolCall ?? snapshotEntry?.toolCall,
+    modalities: runtimeModalities ?? snapshotEntry?.modalities,
     diagnostics: {
       resolutionMode,
       canonicalization: {
@@ -48006,19 +48084,22 @@ function getModelCapabilities(input) {
     }
   };
 }
-var MODEL_ID_OVERRIDES, bundledModelCapabilitiesSnapshot;
-var init_model_capabilities = __esm(() => {
-  init_model_capabilities_generated();
+var MODEL_ID_OVERRIDES;
+var init_get_model_capabilities = __esm(() => {
   init_connected_providers_cache();
   init_model_capability_aliases();
   init_model_capability_heuristics();
+  init_bundled_snapshot();
   MODEL_ID_OVERRIDES = {};
-  bundledModelCapabilitiesSnapshot = normalizeSnapshot(model_capabilities_generated_default);
+});
+
+// src/shared/model-capabilities/index.ts
+var init_model_capabilities = __esm(() => {
+  init_bundled_snapshot();
+  init_get_model_capabilities();
 });
 
 // src/shared/model-capabilities-cache.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
-import { join as join7 } from "path";
 function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -48132,54 +48213,26 @@ async function fetchModelCapabilitiesSnapshot(args = {}) {
   };
 }
 function createModelCapabilitiesCacheStore(getCacheDir2 = getOmoOpenCodeCacheDir) {
-  let memSnapshot;
-  function getCacheFilePath() {
-    return join7(getCacheDir2(), MODEL_CAPABILITIES_CACHE_FILE);
-  }
-  function ensureCacheDir() {
-    const cacheDir = getCacheDir2();
-    if (!existsSync5(cacheDir)) {
-      mkdirSync2(cacheDir, { recursive: true });
-    }
-  }
+  const snapshotCacheStore = createJsonFileCacheStore({
+    getCacheDir: getCacheDir2,
+    filename: MODEL_CAPABILITIES_CACHE_FILE,
+    logPrefix: "model-capabilities-cache",
+    cacheLabel: "Cache",
+    describe: (snapshot) => ({
+      modelCount: Object.keys(snapshot.models).length,
+      generatedAt: snapshot.generatedAt
+    }),
+    serialize: (snapshot) => `${JSON.stringify(snapshot, null, 2)}
+`
+  });
   function readModelCapabilitiesCache() {
-    if (memSnapshot !== undefined) {
-      return memSnapshot;
-    }
-    const cacheFile = getCacheFilePath();
-    if (!existsSync5(cacheFile)) {
-      memSnapshot = null;
-      log("[model-capabilities-cache] Cache file not found", { cacheFile });
-      return null;
-    }
-    try {
-      const content = readFileSync4(cacheFile, "utf-8");
-      const snapshot = JSON.parse(content);
-      memSnapshot = snapshot;
-      log("[model-capabilities-cache] Read cache", {
-        modelCount: Object.keys(snapshot.models).length,
-        generatedAt: snapshot.generatedAt
-      });
-      return snapshot;
-    } catch (error) {
-      memSnapshot = null;
-      log("[model-capabilities-cache] Error reading cache", { error: String(error) });
-      return null;
-    }
+    return snapshotCacheStore.read();
   }
   function hasModelCapabilitiesCache() {
-    return existsSync5(getCacheFilePath());
+    return snapshotCacheStore.has();
   }
   function writeModelCapabilitiesCache(snapshot) {
-    ensureCacheDir();
-    const cacheFile = getCacheFilePath();
-    writeFileSync3(cacheFile, JSON.stringify(snapshot, null, 2) + `
-`);
-    memSnapshot = snapshot;
-    log("[model-capabilities-cache] Cache written", {
-      modelCount: Object.keys(snapshot.models).length,
-      generatedAt: snapshot.generatedAt
-    });
+    snapshotCacheStore.write(snapshot);
   }
   async function refreshModelCapabilitiesCache(args = {}) {
     const snapshot = await fetchModelCapabilitiesSnapshot(args);
@@ -48196,7 +48249,7 @@ function createModelCapabilitiesCacheStore(getCacheDir2 = getOmoOpenCodeCacheDir
 var MODELS_DEV_SOURCE_URL = "https://models.dev/api.json", MODEL_CAPABILITIES_CACHE_FILE = "model-capabilities.json", defaultModelCapabilitiesCacheStore, readModelCapabilitiesCache, hasModelCapabilitiesCache, writeModelCapabilitiesCache, refreshModelCapabilitiesCache;
 var init_model_capabilities_cache = __esm(() => {
   init_data_path();
-  init_logger();
+  init_json_file_cache_store();
   defaultModelCapabilitiesCacheStore = createModelCapabilitiesCacheStore(() => getOmoOpenCodeCacheDir());
   ({
     readModelCapabilitiesCache,
@@ -48241,24 +48294,26 @@ var init_hook_message_injector = __esm(() => {
 });
 
 // src/shared/opencode-storage-paths.ts
-import { join as join8 } from "path";
+import { join as join7 } from "path";
 var OPENCODE_STORAGE, MESSAGE_STORAGE, PART_STORAGE, SESSION_STORAGE;
 var init_opencode_storage_paths = __esm(() => {
   init_data_path();
   OPENCODE_STORAGE = getOpenCodeStorageDir();
-  MESSAGE_STORAGE = join8(OPENCODE_STORAGE, "message");
-  PART_STORAGE = join8(OPENCODE_STORAGE, "part");
-  SESSION_STORAGE = join8(OPENCODE_STORAGE, "session");
+  MESSAGE_STORAGE = join7(OPENCODE_STORAGE, "message");
+  PART_STORAGE = join7(OPENCODE_STORAGE, "part");
+  SESSION_STORAGE = join7(OPENCODE_STORAGE, "session");
 });
 
 // src/shared/opencode-message-dir.ts
 var init_opencode_message_dir = __esm(() => {
   init_opencode_storage_paths();
-  init_opencode_storage_detection();
   init_logger();
 });
 
 // src/shared/agent-display-names.ts
+function stripAgentListSortPrefix(agentName) {
+  return agentName.replace(/^\u200B+/, "");
+}
 function getAgentDisplayName(configKey) {
   const exactMatch = AGENT_DISPLAY_NAMES[configKey];
   if (exactMatch !== undefined)
@@ -48271,7 +48326,7 @@ function getAgentDisplayName(configKey) {
   return configKey;
 }
 function getAgentConfigKey(agentName) {
-  const lower = agentName.toLowerCase();
+  const lower = stripAgentListSortPrefix(agentName).toLowerCase();
   const reversed = REVERSE_DISPLAY_NAMES[lower];
   if (reversed !== undefined)
     return reversed;
@@ -48289,10 +48344,13 @@ var init_agent_display_names = __esm(() => {
     "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"
+    "multimodal-looker": "multimodal-looker",
+    "council-member": "council-member"
   };
   REVERSE_DISPLAY_NAMES = Object.fromEntries(Object.entries(AGENT_DISPLAY_NAMES).map(([key, displayName]) => [displayName.toLowerCase(), key]));
 });
@@ -48310,6 +48368,12 @@ var SESSION_TIMEOUT_MS;
 var init_constants2 = __esm(() => {
   SESSION_TIMEOUT_MS = 10 * 60 * 1000;
 });
+// src/shared/tmux/tmux-utils/server-health.ts
+var SERVER_RUNNING_KEY;
+var init_server_health = __esm(() => {
+  SERVER_RUNNING_KEY = Symbol.for("evil-omo:server-running-in-process");
+});
+
 // src/tools/interactive-bash/tmux-path-resolver.ts
 var init_tmux_path_resolver = () => {};
 
@@ -48321,6 +48385,7 @@ var init_pane_dimensions = __esm(() => {
 // src/shared/tmux/tmux-utils/pane-spawn.ts
 var init_pane_spawn = __esm(() => {
   init_tmux_path_resolver();
+  init_server_health();
 });
 
 // src/shared/tmux/tmux-utils/pane-close.ts
@@ -48333,6 +48398,18 @@ var init_pane_replace = __esm(() => {
   init_tmux_path_resolver();
 });
 
+// src/shared/tmux/tmux-utils/window-spawn.ts
+var init_window_spawn = __esm(() => {
+  init_tmux_path_resolver();
+  init_server_health();
+});
+
+// src/shared/tmux/tmux-utils/session-spawn.ts
+var init_session_spawn = __esm(() => {
+  init_tmux_path_resolver();
+  init_server_health();
+});
+
 // src/shared/tmux/tmux-utils/layout.ts
 var init_layout = __esm(() => {
   init_tmux_path_resolver();
@@ -48340,10 +48417,13 @@ var init_layout = __esm(() => {
 
 // src/shared/tmux/tmux-utils.ts
 var init_tmux_utils = __esm(() => {
+  init_server_health();
   init_pane_dimensions();
   init_pane_spawn();
   init_pane_close();
   init_pane_replace();
+  init_window_spawn();
+  init_session_spawn();
   init_layout();
 });
 
@@ -48475,10 +48555,32 @@ var init_agent_loader = __esm(() => {
   init_logger();
   init_claude_model_mapper();
 });
+
+// src/features/claude-code-mcp-loader/configure-allowed-env-vars.ts
+var additionalAllowedMcpEnvVars;
+var init_configure_allowed_env_vars = __esm(() => {
+  additionalAllowedMcpEnvVars = new Set;
+});
+
+// src/features/claude-code-mcp-loader/env-expander.ts
+var init_env_expander = __esm(() => {
+  init_logger();
+  init_configure_allowed_env_vars();
+});
+
+// src/features/claude-code-mcp-loader/scope-filter.ts
+var init_scope_filter = __esm(() => {
+  init_contains_path();
+});
+
 // src/features/claude-code-mcp-loader/transformer.ts
-var init_transformer = () => {};
+var init_transformer = __esm(() => {
+  init_env_expander();
+});
 // src/features/claude-code-plugin-loader/mcp-server-loader.ts
 var init_mcp_server_loader = __esm(() => {
+  init_env_expander();
+  init_scope_filter();
   init_transformer();
   init_logger();
 });
@@ -48534,13 +48636,28 @@ var init_legacy_plugin_warning = __esm(() => {
   init_plugin_identity();
 });
 
+// src/shared/plugin-entry-migrator.ts
+var init_plugin_entry_migrator = __esm(() => {
+  init_plugin_identity();
+});
+
+// src/shared/migrate-legacy-plugin-entry.ts
+var init_migrate_legacy_plugin_entry = __esm(() => {
+  init_main();
+  init_jsonc_parser();
+  init_logger();
+  init_plugin_identity();
+  init_plugin_entry_migrator();
+});
+
 // src/shared/log-legacy-plugin-startup-warning.ts
 var init_log_legacy_plugin_startup_warning = __esm(() => {
   init_legacy_plugin_warning();
   init_logger();
+  init_migrate_legacy_plugin_entry();
+  init_plugin_entry_migrator();
   init_plugin_identity();
 });
-
 // src/shared/index.ts
 var init_shared = __esm(() => {
   init_model_resolver();
@@ -48548,6 +48665,7 @@ var init_shared = __esm(() => {
   init_session_category_registry();
   init_frontmatter();
   init_command_executor();
+  init_contains_path();
   init_file_reference_resolver();
   init_logger();
   init_snake_case();
@@ -48567,6 +48685,7 @@ var init_shared = __esm(() => {
   init_external_plugin_detector();
   init_zip_extractor();
   init_binary_downloader();
+  init_write_file_atomically();
   init_agent_variant();
   init_session_cursor();
   init_system_directive();
@@ -48678,11 +48797,11 @@ var init_plugin_name_with_version = __esm(() => {
 });
 
 // src/cli/config-manager/ensure-config-directory-exists.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
 function ensureConfigDirectoryExists() {
   const configDir = getConfigDir();
-  if (!existsSync6(configDir)) {
-    mkdirSync3(configDir, { recursive: true });
+  if (!existsSync5(configDir)) {
+    mkdirSync2(configDir, { recursive: true });
   }
 }
 var init_ensure_config_directory_exists = __esm(() => {
@@ -48719,14 +48838,14 @@ function formatErrorWithSuggestion(err, context) {
 }
 
 // src/cli/config-manager/opencode-config-format.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 function detectConfigFormat() {
   const configJsonc = getConfigJsonc();
   const configJson = getConfigJson();
-  if (existsSync7(configJsonc)) {
+  if (existsSync6(configJsonc)) {
     return { format: "jsonc", path: configJsonc };
   }
-  if (existsSync7(configJson)) {
+  if (existsSync6(configJson)) {
     return { format: "json", path: configJson };
   }
   return { format: "none", path: configJson };
@@ -48736,7 +48855,7 @@ var init_opencode_config_format = __esm(() => {
 });
 
 // src/cli/config-manager/parse-opencode-config-file.ts
-import { readFileSync as readFileSync5, statSync } from "fs";
+import { readFileSync as readFileSync4, statSync } from "fs";
 function isEmptyOrWhitespace(content) {
   return content.trim().length === 0;
 }
@@ -48746,7 +48865,7 @@ function parseOpenCodeConfigFileWithError(path3) {
     if (stat.size === 0) {
       return { config: null, error: `Config file is empty: ${path3}. Delete it or add valid JSON content.` };
     }
-    const content = readFileSync5(path3, "utf-8");
+    const content = readFileSync4(path3, "utf-8");
     if (isEmptyOrWhitespace(content)) {
       return { config: null, error: `Config file contains only whitespace: ${path3}. Delete it or add valid JSON content.` };
     }
@@ -48770,7 +48889,7 @@ var init_parse_opencode_config_file = __esm(() => {
 });
 
 // src/cli/config-manager/add-plugin-to-opencode-config.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
 async function addPluginToOpenCodeConfig(currentVersion) {
   try {
     ensureConfigDirectoryExists();
@@ -48786,7 +48905,7 @@ async function addPluginToOpenCodeConfig(currentVersion) {
   try {
     if (format2 === "none") {
       const config2 = { plugin: [pluginEntry] };
-      writeFileSync4(path3, JSON.stringify(config2, null, 2) + `
+      writeFileSync3(path3, JSON.stringify(config2, null, 2) + `
 `);
       return { success: true, configPath: path3 };
     }
@@ -48811,7 +48930,7 @@ async function addPluginToOpenCodeConfig(currentVersion) {
     }
     config.plugin = plugins;
     if (format2 === "jsonc") {
-      const content = readFileSync6(path3, "utf-8");
+      const content = readFileSync5(path3, "utf-8");
       const pluginArrayRegex = /"plugin"\s*:\s*\[([\s\S]*?)\]/;
       const match = content.match(pluginArrayRegex);
       if (match) {
@@ -48820,14 +48939,14 @@ async function addPluginToOpenCodeConfig(currentVersion) {
         const newContent = content.replace(pluginArrayRegex, `"plugin": [
     ${formattedPlugins}
   ]`);
-        writeFileSync4(path3, newContent);
+        writeFileSync3(path3, newContent);
       } else {
         const newContent = content.replace(/(\{)/, `$1
   "plugin": ["${pluginEntry}"],`);
-        writeFileSync4(path3, newContent);
+        writeFileSync3(path3, newContent);
       }
     } else {
-      writeFileSync4(path3, JSON.stringify(config, null, 2) + `
+      writeFileSync3(path3, JSON.stringify(config, null, 2) + `
 `);
     }
     return { success: true, configPath: path3 };
@@ -49077,7 +49196,7 @@ function deepMergeRecord(target, source) {
 }
 
 // src/cli/config-manager/write-omo-config.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7, statSync as statSync2, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6, statSync as statSync2, writeFileSync as writeFileSync4 } from "fs";
 function isEmptyOrWhitespace2(content) {
   return content.trim().length === 0;
 }
@@ -49095,35 +49214,35 @@ function writeOmoConfig(installConfig) {
   const existingConfigPath = getExistingOmoConfigPath() ?? omoConfigPath;
   try {
     const newConfig = generateOmoConfig(installConfig);
-    if (existsSync8(existingConfigPath)) {
+    if (existsSync7(existingConfigPath)) {
       try {
         const stat = statSync2(existingConfigPath);
-        const content = readFileSync7(existingConfigPath, "utf-8");
+        const content = readFileSync6(existingConfigPath, "utf-8");
         if (stat.size === 0 || isEmptyOrWhitespace2(content)) {
-          writeFileSync5(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
+          writeFileSync4(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
 `);
           return { success: true, configPath: omoConfigPath };
         }
         const existing = parseJsonc(content);
         if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
-          writeFileSync5(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
+          writeFileSync4(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
 `);
           return { success: true, configPath: omoConfigPath };
         }
         const merged = deepMergeRecord(newConfig, existing);
         merged.$schema = newConfig.$schema;
-        writeFileSync5(omoConfigPath, JSON.stringify(merged, null, 2) + `
+        writeFileSync4(omoConfigPath, JSON.stringify(merged, null, 2) + `
 `);
       } catch (parseErr) {
         if (parseErr instanceof SyntaxError) {
-          writeFileSync5(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
+          writeFileSync4(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
 `);
           return { success: true, configPath: omoConfigPath };
         }
         throw parseErr;
       }
     } else {
-      writeFileSync5(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
+      writeFileSync4(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
 `);
     }
     return { success: true, configPath: omoConfigPath };
@@ -49239,10 +49358,10 @@ var init_opencode_binary = __esm(() => {
 });
 
 // src/cli/config-manager/detect-current-config.ts
-import { existsSync as existsSync9, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
 function detectProvidersFromOmoConfig() {
   const omoConfigPath = getExistingOmoConfigPath();
-  if (!omoConfigPath || !existsSync9(omoConfigPath)) {
+  if (!omoConfigPath || !existsSync8(omoConfigPath)) {
     return {
       hasOpenAI: true,
       hasOpencodeZen: true,
@@ -49252,7 +49371,7 @@ function detectProvidersFromOmoConfig() {
     };
   }
   try {
-    const content = readFileSync8(omoConfigPath, "utf-8");
+    const content = readFileSync7(omoConfigPath, "utf-8");
     const omoConfig = parseJsonc(content);
     if (!omoConfig || typeof omoConfig !== "object") {
       return {
@@ -49326,7 +49445,11 @@ var init_detect_current_config = __esm(() => {
 });
 
 // src/cli/config-manager/bun-install.ts
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync9 } from "fs";
+import { join as join8 } from "path";
+function getDefaultWorkspaceDir() {
+  return join8(getOpenCodeCacheDir(), "packages");
+}
 function readProcessOutput(stream) {
   if (!stream) {
     return Promise.resolve("");
@@ -49349,9 +49472,9 @@ function logCapturedOutputOnFailure(outputMode, output) {
 }
 async function runBunInstallWithDetails(options) {
   const outputMode = options?.outputMode ?? "pipe";
-  const cacheDir = options?.workspaceDir ?? getOpenCodeCacheDir();
+  const cacheDir = options?.workspaceDir ?? getDefaultWorkspaceDir();
   const packageJsonPath = `${cacheDir}/package.json`;
-  if (!existsSync10(packageJsonPath)) {
+  if (!existsSync9(packageJsonPath)) {
     return {
       success: false,
       error: `Workspace not initialized: ${packageJsonPath} not found. OpenCode should create this on first run.`
@@ -49495,15 +49618,16 @@ function getWindowsAppdataDir() {
     return null;
   return process.env.APPDATA ?? path4.join(os3.homedir(), "AppData", "Roaming");
 }
-var PACKAGE_NAME2, NPM_REGISTRY_URL, NPM_FETCH_TIMEOUT = 5000, CACHE_DIR, VERSION_FILE, USER_CONFIG_DIR, USER_OPENCODE_CONFIG, USER_OPENCODE_CONFIG_JSONC, INSTALLED_PACKAGE_JSON;
+var PACKAGE_NAME2, NPM_REGISTRY_URL, NPM_FETCH_TIMEOUT = 5000, CACHE_ROOT_DIR, CACHE_DIR, VERSION_FILE, USER_CONFIG_DIR, USER_OPENCODE_CONFIG, USER_OPENCODE_CONFIG_JSONC, INSTALLED_PACKAGE_JSON;
 var init_constants3 = __esm(() => {
   init_data_path();
   init_opencode_config_dir();
   init_plugin_identity();
   PACKAGE_NAME2 = PLUGIN_NAME;
   NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME2}/dist-tags`;
-  CACHE_DIR = getOpenCodeCacheDir();
-  VERSION_FILE = path4.join(CACHE_DIR, "version");
+  CACHE_ROOT_DIR = getOpenCodeCacheDir();
+  CACHE_DIR = path4.join(CACHE_ROOT_DIR, "packages");
+  VERSION_FILE = path4.join(CACHE_ROOT_DIR, "version");
   USER_CONFIG_DIR = getOpenCodeConfigDir({ binary: "opencode" });
   USER_OPENCODE_CONFIG = path4.join(USER_CONFIG_DIR, "opencode.json");
   USER_OPENCODE_CONFIG_JSONC = path4.join(USER_CONFIG_DIR, "opencode.jsonc");
@@ -49850,11 +49974,28 @@ function getIntentVersion(pluginInfo) {
   }
   return pluginInfo.pinnedVersion;
 }
+function writeCachePackageJson(cachePackageJsonPath, pkgJson) {
+  const tmpPath = `${cachePackageJsonPath}.${crypto.randomUUID()}`;
+  try {
+    fs9.mkdirSync(path8.dirname(cachePackageJsonPath), { recursive: true });
+    fs9.writeFileSync(tmpPath, JSON.stringify(pkgJson, null, 2));
+    fs9.renameSync(tmpPath, cachePackageJsonPath);
+    return { synced: true, error: null };
+  } catch (err) {
+    log("[auto-update-checker] Failed to write cache package.json:", err);
+    safeUnlink(tmpPath);
+    return { synced: false, error: "write_error", message: "Failed to write cache package.json" };
+  }
+}
 function syncCachePackageJsonToIntent(pluginInfo) {
   const cachePackageJsonPath = path8.join(CACHE_DIR, "package.json");
+  const intentVersion = getIntentVersion(pluginInfo);
   if (!fs9.existsSync(cachePackageJsonPath)) {
-    log("[auto-update-checker] Cache package.json not found, nothing to sync");
-    return { synced: false, error: "file_not_found", message: "Cache package.json not found" };
+    log("[auto-update-checker] Cache package.json missing, creating workspace package.json", { intentVersion });
+    return {
+      ...writeCachePackageJson(cachePackageJsonPath, { dependencies: { [PACKAGE_NAME2]: intentVersion } }),
+      message: `Created cache package.json with: ${intentVersion}`
+    };
   }
   let content;
   let pkgJson;
@@ -49871,11 +50012,20 @@ function syncCachePackageJsonToIntent(pluginInfo) {
     return { synced: false, error: "parse_error", message: "Failed to parse cache package.json (malformed JSON)" };
   }
   if (!pkgJson || !pkgJson.dependencies?.[PACKAGE_NAME2]) {
-    log("[auto-update-checker] Plugin not in cache package.json dependencies, nothing to sync");
-    return { synced: false, error: "plugin_not_in_deps", message: "Plugin not in cache package.json dependencies" };
+    log("[auto-update-checker] Plugin missing from cache package.json dependencies, adding dependency", { intentVersion });
+    const nextPkgJson = {
+      ...pkgJson ?? {},
+      dependencies: {
+        ...pkgJson?.dependencies ?? {},
+        [PACKAGE_NAME2]: intentVersion
+      }
+    };
+    return {
+      ...writeCachePackageJson(cachePackageJsonPath, nextPkgJson),
+      message: `Added ${PACKAGE_NAME2}: ${intentVersion}`
+    };
   }
   const currentVersion = pkgJson.dependencies[PACKAGE_NAME2];
-  const intentVersion = getIntentVersion(pluginInfo);
   if (currentVersion === intentVersion) {
     log("[auto-update-checker] Cache package.json already matches intent:", intentVersion);
     return { synced: false, error: null, message: `Already matches intent: ${intentVersion}` };
@@ -49888,16 +50038,10 @@ function syncCachePackageJsonToIntent(pluginInfo) {
     log(`[auto-update-checker] Updating cache package.json: "${currentVersion}" \u2192 "${intentVersion}"`);
   }
   pkgJson.dependencies[PACKAGE_NAME2] = intentVersion;
-  const tmpPath = `${cachePackageJsonPath}.${crypto.randomUUID()}`;
-  try {
-    fs9.writeFileSync(tmpPath, JSON.stringify(pkgJson, null, 2));
-    fs9.renameSync(tmpPath, cachePackageJsonPath);
-    return { synced: true, error: null, message: `Updated: "${currentVersion}" \u2192 "${intentVersion}"` };
-  } catch (err) {
-    log("[auto-update-checker] Failed to write cache package.json:", err);
-    safeUnlink(tmpPath);
-    return { synced: false, error: "write_error", message: "Failed to write cache package.json" };
-  }
+  return {
+    ...writeCachePackageJson(cachePackageJsonPath, pkgJson),
+    message: `Updated: "${currentVersion}" \u2192 "${intentVersion}"`
+  };
 }
 var EXACT_SEMVER_REGEX2;
 var init_sync_package_json = __esm(() => {
@@ -50023,90 +50167,116 @@ var init_update_toasts = __esm(() => {
 });
 
 // src/hooks/auto-update-checker/hook/background-update-check.ts
-import { existsSync as existsSync21 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 import { join as join19 } from "path";
+function getCacheWorkspaceDir(deps) {
+  return deps.join(deps.getOpenCodeCacheDir(), "packages");
+}
 function getPinnedVersionToastMessage(latestVersion) {
   return `Update available: ${latestVersion} (version pinned, update manually)`;
 }
-function resolveActiveInstallWorkspace() {
-  const configPaths = getOpenCodeConfigPaths({ binary: "opencode" });
-  const cacheDir = getOpenCodeCacheDir();
-  const configInstallPath = join19(configPaths.configDir, "node_modules", PACKAGE_NAME2, "package.json");
-  const cacheInstallPath = join19(cacheDir, "node_modules", PACKAGE_NAME2, "package.json");
-  if (existsSync21(configInstallPath)) {
-    log(`[auto-update-checker] Active workspace: config-dir (${configPaths.configDir})`);
+function resolveActiveInstallWorkspace(deps) {
+  const configPaths = deps.getOpenCodeConfigPaths({ binary: "opencode" });
+  const cacheDir = getCacheWorkspaceDir(deps);
+  const configInstallPath = deps.join(configPaths.configDir, "node_modules", PACKAGE_NAME2, "package.json");
+  const cacheInstallPath = deps.join(cacheDir, "node_modules", PACKAGE_NAME2, "package.json");
+  if (deps.existsSync(configInstallPath)) {
+    deps.log(`[auto-update-checker] Active workspace: config-dir (${configPaths.configDir})`);
     return configPaths.configDir;
   }
-  if (existsSync21(cacheInstallPath)) {
-    log(`[auto-update-checker] Active workspace: cache-dir (${cacheDir})`);
+  if (deps.existsSync(cacheInstallPath)) {
+    deps.log(`[auto-update-checker] Active workspace: cache-dir (${cacheDir})`);
     return cacheDir;
   }
-  log(`[auto-update-checker] Active workspace: config-dir (default, no install detected)`);
+  const cachePackageJsonPath = deps.join(cacheDir, "package.json");
+  if (deps.existsSync(cachePackageJsonPath)) {
+    deps.log(`[auto-update-checker] Active workspace: cache-dir (${cacheDir}, package.json present)`);
+    return cacheDir;
+  }
+  deps.log(`[auto-update-checker] Active workspace: config-dir (default, no install detected)`);
   return configPaths.configDir;
 }
-async function runBunInstallSafe(workspaceDir) {
+async function runBunInstallSafe(workspaceDir, deps) {
   try {
-    const result = await runBunInstallWithDetails({ outputMode: "pipe", workspaceDir });
+    const result = await deps.runBunInstallWithDetails({ outputMode: "pipe", workspaceDir });
     if (!result.success && result.error) {
-      log("[auto-update-checker] bun install error:", result.error);
+      deps.log("[auto-update-checker] bun install error:", result.error);
     }
     return result.success;
   } catch (err) {
     const errorMessage = err instanceof Error ? err.message : String(err);
-    log("[auto-update-checker] bun install error:", errorMessage);
+    deps.log("[auto-update-checker] bun install error:", errorMessage);
     return false;
   }
 }
-async function runBackgroundUpdateCheck(ctx, autoUpdate, getToastMessage) {
-  const pluginInfo = findPluginEntry(ctx.directory);
-  if (!pluginInfo) {
-    log("[auto-update-checker] Plugin not found in config");
-    return;
-  }
-  const cachedVersion = getCachedVersion();
-  const currentVersion = cachedVersion ?? pluginInfo.pinnedVersion;
-  if (!currentVersion) {
-    log("[auto-update-checker] No version found (cached or pinned)");
-    return;
-  }
-  const channel = extractChannel(pluginInfo.pinnedVersion ?? currentVersion);
-  const latestVersion = await getLatestVersion(channel);
-  if (!latestVersion) {
-    log("[auto-update-checker] Failed to fetch latest version for channel:", channel);
-    return;
-  }
-  if (currentVersion === latestVersion) {
-    log("[auto-update-checker] Already on latest version for channel:", channel);
-    return;
-  }
-  log(`[auto-update-checker] Update available (${channel}): ${currentVersion} \u2192 ${latestVersion}`);
-  if (!autoUpdate) {
-    await showUpdateAvailableToast(ctx, latestVersion, getToastMessage);
-    log("[auto-update-checker] Auto-update disabled, notification only");
-    return;
-  }
-  if (pluginInfo.isPinned) {
-    await showUpdateAvailableToast(ctx, latestVersion, () => getPinnedVersionToastMessage(latestVersion));
-    log(`[auto-update-checker] User-pinned version detected (${pluginInfo.entry}), skipping auto-update. Notification only.`);
-    return;
-  }
-  const syncResult = syncCachePackageJsonToIntent(pluginInfo);
-  if (syncResult.error) {
-    log(`[auto-update-checker] Sync failed with error: ${syncResult.error}`, syncResult.message);
-    await showUpdateAvailableToast(ctx, latestVersion, getToastMessage);
-    return;
-  }
-  invalidatePackage(PACKAGE_NAME2);
-  const activeWorkspace = resolveActiveInstallWorkspace();
-  const installSuccess = await runBunInstallSafe(activeWorkspace);
-  if (installSuccess) {
-    await showAutoUpdatedToast(ctx, currentVersion, latestVersion);
-    log(`[auto-update-checker] Update installed: ${currentVersion} \u2192 ${latestVersion}`);
-    return;
+async function primeCacheWorkspace(activeWorkspace, deps) {
+  const cacheWorkspace = getCacheWorkspaceDir(deps);
+  if (activeWorkspace === cacheWorkspace) {
+    return true;
   }
-  await showUpdateAvailableToast(ctx, latestVersion, getToastMessage);
-  log("[auto-update-checker] bun install failed; update not installed (falling back to notification-only)");
+  deps.log(`[auto-update-checker] Priming cache workspace after install: ${cacheWorkspace}`);
+  return runBunInstallSafe(cacheWorkspace, deps);
+}
+function createBackgroundUpdateCheckRunner(overrides = {}) {
+  const deps = { ...defaultDeps, ...overrides };
+  return async function runBackgroundUpdateCheck(ctx, autoUpdate, getToastMessage) {
+    const pluginInfo = deps.findPluginEntry(ctx.directory);
+    if (!pluginInfo) {
+      deps.log("[auto-update-checker] Plugin not found in config");
+      return;
+    }
+    const cachedVersion = deps.getCachedVersion();
+    const currentVersion = cachedVersion ?? pluginInfo.pinnedVersion;
+    if (!currentVersion) {
+      deps.log("[auto-update-checker] No version found (cached or pinned)");
+      return;
+    }
+    const channel = deps.extractChannel(pluginInfo.pinnedVersion ?? currentVersion);
+    const latestVersion = await deps.getLatestVersion(channel);
+    if (!latestVersion) {
+      deps.log("[auto-update-checker] Failed to fetch latest version for channel:", channel);
+      return;
+    }
+    if (currentVersion === latestVersion) {
+      deps.log("[auto-update-checker] Already on latest version for channel:", channel);
+      return;
+    }
+    deps.log(`[auto-update-checker] Update available (${channel}): ${currentVersion} \u2192 ${latestVersion}`);
+    if (!autoUpdate) {
+      await deps.showUpdateAvailableToast(ctx, latestVersion, getToastMessage);
+      deps.log("[auto-update-checker] Auto-update disabled, notification only");
+      return;
+    }
+    if (pluginInfo.isPinned) {
+      await deps.showUpdateAvailableToast(ctx, latestVersion, () => getPinnedVersionToastMessage(latestVersion));
+      deps.log(`[auto-update-checker] User-pinned version detected (${pluginInfo.entry}), skipping auto-update. Notification only.`);
+      return;
+    }
+    const syncResult = deps.syncCachePackageJsonToIntent(pluginInfo);
+    if (syncResult.error) {
+      deps.log(`[auto-update-checker] Sync failed with error: ${syncResult.error}`, syncResult.message);
+      await deps.showUpdateAvailableToast(ctx, latestVersion, getToastMessage);
+      return;
+    }
+    deps.invalidatePackage(PACKAGE_NAME2);
+    const activeWorkspace = resolveActiveInstallWorkspace(deps);
+    const installSuccess = await runBunInstallSafe(activeWorkspace, deps);
+    if (installSuccess) {
+      const cachePrimed = await primeCacheWorkspace(activeWorkspace, deps);
+      if (!cachePrimed) {
+        await deps.showUpdateAvailableToast(ctx, latestVersion, getToastMessage);
+        deps.log("[auto-update-checker] cache workspace priming failed after install");
+        return;
+      }
+      await deps.showAutoUpdatedToast(ctx, currentVersion, latestVersion);
+      deps.log(`[auto-update-checker] Update installed: ${currentVersion} \u2192 ${latestVersion}`);
+      return;
+    }
+    await deps.showUpdateAvailableToast(ctx, latestVersion, getToastMessage);
+    deps.log("[auto-update-checker] bun install failed; update not installed (falling back to notification-only)");
+  };
 }
+var defaultDeps, runBackgroundUpdateCheck;
 var init_background_update_check = __esm(() => {
   init_config_manager();
   init_logger();
@@ -50115,6 +50285,23 @@ var init_background_update_check = __esm(() => {
   init_constants3();
   init_checker();
   init_update_toasts();
+  defaultDeps = {
+    existsSync: existsSync20,
+    join: join19,
+    runBunInstallWithDetails,
+    log,
+    getOpenCodeCacheDir,
+    getOpenCodeConfigPaths,
+    invalidatePackage,
+    extractChannel,
+    findPluginEntry,
+    getCachedVersion,
+    getLatestVersion,
+    syncCachePackageJsonToIntent,
+    showUpdateAvailableToast,
+    showAutoUpdatedToast
+  };
+  runBackgroundUpdateCheck = createBackgroundUpdateCheckRunner();
 });
 
 // src/hooks/auto-update-checker/hook/config-errors-toast.ts
@@ -50380,9 +50567,9 @@ var {
 // package.json
 var package_default = {
   name: "evil-omo",
-  version: "3.14.1",
+  version: "3.15.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",
+  main: "./dist/index.js",
   types: "dist/index.d.ts",
   type: "module",
   bin: {
@@ -50454,21 +50641,21 @@ var package_default = {
   devDependencies: {
     "@types/js-yaml": "^4.0.9",
     "@types/picomatch": "^3.0.2",
-    "bun-types": "1.3.10",
+    "bun-types": "1.3.11",
     typescript: "^5.7.3"
   },
   optionalDependencies: {
-    "evil-omo-darwin-arm64": "3.14.1",
-    "evil-omo-darwin-x64": "3.14.1",
-    "evil-omo-darwin-x64-baseline": "3.14.1",
-    "evil-omo-linux-x64": "3.14.1",
-    "evil-omo-linux-x64-baseline": "3.14.1",
-    "evil-omo-linux-arm64": "3.14.1",
-    "evil-omo-linux-x64-musl": "3.14.1",
-    "evil-omo-linux-x64-musl-baseline": "3.14.1",
-    "evil-omo-linux-arm64-musl": "3.14.1",
-    "evil-omo-windows-x64": "3.14.1",
-    "evil-omo-windows-x64-baseline": "3.14.1"
+    "evil-omo-darwin-arm64": "3.15.2",
+    "evil-omo-darwin-x64": "3.15.2",
+    "evil-omo-darwin-x64-baseline": "3.15.2",
+    "evil-omo-linux-x64": "3.15.2",
+    "evil-omo-linux-x64-baseline": "3.15.2",
+    "evil-omo-linux-arm64": "3.15.2",
+    "evil-omo-linux-x64-musl": "3.15.2",
+    "evil-omo-linux-x64-musl-baseline": "3.15.2",
+    "evil-omo-linux-arm64-musl": "3.15.2",
+    "evil-omo-windows-x64": "3.15.2",
+    "evil-omo-windows-x64-baseline": "3.15.2"
   },
   overrides: {
     "@opencode-ai/sdk": "^1.2.24"
@@ -65753,7 +65940,9 @@ var BuiltinSkillNameSchema = exports_external.enum([
   "agent-browser",
   "dev-browser",
   "frontend-ui-ux",
-  "git-master"
+  "git-master",
+  "review-work",
+  "ai-slop-remover"
 ]);
 var OverridableAgentNameSchema = exports_external.enum([
   "build",
@@ -65784,9 +65973,14 @@ var FallbackModelObjectSchema = exports_external.object({
     budgetTokens: exports_external.number().optional()
   }).optional()
 });
+var FallbackModelStringArraySchema = exports_external.array(exports_external.string());
+var FallbackModelObjectArraySchema = exports_external.array(FallbackModelObjectSchema);
+var FallbackModelMixedArraySchema = exports_external.array(exports_external.union([exports_external.string(), FallbackModelObjectSchema]));
 var FallbackModelsSchema = exports_external.union([
   exports_external.string(),
-  exports_external.array(exports_external.union([exports_external.string(), FallbackModelObjectSchema]))
+  FallbackModelStringArraySchema,
+  FallbackModelObjectArraySchema,
+  FallbackModelMixedArraySchema
 ]);
 
 // src/config/schema/internal/permission.ts
@@ -65874,6 +66068,8 @@ 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(),
+  taskTtlMs: exports_external.number().min(300000).optional(),
+  sessionGoneTimeoutMs: exports_external.number().min(1e4).optional(),
   syncPollTimeoutMs: exports_external.number().min(60000).optional(),
   maxToolCalls: exports_external.number().int().min(10).optional(),
   circuitBreaker: CircuitBreakerConfigSchema.optional()
@@ -65942,7 +66138,8 @@ var BuiltinCommandNameSchema = exports_external.enum([
   "cancel-ralph",
   "refactor",
   "start-work",
-  "stop-continuation"
+  "stop-continuation",
+  "remove-ai-slops"
 ]);
 // src/config/schema/dynamic-context-pruning.ts
 var DynamicContextPruningConfigSchema = exports_external.object({
@@ -65987,7 +66184,8 @@ var ExperimentalConfigSchema = exports_external.object({
   safe_hook_creation: exports_external.boolean().optional(),
   disable_omo_env: exports_external.boolean().optional(),
   hashline_edit: exports_external.boolean().optional(),
-  model_fallback_title: exports_external.boolean().optional()
+  model_fallback_title: exports_external.boolean().optional(),
+  max_tools: exports_external.number().int().min(1).optional()
 });
 // src/config/schema/git-env-prefix.ts
 var GIT_ENV_ASSIGNMENT_PATTERN = /^(?:[A-Za-z_][A-Za-z0-9_]*=[A-Za-z0-9_-]*)(?: [A-Za-z_][A-Za-z0-9_]*=[A-Za-z0-9_-]*)*$/;
@@ -66030,6 +66228,7 @@ var HookNameSchema = exports_external.enum([
   "non-interactive-env",
   "interactive-bash-session",
   "thinking-block-validator",
+  "tool-pair-validator",
   "ralph-loop",
   "category-skill-reminder",
   "compaction-context-injector",
@@ -66051,11 +66250,13 @@ var HookNameSchema = exports_external.enum([
   "tasks-todowrite-disabler",
   "runtime-fallback",
   "write-existing-file-guard",
+  "bash-file-read-guard",
   "anthropic-effort",
   "hashline-read-enhancer",
   "read-image-resizer",
   "todo-description-override",
-  "webfetch-redirect-guard"
+  "webfetch-redirect-guard",
+  "legacy-plugin-toast"
 ]);
 // src/config/schema/model-capabilities.ts
 var ModelCapabilitiesConfigSchema = exports_external.object({
@@ -66166,7 +66367,8 @@ var SisyphusAgentConfigSchema = exports_external.object({
   disabled: exports_external.boolean().optional(),
   default_builder_enabled: exports_external.boolean().optional(),
   planner_enabled: exports_external.boolean().optional(),
-  replace_plan: exports_external.boolean().optional()
+  replace_plan: exports_external.boolean().optional(),
+  tdd: exports_external.boolean().default(true).optional()
 });
 
 // src/config/schema/start-work.ts
@@ -66182,12 +66384,18 @@ var TmuxLayoutSchema = exports_external.enum([
   "even-horizontal",
   "even-vertical"
 ]);
+var TmuxIsolationSchema = exports_external.enum([
+  "inline",
+  "window",
+  "session"
+]);
 var TmuxConfigSchema = exports_external.object({
   enabled: exports_external.boolean().default(false),
   layout: TmuxLayoutSchema.default("main-vertical"),
   main_pane_size: exports_external.number().min(20).max(80).default(60),
   main_pane_min_width: exports_external.number().min(40).default(120),
-  agent_pane_min_width: exports_external.number().min(20).default(40)
+  agent_pane_min_width: exports_external.number().min(20).default(40),
+  isolation: TmuxIsolationSchema.default("inline")
 });
 
 // src/config/schema/websearch.ts
@@ -66212,6 +66420,7 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
   disabled_hooks: StringListSchema.optional(),
   disabled_commands: exports_external.array(BuiltinCommandNameSchema).optional(),
   disabled_tools: StringListSchema.optional(),
+  mcp_env_allowlist: exports_external.array(exports_external.string()).optional(),
   hashline_edit: exports_external.boolean().optional(),
   model_fallback: exports_external.boolean().optional(),
   agents: AgentOverridesSchema.optional(),
@@ -66245,7 +66454,8 @@ var PARTIAL_STRING_ARRAY_KEYS = new Set([
   "disabled_skills",
   "disabled_hooks",
   "disabled_commands",
-  "disabled_tools"
+  "disabled_tools",
+  "mcp_env_allowlist"
 ]);
 function parseConfigPartially(rawConfig) {
   const fullResult = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
@@ -66353,6 +66563,12 @@ function mergeConfigs(base, override) {
         ...override.disabled_tools ?? []
       ])
     ],
+    mcp_env_allowlist: [
+      ...new Set([
+        ...base.mcp_env_allowlist ?? [],
+        ...override.mcp_env_allowlist ?? []
+      ])
+    ],
     claude_code: deepMerge(base.claude_code, override.claude_code)
   };
 }
@@ -68080,6 +68296,22 @@ async function readOutput(stream, streamName) {
     return "";
   }
 }
+function resolveHookShellCommand(command) {
+  const shellType = detectShellType();
+  switch (shellType) {
+    case "powershell": {
+      const powershellExecutable = process.platform === "win32" ? "powershell.exe" : "pwsh";
+      return [powershellExecutable, "-NoProfile", "-Command", command];
+    }
+    case "cmd":
+      return [process.env.ComSpec || "cmd.exe", "/d", "/s", "/c", command];
+    case "csh":
+      return ["csh", "-c", command];
+    case "unix":
+    default:
+      return ["sh", "-c", command];
+  }
+}
 async function executeOnCompleteHook(options) {
   const { command, sessionId, exitCode, durationMs, messageCount } = options;
   const trimmedCommand = command.trim();
@@ -68088,7 +68320,8 @@ async function executeOnCompleteHook(options) {
   }
   log("Running on-complete hook", { command: trimmedCommand });
   try {
-    const proc = spawnWithWindowsHide(["sh", "-c", trimmedCommand], {
+    const shellCommand = resolveHookShellCommand(trimmedCommand);
+    const proc = spawnWithWindowsHide(shellCommand, {
       env: {
         ...process.env,
         SESSION_ID: sessionId,
@@ -68217,7 +68450,7 @@ 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 existsSync12, readFileSync as readFileSync10, writeFileSync as writeFileSync6, mkdirSync as mkdirSync4, readdirSync } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync5, mkdirSync as mkdirSync3, readdirSync } from "fs";
 import { dirname as dirname2, join as join11, basename } from "path";
 var RESERVED_KEYS = new Set(["__proto__", "prototype", "constructor"]);
 function getBoulderFilePath(directory) {
@@ -68225,11 +68458,11 @@ function getBoulderFilePath(directory) {
 }
 function readBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
-  if (!existsSync12(filePath)) {
+  if (!existsSync11(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync10(filePath, "utf-8");
+    const content = readFileSync9(filePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       return null;
@@ -68246,11 +68479,11 @@ function readBoulderState(directory) {
   }
 }
 function getPlanProgress(planPath) {
-  if (!existsSync12(planPath)) {
+  if (!existsSync11(planPath)) {
     return { total: 0, completed: 0, isComplete: true };
   }
   try {
-    const content = readFileSync10(planPath, "utf-8");
+    const content = readFileSync9(planPath, "utf-8");
     const uncheckedMatches = content.match(/^\s*[-*]\s*\[\s*\]/gm) || [];
     const checkedMatches = content.match(/^\s*[-*]\s*\[[xX]\]/gm) || [];
     const total = uncheckedMatches.length + checkedMatches.length;
@@ -68267,17 +68500,17 @@ function getPlanProgress(planPath) {
 // src/features/run-continuation-state/constants.ts
 var CONTINUATION_MARKER_DIR = ".sisyphus/run-continuation";
 // src/features/run-continuation-state/storage.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync5, readFileSync as readFileSync11, rmSync, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync4, readFileSync as readFileSync10, rmSync, writeFileSync as writeFileSync6 } from "fs";
 import { join as join12 } from "path";
 function getMarkerPath(directory, sessionID) {
   return join12(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
 }
 function readContinuationMarker(directory, sessionID) {
   const markerPath = getMarkerPath(directory, sessionID);
-  if (!existsSync13(markerPath))
+  if (!existsSync12(markerPath))
     return null;
   try {
-    const raw = readFileSync11(markerPath, "utf-8");
+    const raw = readFileSync10(markerPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
       return null;
@@ -68302,7 +68535,7 @@ function getActiveContinuationMarkerReason(marker) {
 }
 // src/hooks/ralph-loop/storage.ts
 init_frontmatter();
-import { existsSync as existsSync14, readFileSync as readFileSync12, writeFileSync as writeFileSync8, unlinkSync, mkdirSync as mkdirSync6 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync11, writeFileSync as writeFileSync7, unlinkSync, mkdirSync as mkdirSync5 } from "fs";
 import { dirname as dirname3, join as join13 } from "path";
 
 // src/hooks/ralph-loop/constants.ts
@@ -68316,11 +68549,11 @@ function getStateFilePath(directory, customPath) {
 }
 function readState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
-  if (!existsSync14(filePath)) {
+  if (!existsSync13(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync12(filePath, "utf-8");
+    const content = readFileSync11(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     const active = data.active;
     const iteration = data.iteration;
@@ -69026,11 +69259,11 @@ var PACKAGE_NAME3 = PLUGIN_NAME;
 var OPENCODE_BINARIES2 = ["opencode", "opencode-desktop"];
 
 // src/cli/doctor/checks/system.ts
-import { existsSync as existsSync25, readFileSync as readFileSync22 } 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 existsSync22 } from "fs";
+import { existsSync as existsSync21 } from "fs";
 import { homedir as homedir5 } from "os";
 import { join as join20 } from "path";
 function getDesktopAppPaths(platform) {
@@ -69070,7 +69303,7 @@ function buildVersionCommand(binaryPath, platform) {
   }
   return [binaryPath, "--version"];
 }
-function findDesktopBinary(platform = process.platform, checkExists = existsSync22) {
+function findDesktopBinary(platform = process.platform, checkExists = existsSync21) {
   for (const desktopPath of getDesktopAppPaths(platform)) {
     if (checkExists(desktopPath)) {
       return { binary: "opencode", path: desktopPath };
@@ -69118,12 +69351,12 @@ function compareVersions(current, minimum) {
 
 // src/cli/doctor/checks/system-plugin.ts
 init_shared();
-import { existsSync as existsSync23, readFileSync as readFileSync20 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync19 } from "fs";
 function detectConfigPath() {
   const paths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
-  if (existsSync23(paths.configJsonc))
+  if (existsSync22(paths.configJsonc))
     return paths.configJsonc;
-  if (existsSync23(paths.configJson))
+  if (existsSync22(paths.configJson))
     return paths.configJson;
   return null;
 }
@@ -69169,7 +69402,7 @@ function getPluginInfo() {
     };
   }
   try {
-    const content = readFileSync20(configPath, "utf-8");
+    const content = readFileSync19(configPath, "utf-8");
     const parsedConfig = parseJsonc(content);
     const pluginEntry = findPluginEntry2(parsedConfig.plugin ?? []);
     if (!pluginEntry) {
@@ -69207,7 +69440,7 @@ function getPluginInfo() {
 init_file_utils();
 init_checker();
 init_auto_update_checker();
-import { existsSync as existsSync24, readFileSync as readFileSync21 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync20 } from "fs";
 import { homedir as homedir6 } from "os";
 import { join as join21 } from "path";
 init_shared();
@@ -69224,20 +69457,20 @@ function resolveOpenCodeCacheDir() {
     return join21(xdgCacheHome, "opencode");
   const fromShared = getOpenCodeCacheDir();
   const platformDefault = join21(getPlatformDefaultCacheDir(), "opencode");
-  if (existsSync24(fromShared) || !existsSync24(platformDefault))
+  if (existsSync23(fromShared) || !existsSync23(platformDefault))
     return fromShared;
   return platformDefault;
 }
 function resolveExistingDir(dirPath) {
-  if (!existsSync24(dirPath))
+  if (!existsSync23(dirPath))
     return dirPath;
   return resolveSymlink(dirPath);
 }
 function readPackageJson(filePath) {
-  if (!existsSync24(filePath))
+  if (!existsSync23(filePath))
     return null;
   try {
-    const content = readFileSync21(filePath, "utf-8");
+    const content = readFileSync20(filePath, "utf-8");
     return parseJsonc(content);
   } catch {
     return null;
@@ -69265,7 +69498,7 @@ function getLoadedPluginVersion() {
       installedPackagePath: join21(cacheDir, "node_modules", PACKAGE_NAME3, "package.json")
     }
   ];
-  const selectedCandidate = candidates.find((candidate) => existsSync24(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);
@@ -69292,10 +69525,10 @@ init_shared();
 function isConfigValid(configPath) {
   if (!configPath)
     return true;
-  if (!existsSync25(configPath))
+  if (!existsSync24(configPath))
     return false;
   try {
-    parseJsonc(readFileSync22(configPath, "utf-8"));
+    parseJsonc(readFileSync21(configPath, "utf-8"));
     return true;
   } catch {
     return false;
@@ -69398,14 +69631,14 @@ async function checkSystem() {
 }
 
 // src/cli/doctor/checks/config.ts
-import { readFileSync as readFileSync25 } from "fs";
+import { readFileSync as readFileSync24 } from "fs";
 import { join as join25 } from "path";
 init_shared();
 init_plugin_identity();
 
 // src/cli/doctor/checks/model-resolution-cache.ts
 init_shared();
-import { existsSync as existsSync26, readFileSync as readFileSync23 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync22 } from "fs";
 import { homedir as homedir7 } from "os";
 import { join as join22 } from "path";
 function getOpenCodeCacheDir2() {
@@ -69416,11 +69649,11 @@ function getOpenCodeCacheDir2() {
 }
 function loadAvailableModelsFromCache() {
   const cacheFile = join22(getOpenCodeCacheDir2(), "models.json");
-  if (!existsSync26(cacheFile)) {
+  if (!existsSync25(cacheFile)) {
     return { providers: [], modelCount: 0, cacheExists: false };
   }
   try {
-    const content = readFileSync23(cacheFile, "utf-8");
+    const content = readFileSync22(cacheFile, "utf-8");
     const data = parseJsonc(content);
     const providers = Object.keys(data);
     let modelCount = 0;
@@ -69443,7 +69676,7 @@ init_model_capabilities();
 // src/cli/doctor/checks/model-resolution-config.ts
 init_shared();
 init_plugin_identity();
-import { readFileSync as readFileSync24 } from "fs";
+import { readFileSync as readFileSync23 } from "fs";
 import { join as join23 } from "path";
 var USER_CONFIG_DIR2 = getOpenCodeConfigPaths({ binary: "opencode", version: null }).configDir;
 var PROJECT_CONFIG_DIR = join23(process.cwd(), ".opencode");
@@ -69451,7 +69684,7 @@ function loadOmoConfig() {
   const projectDetected = detectManagedConfigFile(PROJECT_CONFIG_DIR);
   if (projectDetected.format !== "none") {
     try {
-      const content = readFileSync24(projectDetected.path, "utf-8");
+      const content = readFileSync23(projectDetected.path, "utf-8");
       return parseJsonc(content);
     } catch {
       return null;
@@ -69460,7 +69693,7 @@ function loadOmoConfig() {
   const userDetected = detectManagedConfigFile(USER_CONFIG_DIR2);
   if (userDetected.format !== "none") {
     try {
-      const content = readFileSync24(userDetected.path, "utf-8");
+      const content = readFileSync23(userDetected.path, "utf-8");
       return parseJsonc(content);
     } catch {
       return null;
@@ -69574,7 +69807,7 @@ function buildEffectiveResolution(requirement, userOverride) {
 
 // src/cli/doctor/checks/model-resolution.ts
 function parseProviderModel(value) {
-  const slashIndex = value.indexOf("/");
+  const slashIndex = value.lastIndexOf("/");
   if (slashIndex <= 0 || slashIndex === value.length - 1) {
     return null;
   }
@@ -69683,7 +69916,7 @@ function validateConfig() {
     return { exists: false, path: null, valid: true, config: null, errors: [] };
   }
   try {
-    const content = readFileSync25(configPath, "utf-8");
+    const content = readFileSync24(configPath, "utf-8");
     const rawConfig = parseJsonc(content);
     const schemaResult = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
     if (!schemaResult.success) {
@@ -69787,9 +70020,9 @@ async function checkConfig() {
 
 // src/cli/doctor/checks/dependencies.ts
 init_spawn_with_windows_hide();
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync26 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname6, join as join26 } from "path";
+import { dirname as dirname7, join as join26 } from "path";
 async function checkBinaryExists(binary2) {
   try {
     const path10 = Bun.which(binary2);
@@ -69845,7 +70078,7 @@ async function checkAstGrepNapi() {
       path: null
     };
   } catch {
-    const { existsSync: existsSync28 } = await import("fs");
+    const { existsSync: existsSync27 } = await import("fs");
     const { join: join27 } = await import("path");
     const { homedir: homedir8 } = await import("os");
     const pathsToCheck = [
@@ -69853,7 +70086,7 @@ async function checkAstGrepNapi() {
       join27(process.cwd(), "node_modules", "@ast-grep", "napi")
     ];
     for (const napiPath of pathsToCheck) {
-      if (existsSync28(napiPath)) {
+      if (existsSync27(napiPath)) {
         return {
           name: "AST-Grep NAPI",
           required: false,
@@ -69878,8 +70111,8 @@ function findCommentCheckerPackageBinary() {
   try {
     const require2 = createRequire(import.meta.url);
     const pkgPath = require2.resolve("@code-yeongyu/comment-checker/package.json");
-    const binaryPath = join26(dirname6(pkgPath), "bin", binaryName);
-    if (existsSync27(binaryPath))
+    const binaryPath = join26(dirname7(pkgPath), "bin", binaryName);
+    if (existsSync26(binaryPath))
       return binaryPath;
   } catch {}
   return null;
@@ -70036,16 +70269,16 @@ var BUILTIN_SERVERS = {
   "kotlin-ls": { command: ["kotlin-lsp"], extensions: [".kt", ".kts"] }
 };
 // src/tools/lsp/server-config-loader.ts
-import { existsSync as existsSync28, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync25 } from "fs";
 import { join as join27 } from "path";
 init_shared();
 init_jsonc_parser();
 init_plugin_identity();
 function loadJsonFile(path10) {
-  if (!existsSync28(path10))
+  if (!existsSync27(path10))
     return null;
   try {
-    return parseJsonc(readFileSync26(path10, "utf-8"));
+    return parseJsonc(readFileSync25(path10, "utf-8"));
   } catch {
     return null;
   }
@@ -70125,7 +70358,7 @@ function getMergedServers() {
 }
 
 // src/tools/lsp/server-installation.ts
-import { existsSync as existsSync29 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 import { delimiter as delimiter2, join as join29 } from "path";
 
 // src/tools/lsp/server-path-bases.ts
@@ -70149,7 +70382,7 @@ function isServerInstalled(command) {
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync29(cmd))
+    if (existsSync28(cmd))
       return true;
   }
   const isWindows = process.platform === "win32";
@@ -70170,14 +70403,14 @@ function isServerInstalled(command) {
   const paths = pathEnv.split(delimiter2);
   for (const p2 of paths) {
     for (const suffix of exts) {
-      if (existsSync29(join29(p2, cmd + suffix))) {
+      if (existsSync28(join29(p2, cmd + suffix))) {
         return true;
       }
     }
   }
   for (const base of getLspServerAdditionalPathBases(process.cwd())) {
     for (const suffix of exts) {
-      if (existsSync29(join29(base, cmd + suffix))) {
+      if (existsSync28(join29(base, cmd + suffix))) {
         return true;
       }
     }
@@ -70239,7 +70472,7 @@ function getInstalledLspServers() {
 
 // src/cli/doctor/checks/tools-mcp.ts
 init_shared();
-import { existsSync as existsSync30, readFileSync as readFileSync27 } from "fs";
+import { existsSync as existsSync29, readFileSync as readFileSync26 } from "fs";
 import { homedir as homedir8 } from "os";
 import { join as join30 } from "path";
 var BUILTIN_MCP_SERVERS = ["context7", "grep_app"];
@@ -70253,10 +70486,10 @@ function getMcpConfigPaths() {
 function loadUserMcpConfig() {
   const servers = {};
   for (const configPath of getMcpConfigPaths()) {
-    if (!existsSync30(configPath))
+    if (!existsSync29(configPath))
       continue;
     try {
-      const content = readFileSync27(configPath, "utf-8");
+      const content = readFileSync26(configPath, "utf-8");
       const config2 = parseJsonc(content);
       if (config2.mcpServers) {
         Object.assign(servers, config2.mcpServers);
@@ -70679,8 +70912,8 @@ async function doctor(options = { mode: "default" }) {
 
 // src/features/mcp-oauth/storage.ts
 init_shared();
-import { chmodSync, existsSync as existsSync31, mkdirSync as mkdirSync7, readFileSync as readFileSync28, unlinkSync as unlinkSync4, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname7, join as join31 } from "path";
+import { chmodSync, existsSync as existsSync30, mkdirSync as mkdirSync7, readFileSync as readFileSync27, unlinkSync as unlinkSync4, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname8, join as join31 } from "path";
 var STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStoragePath() {
   return join31(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
@@ -70720,11 +70953,11 @@ function buildKey(serverHost, resource) {
 }
 function readStore() {
   const filePath = getMcpOauthStoragePath();
-  if (!existsSync31(filePath)) {
+  if (!existsSync30(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync28(filePath, "utf-8");
+    const content = readFileSync27(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -70733,11 +70966,11 @@ function readStore() {
 function writeStore(store2) {
   const filePath = getMcpOauthStoragePath();
   try {
-    const dir = dirname7(filePath);
-    if (!existsSync31(dir)) {
+    const dir = dirname8(filePath);
+    if (!existsSync30(dir)) {
       mkdirSync7(dir, { recursive: true });
     }
-    writeFileSync11(filePath, JSON.stringify(store2, null, 2), { encoding: "utf-8", mode: 384 });
+    writeFileSync10(filePath, JSON.stringify(store2, null, 2), { encoding: "utf-8", mode: 384 });
     chmodSync(filePath, 384);
     return true;
   } catch {
@@ -70769,7 +71002,7 @@ function deleteToken(serverHost, resource) {
   if (Object.keys(store2).length === 0) {
     try {
       const filePath = getMcpOauthStoragePath();
-      if (existsSync31(filePath)) {
+      if (existsSync30(filePath)) {
         unlinkSync4(filePath);
       }
       return true;
@@ -71196,14 +71429,17 @@ class McpOAuthProvider {
 }
 
 // src/cli/mcp-oauth/login.ts
-async function login(serverName, options) {
+var defaultLoginDependencies = {
+  createProvider: (options) => new McpOAuthProvider(options)
+};
+async function login(serverName, options, deps = defaultLoginDependencies) {
   try {
     const serverUrl = options.serverUrl;
     if (!serverUrl) {
       console.error(`Error: --server-url is required for server "${serverName}"`);
       return 1;
     }
-    const provider = new McpOAuthProvider({
+    const provider = deps.createProvider({
       serverUrl,
       clientId: options.clientId,
       scopes: options.scopes