npm - evil-omo - Versions diffs - 3.15.3 → 3.16.0 - Mend

evil-omo 3.15.3 → 3.16.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (49) hide show

package/dist/cli/index.js CHANGED Viewed

@@ -5995,9 +5995,13 @@ var init_plugin_identity = __esm(() => {
 // src/shared/jsonc-parser.ts
 import { existsSync, readFileSync } from "fs";
 import { join as join4 } 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
   });
@@ -6061,15 +6065,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",
@@ -48392,6 +48396,57 @@ var init_constants = __esm(() => {
   init_shared();
 });
+// src/shared/opencode-storage-paths.ts
+import { join as join9 } 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 = join9(OPENCODE_STORAGE, "message");
+  PART_STORAGE = join9(OPENCODE_STORAGE, "part");
+  SESSION_STORAGE = join9(OPENCODE_STORAGE, "session");
+});
+// src/shared/compaction-marker.ts
+import { existsSync as existsSync6, readdirSync, readFileSync as readFileSync4 } from "fs";
+import { join as join10 } 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 = join10(PART_STORAGE, messageID);
+  if (!existsSync6(partDir)) {
+    return false;
+  }
+  try {
+    return readdirSync(partDir).filter((fileName) => fileName.endsWith(".json")).some((fileName) => {
+      try {
+        const content = readFileSync4(join10(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;
@@ -48400,6 +48455,7 @@ var init_injector = __esm(() => {
   init_logger();
   init_opencode_storage_detection();
   init_shared();
+  init_compaction_marker();
   processPrefix = randomBytes(4).toString("hex");
 });
@@ -48409,35 +48465,24 @@ var init_hook_message_injector = __esm(() => {
   init_constants();
 });
-// src/shared/opencode-storage-paths.ts
-import { join as join9 } 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 = join9(OPENCODE_STORAGE, "message");
-  PART_STORAGE = join9(OPENCODE_STORAGE, "part");
-  SESSION_STORAGE = join9(OPENCODE_STORAGE, "session");
-});
 // src/shared/opencode-message-dir.ts
-import { existsSync as existsSync6, readdirSync } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync7, readdirSync as readdirSync2 } from "fs";
+import { join as join11 } from "path";
 function getMessageDir(sessionID) {
   if (!sessionID.startsWith("ses_"))
     return null;
   if (/[/\\]|\.\./.test(sessionID))
     return null;
-  if (!existsSync6(MESSAGE_STORAGE))
+  if (!existsSync7(MESSAGE_STORAGE))
     return null;
-  const directPath = join10(MESSAGE_STORAGE, sessionID);
-  if (existsSync6(directPath)) {
+  const directPath = join11(MESSAGE_STORAGE, sessionID);
+  if (existsSync7(directPath)) {
     return directPath;
   }
   try {
-    for (const dir of readdirSync(MESSAGE_STORAGE)) {
-      const sessionPath = join10(MESSAGE_STORAGE, dir, sessionID);
-      if (existsSync6(sessionPath)) {
+    for (const dir of readdirSync2(MESSAGE_STORAGE)) {
+      const sessionPath = join11(MESSAGE_STORAGE, dir, sessionID);
+      if (existsSync7(sessionPath)) {
         return sessionPath;
       }
     }
@@ -48472,22 +48517,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",
@@ -48495,6 +48543,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
@@ -48658,9 +48716,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
@@ -48711,7 +48778,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();
 });
@@ -48722,7 +48789,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();
 });
@@ -48858,6 +48925,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_plugin_identity();
   init_log_legacy_plugin_startup_warning();
@@ -48939,12 +49008,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 existsSync7, mkdirSync as mkdirSync3 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync4 } from "fs";
 function ensureConfigDirectoryExists() {
   const configDir = getConfigDir();
-  if (!existsSync7(configDir)) {
-    mkdirSync3(configDir, { recursive: true });
+  if (!existsSync9(configDir)) {
+    mkdirSync4(configDir, { recursive: true });
   }
 }
 var init_ensure_config_directory_exists = __esm(() => {
@@ -48981,14 +49075,14 @@ function formatErrorWithSuggestion(err, context) {
 }
 // src/cli/config-manager/opencode-config-format.ts
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 function detectConfigFormat() {
   const configJsonc = getConfigJsonc();
   const configJson = getConfigJson();
-  if (existsSync8(configJsonc)) {
+  if (existsSync10(configJsonc)) {
     return { format: "jsonc", path: configJsonc };
   }
-  if (existsSync8(configJson)) {
+  if (existsSync10(configJson)) {
     return { format: "json", path: configJson };
   }
   return { format: "none", path: configJson };
@@ -48998,7 +49092,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;
 }
@@ -49008,7 +49102,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.` };
     }
@@ -49031,8 +49125,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();
@@ -49065,19 +49241,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) {
@@ -49107,6 +49299,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();
@@ -49222,6 +49415,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;
@@ -49236,25 +49470,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") {
@@ -49265,7 +49505,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;
     }
@@ -49278,7 +49519,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 };
     }
@@ -49294,7 +49536,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 };
     }
@@ -49311,6 +49554,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
@@ -49339,7 +49583,7 @@ function deepMergeRecord(target, source) {
 }
 // src/cli/config-manager/write-omo-config.ts
-import { existsSync as existsSync9, 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;
 }
@@ -49356,10 +49600,18 @@ function writeOmoConfig(installConfig) {
   const omoConfigPath = getOmoConfigPath();
   try {
     const newConfig = generateOmoConfig(installConfig);
-    if (existsSync9(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) + `
 `);
@@ -49397,6 +49649,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();
@@ -49499,10 +49752,10 @@ var init_opencode_binary = __esm(() => {
 });
 // src/cli/config-manager/detect-current-config.ts
-import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync8 } from "fs";
 function detectProvidersFromOmoConfig() {
   const omoConfigPath = getOmoConfigPath();
-  if (!existsSync10(omoConfigPath)) {
+  if (!existsSync12(omoConfigPath)) {
     return {
       hasOpenAI: true,
       hasOpencodeZen: true,
@@ -49512,7 +49765,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 {
@@ -49543,9 +49796,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,
@@ -49566,7 +49823,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;
   }
@@ -49588,10 +49849,10 @@ var init_detect_current_config = __esm(() => {
 });
 // src/cli/config-manager/bun-install.ts
-import { existsSync as existsSync11 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { join as join12 } from "path";
 function getDefaultWorkspaceDir() {
-  return join11(getOpenCodeCacheDir(), "packages");
+  return join12(getOpenCodeCacheDir(), "packages");
 }
 function readProcessOutput(stream) {
   if (!stream) {
@@ -49617,7 +49878,7 @@ async function runBunInstallWithDetails(options) {
   const outputMode = options?.outputMode ?? "pipe";
   const cacheDir = options?.workspaceDir ?? getDefaultWorkspaceDir();
   const packageJsonPath = `${cacheDir}/package.json`;
-  if (!existsSync11(packageJsonPath)) {
+  if (!existsSync13(packageJsonPath)) {
     return {
       success: false,
       error: `Workspace not initialized: ${packageJsonPath} not found. OpenCode should create this on first run.`
@@ -49693,6 +49954,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
@@ -49753,6 +50015,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";
@@ -49770,15 +50488,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
@@ -49833,7 +50551,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 {
@@ -49865,7 +50583,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 {}
       }
@@ -49914,13 +50632,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 {
@@ -49929,11 +50649,13 @@ 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();
+  init_plugin_identity();
   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
@@ -49973,6 +50695,23 @@ function getCachedVersion() {
   } catch (err) {
     log("[auto-update-checker] Failed to resolve version from execPath:", err);
   }
+  try {
+    const currentFile = fileURLToPath2(import.meta.url);
+    let dir = path7.dirname(currentFile);
+    for (let i2 = 0;i2 < 10; i2++) {
+      const pkgPath = path7.join(dir, "package.json");
+      if (fs8.existsSync(pkgPath)) {
+        const content = fs8.readFileSync(pkgPath, "utf-8");
+        const pkg = JSON.parse(content);
+        if (pkg.version)
+          return pkg.version;
+      }
+      const parent = path7.dirname(dir);
+      if (parent === dir)
+        break;
+      dir = parent;
+    }
+  } catch {}
   return null;
 }
 var init_cached_version = __esm(() => {
@@ -50141,7 +50880,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}`
     };
   }
@@ -50159,21 +50898,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}` };
@@ -50185,7 +50924,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}"`
@@ -50251,7 +50990,7 @@ function removeFromBunLock(packageName) {
   }
   return false;
 }
-function invalidatePackage(packageName = PACKAGE_NAME) {
+function invalidatePackage(packageName = PACKAGE_NAME2) {
   try {
     const userConfigDir = getUserConfigDir();
     const pkgDirs = [
@@ -50291,7 +51030,7 @@ var init_cache = __esm(() => {
 async function showUpdateAvailableToast(ctx, latestVersion, getToastMessage) {
   await ctx.client.tui.showToast({
     body: {
-      title: `OhMyOpenCode ${latestVersion}`,
+      title: `EvilOMO ${latestVersion}`,
       message: getToastMessage(true, latestVersion),
       variant: "info",
       duration: 8000
@@ -50302,7 +51041,7 @@ async function showUpdateAvailableToast(ctx, latestVersion, getToastMessage) {
 async function showAutoUpdatedToast(ctx, oldVersion, newVersion) {
   await ctx.client.tui.showToast({
     body: {
-      title: "OhMyOpenCode Updated!",
+      title: "EvilOMO Updated!",
       message: `v${oldVersion} \u2192 v${newVersion}
 Restart OpenCode to apply.`,
       variant: "success",
@@ -50316,8 +51055,8 @@ var init_update_toasts = __esm(() => {
 });
 // src/hooks/auto-update-checker/hook/background-update-check.ts
-import { existsSync as existsSync22 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync24 } from "fs";
+import { join as join25 } from "path";
 function getCacheWorkspaceDir(deps) {
   return deps.join(deps.getOpenCodeCacheDir(), "packages");
 }
@@ -50327,8 +51066,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;
@@ -50407,7 +51146,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) {
@@ -50435,8 +51174,8 @@ var init_background_update_check = __esm(() => {
   init_checker();
   init_update_toasts();
   defaultDeps = {
-    existsSync: existsSync22,
-    join: join23,
+    existsSync: existsSync24,
+    join: join25,
     runBunInstallWithDetails,
     log,
     getOpenCodeCacheDir,
@@ -50583,7 +51322,7 @@ async function showSpinnerToast(ctx, version2, message) {
     const spinner = SISYPHUS_SPINNER[i2 % SISYPHUS_SPINNER.length];
     await ctx.client.tui.showToast({
       body: {
-        title: `${spinner} OhMyOpenCode ${version2}`,
+        title: `${spinner} EvilOMO ${version2}`,
         message,
         variant: "info",
         duration: frameInterval + 50
@@ -50716,7 +51455,7 @@ var {
 // package.json
 var package_default = {
   name: "evil-omo",
-  version: "3.15.3",
+  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",
@@ -50775,8 +51514,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",
@@ -50785,7 +51524,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",
@@ -50794,21 +51533,19 @@ var package_default = {
     typescript: "^5.7.3"
   },
   optionalDependencies: {
-    "evil-omo-darwin-arm64": "3.15.3",
-    "evil-omo-darwin-x64": "3.15.3",
-    "evil-omo-darwin-x64-baseline": "3.15.3",
-    "evil-omo-linux-x64": "3.15.3",
-    "evil-omo-linux-x64-baseline": "3.15.3",
-    "evil-omo-linux-arm64": "3.15.3",
-    "evil-omo-linux-x64-musl": "3.15.3",
-    "evil-omo-linux-x64-musl-baseline": "3.15.3",
-    "evil-omo-linux-arm64-musl": "3.15.3",
-    "evil-omo-windows-x64": "3.15.3",
-    "evil-omo-windows-x64-baseline": "3.15.3"
-  },
-  overrides: {
-    "@opencode-ai/sdk": "^1.2.24"
+    "evil-omo-darwin-arm64": "3.16.0",
+    "evil-omo-darwin-x64": "3.16.0",
+    "evil-omo-darwin-x64-baseline": "3.16.0",
+    "evil-omo-linux-x64": "3.16.0",
+    "evil-omo-linux-x64-baseline": "3.16.0",
+    "evil-omo-linux-arm64": "3.16.0",
+    "evil-omo-linux-x64-musl": "3.16.0",
+    "evil-omo-linux-x64-musl-baseline": "3.16.0",
+    "evil-omo-linux-arm64-musl": "3.16.0",
+    "evil-omo-windows-x64": "3.16.0",
+    "evil-omo-windows-x64-baseline": "3.16.0"
   },
+  overrides: {},
   trustedDependencies: [
     "@ast-grep/cli",
     "@ast-grep/napi",
@@ -50819,7 +51556,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);
@@ -50966,6 +51703,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);
@@ -50993,6 +51780,11 @@ async function runCliInstaller(args, version) {
     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);
@@ -51005,47 +51797,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/D4ch1au/evil-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/D4ch1au/evil-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;
 }
@@ -51440,7 +52222,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() {
@@ -51473,13 +52255,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) => {
@@ -51489,7 +52271,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) => {
@@ -51497,29 +52279,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();
@@ -51531,53 +52313,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();
@@ -51600,14 +52382,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")
@@ -51620,7 +52402,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();
@@ -51633,7 +52415,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) {
@@ -51754,7 +52536,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}`);
@@ -51764,11 +52546,17 @@ async function runTuiInstaller(args, version) {
   const installed = await isOpenCodeInstalled();
   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)
@@ -51777,55 +52565,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/D4ch1au/evil-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/D4ch1au/evil-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}`);
     }
@@ -51841,7 +52620,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() {
@@ -51875,7 +52654,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";
@@ -51919,10 +52698,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);
@@ -51931,7 +52710,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": {
@@ -51939,10 +52718,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;
     }
@@ -51951,7 +52730,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": {
@@ -51960,7 +52739,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": {
@@ -51978,32 +52757,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) {
@@ -52139,14 +52918,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) {
@@ -52154,7 +52933,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(`
@@ -52162,7 +52941,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(`
@@ -52196,10 +52975,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`;
 }
@@ -52239,7 +53018,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;
@@ -52273,7 +53052,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}`));
   }
 }
@@ -52301,7 +53080,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;
     }
@@ -52348,7 +53127,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;
@@ -52369,10 +53148,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") {
@@ -52380,10 +53159,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(`
 `);
     }
@@ -52445,10 +53224,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) {
@@ -52462,10 +53241,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(`
 `);
   }
@@ -52514,7 +53293,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;
       }
@@ -52532,7 +53311,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}`));
     }
   }
 }
@@ -68085,6 +68864,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) => {
@@ -68103,10 +68907,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",
@@ -68116,19 +68956,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(`
 `);
@@ -68136,9 +68981,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;
         }
@@ -68160,17 +69010,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);
     }
   };
 }
@@ -68190,11 +69039,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, join as join13 } from "path";
+import { delimiter, dirname as dirname2, join as join14 } from "path";
 var OPENCODE_COMMANDS = ["opencode", "opencode-desktop"];
 var WINDOWS_SUFFIXES = ["", ".exe", ".cmd", ".bat", ".ps1"];
 function getCommandCandidates(platform) {
@@ -68217,7 +69066,7 @@ function collectCandidateBinaryPaths(pathEnv, which = Bun.which, platform = proc
   }
   for (const entry of (pathEnv ?? "").split(delimiter).filter(Boolean)) {
     for (const command of commandCandidates) {
-      addCandidate(join13(entry, command));
+      addCandidate(join14(entry, command));
     }
   }
   return candidates;
@@ -68244,7 +69093,7 @@ async function findWorkingOpencodeBinary(pathEnv = process.env.PATH, probe = can
   return null;
 }
 function buildPathWithBinaryFirst(pathEnv, binaryPath) {
-  const preferredDir = dirname(binaryPath);
+  const preferredDir = dirname2(binaryPath);
   const existing = (pathEnv ?? "").split(delimiter).filter((entry) => entry.length > 0 && entry !== preferredDir);
   return [preferredDir, ...existing].join(delimiter);
 }
@@ -68278,13 +69127,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: () => {} };
   }
@@ -68294,7 +69143,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) {
@@ -68305,12 +69154,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: () => {} };
   }
@@ -68328,14 +69177,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 });
@@ -68344,13 +69193,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) {
@@ -68376,11 +69225,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;
@@ -68388,10 +69237,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));
     }
   }
@@ -68509,7 +69358,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) => {
@@ -68554,10 +69403,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;
@@ -68588,11 +69437,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";
@@ -68600,19 +69449,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 existsSync13, readFileSync as readFileSync9, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, readdirSync as readdirSync2 } from "fs";
-import { dirname as dirname2, join as join14, basename } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync10, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, readdirSync as readdirSync3 } from "fs";
+import { dirname as dirname3, join as join15, basename } from "path";
 var RESERVED_KEYS = new Set(["__proto__", "prototype", "constructor"]);
 function getBoulderFilePath(directory) {
-  return join14(directory, BOULDER_DIR, BOULDER_FILE);
+  return join15(directory, BOULDER_DIR, BOULDER_FILE);
 }
 function readBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
-  if (!existsSync13(filePath)) {
+  if (!existsSync15(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync9(filePath, "utf-8");
+    const content = readFileSync10(filePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       return null;
@@ -68637,30 +69486,83 @@ 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 (!existsSync13(planPath)) {
+  if (!existsSync15(planPath)) {
     return { total: 0, completed: 0, isComplete: true };
   }
   try {
-    const content = readFileSync9(planPath, "utf-8");
-    const uncheckedMatches = content.match(/^\s*[-*]\s*\[\s*\]/gm) || [];
-    const checkedMatches = content.match(/^\s*[-*]\s*\[[xX]\]/gm) || [];
-    const total = uncheckedMatches.length + checkedMatches.length;
-    const completed = checkedMatches.length;
-    return {
-      total,
-      completed,
-      isComplete: total > 0 && completed === total
-    };
+    const content = readFileSync10(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);
@@ -68668,17 +69570,17 @@ function getSessionAgent(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 existsSync14, mkdirSync as mkdirSync5, readFileSync as readFileSync10, rmSync, writeFileSync as writeFileSync6 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync6, readFileSync as readFileSync11, rmSync, writeFileSync as writeFileSync6 } from "fs";
+import { join as join16 } from "path";
 function getMarkerPath(directory, sessionID) {
-  return join15(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
+  return join16(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
 }
 function readContinuationMarker(directory, sessionID) {
   const markerPath = getMarkerPath(directory, sessionID);
-  if (!existsSync14(markerPath))
+  if (!existsSync16(markerPath))
     return null;
   try {
-    const raw = readFileSync10(markerPath, "utf-8");
+    const raw = readFileSync11(markerPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
       return null;
@@ -68738,28 +69640,32 @@ async function isSessionInBoulderLineage(input) {
 // src/hooks/atlas/session-last-agent.ts
 init_shared();
-import { readFileSync as readFileSync11, readdirSync as readdirSync3 } from "fs";
-import { join as join16 } from "path";
-function isCompactionAgent(agent) {
-  return typeof agent === "string" && agent.toLowerCase() === "compaction";
-}
+init_compaction_marker();
+import { readFileSync as readFileSync12, readdirSync as readdirSync4 } from "fs";
+import { join as join17 } from "path";
 function getLastAgentFromMessageDir(messageDir) {
   try {
-    const messages = readdirSync3(messageDir).filter((fileName) => fileName.endsWith(".json")).map((fileName) => {
+    const messages = readdirSync4(messageDir).filter((fileName) => fileName.endsWith(".json")).map((fileName) => {
       try {
-        const content = readFileSync11(join16(messageDir, fileName), "utf-8");
+        const content = readFileSync12(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 - left.createdAt || right.fileName.localeCompare(left.fileName));
+    }).filter((message) => message !== null).sort((left, right) => (right?.createdAt ?? 0) - (left?.createdAt ?? 0) || (right?.fileName ?? "").localeCompare(left?.fileName ?? ""));
     for (const message of messages) {
-      if (typeof message.agent === "string" && !isCompactionAgent(message.agent)) {
+      if (!message)
+        continue;
+      if (isCompactionMessage({ agent: message.agent }) || hasCompactionPartInStorage(message?.id)) {
+        continue;
+      }
+      if (typeof message.agent === "string") {
         return message.agent.toLowerCase();
       }
     }
@@ -68785,8 +69691,11 @@ async function getLastAgentFromSession(sessionID, client3) {
         return rightId.localeCompare(leftId);
       });
       for (const message of messages) {
+        if (isCompactionMessage(message)) {
+          continue;
+        }
         const agent = message.info?.agent;
-        if (typeof agent === "string" && !isCompactionAgent(agent)) {
+        if (typeof agent === "string") {
           return agent.toLowerCase();
         }
       }
@@ -68806,8 +69715,8 @@ init_agent_display_names();
 // src/hooks/ralph-loop/storage.ts
 init_frontmatter();
-import { existsSync as existsSync15, readFileSync as readFileSync12, writeFileSync as writeFileSync7, unlinkSync, mkdirSync as mkdirSync6 } from "fs";
-import { dirname as dirname3, join as join17 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync13, writeFileSync as writeFileSync7, unlinkSync, mkdirSync as mkdirSync7 } from "fs";
+import { dirname as dirname4, join as join18 } from "path";
 // src/hooks/ralph-loop/constants.ts
 var DEFAULT_STATE_FILE = ".sisyphus/ralph-loop.local.md";
@@ -68816,15 +69725,15 @@ var DEFAULT_COMPLETION_PROMISE = "DONE";
 // src/hooks/ralph-loop/storage.ts
 function getStateFilePath(directory, customPath) {
-  return customPath ? join17(directory, customPath) : join17(directory, DEFAULT_STATE_FILE);
+  return customPath ? join18(directory, customPath) : join18(directory, DEFAULT_STATE_FILE);
 }
 function readState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
-  if (!existsSync15(filePath)) {
+  if (!existsSync17(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync12(filePath, "utf-8");
+    const content = readFileSync13(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     const active = data.active;
     const iteration = data.iteration;
@@ -68948,7 +69857,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;
   }
 }
@@ -69009,7 +69918,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
@@ -69040,10 +69949,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;
@@ -69054,7 +69963,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") {
@@ -69103,7 +70012,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`));
         }
       }
@@ -69123,7 +70032,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;
@@ -69292,7 +70201,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();
@@ -69305,9 +70214,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,
@@ -69370,7 +70279,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();
@@ -69380,53 +70289,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("evil-omo Version Information")));
-  lines.push(import_picocolors15.default.dim("\u2500".repeat(50)));
+  lines.push(import_picocolors16.default.bold(import_picocolors16.default.white("evil-omo 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 evil-omo")}`);
+      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 evil-omo")}`);
       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("");
@@ -69525,69 +70434,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 existsSync26, readFileSync as readFileSync22 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync23 } from "fs";
 // src/cli/doctor/checks/system-binary.ts
 init_spawn_with_windows_hide();
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join24 } from "path";
+import { join as join26 } from "path";
 function getDesktopAppPaths(platform) {
   const home = homedir5();
   switch (platform) {
     case "darwin":
       return [
         "/Applications/OpenCode.app/Contents/MacOS/OpenCode",
-        join24(home, "Applications", "OpenCode.app", "Contents", "MacOS", "OpenCode")
+        join26(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(join24(programFiles, "OpenCode", "OpenCode.exe"));
+        paths.push(join26(programFiles, "OpenCode", "OpenCode.exe"));
       }
       if (localAppData) {
-        paths.push(join24(localAppData, "OpenCode", "OpenCode.exe"));
+        paths.push(join26(localAppData, "OpenCode", "OpenCode.exe"));
       }
       return paths;
     }
@@ -69595,8 +70466,8 @@ function getDesktopAppPaths(platform) {
       return [
         "/usr/bin/opencode",
         "/usr/lib/opencode/opencode",
-        join24(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
-        join24(home, "Applications", "opencode-desktop-linux-aarch64.AppImage")
+        join26(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
+        join26(home, "Applications", "opencode-desktop-linux-aarch64.AppImage")
       ];
     default:
       return [];
@@ -69608,7 +70479,7 @@ function buildVersionCommand(binaryPath, platform) {
   }
   return [binaryPath, "--version"];
 }
-function findDesktopBinary(platform = process.platform, checkExists = existsSync23) {
+function findDesktopBinary(platform = process.platform, checkExists = existsSync25) {
   for (const desktopPath of getDesktopAppPaths(platform)) {
     if (checkExists(desktopPath)) {
       return { binary: "opencode", path: desktopPath };
@@ -69638,10 +70509,10 @@ async function getOpenCodeVersion3(binaryPath, platform = process.platform) {
     return null;
   }
 }
-function compareVersions2(current, minimum) {
-  const parseVersion2 = (version2) => version2.replace(/^v/, "").split("-")[0].split(".").map((part) => Number.parseInt(part, 10) || 0);
-  const currentParts = parseVersion2(current);
-  const minimumParts = parseVersion2(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;
@@ -69656,12 +70527,12 @@ function compareVersions2(current, minimum) {
 // src/cli/doctor/checks/system-plugin.ts
 init_shared();
-import { existsSync as existsSync24, readFileSync as readFileSync20 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync21 } from "fs";
 function detectConfigPath() {
   const paths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
-  if (existsSync24(paths.configJsonc))
+  if (existsSync26(paths.configJsonc))
     return paths.configJsonc;
-  if (existsSync24(paths.configJson))
+  if (existsSync26(paths.configJson))
     return paths.configJson;
   return null;
 }
@@ -69707,7 +70578,7 @@ function getPluginInfo() {
     };
   }
   try {
-    const content = readFileSync20(configPath, "utf-8");
+    const content = readFileSync21(configPath, "utf-8");
     const parsedConfig = parseJsonc(content);
     const pluginEntry = findPluginEntry2(parsedConfig.plugin ?? []);
     if (!pluginEntry) {
@@ -69745,37 +70616,37 @@ function getPluginInfo() {
 init_file_utils();
 init_checker();
 init_auto_update_checker();
-import { existsSync as existsSync25, readFileSync as readFileSync21 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync22 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join25 } from "path";
+import { join as join27 } from "path";
 init_shared();
 function getPlatformDefaultCacheDir(platform = process.platform) {
   if (platform === "darwin")
-    return join25(homedir6(), "Library", "Caches");
+    return join27(homedir6(), "Library", "Caches");
   if (platform === "win32")
-    return process.env.LOCALAPPDATA ?? join25(homedir6(), "AppData", "Local");
-  return join25(homedir6(), ".cache");
+    return process.env.LOCALAPPDATA ?? join27(homedir6(), "AppData", "Local");
+  return join27(homedir6(), ".cache");
 }
 function resolveOpenCodeCacheDir() {
   const xdgCacheHome = process.env.XDG_CACHE_HOME;
   if (xdgCacheHome)
-    return join25(xdgCacheHome, "opencode");
+    return join27(xdgCacheHome, "opencode");
   const fromShared = getOpenCodeCacheDir();
-  const platformDefault = join25(getPlatformDefaultCacheDir(), "opencode");
-  if (existsSync25(fromShared) || !existsSync25(platformDefault))
+  const platformDefault = join27(getPlatformDefaultCacheDir(), "opencode");
+  if (existsSync27(fromShared) || !existsSync27(platformDefault))
     return fromShared;
   return platformDefault;
 }
 function resolveExistingDir(dirPath) {
-  if (!existsSync25(dirPath))
+  if (!existsSync27(dirPath))
     return dirPath;
   return resolveSymlink(dirPath);
 }
 function readPackageJson(filePath) {
-  if (!existsSync25(filePath))
+  if (!existsSync27(filePath))
     return null;
   try {
-    const content = readFileSync21(filePath, "utf-8");
+    const content = readFileSync22(filePath, "utf-8");
     return parseJsonc(content);
   } catch {
     return null;
@@ -69794,20 +70665,20 @@ function getLoadedPluginVersion() {
   const candidates = [
     {
       cacheDir: configDir,
-      cachePackagePath: join25(configDir, "package.json"),
-      installedPackagePath: join25(configDir, "node_modules", PACKAGE_NAME2, "package.json")
+      cachePackagePath: join27(configDir, "package.json"),
+      installedPackagePath: join27(configDir, "node_modules", PACKAGE_NAME, "package.json")
     },
     {
       cacheDir,
-      cachePackagePath: join25(cacheDir, "package.json"),
-      installedPackagePath: join25(cacheDir, "node_modules", PACKAGE_NAME2, "package.json")
+      cachePackagePath: join27(cacheDir, "package.json"),
+      installedPackagePath: join27(cacheDir, "node_modules", PACKAGE_NAME, "package.json")
     }
   ];
-  const selectedCandidate = candidates.find((candidate) => existsSync25(candidate.installedPackagePath)) ?? candidates[0];
+  const selectedCandidate = candidates.find((candidate) => existsSync27(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,
@@ -69831,10 +70702,10 @@ init_plugin_identity();
 function isConfigValid(configPath) {
   if (!configPath)
     return true;
-  if (!existsSync26(configPath))
+  if (!existsSync28(configPath))
     return false;
   try {
-    parseJsonc(readFileSync22(configPath, "utf-8"));
+    parseJsonc(readFileSync23(configPath, "utf-8"));
     return true;
   } catch {
     return false;
@@ -69885,7 +70756,7 @@ async function checkSystem() {
       affects: ["doctor", "run"]
     });
   }
-  if (systemInfo.opencodeVersion && !compareVersions2(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}.`,
@@ -69925,7 +70796,7 @@ async function checkSystem() {
       affects: ["plugin loading"]
     });
   }
-  if (systemInfo.loadedVersion && latestVersion && !compareVersions2(systemInfo.loadedVersion, latestVersion)) {
+  if (systemInfo.loadedVersion && latestVersion && !compareVersions3(systemInfo.loadedVersion, latestVersion)) {
     issues.push({
       title: "Loaded plugin is outdated",
       description: `Loaded ${systemInfo.loadedVersion}, latest ${latestVersion}.`,
@@ -69950,28 +70821,28 @@ async function checkSystem() {
 }
 // src/cli/doctor/checks/config.ts
-import { readFileSync as readFileSync25 } from "fs";
-import { join as join29 } from "path";
+import { readFileSync as readFileSync26 } from "fs";
+import { join as join31 } from "path";
 init_shared();
 // src/cli/doctor/checks/model-resolution-cache.ts
 init_shared();
-import { existsSync as existsSync27, readFileSync as readFileSync23 } from "fs";
+import { existsSync as existsSync29, readFileSync as readFileSync24 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join26 } from "path";
+import { join as join28 } from "path";
 function getOpenCodeCacheDir2() {
   const xdgCache = process.env.XDG_CACHE_HOME;
   if (xdgCache)
-    return join26(xdgCache, "opencode");
-  return join26(homedir7(), ".cache", "opencode");
+    return join28(xdgCache, "opencode");
+  return join28(homedir7(), ".cache", "opencode");
 }
 function loadAvailableModelsFromCache() {
-  const cacheFile = join26(getOpenCodeCacheDir2(), "models.json");
-  if (!existsSync27(cacheFile)) {
+  const cacheFile = join28(getOpenCodeCacheDir2(), "models.json");
+  if (!existsSync29(cacheFile)) {
     return { providers: [], modelCount: 0, cacheExists: false };
   }
   try {
-    const content = readFileSync23(cacheFile, "utf-8");
+    const content = readFileSync24(cacheFile, "utf-8");
     const data = parseJsonc(content);
     const providers = Object.keys(data);
     let modelCount = 0;
@@ -69993,14 +70864,14 @@ init_model_capabilities();
 // src/cli/doctor/checks/model-resolution-config.ts
 init_shared();
-import { readFileSync as readFileSync24 } from "fs";
-import { join as join27 } from "path";
-var PROJECT_CONFIG_DIR = join27(process.cwd(), ".opencode");
+import { readFileSync as readFileSync25 } from "fs";
+import { join as join29 } from "path";
+var PROJECT_CONFIG_DIR = join29(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 = readFileSync25(projectDetected.path, "utf-8");
       return parseJsonc(content);
     } catch {
       return null;
@@ -70010,7 +70881,7 @@ function loadOmoConfig() {
   const userDetected = detectPluginConfigFile(userConfigDir);
   if (userDetected.format !== "none") {
     try {
-      const content = readFileSync24(userDetected.path, "utf-8");
+      const content = readFileSync25(userDetected.path, "utf-8");
       return parseJsonc(content);
     } catch {
       return null;
@@ -70021,7 +70892,7 @@ function loadOmoConfig() {
 // src/cli/doctor/checks/model-resolution-details.ts
 init_shared();
-import { join as join28 } from "path";
+import { join as join30 } from "path";
 // src/cli/doctor/checks/model-resolution-variant.ts
 function formatModelWithVariant(model, variant) {
@@ -70063,7 +70934,7 @@ function formatCapabilityResolutionLabel(mode) {
 }
 function buildModelResolutionDetails(options) {
   const details = [];
-  const cacheFile = join28(getOpenCodeCacheDir(), "models.json");
+  const cacheFile = join30(getOpenCodeCacheDir(), "models.json");
   details.push("\u2550\u2550\u2550 Available Models (from cache) \u2550\u2550\u2550");
   details.push("");
   if (options.available.cacheExists) {
@@ -70218,7 +71089,7 @@ async function checkModels() {
 }
 // src/cli/doctor/checks/config.ts
-var PROJECT_CONFIG_DIR2 = join29(process.cwd(), ".opencode");
+var PROJECT_CONFIG_DIR2 = join31(process.cwd(), ".opencode");
 function findConfigPath() {
   const projectConfig = detectPluginConfigFile(PROJECT_CONFIG_DIR2);
   if (projectConfig.format !== "none")
@@ -70235,7 +71106,7 @@ function validateConfig() {
     return { exists: false, path: null, valid: true, config: null, errors: [] };
   }
   try {
-    const content = readFileSync25(configPath, "utf-8");
+    const content = readFileSync26(configPath, "utf-8");
     const rawConfig = parseJsonc(content);
     const schemaResult = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
     if (!schemaResult.success) {
@@ -70339,9 +71210,9 @@ async function checkConfig() {
 // src/cli/doctor/checks/dependencies.ts
 init_spawn_with_windows_hide();
-import { existsSync as existsSync28 } from "fs";
+import { existsSync as existsSync30 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname7, join as join30 } from "path";
+import { dirname as dirname8, join as join32 } from "path";
 async function checkBinaryExists(binary2) {
   try {
     const path10 = Bun.which(binary2);
@@ -70397,15 +71268,15 @@ async function checkAstGrepNapi() {
       path: null
     };
   } catch {
-    const { existsSync: existsSync29 } = await import("fs");
-    const { join: join31 } = await import("path");
+    const { existsSync: existsSync31 } = await import("fs");
+    const { join: join33 } = await import("path");
     const { homedir: homedir8 } = await import("os");
     const pathsToCheck = [
-      join31(homedir8(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
-      join31(process.cwd(), "node_modules", "@ast-grep", "napi")
+      join33(homedir8(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
+      join33(process.cwd(), "node_modules", "@ast-grep", "napi")
     ];
     for (const napiPath of pathsToCheck) {
-      if (existsSync29(napiPath)) {
+      if (existsSync31(napiPath)) {
         return {
           name: "AST-Grep NAPI",
           required: false,
@@ -70430,8 +71301,8 @@ function findCommentCheckerPackageBinary() {
   try {
     const require2 = createRequire(import.meta.url);
     const pkgPath = require2.resolve("@code-yeongyu/comment-checker/package.json");
-    const binaryPath = join30(dirname7(pkgPath), "bin", binaryName);
-    if (existsSync28(binaryPath))
+    const binaryPath = join32(dirname8(pkgPath), "bin", binaryName);
+    if (existsSync30(binaryPath))
       return binaryPath;
   } catch {}
   return null;
@@ -70588,15 +71459,15 @@ var BUILTIN_SERVERS = {
   "kotlin-ls": { command: ["kotlin-lsp"], extensions: [".kt", ".kts"] }
 };
 // src/tools/lsp/server-config-loader.ts
-import { existsSync as existsSync29, readFileSync as readFileSync26 } from "fs";
-import { join as join31 } from "path";
+import { existsSync as existsSync31, readFileSync as readFileSync27 } from "fs";
+import { join as join33 } from "path";
 init_shared();
 init_jsonc_parser();
 function loadJsonFile(path10) {
-  if (!existsSync29(path10))
+  if (!existsSync31(path10))
     return null;
   try {
-    return parseJsonc(readFileSync26(path10, "utf-8"));
+    return parseJsonc(readFileSync27(path10, "utf-8"));
   } catch {
     return null;
   }
@@ -70605,9 +71476,9 @@ function getConfigPaths2() {
   const cwd = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   return {
-    project: detectPluginConfigFile(join31(cwd, ".opencode")).path,
+    project: detectPluginConfigFile(join33(cwd, ".opencode")).path,
     user: detectPluginConfigFile(configDir).path,
-    opencode: detectConfigFile(join31(configDir, "opencode")).path
+    opencode: detectConfigFile(join33(configDir, "opencode")).path
   };
 }
 function loadAllConfigs() {
@@ -70676,21 +71547,21 @@ function getMergedServers() {
 }
 // src/tools/lsp/server-installation.ts
-import { existsSync as existsSync30 } from "fs";
-import { delimiter as delimiter2, join as join33 } from "path";
+import { existsSync as existsSync32 } from "fs";
+import { delimiter as delimiter2, join as join35 } from "path";
 // src/tools/lsp/server-path-bases.ts
 init_shared();
-import { join as join32 } from "path";
+import { join as join34 } from "path";
 function getLspServerAdditionalPathBases(workingDirectory) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join32(getDataDir(), "opencode");
+  const dataDir = join34(getDataDir(), "opencode");
   return [
-    join32(workingDirectory, "node_modules", ".bin"),
-    join32(configDir, "bin"),
-    join32(configDir, "node_modules", ".bin"),
-    join32(dataDir, "bin"),
-    join32(dataDir, "bin", "node_modules", ".bin")
+    join34(workingDirectory, "node_modules", ".bin"),
+    join34(configDir, "bin"),
+    join34(configDir, "node_modules", ".bin"),
+    join34(dataDir, "bin"),
+    join34(dataDir, "bin", "node_modules", ".bin")
   ];
 }
@@ -70700,7 +71571,7 @@ function isServerInstalled(command) {
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync30(cmd))
+    if (existsSync32(cmd))
       return true;
   }
   const isWindows = process.platform === "win32";
@@ -70721,14 +71592,14 @@ function isServerInstalled(command) {
   const paths = pathEnv.split(delimiter2);
   for (const p2 of paths) {
     for (const suffix of exts) {
-      if (existsSync30(join33(p2, cmd + suffix))) {
+      if (existsSync32(join35(p2, cmd + suffix))) {
         return true;
       }
     }
   }
   for (const base of getLspServerAdditionalPathBases(process.cwd())) {
     for (const suffix of exts) {
-      if (existsSync30(join33(base, cmd + suffix))) {
+      if (existsSync32(join35(base, cmd + suffix))) {
         return true;
       }
     }
@@ -70790,24 +71661,24 @@ function getInstalledLspServers() {
 // src/cli/doctor/checks/tools-mcp.ts
 init_shared();
-import { existsSync as existsSync31, readFileSync as readFileSync27 } from "fs";
+import { existsSync as existsSync33, readFileSync as readFileSync28 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join34 } from "path";
+import { join as join36 } from "path";
 var BUILTIN_MCP_SERVERS = ["context7", "grep_app"];
 function getMcpConfigPaths() {
   return [
-    join34(homedir8(), ".claude", ".mcp.json"),
-    join34(process.cwd(), ".mcp.json"),
-    join34(process.cwd(), ".claude", ".mcp.json")
+    join36(homedir8(), ".claude", ".mcp.json"),
+    join36(process.cwd(), ".mcp.json"),
+    join36(process.cwd(), ".claude", ".mcp.json")
   ];
 }
 function loadUserMcpConfig() {
   const servers = {};
   for (const configPath of getMcpConfigPaths()) {
-    if (!existsSync31(configPath))
+    if (!existsSync33(configPath))
       continue;
     try {
-      const content = readFileSync27(configPath, "utf-8");
+      const content = readFileSync28(configPath, "utf-8");
       const config2 = parseJsonc(content);
       if (config2.mcpServers) {
         Object.assign(servers, config2.mcpServers);
@@ -70974,17 +71845,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 `
@@ -71014,12 +71885,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 evil-omo ${pluginVer})`)}`);
+    lines.push(` ${import_picocolors18.default.green(SYMBOLS2.check)} ${import_picocolors18.default.green(`System OK (opencode ${opencodeVer} \xB7 evil-omo ${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));
@@ -71260,11 +72131,11 @@ async function refreshModelCapabilities(options, deps = {}) {
 // src/features/mcp-oauth/storage.ts
 init_shared();
-import { chmodSync, existsSync as existsSync32, mkdirSync as mkdirSync8, readFileSync as readFileSync28, unlinkSync as unlinkSync4, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname8, join as join35 } from "path";
+import { chmodSync, existsSync as existsSync34, mkdirSync as mkdirSync9, readFileSync as readFileSync29, renameSync as renameSync3, unlinkSync as unlinkSync4, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname9, join as join37 } from "path";
 var STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStoragePath() {
-  return join35(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
+  return join37(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
 }
 function normalizeHost(serverHost) {
   let host = serverHost.trim();
@@ -71301,11 +72172,11 @@ function buildKey(serverHost, resource) {
 }
 function readStore() {
   const filePath = getMcpOauthStoragePath();
-  if (!existsSync32(filePath)) {
+  if (!existsSync34(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync28(filePath, "utf-8");
+    const content = readFileSync29(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -71314,12 +72185,14 @@ function readStore() {
 function writeStore(store2) {
   const filePath = getMcpOauthStoragePath();
   try {
-    const dir = dirname8(filePath);
-    if (!existsSync32(dir)) {
-      mkdirSync8(dir, { recursive: true });
-    }
-    writeFileSync10(filePath, JSON.stringify(store2, null, 2), { encoding: "utf-8", mode: 384 });
-    chmodSync(filePath, 384);
+    const dir = dirname9(filePath);
+    if (!existsSync34(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);
+    renameSync3(tempPath, filePath);
     return true;
   } catch {
     return false;
@@ -71350,7 +72223,7 @@ function deleteToken(serverHost, resource) {
   if (Object.keys(store2).length === 0) {
     try {
       const filePath = getMcpOauthStoragePath();
-      if (existsSync32(filePath)) {
+      if (existsSync34(filePath)) {
         unlinkSync4(filePath);
       }
       return true;
@@ -71540,7 +72413,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() {
@@ -71621,7 +72494,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 {}
@@ -71648,6 +72521,38 @@ async function runAuthorizationCodeRedirect(options) {
 }
 // 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;
@@ -71742,33 +72647,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;
   }