oh-my-opencode 3.5.2 → 3.5.4

package/dist/cli/index.js

@@ -7052,6 +7052,12 @@ var init_tmux = __esm(() => {
 var init_model_suggestion_retry = __esm(() => {
   init_logger();
 });
+
+// src/shared/opencode-server-auth.ts
+var init_opencode_server_auth = __esm(() => {
+  init_logger();
+});
+
 // src/shared/port-utils.ts
 async function isPortAvailable(port, hostname = "127.0.0.1") {
   try {
@@ -7128,6 +7134,7 @@ var init_shared = __esm(() => {
   init_session_utils();
   init_tmux();
   init_model_suggestion_retry();
+  init_opencode_server_auth();
   init_port_utils();
   init_git_worktree();
   init_safe_create_hook();
@@ -8870,7 +8877,7 @@ var {
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "3.5.2",
+  version: "3.5.4",
   description: "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -8944,13 +8951,13 @@ var package_default = {
     typescript: "^5.7.3"
   },
   optionalDependencies: {
-    "oh-my-opencode-darwin-arm64": "3.5.2",
-    "oh-my-opencode-darwin-x64": "3.5.2",
-    "oh-my-opencode-linux-arm64": "3.5.2",
-    "oh-my-opencode-linux-arm64-musl": "3.5.2",
-    "oh-my-opencode-linux-x64": "3.5.2",
-    "oh-my-opencode-linux-x64-musl": "3.5.2",
-    "oh-my-opencode-windows-x64": "3.5.2"
+    "oh-my-opencode-darwin-arm64": "3.5.4",
+    "oh-my-opencode-darwin-x64": "3.5.4",
+    "oh-my-opencode-linux-arm64": "3.5.4",
+    "oh-my-opencode-linux-arm64-musl": "3.5.4",
+    "oh-my-opencode-linux-x64": "3.5.4",
+    "oh-my-opencode-linux-x64-musl": "3.5.4",
+    "oh-my-opencode-windows-x64": "3.5.4"
   },
   trustedDependencies: [
     "@ast-grep/cli",
@@ -22692,7 +22699,8 @@ var BackgroundTaskConfigSchema = exports_external.object({
   defaultConcurrency: exports_external.number().min(1).optional(),
   providerConcurrency: exports_external.record(exports_external.string(), exports_external.number().min(0)).optional(),
   modelConcurrency: exports_external.record(exports_external.string(), exports_external.number().min(0)).optional(),
-  staleTimeoutMs: exports_external.number().min(60000).optional()
+  staleTimeoutMs: exports_external.number().min(60000).optional(),
+  messageStalenessTimeoutMs: exports_external.number().min(60000).optional()
 });
 // src/config/schema/browser-automation.ts
 var BrowserAutomationProviderSchema = exports_external.enum([
@@ -22818,7 +22826,6 @@ var HookNameSchema = exports_external.enum([
   "directory-readme-injector",
   "empty-task-response-detector",
   "think-mode",
-  "subagent-question-blocker",
   "anthropic-context-window-limit-recovery",
   "preemptive-compaction",
   "rules-injector",
@@ -22891,11 +22898,11 @@ var SkillDefinitionSchema = exports_external.object({
 var SkillEntrySchema = exports_external.union([exports_external.boolean(), SkillDefinitionSchema]);
 var SkillsConfigSchema = exports_external.union([
   exports_external.array(exports_external.string()),
-  exports_external.record(exports_external.string(), SkillEntrySchema).and(exports_external.object({
+  exports_external.object({
     sources: exports_external.array(SkillSourceSchema).optional(),
     enable: exports_external.array(exports_external.string()).optional(),
     disable: exports_external.array(exports_external.string()).optional()
-  }).partial())
+  }).catchall(SkillEntrySchema)
 ]);
 
 // src/config/schema/sisyphus.ts
@@ -22970,6 +22977,32 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
 });
 // src/plugin-config.ts
 init_shared();
+function parseConfigPartially(rawConfig) {
+  const fullResult = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
+  if (fullResult.success) {
+    return fullResult.data;
+  }
+  const partialConfig = {};
+  const invalidSections = [];
+  for (const key of Object.keys(rawConfig)) {
+    const sectionResult = OhMyOpenCodeConfigSchema.safeParse({ [key]: rawConfig[key] });
+    if (sectionResult.success) {
+      const parsed = sectionResult.data;
+      if (parsed[key] !== undefined) {
+        partialConfig[key] = parsed[key];
+      }
+    } else {
+      const sectionErrors = sectionResult.error.issues.filter((i2) => i2.path[0] === key).map((i2) => `${i2.path.join(".")}: ${i2.message}`).join(", ");
+      if (sectionErrors) {
+        invalidSections.push(`${key}: ${sectionErrors}`);
+      }
+    }
+  }
+  if (invalidSections.length > 0) {
+    log("Partial config loaded \u2014 invalid sections skipped:", invalidSections);
+  }
+  return partialConfig;
+}
 function loadConfigFromPath(configPath, ctx) {
   try {
     if (fs3.existsSync(configPath)) {
@@ -22977,17 +23010,22 @@ function loadConfigFromPath(configPath, ctx) {
       const rawConfig = parseJsonc(content);
       migrateConfigFile(configPath, rawConfig);
       const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
-      if (!result.success) {
-        const errorMsg = result.error.issues.map((i2) => `${i2.path.join(".")}: ${i2.message}`).join(", ");
-        log(`Config validation error in ${configPath}:`, result.error.issues);
-        addConfigLoadError({
-          path: configPath,
-          error: `Validation error: ${errorMsg}`
-        });
-        return null;
+      if (result.success) {
+        log(`Config loaded from ${configPath}`, { agents: result.data.agents });
+        return result.data;
+      }
+      const errorMsg = result.error.issues.map((i2) => `${i2.path.join(".")}: ${i2.message}`).join(", ");
+      log(`Config validation error in ${configPath}:`, result.error.issues);
+      addConfigLoadError({
+        path: configPath,
+        error: `Partial config loaded \u2014 invalid sections skipped: ${errorMsg}`
+      });
+      const partialResult = parseConfigPartially(rawConfig);
+      if (partialResult) {
+        log(`Partial config loaded from ${configPath}`, { agents: partialResult.agents });
+        return partialResult;
       }
-      log(`Config loaded from ${configPath}`, { agents: result.data.agents });
-      return result.data;
+      return null;
     }
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
@@ -24752,11 +24790,14 @@ async function areAllDescendantsIdle(ctx, sessionID, allStatuses) {
 var DEFAULT_POLL_INTERVAL_MS = 500;
 var DEFAULT_REQUIRED_CONSECUTIVE = 3;
 var ERROR_GRACE_CYCLES = 3;
+var MIN_STABILIZATION_MS = 1e4;
 async function pollForCompletion(ctx, eventState, abortController, options = {}) {
   const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
   const requiredConsecutive = options.requiredConsecutive ?? DEFAULT_REQUIRED_CONSECUTIVE;
+  const minStabilizationMs = options.minStabilizationMs ?? MIN_STABILIZATION_MS;
   let consecutiveCompleteChecks = 0;
   let errorCycleCount = 0;
+  let firstWorkTimestamp = null;
   while (!abortController.signal.aborted) {
     await new Promise((resolve2) => setTimeout(resolve2, pollIntervalMs));
     if (eventState.mainSessionError) {
@@ -24784,6 +24825,13 @@ Session ended with error: ${eventState.lastError}`));
       consecutiveCompleteChecks = 0;
       continue;
     }
+    if (firstWorkTimestamp === null) {
+      firstWorkTimestamp = Date.now();
+    }
+    if (Date.now() - firstWorkTimestamp < minStabilizationMs) {
+      consecutiveCompleteChecks = 0;
+      continue;
+    }
     const shouldExit = await checkCompletionConditions(ctx);
     if (shouldExit) {
       consecutiveCompleteChecks++;
@@ -24802,6 +24850,16 @@ All tasks completed.`));
 
 // src/cli/run/runner.ts
 var DEFAULT_TIMEOUT_MS = 600000;
+var EVENT_PROCESSOR_SHUTDOWN_TIMEOUT_MS = 2000;
+async function waitForEventProcessorShutdown(eventProcessor, timeoutMs = EVENT_PROCESSOR_SHUTDOWN_TIMEOUT_MS) {
+  const completed = await Promise.race([
+    eventProcessor.then(() => true),
+    new Promise((resolve2) => setTimeout(() => resolve2(false), timeoutMs))
+  ]);
+  if (!completed) {
+    console.log(import_picocolors14.default.dim(`[run] Event stream did not close within ${timeoutMs}ms after abort; continuing shutdown.`));
+  }
+}
 async function run(options) {
   process.env.OPENCODE_CLI_RUN_MODE = "true";
   const startTime = Date.now();
@@ -24848,7 +24906,7 @@ Interrupted. Shutting down...`));
       });
       console.log(import_picocolors14.default.dim(`Session: ${sessionID}`));
       const ctx = { client: client3, sessionID, directory, abortController };
-      const events = await client3.event.subscribe();
+      const events = await client3.event.subscribe({ query: { directory } });
       const eventState = createEventState();
       const eventProcessor = processEvents(ctx, events.stream, eventState).catch(() => {});
       console.log(import_picocolors14.default.dim(`
@@ -24865,7 +24923,7 @@ Sending prompt...`));
 `));
       const exitCode = await pollForCompletion(ctx, eventState, abortController);
       abortController.abort();
-      await eventProcessor;
+      await waitForEventProcessorShutdown(eventProcessor);
       cleanup();
       const durationMs = Date.now() - startTime;
       if (options.onComplete) {
@@ -25052,11 +25110,6 @@ async function getLocalVersion(options = {}) {
     return 1;
   }
 }
-// src/cli/doctor/checks/opencode.ts
-import { existsSync as existsSync16 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join12 } from "path";
-
 // src/cli/doctor/constants.ts
 var import_picocolors16 = __toESM(require_picocolors(), 1);
 var SYMBOLS3 = {
@@ -25075,48 +25128,16 @@ var STATUS_COLORS = {
   skip: import_picocolors16.default.dim
 };
 var CHECK_IDS = {
-  OPENCODE_INSTALLATION: "opencode-installation",
-  PLUGIN_REGISTRATION: "plugin-registration",
-  CONFIG_VALIDATION: "config-validation",
-  MODEL_RESOLUTION: "model-resolution",
-  AUTH_ANTHROPIC: "auth-anthropic",
-  AUTH_OPENAI: "auth-openai",
-  AUTH_GOOGLE: "auth-google",
-  DEP_AST_GREP_CLI: "dep-ast-grep-cli",
-  DEP_AST_GREP_NAPI: "dep-ast-grep-napi",
-  DEP_COMMENT_CHECKER: "dep-comment-checker",
-  GH_CLI: "gh-cli",
-  LSP_SERVERS: "lsp-servers",
-  MCP_BUILTIN: "mcp-builtin",
-  MCP_USER: "mcp-user",
-  MCP_OAUTH_TOKENS: "mcp-oauth-tokens",
-  VERSION_STATUS: "version-status"
+  SYSTEM: "system",
+  CONFIG: "config",
+  TOOLS: "tools",
+  MODELS: "models"
 };
 var CHECK_NAMES = {
-  [CHECK_IDS.OPENCODE_INSTALLATION]: "OpenCode Installation",
-  [CHECK_IDS.PLUGIN_REGISTRATION]: "Plugin Registration",
-  [CHECK_IDS.CONFIG_VALIDATION]: "Configuration Validity",
-  [CHECK_IDS.MODEL_RESOLUTION]: "Model Resolution",
-  [CHECK_IDS.AUTH_ANTHROPIC]: "Anthropic (Claude) Auth",
-  [CHECK_IDS.AUTH_OPENAI]: "OpenAI (ChatGPT) Auth",
-  [CHECK_IDS.AUTH_GOOGLE]: "Google (Gemini) Auth",
-  [CHECK_IDS.DEP_AST_GREP_CLI]: "AST-Grep CLI",
-  [CHECK_IDS.DEP_AST_GREP_NAPI]: "AST-Grep NAPI",
-  [CHECK_IDS.DEP_COMMENT_CHECKER]: "Comment Checker",
-  [CHECK_IDS.GH_CLI]: "GitHub CLI",
-  [CHECK_IDS.LSP_SERVERS]: "LSP Servers",
-  [CHECK_IDS.MCP_BUILTIN]: "Built-in MCP Servers",
-  [CHECK_IDS.MCP_USER]: "User MCP Configuration",
-  [CHECK_IDS.MCP_OAUTH_TOKENS]: "MCP OAuth Tokens",
-  [CHECK_IDS.VERSION_STATUS]: "Version Status"
-};
-var CATEGORY_NAMES = {
-  installation: "Installation",
-  configuration: "Configuration",
-  authentication: "Authentication",
-  dependencies: "Dependencies",
-  tools: "Tools & Servers",
-  updates: "Updates"
+  [CHECK_IDS.SYSTEM]: "System",
+  [CHECK_IDS.CONFIG]: "Configuration",
+  [CHECK_IDS.TOOLS]: "Tools",
+  [CHECK_IDS.MODELS]: "Models"
 };
 var EXIT_CODES = {
   SUCCESS: 0,
@@ -25126,7 +25147,13 @@ var MIN_OPENCODE_VERSION = "1.0.150";
 var PACKAGE_NAME4 = "oh-my-opencode";
 var OPENCODE_BINARIES2 = ["opencode", "opencode-desktop"];
 
-// src/cli/doctor/checks/opencode.ts
+// src/cli/doctor/checks/system.ts
+import { existsSync as existsSync19, readFileSync as readFileSync20 } from "fs";
+
+// src/cli/doctor/checks/system-binary.ts
+import { existsSync as existsSync16 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join12 } from "path";
 function getDesktopAppPaths(platform) {
   const home = homedir5();
   switch (platform) {
@@ -25160,21 +25187,12 @@ function getDesktopAppPaths(platform) {
 }
 function buildVersionCommand(binaryPath, platform) {
   if (platform === "win32" && binaryPath.toLowerCase().endsWith(".ps1")) {
-    return [
-      "powershell",
-      "-NoProfile",
-      "-ExecutionPolicy",
-      "Bypass",
-      "-File",
-      binaryPath,
-      "--version"
-    ];
+    return ["powershell", "-NoProfile", "-ExecutionPolicy", "Bypass", "-File", binaryPath, "--version"];
   }
   return [binaryPath, "--version"];
 }
 function findDesktopBinary(platform = process.platform, checkExists = existsSync16) {
-  const desktopPaths = getDesktopAppPaths(platform);
-  for (const desktopPath of desktopPaths) {
+  for (const desktopPath of getDesktopAppPaths(platform)) {
     if (checkExists(desktopPath)) {
       return { binary: "opencode", path: desktopPath };
     }
@@ -25183,346 +25201,312 @@ function findDesktopBinary(platform = process.platform, checkExists = existsSync
 }
 async function findOpenCodeBinary() {
   for (const binary2 of OPENCODE_BINARIES2) {
-    try {
-      const path9 = Bun.which(binary2);
-      if (path9) {
-        return { binary: binary2, path: path9 };
-      }
-    } catch {
-      continue;
+    const path9 = Bun.which(binary2);
+    if (path9) {
+      return { binary: binary2, path: path9 };
     }
   }
-  const desktopResult = findDesktopBinary();
-  if (desktopResult) {
-    return desktopResult;
-  }
-  return null;
+  return findDesktopBinary();
 }
 async function getOpenCodeVersion2(binaryPath, platform = process.platform) {
   try {
     const command = buildVersionCommand(binaryPath, platform);
-    const proc = Bun.spawn(command, { stdout: "pipe", stderr: "pipe" });
-    const output = await new Response(proc.stdout).text();
-    await proc.exited;
-    if (proc.exitCode === 0) {
-      return output.trim();
-    }
+    const processResult = Bun.spawn(command, { stdout: "pipe", stderr: "pipe" });
+    const output = await new Response(processResult.stdout).text();
+    await processResult.exited;
+    if (processResult.exitCode !== 0)
+      return null;
+    return output.trim() || null;
   } catch {
     return null;
   }
-  return null;
 }
 function compareVersions(current, minimum) {
-  const parseVersion = (v) => {
-    const cleaned = v.replace(/^v/, "").split("-")[0];
-    return cleaned.split(".").map((n) => parseInt(n, 10) || 0);
-  };
-  const curr = parseVersion(current);
-  const min = parseVersion(minimum);
-  for (let i2 = 0;i2 < Math.max(curr.length, min.length); i2++) {
-    const c = curr[i2] ?? 0;
-    const m2 = min[i2] ?? 0;
-    if (c > m2)
+  const parseVersion = (version2) => version2.replace(/^v/, "").split("-")[0].split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const currentParts = parseVersion(current);
+  const minimumParts = parseVersion(minimum);
+  const length = Math.max(currentParts.length, minimumParts.length);
+  for (let index = 0;index < length; index++) {
+    const currentPart = currentParts[index] ?? 0;
+    const minimumPart = minimumParts[index] ?? 0;
+    if (currentPart > minimumPart)
       return true;
-    if (c < m2)
+    if (currentPart < minimumPart)
       return false;
   }
   return true;
 }
-async function getOpenCodeInfo() {
-  const binaryInfo = await findOpenCodeBinary();
-  if (!binaryInfo) {
-    return {
-      installed: false,
-      version: null,
-      path: null,
-      binary: null
-    };
-  }
-  const version2 = await getOpenCodeVersion2(binaryInfo.path ?? binaryInfo.binary);
-  return {
-    installed: true,
-    version: version2,
-    path: binaryInfo.path,
-    binary: binaryInfo.binary
-  };
-}
-async function checkOpenCodeInstallation() {
-  const info = await getOpenCodeInfo();
-  if (!info.installed) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.OPENCODE_INSTALLATION],
-      status: "fail",
-      message: "OpenCode is not installed",
-      details: [
-        "Visit: https://opencode.ai/docs for installation instructions",
-        "Run: npm install -g opencode"
-      ]
-    };
-  }
-  if (info.version && !compareVersions(info.version, MIN_OPENCODE_VERSION)) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.OPENCODE_INSTALLATION],
-      status: "warn",
-      message: `Version ${info.version} is below minimum ${MIN_OPENCODE_VERSION}`,
-      details: [
-        `Current: ${info.version}`,
-        `Required: >= ${MIN_OPENCODE_VERSION}`,
-        "Run: npm update -g opencode"
-      ]
-    };
-  }
-  return {
-    name: CHECK_NAMES[CHECK_IDS.OPENCODE_INSTALLATION],
-    status: "pass",
-    message: info.version ?? "installed",
-    details: info.path ? [`Path: ${info.path}`] : undefined
-  };
-}
-function getOpenCodeCheckDefinition() {
-  return {
-    id: CHECK_IDS.OPENCODE_INSTALLATION,
-    name: CHECK_NAMES[CHECK_IDS.OPENCODE_INSTALLATION],
-    category: "installation",
-    check: checkOpenCodeInstallation,
-    critical: true
-  };
-}
 
-// src/cli/doctor/checks/plugin.ts
+// src/cli/doctor/checks/system-plugin.ts
 import { existsSync as existsSync17, readFileSync as readFileSync18 } from "fs";
 init_shared();
 function detectConfigPath() {
   const paths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
-  if (existsSync17(paths.configJsonc)) {
-    return { path: paths.configJsonc, format: "jsonc" };
-  }
-  if (existsSync17(paths.configJson)) {
-    return { path: paths.configJson, format: "json" };
-  }
+  if (existsSync17(paths.configJsonc))
+    return paths.configJsonc;
+  if (existsSync17(paths.configJson))
+    return paths.configJson;
   return null;
 }
-function findPluginEntry2(plugins) {
-  for (const plugin of plugins) {
-    if (plugin === PACKAGE_NAME4 || plugin.startsWith(`${PACKAGE_NAME4}@`)) {
-      const isPinned = plugin.includes("@");
-      const version2 = isPinned ? plugin.split("@")[1] : null;
-      return { entry: plugin, isPinned, version: version2 };
+function parsePluginVersion(entry) {
+  if (!entry.startsWith(`${PACKAGE_NAME4}@`))
+    return null;
+  const value = entry.slice(PACKAGE_NAME4.length + 1);
+  if (!value || value === "latest")
+    return null;
+  return value;
+}
+function findPluginEntry2(entries) {
+  for (const entry of entries) {
+    if (entry === PACKAGE_NAME4 || entry.startsWith(`${PACKAGE_NAME4}@`)) {
+      return { entry, isLocalDev: false };
     }
-    if (plugin.startsWith("file://") && plugin.includes(PACKAGE_NAME4)) {
-      return { entry: plugin, isPinned: false, version: "local-dev" };
+    if (entry.startsWith("file://") && entry.includes(PACKAGE_NAME4)) {
+      return { entry, isLocalDev: true };
     }
   }
   return null;
 }
 function getPluginInfo() {
-  const configInfo = detectConfigPath();
-  if (!configInfo) {
+  const configPath = detectConfigPath();
+  if (!configPath) {
     return {
       registered: false,
       configPath: null,
       entry: null,
       isPinned: false,
-      pinnedVersion: null
+      pinnedVersion: null,
+      isLocalDev: false
     };
   }
   try {
-    const content = readFileSync18(configInfo.path, "utf-8");
-    const config2 = parseJsonc(content);
-    const plugins = config2.plugin ?? [];
-    const pluginEntry = findPluginEntry2(plugins);
+    const content = readFileSync18(configPath, "utf-8");
+    const parsedConfig = parseJsonc(content);
+    const pluginEntry = findPluginEntry2(parsedConfig.plugin ?? []);
     if (!pluginEntry) {
       return {
         registered: false,
-        configPath: configInfo.path,
+        configPath,
         entry: null,
         isPinned: false,
-        pinnedVersion: null
+        pinnedVersion: null,
+        isLocalDev: false
       };
     }
+    const pinnedVersion = parsePluginVersion(pluginEntry.entry);
     return {
       registered: true,
-      configPath: configInfo.path,
+      configPath,
       entry: pluginEntry.entry,
-      isPinned: pluginEntry.isPinned,
-      pinnedVersion: pluginEntry.version
+      isPinned: pinnedVersion !== null,
+      pinnedVersion,
+      isLocalDev: pluginEntry.isLocalDev
     };
   } catch {
     return {
       registered: false,
-      configPath: configInfo.path,
+      configPath,
       entry: null,
       isPinned: false,
-      pinnedVersion: null
+      pinnedVersion: null,
+      isLocalDev: false
     };
   }
 }
-async function checkPluginRegistration() {
-  const info = getPluginInfo();
-  if (!info.configPath) {
-    const expectedPaths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
-    return {
-      name: CHECK_NAMES[CHECK_IDS.PLUGIN_REGISTRATION],
-      status: "fail",
-      message: "OpenCode config file not found",
-      details: [
-        "Run: bunx oh-my-opencode install",
-        `Expected: ${expectedPaths.configJson} or ${expectedPaths.configJsonc}`
-      ]
-    };
-  }
-  if (!info.registered) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.PLUGIN_REGISTRATION],
-      status: "fail",
-      message: "Plugin not registered in config",
-      details: [
-        "Run: bunx oh-my-opencode install",
-        `Config: ${info.configPath}`
-      ]
-    };
+
+// src/cli/doctor/checks/system-loaded-version.ts
+init_checker();
+init_auto_update_checker();
+import { existsSync as existsSync18, readFileSync as readFileSync19 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join13 } from "path";
+init_shared();
+function getPlatformDefaultCacheDir(platform = process.platform) {
+  if (platform === "darwin")
+    return join13(homedir6(), "Library", "Caches");
+  if (platform === "win32")
+    return process.env.LOCALAPPDATA ?? join13(homedir6(), "AppData", "Local");
+  return join13(homedir6(), ".cache");
+}
+function resolveOpenCodeCacheDir() {
+  const xdgCacheHome = process.env.XDG_CACHE_HOME;
+  if (xdgCacheHome)
+    return join13(xdgCacheHome, "opencode");
+  const fromShared = getOpenCodeCacheDir();
+  const platformDefault = join13(getPlatformDefaultCacheDir(), "opencode");
+  if (existsSync18(fromShared) || !existsSync18(platformDefault))
+    return fromShared;
+  return platformDefault;
+}
+function readPackageJson(filePath) {
+  if (!existsSync18(filePath))
+    return null;
+  try {
+    const content = readFileSync19(filePath, "utf-8");
+    return parseJsonc(content);
+  } catch {
+    return null;
   }
-  const message = info.isPinned ? `Registered (pinned: ${info.pinnedVersion})` : "Registered";
-  return {
-    name: CHECK_NAMES[CHECK_IDS.PLUGIN_REGISTRATION],
-    status: "pass",
-    message,
-    details: [`Config: ${info.configPath}`]
-  };
 }
-function getPluginCheckDefinition() {
+function normalizeVersion(value) {
+  if (!value)
+    return null;
+  const match = value.match(/\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/);
+  return match?.[0] ?? null;
+}
+function getLoadedPluginVersion() {
+  const cacheDir = resolveOpenCodeCacheDir();
+  const cachePackagePath = join13(cacheDir, "package.json");
+  const installedPackagePath = join13(cacheDir, "node_modules", PACKAGE_NAME4, "package.json");
+  const cachePackage = readPackageJson(cachePackagePath);
+  const installedPackage = readPackageJson(installedPackagePath);
+  const expectedVersion = normalizeVersion(cachePackage?.dependencies?.[PACKAGE_NAME4]);
+  const loadedVersion = normalizeVersion(installedPackage?.version);
   return {
-    id: CHECK_IDS.PLUGIN_REGISTRATION,
-    name: CHECK_NAMES[CHECK_IDS.PLUGIN_REGISTRATION],
-    category: "installation",
-    check: checkPluginRegistration,
-    critical: true
+    cacheDir,
+    cachePackagePath,
+    installedPackagePath,
+    expectedVersion,
+    loadedVersion
   };
 }
+async function getLatestPluginVersion(currentVersion) {
+  const channel = extractChannel(currentVersion);
+  return getLatestVersion(channel);
+}
 
-// src/cli/doctor/checks/config.ts
-import { existsSync as existsSync18, readFileSync as readFileSync19 } from "fs";
-import { join as join13 } from "path";
+// src/cli/doctor/checks/system.ts
 init_shared();
-var USER_CONFIG_DIR2 = getOpenCodeConfigDir({ binary: "opencode" });
-var USER_CONFIG_BASE = join13(USER_CONFIG_DIR2, `${PACKAGE_NAME4}`);
-var PROJECT_CONFIG_BASE = join13(process.cwd(), ".opencode", PACKAGE_NAME4);
-function findConfigPath() {
-  const projectDetected = detectConfigFile(PROJECT_CONFIG_BASE);
-  if (projectDetected.format !== "none") {
-    return { path: projectDetected.path, format: projectDetected.format };
-  }
-  const userDetected = detectConfigFile(USER_CONFIG_BASE);
-  if (userDetected.format !== "none") {
-    return { path: userDetected.path, format: userDetected.format };
-  }
-  return null;
-}
-function validateConfig(configPath) {
+function isConfigValid(configPath) {
+  if (!configPath)
+    return true;
+  if (!existsSync19(configPath))
+    return false;
   try {
-    const content = readFileSync19(configPath, "utf-8");
-    const rawConfig = parseJsonc(content);
-    const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
-    if (!result.success) {
-      const errors3 = result.error.issues.map((i2) => `${i2.path.join(".")}: ${i2.message}`);
-      return { valid: false, errors: errors3 };
-    }
-    return { valid: true, errors: [] };
-  } catch (err) {
-    return {
-      valid: false,
-      errors: [err instanceof Error ? err.message : "Failed to parse config"]
-    };
+    parseJsonc(readFileSync20(configPath, "utf-8"));
+    return true;
+  } catch {
+    return false;
   }
 }
-function getConfigInfo() {
-  const configPath = findConfigPath();
-  if (!configPath) {
-    return {
-      exists: false,
-      path: null,
-      format: null,
-      valid: true,
-      errors: []
-    };
+function getResultStatus(issues) {
+  if (issues.some((issue2) => issue2.severity === "error"))
+    return "fail";
+  if (issues.some((issue2) => issue2.severity === "warning"))
+    return "warn";
+  return "pass";
+}
+function buildMessage(status, issues) {
+  if (status === "pass")
+    return "System checks passed";
+  if (status === "fail")
+    return `${issues.length} system issue(s) detected`;
+  return `${issues.length} system warning(s) detected`;
+}
+async function gatherSystemInfo() {
+  const [binaryInfo, pluginInfo] = await Promise.all([findOpenCodeBinary(), Promise.resolve(getPluginInfo())]);
+  const loadedInfo = getLoadedPluginVersion();
+  const opencodeVersion = binaryInfo ? await getOpenCodeVersion2(binaryInfo.path) : null;
+  const pluginVersion = pluginInfo.pinnedVersion ?? loadedInfo.expectedVersion;
+  return {
+    opencodeVersion,
+    opencodePath: binaryInfo?.path ?? null,
+    pluginVersion,
+    loadedVersion: loadedInfo.loadedVersion,
+    bunVersion: Bun.version,
+    configPath: pluginInfo.configPath,
+    configValid: isConfigValid(pluginInfo.configPath),
+    isLocalDev: pluginInfo.isLocalDev
+  };
+}
+async function checkSystem() {
+  const [systemInfo, pluginInfo] = await Promise.all([gatherSystemInfo(), Promise.resolve(getPluginInfo())]);
+  const loadedInfo = getLoadedPluginVersion();
+  const latestVersion = await getLatestPluginVersion(systemInfo.loadedVersion);
+  const issues = [];
+  if (!systemInfo.opencodePath) {
+    issues.push({
+      title: "OpenCode binary not found",
+      description: "Install OpenCode CLI or desktop and ensure the binary is available.",
+      fix: "Install from https://opencode.ai/docs",
+      severity: "error",
+      affects: ["doctor", "run"]
+    });
   }
-  if (!existsSync18(configPath.path)) {
-    return {
-      exists: false,
-      path: configPath.path,
-      format: configPath.format,
-      valid: true,
-      errors: []
-    };
+  if (systemInfo.opencodeVersion && !compareVersions(systemInfo.opencodeVersion, MIN_OPENCODE_VERSION)) {
+    issues.push({
+      title: "OpenCode version below minimum",
+      description: `Detected ${systemInfo.opencodeVersion}; required >= ${MIN_OPENCODE_VERSION}.`,
+      fix: "Update OpenCode to the latest stable release",
+      severity: "warning",
+      affects: ["tooling", "doctor"]
+    });
   }
-  const validation = validateConfig(configPath.path);
-  return {
-    exists: true,
-    path: configPath.path,
-    format: configPath.format,
-    valid: validation.valid,
-    errors: validation.errors
-  };
-}
-async function checkConfigValidity() {
-  const info = getConfigInfo();
-  if (!info.exists) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.CONFIG_VALIDATION],
-      status: "pass",
-      message: "Using default configuration",
-      details: ["No custom config file found (optional)"]
-    };
+  if (!pluginInfo.registered) {
+    issues.push({
+      title: "oh-my-opencode is not registered",
+      description: "Plugin entry is missing from OpenCode configuration.",
+      fix: "Run: bunx oh-my-opencode install",
+      severity: "error",
+      affects: ["all agents"]
+    });
   }
-  if (!info.valid) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.CONFIG_VALIDATION],
-      status: "fail",
-      message: "Configuration has validation errors",
-      details: [
-        `Path: ${info.path}`,
-        ...info.errors.map((e2) => `Error: ${e2}`)
-      ]
-    };
+  if (loadedInfo.expectedVersion && loadedInfo.loadedVersion && loadedInfo.expectedVersion !== loadedInfo.loadedVersion) {
+    issues.push({
+      title: "Loaded plugin version mismatch",
+      description: `Cache expects ${loadedInfo.expectedVersion} but loaded ${loadedInfo.loadedVersion}.`,
+      fix: "Reinstall plugin dependencies in OpenCode cache",
+      severity: "warning",
+      affects: ["plugin loading"]
+    });
   }
+  if (systemInfo.loadedVersion && latestVersion && !compareVersions(systemInfo.loadedVersion, latestVersion)) {
+    issues.push({
+      title: "Loaded plugin is outdated",
+      description: `Loaded ${systemInfo.loadedVersion}, latest ${latestVersion}.`,
+      fix: "Update: cd ~/.config/opencode && bun update oh-my-opencode",
+      severity: "warning",
+      affects: ["plugin features"]
+    });
+  }
+  const status = getResultStatus(issues);
   return {
-    name: CHECK_NAMES[CHECK_IDS.CONFIG_VALIDATION],
-    status: "pass",
-    message: `Valid ${info.format?.toUpperCase()} config`,
-    details: [`Path: ${info.path}`]
-  };
-}
-function getConfigCheckDefinition() {
-  return {
-    id: CHECK_IDS.CONFIG_VALIDATION,
-    name: CHECK_NAMES[CHECK_IDS.CONFIG_VALIDATION],
-    category: "configuration",
-    check: checkConfigValidity,
-    critical: false
+    name: CHECK_NAMES[CHECK_IDS.SYSTEM],
+    status,
+    message: buildMessage(status, issues),
+    details: [
+      systemInfo.opencodeVersion ? `OpenCode: ${systemInfo.opencodeVersion}` : "OpenCode: not detected",
+      `Plugin expected: ${systemInfo.pluginVersion ?? "unknown"}`,
+      `Plugin loaded: ${systemInfo.loadedVersion ?? "unknown"}`,
+      `Bun: ${systemInfo.bunVersion ?? "unknown"}`
+    ],
+    issues
   };
 }
 
-// src/cli/doctor/checks/model-resolution.ts
-init_model_requirements();
+// src/cli/doctor/checks/config.ts
+import { readFileSync as readFileSync23 } from "fs";
+import { join as join17 } from "path";
+init_shared();
 
 // src/cli/doctor/checks/model-resolution-cache.ts
 init_shared();
-import { existsSync as existsSync19, readFileSync as readFileSync20 } from "fs";
-import { homedir as homedir6 } from "os";
+import { existsSync as existsSync20, readFileSync as readFileSync21 } from "fs";
+import { homedir as homedir7 } from "os";
 import { join as join14 } from "path";
 function getOpenCodeCacheDir2() {
   const xdgCache = process.env.XDG_CACHE_HOME;
   if (xdgCache)
     return join14(xdgCache, "opencode");
-  return join14(homedir6(), ".cache", "opencode");
+  return join14(homedir7(), ".cache", "opencode");
 }
 function loadAvailableModelsFromCache() {
   const cacheFile = join14(getOpenCodeCacheDir2(), "models.json");
-  if (!existsSync19(cacheFile)) {
+  if (!existsSync20(cacheFile)) {
     return { providers: [], modelCount: 0, cacheExists: false };
   }
   try {
-    const content = readFileSync20(cacheFile, "utf-8");
+    const content = readFileSync21(cacheFile, "utf-8");
     const data = parseJsonc(content);
     const providers = Object.keys(data);
     let modelCount = 0;
@@ -25538,27 +25522,30 @@ function loadAvailableModelsFromCache() {
   }
 }
 
+// src/cli/doctor/checks/model-resolution.ts
+init_model_requirements();
+
 // src/cli/doctor/checks/model-resolution-config.ts
 init_shared();
-import { readFileSync as readFileSync21 } from "fs";
+import { readFileSync as readFileSync22 } from "fs";
 import { join as join15 } from "path";
 var PACKAGE_NAME5 = "oh-my-opencode";
-var USER_CONFIG_BASE2 = join15(getOpenCodeConfigPaths({ binary: "opencode", version: null }).configDir, PACKAGE_NAME5);
-var PROJECT_CONFIG_BASE2 = join15(process.cwd(), ".opencode", PACKAGE_NAME5);
+var USER_CONFIG_BASE = join15(getOpenCodeConfigPaths({ binary: "opencode", version: null }).configDir, PACKAGE_NAME5);
+var PROJECT_CONFIG_BASE = join15(process.cwd(), ".opencode", PACKAGE_NAME5);
 function loadOmoConfig() {
-  const projectDetected = detectConfigFile(PROJECT_CONFIG_BASE2);
+  const projectDetected = detectConfigFile(PROJECT_CONFIG_BASE);
   if (projectDetected.format !== "none") {
     try {
-      const content = readFileSync21(projectDetected.path, "utf-8");
+      const content = readFileSync22(projectDetected.path, "utf-8");
       return parseJsonc(content);
     } catch {
       return null;
     }
   }
-  const userDetected = detectConfigFile(USER_CONFIG_BASE2);
+  const userDetected = detectConfigFile(USER_CONFIG_BASE);
   if (userDetected.format !== "none") {
     try {
-      const content = readFileSync21(userDetected.path, "utf-8");
+      const content = readFileSync22(userDetected.path, "utf-8");
       return parseJsonc(content);
     } catch {
       return null;
@@ -25567,31 +25554,6 @@ function loadOmoConfig() {
   return null;
 }
 
-// src/cli/doctor/checks/model-resolution-effective-model.ts
-function formatProviderChain(providers) {
-  return providers.join(" \u2192 ");
-}
-function getEffectiveModel(requirement, userOverride) {
-  if (userOverride) {
-    return userOverride;
-  }
-  const firstEntry = requirement.fallbackChain[0];
-  if (!firstEntry) {
-    return "unknown";
-  }
-  return `${firstEntry.providers[0]}/${firstEntry.model}`;
-}
-function buildEffectiveResolution(requirement, userOverride) {
-  if (userOverride) {
-    return `User override: ${userOverride}`;
-  }
-  const firstEntry = requirement.fallbackChain[0];
-  if (!firstEntry) {
-    return "No fallback chain defined";
-  }
-  return `Provider fallback: ${formatProviderChain(firstEntry.providers)} \u2192 ${firstEntry.model}`;
-}
-
 // src/cli/doctor/checks/model-resolution-details.ts
 init_shared();
 import { join as join16 } from "path";
@@ -25667,6 +25629,31 @@ function buildModelResolutionDetails(options) {
   return details;
 }
 
+// src/cli/doctor/checks/model-resolution-effective-model.ts
+function formatProviderChain(providers) {
+  return providers.join(" \u2192 ");
+}
+function getEffectiveModel(requirement, userOverride) {
+  if (userOverride) {
+    return userOverride;
+  }
+  const firstEntry = requirement.fallbackChain[0];
+  if (!firstEntry) {
+    return "unknown";
+  }
+  return `${firstEntry.providers[0]}/${firstEntry.model}`;
+}
+function buildEffectiveResolution(requirement, userOverride) {
+  if (userOverride) {
+    return `User override: ${userOverride}`;
+  }
+  const firstEntry = requirement.fallbackChain[0];
+  if (!firstEntry) {
+    return "No fallback chain defined";
+  }
+  return `Provider fallback: ${formatProviderChain(firstEntry.providers)} \u2192 ${firstEntry.model}`;
+}
+
 // src/cli/doctor/checks/model-resolution.ts
 function getModelResolutionInfoWithOverrides(config2) {
   const agents = Object.entries(AGENT_MODEL_REQUIREMENTS).map(([name, requirement]) => {
@@ -25695,134 +25682,154 @@ function getModelResolutionInfoWithOverrides(config2) {
   });
   return { agents, categories: categories2 };
 }
-async function checkModelResolution() {
+async function checkModels() {
   const config2 = loadOmoConfig() ?? {};
   const info = getModelResolutionInfoWithOverrides(config2);
   const available = loadAvailableModelsFromCache();
-  const agentCount = info.agents.length;
-  const categoryCount = info.categories.length;
-  const agentOverrides = info.agents.filter((a) => a.userOverride).length;
-  const categoryOverrides = info.categories.filter((c) => c.userOverride).length;
-  const totalOverrides = agentOverrides + categoryOverrides;
-  const overrideNote = totalOverrides > 0 ? ` (${totalOverrides} override${totalOverrides > 1 ? "s" : ""})` : "";
-  const cacheNote = available.cacheExists ? `, ${available.modelCount} available` : ", cache not found";
-  return {
-    name: CHECK_NAMES[CHECK_IDS.MODEL_RESOLUTION],
-    status: available.cacheExists ? "pass" : "warn",
-    message: `${agentCount} agents, ${categoryCount} categories${overrideNote}${cacheNote}`,
-    details: buildModelResolutionDetails({ info, available, config: config2 })
-  };
-}
-function getModelResolutionCheckDefinition() {
+  const issues = [];
+  if (!available.cacheExists) {
+    issues.push({
+      title: "Model cache not found",
+      description: "OpenCode model cache is missing, so model availability cannot be validated.",
+      fix: "Run: opencode models --refresh",
+      severity: "warning",
+      affects: ["model resolution"]
+    });
+  }
+  const overrideCount = info.agents.filter((agent) => Boolean(agent.userOverride)).length + info.categories.filter((category) => Boolean(category.userOverride)).length;
   return {
-    id: CHECK_IDS.MODEL_RESOLUTION,
-    name: CHECK_NAMES[CHECK_IDS.MODEL_RESOLUTION],
-    category: "configuration",
-    check: checkModelResolution,
-    critical: false
+    name: CHECK_NAMES[CHECK_IDS.MODELS],
+    status: issues.length > 0 ? "warn" : "pass",
+    message: `${info.agents.length} agents, ${info.categories.length} categories, ${overrideCount} override${overrideCount === 1 ? "" : "s"}`,
+    details: buildModelResolutionDetails({ info, available, config: config2 }),
+    issues
   };
 }
 
-// src/cli/doctor/checks/auth.ts
-import { existsSync as existsSync20, readFileSync as readFileSync22 } from "fs";
-import { join as join17 } from "path";
-init_shared();
-var OPENCODE_CONFIG_DIR = getOpenCodeConfigDir({ binary: "opencode" });
-var OPENCODE_JSON = join17(OPENCODE_CONFIG_DIR, "opencode.json");
-var OPENCODE_JSONC = join17(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 = existsSync20(OPENCODE_JSONC) ? OPENCODE_JSONC : OPENCODE_JSON;
-  if (!existsSync20(configPath))
-    return null;
-  try {
-    const content = readFileSync22(configPath, "utf-8");
-    return parseJsonc(content);
-  } catch {
-    return null;
-  }
-}
-function isPluginInstalled(plugins, pluginName) {
-  if (pluginName === "builtin")
-    return true;
-  return plugins.some((p2) => p2 === pluginName || p2.startsWith(`${pluginName}@`));
-}
-function getAuthProviderInfo(providerId) {
-  const config2 = getOpenCodeConfig();
-  const plugins = config2?.plugin ?? [];
-  const authConfig = AUTH_PLUGINS[providerId];
-  const pluginInstalled = isPluginInstalled(plugins, authConfig.plugin);
-  return {
-    id: providerId,
-    name: authConfig.name,
-    pluginInstalled,
-    configured: pluginInstalled
-  };
+// src/cli/doctor/checks/config.ts
+var USER_CONFIG_BASE2 = join17(getOpenCodeConfigDir({ binary: "opencode" }), PACKAGE_NAME4);
+var PROJECT_CONFIG_BASE2 = join17(process.cwd(), ".opencode", PACKAGE_NAME4);
+function findConfigPath() {
+  const projectConfig = detectConfigFile(PROJECT_CONFIG_BASE2);
+  if (projectConfig.format !== "none")
+    return projectConfig.path;
+  const userConfig = detectConfigFile(USER_CONFIG_BASE2);
+  if (userConfig.format !== "none")
+    return userConfig.path;
+  return null;
 }
-async function checkAuthProvider(providerId) {
-  const info = getAuthProviderInfo(providerId);
-  const checkId = `auth-${providerId}`;
-  const checkName = CHECK_NAMES[checkId] || info.name;
-  if (!info.pluginInstalled) {
+function validateConfig() {
+  const configPath = findConfigPath();
+  if (!configPath) {
+    return { exists: false, path: null, valid: true, config: null, errors: [] };
+  }
+  try {
+    const content = readFileSync23(configPath, "utf-8");
+    const rawConfig = parseJsonc(content);
+    const schemaResult = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
+    if (!schemaResult.success) {
+      return {
+        exists: true,
+        path: configPath,
+        valid: false,
+        config: rawConfig,
+        errors: schemaResult.error.issues.map((issue2) => `${issue2.path.join(".")}: ${issue2.message}`)
+      };
+    }
+    return { exists: true, path: configPath, valid: true, config: rawConfig, errors: [] };
+  } catch (error45) {
     return {
-      name: checkName,
-      status: "skip",
-      message: "Auth plugin not installed",
-      details: [
-        `Plugin: ${AUTH_PLUGINS[providerId].plugin}`,
-        "Run: bunx oh-my-opencode install"
-      ]
+      exists: true,
+      path: configPath,
+      valid: false,
+      config: null,
+      errors: [error45 instanceof Error ? error45.message : "Failed to parse config"]
     };
   }
-  return {
-    name: checkName,
-    status: "pass",
-    message: "Auth plugin available",
-    details: [
-      providerId === "anthropic" ? "Run: opencode auth login (select Anthropic)" : `Plugin: ${AUTH_PLUGINS[providerId].plugin}`
-    ]
-  };
-}
-async function checkAnthropicAuth() {
-  return checkAuthProvider("anthropic");
-}
-async function checkOpenAIAuth() {
-  return checkAuthProvider("openai");
-}
-async function checkGoogleAuth() {
-  return checkAuthProvider("google");
 }
-function getAuthCheckDefinitions() {
-  return [
-    {
-      id: CHECK_IDS.AUTH_ANTHROPIC,
-      name: CHECK_NAMES[CHECK_IDS.AUTH_ANTHROPIC],
-      category: "authentication",
-      check: checkAnthropicAuth,
-      critical: false
-    },
-    {
-      id: CHECK_IDS.AUTH_OPENAI,
-      name: CHECK_NAMES[CHECK_IDS.AUTH_OPENAI],
-      category: "authentication",
-      check: checkOpenAIAuth,
-      critical: false
-    },
-    {
-      id: CHECK_IDS.AUTH_GOOGLE,
-      name: CHECK_NAMES[CHECK_IDS.AUTH_GOOGLE],
-      category: "authentication",
-      check: checkGoogleAuth,
-      critical: false
+function collectModelResolutionIssues(config2) {
+  const issues = [];
+  const availableModels = loadAvailableModelsFromCache();
+  const resolution = getModelResolutionInfoWithOverrides(config2);
+  const invalidAgentOverrides = resolution.agents.filter((agent) => agent.userOverride && !agent.userOverride.includes("/"));
+  const invalidCategoryOverrides = resolution.categories.filter((category) => category.userOverride && !category.userOverride.includes("/"));
+  for (const invalidAgent of invalidAgentOverrides) {
+    issues.push({
+      title: `Invalid agent override: ${invalidAgent.name}`,
+      description: `Override '${invalidAgent.userOverride}' must be in provider/model format.`,
+      severity: "warning",
+      affects: [invalidAgent.name]
+    });
+  }
+  for (const invalidCategory of invalidCategoryOverrides) {
+    issues.push({
+      title: `Invalid category override: ${invalidCategory.name}`,
+      description: `Override '${invalidCategory.userOverride}' must be in provider/model format.`,
+      severity: "warning",
+      affects: [invalidCategory.name]
+    });
+  }
+  if (availableModels.cacheExists) {
+    const providerSet = new Set(availableModels.providers);
+    const unknownProviders = [
+      ...resolution.agents.map((agent) => agent.userOverride),
+      ...resolution.categories.map((category) => category.userOverride)
+    ].filter((value) => Boolean(value)).map((value) => value.split("/")[0]).filter((provider) => provider.length > 0 && !providerSet.has(provider));
+    if (unknownProviders.length > 0) {
+      const uniqueProviders = [...new Set(unknownProviders)];
+      issues.push({
+        title: "Model override uses unavailable provider",
+        description: `Provider(s) not found in OpenCode model cache: ${uniqueProviders.join(", ")}`,
+        severity: "warning",
+        affects: ["model resolution"]
+      });
     }
-  ];
+  }
+  return issues;
+}
+async function checkConfig() {
+  const validation = validateConfig();
+  const issues = [];
+  if (!validation.exists) {
+    return {
+      name: CHECK_NAMES[CHECK_IDS.CONFIG],
+      status: "pass",
+      message: "No custom config found; defaults are used",
+      details: undefined,
+      issues
+    };
+  }
+  if (!validation.valid) {
+    issues.push(...validation.errors.map((error45) => ({
+      title: "Invalid configuration",
+      description: error45,
+      severity: "error",
+      affects: ["plugin startup"]
+    })));
+    return {
+      name: CHECK_NAMES[CHECK_IDS.CONFIG],
+      status: "fail",
+      message: `Configuration invalid (${issues.length} issue${issues.length > 1 ? "s" : ""})`,
+      details: validation.path ? [`Path: ${validation.path}`] : undefined,
+      issues
+    };
+  }
+  if (validation.config) {
+    issues.push(...collectModelResolutionIssues(validation.config));
+  }
+  return {
+    name: CHECK_NAMES[CHECK_IDS.CONFIG],
+    status: issues.length > 0 ? "warn" : "pass",
+    message: issues.length > 0 ? `${issues.length} configuration warning(s)` : "Configuration is valid",
+    details: validation.path ? [`Path: ${validation.path}`] : undefined,
+    issues
+  };
 }
 
 // src/cli/doctor/checks/dependencies.ts
+import { existsSync as existsSync21 } from "fs";
+import { createRequire } from "module";
+import { dirname as dirname3, join as join18 } from "path";
 async function checkBinaryExists(binary2) {
   try {
     const path9 = Bun.which(binary2);
@@ -25878,15 +25885,15 @@ async function checkAstGrepNapi() {
       path: null
     };
   } catch {
-    const { existsSync: existsSync21 } = await import("fs");
-    const { join: join18 } = await import("path");
-    const { homedir: homedir7 } = await import("os");
+    const { existsSync: existsSync22 } = await import("fs");
+    const { join: join19 } = await import("path");
+    const { homedir: homedir8 } = await import("os");
     const pathsToCheck = [
-      join18(homedir7(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
-      join18(process.cwd(), "node_modules", "@ast-grep", "napi")
+      join19(homedir8(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
+      join19(process.cwd(), "node_modules", "@ast-grep", "napi")
     ];
     for (const napiPath of pathsToCheck) {
-      if (existsSync21(napiPath)) {
+      if (existsSync22(napiPath)) {
         return {
           name: "AST-Grep NAPI",
           required: false,
@@ -25906,9 +25913,21 @@ async function checkAstGrepNapi() {
     };
   }
 }
+function findCommentCheckerPackageBinary() {
+  const binaryName = process.platform === "win32" ? "comment-checker.exe" : "comment-checker";
+  try {
+    const require2 = createRequire(import.meta.url);
+    const pkgPath = require2.resolve("@code-yeongyu/comment-checker/package.json");
+    const binaryPath = join18(dirname3(pkgPath), "bin", binaryName);
+    if (existsSync21(binaryPath))
+      return binaryPath;
+  } catch {}
+  return null;
+}
 async function checkCommentChecker() {
   const binaryCheck = await checkBinaryExists("comment-checker");
-  if (!binaryCheck.exists) {
+  const resolvedPath = binaryCheck.exists ? binaryCheck.path : findCommentCheckerPackageBinary();
+  if (!resolvedPath) {
     return {
       name: "Comment Checker",
       required: false,
@@ -25918,112 +25937,59 @@ async function checkCommentChecker() {
       installHint: "Hook will be disabled if not available"
     };
   }
-  const version2 = await getBinaryVersion("comment-checker");
+  const version2 = await getBinaryVersion(resolvedPath);
   return {
     name: "Comment Checker",
     required: false,
     installed: true,
     version: version2,
-    path: binaryCheck.path
-  };
-}
-function dependencyToCheckResult(dep, checkName) {
-  if (dep.installed) {
-    return {
-      name: checkName,
-      status: "pass",
-      message: dep.version ?? "installed",
-      details: dep.path ? [`Path: ${dep.path}`] : undefined
-    };
-  }
-  return {
-    name: checkName,
-    status: "warn",
-    message: "Not installed (optional)",
-    details: dep.installHint ? [dep.installHint] : undefined
+    path: resolvedPath
   };
 }
-async function checkDependencyAstGrepCli() {
-  const info = await checkAstGrepCli();
-  return dependencyToCheckResult(info, CHECK_NAMES[CHECK_IDS.DEP_AST_GREP_CLI]);
-}
-async function checkDependencyAstGrepNapi() {
-  const info = await checkAstGrepNapi();
-  return dependencyToCheckResult(info, CHECK_NAMES[CHECK_IDS.DEP_AST_GREP_NAPI]);
-}
-async function checkDependencyCommentChecker() {
-  const info = await checkCommentChecker();
-  return dependencyToCheckResult(info, CHECK_NAMES[CHECK_IDS.DEP_COMMENT_CHECKER]);
-}
-function getDependencyCheckDefinitions() {
-  return [
-    {
-      id: CHECK_IDS.DEP_AST_GREP_CLI,
-      name: CHECK_NAMES[CHECK_IDS.DEP_AST_GREP_CLI],
-      category: "dependencies",
-      check: checkDependencyAstGrepCli,
-      critical: false
-    },
-    {
-      id: CHECK_IDS.DEP_AST_GREP_NAPI,
-      name: CHECK_NAMES[CHECK_IDS.DEP_AST_GREP_NAPI],
-      category: "dependencies",
-      check: checkDependencyAstGrepNapi,
-      critical: false
-    },
-    {
-      id: CHECK_IDS.DEP_COMMENT_CHECKER,
-      name: CHECK_NAMES[CHECK_IDS.DEP_COMMENT_CHECKER],
-      category: "dependencies",
-      check: checkDependencyCommentChecker,
-      critical: false
-    }
-  ];
-}
 
-// src/cli/doctor/checks/gh.ts
+// src/cli/doctor/checks/tools-gh.ts
 async function checkBinaryExists2(binary2) {
   try {
-    const whichCmd = process.platform === "win32" ? "where" : "which";
-    const proc = Bun.spawn([whichCmd, binary2], { stdout: "pipe", stderr: "pipe" });
-    const output = await new Response(proc.stdout).text();
-    await proc.exited;
-    if (proc.exitCode === 0) {
-      return { exists: true, path: output.trim() };
-    }
-  } catch {}
-  return { exists: false, path: null };
+    const binaryPath = Bun.which(binary2);
+    return { exists: Boolean(binaryPath), path: binaryPath ?? null };
+  } catch {
+    return { exists: false, path: null };
+  }
 }
 async function getGhVersion() {
   try {
-    const proc = Bun.spawn(["gh", "--version"], { stdout: "pipe", stderr: "pipe" });
-    const output = await new Response(proc.stdout).text();
-    await proc.exited;
-    if (proc.exitCode === 0) {
-      const match = output.match(/gh version (\S+)/);
-      return match?.[1] ?? output.trim().split(`
-`)[0];
-    }
-  } catch {}
-  return null;
+    const processResult = Bun.spawn(["gh", "--version"], { stdout: "pipe", stderr: "pipe" });
+    const output = await new Response(processResult.stdout).text();
+    await processResult.exited;
+    if (processResult.exitCode !== 0)
+      return null;
+    const matchedVersion = output.match(/gh version (\S+)/);
+    return matchedVersion?.[1] ?? output.trim().split(`
+`)[0] ?? null;
+  } catch {
+    return null;
+  }
 }
 async function getGhAuthStatus() {
   try {
-    const proc = Bun.spawn(["gh", "auth", "status"], {
+    const processResult = Bun.spawn(["gh", "auth", "status"], {
       stdout: "pipe",
       stderr: "pipe",
       env: { ...process.env, GH_NO_UPDATE_NOTIFIER: "1" }
     });
-    const stdout = await new Response(proc.stdout).text();
-    const stderr = await new Response(proc.stderr).text();
-    await proc.exited;
+    const stdout = await new Response(processResult.stdout).text();
+    const stderr = await new Response(processResult.stderr).text();
+    await processResult.exited;
     const output = stderr || stdout;
-    if (proc.exitCode === 0) {
+    if (processResult.exitCode === 0) {
       const usernameMatch = output.match(/Logged in to github\.com account (\S+)/);
-      const username = usernameMatch?.[1]?.replace(/[()]/g, "") ?? null;
       const scopesMatch = output.match(/Token scopes?:\s*(.+)/i);
-      const scopes = scopesMatch?.[1] ? scopesMatch[1].split(/,\s*/).map((s) => s.replace(/['"]/g, "").trim()).filter(Boolean) : [];
-      return { authenticated: true, username, scopes, error: null };
+      return {
+        authenticated: true,
+        username: usernameMatch?.[1]?.replace(/[()]/g, "") ?? null,
+        scopes: scopesMatch?.[1]?.split(/,\s*/).map((scope) => scope.trim()).filter(Boolean) ?? [],
+        error: null
+      };
     }
     const errorMatch = output.match(/error[:\s]+(.+)/i);
     return {
@@ -26032,18 +25998,18 @@ async function getGhAuthStatus() {
       scopes: [],
       error: errorMatch?.[1]?.trim() ?? "Not authenticated"
     };
-  } catch (err) {
+  } catch (error45) {
     return {
       authenticated: false,
       username: null,
       scopes: [],
-      error: err instanceof Error ? err.message : "Failed to check auth status"
+      error: error45 instanceof Error ? error45.message : "Failed to check auth status"
     };
   }
 }
 async function getGhCliInfo() {
-  const binaryCheck = await checkBinaryExists2("gh");
-  if (!binaryCheck.exists) {
+  const binaryStatus = await checkBinaryExists2("gh");
+  if (!binaryStatus.exists) {
     return {
       installed: false,
       version: null,
@@ -26058,76 +26024,27 @@ async function getGhCliInfo() {
   return {
     installed: true,
     version: version2,
-    path: binaryCheck.path,
+    path: binaryStatus.path,
     authenticated: authStatus.authenticated,
     username: authStatus.username,
     scopes: authStatus.scopes,
     error: authStatus.error
   };
 }
-async function checkGhCli() {
-  const info = await getGhCliInfo();
-  const name = CHECK_NAMES[CHECK_IDS.GH_CLI];
-  if (!info.installed) {
-    return {
-      name,
-      status: "warn",
-      message: "Not installed (optional)",
-      details: [
-        "GitHub CLI is used by librarian agent and scripts",
-        "Install: https://cli.github.com/"
-      ]
-    };
-  }
-  if (!info.authenticated) {
-    return {
-      name,
-      status: "warn",
-      message: `${info.version ?? "installed"} - not authenticated`,
-      details: [
-        info.path ? `Path: ${info.path}` : null,
-        "Authenticate: gh auth login",
-        info.error ? `Error: ${info.error}` : null
-      ].filter((d3) => d3 !== null)
-    };
-  }
-  const details = [];
-  if (info.path)
-    details.push(`Path: ${info.path}`);
-  if (info.username)
-    details.push(`Account: ${info.username}`);
-  if (info.scopes.length > 0)
-    details.push(`Scopes: ${info.scopes.join(", ")}`);
-  return {
-    name,
-    status: "pass",
-    message: `${info.version ?? "installed"} - authenticated as ${info.username ?? "unknown"}`,
-    details: details.length > 0 ? details : undefined
-  };
-}
-function getGhCliCheckDefinition() {
-  return {
-    id: CHECK_IDS.GH_CLI,
-    name: CHECK_NAMES[CHECK_IDS.GH_CLI],
-    category: "tools",
-    check: checkGhCli,
-    critical: false
-  };
-}
 // src/tools/lsp/server-config-loader.ts
 init_shared();
 init_jsonc_parser();
 
 // src/tools/lsp/server-installation.ts
 init_shared();
-import { existsSync as existsSync21 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync22 } from "fs";
+import { join as join19 } from "path";
 function isServerInstalled(command) {
   if (command.length === 0)
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync21(cmd))
+    if (existsSync22(cmd))
       return true;
   }
   const isWindows = process.platform === "win32";
@@ -26149,23 +26066,23 @@ function isServerInstalled(command) {
   const paths = pathEnv.split(pathSeparator);
   for (const p2 of paths) {
     for (const suffix of exts) {
-      if (existsSync21(join18(p2, cmd + suffix))) {
+      if (existsSync22(join19(p2, cmd + suffix))) {
         return true;
       }
     }
   }
   const cwd = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join18(getDataDir(), "opencode");
+  const dataDir = join19(getDataDir(), "opencode");
   const additionalBases = [
-    join18(cwd, "node_modules", ".bin"),
-    join18(configDir, "bin"),
-    join18(configDir, "node_modules", ".bin"),
-    join18(dataDir, "bin")
+    join19(cwd, "node_modules", ".bin"),
+    join19(configDir, "bin"),
+    join19(configDir, "node_modules", ".bin"),
+    join19(dataDir, "bin")
   ];
   for (const base of additionalBases) {
     for (const suffix of exts) {
-      if (existsSync21(join18(base, cmd + suffix))) {
+      if (existsSync22(join19(base, cmd + suffix))) {
         return true;
       }
     }
@@ -26175,180 +26092,454 @@ function isServerInstalled(command) {
   }
   return false;
 }
-// src/cli/doctor/checks/lsp.ts
+// src/cli/doctor/checks/tools-lsp.ts
 var DEFAULT_LSP_SERVERS = [
   { id: "typescript-language-server", binary: "typescript-language-server", extensions: [".ts", ".tsx", ".js", ".jsx"] },
   { id: "pyright", binary: "pyright-langserver", extensions: [".py"] },
   { id: "rust-analyzer", binary: "rust-analyzer", extensions: [".rs"] },
   { id: "gopls", binary: "gopls", extensions: [".go"] }
 ];
-async function getLspServersInfo() {
-  const servers = [];
-  for (const server2 of DEFAULT_LSP_SERVERS) {
-    const installed = isServerInstalled([server2.binary]);
-    servers.push({
-      id: server2.id,
-      installed,
-      extensions: server2.extensions,
-      source: "builtin"
-    });
-  }
-  return servers;
+function getLspServersInfo() {
+  return DEFAULT_LSP_SERVERS.map((server2) => ({
+    id: server2.id,
+    installed: isServerInstalled([server2.binary]),
+    extensions: server2.extensions,
+    source: "builtin"
+  }));
 }
 function getLspServerStats(servers) {
-  const installed = servers.filter((s) => s.installed).length;
-  return { installed, total: servers.length };
-}
-async function checkLspServers() {
-  const servers = await getLspServersInfo();
-  const stats = getLspServerStats(servers);
-  const installedServers = servers.filter((s) => s.installed);
-  const missingServers = servers.filter((s) => !s.installed);
-  if (stats.installed === 0) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.LSP_SERVERS],
-      status: "warn",
-      message: "No LSP servers detected",
-      details: [
-        "LSP tools will have limited functionality",
-        ...missingServers.map((s) => `Missing: ${s.id}`)
-      ]
-    };
-  }
-  const details = [
-    ...installedServers.map((s) => `Installed: ${s.id}`),
-    ...missingServers.map((s) => `Not found: ${s.id} (optional)`)
-  ];
-  return {
-    name: CHECK_NAMES[CHECK_IDS.LSP_SERVERS],
-    status: "pass",
-    message: `${stats.installed}/${stats.total} servers available`,
-    details
-  };
-}
-function getLspCheckDefinition() {
   return {
-    id: CHECK_IDS.LSP_SERVERS,
-    name: CHECK_NAMES[CHECK_IDS.LSP_SERVERS],
-    category: "tools",
-    check: checkLspServers,
-    critical: false
+    installed: servers.filter((server2) => server2.installed).length,
+    total: servers.length
   };
 }
 
-// src/cli/doctor/checks/mcp.ts
-import { existsSync as existsSync22, readFileSync as readFileSync23 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join19 } from "path";
+// src/cli/doctor/checks/tools-mcp.ts
 init_shared();
+import { existsSync as existsSync23, readFileSync as readFileSync24 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join20 } from "path";
 var BUILTIN_MCP_SERVERS = ["context7", "grep_app"];
-var MCP_CONFIG_PATHS = [
-  join19(homedir7(), ".claude", ".mcp.json"),
-  join19(process.cwd(), ".mcp.json"),
-  join19(process.cwd(), ".claude", ".mcp.json")
-];
+function getMcpConfigPaths() {
+  return [
+    join20(homedir8(), ".claude", ".mcp.json"),
+    join20(process.cwd(), ".mcp.json"),
+    join20(process.cwd(), ".claude", ".mcp.json")
+  ];
+}
 function loadUserMcpConfig() {
   const servers = {};
-  for (const configPath of MCP_CONFIG_PATHS) {
-    if (!existsSync22(configPath))
+  for (const configPath of getMcpConfigPaths()) {
+    if (!existsSync23(configPath))
       continue;
     try {
-      const content = readFileSync23(configPath, "utf-8");
+      const content = readFileSync24(configPath, "utf-8");
       const config2 = parseJsonc(content);
       if (config2.mcpServers) {
         Object.assign(servers, config2.mcpServers);
       }
-    } catch {}
+    } catch {
+      continue;
+    }
   }
   return servers;
 }
 function getBuiltinMcpInfo() {
-  return BUILTIN_MCP_SERVERS.map((id) => ({
-    id,
+  return BUILTIN_MCP_SERVERS.map((serverId) => ({
+    id: serverId,
     type: "builtin",
     enabled: true,
     valid: true
   }));
 }
 function getUserMcpInfo() {
-  const userServers = loadUserMcpConfig();
-  const servers = [];
-  for (const [id, config2] of Object.entries(userServers)) {
-    const isValid = typeof config2 === "object" && config2 !== null;
-    servers.push({
-      id,
+  return Object.entries(loadUserMcpConfig()).map(([serverId, value]) => {
+    const valid = typeof value === "object" && value !== null;
+    return {
+      id: serverId,
       type: "user",
       enabled: true,
-      valid: isValid,
-      error: isValid ? undefined : "Invalid configuration format"
-    });
-  }
-  return servers;
+      valid,
+      error: valid ? undefined : "Invalid configuration format"
+    };
+  });
 }
-async function checkBuiltinMcpServers() {
-  const servers = getBuiltinMcpInfo();
+
+// src/cli/doctor/checks/tools.ts
+async function gatherToolsSummary() {
+  const [astGrepCliInfo, astGrepNapiInfo, commentCheckerInfo, ghInfo] = await Promise.all([
+    checkAstGrepCli(),
+    checkAstGrepNapi(),
+    checkCommentChecker(),
+    getGhCliInfo()
+  ]);
+  const lspServers = getLspServersInfo();
+  const lspStats = getLspServerStats(lspServers);
+  const builtinMcp = getBuiltinMcpInfo();
+  const userMcp = getUserMcpInfo();
   return {
-    name: CHECK_NAMES[CHECK_IDS.MCP_BUILTIN],
-    status: "pass",
-    message: `${servers.length} built-in servers enabled`,
-    details: servers.map((s) => `Enabled: ${s.id}`)
-  };
-}
-async function checkUserMcpServers() {
-  const servers = getUserMcpInfo();
-  if (servers.length === 0) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.MCP_USER],
-      status: "skip",
-      message: "No user MCP configuration found",
-      details: ["Optional: Add .mcp.json for custom MCP servers"]
-    };
+    lspInstalled: lspStats.installed,
+    lspTotal: lspStats.total,
+    astGrepCli: astGrepCliInfo.installed,
+    astGrepNapi: astGrepNapiInfo.installed,
+    commentChecker: commentCheckerInfo.installed,
+    ghCli: {
+      installed: ghInfo.installed,
+      authenticated: ghInfo.authenticated,
+      username: ghInfo.username
+    },
+    mcpBuiltin: builtinMcp.map((server2) => server2.id),
+    mcpUser: userMcp.map((server2) => server2.id)
+  };
+}
+function buildToolIssues(summary) {
+  const issues = [];
+  if (!summary.astGrepCli && !summary.astGrepNapi) {
+    issues.push({
+      title: "AST-Grep unavailable",
+      description: "Neither AST-Grep CLI nor NAPI backend is available.",
+      fix: "Install @ast-grep/cli globally or add @ast-grep/napi",
+      severity: "warning",
+      affects: ["ast_grep_search", "ast_grep_replace"]
+    });
   }
-  const invalidServers = servers.filter((s) => !s.valid);
-  if (invalidServers.length > 0) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.MCP_USER],
-      status: "warn",
-      message: `${invalidServers.length} server(s) have configuration issues`,
-      details: [
-        ...servers.filter((s) => s.valid).map((s) => `Valid: ${s.id}`),
-        ...invalidServers.map((s) => `Invalid: ${s.id} - ${s.error}`)
-      ]
-    };
+  if (!summary.commentChecker) {
+    issues.push({
+      title: "Comment checker unavailable",
+      description: "Comment checker binary is not installed.",
+      fix: "Install @code-yeongyu/comment-checker",
+      severity: "warning",
+      affects: ["comment-checker hook"]
+    });
+  }
+  if (summary.lspInstalled === 0) {
+    issues.push({
+      title: "No LSP servers detected",
+      description: "LSP-dependent tools will be limited until at least one server is installed.",
+      severity: "warning",
+      affects: ["lsp diagnostics", "rename", "references"]
+    });
+  }
+  if (!summary.ghCli.installed) {
+    issues.push({
+      title: "GitHub CLI missing",
+      description: "gh CLI is not installed.",
+      fix: "Install from https://cli.github.com/",
+      severity: "warning",
+      affects: ["GitHub automation"]
+    });
+  } else if (!summary.ghCli.authenticated) {
+    issues.push({
+      title: "GitHub CLI not authenticated",
+      description: "gh CLI is installed but not logged in.",
+      fix: "Run: gh auth login",
+      severity: "warning",
+      affects: ["GitHub automation"]
+    });
+  }
+  return issues;
+}
+async function checkTools() {
+  const summary = await gatherToolsSummary();
+  const userMcpServers = getUserMcpInfo();
+  const invalidUserMcpServers = userMcpServers.filter((server2) => !server2.valid);
+  const issues = buildToolIssues(summary);
+  if (invalidUserMcpServers.length > 0) {
+    issues.push({
+      title: "Invalid MCP server configuration",
+      description: `${invalidUserMcpServers.length} user MCP server(s) have invalid config format.`,
+      severity: "warning",
+      affects: ["custom MCP tools"]
+    });
   }
   return {
-    name: CHECK_NAMES[CHECK_IDS.MCP_USER],
-    status: "pass",
-    message: `${servers.length} user server(s) configured`,
-    details: servers.map((s) => `Configured: ${s.id}`)
+    name: CHECK_NAMES[CHECK_IDS.TOOLS],
+    status: issues.length === 0 ? "pass" : "warn",
+    message: issues.length === 0 ? "All tools checks passed" : `${issues.length} tools issue(s) detected`,
+    details: [
+      `AST-Grep: cli=${summary.astGrepCli ? "yes" : "no"}, napi=${summary.astGrepNapi ? "yes" : "no"}`,
+      `Comment checker: ${summary.commentChecker ? "yes" : "no"}`,
+      `LSP: ${summary.lspInstalled}/${summary.lspTotal}`,
+      `GH CLI: ${summary.ghCli.installed ? "installed" : "missing"}${summary.ghCli.authenticated ? " (authenticated)" : ""}`,
+      `MCP: builtin=${summary.mcpBuiltin.length}, user=${summary.mcpUser.length}`
+    ],
+    issues
   };
 }
-function getMcpCheckDefinitions() {
+// src/cli/doctor/checks/index.ts
+function getAllCheckDefinitions() {
   return [
     {
-      id: CHECK_IDS.MCP_BUILTIN,
-      name: CHECK_NAMES[CHECK_IDS.MCP_BUILTIN],
-      category: "tools",
-      check: checkBuiltinMcpServers,
-      critical: false
+      id: CHECK_IDS.SYSTEM,
+      name: CHECK_NAMES[CHECK_IDS.SYSTEM],
+      check: checkSystem,
+      critical: true
+    },
+    {
+      id: CHECK_IDS.CONFIG,
+      name: CHECK_NAMES[CHECK_IDS.CONFIG],
+      check: checkConfig
     },
     {
-      id: CHECK_IDS.MCP_USER,
-      name: CHECK_NAMES[CHECK_IDS.MCP_USER],
-      category: "tools",
-      check: checkUserMcpServers,
-      critical: false
+      id: CHECK_IDS.TOOLS,
+      name: CHECK_NAMES[CHECK_IDS.TOOLS],
+      check: checkTools
+    },
+    {
+      id: CHECK_IDS.MODELS,
+      name: CHECK_NAMES[CHECK_IDS.MODELS],
+      check: checkModels
     }
   ];
 }
 
+// src/cli/doctor/format-default.ts
+var import_picocolors18 = __toESM(require_picocolors(), 1);
+
+// src/cli/doctor/format-shared.ts
+var import_picocolors17 = __toESM(require_picocolors(), 1);
+function formatStatusSymbol(status) {
+  const colorFn = STATUS_COLORS[status];
+  switch (status) {
+    case "pass":
+      return colorFn(SYMBOLS3.check);
+    case "fail":
+      return colorFn(SYMBOLS3.cross);
+    case "warn":
+      return colorFn(SYMBOLS3.warn);
+    case "skip":
+      return colorFn(SYMBOLS3.skip);
+  }
+}
+function formatStatusMark(available) {
+  return available ? import_picocolors17.default.green(SYMBOLS3.check) : import_picocolors17.default.red(SYMBOLS3.cross);
+}
+function formatHeader() {
+  return `
+${import_picocolors17.default.bgMagenta(import_picocolors17.default.white(" oMoMoMoMo Doctor "))}
+`;
+}
+function formatIssue(issue2, index) {
+  const lines = [];
+  const severityColor = issue2.severity === "error" ? import_picocolors17.default.red : import_picocolors17.default.yellow;
+  lines.push(`${index}. ${severityColor(issue2.title)}`);
+  lines.push(`   ${import_picocolors17.default.dim(issue2.description)}`);
+  if (issue2.fix) {
+    lines.push(`   ${import_picocolors17.default.cyan("Fix:")} ${import_picocolors17.default.dim(issue2.fix)}`);
+  }
+  if (issue2.affects && issue2.affects.length > 0) {
+    lines.push(`   ${import_picocolors17.default.cyan("Affects:")} ${import_picocolors17.default.dim(issue2.affects.join(", "))}`);
+  }
+  return lines.join(`
+`);
+}
+
+// src/cli/doctor/format-default.ts
+function formatDefault(result) {
+  const lines = [];
+  lines.push(formatHeader());
+  const allIssues = result.results.flatMap((r2) => r2.issues);
+  if (allIssues.length === 0) {
+    const opencodeVer = result.systemInfo.opencodeVersion ?? "unknown";
+    const pluginVer = result.systemInfo.pluginVersion ?? "unknown";
+    lines.push(` ${import_picocolors18.default.green(SYMBOLS3.check)} ${import_picocolors18.default.green(`System OK (opencode ${opencodeVer} \xB7 oh-my-opencode ${pluginVer})`)}`);
+  } else {
+    const issueCount = allIssues.filter((i2) => i2.severity === "error").length;
+    const warnCount = allIssues.filter((i2) => i2.severity === "warning").length;
+    const totalStr = `${issueCount + warnCount} ${issueCount + warnCount === 1 ? "issue" : "issues"}`;
+    lines.push(` ${import_picocolors18.default.yellow(SYMBOLS3.warn)} ${totalStr} found:
+`);
+    allIssues.forEach((issue2, index) => {
+      lines.push(formatIssue(issue2, index + 1));
+      lines.push("");
+    });
+  }
+  return lines.join(`
+`);
+}
+
+// src/cli/doctor/format-status.ts
+var import_picocolors19 = __toESM(require_picocolors(), 1);
+function formatStatus(result) {
+  const lines = [];
+  lines.push(formatHeader());
+  const { systemInfo, tools } = result;
+  const padding = " ";
+  const opencodeVer = systemInfo.opencodeVersion ?? "unknown";
+  const pluginVer = systemInfo.pluginVersion ?? "unknown";
+  const bunVer = systemInfo.bunVersion ?? "unknown";
+  lines.push(` ${padding}System     ${opencodeVer} \xB7 ${pluginVer} \xB7 Bun ${bunVer}`);
+  const configPath = systemInfo.configPath ?? "unknown";
+  const configStatus = systemInfo.configValid ? import_picocolors19.default.green("(valid)") : import_picocolors19.default.red("(invalid)");
+  lines.push(` ${padding}Config     ${configPath} ${configStatus}`);
+  const lspText = `LSP ${tools.lspInstalled}/${tools.lspTotal}`;
+  const astGrepMark = formatStatusMark(tools.astGrepCli);
+  const ghMark = formatStatusMark(tools.ghCli.installed && tools.ghCli.authenticated);
+  const ghUser = tools.ghCli.username ?? "";
+  lines.push(` ${padding}Tools      ${lspText} \xB7 AST-Grep ${astGrepMark} \xB7 gh ${ghMark}${ghUser ? ` (${ghUser})` : ""}`);
+  const builtinCount = tools.mcpBuiltin.length;
+  const userCount = tools.mcpUser.length;
+  const builtinText = builtinCount > 0 ? tools.mcpBuiltin.join(" \xB7 ") : "none";
+  const userText = userCount > 0 ? `+ ${userCount} user` : "";
+  lines.push(` ${padding}MCPs       ${builtinText} ${userText}`);
+  return lines.join(`
+`);
+}
+
+// src/cli/doctor/format-verbose.ts
+var import_picocolors20 = __toESM(require_picocolors(), 1);
+function formatVerbose(result) {
+  const lines = [];
+  lines.push(formatHeader());
+  const { systemInfo, tools, results, summary } = result;
+  lines.push(`${import_picocolors20.default.bold("System Information")}`);
+  lines.push(`${import_picocolors20.default.dim("\u2500".repeat(40))}`);
+  lines.push(`  ${formatStatusSymbol("pass")} opencode    ${systemInfo.opencodeVersion ?? "unknown"}`);
+  lines.push(`  ${formatStatusSymbol("pass")} oh-my-opencode ${systemInfo.pluginVersion ?? "unknown"}`);
+  if (systemInfo.loadedVersion) {
+    lines.push(`  ${formatStatusSymbol("pass")} loaded      ${systemInfo.loadedVersion}`);
+  }
+  if (systemInfo.bunVersion) {
+    lines.push(`  ${formatStatusSymbol("pass")} bun         ${systemInfo.bunVersion}`);
+  }
+  lines.push(`  ${formatStatusSymbol("pass")} path        ${systemInfo.opencodePath ?? "unknown"}`);
+  if (systemInfo.isLocalDev) {
+    lines.push(`  ${import_picocolors20.default.yellow("*")} ${import_picocolors20.default.dim("(local development mode)")}`);
+  }
+  lines.push("");
+  lines.push(`${import_picocolors20.default.bold("Configuration")}`);
+  lines.push(`${import_picocolors20.default.dim("\u2500".repeat(40))}`);
+  const configStatus = systemInfo.configValid ? import_picocolors20.default.green("valid") : import_picocolors20.default.red("invalid");
+  lines.push(`  ${formatStatusSymbol(systemInfo.configValid ? "pass" : "fail")} ${systemInfo.configPath ?? "unknown"} (${configStatus})`);
+  lines.push("");
+  lines.push(`${import_picocolors20.default.bold("Tools")}`);
+  lines.push(`${import_picocolors20.default.dim("\u2500".repeat(40))}`);
+  lines.push(`  ${formatStatusSymbol("pass")} LSP         ${tools.lspInstalled}/${tools.lspTotal} installed`);
+  lines.push(`  ${formatStatusSymbol(tools.astGrepCli ? "pass" : "fail")} ast-grep CLI ${tools.astGrepCli ? "installed" : "not found"}`);
+  lines.push(`  ${formatStatusSymbol(tools.astGrepNapi ? "pass" : "fail")} ast-grep napi ${tools.astGrepNapi ? "installed" : "not found"}`);
+  lines.push(`  ${formatStatusSymbol(tools.commentChecker ? "pass" : "fail")} comment-checker ${tools.commentChecker ? "installed" : "not found"}`);
+  lines.push(`  ${formatStatusSymbol(tools.ghCli.installed && tools.ghCli.authenticated ? "pass" : "fail")} gh CLI ${tools.ghCli.installed ? "installed" : "not found"}${tools.ghCli.authenticated && tools.ghCli.username ? ` (${tools.ghCli.username})` : ""}`);
+  lines.push("");
+  lines.push(`${import_picocolors20.default.bold("MCPs")}`);
+  lines.push(`${import_picocolors20.default.dim("\u2500".repeat(40))}`);
+  if (tools.mcpBuiltin.length === 0) {
+    lines.push(`  ${import_picocolors20.default.dim("No built-in MCPs")}`);
+  } else {
+    for (const mcp of tools.mcpBuiltin) {
+      lines.push(`  ${formatStatusSymbol("pass")} ${mcp}`);
+    }
+  }
+  if (tools.mcpUser.length > 0) {
+    lines.push(`  ${import_picocolors20.default.cyan("+")} ${tools.mcpUser.length} user MCP(s):`);
+    for (const mcp of tools.mcpUser) {
+      lines.push(`    ${formatStatusSymbol("pass")} ${mcp}`);
+    }
+  }
+  lines.push("");
+  const allIssues = results.flatMap((r2) => r2.issues);
+  if (allIssues.length > 0) {
+    lines.push(`${import_picocolors20.default.bold("Issues")}`);
+    lines.push(`${import_picocolors20.default.dim("\u2500".repeat(40))}`);
+    allIssues.forEach((issue2, index) => {
+      lines.push(formatIssue(issue2, index + 1));
+      lines.push("");
+    });
+  }
+  lines.push(`${import_picocolors20.default.bold("Summary")}`);
+  lines.push(`${import_picocolors20.default.dim("\u2500".repeat(40))}`);
+  const passText = summary.passed > 0 ? import_picocolors20.default.green(`${summary.passed} passed`) : `${summary.passed} passed`;
+  const failText = summary.failed > 0 ? import_picocolors20.default.red(`${summary.failed} failed`) : `${summary.failed} failed`;
+  const warnText = summary.warnings > 0 ? import_picocolors20.default.yellow(`${summary.warnings} warnings`) : `${summary.warnings} warnings`;
+  lines.push(`  ${passText}, ${failText}, ${warnText}`);
+  lines.push(`  ${import_picocolors20.default.dim(`Total: ${summary.total} checks in ${summary.duration}ms`)}`);
+  return lines.join(`
+`);
+}
+
+// src/cli/doctor/formatter.ts
+function formatDoctorOutput(result, mode) {
+  switch (mode) {
+    case "default":
+      return formatDefault(result);
+    case "status":
+      return formatStatus(result);
+    case "verbose":
+      return formatVerbose(result);
+  }
+}
+function formatJsonOutput2(result) {
+  return JSON.stringify(result, null, 2);
+}
+
+// src/cli/doctor/runner.ts
+async function runCheck(check2) {
+  const start = performance.now();
+  try {
+    const result = await check2.check();
+    result.duration = Math.round(performance.now() - start);
+    return result;
+  } catch (err) {
+    return {
+      name: check2.name,
+      status: "fail",
+      message: err instanceof Error ? err.message : "Unknown error",
+      issues: [{ title: check2.name, description: String(err), severity: "error" }],
+      duration: Math.round(performance.now() - start)
+    };
+  }
+}
+function calculateSummary(results, duration3) {
+  return {
+    total: results.length,
+    passed: results.filter((r2) => r2.status === "pass").length,
+    failed: results.filter((r2) => r2.status === "fail").length,
+    warnings: results.filter((r2) => r2.status === "warn").length,
+    skipped: results.filter((r2) => r2.status === "skip").length,
+    duration: Math.round(duration3)
+  };
+}
+function determineExitCode(results) {
+  return results.some((r2) => r2.status === "fail") ? EXIT_CODES.FAILURE : EXIT_CODES.SUCCESS;
+}
+async function runDoctor(options) {
+  const start = performance.now();
+  const allChecks = getAllCheckDefinitions();
+  const [results, systemInfo, tools] = await Promise.all([
+    Promise.all(allChecks.map(runCheck)),
+    gatherSystemInfo(),
+    gatherToolsSummary()
+  ]);
+  const duration3 = performance.now() - start;
+  const summary = calculateSummary(results, duration3);
+  const exitCode = determineExitCode(results);
+  const doctorResult = {
+    results,
+    systemInfo,
+    tools,
+    summary,
+    exitCode
+  };
+  if (options.json) {
+    console.log(formatJsonOutput2(doctorResult));
+  } else {
+    console.log(formatDoctorOutput(doctorResult, options.mode));
+  }
+  return doctorResult;
+}
+
+// src/cli/doctor/index.ts
+async function doctor(options = { mode: "default" }) {
+  const result = await runDoctor(options);
+  return result.exitCode;
+}
+
 // src/features/mcp-oauth/storage.ts
 init_shared();
-import { chmodSync, existsSync as existsSync23, mkdirSync as mkdirSync3, readFileSync as readFileSync24, unlinkSync, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname3, join as join20 } from "path";
+import { chmodSync, existsSync as existsSync24, mkdirSync as mkdirSync3, readFileSync as readFileSync25, unlinkSync, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname4, join as join21 } from "path";
 var STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStoragePath() {
-  return join20(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
+  return join21(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
 }
 function normalizeHost(serverHost) {
   let host = serverHost.trim();
@@ -26385,11 +26576,11 @@ function buildKey(serverHost, resource) {
 }
 function readStore() {
   const filePath = getMcpOauthStoragePath();
-  if (!existsSync23(filePath)) {
+  if (!existsSync24(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync24(filePath, "utf-8");
+    const content = readFileSync25(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -26398,8 +26589,8 @@ function readStore() {
 function writeStore(store) {
   const filePath = getMcpOauthStoragePath();
   try {
-    const dir = dirname3(filePath);
-    if (!existsSync23(dir)) {
+    const dir = dirname4(filePath);
+    if (!existsSync24(dir)) {
       mkdirSync3(dir, { recursive: true });
     }
     writeFileSync9(filePath, JSON.stringify(store, null, 2), { encoding: "utf-8", mode: 384 });
@@ -26434,7 +26625,7 @@ function deleteToken(serverHost, resource) {
   if (Object.keys(store).length === 0) {
     try {
       const filePath = getMcpOauthStoragePath();
-      if (existsSync23(filePath)) {
+      if (existsSync24(filePath)) {
         unlinkSync(filePath);
       }
       return true;
@@ -26462,368 +26653,6 @@ function listAllTokens() {
   return readStore() ?? {};
 }
 
-// src/cli/doctor/checks/mcp-oauth.ts
-import { existsSync as existsSync24, readFileSync as readFileSync25 } from "fs";
-function readTokenStore() {
-  const filePath = getMcpOauthStoragePath();
-  if (!existsSync24(filePath)) {
-    return null;
-  }
-  try {
-    const content = readFileSync25(filePath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-async function checkMcpOAuthTokens() {
-  const store = readTokenStore();
-  if (!store || Object.keys(store).length === 0) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.MCP_OAUTH_TOKENS],
-      status: "skip",
-      message: "No OAuth tokens configured",
-      details: ["Optional: Configure OAuth tokens for MCP servers"]
-    };
-  }
-  const now = Math.floor(Date.now() / 1000);
-  const tokens = Object.entries(store);
-  const expiredTokens = tokens.filter(([, token]) => token.expiresAt && token.expiresAt < now);
-  if (expiredTokens.length > 0) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.MCP_OAUTH_TOKENS],
-      status: "warn",
-      message: `${expiredTokens.length} of ${tokens.length} token(s) expired`,
-      details: [
-        ...tokens.filter(([, token]) => !token.expiresAt || token.expiresAt >= now).map(([key]) => `Valid: ${key}`),
-        ...expiredTokens.map(([key]) => `Expired: ${key}`)
-      ]
-    };
-  }
-  return {
-    name: CHECK_NAMES[CHECK_IDS.MCP_OAUTH_TOKENS],
-    status: "pass",
-    message: `${tokens.length} OAuth token(s) valid`,
-    details: tokens.map(([key]) => `Configured: ${key}`)
-  };
-}
-function getMcpOAuthCheckDefinition() {
-  return {
-    id: CHECK_IDS.MCP_OAUTH_TOKENS,
-    name: CHECK_NAMES[CHECK_IDS.MCP_OAUTH_TOKENS],
-    category: "tools",
-    check: checkMcpOAuthTokens,
-    critical: false
-  };
-}
-
-// src/cli/doctor/checks/version.ts
-init_checker();
-function compareVersions2(current, latest) {
-  const parseVersion = (v) => {
-    const cleaned = v.replace(/^v/, "").split("-")[0];
-    return cleaned.split(".").map((n) => parseInt(n, 10) || 0);
-  };
-  const curr = parseVersion(current);
-  const lat = parseVersion(latest);
-  for (let i2 = 0;i2 < Math.max(curr.length, lat.length); i2++) {
-    const c = curr[i2] ?? 0;
-    const l2 = lat[i2] ?? 0;
-    if (c < l2)
-      return false;
-    if (c > l2)
-      return true;
-  }
-  return true;
-}
-async function getVersionInfo() {
-  const cwd = process.cwd();
-  if (isLocalDevMode(cwd)) {
-    return {
-      currentVersion: "local-dev",
-      latestVersion: null,
-      isUpToDate: true,
-      isLocalDev: true,
-      isPinned: false
-    };
-  }
-  const pluginInfo = findPluginEntry(cwd);
-  if (pluginInfo?.isPinned) {
-    return {
-      currentVersion: pluginInfo.pinnedVersion,
-      latestVersion: null,
-      isUpToDate: true,
-      isLocalDev: false,
-      isPinned: true
-    };
-  }
-  const currentVersion = getCachedVersion();
-  const { extractChannel: extractChannel2 } = await Promise.resolve().then(() => (init_auto_update_checker(), exports_auto_update_checker));
-  const channel = extractChannel2(pluginInfo?.pinnedVersion ?? currentVersion);
-  const latestVersion = await getLatestVersion(channel);
-  const isUpToDate = !currentVersion || !latestVersion || compareVersions2(currentVersion, latestVersion);
-  return {
-    currentVersion,
-    latestVersion,
-    isUpToDate,
-    isLocalDev: false,
-    isPinned: false
-  };
-}
-async function checkVersionStatus() {
-  const info = await getVersionInfo();
-  if (info.isLocalDev) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.VERSION_STATUS],
-      status: "pass",
-      message: "Running in local development mode",
-      details: ["Using file:// protocol from config"]
-    };
-  }
-  if (info.isPinned) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.VERSION_STATUS],
-      status: "pass",
-      message: `Pinned to version ${info.currentVersion}`,
-      details: ["Update check skipped for pinned versions"]
-    };
-  }
-  if (!info.currentVersion) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.VERSION_STATUS],
-      status: "warn",
-      message: "Unable to determine current version",
-      details: ["Run: bunx oh-my-opencode get-local-version"]
-    };
-  }
-  if (!info.latestVersion) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.VERSION_STATUS],
-      status: "warn",
-      message: `Current: ${info.currentVersion}`,
-      details: ["Unable to check for updates (network error)"]
-    };
-  }
-  if (!info.isUpToDate) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.VERSION_STATUS],
-      status: "warn",
-      message: `Update available: ${info.currentVersion} -> ${info.latestVersion}`,
-      details: ["Run: cd ~/.config/opencode && bun update oh-my-opencode"]
-    };
-  }
-  return {
-    name: CHECK_NAMES[CHECK_IDS.VERSION_STATUS],
-    status: "pass",
-    message: `Up to date (${info.currentVersion})`,
-    details: info.latestVersion ? [`Latest: ${info.latestVersion}`] : undefined
-  };
-}
-function getVersionCheckDefinition() {
-  return {
-    id: CHECK_IDS.VERSION_STATUS,
-    name: CHECK_NAMES[CHECK_IDS.VERSION_STATUS],
-    category: "updates",
-    check: checkVersionStatus,
-    critical: false
-  };
-}
-
-// src/cli/doctor/checks/index.ts
-function getAllCheckDefinitions() {
-  return [
-    getOpenCodeCheckDefinition(),
-    getPluginCheckDefinition(),
-    getConfigCheckDefinition(),
-    getModelResolutionCheckDefinition(),
-    ...getAuthCheckDefinitions(),
-    ...getDependencyCheckDefinitions(),
-    getGhCliCheckDefinition(),
-    getLspCheckDefinition(),
-    ...getMcpCheckDefinitions(),
-    getMcpOAuthCheckDefinition(),
-    getVersionCheckDefinition()
-  ];
-}
-
-// src/cli/doctor/formatter.ts
-var import_picocolors17 = __toESM(require_picocolors(), 1);
-function formatStatusSymbol(status) {
-  switch (status) {
-    case "pass":
-      return SYMBOLS3.check;
-    case "fail":
-      return SYMBOLS3.cross;
-    case "warn":
-      return SYMBOLS3.warn;
-    case "skip":
-      return SYMBOLS3.skip;
-  }
-}
-function formatCheckResult(result, verbose) {
-  const symbol2 = formatStatusSymbol(result.status);
-  const colorFn = STATUS_COLORS[result.status];
-  const name = colorFn(result.name);
-  const message = import_picocolors17.default.dim(result.message);
-  let line = `  ${symbol2} ${name}`;
-  if (result.message) {
-    line += ` ${SYMBOLS3.arrow} ${message}`;
-  }
-  if (verbose && result.details && result.details.length > 0) {
-    const detailLines = result.details.map((d3) => `      ${SYMBOLS3.bullet} ${import_picocolors17.default.dim(d3)}`).join(`
-`);
-    line += `
-` + detailLines;
-  }
-  return line;
-}
-function formatCategoryHeader(category) {
-  const name = CATEGORY_NAMES[category] || category;
-  return `
-${import_picocolors17.default.bold(import_picocolors17.default.white(name))}
-${import_picocolors17.default.dim("\u2500".repeat(40))}`;
-}
-function formatSummary(summary) {
-  const lines = [];
-  lines.push(import_picocolors17.default.bold(import_picocolors17.default.white("Summary")));
-  lines.push(import_picocolors17.default.dim("\u2500".repeat(40)));
-  lines.push("");
-  const passText = summary.passed > 0 ? import_picocolors17.default.green(`${summary.passed} passed`) : import_picocolors17.default.dim("0 passed");
-  const failText = summary.failed > 0 ? import_picocolors17.default.red(`${summary.failed} failed`) : import_picocolors17.default.dim("0 failed");
-  const warnText = summary.warnings > 0 ? import_picocolors17.default.yellow(`${summary.warnings} warnings`) : import_picocolors17.default.dim("0 warnings");
-  const skipText = summary.skipped > 0 ? import_picocolors17.default.dim(`${summary.skipped} skipped`) : "";
-  const parts = [passText, failText, warnText];
-  if (skipText)
-    parts.push(skipText);
-  lines.push(`  ${parts.join(", ")}`);
-  lines.push(`  ${import_picocolors17.default.dim(`Total: ${summary.total} checks in ${summary.duration}ms`)}`);
-  return lines.join(`
-`);
-}
-function formatHeader() {
-  return `
-${import_picocolors17.default.bgMagenta(import_picocolors17.default.white(" oMoMoMoMo... Doctor "))}
-`;
-}
-function formatFooter(summary) {
-  if (summary.failed > 0) {
-    return `
-${SYMBOLS3.cross} ${import_picocolors17.default.red("Issues detected. Please review the errors above.")}
-`;
-  }
-  if (summary.warnings > 0) {
-    return `
-${SYMBOLS3.warn} ${import_picocolors17.default.yellow("All systems operational with warnings.")}
-`;
-  }
-  return `
-${SYMBOLS3.check} ${import_picocolors17.default.green("All systems operational!")}
-`;
-}
-function formatJsonOutput2(result) {
-  return JSON.stringify(result, null, 2);
-}
-
-// src/cli/doctor/runner.ts
-async function runCheck(check2) {
-  const start = performance.now();
-  try {
-    const result = await check2.check();
-    result.duration = Math.round(performance.now() - start);
-    return result;
-  } catch (err) {
-    return {
-      name: check2.name,
-      status: "fail",
-      message: err instanceof Error ? err.message : "Unknown error",
-      duration: Math.round(performance.now() - start)
-    };
-  }
-}
-function calculateSummary(results, duration3) {
-  return {
-    total: results.length,
-    passed: results.filter((r2) => r2.status === "pass").length,
-    failed: results.filter((r2) => r2.status === "fail").length,
-    warnings: results.filter((r2) => r2.status === "warn").length,
-    skipped: results.filter((r2) => r2.status === "skip").length,
-    duration: Math.round(duration3)
-  };
-}
-function determineExitCode(results) {
-  const hasFailures = results.some((r2) => r2.status === "fail");
-  return hasFailures ? EXIT_CODES.FAILURE : EXIT_CODES.SUCCESS;
-}
-function filterChecksByCategory(checks3, category) {
-  if (!category)
-    return checks3;
-  return checks3.filter((c) => c.category === category);
-}
-function groupChecksByCategory(checks3) {
-  const groups = new Map;
-  for (const check2 of checks3) {
-    const existing = groups.get(check2.category) ?? [];
-    existing.push(check2);
-    groups.set(check2.category, existing);
-  }
-  return groups;
-}
-var CATEGORY_ORDER = [
-  "installation",
-  "configuration",
-  "authentication",
-  "dependencies",
-  "tools",
-  "updates"
-];
-async function runDoctor(options) {
-  const start = performance.now();
-  const allChecks = getAllCheckDefinitions();
-  const filteredChecks = filterChecksByCategory(allChecks, options.category);
-  const groupedChecks = groupChecksByCategory(filteredChecks);
-  const results = [];
-  if (!options.json) {
-    console.log(formatHeader());
-  }
-  for (const category of CATEGORY_ORDER) {
-    const checks3 = groupedChecks.get(category);
-    if (!checks3 || checks3.length === 0)
-      continue;
-    if (!options.json) {
-      console.log(formatCategoryHeader(category));
-    }
-    for (const check2 of checks3) {
-      const result = await runCheck(check2);
-      results.push(result);
-      if (!options.json) {
-        console.log(formatCheckResult(result, options.verbose ?? false));
-      }
-    }
-  }
-  const duration3 = performance.now() - start;
-  const summary = calculateSummary(results, duration3);
-  const exitCode = determineExitCode(results);
-  const doctorResult = {
-    results,
-    summary,
-    exitCode
-  };
-  if (options.json) {
-    console.log(formatJsonOutput2(doctorResult));
-  } else {
-    console.log("");
-    console.log(formatSummary(summary));
-    console.log(formatFooter(summary));
-  }
-  return doctorResult;
-}
-
-// src/cli/doctor/index.ts
-async function doctor(options = {}) {
-  const result = await runDoctor(options);
-  return result.exitCode;
-}
-
 // src/features/mcp-oauth/discovery.ts
 var discoveryCache = new Map;
 var pendingDiscovery = new Map;
@@ -27327,7 +27156,7 @@ async function status(serverName) {
 
 // src/cli/mcp-oauth/index.ts
 function createMcpOAuthCommand() {
-  const mcp2 = new Command("mcp").description("MCP server management");
+  const mcp = new Command("mcp").description("MCP server management");
   const oauth = new Command("oauth").description("OAuth token management for MCP servers");
   oauth.command("login <server-name>").description("Authenticate with an MCP server using OAuth").option("--server-url <url>", "OAuth server URL (required if not in config)").option("--client-id <id>", "OAuth client ID (optional, uses DCR if not provided)").option("--scopes <scopes...>", "OAuth scopes to request").action(async (serverName, options) => {
     const exitCode = await login(serverName, options);
@@ -27341,8 +27170,8 @@ function createMcpOAuthCommand() {
     const exitCode = await status(serverName);
     process.exit(exitCode);
   });
-  mcp2.addCommand(oauth);
-  return mcp2;
+  mcp.addCommand(oauth);
+  return mcp;
 }
 
 // src/cli/cli-program.ts
@@ -27439,25 +27268,17 @@ This command shows:
   const exitCode = await getLocalVersion(versionOptions);
   process.exit(exitCode);
 });
-program2.command("doctor").description("Check oh-my-opencode installation health and diagnose issues").option("--verbose", "Show detailed diagnostic information").option("--json", "Output results in JSON format").option("--category <category>", "Run only specific category").addHelpText("after", `
+program2.command("doctor").description("Check oh-my-opencode installation health and diagnose issues").option("--status", "Show compact system dashboard").option("--verbose", "Show detailed diagnostic information").option("--json", "Output results in JSON format").addHelpText("after", `
 Examples:
-  $ bunx oh-my-opencode doctor
-  $ bunx oh-my-opencode doctor --verbose
-  $ bunx oh-my-opencode doctor --json
-  $ bunx oh-my-opencode doctor --category authentication
-
-Categories:
-  installation     Check OpenCode and plugin installation
-  configuration    Validate configuration files
-  authentication   Check auth provider status
-  dependencies     Check external dependencies
-  tools            Check LSP and MCP servers
-  updates          Check for version updates
+  $ bunx oh-my-opencode doctor            # Show problems only
+  $ bunx oh-my-opencode doctor --status   # Compact dashboard
+  $ bunx oh-my-opencode doctor --verbose  # Deep diagnostics
+  $ bunx oh-my-opencode doctor --json     # JSON output
 `).action(async (options) => {
+  const mode = options.status ? "status" : options.verbose ? "verbose" : "default";
   const doctorOptions = {
-    verbose: options.verbose ?? false,
-    json: options.json ?? false,
-    category: options.category
+    mode,
+    json: options.json ?? false
   };
   const exitCode = await doctor(doctorOptions);
   process.exit(exitCode);