oh-my-opencode 3.15.1 → 3.15.3

package/dist/cli/index.js

@@ -6360,25 +6360,95 @@ function getOpenCodeConfigPaths(options) {
     configJson: join4(configDir, "opencode.json"),
     configJsonc: join4(configDir, "opencode.jsonc"),
     packageJson: join4(configDir, "package.json"),
-    omoConfig: join4(configDir, "oh-my-opencode.json")
+    omoConfig: join4(configDir, `${CONFIG_BASENAME}.json`)
   };
 }
 var TAURI_APP_IDENTIFIER = "ai.opencode.desktop", TAURI_APP_IDENTIFIER_DEV = "ai.opencode.desktop.dev";
 var init_opencode_config_dir = () => {};
 
 // src/shared/opencode-version.ts
-var NOT_CACHED;
+import { execSync } from "child_process";
+function parseVersion(version) {
+  const cleaned = version.replace(/^v/, "").split("-")[0];
+  return cleaned.split(".").map((n) => parseInt(n, 10) || 0);
+}
+function compareVersions(a, b) {
+  const partsA = parseVersion(a);
+  const partsB = parseVersion(b);
+  const maxLen = Math.max(partsA.length, partsB.length);
+  for (let i2 = 0;i2 < maxLen; i2++) {
+    const numA = partsA[i2] ?? 0;
+    const numB = partsB[i2] ?? 0;
+    if (numA < numB)
+      return -1;
+    if (numA > numB)
+      return 1;
+  }
+  return 0;
+}
+function getOpenCodeVersion() {
+  if (cachedVersion !== NOT_CACHED) {
+    return cachedVersion;
+  }
+  try {
+    const result = execSync("opencode --version", {
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const versionMatch = result.match(/(\d+\.\d+\.\d+(?:-[\w.]+)?)/);
+    cachedVersion = versionMatch?.[1] ?? null;
+    return cachedVersion;
+  } catch {
+    cachedVersion = null;
+    return null;
+  }
+}
+function isOpenCodeVersionAtLeast(version) {
+  const current = getOpenCodeVersion();
+  if (!current)
+    return true;
+  return compareVersions(current, version) >= 0;
+}
+var OPENCODE_SQLITE_VERSION = "1.1.53", NOT_CACHED, cachedVersion;
 var init_opencode_version = __esm(() => {
   NOT_CACHED = Symbol("NOT_CACHED");
+  cachedVersion = NOT_CACHED;
 });
 
 // src/shared/opencode-storage-detection.ts
-var NOT_CACHED2, FALSE_PENDING_RETRY;
+import { existsSync as existsSync3 } from "fs";
+import { join as join5 } from "path";
+function isSqliteBackend() {
+  if (cachedResult === true)
+    return true;
+  if (cachedResult === false)
+    return false;
+  const check = () => {
+    const versionOk = isOpenCodeVersionAtLeast(OPENCODE_SQLITE_VERSION);
+    const dbPath = join5(getDataDir(), "opencode", "opencode.db");
+    return versionOk && existsSync3(dbPath);
+  };
+  if (cachedResult === FALSE_PENDING_RETRY) {
+    const result2 = check();
+    cachedResult = result2;
+    return result2;
+  }
+  const result = check();
+  if (result) {
+    cachedResult = true;
+  } else {
+    cachedResult = FALSE_PENDING_RETRY;
+  }
+  return result;
+}
+var NOT_CACHED2, FALSE_PENDING_RETRY, cachedResult;
 var init_opencode_storage_detection = __esm(() => {
   init_data_path();
   init_opencode_version();
   NOT_CACHED2 = Symbol("NOT_CACHED");
   FALSE_PENDING_RETRY = Symbol("FALSE_PENDING_RETRY");
+  cachedResult = NOT_CACHED2;
 });
 // src/shared/load-opencode-plugins.ts
 var init_load_opencode_plugins = __esm(() => {
@@ -6793,19 +6863,19 @@ function normalizeModelID(modelID) {
 }
 
 // src/shared/json-file-cache-store.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join6 } from "path";
 function toLogLabel(cacheLabel) {
   return cacheLabel.toLowerCase();
 }
 function createJsonFileCacheStore(options) {
   let memoryValue;
   function getCacheFilePath() {
-    return join5(options.getCacheDir(), options.filename);
+    return join6(options.getCacheDir(), options.filename);
   }
   function ensureCacheDir() {
     const cacheDir = options.getCacheDir();
-    if (!existsSync3(cacheDir)) {
+    if (!existsSync4(cacheDir)) {
       mkdirSync2(cacheDir, { recursive: true });
     }
   }
@@ -6814,7 +6884,7 @@ function createJsonFileCacheStore(options) {
       return memoryValue;
     }
     const cacheFile = getCacheFilePath();
-    if (!existsSync3(cacheFile)) {
+    if (!existsSync4(cacheFile)) {
       memoryValue = null;
       log(`[${options.logPrefix}] ${options.cacheLabel} file not found`, { cacheFile });
       return null;
@@ -6834,7 +6904,7 @@ function createJsonFileCacheStore(options) {
     }
   }
   function has() {
-    return existsSync3(getCacheFilePath());
+    return existsSync4(getCacheFilePath());
   }
   function write(value) {
     ensureCacheDir();
@@ -7003,14 +7073,14 @@ var init_connected_providers_cache = __esm(() => {
 });
 
 // src/shared/model-availability.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
+import { join as join7 } from "path";
 function isModelCacheAvailable() {
   if (hasProviderModelsCache()) {
     return true;
   }
-  const cacheFile = join6(getOpenCodeCacheDir(), "models.json");
-  return existsSync4(cacheFile);
+  const cacheFile = join7(getOpenCodeCacheDir(), "models.json");
+  return existsSync5(cacheFile);
 }
 var init_model_availability = __esm(() => {
   init_logger();
@@ -48323,17 +48393,43 @@ var init_hook_message_injector = __esm(() => {
 });
 
 // src/shared/opencode-storage-paths.ts
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 var OPENCODE_STORAGE, MESSAGE_STORAGE, PART_STORAGE, SESSION_STORAGE;
 var init_opencode_storage_paths = __esm(() => {
   init_data_path();
   OPENCODE_STORAGE = getOpenCodeStorageDir();
-  MESSAGE_STORAGE = join7(OPENCODE_STORAGE, "message");
-  PART_STORAGE = join7(OPENCODE_STORAGE, "part");
-  SESSION_STORAGE = join7(OPENCODE_STORAGE, "session");
+  MESSAGE_STORAGE = join8(OPENCODE_STORAGE, "message");
+  PART_STORAGE = join8(OPENCODE_STORAGE, "part");
+  SESSION_STORAGE = join8(OPENCODE_STORAGE, "session");
 });
 
 // src/shared/opencode-message-dir.ts
+import { existsSync as existsSync6, readdirSync } from "fs";
+import { join as join9 } from "path";
+function getMessageDir(sessionID) {
+  if (!sessionID.startsWith("ses_"))
+    return null;
+  if (/[/\\]|\.\./.test(sessionID))
+    return null;
+  if (!existsSync6(MESSAGE_STORAGE))
+    return null;
+  const directPath = join9(MESSAGE_STORAGE, sessionID);
+  if (existsSync6(directPath)) {
+    return directPath;
+  }
+  try {
+    for (const dir of readdirSync(MESSAGE_STORAGE)) {
+      const sessionPath = join9(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();
@@ -48620,6 +48716,7 @@ var init_hook_loader = __esm(() => {
 });
 
 // src/features/claude-code-plugin-loader/loader.ts
+var cachedPluginComponentsByKey;
 var init_loader = __esm(() => {
   init_logger();
   init_discovery();
@@ -48634,6 +48731,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
@@ -48764,6 +48862,10 @@ 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;
 }
 var configContext = null;
@@ -48815,10 +48917,10 @@ var init_plugin_name_with_version = __esm(() => {
 });
 
 // src/cli/config-manager/ensure-config-directory-exists.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3 } from "fs";
 function ensureConfigDirectoryExists() {
   const configDir = getConfigDir();
-  if (!existsSync5(configDir)) {
+  if (!existsSync7(configDir)) {
     mkdirSync3(configDir, { recursive: true });
   }
 }
@@ -48856,14 +48958,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 };
@@ -49214,7 +49316,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;
 }
@@ -49231,7 +49333,7 @@ function writeOmoConfig(installConfig) {
   const omoConfigPath = getOmoConfigPath();
   try {
     const newConfig = generateOmoConfig(installConfig);
-    if (existsSync7(omoConfigPath)) {
+    if (existsSync9(omoConfigPath)) {
       try {
         const stat = statSync2(omoConfigPath);
         const content = readFileSync6(omoConfigPath, "utf-8");
@@ -49362,7 +49464,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;
 }
@@ -49374,10 +49476,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 = getOmoConfigPath();
-  if (!existsSync8(omoConfigPath)) {
+  if (!existsSync10(omoConfigPath)) {
     return {
       hasOpenAI: true,
       hasOpencodeZen: true,
@@ -49463,10 +49565,10 @@ var init_detect_current_config = __esm(() => {
 });
 
 // src/cli/config-manager/bun-install.ts
-import { existsSync as existsSync9 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync11 } from "fs";
+import { join as join10 } from "path";
 function getDefaultWorkspaceDir() {
-  return join8(getOpenCodeCacheDir(), "packages");
+  return join10(getOpenCodeCacheDir(), "packages");
 }
 function readProcessOutput(stream) {
   if (!stream) {
@@ -49492,7 +49594,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.`
@@ -49636,7 +49738,16 @@ function getWindowsAppdataDir() {
     return null;
   return process.env.APPDATA ?? path4.join(os3.homedir(), "AppData", "Roaming");
 }
-var PACKAGE_NAME = "oh-my-openagent", 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();
@@ -49644,9 +49755,6 @@ var init_constants3 = __esm(() => {
   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_NAME, "package.json");
 });
 
@@ -49654,17 +49762,18 @@ var init_constants3 = __esm(() => {
 import * as os4 from "os";
 import * as path5 from "path";
 function getConfigPaths(directory) {
+  const userConfigDir = getUserConfigDir();
   const paths = [
     path5.join(directory, ".opencode", "opencode.json"),
     path5.join(directory, ".opencode", "opencode.jsonc"),
-    USER_OPENCODE_CONFIG,
-    USER_OPENCODE_CONFIG_JSONC
+    getUserOpencodeConfig(),
+    getUserOpencodeConfigJsonc()
   ];
   if (process.platform === "win32") {
     const crossPlatformDir = path5.join(os4.homedir(), ".config");
     const appdataDir = getWindowsAppdataDir();
     if (appdataDir) {
-      const alternateDir = USER_CONFIG_DIR === crossPlatformDir ? appdataDir : crossPlatformDir;
+      const alternateDir = userConfigDir === crossPlatformDir ? appdataDir : crossPlatformDir;
       const alternateConfig = path5.join(alternateDir, "opencode", "opencode.json");
       const alternateConfigJsonc = path5.join(alternateDir, "opencode", "opencode.jsonc");
       if (!paths.includes(alternateConfig)) {
@@ -50121,8 +50230,9 @@ function removeFromBunLock(packageName) {
 }
 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;
@@ -50183,8 +50293,8 @@ var init_update_toasts = __esm(() => {
 });
 
 // src/hooks/auto-update-checker/hook/background-update-check.ts
-import { existsSync as existsSync21 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync23 } from "fs";
+import { join as join23 } from "path";
 function getCacheWorkspaceDir(deps) {
   return deps.join(deps.getOpenCodeCacheDir(), "packages");
 }
@@ -50241,8 +50351,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;
@@ -50302,8 +50412,8 @@ var init_background_update_check = __esm(() => {
   init_checker();
   init_update_toasts();
   defaultDeps = {
-    existsSync: existsSync21,
-    join: join20,
+    existsSync: existsSync23,
+    join: join23,
     runBunInstallWithDetails,
     log,
     getOpenCodeCacheDir,
@@ -50512,9 +50622,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);
@@ -50583,7 +50693,7 @@ var {
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "3.15.1",
+  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",
@@ -50661,17 +50771,17 @@ var package_default = {
     typescript: "^5.7.3"
   },
   optionalDependencies: {
-    "oh-my-opencode-darwin-arm64": "3.15.1",
-    "oh-my-opencode-darwin-x64": "3.15.1",
-    "oh-my-opencode-darwin-x64-baseline": "3.15.1",
-    "oh-my-opencode-linux-arm64": "3.15.1",
-    "oh-my-opencode-linux-arm64-musl": "3.15.1",
-    "oh-my-opencode-linux-x64": "3.15.1",
-    "oh-my-opencode-linux-x64-baseline": "3.15.1",
-    "oh-my-opencode-linux-x64-musl": "3.15.1",
-    "oh-my-opencode-linux-x64-musl-baseline": "3.15.1",
-    "oh-my-opencode-windows-x64": "3.15.1",
-    "oh-my-opencode-windows-x64-baseline": "3.15.1"
+    "oh-my-opencode-darwin-arm64": "3.15.3",
+    "oh-my-opencode-darwin-x64": "3.15.3",
+    "oh-my-opencode-darwin-x64-baseline": "3.15.3",
+    "oh-my-opencode-linux-arm64": "3.15.3",
+    "oh-my-opencode-linux-arm64-musl": "3.15.3",
+    "oh-my-opencode-linux-x64": "3.15.3",
+    "oh-my-opencode-linux-x64-baseline": "3.15.3",
+    "oh-my-opencode-linux-x64-musl": "3.15.3",
+    "oh-my-opencode-linux-x64-musl-baseline": "3.15.3",
+    "oh-my-opencode-windows-x64": "3.15.3",
+    "oh-my-opencode-windows-x64-baseline": "3.15.3"
   },
   overrides: {
     "@opencode-ai/sdk": "^1.2.24"
@@ -50854,7 +50964,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");
@@ -51629,7 +51739,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.");
@@ -66474,12 +66584,12 @@ init_shared();
 // src/shared/migrate-legacy-config-file.ts
 init_logger();
 init_write_file_atomically();
-import { existsSync as existsSync10, readFileSync as readFileSync8, renameSync as renameSync2, rmSync } from "fs";
-import { join as join9, dirname, basename } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync8, renameSync as renameSync2, rmSync } from "fs";
+import { join as join11, dirname, basename } from "path";
 function buildCanonicalPath(legacyPath) {
   const dir = dirname(legacyPath);
   const ext = basename(legacyPath).includes(".jsonc") ? ".jsonc" : ".json";
-  return join9(dir, `${CONFIG_BASENAME}${ext}`);
+  return join11(dir, `${CONFIG_BASENAME}${ext}`);
 }
 function archiveLegacyConfigFile(legacyPath) {
   const backupPath = `${legacyPath}.bak`;
@@ -66511,12 +66621,12 @@ function archiveLegacyConfigFile(legacyPath) {
   }
 }
 function migrateLegacyConfigFile(legacyPath) {
-  if (!existsSync10(legacyPath))
+  if (!existsSync12(legacyPath))
     return false;
   if (!basename(legacyPath).startsWith(LEGACY_CONFIG_BASENAME))
     return false;
   const canonicalPath = buildCanonicalPath(legacyPath);
-  if (existsSync10(canonicalPath))
+  if (existsSync12(canonicalPath))
     return false;
   try {
     const content = readFileSync8(legacyPath, "utf-8");
@@ -66662,7 +66772,7 @@ function mergeConfigs(base, override) {
 function loadPluginConfig(directory, ctx) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   const userDetected = detectPluginConfigFile(configDir);
-  let userConfigPath = userDetected.format !== "none" ? userDetected.path : path3.join(configDir, "oh-my-opencode.json");
+  let userConfigPath = userDetected.format !== "none" ? userDetected.path : path3.join(configDir, `${CONFIG_BASENAME}.json`);
   if (userDetected.legacyPath) {
     log("Canonical plugin config detected alongside legacy config. Remove the legacy file to avoid confusion.", {
       canonicalPath: userDetected.path,
@@ -66670,12 +66780,15 @@ function loadPluginConfig(directory, ctx) {
     });
   }
   if (userDetected.format !== "none" && path3.basename(userDetected.path).startsWith(LEGACY_CONFIG_BASENAME)) {
-    migrateLegacyConfigFile(userDetected.path);
-    userConfigPath = path3.join(path3.dirname(userDetected.path), `${CONFIG_BASENAME}${path3.extname(userDetected.path)}`);
+    const migrated = migrateLegacyConfigFile(userDetected.path);
+    const canonicalPath = path3.join(path3.dirname(userDetected.path), `${CONFIG_BASENAME}${path3.extname(userDetected.path)}`);
+    if (migrated || fs3.existsSync(canonicalPath)) {
+      userConfigPath = canonicalPath;
+    }
   }
   const projectBasePath = path3.join(directory, ".opencode");
   const projectDetected = detectPluginConfigFile(projectBasePath);
-  let projectConfigPath = projectDetected.format !== "none" ? projectDetected.path : path3.join(projectBasePath, "oh-my-opencode.json");
+  let projectConfigPath = projectDetected.format !== "none" ? projectDetected.path : path3.join(projectBasePath, `${CONFIG_BASENAME}.json`);
   if (projectDetected.legacyPath) {
     log("Canonical plugin config detected alongside legacy config. Remove the legacy file to avoid confusion.", {
       canonicalPath: projectDetected.path,
@@ -66683,8 +66796,11 @@ function loadPluginConfig(directory, ctx) {
     });
   }
   if (projectDetected.format !== "none" && path3.basename(projectDetected.path).startsWith(LEGACY_CONFIG_BASENAME)) {
-    migrateLegacyConfigFile(projectDetected.path);
-    projectConfigPath = path3.join(path3.dirname(projectDetected.path), `${CONFIG_BASENAME}${path3.extname(projectDetected.path)}`);
+    const projectMigrated = migrateLegacyConfigFile(projectDetected.path);
+    const canonicalProjectPath = path3.join(path3.dirname(projectDetected.path), `${CONFIG_BASENAME}${path3.extname(projectDetected.path)}`);
+    if (projectMigrated || fs3.existsSync(canonicalProjectPath)) {
+      projectConfigPath = canonicalProjectPath;
+    }
   }
   const userConfig = loadConfigFromPath(userConfigPath, ctx);
   let config2 = userConfig ?? OhMyOpenCodeConfigSchema.parse({});
@@ -68153,7 +68269,7 @@ var import_picocolors9 = __toESM(require_picocolors(), 1);
 
 // src/cli/run/opencode-binary-resolver.ts
 init_spawn_with_windows_hide();
-import { delimiter, dirname as dirname3, join as join11 } from "path";
+import { delimiter, dirname as dirname3, join as join13 } from "path";
 var OPENCODE_COMMANDS = ["opencode", "opencode-desktop"];
 var WINDOWS_SUFFIXES = ["", ".exe", ".cmd", ".bat", ".ps1"];
 function getCommandCandidates(platform) {
@@ -68176,7 +68292,7 @@ function collectCandidateBinaryPaths(pathEnv, which = Bun.which, platform = proc
   }
   for (const entry of (pathEnv ?? "").split(delimiter).filter(Boolean)) {
     for (const command of commandCandidates) {
-      addCandidate(join11(entry, command));
+      addCandidate(join13(entry, command));
     }
   }
   return candidates;
@@ -68559,15 +68675,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 existsSync12, readFileSync as readFileSync10, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, readdirSync } from "fs";
-import { dirname as dirname4, join as join12, basename as basename3 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync10, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, readdirSync as readdirSync2 } from "fs";
+import { dirname as dirname4, join as join14, basename as basename3 } from "path";
 var RESERVED_KEYS = new Set(["__proto__", "prototype", "constructor"]);
 function getBoulderFilePath(directory) {
-  return join12(directory, BOULDER_DIR, BOULDER_FILE);
+  return join14(directory, BOULDER_DIR, BOULDER_FILE);
 }
 function readBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
-  if (!existsSync12(filePath)) {
+  if (!existsSync14(filePath)) {
     return null;
   }
   try {
@@ -68579,6 +68695,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 = {};
     }
@@ -68588,7 +68713,7 @@ function readBoulderState(directory) {
   }
 }
 function getPlanProgress(planPath) {
-  if (!existsSync12(planPath)) {
+  if (!existsSync14(planPath)) {
     return { total: 0, completed: 0, isComplete: true };
   }
   try {
@@ -68606,17 +68731,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 existsSync13, mkdirSync as mkdirSync5, readFileSync as readFileSync11, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync5, readFileSync as readFileSync11, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
+import { join as join15 } from "path";
 function getMarkerPath(directory, sessionID) {
-  return join13(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
+  return join15(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
 }
 function readContinuationMarker(directory, sessionID) {
   const markerPath = getMarkerPath(directory, sessionID);
-  if (!existsSync13(markerPath))
+  if (!existsSync15(markerPath))
     return null;
   try {
     const raw = readFileSync11(markerPath, "utf-8");
@@ -68642,10 +68776,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 readFileSync12, 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 = readFileSync12(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 existsSync14, readFileSync as readFileSync12, writeFileSync as writeFileSync7, unlinkSync, mkdirSync as mkdirSync6 } from "fs";
-import { dirname as dirname5, join as join14 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync13, writeFileSync as writeFileSync7, unlinkSync, mkdirSync as mkdirSync6 } from "fs";
+import { dirname as dirname5, join as join17 } from "path";
 
 // src/hooks/ralph-loop/constants.ts
 var DEFAULT_STATE_FILE = ".sisyphus/ralph-loop.local.md";
@@ -68654,15 +68891,15 @@ var DEFAULT_COMPLETION_PROMISE = "DONE";
 
 // src/hooks/ralph-loop/storage.ts
 function getStateFilePath(directory, customPath) {
-  return customPath ? join14(directory, customPath) : join14(directory, DEFAULT_STATE_FILE);
+  return customPath ? join17(directory, customPath) : join17(directory, DEFAULT_STATE_FILE);
 }
 function readState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
-  if (!existsSync14(filePath)) {
+  if (!existsSync16(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync12(filePath, "utf-8");
+    const content = readFileSync13(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     const active = data.active;
     const iteration = data.iteration;
@@ -68702,10 +68939,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,
@@ -68713,20 +68950,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;
@@ -68735,7 +69006,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);
@@ -69368,30 +69639,30 @@ var PACKAGE_NAME2 = PLUGIN_NAME;
 var OPENCODE_BINARIES2 = ["opencode", "opencode-desktop"];
 
 // src/cli/doctor/checks/system.ts
-import { existsSync as existsSync25, readFileSync as readFileSync22 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync23 } from "fs";
 
 // src/cli/doctor/checks/system-binary.ts
 init_spawn_with_windows_hide();
-import { existsSync as existsSync22 } from "fs";
+import { existsSync as existsSync24 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join21 } 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",
-        join21(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(join21(programFiles, "OpenCode", "OpenCode.exe"));
+        paths.push(join24(programFiles, "OpenCode", "OpenCode.exe"));
       }
       if (localAppData) {
-        paths.push(join21(localAppData, "OpenCode", "OpenCode.exe"));
+        paths.push(join24(localAppData, "OpenCode", "OpenCode.exe"));
       }
       return paths;
     }
@@ -69399,8 +69670,8 @@ function getDesktopAppPaths(platform) {
       return [
         "/usr/bin/opencode",
         "/usr/lib/opencode/opencode",
-        join21(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
-        join21(home, "Applications", "opencode-desktop-linux-aarch64.AppImage")
+        join24(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
+        join24(home, "Applications", "opencode-desktop-linux-aarch64.AppImage")
       ];
     default:
       return [];
@@ -69412,7 +69683,7 @@ function buildVersionCommand(binaryPath, platform) {
   }
   return [binaryPath, "--version"];
 }
-function findDesktopBinary(platform = process.platform, checkExists = existsSync22) {
+function findDesktopBinary(platform = process.platform, checkExists = existsSync24) {
   for (const desktopPath of getDesktopAppPaths(platform)) {
     if (checkExists(desktopPath)) {
       return { binary: "opencode", path: desktopPath };
@@ -69429,7 +69700,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" });
@@ -69442,10 +69713,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;
@@ -69460,12 +69731,12 @@ function compareVersions(current, minimum) {
 
 // src/cli/doctor/checks/system-plugin.ts
 init_shared();
-import { existsSync as existsSync23, readFileSync as readFileSync20 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync21 } from "fs";
 function detectConfigPath() {
   const paths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
-  if (existsSync23(paths.configJsonc))
+  if (existsSync25(paths.configJsonc))
     return paths.configJsonc;
-  if (existsSync23(paths.configJson))
+  if (existsSync25(paths.configJson))
     return paths.configJson;
   return null;
 }
@@ -69511,7 +69782,7 @@ function getPluginInfo() {
     };
   }
   try {
-    const content = readFileSync20(configPath, "utf-8");
+    const content = readFileSync21(configPath, "utf-8");
     const parsedConfig = parseJsonc(content);
     const pluginEntry = findPluginEntry2(parsedConfig.plugin ?? []);
     if (!pluginEntry) {
@@ -69549,37 +69820,37 @@ function getPluginInfo() {
 init_file_utils();
 init_checker();
 init_auto_update_checker();
-import { existsSync as existsSync24, readFileSync as readFileSync21 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync22 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join22 } from "path";
+import { join as join25 } from "path";
 init_shared();
 function getPlatformDefaultCacheDir(platform = process.platform) {
   if (platform === "darwin")
-    return join22(homedir6(), "Library", "Caches");
+    return join25(homedir6(), "Library", "Caches");
   if (platform === "win32")
-    return process.env.LOCALAPPDATA ?? join22(homedir6(), "AppData", "Local");
-  return join22(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 join22(xdgCacheHome, "opencode");
+    return join25(xdgCacheHome, "opencode");
   const fromShared = getOpenCodeCacheDir();
-  const platformDefault = join22(getPlatformDefaultCacheDir(), "opencode");
-  if (existsSync24(fromShared) || !existsSync24(platformDefault))
+  const platformDefault = join25(getPlatformDefaultCacheDir(), "opencode");
+  if (existsSync26(fromShared) || !existsSync26(platformDefault))
     return fromShared;
   return platformDefault;
 }
 function resolveExistingDir(dirPath) {
-  if (!existsSync24(dirPath))
+  if (!existsSync26(dirPath))
     return dirPath;
   return resolveSymlink(dirPath);
 }
 function readPackageJson(filePath) {
-  if (!existsSync24(filePath))
+  if (!existsSync26(filePath))
     return null;
   try {
-    const content = readFileSync21(filePath, "utf-8");
+    const content = readFileSync22(filePath, "utf-8");
     return parseJsonc(content);
   } catch {
     return null;
@@ -69598,16 +69869,16 @@ function getLoadedPluginVersion() {
   const candidates = [
     {
       cacheDir: configDir,
-      cachePackagePath: join22(configDir, "package.json"),
-      installedPackagePath: join22(configDir, "node_modules", PACKAGE_NAME2, "package.json")
+      cachePackagePath: join25(configDir, "package.json"),
+      installedPackagePath: join25(configDir, "node_modules", PACKAGE_NAME2, "package.json")
     },
     {
       cacheDir,
-      cachePackagePath: join22(cacheDir, "package.json"),
-      installedPackagePath: join22(cacheDir, "node_modules", PACKAGE_NAME2, "package.json")
+      cachePackagePath: join25(cacheDir, "package.json"),
+      installedPackagePath: join25(cacheDir, "node_modules", PACKAGE_NAME2, "package.json")
     }
   ];
-  const selectedCandidate = candidates.find((candidate) => existsSync24(candidate.installedPackagePath)) ?? candidates[0];
+  const selectedCandidate = candidates.find((candidate) => existsSync26(candidate.installedPackagePath)) ?? candidates[0];
   const { cacheDir: selectedDir, cachePackagePath, installedPackagePath } = selectedCandidate;
   const cachePackage = readPackageJson(cachePackagePath);
   const installedPackage = readPackageJson(installedPackagePath);
@@ -69634,10 +69905,10 @@ init_shared();
 function isConfigValid(configPath) {
   if (!configPath)
     return true;
-  if (!existsSync25(configPath))
+  if (!existsSync27(configPath))
     return false;
   try {
-    parseJsonc(readFileSync22(configPath, "utf-8"));
+    parseJsonc(readFileSync23(configPath, "utf-8"));
     return true;
   } catch {
     return false;
@@ -69660,7 +69931,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,
@@ -69688,7 +69959,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}.`,
@@ -69728,7 +69999,7 @@ 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}.`,
@@ -69753,28 +70024,28 @@ async function checkSystem() {
 }
 
 // src/cli/doctor/checks/config.ts
-import { readFileSync as readFileSync25 } from "fs";
-import { join as join26 } from "path";
+import { readFileSync as readFileSync26 } from "fs";
+import { join as join29 } from "path";
 init_shared();
 
 // src/cli/doctor/checks/model-resolution-cache.ts
 init_shared();
-import { existsSync as existsSync26, readFileSync as readFileSync23 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync24 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join23 } from "path";
+import { join as join26 } from "path";
 function getOpenCodeCacheDir2() {
   const xdgCache = process.env.XDG_CACHE_HOME;
   if (xdgCache)
-    return join23(xdgCache, "opencode");
-  return join23(homedir7(), ".cache", "opencode");
+    return join26(xdgCache, "opencode");
+  return join26(homedir7(), ".cache", "opencode");
 }
 function loadAvailableModelsFromCache() {
-  const cacheFile = join23(getOpenCodeCacheDir2(), "models.json");
-  if (!existsSync26(cacheFile)) {
+  const cacheFile = join26(getOpenCodeCacheDir2(), "models.json");
+  if (!existsSync28(cacheFile)) {
     return { providers: [], modelCount: 0, cacheExists: false };
   }
   try {
-    const content = readFileSync23(cacheFile, "utf-8");
+    const content = readFileSync24(cacheFile, "utf-8");
     const data = parseJsonc(content);
     const providers = Object.keys(data);
     let modelCount = 0;
@@ -69796,24 +70067,24 @@ init_model_capabilities();
 
 // src/cli/doctor/checks/model-resolution-config.ts
 init_shared();
-import { readFileSync as readFileSync24 } from "fs";
-import { join as join24 } from "path";
-var USER_CONFIG_DIR2 = getOpenCodeConfigPaths({ binary: "opencode", version: null }).configDir;
-var PROJECT_CONFIG_DIR = join24(process.cwd(), ".opencode");
+import { readFileSync as readFileSync25 } from "fs";
+import { join as join27 } from "path";
+var PROJECT_CONFIG_DIR = join27(process.cwd(), ".opencode");
 function loadOmoConfig() {
   const projectDetected = detectPluginConfigFile(PROJECT_CONFIG_DIR);
   if (projectDetected.format !== "none") {
     try {
-      const content = readFileSync24(projectDetected.path, "utf-8");
+      const content = readFileSync25(projectDetected.path, "utf-8");
       return parseJsonc(content);
     } catch {
       return null;
     }
   }
-  const userDetected = detectPluginConfigFile(USER_CONFIG_DIR2);
+  const userConfigDir = getOpenCodeConfigDir({ binary: "opencode" });
+  const userDetected = detectPluginConfigFile(userConfigDir);
   if (userDetected.format !== "none") {
     try {
-      const content = readFileSync24(userDetected.path, "utf-8");
+      const content = readFileSync25(userDetected.path, "utf-8");
       return parseJsonc(content);
     } catch {
       return null;
@@ -69824,7 +70095,7 @@ function loadOmoConfig() {
 
 // src/cli/doctor/checks/model-resolution-details.ts
 init_shared();
-import { join as join25 } from "path";
+import { join as join28 } from "path";
 
 // src/cli/doctor/checks/model-resolution-variant.ts
 function formatModelWithVariant(model, variant) {
@@ -69866,7 +70137,7 @@ function formatCapabilityResolutionLabel(mode) {
 }
 function buildModelResolutionDetails(options) {
   const details = [];
-  const cacheFile = join25(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) {
@@ -70021,13 +70292,13 @@ async function checkModels() {
 }
 
 // src/cli/doctor/checks/config.ts
-var USER_CONFIG_DIR3 = getOpenCodeConfigDir({ binary: "opencode" });
-var PROJECT_CONFIG_DIR2 = join26(process.cwd(), ".opencode");
+var PROJECT_CONFIG_DIR2 = join29(process.cwd(), ".opencode");
 function findConfigPath() {
   const projectConfig = detectPluginConfigFile(PROJECT_CONFIG_DIR2);
   if (projectConfig.format !== "none")
     return projectConfig.path;
-  const userConfig = detectPluginConfigFile(USER_CONFIG_DIR3);
+  const userConfigDir = getOpenCodeConfigDir({ binary: "opencode" });
+  const userConfig = detectPluginConfigFile(userConfigDir);
   if (userConfig.format !== "none")
     return userConfig.path;
   return null;
@@ -70038,7 +70309,7 @@ function validateConfig() {
     return { exists: false, path: null, valid: true, config: null, errors: [] };
   }
   try {
-    const content = readFileSync25(configPath, "utf-8");
+    const content = readFileSync26(configPath, "utf-8");
     const rawConfig = parseJsonc(content);
     const schemaResult = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
     if (!schemaResult.success) {
@@ -70142,9 +70413,9 @@ async function checkConfig() {
 
 // src/cli/doctor/checks/dependencies.ts
 init_spawn_with_windows_hide();
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync29 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname9, join as join27 } from "path";
+import { dirname as dirname9, join as join30 } from "path";
 async function checkBinaryExists(binary2) {
   try {
     const path10 = Bun.which(binary2);
@@ -70200,15 +70471,15 @@ async function checkAstGrepNapi() {
       path: null
     };
   } catch {
-    const { existsSync: existsSync28 } = await import("fs");
-    const { join: join28 } = await import("path");
+    const { existsSync: existsSync30 } = await import("fs");
+    const { join: join31 } = await import("path");
     const { homedir: homedir8 } = await import("os");
     const pathsToCheck = [
-      join28(homedir8(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
-      join28(process.cwd(), "node_modules", "@ast-grep", "napi")
+      join31(homedir8(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
+      join31(process.cwd(), "node_modules", "@ast-grep", "napi")
     ];
     for (const napiPath of pathsToCheck) {
-      if (existsSync28(napiPath)) {
+      if (existsSync30(napiPath)) {
         return {
           name: "AST-Grep NAPI",
           required: false,
@@ -70233,8 +70504,8 @@ function findCommentCheckerPackageBinary() {
   try {
     const require2 = createRequire(import.meta.url);
     const pkgPath = require2.resolve("@code-yeongyu/comment-checker/package.json");
-    const binaryPath = join27(dirname9(pkgPath), "bin", binaryName);
-    if (existsSync27(binaryPath))
+    const binaryPath = join30(dirname9(pkgPath), "bin", binaryName);
+    if (existsSync29(binaryPath))
       return binaryPath;
   } catch {}
   return null;
@@ -70391,15 +70662,15 @@ var BUILTIN_SERVERS = {
   "kotlin-ls": { command: ["kotlin-lsp"], extensions: [".kt", ".kts"] }
 };
 // src/tools/lsp/server-config-loader.ts
-import { existsSync as existsSync28, readFileSync as readFileSync26 } from "fs";
-import { join as join28 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync27 } from "fs";
+import { join as join31 } from "path";
 init_shared();
 init_jsonc_parser();
 function loadJsonFile(path10) {
-  if (!existsSync28(path10))
+  if (!existsSync30(path10))
     return null;
   try {
-    return parseJsonc(readFileSync26(path10, "utf-8"));
+    return parseJsonc(readFileSync27(path10, "utf-8"));
   } catch {
     return null;
   }
@@ -70408,9 +70679,9 @@ function getConfigPaths2() {
   const cwd = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   return {
-    project: detectPluginConfigFile(join28(cwd, ".opencode")).path,
+    project: detectPluginConfigFile(join31(cwd, ".opencode")).path,
     user: detectPluginConfigFile(configDir).path,
-    opencode: detectConfigFile(join28(configDir, "opencode")).path
+    opencode: detectConfigFile(join31(configDir, "opencode")).path
   };
 }
 function loadAllConfigs() {
@@ -70479,21 +70750,21 @@ function getMergedServers() {
 }
 
 // src/tools/lsp/server-installation.ts
-import { existsSync as existsSync29 } from "fs";
-import { delimiter as delimiter2, join as join30 } from "path";
+import { existsSync as existsSync31 } from "fs";
+import { delimiter as delimiter2, join as join33 } from "path";
 
 // src/tools/lsp/server-path-bases.ts
 init_shared();
-import { join as join29 } from "path";
+import { join as join32 } from "path";
 function getLspServerAdditionalPathBases(workingDirectory) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join29(getDataDir(), "opencode");
+  const dataDir = join32(getDataDir(), "opencode");
   return [
-    join29(workingDirectory, "node_modules", ".bin"),
-    join29(configDir, "bin"),
-    join29(configDir, "node_modules", ".bin"),
-    join29(dataDir, "bin"),
-    join29(dataDir, "bin", "node_modules", ".bin")
+    join32(workingDirectory, "node_modules", ".bin"),
+    join32(configDir, "bin"),
+    join32(configDir, "node_modules", ".bin"),
+    join32(dataDir, "bin"),
+    join32(dataDir, "bin", "node_modules", ".bin")
   ];
 }
 
@@ -70503,7 +70774,7 @@ function isServerInstalled(command) {
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync29(cmd))
+    if (existsSync31(cmd))
       return true;
   }
   const isWindows = process.platform === "win32";
@@ -70524,14 +70795,14 @@ function isServerInstalled(command) {
   const paths = pathEnv.split(delimiter2);
   for (const p2 of paths) {
     for (const suffix of exts) {
-      if (existsSync29(join30(p2, cmd + suffix))) {
+      if (existsSync31(join33(p2, cmd + suffix))) {
         return true;
       }
     }
   }
   for (const base of getLspServerAdditionalPathBases(process.cwd())) {
     for (const suffix of exts) {
-      if (existsSync29(join30(base, cmd + suffix))) {
+      if (existsSync31(join33(base, cmd + suffix))) {
         return true;
       }
     }
@@ -70593,24 +70864,24 @@ function getInstalledLspServers() {
 
 // src/cli/doctor/checks/tools-mcp.ts
 init_shared();
-import { existsSync as existsSync30, readFileSync as readFileSync27 } from "fs";
+import { existsSync as existsSync32, readFileSync as readFileSync28 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join31 } from "path";
+import { join as join34 } from "path";
 var BUILTIN_MCP_SERVERS = ["context7", "grep_app"];
 function getMcpConfigPaths() {
   return [
-    join31(homedir8(), ".claude", ".mcp.json"),
-    join31(process.cwd(), ".mcp.json"),
-    join31(process.cwd(), ".claude", ".mcp.json")
+    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 (!existsSync30(configPath))
+    if (!existsSync32(configPath))
       continue;
     try {
-      const content = readFileSync27(configPath, "utf-8");
+      const content = readFileSync28(configPath, "utf-8");
       const config2 = parseJsonc(content);
       if (config2.mcpServers) {
         Object.assign(servers, config2.mcpServers);
@@ -71063,11 +71334,11 @@ async function refreshModelCapabilities(options, deps = {}) {
 
 // src/features/mcp-oauth/storage.ts
 init_shared();
-import { chmodSync, existsSync as existsSync31, mkdirSync as mkdirSync8, readFileSync as readFileSync28, unlinkSync as unlinkSync4, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname10, join as join32 } from "path";
+import { chmodSync, existsSync as existsSync33, mkdirSync as mkdirSync8, readFileSync as readFileSync29, unlinkSync as unlinkSync4, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname10, join as join35 } from "path";
 var STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStoragePath() {
-  return join32(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
+  return join35(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
 }
 function normalizeHost(serverHost) {
   let host = serverHost.trim();
@@ -71104,11 +71375,11 @@ function buildKey(serverHost, resource) {
 }
 function readStore() {
   const filePath = getMcpOauthStoragePath();
-  if (!existsSync31(filePath)) {
+  if (!existsSync33(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync28(filePath, "utf-8");
+    const content = readFileSync29(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -71118,7 +71389,7 @@ function writeStore(store2) {
   const filePath = getMcpOauthStoragePath();
   try {
     const dir = dirname10(filePath);
-    if (!existsSync31(dir)) {
+    if (!existsSync33(dir)) {
       mkdirSync8(dir, { recursive: true });
     }
     writeFileSync10(filePath, JSON.stringify(store2, null, 2), { encoding: "utf-8", mode: 384 });
@@ -71153,7 +71424,7 @@ function deleteToken(serverHost, resource) {
   if (Object.keys(store2).length === 0) {
     try {
       const filePath = getMcpOauthStoragePath();
-      if (existsSync31(filePath)) {
+      if (existsSync33(filePath)) {
         unlinkSync4(filePath);
       }
       return true;
@@ -71376,7 +71647,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;
@@ -71386,7 +71657,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();
@@ -71396,7 +71667,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();
@@ -71432,19 +71703,19 @@ 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 };