evil-omo 3.15.3 → 3.16.1

package/dist/cli/index.js

@@ -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
   });
@@ -6038,47 +6042,8 @@ var init_jsonc_parser = __esm(() => {
 });
 
 // src/shared/migration/agent-names.ts
-function migrateAgentNames(agents) {
-  const migrated = {};
-  let changed = false;
-  for (const [key, value] of Object.entries(agents)) {
-    const newKey = AGENT_NAME_MAP[key.toLowerCase()] ?? AGENT_NAME_MAP[key] ?? key;
-    if (newKey !== key) {
-      changed = true;
-    }
-    migrated[newKey] = value;
-  }
-  return { migrated, changed };
-}
-var AGENT_NAME_MAP, BUILTIN_AGENT_NAMES;
+var BUILTIN_AGENT_NAMES;
 var init_agent_names = __esm(() => {
-  AGENT_NAME_MAP = {
-    omo: "sisyphus",
-    OmO: "sisyphus",
-    Sisyphus: "sisyphus",
-    sisyphus: "sisyphus",
-    "OmO-Plan": "prometheus",
-    "omo-plan": "prometheus",
-    "Planner-Sisyphus": "prometheus",
-    "planner-sisyphus": "prometheus",
-    "Prometheus (Planner)": "prometheus",
-    prometheus: "prometheus",
-    "orchestrator-sisyphus": "atlas",
-    Atlas: "atlas",
-    atlas: "atlas",
-    "plan-consultant": "metis",
-    "Metis (Plan Consultant)": "metis",
-    metis: "metis",
-    "Momus (Plan Reviewer)": "momus",
-    momus: "momus",
-    "Sisyphus-Junior": "sisyphus-junior",
-    "sisyphus-junior": "sisyphus-junior",
-    build: "build",
-    oracle: "oracle",
-    librarian: "librarian",
-    explore: "explore",
-    "multimodal-looker": "multimodal-looker"
-  };
   BUILTIN_AGENT_NAMES = new Set([
     "sisyphus",
     "oracle",
@@ -6094,212 +6059,19 @@ var init_agent_names = __esm(() => {
 });
 
 // src/shared/migration/hook-names.ts
-function migrateHookNames(hooks) {
-  const migrated = [];
-  const removed = [];
-  let changed = false;
-  for (const hook of hooks) {
-    const mapping = HOOK_NAME_MAP[hook];
-    if (mapping === null) {
-      removed.push(hook);
-      changed = true;
-      continue;
-    }
-    const newHook = mapping ?? hook;
-    if (newHook !== hook) {
-      changed = true;
-    }
-    migrated.push(newHook);
-  }
-  return { migrated, changed, removed };
-}
-var HOOK_NAME_MAP;
-var init_hook_names = __esm(() => {
-  HOOK_NAME_MAP = {
-    "anthropic-auto-compact": "anthropic-context-window-limit-recovery",
-    "sisyphus-orchestrator": "atlas",
-    "sisyphus-gpt-hephaestus-reminder": "no-sisyphus-gpt",
-    "empty-message-sanitizer": null,
-    "delegate-task-english-directive": null,
-    "gpt-permission-continuation": null
-  };
-});
+var init_hook_names = () => {};
 
 // src/shared/migration/model-versions.ts
-function migrationKey(oldModel, newModel) {
-  return `model-version:${oldModel}->${newModel}`;
-}
-function migrateModelVersions(configs, appliedMigrations) {
-  const migrated = {};
-  let changed = false;
-  const newMigrations = [];
-  for (const [key, value] of Object.entries(configs)) {
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-      const config = value;
-      if (typeof config.model === "string" && MODEL_VERSION_MAP[config.model]) {
-        const oldModel = config.model;
-        const newModel = MODEL_VERSION_MAP[oldModel];
-        const mKey = migrationKey(oldModel, newModel);
-        if (appliedMigrations?.has(mKey)) {
-          migrated[key] = value;
-          continue;
-        }
-        migrated[key] = { ...config, model: newModel };
-        changed = true;
-        newMigrations.push(mKey);
-        continue;
-      }
-    }
-    migrated[key] = value;
-  }
-  return { migrated, changed, newMigrations };
-}
-var MODEL_VERSION_MAP;
-var init_model_versions = __esm(() => {
-  MODEL_VERSION_MAP = {
-    "anthropic/claude-opus-4-5": "anthropic/claude-opus-4-6",
-    "anthropic/claude-sonnet-4-5": "anthropic/claude-sonnet-4-6",
-    "openai/gpt-5.3-codex": "openai/gpt-5.4"
-  };
-});
+var init_model_versions = () => {};
 
 // src/shared/migration/agent-category.ts
 var init_agent_category = () => {};
 
-// src/shared/write-file-atomically.ts
-import { closeSync, fsyncSync, openSync, renameSync, writeFileSync } from "fs";
-function writeFileAtomically(filePath, content) {
-  const tempPath = `${filePath}.tmp`;
-  writeFileSync(tempPath, content, "utf-8");
-  const tempFileDescriptor = openSync(tempPath, "r");
-  try {
-    fsyncSync(tempFileDescriptor);
-  } finally {
-    closeSync(tempFileDescriptor);
-  }
-  renameSync(tempPath, filePath);
-}
-var init_write_file_atomically = () => {};
-
 // src/shared/migration/config-migration.ts
-import * as fs2 from "fs";
-function migrateConfigFile(configPath, rawConfig) {
-  const copy = structuredClone(rawConfig);
-  let needsWrite = false;
-  const existingMigrations = Array.isArray(copy._migrations) ? new Set(copy._migrations) : new Set;
-  const allNewMigrations = [];
-  if (copy.agents && typeof copy.agents === "object") {
-    const { migrated, changed } = migrateAgentNames(copy.agents);
-    if (changed) {
-      copy.agents = migrated;
-      needsWrite = true;
-    }
-  }
-  if (copy.agents && typeof copy.agents === "object") {
-    const { migrated, changed, newMigrations } = migrateModelVersions(copy.agents, existingMigrations);
-    if (changed) {
-      copy.agents = migrated;
-      needsWrite = true;
-      log("Migrated model versions in agents config");
-    }
-    allNewMigrations.push(...newMigrations);
-  }
-  if (copy.categories && typeof copy.categories === "object") {
-    const { migrated, changed, newMigrations } = migrateModelVersions(copy.categories, existingMigrations);
-    if (changed) {
-      copy.categories = migrated;
-      needsWrite = true;
-      log("Migrated model versions in categories config");
-    }
-    allNewMigrations.push(...newMigrations);
-  }
-  if (allNewMigrations.length > 0) {
-    const updatedMigrations = Array.from(existingMigrations);
-    updatedMigrations.push(...allNewMigrations);
-    copy._migrations = updatedMigrations;
-    needsWrite = true;
-  }
-  if (copy.omo_agent) {
-    copy.sisyphus_agent = copy.omo_agent;
-    delete copy.omo_agent;
-    needsWrite = true;
-  }
-  if (copy.experimental && typeof copy.experimental === "object") {
-    const experimental = copy.experimental;
-    if ("hashline_edit" in experimental) {
-      if (copy.hashline_edit === undefined) {
-        copy.hashline_edit = experimental.hashline_edit;
-      }
-      delete experimental.hashline_edit;
-      if (Object.keys(experimental).length === 0) {
-        delete copy.experimental;
-      }
-      needsWrite = true;
-    }
-  }
-  if (copy.disabled_agents && Array.isArray(copy.disabled_agents)) {
-    const migrated = [];
-    let changed = false;
-    for (const agent of copy.disabled_agents) {
-      const newAgent = AGENT_NAME_MAP[agent.toLowerCase()] ?? AGENT_NAME_MAP[agent] ?? agent;
-      if (newAgent !== agent) {
-        changed = true;
-      }
-      migrated.push(newAgent);
-    }
-    if (changed) {
-      copy.disabled_agents = migrated;
-      needsWrite = true;
-    }
-  }
-  if (copy.disabled_hooks && Array.isArray(copy.disabled_hooks)) {
-    const { migrated, changed, removed } = migrateHookNames(copy.disabled_hooks);
-    if (changed) {
-      copy.disabled_hooks = migrated;
-      needsWrite = true;
-    }
-    if (removed.length > 0) {
-      log(`Removed obsolete hooks from disabled_hooks: ${removed.join(", ")} (these hooks no longer exist in v3.0.0)`);
-    }
-  }
-  if (needsWrite) {
-    const timestamp2 = new Date().toISOString().replace(/[:.]/g, "-");
-    const backupPath = `${configPath}.bak.${timestamp2}`;
-    let backupSucceeded = false;
-    try {
-      fs2.copyFileSync(configPath, backupPath);
-      backupSucceeded = true;
-    } catch {
-      backupSucceeded = false;
-    }
-    let writeSucceeded = false;
-    try {
-      writeFileAtomically(configPath, JSON.stringify(copy, null, 2) + `
-`);
-      writeSucceeded = true;
-    } catch (err) {
-      log(`Failed to write migrated config to ${configPath}:`, err);
-    }
-    for (const key of Object.keys(rawConfig)) {
-      delete rawConfig[key];
-    }
-    Object.assign(rawConfig, copy);
-    if (writeSucceeded) {
-      const backupMessage = backupSucceeded ? ` (backup: ${backupPath})` : "";
-      log(`Migrated config file: ${configPath}${backupMessage}`);
-    } else {
-      const backupMessage = backupSucceeded ? ` (backup: ${backupPath})` : "";
-      log(`Applied migrated config in-memory for: ${configPath}${backupMessage}`);
-    }
-  }
-  return needsWrite;
-}
 var init_config_migration = __esm(() => {
   init_logger();
-  init_write_file_atomically();
   init_agent_names();
   init_hook_names();
-  init_model_versions();
 });
 
 // src/shared/migration.ts
@@ -6520,6 +6292,9 @@ var init_binary_downloader = __esm(() => {
   init_zip_extractor();
 });
 
+// src/shared/write-file-atomically.ts
+var init_write_file_atomically = () => {};
+
 // src/shared/model-requirements.ts
 var AGENT_MODEL_REQUIREMENTS, CATEGORY_MODEL_REQUIREMENTS;
 var init_model_requirements = __esm(() => {
@@ -6880,7 +6655,7 @@ function normalizeModelID(modelID) {
 }
 
 // src/shared/json-file-cache-store.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { join as join7 } from "path";
 function toLogLabel(cacheLabel) {
   return cacheLabel.toLowerCase();
@@ -6927,7 +6702,7 @@ function createJsonFileCacheStore(options) {
     ensureCacheDir();
     const cacheFile = getCacheFilePath();
     try {
-      writeFileSync2(cacheFile, options.serialize?.(value) ?? JSON.stringify(value, null, 2));
+      writeFileSync(cacheFile, options.serialize?.(value) ?? JSON.stringify(value, null, 2));
       memoryValue = value;
       log(`[${options.logPrefix}] ${options.cacheLabel} written`, options.describe(value));
     } catch (error) {
@@ -48392,6 +48167,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 +48226,7 @@ var init_injector = __esm(() => {
   init_logger();
   init_opencode_storage_detection();
   init_shared();
+  init_compaction_marker();
   processPrefix = randomBytes(4).toString("hex");
 });
 
@@ -48409,35 +48236,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 +48288,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 +48314,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 +48487,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 +48549,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 +48560,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 +48696,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 +48779,37 @@ var init_plugin_name_with_version = __esm(() => {
   PRIORITIZED_TAGS = ["latest", "beta", "next"];
 });
 
+// src/cli/config-manager/backup-config.ts
+import { copyFileSync, 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 });
+    }
+    copyFileSync(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 +48846,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 +48863,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 +48873,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 +48896,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 writeFileSync2 } from "fs";
 async function addPluginToOpenCodeConfig(currentVersion) {
   try {
     ensureConfigDirectoryExists();
@@ -49048,7 +48995,7 @@ async function addPluginToOpenCodeConfig(currentVersion) {
   try {
     if (format2 === "none") {
       const config2 = { plugin: [pluginEntry] };
-      writeFileSync3(path3, JSON.stringify(config2, null, 2) + `
+      writeFileSync2(path3, JSON.stringify(config2, null, 2) + `
 `);
       return { success: true, configPath: path3 };
     }
@@ -49065,19 +49012,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) {
@@ -49086,14 +49049,14 @@ async function addPluginToOpenCodeConfig(currentVersion) {
         const newContent = content.replace(pluginArrayRegex, `$1[
     ${formattedPlugins}
   ]`);
-        writeFileSync3(path3, newContent);
+        writeFileSync2(path3, newContent);
       } else {
         const newContent = content.replace(/(\{)/, `$1
   "plugin": ["${pluginEntry}"],`);
-        writeFileSync3(path3, newContent);
+        writeFileSync2(path3, newContent);
       }
     } else {
-      writeFileSync3(path3, JSON.stringify(config, null, 2) + `
+      writeFileSync2(path3, JSON.stringify(config, null, 2) + `
 `);
     }
     return { success: true, configPath: path3 };
@@ -49107,6 +49070,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 +49186,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 +49241,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 +49276,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 +49290,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 +49307,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 +49325,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
@@ -49321,28 +49336,8 @@ var init_generate_omo_config = __esm(() => {
   init_model_fallback();
 });
 
-// src/cli/config-manager/deep-merge-record.ts
-function deepMergeRecord(target, source) {
-  const result = { ...target };
-  for (const key of Object.keys(source)) {
-    if (key === "__proto__" || key === "constructor" || key === "prototype")
-      continue;
-    const sourceValue = source[key];
-    const targetValue = result[key];
-    if (sourceValue !== null && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue !== null && typeof targetValue === "object" && !Array.isArray(targetValue)) {
-      result[key] = deepMergeRecord(targetValue, sourceValue);
-    } else if (sourceValue !== undefined) {
-      result[key] = sourceValue;
-    }
-  }
-  return result;
-}
-
 // src/cli/config-manager/write-omo-config.ts
-import { existsSync as existsSync9, readFileSync as readFileSync6, statSync as statSync2, writeFileSync as writeFileSync4 } from "fs";
-function isEmptyOrWhitespace2(content) {
-  return content.trim().length === 0;
-}
+import { existsSync as existsSync11, writeFileSync as writeFileSync3 } from "fs";
 function writeOmoConfig(installConfig) {
   try {
     ensureConfigDirectoryExists();
@@ -49356,36 +49351,11 @@ function writeOmoConfig(installConfig) {
   const omoConfigPath = getOmoConfigPath();
   try {
     const newConfig = generateOmoConfig(installConfig);
-    if (existsSync9(omoConfigPath)) {
-      try {
-        const stat = statSync2(omoConfigPath);
-        const content = readFileSync6(omoConfigPath, "utf-8");
-        if (stat.size === 0 || isEmptyOrWhitespace2(content)) {
-          writeFileSync4(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
-`);
-          return { success: true, configPath: omoConfigPath };
-        }
-        const existing = parseJsonc(content);
-        if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
-          writeFileSync4(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
-`);
-          return { success: true, configPath: omoConfigPath };
-        }
-        const merged = deepMergeRecord(newConfig, existing);
-        writeFileSync4(omoConfigPath, JSON.stringify(merged, null, 2) + `
-`);
-      } catch (parseErr) {
-        if (parseErr instanceof SyntaxError) {
-          writeFileSync4(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
-`);
-          return { success: true, configPath: omoConfigPath };
-        }
-        throw parseErr;
-      }
-    } else {
-      writeFileSync4(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
-`);
+    if (existsSync11(omoConfigPath)) {
+      return { success: true, configPath: omoConfigPath };
     }
+    writeFileSync3(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
+`);
     return { success: true, configPath: omoConfigPath };
   } catch (err) {
     return {
@@ -49396,7 +49366,6 @@ function writeOmoConfig(installConfig) {
   }
 }
 var init_write_omo_config = __esm(() => {
-  init_shared();
   init_config_context();
   init_ensure_config_directory_exists();
   init_generate_omo_config();
@@ -49499,10 +49468,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 readFileSync7 } from "fs";
 function detectProvidersFromOmoConfig() {
   const omoConfigPath = getOmoConfigPath();
-  if (!existsSync10(omoConfigPath)) {
+  if (!existsSync12(omoConfigPath)) {
     return {
       hasOpenAI: true,
       hasOpencodeZen: true,
@@ -49543,9 +49512,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 +49539,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 +49565,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 +49594,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 +49670,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
@@ -49770,15 +49748,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
@@ -49819,7 +49797,7 @@ function stripJsonComments(json3) {
 }
 
 // src/hooks/auto-update-checker/checker/local-dev-path.ts
-import * as fs4 from "fs";
+import * as fs3 from "fs";
 import { fileURLToPath } from "url";
 function isLocalDevMode(directory) {
   return getLocalDevPath(directory) !== null;
@@ -49827,13 +49805,13 @@ function isLocalDevMode(directory) {
 function getLocalDevPath(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!fs4.existsSync(configPath))
+      if (!fs3.existsSync(configPath))
         continue;
-      const content = fs4.readFileSync(configPath, "utf-8");
+      const content = fs3.readFileSync(configPath, "utf-8");
       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 {
@@ -49853,19 +49831,19 @@ var init_local_dev_path = __esm(() => {
 });
 
 // src/hooks/auto-update-checker/checker/package-json-locator.ts
-import * as fs5 from "fs";
+import * as fs4 from "fs";
 import * as path6 from "path";
 function findPackageJsonUp(startPath) {
   try {
-    const stat = fs5.statSync(startPath);
+    const stat = fs4.statSync(startPath);
     let dir = stat.isDirectory() ? startPath : path6.dirname(startPath);
     for (let i2 = 0;i2 < 10; i2++) {
       const pkgPath = path6.join(dir, "package.json");
-      if (fs5.existsSync(pkgPath)) {
+      if (fs4.existsSync(pkgPath)) {
         try {
-          const content = fs5.readFileSync(pkgPath, "utf-8");
+          const content = fs4.readFileSync(pkgPath, "utf-8");
           const pkg = JSON.parse(content);
-          if (pkg.name === PACKAGE_NAME)
+          if (pkg.name === PACKAGE_NAME2)
             return pkgPath;
         } catch {}
       }
@@ -49882,7 +49860,7 @@ var init_package_json_locator = __esm(() => {
 });
 
 // src/hooks/auto-update-checker/checker/local-dev-version.ts
-import * as fs6 from "fs";
+import * as fs5 from "fs";
 function getLocalDevVersion(directory) {
   const localPath = getLocalDevPath(directory);
   if (!localPath)
@@ -49891,7 +49869,7 @@ function getLocalDevVersion(directory) {
     const pkgPath = findPackageJsonUp(localPath);
     if (!pkgPath)
       return null;
-    const content = fs6.readFileSync(pkgPath, "utf-8");
+    const content = fs5.readFileSync(pkgPath, "utf-8");
     const pkg = JSON.parse(content);
     return pkg.version ?? null;
   } catch {
@@ -49904,23 +49882,25 @@ var init_local_dev_version = __esm(() => {
 });
 
 // src/hooks/auto-update-checker/checker/plugin-entry.ts
-import * as fs7 from "fs";
+import * as fs6 from "fs";
 function findPluginEntry(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!fs7.existsSync(configPath))
+      if (!fs6.existsSync(configPath))
         continue;
-      const content = fs7.readFileSync(configPath, "utf-8");
+      const content = fs6.readFileSync(configPath, "utf-8");
       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,21 +49909,23 @@ 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
-import * as fs8 from "fs";
+import * as fs7 from "fs";
 import * as path7 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function getCachedVersion() {
   try {
-    if (fs8.existsSync(INSTALLED_PACKAGE_JSON)) {
-      const content = fs8.readFileSync(INSTALLED_PACKAGE_JSON, "utf-8");
+    if (fs7.existsSync(INSTALLED_PACKAGE_JSON)) {
+      const content = fs7.readFileSync(INSTALLED_PACKAGE_JSON, "utf-8");
       const pkg = JSON.parse(content);
       if (pkg.version)
         return pkg.version;
@@ -49953,7 +49935,7 @@ function getCachedVersion() {
     const currentDir = path7.dirname(fileURLToPath2(import.meta.url));
     const pkgPath = findPackageJsonUp(currentDir);
     if (pkgPath) {
-      const content = fs8.readFileSync(pkgPath, "utf-8");
+      const content = fs7.readFileSync(pkgPath, "utf-8");
       const pkg = JSON.parse(content);
       if (pkg.version)
         return pkg.version;
@@ -49962,10 +49944,10 @@ function getCachedVersion() {
     log("[auto-update-checker] Failed to resolve version from current directory:", err);
   }
   try {
-    const execDir = path7.dirname(fs8.realpathSync(process.execPath));
+    const execDir = path7.dirname(fs7.realpathSync(process.execPath));
     const pkgPath = findPackageJsonUp(execDir);
     if (pkgPath) {
-      const content = fs8.readFileSync(pkgPath, "utf-8");
+      const content = fs7.readFileSync(pkgPath, "utf-8");
       const pkg = JSON.parse(content);
       if (pkg.version)
         return pkg.version;
@@ -49973,6 +49955,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 (fs7.existsSync(pkgPath)) {
+        const content = fs7.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(() => {
@@ -50107,11 +50106,11 @@ var init_check_for_update = __esm(() => {
 
 // src/hooks/auto-update-checker/checker/sync-package-json.ts
 import * as crypto from "crypto";
-import * as fs9 from "fs";
+import * as fs8 from "fs";
 import * as path8 from "path";
 function safeUnlink(filePath) {
   try {
-    fs9.unlinkSync(filePath);
+    fs8.unlinkSync(filePath);
   } catch (err) {
     log(`[auto-update-checker] Failed to cleanup temp file: ${filePath}`, err);
   }
@@ -50125,9 +50124,9 @@ function getIntentVersion(pluginInfo) {
 function writeCachePackageJson(cachePackageJsonPath, pkgJson) {
   const tmpPath = `${cachePackageJsonPath}.${crypto.randomUUID()}`;
   try {
-    fs9.mkdirSync(path8.dirname(cachePackageJsonPath), { recursive: true });
-    fs9.writeFileSync(tmpPath, JSON.stringify(pkgJson, null, 2));
-    fs9.renameSync(tmpPath, cachePackageJsonPath);
+    fs8.mkdirSync(path8.dirname(cachePackageJsonPath), { recursive: true });
+    fs8.writeFileSync(tmpPath, JSON.stringify(pkgJson, null, 2));
+    fs8.renameSync(tmpPath, cachePackageJsonPath);
     return { synced: true, error: null };
   } catch (err) {
     log("[auto-update-checker] Failed to write cache package.json:", err);
@@ -50138,17 +50137,17 @@ function writeCachePackageJson(cachePackageJsonPath, pkgJson) {
 function syncCachePackageJsonToIntent(pluginInfo) {
   const cachePackageJsonPath = path8.join(CACHE_DIR, "package.json");
   const intentVersion = getIntentVersion(pluginInfo);
-  if (!fs9.existsSync(cachePackageJsonPath)) {
+  if (!fs8.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}`
     };
   }
   let content;
   let pkgJson;
   try {
-    content = fs9.readFileSync(cachePackageJsonPath, "utf-8");
+    content = fs8.readFileSync(cachePackageJsonPath, "utf-8");
   } catch (err) {
     log("[auto-update-checker] Failed to read cache package.json:", err);
     return { synced: false, error: "parse_error", message: "Failed to read cache package.json" };
@@ -50159,21 +50158,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 +50184,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}"`
@@ -50211,18 +50210,18 @@ var init_checker = __esm(() => {
 });
 
 // src/hooks/auto-update-checker/cache.ts
-import * as fs10 from "fs";
+import * as fs9 from "fs";
 import * as path9 from "path";
 function stripTrailingCommas(json3) {
   return json3.replace(/,(\s*[}\]])/g, "$1");
 }
 function removeFromTextBunLock(lockPath, packageName) {
   try {
-    const content = fs10.readFileSync(lockPath, "utf-8");
+    const content = fs9.readFileSync(lockPath, "utf-8");
     const lock = JSON.parse(stripTrailingCommas(content));
     if (lock.packages?.[packageName]) {
       delete lock.packages[packageName];
-      fs10.writeFileSync(lockPath, JSON.stringify(lock, null, 2));
+      fs9.writeFileSync(lockPath, JSON.stringify(lock, null, 2));
       log(`[auto-update-checker] Removed from bun.lock: ${packageName}`);
       return true;
     }
@@ -50233,7 +50232,7 @@ function removeFromTextBunLock(lockPath, packageName) {
 }
 function deleteBinaryBunLock(lockPath) {
   try {
-    fs10.unlinkSync(lockPath);
+    fs9.unlinkSync(lockPath);
     log(`[auto-update-checker] Removed bun.lockb to force re-resolution`);
     return true;
   } catch {
@@ -50243,15 +50242,15 @@ function deleteBinaryBunLock(lockPath) {
 function removeFromBunLock(packageName) {
   const textLockPath = path9.join(CACHE_DIR, "bun.lock");
   const binaryLockPath = path9.join(CACHE_DIR, "bun.lockb");
-  if (fs10.existsSync(textLockPath)) {
+  if (fs9.existsSync(textLockPath)) {
     return removeFromTextBunLock(textLockPath, packageName);
   }
-  if (fs10.existsSync(binaryLockPath)) {
+  if (fs9.existsSync(binaryLockPath)) {
     return deleteBinaryBunLock(binaryLockPath);
   }
   return false;
 }
-function invalidatePackage(packageName = PACKAGE_NAME) {
+function invalidatePackage(packageName = PACKAGE_NAME2) {
   try {
     const userConfigDir = getUserConfigDir();
     const pkgDirs = [
@@ -50261,8 +50260,8 @@ function invalidatePackage(packageName = PACKAGE_NAME) {
     let packageRemoved = false;
     let lockRemoved = false;
     for (const pkgDir of pkgDirs) {
-      if (fs10.existsSync(pkgDir)) {
-        fs10.rmSync(pkgDir, { recursive: true, force: true });
+      if (fs9.existsSync(pkgDir)) {
+        fs9.rmSync(pkgDir, { recursive: true, force: true });
         log(`[auto-update-checker] Package removed: ${pkgDir}`);
         packageRemoved = true;
       }
@@ -50291,7 +50290,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 +50301,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 +50315,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 +50326,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 +50406,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 +50434,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 +50582,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 +50715,7 @@ var {
 // package.json
 var package_default = {
   name: "evil-omo",
-  version: "3.15.3",
+  version: "3.16.1",
   description: "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   main: "./dist/index.js",
   types: "dist/index.d.ts",
@@ -50775,8 +50774,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 +50784,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 +50793,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 +50816,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 +50963,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 +51040,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 +51057,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 +51482,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 +51515,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 +51531,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 +51539,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 +51573,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 +51642,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 +51662,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 +51675,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 +51796,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 +51806,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 +51825,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 +51880,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 +51914,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 +51958,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 +51970,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 +51978,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 +51990,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 +51999,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 +52017,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 +52178,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 +52193,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 +52201,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 +52235,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 +52278,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 +52312,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 +52340,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 +52387,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 +52408,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 +52419,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 +52484,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 +52501,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 +52553,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,12 +52571,12 @@ 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}`));
     }
   }
 }
 // src/plugin-config.ts
-import * as fs3 from "fs";
+import * as fs2 from "fs";
 import * as path3 from "path";
 
 // node_modules/zod/v4/classic/external.js
@@ -66643,10 +66682,9 @@ function parseConfigPartially(rawConfig) {
 }
 function loadConfigFromPath(configPath, _ctx) {
   try {
-    if (fs3.existsSync(configPath)) {
-      const content = fs3.readFileSync(configPath, "utf-8");
+    if (fs2.existsSync(configPath)) {
+      const content = fs2.readFileSync(configPath, "utf-8");
       const rawConfig = parseJsonc(content);
-      migrateConfigFile(configPath, rawConfig);
       const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
       if (result.success) {
         log(`Config loaded from ${configPath}`, { agents: result.data.agents });
@@ -68190,11 +68228,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 +68255,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 +68282,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 +68316,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 +68332,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 +68343,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 +68366,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 +68382,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 +68414,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 +68426,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 +68547,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 +68592,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 +68626,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,15 +68638,15 @@ 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 readFileSync9, writeFileSync as writeFileSync4, 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 {
@@ -68637,30 +68675,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 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,14 +68759,14 @@ 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 readFileSync10, rmSync, writeFileSync as writeFileSync5 } 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");
@@ -68738,28 +68829,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 readFileSync11, 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 = readFileSync11(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 +68880,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 +68904,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 readFileSync12, writeFileSync as writeFileSync6, 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,11 +68914,11 @@ 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 {
@@ -68948,7 +69046,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 +69107,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 +69138,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 +69152,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 +69201,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 +69221,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 +69390,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 +69403,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 +69468,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 +69478,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 +69623,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 readFileSync22 } 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 +69655,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 +69668,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 +69698,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 +69716,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 readFileSync20 } 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;
 }
@@ -69745,34 +69805,34 @@ 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 readFileSync21 } 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");
@@ -69794,20 +69854,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,7 +69891,7 @@ init_plugin_identity();
 function isConfigValid(configPath) {
   if (!configPath)
     return true;
-  if (!existsSync26(configPath))
+  if (!existsSync28(configPath))
     return false;
   try {
     parseJsonc(readFileSync22(configPath, "utf-8"));
@@ -69885,7 +69945,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 +69985,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}.`,
@@ -69951,23 +70011,23 @@ async function checkSystem() {
 
 // src/cli/doctor/checks/config.ts
 import { readFileSync as readFileSync25 } from "fs";
-import { join as join29 } from "path";
+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 readFileSync23 } 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 {
@@ -69994,8 +70054,8 @@ 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 { 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") {
@@ -70021,7 +70081,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 +70123,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 +70278,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")
@@ -70339,9 +70399,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 +70457,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 +70490,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,12 +70648,12 @@ 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 readFileSync26 } 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"));
@@ -70605,9 +70665,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 +70736,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 +70760,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 +70781,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,21 +70850,21 @@ 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 readFileSync27 } 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");
@@ -70974,17 +71034,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 +71074,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 +71320,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 readFileSync28, renameSync as renameSync2, unlinkSync as unlinkSync4, writeFileSync as writeFileSync9 } 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,7 +71361,7 @@ function buildKey(serverHost, resource) {
 }
 function readStore() {
   const filePath = getMcpOauthStoragePath();
-  if (!existsSync32(filePath)) {
+  if (!existsSync34(filePath)) {
     return null;
   }
   try {
@@ -71314,12 +71374,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()}`;
+    writeFileSync9(tempPath, JSON.stringify(store2, null, 2), { encoding: "utf-8", mode: 384 });
+    chmodSync(tempPath, 384);
+    renameSync2(tempPath, filePath);
     return true;
   } catch {
     return false;
@@ -71350,7 +71412,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;
@@ -71648,6 +71710,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 +71836,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;
   }