@hiai-gg/hiai-opencode 0.1.3 → 0.1.5

package/src/mcp/registry.ts

@@ -1,4 +1,5 @@
 import { join } from "node:path"
+import { existsSync } from "node:fs"
 import type { McpServerConfig } from "../config/types.js"
 
 export type HiaiMcpName =
@@ -22,7 +23,11 @@ export interface HiaiMcpRegistryEntry {
 }
 
 function resolveAssetScript(...segments: string[]): string {
-  return join(import.meta.dirname, "..", "assets", ...segments)
+  const candidates = [
+    join(import.meta.dirname, "..", "assets", ...segments),
+    join(import.meta.dirname, "..", "..", "assets", ...segments),
+  ]
+  return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0]
 }
 
 function createNpmPackageCommand(pkg: string, ...args: string[]): string[] {

package/src/plugin/hooks/create-tool-guard-hooks.ts

@@ -136,7 +136,7 @@ export function createToolGuardHooks(args: {
     : null
 
   const fastApply = isHookEnabled("fast-apply")
-    ? safeHook("fast-apply", () => createFastApplyHook(pluginConfig.fast_apply ?? { enabled: false, ollama_url: "http://localhost:11434", model: "qwen3.5:9b", timeout: 30000 }))
+    ? safeHook("fast-apply", () => createFastApplyHook(pluginConfig.fast_apply ?? { enabled: false, ollama_url: "", model: "", timeout: 30000 }))
     : null
 
   return {

package/src/plugin/skill-context.ts

@@ -8,6 +8,7 @@ import type {
 
 import {
   discoverConfigSourceSkills,
+  discoverManagedPluginSkills,
   discoverUserClaudeSkills,
   discoverProjectClaudeSkills,
   discoverOpencodeGlobalSkills,
@@ -18,6 +19,7 @@ import {
 } from "../features/opencode-skill-loader"
 import { createBuiltinSkills } from "../features/builtin-skills"
 import { getSystemMcpServerNames } from "../features/claude-code-mcp-loader"
+import { resolveSkillDiscoveryConfig } from "./skill-discovery-config"
 
 export type SkillContext = {
   mergedSkills: LoadedSkill[]
@@ -71,21 +73,37 @@ export async function createSkillContext(args: {
     return true
   })
 
-  const includeClaudeSkills = pluginConfig.claude_code?.skills !== false
-  const [configSourceSkills, userSkills, globalSkills, projectSkills, opencodeProjectSkills, agentsProjectSkills, agentsGlobalSkills] =
+  const discovery = resolveSkillDiscoveryConfig(pluginConfig)
+  const [
+    managedPluginSkills,
+    configSourceSkills,
+    userSkills,
+    globalSkills,
+    projectSkills,
+    opencodeProjectSkills,
+    agentsProjectSkills,
+    agentsGlobalSkills,
+  ] =
     await Promise.all([
-      discoverConfigSourceSkills({
-        config: pluginConfig.skills,
-        configDir: directory,
-      }),
-      includeClaudeSkills ? discoverUserClaudeSkills() : Promise.resolve([]),
-      discoverOpencodeGlobalSkills(),
-      includeClaudeSkills ? discoverProjectClaudeSkills(directory) : Promise.resolve([]),
-      discoverOpencodeProjectSkills(directory),
-      discoverProjectAgentsSkills(directory),
-      discoverGlobalAgentsSkills(),
+      discoverManagedPluginSkills(),
+      discovery.config_sources
+        ? discoverConfigSourceSkills({
+          config: pluginConfig.skills,
+          configDir: directory,
+        })
+        : Promise.resolve([]),
+      discovery.global_claude ? discoverUserClaudeSkills() : Promise.resolve([]),
+      discovery.global_opencode ? discoverOpencodeGlobalSkills() : Promise.resolve([]),
+      discovery.project_claude ? discoverProjectClaudeSkills(directory) : Promise.resolve([]),
+      discovery.project_opencode ? discoverOpencodeProjectSkills(directory) : Promise.resolve([]),
+      discovery.project_agents ? discoverProjectAgentsSkills(directory) : Promise.resolve([]),
+      discovery.global_agents ? discoverGlobalAgentsSkills() : Promise.resolve([]),
     ])
 
+  const filteredManagedPluginSkills = filterProviderGatedSkills(
+    managedPluginSkills,
+    browserProvider,
+  )
   const filteredConfigSourceSkills = filterProviderGatedSkills(
     configSourceSkills,
     browserProvider,
@@ -109,7 +127,7 @@ export async function createSkillContext(args: {
   const mergedSkills = mergeSkills(
     builtinSkills,
     pluginConfig.skills,
-    filteredConfigSourceSkills,
+    [...filteredManagedPluginSkills, ...filteredConfigSourceSkills],
     [...filteredUserSkills, ...filteredAgentsGlobalSkills],
     filteredGlobalSkills,
     [...filteredProjectSkills, ...filteredAgentsProjectSkills],

package/src/plugin/skill-discovery-config.ts

@@ -0,0 +1,32 @@
+import type { HiaiOpenCodeConfig } from "../config"
+import type { SkillDiscoveryConfig } from "../config/schema"
+
+export type ResolvedSkillDiscoveryConfig = Required<SkillDiscoveryConfig>
+
+const DEFAULT_SKILL_DISCOVERY: ResolvedSkillDiscoveryConfig = {
+  config_sources: true,
+  project_opencode: true,
+  global_opencode: false,
+  project_claude: false,
+  global_claude: false,
+  project_agents: false,
+  global_agents: false,
+}
+
+export function resolveSkillDiscoveryConfig(
+  pluginConfig: HiaiOpenCodeConfig,
+): ResolvedSkillDiscoveryConfig {
+  const resolved: ResolvedSkillDiscoveryConfig = {
+    ...DEFAULT_SKILL_DISCOVERY,
+    ...(pluginConfig.skill_discovery ?? {}),
+  }
+
+  // Compatibility switch: historically this only controlled Claude-style skills.
+  // Keep that meaning, but make it stronger for those two sources.
+  if (pluginConfig.claude_code?.skills === false) {
+    resolved.project_claude = false
+    resolved.global_claude = false
+  }
+
+  return resolved
+}

package/src/plugin/tool-registry.ts

@@ -5,6 +5,7 @@ import type {
   AvailableCategory,
 } from "../agents/dynamic-agent-prompt-builder"
 import type { HiaiOpenCodeConfig } from "../config"
+import type { McpServerConfig } from "../config/types"
 import { isInteractiveBashEnabled } from "../create-runtime-tmux-config"
 import type { PluginContext, ToolsRecord } from "./types"
 
@@ -146,6 +147,7 @@ export function createToolRegistry(args: {
   managers: Pick<Managers, "backgroundManager" | "tmuxSessionManager" | "skillMcpManager">
   skillContext: SkillContext
   availableCategories: AvailableCategory[]
+  builtinMcp?: Record<string, McpServerConfig>
   interactiveBashEnabled?: boolean
   toolFactories?: Partial<ToolRegistryFactories>
 }): ToolRegistryResult {
@@ -155,6 +157,7 @@ export function createToolRegistry(args: {
     managers,
     skillContext,
     availableCategories,
+    builtinMcp,
     interactiveBashEnabled = isInteractiveBashEnabled(),
     toolFactories,
   } = args
@@ -216,6 +219,7 @@ export function createToolRegistry(args: {
     manager: managers.skillMcpManager,
     getLoadedSkills: () => skillContext.mergedSkills,
     getSessionID: getSessionIDForMcp,
+    builtinMcp,
   })
 
   const commands = factories.discoverCommandsSync(ctx.directory, {

package/src/plugin-handlers/agent-config-handler.ts

@@ -7,6 +7,7 @@ import { AGENT_NAME_MAP } from "../shared/migration";
 import { registerAgentName } from "../features/claude-code-session-state";
 import {
   discoverConfigSourceSkills,
+  discoverManagedPluginSkills,
   deduplicateSkillsByName,
   discoverGlobalAgentsSkills,
   discoverOpencodeGlobalSkills,
@@ -31,6 +32,7 @@ import {
   filterProtectedAgentOverrides,
 } from "./agent-override-protection";
 import { buildStrategistAgentConfig } from "./strategist-agent-config-builder";
+import { resolveSkillDiscoveryConfig } from "../plugin/skill-discovery-config";
 
 type AgentConfigRecord = Record<string, Record<string, unknown> | undefined> & {
   build?: Record<string, unknown>;
@@ -130,8 +132,9 @@ export async function applyAgentConfig(params: {
     },
   ) as typeof params.pluginConfig.disabled_agents;
 
-  const includeClaudeSkillsForAwareness = params.pluginConfig.claude_code?.skills ?? true;
+  const discovery = resolveSkillDiscoveryConfig(params.pluginConfig);
   const [
+    discoveredManagedPluginSkills,
     discoveredConfigSourceSkills,
     discoveredUserSkills,
     discoveredProjectSkills,
@@ -140,23 +143,27 @@ export async function applyAgentConfig(params: {
     discoveredOpencodeProjectSkills,
     discoveredGlobalAgentsSkills,
   ] = await Promise.all([
-    discoverConfigSourceSkills({
-      config: params.pluginConfig.skills,
-      configDir: params.ctx.directory,
-    }),
-    includeClaudeSkillsForAwareness ? discoverUserClaudeSkills() : Promise.resolve([]),
-    includeClaudeSkillsForAwareness
-       ? discoverProjectClaudeSkills(params.ctx.directory)
-       : Promise.resolve([]),
-    includeClaudeSkillsForAwareness
+    discoverManagedPluginSkills(),
+    discovery.config_sources
+      ? discoverConfigSourceSkills({
+        config: params.pluginConfig.skills,
+        configDir: params.ctx.directory,
+      })
+      : Promise.resolve([]),
+    discovery.global_claude ? discoverUserClaudeSkills() : Promise.resolve([]),
+    discovery.project_claude
+      ? discoverProjectClaudeSkills(params.ctx.directory)
+      : Promise.resolve([]),
+    discovery.project_agents
       ? discoverProjectAgentsSkills(params.ctx.directory)
       : Promise.resolve([]),
-    discoverOpencodeGlobalSkills(),
-    discoverOpencodeProjectSkills(params.ctx.directory),
-    includeClaudeSkillsForAwareness ? discoverGlobalAgentsSkills() : Promise.resolve([]),
+    discovery.global_opencode ? discoverOpencodeGlobalSkills() : Promise.resolve([]),
+    discovery.project_opencode ? discoverOpencodeProjectSkills(params.ctx.directory) : Promise.resolve([]),
+    discovery.global_agents ? discoverGlobalAgentsSkills() : Promise.resolve([]),
   ]);
 
   const allDiscoveredSkills = [
+    ...discoveredManagedPluginSkills,
     ...discoveredConfigSourceSkills,
     ...discoveredOpencodeProjectSkills,
     ...discoveredProjectSkills,

package/src/plugin-handlers/command-config-handler.ts

@@ -12,6 +12,7 @@ import {
 import { loadBuiltinCommands } from "../features/builtin-commands";
 import {
   discoverConfigSourceSkills,
+  loadManagedPluginSkills,
   loadGlobalAgentsSkills,
   loadProjectAgentsSkills,
   loadUserSkills,
@@ -26,6 +27,7 @@ import {
   log,
 } from "../shared";
 import type { PluginComponents } from "./plugin-components-loader";
+import { resolveSkillDiscoveryConfig } from "../plugin/skill-discovery-config";
 
 export async function applyCommandConfig(params: {
   config: Record<string, unknown>;
@@ -39,10 +41,13 @@ export async function applyCommandConfig(params: {
   const systemCommands = (params.config.command as Record<string, unknown>) ?? {};
 
   const includeClaudeCommands = params.pluginConfig.claude_code?.commands ?? true;
-  const includeClaudeSkills = params.pluginConfig.claude_code?.skills ?? true;
+  const discovery = resolveSkillDiscoveryConfig(params.pluginConfig);
 
   const externalSkillPlugin = detectExternalSkillPlugin(params.ctx.directory);
-  if (includeClaudeSkills && externalSkillPlugin.detected) {
+  if (
+    (discovery.project_claude || discovery.global_claude || discovery.global_opencode) &&
+    externalSkillPlugin.detected
+  ) {
     log(getSkillPluginConflictWarning(externalSkillPlugin.pluginName!));
   }
 
@@ -52,6 +57,7 @@ export async function applyCommandConfig(params: {
     projectCommands,
     opencodeGlobalCommands,
     opencodeProjectCommands,
+    managedPluginSkills,
     userSkills,
     globalAgentsSkills,
     projectSkills,
@@ -59,24 +65,28 @@ export async function applyCommandConfig(params: {
     opencodeGlobalSkills,
     opencodeProjectSkills,
   ] = await Promise.all([
-    discoverConfigSourceSkills({
-      config: params.pluginConfig.skills,
-      configDir: params.ctx.directory,
-    }),
+    discovery.config_sources
+      ? discoverConfigSourceSkills({
+        config: params.pluginConfig.skills,
+        configDir: params.ctx.directory,
+      })
+      : Promise.resolve([]),
     includeClaudeCommands ? loadUserCommands() : Promise.resolve({}),
     includeClaudeCommands ? loadProjectCommands(params.ctx.directory) : Promise.resolve({}),
     loadOpencodeGlobalCommands(),
     loadOpencodeProjectCommands(params.ctx.directory),
-    includeClaudeSkills ? loadUserSkills() : Promise.resolve({}),
-    includeClaudeSkills ? loadGlobalAgentsSkills() : Promise.resolve({}),
-    includeClaudeSkills ? loadProjectSkills(params.ctx.directory) : Promise.resolve({}),
-    includeClaudeSkills ? loadProjectAgentsSkills(params.ctx.directory) : Promise.resolve({}),
-    loadOpencodeGlobalSkills(),
-    loadOpencodeProjectSkills(params.ctx.directory),
+    loadManagedPluginSkills(),
+    discovery.global_claude ? loadUserSkills() : Promise.resolve({}),
+    discovery.global_agents ? loadGlobalAgentsSkills() : Promise.resolve({}),
+    discovery.project_claude ? loadProjectSkills(params.ctx.directory) : Promise.resolve({}),
+    discovery.project_agents ? loadProjectAgentsSkills(params.ctx.directory) : Promise.resolve({}),
+    discovery.global_opencode ? loadOpencodeGlobalSkills() : Promise.resolve({}),
+    discovery.project_opencode ? loadOpencodeProjectSkills(params.ctx.directory) : Promise.resolve({}),
   ]);
 
   params.config.command = {
     ...builtinCommands,
+    ...managedPluginSkills,
     ...skillsToCommandDefinitionRecord(configSourceSkills),
     ...userCommands,
     ...userSkills,

package/src/shared/migration/agent-names.ts

@@ -64,10 +64,10 @@ export const AGENT_NAME_MAP: Record<string, string> = {
   // Designer
   designer: "designer",
 
-  // Multimodal (runtime key remains "ui" for compatibility)
-  ui: "ui",
-  vision: "ui",
-  multimodal: "ui",
+  // Multimodal / Vision
+  ui: "multimodal",
+  vision: "multimodal",
+  multimodal: "multimodal",
 }
 
 export const BUILTIN_AGENT_NAMES = new Set([
@@ -77,7 +77,7 @@ export const BUILTIN_AGENT_NAMES = new Set([
   "critic",
   "designer",
   "researcher",
-  "ui",
+  "multimodal",
   "platform-manager",
   "guard",
 ])

package/src/shared/startup-diagnostics.ts

@@ -0,0 +1,77 @@
+import { existsSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+
+import type { HiaiOpenCodeConfig, HiaiOpencodeConfig } from "../config"
+import { HIAI_MCP_REGISTRY } from "../mcp/registry"
+import { parseJsoncSafe } from "./jsonc-parser"
+import { getOpenCodeConfigPaths } from "./opencode-config-dir"
+import { PLUGIN_NAME } from "./plugin-identity"
+
+interface OpenCodeConfig {
+  plugin?: Array<string | [string, ...unknown[]]>
+}
+
+function readPlugins(configPath: string): string[] {
+  if (!existsSync(configPath)) return []
+
+  try {
+    const content = readFileSync(configPath, "utf-8")
+    const parsed = parseJsoncSafe<OpenCodeConfig>(content)
+    return (parsed.data?.plugin ?? [])
+      .map((entry) => typeof entry === "string" ? entry : Array.isArray(entry) ? entry[0] : "")
+      .filter((entry): entry is string => typeof entry === "string" && entry.trim().length > 0)
+  } catch {
+    return []
+  }
+}
+
+export function warnIfListPluginEntry(directory: string): void {
+  const globalPaths = getOpenCodeConfigPaths({ binary: "opencode", version: null })
+  const candidates = [
+    join(directory, ".opencode", "opencode.json"),
+    join(directory, ".opencode", "opencode.jsonc"),
+    globalPaths.configJson,
+    globalPaths.configJsonc,
+  ]
+
+  for (const configPath of candidates) {
+    const plugins = readPlugins(configPath)
+    if (!plugins.includes("list")) continue
+
+    console.warn(`[hiai-opencode] WARNING: ${configPath} contains plugin: ["list"].`)
+    console.warn("[hiai-opencode] This can prevent hiai-opencode MCP servers from loading from that config scope.")
+    console.warn(`[hiai-opencode] Update it to: plugin: ["${PLUGIN_NAME}"]`)
+  }
+}
+
+function hasConfigAuthFallback(pluginConfig: HiaiOpenCodeConfig, envName: string): boolean {
+  if (envName === "FIRECRAWL_API_KEY") return !!pluginConfig.auth?.firecrawl?.trim()
+  if (envName === "STITCH_AI_API_KEY") return !!pluginConfig.auth?.stitch?.trim()
+  if (envName === "CONTEXT7_API_KEY") return !!pluginConfig.auth?.context7?.trim()
+  return false
+}
+
+export function warnMissingRequiredMcpEnv(args: {
+  pluginConfig: HiaiOpenCodeConfig
+  platformConfig: HiaiOpencodeConfig
+}): void {
+  const disabled = new Set(args.pluginConfig.disabled_mcps ?? [])
+  const mcpConfig = args.platformConfig.mcp ?? {}
+
+  for (const [name, entry] of Object.entries(HIAI_MCP_REGISTRY)) {
+    if (disabled.has(name)) continue
+    if (mcpConfig[name]?.enabled === false) continue
+    if (!entry.requiredEnv || entry.requiredEnv.length === 0) continue
+
+    const missing = entry.requiredEnv.filter((envName) =>
+      !process.env[envName]?.trim() && !hasConfigAuthFallback(args.pluginConfig, envName)
+    )
+
+    if (missing.length === 0) continue
+
+    console.warn(
+      `[hiai-opencode] MCP "${name}" is enabled but missing required env: ${missing.join(", ")}.`
+      + " The plugin will continue to load; set the key or disable this MCP in hiai-opencode.json.",
+    )
+  }
+}

package/src/tools/skill-mcp/tools.ts

@@ -1,14 +1,17 @@
 import { tool, type ToolDefinition } from "@opencode-ai/plugin"
 import type { ToolContext } from "@opencode-ai/plugin/tool"
 import { BUILTIN_MCP_TOOL_HINTS, SKILL_MCP_DESCRIPTION } from "./constants"
+import type { McpServerConfig } from "../../config/types"
 import type { SkillMcpArgs } from "./types"
 import type { SkillMcpManager, SkillMcpClientInfo, SkillMcpServerContext } from "../../features/skill-mcp-manager"
+import type { ClaudeCodeMcpServer } from "../../features/claude-code-mcp-loader/types"
 import type { LoadedSkill } from "../../features/opencode-skill-loader/types"
 
 interface SkillMcpToolOptions {
   manager: SkillMcpManager
   getLoadedSkills: () => LoadedSkill[]
   getSessionID?: () => string | undefined
+  builtinMcp?: Record<string, McpServerConfig>
 }
 
 type OperationType = { type: "tool" | "resource" | "prompt"; name: string }
@@ -60,6 +63,28 @@ function findMcpServer(
   return null
 }
 
+function convertBuiltinMcpConfig(config: McpServerConfig): ClaudeCodeMcpServer | null {
+  if (config.enabled === false) return null
+
+  if (config.type === "remote") {
+    return {
+      type: "http",
+      url: config.url,
+      headers: config.headers,
+    }
+  }
+
+  const [command, ...args] = config.command ?? []
+  if (!command) return null
+
+  return {
+    type: "stdio",
+    command,
+    args,
+    env: config.environment,
+  }
+}
+
 function formatAvailableMcps(skills: LoadedSkill[]): string {
   const mcps: string[] = []
   for (const skill of skills) {
@@ -72,6 +97,14 @@ function formatAvailableMcps(skills: LoadedSkill[]): string {
   return mcps.length > 0 ? mcps.join("\n") : "  (none found)"
 }
 
+function formatAvailableBuiltinMcps(builtinMcp: Record<string, McpServerConfig> | undefined): string {
+  const names = Object.entries(builtinMcp ?? {})
+    .filter(([, config]) => config.enabled !== false)
+    .map(([name]) => `  - "${name}" from hiai-opencode config`)
+
+  return names.length > 0 ? names.join("\n") : "  (none found)"
+}
+
 function formatBuiltinMcpHint(mcpName: string): string | null {
   const nativeTools = BUILTIN_MCP_TOOL_HINTS[mcpName]
   if (!nativeTools) return null
@@ -119,7 +152,7 @@ export function applyGrepFilter(output: string, pattern: string | undefined): st
 }
 
 export function createSkillMcpTool(options: SkillMcpToolOptions): ToolDefinition {
-  const { manager, getLoadedSkills, getSessionID } = options
+  const { manager, getLoadedSkills, getSessionID, builtinMcp } = options
 
   return tool({
     description: SKILL_MCP_DESCRIPTION,
@@ -141,8 +174,10 @@ export function createSkillMcpTool(options: SkillMcpToolOptions): ToolDefinition
       const operation = validateOperationParams(args)
       const skills = getLoadedSkills()
       const found = findMcpServer(args.mcp_name, skills)
+      const builtinConfig = builtinMcp?.[args.mcp_name]
+      const convertedBuiltinConfig = builtinConfig ? convertBuiltinMcpConfig(builtinConfig) : null
 
-      if (!found) {
+      if (!found && !convertedBuiltinConfig) {
         const builtinHint = formatBuiltinMcpHint(args.mcp_name)
         if (builtinHint) {
           throw new Error(builtinHint)
@@ -153,7 +188,10 @@ export function createSkillMcpTool(options: SkillMcpToolOptions): ToolDefinition
             `Available MCP servers in loaded skills:\n` +
             formatAvailableMcps(skills) +
             `\n\n` +
-            `Hint: Load the skill first using the 'skill' tool, then call skill_mcp.`,
+            `Available MCP servers in hiai-opencode config:\n` +
+            formatAvailableBuiltinMcps(builtinMcp) +
+            `\n\n` +
+            `Hint: Load the skill first for skill-embedded MCPs. Builtin hiai-opencode MCPs can be called directly when enabled in hiai-opencode.json.`,
         )
       }
 
@@ -164,14 +202,14 @@ export function createSkillMcpTool(options: SkillMcpToolOptions): ToolDefinition
 
       const info: SkillMcpClientInfo = {
         serverName: args.mcp_name,
-        skillName: found.skill.name,
+        skillName: found?.skill.name ?? "hiai-opencode",
         sessionID,
-        scope: found.skill.scope,
+        scope: found?.skill.scope ?? "user",
       }
 
       const context: SkillMcpServerContext = {
-        config: found.config,
-        skillName: found.skill.name,
+        config: found?.config ?? convertedBuiltinConfig!,
+        skillName: found?.skill.name ?? "hiai-opencode",
       }
 
       const parsedArgs = parseArguments(args.arguments)

package/src/config/models.ts

@@ -1,32 +0,0 @@
-export const MODEL_ROLE_GUIDE = [
-  "fast: cheap/default for bounded helpers, researcher-style scans, platform chores",
-  "mid: balanced default for steady execution/review work",
-  "high: stronger general-purpose model for primary implementation and planning",
-  "ultrahigh: highest-cost/high-accuracy slot for hard architecture or critical decisions",
-  "vision: preferred for UI/media/multimodal interpretation and visual work",
-  "reasoning: preferred for deeper multi-step reasoning when latency/cost are acceptable",
-] as const;
-
-export const PROVIDER_MODEL_RULES = [
-  "openai: use `openai/<model>` for direct OpenAI calls, e.g. `openai/gpt-5` or `openai/o1`",
-  "anthropic: use `anthropic/<model>`, e.g. `anthropic/claude-3.5-sonnet`",
-  "deepseek: use `deepseek/<model>` when connected directly",
-  "glm: use `z-ai/<model>` or the provider id exposed by your gateway/client",
-  "minimax: use `minimax/<model>`",
-  "qwen: use `qwen/<model>`",
-  "ollama: use the native local model id in Ollama config, e.g. `qwen3.5:4b`",
-  "openrouter: use `openrouter/<vendor>/<model>`, e.g. `openrouter/anthropic/claude-3.5-sonnet`",
-  "rule: store fully qualified model ids in config; avoid local aliases like `fast`, `sonnet`, or provider-less ids",
-] as const;
-
-export const MODEL_PRESETS = {
-  fast: "openrouter/google/gemini-2.0-flash",
-  mid: "openrouter/anthropic/claude-3.5-sonnet",
-  high: "openrouter/anthropic/claude-3.5-opus",
-  ultrahigh: "openrouter/openai/gpt-4o",
-  vision: "openrouter/google/gemini-2.0-pro-exp-02-05",
-  reasoning: "openrouter/openai/o1",
-  strategist: "openrouter/z-ai/glm-5.1",
-  critic: "openrouter/qwen/qwen2.5-72b-instruct",
-  writing: "openrouter/kimi/kimi-latest",
-} as const;