evil-omo 3.15.2 → 3.15.3

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,8 +5971,30 @@ 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 parseJsonc(content) {
   const errors = [];
   const result = parse2(content, errors, {
@@ -5806,202 +6018,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;
-  }
-  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;
+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 (options?.preferResponseOnMissingData === true) {
-    return response;
+  if (legacyResult.format !== "none") {
+    return legacyResult;
   }
-  return fallback;
+  return { format: "none", path: join4(dir, `${CONFIG_BASENAME}.json`) };
 }
-
-// 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");
-}
-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 = {};
@@ -6277,9 +6312,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 +6324,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 +6360,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 +6376,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 +6388,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 +6880,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 +6901,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 +6921,7 @@ function createJsonFileCacheStore(options) {
     }
   }
   function has() {
-    return existsSync3(getCacheFilePath());
+    return existsSync4(getCacheFilePath());
   }
   function write(value) {
     ensureCacheDir();
@@ -6974,14 +7090,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();
@@ -48294,17 +48410,43 @@ var init_hook_message_injector = __esm(() => {
 });
 
 // src/shared/opencode-storage-paths.ts
-import { join as join7 } from "path";
+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 = join7(OPENCODE_STORAGE, "message");
-  PART_STORAGE = join7(OPENCODE_STORAGE, "part");
-  SESSION_STORAGE = join7(OPENCODE_STORAGE, "session");
+  MESSAGE_STORAGE = join9(OPENCODE_STORAGE, "message");
+  PART_STORAGE = join9(OPENCODE_STORAGE, "part");
+  SESSION_STORAGE = join9(OPENCODE_STORAGE, "session");
 });
 
 // src/shared/opencode-message-dir.ts
+import { existsSync as existsSync6, readdirSync } from "fs";
+import { join as join10 } from "path";
+function getMessageDir(sessionID) {
+  if (!sessionID.startsWith("ses_"))
+    return null;
+  if (/[/\\]|\.\./.test(sessionID))
+    return null;
+  if (!existsSync6(MESSAGE_STORAGE))
+    return null;
+  const directPath = join10(MESSAGE_STORAGE, sessionID);
+  if (existsSync6(directPath)) {
+    return directPath;
+  }
+  try {
+    for (const dir of readdirSync(MESSAGE_STORAGE)) {
+      const sessionPath = join10(MESSAGE_STORAGE, dir, sessionID);
+      if (existsSync6(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();
@@ -48591,6 +48733,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 +48748,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
@@ -48741,16 +48885,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 +48934,17 @@ 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/ensure-config-directory-exists.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3 } from "fs";
 function ensureConfigDirectoryExists() {
   const configDir = getConfigDir();
-  if (!existsSync5(configDir)) {
-    mkdirSync2(configDir, { recursive: true });
+  if (!existsSync7(configDir)) {
+    mkdirSync3(configDir, { recursive: true });
   }
 }
 var init_ensure_config_directory_exists = __esm(() => {
@@ -48838,14 +48981,14 @@ function formatErrorWithSuggestion(err, context) {
 }
 
 // src/cli/config-manager/opencode-config-format.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 function detectConfigFormat() {
   const configJsonc = getConfigJsonc();
   const configJson = getConfigJson();
-  if (existsSync6(configJsonc)) {
+  if (existsSync8(configJsonc)) {
     return { format: "jsonc", path: configJsonc };
   }
-  if (existsSync6(configJson)) {
+  if (existsSync8(configJson)) {
     return { format: "json", path: configJson };
   }
   return { format: "none", path: configJson };
@@ -48901,7 +49044,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 +49062,28 @@ 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 };
-      }
-      plugins[existingPlugin.index] = pluginEntry;
+    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 normalizedPlugins = [...otherPlugins];
+    if (canonicalEntries.length > 0) {
+      normalizedPlugins.push(canonicalEntries[0]);
+    } else if (legacyEntries.length > 0) {
+      const versionMatch = legacyEntries[0].match(/@(.+)$/);
+      const preservedVersion = versionMatch ? versionMatch[1] : null;
+      normalizedPlugins.push(preservedVersion ? `${PLUGIN_NAME}@${preservedVersion}` : pluginEntry);
     } 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 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 +49105,13 @@ async function addPluginToOpenCodeConfig(currentVersion) {
     };
   }
 }
-var PACKAGE_NAME;
 var init_add_plugin_to_opencode_config = __esm(() => {
-  init_plugin_identity();
+  init_shared();
   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
@@ -49092,7 +49237,7 @@ function generateModelConfig(config) {
   for (const [role, req] of Object.entries(CLI_AGENT_MODEL_REQUIREMENTS)) {
     if (role === "librarian") {
       if (avail.opencodeGo) {
-        agents[role] = { model: "opencode-go/minimax-m2.5" };
+        agents[role] = { model: "opencode-go/minimax-m2.7" };
       } else if (avail.zai) {
         agents[role] = { model: ZAI_MODEL };
       }
@@ -49104,7 +49249,7 @@ function generateModelConfig(config) {
       } else if (avail.opencodeZen) {
         agents[role] = { model: "opencode/claude-haiku-4-5" };
       } else if (avail.opencodeGo) {
-        agents[role] = { model: "opencode-go/minimax-m2.5" };
+        agents[role] = { model: "opencode-go/minimax-m2.7" };
       } else if (avail.copilot) {
         agents[role] = { model: "github-copilot/gpt-5-mini" };
       } else {
@@ -49161,13 +49306,11 @@ 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}`;
 });
 
 // src/cli/config-manager/generate-omo-config.ts
@@ -49196,7 +49339,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 existsSync9, readFileSync as readFileSync6, statSync as statSync2, writeFileSync as writeFileSync4 } from "fs";
 function isEmptyOrWhitespace2(content) {
   return content.trim().length === 0;
 }
@@ -49211,13 +49354,12 @@ function writeOmoConfig(installConfig) {
     };
   }
   const omoConfigPath = getOmoConfigPath();
-  const existingConfigPath = getExistingOmoConfigPath() ?? omoConfigPath;
   try {
     const newConfig = generateOmoConfig(installConfig);
-    if (existsSync7(existingConfigPath)) {
+    if (existsSync9(omoConfigPath)) {
       try {
-        const stat = statSync2(existingConfigPath);
-        const content = readFileSync6(existingConfigPath, "utf-8");
+        const stat = statSync2(omoConfigPath);
+        const content = readFileSync6(omoConfigPath, "utf-8");
         if (stat.size === 0 || isEmptyOrWhitespace2(content)) {
           writeFileSync4(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
 `);
@@ -49230,7 +49372,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) {
@@ -49346,7 +49487,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 +49499,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 existsSync10, readFileSync as readFileSync7 } from "fs";
 function detectProvidersFromOmoConfig() {
-  const omoConfigPath = getExistingOmoConfigPath();
-  if (!omoConfigPath || !existsSync8(omoConfigPath)) {
+  const omoConfigPath = getOmoConfigPath();
+  if (!existsSync10(omoConfigPath)) {
     return {
       hasOpenAI: true,
       hasOpencodeZen: true,
@@ -49399,6 +49540,9 @@ function detectProvidersFromOmoConfig() {
     };
   }
 }
+function isOurPlugin(plugin) {
+  return plugin === PLUGIN_NAME || plugin.startsWith(`${PLUGIN_NAME}@`) || plugin === LEGACY_PLUGIN_NAME || plugin.startsWith(`${LEGACY_PLUGIN_NAME}@`);
+}
 function detectCurrentConfig() {
   const result = {
     isInstalled: false,
@@ -49422,7 +49566,7 @@ function detectCurrentConfig() {
   }
   const openCodeConfig = parseResult.config;
   const plugins = openCodeConfig.plugin ?? [];
-  result.isInstalled = findManagedPluginEntry(plugins) !== null;
+  result.isInstalled = plugins.some(isOurPlugin);
   if (!result.isInstalled) {
     return result;
   }
@@ -49438,17 +49582,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 existsSync11 } from "fs";
+import { join as join11 } from "path";
 function getDefaultWorkspaceDir() {
-  return join8(getOpenCodeCacheDir(), "packages");
+  return join11(getOpenCodeCacheDir(), "packages");
 }
 function readProcessOutput(stream) {
   if (!stream) {
@@ -49474,7 +49617,7 @@ async function runBunInstallWithDetails(options) {
   const outputMode = options?.outputMode ?? "pipe";
   const cacheDir = options?.workspaceDir ?? getDefaultWorkspaceDir();
   const packageJsonPath = `${cacheDir}/package.json`;
-  if (!existsSync9(packageJsonPath)) {
+  if (!existsSync11(packageJsonPath)) {
     return {
       success: false,
       error: `Workspace not initialized: ${packageJsonPath} not found. OpenCode should create this on first run.`
@@ -49618,37 +49761,42 @@ 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_NAME = "oh-my-openagent", 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`;
+  NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/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");
+  INSTALLED_PACKAGE_JSON = path4.join(CACHE_DIR, "node_modules", PACKAGE_NAME, "package.json");
 });
 
 // src/hooks/auto-update-checker/checker/config-paths.ts
 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)) {
@@ -49685,7 +49833,7 @@ function getLocalDevPath(directory) {
       const config2 = JSON.parse(stripJsonComments(content));
       const plugins = config2.plugin ?? [];
       for (const entry of plugins) {
-        if (entry.startsWith("file://") && entry.includes(PACKAGE_NAME2)) {
+        if (entry.startsWith("file://") && entry.includes(PACKAGE_NAME)) {
           try {
             return fileURLToPath(entry);
           } catch {
@@ -49717,7 +49865,7 @@ function findPackageJsonUp(startPath) {
         try {
           const content = fs5.readFileSync(pkgPath, "utf-8");
           const pkg = JSON.parse(content);
-          if (pkg.name === PACKAGE_NAME2)
+          if (pkg.name === PACKAGE_NAME)
             return pkgPath;
         } catch {}
       }
@@ -49765,15 +49913,15 @@ 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) {
+      for (const entry of plugins) {
+        if (entry === PACKAGE_NAME) {
           return { entry, isPinned: false, pinnedVersion: null, configPath };
         }
-        const pinnedVersion = entry.slice(managedEntry.packageName.length + 1);
-        const isPinned = EXACT_SEMVER_REGEX.test(pinnedVersion.trim());
-        return { entry, isPinned, pinnedVersion, configPath };
+        if (entry.startsWith(`${PACKAGE_NAME}@`)) {
+          const pinnedVersion = entry.slice(PACKAGE_NAME.length + 1);
+          const isPinned = EXACT_SEMVER_REGEX.test(pinnedVersion.trim());
+          return { entry, isPinned, pinnedVersion, configPath };
+        }
       }
     } catch {
       continue;
@@ -49783,7 +49931,7 @@ function findPluginEntry(directory) {
 }
 var EXACT_SEMVER_REGEX;
 var init_plugin_entry = __esm(() => {
-  init_plugin_identity();
+  init_constants3();
   init_config_paths();
   EXACT_SEMVER_REGEX = /^\d+\.\d+\.\d+(-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?(\+[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?$/;
 });
@@ -49993,7 +50141,7 @@ function syncCachePackageJsonToIntent(pluginInfo) {
   if (!fs9.existsSync(cachePackageJsonPath)) {
     log("[auto-update-checker] Cache package.json missing, creating workspace package.json", { intentVersion });
     return {
-      ...writeCachePackageJson(cachePackageJsonPath, { dependencies: { [PACKAGE_NAME2]: intentVersion } }),
+      ...writeCachePackageJson(cachePackageJsonPath, { dependencies: { [PACKAGE_NAME]: intentVersion } }),
       message: `Created cache package.json with: ${intentVersion}`
     };
   }
@@ -50011,21 +50159,21 @@ function syncCachePackageJsonToIntent(pluginInfo) {
     log("[auto-update-checker] Failed to parse cache package.json:", err);
     return { synced: false, error: "parse_error", message: "Failed to parse cache package.json (malformed JSON)" };
   }
-  if (!pkgJson || !pkgJson.dependencies?.[PACKAGE_NAME2]) {
+  if (!pkgJson || !pkgJson.dependencies?.[PACKAGE_NAME]) {
     log("[auto-update-checker] Plugin missing from cache package.json dependencies, adding dependency", { intentVersion });
     const nextPkgJson = {
       ...pkgJson ?? {},
       dependencies: {
         ...pkgJson?.dependencies ?? {},
-        [PACKAGE_NAME2]: intentVersion
+        [PACKAGE_NAME]: intentVersion
       }
     };
     return {
       ...writeCachePackageJson(cachePackageJsonPath, nextPkgJson),
-      message: `Added ${PACKAGE_NAME2}: ${intentVersion}`
+      message: `Added ${PACKAGE_NAME}: ${intentVersion}`
     };
   }
-  const currentVersion = pkgJson.dependencies[PACKAGE_NAME2];
+  const currentVersion = pkgJson.dependencies[PACKAGE_NAME];
   if (currentVersion === intentVersion) {
     log("[auto-update-checker] Cache package.json already matches intent:", intentVersion);
     return { synced: false, error: null, message: `Already matches intent: ${intentVersion}` };
@@ -50037,7 +50185,7 @@ function syncCachePackageJsonToIntent(pluginInfo) {
   } else {
     log(`[auto-update-checker] Updating cache package.json: "${currentVersion}" \u2192 "${intentVersion}"`);
   }
-  pkgJson.dependencies[PACKAGE_NAME2] = intentVersion;
+  pkgJson.dependencies[PACKAGE_NAME] = intentVersion;
   return {
     ...writeCachePackageJson(cachePackageJsonPath, pkgJson),
     message: `Updated: "${currentVersion}" \u2192 "${intentVersion}"`
@@ -50103,10 +50251,11 @@ function removeFromBunLock(packageName) {
   }
   return false;
 }
-function invalidatePackage(packageName = PACKAGE_NAME2) {
+function invalidatePackage(packageName = PACKAGE_NAME) {
   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;
@@ -50167,8 +50316,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 existsSync22 } from "fs";
+import { join as join23 } from "path";
 function getCacheWorkspaceDir(deps) {
   return deps.join(deps.getOpenCodeCacheDir(), "packages");
 }
@@ -50178,8 +50327,8 @@ function getPinnedVersionToastMessage(latestVersion) {
 function resolveActiveInstallWorkspace(deps) {
   const configPaths = deps.getOpenCodeConfigPaths({ binary: "opencode" });
   const cacheDir = getCacheWorkspaceDir(deps);
-  const configInstallPath = deps.join(configPaths.configDir, "node_modules", PACKAGE_NAME2, "package.json");
-  const cacheInstallPath = deps.join(cacheDir, "node_modules", PACKAGE_NAME2, "package.json");
+  const configInstallPath = deps.join(configPaths.configDir, "node_modules", PACKAGE_NAME, "package.json");
+  const cacheInstallPath = deps.join(cacheDir, "node_modules", PACKAGE_NAME, "package.json");
   if (deps.existsSync(configInstallPath)) {
     deps.log(`[auto-update-checker] Active workspace: config-dir (${configPaths.configDir})`);
     return configPaths.configDir;
@@ -50225,8 +50374,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;
@@ -50258,7 +50407,7 @@ function createBackgroundUpdateCheckRunner(overrides = {}) {
       await deps.showUpdateAvailableToast(ctx, latestVersion, getToastMessage);
       return;
     }
-    deps.invalidatePackage(PACKAGE_NAME2);
+    deps.invalidatePackage(PACKAGE_NAME);
     const activeWorkspace = resolveActiveInstallWorkspace(deps);
     const installSuccess = await runBunInstallSafe(activeWorkspace, deps);
     if (installSuccess) {
@@ -50286,8 +50435,8 @@ var init_background_update_check = __esm(() => {
   init_checker();
   init_update_toasts();
   defaultDeps = {
-    existsSync: existsSync20,
-    join: join19,
+    existsSync: existsSync22,
+    join: join23,
     runBunInstallWithDetails,
     log,
     getOpenCodeCacheDir,
@@ -50496,9 +50645,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 +50716,7 @@ var {
 // package.json
 var package_default = {
   name: "evil-omo",
-  version: "3.15.2",
+  version: "3.15.3",
   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",
@@ -50645,17 +50794,17 @@ 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"
+    "evil-omo-darwin-arm64": "3.15.3",
+    "evil-omo-darwin-x64": "3.15.3",
+    "evil-omo-darwin-x64-baseline": "3.15.3",
+    "evil-omo-linux-x64": "3.15.3",
+    "evil-omo-linux-x64-baseline": "3.15.3",
+    "evil-omo-linux-arm64": "3.15.3",
+    "evil-omo-linux-x64-musl": "3.15.3",
+    "evil-omo-linux-x64-musl-baseline": "3.15.3",
+    "evil-omo-linux-arm64-musl": "3.15.3",
+    "evil-omo-windows-x64": "3.15.3",
+    "evil-omo-windows-x64-baseline": "3.15.3"
   },
   overrides: {
     "@opencode-ai/sdk": "^1.2.24"
@@ -50668,6 +50817,7 @@ var package_default = {
 };
 
 // src/cli/cli-installer.ts
+init_shared();
 init_config_manager();
 var import_picocolors2 = __toESM(require_picocolors(), 1);
 
@@ -50826,7 +50976,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,7 +50987,7 @@ 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");
@@ -50849,14 +50999,14 @@ async function runCliInstaller(args, version) {
     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...");
+  printStep(step++, totalSteps, `Writing ${PLUGIN_NAME} configuration...`);
   const omoResult = writeOmoConfig(config);
   if (!omoResult.success) {
     printError(`Failed: ${omoResult.error}`);
@@ -50884,7 +51034,7 @@ async function runCliInstaller(args, version) {
   console.log(`  Run ${import_picocolors2.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,
+` + `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")}`);
@@ -51481,6 +51631,7 @@ var Y2 = ({ indicator: t = "dots" } = {}) => {
 };
 
 // src/cli/tui-installer.ts
+init_shared();
 init_config_manager();
 var import_picocolors4 = __toESM(require_picocolors(), 1);
 
@@ -51611,7 +51762,7 @@ 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("[!]")}`);
     M2.warn("OpenCode binary not found. Plugin will be configured, but you'll need to install OpenCode to use it.");
@@ -51622,7 +51773,7 @@ async function runTuiInstaller(args, version) {
   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}`);
@@ -51630,7 +51781,7 @@ async function runTuiInstaller(args, version) {
     return 1;
   }
   spinner.stop(`Plugin added to ${import_picocolors4.default.cyan(pluginResult.configPath)}`);
-  spinner.start("Writing evil-omo configuration");
+  spinner.start(`Writing ${PLUGIN_NAME} configuration`);
   const omoResult = writeOmoConfig(config);
   if (!omoResult.success) {
     spinner.stop(`Failed to write config: ${omoResult.error}`);
@@ -51658,7 +51809,7 @@ async function runTuiInstaller(args, version) {
   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,
+` + `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")}`);
@@ -66618,7 +66769,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 +66781,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(`
 `);
@@ -68043,7 +68194,7 @@ var import_picocolors9 = __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, join as join13 } from "path";
 var OPENCODE_COMMANDS = ["opencode", "opencode-desktop"];
 var WINDOWS_SUFFIXES = ["", ".exe", ".cmd", ".bat", ".ps1"];
 function getCommandCandidates(platform) {
@@ -68066,7 +68217,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(join13(entry, command));
     }
   }
   return candidates;
@@ -68200,7 +68351,6 @@ async function createServerConnection(options) {
 
 // src/cli/run/session-resolver.ts
 var import_picocolors10 = __toESM(require_picocolors(), 1);
-init_plugin_identity();
 var SESSION_CREATE_MAX_RETRIES = 3;
 var SESSION_CREATE_RETRY_DELAY_MS = 1000;
 async function resolveSession(options) {
@@ -68218,7 +68368,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: "*" }
         ]
@@ -68450,15 +68600,15 @@ var BOULDER_STATE_PATH = `${BOULDER_DIR}/${BOULDER_FILE}`;
 var NOTEPAD_DIR = "notepads";
 var NOTEPAD_BASE_PATH = `${BOULDER_DIR}/${NOTEPAD_DIR}`;
 // src/features/boulder-state/storage.ts
-import { existsSync as 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 existsSync13, readFileSync as readFileSync9, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, readdirSync as readdirSync2 } from "fs";
+import { dirname as dirname2, join as join14, basename } from "path";
 var RESERVED_KEYS = new Set(["__proto__", "prototype", "constructor"]);
 function getBoulderFilePath(directory) {
-  return join11(directory, BOULDER_DIR, BOULDER_FILE);
+  return join14(directory, BOULDER_DIR, BOULDER_FILE);
 }
 function readBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
-  if (!existsSync11(filePath)) {
+  if (!existsSync13(filePath)) {
     return null;
   }
   try {
@@ -68470,6 +68620,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 = {};
     }
@@ -68479,7 +68638,7 @@ function readBoulderState(directory) {
   }
 }
 function getPlanProgress(planPath) {
-  if (!existsSync11(planPath)) {
+  if (!existsSync13(planPath)) {
     return { total: 0, completed: 0, isComplete: true };
   }
   try {
@@ -68497,17 +68656,26 @@ function getPlanProgress(planPath) {
     return { total: 0, completed: 0, isComplete: true };
   }
 }
+// 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 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 existsSync14, mkdirSync as mkdirSync5, readFileSync as readFileSync10, rmSync, writeFileSync as writeFileSync6 } from "fs";
+import { join as join15 } from "path";
 function getMarkerPath(directory, sessionID) {
-  return join12(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
+  return join15(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
 }
 function readContinuationMarker(directory, sessionID) {
   const markerPath = getMarkerPath(directory, sessionID);
-  if (!existsSync12(markerPath))
+  if (!existsSync14(markerPath))
     return null;
   try {
     const raw = readFileSync10(markerPath, "utf-8");
@@ -68533,10 +68701,113 @@ 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();
+import { readFileSync as readFileSync11, readdirSync as readdirSync3 } from "fs";
+import { join as join16 } from "path";
+function isCompactionAgent(agent) {
+  return typeof agent === "string" && agent.toLowerCase() === "compaction";
+}
+function getLastAgentFromMessageDir(messageDir) {
+  try {
+    const messages = readdirSync3(messageDir).filter((fileName) => fileName.endsWith(".json")).map((fileName) => {
+      try {
+        const content = readFileSync11(join16(messageDir, fileName), "utf-8");
+        const parsed = JSON.parse(content);
+        return {
+          fileName,
+          agent: parsed.agent,
+          createdAt: typeof parsed.time?.created === "number" ? parsed.time.created : Number.NEGATIVE_INFINITY
+        };
+      } catch {
+        return null;
+      }
+    }).filter((message) => message !== null).sort((left, right) => right.createdAt - left.createdAt || right.fileName.localeCompare(left.fileName));
+    for (const message of messages) {
+      if (typeof message.agent === "string" && !isCompactionAgent(message.agent)) {
+        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) {
+        const agent = message.info?.agent;
+        if (typeof agent === "string" && !isCompactionAgent(agent)) {
+          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 existsSync15, readFileSync as readFileSync12, writeFileSync as writeFileSync7, unlinkSync, mkdirSync as mkdirSync6 } from "fs";
+import { dirname as dirname3, join as join17 } from "path";
 
 // src/hooks/ralph-loop/constants.ts
 var DEFAULT_STATE_FILE = ".sisyphus/ralph-loop.local.md";
@@ -68545,15 +68816,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 ? join17(directory, customPath) : join17(directory, DEFAULT_STATE_FILE);
 }
 function readState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
-  if (!existsSync13(filePath)) {
+  if (!existsSync15(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync11(filePath, "utf-8");
+    const content = readFileSync12(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     const active = data.active;
     const iteration = data.iteration;
@@ -68593,10 +68864,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 +68875,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 +68931,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);
@@ -69221,7 +69526,7 @@ async function getLocalVersion(options = {}) {
   }
 }
 // src/cli/doctor/constants.ts
-init_plugin_identity();
+init_shared();
 var import_picocolors16 = __toESM(require_picocolors(), 1);
 var SYMBOLS3 = {
   check: import_picocolors16.default.green("\u2713"),
@@ -69255,34 +69560,34 @@ var EXIT_CODES = {
   FAILURE: 1
 };
 var MIN_OPENCODE_VERSION = "1.0.150";
-var PACKAGE_NAME3 = PLUGIN_NAME;
+var PACKAGE_NAME2 = 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 existsSync26, readFileSync as readFileSync22 } from "fs";
 
 // src/cli/doctor/checks/system-binary.ts
 init_spawn_with_windows_hide();
-import { existsSync as existsSync21 } from "fs";
+import { existsSync as existsSync23 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join20 } from "path";
+import { join as join24 } 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")
+        join24(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(join24(programFiles, "OpenCode", "OpenCode.exe"));
       }
       if (localAppData) {
-        paths.push(join20(localAppData, "OpenCode", "OpenCode.exe"));
+        paths.push(join24(localAppData, "OpenCode", "OpenCode.exe"));
       }
       return paths;
     }
@@ -69290,8 +69595,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")
+        join24(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
+        join24(home, "Applications", "opencode-desktop-linux-aarch64.AppImage")
       ];
     default:
       return [];
@@ -69303,7 +69608,7 @@ function buildVersionCommand(binaryPath, platform) {
   }
   return [binaryPath, "--version"];
 }
-function findDesktopBinary(platform = process.platform, checkExists = existsSync21) {
+function findDesktopBinary(platform = process.platform, checkExists = existsSync23) {
   for (const desktopPath of getDesktopAppPaths(platform)) {
     if (checkExists(desktopPath)) {
       return { binary: "opencode", path: desktopPath };
@@ -69320,7 +69625,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 +69638,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 compareVersions2(current, minimum) {
+  const parseVersion2 = (version2) => version2.replace(/^v/, "").split("-")[0].split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const currentParts = parseVersion2(current);
+  const minimumParts = parseVersion2(minimum);
   const length = Math.max(currentParts.length, minimumParts.length);
   for (let index = 0;index < length; index++) {
     const currentPart = currentParts[index] ?? 0;
@@ -69351,12 +69656,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 existsSync24, readFileSync as readFileSync20 } from "fs";
 function detectConfigPath() {
   const paths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
-  if (existsSync22(paths.configJsonc))
+  if (existsSync24(paths.configJsonc))
     return paths.configJsonc;
-  if (existsSync22(paths.configJson))
+  if (existsSync24(paths.configJson))
     return paths.configJson;
   return null;
 }
@@ -69402,7 +69707,7 @@ function getPluginInfo() {
     };
   }
   try {
-    const content = readFileSync19(configPath, "utf-8");
+    const content = readFileSync20(configPath, "utf-8");
     const parsedConfig = parseJsonc(content);
     const pluginEntry = findPluginEntry2(parsedConfig.plugin ?? []);
     if (!pluginEntry) {
@@ -69440,37 +69745,37 @@ function getPluginInfo() {
 init_file_utils();
 init_checker();
 init_auto_update_checker();
-import { existsSync as existsSync23, readFileSync as readFileSync20 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync21 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join21 } from "path";
+import { join as join25 } from "path";
 init_shared();
 function getPlatformDefaultCacheDir(platform = process.platform) {
   if (platform === "darwin")
-    return join21(homedir6(), "Library", "Caches");
+    return join25(homedir6(), "Library", "Caches");
   if (platform === "win32")
-    return process.env.LOCALAPPDATA ?? join21(homedir6(), "AppData", "Local");
-  return join21(homedir6(), ".cache");
+    return process.env.LOCALAPPDATA ?? join25(homedir6(), "AppData", "Local");
+  return join25(homedir6(), ".cache");
 }
 function resolveOpenCodeCacheDir() {
   const xdgCacheHome = process.env.XDG_CACHE_HOME;
   if (xdgCacheHome)
-    return join21(xdgCacheHome, "opencode");
+    return join25(xdgCacheHome, "opencode");
   const fromShared = getOpenCodeCacheDir();
-  const platformDefault = join21(getPlatformDefaultCacheDir(), "opencode");
-  if (existsSync23(fromShared) || !existsSync23(platformDefault))
+  const platformDefault = join25(getPlatformDefaultCacheDir(), "opencode");
+  if (existsSync25(fromShared) || !existsSync25(platformDefault))
     return fromShared;
   return platformDefault;
 }
 function resolveExistingDir(dirPath) {
-  if (!existsSync23(dirPath))
+  if (!existsSync25(dirPath))
     return dirPath;
   return resolveSymlink(dirPath);
 }
 function readPackageJson(filePath) {
-  if (!existsSync23(filePath))
+  if (!existsSync25(filePath))
     return null;
   try {
-    const content = readFileSync20(filePath, "utf-8");
+    const content = readFileSync21(filePath, "utf-8");
     return parseJsonc(content);
   } catch {
     return null;
@@ -69489,20 +69794,20 @@ function getLoadedPluginVersion() {
   const candidates = [
     {
       cacheDir: configDir,
-      cachePackagePath: join21(configDir, "package.json"),
-      installedPackagePath: join21(configDir, "node_modules", PACKAGE_NAME3, "package.json")
+      cachePackagePath: join25(configDir, "package.json"),
+      installedPackagePath: join25(configDir, "node_modules", PACKAGE_NAME2, "package.json")
     },
     {
       cacheDir,
-      cachePackagePath: join21(cacheDir, "package.json"),
-      installedPackagePath: join21(cacheDir, "node_modules", PACKAGE_NAME3, "package.json")
+      cachePackagePath: join25(cacheDir, "package.json"),
+      installedPackagePath: join25(cacheDir, "node_modules", PACKAGE_NAME2, "package.json")
     }
   ];
-  const selectedCandidate = candidates.find((candidate) => existsSync23(candidate.installedPackagePath)) ?? candidates[0];
+  const selectedCandidate = candidates.find((candidate) => existsSync25(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_NAME2]);
   const loadedVersion = normalizeVersion(installedPackage?.version);
   return {
     cacheDir: selectedDir,
@@ -69522,13 +69827,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 (!existsSync26(configPath))
     return false;
   try {
-    parseJsonc(readFileSync21(configPath, "utf-8"));
+    parseJsonc(readFileSync22(configPath, "utf-8"));
     return true;
   } catch {
     return false;
@@ -69551,7 +69857,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 +69885,7 @@ async function checkSystem() {
       affects: ["doctor", "run"]
     });
   }
-  if (systemInfo.opencodeVersion && !compareVersions(systemInfo.opencodeVersion, MIN_OPENCODE_VERSION)) {
+  if (systemInfo.opencodeVersion && !compareVersions2(systemInfo.opencodeVersion, MIN_OPENCODE_VERSION)) {
     issues.push({
       title: "OpenCode version below minimum",
       description: `Detected ${systemInfo.opencodeVersion}; required >= ${MIN_OPENCODE_VERSION}.`,
@@ -69590,13 +69896,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 +69925,11 @@ async function checkSystem() {
       affects: ["plugin loading"]
     });
   }
-  if (systemInfo.loadedVersion && latestVersion && !compareVersions(systemInfo.loadedVersion, latestVersion)) {
+  if (systemInfo.loadedVersion && latestVersion && !compareVersions2(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 +69950,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 readFileSync25 } from "fs";
+import { join as join29 } 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 existsSync27, readFileSync as readFileSync23 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join22 } from "path";
+import { join as join26 } from "path";
 function getOpenCodeCacheDir2() {
   const xdgCache = process.env.XDG_CACHE_HOME;
   if (xdgCache)
-    return join22(xdgCache, "opencode");
-  return join22(homedir7(), ".cache", "opencode");
+    return join26(xdgCache, "opencode");
+  return join26(homedir7(), ".cache", "opencode");
 }
 function loadAvailableModelsFromCache() {
-  const cacheFile = join22(getOpenCodeCacheDir2(), "models.json");
-  if (!existsSync25(cacheFile)) {
+  const cacheFile = join26(getOpenCodeCacheDir2(), "models.json");
+  if (!existsSync27(cacheFile)) {
     return { providers: [], modelCount: 0, cacheExists: false };
   }
   try {
-    const content = readFileSync22(cacheFile, "utf-8");
+    const content = readFileSync23(cacheFile, "utf-8");
     const data = parseJsonc(content);
     const providers = Object.keys(data);
     let modelCount = 0;
@@ -69675,25 +69993,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 readFileSync24 } from "fs";
+import { join as join27 } from "path";
+var PROJECT_CONFIG_DIR = join27(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 = readFileSync24(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 = readFileSync24(userDetected.path, "utf-8");
       return parseJsonc(content);
     } catch {
       return null;
@@ -69704,7 +70021,7 @@ function loadOmoConfig() {
 
 // src/cli/doctor/checks/model-resolution-details.ts
 init_shared();
-import { join as join24 } from "path";
+import { join as join28 } from "path";
 
 // src/cli/doctor/checks/model-resolution-variant.ts
 function formatModelWithVariant(model, variant) {
@@ -69746,7 +70063,7 @@ function formatCapabilityResolutionLabel(mode) {
 }
 function buildModelResolutionDetails(options) {
   const details = [];
-  const cacheFile = join24(getOpenCodeCacheDir(), "models.json");
+  const cacheFile = join28(getOpenCodeCacheDir(), "models.json");
   details.push("\u2550\u2550\u2550 Available Models (from cache) \u2550\u2550\u2550");
   details.push("");
   if (options.available.cacheExists) {
@@ -69901,11 +70218,13 @@ async function checkModels() {
 }
 
 // src/cli/doctor/checks/config.ts
+var PROJECT_CONFIG_DIR2 = join29(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 +70235,7 @@ function validateConfig() {
     return { exists: false, path: null, valid: true, config: null, errors: [] };
   }
   try {
-    const content = readFileSync24(configPath, "utf-8");
+    const content = readFileSync25(configPath, "utf-8");
     const rawConfig = parseJsonc(content);
     const schemaResult = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
     if (!schemaResult.success) {
@@ -70020,9 +70339,9 @@ async function checkConfig() {
 
 // src/cli/doctor/checks/dependencies.ts
 init_spawn_with_windows_hide();
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname7, join as join26 } from "path";
+import { dirname as dirname7, join as join30 } from "path";
 async function checkBinaryExists(binary2) {
   try {
     const path10 = Bun.which(binary2);
@@ -70078,15 +70397,15 @@ async function checkAstGrepNapi() {
       path: null
     };
   } catch {
-    const { existsSync: existsSync27 } = await import("fs");
-    const { join: join27 } = await import("path");
+    const { existsSync: existsSync29 } = await import("fs");
+    const { join: join31 } = 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")
+      join31(homedir8(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
+      join31(process.cwd(), "node_modules", "@ast-grep", "napi")
     ];
     for (const napiPath of pathsToCheck) {
-      if (existsSync27(napiPath)) {
+      if (existsSync29(napiPath)) {
         return {
           name: "AST-Grep NAPI",
           required: false,
@@ -70111,8 +70430,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 = join30(dirname7(pkgPath), "bin", binaryName);
+    if (existsSync28(binaryPath))
       return binaryPath;
   } catch {}
   return null;
@@ -70269,16 +70588,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 existsSync29, readFileSync as readFileSync26 } from "fs";
+import { join as join31 } from "path";
 init_shared();
 init_jsonc_parser();
-init_plugin_identity();
 function loadJsonFile(path10) {
-  if (!existsSync27(path10))
+  if (!existsSync29(path10))
     return null;
   try {
-    return parseJsonc(readFileSync25(path10, "utf-8"));
+    return parseJsonc(readFileSync26(path10, "utf-8"));
   } catch {
     return null;
   }
@@ -70287,9 +70605,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(join31(cwd, ".opencode")).path,
+    user: detectPluginConfigFile(configDir).path,
+    opencode: detectConfigFile(join31(configDir, "opencode")).path
   };
 }
 function loadAllConfigs() {
@@ -70358,21 +70676,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 existsSync30 } from "fs";
+import { delimiter as delimiter2, join as join33 } from "path";
 
 // src/tools/lsp/server-path-bases.ts
 init_shared();
-import { join as join28 } from "path";
+import { join as join32 } from "path";
 function getLspServerAdditionalPathBases(workingDirectory) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join28(getDataDir(), "opencode");
+  const dataDir = join32(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")
+    join32(workingDirectory, "node_modules", ".bin"),
+    join32(configDir, "bin"),
+    join32(configDir, "node_modules", ".bin"),
+    join32(dataDir, "bin"),
+    join32(dataDir, "bin", "node_modules", ".bin")
   ];
 }
 
@@ -70382,7 +70700,7 @@ function isServerInstalled(command) {
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync28(cmd))
+    if (existsSync30(cmd))
       return true;
   }
   const isWindows = process.platform === "win32";
@@ -70403,14 +70721,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 (existsSync30(join33(p2, cmd + suffix))) {
         return true;
       }
     }
   }
   for (const base of getLspServerAdditionalPathBases(process.cwd())) {
     for (const suffix of exts) {
-      if (existsSync28(join29(base, cmd + suffix))) {
+      if (existsSync30(join33(base, cmd + suffix))) {
         return true;
       }
     }
@@ -70472,24 +70790,24 @@ function getInstalledLspServers() {
 
 // src/cli/doctor/checks/tools-mcp.ts
 init_shared();
-import { existsSync as existsSync29, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync31, readFileSync as readFileSync27 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join30 } from "path";
+import { join as join34 } 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")
+    join34(homedir8(), ".claude", ".mcp.json"),
+    join34(process.cwd(), ".mcp.json"),
+    join34(process.cwd(), ".claude", ".mcp.json")
   ];
 }
 function loadUserMcpConfig() {
   const servers = {};
   for (const configPath of getMcpConfigPaths()) {
-    if (!existsSync29(configPath))
+    if (!existsSync31(configPath))
       continue;
     try {
-      const content = readFileSync26(configPath, "utf-8");
+      const content = readFileSync27(configPath, "utf-8");
       const config2 = parseJsonc(content);
       if (config2.mcpServers) {
         Object.assign(servers, config2.mcpServers);
@@ -70689,7 +71007,6 @@ function formatIssue(issue2, index) {
 }
 
 // src/cli/doctor/format-default.ts
-init_plugin_identity();
 function formatDefault(result) {
   const lines = [];
   lines.push(formatHeader());
@@ -70697,7 +71014,7 @@ 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(SYMBOLS3.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;
@@ -70745,7 +71062,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 +71069,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 +71226,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 existsSync32, mkdirSync as mkdirSync8, readFileSync as readFileSync28, unlinkSync as unlinkSync4, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname8, join as join35 } from "path";
 var STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStoragePath() {
-  return join31(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
+  return join35(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
 }
 function normalizeHost(serverHost) {
   let host = serverHost.trim();
@@ -70953,11 +71301,11 @@ function buildKey(serverHost, resource) {
 }
 function readStore() {
   const filePath = getMcpOauthStoragePath();
-  if (!existsSync30(filePath)) {
+  if (!existsSync32(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync27(filePath, "utf-8");
+    const content = readFileSync28(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -70967,8 +71315,8 @@ function writeStore(store2) {
   const filePath = getMcpOauthStoragePath();
   try {
     const dir = dirname8(filePath);
-    if (!existsSync30(dir)) {
-      mkdirSync7(dir, { recursive: true });
+    if (!existsSync32(dir)) {
+      mkdirSync8(dir, { recursive: true });
     }
     writeFileSync10(filePath, JSON.stringify(store2, null, 2), { encoding: "utf-8", mode: 384 });
     chmodSync(filePath, 384);
@@ -71002,7 +71350,7 @@ function deleteToken(serverHost, resource) {
   if (Object.keys(store2).length === 0) {
     try {
       const filePath = getMcpOauthStoragePath();
-      if (existsSync30(filePath)) {
+      if (existsSync32(filePath)) {
         unlinkSync4(filePath);
       }
       return true;
@@ -71225,7 +71573,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 +71583,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 +71593,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();
@@ -71281,27 +71629,25 @@ 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();
-
 class McpOAuthProvider {
   serverUrl;
   configClientId;
@@ -71369,7 +71715,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,
@@ -71560,7 +71906,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 +72006,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}`);
 });