oh-my-opencode 3.14.0 → 3.15.1

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 = () => {};
+
 // src/shared/logger.ts
 import * as fs from "fs";
 import * as os from "os";
@@ -4956,6 +4957,11 @@ var init_logger = __esm(() => {
   buffer = [];
 });
 
+// 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]";
@@ -5018,15 +5024,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) {
@@ -5973,6 +5971,9 @@ var init_main = __esm(() => {
   })(ParseErrorCode || (ParseErrorCode = {}));
 });
 
+// src/shared/plugin-identity.ts
+var PLUGIN_NAME = "oh-my-openagent", LEGACY_PLUGIN_NAME = "oh-my-opencode", CONFIG_BASENAME = "oh-my-openagent", LEGACY_CONFIG_BASENAME = "oh-my-opencode";
+
 // src/shared/jsonc-parser.ts
 import { existsSync, readFileSync } from "fs";
 import { join as join3 } from "path";
@@ -6000,17 +6001,21 @@ function detectConfigFile(basePath) {
   return { format: "none", path: jsonPath };
 }
 function detectPluginConfigFile(dir) {
-  for (const name of PLUGIN_CONFIG_NAMES) {
-    const result = detectConfigFile(join3(dir, name));
-    if (result.format !== "none")
-      return result;
+  const canonicalResult = detectConfigFile(join3(dir, CONFIG_BASENAME));
+  const legacyResult = detectConfigFile(join3(dir, LEGACY_CONFIG_BASENAME));
+  if (canonicalResult.format !== "none") {
+    return {
+      ...canonicalResult,
+      legacyPath: legacyResult.format !== "none" ? legacyResult.path : undefined
+    };
+  }
+  if (legacyResult.format !== "none") {
+    return legacyResult;
   }
-  return { format: "none", path: join3(dir, PLUGIN_CONFIG_NAMES[0] + ".json") };
+  return { format: "none", path: join3(dir, `${CONFIG_BASENAME}.json`) };
 }
-var PLUGIN_CONFIG_NAMES;
 var init_jsonc_parser = __esm(() => {
   init_main();
-  PLUGIN_CONFIG_NAMES = ["oh-my-opencode", "oh-my-openagent"];
 });
 
 // src/shared/migration/agent-names.ts
@@ -6134,13 +6139,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) {
@@ -6229,11 +6250,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);
@@ -6254,6 +6277,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();
@@ -6356,17 +6380,56 @@ var init_opencode_storage_detection = __esm(() => {
   NOT_CACHED2 = Symbol("NOT_CACHED");
   FALSE_PENDING_RETRY = Symbol("FALSE_PENDING_RETRY");
 });
+// src/shared/load-opencode-plugins.ts
+var init_load_opencode_plugins = __esm(() => {
+  init_jsonc_parser();
+});
+
 // src/shared/external-plugin-detector.ts
 var init_external_plugin_detector = __esm(() => {
+  init_load_opencode_plugins();
   init_logger();
-  init_jsonc_parser();
+});
+
+// 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();
 });
 
@@ -6433,7 +6496,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" }
       ]
@@ -6441,8 +6504,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" }
       ]
@@ -6577,8 +6640,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"
         },
         {
@@ -6591,8 +6654,7 @@ var init_model_requirements = __esm(() => {
           model: "gemini-3.1-pro",
           variant: "high"
         }
-      ],
-      requiresModel: "gpt-5.3-codex"
+      ]
     },
     artistry: {
       fallbackChain: [
@@ -6703,6 +6765,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 = () => {};
 
@@ -6714,108 +6792,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 as mkdirSync2 } from "fs";
+// src/shared/json-file-cache-store.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, 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)) {
       mkdirSync2(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) {
@@ -6861,13 +6953,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()) {
@@ -6882,16 +6979,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,
@@ -6899,7 +6997,8 @@ var init_connected_providers_cache = __esm(() => {
     readProviderModelsCache,
     hasProviderModelsCache,
     writeProviderModelsCache,
-    updateConnectedProvidersCache
+    updateConnectedProvidersCache,
+    _resetMemCacheForTesting
   } = defaultConnectedProvidersCacheStore);
 });
 
@@ -19077,7 +19176,7 @@ var init_model_capabilities_generated = __esm(() => {
         family: "gpt-nano",
         reasoning: false,
         temperature: true,
-        toolCall: false,
+        toolCall: true,
         modalities: {
           input: [
             "text",
@@ -19238,7 +19337,7 @@ var init_model_capabilities_generated = __esm(() => {
         family: "gpt-mini",
         reasoning: false,
         temperature: true,
-        toolCall: false,
+        toolCall: true,
         modalities: {
           input: [
             "text",
@@ -47654,53 +47753,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",
@@ -47712,16 +47820,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
@@ -47807,13 +47922,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;
 }
@@ -47860,32 +47972,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;
     }
@@ -47896,114 +47989,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: {
@@ -48024,19 +48113,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 mkdirSync3, 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);
 }
@@ -48150,54 +48242,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)) {
-      mkdirSync3(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);
@@ -48214,7 +48278,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,
@@ -48259,24 +48323,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)
@@ -48289,7 +48355,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;
@@ -48307,10 +48373,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]));
 });
@@ -48328,6 +48397,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("oh-my-opencode:server-running-in-process");
+});
+
 // src/tools/interactive-bash/tmux-path-resolver.ts
 var init_tmux_path_resolver = () => {};
 
@@ -48339,6 +48414,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
@@ -48351,6 +48427,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();
@@ -48358,10 +48446,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();
 });
 
@@ -48493,10 +48584,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();
 });
@@ -48545,21 +48658,30 @@ var init_session_category_registry = __esm(() => {
   sessionCategoryMap = new Map;
 });
 
-// src/shared/plugin-identity.ts
-var PLUGIN_NAME = "oh-my-openagent", LEGACY_PLUGIN_NAME = "oh-my-opencode";
-
 // src/shared/legacy-plugin-warning.ts
 var init_legacy_plugin_warning = __esm(() => {
   init_jsonc_parser();
   init_opencode_config_dir();
 });
 
+// src/shared/plugin-entry-migrator.ts
+var init_plugin_entry_migrator = () => {};
+
+// src/shared/migrate-legacy-plugin-entry.ts
+var init_migrate_legacy_plugin_entry = __esm(() => {
+  init_main();
+  init_jsonc_parser();
+  init_logger();
+  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();
 });
-
 // src/shared/index.ts
 var init_shared = __esm(() => {
   init_model_resolver();
@@ -48567,6 +48689,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();
@@ -48586,6 +48709,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();
@@ -48691,11 +48815,11 @@ var init_plugin_name_with_version = __esm(() => {
 });
 
 // src/cli/config-manager/ensure-config-directory-exists.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
 function ensureConfigDirectoryExists() {
   const configDir = getConfigDir();
-  if (!existsSync6(configDir)) {
-    mkdirSync4(configDir, { recursive: true });
+  if (!existsSync5(configDir)) {
+    mkdirSync3(configDir, { recursive: true });
   }
 }
 var init_ensure_config_directory_exists = __esm(() => {
@@ -48732,14 +48856,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 };
@@ -48749,7 +48873,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;
 }
@@ -48759,7 +48883,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.` };
     }
@@ -48783,7 +48907,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();
@@ -48799,7 +48923,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 };
     }
@@ -48828,7 +48952,7 @@ async function addPluginToOpenCodeConfig(currentVersion) {
     }
     config.plugin = normalizedPlugins;
     if (format2 === "jsonc") {
-      const content = readFileSync6(path3, "utf-8");
+      const content = readFileSync5(path3, "utf-8");
       const pluginArrayRegex = /((?:"plugin"|plugin)\s*:\s*)\[([\s\S]*?)\]/;
       const match = content.match(pluginArrayRegex);
       if (match) {
@@ -48837,14 +48961,14 @@ async function addPluginToOpenCodeConfig(currentVersion) {
         const newContent = content.replace(pluginArrayRegex, `$1[
     ${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 };
@@ -49090,7 +49214,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;
 }
@@ -49107,34 +49231,34 @@ function writeOmoConfig(installConfig) {
   const omoConfigPath = getOmoConfigPath();
   try {
     const newConfig = generateOmoConfig(installConfig);
-    if (existsSync8(omoConfigPath)) {
+    if (existsSync7(omoConfigPath)) {
       try {
         const stat = statSync2(omoConfigPath);
-        const content = readFileSync7(omoConfigPath, "utf-8");
+        const content = readFileSync6(omoConfigPath, "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);
-        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 };
@@ -49250,10 +49374,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 = getOmoConfigPath();
-  if (!existsSync9(omoConfigPath)) {
+  if (!existsSync8(omoConfigPath)) {
     return {
       hasOpenAI: true,
       hasOpencodeZen: true,
@@ -49263,7 +49387,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 {
@@ -49339,7 +49463,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("");
@@ -49362,9 +49490,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.`
@@ -49508,13 +49636,14 @@ function getWindowsAppdataDir() {
     return null;
   return process.env.APPDATA ?? path4.join(os3.homedir(), "AppData", "Roaming");
 }
-var PACKAGE_NAME = "oh-my-opencode", 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_NAME = "oh-my-openagent", 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();
   NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/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");
@@ -49861,11 +49990,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_NAME]: intentVersion } }),
+      message: `Created cache package.json with: ${intentVersion}`
+    };
   }
   let content;
   let pkgJson;
@@ -49882,11 +50028,20 @@ function syncCachePackageJsonToIntent(pluginInfo) {
     return { synced: false, error: "parse_error", message: "Failed to parse cache package.json (malformed JSON)" };
   }
   if (!pkgJson || !pkgJson.dependencies?.[PACKAGE_NAME]) {
-    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_NAME]: intentVersion
+      }
+    };
+    return {
+      ...writeCachePackageJson(cachePackageJsonPath, nextPkgJson),
+      message: `Added ${PACKAGE_NAME}: ${intentVersion}`
+    };
   }
   const currentVersion = pkgJson.dependencies[PACKAGE_NAME];
-  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}` };
@@ -49899,16 +50054,10 @@ function syncCachePackageJsonToIntent(pluginInfo) {
     log(`[auto-update-checker] Updating cache package.json: "${currentVersion}" \u2192 "${intentVersion}"`);
   }
   pkgJson.dependencies[PACKAGE_NAME] = 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(() => {
@@ -50035,89 +50184,115 @@ var init_update_toasts = __esm(() => {
 
 // src/hooks/auto-update-checker/hook/background-update-check.ts
 import { existsSync as existsSync21 } from "fs";
-import { join as join19 } from "path";
+import { join as join20 } 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_NAME, "package.json");
-  const cacheInstallPath = join19(cacheDir, "node_modules", PACKAGE_NAME, "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_NAME, "package.json");
+  const cacheInstallPath = deps.join(cacheDir, "node_modules", PACKAGE_NAME, "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_NAME);
-  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_NAME);
+    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();
@@ -50126,6 +50301,23 @@ var init_background_update_check = __esm(() => {
   init_constants3();
   init_checker();
   init_update_toasts();
+  defaultDeps = {
+    existsSync: existsSync21,
+    join: join20,
+    runBunInstallWithDetails,
+    log,
+    getOpenCodeCacheDir,
+    getOpenCodeConfigPaths,
+    invalidatePackage,
+    extractChannel,
+    findPluginEntry,
+    getCachedVersion,
+    getLatestVersion,
+    syncCachePackageJsonToIntent,
+    showUpdateAvailableToast,
+    showAutoUpdatedToast
+  };
+  runBackgroundUpdateCheck = createBackgroundUpdateCheckRunner();
 });
 
 // src/hooks/auto-update-checker/hook/config-errors-toast.ts
@@ -50391,9 +50583,9 @@ var {
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "3.14.0",
+  version: "3.15.1",
   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: {
@@ -50465,21 +50657,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: {
-    "oh-my-opencode-darwin-arm64": "3.14.0",
-    "oh-my-opencode-darwin-x64": "3.14.0",
-    "oh-my-opencode-darwin-x64-baseline": "3.14.0",
-    "oh-my-opencode-linux-arm64": "3.14.0",
-    "oh-my-opencode-linux-arm64-musl": "3.14.0",
-    "oh-my-opencode-linux-x64": "3.14.0",
-    "oh-my-opencode-linux-x64-baseline": "3.14.0",
-    "oh-my-opencode-linux-x64-musl": "3.14.0",
-    "oh-my-opencode-linux-x64-musl-baseline": "3.14.0",
-    "oh-my-opencode-windows-x64": "3.14.0",
-    "oh-my-opencode-windows-x64-baseline": "3.14.0"
+    "oh-my-opencode-darwin-arm64": "3.15.1",
+    "oh-my-opencode-darwin-x64": "3.15.1",
+    "oh-my-opencode-darwin-x64-baseline": "3.15.1",
+    "oh-my-opencode-linux-arm64": "3.15.1",
+    "oh-my-opencode-linux-arm64-musl": "3.15.1",
+    "oh-my-opencode-linux-x64": "3.15.1",
+    "oh-my-opencode-linux-x64-baseline": "3.15.1",
+    "oh-my-opencode-linux-x64-musl": "3.15.1",
+    "oh-my-opencode-linux-x64-musl-baseline": "3.15.1",
+    "oh-my-opencode-windows-x64": "3.15.1",
+    "oh-my-opencode-windows-x64-baseline": "3.15.1"
   },
   overrides: {
     "@opencode-ai/sdk": "^1.2.24"
@@ -50709,7 +50901,7 @@ async function runCliInstaller(args, version) {
   console.log(`  Run ${import_picocolors2.default.cyan("opencode")} to start!`);
   console.log();
   printBox(`${import_picocolors2.default.bold("Pro Tip:")} Include ${import_picocolors2.default.cyan("ultrawork")} (or ${import_picocolors2.default.cyan("ulw")}) in your prompt.
-` + `All features work like magic\u2014parallel agents, background tasks,
+` + `All features work like magic-parallel agents, background tasks,
 ` + `deep exploration, and relentless execution until completion.`, "The Magic Word");
   console.log(`${SYMBOLS.star} ${import_picocolors2.default.yellow("If you found this helpful, consider starring the repo!")}`);
   console.log(`  ${import_picocolors2.default.dim("gh api --silent --method PUT /user/starred/code-yeongyu/oh-my-openagent >/dev/null 2>&1 || true")}`);
@@ -51484,7 +51676,7 @@ async function runTuiInstaller(args, version) {
   M2.success(import_picocolors4.default.bold(isUpdate ? "Configuration updated!" : "Installation complete!"));
   M2.message(`Run ${import_picocolors4.default.cyan("opencode")} to start!`);
   Me(`Include ${import_picocolors4.default.cyan("ultrawork")} (or ${import_picocolors4.default.cyan("ulw")}) in your prompt.
-` + `All features work like magic\u2014parallel agents, background tasks,
+` + `All features work like magic-parallel agents, background tasks,
 ` + `deep exploration, and relentless execution until completion.`, "The Magic Word");
   M2.message(`${import_picocolors4.default.yellow("\u2605")} If you found this helpful, consider starring the repo!`);
   M2.message(`  ${import_picocolors4.default.dim("gh api --silent --method PUT /user/starred/code-yeongyu/oh-my-openagent >/dev/null 2>&1 || true")}`);
@@ -65766,7 +65958,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",
@@ -65797,9 +65991,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
@@ -65887,6 +66086,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()
@@ -65955,7 +66156,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({
@@ -66000,7 +66202,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_-]*)*$/;
@@ -66043,6 +66246,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",
@@ -66064,11 +66268,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({
@@ -66184,7 +66390,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/tmux.ts
@@ -66195,12 +66402,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/start-work.ts
@@ -66225,6 +66438,7 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
   disabled_hooks: exports_external.array(exports_external.string()).optional(),
   disabled_commands: exports_external.array(BuiltinCommandNameSchema).optional(),
   disabled_tools: exports_external.array(exports_external.string()).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(),
@@ -66242,7 +66456,11 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
   model_capabilities: ModelCapabilitiesConfigSchema.optional(),
   openclaw: OpenClawConfigSchema.optional(),
   babysitting: BabysittingConfigSchema.optional(),
-  git_master: GitMasterConfigSchema.optional(),
+  git_master: GitMasterConfigSchema.default({
+    commit_footer: true,
+    include_co_authored_by: true,
+    git_env_prefix: "GIT_MASTER=1"
+  }),
   browser_automation_engine: BrowserAutomationConfigSchema.optional(),
   websearch: WebsearchConfigSchema.optional(),
   tmux: TmuxConfigSchema.optional(),
@@ -66252,13 +66470,79 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
 });
 // src/plugin-config.ts
 init_shared();
+
+// src/shared/migrate-legacy-config-file.ts
+init_logger();
+init_write_file_atomically();
+import { existsSync as existsSync10, readFileSync as readFileSync8, renameSync as renameSync2, rmSync } from "fs";
+import { join as join9, dirname, basename } from "path";
+function buildCanonicalPath(legacyPath) {
+  const dir = dirname(legacyPath);
+  const ext = basename(legacyPath).includes(".jsonc") ? ".jsonc" : ".json";
+  return join9(dir, `${CONFIG_BASENAME}${ext}`);
+}
+function archiveLegacyConfigFile(legacyPath) {
+  const backupPath = `${legacyPath}.bak`;
+  try {
+    renameSync2(legacyPath, backupPath);
+    log("[migrateLegacyConfigFile] Legacy config was migrated and renamed to backup. Update the canonical file only.", {
+      legacyPath,
+      backupPath
+    });
+    return true;
+  } catch (renameError) {
+    try {
+      rmSync(legacyPath);
+      log("[migrateLegacyConfigFile] Legacy config was migrated and removed after backup rename failed. Update the canonical file only.", {
+        legacyPath,
+        backupPath,
+        renameError
+      });
+      return true;
+    } catch (removeError) {
+      log("[migrateLegacyConfigFile] WARNING: canonical config was written but the legacy file still exists and will be ignored. Remove or rename it manually.", {
+        legacyPath,
+        backupPath,
+        renameError,
+        removeError
+      });
+      return false;
+    }
+  }
+}
+function migrateLegacyConfigFile(legacyPath) {
+  if (!existsSync10(legacyPath))
+    return false;
+  if (!basename(legacyPath).startsWith(LEGACY_CONFIG_BASENAME))
+    return false;
+  const canonicalPath = buildCanonicalPath(legacyPath);
+  if (existsSync10(canonicalPath))
+    return false;
+  try {
+    const content = readFileSync8(legacyPath, "utf-8");
+    writeFileAtomically(canonicalPath, content);
+    const archivedLegacyConfig = archiveLegacyConfigFile(legacyPath);
+    log("[migrateLegacyConfigFile] Migrated legacy config to canonical path", {
+      from: legacyPath,
+      to: canonicalPath,
+      archivedLegacyConfig
+    });
+    return archivedLegacyConfig;
+  } catch (error48) {
+    log("[migrateLegacyConfigFile] Failed to migrate legacy config file", { legacyPath, error: error48 });
+    return false;
+  }
+}
+
+// src/plugin-config.ts
 var PARTIAL_STRING_ARRAY_KEYS = new Set([
   "disabled_mcps",
   "disabled_agents",
   "disabled_skills",
   "disabled_hooks",
   "disabled_commands",
-  "disabled_tools"
+  "disabled_tools",
+  "mcp_env_allowlist"
 ]);
 function parseConfigPartially(rawConfig) {
   const fullResult = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
@@ -66289,7 +66573,7 @@ function parseConfigPartially(rawConfig) {
     }
   }
   if (invalidSections.length > 0) {
-    log("Partial config loaded \u2014 invalid sections skipped:", invalidSections);
+    log("Partial config loaded - invalid sections skipped:", invalidSections);
   }
   return partialConfig;
 }
@@ -66308,7 +66592,7 @@ function loadConfigFromPath(configPath, _ctx) {
       log(`Config validation error in ${configPath}:`, result.error.issues);
       addConfigLoadError({
         path: configPath,
-        error: `Partial config loaded \u2014 invalid sections skipped: ${errorMsg}`
+        error: `Partial config loaded - invalid sections skipped: ${errorMsg}`
       });
       const partialResult = parseConfigPartially(rawConfig);
       if (partialResult) {
@@ -66366,23 +66650,51 @@ 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)
   };
 }
 function loadPluginConfig(directory, ctx) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   const userDetected = detectPluginConfigFile(configDir);
-  const userConfigPath = userDetected.format !== "none" ? userDetected.path : path3.join(configDir, "oh-my-opencode.json");
+  let userConfigPath = userDetected.format !== "none" ? userDetected.path : path3.join(configDir, "oh-my-opencode.json");
+  if (userDetected.legacyPath) {
+    log("Canonical plugin config detected alongside legacy config. Remove the legacy file to avoid confusion.", {
+      canonicalPath: userDetected.path,
+      legacyPath: userDetected.legacyPath
+    });
+  }
+  if (userDetected.format !== "none" && path3.basename(userDetected.path).startsWith(LEGACY_CONFIG_BASENAME)) {
+    migrateLegacyConfigFile(userDetected.path);
+    userConfigPath = path3.join(path3.dirname(userDetected.path), `${CONFIG_BASENAME}${path3.extname(userDetected.path)}`);
+  }
   const projectBasePath = path3.join(directory, ".opencode");
   const projectDetected = detectPluginConfigFile(projectBasePath);
-  const projectConfigPath = projectDetected.format !== "none" ? projectDetected.path : path3.join(projectBasePath, "oh-my-opencode.json");
-  let config2 = loadConfigFromPath(userConfigPath, ctx) ?? {};
+  let projectConfigPath = projectDetected.format !== "none" ? projectDetected.path : path3.join(projectBasePath, "oh-my-opencode.json");
+  if (projectDetected.legacyPath) {
+    log("Canonical plugin config detected alongside legacy config. Remove the legacy file to avoid confusion.", {
+      canonicalPath: projectDetected.path,
+      legacyPath: projectDetected.legacyPath
+    });
+  }
+  if (projectDetected.format !== "none" && path3.basename(projectDetected.path).startsWith(LEGACY_CONFIG_BASENAME)) {
+    migrateLegacyConfigFile(projectDetected.path);
+    projectConfigPath = path3.join(path3.dirname(projectDetected.path), `${CONFIG_BASENAME}${path3.extname(projectDetected.path)}`);
+  }
+  const userConfig = loadConfigFromPath(userConfigPath, ctx);
+  let config2 = userConfig ?? OhMyOpenCodeConfigSchema.parse({});
   const projectConfig = loadConfigFromPath(projectConfigPath, ctx);
   if (projectConfig) {
     config2 = mergeConfigs(config2, projectConfig);
   }
   config2 = {
-    ...config2
+    ...config2,
+    mcp_env_allowlist: userConfig?.mcp_env_allowlist ?? []
   };
   log("Final merged config", {
     agents: config2.agents,
@@ -67841,7 +68153,7 @@ var import_picocolors9 = __toESM(require_picocolors(), 1);
 
 // src/cli/run/opencode-binary-resolver.ts
 init_spawn_with_windows_hide();
-import { delimiter, dirname, join as join10 } from "path";
+import { delimiter, dirname as dirname3, join as join11 } from "path";
 var OPENCODE_COMMANDS = ["opencode", "opencode-desktop"];
 var WINDOWS_SUFFIXES = ["", ".exe", ".cmd", ".bat", ".ps1"];
 function getCommandCandidates(platform) {
@@ -67864,7 +68176,7 @@ function collectCandidateBinaryPaths(pathEnv, which = Bun.which, platform = proc
   }
   for (const entry of (pathEnv ?? "").split(delimiter).filter(Boolean)) {
     for (const command of commandCandidates) {
-      addCandidate(join10(entry, command));
+      addCandidate(join11(entry, command));
     }
   }
   return candidates;
@@ -67891,7 +68203,7 @@ async function findWorkingOpencodeBinary(pathEnv = process.env.PATH, probe = can
   return null;
 }
 function buildPathWithBinaryFirst(pathEnv, binaryPath) {
-  const preferredDir = dirname(binaryPath);
+  const preferredDir = dirname3(binaryPath);
   const existing = (pathEnv ?? "").split(delimiter).filter((entry) => entry.length > 0 && entry !== preferredDir);
   return [preferredDir, ...existing].join(delimiter);
 }
@@ -68093,6 +68405,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();
@@ -68101,7 +68429,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,
@@ -68230,11 +68559,11 @@ 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 mkdirSync5, readdirSync } from "fs";
-import { dirname as dirname2, join as join11, basename } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync10, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, readdirSync } from "fs";
+import { dirname as dirname4, join as join12, basename as basename3 } from "path";
 var RESERVED_KEYS = new Set(["__proto__", "prototype", "constructor"]);
 function getBoulderFilePath(directory) {
-  return join11(directory, BOULDER_DIR, BOULDER_FILE);
+  return join12(directory, BOULDER_DIR, BOULDER_FILE);
 }
 function readBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
@@ -68280,10 +68609,10 @@ 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 mkdirSync6, readFileSync as readFileSync11, rmSync, writeFileSync as writeFileSync7 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync5, readFileSync as readFileSync11, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
+import { join as join13 } from "path";
 function getMarkerPath(directory, sessionID) {
-  return join12(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
+  return join13(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
 }
 function readContinuationMarker(directory, sessionID) {
   const markerPath = getMarkerPath(directory, sessionID);
@@ -68315,8 +68644,8 @@ function getActiveContinuationMarkerReason(marker) {
 }
 // src/hooks/ralph-loop/storage.ts
 init_frontmatter();
-import { existsSync as existsSync14, readFileSync as readFileSync12, writeFileSync as writeFileSync8, unlinkSync, mkdirSync as mkdirSync7 } from "fs";
-import { dirname as dirname3, join as join13 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync12, writeFileSync as writeFileSync7, unlinkSync, mkdirSync as mkdirSync6 } from "fs";
+import { dirname as dirname5, join as join14 } from "path";
 
 // src/hooks/ralph-loop/constants.ts
 var DEFAULT_STATE_FILE = ".sisyphus/ralph-loop.local.md";
@@ -68325,7 +68654,7 @@ var DEFAULT_COMPLETION_PROMISE = "DONE";
 
 // src/hooks/ralph-loop/storage.ts
 function getStateFilePath(directory, customPath) {
-  return customPath ? join13(directory, customPath) : join13(directory, DEFAULT_STATE_FILE);
+  return customPath ? join14(directory, customPath) : join14(directory, DEFAULT_STATE_FILE);
 }
 function readState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
@@ -69045,24 +69374,24 @@ import { existsSync as existsSync25, readFileSync as readFileSync22 } from "fs";
 init_spawn_with_windows_hide();
 import { existsSync as existsSync22 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 function getDesktopAppPaths(platform) {
   const home = homedir5();
   switch (platform) {
     case "darwin":
       return [
         "/Applications/OpenCode.app/Contents/MacOS/OpenCode",
-        join20(home, "Applications", "OpenCode.app", "Contents", "MacOS", "OpenCode")
+        join21(home, "Applications", "OpenCode.app", "Contents", "MacOS", "OpenCode")
       ];
     case "win32": {
       const programFiles = process.env.ProgramFiles;
       const localAppData = process.env.LOCALAPPDATA;
       const paths = [];
       if (programFiles) {
-        paths.push(join20(programFiles, "OpenCode", "OpenCode.exe"));
+        paths.push(join21(programFiles, "OpenCode", "OpenCode.exe"));
       }
       if (localAppData) {
-        paths.push(join20(localAppData, "OpenCode", "OpenCode.exe"));
+        paths.push(join21(localAppData, "OpenCode", "OpenCode.exe"));
       }
       return paths;
     }
@@ -69070,8 +69399,8 @@ function getDesktopAppPaths(platform) {
       return [
         "/usr/bin/opencode",
         "/usr/lib/opencode/opencode",
-        join20(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
-        join20(home, "Applications", "opencode-desktop-linux-aarch64.AppImage")
+        join21(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
+        join21(home, "Applications", "opencode-desktop-linux-aarch64.AppImage")
       ];
     default:
       return [];
@@ -69222,21 +69551,21 @@ init_checker();
 init_auto_update_checker();
 import { existsSync as existsSync24, readFileSync as readFileSync21 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 init_shared();
 function getPlatformDefaultCacheDir(platform = process.platform) {
   if (platform === "darwin")
-    return join21(homedir6(), "Library", "Caches");
+    return join22(homedir6(), "Library", "Caches");
   if (platform === "win32")
-    return process.env.LOCALAPPDATA ?? join21(homedir6(), "AppData", "Local");
-  return join21(homedir6(), ".cache");
+    return process.env.LOCALAPPDATA ?? join22(homedir6(), "AppData", "Local");
+  return join22(homedir6(), ".cache");
 }
 function resolveOpenCodeCacheDir() {
   const xdgCacheHome = process.env.XDG_CACHE_HOME;
   if (xdgCacheHome)
-    return join21(xdgCacheHome, "opencode");
+    return join22(xdgCacheHome, "opencode");
   const fromShared = getOpenCodeCacheDir();
-  const platformDefault = join21(getPlatformDefaultCacheDir(), "opencode");
+  const platformDefault = join22(getPlatformDefaultCacheDir(), "opencode");
   if (existsSync24(fromShared) || !existsSync24(platformDefault))
     return fromShared;
   return platformDefault;
@@ -69269,13 +69598,13 @@ function getLoadedPluginVersion() {
   const candidates = [
     {
       cacheDir: configDir,
-      cachePackagePath: join21(configDir, "package.json"),
-      installedPackagePath: join21(configDir, "node_modules", PACKAGE_NAME2, "package.json")
+      cachePackagePath: join22(configDir, "package.json"),
+      installedPackagePath: join22(configDir, "node_modules", PACKAGE_NAME2, "package.json")
     },
     {
       cacheDir,
-      cachePackagePath: join21(cacheDir, "package.json"),
-      installedPackagePath: join21(cacheDir, "node_modules", PACKAGE_NAME2, "package.json")
+      cachePackagePath: join22(cacheDir, "package.json"),
+      installedPackagePath: join22(cacheDir, "node_modules", PACKAGE_NAME2, "package.json")
     }
   ];
   const selectedCandidate = candidates.find((candidate) => existsSync24(candidate.installedPackagePath)) ?? candidates[0];
@@ -69425,22 +69754,22 @@ async function checkSystem() {
 
 // src/cli/doctor/checks/config.ts
 import { readFileSync as readFileSync25 } from "fs";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 init_shared();
 
 // src/cli/doctor/checks/model-resolution-cache.ts
 init_shared();
 import { existsSync as existsSync26, readFileSync as readFileSync23 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 function getOpenCodeCacheDir2() {
   const xdgCache = process.env.XDG_CACHE_HOME;
   if (xdgCache)
-    return join22(xdgCache, "opencode");
-  return join22(homedir7(), ".cache", "opencode");
+    return join23(xdgCache, "opencode");
+  return join23(homedir7(), ".cache", "opencode");
 }
 function loadAvailableModelsFromCache() {
-  const cacheFile = join22(getOpenCodeCacheDir2(), "models.json");
+  const cacheFile = join23(getOpenCodeCacheDir2(), "models.json");
   if (!existsSync26(cacheFile)) {
     return { providers: [], modelCount: 0, cacheExists: false };
   }
@@ -69468,9 +69797,9 @@ init_model_capabilities();
 // src/cli/doctor/checks/model-resolution-config.ts
 init_shared();
 import { readFileSync as readFileSync24 } from "fs";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 var USER_CONFIG_DIR2 = getOpenCodeConfigPaths({ binary: "opencode", version: null }).configDir;
-var PROJECT_CONFIG_DIR = join23(process.cwd(), ".opencode");
+var PROJECT_CONFIG_DIR = join24(process.cwd(), ".opencode");
 function loadOmoConfig() {
   const projectDetected = detectPluginConfigFile(PROJECT_CONFIG_DIR);
   if (projectDetected.format !== "none") {
@@ -69495,7 +69824,7 @@ function loadOmoConfig() {
 
 // src/cli/doctor/checks/model-resolution-details.ts
 init_shared();
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 
 // src/cli/doctor/checks/model-resolution-variant.ts
 function formatModelWithVariant(model, variant) {
@@ -69537,7 +69866,7 @@ function formatCapabilityResolutionLabel(mode) {
 }
 function buildModelResolutionDetails(options) {
   const details = [];
-  const cacheFile = join24(getOpenCodeCacheDir(), "models.json");
+  const cacheFile = join25(getOpenCodeCacheDir(), "models.json");
   details.push("\u2550\u2550\u2550 Available Models (from cache) \u2550\u2550\u2550");
   details.push("");
   if (options.available.cacheExists) {
@@ -69598,7 +69927,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;
   }
@@ -69693,7 +70022,7 @@ async function checkModels() {
 
 // src/cli/doctor/checks/config.ts
 var USER_CONFIG_DIR3 = getOpenCodeConfigDir({ binary: "opencode" });
-var PROJECT_CONFIG_DIR2 = join25(process.cwd(), ".opencode");
+var PROJECT_CONFIG_DIR2 = join26(process.cwd(), ".opencode");
 function findConfigPath() {
   const projectConfig = detectPluginConfigFile(PROJECT_CONFIG_DIR2);
   if (projectConfig.format !== "none")
@@ -69815,7 +70144,7 @@ async function checkConfig() {
 init_spawn_with_windows_hide();
 import { existsSync as existsSync27 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname6, join as join26 } from "path";
+import { dirname as dirname9, join as join27 } from "path";
 async function checkBinaryExists(binary2) {
   try {
     const path10 = Bun.which(binary2);
@@ -69872,11 +70201,11 @@ async function checkAstGrepNapi() {
     };
   } catch {
     const { existsSync: existsSync28 } = await import("fs");
-    const { join: join27 } = await import("path");
+    const { join: join28 } = await import("path");
     const { homedir: homedir8 } = await import("os");
     const pathsToCheck = [
-      join27(homedir8(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
-      join27(process.cwd(), "node_modules", "@ast-grep", "napi")
+      join28(homedir8(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
+      join28(process.cwd(), "node_modules", "@ast-grep", "napi")
     ];
     for (const napiPath of pathsToCheck) {
       if (existsSync28(napiPath)) {
@@ -69904,7 +70233,7 @@ 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);
+    const binaryPath = join27(dirname9(pkgPath), "bin", binaryName);
     if (existsSync27(binaryPath))
       return binaryPath;
   } catch {}
@@ -70063,7 +70392,7 @@ var BUILTIN_SERVERS = {
 };
 // src/tools/lsp/server-config-loader.ts
 import { existsSync as existsSync28, readFileSync as readFileSync26 } from "fs";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 init_shared();
 init_jsonc_parser();
 function loadJsonFile(path10) {
@@ -70079,9 +70408,9 @@ function getConfigPaths2() {
   const cwd = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   return {
-    project: detectPluginConfigFile(join27(cwd, ".opencode")).path,
+    project: detectPluginConfigFile(join28(cwd, ".opencode")).path,
     user: detectPluginConfigFile(configDir).path,
-    opencode: detectConfigFile(join27(configDir, "opencode")).path
+    opencode: detectConfigFile(join28(configDir, "opencode")).path
   };
 }
 function loadAllConfigs() {
@@ -70151,20 +70480,20 @@ function getMergedServers() {
 
 // src/tools/lsp/server-installation.ts
 import { existsSync as existsSync29 } from "fs";
-import { delimiter as delimiter2, join as join29 } from "path";
+import { delimiter as delimiter2, join as join30 } from "path";
 
 // src/tools/lsp/server-path-bases.ts
 init_shared();
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 function getLspServerAdditionalPathBases(workingDirectory) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join28(getDataDir(), "opencode");
+  const dataDir = join29(getDataDir(), "opencode");
   return [
-    join28(workingDirectory, "node_modules", ".bin"),
-    join28(configDir, "bin"),
-    join28(configDir, "node_modules", ".bin"),
-    join28(dataDir, "bin"),
-    join28(dataDir, "bin", "node_modules", ".bin")
+    join29(workingDirectory, "node_modules", ".bin"),
+    join29(configDir, "bin"),
+    join29(configDir, "node_modules", ".bin"),
+    join29(dataDir, "bin"),
+    join29(dataDir, "bin", "node_modules", ".bin")
   ];
 }
 
@@ -70195,14 +70524,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 (existsSync29(join30(p2, cmd + suffix))) {
         return true;
       }
     }
   }
   for (const base of getLspServerAdditionalPathBases(process.cwd())) {
     for (const suffix of exts) {
-      if (existsSync29(join29(base, cmd + suffix))) {
+      if (existsSync29(join30(base, cmd + suffix))) {
         return true;
       }
     }
@@ -70266,13 +70595,13 @@ function getInstalledLspServers() {
 init_shared();
 import { existsSync as existsSync30, readFileSync as readFileSync27 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 var BUILTIN_MCP_SERVERS = ["context7", "grep_app"];
 function getMcpConfigPaths() {
   return [
-    join30(homedir8(), ".claude", ".mcp.json"),
-    join30(process.cwd(), ".mcp.json"),
-    join30(process.cwd(), ".claude", ".mcp.json")
+    join31(homedir8(), ".claude", ".mcp.json"),
+    join31(process.cwd(), ".mcp.json"),
+    join31(process.cwd(), ".claude", ".mcp.json")
   ];
 }
 function loadUserMcpConfig() {
@@ -70734,11 +71063,11 @@ async function refreshModelCapabilities(options, deps = {}) {
 
 // src/features/mcp-oauth/storage.ts
 init_shared();
-import { chmodSync, existsSync as existsSync31, mkdirSync as mkdirSync8, readFileSync as readFileSync28, unlinkSync as unlinkSync4, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname7, join as join31 } from "path";
+import { chmodSync, existsSync as existsSync31, mkdirSync as mkdirSync8, readFileSync as readFileSync28, unlinkSync as unlinkSync4, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname10, join as join32 } from "path";
 var STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStoragePath() {
-  return join31(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
+  return join32(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
 }
 function normalizeHost(serverHost) {
   let host = serverHost.trim();
@@ -70788,11 +71117,11 @@ function readStore() {
 function writeStore(store2) {
   const filePath = getMcpOauthStoragePath();
   try {
-    const dir = dirname7(filePath);
+    const dir = dirname10(filePath);
     if (!existsSync31(dir)) {
       mkdirSync8(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 {
@@ -71249,14 +71578,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