oh-my-opencode 5.0.0-beta.82 → 5.0.0-beta.83

package/dist/tui.js

@@ -3268,8 +3268,10 @@ var init_command_executor2 = __esm(() => {
 var init_contains_path2 = () => {};
 
 // packages/omo-opencode/src/shared/plugin-identity.ts
-var PUBLISHED_PACKAGE_NAME = "oh-my-openagent", LOG_FILENAME = "oh-my-opencode.log", CACHE_DIR_NAME = "oh-my-opencode";
-var init_plugin_identity = () => {};
+var PUBLISHED_PACKAGE_NAME = "oh-my-openagent", ACCEPTED_PACKAGE_NAMES, LOG_FILENAME = "oh-my-opencode.log", CACHE_DIR_NAME = "oh-my-opencode";
+var init_plugin_identity = __esm(() => {
+  ACCEPTED_PACKAGE_NAMES = ["oh-my-openagent", "oh-my-opencode"];
+});
 
 // packages/omo-opencode/src/shared/logger.ts
 var logger3, log2, getLogFilePath;
@@ -3343,6 +3345,7 @@ var init_agent_model_requirements = __esm(() => {
     },
     librarian: {
       fallbackChain: [
+        { providers: ["kimi-for-coding"], model: "kimi-for-coding-highspeed", variant: "off" },
         { providers: ["openai", "openai-codex"], model: "gpt-5.6-luna-fast", variant: "low" },
         { providers: ["deepseek"], model: "deepseek-v4-flash", variant: "max" },
         { providers: ["opencode-go", "bailian-coding-plan"], model: "qwen3.7-plus" },
@@ -3355,6 +3358,7 @@ var init_agent_model_requirements = __esm(() => {
     },
     explore: {
       fallbackChain: [
+        { providers: ["kimi-for-coding"], model: "kimi-for-coding-highspeed", variant: "off" },
         { providers: ["openai", "openai-codex"], model: "gpt-5.6-luna-fast", variant: "low" },
         { providers: ["deepseek"], model: "deepseek-v4-flash", variant: "max" },
         { providers: ["opencode-go", "bailian-coding-plan"], model: "qwen3.7-plus" },
@@ -3528,7 +3532,6 @@ var init_category_model_requirements = __esm(() => {
     },
     quick: {
       fallbackChain: [
-        { providers: ["kimi-for-coding"], model: "kimi-for-coding-highspeed" },
         { providers: ["openai-codex"], model: "gpt-5.6-luna-fast", variant: "low" },
         { providers: ["deepseek"], model: "deepseek-v4-flash", variant: "off" },
         {
@@ -3548,7 +3551,8 @@ var init_category_model_requirements = __esm(() => {
     },
     "unspecified-low": {
       fallbackChain: [
-        { providers: ["xai", "github-copilot", "opencode"], model: "grok-4.6", variant: "xhigh" },
+        { providers: ["xiaomi", "opencode-go"], model: "mimo-v2.6-pro", variant: "max" },
+        { providers: ["xai", "github-copilot", "opencode-go"], model: "grok-4.7", variant: "xhigh" },
         {
           providers: ["openai", "openai-codex", "github-copilot", "opencode"],
           model: "gpt-5.6-terra",
@@ -3570,11 +3574,6 @@ var init_category_model_requirements = __esm(() => {
     },
     "unspecified-high": {
       fallbackChain: [
-        {
-          providers: ["openai", "openai-codex", "github-copilot", "opencode"],
-          model: "gpt-6-astra",
-          variant: "high"
-        },
         {
           providers: ["anthropic", "anthropic-api", "github-copilot", "opencode"],
           model: "claude-opus-5",
@@ -4188,6 +4187,36 @@ var init_supplemental_entries = __esm(() => {
         output: 32768
       }
     },
+    "grok-4.7": {
+      id: "grok-4.7",
+      family: "grok",
+      reasoning: false,
+      temperature: true,
+      toolCall: true,
+      modalities: {
+        input: ["text", "image"],
+        output: ["text"]
+      },
+      limit: {
+        context: 500000,
+        output: 32768
+      }
+    },
+    "xai/grok-4.7": {
+      id: "xai/grok-4.7",
+      family: "grok",
+      reasoning: false,
+      temperature: true,
+      toolCall: true,
+      modalities: {
+        input: ["text", "image"],
+        output: ["text"]
+      },
+      limit: {
+        context: 500000,
+        output: 32768
+      }
+    },
     "xai/grok-build-0.1": {
       id: "xai/grok-build-0.1",
       family: "grok",
@@ -4217,6 +4246,36 @@ var init_supplemental_entries = __esm(() => {
         context: 256000,
         output: 32768
       }
+    },
+    "mimo-v2.6-pro": {
+      id: "mimo-v2.6-pro",
+      family: "mimo",
+      reasoning: true,
+      temperature: true,
+      toolCall: true,
+      modalities: {
+        input: ["text", "image"],
+        output: ["text"]
+      },
+      limit: {
+        context: 1048576,
+        output: 131072
+      }
+    },
+    "xiaomi/mimo-v2.6-pro": {
+      id: "xiaomi/mimo-v2.6-pro",
+      family: "mimo",
+      reasoning: true,
+      temperature: true,
+      toolCall: true,
+      modalities: {
+        input: ["text", "image"],
+        output: ["text"]
+      },
+      limit: {
+        context: 1048576,
+        output: 131072
+      }
     }
   };
 });
@@ -4740,6 +4799,9 @@ function getCacheDir() {
 function getOmoOpenCodeCacheDir() {
   return path3.join(getCacheDir(), CACHE_DIR_NAME);
 }
+function getOpenCodeCacheDir() {
+  return path3.join(getCacheDir(), "opencode");
+}
 var init_data_path = __esm(() => {
   init_src();
   init_plugin_identity();
@@ -5102,21 +5164,21 @@ var init_openai_categories = __esm(() => {
     },
     {
       name: "quick",
-      config: { model: "kimi-for-coding/kimi-for-coding-highspeed" },
+      config: { model: "openai/gpt-5.6-luna-fast", variant: "low" },
       description: "Trivial tasks - single file changes, typo fixes, simple modifications",
       callerGuidance: QUICK_CATEGORY_CALLER_GUIDANCE,
       promptAppend: QUICK_CATEGORY_PROMPT_APPEND
     },
     {
       name: "unspecified-low",
-      config: { model: "xai/grok-4.6", variant: "xhigh" },
+      config: { model: "xiaomi/mimo-v2.6-pro", variant: "max" },
       description: "Tasks that don't fit other categories, low effort required",
       callerGuidance: UNSPECIFIED_LOW_CATEGORY_CALLER_GUIDANCE,
       promptAppend: UNSPECIFIED_LOW_CATEGORY_PROMPT_APPEND
     },
     {
       name: "unspecified-high",
-      config: { model: "openai/gpt-6-astra", variant: "high" },
+      config: { model: "anthropic/claude-opus-5", variant: "xhigh" },
       description: "Tasks that don't fit other categories, high effort required",
       callerGuidance: UNSPECIFIED_HIGH_CATEGORY_CALLER_GUIDANCE,
       promptAppend: UNSPECIFIED_HIGH_CATEGORY_PROMPT_APPEND,
@@ -5164,6 +5226,102 @@ var init_migration2 = __esm(() => {
 });
 
 // packages/omo-opencode/src/shared/opencode-config-dir.ts
+import { existsSync as existsSync2, realpathSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3, posix, resolve, win32 } from "path";
+function isDevBuild(version) {
+  if (!version)
+    return false;
+  return version.includes("-dev") || version.includes(".dev");
+}
+function getTauriConfigDir(identifier) {
+  const platform = process.platform;
+  switch (platform) {
+    case "darwin":
+      return join3(homedir2(), "Library", "Application Support", identifier);
+    case "win32": {
+      const appData = process.env.APPDATA || join3(homedir2(), "AppData", "Roaming");
+      return win32.join(appData, identifier);
+    }
+    case "linux":
+    default: {
+      const xdgConfig = process.env.XDG_CONFIG_HOME || join3(homedir2(), ".config");
+      return join3(xdgConfig, identifier);
+    }
+  }
+}
+function resolveConfigPath(pathValue) {
+  if (isWslEnvironment() && pathValue.startsWith("/")) {
+    return posix.normalize(pathValue);
+  }
+  const resolvedPath = resolve(pathValue);
+  if (!existsSync2(resolvedPath))
+    return resolvedPath;
+  try {
+    return realpathSync(resolvedPath);
+  } catch (error) {
+    if (error instanceof Error) {
+      return resolvedPath;
+    }
+    return resolvedPath;
+  }
+}
+function isWslEnvironment() {
+  return process.platform === "linux" && (Boolean(process.env.WSL_DISTRO_NAME?.trim()) || Boolean(process.env.WSL_INTEROP?.trim()));
+}
+function isWindowsUserConfigRoot(pathValue) {
+  const normalizedPath = pathValue.replaceAll("\\", "/").toLowerCase();
+  return /^[a-z]:\/users\//.test(normalizedPath) || /^\/mnt\/[a-z]\/users\//.test(normalizedPath);
+}
+function getWindowsUserFromConfigRoot(pathValue) {
+  const normalizedPath = pathValue.replaceAll("\\", "/");
+  const match = /^(?:[a-z]:|\/mnt\/[a-z])\/Users\/([^/]+)/i.exec(normalizedPath);
+  return match?.[1] ?? null;
+}
+function getWslLinuxHomeDir(windowsConfigRoot) {
+  const envHome = process.env.HOME?.trim();
+  if (envHome && envHome.startsWith("/") && !isWindowsUserConfigRoot(envHome)) {
+    return envHome;
+  }
+  const user = process.env.USER?.trim() || process.env.LOGNAME?.trim() || process.env.SUDO_USER?.trim() || (windowsConfigRoot ? getWindowsUserFromConfigRoot(windowsConfigRoot) : undefined);
+  return user ? posix.join("/home", user) : null;
+}
+function getCliDefaultConfigDir() {
+  const envXdgConfig = process.env.XDG_CONFIG_HOME?.trim();
+  const shouldIgnoreWindowsXdg = envXdgConfig !== undefined && envXdgConfig.length > 0 && isWslEnvironment() && isWindowsUserConfigRoot(envXdgConfig);
+  const xdgConfig = shouldIgnoreWindowsXdg ? posix.join(getWslLinuxHomeDir(envXdgConfig) ?? "/home", ".config") : envXdgConfig || join3(homedir2(), ".config");
+  const configDir = isWslEnvironment() ? posix.join(xdgConfig, "opencode") : join3(xdgConfig, "opencode");
+  return resolveConfigPath(configDir);
+}
+function getCliCustomConfigDir() {
+  const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
+  if (!envConfigDir) {
+    return null;
+  }
+  return resolveConfigPath(envConfigDir);
+}
+function getCliConfigDir() {
+  return getCliCustomConfigDir() ?? getCliDefaultConfigDir();
+}
+function getOpenCodeConfigDir(options) {
+  const { binary, version, checkExisting = true } = options;
+  if (binary === "opencode") {
+    return getCliConfigDir();
+  }
+  const identifier = isDevBuild(version) ? TAURI_APP_IDENTIFIER_DEV : TAURI_APP_IDENTIFIER;
+  const tauriDirBase = getTauriConfigDir(identifier);
+  const tauriDir = process.platform === "win32" ? win32.isAbsolute(tauriDirBase) ? win32.normalize(tauriDirBase) : win32.resolve(tauriDirBase) : resolveConfigPath(tauriDirBase);
+  if (checkExisting) {
+    const legacyDir = getCliConfigDir();
+    const legacyConfig = join3(legacyDir, "opencode.json");
+    const legacyConfigC = join3(legacyDir, "opencode.jsonc");
+    if (existsSync2(legacyConfig) || existsSync2(legacyConfigC)) {
+      return legacyDir;
+    }
+  }
+  return tauriDir;
+}
+var TAURI_APP_IDENTIFIER = "ai.opencode.desktop", TAURI_APP_IDENTIFIER_DEV = "ai.opencode.desktop.dev";
 var init_opencode_config_dir = () => {};
 
 // packages/omo-opencode/src/shared/resolve-agent-definition-paths.ts
@@ -5265,8 +5423,8 @@ var init_write_file_atomically = __esm(() => {
 });
 
 // packages/omo-opencode/src/shared/json-file-cache-store.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync, writeFileSync } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync, writeFileSync } from "fs";
+import { join as join4 } from "path";
 function toLogLabel(cacheLabel) {
   return cacheLabel.toLowerCase();
 }
@@ -5274,11 +5432,11 @@ function createJsonFileCacheStore(options) {
   let memoryValue;
   let writtenInCurrentProcess = false;
   function getCacheFilePath() {
-    return join3(options.getCacheDir(), options.filename);
+    return join4(options.getCacheDir(), options.filename);
   }
   function ensureCacheDir() {
     const cacheDir = options.getCacheDir();
-    if (!existsSync2(cacheDir)) {
+    if (!existsSync3(cacheDir)) {
       mkdirSync3(cacheDir, { recursive: true });
     }
   }
@@ -5287,7 +5445,7 @@ function createJsonFileCacheStore(options) {
       return memoryValue;
     }
     const cacheFile = getCacheFilePath();
-    if (!existsSync2(cacheFile)) {
+    if (!existsSync3(cacheFile)) {
       memoryValue = null;
       log2(`[${options.logPrefix}] ${options.cacheLabel} file not found`, { cacheFile });
       return null;
@@ -5313,7 +5471,7 @@ function createJsonFileCacheStore(options) {
     if (writtenInCurrentProcess) {
       return true;
     }
-    return existsSync2(getCacheFilePath());
+    return existsSync3(getCacheFilePath());
   }
   function write(value) {
     ensureCacheDir();
@@ -59882,14 +60040,14 @@ var init_fallback_model_availability = __esm(() => {
 });
 
 // packages/omo-opencode/src/shared/opencode-storage-paths.ts
-import { join as join4 } from "path";
+import { join as join5 } 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 = join4(OPENCODE_STORAGE, "message");
-  PART_STORAGE = join4(OPENCODE_STORAGE, "part");
-  SESSION_STORAGE = join4(OPENCODE_STORAGE, "session");
+  MESSAGE_STORAGE = join5(OPENCODE_STORAGE, "message");
+  PART_STORAGE = join5(OPENCODE_STORAGE, "part");
+  SESSION_STORAGE = join5(OPENCODE_STORAGE, "session");
 });
 
 // packages/omo-opencode/src/shared/compaction-marker.ts
@@ -69224,12 +69382,14 @@ var init_git_master = __esm(() => {
 });
 
 // packages/omo-config-core/src/schema/harness.ts
-var HARNESS_IDS, OMO_CONFIG_HARNESS_IDS, OmoHarnessIdSchema;
+var HARNESS_IDS, OMO_CONFIG_HARNESS_IDS, OmoHarnessIdSchema, OMO_CONFIG_LEGACY_HARNESS_ALIASES, OMO_CONFIG_LEGACY_HARNESS_IDS;
 var init_harness = __esm(() => {
   init_zod();
   HARNESS_IDS = ["codex", "opencode", "omo"];
-  OMO_CONFIG_HARNESS_IDS = ["opencode", "senpi", "codex"];
+  OMO_CONFIG_HARNESS_IDS = ["opencode", "native", "codex"];
   OmoHarnessIdSchema = _enum(OMO_CONFIG_HARNESS_IDS);
+  OMO_CONFIG_LEGACY_HARNESS_ALIASES = { senpi: "native" };
+  OMO_CONFIG_LEGACY_HARNESS_IDS = Object.keys(OMO_CONFIG_LEGACY_HARNESS_ALIASES);
 });
 
 // packages/omo-config-core/src/schema/memory.ts
@@ -69732,6 +69892,7 @@ var init_config = __esm(() => {
     telemetry: OmoTelemetrySettingsLayerSchema.optional(),
     disabled_skills: OmoDisabledSkillsSchema.optional(),
     "[opencode]": OmoOpenCodeHarnessConfigSchema.optional(),
+    "[native]": OmoTypedHarnessConfigSchema.optional(),
     "[senpi]": OmoTypedHarnessConfigSchema.optional(),
     "[codex]": OmoTypedHarnessConfigSchema.optional()
   }).strict();
@@ -69750,6 +69911,7 @@ var init_config = __esm(() => {
     telemetry: OmoTelemetrySettingsSchema.optional(),
     disabled_skills: OmoDisabledSkillsSchema.optional(),
     "[opencode]": OmoOpenCodeHarnessConfigSchema.optional(),
+    "[native]": OmoTypedHarnessConfigSchema.optional(),
     "[senpi]": OmoTypedHarnessConfigSchema.optional(),
     "[codex]": OmoTypedHarnessConfigSchema.optional(),
     profiles: record(string2(), OmoConfigProfileSchema).default({}),
@@ -69771,6 +69933,7 @@ var init_config = __esm(() => {
     telemetry: OmoTelemetrySettingsLayerSchema.optional(),
     disabled_skills: OmoDisabledSkillsSchema.optional(),
     "[opencode]": OmoOpenCodeHarnessConfigSchema.optional(),
+    "[native]": OmoTypedHarnessConfigSchema.optional(),
     "[senpi]": OmoTypedHarnessConfigSchema.optional(),
     "[codex]": OmoTypedHarnessConfigSchema.optional(),
     profiles: record(string2(), OmoConfigProfileSchema).optional(),
@@ -69838,6 +70001,57 @@ var init_legacy_category_names = __esm(() => {
   LEGACY_CATEGORY_NAME_ALIASES = { deep: "deep-low" };
 });
 
+// packages/omo-config-core/src/schema/legacy-harness-names.ts
+function canonicalHarnessName(name) {
+  return Object.hasOwn(OMO_CONFIG_LEGACY_HARNESS_ALIASES, name) ? OMO_CONFIG_LEGACY_HARNESS_ALIASES[name] : name;
+}
+function harnessBlockKey(harness) {
+  return `[${harness}]`;
+}
+function legacyHarnessOfBlockKey(key) {
+  if (!key.startsWith("[") || !key.endsWith("]"))
+    return;
+  const harness = key.slice(1, -1);
+  return Object.hasOwn(OMO_CONFIG_LEGACY_HARNESS_ALIASES, harness) ? harness : undefined;
+}
+function isRecord10(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function canonicalizeBlocksIn(container, path, renames) {
+  const result = {};
+  for (const [key, value] of Object.entries(container)) {
+    const legacyHarness = legacyHarnessOfBlockKey(key);
+    if (legacyHarness === undefined) {
+      result[key] = value;
+      continue;
+    }
+    const canonical = harnessBlockKey(canonicalHarnessName(legacyHarness));
+    const dropped = Object.hasOwn(container, canonical);
+    renames.push({ canonical, dropped, legacy: key, path: [...path, key].join(".") });
+    if (!dropped)
+      result[canonical] = value;
+  }
+  return result;
+}
+function canonicalizeLegacyHarnessBlocks(document) {
+  if (!isRecord10(document))
+    return { document: {}, renames: [] };
+  const renames = [];
+  const canonicalized = canonicalizeBlocksIn(document, [], renames);
+  const profiles = canonicalized["profiles"];
+  if (isRecord10(profiles)) {
+    const canonicalProfiles = {};
+    for (const [name, profile] of Object.entries(profiles)) {
+      canonicalProfiles[name] = isRecord10(profile) ? canonicalizeBlocksIn(profile, ["profiles", name], renames) : profile;
+    }
+    canonicalized["profiles"] = canonicalProfiles;
+  }
+  return { document: canonicalized, renames };
+}
+var init_legacy_harness_names = __esm(() => {
+  init_harness();
+});
+
 // packages/omo-config-core/src/schema/index.ts
 var init_schema = __esm(() => {
   init_agent();
@@ -69848,6 +70062,7 @@ var init_schema = __esm(() => {
   init_git_master();
   init_harness();
   init_legacy_category_names();
+  init_legacy_harness_names();
   init_memory();
   init_model_catalog();
   init_model_profile();
@@ -69857,6 +70072,9 @@ var init_schema = __esm(() => {
   init_telemetry();
 });
 
+// packages/omo-config-core/src/loader/disabled-skills.ts
+var init_disabled_skills = () => {};
+
 // packages/omo-config-core/src/loader/merge.ts
 function isUnsafeObjectKey2(key) {
   return DANGEROUS_KEYS2.has(key);
@@ -69900,33 +70118,33 @@ function toPosixPath(path) {
 var init_posix_path = () => {};
 
 // packages/omo-config-core/src/loader/types.ts
-import { existsSync as existsSync3, lstatSync, readFileSync as readFileSync3, realpathSync as realpathSync2 } from "fs";
+import { existsSync as existsSync4, lstatSync, readFileSync as readFileSync4, realpathSync as realpathSync3 } from "fs";
 var DEFAULT_READ_FILE_SYSTEM;
 var init_types3 = __esm(() => {
   DEFAULT_READ_FILE_SYSTEM = {
-    existsSync: existsSync3,
+    existsSync: existsSync4,
     lstatSync,
-    readFileSync: readFileSync3,
-    realpathSync: realpathSync2
+    readFileSync: readFileSync4,
+    realpathSync: realpathSync3
   };
 });
 
 // packages/omo-config-core/src/loader/paths.ts
 import { userInfo } from "os";
-import { dirname, join as join6, posix, resolve as resolve2 } from "path";
+import { dirname, join as join10, posix as posix2, resolve as resolve3 } from "path";
 function resolveHomeDir(env = process.env) {
   const homeDir = env.HOME ?? env.USERPROFILE ?? process.cwd();
-  return homeDir.startsWith("/") ? posix.resolve(homeDir) : toPosixPath(resolve2(homeDir));
+  return homeDir.startsWith("/") ? posix2.resolve(homeDir) : toPosixPath(resolve3(homeDir));
 }
 function resolveUserOmoConfigDirectory(env = process.env) {
-  return join6(resolveHomeDir(env), ".omo");
+  return join10(resolveHomeDir(env), ".omo");
 }
 function detectUserOmoJsonPath(env, fileSystem) {
   const configDir = resolveUserOmoConfigDirectory(env);
-  const jsoncPath = join6(configDir, "omo.jsonc");
+  const jsoncPath = join10(configDir, "omo.jsonc");
   if (fileSystem.existsSync(jsoncPath))
     return jsoncPath;
-  const jsonPath = join6(configDir, "omo.json");
+  const jsonPath = join10(configDir, "omo.json");
   return fileSystem.existsSync(jsonPath) ? jsonPath : jsoncPath;
 }
 function isSymlinkedProjectPath(path, fileSystem) {
@@ -69944,13 +70162,13 @@ function isLoadableProjectConfigFile(path, fileSystem) {
   return fileSystem.existsSync(path) && !isSymlinkedProjectPath(path, fileSystem);
 }
 function detectOmoJsonPath(dir, fileSystem) {
-  const omoDir = join6(dir, ".omo");
+  const omoDir = join10(dir, ".omo");
   if (isSymlinkedProjectPath(omoDir, fileSystem))
     return null;
-  const jsoncPath = join6(omoDir, "omo.jsonc");
+  const jsoncPath = join10(omoDir, "omo.jsonc");
   if (isLoadableProjectConfigFile(jsoncPath, fileSystem))
     return jsoncPath;
-  const jsonPath = join6(omoDir, "omo.json");
+  const jsonPath = join10(omoDir, "omo.json");
   return isLoadableProjectConfigFile(jsonPath, fileSystem) ? jsonPath : null;
 }
 function realpathOrSelf(path, fileSystem) {
@@ -69963,8 +70181,8 @@ function realpathOrSelf(path, fileSystem) {
   }
 }
 function findProjectConfigPathsFarthestFirst(cwd, homeDir, fileSystem, accountHomeDir = homeDir) {
-  const startDir = resolve2(cwd);
-  const boundaryDirs = [...new Set([resolve2(homeDir), resolve2(accountHomeDir)])];
+  const startDir = resolve3(cwd);
+  const boundaryDirs = [...new Set([resolve3(homeDir), resolve3(accountHomeDir)])];
   const realBoundaryDirs = new Set(boundaryDirs.map((path) => realpathOrSelf(path, fileSystem)));
   const nearestFirst = [];
   let currentDir = startDir;
@@ -70028,7 +70246,13 @@ function withoutControlKeys(config) {
 function harnessLayer(config, harness) {
   if (harness === undefined)
     return {};
-  return toRecord(config[`[${harness}]`]) ?? {};
+  const canonical = canonicalHarnessName(harness);
+  const legacyKeys = Object.entries(OMO_CONFIG_LEGACY_HARNESS_ALIASES).filter(([, target]) => target === canonical).map(([legacy]) => harnessBlockKey(legacy));
+  let layer = {};
+  for (const key of [...legacyKeys, harnessBlockKey(canonical)]) {
+    layer = mergeOmoConfigRecords(layer, toRecord(config[key]) ?? {});
+  }
+  return layer;
 }
 function resolveOmoConfigView(options) {
   const profiles = toRecord(options.config["profiles"]);
@@ -70058,7 +70282,7 @@ var HARNESS_KEYS;
 var init_resolution = __esm(() => {
   init_schema();
   init_merge();
-  HARNESS_KEYS = [...new Set([...HARNESS_IDS, ...OMO_CONFIG_HARNESS_IDS])].map((harness) => `[${harness}]`);
+  HARNESS_KEYS = [...new Set([...HARNESS_IDS, ...OMO_CONFIG_HARNESS_IDS, ...OMO_CONFIG_LEGACY_HARNESS_IDS])].map((harness) => harnessBlockKey(harness));
 });
 
 // packages/omo-config-core/src/loader/loader.ts
@@ -70079,6 +70303,7 @@ function parseJsoncSafe2(content) {
 function stripResolutionControlKeys(config) {
   const {
     "[codex]": _codex,
+    "[native]": _native,
     "[opencode]": _opencode,
     "[senpi]": _senpi,
     profiles: _profiles,
@@ -70104,21 +70329,21 @@ function hasUnsafeUnrecognizedKey(issues) {
 function hasTamperedPrototype(value) {
   if (Array.isArray(value))
     return value.some((entry) => hasTamperedPrototype(entry));
-  if (!isRecord10(value))
+  if (!isRecord11(value))
     return false;
   const prototype = Object.getPrototypeOf(value);
   if (prototype !== Object.prototype && prototype !== null)
     return true;
   return Object.values(value).some((entry) => hasTamperedPrototype(entry));
 }
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function containerAt(record, path) {
   let container = record;
   for (const segment of path) {
     const next = container[segment];
-    if (!isRecord10(next))
+    if (!isRecord11(next))
       return null;
     container = next;
   }
@@ -70229,6 +70454,15 @@ function legacyCategoryDiagnostic(path, renames) {
     issuePaths: renames.map((rename) => rename.path)
   };
 }
+function legacyHarnessDiagnostic(path, renames) {
+  const detail = renames.map((rename) => rename.dropped ? `${rename.path} ignored because ${rename.canonical} is also configured` : `${rename.path} renamed to ${rename.canonical}`).join(", ");
+  return {
+    kind: "deprecated-keys",
+    message: `Deprecated harness block in ${path}: ${detail}. Rename it; the alias is removed in a future release.`,
+    path,
+    issuePaths: renames.map((rename) => rename.path)
+  };
+}
 function loadOmoConfig(options = {}) {
   const fileSystem = options.fileSystem ?? DEFAULT_READ_FILE_SYSTEM;
   const cwd = options.cwd ?? process.cwd();
@@ -70251,8 +70485,12 @@ function loadOmoConfig(options = {}) {
       if (canonicalized.renames.length > 0) {
         diagnostics.push(legacyCategoryDiagnostic(candidate.path, canonicalized.renames));
       }
-      layers.push({ config: canonicalized.document, source: loaded.source });
-      merged = mergeOmoConfigRecords(merged, canonicalized.document);
+      const harnessCanonicalized = canonicalizeLegacyHarnessBlocks(canonicalized.document);
+      if (harnessCanonicalized.renames.length > 0) {
+        diagnostics.push(legacyHarnessDiagnostic(candidate.path, harnessCanonicalized.renames));
+      }
+      layers.push({ config: harnessCanonicalized.document, source: loaded.source });
+      merged = mergeOmoConfigRecords(merged, harnessCanonicalized.document);
     }
   }
   const requestedProfile = resolveOmoProfileName({
@@ -70300,6 +70538,7 @@ var init_loader2 = __esm(() => {
 
 // packages/omo-config-core/src/loader/index.ts
 var init_loader3 = __esm(() => {
+  init_disabled_skills();
   init_loader2();
   init_merge();
   init_paths();
@@ -70475,30 +70714,30 @@ var init_models = __esm(() => {
 // packages/omo-config-core/src/writer/types.ts
 import {
   copyFileSync,
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   lstatSync as lstatSync2,
-  mkdirSync as mkdirSync5,
-  readFileSync as readFileSync4,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync5,
   readdirSync,
   renameSync as renameSync2,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync2
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync3
 } from "fs";
 var DEFAULT_WRITE_FILE_SYSTEM;
 var init_types4 = __esm(() => {
   DEFAULT_WRITE_FILE_SYSTEM = {
     copyFileSync,
-    existsSync: existsSync4,
+    existsSync: existsSync5,
     lstatSync: lstatSync2,
-    mkdirSync: mkdirSync5,
-    readFileSync: readFileSync4,
+    mkdirSync: mkdirSync6,
+    readFileSync: readFileSync5,
     readdirSync,
     renameSync: renameSync2,
-    unlinkSync: unlinkSync2,
+    unlinkSync: unlinkSync3,
     writeFileExclusiveSync: (path, content) => {
-      writeFileSync2(path, content, { encoding: "utf-8", flag: "wx" });
+      writeFileSync3(path, content, { encoding: "utf-8", flag: "wx" });
     },
-    writeFileSync: writeFileSync2
+    writeFileSync: writeFileSync3
   };
 });
 
@@ -71277,7 +71516,8 @@ var init_hooks = __esm(() => {
     "webfetch-redirect-guard",
     "fsync-skip-warning",
     "plan-format-validator",
-    "legacy-plugin-toast"
+    "legacy-plugin-toast",
+    "native-edition-nudge"
   ]);
 });
 
@@ -73515,6 +73755,212 @@ async function registerBtwSideTui(api, solid) {
   });
   log2("[btw-side] TUI controls registered");
 }
+// packages/omo-opencode/src/cli/native-edition-hint.ts
+var NATIVE_EDITION_INSTALL_COMMAND = "bun add -g omo-ai@beta";
+var NATIVE_EDITION_GUIDE_URL = "https://github.com/code-yeongyu/oh-my-openagent/blob/dev/docs/guide/installation.md#omo-native-beta-omo-via-omo-ai";
+
+// packages/omo-opencode/src/cli/install-native/plan.ts
+var NATIVE_PACKAGE_SPEC = "omo-ai@beta";
+var NATIVE_SETUP_COMMAND = "omo setup";
+var PLANS = {
+  bun: { packageManager: "bun", command: "bun", args: ["add", "-g", NATIVE_PACKAGE_SPEC] },
+  npm: { packageManager: "npm", command: "npm", args: ["i", "-g", NATIVE_PACKAGE_SPEC] }
+};
+function resolveNativeInstallPlan(bunAvailable) {
+  return bunAvailable ? PLANS.bun : PLANS.npm;
+}
+function formatNativeInstallCommand(plan) {
+  return [plan.command, ...plan.args].join(" ");
+}
+// packages/omo-opencode/src/cli/install-native/run-native-install.ts
+init_bun_which_shim();
+
+// packages/omo-opencode/src/shared/spawn-with-windows-hide.ts
+init_bun_spawn_shim();
+// packages/omo-opencode/src/hooks/native-edition-nudge/types.ts
+var NUDGE_STATE_VERSION = 1;
+var NUDGE_INTERVALS_MS = [3, 7, 14].map((days) => days * 24 * 60 * 60 * 1000);
+var NUDGE_SNOOZE_MS = 7 * 24 * 60 * 60 * 1000;
+var NUDGE_CORRUPT_RECOVERY_MS = 3 * 24 * 60 * 60 * 1000;
+// packages/omo-opencode/src/hooks/native-edition-nudge/hook.ts
+import { join as join8 } from "path";
+init_logger2();
+
+// packages/omo-opencode/src/hooks/auto-update-checker/constants.ts
+import * as path4 from "path";
+init_data_path();
+init_opencode_config_dir();
+init_plugin_identity();
+var PACKAGE_NAME = PUBLISHED_PACKAGE_NAME;
+var ACCEPTED_PACKAGE_NAMES2 = ACCEPTED_PACKAGE_NAMES;
+var NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
+var CACHE_ROOT_DIR = getOpenCodeCacheDir();
+var CACHE_DIR = path4.join(CACHE_ROOT_DIR, "packages");
+var VERSION_FILE = path4.join(CACHE_ROOT_DIR, "version");
+function getUserConfigDir() {
+  return getOpenCodeConfigDir({ binary: "opencode" });
+}
+var INSTALLED_PACKAGE_JSON = path4.join(CACHE_DIR, "node_modules", PACKAGE_NAME, "package.json");
+var INSTALLED_PACKAGE_JSON_CANDIDATES = ACCEPTED_PACKAGE_NAMES2.map((name) => path4.join(CACHE_DIR, "node_modules", name, "package.json"));
+
+// packages/omo-opencode/src/hooks/native-edition-nudge/state.ts
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join7 } from "path";
+var NUDGE_STATE_FILE = "native-nudge.json";
+function isDecision(value) {
+  return value === "none" || value === "snoozed" || value === "never" || value === "migrated";
+}
+function isEpoch(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function parseNudgeState(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return "corrupt";
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+    return "corrupt";
+  const record = parsed;
+  if (!isDecision(record["decision"]))
+    return "corrupt";
+  if (!isEpoch(record["nextEligibleAt"]))
+    return "corrupt";
+  const autoShows = record["autoShows"];
+  return {
+    schemaVersion: typeof record["schemaVersion"] === "number" ? record["schemaVersion"] : NUDGE_STATE_VERSION,
+    autoShows: typeof autoShows === "number" && Number.isSafeInteger(autoShows) && autoShows >= 0 ? autoShows : 0,
+    lastShownAt: isEpoch(record["lastShownAt"]) ? record["lastShownAt"] : null,
+    nextEligibleAt: record["nextEligibleAt"],
+    decision: record["decision"],
+    decidedAt: isEpoch(record["decidedAt"]) ? record["decidedAt"] : null,
+    writtenBy: typeof record["writtenBy"] === "string" ? record["writtenBy"] : "unknown"
+  };
+}
+function createNudgeStateStore(stateDir) {
+  const path = join7(stateDir, NUDGE_STATE_FILE);
+  return {
+    read: () => {
+      let raw;
+      try {
+        raw = readFileSync2(path, "utf8");
+      } catch {
+        return "missing";
+      }
+      return parseNudgeState(raw);
+    },
+    write: (state) => {
+      try {
+        mkdirSync4(stateDir, { recursive: true });
+        writeFileSync2(path, `${JSON.stringify(state, null, 2)}
+`, { mode: 384 });
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    probeWritable: () => {
+      const probe = join7(stateDir, `.${NUDGE_STATE_FILE}.probe`);
+      try {
+        mkdirSync4(stateDir, { recursive: true });
+        writeFileSync2(probe, "", { mode: 384 });
+      } catch {
+        return false;
+      }
+      try {
+        unlinkSync2(probe);
+      } catch {}
+      return true;
+    }
+  };
+}
+
+// packages/omo-opencode/src/hooks/native-edition-nudge/hook.ts
+var NATIVE_NUDGE_TOAST_MESSAGE = `Same agent, one binary, nothing else to keep updated.
+Install: ${NATIVE_EDITION_INSTALL_COMMAND}`;
+function nativeEditionStateDir() {
+  return join8(getUserConfigDir(), "oh-my-openagent");
+}
+// packages/omo-opencode/src/features/native-edition-nudge/tui.ts
+var NATIVE_NUDGE_DIALOG_TITLE = "OmO Native";
+var NATIVE_NUDGE_OPTIONS = [
+  { value: "install", title: "Install OmO Native" },
+  { value: "guide", title: "Open the guide" },
+  { value: "later", title: "Remind me in a week" },
+  { value: "never", title: "Don't ask again" }
+];
+function baseState(now) {
+  return {
+    schemaVersion: NUDGE_STATE_VERSION,
+    autoShows: 0,
+    lastShownAt: null,
+    nextEligibleAt: now,
+    decision: "none",
+    decidedAt: null,
+    writtenBy: "tui"
+  };
+}
+function currentState(store, now) {
+  const read = store.read();
+  return read === "missing" || read === "corrupt" ? baseState(now) : read;
+}
+function applyNativeEditionNudgeAction(action, options) {
+  const state = currentState(options.store, options.now);
+  if (action === "install") {
+    const command = formatNativeInstallCommand(resolveNativeInstallPlan(options.bunAvailable));
+    return { toast: `Run: ${command}
+Then: ${NATIVE_SETUP_COMMAND}` };
+  }
+  if (action === "guide") {
+    options.store.write({ ...state, nextEligibleAt: options.now + NUDGE_SNOOZE_MS, writtenBy: "tui" });
+    return { toast: "Opening the OmO Native guide.", url: NATIVE_EDITION_GUIDE_URL };
+  }
+  if (action === "later") {
+    options.store.write({
+      ...state,
+      nextEligibleAt: options.now + NUDGE_SNOOZE_MS,
+      decision: "snoozed",
+      decidedAt: options.now,
+      writtenBy: "tui"
+    });
+    return { toast: "I'll mention OmO Native again in a week." };
+  }
+  options.store.write({ ...state, decision: "never", decidedAt: options.now, writtenBy: "tui" });
+  return { toast: "I won't bring up OmO Native again. The command palette entry stays available." };
+}
+function registerNativeEditionNudgeTui(api, deps = {}) {
+  const store = deps.store ?? createNudgeStateStore(nativeEditionStateDir());
+  const open = () => {
+    api.ui.dialog.replace(() => api.ui.DialogSelect({
+      title: NATIVE_NUDGE_DIALOG_TITLE,
+      placeholder: "The same omo as one command, with no host app",
+      options: NATIVE_NUDGE_OPTIONS.map((option) => ({ title: option.title, value: option.value })),
+      onSelect: (option) => {
+        const result = applyNativeEditionNudgeAction(option.value, {
+          store,
+          now: Date.now(),
+          bunAvailable: true
+        });
+        api.ui.dialog.clear();
+        api.ui.toast?.({ message: result.toast });
+      }
+    }));
+  };
+  return api.command?.register(() => [
+    {
+      title: "OmO Native",
+      value: "omo.native.nudge",
+      description: "Install the standalone OmO Native edition, or stop being reminded about it",
+      category: "Session",
+      enabled: true,
+      slash: { name: "native", aliases: ["omo-native"] },
+      onSelect: open
+    }
+  ]) ?? (() => {
+    return;
+  });
+}
 // packages/omo-opencode/src/features/tui-sidebar/state-types.ts
 function assertNever(value) {
   throw new Error(`Unexpected variant: ${JSON.stringify(value)}`);
@@ -73682,30 +74128,30 @@ function compareJobs(left, right) {
 }
 
 // packages/omo-opencode/src/features/tui-sidebar/mirror-io.ts
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync2 } from "fs";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync3 } from "fs";
 init_write_file_atomically();
 
 // packages/omo-opencode/src/features/tui-sidebar/mirror-path.ts
 import { createHash } from "crypto";
-import { realpathSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join5, resolve } from "path";
+import { realpathSync as realpathSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join9, resolve as resolve2 } from "path";
 function mirrorStorageDir() {
-  return join5(process.env.XDG_DATA_HOME ?? join5(homedir2(), ".local", "share"), "opencode", "storage", "oh-my-openagent", MIRROR_DIR_NAME);
+  return join9(process.env.XDG_DATA_HOME ?? join9(homedir3(), ".local", "share"), "opencode", "storage", "oh-my-openagent", MIRROR_DIR_NAME);
 }
 function canonicalProjectDir(projectDir) {
   try {
-    return realpathSync.native(projectDir);
+    return realpathSync2.native(projectDir);
   } catch (error) {
     if (error instanceof Error) {
-      return resolve(projectDir);
+      return resolve2(projectDir);
     }
     throw error;
   }
 }
 function mirrorFilePath(projectDir) {
   const projectHash = createHash("sha1").update(canonicalProjectDir(projectDir)).digest("hex").slice(0, 16);
-  return join5(mirrorStorageDir(), `${projectHash}.json`);
+  return join9(mirrorStorageDir(), `${projectHash}.json`);
 }
 
 // packages/omo-opencode/src/features/tui-sidebar/snapshot-schema.ts
@@ -73765,7 +74211,7 @@ function parseSnapshot(raw) {
 function readMirror(projectDir) {
   let raw;
   try {
-    raw = JSON.parse(readFileSync2(mirrorFilePath(projectDir), "utf-8"));
+    raw = JSON.parse(readFileSync3(mirrorFilePath(projectDir), "utf-8"));
   } catch (error) {
     if (error instanceof Error) {
       return null;
@@ -73975,6 +74421,11 @@ var module = {
     } catch (error) {
       log2("[btw-side] TUI registration failed", { error });
     }
+    try {
+      registerNativeEditionNudgeTui(api);
+    } catch (error) {
+      log2("[native-edition-nudge] TUI registration failed", { error });
+    }
     const directory = api.state.path.directory;
     if ((await loadPluginValidation(directory)).config.tui?.sidebar?.enabled === false) {
       return;