oh-my-opencode-gpt-slim 0.1.2 → 0.1.4

package/dist/cli/index.js

@@ -2145,7 +2145,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "oh-my-opencode-gpt-slim",
-    version: "0.1.2",
+    version: "0.1.4",
     description: "GPT-optimized lean fork of oh-my-openagent \u2014 33 hooks removed, 5 tools removed, Sisyphus prompt rewritten based on OpenAI Codex prompt.md",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -2223,15 +2223,15 @@ var init_package = __esm(() => {
       typescript: "^5.7.3"
     },
     optionalDependencies: {
-      "oh-my-opencode-gpt-slim-darwin-arm64": "0.1.2",
-      "oh-my-opencode-gpt-slim-darwin-x64": "0.1.2",
-      "oh-my-opencode-gpt-slim-darwin-x64-baseline": "0.1.2",
-      "oh-my-opencode-gpt-slim-linux-arm64": "0.1.2",
-      "oh-my-opencode-gpt-slim-linux-arm64-musl": "0.1.2",
-      "oh-my-opencode-gpt-slim-linux-x64": "0.1.2",
-      "oh-my-opencode-gpt-slim-linux-x64-baseline": "0.1.2",
-      "oh-my-opencode-gpt-slim-linux-x64-musl": "0.1.2",
-      "oh-my-opencode-gpt-slim-linux-x64-musl-baseline": "0.1.2"
+      "oh-my-opencode-gpt-slim-darwin-arm64": "0.1.4",
+      "oh-my-opencode-gpt-slim-darwin-x64": "0.1.4",
+      "oh-my-opencode-gpt-slim-darwin-x64-baseline": "0.1.4",
+      "oh-my-opencode-gpt-slim-linux-arm64": "0.1.4",
+      "oh-my-opencode-gpt-slim-linux-arm64-musl": "0.1.4",
+      "oh-my-opencode-gpt-slim-linux-x64": "0.1.4",
+      "oh-my-opencode-gpt-slim-linux-x64-baseline": "0.1.4",
+      "oh-my-opencode-gpt-slim-linux-x64-musl": "0.1.4",
+      "oh-my-opencode-gpt-slim-linux-x64-musl-baseline": "0.1.4"
     },
     overrides: {
       "@opencode-ai/sdk": "^1.2.17"
@@ -2451,11 +2451,10 @@ function getPluginEntrySource(entry) {
     return "github";
   return "package";
 }
-var LEGACY_PLUGIN_PACKAGE_NAME = "oh-my-opencode", PLUGIN_PACKAGE_NAME, CONFIG_BASENAME, rawRepositoryUrl, PLUGIN_REPOSITORY_URL, PLUGIN_GITHUB_REPOSITORY, CURRENT_PLUGIN_PREFIXES, LEGACY_PLUGIN_PREFIXES, FILE_REFERENCE_TOKENS;
+var LEGACY_PLUGIN_PACKAGE_NAME = "oh-my-opencode", PLUGIN_PACKAGE_NAME, rawRepositoryUrl, PLUGIN_REPOSITORY_URL, PLUGIN_GITHUB_REPOSITORY, CURRENT_PLUGIN_PREFIXES, LEGACY_PLUGIN_PREFIXES, FILE_REFERENCE_TOKENS;
 var init_plugin_reference = __esm(() => {
   init_package();
   PLUGIN_PACKAGE_NAME = package_default.name;
-  CONFIG_BASENAME = PLUGIN_PACKAGE_NAME;
   rawRepositoryUrl = typeof package_default.repository === "string" ? package_default.repository : package_default.repository.url;
   PLUGIN_REPOSITORY_URL = rawRepositoryUrl.replace(/^git\+/, "");
   PLUGIN_GITHUB_REPOSITORY = PLUGIN_REPOSITORY_URL.replace(/^https:\/\/github\.com\//, "").replace(/\.git$/, "");
@@ -6234,7 +6233,6 @@ var init_main = __esm(() => {
 });
 
 // src/shared/jsonc-parser.ts
-import { existsSync as existsSync4, readFileSync } from "fs";
 function parseJsonc(content) {
   const errors = [];
   const result = parse2(content, errors, {
@@ -6247,21 +6245,24 @@ function parseJsonc(content) {
   }
   return result;
 }
-function detectConfigFile(basePath) {
-  const jsoncPath = `${basePath}.jsonc`;
-  const jsonPath = `${basePath}.json`;
-  if (existsSync4(jsoncPath)) {
-    return { format: "jsonc", path: jsoncPath };
-  }
-  if (existsSync4(jsonPath)) {
-    return { format: "json", path: jsonPath };
-  }
-  return { format: "none", path: jsonPath };
-}
 var init_jsonc_parser = __esm(() => {
   init_main();
 });
 
+// src/shared/omo-config-file.ts
+import { join as join5 } from "path";
+function getOmoConfigFilePath(directory) {
+  return join5(directory, OMO_CONFIG_FILENAME);
+}
+function getProjectOmoConfigFilePath(projectRoot) {
+  return getOmoConfigFilePath(join5(projectRoot, ".opencode"));
+}
+function parseOmoConfigJson(content) {
+  return JSON.parse(content);
+}
+var OMO_CONFIG_FILENAME = "oh-my-opencode-gpt-slim.json";
+var init_omo_config_file = () => {};
+
 // src/shared/migration/agent-names.ts
 function migrateAgentNames(agents) {
   const migrated = {};
@@ -6624,8 +6625,8 @@ var init_opencode_version = __esm(() => {
 });
 
 // src/shared/opencode-storage-detection.ts
-import { existsSync as existsSync5 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { join as join6 } from "path";
 function isSqliteBackend() {
   if (cachedResult === true)
     return true;
@@ -6633,8 +6634,8 @@ function isSqliteBackend() {
     return false;
   const check = () => {
     const versionOk = isOpenCodeVersionAtLeast(OPENCODE_SQLITE_VERSION);
-    const dbPath = join5(getDataDir(), "opencode", "opencode.db");
-    return versionOk && existsSync5(dbPath);
+    const dbPath = join6(getDataDir(), "opencode", "opencode.db");
+    return versionOk && existsSync4(dbPath);
   };
   if (cachedResult === FALSE_PENDING_RETRY) {
     const result2 = check();
@@ -6988,19 +6989,19 @@ var init_hook_message_injector = __esm(() => {
 });
 
 // src/shared/opencode-storage-paths.ts
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 var OPENCODE_STORAGE, MESSAGE_STORAGE, PART_STORAGE, SESSION_STORAGE;
 var init_opencode_storage_paths = __esm(() => {
   init_data_path();
   OPENCODE_STORAGE = getOpenCodeStorageDir();
-  MESSAGE_STORAGE = join6(OPENCODE_STORAGE, "message");
-  PART_STORAGE = join6(OPENCODE_STORAGE, "part");
-  SESSION_STORAGE = join6(OPENCODE_STORAGE, "session");
+  MESSAGE_STORAGE = join7(OPENCODE_STORAGE, "message");
+  PART_STORAGE = join7(OPENCODE_STORAGE, "part");
+  SESSION_STORAGE = join7(OPENCODE_STORAGE, "session");
 });
 
 // src/shared/opencode-message-dir.ts
-import { existsSync as existsSync6, readdirSync } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync5, readdirSync } from "fs";
+import { join as join8 } from "path";
 function getMessageDir(sessionID) {
   if (!sessionID.startsWith("ses_"))
     return null;
@@ -7008,16 +7009,16 @@ function getMessageDir(sessionID) {
     return null;
   if (isSqliteBackend())
     return null;
-  if (!existsSync6(MESSAGE_STORAGE))
+  if (!existsSync5(MESSAGE_STORAGE))
     return null;
-  const directPath = join7(MESSAGE_STORAGE, sessionID);
-  if (existsSync6(directPath)) {
+  const directPath = join8(MESSAGE_STORAGE, sessionID);
+  if (existsSync5(directPath)) {
     return directPath;
   }
   try {
     for (const dir of readdirSync(MESSAGE_STORAGE)) {
-      const sessionPath = join7(MESSAGE_STORAGE, dir, sessionID);
-      if (existsSync6(sessionPath)) {
+      const sessionPath = join8(MESSAGE_STORAGE, dir, sessionID);
+      if (existsSync5(sessionPath)) {
         return sessionPath;
       }
     }
@@ -7328,6 +7329,7 @@ var init_shared = __esm(() => {
   init_config_errors();
   init_claude_config_dir();
   init_jsonc_parser();
+  init_omo_config_file();
   init_migration();
   init_opencode_config_dir();
   init_opencode_version();
@@ -7361,7 +7363,7 @@ var init_shared = __esm(() => {
 });
 
 // src/cli/config-manager/parse-opencode-config-file.ts
-import { readFileSync as readFileSync2, statSync } from "fs";
+import { readFileSync, statSync } from "fs";
 function isEmptyOrWhitespace(content) {
   return content.trim().length === 0;
 }
@@ -7371,7 +7373,7 @@ function parseOpenCodeConfigFileWithError(path3) {
     if (stat.size === 0) {
       return { config: null, error: `Config file is empty: ${path3}. Delete it or add valid JSON content.` };
     }
-    const content = readFileSync2(path3, "utf-8");
+    const content = readFileSync(path3, "utf-8");
     if (isEmptyOrWhitespace(content)) {
       return { config: null, error: `Config file contains only whitespace: ${path3}. Delete it or add valid JSON content.` };
     }
@@ -7413,7 +7415,7 @@ var init_plugin_array_updater = __esm(() => {
 });
 
 // src/cli/config-manager/add-plugin-to-opencode-config.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 async function addPluginToOpenCodeConfig(currentVersion) {
   try {
     ensureConfigDirectoryExists();
@@ -7448,7 +7450,7 @@ async function addPluginToOpenCodeConfig(currentVersion) {
     }
     config.plugin = plugins;
     if (format2 === "jsonc") {
-      const content = readFileSync3(path3, "utf-8");
+      const content = readFileSync2(path3, "utf-8");
       const pluginArrayRegex = /"plugin"\s*:\s*\[([\s\S]*?)\]/;
       const match = content.match(pluginArrayRegex);
       if (match) {
@@ -7887,7 +7889,7 @@ function deepMergeRecord(target, source) {
 }
 
 // src/cli/config-manager/write-omo-config.ts
-import { existsSync as existsSync7, readFileSync as readFileSync4, statSync as statSync2, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync3, statSync as statSync2, writeFileSync as writeFileSync3 } from "fs";
 function isEmptyOrWhitespace2(content) {
   return content.trim().length === 0;
 }
@@ -7904,34 +7906,34 @@ function writeOmoConfig(installConfig) {
   const omoConfigPath = getOmoConfigPath();
   try {
     const newConfig = generateOmoConfig(installConfig);
-    if (existsSync7(omoConfigPath)) {
+    if (existsSync6(omoConfigPath)) {
       try {
         const stat = statSync2(omoConfigPath);
-        const content = readFileSync4(omoConfigPath, "utf-8");
+        const content = readFileSync3(omoConfigPath, "utf-8");
         if (stat.size === 0 || isEmptyOrWhitespace2(content)) {
-          writeFileSync3(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
+          writeFileSync3(omoConfigPath, `${JSON.stringify(newConfig, null, 2)}
 `);
           return { success: true, configPath: omoConfigPath };
         }
-        const existing = parseJsonc(content);
+        const existing = parseOmoConfigJson(content);
         if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
-          writeFileSync3(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
+          writeFileSync3(omoConfigPath, `${JSON.stringify(newConfig, null, 2)}
 `);
           return { success: true, configPath: omoConfigPath };
         }
         const merged = deepMergeRecord(newConfig, existing);
-        writeFileSync3(omoConfigPath, JSON.stringify(merged, null, 2) + `
+        writeFileSync3(omoConfigPath, `${JSON.stringify(merged, null, 2)}
 `);
       } catch (parseErr) {
         if (parseErr instanceof SyntaxError) {
-          writeFileSync3(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
+          writeFileSync3(omoConfigPath, `${JSON.stringify(newConfig, null, 2)}
 `);
           return { success: true, configPath: omoConfigPath };
         }
         throw parseErr;
       }
     } else {
-      writeFileSync3(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
+      writeFileSync3(omoConfigPath, `${JSON.stringify(newConfig, null, 2)}
 `);
     }
     return { success: true, configPath: omoConfigPath };
@@ -8047,17 +8049,27 @@ var init_opencode_binary = __esm(() => {
 });
 
 // src/cli/config-manager/detect-current-config.ts
-import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync4 } from "fs";
 function detectProvidersFromOmoConfig() {
   const omoConfigPath = getOmoConfigPath();
-  if (!existsSync8(omoConfigPath)) {
-    return { hasOpenAI: true, hasOpencodeZen: true, hasZaiCodingPlan: false, hasKimiForCoding: false };
+  if (!existsSync7(omoConfigPath)) {
+    return {
+      hasOpenAI: true,
+      hasOpencodeZen: true,
+      hasZaiCodingPlan: false,
+      hasKimiForCoding: false
+    };
   }
   try {
-    const content = readFileSync5(omoConfigPath, "utf-8");
-    const omoConfig = parseJsonc(content);
+    const content = readFileSync4(omoConfigPath, "utf-8");
+    const omoConfig = parseOmoConfigJson(content);
     if (!omoConfig || typeof omoConfig !== "object") {
-      return { hasOpenAI: true, hasOpencodeZen: true, hasZaiCodingPlan: false, hasKimiForCoding: false };
+      return {
+        hasOpenAI: true,
+        hasOpencodeZen: true,
+        hasZaiCodingPlan: false,
+        hasKimiForCoding: false
+      };
     }
     const configStr = JSON.stringify(omoConfig);
     const hasOpenAI = configStr.includes('"openai/');
@@ -8066,7 +8078,12 @@ function detectProvidersFromOmoConfig() {
     const hasKimiForCoding = configStr.includes('"kimi-for-coding/');
     return { hasOpenAI, hasOpencodeZen, hasZaiCodingPlan, hasKimiForCoding };
   } catch {
-    return { hasOpenAI: true, hasOpencodeZen: true, hasZaiCodingPlan: false, hasKimiForCoding: false };
+    return {
+      hasOpenAI: true,
+      hasOpencodeZen: true,
+      hasZaiCodingPlan: false,
+      hasKimiForCoding: false
+    };
   }
 }
 function detectCurrentConfig() {
@@ -8105,15 +8122,15 @@ function detectCurrentConfig() {
   return result;
 }
 var init_detect_current_config = __esm(() => {
-  init_config_context();
+  init_omo_config_file();
   init_plugin_reference();
-  init_jsonc_parser();
+  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 { existsSync as existsSync8 } from "fs";
 async function runBunInstall() {
   const result = await runBunInstallWithDetails();
   return result.success;
@@ -8121,7 +8138,7 @@ async function runBunInstall() {
 async function runBunInstallWithDetails() {
   const cacheDir = getOpenCodeCacheDir();
   const packageJsonPath = `${cacheDir}/package.json`;
-  if (!existsSync9(packageJsonPath)) {
+  if (!existsSync8(packageJsonPath)) {
     return {
       success: false,
       error: `Workspace not initialized: ${packageJsonPath} not found. OpenCode should create this on first run.`
@@ -8261,16 +8278,16 @@ var init_config_paths = __esm(() => {
 });
 
 // src/hooks/auto-update-checker/checker/plugin-entry.ts
-import { existsSync as existsSync14, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync9 } from "fs";
 function isExplicitVersionPin(version2) {
   return version2 !== null && /^\d+\.\d+\.\d+/.test(version2);
 }
 function findPluginEntry(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!existsSync14(configPath))
+      if (!existsSync13(configPath))
         continue;
-      const config2 = parseJsonc(readFileSync10(configPath, "utf-8"));
+      const config2 = parseJsonc(readFileSync9(configPath, "utf-8"));
       for (const entry of config2.plugin ?? []) {
         if (!isManagedPluginEntry(entry))
           continue;
@@ -8311,11 +8328,11 @@ var init_constants3 = __esm(() => {
 });
 
 // src/hooks/auto-update-checker/checker/cached-version.ts
-import { existsSync as existsSync15, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync10 } from "fs";
 function getCachedVersion() {
   try {
-    if (existsSync15(INSTALLED_PACKAGE_JSON)) {
-      const installedPackage = JSON.parse(readFileSync11(INSTALLED_PACKAGE_JSON, "utf-8"));
+    if (existsSync14(INSTALLED_PACKAGE_JSON)) {
+      const installedPackage = JSON.parse(readFileSync10(INSTALLED_PACKAGE_JSON, "utf-8"));
       if (installedPackage.version)
         return installedPackage.version;
     }
@@ -8351,14 +8368,14 @@ var init_latest_version = __esm(() => {
 });
 
 // src/hooks/auto-update-checker/checker/local-dev-path.ts
-import { existsSync as existsSync16, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync11 } from "fs";
 import { fileURLToPath } from "url";
 function getLocalDevPath(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!existsSync16(configPath))
+      if (!existsSync15(configPath))
         continue;
-      const config2 = parseJsonc(readFileSync12(configPath, "utf-8"));
+      const config2 = parseJsonc(readFileSync11(configPath, "utf-8"));
       for (const entry of config2.plugin ?? []) {
         if (!isManagedPluginEntry(entry))
           continue;
@@ -8386,13 +8403,13 @@ var init_local_dev_path = __esm(() => {
 });
 
 // src/hooks/auto-update-checker/checker/local-dev-version.ts
-import { existsSync as existsSync17, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync12 } from "fs";
 import { dirname as dirname3, join as join15 } from "path";
 function findPackageJsonUp(startPath) {
   let current = startPath;
   while (true) {
     const candidate = join15(current, "package.json");
-    if (existsSync17(candidate))
+    if (existsSync16(candidate))
       return candidate;
     const parent = dirname3(current);
     if (parent === current)
@@ -8408,7 +8425,7 @@ function getLocalDevVersion(directory) {
     const packageJsonPath = findPackageJsonUp(localPath);
     if (!packageJsonPath)
       return null;
-    const packageJson = JSON.parse(readFileSync13(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(readFileSync12(packageJsonPath, "utf-8"));
     return packageJson.version ?? null;
   } catch {
     return null;
@@ -8515,10 +8532,10 @@ var init_checker = __esm(() => {
 });
 
 // src/hooks/auto-update-checker/cache.ts
-import { existsSync as existsSync18, rmSync as rmSync3, unlinkSync } from "fs";
+import { existsSync as existsSync17, rmSync as rmSync3, unlinkSync } from "fs";
 import { join as join16 } from "path";
 function deleteLockfile(lockPath) {
-  if (!existsSync18(lockPath))
+  if (!existsSync17(lockPath))
     return false;
   try {
     unlinkSync(lockPath);
@@ -8534,7 +8551,7 @@ function invalidatePackage(packageName = PACKAGE_NAME) {
     join16(USER_CONFIG_DIR, "node_modules", packageName),
     join16(CACHE_DIR, "node_modules", packageName)
   ]) {
-    if (!existsSync18(packageDir))
+    if (!existsSync17(packageDir))
       continue;
     rmSync3(packageDir, { recursive: true, force: true });
     changed = true;
@@ -9669,6 +9686,7 @@ function createEventState() {
     currentAgent: null,
     currentModel: null,
     currentVariant: null,
+    currentReasoningEffort: null,
     currentMessageRole: null,
     agentColorsByName: {},
     partTypesById: {},
@@ -9951,13 +9969,13 @@ var displayChars = {
 
 // src/cli/run/output-renderer.ts
 var import_picocolors6 = __toESM(require_picocolors(), 1);
-function renderAgentHeader(agent, model, variant, agentColorsByName) {
+function renderAgentHeader(agent, model, variant, reasoningEffort, agentColorsByName) {
   if (!agent && !model)
     return;
   const agentLabel = agent ? import_picocolors6.default.bold(colorizeWithProfileColor(agent, agentColorsByName[agent])) : "";
   const modelBase = model ?? "";
-  const variantSuffix = variant ? ` (${variant})` : "";
-  const modelLabel = model ? import_picocolors6.default.dim(`${modelBase}${variantSuffix}`) : "";
+  const modelDetails = formatModelDetails(variant, reasoningEffort);
+  const modelLabel = model ? import_picocolors6.default.dim(`${modelBase}${modelDetails}`) : "";
   process.stdout.write(`
 `);
   if (modelLabel) {
@@ -9971,6 +9989,10 @@ function renderAgentHeader(agent, model, variant, agentColorsByName) {
   process.stdout.write(`
 `);
 }
+function formatModelDetails(variant, reasoningEffort) {
+  const details = [variant, reasoningEffort ? `effort: ${reasoningEffort}` : null].filter(Boolean);
+  return details.length > 0 ? ` (${details.join(", ")})` : "";
+}
 function openThinkBlock() {
   process.stdout.write(`
   ${import_picocolors6.default.dim("\u2503  Thinking:")} `);
@@ -10049,9 +10071,9 @@ function renderCompletionMetaLine(state, messageID) {
   const elapsedSec = startedAt ? ((Date.now() - startedAt) / 1000).toFixed(1) : "0.0";
   const agent = state.currentAgent ?? "assistant";
   const model = state.currentModel ?? "unknown-model";
-  const variant = state.currentVariant ? ` (${state.currentVariant})` : "";
+  const modelDetails = formatModelDetails(state.currentVariant, state.currentReasoningEffort);
   process.stdout.write(import_picocolors7.default.dim(`
-  ${displayChars.treeEnd} ${agent} \xB7 ${model}${variant} \xB7 ${elapsedSec}s  
+  ${displayChars.treeEnd} ${agent} \xB7 ${model}${modelDetails} \xB7 ${elapsedSec}s  
 `));
   state.completionMetaPrintedByMessageId[messageID] = true;
 }
@@ -10237,11 +10259,13 @@ function handleMessageUpdated(ctx, payload, state) {
   const agent = props?.info?.agent ?? null;
   const model = props?.info?.modelID ?? null;
   const variant = props?.info?.variant ?? null;
-  if (agent !== state.currentAgent || model !== state.currentModel || variant !== state.currentVariant) {
+  const reasoningEffort = props?.info?.reasoningEffort ?? null;
+  if (agent !== state.currentAgent || model !== state.currentModel || variant !== state.currentVariant || reasoningEffort !== state.currentReasoningEffort) {
     state.currentAgent = agent;
     state.currentModel = model;
     state.currentVariant = variant;
-    renderAgentHeader(agent, model, variant, state.agentColorsByName);
+    state.currentReasoningEffort = reasoningEffort;
+    renderAgentHeader(agent, model, variant, reasoningEffort, state.agentColorsByName);
   }
 }
 function handleToolExecute(ctx, payload, state) {
@@ -10349,7 +10373,6 @@ async function processEvents(ctx, stream, state) {
 }
 // src/plugin-config.ts
 import * as fs3 from "fs";
-import * as path3 from "path";
 
 // node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -24309,7 +24332,9 @@ function parseConfigPartially(rawConfig) {
   const partialConfig = {};
   const invalidSections = [];
   for (const key of Object.keys(rawConfig)) {
-    const sectionResult = OhMyOpenCodeConfigSchema.safeParse({ [key]: rawConfig[key] });
+    const sectionResult = OhMyOpenCodeConfigSchema.safeParse({
+      [key]: rawConfig[key]
+    });
     if (sectionResult.success) {
       const parsed = sectionResult.data;
       if (parsed[key] !== undefined) {
@@ -24331,7 +24356,7 @@ function loadConfigFromPath(configPath, _ctx) {
   try {
     if (fs3.existsSync(configPath)) {
       const content = fs3.readFileSync(configPath, "utf-8");
-      const rawConfig = parseJsonc(content);
+      const rawConfig = parseOmoConfigJson(content);
       migrateConfigFile(configPath, rawConfig);
       const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
       if (result.success) {
@@ -24346,7 +24371,9 @@ function loadConfigFromPath(configPath, _ctx) {
       });
       const partialResult = parseConfigPartially(rawConfig);
       if (partialResult) {
-        log(`Partial config loaded from ${configPath}`, { agents: partialResult.agents });
+        log(`Partial config loaded from ${configPath}`, {
+          agents: partialResult.agents
+        });
         return partialResult;
       }
       return null;
@@ -24398,13 +24425,11 @@ function mergeConfigs(base, override) {
   };
 }
 function loadPluginConfig(directory, ctx) {
-  const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const userBasePath = path3.join(configDir, "oh-my-opencode-gpt-slim");
-  const userDetected = detectConfigFile(userBasePath);
-  const userConfigPath = userDetected.format !== "none" ? userDetected.path : userBasePath + ".json";
-  const projectBasePath = path3.join(directory, ".opencode", "oh-my-opencode-gpt-slim");
-  const projectDetected = detectConfigFile(projectBasePath);
-  const projectConfigPath = projectDetected.format !== "none" ? projectDetected.path : projectBasePath + ".json";
+  const userConfigPath = getOpenCodeConfigPaths({
+    binary: "opencode",
+    version: null
+  }).omoConfig;
+  const projectConfigPath = getProjectOmoConfigFilePath(directory);
   let config2 = loadConfigFromPath(userConfigPath, ctx) ?? {};
   const projectConfig = loadConfigFromPath(projectConfigPath, ctx);
   if (projectConfig) {
@@ -24656,7 +24681,7 @@ var serializeObjectParam = ({ allowReserved, explode, name, style, value, valueO
 
 // node_modules/@opencode-ai/sdk/dist/gen/core/utils.gen.js
 var PATH_PARAM_RE = /\{[^{}]+\}/g;
-var defaultPathSerializer = ({ path: path4, url: _url2 }) => {
+var defaultPathSerializer = ({ path: path3, url: _url2 }) => {
   let url2 = _url2;
   const matches = _url2.match(PATH_PARAM_RE);
   if (matches) {
@@ -24675,7 +24700,7 @@ var defaultPathSerializer = ({ path: path4, url: _url2 }) => {
         name = name.substring(1);
         style = "matrix";
       }
-      const value = path4[name];
+      const value = path3[name];
       if (value === undefined || value === null) {
         continue;
       }
@@ -24706,11 +24731,11 @@ var defaultPathSerializer = ({ path: path4, url: _url2 }) => {
   }
   return url2;
 };
-var getUrl = ({ baseUrl, path: path4, query, querySerializer, url: _url2 }) => {
+var getUrl = ({ baseUrl, path: path3, query, querySerializer, url: _url2 }) => {
   const pathUrl = _url2.startsWith("/") ? _url2 : `/${_url2}`;
   let url2 = (baseUrl ?? "") + pathUrl;
-  if (path4) {
-    url2 = defaultPathSerializer({ path: path4, url: url2 });
+  if (path3) {
+    url2 = defaultPathSerializer({ path: path3, url: url2 });
   }
   let search = query ? querySerializer(query) : "";
   if (search.startsWith("?")) {
@@ -26205,18 +26230,18 @@ 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 readFileSync7, writeFileSync as writeFileSync4, mkdirSync as mkdirSync2, readdirSync as readdirSync2 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync6, writeFileSync as writeFileSync4, mkdirSync as mkdirSync2, readdirSync as readdirSync2 } from "fs";
 import { dirname as dirname2, join as join10, basename } from "path";
 function getBoulderFilePath(directory) {
   return join10(directory, BOULDER_DIR, BOULDER_FILE);
 }
 function readBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
-  if (!existsSync11(filePath)) {
+  if (!existsSync10(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync7(filePath, "utf-8");
+    const content = readFileSync6(filePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       return null;
@@ -26230,11 +26255,11 @@ function readBoulderState(directory) {
   }
 }
 function getPlanProgress(planPath) {
-  if (!existsSync11(planPath)) {
+  if (!existsSync10(planPath)) {
     return { total: 0, completed: 0, isComplete: true };
   }
   try {
-    const content = readFileSync7(planPath, "utf-8");
+    const content = readFileSync6(planPath, "utf-8");
     const uncheckedMatches = content.match(/^\s*[-*]\s*\[\s*\]/gm) || [];
     const checkedMatches = content.match(/^\s*[-*]\s*\[[xX]\]/gm) || [];
     const total = uncheckedMatches.length + checkedMatches.length;
@@ -26251,17 +26276,17 @@ function getPlanProgress(planPath) {
 // 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 mkdirSync3, readFileSync as readFileSync8, rmSync, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync3, readFileSync as readFileSync7, rmSync, writeFileSync as writeFileSync5 } from "fs";
 import { join as join11 } from "path";
 function getMarkerPath(directory, sessionID) {
   return join11(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
 }
 function readContinuationMarker(directory, sessionID) {
   const markerPath = getMarkerPath(directory, sessionID);
-  if (!existsSync12(markerPath))
+  if (!existsSync11(markerPath))
     return null;
   try {
-    const raw = readFileSync8(markerPath, "utf-8");
+    const raw = readFileSync7(markerPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
       return null;
@@ -26285,17 +26310,17 @@ function getActiveContinuationMarkerReason(marker) {
   return entry.reason ?? `${source} continuation is active`;
 }
 // src/hooks/ralph-loop/storage.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync4, readFileSync as readFileSync9, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync4, readFileSync as readFileSync8, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
 import { join as join12 } from "path";
 function getStatePath(directory) {
   return join12(directory, ".sisyphus", "ralph-loop-state.json");
 }
 function readState(directory) {
   const statePath = getStatePath(directory);
-  if (!existsSync13(statePath))
+  if (!existsSync12(statePath))
     return null;
   try {
-    return JSON.parse(readFileSync9(statePath, "utf-8"));
+    return JSON.parse(readFileSync8(statePath, "utf-8"));
   } catch {
     return null;
   }
@@ -26982,17 +27007,16 @@ var EXIT_CODES = {
   FAILURE: 1
 };
 var MIN_OPENCODE_VERSION = "1.0.150";
-var CONFIG_BASENAME2 = "oh-my-opencode-gpt-slim";
 var OPENCODE_BINARIES2 = ["opencode", "opencode-desktop"];
 
 // src/cli/doctor/checks/system.ts
 init_plugin_reference();
 init_jsonc_parser();
-import { existsSync as existsSync22, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync15 } from "fs";
 
 // src/cli/doctor/checks/system-binary.ts
 init_spawn_with_windows_hide();
-import { existsSync as existsSync19 } from "fs";
+import { existsSync as existsSync18 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join17 } from "path";
 function getDesktopAppPaths(platform) {
@@ -27032,7 +27056,7 @@ function buildVersionCommand(binaryPath, platform) {
   }
   return [binaryPath, "--version"];
 }
-function findDesktopBinary(platform = process.platform, checkExists = existsSync19) {
+function findDesktopBinary(platform = process.platform, checkExists = existsSync18) {
   for (const desktopPath of getDesktopAppPaths(platform)) {
     if (checkExists(desktopPath)) {
       return { binary: "opencode", path: desktopPath };
@@ -27042,9 +27066,9 @@ function findDesktopBinary(platform = process.platform, checkExists = existsSync
 }
 async function findOpenCodeBinary() {
   for (const binary2 of OPENCODE_BINARIES2) {
-    const path4 = Bun.which(binary2);
-    if (path4) {
-      return { binary: binary2, path: path4 };
+    const path3 = Bun.which(binary2);
+    if (path3) {
+      return { binary: binary2, path: path3 };
     }
   }
   return findDesktopBinary();
@@ -27084,7 +27108,7 @@ init_auto_update_checker();
 init_plugin_reference();
 init_data_path();
 init_jsonc_parser();
-import { existsSync as existsSync20, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync13 } from "fs";
 import { homedir as homedir5 } from "os";
 import { join as join18 } from "path";
 function getPlatformDefaultCacheDir(platform = process.platform) {
@@ -27100,15 +27124,15 @@ function resolveOpenCodeCacheDir() {
     return join18(xdgCacheHome, "opencode");
   const fromShared = getOpenCodeCacheDir();
   const platformDefault = join18(getPlatformDefaultCacheDir(), "opencode");
-  if (existsSync20(fromShared) || !existsSync20(platformDefault))
+  if (existsSync19(fromShared) || !existsSync19(platformDefault))
     return fromShared;
   return platformDefault;
 }
 function readPackageJson(filePath) {
-  if (!existsSync20(filePath))
+  if (!existsSync19(filePath))
     return null;
   try {
-    const content = readFileSync14(filePath, "utf-8");
+    const content = readFileSync13(filePath, "utf-8");
     return parseJsonc(content);
   } catch {
     return null;
@@ -27148,12 +27172,12 @@ function getSuggestedInstallTag(currentVersion) {
 init_plugin_reference();
 init_opencode_config_dir();
 init_jsonc_parser();
-import { existsSync as existsSync21, readFileSync as readFileSync15 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync14 } from "fs";
 function detectConfigPath() {
   const paths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
-  if (existsSync21(paths.configJsonc))
+  if (existsSync20(paths.configJsonc))
     return paths.configJsonc;
-  if (existsSync21(paths.configJson))
+  if (existsSync20(paths.configJson))
     return paths.configJson;
   return null;
 }
@@ -27180,7 +27204,7 @@ function getPluginInfo() {
     };
   }
   try {
-    const content = readFileSync15(configPath, "utf-8");
+    const content = readFileSync14(configPath, "utf-8");
     const parsedConfig = parseJsonc(content);
     const pluginEntry = findPluginEntry2(parsedConfig.plugin ?? []);
     if (!pluginEntry) {
@@ -27221,10 +27245,10 @@ function getPluginInfo() {
 function isConfigValid(configPath) {
   if (!configPath)
     return true;
-  if (!existsSync22(configPath))
+  if (!existsSync21(configPath))
     return false;
   try {
-    parseJsonc(readFileSync16(configPath, "utf-8"));
+    parseJsonc(readFileSync15(configPath, "utf-8"));
     return true;
   } catch {
     return false;
@@ -27327,11 +27351,56 @@ async function checkSystem() {
 }
 
 // src/cli/doctor/checks/config.ts
-import { existsSync as existsSync24, readFileSync as readFileSync19 } from "fs";
-import { join as join22 } from "path";
 init_data_path();
+import { existsSync as existsSync24, readFileSync as readFileSync19 } from "fs";
+import { join as join21 } from "path";
+
+// src/cli/doctor/checks/config-validation.ts
+import { existsSync as existsSync22, readFileSync as readFileSync16 } from "fs";
+init_omo_config_file();
 init_opencode_config_dir();
-init_jsonc_parser();
+var USER_CONFIG_PATH = getOmoConfigFilePath(getOpenCodeConfigDir({ binary: "opencode" }));
+var PROJECT_CONFIG_PATH = getProjectOmoConfigFilePath(process.cwd());
+function findConfigPath() {
+  if (existsSync22(PROJECT_CONFIG_PATH)) {
+    return PROJECT_CONFIG_PATH;
+  }
+  if (existsSync22(USER_CONFIG_PATH)) {
+    return USER_CONFIG_PATH;
+  }
+  return null;
+}
+function validateConfig() {
+  const configPath = findConfigPath();
+  if (!configPath) {
+    return { exists: false, path: null, valid: true, config: null, errors: [] };
+  }
+  try {
+    const rawConfig = parseOmoConfigJson(readFileSync16(configPath, "utf-8"));
+    const schemaResult = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
+    if (!schemaResult.success) {
+      return {
+        exists: true,
+        path: configPath,
+        valid: false,
+        config: rawConfig,
+        errors: schemaResult.error.issues.map((issue2) => `${issue2.path.join(".")}: ${issue2.message}`)
+      };
+    }
+    return { exists: true, path: configPath, valid: true, config: rawConfig, errors: [] };
+  } catch (error48) {
+    return {
+      exists: true,
+      path: configPath,
+      valid: false,
+      config: null,
+      errors: [error48 instanceof Error ? error48.message : "Failed to parse config"]
+    };
+  }
+}
+
+// src/cli/doctor/checks/model-resolution.ts
+init_model_requirements();
 
 // src/cli/doctor/checks/model-resolution-cache.ts
 init_shared();
@@ -27366,42 +27435,31 @@ function loadAvailableModelsFromCache() {
   }
 }
 
-// src/cli/doctor/checks/model-resolution.ts
-init_model_requirements();
-
 // src/cli/doctor/checks/model-resolution-config.ts
-init_plugin_reference();
+init_omo_config_file();
 init_opencode_config_dir();
-init_jsonc_parser();
 import { readFileSync as readFileSync18 } from "fs";
-import { join as join20 } from "path";
-var USER_CONFIG_BASE = join20(getOpenCodeConfigPaths({ binary: "opencode", version: null }).configDir, CONFIG_BASENAME);
-var PROJECT_CONFIG_BASE = join20(process.cwd(), ".opencode", CONFIG_BASENAME);
+var USER_CONFIG_PATH2 = getOpenCodeConfigPaths({
+  binary: "opencode",
+  version: null
+}).omoConfig;
+var PROJECT_CONFIG_PATH2 = getProjectOmoConfigFilePath(process.cwd());
 function loadOmoConfig() {
-  const projectDetected = detectConfigFile(PROJECT_CONFIG_BASE);
-  if (projectDetected.format !== "none") {
-    try {
-      const content = readFileSync18(projectDetected.path, "utf-8");
-      return parseJsonc(content);
-    } catch {
-      return null;
-    }
-  }
-  const userDetected = detectConfigFile(USER_CONFIG_BASE);
-  if (userDetected.format !== "none") {
-    try {
-      const content = readFileSync18(userDetected.path, "utf-8");
-      return parseJsonc(content);
-    } catch {
-      return null;
-    }
+  try {
+    const content = readFileSync18(PROJECT_CONFIG_PATH2, "utf-8");
+    return parseOmoConfigJson(content);
+  } catch {}
+  try {
+    const content = readFileSync18(USER_CONFIG_PATH2, "utf-8");
+    return parseOmoConfigJson(content);
+  } catch {
+    return null;
   }
-  return null;
 }
 
 // src/cli/doctor/checks/model-resolution-details.ts
 init_shared();
-import { join as join21 } from "path";
+import { join as join20 } from "path";
 
 // src/cli/doctor/checks/model-resolution-variant.ts
 function formatModelWithVariant(model, variant) {
@@ -27440,7 +27498,7 @@ function getCategoryEffectiveVariant(categoryName, requirement, config2) {
 // src/cli/doctor/checks/model-resolution-details.ts
 function buildModelResolutionDetails(options) {
   const details = [];
-  const cacheFile = join21(getOpenCodeCacheDir(), "models.json");
+  const cacheFile = join20(getOpenCodeCacheDir(), "models.json");
   details.push("\u2550\u2550\u2550 Available Models (from cache) \u2550\u2550\u2550");
   details.push("");
   if (options.available.cacheExists) {
@@ -27552,55 +27610,15 @@ async function checkModels() {
 }
 
 // src/cli/doctor/checks/config.ts
-var USER_CONFIG_BASE2 = join22(getOpenCodeConfigDir({ binary: "opencode" }), CONFIG_BASENAME2);
-var PROJECT_CONFIG_BASE2 = join22(process.cwd(), ".opencode", CONFIG_BASENAME2);
-function findConfigPath() {
-  const projectConfig = detectConfigFile(PROJECT_CONFIG_BASE2);
-  if (projectConfig.format !== "none")
-    return projectConfig.path;
-  const userConfig = detectConfigFile(USER_CONFIG_BASE2);
-  if (userConfig.format !== "none")
-    return userConfig.path;
-  return null;
-}
-function validateConfig() {
-  const configPath = findConfigPath();
-  if (!configPath) {
-    return { exists: false, path: null, valid: true, config: null, errors: [] };
-  }
-  try {
-    const content = readFileSync19(configPath, "utf-8");
-    const rawConfig = parseJsonc(content);
-    const schemaResult = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
-    if (!schemaResult.success) {
-      return {
-        exists: true,
-        path: configPath,
-        valid: false,
-        config: rawConfig,
-        errors: schemaResult.error.issues.map((issue2) => `${issue2.path.join(".")}: ${issue2.message}`)
-      };
-    }
-    return { exists: true, path: configPath, valid: true, config: rawConfig, errors: [] };
-  } catch (error48) {
-    return {
-      exists: true,
-      path: configPath,
-      valid: false,
-      config: null,
-      errors: [error48 instanceof Error ? error48.message : "Failed to parse config"]
-    };
-  }
-}
 function loadKnownProviderIds() {
   const availableModels = loadAvailableModelsFromCache();
   const providers = new Set(availableModels.providers);
   const cacheDirs = [
-    join22(getCacheDir(), "oh-my-opencode-gpt-slim"),
-    join22(getCacheDir(), "oh-my-opencode")
+    join21(getCacheDir(), "oh-my-opencode-gpt-slim"),
+    join21(getCacheDir(), "oh-my-opencode")
   ];
   for (const cacheDir of cacheDirs) {
-    const providerModelsPath = join22(cacheDir, "provider-models.json");
+    const providerModelsPath = join21(cacheDir, "provider-models.json");
     if (existsSync24(providerModelsPath)) {
       try {
         const content = readFileSync19(providerModelsPath, "utf-8");
@@ -27610,7 +27628,7 @@ function loadKnownProviderIds() {
         }
       } catch {}
     }
-    const connectedProvidersPath = join22(cacheDir, "connected-providers.json");
+    const connectedProvidersPath = join21(cacheDir, "connected-providers.json");
     if (existsSync24(connectedProvidersPath)) {
       try {
         const content = readFileSync19(connectedProvidersPath, "utf-8");
@@ -27705,12 +27723,12 @@ async function checkConfig() {
 init_spawn_with_windows_hide();
 import { existsSync as existsSync25 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname4, join as join23 } from "path";
+import { dirname as dirname4, join as join22 } from "path";
 async function checkBinaryExists(binary2) {
   try {
-    const path4 = Bun.which(binary2);
-    if (path4) {
-      return { exists: true, path: path4 };
+    const path3 = Bun.which(binary2);
+    if (path3) {
+      return { exists: true, path: path3 };
     }
   } catch {}
   return { exists: false, path: null };
@@ -27762,11 +27780,11 @@ async function checkAstGrepNapi() {
     };
   } catch {
     const { existsSync: existsSync26 } = await import("fs");
-    const { join: join24 } = await import("path");
+    const { join: join23 } = await import("path");
     const { homedir: homedir7 } = await import("os");
     const pathsToCheck = [
-      join24(homedir7(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
-      join24(process.cwd(), "node_modules", "@ast-grep", "napi")
+      join23(homedir7(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
+      join23(process.cwd(), "node_modules", "@ast-grep", "napi")
     ];
     for (const napiPath of pathsToCheck) {
       if (existsSync26(napiPath)) {
@@ -27794,7 +27812,7 @@ function findCommentCheckerPackageBinary() {
   try {
     const require2 = createRequire(import.meta.url);
     const pkgPath = require2.resolve("@code-yeongyu/comment-checker/package.json");
-    const binaryPath = join23(dirname4(pkgPath), "bin", binaryName);
+    const binaryPath = join22(dirname4(pkgPath), "bin", binaryName);
     if (existsSync25(binaryPath))
       return binaryPath;
   } catch {}
@@ -27911,11 +27929,12 @@ async function getGhCliInfo() {
 // src/tools/lsp/server-config-loader.ts
 init_shared();
 init_jsonc_parser();
+init_omo_config_file();
 
 // src/tools/lsp/server-installation.ts
 init_shared();
 import { existsSync as existsSync26 } from "fs";
-import { join as join24 } from "path";
+import { join as join23 } from "path";
 function isServerInstalled(command) {
   if (command.length === 0)
     return false;
@@ -27943,23 +27962,23 @@ function isServerInstalled(command) {
   const paths = pathEnv.split(pathSeparator);
   for (const p2 of paths) {
     for (const suffix of exts) {
-      if (existsSync26(join24(p2, cmd + suffix))) {
+      if (existsSync26(join23(p2, cmd + suffix))) {
         return true;
       }
     }
   }
   const cwd = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join24(getDataDir(), "opencode");
+  const dataDir = join23(getDataDir(), "opencode");
   const additionalBases = [
-    join24(cwd, "node_modules", ".bin"),
-    join24(configDir, "bin"),
-    join24(configDir, "node_modules", ".bin"),
-    join24(dataDir, "bin")
+    join23(cwd, "node_modules", ".bin"),
+    join23(configDir, "bin"),
+    join23(configDir, "node_modules", ".bin"),
+    join23(dataDir, "bin")
   ];
   for (const base of additionalBases) {
     for (const suffix of exts) {
-      if (existsSync26(join24(base, cmd + suffix))) {
+      if (existsSync26(join23(base, cmd + suffix))) {
         return true;
       }
     }
@@ -27995,13 +28014,13 @@ function getLspServerStats(servers) {
 init_shared();
 import { existsSync as existsSync27, readFileSync as readFileSync20 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join25 } from "path";
+import { join as join24 } from "path";
 var BUILTIN_MCP_SERVERS = ["context7", "grep_app"];
 function getMcpConfigPaths() {
   return [
-    join25(homedir7(), ".claude", ".mcp.json"),
-    join25(process.cwd(), ".mcp.json"),
-    join25(process.cwd(), ".claude", ".mcp.json")
+    join24(homedir7(), ".claude", ".mcp.json"),
+    join24(process.cwd(), ".mcp.json"),
+    join24(process.cwd(), ".claude", ".mcp.json")
   ];
 }
 function loadUserMcpConfig() {
@@ -28413,10 +28432,10 @@ async function doctor(options = { mode: "default" }) {
 // src/features/mcp-oauth/storage.ts
 init_shared();
 import { chmodSync, existsSync as existsSync28, mkdirSync as mkdirSync5, readFileSync as readFileSync21, unlinkSync as unlinkSync2, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname5, join as join26 } from "path";
+import { dirname as dirname5, join as join25 } from "path";
 var STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStoragePath() {
-  return join26(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
+  return join25(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
 }
 function normalizeHost(serverHost) {
   let host = serverHost.trim();
@@ -29034,7 +29053,7 @@ function createMcpOAuthCommand() {
 
 // src/cli/validate-skill/validate-skill.ts
 import { existsSync as existsSync30 } from "fs";
-import { join as join31 } from "path";
+import { join as join30 } from "path";
 
 // src/features/skill-creator/eval-grader.ts
 function includesAll(text, values) {
@@ -29113,7 +29132,7 @@ function gradeEvalReport(report, sourceReport) {
 }
 // src/features/skill-creator/eval-runner.ts
 import { mkdtemp, mkdir, cp, rm } from "fs/promises";
-import { dirname as dirname6, join as join29, resolve as resolve2 } from "path";
+import { dirname as dirname6, join as join28, resolve as resolve2 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 
 // src/tools/session-manager/storage.ts
@@ -29122,14 +29141,14 @@ init_opencode_message_dir();
 init_opencode_storage_detection();
 import { existsSync as existsSync29 } from "fs";
 import { readdir, readFile } from "fs/promises";
-import { join as join28 } from "path";
+import { join as join27 } from "path";
 
 // src/tools/session-manager/constants.ts
 init_shared();
 init_shared();
-import { join as join27 } from "path";
-var TODO_DIR = join27(getClaudeConfigDir(), "todos");
-var TRANSCRIPT_DIR = join27(getClaudeConfigDir(), "transcripts");
+import { join as join26 } from "path";
+var TODO_DIR = join26(getClaudeConfigDir(), "todos");
+var TRANSCRIPT_DIR = join26(getClaudeConfigDir(), "transcripts");
 
 // src/tools/session-manager/storage.ts
 init_opencode_message_dir();
@@ -29201,7 +29220,7 @@ async function readSessionMessages(sessionID) {
       if (!file2.endsWith(".json"))
         continue;
       try {
-        const content = await readFile(join28(messageDir, file2), "utf-8");
+        const content = await readFile(join27(messageDir, file2), "utf-8");
         const meta3 = JSON.parse(content);
         const parts = await readParts(meta3.id);
         messages.push({
@@ -29225,7 +29244,7 @@ async function readSessionMessages(sessionID) {
   });
 }
 async function readParts(messageID) {
-  const partDir = join28(PART_STORAGE, messageID);
+  const partDir = join27(PART_STORAGE, messageID);
   if (!existsSync29(partDir))
     return [];
   const parts = [];
@@ -29235,7 +29254,7 @@ async function readParts(messageID) {
       if (!file2.endsWith(".json"))
         continue;
       try {
-        const content = await readFile(join28(partDir, file2), "utf-8");
+        const content = await readFile(join27(partDir, file2), "utf-8");
         parts.push(JSON.parse(content));
       } catch {}
     }
@@ -29317,13 +29336,13 @@ function detectSkillInvocation(messages, skillName) {
   }));
 }
 async function createEvalWorkspace(skillDir, skillName, evalBaseDir, files) {
-  const workspaceDir = await mkdtemp(join29(tmpdir2(), "omo-skill-eval-"));
-  const skillTargetDir = join29(workspaceDir, ".opencode", "skills", skillName);
+  const workspaceDir = await mkdtemp(join28(tmpdir2(), "omo-skill-eval-"));
+  const skillTargetDir = join28(workspaceDir, ".opencode", "skills", skillName);
   await mkdir(dirname6(skillTargetDir), { recursive: true });
   await cp(skillDir, skillTargetDir, { recursive: true });
   for (const file2 of files) {
     const sourcePath = resolve2(evalBaseDir, file2);
-    const targetPath = join29(workspaceDir, file2);
+    const targetPath = join28(workspaceDir, file2);
     await mkdir(dirname6(targetPath), { recursive: true });
     await cp(sourcePath, targetPath, { recursive: true });
   }
@@ -29430,7 +29449,7 @@ async function loadSkillEvalSuite(evalFilePath) {
 }
 // src/features/skill-creator/skill-validator.ts
 import { access, readFile as readFile3 } from "fs/promises";
-import { dirname as dirname7, join as join30, resolve as resolve3 } from "path";
+import { dirname as dirname7, join as join29, resolve as resolve3 } from "path";
 init_frontmatter();
 var ALLOWED_FRONTMATTER_KEYS = new Set([
   "name",
@@ -29448,16 +29467,16 @@ var ALLOWED_FRONTMATTER_KEYS = new Set([
 function isZodError(error48) {
   return error48 instanceof exports_external.ZodError;
 }
-async function pathExists(path4) {
+async function pathExists(path3) {
   try {
-    await access(path4);
+    await access(path3);
     return true;
   } catch {
     return false;
   }
 }
 async function resolveSkillFilePath(skillPath) {
-  const directSkillFile = skillPath.endsWith("SKILL.md") ? skillPath : join30(skillPath, "SKILL.md");
+  const directSkillFile = skillPath.endsWith("SKILL.md") ? skillPath : join29(skillPath, "SKILL.md");
   const exists = await pathExists(directSkillFile);
   if (!exists) {
     throw new Error(`SKILL.md not found at ${directSkillFile}`);
@@ -29579,9 +29598,9 @@ async function validateSkillDirectory(skillPath, evalFilePath) {
 // src/cli/validate-skill/validate-skill.ts
 function findDefaultEvalFile(skillDir) {
   const candidates = [
-    join31(skillDir, "evals", "evals.json"),
-    join31(skillDir, "evals", "evals.yaml"),
-    join31(skillDir, "evals", "evals.yml")
+    join30(skillDir, "evals", "evals.json"),
+    join30(skillDir, "evals", "evals.yaml"),
+    join30(skillDir, "evals", "evals.yml")
   ];
   return candidates.find((candidate) => existsSync30(candidate));
 }