oh-my-opencode 3.0.1 → 3.1.0

package/dist/cli/index.js

@@ -4919,6 +4919,18 @@ import * as os2 from "os";
 function getDataDir() {
   return process.env.XDG_DATA_HOME ?? path2.join(os2.homedir(), ".local", "share");
 }
+function getOpenCodeStorageDir() {
+  return path2.join(getDataDir(), "opencode", "storage");
+}
+function getCacheDir() {
+  return process.env.XDG_CACHE_HOME ?? path2.join(os2.homedir(), ".cache");
+}
+function getOmoOpenCodeCacheDir() {
+  return path2.join(getCacheDir(), "oh-my-opencode");
+}
+function getOpenCodeCacheDir() {
+  return path2.join(getCacheDir(), "opencode");
+}
 var init_data_path = () => {};
 
 // src/shared/config-errors.ts
@@ -5980,6 +5992,7 @@ var init_model_requirements = __esm(() => {
     explore: {
       fallbackChain: [
         { providers: ["anthropic", "opencode"], model: "claude-haiku-4-5" },
+        { providers: ["github-copilot"], model: "gpt-5-mini" },
         { providers: ["opencode"], model: "gpt-5-nano" }
       ]
     },
@@ -6075,28 +6088,165 @@ var init_model_requirements = __esm(() => {
   };
 });
 
-// src/shared/model-availability.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { homedir as homedir3 } from "os";
+// src/shared/connected-providers-cache.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
 import { join as join4 } from "path";
-function getOpenCodeCacheDir() {
-  const xdgCache = process.env.XDG_CACHE_HOME;
-  if (xdgCache)
-    return join4(xdgCache, "opencode");
-  return join4(homedir3(), ".cache", "opencode");
+function getCacheFilePath(filename) {
+  return join4(getOmoOpenCodeCacheDir(), filename);
 }
-function isModelCacheAvailable() {
-  const cacheFile = join4(getOpenCodeCacheDir(), "models.json");
+function ensureCacheDir() {
+  const cacheDir = getOmoOpenCodeCacheDir();
+  if (!existsSync3(cacheDir)) {
+    mkdirSync(cacheDir, { recursive: true });
+  }
+}
+function hasConnectedProvidersCache() {
+  const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE);
   return existsSync3(cacheFile);
 }
+function writeConnectedProvidersCache(connected) {
+  ensureCacheDir();
+  const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE);
+  const data = {
+    connected,
+    updatedAt: new Date().toISOString()
+  };
+  try {
+    writeFileSync(cacheFile, JSON.stringify(data, null, 2));
+    log("[connected-providers-cache] Cache written", { count: connected.length });
+  } catch (err) {
+    log("[connected-providers-cache] Error writing cache", { error: String(err) });
+  }
+}
+function hasProviderModelsCache() {
+  const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
+  return existsSync3(cacheFile);
+}
+function writeProviderModelsCache(data) {
+  ensureCacheDir();
+  const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
+  const cacheData = {
+    ...data,
+    updatedAt: new Date().toISOString()
+  };
+  try {
+    writeFileSync(cacheFile, JSON.stringify(cacheData, null, 2));
+    log("[connected-providers-cache] Provider-models cache written", {
+      providerCount: Object.keys(data.models).length
+    });
+  } catch (err) {
+    log("[connected-providers-cache] Error writing provider-models cache", { error: String(err) });
+  }
+}
+async function updateConnectedProvidersCache(client) {
+  if (!client?.provider?.list) {
+    log("[connected-providers-cache] client.provider.list not available");
+    return;
+  }
+  try {
+    const result = await client.provider.list();
+    const connected = result.data?.connected ?? [];
+    log("[connected-providers-cache] Fetched connected providers", { count: connected.length, providers: connected });
+    writeConnectedProvidersCache(connected);
+    if (client.model?.list) {
+      try {
+        const modelsResult = await client.model.list();
+        const models = modelsResult.data ?? [];
+        const modelsByProvider = {};
+        for (const model of models) {
+          if (!modelsByProvider[model.provider]) {
+            modelsByProvider[model.provider] = [];
+          }
+          modelsByProvider[model.provider].push(model.id);
+        }
+        writeProviderModelsCache({
+          models: modelsByProvider,
+          connected
+        });
+        log("[connected-providers-cache] Provider-models cache updated", {
+          providerCount: Object.keys(modelsByProvider).length,
+          totalModels: models.length
+        });
+      } catch (modelErr) {
+        log("[connected-providers-cache] Error fetching models", { error: String(modelErr) });
+      }
+    }
+  } catch (err) {
+    log("[connected-providers-cache] Error updating cache", { error: String(err) });
+  }
+}
+var CONNECTED_PROVIDERS_CACHE_FILE = "connected-providers.json", PROVIDER_MODELS_CACHE_FILE = "provider-models.json";
+var init_connected_providers_cache = __esm(() => {
+  init_logger();
+  init_data_path();
+});
+
+// src/shared/model-availability.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { join as join5 } from "path";
+function isModelCacheAvailable() {
+  if (hasProviderModelsCache()) {
+    return true;
+  }
+  const cacheFile = join5(getOpenCodeCacheDir(), "models.json");
+  return existsSync4(cacheFile);
+}
 var init_model_availability = __esm(() => {
   init_logger();
+  init_data_path();
+  init_connected_providers_cache();
 });
 
 // src/shared/model-resolver.ts
 var init_model_resolver = __esm(() => {
   init_logger();
   init_model_availability();
+  init_connected_providers_cache();
+});
+
+// src/features/hook-message-injector/constants.ts
+import { join as join6 } from "path";
+var OPENCODE_STORAGE, MESSAGE_STORAGE, PART_STORAGE;
+var init_constants = __esm(() => {
+  init_data_path();
+  OPENCODE_STORAGE = getOpenCodeStorageDir();
+  MESSAGE_STORAGE = join6(OPENCODE_STORAGE, "message");
+  PART_STORAGE = join6(OPENCODE_STORAGE, "part");
+});
+
+// src/features/hook-message-injector/injector.ts
+var init_injector = __esm(() => {
+  init_constants();
+});
+
+// src/features/hook-message-injector/index.ts
+var init_hook_message_injector = __esm(() => {
+  init_injector();
+  init_constants();
+});
+
+// src/shared/session-utils.ts
+var init_session_utils = __esm(() => {
+  init_hook_message_injector();
+});
+// src/shared/tmux/constants.ts
+var SESSION_TIMEOUT_MS;
+var init_constants2 = __esm(() => {
+  SESSION_TIMEOUT_MS = 10 * 60 * 1000;
+});
+
+// src/tools/interactive-bash/utils.ts
+var init_utils = () => {};
+
+// src/shared/tmux/tmux-utils.ts
+var init_tmux_utils = __esm(() => {
+  init_utils();
+});
+
+// src/shared/tmux/index.ts
+var init_tmux = __esm(() => {
+  init_constants2();
+  init_tmux_utils();
 });
 
 // src/shared/index.ts
@@ -6126,6 +6276,9 @@ var init_shared = __esm(() => {
   init_model_requirements();
   init_model_resolver();
   init_model_availability();
+  init_connected_providers_cache();
+  init_session_utils();
+  init_tmux();
 });
 
 // src/cli/model-fallback.ts
@@ -6205,6 +6358,8 @@ function generateModelConfig(config) {
         agents[role] = { model: "anthropic/claude-haiku-4-5" };
       } else if (avail.opencodeZen) {
         agents[role] = { model: "opencode/claude-haiku-4-5" };
+      } else if (avail.copilot) {
+        agents[role] = { model: "github-copilot/gpt-5-mini" };
       } else {
         agents[role] = { model: "opencode/gpt-5-nano" };
       }
@@ -6241,7 +6396,7 @@ var init_model_fallback = __esm(() => {
 });
 
 // src/cli/config-manager.ts
-import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync3, writeFileSync, statSync } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2, statSync } from "fs";
 function initConfigContext(binary2, version) {
   const paths = getOpenCodeConfigPaths({ binary: binary2, version });
   configContext = { binary: binary2, version, paths };
@@ -6331,10 +6486,10 @@ async function getPluginNameWithVersion(currentVersion) {
 function detectConfigFormat() {
   const configJsonc = getConfigJsonc();
   const configJson = getConfigJson();
-  if (existsSync4(configJsonc)) {
+  if (existsSync5(configJsonc)) {
     return { format: "jsonc", path: configJsonc };
   }
-  if (existsSync4(configJson)) {
+  if (existsSync5(configJson)) {
     return { format: "json", path: configJson };
   }
   return { format: "none", path: configJson };
@@ -6348,7 +6503,7 @@ function parseConfigWithError(path3) {
     if (stat.size === 0) {
       return { config: null, error: `Config file is empty: ${path3}. Delete it or add valid JSON content.` };
     }
-    const content = readFileSync3(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.` };
     }
@@ -6366,8 +6521,8 @@ function parseConfigWithError(path3) {
 }
 function ensureConfigDir() {
   const configDir = getConfigDir();
-  if (!existsSync4(configDir)) {
-    mkdirSync(configDir, { recursive: true });
+  if (!existsSync5(configDir)) {
+    mkdirSync2(configDir, { recursive: true });
   }
 }
 async function addPluginToOpenCodeConfig(currentVersion) {
@@ -6381,7 +6536,7 @@ async function addPluginToOpenCodeConfig(currentVersion) {
   try {
     if (format2 === "none") {
       const config2 = { plugin: [pluginEntry] };
-      writeFileSync(path3, JSON.stringify(config2, null, 2) + `
+      writeFileSync2(path3, JSON.stringify(config2, null, 2) + `
 `);
       return { success: true, configPath: path3 };
     }
@@ -6402,7 +6557,7 @@ async function addPluginToOpenCodeConfig(currentVersion) {
     }
     config.plugin = plugins;
     if (format2 === "jsonc") {
-      const content = readFileSync3(path3, "utf-8");
+      const content = readFileSync4(path3, "utf-8");
       const pluginArrayRegex = /"plugin"\s*:\s*\[([\s\S]*?)\]/;
       const match = content.match(pluginArrayRegex);
       if (match) {
@@ -6411,14 +6566,14 @@ async function addPluginToOpenCodeConfig(currentVersion) {
         const newContent = content.replace(pluginArrayRegex, `"plugin": [
     ${formattedPlugins}
   ]`);
-        writeFileSync(path3, newContent);
+        writeFileSync2(path3, newContent);
       } else {
         const newContent = content.replace(/^(\s*\{)/, `$1
   "plugin": ["${pluginEntry}"],`);
-        writeFileSync(path3, newContent);
+        writeFileSync2(path3, newContent);
       }
     } else {
-      writeFileSync(path3, JSON.stringify(config, null, 2) + `
+      writeFileSync2(path3, JSON.stringify(config, null, 2) + `
 `);
     }
     return { success: true, configPath: path3 };
@@ -6451,34 +6606,34 @@ function writeOmoConfig(installConfig) {
   const omoConfigPath = getOmoConfig();
   try {
     const newConfig = generateOmoConfig(installConfig);
-    if (existsSync4(omoConfigPath)) {
+    if (existsSync5(omoConfigPath)) {
       try {
         const stat = statSync(omoConfigPath);
-        const content = readFileSync3(omoConfigPath, "utf-8");
+        const content = readFileSync4(omoConfigPath, "utf-8");
         if (stat.size === 0 || isEmptyOrWhitespace(content)) {
-          writeFileSync(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
+          writeFileSync2(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
 `);
           return { success: true, configPath: omoConfigPath };
         }
         const existing = parseJsonc(content);
         if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
-          writeFileSync(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
+          writeFileSync2(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
 `);
           return { success: true, configPath: omoConfigPath };
         }
         const merged = deepMerge(existing, newConfig);
-        writeFileSync(omoConfigPath, JSON.stringify(merged, null, 2) + `
+        writeFileSync2(omoConfigPath, JSON.stringify(merged, null, 2) + `
 `);
       } catch (parseErr) {
         if (parseErr instanceof SyntaxError) {
-          writeFileSync(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
+          writeFileSync2(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
 `);
           return { success: true, configPath: omoConfigPath };
         }
         throw parseErr;
       }
     } else {
-      writeFileSync(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
+      writeFileSync2(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
 `);
     }
     return { success: true, configPath: omoConfigPath };
@@ -6540,7 +6695,7 @@ async function addAuthPlugins(config) {
       }
     }
     const newConfig = { ...existingConfig ?? {}, plugin: plugins };
-    writeFileSync(path3, JSON.stringify(newConfig, null, 2) + `
+    writeFileSync2(path3, JSON.stringify(newConfig, null, 2) + `
 `);
     return { success: true, configPath: path3 };
   } catch (err) {
@@ -6612,7 +6767,7 @@ function addProviderConfig(config) {
     if (Object.keys(providers).length > 0) {
       newConfig.provider = providers;
     }
-    writeFileSync(path3, JSON.stringify(newConfig, null, 2) + `
+    writeFileSync2(path3, JSON.stringify(newConfig, null, 2) + `
 `);
     return { success: true, configPath: path3 };
   } catch (err) {
@@ -6621,11 +6776,11 @@ function addProviderConfig(config) {
 }
 function detectProvidersFromOmoConfig() {
   const omoConfigPath = getOmoConfig();
-  if (!existsSync4(omoConfigPath)) {
+  if (!existsSync5(omoConfigPath)) {
     return { hasOpenAI: true, hasOpencodeZen: true, hasZaiCodingPlan: false };
   }
   try {
-    const content = readFileSync3(omoConfigPath, "utf-8");
+    const content = readFileSync4(omoConfigPath, "utf-8");
     const omoConfig = parseJsonc(content);
     if (!omoConfig || typeof omoConfig !== "object") {
       return { hasOpenAI: true, hasOpencodeZen: true, hasZaiCodingPlan: false };
@@ -6733,7 +6888,7 @@ var init_config_manager = __esm(() => {
 // src/hooks/auto-update-checker/constants.ts
 import * as path3 from "path";
 import * as os3 from "os";
-function getCacheDir() {
+function getCacheDir2() {
   if (process.platform === "win32") {
     return path3.join(process.env.LOCALAPPDATA ?? os3.homedir(), "opencode");
   }
@@ -6745,10 +6900,10 @@ function getWindowsAppdataDir() {
   return process.env.APPDATA ?? path3.join(os3.homedir(), "AppData", "Roaming");
 }
 var PACKAGE_NAME2 = "oh-my-opencode", NPM_REGISTRY_URL, NPM_FETCH_TIMEOUT = 5000, CACHE_DIR, VERSION_FILE, INSTALLED_PACKAGE_JSON, USER_CONFIG_DIR, USER_OPENCODE_CONFIG, USER_OPENCODE_CONFIG_JSONC;
-var init_constants = __esm(() => {
+var init_constants3 = __esm(() => {
   init_shared();
   NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME2}/dist-tags`;
-  CACHE_DIR = getCacheDir();
+  CACHE_DIR = getCacheDir2();
   VERSION_FILE = path3.join(CACHE_DIR, "version");
   INSTALLED_PACKAGE_JSON = path3.join(CACHE_DIR, "node_modules", PACKAGE_NAME2, "package.json");
   USER_CONFIG_DIR = getOpenCodeConfigDir({ binary: "opencode" });
@@ -6825,7 +6980,7 @@ function invalidateCache() {
   return invalidatePackage();
 }
 var init_cache = __esm(() => {
-  init_constants();
+  init_constants3();
   init_logger();
 });
 
@@ -6897,6 +7052,7 @@ v${latestVersion} available. Restart OpenCode to apply.` : `OpenCode is now on S
         const displayVersion = localDevVersion ?? cachedVersion;
         await showConfigErrorsIfAny(ctx);
         await showModelCacheWarningIfNeeded(ctx);
+        await updateAndShowConnectedProvidersCacheStatus(ctx);
         if (localDevVersion) {
           if (showStartupToast) {
             showLocalDevToast(ctx, displayVersion, isSisyphusEnabled).catch(() => {});
@@ -6983,6 +7139,23 @@ async function showModelCacheWarningIfNeeded(ctx) {
   }).catch(() => {});
   log("[auto-update-checker] Model cache warning shown");
 }
+async function updateAndShowConnectedProvidersCacheStatus(ctx) {
+  const hadCache = hasConnectedProvidersCache();
+  updateConnectedProvidersCache(ctx.client).catch(() => {});
+  if (!hadCache) {
+    await ctx.client.tui.showToast({
+      body: {
+        title: "Connected Providers Cache",
+        message: "Building provider cache for first time. Restart OpenCode for full model filtering.",
+        variant: "info",
+        duration: 8000
+      }
+    }).catch(() => {});
+    log("[auto-update-checker] Connected providers cache toast shown (first run)");
+  } else {
+    log("[auto-update-checker] Connected providers cache exists, updating in background");
+  }
+}
 async function showConfigErrorsIfAny(ctx) {
   const errors = getConfigLoadErrors();
   if (errors.length === 0)
@@ -7056,11 +7229,12 @@ var SISYPHUS_SPINNER;
 var init_auto_update_checker = __esm(() => {
   init_checker();
   init_cache();
-  init_constants();
+  init_constants3();
   init_logger();
   init_config_errors();
   init_config_manager();
   init_model_availability();
+  init_connected_providers_cache();
   init_checker();
   init_cache();
   SISYPHUS_SPINNER = ["\xB7", "\u2022", "\u25CF", "\u25CB", "\u25CC", "\u25E6", " "];
@@ -7295,7 +7469,7 @@ async function checkForUpdate(directory) {
   return { needsUpdate, currentVersion, latestVersion, isLocalDev: false, isPinned: pluginInfo.isPinned };
 }
 var init_checker = __esm(() => {
-  init_constants();
+  init_constants3();
   init_logger();
 });
 
@@ -7901,7 +8075,7 @@ var import_picocolors2 = __toESM(require_picocolors(), 1);
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "3.0.1",
+  version: "3.1.0",
   description: "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -7974,13 +8148,13 @@ var package_default = {
     typescript: "^5.7.3"
   },
   optionalDependencies: {
-    "oh-my-opencode-darwin-arm64": "3.0.1",
-    "oh-my-opencode-darwin-x64": "3.0.1",
-    "oh-my-opencode-linux-arm64": "3.0.1",
-    "oh-my-opencode-linux-arm64-musl": "3.0.1",
-    "oh-my-opencode-linux-x64": "3.0.1",
-    "oh-my-opencode-linux-x64-musl": "3.0.1",
-    "oh-my-opencode-windows-x64": "3.0.1"
+    "oh-my-opencode-darwin-arm64": "3.1.0",
+    "oh-my-opencode-darwin-x64": "3.1.0",
+    "oh-my-opencode-linux-arm64": "3.1.0",
+    "oh-my-opencode-linux-arm64-musl": "3.1.0",
+    "oh-my-opencode-linux-x64": "3.1.0",
+    "oh-my-opencode-linux-x64-musl": "3.1.0",
+    "oh-my-opencode-windows-x64": "3.1.0"
   },
   trustedDependencies: [
     "@ast-grep/cli",
@@ -10642,14 +10816,14 @@ function getOpenCodeCheckDefinition() {
 }
 
 // src/cli/doctor/checks/plugin.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
 init_shared();
 function detectConfigPath() {
   const paths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
-  if (existsSync7(paths.configJsonc)) {
+  if (existsSync8(paths.configJsonc)) {
     return { path: paths.configJsonc, format: "jsonc" };
   }
-  if (existsSync7(paths.configJson)) {
+  if (existsSync8(paths.configJson)) {
     return { path: paths.configJson, format: "json" };
   }
   return null;
@@ -10679,7 +10853,7 @@ function getPluginInfo() {
     };
   }
   try {
-    const content = readFileSync6(configInfo.path, "utf-8");
+    const content = readFileSync7(configInfo.path, "utf-8");
     const config = parseJsonc(content);
     const plugins = config.plugin ?? [];
     const pluginEntry = findPluginEntry2(plugins);
@@ -10753,8 +10927,8 @@ function getPluginCheckDefinition() {
 }
 
 // src/cli/doctor/checks/config.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync8 } from "fs";
+import { join as join10 } from "path";
 init_shared();
 
 // node_modules/zod/v4/classic/external.js
@@ -20841,10 +21015,10 @@ function _property(property, schema2, params) {
     ...normalizeParams(params)
   });
 }
-function _mime(types2, params) {
+function _mime(types3, params) {
   return new $ZodCheckMimeType({
     check: "mime_type",
-    mime: types2,
+    mime: types3,
     ...normalizeParams(params)
   });
 }
@@ -22754,7 +22928,7 @@ var ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => {
   ZodType.init(inst, def);
   inst.min = (size, params) => inst.check(_minSize(size, params));
   inst.max = (size, params) => inst.check(_maxSize(size, params));
-  inst.mime = (types2, params) => inst.check(_mime(Array.isArray(types2) ? types2 : [types2], params));
+  inst.mime = (types3, params) => inst.check(_mime(Array.isArray(types3) ? types3 : [types3], params));
 });
 function file(params) {
   return _file(ZodFile, params);
@@ -23102,6 +23276,7 @@ var BuiltinAgentNameSchema = exports_external.enum([
 ]);
 var BuiltinSkillNameSchema = exports_external.enum([
   "playwright",
+  "agent-browser",
   "frontend-ui-ux",
   "git-master"
 ]);
@@ -23143,12 +23318,14 @@ var HookNameSchema = exports_external.enum([
   "interactive-bash-session",
   "thinking-block-validator",
   "ralph-loop",
+  "category-skill-reminder",
   "compaction-context-injector",
   "claude-code-hooks",
   "auto-slash-command",
   "edit-error-recovery",
   "delegate-task-retry",
   "prometheus-md-only",
+  "sisyphus-junior-notepad",
   "start-work",
   "atlas"
 ]);
@@ -23320,6 +23497,24 @@ var GitMasterConfigSchema = exports_external.object({
   commit_footer: exports_external.boolean().default(true),
   include_co_authored_by: exports_external.boolean().default(true)
 });
+var BrowserAutomationProviderSchema = exports_external.enum(["playwright", "agent-browser"]);
+var BrowserAutomationConfigSchema = exports_external.object({
+  provider: BrowserAutomationProviderSchema.default("playwright")
+});
+var TmuxLayoutSchema = exports_external.enum([
+  "main-horizontal",
+  "main-vertical",
+  "tiled",
+  "even-horizontal",
+  "even-vertical"
+]);
+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)
+});
 var OhMyOpenCodeConfigSchema = exports_external.object({
   $schema: exports_external.string().optional(),
   disabled_mcps: exports_external.array(AnyMcpNameSchema).optional(),
@@ -23338,12 +23533,14 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
   ralph_loop: RalphLoopConfigSchema.optional(),
   background_task: BackgroundTaskConfigSchema.optional(),
   notification: NotificationConfigSchema.optional(),
-  git_master: GitMasterConfigSchema.optional()
+  git_master: GitMasterConfigSchema.optional(),
+  browser_automation_engine: BrowserAutomationConfigSchema.optional(),
+  tmux: TmuxConfigSchema.optional()
 });
 // src/cli/doctor/checks/config.ts
 var USER_CONFIG_DIR2 = getOpenCodeConfigDir({ binary: "opencode" });
-var USER_CONFIG_BASE = join8(USER_CONFIG_DIR2, `${PACKAGE_NAME3}`);
-var PROJECT_CONFIG_BASE = join8(process.cwd(), ".opencode", PACKAGE_NAME3);
+var USER_CONFIG_BASE = join10(USER_CONFIG_DIR2, `${PACKAGE_NAME3}`);
+var PROJECT_CONFIG_BASE = join10(process.cwd(), ".opencode", PACKAGE_NAME3);
 function findConfigPath() {
   const projectDetected = detectConfigFile(PROJECT_CONFIG_BASE);
   if (projectDetected.format !== "none") {
@@ -23357,7 +23554,7 @@ function findConfigPath() {
 }
 function validateConfig(configPath) {
   try {
-    const content = readFileSync7(configPath, "utf-8");
+    const content = readFileSync8(configPath, "utf-8");
     const rawConfig = parseJsonc(content);
     const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
     if (!result.success) {
@@ -23383,7 +23580,7 @@ function getConfigInfo() {
       errors: []
     };
   }
-  if (!existsSync8(configPath.path)) {
+  if (!existsSync9(configPath.path)) {
     return {
       exists: false,
       path: configPath.path,
@@ -23440,24 +23637,24 @@ function getConfigCheckDefinition() {
 }
 
 // src/cli/doctor/checks/model-resolution.ts
-import { readFileSync as readFileSync8, existsSync as existsSync9 } from "fs";
+import { readFileSync as readFileSync9, existsSync as existsSync10 } from "fs";
 init_shared();
 init_model_requirements();
-import { homedir as homedir6 } from "os";
-import { join as join9 } from "path";
+import { homedir as homedir5 } from "os";
+import { join as join11 } from "path";
 function getOpenCodeCacheDir2() {
   const xdgCache = process.env.XDG_CACHE_HOME;
   if (xdgCache)
-    return join9(xdgCache, "opencode");
-  return join9(homedir6(), ".cache", "opencode");
+    return join11(xdgCache, "opencode");
+  return join11(homedir5(), ".cache", "opencode");
 }
 function loadAvailableModels() {
-  const cacheFile = join9(getOpenCodeCacheDir2(), "models.json");
-  if (!existsSync9(cacheFile)) {
+  const cacheFile = join11(getOpenCodeCacheDir2(), "models.json");
+  if (!existsSync10(cacheFile)) {
     return { providers: [], modelCount: 0, cacheExists: false };
   }
   try {
-    const content = readFileSync8(cacheFile, "utf-8");
+    const content = readFileSync9(cacheFile, "utf-8");
     const data = JSON.parse(content);
     const providers = Object.keys(data);
     let modelCount = 0;
@@ -23473,14 +23670,14 @@ function loadAvailableModels() {
   }
 }
 var PACKAGE_NAME4 = "oh-my-opencode";
-var USER_CONFIG_DIR3 = join9(homedir6(), ".config", "opencode");
-var USER_CONFIG_BASE2 = join9(USER_CONFIG_DIR3, PACKAGE_NAME4);
-var PROJECT_CONFIG_BASE2 = join9(process.cwd(), ".opencode", PACKAGE_NAME4);
+var USER_CONFIG_DIR3 = join11(homedir5(), ".config", "opencode");
+var USER_CONFIG_BASE2 = join11(USER_CONFIG_DIR3, PACKAGE_NAME4);
+var PROJECT_CONFIG_BASE2 = join11(process.cwd(), ".opencode", PACKAGE_NAME4);
 function loadConfig() {
   const projectDetected = detectConfigFile(PROJECT_CONFIG_BASE2);
   if (projectDetected.format !== "none") {
     try {
-      const content = readFileSync8(projectDetected.path, "utf-8");
+      const content = readFileSync9(projectDetected.path, "utf-8");
       return parseJsonc(content);
     } catch {
       return null;
@@ -23489,7 +23686,7 @@ function loadConfig() {
   const userDetected = detectConfigFile(USER_CONFIG_BASE2);
   if (userDetected.format !== "none") {
     try {
-      const content = readFileSync8(userDetected.path, "utf-8");
+      const content = readFileSync9(userDetected.path, "utf-8");
       return parseJsonc(content);
     } catch {
       return null;
@@ -23555,9 +23752,11 @@ function buildDetailsArray(info, available) {
   details.push("\u2550\u2550\u2550 Available Models (from cache) \u2550\u2550\u2550");
   details.push("");
   if (available.cacheExists) {
-    details.push(`  Providers: ${available.providers.length} (${available.providers.slice(0, 8).join(", ")}${available.providers.length > 8 ? "..." : ""})`);
+    details.push(`  Providers in cache: ${available.providers.length}`);
+    details.push(`  Sample: ${available.providers.slice(0, 6).join(", ")}${available.providers.length > 6 ? "..." : ""}`);
     details.push(`  Total models: ${available.modelCount}`);
     details.push(`  Cache: ~/.cache/opencode/models.json`);
+    details.push(`  \u2139 Runtime: only connected providers used`);
     details.push(`  Refresh: opencode models --refresh`);
   } else {
     details.push("  \u26A0 Cache not found. Run 'opencode' to populate.");
@@ -23611,23 +23810,23 @@ function getModelResolutionCheckDefinition() {
 }
 
 // src/cli/doctor/checks/auth.ts
-import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync10 } from "fs";
+import { join as join12 } from "path";
 init_shared();
 var OPENCODE_CONFIG_DIR = getOpenCodeConfigDir({ binary: "opencode" });
-var OPENCODE_JSON = join10(OPENCODE_CONFIG_DIR, "opencode.json");
-var OPENCODE_JSONC = join10(OPENCODE_CONFIG_DIR, "opencode.jsonc");
+var OPENCODE_JSON = join12(OPENCODE_CONFIG_DIR, "opencode.json");
+var OPENCODE_JSONC = join12(OPENCODE_CONFIG_DIR, "opencode.jsonc");
 var AUTH_PLUGINS = {
   anthropic: { plugin: "builtin", name: "Anthropic (Claude)" },
   openai: { plugin: "opencode-openai-codex-auth", name: "OpenAI (ChatGPT)" },
   google: { plugin: "opencode-antigravity-auth", name: "Google (Gemini)" }
 };
 function getOpenCodeConfig() {
-  const configPath = existsSync10(OPENCODE_JSONC) ? OPENCODE_JSONC : OPENCODE_JSON;
-  if (!existsSync10(configPath))
+  const configPath = existsSync11(OPENCODE_JSONC) ? OPENCODE_JSONC : OPENCODE_JSON;
+  if (!existsSync11(configPath))
     return null;
   try {
-    const content = readFileSync9(configPath, "utf-8");
+    const content = readFileSync10(configPath, "utf-8");
     return parseJsonc(content);
   } catch {
     return null;
@@ -23767,15 +23966,15 @@ async function checkAstGrepNapi() {
       path: null
     };
   } catch {
-    const { existsSync: existsSync11 } = await import("fs");
-    const { join: join11 } = await import("path");
-    const { homedir: homedir7 } = await import("os");
+    const { existsSync: existsSync12 } = await import("fs");
+    const { join: join13 } = await import("path");
+    const { homedir: homedir6 } = await import("os");
     const pathsToCheck = [
-      join11(homedir7(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
-      join11(process.cwd(), "node_modules", "@ast-grep", "napi")
+      join13(homedir6(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
+      join13(process.cwd(), "node_modules", "@ast-grep", "napi")
     ];
     for (const napiPath of pathsToCheck) {
-      if (existsSync11(napiPath)) {
+      if (existsSync12(napiPath)) {
         return {
           name: "AST-Grep NAPI",
           required: false,
@@ -24004,15 +24203,15 @@ function getGhCliCheckDefinition() {
 }
 
 // src/tools/lsp/config.ts
-import { existsSync as existsSync11, readFileSync as readFileSync10 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync11 } from "fs";
+import { join as join13 } from "path";
 init_shared();
 function isServerInstalled(command) {
   if (command.length === 0)
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync11(cmd))
+    if (existsSync12(cmd))
       return true;
   }
   const isWindows = process.platform === "win32";
@@ -24034,23 +24233,23 @@ function isServerInstalled(command) {
   const paths = pathEnv.split(pathSeparator);
   for (const p2 of paths) {
     for (const suffix of exts) {
-      if (existsSync11(join11(p2, cmd + suffix))) {
+      if (existsSync12(join13(p2, cmd + suffix))) {
         return true;
       }
     }
   }
   const cwd = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join11(getDataDir(), "opencode");
+  const dataDir = join13(getDataDir(), "opencode");
   const additionalBases = [
-    join11(cwd, "node_modules", ".bin"),
-    join11(configDir, "bin"),
-    join11(configDir, "node_modules", ".bin"),
-    join11(dataDir, "bin")
+    join13(cwd, "node_modules", ".bin"),
+    join13(configDir, "bin"),
+    join13(configDir, "node_modules", ".bin"),
+    join13(dataDir, "bin")
   ];
   for (const base of additionalBases) {
     for (const suffix of exts) {
-      if (existsSync11(join11(base, cmd + suffix))) {
+      if (existsSync12(join13(base, cmd + suffix))) {
         return true;
       }
     }
@@ -24123,23 +24322,23 @@ function getLspCheckDefinition() {
 }
 
 // src/cli/doctor/checks/mcp.ts
-import { existsSync as existsSync12, readFileSync as readFileSync11 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join12 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync12 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join14 } from "path";
 init_shared();
 var BUILTIN_MCP_SERVERS = ["context7", "grep_app"];
 var MCP_CONFIG_PATHS = [
-  join12(homedir7(), ".claude", ".mcp.json"),
-  join12(process.cwd(), ".mcp.json"),
-  join12(process.cwd(), ".claude", ".mcp.json")
+  join14(homedir6(), ".claude", ".mcp.json"),
+  join14(process.cwd(), ".mcp.json"),
+  join14(process.cwd(), ".claude", ".mcp.json")
 ];
 function loadUserMcpConfig() {
   const servers = {};
   for (const configPath of MCP_CONFIG_PATHS) {
-    if (!existsSync12(configPath))
+    if (!existsSync13(configPath))
       continue;
     try {
-      const content = readFileSync11(configPath, "utf-8");
+      const content = readFileSync12(configPath, "utf-8");
       const config2 = parseJsonc(content);
       if (config2.mcpServers) {
         Object.assign(servers, config2.mcpServers);