oh-my-opencode 3.15.2 → 3.16.0

package/dist/cli/index.js

@@ -5977,9 +5977,13 @@ var PLUGIN_NAME = "oh-my-openagent", LEGACY_PLUGIN_NAME = "oh-my-opencode", CONF
 // src/shared/jsonc-parser.ts
 import { existsSync, readFileSync } from "fs";
 import { join as join3 } from "path";
+function stripBom(content) {
+  return content.charCodeAt(0) === 65279 ? content.slice(1) : content;
+}
 function parseJsonc(content) {
+  content = content.replace(/^\uFEFF/, "");
   const errors = [];
-  const result = parse2(content, errors, {
+  const result = parse2(stripBom(content), errors, {
     allowTrailingComma: true,
     disallowComments: false
   });
@@ -6042,15 +6046,15 @@ var init_agent_names = __esm(() => {
     "omo-plan": "prometheus",
     "Planner-Sisyphus": "prometheus",
     "planner-sisyphus": "prometheus",
-    "Prometheus (Planner)": "prometheus",
+    "Prometheus - Plan Builder": "prometheus",
     prometheus: "prometheus",
     "orchestrator-sisyphus": "atlas",
     Atlas: "atlas",
     atlas: "atlas",
     "plan-consultant": "metis",
-    "Metis (Plan Consultant)": "metis",
+    "Metis - Plan Consultant": "metis",
     metis: "metis",
-    "Momus (Plan Reviewer)": "momus",
+    "Momus - Plan Critic": "momus",
     momus: "momus",
     "Sisyphus-Junior": "sisyphus-junior",
     "sisyphus-junior": "sisyphus-junior",
@@ -6367,18 +6371,88 @@ var TAURI_APP_IDENTIFIER = "ai.opencode.desktop", TAURI_APP_IDENTIFIER_DEV = "ai
 var init_opencode_config_dir = () => {};
 
 // src/shared/opencode-version.ts
-var NOT_CACHED;
+import { execSync } from "child_process";
+function parseVersion(version) {
+  const cleaned = version.replace(/^v/, "").split("-")[0];
+  return cleaned.split(".").map((n) => parseInt(n, 10) || 0);
+}
+function compareVersions(a, b) {
+  const partsA = parseVersion(a);
+  const partsB = parseVersion(b);
+  const maxLen = Math.max(partsA.length, partsB.length);
+  for (let i2 = 0;i2 < maxLen; i2++) {
+    const numA = partsA[i2] ?? 0;
+    const numB = partsB[i2] ?? 0;
+    if (numA < numB)
+      return -1;
+    if (numA > numB)
+      return 1;
+  }
+  return 0;
+}
+function getOpenCodeVersion() {
+  if (cachedVersion !== NOT_CACHED) {
+    return cachedVersion;
+  }
+  try {
+    const result = execSync("opencode --version", {
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const versionMatch = result.match(/(\d+\.\d+\.\d+(?:-[\w.]+)?)/);
+    cachedVersion = versionMatch?.[1] ?? null;
+    return cachedVersion;
+  } catch {
+    cachedVersion = null;
+    return null;
+  }
+}
+function isOpenCodeVersionAtLeast(version) {
+  const current = getOpenCodeVersion();
+  if (!current)
+    return true;
+  return compareVersions(current, version) >= 0;
+}
+var OPENCODE_SQLITE_VERSION = "1.1.53", NOT_CACHED, cachedVersion;
 var init_opencode_version = __esm(() => {
   NOT_CACHED = Symbol("NOT_CACHED");
+  cachedVersion = NOT_CACHED;
 });
 
 // src/shared/opencode-storage-detection.ts
-var NOT_CACHED2, FALSE_PENDING_RETRY;
+import { existsSync as existsSync3 } from "fs";
+import { join as join5 } from "path";
+function isSqliteBackend() {
+  if (cachedResult === true)
+    return true;
+  if (cachedResult === false)
+    return false;
+  const check = () => {
+    const versionOk = isOpenCodeVersionAtLeast(OPENCODE_SQLITE_VERSION);
+    const dbPath = join5(getDataDir(), "opencode", "opencode.db");
+    return versionOk && existsSync3(dbPath);
+  };
+  if (cachedResult === FALSE_PENDING_RETRY) {
+    const result2 = check();
+    cachedResult = result2;
+    return result2;
+  }
+  const result = check();
+  if (result) {
+    cachedResult = true;
+  } else {
+    cachedResult = FALSE_PENDING_RETRY;
+  }
+  return result;
+}
+var NOT_CACHED2, FALSE_PENDING_RETRY, cachedResult;
 var init_opencode_storage_detection = __esm(() => {
   init_data_path();
   init_opencode_version();
   NOT_CACHED2 = Symbol("NOT_CACHED");
   FALSE_PENDING_RETRY = Symbol("FALSE_PENDING_RETRY");
+  cachedResult = NOT_CACHED2;
 });
 // src/shared/load-opencode-plugins.ts
 var init_load_opencode_plugins = __esm(() => {
@@ -6793,19 +6867,19 @@ function normalizeModelID(modelID) {
 }
 
 // src/shared/json-file-cache-store.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join6 } from "path";
 function toLogLabel(cacheLabel) {
   return cacheLabel.toLowerCase();
 }
 function createJsonFileCacheStore(options) {
   let memoryValue;
   function getCacheFilePath() {
-    return join5(options.getCacheDir(), options.filename);
+    return join6(options.getCacheDir(), options.filename);
   }
   function ensureCacheDir() {
     const cacheDir = options.getCacheDir();
-    if (!existsSync3(cacheDir)) {
+    if (!existsSync4(cacheDir)) {
       mkdirSync2(cacheDir, { recursive: true });
     }
   }
@@ -6814,7 +6888,7 @@ function createJsonFileCacheStore(options) {
       return memoryValue;
     }
     const cacheFile = getCacheFilePath();
-    if (!existsSync3(cacheFile)) {
+    if (!existsSync4(cacheFile)) {
       memoryValue = null;
       log(`[${options.logPrefix}] ${options.cacheLabel} file not found`, { cacheFile });
       return null;
@@ -6834,7 +6908,7 @@ function createJsonFileCacheStore(options) {
     }
   }
   function has() {
-    return existsSync3(getCacheFilePath());
+    return existsSync4(getCacheFilePath());
   }
   function write(value) {
     ensureCacheDir();
@@ -7003,14 +7077,14 @@ var init_connected_providers_cache = __esm(() => {
 });
 
 // src/shared/model-availability.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
+import { join as join7 } from "path";
 function isModelCacheAvailable() {
   if (hasProviderModelsCache()) {
     return true;
   }
-  const cacheFile = join6(getOpenCodeCacheDir(), "models.json");
-  return existsSync4(cacheFile);
+  const cacheFile = join7(getOpenCodeCacheDir(), "models.json");
+  return existsSync5(cacheFile);
 }
 var init_model_availability = __esm(() => {
   init_logger();
@@ -48305,6 +48379,57 @@ var init_constants = __esm(() => {
   init_shared();
 });
 
+// src/shared/opencode-storage-paths.ts
+import { join as join8 } from "path";
+var OPENCODE_STORAGE, MESSAGE_STORAGE, PART_STORAGE, SESSION_STORAGE;
+var init_opencode_storage_paths = __esm(() => {
+  init_data_path();
+  OPENCODE_STORAGE = getOpenCodeStorageDir();
+  MESSAGE_STORAGE = join8(OPENCODE_STORAGE, "message");
+  PART_STORAGE = join8(OPENCODE_STORAGE, "part");
+  SESSION_STORAGE = join8(OPENCODE_STORAGE, "session");
+});
+
+// src/shared/compaction-marker.ts
+import { existsSync as existsSync6, readdirSync, readFileSync as readFileSync4 } from "fs";
+import { join as join9 } from "path";
+function isCompactionPart(part) {
+  return typeof part === "object" && part !== null && part.type === "compaction";
+}
+function isCompactionAgent(agent) {
+  return typeof agent === "string" && agent.trim().toLowerCase() === "compaction";
+}
+function hasCompactionPart(parts) {
+  return Array.isArray(parts) && parts.some((part) => isCompactionPart(part));
+}
+function isCompactionMessage(message) {
+  return isCompactionAgent(message.info?.agent ?? message.agent) || hasCompactionPart(message.parts);
+}
+function hasCompactionPartInStorage(messageID) {
+  if (!messageID) {
+    return false;
+  }
+  const partDir = join9(PART_STORAGE, messageID);
+  if (!existsSync6(partDir)) {
+    return false;
+  }
+  try {
+    return readdirSync(partDir).filter((fileName) => fileName.endsWith(".json")).some((fileName) => {
+      try {
+        const content = readFileSync4(join9(partDir, fileName), "utf-8");
+        return isCompactionPart(JSON.parse(content));
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return false;
+  }
+}
+var init_compaction_marker = __esm(() => {
+  init_opencode_storage_paths();
+});
+
 // src/features/hook-message-injector/injector.ts
 import { randomBytes } from "crypto";
 var processPrefix;
@@ -48313,6 +48438,7 @@ var init_injector = __esm(() => {
   init_logger();
   init_opencode_storage_detection();
   init_shared();
+  init_compaction_marker();
   processPrefix = randomBytes(4).toString("hex");
 });
 
@@ -48322,18 +48448,33 @@ var init_hook_message_injector = __esm(() => {
   init_constants();
 });
 
-// src/shared/opencode-storage-paths.ts
-import { join as join7 } from "path";
-var OPENCODE_STORAGE, MESSAGE_STORAGE, PART_STORAGE, SESSION_STORAGE;
-var init_opencode_storage_paths = __esm(() => {
-  init_data_path();
-  OPENCODE_STORAGE = getOpenCodeStorageDir();
-  MESSAGE_STORAGE = join7(OPENCODE_STORAGE, "message");
-  PART_STORAGE = join7(OPENCODE_STORAGE, "part");
-  SESSION_STORAGE = join7(OPENCODE_STORAGE, "session");
-});
-
 // src/shared/opencode-message-dir.ts
+import { existsSync as existsSync7, readdirSync as readdirSync2 } from "fs";
+import { join as join10 } from "path";
+function getMessageDir(sessionID) {
+  if (!sessionID.startsWith("ses_"))
+    return null;
+  if (/[/\\]|\.\./.test(sessionID))
+    return null;
+  if (!existsSync7(MESSAGE_STORAGE))
+    return null;
+  const directPath = join10(MESSAGE_STORAGE, sessionID);
+  if (existsSync7(directPath)) {
+    return directPath;
+  }
+  try {
+    for (const dir of readdirSync2(MESSAGE_STORAGE)) {
+      const sessionPath = join10(MESSAGE_STORAGE, dir, sessionID);
+      if (existsSync7(sessionPath)) {
+        return sessionPath;
+      }
+    }
+  } catch (error) {
+    log("[opencode-message-dir] Failed to scan message directories", { sessionID, error: String(error) });
+    return null;
+  }
+  return null;
+}
 var init_opencode_message_dir = __esm(() => {
   init_opencode_storage_paths();
   init_logger();
@@ -48359,22 +48500,25 @@ function getAgentConfigKey(agentName) {
   const reversed = REVERSE_DISPLAY_NAMES[lower];
   if (reversed !== undefined)
     return reversed;
+  const legacy = LEGACY_DISPLAY_NAMES[lower];
+  if (legacy !== undefined)
+    return legacy;
   if (AGENT_DISPLAY_NAMES[lower] !== undefined)
     return lower;
   return lower;
 }
-var AGENT_DISPLAY_NAMES, REVERSE_DISPLAY_NAMES;
+var AGENT_DISPLAY_NAMES, REVERSE_DISPLAY_NAMES, LEGACY_DISPLAY_NAMES;
 var init_agent_display_names = __esm(() => {
   AGENT_DISPLAY_NAMES = {
-    sisyphus: "Sisyphus (Ultraworker)",
-    hephaestus: "Hephaestus (Deep Agent)",
-    prometheus: "Prometheus (Plan Builder)",
-    atlas: "Atlas (Plan Executor)",
+    sisyphus: "Sisyphus - Ultraworker",
+    hephaestus: "Hephaestus - Deep Agent",
+    prometheus: "Prometheus - Plan Builder",
+    atlas: "Atlas - Plan Executor",
     "sisyphus-junior": "Sisyphus-Junior",
-    metis: "Metis (Plan Consultant)",
-    momus: "Momus (Plan Critic)",
-    athena: "Athena (Council)",
-    "athena-junior": "Athena-Junior (Council)",
+    metis: "Metis - Plan Consultant",
+    momus: "Momus - Plan Critic",
+    athena: "Athena - Council",
+    "athena-junior": "Athena-Junior - Council",
     oracle: "oracle",
     librarian: "librarian",
     explore: "explore",
@@ -48382,6 +48526,16 @@ var init_agent_display_names = __esm(() => {
     "council-member": "council-member"
   };
   REVERSE_DISPLAY_NAMES = Object.fromEntries(Object.entries(AGENT_DISPLAY_NAMES).map(([key, displayName]) => [displayName.toLowerCase(), key]));
+  LEGACY_DISPLAY_NAMES = {
+    "sisyphus (ultraworker)": "sisyphus",
+    "hephaestus (deep agent)": "hephaestus",
+    "prometheus (plan builder)": "prometheus",
+    "atlas (plan executor)": "atlas",
+    "metis (plan consultant)": "metis",
+    "momus (plan critic)": "momus",
+    "athena (council)": "athena",
+    "athena-junior (council)": "athena-junior"
+  };
 });
 
 // src/shared/session-utils.ts
@@ -48545,9 +48699,18 @@ var init_session_tools_store = __esm(() => {
 var init_prompt_tools = __esm(() => {
   init_session_tools_store();
 });
+
+// src/shared/internal-initiator-marker.ts
+var init_internal_initiator_marker = () => {};
+// src/features/claude-code-plugin-loader/scope-filter.ts
+var init_scope_filter = __esm(() => {
+  init_contains_path();
+});
+
 // src/features/claude-code-plugin-loader/discovery.ts
 var init_discovery = __esm(() => {
   init_logger();
+  init_scope_filter();
 });
 
 // src/features/claude-code-plugin-loader/command-loader.ts
@@ -48598,7 +48761,7 @@ var init_env_expander = __esm(() => {
 });
 
 // src/features/claude-code-mcp-loader/scope-filter.ts
-var init_scope_filter = __esm(() => {
+var init_scope_filter2 = __esm(() => {
   init_contains_path();
 });
 
@@ -48609,7 +48772,7 @@ var init_transformer = __esm(() => {
 // src/features/claude-code-plugin-loader/mcp-server-loader.ts
 var init_mcp_server_loader = __esm(() => {
   init_env_expander();
-  init_scope_filter();
+  init_scope_filter2();
   init_transformer();
   init_logger();
 });
@@ -48740,6 +48903,8 @@ var init_shared = __esm(() => {
   init_project_discovery_dirs();
   init_session_directory_resolver();
   init_prompt_tools();
+  init_compaction_marker();
+  init_internal_initiator_marker();
   init_plugin_command_discovery();
   init_log_legacy_plugin_startup_warning();
 });
@@ -48820,12 +48985,37 @@ var init_plugin_name_with_version = __esm(() => {
   PRIORITIZED_TAGS = ["latest", "beta", "next"];
 });
 
+// src/cli/config-manager/backup-config.ts
+import { copyFileSync as copyFileSync2, existsSync as existsSync8, mkdirSync as mkdirSync3 } from "fs";
+import { dirname } from "path";
+function backupConfigFile(configPath) {
+  if (!existsSync8(configPath)) {
+    return { success: true };
+  }
+  const timestamp2 = new Date().toISOString().replace(/[:.]/g, "-");
+  const backupPath = `${configPath}.backup-${timestamp2}`;
+  try {
+    const dir = dirname(backupPath);
+    if (!existsSync8(dir)) {
+      mkdirSync3(dir, { recursive: true });
+    }
+    copyFileSync2(configPath, backupPath);
+    return { success: true, backupPath };
+  } catch (err) {
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : "Failed to create backup"
+    };
+  }
+}
+var init_backup_config = () => {};
+
 // src/cli/config-manager/ensure-config-directory-exists.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync4 } from "fs";
 function ensureConfigDirectoryExists() {
   const configDir = getConfigDir();
-  if (!existsSync5(configDir)) {
-    mkdirSync3(configDir, { recursive: true });
+  if (!existsSync9(configDir)) {
+    mkdirSync4(configDir, { recursive: true });
   }
 }
 var init_ensure_config_directory_exists = __esm(() => {
@@ -48862,14 +49052,14 @@ function formatErrorWithSuggestion(err, context) {
 }
 
 // src/cli/config-manager/opencode-config-format.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 function detectConfigFormat() {
   const configJsonc = getConfigJsonc();
   const configJson = getConfigJson();
-  if (existsSync6(configJsonc)) {
+  if (existsSync10(configJsonc)) {
     return { format: "jsonc", path: configJsonc };
   }
-  if (existsSync6(configJson)) {
+  if (existsSync10(configJson)) {
     return { format: "json", path: configJson };
   }
   return { format: "none", path: configJson };
@@ -48879,7 +49069,7 @@ var init_opencode_config_format = __esm(() => {
 });
 
 // src/cli/config-manager/parse-opencode-config-file.ts
-import { readFileSync as readFileSync4, statSync } from "fs";
+import { readFileSync as readFileSync5, statSync } from "fs";
 function isEmptyOrWhitespace(content) {
   return content.trim().length === 0;
 }
@@ -48889,7 +49079,7 @@ function parseOpenCodeConfigFileWithError(path3) {
     if (stat.size === 0) {
       return { config: null, error: `Config file is empty: ${path3}. Delete it or add valid JSON content.` };
     }
-    const content = readFileSync4(path3, "utf-8");
+    const content = readFileSync5(path3, "utf-8");
     if (isEmptyOrWhitespace(content)) {
       return { config: null, error: `Config file contains only whitespace: ${path3}. Delete it or add valid JSON content.` };
     }
@@ -48912,8 +49102,90 @@ var init_parse_opencode_config_file = __esm(() => {
   init_shared();
 });
 
+// src/cli/config-manager/version-compatibility.ts
+function parseVersion2(version) {
+  const clean = version.replace(/^v/, "").split("-")[0];
+  return clean.split(".").map(Number);
+}
+function compareVersions2(a, b) {
+  const partsA = parseVersion2(a);
+  const partsB = parseVersion2(b);
+  const maxLen = Math.max(partsA.length, partsB.length);
+  for (let i2 = 0;i2 < maxLen; i2++) {
+    const numA = partsA[i2] ?? 0;
+    const numB = partsB[i2] ?? 0;
+    if (numA !== numB) {
+      return numA - numB;
+    }
+  }
+  return 0;
+}
+function checkVersionCompatibility(currentVersion, newVersion) {
+  if (!currentVersion) {
+    return {
+      canUpgrade: true,
+      isDowngrade: false,
+      isMajorBump: false,
+      requiresMigration: false
+    };
+  }
+  const cleanCurrent = currentVersion.replace(/^v/, "");
+  const cleanNew = newVersion.replace(/^v/, "");
+  try {
+    const comparison = compareVersions2(cleanNew, cleanCurrent);
+    if (comparison < 0) {
+      return {
+        canUpgrade: false,
+        reason: `Downgrade from ${currentVersion} to ${newVersion} is not allowed`,
+        isDowngrade: true,
+        isMajorBump: false,
+        requiresMigration: false
+      };
+    }
+    if (comparison === 0) {
+      return {
+        canUpgrade: true,
+        reason: `Version ${newVersion} is already installed`,
+        isDowngrade: false,
+        isMajorBump: false,
+        requiresMigration: false
+      };
+    }
+    const currentMajor = cleanCurrent.split(".")[0];
+    const newMajor = cleanNew.split(".")[0];
+    const isMajorBump = currentMajor !== newMajor;
+    if (isMajorBump) {
+      return {
+        canUpgrade: true,
+        reason: `Major version upgrade from ${currentVersion} to ${newVersion} - configuration migration may be required`,
+        isDowngrade: false,
+        isMajorBump: true,
+        requiresMigration: true
+      };
+    }
+    return {
+      canUpgrade: true,
+      isDowngrade: false,
+      isMajorBump: false,
+      requiresMigration: false
+    };
+  } catch {
+    return {
+      canUpgrade: true,
+      reason: `Unable to compare versions ${currentVersion} and ${newVersion} - proceeding with caution`,
+      isDowngrade: false,
+      isMajorBump: false,
+      requiresMigration: false
+    };
+  }
+}
+function extractVersionFromPluginEntry(entry) {
+  const match = entry.match(/@(.+)$/);
+  return match ? match[1] : null;
+}
+
 // src/cli/config-manager/add-plugin-to-opencode-config.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
 async function addPluginToOpenCodeConfig(currentVersion) {
   try {
     ensureConfigDirectoryExists();
@@ -48946,19 +49218,35 @@ async function addPluginToOpenCodeConfig(currentVersion) {
     const canonicalEntries = plugins.filter((plugin) => plugin === PLUGIN_NAME || plugin.startsWith(`${PLUGIN_NAME}@`));
     const legacyEntries = plugins.filter((plugin) => plugin === LEGACY_PLUGIN_NAME || plugin.startsWith(`${LEGACY_PLUGIN_NAME}@`));
     const otherPlugins = plugins.filter((plugin) => !(plugin === PLUGIN_NAME || plugin.startsWith(`${PLUGIN_NAME}@`)) && !(plugin === LEGACY_PLUGIN_NAME || plugin.startsWith(`${LEGACY_PLUGIN_NAME}@`)));
+    const existingEntry = canonicalEntries[0] ?? legacyEntries[0];
+    if (existingEntry) {
+      const installedVersion = extractVersionFromPluginEntry(existingEntry);
+      const compatibility = checkVersionCompatibility(installedVersion, currentVersion);
+      if (!compatibility.canUpgrade) {
+        return {
+          success: false,
+          configPath: path3,
+          error: compatibility.reason ?? "Version compatibility check failed"
+        };
+      }
+      const backupResult = backupConfigFile(path3);
+      if (!backupResult.success) {
+        return {
+          success: false,
+          configPath: path3,
+          error: `Failed to create backup: ${backupResult.error}`
+        };
+      }
+    }
     const normalizedPlugins = [...otherPlugins];
-    if (canonicalEntries.length > 0) {
-      normalizedPlugins.push(canonicalEntries[0]);
-    } else if (legacyEntries.length > 0) {
-      const versionMatch = legacyEntries[0].match(/@(.+)$/);
-      const preservedVersion = versionMatch ? versionMatch[1] : null;
-      normalizedPlugins.push(preservedVersion ? `${PLUGIN_NAME}@${preservedVersion}` : pluginEntry);
+    if (canonicalEntries.length > 0 || legacyEntries.length > 0) {
+      normalizedPlugins.push(pluginEntry);
     } else {
       normalizedPlugins.push(pluginEntry);
     }
     config.plugin = normalizedPlugins;
     if (format2 === "jsonc") {
-      const content = readFileSync5(path3, "utf-8");
+      const content = readFileSync6(path3, "utf-8");
       const pluginArrayRegex = /((?:"plugin"|plugin)\s*:\s*)\[([\s\S]*?)\]/;
       const match = content.match(pluginArrayRegex);
       if (match) {
@@ -48988,6 +49276,7 @@ async function addPluginToOpenCodeConfig(currentVersion) {
 }
 var init_add_plugin_to_opencode_config = __esm(() => {
   init_shared();
+  init_backup_config();
   init_config_context();
   init_ensure_config_directory_exists();
   init_opencode_config_format();
@@ -49103,6 +49392,47 @@ var init_fallback_chain_resolution = __esm(() => {
 });
 
 // src/cli/model-fallback.ts
+function toFallbackModelObject(entry, provider) {
+  return {
+    model: `${provider}/${transformModelForProvider(provider, entry.model)}`,
+    ...entry.variant ? { variant: entry.variant } : {},
+    ...entry.reasoningEffort ? { reasoningEffort: entry.reasoningEffort } : {},
+    ...entry.temperature !== undefined ? { temperature: entry.temperature } : {},
+    ...entry.top_p !== undefined ? { top_p: entry.top_p } : {},
+    ...entry.maxTokens !== undefined ? { maxTokens: entry.maxTokens } : {},
+    ...entry.thinking ? { thinking: entry.thinking } : {}
+  };
+}
+function collectAvailableFallbacks(fallbackChain, availability) {
+  const expandedFallbacks = fallbackChain.flatMap((entry) => entry.providers.filter((provider) => isProviderAvailable(provider, availability)).map((provider) => toFallbackModelObject(entry, provider)));
+  return expandedFallbacks.filter((entry, index, allEntries) => allEntries.findIndex((candidate) => candidate.model === entry.model && candidate.variant === entry.variant) === index);
+}
+function attachFallbackModels(config, fallbackChain, availability) {
+  const uniqueFallbacks = collectAvailableFallbacks(fallbackChain, availability);
+  const primaryIndex = uniqueFallbacks.findIndex((entry) => entry.model === config.model);
+  if (primaryIndex === -1) {
+    return config;
+  }
+  const fallbackModels = uniqueFallbacks.slice(primaryIndex + 1);
+  if (fallbackModels.length === 0) {
+    return config;
+  }
+  return {
+    ...config,
+    fallback_models: fallbackModels
+  };
+}
+function attachAllFallbackModels(config, fallbackChain, availability) {
+  const uniqueFallbacks = collectAvailableFallbacks(fallbackChain, availability);
+  const fallbackModels = uniqueFallbacks.filter((entry) => entry.model !== config.model);
+  if (fallbackModels.length === 0) {
+    return config;
+  }
+  return {
+    ...config,
+    fallback_models: fallbackModels
+  };
+}
 function generateModelConfig(config) {
   const avail = toProviderAvailability(config);
   const hasAnyProvider = avail.native.claude || avail.native.openai || avail.native.gemini || avail.opencodeZen || avail.copilot || avail.zai || avail.kimiForCoding || avail.opencodeGo;
@@ -49117,25 +49447,31 @@ function generateModelConfig(config) {
   const categories = {};
   for (const [role, req] of Object.entries(CLI_AGENT_MODEL_REQUIREMENTS)) {
     if (role === "librarian") {
+      let agentConfig;
       if (avail.opencodeGo) {
-        agents[role] = { model: "opencode-go/minimax-m2.7" };
+        agentConfig = { model: "opencode-go/minimax-m2.7" };
       } else if (avail.zai) {
-        agents[role] = { model: ZAI_MODEL };
+        agentConfig = { model: ZAI_MODEL };
+      }
+      if (agentConfig) {
+        agents[role] = attachAllFallbackModels(agentConfig, req.fallbackChain, avail);
       }
       continue;
     }
     if (role === "explore") {
+      let agentConfig;
       if (avail.native.claude) {
-        agents[role] = { model: "anthropic/claude-haiku-4-5" };
+        agentConfig = { model: "anthropic/claude-haiku-4-5" };
       } else if (avail.opencodeZen) {
-        agents[role] = { model: "opencode/claude-haiku-4-5" };
+        agentConfig = { model: "opencode/claude-haiku-4-5" };
       } else if (avail.opencodeGo) {
-        agents[role] = { model: "opencode-go/minimax-m2.7" };
+        agentConfig = { model: "opencode-go/minimax-m2.7" };
       } else if (avail.copilot) {
-        agents[role] = { model: "github-copilot/gpt-5-mini" };
+        agentConfig = { model: "github-copilot/gpt-5-mini" };
       } else {
-        agents[role] = { model: "opencode/gpt-5-nano" };
+        agentConfig = { model: "opencode/gpt-5-nano" };
       }
+      agents[role] = attachAllFallbackModels(agentConfig, req.fallbackChain, avail);
       continue;
     }
     if (role === "sisyphus") {
@@ -49146,7 +49482,8 @@ function generateModelConfig(config) {
       const resolved2 = resolveModelFromChain(fallbackChain, avail);
       if (resolved2) {
         const variant = resolved2.variant ?? req.variant;
-        agents[role] = variant ? { model: resolved2.model, variant } : { model: resolved2.model };
+        const agentConfig = variant ? { model: resolved2.model, variant } : { model: resolved2.model };
+        agents[role] = attachFallbackModels(agentConfig, fallbackChain, avail);
       }
       continue;
     }
@@ -49159,7 +49496,8 @@ function generateModelConfig(config) {
     const resolved = resolveModelFromChain(req.fallbackChain, avail);
     if (resolved) {
       const variant = resolved.variant ?? req.variant;
-      agents[role] = variant ? { model: resolved.model, variant } : { model: resolved.model };
+      const agentConfig = variant ? { model: resolved.model, variant } : { model: resolved.model };
+      agents[role] = attachFallbackModels(agentConfig, req.fallbackChain, avail);
     } else {
       agents[role] = { model: ULTIMATE_FALLBACK };
     }
@@ -49175,7 +49513,8 @@ function generateModelConfig(config) {
     const resolved = resolveModelFromChain(fallbackChain, avail);
     if (resolved) {
       const variant = resolved.variant ?? req.variant;
-      categories[cat] = variant ? { model: resolved.model, variant } : { model: resolved.model };
+      const categoryConfig = variant ? { model: resolved.model, variant } : { model: resolved.model };
+      categories[cat] = attachFallbackModels(categoryConfig, fallbackChain, avail);
     } else {
       categories[cat] = { model: ULTIMATE_FALLBACK };
     }
@@ -49192,6 +49531,7 @@ var init_model_fallback = __esm(() => {
   init_model_fallback_requirements();
   init_openai_only_model_catalog();
   init_fallback_chain_resolution();
+  init_provider_model_id_transform();
 });
 
 // src/cli/config-manager/generate-omo-config.ts
@@ -49220,7 +49560,7 @@ function deepMergeRecord(target, source) {
 }
 
 // src/cli/config-manager/write-omo-config.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6, statSync as statSync2, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync7, statSync as statSync2, writeFileSync as writeFileSync4 } from "fs";
 function isEmptyOrWhitespace2(content) {
   return content.trim().length === 0;
 }
@@ -49237,10 +49577,18 @@ function writeOmoConfig(installConfig) {
   const omoConfigPath = getOmoConfigPath();
   try {
     const newConfig = generateOmoConfig(installConfig);
-    if (existsSync7(omoConfigPath)) {
+    if (existsSync11(omoConfigPath)) {
+      const backupResult = backupConfigFile(omoConfigPath);
+      if (!backupResult.success) {
+        return {
+          success: false,
+          configPath: omoConfigPath,
+          error: `Failed to create backup: ${backupResult.error}`
+        };
+      }
       try {
         const stat = statSync2(omoConfigPath);
-        const content = readFileSync6(omoConfigPath, "utf-8");
+        const content = readFileSync7(omoConfigPath, "utf-8");
         if (stat.size === 0 || isEmptyOrWhitespace2(content)) {
           writeFileSync4(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
 `);
@@ -49278,6 +49626,7 @@ function writeOmoConfig(installConfig) {
 }
 var init_write_omo_config = __esm(() => {
   init_shared();
+  init_backup_config();
   init_config_context();
   init_ensure_config_directory_exists();
   init_generate_omo_config();
@@ -49368,7 +49717,7 @@ async function isOpenCodeInstalled() {
   const result = await findOpenCodeBinaryWithVersion();
   return result !== null;
 }
-async function getOpenCodeVersion() {
+async function getOpenCodeVersion2() {
   const result = await findOpenCodeBinaryWithVersion();
   return result?.version ?? null;
 }
@@ -49380,10 +49729,10 @@ var init_opencode_binary = __esm(() => {
 });
 
 // src/cli/config-manager/detect-current-config.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync8 } from "fs";
 function detectProvidersFromOmoConfig() {
   const omoConfigPath = getOmoConfigPath();
-  if (!existsSync8(omoConfigPath)) {
+  if (!existsSync12(omoConfigPath)) {
     return {
       hasOpenAI: true,
       hasOpencodeZen: true,
@@ -49393,7 +49742,7 @@ function detectProvidersFromOmoConfig() {
     };
   }
   try {
-    const content = readFileSync7(omoConfigPath, "utf-8");
+    const content = readFileSync8(omoConfigPath, "utf-8");
     const omoConfig = parseJsonc(content);
     if (!omoConfig || typeof omoConfig !== "object") {
       return {
@@ -49424,9 +49773,13 @@ function detectProvidersFromOmoConfig() {
 function isOurPlugin(plugin) {
   return plugin === PLUGIN_NAME || plugin.startsWith(`${PLUGIN_NAME}@`) || plugin === LEGACY_PLUGIN_NAME || plugin.startsWith(`${LEGACY_PLUGIN_NAME}@`);
 }
+function findOurPluginEntry(plugins) {
+  return plugins.find(isOurPlugin) ?? null;
+}
 function detectCurrentConfig() {
   const result = {
     isInstalled: false,
+    installedVersion: null,
     hasClaude: true,
     isMax20: true,
     hasOpenAI: true,
@@ -49447,7 +49800,11 @@ function detectCurrentConfig() {
   }
   const openCodeConfig = parseResult.config;
   const plugins = openCodeConfig.plugin ?? [];
-  result.isInstalled = plugins.some(isOurPlugin);
+  const ourPluginEntry = findOurPluginEntry(plugins);
+  result.isInstalled = !!ourPluginEntry;
+  if (ourPluginEntry) {
+    result.installedVersion = extractVersionFromPluginEntry(ourPluginEntry);
+  }
   if (!result.isInstalled) {
     return result;
   }
@@ -49469,10 +49826,10 @@ var init_detect_current_config = __esm(() => {
 });
 
 // src/cli/config-manager/bun-install.ts
-import { existsSync as existsSync9 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { join as join11 } from "path";
 function getDefaultWorkspaceDir() {
-  return join8(getOpenCodeCacheDir(), "packages");
+  return join11(getOpenCodeCacheDir(), "packages");
 }
 function readProcessOutput(stream) {
   if (!stream) {
@@ -49498,7 +49855,7 @@ async function runBunInstallWithDetails(options) {
   const outputMode = options?.outputMode ?? "pipe";
   const cacheDir = options?.workspaceDir ?? getDefaultWorkspaceDir();
   const packageJsonPath = `${cacheDir}/package.json`;
-  if (!existsSync9(packageJsonPath)) {
+  if (!existsSync13(packageJsonPath)) {
     return {
       success: false,
       error: `Workspace not initialized: ${packageJsonPath} not found. OpenCode should create this on first run.`
@@ -49574,6 +49931,7 @@ var init_config_manager = __esm(() => {
   init_opencode_binary();
   init_detect_current_config();
   init_bun_install();
+  init_backup_config();
 });
 
 // node_modules/sisteransi/src/index.js
@@ -49634,6 +49992,462 @@ var require_src = __commonJS((exports, module) => {
   module.exports = { cursor, scroll, erase, beep };
 });
 
+// node_modules/isexe/windows.js
+var require_windows = __commonJS((exports, module) => {
+  module.exports = isexe;
+  isexe.sync = sync;
+  var fs4 = __require("fs");
+  function checkPathExt(path4, options) {
+    var pathext = options.pathExt !== undefined ? options.pathExt : process.env.PATHEXT;
+    if (!pathext) {
+      return true;
+    }
+    pathext = pathext.split(";");
+    if (pathext.indexOf("") !== -1) {
+      return true;
+    }
+    for (var i2 = 0;i2 < pathext.length; i2++) {
+      var p2 = pathext[i2].toLowerCase();
+      if (p2 && path4.substr(-p2.length).toLowerCase() === p2) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function checkStat(stat, path4, options) {
+    if (!stat.isSymbolicLink() && !stat.isFile()) {
+      return false;
+    }
+    return checkPathExt(path4, options);
+  }
+  function isexe(path4, options, cb) {
+    fs4.stat(path4, function(er, stat) {
+      cb(er, er ? false : checkStat(stat, path4, options));
+    });
+  }
+  function sync(path4, options) {
+    return checkStat(fs4.statSync(path4), path4, options);
+  }
+});
+
+// node_modules/isexe/mode.js
+var require_mode = __commonJS((exports, module) => {
+  module.exports = isexe;
+  isexe.sync = sync;
+  var fs4 = __require("fs");
+  function isexe(path4, options, cb) {
+    fs4.stat(path4, function(er, stat) {
+      cb(er, er ? false : checkStat(stat, options));
+    });
+  }
+  function sync(path4, options) {
+    return checkStat(fs4.statSync(path4), options);
+  }
+  function checkStat(stat, options) {
+    return stat.isFile() && checkMode(stat, options);
+  }
+  function checkMode(stat, options) {
+    var mod = stat.mode;
+    var uid = stat.uid;
+    var gid = stat.gid;
+    var myUid = options.uid !== undefined ? options.uid : process.getuid && process.getuid();
+    var myGid = options.gid !== undefined ? options.gid : process.getgid && process.getgid();
+    var u2 = parseInt("100", 8);
+    var g2 = parseInt("010", 8);
+    var o2 = parseInt("001", 8);
+    var ug = u2 | g2;
+    var ret = mod & o2 || mod & g2 && gid === myGid || mod & u2 && uid === myUid || mod & ug && myUid === 0;
+    return ret;
+  }
+});
+
+// node_modules/isexe/index.js
+var require_isexe = __commonJS((exports, module) => {
+  var fs4 = __require("fs");
+  var core3;
+  if (process.platform === "win32" || global.TESTING_WINDOWS) {
+    core3 = require_windows();
+  } else {
+    core3 = require_mode();
+  }
+  module.exports = isexe;
+  isexe.sync = sync;
+  function isexe(path4, options, cb) {
+    if (typeof options === "function") {
+      cb = options;
+      options = {};
+    }
+    if (!cb) {
+      if (typeof Promise !== "function") {
+        throw new TypeError("callback not provided");
+      }
+      return new Promise(function(resolve2, reject) {
+        isexe(path4, options || {}, function(er, is) {
+          if (er) {
+            reject(er);
+          } else {
+            resolve2(is);
+          }
+        });
+      });
+    }
+    core3(path4, options || {}, function(er, is) {
+      if (er) {
+        if (er.code === "EACCES" || options && options.ignoreErrors) {
+          er = null;
+          is = false;
+        }
+      }
+      cb(er, is);
+    });
+  }
+  function sync(path4, options) {
+    try {
+      return core3.sync(path4, options || {});
+    } catch (er) {
+      if (options && options.ignoreErrors || er.code === "EACCES") {
+        return false;
+      } else {
+        throw er;
+      }
+    }
+  }
+});
+
+// node_modules/which/which.js
+var require_which = __commonJS((exports, module) => {
+  var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+  var path4 = __require("path");
+  var COLON = isWindows ? ";" : ":";
+  var isexe = require_isexe();
+  var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+  var getPathInfo = (cmd, opt) => {
+    const colon = opt.colon || COLON;
+    const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [
+      ...isWindows ? [process.cwd()] : [],
+      ...(opt.path || process.env.PATH || "").split(colon)
+    ];
+    const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+    const pathExt = isWindows ? pathExtExe.split(colon) : [""];
+    if (isWindows) {
+      if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
+        pathExt.unshift("");
+    }
+    return {
+      pathEnv,
+      pathExt,
+      pathExtExe
+    };
+  };
+  var which = (cmd, opt, cb) => {
+    if (typeof opt === "function") {
+      cb = opt;
+      opt = {};
+    }
+    if (!opt)
+      opt = {};
+    const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+    const found = [];
+    const step = (i2) => new Promise((resolve2, reject) => {
+      if (i2 === pathEnv.length)
+        return opt.all && found.length ? resolve2(found) : reject(getNotFoundError(cmd));
+      const ppRaw = pathEnv[i2];
+      const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+      const pCmd = path4.join(pathPart, cmd);
+      const p2 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+      resolve2(subStep(p2, i2, 0));
+    });
+    const subStep = (p2, i2, ii) => new Promise((resolve2, reject) => {
+      if (ii === pathExt.length)
+        return resolve2(step(i2 + 1));
+      const ext = pathExt[ii];
+      isexe(p2 + ext, { pathExt: pathExtExe }, (er, is) => {
+        if (!er && is) {
+          if (opt.all)
+            found.push(p2 + ext);
+          else
+            return resolve2(p2 + ext);
+        }
+        return resolve2(subStep(p2, i2, ii + 1));
+      });
+    });
+    return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+  };
+  var whichSync = (cmd, opt) => {
+    opt = opt || {};
+    const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+    const found = [];
+    for (let i2 = 0;i2 < pathEnv.length; i2++) {
+      const ppRaw = pathEnv[i2];
+      const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+      const pCmd = path4.join(pathPart, cmd);
+      const p2 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+      for (let j2 = 0;j2 < pathExt.length; j2++) {
+        const cur = p2 + pathExt[j2];
+        try {
+          const is = isexe.sync(cur, { pathExt: pathExtExe });
+          if (is) {
+            if (opt.all)
+              found.push(cur);
+            else
+              return cur;
+          }
+        } catch (ex) {}
+      }
+    }
+    if (opt.all && found.length)
+      return found;
+    if (opt.nothrow)
+      return null;
+    throw getNotFoundError(cmd);
+  };
+  module.exports = which;
+  which.sync = whichSync;
+});
+
+// node_modules/path-key/index.js
+var require_path_key = __commonJS((exports, module) => {
+  var pathKey = (options = {}) => {
+    const environment = options.env || process.env;
+    const platform = options.platform || process.platform;
+    if (platform !== "win32") {
+      return "PATH";
+    }
+    return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+  };
+  module.exports = pathKey;
+  module.exports.default = pathKey;
+});
+
+// node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = __commonJS((exports, module) => {
+  var path4 = __require("path");
+  var which = require_which();
+  var getPathKey = require_path_key();
+  function resolveCommandAttempt(parsed, withoutPathExt) {
+    const env = parsed.options.env || process.env;
+    const cwd = process.cwd();
+    const hasCustomCwd = parsed.options.cwd != null;
+    const shouldSwitchCwd = hasCustomCwd && process.chdir !== undefined && !process.chdir.disabled;
+    if (shouldSwitchCwd) {
+      try {
+        process.chdir(parsed.options.cwd);
+      } catch (err) {}
+    }
+    let resolved;
+    try {
+      resolved = which.sync(parsed.command, {
+        path: env[getPathKey({ env })],
+        pathExt: withoutPathExt ? path4.delimiter : undefined
+      });
+    } catch (e2) {} finally {
+      if (shouldSwitchCwd) {
+        process.chdir(cwd);
+      }
+    }
+    if (resolved) {
+      resolved = path4.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+    }
+    return resolved;
+  }
+  function resolveCommand(parsed) {
+    return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+  }
+  module.exports = resolveCommand;
+});
+
+// node_modules/cross-spawn/lib/util/escape.js
+var require_escape = __commonJS((exports, module) => {
+  var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+  function escapeCommand(arg) {
+    arg = arg.replace(metaCharsRegExp, "^$1");
+    return arg;
+  }
+  function escapeArgument(arg, doubleEscapeMetaChars) {
+    arg = `${arg}`;
+    arg = arg.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
+    arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+    arg = `"${arg}"`;
+    arg = arg.replace(metaCharsRegExp, "^$1");
+    if (doubleEscapeMetaChars) {
+      arg = arg.replace(metaCharsRegExp, "^$1");
+    }
+    return arg;
+  }
+  exports.command = escapeCommand;
+  exports.argument = escapeArgument;
+});
+
+// node_modules/shebang-regex/index.js
+var require_shebang_regex = __commonJS((exports, module) => {
+  module.exports = /^#!(.*)/;
+});
+
+// node_modules/shebang-command/index.js
+var require_shebang_command = __commonJS((exports, module) => {
+  var shebangRegex = require_shebang_regex();
+  module.exports = (string4 = "") => {
+    const match = string4.match(shebangRegex);
+    if (!match) {
+      return null;
+    }
+    const [path4, argument] = match[0].replace(/#! ?/, "").split(" ");
+    const binary2 = path4.split("/").pop();
+    if (binary2 === "env") {
+      return argument;
+    }
+    return argument ? `${binary2} ${argument}` : binary2;
+  };
+});
+
+// node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = __commonJS((exports, module) => {
+  var fs4 = __require("fs");
+  var shebangCommand = require_shebang_command();
+  function readShebang(command) {
+    const size = 150;
+    const buffer2 = Buffer.alloc(size);
+    let fd;
+    try {
+      fd = fs4.openSync(command, "r");
+      fs4.readSync(fd, buffer2, 0, size, 0);
+      fs4.closeSync(fd);
+    } catch (e2) {}
+    return shebangCommand(buffer2.toString());
+  }
+  module.exports = readShebang;
+});
+
+// node_modules/cross-spawn/lib/parse.js
+var require_parse = __commonJS((exports, module) => {
+  var path4 = __require("path");
+  var resolveCommand = require_resolveCommand();
+  var escape = require_escape();
+  var readShebang = require_readShebang();
+  var isWin = process.platform === "win32";
+  var isExecutableRegExp = /\.(?:com|exe)$/i;
+  var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+  function detectShebang(parsed) {
+    parsed.file = resolveCommand(parsed);
+    const shebang = parsed.file && readShebang(parsed.file);
+    if (shebang) {
+      parsed.args.unshift(parsed.file);
+      parsed.command = shebang;
+      return resolveCommand(parsed);
+    }
+    return parsed.file;
+  }
+  function parseNonShell(parsed) {
+    if (!isWin) {
+      return parsed;
+    }
+    const commandFile = detectShebang(parsed);
+    const needsShell = !isExecutableRegExp.test(commandFile);
+    if (parsed.options.forceShell || needsShell) {
+      const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+      parsed.command = path4.normalize(parsed.command);
+      parsed.command = escape.command(parsed.command);
+      parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+      const shellCommand = [parsed.command].concat(parsed.args).join(" ");
+      parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
+      parsed.command = process.env.comspec || "cmd.exe";
+      parsed.options.windowsVerbatimArguments = true;
+    }
+    return parsed;
+  }
+  function parse7(command, args, options) {
+    if (args && !Array.isArray(args)) {
+      options = args;
+      args = null;
+    }
+    args = args ? args.slice(0) : [];
+    options = Object.assign({}, options);
+    const parsed = {
+      command,
+      args,
+      options,
+      file: undefined,
+      original: {
+        command,
+        args
+      }
+    };
+    return options.shell ? parsed : parseNonShell(parsed);
+  }
+  module.exports = parse7;
+});
+
+// node_modules/cross-spawn/lib/enoent.js
+var require_enoent = __commonJS((exports, module) => {
+  var isWin = process.platform === "win32";
+  function notFoundError(original, syscall) {
+    return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+      code: "ENOENT",
+      errno: "ENOENT",
+      syscall: `${syscall} ${original.command}`,
+      path: original.command,
+      spawnargs: original.args
+    });
+  }
+  function hookChildProcess(cp, parsed) {
+    if (!isWin) {
+      return;
+    }
+    const originalEmit = cp.emit;
+    cp.emit = function(name, arg1) {
+      if (name === "exit") {
+        const err = verifyENOENT(arg1, parsed);
+        if (err) {
+          return originalEmit.call(cp, "error", err);
+        }
+      }
+      return originalEmit.apply(cp, arguments);
+    };
+  }
+  function verifyENOENT(status, parsed) {
+    if (isWin && status === 1 && !parsed.file) {
+      return notFoundError(parsed.original, "spawn");
+    }
+    return null;
+  }
+  function verifyENOENTSync(status, parsed) {
+    if (isWin && status === 1 && !parsed.file) {
+      return notFoundError(parsed.original, "spawnSync");
+    }
+    return null;
+  }
+  module.exports = {
+    hookChildProcess,
+    verifyENOENT,
+    verifyENOENTSync,
+    notFoundError
+  };
+});
+
+// node_modules/cross-spawn/index.js
+var require_cross_spawn = __commonJS((exports, module) => {
+  var cp = __require("child_process");
+  var parse7 = require_parse();
+  var enoent = require_enoent();
+  function spawn(command, args, options) {
+    const parsed = parse7(command, args, options);
+    const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+    enoent.hookChildProcess(spawned, parsed);
+    return spawned;
+  }
+  function spawnSync(command, args, options) {
+    const parsed = parse7(command, args, options);
+    const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+    result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+    return result;
+  }
+  module.exports = spawn;
+  module.exports.spawn = spawn;
+  module.exports.sync = spawnSync;
+  module.exports._parse = parse7;
+  module.exports._enoent = enoent;
+});
+
 // src/hooks/auto-update-checker/constants.ts
 import * as path4 from "path";
 import * as os3 from "os";
@@ -49651,15 +50465,15 @@ function getUserOpencodeConfig() {
 function getUserOpencodeConfigJsonc() {
   return path4.join(getUserConfigDir(), "opencode.jsonc");
 }
-var PACKAGE_NAME = "oh-my-openagent", NPM_REGISTRY_URL, NPM_FETCH_TIMEOUT = 5000, CACHE_ROOT_DIR, CACHE_DIR, VERSION_FILE, INSTALLED_PACKAGE_JSON;
+var PACKAGE_NAME2 = "oh-my-opencode", NPM_REGISTRY_URL, NPM_FETCH_TIMEOUT = 5000, CACHE_ROOT_DIR, CACHE_DIR, VERSION_FILE, INSTALLED_PACKAGE_JSON;
 var init_constants3 = __esm(() => {
   init_data_path();
   init_opencode_config_dir();
-  NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
+  NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME2}/dist-tags`;
   CACHE_ROOT_DIR = getOpenCodeCacheDir();
   CACHE_DIR = path4.join(CACHE_ROOT_DIR, "packages");
   VERSION_FILE = path4.join(CACHE_ROOT_DIR, "version");
-  INSTALLED_PACKAGE_JSON = path4.join(CACHE_DIR, "node_modules", PACKAGE_NAME, "package.json");
+  INSTALLED_PACKAGE_JSON = path4.join(CACHE_DIR, "node_modules", PACKAGE_NAME2, "package.json");
 });
 
 // src/hooks/auto-update-checker/checker/config-paths.ts
@@ -49714,7 +50528,7 @@ function getLocalDevPath(directory) {
       const config2 = JSON.parse(stripJsonComments(content));
       const plugins = config2.plugin ?? [];
       for (const entry of plugins) {
-        if (entry.startsWith("file://") && entry.includes(PACKAGE_NAME)) {
+        if (entry.startsWith("file://") && entry.includes(PACKAGE_NAME2)) {
           try {
             return fileURLToPath(entry);
           } catch {
@@ -49746,7 +50560,7 @@ function findPackageJsonUp(startPath) {
         try {
           const content = fs5.readFileSync(pkgPath, "utf-8");
           const pkg = JSON.parse(content);
-          if (pkg.name === PACKAGE_NAME)
+          if (pkg.name === PACKAGE_NAME2)
             return pkgPath;
         } catch {}
       }
@@ -49795,13 +50609,15 @@ function findPluginEntry(directory) {
       const config2 = JSON.parse(stripJsonComments(content));
       const plugins = config2.plugin ?? [];
       for (const entry of plugins) {
-        if (entry === PACKAGE_NAME) {
-          return { entry, isPinned: false, pinnedVersion: null, configPath };
-        }
-        if (entry.startsWith(`${PACKAGE_NAME}@`)) {
-          const pinnedVersion = entry.slice(PACKAGE_NAME.length + 1);
-          const isPinned = EXACT_SEMVER_REGEX.test(pinnedVersion.trim());
-          return { entry, isPinned, pinnedVersion, configPath };
+        for (const pluginName of MATCH_PLUGIN_NAMES) {
+          if (entry === pluginName) {
+            return { entry, isPinned: false, pinnedVersion: null, configPath };
+          }
+          if (entry.startsWith(`${pluginName}@`)) {
+            const pinnedVersion = entry.slice(pluginName.length + 1);
+            const isPinned = EXACT_SEMVER_REGEX.test(pinnedVersion.trim());
+            return { entry, isPinned, pinnedVersion, configPath };
+          }
         }
       }
     } catch {
@@ -49810,11 +50626,12 @@ function findPluginEntry(directory) {
   }
   return null;
 }
-var EXACT_SEMVER_REGEX;
+var EXACT_SEMVER_REGEX, MATCH_PLUGIN_NAMES;
 var init_plugin_entry = __esm(() => {
   init_constants3();
   init_config_paths();
   EXACT_SEMVER_REGEX = /^\d+\.\d+\.\d+(-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?(\+[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?$/;
+  MATCH_PLUGIN_NAMES = [PACKAGE_NAME2, PLUGIN_NAME, LEGACY_PLUGIN_NAME];
 });
 
 // src/hooks/auto-update-checker/checker/cached-version.ts
@@ -50022,7 +50839,7 @@ function syncCachePackageJsonToIntent(pluginInfo) {
   if (!fs9.existsSync(cachePackageJsonPath)) {
     log("[auto-update-checker] Cache package.json missing, creating workspace package.json", { intentVersion });
     return {
-      ...writeCachePackageJson(cachePackageJsonPath, { dependencies: { [PACKAGE_NAME]: intentVersion } }),
+      ...writeCachePackageJson(cachePackageJsonPath, { dependencies: { [PACKAGE_NAME2]: intentVersion } }),
       message: `Created cache package.json with: ${intentVersion}`
     };
   }
@@ -50040,21 +50857,21 @@ function syncCachePackageJsonToIntent(pluginInfo) {
     log("[auto-update-checker] Failed to parse cache package.json:", err);
     return { synced: false, error: "parse_error", message: "Failed to parse cache package.json (malformed JSON)" };
   }
-  if (!pkgJson || !pkgJson.dependencies?.[PACKAGE_NAME]) {
+  if (!pkgJson || !pkgJson.dependencies?.[PACKAGE_NAME2]) {
     log("[auto-update-checker] Plugin missing from cache package.json dependencies, adding dependency", { intentVersion });
     const nextPkgJson = {
       ...pkgJson ?? {},
       dependencies: {
         ...pkgJson?.dependencies ?? {},
-        [PACKAGE_NAME]: intentVersion
+        [PACKAGE_NAME2]: intentVersion
       }
     };
     return {
       ...writeCachePackageJson(cachePackageJsonPath, nextPkgJson),
-      message: `Added ${PACKAGE_NAME}: ${intentVersion}`
+      message: `Added ${PACKAGE_NAME2}: ${intentVersion}`
     };
   }
-  const currentVersion = pkgJson.dependencies[PACKAGE_NAME];
+  const currentVersion = pkgJson.dependencies[PACKAGE_NAME2];
   if (currentVersion === intentVersion) {
     log("[auto-update-checker] Cache package.json already matches intent:", intentVersion);
     return { synced: false, error: null, message: `Already matches intent: ${intentVersion}` };
@@ -50066,7 +50883,7 @@ function syncCachePackageJsonToIntent(pluginInfo) {
   } else {
     log(`[auto-update-checker] Updating cache package.json: "${currentVersion}" \u2192 "${intentVersion}"`);
   }
-  pkgJson.dependencies[PACKAGE_NAME] = intentVersion;
+  pkgJson.dependencies[PACKAGE_NAME2] = intentVersion;
   return {
     ...writeCachePackageJson(cachePackageJsonPath, pkgJson),
     message: `Updated: "${currentVersion}" \u2192 "${intentVersion}"`
@@ -50132,7 +50949,7 @@ function removeFromBunLock(packageName) {
   }
   return false;
 }
-function invalidatePackage(packageName = PACKAGE_NAME) {
+function invalidatePackage(packageName = PACKAGE_NAME2) {
   try {
     const userConfigDir = getUserConfigDir();
     const pkgDirs = [
@@ -50197,8 +51014,8 @@ var init_update_toasts = __esm(() => {
 });
 
 // src/hooks/auto-update-checker/hook/background-update-check.ts
-import { existsSync as existsSync21 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync25 } from "fs";
+import { join as join24 } from "path";
 function getCacheWorkspaceDir(deps) {
   return deps.join(deps.getOpenCodeCacheDir(), "packages");
 }
@@ -50208,8 +51025,8 @@ function getPinnedVersionToastMessage(latestVersion) {
 function resolveActiveInstallWorkspace(deps) {
   const configPaths = deps.getOpenCodeConfigPaths({ binary: "opencode" });
   const cacheDir = getCacheWorkspaceDir(deps);
-  const configInstallPath = deps.join(configPaths.configDir, "node_modules", PACKAGE_NAME, "package.json");
-  const cacheInstallPath = deps.join(cacheDir, "node_modules", PACKAGE_NAME, "package.json");
+  const configInstallPath = deps.join(configPaths.configDir, "node_modules", PACKAGE_NAME2, "package.json");
+  const cacheInstallPath = deps.join(cacheDir, "node_modules", PACKAGE_NAME2, "package.json");
   if (deps.existsSync(configInstallPath)) {
     deps.log(`[auto-update-checker] Active workspace: config-dir (${configPaths.configDir})`);
     return configPaths.configDir;
@@ -50255,8 +51072,8 @@ function createBackgroundUpdateCheckRunner(overrides = {}) {
       deps.log("[auto-update-checker] Plugin not found in config");
       return;
     }
-    const cachedVersion = deps.getCachedVersion();
-    const currentVersion = cachedVersion ?? pluginInfo.pinnedVersion;
+    const cachedVersion2 = deps.getCachedVersion();
+    const currentVersion = cachedVersion2 ?? pluginInfo.pinnedVersion;
     if (!currentVersion) {
       deps.log("[auto-update-checker] No version found (cached or pinned)");
       return;
@@ -50288,7 +51105,7 @@ function createBackgroundUpdateCheckRunner(overrides = {}) {
       await deps.showUpdateAvailableToast(ctx, latestVersion, getToastMessage);
       return;
     }
-    deps.invalidatePackage(PACKAGE_NAME);
+    deps.invalidatePackage(PACKAGE_NAME2);
     const activeWorkspace = resolveActiveInstallWorkspace(deps);
     const installSuccess = await runBunInstallSafe(activeWorkspace, deps);
     if (installSuccess) {
@@ -50316,8 +51133,8 @@ var init_background_update_check = __esm(() => {
   init_checker();
   init_update_toasts();
   defaultDeps = {
-    existsSync: existsSync21,
-    join: join20,
+    existsSync: existsSync25,
+    join: join24,
     runBunInstallWithDetails,
     log,
     getOpenCodeCacheDir,
@@ -50526,9 +51343,9 @@ v${latestVersion} available. Restart OpenCode to apply.` : "OpenCode is now on S
         return;
       hasChecked = true;
       setTimeout(async () => {
-        const cachedVersion = getCachedVersion();
+        const cachedVersion2 = getCachedVersion();
         const localDevVersion = getLocalDevVersion(ctx.directory);
-        const displayVersion = localDevVersion ?? cachedVersion;
+        const displayVersion = localDevVersion ?? cachedVersion2;
         await showConfigErrorsIfAny(ctx);
         await updateAndShowConnectedProvidersCacheStatus(ctx);
         await refreshModelCapabilitiesOnStartup(modelCapabilities);
@@ -50597,7 +51414,7 @@ var {
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "3.15.2",
+  version: "3.16.0",
   description: "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   main: "./dist/index.js",
   types: "dist/index.d.ts",
@@ -50656,8 +51473,8 @@ var package_default = {
     "@clack/prompts": "^0.11.0",
     "@code-yeongyu/comment-checker": "^0.7.0",
     "@modelcontextprotocol/sdk": "^1.25.2",
-    "@opencode-ai/plugin": "^1.2.24",
-    "@opencode-ai/sdk": "^1.2.24",
+    "@opencode-ai/plugin": "^1.4.0",
+    "@opencode-ai/sdk": "^1.4.0",
     commander: "^14.0.2",
     "detect-libc": "^2.0.0",
     diff: "^8.0.3",
@@ -50666,7 +51483,7 @@ var package_default = {
     picocolors: "^1.1.1",
     picomatch: "^4.0.2",
     "vscode-jsonrpc": "^8.2.0",
-    zod: "^4.1.8"
+    zod: "^4.3.0"
   },
   devDependencies: {
     "@types/js-yaml": "^4.0.9",
@@ -50675,21 +51492,19 @@ var package_default = {
     typescript: "^5.7.3"
   },
   optionalDependencies: {
-    "oh-my-opencode-darwin-arm64": "3.15.2",
-    "oh-my-opencode-darwin-x64": "3.15.2",
-    "oh-my-opencode-darwin-x64-baseline": "3.15.2",
-    "oh-my-opencode-linux-arm64": "3.15.2",
-    "oh-my-opencode-linux-arm64-musl": "3.15.2",
-    "oh-my-opencode-linux-x64": "3.15.2",
-    "oh-my-opencode-linux-x64-baseline": "3.15.2",
-    "oh-my-opencode-linux-x64-musl": "3.15.2",
-    "oh-my-opencode-linux-x64-musl-baseline": "3.15.2",
-    "oh-my-opencode-windows-x64": "3.15.2",
-    "oh-my-opencode-windows-x64-baseline": "3.15.2"
-  },
-  overrides: {
-    "@opencode-ai/sdk": "^1.2.24"
+    "oh-my-opencode-darwin-arm64": "3.16.0",
+    "oh-my-opencode-darwin-x64": "3.16.0",
+    "oh-my-opencode-darwin-x64-baseline": "3.16.0",
+    "oh-my-opencode-linux-arm64": "3.16.0",
+    "oh-my-opencode-linux-arm64-musl": "3.16.0",
+    "oh-my-opencode-linux-x64": "3.16.0",
+    "oh-my-opencode-linux-x64-baseline": "3.16.0",
+    "oh-my-opencode-linux-x64-musl": "3.16.0",
+    "oh-my-opencode-linux-x64-musl-baseline": "3.16.0",
+    "oh-my-opencode-windows-x64": "3.16.0",
+    "oh-my-opencode-windows-x64-baseline": "3.16.0"
   },
+  overrides: {},
   trustedDependencies: [
     "@ast-grep/cli",
     "@ast-grep/napi",
@@ -50700,7 +51515,7 @@ var package_default = {
 // src/cli/cli-installer.ts
 init_shared();
 init_config_manager();
-var import_picocolors2 = __toESM(require_picocolors(), 1);
+var import_picocolors3 = __toESM(require_picocolors(), 1);
 
 // src/cli/install-validators.ts
 var import_picocolors = __toESM(require_picocolors(), 1);
@@ -50847,6 +51662,56 @@ function detectedToInitialValues(detected) {
   };
 }
 
+// src/cli/doctor/constants.ts
+init_shared();
+var import_picocolors2 = __toESM(require_picocolors(), 1);
+var SYMBOLS2 = {
+  check: import_picocolors2.default.green("\u2713"),
+  cross: import_picocolors2.default.red("\u2717"),
+  warn: import_picocolors2.default.yellow("\u26A0"),
+  info: import_picocolors2.default.blue("\u2139"),
+  arrow: import_picocolors2.default.cyan("\u2192"),
+  bullet: import_picocolors2.default.dim("\u2022"),
+  skip: import_picocolors2.default.dim("\u25CB")
+};
+var STATUS_COLORS = {
+  pass: import_picocolors2.default.green,
+  fail: import_picocolors2.default.red,
+  warn: import_picocolors2.default.yellow,
+  skip: import_picocolors2.default.dim
+};
+var CHECK_IDS = {
+  SYSTEM: "system",
+  CONFIG: "config",
+  TOOLS: "tools",
+  MODELS: "models"
+};
+var CHECK_NAMES = {
+  [CHECK_IDS.SYSTEM]: "System",
+  [CHECK_IDS.CONFIG]: "Configuration",
+  [CHECK_IDS.TOOLS]: "Tools",
+  [CHECK_IDS.MODELS]: "Models"
+};
+var EXIT_CODES = {
+  SUCCESS: 0,
+  FAILURE: 1
+};
+var MIN_OPENCODE_VERSION = "1.4.0";
+var PACKAGE_NAME = PLUGIN_NAME;
+var OPENCODE_BINARIES2 = ["opencode", "opencode-desktop"];
+
+// src/cli/minimum-opencode-version.ts
+init_opencode_version();
+function getUnsupportedOpenCodeVersionMessage(openCodeVersion) {
+  if (!openCodeVersion) {
+    return null;
+  }
+  if (compareVersions(openCodeVersion, MIN_OPENCODE_VERSION) >= 0) {
+    return null;
+  }
+  return `Detected OpenCode ${openCodeVersion}, but ${MIN_OPENCODE_VERSION}+ is required. Update OpenCode, then rerun the installer.`;
+}
+
 // src/cli/cli-installer.ts
 async function runCliInstaller(args, version) {
   const validation = validateNonTuiArgs(args);
@@ -50868,12 +51733,17 @@ async function runCliInstaller(args, version) {
   let step = 1;
   printStep(step++, totalSteps, "Checking OpenCode installation...");
   const installed = await isOpenCodeInstalled();
-  const openCodeVersion = await getOpenCodeVersion();
+  const openCodeVersion = await getOpenCodeVersion2();
   if (!installed) {
     printWarning("OpenCode binary not found. Plugin will be configured, but you'll need to install OpenCode to use it.");
     printInfo("Visit https://opencode.ai/docs for installation instructions");
   } else {
     printSuccess(`OpenCode ${openCodeVersion ?? ""} detected`);
+    const unsupportedVersionMessage = getUnsupportedOpenCodeVersionMessage(openCodeVersion);
+    if (unsupportedVersionMessage) {
+      printWarning(unsupportedVersionMessage);
+      return 1;
+    }
   }
   if (isUpdate) {
     const initial = detectedToInitialValues(detected);
@@ -50886,47 +51756,37 @@ async function runCliInstaller(args, version) {
     printError(`Failed: ${pluginResult.error}`);
     return 1;
   }
-  printSuccess(`Plugin ${isUpdate ? "verified" : "added"} ${SYMBOLS.arrow} ${import_picocolors2.default.dim(pluginResult.configPath)}`);
+  printSuccess(`Plugin ${isUpdate ? "verified" : "added"} ${SYMBOLS.arrow} ${import_picocolors3.default.dim(pluginResult.configPath)}`);
   printStep(step++, totalSteps, `Writing ${PLUGIN_NAME} configuration...`);
   const omoResult = writeOmoConfig(config);
   if (!omoResult.success) {
     printError(`Failed: ${omoResult.error}`);
     return 1;
   }
-  printSuccess(`Config written ${SYMBOLS.arrow} ${import_picocolors2.default.dim(omoResult.configPath)}`);
+  printSuccess(`Config written ${SYMBOLS.arrow} ${import_picocolors3.default.dim(omoResult.configPath)}`);
   printBox(formatConfigSummary(config), isUpdate ? "Updated Configuration" : "Installation Complete");
   if (!config.hasClaude) {
-    console.log();
-    console.log(import_picocolors2.default.bgRed(import_picocolors2.default.white(import_picocolors2.default.bold(" CRITICAL WARNING "))));
-    console.log();
-    console.log(import_picocolors2.default.red(import_picocolors2.default.bold("  Sisyphus agent is STRONGLY optimized for Claude Opus 4.5.")));
-    console.log(import_picocolors2.default.red("  Without Claude, you may experience significantly degraded performance:"));
-    console.log(import_picocolors2.default.dim("    \u2022 Reduced orchestration quality"));
-    console.log(import_picocolors2.default.dim("    \u2022 Weaker tool selection and delegation"));
-    console.log(import_picocolors2.default.dim("    \u2022 Less reliable task completion"));
-    console.log();
-    console.log(import_picocolors2.default.yellow("  Consider subscribing to Claude Pro/Max for the best experience."));
-    console.log();
+    printInfo("Note: Sisyphus agent performs best with Claude Opus 4.5+. " + "Other models work but may have reduced orchestration quality.");
   }
   if (!config.hasClaude && !config.hasOpenAI && !config.hasGemini && !config.hasCopilot && !config.hasOpencodeZen) {
     printWarning("No model providers configured. Using opencode/big-pickle as fallback.");
   }
-  console.log(`${SYMBOLS.star} ${import_picocolors2.default.bold(import_picocolors2.default.green(isUpdate ? "Configuration updated!" : "Installation complete!"))}`);
-  console.log(`  Run ${import_picocolors2.default.cyan("opencode")} to start!`);
+  console.log(`${SYMBOLS.star} ${import_picocolors3.default.bold(import_picocolors3.default.green(isUpdate ? "Configuration updated!" : "Installation complete!"))}`);
+  console.log(`  Run ${import_picocolors3.default.cyan("opencode")} to start!`);
   console.log();
-  printBox(`${import_picocolors2.default.bold("Pro Tip:")} Include ${import_picocolors2.default.cyan("ultrawork")} (or ${import_picocolors2.default.cyan("ulw")}) in your prompt.
+  printBox(`${import_picocolors3.default.bold("Pro Tip:")} Include ${import_picocolors3.default.cyan("ultrawork")} (or ${import_picocolors3.default.cyan("ulw")}) in your prompt.
 ` + `All features work like magic-parallel agents, background tasks,
 ` + `deep exploration, and relentless execution until completion.`, "The Magic Word");
-  console.log(`${SYMBOLS.star} ${import_picocolors2.default.yellow("If you found this helpful, consider starring the repo!")}`);
-  console.log(`  ${import_picocolors2.default.dim("gh api --silent --method PUT /user/starred/code-yeongyu/oh-my-openagent >/dev/null 2>&1 || true")}`);
+  console.log(`${SYMBOLS.star} ${import_picocolors3.default.yellow("If you found this helpful, consider starring the repo!")}`);
+  console.log(`  ${import_picocolors3.default.dim("gh api --silent --method PUT /user/starred/code-yeongyu/oh-my-openagent >/dev/null 2>&1 || true")}`);
   console.log();
-  console.log(import_picocolors2.default.dim("oMoMoMoMo... Enjoy!"));
+  console.log(import_picocolors3.default.dim("oMoMoMoMo... Enjoy!"));
   console.log();
   if ((config.hasClaude || config.hasGemini || config.hasCopilot) && !args.skipAuth) {
-    printBox(`Run ${import_picocolors2.default.cyan("opencode auth login")} and select your provider:
-` + (config.hasClaude ? `  ${SYMBOLS.bullet} Anthropic ${import_picocolors2.default.gray("\u2192 Claude Pro/Max")}
-` : "") + (config.hasGemini ? `  ${SYMBOLS.bullet} Google ${import_picocolors2.default.gray("\u2192 Gemini")}
-` : "") + (config.hasCopilot ? `  ${SYMBOLS.bullet} GitHub ${import_picocolors2.default.gray("\u2192 Copilot")}` : ""), "Authenticate Your Providers");
+    printBox(`Run ${import_picocolors3.default.cyan("opencode auth login")} and select your provider:
+` + (config.hasClaude ? `  ${SYMBOLS.bullet} Anthropic ${import_picocolors3.default.gray("\u2192 Claude Pro/Max")}
+` : "") + (config.hasGemini ? `  ${SYMBOLS.bullet} Google ${import_picocolors3.default.gray("\u2192 Gemini")}
+` : "") + (config.hasCopilot ? `  ${SYMBOLS.bullet} GitHub ${import_picocolors3.default.gray("\u2192 Copilot")}` : ""), "Authenticate Your Providers");
   }
   return 0;
 }
@@ -51321,7 +52181,7 @@ class LD extends x {
 }
 
 // node_modules/@clack/prompts/dist/index.mjs
-var import_picocolors3 = __toESM(require_picocolors(), 1);
+var import_picocolors4 = __toESM(require_picocolors(), 1);
 var import_sisteransi2 = __toESM(require_src(), 1);
 import y2 from "process";
 function ce() {
@@ -51354,13 +52214,13 @@ var b2 = (t) => {
   switch (t) {
     case "initial":
     case "active":
-      return import_picocolors3.default.cyan(le);
+      return import_picocolors4.default.cyan(le);
     case "cancel":
-      return import_picocolors3.default.red(L2);
+      return import_picocolors4.default.red(L2);
     case "error":
-      return import_picocolors3.default.yellow(W2);
+      return import_picocolors4.default.yellow(W2);
     case "submit":
-      return import_picocolors3.default.green(C);
+      return import_picocolors4.default.green(C);
   }
 };
 var G2 = (t) => {
@@ -51370,7 +52230,7 @@ var G2 = (t) => {
   const $2 = a < r2.length && l2 > 0, g2 = a < r2.length && l2 + a < r2.length;
   return r2.slice(l2, l2 + a).map((p2, v, f) => {
     const j2 = v === 0 && $2, E = v === f.length - 1 && g2;
-    return j2 || E ? import_picocolors3.default.dim("...") : i2(p2, v + l2 === n);
+    return j2 || E ? import_picocolors4.default.dim("...") : i2(p2, v + l2 === n);
   });
 };
 var ve = (t) => {
@@ -51378,29 +52238,29 @@ var ve = (t) => {
     const s = r2.label ?? String(r2.value);
     switch (i2) {
       case "selected":
-        return `${import_picocolors3.default.dim(s)}`;
+        return `${import_picocolors4.default.dim(s)}`;
       case "active":
-        return `${import_picocolors3.default.green(k2)} ${s} ${r2.hint ? import_picocolors3.default.dim(`(${r2.hint})`) : ""}`;
+        return `${import_picocolors4.default.green(k2)} ${s} ${r2.hint ? import_picocolors4.default.dim(`(${r2.hint})`) : ""}`;
       case "cancelled":
-        return `${import_picocolors3.default.strikethrough(import_picocolors3.default.dim(s))}`;
+        return `${import_picocolors4.default.strikethrough(import_picocolors4.default.dim(s))}`;
       default:
-        return `${import_picocolors3.default.dim(P2)} ${import_picocolors3.default.dim(s)}`;
+        return `${import_picocolors4.default.dim(P2)} ${import_picocolors4.default.dim(s)}`;
     }
   };
   return new LD({ options: t.options, initialValue: t.initialValue, render() {
-    const r2 = `${import_picocolors3.default.gray(o)}
+    const r2 = `${import_picocolors4.default.gray(o)}
 ${b2(this.state)}  ${t.message}
 `;
     switch (this.state) {
       case "submit":
-        return `${r2}${import_picocolors3.default.gray(o)}  ${n(this.options[this.cursor], "selected")}`;
+        return `${r2}${import_picocolors4.default.gray(o)}  ${n(this.options[this.cursor], "selected")}`;
       case "cancel":
-        return `${r2}${import_picocolors3.default.gray(o)}  ${n(this.options[this.cursor], "cancelled")}
-${import_picocolors3.default.gray(o)}`;
+        return `${r2}${import_picocolors4.default.gray(o)}  ${n(this.options[this.cursor], "cancelled")}
+${import_picocolors4.default.gray(o)}`;
       default:
-        return `${r2}${import_picocolors3.default.cyan(o)}  ${G2({ cursor: this.cursor, options: this.options, maxItems: t.maxItems, style: (i2, s) => n(i2, s ? "active" : "inactive") }).join(`
-${import_picocolors3.default.cyan(o)}  `)}
-${import_picocolors3.default.cyan(d2)}
+        return `${r2}${import_picocolors4.default.cyan(o)}  ${G2({ cursor: this.cursor, options: this.options, maxItems: t.maxItems, style: (i2, s) => n(i2, s ? "active" : "inactive") }).join(`
+${import_picocolors4.default.cyan(o)}  `)}
+${import_picocolors4.default.cyan(d2)}
 `;
     }
   } }).prompt();
@@ -51412,53 +52272,53 @@ ${t}
 `), i2 = S2(n).length, s = Math.max(r2.reduce((a, l2) => {
     const $2 = S2(l2);
     return $2.length > a ? $2.length : a;
-  }, 0), i2) + 2, c = r2.map((a) => `${import_picocolors3.default.gray(o)}  ${import_picocolors3.default.dim(a)}${" ".repeat(s - S2(a).length)}${import_picocolors3.default.gray(o)}`).join(`
+  }, 0), i2) + 2, c = r2.map((a) => `${import_picocolors4.default.gray(o)}  ${import_picocolors4.default.dim(a)}${" ".repeat(s - S2(a).length)}${import_picocolors4.default.gray(o)}`).join(`
 `);
-  process.stdout.write(`${import_picocolors3.default.gray(o)}
-${import_picocolors3.default.green(C)}  ${import_picocolors3.default.reset(n)} ${import_picocolors3.default.gray(_2.repeat(Math.max(s - i2 - 1, 1)) + me)}
+  process.stdout.write(`${import_picocolors4.default.gray(o)}
+${import_picocolors4.default.green(C)}  ${import_picocolors4.default.reset(n)} ${import_picocolors4.default.gray(_2.repeat(Math.max(s - i2 - 1, 1)) + me)}
 ${c}
-${import_picocolors3.default.gray(de + _2.repeat(s + 2) + pe)}
+${import_picocolors4.default.gray(de + _2.repeat(s + 2) + pe)}
 `);
 };
 var xe = (t = "") => {
-  process.stdout.write(`${import_picocolors3.default.gray(d2)}  ${import_picocolors3.default.red(t)}
+  process.stdout.write(`${import_picocolors4.default.gray(d2)}  ${import_picocolors4.default.red(t)}
 
 `);
 };
 var Ie = (t = "") => {
-  process.stdout.write(`${import_picocolors3.default.gray(ue)}  ${t}
+  process.stdout.write(`${import_picocolors4.default.gray(ue)}  ${t}
 `);
 };
 var Se = (t = "") => {
-  process.stdout.write(`${import_picocolors3.default.gray(o)}
-${import_picocolors3.default.gray(d2)}  ${t}
+  process.stdout.write(`${import_picocolors4.default.gray(o)}
+${import_picocolors4.default.gray(d2)}  ${t}
 
 `);
 };
-var M2 = { message: (t = "", { symbol: n = import_picocolors3.default.gray(o) } = {}) => {
-  const r2 = [`${import_picocolors3.default.gray(o)}`];
+var M2 = { message: (t = "", { symbol: n = import_picocolors4.default.gray(o) } = {}) => {
+  const r2 = [`${import_picocolors4.default.gray(o)}`];
   if (t) {
     const [i2, ...s] = t.split(`
 `);
-    r2.push(`${n}  ${i2}`, ...s.map((c) => `${import_picocolors3.default.gray(o)}  ${c}`));
+    r2.push(`${n}  ${i2}`, ...s.map((c) => `${import_picocolors4.default.gray(o)}  ${c}`));
   }
   process.stdout.write(`${r2.join(`
 `)}
 `);
 }, info: (t) => {
-  M2.message(t, { symbol: import_picocolors3.default.blue(q) });
+  M2.message(t, { symbol: import_picocolors4.default.blue(q) });
 }, success: (t) => {
-  M2.message(t, { symbol: import_picocolors3.default.green(D) });
+  M2.message(t, { symbol: import_picocolors4.default.green(D) });
 }, step: (t) => {
-  M2.message(t, { symbol: import_picocolors3.default.green(C) });
+  M2.message(t, { symbol: import_picocolors4.default.green(C) });
 }, warn: (t) => {
-  M2.message(t, { symbol: import_picocolors3.default.yellow(U) });
+  M2.message(t, { symbol: import_picocolors4.default.yellow(U) });
 }, warning: (t) => {
   M2.warn(t);
 }, error: (t) => {
-  M2.message(t, { symbol: import_picocolors3.default.red(K2) });
+  M2.message(t, { symbol: import_picocolors4.default.red(K2) });
 } };
-var J2 = `${import_picocolors3.default.gray(o)}  `;
+var J2 = `${import_picocolors4.default.gray(o)}  `;
 var Y2 = ({ indicator: t = "dots" } = {}) => {
   const n = V2 ? ["\u25D2", "\u25D0", "\u25D3", "\u25D1"] : ["\u2022", "o", "O", "0"], r2 = V2 ? 80 : 120, i2 = process.env.CI === "true";
   let s, c, a = false, l2 = "", $2, g2 = performance.now();
@@ -51481,14 +52341,14 @@ var Y2 = ({ indicator: t = "dots" } = {}) => {
     const h2 = (performance.now() - m2) / 1000, w2 = Math.floor(h2 / 60), I2 = Math.floor(h2 % 60);
     return w2 > 0 ? `[${w2}m ${I2}s]` : `[${I2}s]`;
   }, H = (m2 = "") => {
-    a = true, s = fD(), l2 = R2(m2), g2 = performance.now(), process.stdout.write(`${import_picocolors3.default.gray(o)}
+    a = true, s = fD(), l2 = R2(m2), g2 = performance.now(), process.stdout.write(`${import_picocolors4.default.gray(o)}
 `);
     let h2 = 0, w2 = 0;
     j2(), c = setInterval(() => {
       if (i2 && l2 === $2)
         return;
       B2(), $2 = l2;
-      const I2 = import_picocolors3.default.magenta(n[h2]);
+      const I2 = import_picocolors4.default.magenta(n[h2]);
       if (i2)
         process.stdout.write(`${I2}  ${l2}...`);
       else if (t === "timer")
@@ -51501,7 +52361,7 @@ var Y2 = ({ indicator: t = "dots" } = {}) => {
     }, r2);
   }, N2 = (m2 = "", h2 = 0) => {
     a = false, clearInterval(c), B2();
-    const w2 = h2 === 0 ? import_picocolors3.default.green(C) : h2 === 1 ? import_picocolors3.default.red(L2) : import_picocolors3.default.red(W2);
+    const w2 = h2 === 0 ? import_picocolors4.default.green(C) : h2 === 1 ? import_picocolors4.default.red(L2) : import_picocolors4.default.red(W2);
     l2 = R2(m2 ?? l2), t === "timer" ? process.stdout.write(`${w2}  ${l2} ${O2(g2)}
 `) : process.stdout.write(`${w2}  ${l2}
 `), E(), s();
@@ -51514,7 +52374,7 @@ var Y2 = ({ indicator: t = "dots" } = {}) => {
 // src/cli/tui-installer.ts
 init_shared();
 init_config_manager();
-var import_picocolors4 = __toESM(require_picocolors(), 1);
+var import_picocolors5 = __toESM(require_picocolors(), 1);
 
 // src/cli/tui-install-prompts.ts
 async function selectOrCancel(params) {
@@ -51635,7 +52495,7 @@ async function runTuiInstaller(args, version) {
   }
   const detected = detectCurrentConfig();
   const isUpdate = detected.isInstalled;
-  Ie(import_picocolors4.default.bgMagenta(import_picocolors4.default.white(isUpdate ? " oMoMoMoMo... Update " : " oMoMoMoMo... ")));
+  Ie(import_picocolors5.default.bgMagenta(import_picocolors5.default.white(isUpdate ? " oMoMoMoMo... Update " : " oMoMoMoMo... ")));
   if (isUpdate) {
     const initial = detectedToInitialValues(detected);
     M2.info(`Existing configuration detected: Claude=${initial.claude}, Gemini=${initial.gemini}`);
@@ -51643,13 +52503,19 @@ async function runTuiInstaller(args, version) {
   const spinner = Y2();
   spinner.start("Checking OpenCode installation");
   const installed = await isOpenCodeInstalled();
-  const openCodeVersion = await getOpenCodeVersion();
+  const openCodeVersion = await getOpenCodeVersion2();
   if (!installed) {
-    spinner.stop(`OpenCode binary not found ${import_picocolors4.default.yellow("[!]")}`);
+    spinner.stop(`OpenCode binary not found ${import_picocolors5.default.yellow("[!]")}`);
     M2.warn("OpenCode binary not found. Plugin will be configured, but you'll need to install OpenCode to use it.");
     Me("Visit https://opencode.ai/docs for installation instructions", "Installation Guide");
   } else {
-    spinner.stop(`OpenCode ${openCodeVersion ?? "installed"} ${import_picocolors4.default.green("[OK]")}`);
+    spinner.stop(`OpenCode ${openCodeVersion ?? "installed"} ${import_picocolors5.default.green("[OK]")}`);
+    const unsupportedVersionMessage = getUnsupportedOpenCodeVersionMessage(openCodeVersion);
+    if (unsupportedVersionMessage) {
+      M2.warn(unsupportedVersionMessage);
+      Se(import_picocolors5.default.red("Installation blocked."));
+      return 1;
+    }
   }
   const config = await promptInstallConfig(detected);
   if (!config)
@@ -51658,55 +52524,46 @@ async function runTuiInstaller(args, version) {
   const pluginResult = await addPluginToOpenCodeConfig(version);
   if (!pluginResult.success) {
     spinner.stop(`Failed to add plugin: ${pluginResult.error}`);
-    Se(import_picocolors4.default.red("Installation failed."));
+    Se(import_picocolors5.default.red("Installation failed."));
     return 1;
   }
-  spinner.stop(`Plugin added to ${import_picocolors4.default.cyan(pluginResult.configPath)}`);
+  spinner.stop(`Plugin added to ${import_picocolors5.default.cyan(pluginResult.configPath)}`);
   spinner.start(`Writing ${PLUGIN_NAME} configuration`);
   const omoResult = writeOmoConfig(config);
   if (!omoResult.success) {
     spinner.stop(`Failed to write config: ${omoResult.error}`);
-    Se(import_picocolors4.default.red("Installation failed."));
+    Se(import_picocolors5.default.red("Installation failed."));
     return 1;
   }
-  spinner.stop(`Config written to ${import_picocolors4.default.cyan(omoResult.configPath)}`);
+  spinner.stop(`Config written to ${import_picocolors5.default.cyan(omoResult.configPath)}`);
   if (!config.hasClaude) {
-    console.log();
-    console.log(import_picocolors4.default.bgRed(import_picocolors4.default.white(import_picocolors4.default.bold(" CRITICAL WARNING "))));
-    console.log();
-    console.log(import_picocolors4.default.red(import_picocolors4.default.bold("  Sisyphus agent is STRONGLY optimized for Claude Opus 4.5.")));
-    console.log(import_picocolors4.default.red("  Without Claude, you may experience significantly degraded performance:"));
-    console.log(import_picocolors4.default.dim("    \u2022 Reduced orchestration quality"));
-    console.log(import_picocolors4.default.dim("    \u2022 Weaker tool selection and delegation"));
-    console.log(import_picocolors4.default.dim("    \u2022 Less reliable task completion"));
-    console.log();
-    console.log(import_picocolors4.default.yellow("  Consider subscribing to Claude Pro/Max for the best experience."));
-    console.log();
+    M2.info(`${import_picocolors5.default.bold("Note:")} Sisyphus agent performs best with Claude Opus 4.5+.
+` + `Other models work but may have reduced orchestration quality.`);
   }
   if (!config.hasClaude && !config.hasOpenAI && !config.hasGemini && !config.hasCopilot && !config.hasOpencodeZen) {
     M2.warn("No model providers configured. Using opencode/big-pickle as fallback.");
   }
   Me(formatConfigSummary(config), isUpdate ? "Updated Configuration" : "Installation Complete");
-  M2.success(import_picocolors4.default.bold(isUpdate ? "Configuration updated!" : "Installation complete!"));
-  M2.message(`Run ${import_picocolors4.default.cyan("opencode")} to start!`);
-  Me(`Include ${import_picocolors4.default.cyan("ultrawork")} (or ${import_picocolors4.default.cyan("ulw")}) in your prompt.
+  M2.success(import_picocolors5.default.bold(isUpdate ? "Configuration updated!" : "Installation complete!"));
+  M2.message(`Run ${import_picocolors5.default.cyan("opencode")} to start!`);
+  Me(`Include ${import_picocolors5.default.cyan("ultrawork")} (or ${import_picocolors5.default.cyan("ulw")}) in your prompt.
 ` + `All features work like magic-parallel agents, background tasks,
 ` + `deep exploration, and relentless execution until completion.`, "The Magic Word");
-  M2.message(`${import_picocolors4.default.yellow("\u2605")} If you found this helpful, consider starring the repo!`);
-  M2.message(`  ${import_picocolors4.default.dim("gh api --silent --method PUT /user/starred/code-yeongyu/oh-my-openagent >/dev/null 2>&1 || true")}`);
-  Se(import_picocolors4.default.green("oMoMoMoMo... Enjoy!"));
+  M2.message(`${import_picocolors5.default.yellow("\u2605")} If you found this helpful, consider starring the repo!`);
+  M2.message(`  ${import_picocolors5.default.dim("gh api --silent --method PUT /user/starred/code-yeongyu/oh-my-openagent >/dev/null 2>&1 || true")}`);
+  Se(import_picocolors5.default.green("oMoMoMoMo... Enjoy!"));
   if ((config.hasClaude || config.hasGemini || config.hasCopilot) && !args.skipAuth) {
     const providers = [];
     if (config.hasClaude)
-      providers.push(`Anthropic ${import_picocolors4.default.gray("\u2192 Claude Pro/Max")}`);
+      providers.push(`Anthropic ${import_picocolors5.default.gray("\u2192 Claude Pro/Max")}`);
     if (config.hasGemini)
-      providers.push(`Google ${import_picocolors4.default.gray("\u2192 Gemini")}`);
+      providers.push(`Google ${import_picocolors5.default.gray("\u2192 Gemini")}`);
     if (config.hasCopilot)
-      providers.push(`GitHub ${import_picocolors4.default.gray("\u2192 Copilot")}`);
+      providers.push(`GitHub ${import_picocolors5.default.gray("\u2192 Copilot")}`);
     console.log();
-    console.log(import_picocolors4.default.bold("Authenticate Your Providers"));
+    console.log(import_picocolors5.default.bold("Authenticate Your Providers"));
     console.log();
-    console.log(`   Run ${import_picocolors4.default.cyan("opencode auth login")} and select:`);
+    console.log(`   Run ${import_picocolors5.default.cyan("opencode auth login")} and select:`);
     for (const provider of providers) {
       console.log(`   ${SYMBOLS.bullet} ${provider}`);
     }
@@ -51722,7 +52579,7 @@ async function install(args) {
 }
 
 // src/cli/run/runner.ts
-var import_picocolors14 = __toESM(require_picocolors(), 1);
+var import_picocolors15 = __toESM(require_picocolors(), 1);
 
 // src/cli/run/event-state.ts
 function createEventState() {
@@ -51756,7 +52613,7 @@ function createEventState() {
   };
 }
 // src/cli/run/event-formatting.ts
-var import_picocolors5 = __toESM(require_picocolors(), 1);
+var import_picocolors6 = __toESM(require_picocolors(), 1);
 function serializeError(error) {
   if (!error)
     return "Unknown error";
@@ -51800,10 +52657,10 @@ function getSessionTag(ctx, payload) {
   const sessionID = props?.sessionID ?? props?.sessionId ?? info?.sessionID ?? info?.sessionId ?? part?.sessionID ?? part?.sessionId;
   const isMainSession = sessionID === ctx.sessionID;
   if (isMainSession)
-    return import_picocolors5.default.green("[MAIN]");
+    return import_picocolors6.default.green("[MAIN]");
   if (sessionID)
-    return import_picocolors5.default.yellow(`[${String(sessionID).slice(0, 8)}]`);
-  return import_picocolors5.default.dim("[system]");
+    return import_picocolors6.default.yellow(`[${String(sessionID).slice(0, 8)}]`);
+  return import_picocolors6.default.dim("[system]");
 }
 function logEventVerbose(ctx, payload) {
   const sessionTag = getSessionTag(ctx, payload);
@@ -51812,7 +52669,7 @@ function logEventVerbose(ctx, payload) {
     case "session.idle":
     case "session.status": {
       const status = props?.status?.type ?? "idle";
-      console.error(import_picocolors5.default.dim(`${sessionTag} ${payload.type}: ${status}`));
+      console.error(import_picocolors6.default.dim(`${sessionTag} ${payload.type}: ${status}`));
       break;
     }
     case "message.part.updated": {
@@ -51820,10 +52677,10 @@ function logEventVerbose(ctx, payload) {
       const part = partProps?.part;
       if (part?.type === "tool") {
         const status = part.state?.status ?? "unknown";
-        console.error(import_picocolors5.default.dim(`${sessionTag} message.part (tool): ${part.tool ?? part.name ?? "?"} [${status}]`));
+        console.error(import_picocolors6.default.dim(`${sessionTag} message.part (tool): ${part.tool ?? part.name ?? "?"} [${status}]`));
       } else if (part?.type === "text" && part.text) {
         const preview = part.text.slice(0, 80).replace(/\n/g, "\\n");
-        console.error(import_picocolors5.default.dim(`${sessionTag} message.part (text): "${preview}${part.text.length > 80 ? "..." : ""}"`));
+        console.error(import_picocolors6.default.dim(`${sessionTag} message.part (text): "${preview}${part.text.length > 80 ? "..." : ""}"`));
       }
       break;
     }
@@ -51832,7 +52689,7 @@ function logEventVerbose(ctx, payload) {
       const field = deltaProps?.field ?? "unknown";
       const delta = deltaProps?.delta ?? "";
       const preview = delta.slice(0, 80).replace(/\n/g, "\\n");
-      console.error(import_picocolors5.default.dim(`${sessionTag} message.part.delta (${field}): "${preview}${delta.length > 80 ? "..." : ""}"`));
+      console.error(import_picocolors6.default.dim(`${sessionTag} message.part.delta (${field}): "${preview}${delta.length > 80 ? "..." : ""}"`));
       break;
     }
     case "message.updated": {
@@ -51841,7 +52698,7 @@ function logEventVerbose(ctx, payload) {
       const model = msgProps?.info?.modelID;
       const agent = msgProps?.info?.agent;
       const details = [role, agent, model].filter(Boolean).join(", ");
-      console.error(import_picocolors5.default.dim(`${sessionTag} message.updated (${details})`));
+      console.error(import_picocolors6.default.dim(`${sessionTag} message.updated (${details})`));
       break;
     }
     case "tool.execute": {
@@ -51859,32 +52716,32 @@ function logEventVerbose(ctx, payload) {
         }
       }
       const inputPreview = inputStr.slice(0, 150);
-      console.error(import_picocolors5.default.cyan(`${sessionTag} TOOL.EXECUTE: ${import_picocolors5.default.bold(toolName)}`));
-      console.error(import_picocolors5.default.dim(`   input: ${inputPreview}${inputStr.length >= 150 ? "..." : ""}`));
+      console.error(import_picocolors6.default.cyan(`${sessionTag} TOOL.EXECUTE: ${import_picocolors6.default.bold(toolName)}`));
+      console.error(import_picocolors6.default.dim(`   input: ${inputPreview}${inputStr.length >= 150 ? "..." : ""}`));
       break;
     }
     case "tool.result": {
       const resultProps = props;
       const output = resultProps?.output ?? "";
       const preview = output.slice(0, 200).replace(/\n/g, "\\n");
-      console.error(import_picocolors5.default.green(`${sessionTag} TOOL.RESULT: "${preview}${output.length > 200 ? "..." : ""}"`));
+      console.error(import_picocolors6.default.green(`${sessionTag} TOOL.RESULT: "${preview}${output.length > 200 ? "..." : ""}"`));
       break;
     }
     case "session.error": {
       const errorProps = props;
       const errorMsg = serializeError(errorProps?.error);
-      console.error(import_picocolors5.default.red(`${sessionTag} SESSION.ERROR: ${errorMsg}`));
+      console.error(import_picocolors6.default.red(`${sessionTag} SESSION.ERROR: ${errorMsg}`));
       break;
     }
     default:
-      console.error(import_picocolors5.default.dim(`${sessionTag} ${payload.type}`));
+      console.error(import_picocolors6.default.dim(`${sessionTag} ${payload.type}`));
   }
 }
 // src/cli/run/event-stream-processor.ts
-var import_picocolors8 = __toESM(require_picocolors(), 1);
+var import_picocolors9 = __toESM(require_picocolors(), 1);
 
 // src/cli/run/event-handlers.ts
-var import_picocolors7 = __toESM(require_picocolors(), 1);
+var import_picocolors8 = __toESM(require_picocolors(), 1);
 
 // src/cli/run/tool-input-preview.ts
 function formatToolHeader(toolName, input) {
@@ -52020,14 +52877,14 @@ var displayChars = {
 };
 
 // src/cli/run/output-renderer.ts
-var import_picocolors6 = __toESM(require_picocolors(), 1);
+var import_picocolors7 = __toESM(require_picocolors(), 1);
 function renderAgentHeader(agent, model, variant, agentColorsByName) {
   if (!agent && !model)
     return;
-  const agentLabel = agent ? import_picocolors6.default.bold(colorizeWithProfileColor(agent, agentColorsByName[agent])) : "";
+  const agentLabel = agent ? import_picocolors7.default.bold(colorizeWithProfileColor(agent, agentColorsByName[agent])) : "";
   const modelBase = model ?? "";
   const variantSuffix = variant ? ` (${variant})` : "";
-  const modelLabel = model ? import_picocolors6.default.dim(`${modelBase}${variantSuffix}`) : "";
+  const modelLabel = model ? import_picocolors7.default.dim(`${modelBase}${variantSuffix}`) : "";
   process.stdout.write(`
 `);
   if (modelLabel) {
@@ -52035,7 +52892,7 @@ function renderAgentHeader(agent, model, variant, agentColorsByName) {
 `);
   }
   if (agentLabel) {
-    process.stdout.write(`  ${import_picocolors6.default.dim("\u2514\u2500")} ${agentLabel}  
+    process.stdout.write(`  ${import_picocolors7.default.dim("\u2514\u2500")} ${agentLabel}  
 `);
   }
   process.stdout.write(`
@@ -52043,7 +52900,7 @@ function renderAgentHeader(agent, model, variant, agentColorsByName) {
 }
 function openThinkBlock() {
   process.stdout.write(`
-  ${import_picocolors6.default.dim("\u2503  Thinking:")} `);
+  ${import_picocolors7.default.dim("\u2503  Thinking:")} `);
 }
 function closeThinkBlock() {
   process.stdout.write(`  
@@ -52077,10 +52934,10 @@ function writePaddedText(text, atLineStart) {
 }
 function colorizeWithProfileColor(text, hexColor) {
   if (!hexColor)
-    return import_picocolors6.default.magenta(text);
+    return import_picocolors7.default.magenta(text);
   const rgb = parseHexColor(hexColor);
   if (!rgb)
-    return import_picocolors6.default.magenta(text);
+    return import_picocolors7.default.magenta(text);
   const [r2, g2, b3] = rgb;
   return `\x1B[38;2;${r2};${g2};${b3}m${text}\x1B[39m`;
 }
@@ -52120,7 +52977,7 @@ function renderCompletionMetaLine(state, messageID) {
   const agent = state.currentAgent ?? "assistant";
   const model = state.currentModel ?? "unknown-model";
   const variant = state.currentVariant ? ` (${state.currentVariant})` : "";
-  process.stdout.write(import_picocolors7.default.dim(`
+  process.stdout.write(import_picocolors8.default.dim(`
   ${displayChars.treeEnd} ${agent} \xB7 ${model}${variant} \xB7 ${elapsedSec}s  
 `));
   state.completionMetaPrintedByMessageId[messageID] = true;
@@ -52154,7 +53011,7 @@ function handleSessionError(ctx, payload, state) {
   if (getSessionId(props) === ctx.sessionID) {
     state.mainSessionError = true;
     state.lastError = serializeError(props?.error);
-    console.error(import_picocolors7.default.red(`
+    console.error(import_picocolors8.default.red(`
 [session.error] ${state.lastError}`));
   }
 }
@@ -52182,7 +53039,7 @@ function handleMessagePartUpdated(ctx, payload, state) {
     const newText = reasoningText.slice(state.lastReasoningText.length);
     if (newText) {
       const padded = writePaddedText(newText, state.thinkingAtLineStart);
-      process.stdout.write(import_picocolors7.default.dim(padded.output));
+      process.stdout.write(import_picocolors8.default.dim(padded.output));
       state.thinkingAtLineStart = padded.atLineStart;
       state.hasReceivedMeaningfulWork = true;
     }
@@ -52229,7 +53086,7 @@ function handleMessagePartDelta(ctx, payload, state) {
   if (partType === "reasoning") {
     ensureThinkBlockOpen(state);
     const padded2 = writePaddedText(delta, state.thinkingAtLineStart);
-    process.stdout.write(import_picocolors7.default.dim(padded2.output));
+    process.stdout.write(import_picocolors8.default.dim(padded2.output));
     state.thinkingAtLineStart = padded2.atLineStart;
     state.lastReasoningText += delta;
     state.hasReceivedMeaningfulWork = true;
@@ -52250,10 +53107,10 @@ function handleToolPart(_ctx, part, state) {
       return;
     state.currentTool = toolName;
     const header = formatToolHeader(toolName, part.state?.input ?? {});
-    const suffix = header.description ? ` ${import_picocolors7.default.dim(header.description)}` : "";
+    const suffix = header.description ? ` ${import_picocolors8.default.dim(header.description)}` : "";
     state.hasReceivedMeaningfulWork = true;
     process.stdout.write(`
-  ${import_picocolors7.default.cyan(header.icon)} ${import_picocolors7.default.bold(header.title)}${suffix}  
+  ${import_picocolors8.default.cyan(header.icon)} ${import_picocolors8.default.bold(header.title)}${suffix}  
 `);
   }
   if (status === "completed" || status === "error") {
@@ -52261,10 +53118,10 @@ function handleToolPart(_ctx, part, state) {
       return;
     const output = part.state?.output || "";
     if (output.trim()) {
-      process.stdout.write(import_picocolors7.default.dim(`  ${displayChars.treeEnd} output  
+      process.stdout.write(import_picocolors8.default.dim(`  ${displayChars.treeEnd} output  
 `));
       const padded = writePaddedText(output, true);
-      process.stdout.write(import_picocolors7.default.dim(padded.output + (padded.atLineStart ? "" : "  ")));
+      process.stdout.write(import_picocolors8.default.dim(padded.output + (padded.atLineStart ? "" : "  ")));
       process.stdout.write(`
 `);
     }
@@ -52326,10 +53183,10 @@ function handleToolExecute(ctx, payload, state) {
   const toolName = props?.name || "unknown";
   state.currentTool = toolName;
   const header = formatToolHeader(toolName, props?.input ?? {});
-  const suffix = header.description ? ` ${import_picocolors7.default.dim(header.description)}` : "";
+  const suffix = header.description ? ` ${import_picocolors8.default.dim(header.description)}` : "";
   state.hasReceivedMeaningfulWork = true;
   process.stdout.write(`
-  ${import_picocolors7.default.cyan(header.icon)} ${import_picocolors7.default.bold(header.title)}${suffix}  
+  ${import_picocolors8.default.cyan(header.icon)} ${import_picocolors8.default.bold(header.title)}${suffix}  
 `);
 }
 function handleToolResult(ctx, payload, state) {
@@ -52343,10 +53200,10 @@ function handleToolResult(ctx, payload, state) {
     return;
   const output = props?.output || "";
   if (output.trim()) {
-    process.stdout.write(import_picocolors7.default.dim(`  ${displayChars.treeEnd} output  
+    process.stdout.write(import_picocolors8.default.dim(`  ${displayChars.treeEnd} output  
 `));
     const padded = writePaddedText(output, true);
-    process.stdout.write(import_picocolors7.default.dim(padded.output + (padded.atLineStart ? "" : "  ")));
+    process.stdout.write(import_picocolors8.default.dim(padded.output + (padded.atLineStart ? "" : "  ")));
     process.stdout.write(`
 `);
   }
@@ -52395,7 +53252,7 @@ async function processEvents(ctx, stream, state) {
       const payload = event;
       if (!payload?.type) {
         if (ctx.verbose) {
-          console.error(import_picocolors8.default.dim(`[event] no type: ${JSON.stringify(event)}`));
+          console.error(import_picocolors9.default.dim(`[event] no type: ${JSON.stringify(event)}`));
         }
         continue;
       }
@@ -52413,7 +53270,7 @@ async function processEvents(ctx, stream, state) {
       handleToolResult(ctx, payload, state);
       handleTuiToast(ctx, payload, state);
     } catch (err) {
-      console.error(import_picocolors8.default.red(`[event error] ${err}`));
+      console.error(import_picocolors9.default.red(`[event error] ${err}`));
     }
   }
 }
@@ -66488,12 +67345,12 @@ init_shared();
 // src/shared/migrate-legacy-config-file.ts
 init_logger();
 init_write_file_atomically();
-import { existsSync as existsSync10, readFileSync as readFileSync8, renameSync as renameSync2, rmSync } from "fs";
-import { join as join9, dirname, basename } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync9, renameSync as renameSync2, rmSync } from "fs";
+import { join as join12, dirname as dirname2, basename } from "path";
 function buildCanonicalPath(legacyPath) {
-  const dir = dirname(legacyPath);
+  const dir = dirname2(legacyPath);
   const ext = basename(legacyPath).includes(".jsonc") ? ".jsonc" : ".json";
-  return join9(dir, `${CONFIG_BASENAME}${ext}`);
+  return join12(dir, `${CONFIG_BASENAME}${ext}`);
 }
 function archiveLegacyConfigFile(legacyPath) {
   const backupPath = `${legacyPath}.bak`;
@@ -66525,15 +67382,15 @@ function archiveLegacyConfigFile(legacyPath) {
   }
 }
 function migrateLegacyConfigFile(legacyPath) {
-  if (!existsSync10(legacyPath))
+  if (!existsSync14(legacyPath))
     return false;
   if (!basename(legacyPath).startsWith(LEGACY_CONFIG_BASENAME))
     return false;
   const canonicalPath = buildCanonicalPath(legacyPath);
-  if (existsSync10(canonicalPath))
+  if (existsSync14(canonicalPath))
     return false;
   try {
-    const content = readFileSync8(legacyPath, "utf-8");
+    const content = readFileSync9(legacyPath, "utf-8");
     writeFileAtomically(canonicalPath, content);
     const archivedLegacyConfig = archiveLegacyConfigFile(legacyPath);
     log("[migrateLegacyConfigFile] Migrated legacy config to canonical path", {
@@ -68064,6 +68921,31 @@ class OpencodeClient extends _HeyApiClient {
 }
 
 // node_modules/@opencode-ai/sdk/dist/client.js
+function pick2(value, fallback) {
+  if (!value)
+    return;
+  if (!fallback)
+    return value;
+  if (value === fallback)
+    return fallback;
+  if (value === encodeURIComponent(fallback))
+    return fallback;
+  return value;
+}
+function rewrite(request, directory) {
+  if (request.method !== "GET" && request.method !== "HEAD")
+    return request;
+  const value = pick2(request.headers.get("x-opencode-directory"), directory);
+  if (!value)
+    return request;
+  const url2 = new URL(request.url);
+  if (!url2.searchParams.has("directory")) {
+    url2.searchParams.set("directory", value);
+  }
+  const next = new Request(url2, request);
+  next.headers.delete("x-opencode-directory");
+  return next;
+}
 function createOpencodeClient(config2) {
   if (!config2?.fetch) {
     const customFetch = (req) => {
@@ -68082,10 +68964,46 @@ function createOpencodeClient(config2) {
     };
   }
   const client2 = createClient(config2);
+  client2.interceptors.request.use((request) => rewrite(request, config2?.directory));
   return new OpencodeClient({ client: client2 });
 }
 // node_modules/@opencode-ai/sdk/dist/server.js
-import { spawn } from "child_process";
+var import_cross_spawn = __toESM(require_cross_spawn(), 1);
+
+// node_modules/@opencode-ai/sdk/dist/process.js
+import { spawnSync } from "child_process";
+function stop(proc) {
+  if (proc.exitCode !== null || proc.signalCode !== null)
+    return;
+  if (process.platform === "win32" && proc.pid) {
+    const out = spawnSync("taskkill", ["/pid", String(proc.pid), "/T", "/F"], { windowsHide: true });
+    if (!out.error && out.status === 0)
+      return;
+  }
+  proc.kill();
+}
+function bindAbort(proc, signal, onAbort) {
+  if (!signal)
+    return () => {};
+  const abort = () => {
+    clear();
+    stop(proc);
+    onAbort?.();
+  };
+  const clear = () => {
+    signal.removeEventListener("abort", abort);
+    proc.off("exit", clear);
+    proc.off("error", clear);
+  };
+  signal.addEventListener("abort", abort, { once: true });
+  proc.on("exit", clear);
+  proc.on("error", clear);
+  if (signal.aborted)
+    abort();
+  return clear;
+}
+
+// node_modules/@opencode-ai/sdk/dist/server.js
 async function createOpencodeServer(options) {
   options = Object.assign({
     hostname: "127.0.0.1",
@@ -68095,19 +69013,24 @@ async function createOpencodeServer(options) {
   const args = [`serve`, `--hostname=${options.hostname}`, `--port=${options.port}`];
   if (options.config?.logLevel)
     args.push(`--log-level=${options.config.logLevel}`);
-  const proc = spawn(`opencode`, args, {
-    signal: options.signal,
+  const proc = import_cross_spawn.default(`opencode`, args, {
     env: {
       ...process.env,
       OPENCODE_CONFIG_CONTENT: JSON.stringify(options.config ?? {})
     }
   });
+  let clear = () => {};
   const url2 = await new Promise((resolve2, reject) => {
     const id = setTimeout(() => {
+      clear();
+      stop(proc);
       reject(new Error(`Timeout waiting for server to start after ${options.timeout}ms`));
     }, options.timeout);
     let output = "";
+    let resolved = false;
     proc.stdout?.on("data", (chunk) => {
+      if (resolved)
+        return;
       output += chunk.toString();
       const lines = output.split(`
 `);
@@ -68115,9 +69038,14 @@ async function createOpencodeServer(options) {
         if (line.startsWith("opencode server listening")) {
           const match = line.match(/on\s+(https?:\/\/[^\s]+)/);
           if (!match) {
-            throw new Error(`Failed to parse server url from output: ${line}`);
+            clear();
+            stop(proc);
+            clearTimeout(id);
+            reject(new Error(`Failed to parse server url from output: ${line}`));
+            return;
           }
           clearTimeout(id);
+          resolved = true;
           resolve2(match[1]);
           return;
         }
@@ -68139,17 +69067,16 @@ Server output: ${output}`;
       clearTimeout(id);
       reject(error48);
     });
-    if (options.signal) {
-      options.signal.addEventListener("abort", () => {
-        clearTimeout(id);
-        reject(new Error("Aborted"));
-      });
-    }
+    clear = bindAbort(proc, options.signal, () => {
+      clearTimeout(id);
+      reject(options.signal?.reason);
+    });
   });
   return {
     url: url2,
     close() {
-      proc.kill();
+      clear();
+      stop(proc);
     }
   };
 }
@@ -68169,11 +69096,11 @@ async function createOpencode(options) {
 
 // src/cli/run/server-connection.ts
 init_port_utils();
-var import_picocolors9 = __toESM(require_picocolors(), 1);
+var import_picocolors10 = __toESM(require_picocolors(), 1);
 
 // src/cli/run/opencode-binary-resolver.ts
 init_spawn_with_windows_hide();
-import { delimiter, dirname as dirname3, join as join11 } from "path";
+import { delimiter, dirname as dirname4, join as join14 } from "path";
 var OPENCODE_COMMANDS = ["opencode", "opencode-desktop"];
 var WINDOWS_SUFFIXES = ["", ".exe", ".cmd", ".bat", ".ps1"];
 function getCommandCandidates(platform) {
@@ -68196,7 +69123,7 @@ function collectCandidateBinaryPaths(pathEnv, which = Bun.which, platform = proc
   }
   for (const entry of (pathEnv ?? "").split(delimiter).filter(Boolean)) {
     for (const command of commandCandidates) {
-      addCandidate(join11(entry, command));
+      addCandidate(join14(entry, command));
     }
   }
   return candidates;
@@ -68223,7 +69150,7 @@ async function findWorkingOpencodeBinary(pathEnv = process.env.PATH, probe = can
   return null;
 }
 function buildPathWithBinaryFirst(pathEnv, binaryPath) {
-  const preferredDir = dirname3(binaryPath);
+  const preferredDir = dirname4(binaryPath);
   const existing = (pathEnv ?? "").split(delimiter).filter((entry) => entry.length > 0 && entry !== preferredDir);
   return [preferredDir, ...existing].join(delimiter);
 }
@@ -68257,13 +69184,13 @@ function isPortRangeExhausted(error48) {
 async function startServer(options) {
   const { signal, port } = options;
   const { client: client3, server: server2 } = await withWorkingOpencodePath(() => createOpencode({ signal, port, hostname: "127.0.0.1" }));
-  console.log(import_picocolors9.default.dim("Server listening at"), import_picocolors9.default.cyan(server2.url));
+  console.log(import_picocolors10.default.dim("Server listening at"), import_picocolors10.default.cyan(server2.url));
   return { client: client3, cleanup: () => server2.close() };
 }
 async function createServerConnection(options) {
   const { port, attach, signal } = options;
   if (attach !== undefined) {
-    console.log(import_picocolors9.default.dim("Attaching to existing server at"), import_picocolors9.default.cyan(attach));
+    console.log(import_picocolors10.default.dim("Attaching to existing server at"), import_picocolors10.default.cyan(attach));
     const client3 = createOpencodeClient({ baseUrl: attach });
     return { client: client3, cleanup: () => {} };
   }
@@ -68273,7 +69200,7 @@ async function createServerConnection(options) {
     }
     const available = await isPortAvailable(port, "127.0.0.1");
     if (available) {
-      console.log(import_picocolors9.default.dim("Starting server on port"), import_picocolors9.default.cyan(port.toString()));
+      console.log(import_picocolors10.default.dim("Starting server on port"), import_picocolors10.default.cyan(port.toString()));
       try {
         return await startServer({ signal, port });
       } catch (error48) {
@@ -68284,12 +69211,12 @@ async function createServerConnection(options) {
         if (stillAvailable) {
           throw error48;
         }
-        console.log(import_picocolors9.default.dim("Port"), import_picocolors9.default.cyan(port.toString()), import_picocolors9.default.dim("became occupied, attaching to existing server"));
+        console.log(import_picocolors10.default.dim("Port"), import_picocolors10.default.cyan(port.toString()), import_picocolors10.default.dim("became occupied, attaching to existing server"));
         const client4 = createOpencodeClient({ baseUrl: `http://127.0.0.1:${port}` });
         return { client: client4, cleanup: () => {} };
       }
     }
-    console.log(import_picocolors9.default.dim("Port"), import_picocolors9.default.cyan(port.toString()), import_picocolors9.default.dim("is occupied, attaching to existing server"));
+    console.log(import_picocolors10.default.dim("Port"), import_picocolors10.default.cyan(port.toString()), import_picocolors10.default.dim("is occupied, attaching to existing server"));
     const client3 = createOpencodeClient({ baseUrl: `http://127.0.0.1:${port}` });
     return { client: client3, cleanup: () => {} };
   }
@@ -68307,14 +69234,14 @@ async function createServerConnection(options) {
     if (defaultPortIsAvailable) {
       throw error48;
     }
-    console.log(import_picocolors9.default.dim("Port range exhausted, attaching to existing server on"), import_picocolors9.default.cyan(DEFAULT_SERVER_PORT.toString()));
+    console.log(import_picocolors10.default.dim("Port range exhausted, attaching to existing server on"), import_picocolors10.default.cyan(DEFAULT_SERVER_PORT.toString()));
     const client3 = createOpencodeClient({ baseUrl: `http://127.0.0.1:${DEFAULT_SERVER_PORT}` });
     return { client: client3, cleanup: () => {} };
   }
   if (wasAutoSelected) {
-    console.log(import_picocolors9.default.dim("Auto-selected port"), import_picocolors9.default.cyan(selectedPort.toString()));
+    console.log(import_picocolors10.default.dim("Auto-selected port"), import_picocolors10.default.cyan(selectedPort.toString()));
   } else {
-    console.log(import_picocolors9.default.dim("Starting server on port"), import_picocolors9.default.cyan(selectedPort.toString()));
+    console.log(import_picocolors10.default.dim("Starting server on port"), import_picocolors10.default.cyan(selectedPort.toString()));
   }
   try {
     return await startServer({ signal, port: selectedPort });
@@ -68323,13 +69250,13 @@ async function createServerConnection(options) {
       throw error48;
     }
     const { port: retryPort } = await getAvailableServerPort(selectedPort + 1, "127.0.0.1");
-    console.log(import_picocolors9.default.dim("Retrying server start on port"), import_picocolors9.default.cyan(retryPort.toString()));
+    console.log(import_picocolors10.default.dim("Retrying server start on port"), import_picocolors10.default.cyan(retryPort.toString()));
     return await startServer({ signal, port: retryPort });
   }
 }
 
 // src/cli/run/session-resolver.ts
-var import_picocolors10 = __toESM(require_picocolors(), 1);
+var import_picocolors11 = __toESM(require_picocolors(), 1);
 var SESSION_CREATE_MAX_RETRIES = 3;
 var SESSION_CREATE_RETRY_DELAY_MS = 1000;
 async function resolveSession(options) {
@@ -68355,11 +69282,11 @@ async function resolveSession(options) {
       query: { directory }
     });
     if (res.error) {
-      console.error(import_picocolors10.default.yellow(`Session create attempt ${attempt}/${SESSION_CREATE_MAX_RETRIES} failed:`));
-      console.error(import_picocolors10.default.dim(`  Error: ${serializeError(res.error)}`));
+      console.error(import_picocolors11.default.yellow(`Session create attempt ${attempt}/${SESSION_CREATE_MAX_RETRIES} failed:`));
+      console.error(import_picocolors11.default.dim(`  Error: ${serializeError(res.error)}`));
       if (attempt < SESSION_CREATE_MAX_RETRIES) {
         const delay = SESSION_CREATE_RETRY_DELAY_MS * attempt;
-        console.log(import_picocolors10.default.dim(`  Retrying in ${delay}ms...`));
+        console.log(import_picocolors11.default.dim(`  Retrying in ${delay}ms...`));
         await new Promise((resolve2) => setTimeout(resolve2, delay));
       }
       continue;
@@ -68367,10 +69294,10 @@ async function resolveSession(options) {
     if (res.data?.id) {
       return res.data.id;
     }
-    console.error(import_picocolors10.default.yellow(`Session create attempt ${attempt}/${SESSION_CREATE_MAX_RETRIES}: No session ID returned`));
+    console.error(import_picocolors11.default.yellow(`Session create attempt ${attempt}/${SESSION_CREATE_MAX_RETRIES}: No session ID returned`));
     if (attempt < SESSION_CREATE_MAX_RETRIES) {
       const delay = SESSION_CREATE_RETRY_DELAY_MS * attempt;
-      console.log(import_picocolors10.default.dim(`  Retrying in ${delay}ms...`));
+      console.log(import_picocolors11.default.dim(`  Retrying in ${delay}ms...`));
       await new Promise((resolve2) => setTimeout(resolve2, delay));
     }
   }
@@ -68488,7 +69415,7 @@ async function executeOnCompleteHook(options) {
 
 // src/cli/run/agent-resolver.ts
 init_agent_display_names();
-var import_picocolors11 = __toESM(require_picocolors(), 1);
+var import_picocolors12 = __toESM(require_picocolors(), 1);
 var CORE_AGENT_ORDER = ["sisyphus", "hephaestus", "prometheus", "atlas"];
 var DEFAULT_AGENT = "sisyphus";
 var normalizeAgentName = (agent) => {
@@ -68533,10 +69460,10 @@ var resolveRunAgent = (options, pluginConfig, env = process.env) => {
     const fallbackName = getAgentDisplayName(fallback);
     const fallbackDisabled = isAgentDisabled(fallback, pluginConfig);
     if (fallbackDisabled) {
-      console.log(import_picocolors11.default.yellow(`Requested agent "${resolved.resolvedName}" is disabled and no enabled core agent was found. Proceeding with "${fallbackName}".`));
+      console.log(import_picocolors12.default.yellow(`Requested agent "${resolved.resolvedName}" is disabled and no enabled core agent was found. Proceeding with "${fallbackName}".`));
       return fallbackName;
     }
-    console.log(import_picocolors11.default.yellow(`Requested agent "${resolved.resolvedName}" is disabled. Falling back to "${fallbackName}".`));
+    console.log(import_picocolors12.default.yellow(`Requested agent "${resolved.resolvedName}" is disabled. Falling back to "${fallbackName}".`));
     return fallbackName;
   }
   return resolved.resolvedName;
@@ -68567,11 +69494,11 @@ function resolveRunModel(modelString) {
 }
 
 // src/cli/run/poll-for-completion.ts
-var import_picocolors13 = __toESM(require_picocolors(), 1);
+var import_picocolors14 = __toESM(require_picocolors(), 1);
 
 // src/cli/run/completion.ts
 init_shared();
-var import_picocolors12 = __toESM(require_picocolors(), 1);
+var import_picocolors13 = __toESM(require_picocolors(), 1);
 // src/features/boulder-state/constants.ts
 var BOULDER_DIR = ".sisyphus";
 var BOULDER_FILE = "boulder.json";
@@ -68579,19 +69506,19 @@ var BOULDER_STATE_PATH = `${BOULDER_DIR}/${BOULDER_FILE}`;
 var NOTEPAD_DIR = "notepads";
 var NOTEPAD_BASE_PATH = `${BOULDER_DIR}/${NOTEPAD_DIR}`;
 // src/features/boulder-state/storage.ts
-import { existsSync as existsSync12, readFileSync as readFileSync10, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, readdirSync } from "fs";
-import { dirname as dirname4, join as join12, basename as basename3 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync11, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, readdirSync as readdirSync3 } from "fs";
+import { dirname as dirname5, join as join15, basename as basename3 } from "path";
 var RESERVED_KEYS = new Set(["__proto__", "prototype", "constructor"]);
 function getBoulderFilePath(directory) {
-  return join12(directory, BOULDER_DIR, BOULDER_FILE);
+  return join15(directory, BOULDER_DIR, BOULDER_FILE);
 }
 function readBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
-  if (!existsSync12(filePath)) {
+  if (!existsSync16(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync10(filePath, "utf-8");
+    const content = readFileSync11(filePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       return null;
@@ -68599,6 +69526,15 @@ function readBoulderState(directory) {
     if (!Array.isArray(parsed.session_ids)) {
       parsed.session_ids = [];
     }
+    if (!parsed.session_origins || typeof parsed.session_origins !== "object" || Array.isArray(parsed.session_origins)) {
+      parsed.session_origins = {};
+    }
+    if (parsed.session_ids.length === 1) {
+      const soleSessionId = parsed.session_ids[0];
+      if (typeof soleSessionId === "string" && parsed.session_origins[soleSessionId] !== "appended" && parsed.session_origins[soleSessionId] !== "direct") {
+        parsed.session_origins[soleSessionId] = "direct";
+      }
+    }
     if (!parsed.task_sessions || typeof parsed.task_sessions !== "object" || Array.isArray(parsed.task_sessions)) {
       parsed.task_sessions = {};
     }
@@ -68607,39 +69543,101 @@ function readBoulderState(directory) {
     return null;
   }
 }
+var TODO_HEADING_PATTERN = /^##\s+TODOs\b/i;
+var FINAL_VERIFICATION_HEADING_PATTERN = /^##\s+Final Verification Wave\b/i;
+var SECOND_LEVEL_HEADING_PATTERN = /^##\s+/;
+var UNCHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[\s*\]\s*(.+)$/;
+var CHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[[xX]\]\s*(.+)$/;
+var TODO_TASK_PATTERN = /^\d+\.\s+/;
+var FINAL_WAVE_TASK_PATTERN = /^F\d+\.\s+/i;
 function getPlanProgress(planPath) {
-  if (!existsSync12(planPath)) {
+  if (!existsSync16(planPath)) {
     return { total: 0, completed: 0, isComplete: true };
   }
   try {
-    const content = readFileSync10(planPath, "utf-8");
-    const uncheckedMatches = content.match(/^\s*[-*]\s*\[\s*\]/gm) || [];
-    const checkedMatches = content.match(/^\s*[-*]\s*\[[xX]\]/gm) || [];
-    const total = uncheckedMatches.length + checkedMatches.length;
-    const completed = checkedMatches.length;
-    return {
-      total,
-      completed,
-      isComplete: total > 0 && completed === total
-    };
+    const content = readFileSync11(planPath, "utf-8");
+    const lines = content.split(/\r?\n/);
+    const hasStructuredSections = lines.some((line) => TODO_HEADING_PATTERN.test(line) || FINAL_VERIFICATION_HEADING_PATTERN.test(line));
+    if (hasStructuredSections) {
+      return getStructuredPlanProgress(lines);
+    }
+    return getSimplePlanProgress(content);
   } catch {
     return { total: 0, completed: 0, isComplete: true };
   }
 }
+function getStructuredPlanProgress(lines) {
+  let section = "other";
+  let total = 0;
+  let completed = 0;
+  for (const line of lines) {
+    if (SECOND_LEVEL_HEADING_PATTERN.test(line)) {
+      section = TODO_HEADING_PATTERN.test(line) ? "todo" : FINAL_VERIFICATION_HEADING_PATTERN.test(line) ? "final-wave" : "other";
+      continue;
+    }
+    if (section !== "todo" && section !== "final-wave") {
+      continue;
+    }
+    const checkedMatch = line.match(CHECKED_CHECKBOX_PATTERN);
+    const uncheckedMatch = checkedMatch ? null : line.match(UNCHECKED_CHECKBOX_PATTERN);
+    const match = checkedMatch ?? uncheckedMatch;
+    if (!match) {
+      continue;
+    }
+    if (match[1].length > 0) {
+      continue;
+    }
+    const taskBody = match[2].trim();
+    const labelPattern = section === "todo" ? TODO_TASK_PATTERN : FINAL_WAVE_TASK_PATTERN;
+    if (!labelPattern.test(taskBody)) {
+      continue;
+    }
+    total++;
+    if (checkedMatch) {
+      completed++;
+    }
+  }
+  return {
+    total,
+    completed,
+    isComplete: total > 0 && completed === total
+  };
+}
+function getSimplePlanProgress(content) {
+  const uncheckedMatches = content.match(/^[-*]\s*\[\s*\]/gm) || [];
+  const checkedMatches = content.match(/^[-*]\s*\[[xX]\]/gm) || [];
+  const total = uncheckedMatches.length + checkedMatches.length;
+  const completed = checkedMatches.length;
+  return {
+    total,
+    completed,
+    isComplete: total > 0 && completed === total
+  };
+}
+// src/features/claude-code-session-state/state.ts
+init_agent_display_names();
+var subagentSessions = new Set;
+var syncSubagentSessions = new Set;
+var registeredAgentNames = new Set;
+var registeredAgentAliases = new Map;
+var sessionAgentMap = new Map;
+function getSessionAgent(sessionID) {
+  return sessionAgentMap.get(sessionID);
+}
 // src/features/run-continuation-state/constants.ts
 var CONTINUATION_MARKER_DIR = ".sisyphus/run-continuation";
 // src/features/run-continuation-state/storage.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync5, readFileSync as readFileSync11, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync6, readFileSync as readFileSync12, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
+import { join as join16 } from "path";
 function getMarkerPath(directory, sessionID) {
-  return join13(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
+  return join16(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
 }
 function readContinuationMarker(directory, sessionID) {
   const markerPath = getMarkerPath(directory, sessionID);
-  if (!existsSync13(markerPath))
+  if (!existsSync17(markerPath))
     return null;
   try {
-    const raw = readFileSync11(markerPath, "utf-8");
+    const raw = readFileSync12(markerPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
       return null;
@@ -68662,10 +69660,120 @@ function getActiveContinuationMarkerReason(marker) {
   const [source, entry] = active;
   return entry.reason ?? `${source} continuation is active`;
 }
+// src/hooks/atlas/boulder-session-lineage.ts
+init_logger();
+
+// src/hooks/atlas/hook-name.ts
+var HOOK_NAME = "atlas";
+
+// src/hooks/atlas/boulder-session-lineage.ts
+async function isSessionInBoulderLineage(input) {
+  const visitedSessionIDs = new Set;
+  let currentSessionID = input.sessionID;
+  while (!visitedSessionIDs.has(currentSessionID)) {
+    visitedSessionIDs.add(currentSessionID);
+    const sessionResult = await input.client.session.get({ path: { id: currentSessionID } }).catch((error48) => {
+      log(`[${HOOK_NAME}] Failed to resolve session lineage`, {
+        sessionID: input.sessionID,
+        currentSessionID,
+        error: error48
+      });
+      return null;
+    });
+    if (!sessionResult || sessionResult.error) {
+      return false;
+    }
+    const parentSessionID = sessionResult.data?.parentID;
+    if (!parentSessionID) {
+      return false;
+    }
+    if (input.boulderSessionIDs.includes(parentSessionID)) {
+      return true;
+    }
+    currentSessionID = parentSessionID;
+  }
+  return false;
+}
+
+// src/hooks/atlas/session-last-agent.ts
+init_shared();
+init_compaction_marker();
+import { readFileSync as readFileSync13, readdirSync as readdirSync4 } from "fs";
+import { join as join17 } from "path";
+function getLastAgentFromMessageDir(messageDir) {
+  try {
+    const messages = readdirSync4(messageDir).filter((fileName) => fileName.endsWith(".json")).map((fileName) => {
+      try {
+        const content = readFileSync13(join17(messageDir, fileName), "utf-8");
+        const parsed = JSON.parse(content);
+        return {
+          fileName,
+          id: parsed.id,
+          agent: parsed.agent,
+          createdAt: typeof parsed.time?.created === "number" ? parsed.time.created : Number.NEGATIVE_INFINITY
+        };
+      } catch {
+        return null;
+      }
+    }).filter((message) => message !== null).sort((left, right) => (right?.createdAt ?? 0) - (left?.createdAt ?? 0) || (right?.fileName ?? "").localeCompare(left?.fileName ?? ""));
+    for (const message of messages) {
+      if (!message)
+        continue;
+      if (isCompactionMessage({ agent: message.agent }) || hasCompactionPartInStorage(message?.id)) {
+        continue;
+      }
+      if (typeof message.agent === "string") {
+        return message.agent.toLowerCase();
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+async function getLastAgentFromSession(sessionID, client3) {
+  if (isSqliteBackend() && client3) {
+    try {
+      const response = await client3.session.messages({ path: { id: sessionID } });
+      const messages = normalizeSDKResponse(response, [], {
+        preferResponseOnMissingData: true
+      }).sort((left, right) => {
+        const leftTime = left.info?.time?.created ?? Number.NEGATIVE_INFINITY;
+        const rightTime = right.info?.time?.created ?? Number.NEGATIVE_INFINITY;
+        if (leftTime !== rightTime) {
+          return rightTime - leftTime;
+        }
+        const leftId = typeof left.id === "string" ? left.id : "";
+        const rightId = typeof right.id === "string" ? right.id : "";
+        return rightId.localeCompare(leftId);
+      });
+      for (const message of messages) {
+        if (isCompactionMessage(message)) {
+          continue;
+        }
+        const agent = message.info?.agent;
+        if (typeof agent === "string") {
+          return agent.toLowerCase();
+        }
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  }
+  const messageDir = getMessageDir(sessionID);
+  if (!messageDir)
+    return null;
+  return getLastAgentFromMessageDir(messageDir);
+}
+
+// src/cli/run/continuation-state.ts
+init_agent_display_names();
+
 // src/hooks/ralph-loop/storage.ts
 init_frontmatter();
-import { existsSync as existsSync14, readFileSync as readFileSync12, writeFileSync as writeFileSync7, unlinkSync, mkdirSync as mkdirSync6 } from "fs";
-import { dirname as dirname5, join as join14 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync14, writeFileSync as writeFileSync7, unlinkSync, mkdirSync as mkdirSync7 } from "fs";
+import { dirname as dirname6, join as join18 } from "path";
 
 // src/hooks/ralph-loop/constants.ts
 var DEFAULT_STATE_FILE = ".sisyphus/ralph-loop.local.md";
@@ -68674,15 +69782,15 @@ var DEFAULT_COMPLETION_PROMISE = "DONE";
 
 // src/hooks/ralph-loop/storage.ts
 function getStateFilePath(directory, customPath) {
-  return customPath ? join14(directory, customPath) : join14(directory, DEFAULT_STATE_FILE);
+  return customPath ? join18(directory, customPath) : join18(directory, DEFAULT_STATE_FILE);
 }
 function readState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
-  if (!existsSync14(filePath)) {
+  if (!existsSync18(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync12(filePath, "utf-8");
+    const content = readFileSync14(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     const active = data.active;
     const iteration = data.iteration;
@@ -68722,10 +69830,10 @@ function readState(directory, customPath) {
 }
 
 // src/cli/run/continuation-state.ts
-function getContinuationState(directory, sessionID) {
+async function getContinuationState(directory, sessionID, client3) {
   const marker = readContinuationMarker(directory, sessionID);
   return {
-    hasActiveBoulder: hasActiveBoulderContinuation(directory, sessionID),
+    hasActiveBoulder: await hasActiveBoulderContinuation(directory, sessionID, client3),
     hasActiveRalphLoop: hasActiveRalphLoopContinuation(directory, sessionID),
     hasHookMarker: marker !== null,
     hasTodoHookMarker: marker?.sources.todo !== undefined,
@@ -68733,20 +69841,54 @@ function getContinuationState(directory, sessionID) {
     activeHookMarkerReason: getActiveContinuationMarkerReason(marker)
   };
 }
-function hasActiveBoulderContinuation(directory, sessionID) {
+async function hasActiveBoulderContinuation(directory, sessionID, client3) {
   const boulder = readBoulderState(directory);
   if (!boulder)
     return false;
-  if (!boulder.session_ids.includes(sessionID))
-    return false;
   const progress = getPlanProgress(boulder.active_plan);
-  return !progress.isComplete;
+  if (progress.isComplete)
+    return false;
+  if (!client3)
+    return false;
+  const isTrackedSession = boulder.session_ids.includes(sessionID);
+  const sessionOrigin = boulder.session_origins?.[sessionID];
+  if (!isTrackedSession) {
+    return false;
+  }
+  const isTrackedDescendant = await isTrackedDescendantSession(client3, sessionID, boulder.session_ids);
+  if (isTrackedSession && sessionOrigin === "direct") {
+    return true;
+  }
+  if (isTrackedSession && sessionOrigin !== "direct" && !isTrackedDescendant) {
+    return false;
+  }
+  const sessionAgent = await getLastAgentFromSession(sessionID, client3) ?? getSessionAgent(sessionID);
+  if (!sessionAgent) {
+    return false;
+  }
+  const requiredAgentKey = getAgentConfigKey(boulder.agent ?? "atlas");
+  const sessionAgentKey = getAgentConfigKey(sessionAgent);
+  if (sessionAgentKey !== requiredAgentKey && !(requiredAgentKey === getAgentConfigKey("atlas") && sessionAgentKey === getAgentConfigKey("sisyphus"))) {
+    return false;
+  }
+  return isTrackedSession || isTrackedDescendant;
+}
+async function isTrackedDescendantSession(client3, sessionID, trackedSessionIDs) {
+  const ancestorSessionIDs = trackedSessionIDs.filter((trackedSessionID) => trackedSessionID !== sessionID);
+  if (ancestorSessionIDs.length === 0) {
+    return false;
+  }
+  return isSessionInBoulderLineage({
+    client: client3,
+    sessionID,
+    boulderSessionIDs: ancestorSessionIDs
+  });
 }
 function hasActiveRalphLoopContinuation(directory, sessionID) {
-  const state = readState(directory);
-  if (!state || !state.active)
+  const state2 = readState(directory);
+  if (!state2 || !state2.active)
     return false;
-  if (state.session_id && state.session_id !== sessionID) {
+  if (state2.session_id && state2.session_id !== sessionID) {
     return false;
   }
   return true;
@@ -68755,7 +69897,7 @@ function hasActiveRalphLoopContinuation(directory, sessionID) {
 // src/cli/run/completion.ts
 async function checkCompletionConditions(ctx) {
   try {
-    const continuationState = getContinuationState(ctx.directory, ctx.sessionID);
+    const continuationState = await getContinuationState(ctx.directory, ctx.sessionID, ctx.client);
     if (continuationState.hasActiveHookMarker) {
       const reason = continuationState.activeHookMarkerReason ?? "continuation hook is active";
       logWaiting(ctx, reason);
@@ -68772,7 +69914,7 @@ async function checkCompletionConditions(ctx) {
     }
     return true;
   } catch (err) {
-    console.error(import_picocolors12.default.red(`[completion] API error: ${err}`));
+    console.error(import_picocolors13.default.red(`[completion] API error: ${err}`));
     return false;
   }
 }
@@ -68833,7 +69975,7 @@ function logWaiting(ctx, message) {
   if (!ctx.verbose) {
     return;
   }
-  console.log(import_picocolors12.default.dim(`  Waiting: ${message}`));
+  console.log(import_picocolors13.default.dim(`  Waiting: ${message}`));
 }
 
 // src/cli/run/poll-for-completion.ts
@@ -68864,10 +70006,10 @@ async function pollForCompletion(ctx, eventState, abortController, options = {})
     if (eventState.mainSessionError) {
       errorCycleCount++;
       if (errorCycleCount >= ERROR_GRACE_CYCLES) {
-        console.error(import_picocolors13.default.red(`
+        console.error(import_picocolors14.default.red(`
 
 Session ended with error: ${eventState.lastError}`));
-        console.error(import_picocolors13.default.yellow("Check if todos were completed before the error."));
+        console.error(import_picocolors14.default.yellow("Check if todos were completed before the error."));
         return 1;
       }
       continue;
@@ -68878,7 +70020,7 @@ Session ended with error: ${eventState.lastError}`));
     if (eventState.lastEventTimestamp !== null) {
       const timeSinceLastEvent = Date.now() - eventState.lastEventTimestamp;
       if (timeSinceLastEvent > eventWatchdogMs) {
-        console.log(import_picocolors13.default.yellow(`
+        console.log(import_picocolors14.default.yellow(`
   No events for ${Math.round(timeSinceLastEvent / 1000)}s, verifying session status...`));
         mainSessionStatus = await getMainSessionStatus(ctx);
         if (mainSessionStatus === "idle") {
@@ -68927,7 +70069,7 @@ Session ended with error: ${eventState.lastError}`));
         const hasActiveWork = hasActiveChildren || hasActiveTodos;
         if (hasActiveWork) {
           eventState.hasReceivedMeaningfulWork = true;
-          console.log(import_picocolors13.default.yellow(`
+          console.log(import_picocolors14.default.yellow(`
   No meaningful work events for ${Math.round(secondaryMeaningfulWorkTimeoutMs / 1000)}s but session has active work - assuming in progress`));
         }
       }
@@ -68947,7 +70089,7 @@ Session ended with error: ${eventState.lastError}`));
       }
       consecutiveCompleteChecks++;
       if (consecutiveCompleteChecks >= requiredConsecutive) {
-        console.log(import_picocolors13.default.green(`
+        console.log(import_picocolors14.default.green(`
 
 All tasks completed.`));
         return 0;
@@ -69116,7 +70258,7 @@ async function run(options) {
     };
     const restoreInput = suppressRunInput();
     const handleSigint = () => {
-      console.log(import_picocolors14.default.yellow(`
+      console.log(import_picocolors15.default.yellow(`
 Interrupted. Shutting down...`));
       restoreInput();
       cleanup();
@@ -69129,9 +70271,9 @@ Interrupted. Shutting down...`));
         sessionId: options.sessionId,
         directory
       });
-      console.log(import_picocolors14.default.dim(`Session: ${sessionID}`));
+      console.log(import_picocolors15.default.dim(`Session: ${sessionID}`));
       if (resolvedModel) {
-        console.log(import_picocolors14.default.dim(`Model: ${resolvedModel.providerID}/${resolvedModel.modelID}`));
+        console.log(import_picocolors15.default.dim(`Model: ${resolvedModel.providerID}/${resolvedModel.modelID}`));
       }
       const ctx = {
         client: client3,
@@ -69194,7 +70336,7 @@ Interrupted. Shutting down...`));
     if (err instanceof Error && err.name === "AbortError") {
       return 130;
     }
-    console.error(import_picocolors14.default.red(`Error: ${serializeError(err)}`));
+    console.error(import_picocolors15.default.red(`Error: ${serializeError(err)}`));
     return 1;
   } finally {
     timestampOutput?.restore();
@@ -69204,53 +70346,53 @@ Interrupted. Shutting down...`));
 init_checker();
 
 // src/cli/get-local-version/formatter.ts
-var import_picocolors15 = __toESM(require_picocolors(), 1);
-var SYMBOLS2 = {
-  check: import_picocolors15.default.green("[OK]"),
-  cross: import_picocolors15.default.red("[X]"),
-  arrow: import_picocolors15.default.cyan("->"),
-  info: import_picocolors15.default.blue("[i]"),
-  warn: import_picocolors15.default.yellow("[!]"),
-  pin: import_picocolors15.default.magenta("[PINNED]"),
-  dev: import_picocolors15.default.cyan("[DEV]")
+var import_picocolors16 = __toESM(require_picocolors(), 1);
+var SYMBOLS3 = {
+  check: import_picocolors16.default.green("[OK]"),
+  cross: import_picocolors16.default.red("[X]"),
+  arrow: import_picocolors16.default.cyan("->"),
+  info: import_picocolors16.default.blue("[i]"),
+  warn: import_picocolors16.default.yellow("[!]"),
+  pin: import_picocolors16.default.magenta("[PINNED]"),
+  dev: import_picocolors16.default.cyan("[DEV]")
 };
 function formatVersionOutput(info) {
   const lines = [];
   lines.push("");
-  lines.push(import_picocolors15.default.bold(import_picocolors15.default.white("oh-my-opencode Version Information")));
-  lines.push(import_picocolors15.default.dim("\u2500".repeat(50)));
+  lines.push(import_picocolors16.default.bold(import_picocolors16.default.white("oh-my-opencode Version Information")));
+  lines.push(import_picocolors16.default.dim("\u2500".repeat(50)));
   lines.push("");
   if (info.currentVersion) {
-    lines.push(`  Current Version: ${import_picocolors15.default.cyan(info.currentVersion)}`);
+    lines.push(`  Current Version: ${import_picocolors16.default.cyan(info.currentVersion)}`);
   } else {
-    lines.push(`  Current Version: ${import_picocolors15.default.dim("unknown")}`);
+    lines.push(`  Current Version: ${import_picocolors16.default.dim("unknown")}`);
   }
   if (!info.isLocalDev && info.latestVersion) {
-    lines.push(`  Latest Version:  ${import_picocolors15.default.cyan(info.latestVersion)}`);
+    lines.push(`  Latest Version:  ${import_picocolors16.default.cyan(info.latestVersion)}`);
   }
   lines.push("");
   switch (info.status) {
     case "up-to-date":
-      lines.push(`  ${SYMBOLS2.check} ${import_picocolors15.default.green("You're up to date!")}`);
+      lines.push(`  ${SYMBOLS3.check} ${import_picocolors16.default.green("You're up to date!")}`);
       break;
     case "outdated":
-      lines.push(`  ${SYMBOLS2.warn} ${import_picocolors15.default.yellow("Update available")}`);
-      lines.push(`  ${import_picocolors15.default.dim("Run:")} ${import_picocolors15.default.cyan("cd ~/.config/opencode && bun update oh-my-opencode")}`);
+      lines.push(`  ${SYMBOLS3.warn} ${import_picocolors16.default.yellow("Update available")}`);
+      lines.push(`  ${import_picocolors16.default.dim("Run:")} ${import_picocolors16.default.cyan("cd ~/.config/opencode && bun update oh-my-opencode")}`);
       break;
     case "local-dev":
-      lines.push(`  ${SYMBOLS2.dev} ${import_picocolors15.default.cyan("Running in local development mode")}`);
-      lines.push(`  ${import_picocolors15.default.dim("Using file:// protocol from config")}`);
+      lines.push(`  ${SYMBOLS3.dev} ${import_picocolors16.default.cyan("Running in local development mode")}`);
+      lines.push(`  ${import_picocolors16.default.dim("Using file:// protocol from config")}`);
       break;
     case "pinned":
-      lines.push(`  ${SYMBOLS2.pin} ${import_picocolors15.default.magenta(`Version pinned to ${info.pinnedVersion}`)}`);
-      lines.push(`  ${import_picocolors15.default.dim("Update check skipped for pinned versions")}`);
+      lines.push(`  ${SYMBOLS3.pin} ${import_picocolors16.default.magenta(`Version pinned to ${info.pinnedVersion}`)}`);
+      lines.push(`  ${import_picocolors16.default.dim("Update check skipped for pinned versions")}`);
       break;
     case "error":
-      lines.push(`  ${SYMBOLS2.cross} ${import_picocolors15.default.red("Unable to check for updates")}`);
-      lines.push(`  ${import_picocolors15.default.dim("Network error or npm registry unavailable")}`);
+      lines.push(`  ${SYMBOLS3.cross} ${import_picocolors16.default.red("Unable to check for updates")}`);
+      lines.push(`  ${import_picocolors16.default.dim("Network error or npm registry unavailable")}`);
       break;
     case "unknown":
-      lines.push(`  ${SYMBOLS2.info} ${import_picocolors15.default.yellow("Version information unavailable")}`);
+      lines.push(`  ${SYMBOLS3.info} ${import_picocolors16.default.yellow("Version information unavailable")}`);
       break;
   }
   lines.push("");
@@ -69349,69 +70491,31 @@ async function getLocalVersion(options = {}) {
     return 1;
   }
 }
-// src/cli/doctor/constants.ts
-init_shared();
-var import_picocolors16 = __toESM(require_picocolors(), 1);
-var SYMBOLS3 = {
-  check: import_picocolors16.default.green("\u2713"),
-  cross: import_picocolors16.default.red("\u2717"),
-  warn: import_picocolors16.default.yellow("\u26A0"),
-  info: import_picocolors16.default.blue("\u2139"),
-  arrow: import_picocolors16.default.cyan("\u2192"),
-  bullet: import_picocolors16.default.dim("\u2022"),
-  skip: import_picocolors16.default.dim("\u25CB")
-};
-var STATUS_COLORS = {
-  pass: import_picocolors16.default.green,
-  fail: import_picocolors16.default.red,
-  warn: import_picocolors16.default.yellow,
-  skip: import_picocolors16.default.dim
-};
-var CHECK_IDS = {
-  SYSTEM: "system",
-  CONFIG: "config",
-  TOOLS: "tools",
-  MODELS: "models"
-};
-var CHECK_NAMES = {
-  [CHECK_IDS.SYSTEM]: "System",
-  [CHECK_IDS.CONFIG]: "Configuration",
-  [CHECK_IDS.TOOLS]: "Tools",
-  [CHECK_IDS.MODELS]: "Models"
-};
-var EXIT_CODES = {
-  SUCCESS: 0,
-  FAILURE: 1
-};
-var MIN_OPENCODE_VERSION = "1.0.150";
-var PACKAGE_NAME2 = PLUGIN_NAME;
-var OPENCODE_BINARIES2 = ["opencode", "opencode-desktop"];
-
 // src/cli/doctor/checks/system.ts
-import { existsSync as existsSync25, readFileSync as readFileSync22 } from "fs";
+import { existsSync as existsSync29, readFileSync as readFileSync24 } from "fs";
 
 // src/cli/doctor/checks/system-binary.ts
 init_spawn_with_windows_hide();
-import { existsSync as existsSync22 } from "fs";
+import { existsSync as existsSync26 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join21 } from "path";
+import { join as join25 } from "path";
 function getDesktopAppPaths(platform) {
   const home = homedir5();
   switch (platform) {
     case "darwin":
       return [
         "/Applications/OpenCode.app/Contents/MacOS/OpenCode",
-        join21(home, "Applications", "OpenCode.app", "Contents", "MacOS", "OpenCode")
+        join25(home, "Applications", "OpenCode.app", "Contents", "MacOS", "OpenCode")
       ];
     case "win32": {
       const programFiles = process.env.ProgramFiles;
       const localAppData = process.env.LOCALAPPDATA;
       const paths = [];
       if (programFiles) {
-        paths.push(join21(programFiles, "OpenCode", "OpenCode.exe"));
+        paths.push(join25(programFiles, "OpenCode", "OpenCode.exe"));
       }
       if (localAppData) {
-        paths.push(join21(localAppData, "OpenCode", "OpenCode.exe"));
+        paths.push(join25(localAppData, "OpenCode", "OpenCode.exe"));
       }
       return paths;
     }
@@ -69419,8 +70523,8 @@ function getDesktopAppPaths(platform) {
       return [
         "/usr/bin/opencode",
         "/usr/lib/opencode/opencode",
-        join21(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
-        join21(home, "Applications", "opencode-desktop-linux-aarch64.AppImage")
+        join25(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
+        join25(home, "Applications", "opencode-desktop-linux-aarch64.AppImage")
       ];
     default:
       return [];
@@ -69432,7 +70536,7 @@ function buildVersionCommand(binaryPath, platform) {
   }
   return [binaryPath, "--version"];
 }
-function findDesktopBinary(platform = process.platform, checkExists = existsSync22) {
+function findDesktopBinary(platform = process.platform, checkExists = existsSync26) {
   for (const desktopPath of getDesktopAppPaths(platform)) {
     if (checkExists(desktopPath)) {
       return { binary: "opencode", path: desktopPath };
@@ -69449,7 +70553,7 @@ async function findOpenCodeBinary() {
   }
   return findDesktopBinary();
 }
-async function getOpenCodeVersion2(binaryPath, platform = process.platform) {
+async function getOpenCodeVersion3(binaryPath, platform = process.platform) {
   try {
     const command = buildVersionCommand(binaryPath, platform);
     const processResult = spawnWithWindowsHide(command, { stdout: "pipe", stderr: "pipe" });
@@ -69462,10 +70566,10 @@ async function getOpenCodeVersion2(binaryPath, platform = process.platform) {
     return null;
   }
 }
-function compareVersions(current, minimum) {
-  const parseVersion = (version2) => version2.replace(/^v/, "").split("-")[0].split(".").map((part) => Number.parseInt(part, 10) || 0);
-  const currentParts = parseVersion(current);
-  const minimumParts = parseVersion(minimum);
+function compareVersions3(current, minimum) {
+  const parseVersion3 = (version2) => version2.replace(/^v/, "").split("-")[0].split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const currentParts = parseVersion3(current);
+  const minimumParts = parseVersion3(minimum);
   const length = Math.max(currentParts.length, minimumParts.length);
   for (let index = 0;index < length; index++) {
     const currentPart = currentParts[index] ?? 0;
@@ -69480,12 +70584,12 @@ function compareVersions(current, minimum) {
 
 // src/cli/doctor/checks/system-plugin.ts
 init_shared();
-import { existsSync as existsSync23, readFileSync as readFileSync20 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync22 } from "fs";
 function detectConfigPath() {
   const paths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
-  if (existsSync23(paths.configJsonc))
+  if (existsSync27(paths.configJsonc))
     return paths.configJsonc;
-  if (existsSync23(paths.configJson))
+  if (existsSync27(paths.configJson))
     return paths.configJson;
   return null;
 }
@@ -69531,7 +70635,7 @@ function getPluginInfo() {
     };
   }
   try {
-    const content = readFileSync20(configPath, "utf-8");
+    const content = readFileSync22(configPath, "utf-8");
     const parsedConfig = parseJsonc(content);
     const pluginEntry = findPluginEntry2(parsedConfig.plugin ?? []);
     if (!pluginEntry) {
@@ -69569,37 +70673,37 @@ function getPluginInfo() {
 init_file_utils();
 init_checker();
 init_auto_update_checker();
-import { existsSync as existsSync24, readFileSync as readFileSync21 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync23 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join22 } from "path";
+import { join as join26 } from "path";
 init_shared();
 function getPlatformDefaultCacheDir(platform = process.platform) {
   if (platform === "darwin")
-    return join22(homedir6(), "Library", "Caches");
+    return join26(homedir6(), "Library", "Caches");
   if (platform === "win32")
-    return process.env.LOCALAPPDATA ?? join22(homedir6(), "AppData", "Local");
-  return join22(homedir6(), ".cache");
+    return process.env.LOCALAPPDATA ?? join26(homedir6(), "AppData", "Local");
+  return join26(homedir6(), ".cache");
 }
 function resolveOpenCodeCacheDir() {
   const xdgCacheHome = process.env.XDG_CACHE_HOME;
   if (xdgCacheHome)
-    return join22(xdgCacheHome, "opencode");
+    return join26(xdgCacheHome, "opencode");
   const fromShared = getOpenCodeCacheDir();
-  const platformDefault = join22(getPlatformDefaultCacheDir(), "opencode");
-  if (existsSync24(fromShared) || !existsSync24(platformDefault))
+  const platformDefault = join26(getPlatformDefaultCacheDir(), "opencode");
+  if (existsSync28(fromShared) || !existsSync28(platformDefault))
     return fromShared;
   return platformDefault;
 }
 function resolveExistingDir(dirPath) {
-  if (!existsSync24(dirPath))
+  if (!existsSync28(dirPath))
     return dirPath;
   return resolveSymlink(dirPath);
 }
 function readPackageJson(filePath) {
-  if (!existsSync24(filePath))
+  if (!existsSync28(filePath))
     return null;
   try {
-    const content = readFileSync21(filePath, "utf-8");
+    const content = readFileSync23(filePath, "utf-8");
     return parseJsonc(content);
   } catch {
     return null;
@@ -69618,20 +70722,20 @@ function getLoadedPluginVersion() {
   const candidates = [
     {
       cacheDir: configDir,
-      cachePackagePath: join22(configDir, "package.json"),
-      installedPackagePath: join22(configDir, "node_modules", PACKAGE_NAME2, "package.json")
+      cachePackagePath: join26(configDir, "package.json"),
+      installedPackagePath: join26(configDir, "node_modules", PACKAGE_NAME, "package.json")
     },
     {
       cacheDir,
-      cachePackagePath: join22(cacheDir, "package.json"),
-      installedPackagePath: join22(cacheDir, "node_modules", PACKAGE_NAME2, "package.json")
+      cachePackagePath: join26(cacheDir, "package.json"),
+      installedPackagePath: join26(cacheDir, "node_modules", PACKAGE_NAME, "package.json")
     }
   ];
-  const selectedCandidate = candidates.find((candidate) => existsSync24(candidate.installedPackagePath)) ?? candidates[0];
+  const selectedCandidate = candidates.find((candidate) => existsSync28(candidate.installedPackagePath)) ?? candidates[0];
   const { cacheDir: selectedDir, cachePackagePath, installedPackagePath } = selectedCandidate;
   const cachePackage = readPackageJson(cachePackagePath);
   const installedPackage = readPackageJson(installedPackagePath);
-  const expectedVersion = normalizeVersion(cachePackage?.dependencies?.[PACKAGE_NAME2]);
+  const expectedVersion = normalizeVersion(cachePackage?.dependencies?.[PACKAGE_NAME]);
   const loadedVersion = normalizeVersion(installedPackage?.version);
   return {
     cacheDir: selectedDir,
@@ -69654,10 +70758,10 @@ init_shared();
 function isConfigValid(configPath) {
   if (!configPath)
     return true;
-  if (!existsSync25(configPath))
+  if (!existsSync29(configPath))
     return false;
   try {
-    parseJsonc(readFileSync22(configPath, "utf-8"));
+    parseJsonc(readFileSync24(configPath, "utf-8"));
     return true;
   } catch {
     return false;
@@ -69680,7 +70784,7 @@ function buildMessage(status, issues) {
 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 opencodeVersion = binaryInfo ? await getOpenCodeVersion3(binaryInfo.path) : null;
   const pluginVersion = pluginInfo.pinnedVersion ?? loadedInfo.expectedVersion ?? loadedInfo.loadedVersion;
   return {
     opencodeVersion,
@@ -69708,7 +70812,7 @@ async function checkSystem() {
       affects: ["doctor", "run"]
     });
   }
-  if (systemInfo.opencodeVersion && !compareVersions(systemInfo.opencodeVersion, MIN_OPENCODE_VERSION)) {
+  if (systemInfo.opencodeVersion && !compareVersions3(systemInfo.opencodeVersion, MIN_OPENCODE_VERSION)) {
     issues.push({
       title: "OpenCode version below minimum",
       description: `Detected ${systemInfo.opencodeVersion}; required >= ${MIN_OPENCODE_VERSION}.`,
@@ -69748,7 +70852,7 @@ async function checkSystem() {
       affects: ["plugin loading"]
     });
   }
-  if (systemInfo.loadedVersion && latestVersion && !compareVersions(systemInfo.loadedVersion, latestVersion)) {
+  if (systemInfo.loadedVersion && latestVersion && !compareVersions3(systemInfo.loadedVersion, latestVersion)) {
     issues.push({
       title: "Loaded plugin is outdated",
       description: `Loaded ${systemInfo.loadedVersion}, latest ${latestVersion}.`,
@@ -69773,28 +70877,28 @@ async function checkSystem() {
 }
 
 // src/cli/doctor/checks/config.ts
-import { readFileSync as readFileSync25 } from "fs";
-import { join as join26 } from "path";
+import { readFileSync as readFileSync27 } from "fs";
+import { join as join30 } from "path";
 init_shared();
 
 // src/cli/doctor/checks/model-resolution-cache.ts
 init_shared();
-import { existsSync as existsSync26, readFileSync as readFileSync23 } from "fs";
+import { existsSync as existsSync30, readFileSync as readFileSync25 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join23 } from "path";
+import { join as join27 } from "path";
 function getOpenCodeCacheDir2() {
   const xdgCache = process.env.XDG_CACHE_HOME;
   if (xdgCache)
-    return join23(xdgCache, "opencode");
-  return join23(homedir7(), ".cache", "opencode");
+    return join27(xdgCache, "opencode");
+  return join27(homedir7(), ".cache", "opencode");
 }
 function loadAvailableModelsFromCache() {
-  const cacheFile = join23(getOpenCodeCacheDir2(), "models.json");
-  if (!existsSync26(cacheFile)) {
+  const cacheFile = join27(getOpenCodeCacheDir2(), "models.json");
+  if (!existsSync30(cacheFile)) {
     return { providers: [], modelCount: 0, cacheExists: false };
   }
   try {
-    const content = readFileSync23(cacheFile, "utf-8");
+    const content = readFileSync25(cacheFile, "utf-8");
     const data = parseJsonc(content);
     const providers = Object.keys(data);
     let modelCount = 0;
@@ -69816,14 +70920,14 @@ init_model_capabilities();
 
 // src/cli/doctor/checks/model-resolution-config.ts
 init_shared();
-import { readFileSync as readFileSync24 } from "fs";
-import { join as join24 } from "path";
-var PROJECT_CONFIG_DIR = join24(process.cwd(), ".opencode");
+import { readFileSync as readFileSync26 } from "fs";
+import { join as join28 } from "path";
+var PROJECT_CONFIG_DIR = join28(process.cwd(), ".opencode");
 function loadOmoConfig() {
   const projectDetected = detectPluginConfigFile(PROJECT_CONFIG_DIR);
   if (projectDetected.format !== "none") {
     try {
-      const content = readFileSync24(projectDetected.path, "utf-8");
+      const content = readFileSync26(projectDetected.path, "utf-8");
       return parseJsonc(content);
     } catch {
       return null;
@@ -69833,7 +70937,7 @@ function loadOmoConfig() {
   const userDetected = detectPluginConfigFile(userConfigDir);
   if (userDetected.format !== "none") {
     try {
-      const content = readFileSync24(userDetected.path, "utf-8");
+      const content = readFileSync26(userDetected.path, "utf-8");
       return parseJsonc(content);
     } catch {
       return null;
@@ -69844,7 +70948,7 @@ function loadOmoConfig() {
 
 // src/cli/doctor/checks/model-resolution-details.ts
 init_shared();
-import { join as join25 } from "path";
+import { join as join29 } from "path";
 
 // src/cli/doctor/checks/model-resolution-variant.ts
 function formatModelWithVariant(model, variant) {
@@ -69886,7 +70990,7 @@ function formatCapabilityResolutionLabel(mode) {
 }
 function buildModelResolutionDetails(options) {
   const details = [];
-  const cacheFile = join25(getOpenCodeCacheDir(), "models.json");
+  const cacheFile = join29(getOpenCodeCacheDir(), "models.json");
   details.push("\u2550\u2550\u2550 Available Models (from cache) \u2550\u2550\u2550");
   details.push("");
   if (options.available.cacheExists) {
@@ -70041,7 +71145,7 @@ async function checkModels() {
 }
 
 // src/cli/doctor/checks/config.ts
-var PROJECT_CONFIG_DIR2 = join26(process.cwd(), ".opencode");
+var PROJECT_CONFIG_DIR2 = join30(process.cwd(), ".opencode");
 function findConfigPath() {
   const projectConfig = detectPluginConfigFile(PROJECT_CONFIG_DIR2);
   if (projectConfig.format !== "none")
@@ -70058,7 +71162,7 @@ function validateConfig() {
     return { exists: false, path: null, valid: true, config: null, errors: [] };
   }
   try {
-    const content = readFileSync25(configPath, "utf-8");
+    const content = readFileSync27(configPath, "utf-8");
     const rawConfig = parseJsonc(content);
     const schemaResult = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
     if (!schemaResult.success) {
@@ -70162,9 +71266,9 @@ async function checkConfig() {
 
 // src/cli/doctor/checks/dependencies.ts
 init_spawn_with_windows_hide();
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync31 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname9, join as join27 } from "path";
+import { dirname as dirname10, join as join31 } from "path";
 async function checkBinaryExists(binary2) {
   try {
     const path10 = Bun.which(binary2);
@@ -70220,15 +71324,15 @@ async function checkAstGrepNapi() {
       path: null
     };
   } catch {
-    const { existsSync: existsSync28 } = await import("fs");
-    const { join: join28 } = await import("path");
+    const { existsSync: existsSync32 } = await import("fs");
+    const { join: join32 } = await import("path");
     const { homedir: homedir8 } = await import("os");
     const pathsToCheck = [
-      join28(homedir8(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
-      join28(process.cwd(), "node_modules", "@ast-grep", "napi")
+      join32(homedir8(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
+      join32(process.cwd(), "node_modules", "@ast-grep", "napi")
     ];
     for (const napiPath of pathsToCheck) {
-      if (existsSync28(napiPath)) {
+      if (existsSync32(napiPath)) {
         return {
           name: "AST-Grep NAPI",
           required: false,
@@ -70253,8 +71357,8 @@ function findCommentCheckerPackageBinary() {
   try {
     const require2 = createRequire(import.meta.url);
     const pkgPath = require2.resolve("@code-yeongyu/comment-checker/package.json");
-    const binaryPath = join27(dirname9(pkgPath), "bin", binaryName);
-    if (existsSync27(binaryPath))
+    const binaryPath = join31(dirname10(pkgPath), "bin", binaryName);
+    if (existsSync31(binaryPath))
       return binaryPath;
   } catch {}
   return null;
@@ -70411,15 +71515,15 @@ var BUILTIN_SERVERS = {
   "kotlin-ls": { command: ["kotlin-lsp"], extensions: [".kt", ".kts"] }
 };
 // src/tools/lsp/server-config-loader.ts
-import { existsSync as existsSync28, readFileSync as readFileSync26 } from "fs";
-import { join as join28 } from "path";
+import { existsSync as existsSync32, readFileSync as readFileSync28 } from "fs";
+import { join as join32 } from "path";
 init_shared();
 init_jsonc_parser();
 function loadJsonFile(path10) {
-  if (!existsSync28(path10))
+  if (!existsSync32(path10))
     return null;
   try {
-    return parseJsonc(readFileSync26(path10, "utf-8"));
+    return parseJsonc(readFileSync28(path10, "utf-8"));
   } catch {
     return null;
   }
@@ -70428,9 +71532,9 @@ function getConfigPaths2() {
   const cwd = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   return {
-    project: detectPluginConfigFile(join28(cwd, ".opencode")).path,
+    project: detectPluginConfigFile(join32(cwd, ".opencode")).path,
     user: detectPluginConfigFile(configDir).path,
-    opencode: detectConfigFile(join28(configDir, "opencode")).path
+    opencode: detectConfigFile(join32(configDir, "opencode")).path
   };
 }
 function loadAllConfigs() {
@@ -70499,21 +71603,21 @@ function getMergedServers() {
 }
 
 // src/tools/lsp/server-installation.ts
-import { existsSync as existsSync29 } from "fs";
-import { delimiter as delimiter2, join as join30 } from "path";
+import { existsSync as existsSync33 } from "fs";
+import { delimiter as delimiter2, join as join34 } from "path";
 
 // src/tools/lsp/server-path-bases.ts
 init_shared();
-import { join as join29 } from "path";
+import { join as join33 } from "path";
 function getLspServerAdditionalPathBases(workingDirectory) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join29(getDataDir(), "opencode");
+  const dataDir = join33(getDataDir(), "opencode");
   return [
-    join29(workingDirectory, "node_modules", ".bin"),
-    join29(configDir, "bin"),
-    join29(configDir, "node_modules", ".bin"),
-    join29(dataDir, "bin"),
-    join29(dataDir, "bin", "node_modules", ".bin")
+    join33(workingDirectory, "node_modules", ".bin"),
+    join33(configDir, "bin"),
+    join33(configDir, "node_modules", ".bin"),
+    join33(dataDir, "bin"),
+    join33(dataDir, "bin", "node_modules", ".bin")
   ];
 }
 
@@ -70523,7 +71627,7 @@ function isServerInstalled(command) {
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync29(cmd))
+    if (existsSync33(cmd))
       return true;
   }
   const isWindows = process.platform === "win32";
@@ -70544,14 +71648,14 @@ function isServerInstalled(command) {
   const paths = pathEnv.split(delimiter2);
   for (const p2 of paths) {
     for (const suffix of exts) {
-      if (existsSync29(join30(p2, cmd + suffix))) {
+      if (existsSync33(join34(p2, cmd + suffix))) {
         return true;
       }
     }
   }
   for (const base of getLspServerAdditionalPathBases(process.cwd())) {
     for (const suffix of exts) {
-      if (existsSync29(join30(base, cmd + suffix))) {
+      if (existsSync33(join34(base, cmd + suffix))) {
         return true;
       }
     }
@@ -70613,24 +71717,24 @@ function getInstalledLspServers() {
 
 // src/cli/doctor/checks/tools-mcp.ts
 init_shared();
-import { existsSync as existsSync30, readFileSync as readFileSync27 } from "fs";
+import { existsSync as existsSync34, readFileSync as readFileSync29 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join31 } from "path";
+import { join as join35 } from "path";
 var BUILTIN_MCP_SERVERS = ["context7", "grep_app"];
 function getMcpConfigPaths() {
   return [
-    join31(homedir8(), ".claude", ".mcp.json"),
-    join31(process.cwd(), ".mcp.json"),
-    join31(process.cwd(), ".claude", ".mcp.json")
+    join35(homedir8(), ".claude", ".mcp.json"),
+    join35(process.cwd(), ".mcp.json"),
+    join35(process.cwd(), ".claude", ".mcp.json")
   ];
 }
 function loadUserMcpConfig() {
   const servers = {};
   for (const configPath of getMcpConfigPaths()) {
-    if (!existsSync30(configPath))
+    if (!existsSync34(configPath))
       continue;
     try {
-      const content = readFileSync27(configPath, "utf-8");
+      const content = readFileSync29(configPath, "utf-8");
       const config2 = parseJsonc(content);
       if (config2.mcpServers) {
         Object.assign(servers, config2.mcpServers);
@@ -70797,17 +71901,17 @@ function formatStatusSymbol(status) {
   const colorFn = STATUS_COLORS[status];
   switch (status) {
     case "pass":
-      return colorFn(SYMBOLS3.check);
+      return colorFn(SYMBOLS2.check);
     case "fail":
-      return colorFn(SYMBOLS3.cross);
+      return colorFn(SYMBOLS2.cross);
     case "warn":
-      return colorFn(SYMBOLS3.warn);
+      return colorFn(SYMBOLS2.warn);
     case "skip":
-      return colorFn(SYMBOLS3.skip);
+      return colorFn(SYMBOLS2.skip);
   }
 }
 function formatStatusMark(available) {
-  return available ? import_picocolors17.default.green(SYMBOLS3.check) : import_picocolors17.default.red(SYMBOLS3.cross);
+  return available ? import_picocolors17.default.green(SYMBOLS2.check) : import_picocolors17.default.red(SYMBOLS2.cross);
 }
 function formatHeader() {
   return `
@@ -70837,12 +71941,12 @@ function formatDefault(result) {
   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})`)}`);
+    lines.push(` ${import_picocolors18.default.green(SYMBOLS2.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:
+    lines.push(` ${import_picocolors18.default.yellow(SYMBOLS2.warn)} ${totalStr} found:
 `);
     allIssues.forEach((issue2, index) => {
       lines.push(formatIssue(issue2, index + 1));
@@ -71083,11 +72187,11 @@ async function refreshModelCapabilities(options, deps = {}) {
 
 // src/features/mcp-oauth/storage.ts
 init_shared();
-import { chmodSync, existsSync as existsSync31, mkdirSync as mkdirSync8, readFileSync as readFileSync28, unlinkSync as unlinkSync4, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname10, join as join32 } from "path";
+import { chmodSync, existsSync as existsSync35, mkdirSync as mkdirSync9, readFileSync as readFileSync30, renameSync as renameSync4, unlinkSync as unlinkSync4, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname11, join as join36 } from "path";
 var STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStoragePath() {
-  return join32(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
+  return join36(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
 }
 function normalizeHost(serverHost) {
   let host = serverHost.trim();
@@ -71124,11 +72228,11 @@ function buildKey(serverHost, resource) {
 }
 function readStore() {
   const filePath = getMcpOauthStoragePath();
-  if (!existsSync31(filePath)) {
+  if (!existsSync35(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync28(filePath, "utf-8");
+    const content = readFileSync30(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -71137,12 +72241,14 @@ function readStore() {
 function writeStore(store2) {
   const filePath = getMcpOauthStoragePath();
   try {
-    const dir = dirname10(filePath);
-    if (!existsSync31(dir)) {
-      mkdirSync8(dir, { recursive: true });
-    }
-    writeFileSync10(filePath, JSON.stringify(store2, null, 2), { encoding: "utf-8", mode: 384 });
-    chmodSync(filePath, 384);
+    const dir = dirname11(filePath);
+    if (!existsSync35(dir)) {
+      mkdirSync9(dir, { recursive: true });
+    }
+    const tempPath = `${filePath}.tmp.${Date.now()}`;
+    writeFileSync10(tempPath, JSON.stringify(store2, null, 2), { encoding: "utf-8", mode: 384 });
+    chmodSync(tempPath, 384);
+    renameSync4(tempPath, filePath);
     return true;
   } catch {
     return false;
@@ -71173,7 +72279,7 @@ function deleteToken(serverHost, resource) {
   if (Object.keys(store2).length === 0) {
     try {
       const filePath = getMcpOauthStoragePath();
-      if (existsSync31(filePath)) {
+      if (existsSync35(filePath)) {
         unlinkSync4(filePath);
       }
       return true;
@@ -71363,7 +72469,7 @@ async function findAvailablePort2(startPort = DEFAULT_PORT) {
 }
 
 // src/features/mcp-oauth/oauth-authorization-flow.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn } from "child_process";
 import { createHash, randomBytes as randomBytes2 } from "crypto";
 import { createServer } from "http";
 function generateCodeVerifier() {
@@ -71396,7 +72502,7 @@ function startCallbackServer(port) {
       clearTimeout(timeoutId);
       const requestUrl = new URL(request.url ?? "/", `http://localhost:${port}`);
       const code = requestUrl.searchParams.get("code");
-      const state = requestUrl.searchParams.get("state");
+      const state2 = requestUrl.searchParams.get("state");
       const error48 = requestUrl.searchParams.get("error");
       if (error48) {
         const errorDescription = requestUrl.searchParams.get("error_description") ?? error48;
@@ -71406,7 +72512,7 @@ function startCallbackServer(port) {
         reject(new Error(`OAuth authorization error: ${errorDescription}`));
         return;
       }
-      if (!code || !state) {
+      if (!code || !state2) {
         response.writeHead(400, { "content-type": "text/html" });
         response.end("<html><body><h1>Missing code or state</h1></body></html>");
         server2.close();
@@ -71416,7 +72522,7 @@ function startCallbackServer(port) {
       response.writeHead(200, { "content-type": "text/html" });
       response.end("<html><body><h1>Authorization successful. You can close this tab.</h1></body></html>");
       server2.close();
-      resolve2({ code, state });
+      resolve2({ code, state: state2 });
     });
     timeoutId = setTimeout(() => {
       server2.close();
@@ -71444,7 +72550,7 @@ function openBrowser(url2) {
     args = [url2];
   }
   try {
-    const child = spawn2(command, args, { stdio: "ignore", detached: true });
+    const child = spawn(command, args, { stdio: "ignore", detached: true });
     child.on("error", () => {});
     child.unref();
   } catch {}
@@ -71452,25 +72558,57 @@ function openBrowser(url2) {
 async function runAuthorizationCodeRedirect(options) {
   const verifier = generateCodeVerifier();
   const challenge = generateCodeChallenge(verifier);
-  const state = randomBytes2(16).toString("hex");
+  const state2 = randomBytes2(16).toString("hex");
   const authorizationUrl = buildAuthorizationUrl(options.authorizationEndpoint, {
     clientId: options.clientId,
     redirectUri: options.redirectUri,
     codeChallenge: challenge,
-    state,
+    state: state2,
     scopes: options.scopes,
     resource: options.resource
   });
   const callbackPromise = startCallbackServer(options.callbackPort);
   openBrowser(authorizationUrl);
   const result = await callbackPromise;
-  if (result.state !== state) {
+  if (result.state !== state2) {
     throw new Error("OAuth state mismatch");
   }
   return { code: result.code, verifier };
 }
 
 // src/features/mcp-oauth/provider.ts
+async function parseTokenResponse(tokenResponse) {
+  if (!tokenResponse.ok) {
+    let errorDetail = `${tokenResponse.status}`;
+    try {
+      const body = await tokenResponse.json();
+      if (body.error) {
+        errorDetail = `${tokenResponse.status} ${body.error}`;
+        if (body.error_description) {
+          errorDetail += `: ${body.error_description}`;
+        }
+      }
+    } catch {}
+    throw new Error(`Token exchange failed: ${errorDetail}`);
+  }
+  return await tokenResponse.json();
+}
+function buildOAuthTokenData(tokenData, clientInfo, fallbackRefreshToken) {
+  const accessToken = tokenData.access_token;
+  if (typeof accessToken !== "string") {
+    throw new Error("Token response missing access_token");
+  }
+  return {
+    accessToken,
+    refreshToken: typeof tokenData.refresh_token === "string" ? tokenData.refresh_token : fallbackRefreshToken,
+    expiresAt: typeof tokenData.expires_in === "number" ? Math.floor(Date.now() / 1000) + tokenData.expires_in : undefined,
+    clientInfo: {
+      clientId: clientInfo.clientId,
+      ...clientInfo.clientSecret ? { clientSecret: clientInfo.clientSecret } : {}
+    }
+  };
+}
+
 class McpOAuthProvider {
   serverUrl;
   configClientId;
@@ -71565,33 +72703,34 @@ class McpOAuthProvider {
         ...metadata.resource ? { resource: metadata.resource } : {}
       }).toString()
     });
-    if (!tokenResponse.ok) {
-      let errorDetail = `${tokenResponse.status}`;
-      try {
-        const body = await tokenResponse.json();
-        if (body.error) {
-          errorDetail = `${tokenResponse.status} ${body.error}`;
-          if (body.error_description) {
-            errorDetail += `: ${body.error_description}`;
-          }
-        }
-      } catch {}
-      throw new Error(`Token exchange failed: ${errorDetail}`);
-    }
-    const tokenData = await tokenResponse.json();
-    const accessToken = tokenData.access_token;
-    if (typeof accessToken !== "string") {
-      throw new Error("Token response missing access_token");
+    const tokenData = await parseTokenResponse(tokenResponse);
+    const oauthTokenData = buildOAuthTokenData(tokenData, clientInfo);
+    this.saveTokens(oauthTokenData);
+    return oauthTokenData;
+  }
+  async refresh(refreshToken) {
+    const metadata = await discoverOAuthServerMetadata(this.serverUrl);
+    const clientInfo = this.clientInformation();
+    const clientId = clientInfo?.clientId ?? this.configClientId;
+    if (!clientId) {
+      throw new Error("No client information available. Run login() or register a client first.");
     }
-    const oauthTokenData = {
-      accessToken,
-      refreshToken: typeof tokenData.refresh_token === "string" ? tokenData.refresh_token : undefined,
-      expiresAt: typeof tokenData.expires_in === "number" ? Math.floor(Date.now() / 1000) + tokenData.expires_in : undefined,
-      clientInfo: {
-        clientId: clientInfo.clientId,
-        clientSecret: clientInfo.clientSecret
-      }
-    };
+    const tokenResponse = await fetch(metadata.tokenEndpoint, {
+      method: "POST",
+      headers: { "content-type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: refreshToken,
+        client_id: clientId,
+        ...clientInfo?.clientSecret ? { client_secret: clientInfo.clientSecret } : {},
+        ...metadata.resource ? { resource: metadata.resource } : {}
+      }).toString()
+    });
+    const tokenData = await parseTokenResponse(tokenResponse);
+    const oauthTokenData = buildOAuthTokenData(tokenData, {
+      clientId,
+      ...clientInfo?.clientSecret ? { clientSecret: clientInfo.clientSecret } : {}
+    }, refreshToken);
     this.saveTokens(oauthTokenData);
     return oauthTokenData;
   }