evil-omo 3.15.2 → 3.16.0

package/dist/cli/index.js

@@ -4917,6 +4917,196 @@ var init_command_executor = __esm(() => {
 // src/shared/contains-path.ts
 var init_contains_path = () => {};
 
+// src/shared/logger.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+function flush() {
+  if (buffer.length === 0)
+    return;
+  const data = buffer.join("");
+  buffer = [];
+  try {
+    fs.appendFileSync(logFile, data);
+  } catch {}
+}
+function scheduleFlush() {
+  if (flushTimer)
+    return;
+  flushTimer = setTimeout(() => {
+    flushTimer = null;
+    flush();
+  }, FLUSH_INTERVAL_MS);
+}
+function log(message, data) {
+  try {
+    const timestamp2 = new Date().toISOString();
+    const logEntry = `[${timestamp2}] ${message} ${data ? JSON.stringify(data) : ""}
+`;
+    buffer.push(logEntry);
+    if (buffer.length >= BUFFER_SIZE_LIMIT) {
+      flush();
+    } else {
+      scheduleFlush();
+    }
+  } catch {}
+}
+var logFile, buffer, flushTimer = null, FLUSH_INTERVAL_MS = 500, BUFFER_SIZE_LIMIT = 50;
+var init_logger = __esm(() => {
+  logFile = path.join(os.tmpdir(), "evil-omo.log");
+  buffer = [];
+});
+
+// src/shared/file-reference-resolver.ts
+var init_file_reference_resolver = __esm(() => {
+  init_contains_path();
+  init_logger();
+});
+// src/shared/deep-merge.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
+}
+function deepMerge(base, override, depth = 0) {
+  if (!base && !override)
+    return;
+  if (!base)
+    return override;
+  if (!override)
+    return base;
+  if (depth > MAX_DEPTH)
+    return override ?? base;
+  const result = { ...base };
+  for (const key of Object.keys(override)) {
+    if (DANGEROUS_KEYS.has(key))
+      continue;
+    const baseValue = base[key];
+    const overrideValue = override[key];
+    if (overrideValue === undefined)
+      continue;
+    if (isPlainObject(baseValue) && isPlainObject(overrideValue)) {
+      result[key] = deepMerge(baseValue, overrideValue, depth + 1);
+    } else {
+      result[key] = overrideValue;
+    }
+  }
+  return result;
+}
+var DANGEROUS_KEYS, MAX_DEPTH = 50;
+var init_deep_merge = __esm(() => {
+  DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+});
+
+// src/shared/snake-case.ts
+var init_snake_case = __esm(() => {
+  init_deep_merge();
+});
+
+// src/shared/tool-name.ts
+var init_tool_name = () => {};
+
+// src/shared/pattern-matcher.ts
+var regexCache;
+var init_pattern_matcher = __esm(() => {
+  regexCache = new Map;
+});
+// src/shared/file-utils.ts
+import { lstatSync, realpathSync } from "fs";
+function normalizeDarwinRealpath(filePath) {
+  return filePath.startsWith("/private/var/") ? filePath.slice("/private".length) : filePath;
+}
+function resolveSymlink(filePath) {
+  try {
+    return normalizeDarwinRealpath(realpathSync(filePath));
+  } catch {
+    return filePath;
+  }
+}
+var init_file_utils = () => {};
+
+// src/shared/context-limit-resolver.ts
+var init_context_limit_resolver = () => {};
+
+// src/shared/normalize-sdk-response.ts
+function normalizeSDKResponse(response, fallback, options) {
+  if (response === null || response === undefined) {
+    return fallback;
+  }
+  if (Array.isArray(response)) {
+    return response;
+  }
+  if (typeof response === "object" && "data" in response) {
+    const data = response.data;
+    if (data !== null && data !== undefined) {
+      return data;
+    }
+    if (options?.preferResponseOnMissingData === true) {
+      return response;
+    }
+    return fallback;
+  }
+  if (options?.preferResponseOnMissingData === true) {
+    return response;
+  }
+  return fallback;
+}
+
+// src/shared/dynamic-truncator.ts
+var init_dynamic_truncator = __esm(() => {
+  init_context_limit_resolver();
+});
+
+// src/shared/data-path.ts
+import * as path2 from "path";
+import * as os2 from "os";
+import { accessSync, constants, mkdirSync } from "fs";
+function resolveWritableDirectory(preferredDir, fallbackSuffix) {
+  try {
+    mkdirSync(preferredDir, { recursive: true });
+    accessSync(preferredDir, constants.W_OK);
+    return preferredDir;
+  } catch {
+    const fallbackDir = path2.join(os2.tmpdir(), fallbackSuffix);
+    mkdirSync(fallbackDir, { recursive: true });
+    return fallbackDir;
+  }
+}
+function getDataDir() {
+  const preferredDir = process.env.XDG_DATA_HOME ?? path2.join(os2.homedir(), ".local", "share");
+  return resolveWritableDirectory(preferredDir, "opencode-data");
+}
+function getOpenCodeStorageDir() {
+  return path2.join(getDataDir(), "opencode", "storage");
+}
+function getCacheDir() {
+  const preferredDir = process.env.XDG_CACHE_HOME ?? path2.join(os2.homedir(), ".cache");
+  return resolveWritableDirectory(preferredDir, "opencode-cache");
+}
+function getOmoOpenCodeCacheDir() {
+  return path2.join(getCacheDir(), "evil-omo");
+}
+function getOpenCodeCacheDir() {
+  return path2.join(getCacheDir(), "opencode");
+}
+var init_data_path = () => {};
+
+// src/shared/config-errors.ts
+function getConfigLoadErrors() {
+  return configLoadErrors;
+}
+function clearConfigLoadErrors() {
+  configLoadErrors = [];
+}
+function addConfigLoadError(error) {
+  configLoadErrors.push(error);
+}
+var configLoadErrors;
+var init_config_errors = __esm(() => {
+  configLoadErrors = [];
+});
+
+// src/shared/claude-config-dir.ts
+var init_claude_config_dir = () => {};
+
 // node_modules/jsonc-parser/lib/esm/impl/scanner.js
 function createScanner(text, ignoreTrivia = false) {
   const len = text.length;
@@ -5781,11 +5971,37 @@ var init_main = __esm(() => {
   })(ParseErrorCode || (ParseErrorCode = {}));
 });
 
+// src/shared/plugin-identity.ts
+import { join as join3 } from "path";
+function detectManagedConfigFile(directory) {
+  for (const baseName of ALL_CONFIG_BASENAMES) {
+    const detected = detectConfigFile(join3(directory, baseName));
+    if (detected.format !== "none") {
+      return { ...detected, baseName };
+    }
+  }
+  return {
+    format: "none",
+    path: join3(directory, `${CONFIG_BASENAME}.json`),
+    baseName: CONFIG_BASENAME
+  };
+}
+var PLUGIN_NAME = "evil-omo", LEGACY_PLUGIN_NAME = "oh-my-opencode", CONFIG_BASENAME = "evil-omo", LEGACY_CONFIG_BASENAME = "oh-my-opencode", ALL_CONFIG_BASENAMES;
+var init_plugin_identity = __esm(() => {
+  init_jsonc_parser();
+  ALL_CONFIG_BASENAMES = [CONFIG_BASENAME, LEGACY_CONFIG_BASENAME];
+});
+
 // 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
   });
@@ -5806,202 +6022,25 @@ function detectConfigFile(basePath) {
   }
   return { format: "none", path: jsonPath };
 }
-var init_jsonc_parser = __esm(() => {
-  init_main();
-  init_plugin_identity();
-});
-
-// src/shared/plugin-identity.ts
-import { join } from "path";
-function matchesManagedName(entry, packageName) {
-  return entry === packageName || entry.startsWith(`${packageName}@`);
-}
-function findManagedPluginEntry(plugins) {
-  for (const [index, entry] of plugins.entries()) {
-    for (const packageName of ALL_PLUGIN_NAMES) {
-      if (matchesManagedName(entry, packageName)) {
-        return { index, packageName };
-      }
-    }
-  }
-  return null;
-}
-function detectManagedConfigFile(directory) {
-  for (const baseName of ALL_CONFIG_BASENAMES) {
-    const detected = detectConfigFile(join(directory, baseName));
-    if (detected.format !== "none") {
-      return { ...detected, baseName };
-    }
-  }
-  return {
-    format: "none",
-    path: join(directory, `${CONFIG_BASENAME}.json`),
-    baseName: CONFIG_BASENAME
-  };
-}
-var PLUGIN_NAME = "evil-omo", LEGACY_PLUGIN_NAME = "oh-my-opencode", ALL_PLUGIN_NAMES, CONFIG_BASENAME = "evil-omo", LEGACY_CONFIG_BASENAME = "oh-my-opencode", ALL_CONFIG_BASENAMES, LOG_FILENAME = "evil-omo.log", CACHE_DIR_NAME = "evil-omo", SCHEMA_FILENAME = "evil-omo.schema.json";
-var init_plugin_identity = __esm(() => {
-  init_jsonc_parser();
-  ALL_PLUGIN_NAMES = [PLUGIN_NAME, LEGACY_PLUGIN_NAME];
-  ALL_CONFIG_BASENAMES = [CONFIG_BASENAME, LEGACY_CONFIG_BASENAME];
-});
-
-// src/shared/logger.ts
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-function log(message, data) {
-  try {
-    const timestamp2 = new Date().toISOString();
-    const logEntry = `[${timestamp2}] ${message} ${data ? JSON.stringify(data) : ""}
-`;
-    fs.appendFileSync(logFile, logEntry);
-  } catch {}
-}
-var logFile;
-var init_logger = __esm(() => {
-  init_plugin_identity();
-  logFile = path.join(os.tmpdir(), LOG_FILENAME);
-});
-
-// src/shared/file-reference-resolver.ts
-var init_file_reference_resolver = __esm(() => {
-  init_contains_path();
-  init_logger();
-});
-// src/shared/deep-merge.ts
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
-}
-function deepMerge(base, override, depth = 0) {
-  if (!base && !override)
-    return;
-  if (!base)
-    return override;
-  if (!override)
-    return base;
-  if (depth > MAX_DEPTH)
-    return override ?? base;
-  const result = { ...base };
-  for (const key of Object.keys(override)) {
-    if (DANGEROUS_KEYS.has(key))
-      continue;
-    const baseValue = base[key];
-    const overrideValue = override[key];
-    if (overrideValue === undefined)
-      continue;
-    if (isPlainObject(baseValue) && isPlainObject(overrideValue)) {
-      result[key] = deepMerge(baseValue, overrideValue, depth + 1);
-    } else {
-      result[key] = overrideValue;
-    }
-  }
-  return result;
-}
-var DANGEROUS_KEYS, MAX_DEPTH = 50;
-var init_deep_merge = __esm(() => {
-  DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
-});
-
-// src/shared/snake-case.ts
-var init_snake_case = __esm(() => {
-  init_deep_merge();
-});
-
-// src/shared/tool-name.ts
-var init_tool_name = () => {};
-
-// src/shared/pattern-matcher.ts
-var regexCache;
-var init_pattern_matcher = __esm(() => {
-  regexCache = new Map;
-});
-// src/shared/file-utils.ts
-import { lstatSync, realpathSync } from "fs";
-function normalizeDarwinRealpath(filePath) {
-  return filePath.startsWith("/private/var/") ? filePath.slice("/private".length) : filePath;
-}
-function resolveSymlink(filePath) {
-  try {
-    return normalizeDarwinRealpath(realpathSync(filePath));
-  } catch {
-    return filePath;
-  }
-}
-var init_file_utils = () => {};
-
-// src/shared/context-limit-resolver.ts
-var init_context_limit_resolver = () => {};
-
-// src/shared/normalize-sdk-response.ts
-function normalizeSDKResponse(response, fallback, options) {
-  if (response === null || response === undefined) {
-    return fallback;
-  }
-  if (Array.isArray(response)) {
-    return response;
+function detectPluginConfigFile(dir) {
+  const canonicalResult = detectConfigFile(join4(dir, CONFIG_BASENAME));
+  const legacyResult = detectConfigFile(join4(dir, LEGACY_CONFIG_BASENAME));
+  if (canonicalResult.format !== "none") {
+    return {
+      ...canonicalResult,
+      legacyPath: legacyResult.format !== "none" ? legacyResult.path : undefined
+    };
   }
-  if (typeof response === "object" && "data" in response) {
-    const data = response.data;
-    if (data !== null && data !== undefined) {
-      return data;
-    }
-    if (options?.preferResponseOnMissingData === true) {
-      return response;
-    }
-    return fallback;
+  if (legacyResult.format !== "none") {
+    return legacyResult;
   }
-  if (options?.preferResponseOnMissingData === true) {
-    return response;
-  }
-  return fallback;
-}
-
-// src/shared/dynamic-truncator.ts
-var init_dynamic_truncator = __esm(() => {
-  init_context_limit_resolver();
-});
-
-// src/shared/data-path.ts
-import * as path2 from "path";
-import * as os2 from "os";
-function getDataDir() {
-  return process.env.XDG_DATA_HOME ?? path2.join(os2.homedir(), ".local", "share");
-}
-function getOpenCodeStorageDir() {
-  return path2.join(getDataDir(), "opencode", "storage");
-}
-function getCacheDir() {
-  return process.env.XDG_CACHE_HOME ?? path2.join(os2.homedir(), ".cache");
-}
-function getOmoOpenCodeCacheDir() {
-  return path2.join(getCacheDir(), CACHE_DIR_NAME);
-}
-function getOpenCodeCacheDir() {
-  return path2.join(getCacheDir(), "opencode");
+  return { format: "none", path: join4(dir, `${CONFIG_BASENAME}.json`) };
 }
-var init_data_path = __esm(() => {
+var init_jsonc_parser = __esm(() => {
+  init_main();
   init_plugin_identity();
 });
 
-// src/shared/config-errors.ts
-function getConfigLoadErrors() {
-  return configLoadErrors;
-}
-function clearConfigLoadErrors() {
-  configLoadErrors = [];
-}
-function addConfigLoadError(error) {
-  configLoadErrors.push(error);
-}
-var configLoadErrors;
-var init_config_errors = __esm(() => {
-  configLoadErrors = [];
-});
-
-// src/shared/claude-config-dir.ts
-var init_claude_config_dir = () => {};
-
 // src/shared/migration/agent-names.ts
 function migrateAgentNames(agents) {
   const migrated = {};
@@ -6026,15 +6065,15 @@ var init_agent_names = __esm(() => {
     "omo-plan": "prometheus",
     "Planner-Sisyphus": "prometheus",
     "planner-sisyphus": "prometheus",
-    "Prometheus (Planner)": "prometheus",
+    "Prometheus - Plan Builder": "prometheus",
     prometheus: "prometheus",
     "orchestrator-sisyphus": "atlas",
     Atlas: "atlas",
     atlas: "atlas",
     "plan-consultant": "metis",
-    "Metis (Plan Consultant)": "metis",
+    "Metis - Plan Consultant": "metis",
     metis: "metis",
-    "Momus (Plan Reviewer)": "momus",
+    "Momus - Plan Critic": "momus",
     momus: "momus",
     "Sisyphus-Junior": "sisyphus-junior",
     "sisyphus-junior": "sisyphus-junior",
@@ -6277,9 +6316,9 @@ var init_migration = __esm(() => {
 });
 
 // src/shared/opencode-config-dir.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync2, realpathSync as realpathSync2 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join4, resolve } from "path";
+import { join as join5, resolve, win32 } from "path";
 function isDevBuild(version) {
   if (!version)
     return false;
@@ -6289,25 +6328,35 @@ function getTauriConfigDir(identifier) {
   const platform = process.platform;
   switch (platform) {
     case "darwin":
-      return join4(homedir2(), "Library", "Application Support", identifier);
+      return join5(homedir2(), "Library", "Application Support", identifier);
     case "win32": {
-      const appData = process.env.APPDATA || join4(homedir2(), "AppData", "Roaming");
-      return join4(appData, identifier);
+      const appData = process.env.APPDATA || join5(homedir2(), "AppData", "Roaming");
+      return win32.join(appData, identifier);
     }
     case "linux":
     default: {
-      const xdgConfig = process.env.XDG_CONFIG_HOME || join4(homedir2(), ".config");
-      return join4(xdgConfig, identifier);
+      const xdgConfig = process.env.XDG_CONFIG_HOME || join5(homedir2(), ".config");
+      return join5(xdgConfig, identifier);
     }
   }
 }
+function resolveConfigPath(pathValue) {
+  const resolvedPath = resolve(pathValue);
+  if (!existsSync2(resolvedPath))
+    return resolvedPath;
+  try {
+    return realpathSync2(resolvedPath);
+  } catch {
+    return resolvedPath;
+  }
+}
 function getCliConfigDir() {
   const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   if (envConfigDir) {
-    return resolve(envConfigDir);
+    return resolveConfigPath(envConfigDir);
   }
-  const xdgConfig = process.env.XDG_CONFIG_HOME || join4(homedir2(), ".config");
-  return join4(xdgConfig, "opencode");
+  const xdgConfig = process.env.XDG_CONFIG_HOME || join5(homedir2(), ".config");
+  return resolveConfigPath(join5(xdgConfig, "opencode"));
 }
 function getOpenCodeConfigDir(options) {
   const { binary: binary2, version, checkExisting = true } = options;
@@ -6315,11 +6364,12 @@ function getOpenCodeConfigDir(options) {
     return getCliConfigDir();
   }
   const identifier = isDevBuild(version) ? TAURI_APP_IDENTIFIER_DEV : TAURI_APP_IDENTIFIER;
-  const tauriDir = getTauriConfigDir(identifier);
+  const tauriDirBase = getTauriConfigDir(identifier);
+  const tauriDir = process.platform === "win32" ? win32.isAbsolute(tauriDirBase) ? win32.normalize(tauriDirBase) : win32.resolve(tauriDirBase) : resolveConfigPath(tauriDirBase);
   if (checkExisting) {
     const legacyDir = getCliConfigDir();
-    const legacyConfig = join4(legacyDir, "opencode.json");
-    const legacyConfigC = join4(legacyDir, "opencode.jsonc");
+    const legacyConfig = join5(legacyDir, "opencode.json");
+    const legacyConfigC = join5(legacyDir, "opencode.jsonc");
     if (existsSync2(legacyConfig) || existsSync2(legacyConfigC)) {
       return legacyDir;
     }
@@ -6330,10 +6380,10 @@ function getOpenCodeConfigPaths(options) {
   const configDir = getOpenCodeConfigDir(options);
   return {
     configDir,
-    configJson: join4(configDir, "opencode.json"),
-    configJsonc: join4(configDir, "opencode.jsonc"),
-    packageJson: join4(configDir, "package.json"),
-    omoConfig: join4(configDir, `${CONFIG_BASENAME}.json`)
+    configJson: join5(configDir, "opencode.json"),
+    configJsonc: join5(configDir, "opencode.jsonc"),
+    packageJson: join5(configDir, "package.json"),
+    omoConfig: join5(configDir, `${CONFIG_BASENAME}.json`)
   };
 }
 var TAURI_APP_IDENTIFIER = "ai.opencode.desktop", TAURI_APP_IDENTIFIER_DEV = "ai.opencode.desktop.dev";
@@ -6342,18 +6392,88 @@ var init_opencode_config_dir = __esm(() => {
 });
 
 // src/shared/opencode-version.ts
-var NOT_CACHED;
+import { execSync } from "child_process";
+function parseVersion(version) {
+  const cleaned = version.replace(/^v/, "").split("-")[0];
+  return cleaned.split(".").map((n) => parseInt(n, 10) || 0);
+}
+function compareVersions(a, b) {
+  const partsA = parseVersion(a);
+  const partsB = parseVersion(b);
+  const maxLen = Math.max(partsA.length, partsB.length);
+  for (let i2 = 0;i2 < maxLen; i2++) {
+    const numA = partsA[i2] ?? 0;
+    const numB = partsB[i2] ?? 0;
+    if (numA < numB)
+      return -1;
+    if (numA > numB)
+      return 1;
+  }
+  return 0;
+}
+function getOpenCodeVersion() {
+  if (cachedVersion !== NOT_CACHED) {
+    return cachedVersion;
+  }
+  try {
+    const result = execSync("opencode --version", {
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const versionMatch = result.match(/(\d+\.\d+\.\d+(?:-[\w.]+)?)/);
+    cachedVersion = versionMatch?.[1] ?? null;
+    return cachedVersion;
+  } catch {
+    cachedVersion = null;
+    return null;
+  }
+}
+function isOpenCodeVersionAtLeast(version) {
+  const current = getOpenCodeVersion();
+  if (!current)
+    return true;
+  return compareVersions(current, version) >= 0;
+}
+var OPENCODE_SQLITE_VERSION = "1.1.53", NOT_CACHED, cachedVersion;
 var init_opencode_version = __esm(() => {
   NOT_CACHED = Symbol("NOT_CACHED");
+  cachedVersion = NOT_CACHED;
 });
 
 // src/shared/opencode-storage-detection.ts
-var NOT_CACHED2, FALSE_PENDING_RETRY;
+import { existsSync as existsSync3 } from "fs";
+import { join as join6 } from "path";
+function isSqliteBackend() {
+  if (cachedResult === true)
+    return true;
+  if (cachedResult === false)
+    return false;
+  const check = () => {
+    const versionOk = isOpenCodeVersionAtLeast(OPENCODE_SQLITE_VERSION);
+    const dbPath = join6(getDataDir(), "opencode", "opencode.db");
+    return versionOk && existsSync3(dbPath);
+  };
+  if (cachedResult === FALSE_PENDING_RETRY) {
+    const result2 = check();
+    cachedResult = result2;
+    return result2;
+  }
+  const result = check();
+  if (result) {
+    cachedResult = true;
+  } else {
+    cachedResult = FALSE_PENDING_RETRY;
+  }
+  return result;
+}
+var NOT_CACHED2, FALSE_PENDING_RETRY, cachedResult;
 var init_opencode_storage_detection = __esm(() => {
   init_data_path();
   init_opencode_version();
   NOT_CACHED2 = Symbol("NOT_CACHED");
   FALSE_PENDING_RETRY = Symbol("FALSE_PENDING_RETRY");
+  cachedResult = NOT_CACHED2;
 });
 // src/shared/external-plugin-detector.ts
 var init_external_plugin_detector = __esm(() => {
@@ -6764,20 +6884,20 @@ function normalizeModelID(modelID) {
 }
 
 // src/shared/json-file-cache-store.ts
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join7 } from "path";
 function toLogLabel(cacheLabel) {
   return cacheLabel.toLowerCase();
 }
 function createJsonFileCacheStore(options) {
   let memoryValue;
   function getCacheFilePath() {
-    return join5(options.getCacheDir(), options.filename);
+    return join7(options.getCacheDir(), options.filename);
   }
   function ensureCacheDir() {
     const cacheDir = options.getCacheDir();
-    if (!existsSync3(cacheDir)) {
-      mkdirSync(cacheDir, { recursive: true });
+    if (!existsSync4(cacheDir)) {
+      mkdirSync2(cacheDir, { recursive: true });
     }
   }
   function read() {
@@ -6785,7 +6905,7 @@ function createJsonFileCacheStore(options) {
       return memoryValue;
     }
     const cacheFile = getCacheFilePath();
-    if (!existsSync3(cacheFile)) {
+    if (!existsSync4(cacheFile)) {
       memoryValue = null;
       log(`[${options.logPrefix}] ${options.cacheLabel} file not found`, { cacheFile });
       return null;
@@ -6805,7 +6925,7 @@ function createJsonFileCacheStore(options) {
     }
   }
   function has() {
-    return existsSync3(getCacheFilePath());
+    return existsSync4(getCacheFilePath());
   }
   function write(value) {
     ensureCacheDir();
@@ -6974,14 +7094,14 @@ var init_connected_providers_cache = __esm(() => {
 });
 
 // src/shared/model-availability.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
+import { join as join8 } from "path";
 function isModelCacheAvailable() {
   if (hasProviderModelsCache()) {
     return true;
   }
-  const cacheFile = join6(getOpenCodeCacheDir(), "models.json");
-  return existsSync4(cacheFile);
+  const cacheFile = join8(getOpenCodeCacheDir(), "models.json");
+  return existsSync5(cacheFile);
 }
 var init_model_availability = __esm(() => {
   init_logger();
@@ -48276,6 +48396,57 @@ var init_constants = __esm(() => {
   init_shared();
 });
 
+// src/shared/opencode-storage-paths.ts
+import { join as join9 } from "path";
+var OPENCODE_STORAGE, MESSAGE_STORAGE, PART_STORAGE, SESSION_STORAGE;
+var init_opencode_storage_paths = __esm(() => {
+  init_data_path();
+  OPENCODE_STORAGE = getOpenCodeStorageDir();
+  MESSAGE_STORAGE = join9(OPENCODE_STORAGE, "message");
+  PART_STORAGE = join9(OPENCODE_STORAGE, "part");
+  SESSION_STORAGE = join9(OPENCODE_STORAGE, "session");
+});
+
+// src/shared/compaction-marker.ts
+import { existsSync as existsSync6, readdirSync, readFileSync as readFileSync4 } from "fs";
+import { join as join10 } from "path";
+function isCompactionPart(part) {
+  return typeof part === "object" && part !== null && part.type === "compaction";
+}
+function isCompactionAgent(agent) {
+  return typeof agent === "string" && agent.trim().toLowerCase() === "compaction";
+}
+function hasCompactionPart(parts) {
+  return Array.isArray(parts) && parts.some((part) => isCompactionPart(part));
+}
+function isCompactionMessage(message) {
+  return isCompactionAgent(message.info?.agent ?? message.agent) || hasCompactionPart(message.parts);
+}
+function hasCompactionPartInStorage(messageID) {
+  if (!messageID) {
+    return false;
+  }
+  const partDir = join10(PART_STORAGE, messageID);
+  if (!existsSync6(partDir)) {
+    return false;
+  }
+  try {
+    return readdirSync(partDir).filter((fileName) => fileName.endsWith(".json")).some((fileName) => {
+      try {
+        const content = readFileSync4(join10(partDir, fileName), "utf-8");
+        return isCompactionPart(JSON.parse(content));
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return false;
+  }
+}
+var init_compaction_marker = __esm(() => {
+  init_opencode_storage_paths();
+});
+
 // src/features/hook-message-injector/injector.ts
 import { randomBytes } from "crypto";
 var processPrefix;
@@ -48284,6 +48455,7 @@ var init_injector = __esm(() => {
   init_logger();
   init_opencode_storage_detection();
   init_shared();
+  init_compaction_marker();
   processPrefix = randomBytes(4).toString("hex");
 });
 
@@ -48293,18 +48465,33 @@ var init_hook_message_injector = __esm(() => {
   init_constants();
 });
 
-// src/shared/opencode-storage-paths.ts
-import { join as join7 } from "path";
-var OPENCODE_STORAGE, MESSAGE_STORAGE, PART_STORAGE, SESSION_STORAGE;
-var init_opencode_storage_paths = __esm(() => {
-  init_data_path();
-  OPENCODE_STORAGE = getOpenCodeStorageDir();
-  MESSAGE_STORAGE = join7(OPENCODE_STORAGE, "message");
-  PART_STORAGE = join7(OPENCODE_STORAGE, "part");
-  SESSION_STORAGE = join7(OPENCODE_STORAGE, "session");
-});
-
 // src/shared/opencode-message-dir.ts
+import { existsSync as existsSync7, readdirSync as readdirSync2 } from "fs";
+import { join as join11 } from "path";
+function getMessageDir(sessionID) {
+  if (!sessionID.startsWith("ses_"))
+    return null;
+  if (/[/\\]|\.\./.test(sessionID))
+    return null;
+  if (!existsSync7(MESSAGE_STORAGE))
+    return null;
+  const directPath = join11(MESSAGE_STORAGE, sessionID);
+  if (existsSync7(directPath)) {
+    return directPath;
+  }
+  try {
+    for (const dir of readdirSync2(MESSAGE_STORAGE)) {
+      const sessionPath = join11(MESSAGE_STORAGE, dir, sessionID);
+      if (existsSync7(sessionPath)) {
+        return sessionPath;
+      }
+    }
+  } catch (error) {
+    log("[opencode-message-dir] Failed to scan message directories", { sessionID, error: String(error) });
+    return null;
+  }
+  return null;
+}
 var init_opencode_message_dir = __esm(() => {
   init_opencode_storage_paths();
   init_logger();
@@ -48330,22 +48517,25 @@ function getAgentConfigKey(agentName) {
   const reversed = REVERSE_DISPLAY_NAMES[lower];
   if (reversed !== undefined)
     return reversed;
+  const legacy = LEGACY_DISPLAY_NAMES[lower];
+  if (legacy !== undefined)
+    return legacy;
   if (AGENT_DISPLAY_NAMES[lower] !== undefined)
     return lower;
   return lower;
 }
-var AGENT_DISPLAY_NAMES, REVERSE_DISPLAY_NAMES;
+var AGENT_DISPLAY_NAMES, REVERSE_DISPLAY_NAMES, LEGACY_DISPLAY_NAMES;
 var init_agent_display_names = __esm(() => {
   AGENT_DISPLAY_NAMES = {
-    sisyphus: "Sisyphus (Ultraworker)",
-    hephaestus: "Hephaestus (Deep Agent)",
-    prometheus: "Prometheus (Plan Builder)",
-    atlas: "Atlas (Plan Executor)",
+    sisyphus: "Sisyphus - Ultraworker",
+    hephaestus: "Hephaestus - Deep Agent",
+    prometheus: "Prometheus - Plan Builder",
+    atlas: "Atlas - Plan Executor",
     "sisyphus-junior": "Sisyphus-Junior",
-    metis: "Metis (Plan Consultant)",
-    momus: "Momus (Plan Critic)",
-    athena: "Athena (Council)",
-    "athena-junior": "Athena-Junior (Council)",
+    metis: "Metis - Plan Consultant",
+    momus: "Momus - Plan Critic",
+    athena: "Athena - Council",
+    "athena-junior": "Athena-Junior - Council",
     oracle: "oracle",
     librarian: "librarian",
     explore: "explore",
@@ -48353,6 +48543,16 @@ var init_agent_display_names = __esm(() => {
     "council-member": "council-member"
   };
   REVERSE_DISPLAY_NAMES = Object.fromEntries(Object.entries(AGENT_DISPLAY_NAMES).map(([key, displayName]) => [displayName.toLowerCase(), key]));
+  LEGACY_DISPLAY_NAMES = {
+    "sisyphus (ultraworker)": "sisyphus",
+    "hephaestus (deep agent)": "hephaestus",
+    "prometheus (plan builder)": "prometheus",
+    "atlas (plan executor)": "atlas",
+    "metis (plan consultant)": "metis",
+    "momus (plan critic)": "momus",
+    "athena (council)": "athena",
+    "athena-junior (council)": "athena-junior"
+  };
 });
 
 // src/shared/session-utils.ts
@@ -48516,9 +48716,18 @@ var init_session_tools_store = __esm(() => {
 var init_prompt_tools = __esm(() => {
   init_session_tools_store();
 });
+
+// src/shared/internal-initiator-marker.ts
+var init_internal_initiator_marker = () => {};
+// src/features/claude-code-plugin-loader/scope-filter.ts
+var init_scope_filter = __esm(() => {
+  init_contains_path();
+});
+
 // src/features/claude-code-plugin-loader/discovery.ts
 var init_discovery = __esm(() => {
   init_logger();
+  init_scope_filter();
 });
 
 // src/features/claude-code-plugin-loader/command-loader.ts
@@ -48569,7 +48778,7 @@ var init_env_expander = __esm(() => {
 });
 
 // src/features/claude-code-mcp-loader/scope-filter.ts
-var init_scope_filter = __esm(() => {
+var init_scope_filter2 = __esm(() => {
   init_contains_path();
 });
 
@@ -48580,7 +48789,7 @@ var init_transformer = __esm(() => {
 // src/features/claude-code-plugin-loader/mcp-server-loader.ts
 var init_mcp_server_loader = __esm(() => {
   init_env_expander();
-  init_scope_filter();
+  init_scope_filter2();
   init_transformer();
   init_logger();
 });
@@ -48591,6 +48800,7 @@ var init_hook_loader = __esm(() => {
 });
 
 // src/features/claude-code-plugin-loader/loader.ts
+var cachedPluginComponentsByKey;
 var init_loader = __esm(() => {
   init_logger();
   init_discovery();
@@ -48605,6 +48815,7 @@ var init_loader = __esm(() => {
   init_agent_loader();
   init_mcp_server_loader();
   init_hook_loader();
+  cachedPluginComponentsByKey = new Map;
 });
 
 // src/features/claude-code-plugin-loader/index.ts
@@ -48714,6 +48925,8 @@ var init_shared = __esm(() => {
   init_project_discovery_dirs();
   init_session_directory_resolver();
   init_prompt_tools();
+  init_compaction_marker();
+  init_internal_initiator_marker();
   init_plugin_command_discovery();
   init_plugin_identity();
   init_log_legacy_plugin_startup_warning();
@@ -48741,16 +48954,15 @@ function getConfigJsonc() {
   return getConfigContext().paths.configJsonc;
 }
 function getOmoConfigPath() {
+  const configDir = getConfigContext().paths.configDir;
+  const detected = detectPluginConfigFile(configDir);
+  if (detected.format !== "none")
+    return detected.path;
   return getConfigContext().paths.omoConfig;
 }
-function getExistingOmoConfigPath() {
-  const detected = detectManagedConfigFile(getConfigDir());
-  return detected.format === "none" ? null : detected.path;
-}
 var configContext = null;
 var init_config_context = __esm(() => {
   init_shared();
-  init_plugin_identity();
 });
 
 // src/cli/config-manager/npm-dist-tags.ts
@@ -48791,17 +49003,42 @@ async function getPluginNameWithVersion(currentVersion, packageName = DEFAULT_PA
 }
 var DEFAULT_PACKAGE_NAME, PRIORITIZED_TAGS;
 var init_plugin_name_with_version = __esm(() => {
-  init_plugin_identity();
+  init_shared();
   DEFAULT_PACKAGE_NAME = PLUGIN_NAME;
   PRIORITIZED_TAGS = ["latest", "beta", "next"];
 });
 
+// src/cli/config-manager/backup-config.ts
+import { copyFileSync as copyFileSync2, existsSync as existsSync8, mkdirSync as mkdirSync3 } from "fs";
+import { dirname } from "path";
+function backupConfigFile(configPath) {
+  if (!existsSync8(configPath)) {
+    return { success: true };
+  }
+  const timestamp2 = new Date().toISOString().replace(/[:.]/g, "-");
+  const backupPath = `${configPath}.backup-${timestamp2}`;
+  try {
+    const dir = dirname(backupPath);
+    if (!existsSync8(dir)) {
+      mkdirSync3(dir, { recursive: true });
+    }
+    copyFileSync2(configPath, backupPath);
+    return { success: true, backupPath };
+  } catch (err) {
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : "Failed to create backup"
+    };
+  }
+}
+var init_backup_config = () => {};
+
 // src/cli/config-manager/ensure-config-directory-exists.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync4 } from "fs";
 function ensureConfigDirectoryExists() {
   const configDir = getConfigDir();
-  if (!existsSync5(configDir)) {
-    mkdirSync2(configDir, { recursive: true });
+  if (!existsSync9(configDir)) {
+    mkdirSync4(configDir, { recursive: true });
   }
 }
 var init_ensure_config_directory_exists = __esm(() => {
@@ -48838,14 +49075,14 @@ function formatErrorWithSuggestion(err, context) {
 }
 
 // src/cli/config-manager/opencode-config-format.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 function detectConfigFormat() {
   const configJsonc = getConfigJsonc();
   const configJson = getConfigJson();
-  if (existsSync6(configJsonc)) {
+  if (existsSync10(configJsonc)) {
     return { format: "jsonc", path: configJsonc };
   }
-  if (existsSync6(configJson)) {
+  if (existsSync10(configJson)) {
     return { format: "json", path: configJson };
   }
   return { format: "none", path: configJson };
@@ -48855,7 +49092,7 @@ var init_opencode_config_format = __esm(() => {
 });
 
 // src/cli/config-manager/parse-opencode-config-file.ts
-import { readFileSync as readFileSync4, statSync } from "fs";
+import { readFileSync as readFileSync5, statSync } from "fs";
 function isEmptyOrWhitespace(content) {
   return content.trim().length === 0;
 }
@@ -48865,7 +49102,7 @@ function parseOpenCodeConfigFileWithError(path3) {
     if (stat.size === 0) {
       return { config: null, error: `Config file is empty: ${path3}. Delete it or add valid JSON content.` };
     }
-    const content = readFileSync4(path3, "utf-8");
+    const content = readFileSync5(path3, "utf-8");
     if (isEmptyOrWhitespace(content)) {
       return { config: null, error: `Config file contains only whitespace: ${path3}. Delete it or add valid JSON content.` };
     }
@@ -48888,8 +49125,90 @@ var init_parse_opencode_config_file = __esm(() => {
   init_shared();
 });
 
+// src/cli/config-manager/version-compatibility.ts
+function parseVersion2(version) {
+  const clean = version.replace(/^v/, "").split("-")[0];
+  return clean.split(".").map(Number);
+}
+function compareVersions2(a, b) {
+  const partsA = parseVersion2(a);
+  const partsB = parseVersion2(b);
+  const maxLen = Math.max(partsA.length, partsB.length);
+  for (let i2 = 0;i2 < maxLen; i2++) {
+    const numA = partsA[i2] ?? 0;
+    const numB = partsB[i2] ?? 0;
+    if (numA !== numB) {
+      return numA - numB;
+    }
+  }
+  return 0;
+}
+function checkVersionCompatibility(currentVersion, newVersion) {
+  if (!currentVersion) {
+    return {
+      canUpgrade: true,
+      isDowngrade: false,
+      isMajorBump: false,
+      requiresMigration: false
+    };
+  }
+  const cleanCurrent = currentVersion.replace(/^v/, "");
+  const cleanNew = newVersion.replace(/^v/, "");
+  try {
+    const comparison = compareVersions2(cleanNew, cleanCurrent);
+    if (comparison < 0) {
+      return {
+        canUpgrade: false,
+        reason: `Downgrade from ${currentVersion} to ${newVersion} is not allowed`,
+        isDowngrade: true,
+        isMajorBump: false,
+        requiresMigration: false
+      };
+    }
+    if (comparison === 0) {
+      return {
+        canUpgrade: true,
+        reason: `Version ${newVersion} is already installed`,
+        isDowngrade: false,
+        isMajorBump: false,
+        requiresMigration: false
+      };
+    }
+    const currentMajor = cleanCurrent.split(".")[0];
+    const newMajor = cleanNew.split(".")[0];
+    const isMajorBump = currentMajor !== newMajor;
+    if (isMajorBump) {
+      return {
+        canUpgrade: true,
+        reason: `Major version upgrade from ${currentVersion} to ${newVersion} - configuration migration may be required`,
+        isDowngrade: false,
+        isMajorBump: true,
+        requiresMigration: true
+      };
+    }
+    return {
+      canUpgrade: true,
+      isDowngrade: false,
+      isMajorBump: false,
+      requiresMigration: false
+    };
+  } catch {
+    return {
+      canUpgrade: true,
+      reason: `Unable to compare versions ${currentVersion} and ${newVersion} - proceeding with caution`,
+      isDowngrade: false,
+      isMajorBump: false,
+      requiresMigration: false
+    };
+  }
+}
+function extractVersionFromPluginEntry(entry) {
+  const match = entry.match(/@(.+)$/);
+  return match ? match[1] : null;
+}
+
 // src/cli/config-manager/add-plugin-to-opencode-config.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
 async function addPluginToOpenCodeConfig(currentVersion) {
   try {
     ensureConfigDirectoryExists();
@@ -48901,7 +49220,7 @@ async function addPluginToOpenCodeConfig(currentVersion) {
     };
   }
   const { format: format2, path: path3 } = detectConfigFormat();
-  const pluginEntry = await getPluginNameWithVersion(currentVersion, PACKAGE_NAME);
+  const pluginEntry = await getPluginNameWithVersion(currentVersion, PLUGIN_NAME);
   try {
     if (format2 === "none") {
       const config2 = { plugin: [pluginEntry] };
@@ -48919,24 +49238,44 @@ async function addPluginToOpenCodeConfig(currentVersion) {
     }
     const config = parseResult.config;
     const plugins = config.plugin ?? [];
-    const existingPlugin = findManagedPluginEntry(plugins);
-    if (existingPlugin) {
-      if (plugins[existingPlugin.index] === pluginEntry) {
-        return { success: true, configPath: path3 };
+    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"
+        };
       }
-      plugins[existingPlugin.index] = pluginEntry;
+      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 || legacyEntries.length > 0) {
+      normalizedPlugins.push(pluginEntry);
     } else {
-      plugins.push(pluginEntry);
+      normalizedPlugins.push(pluginEntry);
     }
-    config.plugin = plugins;
+    config.plugin = normalizedPlugins;
     if (format2 === "jsonc") {
-      const content = readFileSync5(path3, "utf-8");
-      const pluginArrayRegex = /"plugin"\s*:\s*\[([\s\S]*?)\]/;
+      const content = readFileSync6(path3, "utf-8");
+      const pluginArrayRegex = /((?:"plugin"|plugin)\s*:\s*)\[([\s\S]*?)\]/;
       const match = content.match(pluginArrayRegex);
       if (match) {
-        const formattedPlugins = plugins.map((p) => `"${p}"`).join(`,
+        const formattedPlugins = normalizedPlugins.map((p) => `"${p}"`).join(`,
     `);
-        const newContent = content.replace(pluginArrayRegex, `"plugin": [
+        const newContent = content.replace(pluginArrayRegex, `$1[
     ${formattedPlugins}
   ]`);
         writeFileSync3(path3, newContent);
@@ -48958,15 +49297,14 @@ async function addPluginToOpenCodeConfig(currentVersion) {
     };
   }
 }
-var PACKAGE_NAME;
 var init_add_plugin_to_opencode_config = __esm(() => {
-  init_plugin_identity();
+  init_shared();
+  init_backup_config();
   init_config_context();
   init_ensure_config_directory_exists();
   init_opencode_config_format();
   init_parse_opencode_config_file();
   init_plugin_name_with_version();
-  PACKAGE_NAME = PLUGIN_NAME;
 });
 
 // src/cli/model-fallback-requirements.ts
@@ -49077,6 +49415,47 @@ var init_fallback_chain_resolution = __esm(() => {
 });
 
 // src/cli/model-fallback.ts
+function toFallbackModelObject(entry, provider) {
+  return {
+    model: `${provider}/${transformModelForProvider(provider, entry.model)}`,
+    ...entry.variant ? { variant: entry.variant } : {},
+    ...entry.reasoningEffort ? { reasoningEffort: entry.reasoningEffort } : {},
+    ...entry.temperature !== undefined ? { temperature: entry.temperature } : {},
+    ...entry.top_p !== undefined ? { top_p: entry.top_p } : {},
+    ...entry.maxTokens !== undefined ? { maxTokens: entry.maxTokens } : {},
+    ...entry.thinking ? { thinking: entry.thinking } : {}
+  };
+}
+function collectAvailableFallbacks(fallbackChain, availability) {
+  const expandedFallbacks = fallbackChain.flatMap((entry) => entry.providers.filter((provider) => isProviderAvailable(provider, availability)).map((provider) => toFallbackModelObject(entry, provider)));
+  return expandedFallbacks.filter((entry, index, allEntries) => allEntries.findIndex((candidate) => candidate.model === entry.model && candidate.variant === entry.variant) === index);
+}
+function attachFallbackModels(config, fallbackChain, availability) {
+  const uniqueFallbacks = collectAvailableFallbacks(fallbackChain, availability);
+  const primaryIndex = uniqueFallbacks.findIndex((entry) => entry.model === config.model);
+  if (primaryIndex === -1) {
+    return config;
+  }
+  const fallbackModels = uniqueFallbacks.slice(primaryIndex + 1);
+  if (fallbackModels.length === 0) {
+    return config;
+  }
+  return {
+    ...config,
+    fallback_models: fallbackModels
+  };
+}
+function attachAllFallbackModels(config, fallbackChain, availability) {
+  const uniqueFallbacks = collectAvailableFallbacks(fallbackChain, availability);
+  const fallbackModels = uniqueFallbacks.filter((entry) => entry.model !== config.model);
+  if (fallbackModels.length === 0) {
+    return config;
+  }
+  return {
+    ...config,
+    fallback_models: fallbackModels
+  };
+}
 function generateModelConfig(config) {
   const avail = toProviderAvailability(config);
   const hasAnyProvider = avail.native.claude || avail.native.openai || avail.native.gemini || avail.opencodeZen || avail.copilot || avail.zai || avail.kimiForCoding || avail.opencodeGo;
@@ -49091,25 +49470,31 @@ function generateModelConfig(config) {
   const categories = {};
   for (const [role, req] of Object.entries(CLI_AGENT_MODEL_REQUIREMENTS)) {
     if (role === "librarian") {
+      let agentConfig;
       if (avail.opencodeGo) {
-        agents[role] = { model: "opencode-go/minimax-m2.5" };
+        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.5" };
+        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") {
@@ -49120,7 +49505,8 @@ function generateModelConfig(config) {
       const resolved2 = resolveModelFromChain(fallbackChain, avail);
       if (resolved2) {
         const variant = resolved2.variant ?? req.variant;
-        agents[role] = variant ? { model: resolved2.model, variant } : { model: resolved2.model };
+        const agentConfig = variant ? { model: resolved2.model, variant } : { model: resolved2.model };
+        agents[role] = attachFallbackModels(agentConfig, fallbackChain, avail);
       }
       continue;
     }
@@ -49133,7 +49519,8 @@ function generateModelConfig(config) {
     const resolved = resolveModelFromChain(req.fallbackChain, avail);
     if (resolved) {
       const variant = resolved.variant ?? req.variant;
-      agents[role] = variant ? { model: resolved.model, variant } : { model: resolved.model };
+      const agentConfig = variant ? { model: resolved.model, variant } : { model: resolved.model };
+      agents[role] = attachFallbackModels(agentConfig, req.fallbackChain, avail);
     } else {
       agents[role] = { model: ULTIMATE_FALLBACK };
     }
@@ -49149,7 +49536,8 @@ function generateModelConfig(config) {
     const resolved = resolveModelFromChain(fallbackChain, avail);
     if (resolved) {
       const variant = resolved.variant ?? req.variant;
-      categories[cat] = variant ? { model: resolved.model, variant } : { model: resolved.model };
+      const categoryConfig = variant ? { model: resolved.model, variant } : { model: resolved.model };
+      categories[cat] = attachFallbackModels(categoryConfig, fallbackChain, avail);
     } else {
       categories[cat] = { model: ULTIMATE_FALLBACK };
     }
@@ -49161,13 +49549,12 @@ function generateModelConfig(config) {
   };
   return isOpenAiOnlyAvailability(avail) ? applyOpenAiOnlyModelCatalog(generatedConfig) : generatedConfig;
 }
-var ZAI_MODEL = "zai-coding-plan/glm-4.7", ULTIMATE_FALLBACK = "opencode/glm-4.7-free", SCHEMA_URL;
+var ZAI_MODEL = "zai-coding-plan/glm-4.7", ULTIMATE_FALLBACK = "opencode/gpt-5-nano", SCHEMA_URL = "https://raw.githubusercontent.com/D4ch1au/evil-oh-my-openagent/dev/assets/evil-omo.schema.json";
 var init_model_fallback = __esm(() => {
   init_model_fallback_requirements();
   init_openai_only_model_catalog();
   init_fallback_chain_resolution();
-  init_plugin_identity();
-  SCHEMA_URL = `https://raw.githubusercontent.com/D4ch1au/evil-oh-my-openagent/dev/assets/${SCHEMA_FILENAME}`;
+  init_provider_model_id_transform();
 });
 
 // src/cli/config-manager/generate-omo-config.ts
@@ -49196,7 +49583,7 @@ function deepMergeRecord(target, source) {
 }
 
 // src/cli/config-manager/write-omo-config.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6, statSync as statSync2, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync7, statSync as statSync2, writeFileSync as writeFileSync4 } from "fs";
 function isEmptyOrWhitespace2(content) {
   return content.trim().length === 0;
 }
@@ -49211,13 +49598,20 @@ function writeOmoConfig(installConfig) {
     };
   }
   const omoConfigPath = getOmoConfigPath();
-  const existingConfigPath = getExistingOmoConfigPath() ?? omoConfigPath;
   try {
     const newConfig = generateOmoConfig(installConfig);
-    if (existsSync7(existingConfigPath)) {
+    if (existsSync11(omoConfigPath)) {
+      const backupResult = backupConfigFile(omoConfigPath);
+      if (!backupResult.success) {
+        return {
+          success: false,
+          configPath: omoConfigPath,
+          error: `Failed to create backup: ${backupResult.error}`
+        };
+      }
       try {
-        const stat = statSync2(existingConfigPath);
-        const content = readFileSync6(existingConfigPath, "utf-8");
+        const stat = statSync2(omoConfigPath);
+        const content = readFileSync7(omoConfigPath, "utf-8");
         if (stat.size === 0 || isEmptyOrWhitespace2(content)) {
           writeFileSync4(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
 `);
@@ -49230,7 +49624,6 @@ function writeOmoConfig(installConfig) {
           return { success: true, configPath: omoConfigPath };
         }
         const merged = deepMergeRecord(newConfig, existing);
-        merged.$schema = newConfig.$schema;
         writeFileSync4(omoConfigPath, JSON.stringify(merged, null, 2) + `
 `);
       } catch (parseErr) {
@@ -49256,6 +49649,7 @@ function writeOmoConfig(installConfig) {
 }
 var init_write_omo_config = __esm(() => {
   init_shared();
+  init_backup_config();
   init_config_context();
   init_ensure_config_directory_exists();
   init_generate_omo_config();
@@ -49346,7 +49740,7 @@ async function isOpenCodeInstalled() {
   const result = await findOpenCodeBinaryWithVersion();
   return result !== null;
 }
-async function getOpenCodeVersion() {
+async function getOpenCodeVersion2() {
   const result = await findOpenCodeBinaryWithVersion();
   return result?.version ?? null;
 }
@@ -49358,10 +49752,10 @@ var init_opencode_binary = __esm(() => {
 });
 
 // src/cli/config-manager/detect-current-config.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync8 } from "fs";
 function detectProvidersFromOmoConfig() {
-  const omoConfigPath = getExistingOmoConfigPath();
-  if (!omoConfigPath || !existsSync8(omoConfigPath)) {
+  const omoConfigPath = getOmoConfigPath();
+  if (!existsSync12(omoConfigPath)) {
     return {
       hasOpenAI: true,
       hasOpencodeZen: true,
@@ -49371,7 +49765,7 @@ function detectProvidersFromOmoConfig() {
     };
   }
   try {
-    const content = readFileSync7(omoConfigPath, "utf-8");
+    const content = readFileSync8(omoConfigPath, "utf-8");
     const omoConfig = parseJsonc(content);
     if (!omoConfig || typeof omoConfig !== "object") {
       return {
@@ -49399,9 +49793,16 @@ 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,
@@ -49422,7 +49823,11 @@ function detectCurrentConfig() {
   }
   const openCodeConfig = parseResult.config;
   const plugins = openCodeConfig.plugin ?? [];
-  result.isInstalled = findManagedPluginEntry(plugins) !== null;
+  const ourPluginEntry = findOurPluginEntry(plugins);
+  result.isInstalled = !!ourPluginEntry;
+  if (ourPluginEntry) {
+    result.installedVersion = extractVersionFromPluginEntry(ourPluginEntry);
+  }
   if (!result.isInstalled) {
     return result;
   }
@@ -49438,17 +49843,16 @@ function detectCurrentConfig() {
 }
 var init_detect_current_config = __esm(() => {
   init_shared();
-  init_plugin_identity();
   init_config_context();
   init_opencode_config_format();
   init_parse_opencode_config_file();
 });
 
 // src/cli/config-manager/bun-install.ts
-import { existsSync as existsSync9 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { join as join12 } from "path";
 function getDefaultWorkspaceDir() {
-  return join8(getOpenCodeCacheDir(), "packages");
+  return join12(getOpenCodeCacheDir(), "packages");
 }
 function readProcessOutput(stream) {
   if (!stream) {
@@ -49474,7 +49878,7 @@ async function runBunInstallWithDetails(options) {
   const outputMode = options?.outputMode ?? "pipe";
   const cacheDir = options?.workspaceDir ?? getDefaultWorkspaceDir();
   const packageJsonPath = `${cacheDir}/package.json`;
-  if (!existsSync9(packageJsonPath)) {
+  if (!existsSync13(packageJsonPath)) {
     return {
       success: false,
       error: `Workspace not initialized: ${packageJsonPath} not found. OpenCode should create this on first run.`
@@ -49550,6 +49954,7 @@ var init_config_manager = __esm(() => {
   init_opencode_binary();
   init_detect_current_config();
   init_bun_install();
+  init_backup_config();
 });
 
 // node_modules/sisteransi/src/index.js
@@ -49610,6 +50015,462 @@ var require_src = __commonJS((exports, module) => {
   module.exports = { cursor, scroll, erase, beep };
 });
 
+// node_modules/isexe/windows.js
+var require_windows = __commonJS((exports, module) => {
+  module.exports = isexe;
+  isexe.sync = sync;
+  var fs4 = __require("fs");
+  function checkPathExt(path4, options) {
+    var pathext = options.pathExt !== undefined ? options.pathExt : process.env.PATHEXT;
+    if (!pathext) {
+      return true;
+    }
+    pathext = pathext.split(";");
+    if (pathext.indexOf("") !== -1) {
+      return true;
+    }
+    for (var i2 = 0;i2 < pathext.length; i2++) {
+      var p2 = pathext[i2].toLowerCase();
+      if (p2 && path4.substr(-p2.length).toLowerCase() === p2) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function checkStat(stat, path4, options) {
+    if (!stat.isSymbolicLink() && !stat.isFile()) {
+      return false;
+    }
+    return checkPathExt(path4, options);
+  }
+  function isexe(path4, options, cb) {
+    fs4.stat(path4, function(er, stat) {
+      cb(er, er ? false : checkStat(stat, path4, options));
+    });
+  }
+  function sync(path4, options) {
+    return checkStat(fs4.statSync(path4), path4, options);
+  }
+});
+
+// node_modules/isexe/mode.js
+var require_mode = __commonJS((exports, module) => {
+  module.exports = isexe;
+  isexe.sync = sync;
+  var fs4 = __require("fs");
+  function isexe(path4, options, cb) {
+    fs4.stat(path4, function(er, stat) {
+      cb(er, er ? false : checkStat(stat, options));
+    });
+  }
+  function sync(path4, options) {
+    return checkStat(fs4.statSync(path4), options);
+  }
+  function checkStat(stat, options) {
+    return stat.isFile() && checkMode(stat, options);
+  }
+  function checkMode(stat, options) {
+    var mod = stat.mode;
+    var uid = stat.uid;
+    var gid = stat.gid;
+    var myUid = options.uid !== undefined ? options.uid : process.getuid && process.getuid();
+    var myGid = options.gid !== undefined ? options.gid : process.getgid && process.getgid();
+    var u2 = parseInt("100", 8);
+    var g2 = parseInt("010", 8);
+    var o2 = parseInt("001", 8);
+    var ug = u2 | g2;
+    var ret = mod & o2 || mod & g2 && gid === myGid || mod & u2 && uid === myUid || mod & ug && myUid === 0;
+    return ret;
+  }
+});
+
+// node_modules/isexe/index.js
+var require_isexe = __commonJS((exports, module) => {
+  var fs4 = __require("fs");
+  var core3;
+  if (process.platform === "win32" || global.TESTING_WINDOWS) {
+    core3 = require_windows();
+  } else {
+    core3 = require_mode();
+  }
+  module.exports = isexe;
+  isexe.sync = sync;
+  function isexe(path4, options, cb) {
+    if (typeof options === "function") {
+      cb = options;
+      options = {};
+    }
+    if (!cb) {
+      if (typeof Promise !== "function") {
+        throw new TypeError("callback not provided");
+      }
+      return new Promise(function(resolve2, reject) {
+        isexe(path4, options || {}, function(er, is) {
+          if (er) {
+            reject(er);
+          } else {
+            resolve2(is);
+          }
+        });
+      });
+    }
+    core3(path4, options || {}, function(er, is) {
+      if (er) {
+        if (er.code === "EACCES" || options && options.ignoreErrors) {
+          er = null;
+          is = false;
+        }
+      }
+      cb(er, is);
+    });
+  }
+  function sync(path4, options) {
+    try {
+      return core3.sync(path4, options || {});
+    } catch (er) {
+      if (options && options.ignoreErrors || er.code === "EACCES") {
+        return false;
+      } else {
+        throw er;
+      }
+    }
+  }
+});
+
+// node_modules/which/which.js
+var require_which = __commonJS((exports, module) => {
+  var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+  var path4 = __require("path");
+  var COLON = isWindows ? ";" : ":";
+  var isexe = require_isexe();
+  var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+  var getPathInfo = (cmd, opt) => {
+    const colon = opt.colon || COLON;
+    const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [
+      ...isWindows ? [process.cwd()] : [],
+      ...(opt.path || process.env.PATH || "").split(colon)
+    ];
+    const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+    const pathExt = isWindows ? pathExtExe.split(colon) : [""];
+    if (isWindows) {
+      if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
+        pathExt.unshift("");
+    }
+    return {
+      pathEnv,
+      pathExt,
+      pathExtExe
+    };
+  };
+  var which = (cmd, opt, cb) => {
+    if (typeof opt === "function") {
+      cb = opt;
+      opt = {};
+    }
+    if (!opt)
+      opt = {};
+    const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+    const found = [];
+    const step = (i2) => new Promise((resolve2, reject) => {
+      if (i2 === pathEnv.length)
+        return opt.all && found.length ? resolve2(found) : reject(getNotFoundError(cmd));
+      const ppRaw = pathEnv[i2];
+      const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+      const pCmd = path4.join(pathPart, cmd);
+      const p2 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+      resolve2(subStep(p2, i2, 0));
+    });
+    const subStep = (p2, i2, ii) => new Promise((resolve2, reject) => {
+      if (ii === pathExt.length)
+        return resolve2(step(i2 + 1));
+      const ext = pathExt[ii];
+      isexe(p2 + ext, { pathExt: pathExtExe }, (er, is) => {
+        if (!er && is) {
+          if (opt.all)
+            found.push(p2 + ext);
+          else
+            return resolve2(p2 + ext);
+        }
+        return resolve2(subStep(p2, i2, ii + 1));
+      });
+    });
+    return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+  };
+  var whichSync = (cmd, opt) => {
+    opt = opt || {};
+    const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+    const found = [];
+    for (let i2 = 0;i2 < pathEnv.length; i2++) {
+      const ppRaw = pathEnv[i2];
+      const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+      const pCmd = path4.join(pathPart, cmd);
+      const p2 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+      for (let j2 = 0;j2 < pathExt.length; j2++) {
+        const cur = p2 + pathExt[j2];
+        try {
+          const is = isexe.sync(cur, { pathExt: pathExtExe });
+          if (is) {
+            if (opt.all)
+              found.push(cur);
+            else
+              return cur;
+          }
+        } catch (ex) {}
+      }
+    }
+    if (opt.all && found.length)
+      return found;
+    if (opt.nothrow)
+      return null;
+    throw getNotFoundError(cmd);
+  };
+  module.exports = which;
+  which.sync = whichSync;
+});
+
+// node_modules/path-key/index.js
+var require_path_key = __commonJS((exports, module) => {
+  var pathKey = (options = {}) => {
+    const environment = options.env || process.env;
+    const platform = options.platform || process.platform;
+    if (platform !== "win32") {
+      return "PATH";
+    }
+    return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+  };
+  module.exports = pathKey;
+  module.exports.default = pathKey;
+});
+
+// node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = __commonJS((exports, module) => {
+  var path4 = __require("path");
+  var which = require_which();
+  var getPathKey = require_path_key();
+  function resolveCommandAttempt(parsed, withoutPathExt) {
+    const env = parsed.options.env || process.env;
+    const cwd = process.cwd();
+    const hasCustomCwd = parsed.options.cwd != null;
+    const shouldSwitchCwd = hasCustomCwd && process.chdir !== undefined && !process.chdir.disabled;
+    if (shouldSwitchCwd) {
+      try {
+        process.chdir(parsed.options.cwd);
+      } catch (err) {}
+    }
+    let resolved;
+    try {
+      resolved = which.sync(parsed.command, {
+        path: env[getPathKey({ env })],
+        pathExt: withoutPathExt ? path4.delimiter : undefined
+      });
+    } catch (e2) {} finally {
+      if (shouldSwitchCwd) {
+        process.chdir(cwd);
+      }
+    }
+    if (resolved) {
+      resolved = path4.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+    }
+    return resolved;
+  }
+  function resolveCommand(parsed) {
+    return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+  }
+  module.exports = resolveCommand;
+});
+
+// node_modules/cross-spawn/lib/util/escape.js
+var require_escape = __commonJS((exports, module) => {
+  var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+  function escapeCommand(arg) {
+    arg = arg.replace(metaCharsRegExp, "^$1");
+    return arg;
+  }
+  function escapeArgument(arg, doubleEscapeMetaChars) {
+    arg = `${arg}`;
+    arg = arg.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
+    arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+    arg = `"${arg}"`;
+    arg = arg.replace(metaCharsRegExp, "^$1");
+    if (doubleEscapeMetaChars) {
+      arg = arg.replace(metaCharsRegExp, "^$1");
+    }
+    return arg;
+  }
+  exports.command = escapeCommand;
+  exports.argument = escapeArgument;
+});
+
+// node_modules/shebang-regex/index.js
+var require_shebang_regex = __commonJS((exports, module) => {
+  module.exports = /^#!(.*)/;
+});
+
+// node_modules/shebang-command/index.js
+var require_shebang_command = __commonJS((exports, module) => {
+  var shebangRegex = require_shebang_regex();
+  module.exports = (string4 = "") => {
+    const match = string4.match(shebangRegex);
+    if (!match) {
+      return null;
+    }
+    const [path4, argument] = match[0].replace(/#! ?/, "").split(" ");
+    const binary2 = path4.split("/").pop();
+    if (binary2 === "env") {
+      return argument;
+    }
+    return argument ? `${binary2} ${argument}` : binary2;
+  };
+});
+
+// node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = __commonJS((exports, module) => {
+  var fs4 = __require("fs");
+  var shebangCommand = require_shebang_command();
+  function readShebang(command) {
+    const size = 150;
+    const buffer2 = Buffer.alloc(size);
+    let fd;
+    try {
+      fd = fs4.openSync(command, "r");
+      fs4.readSync(fd, buffer2, 0, size, 0);
+      fs4.closeSync(fd);
+    } catch (e2) {}
+    return shebangCommand(buffer2.toString());
+  }
+  module.exports = readShebang;
+});
+
+// node_modules/cross-spawn/lib/parse.js
+var require_parse = __commonJS((exports, module) => {
+  var path4 = __require("path");
+  var resolveCommand = require_resolveCommand();
+  var escape = require_escape();
+  var readShebang = require_readShebang();
+  var isWin = process.platform === "win32";
+  var isExecutableRegExp = /\.(?:com|exe)$/i;
+  var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+  function detectShebang(parsed) {
+    parsed.file = resolveCommand(parsed);
+    const shebang = parsed.file && readShebang(parsed.file);
+    if (shebang) {
+      parsed.args.unshift(parsed.file);
+      parsed.command = shebang;
+      return resolveCommand(parsed);
+    }
+    return parsed.file;
+  }
+  function parseNonShell(parsed) {
+    if (!isWin) {
+      return parsed;
+    }
+    const commandFile = detectShebang(parsed);
+    const needsShell = !isExecutableRegExp.test(commandFile);
+    if (parsed.options.forceShell || needsShell) {
+      const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+      parsed.command = path4.normalize(parsed.command);
+      parsed.command = escape.command(parsed.command);
+      parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+      const shellCommand = [parsed.command].concat(parsed.args).join(" ");
+      parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
+      parsed.command = process.env.comspec || "cmd.exe";
+      parsed.options.windowsVerbatimArguments = true;
+    }
+    return parsed;
+  }
+  function parse7(command, args, options) {
+    if (args && !Array.isArray(args)) {
+      options = args;
+      args = null;
+    }
+    args = args ? args.slice(0) : [];
+    options = Object.assign({}, options);
+    const parsed = {
+      command,
+      args,
+      options,
+      file: undefined,
+      original: {
+        command,
+        args
+      }
+    };
+    return options.shell ? parsed : parseNonShell(parsed);
+  }
+  module.exports = parse7;
+});
+
+// node_modules/cross-spawn/lib/enoent.js
+var require_enoent = __commonJS((exports, module) => {
+  var isWin = process.platform === "win32";
+  function notFoundError(original, syscall) {
+    return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+      code: "ENOENT",
+      errno: "ENOENT",
+      syscall: `${syscall} ${original.command}`,
+      path: original.command,
+      spawnargs: original.args
+    });
+  }
+  function hookChildProcess(cp, parsed) {
+    if (!isWin) {
+      return;
+    }
+    const originalEmit = cp.emit;
+    cp.emit = function(name, arg1) {
+      if (name === "exit") {
+        const err = verifyENOENT(arg1, parsed);
+        if (err) {
+          return originalEmit.call(cp, "error", err);
+        }
+      }
+      return originalEmit.apply(cp, arguments);
+    };
+  }
+  function verifyENOENT(status, parsed) {
+    if (isWin && status === 1 && !parsed.file) {
+      return notFoundError(parsed.original, "spawn");
+    }
+    return null;
+  }
+  function verifyENOENTSync(status, parsed) {
+    if (isWin && status === 1 && !parsed.file) {
+      return notFoundError(parsed.original, "spawnSync");
+    }
+    return null;
+  }
+  module.exports = {
+    hookChildProcess,
+    verifyENOENT,
+    verifyENOENTSync,
+    notFoundError
+  };
+});
+
+// node_modules/cross-spawn/index.js
+var require_cross_spawn = __commonJS((exports, module) => {
+  var cp = __require("child_process");
+  var parse7 = require_parse();
+  var enoent = require_enoent();
+  function spawn(command, args, options) {
+    const parsed = parse7(command, args, options);
+    const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+    enoent.hookChildProcess(spawned, parsed);
+    return spawned;
+  }
+  function spawnSync(command, args, options) {
+    const parsed = parse7(command, args, options);
+    const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+    result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+    return result;
+  }
+  module.exports = spawn;
+  module.exports.spawn = spawn;
+  module.exports.sync = spawnSync;
+  module.exports._parse = parse7;
+  module.exports._enoent = enoent;
+});
+
 // src/hooks/auto-update-checker/constants.ts
 import * as path4 from "path";
 import * as os3 from "os";
@@ -49618,19 +50479,23 @@ function getWindowsAppdataDir() {
     return null;
   return process.env.APPDATA ?? path4.join(os3.homedir(), "AppData", "Roaming");
 }
-var PACKAGE_NAME2, NPM_REGISTRY_URL, NPM_FETCH_TIMEOUT = 5000, CACHE_ROOT_DIR, CACHE_DIR, VERSION_FILE, USER_CONFIG_DIR, USER_OPENCODE_CONFIG, USER_OPENCODE_CONFIG_JSONC, INSTALLED_PACKAGE_JSON;
+function getUserConfigDir() {
+  return getOpenCodeConfigDir({ binary: "opencode" });
+}
+function getUserOpencodeConfig() {
+  return path4.join(getUserConfigDir(), "opencode.json");
+}
+function getUserOpencodeConfigJsonc() {
+  return path4.join(getUserConfigDir(), "opencode.jsonc");
+}
+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();
-  init_plugin_identity();
-  PACKAGE_NAME2 = PLUGIN_NAME;
   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");
-  USER_CONFIG_DIR = getOpenCodeConfigDir({ binary: "opencode" });
-  USER_OPENCODE_CONFIG = path4.join(USER_CONFIG_DIR, "opencode.json");
-  USER_OPENCODE_CONFIG_JSONC = path4.join(USER_CONFIG_DIR, "opencode.jsonc");
   INSTALLED_PACKAGE_JSON = path4.join(CACHE_DIR, "node_modules", PACKAGE_NAME2, "package.json");
 });
 
@@ -49638,17 +50503,18 @@ var init_constants3 = __esm(() => {
 import * as os4 from "os";
 import * as path5 from "path";
 function getConfigPaths(directory) {
+  const userConfigDir = getUserConfigDir();
   const paths = [
     path5.join(directory, ".opencode", "opencode.json"),
     path5.join(directory, ".opencode", "opencode.jsonc"),
-    USER_OPENCODE_CONFIG,
-    USER_OPENCODE_CONFIG_JSONC
+    getUserOpencodeConfig(),
+    getUserOpencodeConfigJsonc()
   ];
   if (process.platform === "win32") {
     const crossPlatformDir = path5.join(os4.homedir(), ".config");
     const appdataDir = getWindowsAppdataDir();
     if (appdataDir) {
-      const alternateDir = USER_CONFIG_DIR === crossPlatformDir ? appdataDir : crossPlatformDir;
+      const alternateDir = userConfigDir === crossPlatformDir ? appdataDir : crossPlatformDir;
       const alternateConfig = path5.join(alternateDir, "opencode", "opencode.json");
       const alternateConfigJsonc = path5.join(alternateDir, "opencode", "opencode.jsonc");
       if (!paths.includes(alternateConfig)) {
@@ -49765,15 +50631,17 @@ function findPluginEntry(directory) {
       const content = fs7.readFileSync(configPath, "utf-8");
       const config2 = JSON.parse(stripJsonComments(content));
       const plugins = config2.plugin ?? [];
-      const managedEntry = findManagedPluginEntry(plugins);
-      if (managedEntry) {
-        const entry = plugins[managedEntry.index];
-        if (entry === managedEntry.packageName) {
-          return { entry, isPinned: false, pinnedVersion: null, configPath };
+      for (const entry of plugins) {
+        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 };
+          }
         }
-        const pinnedVersion = entry.slice(managedEntry.packageName.length + 1);
-        const isPinned = EXACT_SEMVER_REGEX.test(pinnedVersion.trim());
-        return { entry, isPinned, pinnedVersion, configPath };
       }
     } catch {
       continue;
@@ -49781,11 +50649,13 @@ function findPluginEntry(directory) {
   }
   return null;
 }
-var EXACT_SEMVER_REGEX;
+var EXACT_SEMVER_REGEX, MATCH_PLUGIN_NAMES;
 var init_plugin_entry = __esm(() => {
-  init_plugin_identity();
+  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
@@ -49825,6 +50695,23 @@ function getCachedVersion() {
   } catch (err) {
     log("[auto-update-checker] Failed to resolve version from execPath:", err);
   }
+  try {
+    const currentFile = fileURLToPath2(import.meta.url);
+    let dir = path7.dirname(currentFile);
+    for (let i2 = 0;i2 < 10; i2++) {
+      const pkgPath = path7.join(dir, "package.json");
+      if (fs8.existsSync(pkgPath)) {
+        const content = fs8.readFileSync(pkgPath, "utf-8");
+        const pkg = JSON.parse(content);
+        if (pkg.version)
+          return pkg.version;
+      }
+      const parent = path7.dirname(dir);
+      if (parent === dir)
+        break;
+      dir = parent;
+    }
+  } catch {}
   return null;
 }
 var init_cached_version = __esm(() => {
@@ -50105,8 +50992,9 @@ function removeFromBunLock(packageName) {
 }
 function invalidatePackage(packageName = PACKAGE_NAME2) {
   try {
+    const userConfigDir = getUserConfigDir();
     const pkgDirs = [
-      path9.join(USER_CONFIG_DIR, "node_modules", packageName),
+      path9.join(userConfigDir, "node_modules", packageName),
       path9.join(CACHE_DIR, "node_modules", packageName)
     ];
     let packageRemoved = false;
@@ -50142,7 +51030,7 @@ var init_cache = __esm(() => {
 async function showUpdateAvailableToast(ctx, latestVersion, getToastMessage) {
   await ctx.client.tui.showToast({
     body: {
-      title: `OhMyOpenCode ${latestVersion}`,
+      title: `EvilOMO ${latestVersion}`,
       message: getToastMessage(true, latestVersion),
       variant: "info",
       duration: 8000
@@ -50153,7 +51041,7 @@ async function showUpdateAvailableToast(ctx, latestVersion, getToastMessage) {
 async function showAutoUpdatedToast(ctx, oldVersion, newVersion) {
   await ctx.client.tui.showToast({
     body: {
-      title: "OhMyOpenCode Updated!",
+      title: "EvilOMO Updated!",
       message: `v${oldVersion} \u2192 v${newVersion}
 Restart OpenCode to apply.`,
       variant: "success",
@@ -50167,8 +51055,8 @@ var init_update_toasts = __esm(() => {
 });
 
 // src/hooks/auto-update-checker/hook/background-update-check.ts
-import { existsSync as existsSync20 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync24 } from "fs";
+import { join as join25 } from "path";
 function getCacheWorkspaceDir(deps) {
   return deps.join(deps.getOpenCodeCacheDir(), "packages");
 }
@@ -50225,8 +51113,8 @@ function createBackgroundUpdateCheckRunner(overrides = {}) {
       deps.log("[auto-update-checker] Plugin not found in config");
       return;
     }
-    const cachedVersion = deps.getCachedVersion();
-    const currentVersion = cachedVersion ?? pluginInfo.pinnedVersion;
+    const cachedVersion2 = deps.getCachedVersion();
+    const currentVersion = cachedVersion2 ?? pluginInfo.pinnedVersion;
     if (!currentVersion) {
       deps.log("[auto-update-checker] No version found (cached or pinned)");
       return;
@@ -50286,8 +51174,8 @@ var init_background_update_check = __esm(() => {
   init_checker();
   init_update_toasts();
   defaultDeps = {
-    existsSync: existsSync20,
-    join: join19,
+    existsSync: existsSync24,
+    join: join25,
     runBunInstallWithDetails,
     log,
     getOpenCodeCacheDir,
@@ -50434,7 +51322,7 @@ async function showSpinnerToast(ctx, version2, message) {
     const spinner = SISYPHUS_SPINNER[i2 % SISYPHUS_SPINNER.length];
     await ctx.client.tui.showToast({
       body: {
-        title: `${spinner} OhMyOpenCode ${version2}`,
+        title: `${spinner} EvilOMO ${version2}`,
         message,
         variant: "info",
         duration: frameInterval + 50
@@ -50496,9 +51384,9 @@ v${latestVersion} available. Restart OpenCode to apply.` : "OpenCode is now on S
         return;
       hasChecked = true;
       setTimeout(async () => {
-        const cachedVersion = getCachedVersion();
+        const cachedVersion2 = getCachedVersion();
         const localDevVersion = getLocalDevVersion(ctx.directory);
-        const displayVersion = localDevVersion ?? cachedVersion;
+        const displayVersion = localDevVersion ?? cachedVersion2;
         await showConfigErrorsIfAny(ctx);
         await updateAndShowConnectedProvidersCacheStatus(ctx);
         await refreshModelCapabilitiesOnStartup(modelCapabilities);
@@ -50567,7 +51455,7 @@ var {
 // package.json
 var package_default = {
   name: "evil-omo",
-  version: "3.15.2",
+  version: "3.16.0",
   description: "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   main: "./dist/index.js",
   types: "dist/index.d.ts",
@@ -50626,8 +51514,8 @@ var package_default = {
     "@clack/prompts": "^0.11.0",
     "@code-yeongyu/comment-checker": "^0.7.0",
     "@modelcontextprotocol/sdk": "^1.25.2",
-    "@opencode-ai/plugin": "^1.2.24",
-    "@opencode-ai/sdk": "^1.2.24",
+    "@opencode-ai/plugin": "^1.4.0",
+    "@opencode-ai/sdk": "^1.4.0",
     commander: "^14.0.2",
     "detect-libc": "^2.0.0",
     diff: "^8.0.3",
@@ -50636,7 +51524,7 @@ var package_default = {
     picocolors: "^1.1.1",
     picomatch: "^4.0.2",
     "vscode-jsonrpc": "^8.2.0",
-    zod: "^4.1.8"
+    zod: "^4.3.0"
   },
   devDependencies: {
     "@types/js-yaml": "^4.0.9",
@@ -50645,21 +51533,19 @@ var package_default = {
     typescript: "^5.7.3"
   },
   optionalDependencies: {
-    "evil-omo-darwin-arm64": "3.15.2",
-    "evil-omo-darwin-x64": "3.15.2",
-    "evil-omo-darwin-x64-baseline": "3.15.2",
-    "evil-omo-linux-x64": "3.15.2",
-    "evil-omo-linux-x64-baseline": "3.15.2",
-    "evil-omo-linux-arm64": "3.15.2",
-    "evil-omo-linux-x64-musl": "3.15.2",
-    "evil-omo-linux-x64-musl-baseline": "3.15.2",
-    "evil-omo-linux-arm64-musl": "3.15.2",
-    "evil-omo-windows-x64": "3.15.2",
-    "evil-omo-windows-x64-baseline": "3.15.2"
-  },
-  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",
@@ -50668,8 +51554,9 @@ 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);
@@ -50816,6 +51703,56 @@ function detectedToInitialValues(detected) {
   };
 }
 
+// src/cli/doctor/constants.ts
+init_shared();
+var import_picocolors2 = __toESM(require_picocolors(), 1);
+var SYMBOLS2 = {
+  check: import_picocolors2.default.green("\u2713"),
+  cross: import_picocolors2.default.red("\u2717"),
+  warn: import_picocolors2.default.yellow("\u26A0"),
+  info: import_picocolors2.default.blue("\u2139"),
+  arrow: import_picocolors2.default.cyan("\u2192"),
+  bullet: import_picocolors2.default.dim("\u2022"),
+  skip: import_picocolors2.default.dim("\u25CB")
+};
+var STATUS_COLORS = {
+  pass: import_picocolors2.default.green,
+  fail: import_picocolors2.default.red,
+  warn: import_picocolors2.default.yellow,
+  skip: import_picocolors2.default.dim
+};
+var CHECK_IDS = {
+  SYSTEM: "system",
+  CONFIG: "config",
+  TOOLS: "tools",
+  MODELS: "models"
+};
+var CHECK_NAMES = {
+  [CHECK_IDS.SYSTEM]: "System",
+  [CHECK_IDS.CONFIG]: "Configuration",
+  [CHECK_IDS.TOOLS]: "Tools",
+  [CHECK_IDS.MODELS]: "Models"
+};
+var EXIT_CODES = {
+  SUCCESS: 0,
+  FAILURE: 1
+};
+var MIN_OPENCODE_VERSION = "1.4.0";
+var PACKAGE_NAME = PLUGIN_NAME;
+var OPENCODE_BINARIES2 = ["opencode", "opencode-desktop"];
+
+// src/cli/minimum-opencode-version.ts
+init_opencode_version();
+function getUnsupportedOpenCodeVersionMessage(openCodeVersion) {
+  if (!openCodeVersion) {
+    return null;
+  }
+  if (compareVersions(openCodeVersion, MIN_OPENCODE_VERSION) >= 0) {
+    return null;
+  }
+  return `Detected OpenCode ${openCodeVersion}, but ${MIN_OPENCODE_VERSION}+ is required. Update OpenCode, then rerun the installer.`;
+}
+
 // src/cli/cli-installer.ts
 async function runCliInstaller(args, version) {
   const validation = validateNonTuiArgs(args);
@@ -50826,7 +51763,7 @@ async function runCliInstaller(args, version) {
       console.log(`  ${SYMBOLS.bullet} ${err}`);
     }
     console.log();
-    printInfo("Usage: bunx evil-omo install --no-tui --claude=<no|yes|max20> --gemini=<no|yes> --copilot=<no|yes>");
+    printInfo(`Usage: bunx ${PLUGIN_NAME} install --no-tui --claude=<no|yes|max20> --gemini=<no|yes> --copilot=<no|yes>`);
     console.log();
     return 1;
   }
@@ -50837,65 +51774,60 @@ async function runCliInstaller(args, version) {
   let step = 1;
   printStep(step++, totalSteps, "Checking OpenCode installation...");
   const installed = await isOpenCodeInstalled();
-  const openCodeVersion = await getOpenCodeVersion();
+  const openCodeVersion = await getOpenCodeVersion2();
   if (!installed) {
     printWarning("OpenCode binary not found. Plugin will be configured, but you'll need to install OpenCode to use it.");
     printInfo("Visit https://opencode.ai/docs for installation instructions");
   } else {
     printSuccess(`OpenCode ${openCodeVersion ?? ""} detected`);
+    const unsupportedVersionMessage = getUnsupportedOpenCodeVersionMessage(openCodeVersion);
+    if (unsupportedVersionMessage) {
+      printWarning(unsupportedVersionMessage);
+      return 1;
+    }
   }
   if (isUpdate) {
     const initial = detectedToInitialValues(detected);
     printInfo(`Current config: Claude=${initial.claude}, Gemini=${initial.gemini}`);
   }
   const config = argsToConfig(args);
-  printStep(step++, totalSteps, "Adding evil-omo plugin...");
+  printStep(step++, totalSteps, `Adding ${PLUGIN_NAME} plugin...`);
   const pluginResult = await addPluginToOpenCodeConfig(version);
   if (!pluginResult.success) {
     printError(`Failed: ${pluginResult.error}`);
     return 1;
   }
-  printSuccess(`Plugin ${isUpdate ? "verified" : "added"} ${SYMBOLS.arrow} ${import_picocolors2.default.dim(pluginResult.configPath)}`);
-  printStep(step++, totalSteps, "Writing evil-omo configuration...");
+  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.
-` + `All features work like magic\u2014parallel agents, background tasks,
+  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;
 }
@@ -51290,7 +52222,7 @@ class LD extends x {
 }
 
 // node_modules/@clack/prompts/dist/index.mjs
-var import_picocolors3 = __toESM(require_picocolors(), 1);
+var import_picocolors4 = __toESM(require_picocolors(), 1);
 var import_sisteransi2 = __toESM(require_src(), 1);
 import y2 from "process";
 function ce() {
@@ -51323,13 +52255,13 @@ var b2 = (t) => {
   switch (t) {
     case "initial":
     case "active":
-      return import_picocolors3.default.cyan(le);
+      return import_picocolors4.default.cyan(le);
     case "cancel":
-      return import_picocolors3.default.red(L2);
+      return import_picocolors4.default.red(L2);
     case "error":
-      return import_picocolors3.default.yellow(W2);
+      return import_picocolors4.default.yellow(W2);
     case "submit":
-      return import_picocolors3.default.green(C);
+      return import_picocolors4.default.green(C);
   }
 };
 var G2 = (t) => {
@@ -51339,7 +52271,7 @@ var G2 = (t) => {
   const $2 = a < r2.length && l2 > 0, g2 = a < r2.length && l2 + a < r2.length;
   return r2.slice(l2, l2 + a).map((p2, v, f) => {
     const j2 = v === 0 && $2, E = v === f.length - 1 && g2;
-    return j2 || E ? import_picocolors3.default.dim("...") : i2(p2, v + l2 === n);
+    return j2 || E ? import_picocolors4.default.dim("...") : i2(p2, v + l2 === n);
   });
 };
 var ve = (t) => {
@@ -51347,29 +52279,29 @@ var ve = (t) => {
     const s = r2.label ?? String(r2.value);
     switch (i2) {
       case "selected":
-        return `${import_picocolors3.default.dim(s)}`;
+        return `${import_picocolors4.default.dim(s)}`;
       case "active":
-        return `${import_picocolors3.default.green(k2)} ${s} ${r2.hint ? import_picocolors3.default.dim(`(${r2.hint})`) : ""}`;
+        return `${import_picocolors4.default.green(k2)} ${s} ${r2.hint ? import_picocolors4.default.dim(`(${r2.hint})`) : ""}`;
       case "cancelled":
-        return `${import_picocolors3.default.strikethrough(import_picocolors3.default.dim(s))}`;
+        return `${import_picocolors4.default.strikethrough(import_picocolors4.default.dim(s))}`;
       default:
-        return `${import_picocolors3.default.dim(P2)} ${import_picocolors3.default.dim(s)}`;
+        return `${import_picocolors4.default.dim(P2)} ${import_picocolors4.default.dim(s)}`;
     }
   };
   return new LD({ options: t.options, initialValue: t.initialValue, render() {
-    const r2 = `${import_picocolors3.default.gray(o)}
+    const r2 = `${import_picocolors4.default.gray(o)}
 ${b2(this.state)}  ${t.message}
 `;
     switch (this.state) {
       case "submit":
-        return `${r2}${import_picocolors3.default.gray(o)}  ${n(this.options[this.cursor], "selected")}`;
+        return `${r2}${import_picocolors4.default.gray(o)}  ${n(this.options[this.cursor], "selected")}`;
       case "cancel":
-        return `${r2}${import_picocolors3.default.gray(o)}  ${n(this.options[this.cursor], "cancelled")}
-${import_picocolors3.default.gray(o)}`;
+        return `${r2}${import_picocolors4.default.gray(o)}  ${n(this.options[this.cursor], "cancelled")}
+${import_picocolors4.default.gray(o)}`;
       default:
-        return `${r2}${import_picocolors3.default.cyan(o)}  ${G2({ cursor: this.cursor, options: this.options, maxItems: t.maxItems, style: (i2, s) => n(i2, s ? "active" : "inactive") }).join(`
-${import_picocolors3.default.cyan(o)}  `)}
-${import_picocolors3.default.cyan(d2)}
+        return `${r2}${import_picocolors4.default.cyan(o)}  ${G2({ cursor: this.cursor, options: this.options, maxItems: t.maxItems, style: (i2, s) => n(i2, s ? "active" : "inactive") }).join(`
+${import_picocolors4.default.cyan(o)}  `)}
+${import_picocolors4.default.cyan(d2)}
 `;
     }
   } }).prompt();
@@ -51381,53 +52313,53 @@ ${t}
 `), i2 = S2(n).length, s = Math.max(r2.reduce((a, l2) => {
     const $2 = S2(l2);
     return $2.length > a ? $2.length : a;
-  }, 0), i2) + 2, c = r2.map((a) => `${import_picocolors3.default.gray(o)}  ${import_picocolors3.default.dim(a)}${" ".repeat(s - S2(a).length)}${import_picocolors3.default.gray(o)}`).join(`
+  }, 0), i2) + 2, c = r2.map((a) => `${import_picocolors4.default.gray(o)}  ${import_picocolors4.default.dim(a)}${" ".repeat(s - S2(a).length)}${import_picocolors4.default.gray(o)}`).join(`
 `);
-  process.stdout.write(`${import_picocolors3.default.gray(o)}
-${import_picocolors3.default.green(C)}  ${import_picocolors3.default.reset(n)} ${import_picocolors3.default.gray(_2.repeat(Math.max(s - i2 - 1, 1)) + me)}
+  process.stdout.write(`${import_picocolors4.default.gray(o)}
+${import_picocolors4.default.green(C)}  ${import_picocolors4.default.reset(n)} ${import_picocolors4.default.gray(_2.repeat(Math.max(s - i2 - 1, 1)) + me)}
 ${c}
-${import_picocolors3.default.gray(de + _2.repeat(s + 2) + pe)}
+${import_picocolors4.default.gray(de + _2.repeat(s + 2) + pe)}
 `);
 };
 var xe = (t = "") => {
-  process.stdout.write(`${import_picocolors3.default.gray(d2)}  ${import_picocolors3.default.red(t)}
+  process.stdout.write(`${import_picocolors4.default.gray(d2)}  ${import_picocolors4.default.red(t)}
 
 `);
 };
 var Ie = (t = "") => {
-  process.stdout.write(`${import_picocolors3.default.gray(ue)}  ${t}
+  process.stdout.write(`${import_picocolors4.default.gray(ue)}  ${t}
 `);
 };
 var Se = (t = "") => {
-  process.stdout.write(`${import_picocolors3.default.gray(o)}
-${import_picocolors3.default.gray(d2)}  ${t}
+  process.stdout.write(`${import_picocolors4.default.gray(o)}
+${import_picocolors4.default.gray(d2)}  ${t}
 
 `);
 };
-var M2 = { message: (t = "", { symbol: n = import_picocolors3.default.gray(o) } = {}) => {
-  const r2 = [`${import_picocolors3.default.gray(o)}`];
+var M2 = { message: (t = "", { symbol: n = import_picocolors4.default.gray(o) } = {}) => {
+  const r2 = [`${import_picocolors4.default.gray(o)}`];
   if (t) {
     const [i2, ...s] = t.split(`
 `);
-    r2.push(`${n}  ${i2}`, ...s.map((c) => `${import_picocolors3.default.gray(o)}  ${c}`));
+    r2.push(`${n}  ${i2}`, ...s.map((c) => `${import_picocolors4.default.gray(o)}  ${c}`));
   }
   process.stdout.write(`${r2.join(`
 `)}
 `);
 }, info: (t) => {
-  M2.message(t, { symbol: import_picocolors3.default.blue(q) });
+  M2.message(t, { symbol: import_picocolors4.default.blue(q) });
 }, success: (t) => {
-  M2.message(t, { symbol: import_picocolors3.default.green(D) });
+  M2.message(t, { symbol: import_picocolors4.default.green(D) });
 }, step: (t) => {
-  M2.message(t, { symbol: import_picocolors3.default.green(C) });
+  M2.message(t, { symbol: import_picocolors4.default.green(C) });
 }, warn: (t) => {
-  M2.message(t, { symbol: import_picocolors3.default.yellow(U) });
+  M2.message(t, { symbol: import_picocolors4.default.yellow(U) });
 }, warning: (t) => {
   M2.warn(t);
 }, error: (t) => {
-  M2.message(t, { symbol: import_picocolors3.default.red(K2) });
+  M2.message(t, { symbol: import_picocolors4.default.red(K2) });
 } };
-var J2 = `${import_picocolors3.default.gray(o)}  `;
+var J2 = `${import_picocolors4.default.gray(o)}  `;
 var Y2 = ({ indicator: t = "dots" } = {}) => {
   const n = V2 ? ["\u25D2", "\u25D0", "\u25D3", "\u25D1"] : ["\u2022", "o", "O", "0"], r2 = V2 ? 80 : 120, i2 = process.env.CI === "true";
   let s, c, a = false, l2 = "", $2, g2 = performance.now();
@@ -51450,14 +52382,14 @@ var Y2 = ({ indicator: t = "dots" } = {}) => {
     const h2 = (performance.now() - m2) / 1000, w2 = Math.floor(h2 / 60), I2 = Math.floor(h2 % 60);
     return w2 > 0 ? `[${w2}m ${I2}s]` : `[${I2}s]`;
   }, H = (m2 = "") => {
-    a = true, s = fD(), l2 = R2(m2), g2 = performance.now(), process.stdout.write(`${import_picocolors3.default.gray(o)}
+    a = true, s = fD(), l2 = R2(m2), g2 = performance.now(), process.stdout.write(`${import_picocolors4.default.gray(o)}
 `);
     let h2 = 0, w2 = 0;
     j2(), c = setInterval(() => {
       if (i2 && l2 === $2)
         return;
       B2(), $2 = l2;
-      const I2 = import_picocolors3.default.magenta(n[h2]);
+      const I2 = import_picocolors4.default.magenta(n[h2]);
       if (i2)
         process.stdout.write(`${I2}  ${l2}...`);
       else if (t === "timer")
@@ -51470,7 +52402,7 @@ var Y2 = ({ indicator: t = "dots" } = {}) => {
     }, r2);
   }, N2 = (m2 = "", h2 = 0) => {
     a = false, clearInterval(c), B2();
-    const w2 = h2 === 0 ? import_picocolors3.default.green(C) : h2 === 1 ? import_picocolors3.default.red(L2) : import_picocolors3.default.red(W2);
+    const w2 = h2 === 0 ? import_picocolors4.default.green(C) : h2 === 1 ? import_picocolors4.default.red(L2) : import_picocolors4.default.red(W2);
     l2 = R2(m2 ?? l2), t === "timer" ? process.stdout.write(`${w2}  ${l2} ${O2(g2)}
 `) : process.stdout.write(`${w2}  ${l2}
 `), E(), s();
@@ -51481,8 +52413,9 @@ 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) {
@@ -51603,7 +52536,7 @@ async function runTuiInstaller(args, version) {
   }
   const detected = detectCurrentConfig();
   const isUpdate = detected.isInstalled;
-  Ie(import_picocolors4.default.bgMagenta(import_picocolors4.default.white(isUpdate ? " oMoMoMoMo... Update " : " oMoMoMoMo... ")));
+  Ie(import_picocolors5.default.bgMagenta(import_picocolors5.default.white(isUpdate ? " oMoMoMoMo... Update " : " oMoMoMoMo... ")));
   if (isUpdate) {
     const initial = detectedToInitialValues(detected);
     M2.info(`Existing configuration detected: Claude=${initial.claude}, Gemini=${initial.gemini}`);
@@ -51611,70 +52544,67 @@ async function runTuiInstaller(args, version) {
   const spinner = Y2();
   spinner.start("Checking OpenCode installation");
   const installed = await isOpenCodeInstalled();
-  const openCodeVersion = await getOpenCodeVersion();
+  const openCodeVersion = await getOpenCodeVersion2();
   if (!installed) {
-    spinner.stop(`OpenCode binary not found ${import_picocolors4.default.yellow("[!]")}`);
+    spinner.stop(`OpenCode binary not found ${import_picocolors5.default.yellow("[!]")}`);
     M2.warn("OpenCode binary not found. Plugin will be configured, but you'll need to install OpenCode to use it.");
     Me("Visit https://opencode.ai/docs for installation instructions", "Installation Guide");
   } else {
-    spinner.stop(`OpenCode ${openCodeVersion ?? "installed"} ${import_picocolors4.default.green("[OK]")}`);
+    spinner.stop(`OpenCode ${openCodeVersion ?? "installed"} ${import_picocolors5.default.green("[OK]")}`);
+    const unsupportedVersionMessage = getUnsupportedOpenCodeVersionMessage(openCodeVersion);
+    if (unsupportedVersionMessage) {
+      M2.warn(unsupportedVersionMessage);
+      Se(import_picocolors5.default.red("Installation blocked."));
+      return 1;
+    }
   }
   const config = await promptInstallConfig(detected);
   if (!config)
     return 1;
-  spinner.start("Adding evil-omo to OpenCode config");
+  spinner.start(`Adding ${PLUGIN_NAME} to OpenCode config`);
   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.start("Writing evil-omo configuration");
+  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.
-` + `All features work like magic\u2014parallel agents, background tasks,
+  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}`);
     }
@@ -51690,7 +52620,7 @@ async function install(args) {
 }
 
 // src/cli/run/runner.ts
-var import_picocolors14 = __toESM(require_picocolors(), 1);
+var import_picocolors15 = __toESM(require_picocolors(), 1);
 
 // src/cli/run/event-state.ts
 function createEventState() {
@@ -51724,7 +52654,7 @@ function createEventState() {
   };
 }
 // src/cli/run/event-formatting.ts
-var import_picocolors5 = __toESM(require_picocolors(), 1);
+var import_picocolors6 = __toESM(require_picocolors(), 1);
 function serializeError(error) {
   if (!error)
     return "Unknown error";
@@ -51768,10 +52698,10 @@ function getSessionTag(ctx, payload) {
   const sessionID = props?.sessionID ?? props?.sessionId ?? info?.sessionID ?? info?.sessionId ?? part?.sessionID ?? part?.sessionId;
   const isMainSession = sessionID === ctx.sessionID;
   if (isMainSession)
-    return import_picocolors5.default.green("[MAIN]");
+    return import_picocolors6.default.green("[MAIN]");
   if (sessionID)
-    return import_picocolors5.default.yellow(`[${String(sessionID).slice(0, 8)}]`);
-  return import_picocolors5.default.dim("[system]");
+    return import_picocolors6.default.yellow(`[${String(sessionID).slice(0, 8)}]`);
+  return import_picocolors6.default.dim("[system]");
 }
 function logEventVerbose(ctx, payload) {
   const sessionTag = getSessionTag(ctx, payload);
@@ -51780,7 +52710,7 @@ function logEventVerbose(ctx, payload) {
     case "session.idle":
     case "session.status": {
       const status = props?.status?.type ?? "idle";
-      console.error(import_picocolors5.default.dim(`${sessionTag} ${payload.type}: ${status}`));
+      console.error(import_picocolors6.default.dim(`${sessionTag} ${payload.type}: ${status}`));
       break;
     }
     case "message.part.updated": {
@@ -51788,10 +52718,10 @@ function logEventVerbose(ctx, payload) {
       const part = partProps?.part;
       if (part?.type === "tool") {
         const status = part.state?.status ?? "unknown";
-        console.error(import_picocolors5.default.dim(`${sessionTag} message.part (tool): ${part.tool ?? part.name ?? "?"} [${status}]`));
+        console.error(import_picocolors6.default.dim(`${sessionTag} message.part (tool): ${part.tool ?? part.name ?? "?"} [${status}]`));
       } else if (part?.type === "text" && part.text) {
         const preview = part.text.slice(0, 80).replace(/\n/g, "\\n");
-        console.error(import_picocolors5.default.dim(`${sessionTag} message.part (text): "${preview}${part.text.length > 80 ? "..." : ""}"`));
+        console.error(import_picocolors6.default.dim(`${sessionTag} message.part (text): "${preview}${part.text.length > 80 ? "..." : ""}"`));
       }
       break;
     }
@@ -51800,7 +52730,7 @@ function logEventVerbose(ctx, payload) {
       const field = deltaProps?.field ?? "unknown";
       const delta = deltaProps?.delta ?? "";
       const preview = delta.slice(0, 80).replace(/\n/g, "\\n");
-      console.error(import_picocolors5.default.dim(`${sessionTag} message.part.delta (${field}): "${preview}${delta.length > 80 ? "..." : ""}"`));
+      console.error(import_picocolors6.default.dim(`${sessionTag} message.part.delta (${field}): "${preview}${delta.length > 80 ? "..." : ""}"`));
       break;
     }
     case "message.updated": {
@@ -51809,7 +52739,7 @@ function logEventVerbose(ctx, payload) {
       const model = msgProps?.info?.modelID;
       const agent = msgProps?.info?.agent;
       const details = [role, agent, model].filter(Boolean).join(", ");
-      console.error(import_picocolors5.default.dim(`${sessionTag} message.updated (${details})`));
+      console.error(import_picocolors6.default.dim(`${sessionTag} message.updated (${details})`));
       break;
     }
     case "tool.execute": {
@@ -51827,32 +52757,32 @@ function logEventVerbose(ctx, payload) {
         }
       }
       const inputPreview = inputStr.slice(0, 150);
-      console.error(import_picocolors5.default.cyan(`${sessionTag} TOOL.EXECUTE: ${import_picocolors5.default.bold(toolName)}`));
-      console.error(import_picocolors5.default.dim(`   input: ${inputPreview}${inputStr.length >= 150 ? "..." : ""}`));
+      console.error(import_picocolors6.default.cyan(`${sessionTag} TOOL.EXECUTE: ${import_picocolors6.default.bold(toolName)}`));
+      console.error(import_picocolors6.default.dim(`   input: ${inputPreview}${inputStr.length >= 150 ? "..." : ""}`));
       break;
     }
     case "tool.result": {
       const resultProps = props;
       const output = resultProps?.output ?? "";
       const preview = output.slice(0, 200).replace(/\n/g, "\\n");
-      console.error(import_picocolors5.default.green(`${sessionTag} TOOL.RESULT: "${preview}${output.length > 200 ? "..." : ""}"`));
+      console.error(import_picocolors6.default.green(`${sessionTag} TOOL.RESULT: "${preview}${output.length > 200 ? "..." : ""}"`));
       break;
     }
     case "session.error": {
       const errorProps = props;
       const errorMsg = serializeError(errorProps?.error);
-      console.error(import_picocolors5.default.red(`${sessionTag} SESSION.ERROR: ${errorMsg}`));
+      console.error(import_picocolors6.default.red(`${sessionTag} SESSION.ERROR: ${errorMsg}`));
       break;
     }
     default:
-      console.error(import_picocolors5.default.dim(`${sessionTag} ${payload.type}`));
+      console.error(import_picocolors6.default.dim(`${sessionTag} ${payload.type}`));
   }
 }
 // src/cli/run/event-stream-processor.ts
-var import_picocolors8 = __toESM(require_picocolors(), 1);
+var import_picocolors9 = __toESM(require_picocolors(), 1);
 
 // src/cli/run/event-handlers.ts
-var import_picocolors7 = __toESM(require_picocolors(), 1);
+var import_picocolors8 = __toESM(require_picocolors(), 1);
 
 // src/cli/run/tool-input-preview.ts
 function formatToolHeader(toolName, input) {
@@ -51988,14 +52918,14 @@ var displayChars = {
 };
 
 // src/cli/run/output-renderer.ts
-var import_picocolors6 = __toESM(require_picocolors(), 1);
+var import_picocolors7 = __toESM(require_picocolors(), 1);
 function renderAgentHeader(agent, model, variant, agentColorsByName) {
   if (!agent && !model)
     return;
-  const agentLabel = agent ? import_picocolors6.default.bold(colorizeWithProfileColor(agent, agentColorsByName[agent])) : "";
+  const agentLabel = agent ? import_picocolors7.default.bold(colorizeWithProfileColor(agent, agentColorsByName[agent])) : "";
   const modelBase = model ?? "";
   const variantSuffix = variant ? ` (${variant})` : "";
-  const modelLabel = model ? import_picocolors6.default.dim(`${modelBase}${variantSuffix}`) : "";
+  const modelLabel = model ? import_picocolors7.default.dim(`${modelBase}${variantSuffix}`) : "";
   process.stdout.write(`
 `);
   if (modelLabel) {
@@ -52003,7 +52933,7 @@ function renderAgentHeader(agent, model, variant, agentColorsByName) {
 `);
   }
   if (agentLabel) {
-    process.stdout.write(`  ${import_picocolors6.default.dim("\u2514\u2500")} ${agentLabel}  
+    process.stdout.write(`  ${import_picocolors7.default.dim("\u2514\u2500")} ${agentLabel}  
 `);
   }
   process.stdout.write(`
@@ -52011,7 +52941,7 @@ function renderAgentHeader(agent, model, variant, agentColorsByName) {
 }
 function openThinkBlock() {
   process.stdout.write(`
-  ${import_picocolors6.default.dim("\u2503  Thinking:")} `);
+  ${import_picocolors7.default.dim("\u2503  Thinking:")} `);
 }
 function closeThinkBlock() {
   process.stdout.write(`  
@@ -52045,10 +52975,10 @@ function writePaddedText(text, atLineStart) {
 }
 function colorizeWithProfileColor(text, hexColor) {
   if (!hexColor)
-    return import_picocolors6.default.magenta(text);
+    return import_picocolors7.default.magenta(text);
   const rgb = parseHexColor(hexColor);
   if (!rgb)
-    return import_picocolors6.default.magenta(text);
+    return import_picocolors7.default.magenta(text);
   const [r2, g2, b3] = rgb;
   return `\x1B[38;2;${r2};${g2};${b3}m${text}\x1B[39m`;
 }
@@ -52088,7 +53018,7 @@ function renderCompletionMetaLine(state, messageID) {
   const agent = state.currentAgent ?? "assistant";
   const model = state.currentModel ?? "unknown-model";
   const variant = state.currentVariant ? ` (${state.currentVariant})` : "";
-  process.stdout.write(import_picocolors7.default.dim(`
+  process.stdout.write(import_picocolors8.default.dim(`
   ${displayChars.treeEnd} ${agent} \xB7 ${model}${variant} \xB7 ${elapsedSec}s  
 `));
   state.completionMetaPrintedByMessageId[messageID] = true;
@@ -52122,7 +53052,7 @@ function handleSessionError(ctx, payload, state) {
   if (getSessionId(props) === ctx.sessionID) {
     state.mainSessionError = true;
     state.lastError = serializeError(props?.error);
-    console.error(import_picocolors7.default.red(`
+    console.error(import_picocolors8.default.red(`
 [session.error] ${state.lastError}`));
   }
 }
@@ -52150,7 +53080,7 @@ function handleMessagePartUpdated(ctx, payload, state) {
     const newText = reasoningText.slice(state.lastReasoningText.length);
     if (newText) {
       const padded = writePaddedText(newText, state.thinkingAtLineStart);
-      process.stdout.write(import_picocolors7.default.dim(padded.output));
+      process.stdout.write(import_picocolors8.default.dim(padded.output));
       state.thinkingAtLineStart = padded.atLineStart;
       state.hasReceivedMeaningfulWork = true;
     }
@@ -52197,7 +53127,7 @@ function handleMessagePartDelta(ctx, payload, state) {
   if (partType === "reasoning") {
     ensureThinkBlockOpen(state);
     const padded2 = writePaddedText(delta, state.thinkingAtLineStart);
-    process.stdout.write(import_picocolors7.default.dim(padded2.output));
+    process.stdout.write(import_picocolors8.default.dim(padded2.output));
     state.thinkingAtLineStart = padded2.atLineStart;
     state.lastReasoningText += delta;
     state.hasReceivedMeaningfulWork = true;
@@ -52218,10 +53148,10 @@ function handleToolPart(_ctx, part, state) {
       return;
     state.currentTool = toolName;
     const header = formatToolHeader(toolName, part.state?.input ?? {});
-    const suffix = header.description ? ` ${import_picocolors7.default.dim(header.description)}` : "";
+    const suffix = header.description ? ` ${import_picocolors8.default.dim(header.description)}` : "";
     state.hasReceivedMeaningfulWork = true;
     process.stdout.write(`
-  ${import_picocolors7.default.cyan(header.icon)} ${import_picocolors7.default.bold(header.title)}${suffix}  
+  ${import_picocolors8.default.cyan(header.icon)} ${import_picocolors8.default.bold(header.title)}${suffix}  
 `);
   }
   if (status === "completed" || status === "error") {
@@ -52229,10 +53159,10 @@ function handleToolPart(_ctx, part, state) {
       return;
     const output = part.state?.output || "";
     if (output.trim()) {
-      process.stdout.write(import_picocolors7.default.dim(`  ${displayChars.treeEnd} output  
+      process.stdout.write(import_picocolors8.default.dim(`  ${displayChars.treeEnd} output  
 `));
       const padded = writePaddedText(output, true);
-      process.stdout.write(import_picocolors7.default.dim(padded.output + (padded.atLineStart ? "" : "  ")));
+      process.stdout.write(import_picocolors8.default.dim(padded.output + (padded.atLineStart ? "" : "  ")));
       process.stdout.write(`
 `);
     }
@@ -52294,10 +53224,10 @@ function handleToolExecute(ctx, payload, state) {
   const toolName = props?.name || "unknown";
   state.currentTool = toolName;
   const header = formatToolHeader(toolName, props?.input ?? {});
-  const suffix = header.description ? ` ${import_picocolors7.default.dim(header.description)}` : "";
+  const suffix = header.description ? ` ${import_picocolors8.default.dim(header.description)}` : "";
   state.hasReceivedMeaningfulWork = true;
   process.stdout.write(`
-  ${import_picocolors7.default.cyan(header.icon)} ${import_picocolors7.default.bold(header.title)}${suffix}  
+  ${import_picocolors8.default.cyan(header.icon)} ${import_picocolors8.default.bold(header.title)}${suffix}  
 `);
 }
 function handleToolResult(ctx, payload, state) {
@@ -52311,10 +53241,10 @@ function handleToolResult(ctx, payload, state) {
     return;
   const output = props?.output || "";
   if (output.trim()) {
-    process.stdout.write(import_picocolors7.default.dim(`  ${displayChars.treeEnd} output  
+    process.stdout.write(import_picocolors8.default.dim(`  ${displayChars.treeEnd} output  
 `));
     const padded = writePaddedText(output, true);
-    process.stdout.write(import_picocolors7.default.dim(padded.output + (padded.atLineStart ? "" : "  ")));
+    process.stdout.write(import_picocolors8.default.dim(padded.output + (padded.atLineStart ? "" : "  ")));
     process.stdout.write(`
 `);
   }
@@ -52363,7 +53293,7 @@ async function processEvents(ctx, stream, state) {
       const payload = event;
       if (!payload?.type) {
         if (ctx.verbose) {
-          console.error(import_picocolors8.default.dim(`[event] no type: ${JSON.stringify(event)}`));
+          console.error(import_picocolors9.default.dim(`[event] no type: ${JSON.stringify(event)}`));
         }
         continue;
       }
@@ -52381,7 +53311,7 @@ async function processEvents(ctx, stream, state) {
       handleToolResult(ctx, payload, state);
       handleTuiToast(ctx, payload, state);
     } catch (err) {
-      console.error(import_picocolors8.default.red(`[event error] ${err}`));
+      console.error(import_picocolors9.default.red(`[event error] ${err}`));
     }
   }
 }
@@ -66618,7 +67548,7 @@ var createSseClient = ({ onSseError, onSseEvent, responseTransformer, responseVa
         if (!response.body)
           throw new Error("No body in SSE response");
         const reader = response.body.pipeThrough(new TextDecoderStream).getReader();
-        let buffer = "";
+        let buffer2 = "";
         const abortHandler = () => {
           try {
             reader.cancel();
@@ -66630,11 +67560,11 @@ var createSseClient = ({ onSseError, onSseEvent, responseTransformer, responseVa
             const { done, value } = await reader.read();
             if (done)
               break;
-            buffer += value;
-            const chunks = buffer.split(`
+            buffer2 += value;
+            const chunks = buffer2.split(`
 
 `);
-            buffer = chunks.pop() ?? "";
+            buffer2 = chunks.pop() ?? "";
             for (const chunk of chunks) {
               const lines = chunk.split(`
 `);
@@ -67934,6 +68864,31 @@ class OpencodeClient extends _HeyApiClient {
 }
 
 // node_modules/@opencode-ai/sdk/dist/client.js
+function pick2(value, fallback) {
+  if (!value)
+    return;
+  if (!fallback)
+    return value;
+  if (value === fallback)
+    return fallback;
+  if (value === encodeURIComponent(fallback))
+    return fallback;
+  return value;
+}
+function rewrite(request, directory) {
+  if (request.method !== "GET" && request.method !== "HEAD")
+    return request;
+  const value = pick2(request.headers.get("x-opencode-directory"), directory);
+  if (!value)
+    return request;
+  const url2 = new URL(request.url);
+  if (!url2.searchParams.has("directory")) {
+    url2.searchParams.set("directory", value);
+  }
+  const next = new Request(url2, request);
+  next.headers.delete("x-opencode-directory");
+  return next;
+}
 function createOpencodeClient(config2) {
   if (!config2?.fetch) {
     const customFetch = (req) => {
@@ -67952,10 +68907,46 @@ function createOpencodeClient(config2) {
     };
   }
   const client2 = createClient(config2);
+  client2.interceptors.request.use((request) => rewrite(request, config2?.directory));
   return new OpencodeClient({ client: client2 });
 }
 // node_modules/@opencode-ai/sdk/dist/server.js
-import { spawn } from "child_process";
+var import_cross_spawn = __toESM(require_cross_spawn(), 1);
+
+// node_modules/@opencode-ai/sdk/dist/process.js
+import { spawnSync } from "child_process";
+function stop(proc) {
+  if (proc.exitCode !== null || proc.signalCode !== null)
+    return;
+  if (process.platform === "win32" && proc.pid) {
+    const out = spawnSync("taskkill", ["/pid", String(proc.pid), "/T", "/F"], { windowsHide: true });
+    if (!out.error && out.status === 0)
+      return;
+  }
+  proc.kill();
+}
+function bindAbort(proc, signal, onAbort) {
+  if (!signal)
+    return () => {};
+  const abort = () => {
+    clear();
+    stop(proc);
+    onAbort?.();
+  };
+  const clear = () => {
+    signal.removeEventListener("abort", abort);
+    proc.off("exit", clear);
+    proc.off("error", clear);
+  };
+  signal.addEventListener("abort", abort, { once: true });
+  proc.on("exit", clear);
+  proc.on("error", clear);
+  if (signal.aborted)
+    abort();
+  return clear;
+}
+
+// node_modules/@opencode-ai/sdk/dist/server.js
 async function createOpencodeServer(options) {
   options = Object.assign({
     hostname: "127.0.0.1",
@@ -67965,19 +68956,24 @@ async function createOpencodeServer(options) {
   const args = [`serve`, `--hostname=${options.hostname}`, `--port=${options.port}`];
   if (options.config?.logLevel)
     args.push(`--log-level=${options.config.logLevel}`);
-  const proc = spawn(`opencode`, args, {
-    signal: options.signal,
+  const proc = import_cross_spawn.default(`opencode`, args, {
     env: {
       ...process.env,
       OPENCODE_CONFIG_CONTENT: JSON.stringify(options.config ?? {})
     }
   });
+  let clear = () => {};
   const url2 = await new Promise((resolve2, reject) => {
     const id = setTimeout(() => {
+      clear();
+      stop(proc);
       reject(new Error(`Timeout waiting for server to start after ${options.timeout}ms`));
     }, options.timeout);
     let output = "";
+    let resolved = false;
     proc.stdout?.on("data", (chunk) => {
+      if (resolved)
+        return;
       output += chunk.toString();
       const lines = output.split(`
 `);
@@ -67985,9 +68981,14 @@ async function createOpencodeServer(options) {
         if (line.startsWith("opencode server listening")) {
           const match = line.match(/on\s+(https?:\/\/[^\s]+)/);
           if (!match) {
-            throw new Error(`Failed to parse server url from output: ${line}`);
+            clear();
+            stop(proc);
+            clearTimeout(id);
+            reject(new Error(`Failed to parse server url from output: ${line}`));
+            return;
           }
           clearTimeout(id);
+          resolved = true;
           resolve2(match[1]);
           return;
         }
@@ -68009,17 +69010,16 @@ Server output: ${output}`;
       clearTimeout(id);
       reject(error48);
     });
-    if (options.signal) {
-      options.signal.addEventListener("abort", () => {
-        clearTimeout(id);
-        reject(new Error("Aborted"));
-      });
-    }
+    clear = bindAbort(proc, options.signal, () => {
+      clearTimeout(id);
+      reject(options.signal?.reason);
+    });
   });
   return {
     url: url2,
     close() {
-      proc.kill();
+      clear();
+      stop(proc);
     }
   };
 }
@@ -68039,11 +69039,11 @@ async function createOpencode(options) {
 
 // src/cli/run/server-connection.ts
 init_port_utils();
-var import_picocolors9 = __toESM(require_picocolors(), 1);
+var import_picocolors10 = __toESM(require_picocolors(), 1);
 
 // src/cli/run/opencode-binary-resolver.ts
 init_spawn_with_windows_hide();
-import { delimiter, dirname, join as join10 } 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) {
@@ -68066,7 +69066,7 @@ function collectCandidateBinaryPaths(pathEnv, which = Bun.which, platform = proc
   }
   for (const entry of (pathEnv ?? "").split(delimiter).filter(Boolean)) {
     for (const command of commandCandidates) {
-      addCandidate(join10(entry, command));
+      addCandidate(join14(entry, command));
     }
   }
   return candidates;
@@ -68093,7 +69093,7 @@ async function findWorkingOpencodeBinary(pathEnv = process.env.PATH, probe = can
   return null;
 }
 function buildPathWithBinaryFirst(pathEnv, binaryPath) {
-  const preferredDir = dirname(binaryPath);
+  const preferredDir = dirname2(binaryPath);
   const existing = (pathEnv ?? "").split(delimiter).filter((entry) => entry.length > 0 && entry !== preferredDir);
   return [preferredDir, ...existing].join(delimiter);
 }
@@ -68127,13 +69127,13 @@ function isPortRangeExhausted(error48) {
 async function startServer(options) {
   const { signal, port } = options;
   const { client: client3, server: server2 } = await withWorkingOpencodePath(() => createOpencode({ signal, port, hostname: "127.0.0.1" }));
-  console.log(import_picocolors9.default.dim("Server listening at"), import_picocolors9.default.cyan(server2.url));
+  console.log(import_picocolors10.default.dim("Server listening at"), import_picocolors10.default.cyan(server2.url));
   return { client: client3, cleanup: () => server2.close() };
 }
 async function createServerConnection(options) {
   const { port, attach, signal } = options;
   if (attach !== undefined) {
-    console.log(import_picocolors9.default.dim("Attaching to existing server at"), import_picocolors9.default.cyan(attach));
+    console.log(import_picocolors10.default.dim("Attaching to existing server at"), import_picocolors10.default.cyan(attach));
     const client3 = createOpencodeClient({ baseUrl: attach });
     return { client: client3, cleanup: () => {} };
   }
@@ -68143,7 +69143,7 @@ async function createServerConnection(options) {
     }
     const available = await isPortAvailable(port, "127.0.0.1");
     if (available) {
-      console.log(import_picocolors9.default.dim("Starting server on port"), import_picocolors9.default.cyan(port.toString()));
+      console.log(import_picocolors10.default.dim("Starting server on port"), import_picocolors10.default.cyan(port.toString()));
       try {
         return await startServer({ signal, port });
       } catch (error48) {
@@ -68154,12 +69154,12 @@ async function createServerConnection(options) {
         if (stillAvailable) {
           throw error48;
         }
-        console.log(import_picocolors9.default.dim("Port"), import_picocolors9.default.cyan(port.toString()), import_picocolors9.default.dim("became occupied, attaching to existing server"));
+        console.log(import_picocolors10.default.dim("Port"), import_picocolors10.default.cyan(port.toString()), import_picocolors10.default.dim("became occupied, attaching to existing server"));
         const client4 = createOpencodeClient({ baseUrl: `http://127.0.0.1:${port}` });
         return { client: client4, cleanup: () => {} };
       }
     }
-    console.log(import_picocolors9.default.dim("Port"), import_picocolors9.default.cyan(port.toString()), import_picocolors9.default.dim("is occupied, attaching to existing server"));
+    console.log(import_picocolors10.default.dim("Port"), import_picocolors10.default.cyan(port.toString()), import_picocolors10.default.dim("is occupied, attaching to existing server"));
     const client3 = createOpencodeClient({ baseUrl: `http://127.0.0.1:${port}` });
     return { client: client3, cleanup: () => {} };
   }
@@ -68177,14 +69177,14 @@ async function createServerConnection(options) {
     if (defaultPortIsAvailable) {
       throw error48;
     }
-    console.log(import_picocolors9.default.dim("Port range exhausted, attaching to existing server on"), import_picocolors9.default.cyan(DEFAULT_SERVER_PORT.toString()));
+    console.log(import_picocolors10.default.dim("Port range exhausted, attaching to existing server on"), import_picocolors10.default.cyan(DEFAULT_SERVER_PORT.toString()));
     const client3 = createOpencodeClient({ baseUrl: `http://127.0.0.1:${DEFAULT_SERVER_PORT}` });
     return { client: client3, cleanup: () => {} };
   }
   if (wasAutoSelected) {
-    console.log(import_picocolors9.default.dim("Auto-selected port"), import_picocolors9.default.cyan(selectedPort.toString()));
+    console.log(import_picocolors10.default.dim("Auto-selected port"), import_picocolors10.default.cyan(selectedPort.toString()));
   } else {
-    console.log(import_picocolors9.default.dim("Starting server on port"), import_picocolors9.default.cyan(selectedPort.toString()));
+    console.log(import_picocolors10.default.dim("Starting server on port"), import_picocolors10.default.cyan(selectedPort.toString()));
   }
   try {
     return await startServer({ signal, port: selectedPort });
@@ -68193,14 +69193,13 @@ async function createServerConnection(options) {
       throw error48;
     }
     const { port: retryPort } = await getAvailableServerPort(selectedPort + 1, "127.0.0.1");
-    console.log(import_picocolors9.default.dim("Retrying server start on port"), import_picocolors9.default.cyan(retryPort.toString()));
+    console.log(import_picocolors10.default.dim("Retrying server start on port"), import_picocolors10.default.cyan(retryPort.toString()));
     return await startServer({ signal, port: retryPort });
   }
 }
 
 // src/cli/run/session-resolver.ts
-var import_picocolors10 = __toESM(require_picocolors(), 1);
-init_plugin_identity();
+var import_picocolors11 = __toESM(require_picocolors(), 1);
 var SESSION_CREATE_MAX_RETRIES = 3;
 var SESSION_CREATE_RETRY_DELAY_MS = 1000;
 async function resolveSession(options) {
@@ -68218,7 +69217,7 @@ async function resolveSession(options) {
   for (let attempt = 1;attempt <= SESSION_CREATE_MAX_RETRIES; attempt++) {
     const res = await client3.session.create({
       body: {
-        title: `${PLUGIN_NAME} run`,
+        title: "evil-omo run",
         permission: [
           { permission: "question", action: "deny", pattern: "*" }
         ]
@@ -68226,11 +69225,11 @@ async function resolveSession(options) {
       query: { directory }
     });
     if (res.error) {
-      console.error(import_picocolors10.default.yellow(`Session create attempt ${attempt}/${SESSION_CREATE_MAX_RETRIES} failed:`));
-      console.error(import_picocolors10.default.dim(`  Error: ${serializeError(res.error)}`));
+      console.error(import_picocolors11.default.yellow(`Session create attempt ${attempt}/${SESSION_CREATE_MAX_RETRIES} failed:`));
+      console.error(import_picocolors11.default.dim(`  Error: ${serializeError(res.error)}`));
       if (attempt < SESSION_CREATE_MAX_RETRIES) {
         const delay = SESSION_CREATE_RETRY_DELAY_MS * attempt;
-        console.log(import_picocolors10.default.dim(`  Retrying in ${delay}ms...`));
+        console.log(import_picocolors11.default.dim(`  Retrying in ${delay}ms...`));
         await new Promise((resolve2) => setTimeout(resolve2, delay));
       }
       continue;
@@ -68238,10 +69237,10 @@ async function resolveSession(options) {
     if (res.data?.id) {
       return res.data.id;
     }
-    console.error(import_picocolors10.default.yellow(`Session create attempt ${attempt}/${SESSION_CREATE_MAX_RETRIES}: No session ID returned`));
+    console.error(import_picocolors11.default.yellow(`Session create attempt ${attempt}/${SESSION_CREATE_MAX_RETRIES}: No session ID returned`));
     if (attempt < SESSION_CREATE_MAX_RETRIES) {
       const delay = SESSION_CREATE_RETRY_DELAY_MS * attempt;
-      console.log(import_picocolors10.default.dim(`  Retrying in ${delay}ms...`));
+      console.log(import_picocolors11.default.dim(`  Retrying in ${delay}ms...`));
       await new Promise((resolve2) => setTimeout(resolve2, delay));
     }
   }
@@ -68359,7 +69358,7 @@ async function executeOnCompleteHook(options) {
 
 // src/cli/run/agent-resolver.ts
 init_agent_display_names();
-var import_picocolors11 = __toESM(require_picocolors(), 1);
+var import_picocolors12 = __toESM(require_picocolors(), 1);
 var CORE_AGENT_ORDER = ["sisyphus", "hephaestus", "prometheus", "atlas"];
 var DEFAULT_AGENT = "sisyphus";
 var normalizeAgentName = (agent) => {
@@ -68404,10 +69403,10 @@ var resolveRunAgent = (options, pluginConfig, env = process.env) => {
     const fallbackName = getAgentDisplayName(fallback);
     const fallbackDisabled = isAgentDisabled(fallback, pluginConfig);
     if (fallbackDisabled) {
-      console.log(import_picocolors11.default.yellow(`Requested agent "${resolved.resolvedName}" is disabled and no enabled core agent was found. Proceeding with "${fallbackName}".`));
+      console.log(import_picocolors12.default.yellow(`Requested agent "${resolved.resolvedName}" is disabled and no enabled core agent was found. Proceeding with "${fallbackName}".`));
       return fallbackName;
     }
-    console.log(import_picocolors11.default.yellow(`Requested agent "${resolved.resolvedName}" is disabled. Falling back to "${fallbackName}".`));
+    console.log(import_picocolors12.default.yellow(`Requested agent "${resolved.resolvedName}" is disabled. Falling back to "${fallbackName}".`));
     return fallbackName;
   }
   return resolved.resolvedName;
@@ -68438,11 +69437,11 @@ function resolveRunModel(modelString) {
 }
 
 // src/cli/run/poll-for-completion.ts
-var import_picocolors13 = __toESM(require_picocolors(), 1);
+var import_picocolors14 = __toESM(require_picocolors(), 1);
 
 // src/cli/run/completion.ts
 init_shared();
-var import_picocolors12 = __toESM(require_picocolors(), 1);
+var import_picocolors13 = __toESM(require_picocolors(), 1);
 // src/features/boulder-state/constants.ts
 var BOULDER_DIR = ".sisyphus";
 var BOULDER_FILE = "boulder.json";
@@ -68450,19 +69449,19 @@ var BOULDER_STATE_PATH = `${BOULDER_DIR}/${BOULDER_FILE}`;
 var NOTEPAD_DIR = "notepads";
 var NOTEPAD_BASE_PATH = `${BOULDER_DIR}/${NOTEPAD_DIR}`;
 // src/features/boulder-state/storage.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync5, mkdirSync as mkdirSync3, readdirSync } from "fs";
-import { dirname as dirname2, join as join11, basename } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync10, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, readdirSync as readdirSync3 } from "fs";
+import { dirname as dirname3, join as join15, basename } from "path";
 var RESERVED_KEYS = new Set(["__proto__", "prototype", "constructor"]);
 function getBoulderFilePath(directory) {
-  return join11(directory, BOULDER_DIR, BOULDER_FILE);
+  return join15(directory, BOULDER_DIR, BOULDER_FILE);
 }
 function readBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
-  if (!existsSync11(filePath)) {
+  if (!existsSync15(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync9(filePath, "utf-8");
+    const content = readFileSync10(filePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       return null;
@@ -68470,6 +69469,15 @@ function readBoulderState(directory) {
     if (!Array.isArray(parsed.session_ids)) {
       parsed.session_ids = [];
     }
+    if (!parsed.session_origins || typeof parsed.session_origins !== "object" || Array.isArray(parsed.session_origins)) {
+      parsed.session_origins = {};
+    }
+    if (parsed.session_ids.length === 1) {
+      const soleSessionId = parsed.session_ids[0];
+      if (typeof soleSessionId === "string" && parsed.session_origins[soleSessionId] !== "appended" && parsed.session_origins[soleSessionId] !== "direct") {
+        parsed.session_origins[soleSessionId] = "direct";
+      }
+    }
     if (!parsed.task_sessions || typeof parsed.task_sessions !== "object" || Array.isArray(parsed.task_sessions)) {
       parsed.task_sessions = {};
     }
@@ -68478,39 +69486,101 @@ function readBoulderState(directory) {
     return null;
   }
 }
+var TODO_HEADING_PATTERN = /^##\s+TODOs\b/i;
+var FINAL_VERIFICATION_HEADING_PATTERN = /^##\s+Final Verification Wave\b/i;
+var SECOND_LEVEL_HEADING_PATTERN = /^##\s+/;
+var UNCHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[\s*\]\s*(.+)$/;
+var CHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[[xX]\]\s*(.+)$/;
+var TODO_TASK_PATTERN = /^\d+\.\s+/;
+var FINAL_WAVE_TASK_PATTERN = /^F\d+\.\s+/i;
 function getPlanProgress(planPath) {
-  if (!existsSync11(planPath)) {
+  if (!existsSync15(planPath)) {
     return { total: 0, completed: 0, isComplete: true };
   }
   try {
-    const content = readFileSync9(planPath, "utf-8");
-    const uncheckedMatches = content.match(/^\s*[-*]\s*\[\s*\]/gm) || [];
-    const checkedMatches = content.match(/^\s*[-*]\s*\[[xX]\]/gm) || [];
-    const total = uncheckedMatches.length + checkedMatches.length;
-    const completed = checkedMatches.length;
-    return {
-      total,
-      completed,
-      isComplete: total > 0 && completed === total
-    };
+    const content = readFileSync10(planPath, "utf-8");
+    const lines = content.split(/\r?\n/);
+    const hasStructuredSections = lines.some((line) => TODO_HEADING_PATTERN.test(line) || FINAL_VERIFICATION_HEADING_PATTERN.test(line));
+    if (hasStructuredSections) {
+      return getStructuredPlanProgress(lines);
+    }
+    return getSimplePlanProgress(content);
   } catch {
     return { total: 0, completed: 0, isComplete: true };
   }
 }
+function getStructuredPlanProgress(lines) {
+  let section = "other";
+  let total = 0;
+  let completed = 0;
+  for (const line of lines) {
+    if (SECOND_LEVEL_HEADING_PATTERN.test(line)) {
+      section = TODO_HEADING_PATTERN.test(line) ? "todo" : FINAL_VERIFICATION_HEADING_PATTERN.test(line) ? "final-wave" : "other";
+      continue;
+    }
+    if (section !== "todo" && section !== "final-wave") {
+      continue;
+    }
+    const checkedMatch = line.match(CHECKED_CHECKBOX_PATTERN);
+    const uncheckedMatch = checkedMatch ? null : line.match(UNCHECKED_CHECKBOX_PATTERN);
+    const match = checkedMatch ?? uncheckedMatch;
+    if (!match) {
+      continue;
+    }
+    if (match[1].length > 0) {
+      continue;
+    }
+    const taskBody = match[2].trim();
+    const labelPattern = section === "todo" ? TODO_TASK_PATTERN : FINAL_WAVE_TASK_PATTERN;
+    if (!labelPattern.test(taskBody)) {
+      continue;
+    }
+    total++;
+    if (checkedMatch) {
+      completed++;
+    }
+  }
+  return {
+    total,
+    completed,
+    isComplete: total > 0 && completed === total
+  };
+}
+function getSimplePlanProgress(content) {
+  const uncheckedMatches = content.match(/^[-*]\s*\[\s*\]/gm) || [];
+  const checkedMatches = content.match(/^[-*]\s*\[[xX]\]/gm) || [];
+  const total = uncheckedMatches.length + checkedMatches.length;
+  const completed = checkedMatches.length;
+  return {
+    total,
+    completed,
+    isComplete: total > 0 && completed === total
+  };
+}
+// src/features/claude-code-session-state/state.ts
+init_agent_display_names();
+var subagentSessions = new Set;
+var syncSubagentSessions = new Set;
+var registeredAgentNames = new Set;
+var registeredAgentAliases = new Map;
+var sessionAgentMap = new Map;
+function getSessionAgent(sessionID) {
+  return sessionAgentMap.get(sessionID);
+}
 // src/features/run-continuation-state/constants.ts
 var CONTINUATION_MARKER_DIR = ".sisyphus/run-continuation";
 // src/features/run-continuation-state/storage.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync4, readFileSync as readFileSync10, rmSync, writeFileSync as writeFileSync6 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync6, readFileSync as readFileSync11, rmSync, writeFileSync as writeFileSync6 } from "fs";
+import { join as join16 } from "path";
 function getMarkerPath(directory, sessionID) {
-  return join12(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
+  return join16(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
 }
 function readContinuationMarker(directory, sessionID) {
   const markerPath = getMarkerPath(directory, sessionID);
-  if (!existsSync12(markerPath))
+  if (!existsSync16(markerPath))
     return null;
   try {
-    const raw = readFileSync10(markerPath, "utf-8");
+    const raw = readFileSync11(markerPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
       return null;
@@ -68533,10 +69603,120 @@ function getActiveContinuationMarkerReason(marker) {
   const [source, entry] = active;
   return entry.reason ?? `${source} continuation is active`;
 }
+// src/hooks/atlas/boulder-session-lineage.ts
+init_logger();
+
+// src/hooks/atlas/hook-name.ts
+var HOOK_NAME = "atlas";
+
+// src/hooks/atlas/boulder-session-lineage.ts
+async function isSessionInBoulderLineage(input) {
+  const visitedSessionIDs = new Set;
+  let currentSessionID = input.sessionID;
+  while (!visitedSessionIDs.has(currentSessionID)) {
+    visitedSessionIDs.add(currentSessionID);
+    const sessionResult = await input.client.session.get({ path: { id: currentSessionID } }).catch((error48) => {
+      log(`[${HOOK_NAME}] Failed to resolve session lineage`, {
+        sessionID: input.sessionID,
+        currentSessionID,
+        error: error48
+      });
+      return null;
+    });
+    if (!sessionResult || sessionResult.error) {
+      return false;
+    }
+    const parentSessionID = sessionResult.data?.parentID;
+    if (!parentSessionID) {
+      return false;
+    }
+    if (input.boulderSessionIDs.includes(parentSessionID)) {
+      return true;
+    }
+    currentSessionID = parentSessionID;
+  }
+  return false;
+}
+
+// src/hooks/atlas/session-last-agent.ts
+init_shared();
+init_compaction_marker();
+import { readFileSync as readFileSync12, readdirSync as readdirSync4 } from "fs";
+import { join as join17 } from "path";
+function getLastAgentFromMessageDir(messageDir) {
+  try {
+    const messages = readdirSync4(messageDir).filter((fileName) => fileName.endsWith(".json")).map((fileName) => {
+      try {
+        const content = readFileSync12(join17(messageDir, fileName), "utf-8");
+        const parsed = JSON.parse(content);
+        return {
+          fileName,
+          id: parsed.id,
+          agent: parsed.agent,
+          createdAt: typeof parsed.time?.created === "number" ? parsed.time.created : Number.NEGATIVE_INFINITY
+        };
+      } catch {
+        return null;
+      }
+    }).filter((message) => message !== null).sort((left, right) => (right?.createdAt ?? 0) - (left?.createdAt ?? 0) || (right?.fileName ?? "").localeCompare(left?.fileName ?? ""));
+    for (const message of messages) {
+      if (!message)
+        continue;
+      if (isCompactionMessage({ agent: message.agent }) || hasCompactionPartInStorage(message?.id)) {
+        continue;
+      }
+      if (typeof message.agent === "string") {
+        return message.agent.toLowerCase();
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+async function getLastAgentFromSession(sessionID, client3) {
+  if (isSqliteBackend() && client3) {
+    try {
+      const response = await client3.session.messages({ path: { id: sessionID } });
+      const messages = normalizeSDKResponse(response, [], {
+        preferResponseOnMissingData: true
+      }).sort((left, right) => {
+        const leftTime = left.info?.time?.created ?? Number.NEGATIVE_INFINITY;
+        const rightTime = right.info?.time?.created ?? Number.NEGATIVE_INFINITY;
+        if (leftTime !== rightTime) {
+          return rightTime - leftTime;
+        }
+        const leftId = typeof left.id === "string" ? left.id : "";
+        const rightId = typeof right.id === "string" ? right.id : "";
+        return rightId.localeCompare(leftId);
+      });
+      for (const message of messages) {
+        if (isCompactionMessage(message)) {
+          continue;
+        }
+        const agent = message.info?.agent;
+        if (typeof agent === "string") {
+          return agent.toLowerCase();
+        }
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  }
+  const messageDir = getMessageDir(sessionID);
+  if (!messageDir)
+    return null;
+  return getLastAgentFromMessageDir(messageDir);
+}
+
+// src/cli/run/continuation-state.ts
+init_agent_display_names();
+
 // src/hooks/ralph-loop/storage.ts
 init_frontmatter();
-import { existsSync as existsSync13, readFileSync as readFileSync11, writeFileSync as writeFileSync7, unlinkSync, mkdirSync as mkdirSync5 } from "fs";
-import { dirname as dirname3, join as join13 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync13, writeFileSync as writeFileSync7, unlinkSync, mkdirSync as mkdirSync7 } from "fs";
+import { dirname as dirname4, join as join18 } from "path";
 
 // src/hooks/ralph-loop/constants.ts
 var DEFAULT_STATE_FILE = ".sisyphus/ralph-loop.local.md";
@@ -68545,15 +69725,15 @@ var DEFAULT_COMPLETION_PROMISE = "DONE";
 
 // src/hooks/ralph-loop/storage.ts
 function getStateFilePath(directory, customPath) {
-  return customPath ? join13(directory, customPath) : join13(directory, DEFAULT_STATE_FILE);
+  return customPath ? join18(directory, customPath) : join18(directory, DEFAULT_STATE_FILE);
 }
 function readState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
-  if (!existsSync13(filePath)) {
+  if (!existsSync17(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync11(filePath, "utf-8");
+    const content = readFileSync13(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     const active = data.active;
     const iteration = data.iteration;
@@ -68593,10 +69773,10 @@ function readState(directory, customPath) {
 }
 
 // src/cli/run/continuation-state.ts
-function getContinuationState(directory, sessionID) {
+async function getContinuationState(directory, sessionID, client3) {
   const marker = readContinuationMarker(directory, sessionID);
   return {
-    hasActiveBoulder: hasActiveBoulderContinuation(directory, sessionID),
+    hasActiveBoulder: await hasActiveBoulderContinuation(directory, sessionID, client3),
     hasActiveRalphLoop: hasActiveRalphLoopContinuation(directory, sessionID),
     hasHookMarker: marker !== null,
     hasTodoHookMarker: marker?.sources.todo !== undefined,
@@ -68604,20 +69784,54 @@ function getContinuationState(directory, sessionID) {
     activeHookMarkerReason: getActiveContinuationMarkerReason(marker)
   };
 }
-function hasActiveBoulderContinuation(directory, sessionID) {
+async function hasActiveBoulderContinuation(directory, sessionID, client3) {
   const boulder = readBoulderState(directory);
   if (!boulder)
     return false;
-  if (!boulder.session_ids.includes(sessionID))
-    return false;
   const progress = getPlanProgress(boulder.active_plan);
-  return !progress.isComplete;
+  if (progress.isComplete)
+    return false;
+  if (!client3)
+    return false;
+  const isTrackedSession = boulder.session_ids.includes(sessionID);
+  const sessionOrigin = boulder.session_origins?.[sessionID];
+  if (!isTrackedSession) {
+    return false;
+  }
+  const isTrackedDescendant = await isTrackedDescendantSession(client3, sessionID, boulder.session_ids);
+  if (isTrackedSession && sessionOrigin === "direct") {
+    return true;
+  }
+  if (isTrackedSession && sessionOrigin !== "direct" && !isTrackedDescendant) {
+    return false;
+  }
+  const sessionAgent = await getLastAgentFromSession(sessionID, client3) ?? getSessionAgent(sessionID);
+  if (!sessionAgent) {
+    return false;
+  }
+  const requiredAgentKey = getAgentConfigKey(boulder.agent ?? "atlas");
+  const sessionAgentKey = getAgentConfigKey(sessionAgent);
+  if (sessionAgentKey !== requiredAgentKey && !(requiredAgentKey === getAgentConfigKey("atlas") && sessionAgentKey === getAgentConfigKey("sisyphus"))) {
+    return false;
+  }
+  return isTrackedSession || isTrackedDescendant;
+}
+async function isTrackedDescendantSession(client3, sessionID, trackedSessionIDs) {
+  const ancestorSessionIDs = trackedSessionIDs.filter((trackedSessionID) => trackedSessionID !== sessionID);
+  if (ancestorSessionIDs.length === 0) {
+    return false;
+  }
+  return isSessionInBoulderLineage({
+    client: client3,
+    sessionID,
+    boulderSessionIDs: ancestorSessionIDs
+  });
 }
 function hasActiveRalphLoopContinuation(directory, sessionID) {
-  const state = readState(directory);
-  if (!state || !state.active)
+  const state2 = readState(directory);
+  if (!state2 || !state2.active)
     return false;
-  if (state.session_id && state.session_id !== sessionID) {
+  if (state2.session_id && state2.session_id !== sessionID) {
     return false;
   }
   return true;
@@ -68626,7 +69840,7 @@ function hasActiveRalphLoopContinuation(directory, sessionID) {
 // src/cli/run/completion.ts
 async function checkCompletionConditions(ctx) {
   try {
-    const continuationState = getContinuationState(ctx.directory, ctx.sessionID);
+    const continuationState = await getContinuationState(ctx.directory, ctx.sessionID, ctx.client);
     if (continuationState.hasActiveHookMarker) {
       const reason = continuationState.activeHookMarkerReason ?? "continuation hook is active";
       logWaiting(ctx, reason);
@@ -68643,7 +69857,7 @@ async function checkCompletionConditions(ctx) {
     }
     return true;
   } catch (err) {
-    console.error(import_picocolors12.default.red(`[completion] API error: ${err}`));
+    console.error(import_picocolors13.default.red(`[completion] API error: ${err}`));
     return false;
   }
 }
@@ -68704,7 +69918,7 @@ function logWaiting(ctx, message) {
   if (!ctx.verbose) {
     return;
   }
-  console.log(import_picocolors12.default.dim(`  Waiting: ${message}`));
+  console.log(import_picocolors13.default.dim(`  Waiting: ${message}`));
 }
 
 // src/cli/run/poll-for-completion.ts
@@ -68735,10 +69949,10 @@ async function pollForCompletion(ctx, eventState, abortController, options = {})
     if (eventState.mainSessionError) {
       errorCycleCount++;
       if (errorCycleCount >= ERROR_GRACE_CYCLES) {
-        console.error(import_picocolors13.default.red(`
+        console.error(import_picocolors14.default.red(`
 
 Session ended with error: ${eventState.lastError}`));
-        console.error(import_picocolors13.default.yellow("Check if todos were completed before the error."));
+        console.error(import_picocolors14.default.yellow("Check if todos were completed before the error."));
         return 1;
       }
       continue;
@@ -68749,7 +69963,7 @@ Session ended with error: ${eventState.lastError}`));
     if (eventState.lastEventTimestamp !== null) {
       const timeSinceLastEvent = Date.now() - eventState.lastEventTimestamp;
       if (timeSinceLastEvent > eventWatchdogMs) {
-        console.log(import_picocolors13.default.yellow(`
+        console.log(import_picocolors14.default.yellow(`
   No events for ${Math.round(timeSinceLastEvent / 1000)}s, verifying session status...`));
         mainSessionStatus = await getMainSessionStatus(ctx);
         if (mainSessionStatus === "idle") {
@@ -68798,7 +70012,7 @@ Session ended with error: ${eventState.lastError}`));
         const hasActiveWork = hasActiveChildren || hasActiveTodos;
         if (hasActiveWork) {
           eventState.hasReceivedMeaningfulWork = true;
-          console.log(import_picocolors13.default.yellow(`
+          console.log(import_picocolors14.default.yellow(`
   No meaningful work events for ${Math.round(secondaryMeaningfulWorkTimeoutMs / 1000)}s but session has active work - assuming in progress`));
         }
       }
@@ -68818,7 +70032,7 @@ Session ended with error: ${eventState.lastError}`));
       }
       consecutiveCompleteChecks++;
       if (consecutiveCompleteChecks >= requiredConsecutive) {
-        console.log(import_picocolors13.default.green(`
+        console.log(import_picocolors14.default.green(`
 
 All tasks completed.`));
         return 0;
@@ -68987,7 +70201,7 @@ async function run(options) {
     };
     const restoreInput = suppressRunInput();
     const handleSigint = () => {
-      console.log(import_picocolors14.default.yellow(`
+      console.log(import_picocolors15.default.yellow(`
 Interrupted. Shutting down...`));
       restoreInput();
       cleanup();
@@ -69000,9 +70214,9 @@ Interrupted. Shutting down...`));
         sessionId: options.sessionId,
         directory
       });
-      console.log(import_picocolors14.default.dim(`Session: ${sessionID}`));
+      console.log(import_picocolors15.default.dim(`Session: ${sessionID}`));
       if (resolvedModel) {
-        console.log(import_picocolors14.default.dim(`Model: ${resolvedModel.providerID}/${resolvedModel.modelID}`));
+        console.log(import_picocolors15.default.dim(`Model: ${resolvedModel.providerID}/${resolvedModel.modelID}`));
       }
       const ctx = {
         client: client3,
@@ -69065,7 +70279,7 @@ Interrupted. Shutting down...`));
     if (err instanceof Error && err.name === "AbortError") {
       return 130;
     }
-    console.error(import_picocolors14.default.red(`Error: ${serializeError(err)}`));
+    console.error(import_picocolors15.default.red(`Error: ${serializeError(err)}`));
     return 1;
   } finally {
     timestampOutput?.restore();
@@ -69075,53 +70289,53 @@ Interrupted. Shutting down...`));
 init_checker();
 
 // src/cli/get-local-version/formatter.ts
-var import_picocolors15 = __toESM(require_picocolors(), 1);
-var SYMBOLS2 = {
-  check: import_picocolors15.default.green("[OK]"),
-  cross: import_picocolors15.default.red("[X]"),
-  arrow: import_picocolors15.default.cyan("->"),
-  info: import_picocolors15.default.blue("[i]"),
-  warn: import_picocolors15.default.yellow("[!]"),
-  pin: import_picocolors15.default.magenta("[PINNED]"),
-  dev: import_picocolors15.default.cyan("[DEV]")
+var import_picocolors16 = __toESM(require_picocolors(), 1);
+var SYMBOLS3 = {
+  check: import_picocolors16.default.green("[OK]"),
+  cross: import_picocolors16.default.red("[X]"),
+  arrow: import_picocolors16.default.cyan("->"),
+  info: import_picocolors16.default.blue("[i]"),
+  warn: import_picocolors16.default.yellow("[!]"),
+  pin: import_picocolors16.default.magenta("[PINNED]"),
+  dev: import_picocolors16.default.cyan("[DEV]")
 };
 function formatVersionOutput(info) {
   const lines = [];
   lines.push("");
-  lines.push(import_picocolors15.default.bold(import_picocolors15.default.white("evil-omo Version Information")));
-  lines.push(import_picocolors15.default.dim("\u2500".repeat(50)));
+  lines.push(import_picocolors16.default.bold(import_picocolors16.default.white("evil-omo Version Information")));
+  lines.push(import_picocolors16.default.dim("\u2500".repeat(50)));
   lines.push("");
   if (info.currentVersion) {
-    lines.push(`  Current Version: ${import_picocolors15.default.cyan(info.currentVersion)}`);
+    lines.push(`  Current Version: ${import_picocolors16.default.cyan(info.currentVersion)}`);
   } else {
-    lines.push(`  Current Version: ${import_picocolors15.default.dim("unknown")}`);
+    lines.push(`  Current Version: ${import_picocolors16.default.dim("unknown")}`);
   }
   if (!info.isLocalDev && info.latestVersion) {
-    lines.push(`  Latest Version:  ${import_picocolors15.default.cyan(info.latestVersion)}`);
+    lines.push(`  Latest Version:  ${import_picocolors16.default.cyan(info.latestVersion)}`);
   }
   lines.push("");
   switch (info.status) {
     case "up-to-date":
-      lines.push(`  ${SYMBOLS2.check} ${import_picocolors15.default.green("You're up to date!")}`);
+      lines.push(`  ${SYMBOLS3.check} ${import_picocolors16.default.green("You're up to date!")}`);
       break;
     case "outdated":
-      lines.push(`  ${SYMBOLS2.warn} ${import_picocolors15.default.yellow("Update available")}`);
-      lines.push(`  ${import_picocolors15.default.dim("Run:")} ${import_picocolors15.default.cyan("cd ~/.config/opencode && bun update evil-omo")}`);
+      lines.push(`  ${SYMBOLS3.warn} ${import_picocolors16.default.yellow("Update available")}`);
+      lines.push(`  ${import_picocolors16.default.dim("Run:")} ${import_picocolors16.default.cyan("cd ~/.config/opencode && bun update evil-omo")}`);
       break;
     case "local-dev":
-      lines.push(`  ${SYMBOLS2.dev} ${import_picocolors15.default.cyan("Running in local development mode")}`);
-      lines.push(`  ${import_picocolors15.default.dim("Using file:// protocol from config")}`);
+      lines.push(`  ${SYMBOLS3.dev} ${import_picocolors16.default.cyan("Running in local development mode")}`);
+      lines.push(`  ${import_picocolors16.default.dim("Using file:// protocol from config")}`);
       break;
     case "pinned":
-      lines.push(`  ${SYMBOLS2.pin} ${import_picocolors15.default.magenta(`Version pinned to ${info.pinnedVersion}`)}`);
-      lines.push(`  ${import_picocolors15.default.dim("Update check skipped for pinned versions")}`);
+      lines.push(`  ${SYMBOLS3.pin} ${import_picocolors16.default.magenta(`Version pinned to ${info.pinnedVersion}`)}`);
+      lines.push(`  ${import_picocolors16.default.dim("Update check skipped for pinned versions")}`);
       break;
     case "error":
-      lines.push(`  ${SYMBOLS2.cross} ${import_picocolors15.default.red("Unable to check for updates")}`);
-      lines.push(`  ${import_picocolors15.default.dim("Network error or npm registry unavailable")}`);
+      lines.push(`  ${SYMBOLS3.cross} ${import_picocolors16.default.red("Unable to check for updates")}`);
+      lines.push(`  ${import_picocolors16.default.dim("Network error or npm registry unavailable")}`);
       break;
     case "unknown":
-      lines.push(`  ${SYMBOLS2.info} ${import_picocolors15.default.yellow("Version information unavailable")}`);
+      lines.push(`  ${SYMBOLS3.info} ${import_picocolors16.default.yellow("Version information unavailable")}`);
       break;
   }
   lines.push("");
@@ -69220,69 +70434,31 @@ async function getLocalVersion(options = {}) {
     return 1;
   }
 }
-// src/cli/doctor/constants.ts
-init_plugin_identity();
-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_NAME3 = PLUGIN_NAME;
-var OPENCODE_BINARIES2 = ["opencode", "opencode-desktop"];
-
 // src/cli/doctor/checks/system.ts
-import { existsSync as existsSync24, readFileSync as readFileSync21 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync23 } from "fs";
 
 // src/cli/doctor/checks/system-binary.ts
 init_spawn_with_windows_hide();
-import { existsSync as existsSync21 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join20 } 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",
-        join20(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(join20(programFiles, "OpenCode", "OpenCode.exe"));
+        paths.push(join26(programFiles, "OpenCode", "OpenCode.exe"));
       }
       if (localAppData) {
-        paths.push(join20(localAppData, "OpenCode", "OpenCode.exe"));
+        paths.push(join26(localAppData, "OpenCode", "OpenCode.exe"));
       }
       return paths;
     }
@@ -69290,8 +70466,8 @@ function getDesktopAppPaths(platform) {
       return [
         "/usr/bin/opencode",
         "/usr/lib/opencode/opencode",
-        join20(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
-        join20(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 [];
@@ -69303,7 +70479,7 @@ function buildVersionCommand(binaryPath, platform) {
   }
   return [binaryPath, "--version"];
 }
-function findDesktopBinary(platform = process.platform, checkExists = existsSync21) {
+function findDesktopBinary(platform = process.platform, checkExists = existsSync25) {
   for (const desktopPath of getDesktopAppPaths(platform)) {
     if (checkExists(desktopPath)) {
       return { binary: "opencode", path: desktopPath };
@@ -69320,7 +70496,7 @@ async function findOpenCodeBinary() {
   }
   return findDesktopBinary();
 }
-async function getOpenCodeVersion2(binaryPath, platform = process.platform) {
+async function getOpenCodeVersion3(binaryPath, platform = process.platform) {
   try {
     const command = buildVersionCommand(binaryPath, platform);
     const processResult = spawnWithWindowsHide(command, { stdout: "pipe", stderr: "pipe" });
@@ -69333,10 +70509,10 @@ async function getOpenCodeVersion2(binaryPath, platform = process.platform) {
     return null;
   }
 }
-function compareVersions(current, minimum) {
-  const parseVersion = (version2) => version2.replace(/^v/, "").split("-")[0].split(".").map((part) => Number.parseInt(part, 10) || 0);
-  const currentParts = parseVersion(current);
-  const minimumParts = parseVersion(minimum);
+function compareVersions3(current, minimum) {
+  const parseVersion3 = (version2) => version2.replace(/^v/, "").split("-")[0].split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const currentParts = parseVersion3(current);
+  const minimumParts = parseVersion3(minimum);
   const length = Math.max(currentParts.length, minimumParts.length);
   for (let index = 0;index < length; index++) {
     const currentPart = currentParts[index] ?? 0;
@@ -69351,12 +70527,12 @@ function compareVersions(current, minimum) {
 
 // src/cli/doctor/checks/system-plugin.ts
 init_shared();
-import { existsSync as existsSync22, readFileSync as readFileSync19 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync21 } from "fs";
 function detectConfigPath() {
   const paths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
-  if (existsSync22(paths.configJsonc))
+  if (existsSync26(paths.configJsonc))
     return paths.configJsonc;
-  if (existsSync22(paths.configJson))
+  if (existsSync26(paths.configJson))
     return paths.configJson;
   return null;
 }
@@ -69402,7 +70578,7 @@ function getPluginInfo() {
     };
   }
   try {
-    const content = readFileSync19(configPath, "utf-8");
+    const content = readFileSync21(configPath, "utf-8");
     const parsedConfig = parseJsonc(content);
     const pluginEntry = findPluginEntry2(parsedConfig.plugin ?? []);
     if (!pluginEntry) {
@@ -69440,37 +70616,37 @@ function getPluginInfo() {
 init_file_utils();
 init_checker();
 init_auto_update_checker();
-import { existsSync as existsSync23, readFileSync as readFileSync20 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync22 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join21 } from "path";
+import { join as join27 } from "path";
 init_shared();
 function getPlatformDefaultCacheDir(platform = process.platform) {
   if (platform === "darwin")
-    return join21(homedir6(), "Library", "Caches");
+    return join27(homedir6(), "Library", "Caches");
   if (platform === "win32")
-    return process.env.LOCALAPPDATA ?? join21(homedir6(), "AppData", "Local");
-  return join21(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 join21(xdgCacheHome, "opencode");
+    return join27(xdgCacheHome, "opencode");
   const fromShared = getOpenCodeCacheDir();
-  const platformDefault = join21(getPlatformDefaultCacheDir(), "opencode");
-  if (existsSync23(fromShared) || !existsSync23(platformDefault))
+  const platformDefault = join27(getPlatformDefaultCacheDir(), "opencode");
+  if (existsSync27(fromShared) || !existsSync27(platformDefault))
     return fromShared;
   return platformDefault;
 }
 function resolveExistingDir(dirPath) {
-  if (!existsSync23(dirPath))
+  if (!existsSync27(dirPath))
     return dirPath;
   return resolveSymlink(dirPath);
 }
 function readPackageJson(filePath) {
-  if (!existsSync23(filePath))
+  if (!existsSync27(filePath))
     return null;
   try {
-    const content = readFileSync20(filePath, "utf-8");
+    const content = readFileSync22(filePath, "utf-8");
     return parseJsonc(content);
   } catch {
     return null;
@@ -69489,20 +70665,20 @@ function getLoadedPluginVersion() {
   const candidates = [
     {
       cacheDir: configDir,
-      cachePackagePath: join21(configDir, "package.json"),
-      installedPackagePath: join21(configDir, "node_modules", PACKAGE_NAME3, "package.json")
+      cachePackagePath: join27(configDir, "package.json"),
+      installedPackagePath: join27(configDir, "node_modules", PACKAGE_NAME, "package.json")
     },
     {
       cacheDir,
-      cachePackagePath: join21(cacheDir, "package.json"),
-      installedPackagePath: join21(cacheDir, "node_modules", PACKAGE_NAME3, "package.json")
+      cachePackagePath: join27(cacheDir, "package.json"),
+      installedPackagePath: join27(cacheDir, "node_modules", PACKAGE_NAME, "package.json")
     }
   ];
-  const selectedCandidate = candidates.find((candidate) => existsSync23(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_NAME3]);
+  const expectedVersion = normalizeVersion(cachePackage?.dependencies?.[PACKAGE_NAME]);
   const loadedVersion = normalizeVersion(installedPackage?.version);
   return {
     cacheDir: selectedDir,
@@ -69522,13 +70698,14 @@ function getSuggestedInstallTag(currentVersion) {
 
 // src/cli/doctor/checks/system.ts
 init_shared();
+init_plugin_identity();
 function isConfigValid(configPath) {
   if (!configPath)
     return true;
-  if (!existsSync24(configPath))
+  if (!existsSync28(configPath))
     return false;
   try {
-    parseJsonc(readFileSync21(configPath, "utf-8"));
+    parseJsonc(readFileSync23(configPath, "utf-8"));
     return true;
   } catch {
     return false;
@@ -69551,7 +70728,7 @@ function buildMessage(status, issues) {
 async function gatherSystemInfo() {
   const [binaryInfo, pluginInfo] = await Promise.all([findOpenCodeBinary(), Promise.resolve(getPluginInfo())]);
   const loadedInfo = getLoadedPluginVersion();
-  const opencodeVersion = binaryInfo ? await getOpenCodeVersion2(binaryInfo.path) : null;
+  const opencodeVersion = binaryInfo ? await getOpenCodeVersion3(binaryInfo.path) : null;
   const pluginVersion = pluginInfo.pinnedVersion ?? loadedInfo.expectedVersion ?? loadedInfo.loadedVersion;
   return {
     opencodeVersion,
@@ -69579,7 +70756,7 @@ async function checkSystem() {
       affects: ["doctor", "run"]
     });
   }
-  if (systemInfo.opencodeVersion && !compareVersions(systemInfo.opencodeVersion, MIN_OPENCODE_VERSION)) {
+  if (systemInfo.opencodeVersion && !compareVersions3(systemInfo.opencodeVersion, MIN_OPENCODE_VERSION)) {
     issues.push({
       title: "OpenCode version below minimum",
       description: `Detected ${systemInfo.opencodeVersion}; required >= ${MIN_OPENCODE_VERSION}.`,
@@ -69590,13 +70767,26 @@ async function checkSystem() {
   }
   if (!pluginInfo.registered) {
     issues.push({
-      title: `${PACKAGE_NAME3} is not registered`,
+      title: `${PLUGIN_NAME} is not registered`,
       description: "Plugin entry is missing from OpenCode configuration.",
-      fix: `Run: bunx ${PACKAGE_NAME3} install`,
+      fix: `Run: bunx ${PLUGIN_NAME} install`,
       severity: "error",
       affects: ["all agents"]
     });
   }
+  if (pluginInfo.entry && !pluginInfo.isLocalDev) {
+    const isLegacyName = pluginInfo.entry === LEGACY_PLUGIN_NAME || pluginInfo.entry.startsWith(`${LEGACY_PLUGIN_NAME}@`);
+    if (isLegacyName) {
+      const suggestedEntry = pluginInfo.entry.replace(LEGACY_PLUGIN_NAME, PLUGIN_NAME);
+      issues.push({
+        title: "Using legacy package name",
+        description: `Your opencode.json references "${LEGACY_PLUGIN_NAME}" which has been renamed to "${PLUGIN_NAME}". The old name may stop working in a future release.`,
+        fix: `Update your opencode.json plugin entry: "${pluginInfo.entry}" \u2192 "${suggestedEntry}"`,
+        severity: "warning",
+        affects: ["plugin loading"]
+      });
+    }
+  }
   if (loadedInfo.expectedVersion && loadedInfo.loadedVersion && loadedInfo.expectedVersion !== loadedInfo.loadedVersion) {
     issues.push({
       title: "Loaded plugin version mismatch",
@@ -69606,11 +70796,11 @@ async function checkSystem() {
       affects: ["plugin loading"]
     });
   }
-  if (systemInfo.loadedVersion && latestVersion && !compareVersions(systemInfo.loadedVersion, latestVersion)) {
+  if (systemInfo.loadedVersion && latestVersion && !compareVersions3(systemInfo.loadedVersion, latestVersion)) {
     issues.push({
       title: "Loaded plugin is outdated",
       description: `Loaded ${systemInfo.loadedVersion}, latest ${latestVersion}.`,
-      fix: `Update: cd "${loadedInfo.cacheDir}" && bun add ${PACKAGE_NAME3}@${installTag}`,
+      fix: `Update: cd "${loadedInfo.cacheDir}" && bun add ${PLUGIN_NAME}@${installTag}`,
       severity: "warning",
       affects: ["plugin features"]
     });
@@ -69631,29 +70821,28 @@ async function checkSystem() {
 }
 
 // src/cli/doctor/checks/config.ts
-import { readFileSync as readFileSync24 } from "fs";
-import { join as join25 } from "path";
+import { readFileSync as readFileSync26 } from "fs";
+import { join as join31 } from "path";
 init_shared();
-init_plugin_identity();
 
 // src/cli/doctor/checks/model-resolution-cache.ts
 init_shared();
-import { existsSync as existsSync25, readFileSync as readFileSync22 } from "fs";
+import { existsSync as existsSync29, readFileSync as readFileSync24 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join22 } from "path";
+import { join as join28 } from "path";
 function getOpenCodeCacheDir2() {
   const xdgCache = process.env.XDG_CACHE_HOME;
   if (xdgCache)
-    return join22(xdgCache, "opencode");
-  return join22(homedir7(), ".cache", "opencode");
+    return join28(xdgCache, "opencode");
+  return join28(homedir7(), ".cache", "opencode");
 }
 function loadAvailableModelsFromCache() {
-  const cacheFile = join22(getOpenCodeCacheDir2(), "models.json");
-  if (!existsSync25(cacheFile)) {
+  const cacheFile = join28(getOpenCodeCacheDir2(), "models.json");
+  if (!existsSync29(cacheFile)) {
     return { providers: [], modelCount: 0, cacheExists: false };
   }
   try {
-    const content = readFileSync22(cacheFile, "utf-8");
+    const content = readFileSync24(cacheFile, "utf-8");
     const data = parseJsonc(content);
     const providers = Object.keys(data);
     let modelCount = 0;
@@ -69675,25 +70864,24 @@ init_model_capabilities();
 
 // src/cli/doctor/checks/model-resolution-config.ts
 init_shared();
-init_plugin_identity();
-import { readFileSync as readFileSync23 } from "fs";
-import { join as join23 } from "path";
-var USER_CONFIG_DIR2 = getOpenCodeConfigPaths({ binary: "opencode", version: null }).configDir;
-var PROJECT_CONFIG_DIR = join23(process.cwd(), ".opencode");
+import { readFileSync as readFileSync25 } from "fs";
+import { join as join29 } from "path";
+var PROJECT_CONFIG_DIR = join29(process.cwd(), ".opencode");
 function loadOmoConfig() {
-  const projectDetected = detectManagedConfigFile(PROJECT_CONFIG_DIR);
+  const projectDetected = detectPluginConfigFile(PROJECT_CONFIG_DIR);
   if (projectDetected.format !== "none") {
     try {
-      const content = readFileSync23(projectDetected.path, "utf-8");
+      const content = readFileSync25(projectDetected.path, "utf-8");
       return parseJsonc(content);
     } catch {
       return null;
     }
   }
-  const userDetected = detectManagedConfigFile(USER_CONFIG_DIR2);
+  const userConfigDir = getOpenCodeConfigDir({ binary: "opencode" });
+  const userDetected = detectPluginConfigFile(userConfigDir);
   if (userDetected.format !== "none") {
     try {
-      const content = readFileSync23(userDetected.path, "utf-8");
+      const content = readFileSync25(userDetected.path, "utf-8");
       return parseJsonc(content);
     } catch {
       return null;
@@ -69704,7 +70892,7 @@ function loadOmoConfig() {
 
 // src/cli/doctor/checks/model-resolution-details.ts
 init_shared();
-import { join as join24 } from "path";
+import { join as join30 } from "path";
 
 // src/cli/doctor/checks/model-resolution-variant.ts
 function formatModelWithVariant(model, variant) {
@@ -69746,7 +70934,7 @@ function formatCapabilityResolutionLabel(mode) {
 }
 function buildModelResolutionDetails(options) {
   const details = [];
-  const cacheFile = join24(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) {
@@ -69901,11 +71089,13 @@ async function checkModels() {
 }
 
 // src/cli/doctor/checks/config.ts
+var PROJECT_CONFIG_DIR2 = join31(process.cwd(), ".opencode");
 function findConfigPath() {
-  const projectConfig = detectManagedConfigFile(join25(process.cwd(), ".opencode"));
+  const projectConfig = detectPluginConfigFile(PROJECT_CONFIG_DIR2);
   if (projectConfig.format !== "none")
     return projectConfig.path;
-  const userConfig = detectManagedConfigFile(getOpenCodeConfigDir({ binary: "opencode" }));
+  const userConfigDir = getOpenCodeConfigDir({ binary: "opencode" });
+  const userConfig = detectPluginConfigFile(userConfigDir);
   if (userConfig.format !== "none")
     return userConfig.path;
   return null;
@@ -69916,7 +71106,7 @@ function validateConfig() {
     return { exists: false, path: null, valid: true, config: null, errors: [] };
   }
   try {
-    const content = readFileSync24(configPath, "utf-8");
+    const content = readFileSync26(configPath, "utf-8");
     const rawConfig = parseJsonc(content);
     const schemaResult = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
     if (!schemaResult.success) {
@@ -70020,9 +71210,9 @@ async function checkConfig() {
 
 // src/cli/doctor/checks/dependencies.ts
 init_spawn_with_windows_hide();
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync30 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname7, join as join26 } from "path";
+import { dirname as dirname8, join as join32 } from "path";
 async function checkBinaryExists(binary2) {
   try {
     const path10 = Bun.which(binary2);
@@ -70078,15 +71268,15 @@ async function checkAstGrepNapi() {
       path: null
     };
   } catch {
-    const { existsSync: existsSync27 } = await import("fs");
-    const { join: join27 } = await import("path");
+    const { existsSync: existsSync31 } = await import("fs");
+    const { join: join33 } = await import("path");
     const { homedir: homedir8 } = await import("os");
     const pathsToCheck = [
-      join27(homedir8(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
-      join27(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 (existsSync27(napiPath)) {
+      if (existsSync31(napiPath)) {
         return {
           name: "AST-Grep NAPI",
           required: false,
@@ -70111,8 +71301,8 @@ function findCommentCheckerPackageBinary() {
   try {
     const require2 = createRequire(import.meta.url);
     const pkgPath = require2.resolve("@code-yeongyu/comment-checker/package.json");
-    const binaryPath = join26(dirname7(pkgPath), "bin", binaryName);
-    if (existsSync26(binaryPath))
+    const binaryPath = join32(dirname8(pkgPath), "bin", binaryName);
+    if (existsSync30(binaryPath))
       return binaryPath;
   } catch {}
   return null;
@@ -70269,16 +71459,15 @@ var BUILTIN_SERVERS = {
   "kotlin-ls": { command: ["kotlin-lsp"], extensions: [".kt", ".kts"] }
 };
 // src/tools/lsp/server-config-loader.ts
-import { existsSync as existsSync27, readFileSync as readFileSync25 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync31, readFileSync as readFileSync27 } from "fs";
+import { join as join33 } from "path";
 init_shared();
 init_jsonc_parser();
-init_plugin_identity();
 function loadJsonFile(path10) {
-  if (!existsSync27(path10))
+  if (!existsSync31(path10))
     return null;
   try {
-    return parseJsonc(readFileSync25(path10, "utf-8"));
+    return parseJsonc(readFileSync27(path10, "utf-8"));
   } catch {
     return null;
   }
@@ -70287,9 +71476,9 @@ function getConfigPaths2() {
   const cwd = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   return {
-    project: detectManagedConfigFile(join27(cwd, ".opencode")).path,
-    user: detectManagedConfigFile(configDir).path,
-    opencode: detectConfigFile(join27(configDir, "opencode")).path
+    project: detectPluginConfigFile(join33(cwd, ".opencode")).path,
+    user: detectPluginConfigFile(configDir).path,
+    opencode: detectConfigFile(join33(configDir, "opencode")).path
   };
 }
 function loadAllConfigs() {
@@ -70358,21 +71547,21 @@ function getMergedServers() {
 }
 
 // src/tools/lsp/server-installation.ts
-import { existsSync as existsSync28 } from "fs";
-import { delimiter as delimiter2, join as join29 } 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 join28 } from "path";
+import { join as join34 } from "path";
 function getLspServerAdditionalPathBases(workingDirectory) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join28(getDataDir(), "opencode");
+  const dataDir = join34(getDataDir(), "opencode");
   return [
-    join28(workingDirectory, "node_modules", ".bin"),
-    join28(configDir, "bin"),
-    join28(configDir, "node_modules", ".bin"),
-    join28(dataDir, "bin"),
-    join28(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")
   ];
 }
 
@@ -70382,7 +71571,7 @@ function isServerInstalled(command) {
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync28(cmd))
+    if (existsSync32(cmd))
       return true;
   }
   const isWindows = process.platform === "win32";
@@ -70403,14 +71592,14 @@ function isServerInstalled(command) {
   const paths = pathEnv.split(delimiter2);
   for (const p2 of paths) {
     for (const suffix of exts) {
-      if (existsSync28(join29(p2, cmd + suffix))) {
+      if (existsSync32(join35(p2, cmd + suffix))) {
         return true;
       }
     }
   }
   for (const base of getLspServerAdditionalPathBases(process.cwd())) {
     for (const suffix of exts) {
-      if (existsSync28(join29(base, cmd + suffix))) {
+      if (existsSync32(join35(base, cmd + suffix))) {
         return true;
       }
     }
@@ -70472,24 +71661,24 @@ function getInstalledLspServers() {
 
 // src/cli/doctor/checks/tools-mcp.ts
 init_shared();
-import { existsSync as existsSync29, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync33, readFileSync as readFileSync28 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join30 } from "path";
+import { join as join36 } from "path";
 var BUILTIN_MCP_SERVERS = ["context7", "grep_app"];
 function getMcpConfigPaths() {
   return [
-    join30(homedir8(), ".claude", ".mcp.json"),
-    join30(process.cwd(), ".mcp.json"),
-    join30(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 (!existsSync29(configPath))
+    if (!existsSync33(configPath))
       continue;
     try {
-      const content = readFileSync26(configPath, "utf-8");
+      const content = readFileSync28(configPath, "utf-8");
       const config2 = parseJsonc(content);
       if (config2.mcpServers) {
         Object.assign(servers, config2.mcpServers);
@@ -70656,17 +71845,17 @@ function formatStatusSymbol(status) {
   const colorFn = STATUS_COLORS[status];
   switch (status) {
     case "pass":
-      return colorFn(SYMBOLS3.check);
+      return colorFn(SYMBOLS2.check);
     case "fail":
-      return colorFn(SYMBOLS3.cross);
+      return colorFn(SYMBOLS2.cross);
     case "warn":
-      return colorFn(SYMBOLS3.warn);
+      return colorFn(SYMBOLS2.warn);
     case "skip":
-      return colorFn(SYMBOLS3.skip);
+      return colorFn(SYMBOLS2.skip);
   }
 }
 function formatStatusMark(available) {
-  return available ? import_picocolors17.default.green(SYMBOLS3.check) : import_picocolors17.default.red(SYMBOLS3.cross);
+  return available ? import_picocolors17.default.green(SYMBOLS2.check) : import_picocolors17.default.red(SYMBOLS2.cross);
 }
 function formatHeader() {
   return `
@@ -70689,7 +71878,6 @@ function formatIssue(issue2, index) {
 }
 
 // src/cli/doctor/format-default.ts
-init_plugin_identity();
 function formatDefault(result) {
   const lines = [];
   lines.push(formatHeader());
@@ -70697,12 +71885,12 @@ function formatDefault(result) {
   if (allIssues.length === 0) {
     const opencodeVer = result.systemInfo.opencodeVersion ?? "unknown";
     const pluginVer = result.systemInfo.pluginVersion ?? "unknown";
-    lines.push(` ${import_picocolors18.default.green(SYMBOLS3.check)} ${import_picocolors18.default.green(`System OK (opencode ${opencodeVer} \xB7 ${PLUGIN_NAME} ${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));
@@ -70745,7 +71933,6 @@ function formatStatus(result) {
 
 // src/cli/doctor/format-verbose.ts
 var import_picocolors20 = __toESM(require_picocolors(), 1);
-init_plugin_identity();
 function formatVerbose(result) {
   const lines = [];
   lines.push(formatHeader());
@@ -70753,7 +71940,7 @@ function formatVerbose(result) {
   lines.push(`${import_picocolors20.default.bold("System Information")}`);
   lines.push(`${import_picocolors20.default.dim("\u2500".repeat(40))}`);
   lines.push(`  ${formatStatusSymbol("pass")} opencode    ${systemInfo.opencodeVersion ?? "unknown"}`);
-  lines.push(`  ${formatStatusSymbol("pass")} ${PLUGIN_NAME} ${systemInfo.pluginVersion ?? "unknown"}`);
+  lines.push(`  ${formatStatusSymbol("pass")} evil-omo ${systemInfo.pluginVersion ?? "unknown"}`);
   if (systemInfo.loadedVersion) {
     lines.push(`  ${formatStatusSymbol("pass")} loaded      ${systemInfo.loadedVersion}`);
   }
@@ -70910,13 +72097,45 @@ async function doctor(options = { mode: "default" }) {
   return result.exitCode;
 }
 
+// src/cli/refresh-model-capabilities.ts
+init_model_capabilities_cache();
+async function refreshModelCapabilities(options, deps = {}) {
+  const directory = options.directory ?? process.cwd();
+  const loadConfig = deps.loadConfig ?? loadPluginConfig;
+  const refreshCache = deps.refreshCache ?? refreshModelCapabilitiesCache;
+  const stdout = deps.stdout ?? process.stdout;
+  const stderr = deps.stderr ?? process.stderr;
+  try {
+    const config2 = loadConfig(directory, null);
+    const sourceUrl = options.sourceUrl ?? config2.model_capabilities?.source_url;
+    const snapshot = await refreshCache({ sourceUrl });
+    const summary = {
+      sourceUrl: snapshot.sourceUrl,
+      generatedAt: snapshot.generatedAt,
+      modelCount: Object.keys(snapshot.models).length
+    };
+    if (options.json) {
+      stdout.write(`${JSON.stringify(summary, null, 2)}
+`);
+    } else {
+      stdout.write(`Refreshed model capabilities cache (${summary.modelCount} models) from ${summary.sourceUrl}
+`);
+    }
+    return 0;
+  } catch (error48) {
+    stderr.write(`Failed to refresh model capabilities cache: ${String(error48)}
+`);
+    return 1;
+  }
+}
+
 // src/features/mcp-oauth/storage.ts
 init_shared();
-import { chmodSync, existsSync as existsSync30, mkdirSync as mkdirSync7, readFileSync as readFileSync27, unlinkSync as unlinkSync4, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname8, join as join31 } from "path";
+import { chmodSync, existsSync as existsSync34, mkdirSync as mkdirSync9, readFileSync as readFileSync29, renameSync as renameSync3, unlinkSync as unlinkSync4, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname9, join as join37 } from "path";
 var STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStoragePath() {
-  return join31(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
+  return join37(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
 }
 function normalizeHost(serverHost) {
   let host = serverHost.trim();
@@ -70953,11 +72172,11 @@ function buildKey(serverHost, resource) {
 }
 function readStore() {
   const filePath = getMcpOauthStoragePath();
-  if (!existsSync30(filePath)) {
+  if (!existsSync34(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync27(filePath, "utf-8");
+    const content = readFileSync29(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -70966,12 +72185,14 @@ function readStore() {
 function writeStore(store2) {
   const filePath = getMcpOauthStoragePath();
   try {
-    const dir = dirname8(filePath);
-    if (!existsSync30(dir)) {
-      mkdirSync7(dir, { recursive: true });
-    }
-    writeFileSync10(filePath, JSON.stringify(store2, null, 2), { encoding: "utf-8", mode: 384 });
-    chmodSync(filePath, 384);
+    const dir = dirname9(filePath);
+    if (!existsSync34(dir)) {
+      mkdirSync9(dir, { recursive: true });
+    }
+    const tempPath = `${filePath}.tmp.${Date.now()}`;
+    writeFileSync10(tempPath, JSON.stringify(store2, null, 2), { encoding: "utf-8", mode: 384 });
+    chmodSync(tempPath, 384);
+    renameSync3(tempPath, filePath);
     return true;
   } catch {
     return false;
@@ -71002,7 +72223,7 @@ function deleteToken(serverHost, resource) {
   if (Object.keys(store2).length === 0) {
     try {
       const filePath = getMcpOauthStoragePath();
-      if (existsSync30(filePath)) {
+      if (existsSync34(filePath)) {
         unlinkSync4(filePath);
       }
       return true;
@@ -71192,7 +72413,7 @@ async function findAvailablePort2(startPort = DEFAULT_PORT) {
 }
 
 // src/features/mcp-oauth/oauth-authorization-flow.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn } from "child_process";
 import { createHash, randomBytes as randomBytes2 } from "crypto";
 import { createServer } from "http";
 function generateCodeVerifier() {
@@ -71225,7 +72446,7 @@ function startCallbackServer(port) {
       clearTimeout(timeoutId);
       const requestUrl = new URL(request.url ?? "/", `http://localhost:${port}`);
       const code = requestUrl.searchParams.get("code");
-      const state = requestUrl.searchParams.get("state");
+      const state2 = requestUrl.searchParams.get("state");
       const error48 = requestUrl.searchParams.get("error");
       if (error48) {
         const errorDescription = requestUrl.searchParams.get("error_description") ?? error48;
@@ -71235,7 +72456,7 @@ function startCallbackServer(port) {
         reject(new Error(`OAuth authorization error: ${errorDescription}`));
         return;
       }
-      if (!code || !state) {
+      if (!code || !state2) {
         response.writeHead(400, { "content-type": "text/html" });
         response.end("<html><body><h1>Missing code or state</h1></body></html>");
         server2.close();
@@ -71245,7 +72466,7 @@ function startCallbackServer(port) {
       response.writeHead(200, { "content-type": "text/html" });
       response.end("<html><body><h1>Authorization successful. You can close this tab.</h1></body></html>");
       server2.close();
-      resolve2({ code, state });
+      resolve2({ code, state: state2 });
     });
     timeoutId = setTimeout(() => {
       server2.close();
@@ -71273,7 +72494,7 @@ function openBrowser(url2) {
     args = [url2];
   }
   try {
-    const child = spawn2(command, args, { stdio: "ignore", detached: true });
+    const child = spawn(command, args, { stdio: "ignore", detached: true });
     child.on("error", () => {});
     child.unref();
   } catch {}
@@ -71281,26 +72502,56 @@ function openBrowser(url2) {
 async function runAuthorizationCodeRedirect(options) {
   const verifier = generateCodeVerifier();
   const challenge = generateCodeChallenge(verifier);
-  const state = randomBytes2(16).toString("hex");
+  const state2 = randomBytes2(16).toString("hex");
   const authorizationUrl = buildAuthorizationUrl(options.authorizationEndpoint, {
     clientId: options.clientId,
     redirectUri: options.redirectUri,
     codeChallenge: challenge,
-    state,
+    state: state2,
     scopes: options.scopes,
     resource: options.resource
   });
   const callbackPromise = startCallbackServer(options.callbackPort);
   openBrowser(authorizationUrl);
   const result = await callbackPromise;
-  if (result.state !== state) {
+  if (result.state !== state2) {
     throw new Error("OAuth state mismatch");
   }
   return { code: result.code, verifier };
 }
 
 // src/features/mcp-oauth/provider.ts
-init_plugin_identity();
+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;
@@ -71369,7 +72620,7 @@ class McpOAuthProvider {
     const clientInfo = await getOrRegisterClient({
       registrationEndpoint: metadata.registrationEndpoint,
       serverIdentifier: this.serverUrl,
-      clientName: PLUGIN_NAME,
+      clientName: "evil-omo",
       redirectUris: [this.redirectUrl()],
       tokenEndpointAuthMethod: "none",
       clientId: this.configClientId,
@@ -71396,33 +72647,34 @@ class McpOAuthProvider {
         ...metadata.resource ? { resource: metadata.resource } : {}
       }).toString()
     });
-    if (!tokenResponse.ok) {
-      let errorDetail = `${tokenResponse.status}`;
-      try {
-        const body = await tokenResponse.json();
-        if (body.error) {
-          errorDetail = `${tokenResponse.status} ${body.error}`;
-          if (body.error_description) {
-            errorDetail += `: ${body.error_description}`;
-          }
-        }
-      } catch {}
-      throw new Error(`Token exchange failed: ${errorDetail}`);
-    }
-    const tokenData = await tokenResponse.json();
-    const accessToken = tokenData.access_token;
-    if (typeof accessToken !== "string") {
-      throw new Error("Token response missing access_token");
+    const tokenData = await parseTokenResponse(tokenResponse);
+    const oauthTokenData = buildOAuthTokenData(tokenData, clientInfo);
+    this.saveTokens(oauthTokenData);
+    return oauthTokenData;
+  }
+  async refresh(refreshToken) {
+    const metadata = await discoverOAuthServerMetadata(this.serverUrl);
+    const clientInfo = this.clientInformation();
+    const clientId = clientInfo?.clientId ?? this.configClientId;
+    if (!clientId) {
+      throw new Error("No client information available. Run login() or register a client first.");
     }
-    const oauthTokenData = {
-      accessToken,
-      refreshToken: typeof tokenData.refresh_token === "string" ? tokenData.refresh_token : undefined,
-      expiresAt: typeof tokenData.expires_in === "number" ? Math.floor(Date.now() / 1000) + tokenData.expires_in : undefined,
-      clientInfo: {
-        clientId: clientInfo.clientId,
-        clientSecret: clientInfo.clientSecret
-      }
-    };
+    const tokenResponse = await fetch(metadata.tokenEndpoint, {
+      method: "POST",
+      headers: { "content-type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: refreshToken,
+        client_id: clientId,
+        ...clientInfo?.clientSecret ? { client_secret: clientInfo.clientSecret } : {},
+        ...metadata.resource ? { resource: metadata.resource } : {}
+      }).toString()
+    });
+    const tokenData = await parseTokenResponse(tokenResponse);
+    const oauthTokenData = buildOAuthTokenData(tokenData, {
+      clientId,
+      ...clientInfo?.clientSecret ? { clientSecret: clientInfo.clientSecret } : {}
+    }, refreshToken);
     this.saveTokens(oauthTokenData);
     return oauthTokenData;
   }
@@ -71560,7 +72812,7 @@ Examples:
 Model Providers (Priority: Native > Copilot > OpenCode Zen > Z.ai > Kimi):
   Claude        Native anthropic/ models (Opus, Sonnet, Haiku)
   OpenAI        Native openai/ models (GPT-5.4 for Oracle)
-  Gemini        Native google/ models (Gemini 3 Pro, Flash)
+  Gemini        Native google/ models (Gemini 3.1 Pro, Flash)
   Copilot       github-copilot/ models (fallback)
   OpenCode Zen  opencode/ models (opencode/claude-opus-4-6, etc.)
    Z.ai          zai-coding-plan/glm-5 (visual-engineering fallback)
@@ -71660,6 +72912,14 @@ Examples:
   const exitCode = await doctor(doctorOptions);
   process.exit(exitCode);
 });
+program2.command("refresh-model-capabilities").description("Refresh the cached models.dev-based model capabilities snapshot").option("-d, --directory <path>", "Working directory to read evil-omo config from").option("--source-url <url>", "Override the models.dev source URL").option("--json", "Output refresh summary as JSON").action(async (options) => {
+  const exitCode = await refreshModelCapabilities({
+    directory: options.directory,
+    sourceUrl: options.sourceUrl,
+    json: options.json ?? false
+  });
+  process.exit(exitCode);
+});
 program2.command("version").description("Show version information").action(() => {
   console.log(`evil-omo v${VERSION2}`);
 });