@hiai-gg/hiai-opencode 0.1.4 → 0.1.6

package/src/features/builtin-skills/skills/hiai-opencode-setup.ts

@@ -0,0 +1,69 @@
+import type { BuiltinSkill } from "../types"
+
+export const hiaiOpencodeSetupSkill: BuiltinSkill = {
+  name: "hiai-opencode-setup",
+  description:
+    "Use when install/setup/onboarding or MCP debug mentions: install, setup, bootstrap, doctor, mcp-status, MCP not found, mcp list empty, MemPalace, RAG, firecrawl, stitch, sequential-thinking, playwright, DCP, agents, skills, or LSP.",
+  template: `# hiai-opencode Setup And Runtime Operations
+
+Use this skill for hiai-opencode installation, diagnostics, and integration repair.
+
+## Architecture
+
+- hiai-opencode is an OpenCode plugin, not a standalone app.
+- MCP servers are external upstream tools launched by hiai-opencode wiring.
+- The user-facing config is \`hiai-opencode.json\` or \`.opencode/hiai-opencode.json\`.
+- Model provider credentials belong to OpenCode Connect. Do not ask for \`OPENROUTER_API_KEY\`, \`OPENAI_API_KEY\`, or \`ANTHROPIC_API_KEY\` for normal model usage.
+- Service credentials are separate: \`FIRECRAWL_API_KEY\`, \`STITCH_AI_API_KEY\`, \`CONTEXT7_API_KEY\`.
+
+## First Diagnostic Commands
+
+\`\`\`bash
+hiai-opencode doctor
+hiai-opencode mcp-status
+opencode debug config
+\`\`\`
+
+If \`opencode mcp list\` is empty but doctor/mcp-status sees servers, explain that OpenCode's list may read only static \`.mcp.json\`. Refresh static visibility:
+
+\`\`\`bash
+hiai-opencode export-mcp .mcp.json
+opencode mcp list --print-logs --log-level INFO
+\`\`\`
+
+## Plugin vs MCP
+
+Install OpenCode plugins with:
+
+\`\`\`bash
+opencode plugin @hiai-gg/hiai-opencode@latest --global
+opencode plugin @tarquinen/opencode-dcp@latest --global
+\`\`\`
+
+Do not add MCP packages to the OpenCode plugin array. MCP packages are launched through \`hiai-opencode.json\` and helper scripts.
+
+## MCP Runtime Notes
+
+- \`playwright\`: node/npx; browser binaries may need \`HIAI_PLAYWRIGHT_INSTALL_BROWSERS=1\`; Linux system deps may require admin rights.
+- \`sequential-thinking\`: node/npx; use for complex planning, revision, and branching.
+- \`firecrawl\`: requires \`FIRECRAWL_API_KEY\`.
+- \`mempalace\`: prefers \`uv\`; otherwise Python 3.9+ with \`mempalace\`. Use \`mempalace_status\` first, search before answering memory questions, and never invent memories.
+- \`rag\`: requires \`OPENCODE_RAG_URL\` or a reachable default \`http://localhost:9002/tools/search\`.
+- \`stitch\`: requires \`STITCH_AI_API_KEY\`.
+- \`context7\`: remote docs/search; key optional but recommended for limits.
+
+## Calling MCP
+
+- Use native MCP tools if OpenCode exposes them.
+- Use \`skill_mcp\` for skill-embedded MCP or enabled hiai-opencode MCP.
+- If \`skill_mcp\` says a server is not found, check whether the skill is loaded, whether the MCP is enabled in \`hiai-opencode.json\`, and whether \`.mcp.json\` needs export.
+
+## Safety Rules
+
+- Report missing keys by env var name only. Never print key values.
+- Prefer project-local or user-level installs. Do not use sudo/admin rights unless the user explicitly asks.
+- Do not edit unrelated OpenCode/Claude/Agents global skill folders unless the user opts in.
+- Keep DCP separate: it is an optional OpenCode plugin, not part of the hiai-opencode package.
+`,
+  allowedTools: ["Bash(*)", "Read(*)", "Edit(*)", "Glob(*)", "Grep(*)", "skill_mcp(*)"],
+}

package/src/features/builtin-skills/skills/index.ts

@@ -5,3 +5,4 @@ export { gitMasterSkill } from "./git-master"
 export { devBrowserSkill } from "./dev-browser"
 export { reviewWorkSkill } from "./review-work"
 export { aiSlopRemoverSkill } from "./ai-slop-remover"
+export { hiaiOpencodeSetupSkill } from "./hiai-opencode-setup"

package/src/features/builtin-skills/skills.ts

@@ -10,6 +10,7 @@ import {
   devBrowserSkill,
   reviewWorkSkill,
   aiSlopRemoverSkill,
+  hiaiOpencodeSetupSkill,
 } from "./skills/index"
 
 export interface CreateBuiltinSkillsOptions {
@@ -29,7 +30,15 @@ export function createBuiltinSkills(options: CreateBuiltinSkillsOptions = {}): B
     browserSkill = playwrightSkill
   }
 
-  const skills = [browserSkill, frontendUiUxSkill, gitMasterSkill, devBrowserSkill, reviewWorkSkill, aiSlopRemoverSkill]
+  const skills = [
+    browserSkill,
+    hiaiOpencodeSetupSkill,
+    frontendUiUxSkill,
+    gitMasterSkill,
+    devBrowserSkill,
+    reviewWorkSkill,
+    aiSlopRemoverSkill,
+  ]
 
   if (!disabledSkills) {
     return skills

package/src/index.ts

@@ -18,18 +18,15 @@ import { injectServerAuthIntoClient, log } from "./shared"
 import { hydratePluginConfigWithPlatformDefaults } from "./shared/runtime-plugin-config"
 import { detectExternalSkillPlugin, getSkillPluginConflictWarning } from "./shared/external-plugin-detector"
 import { PLUGIN_NAME } from "./shared/plugin-identity"
+import { autoExportStaticMcpJson } from "./shared/mcp-static-export"
 import { warnIfListPluginEntry, warnMissingRequiredMcpEnv } from "./shared/startup-diagnostics"
 import { startBackgroundCheck as startTmuxCheck } from "./tools/interactive-bash"
 import { lspManager } from "./tools/lsp/client"
 
-import { loadConfig, resolveEnvVars } from "./config/loader"
+import { loadConfig } from "./config/loader"
 import type { HiaiOpencodeConfig } from "./config/types"
 
 import { createPlugin as createSubtask2Plugin } from "./internals/plugins/subtask2/core/plugin"
-import WebsearchCitedPlugin, { 
-  WebsearchCitedGooglePlugin, 
-  WebsearchCitedOpenAIPlugin 
-} from "./internals/plugins/websearch-cited/index"
 import { createBuiltinSkills } from "./features/builtin-skills"
 import {
   materializeBuiltinSkills,
@@ -89,6 +86,7 @@ const HiaiOpenCodePlugin: Plugin = async (ctx) => {
     pluginConfig,
     platformConfig: internalConfig,
   })
+  autoExportStaticMcpJson(ctx.directory, internalConfig)
 
   materializeBuiltinSkills(
     createBuiltinSkills({
@@ -129,6 +127,7 @@ const HiaiOpenCodePlugin: Plugin = async (ctx) => {
   const toolsResult = await createTools({
     ctx,
     pluginConfig,
+    platformConfig: internalConfig,
     managers,
   })
 
@@ -169,10 +168,6 @@ const HiaiOpenCodePlugin: Plugin = async (ctx) => {
   } catch (err) {
     console.error("[hiai-opencode] PTYPlugin failed to load:", err);
   }
-  const websearchResult = await WebsearchCitedPlugin(ctx)
-  const websearchGoogleResult = await WebsearchCitedGooglePlugin(ctx)
-  const websearchOpenAIResult = await WebsearchCitedOpenAIPlugin(ctx)
-
   const combinedResult = {
     name: PLUGIN_NAME,
     ...pluginInterface,
@@ -181,7 +176,6 @@ const HiaiOpenCodePlugin: Plugin = async (ctx) => {
     tool: {
       ...pluginInterface.tool,
       ...ptyResult.tool,
-      ...websearchResult.tool,
     },
 
     // Chain hooks: command.execute.before
@@ -212,7 +206,6 @@ const HiaiOpenCodePlugin: Plugin = async (ctx) => {
     config: async (input: any) => {
       await pluginInterface.config?.(input);
       await (subtask2Result as any).config?.(input);
-      await (websearchResult as any).config?.(input);
     },
 
     // Merge Events
@@ -222,33 +215,6 @@ const HiaiOpenCodePlugin: Plugin = async (ctx) => {
       await (ptyResult as any).event?.(input);
     },
 
-    // Auth (Consolidated)
-    auth: {
-      provider: "hiai-opencode",
-      methods: [
-        { type: "api" as const, label: "Google Search API key" },
-      ],
-      loader: async (getAuth: any) => {
-        const authData = await getAuth();
-        const { registerGetAuth, GOOGLE_PROVIDER_ID, OPENAI_PROVIDER_ID, OPENROUTER_PROVIDER_ID } = await import("./internals/plugins/websearch-cited/index");
-
-        const getConfiguredKey = (configKey?: string) => {
-          if (configKey) return resolveEnvVars(configKey);
-          return undefined;
-        };
-
-        const googleKey = authData["Google Search API key"] || getConfiguredKey(internalConfig.auth?.googleSearch);
-        const openaiKey = getConfiguredKey(internalConfig.auth?.openai);
-        const openRouterKey = getConfiguredKey(internalConfig.auth?.openrouter);
-
-        if (googleKey) registerGetAuth(GOOGLE_PROVIDER_ID, () => Promise.resolve({ type: "api", key: googleKey }));
-        if (openaiKey) registerGetAuth(OPENAI_PROVIDER_ID, () => Promise.resolve({ type: "api", key: openaiKey }));
-        if (openRouterKey) registerGetAuth(OPENROUTER_PROVIDER_ID, () => Promise.resolve({ type: "api", key: openRouterKey }));
-
-        return {};
-      },
-    },
-
     "experimental.session.compacting": async (
       _input: { sessionID: string },
       output: { context: string[] },

package/src/lsp/index.ts

@@ -4,6 +4,7 @@ export function buildLspConfig(lsp: Record<string, LspServerConfig>): Record<str
   const result: Record<string, unknown> = {};
 
   for (const [name, server] of Object.entries(lsp)) {
+    if (server.enabled === false) continue;
     result[name] = {
       command: server.command,
       extensions: server.extensions,

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/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/shared/mcp-static-export.ts

@@ -0,0 +1,121 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
+import { dirname, join } from "node:path"
+
+import type { HiaiOpencodeConfig, McpServerConfig } from "../config/types"
+import { resolveEnvVars } from "../config/loader"
+import { log } from "./logger"
+
+type StaticMcpServer = {
+  type?: "http" | "stdio"
+  url?: string
+  command?: string
+  args?: string[]
+  env?: Record<string, string>
+  headers?: Record<string, string>
+}
+
+export const MCP_EXPORT_MARKER = "hiai-opencode"
+
+type StaticMcpJsonPayload = {
+  mcpServers: Record<string, StaticMcpServer>
+  _meta?: {
+    generatedBy: typeof MCP_EXPORT_MARKER
+    version: 1
+    generatedAt: string
+  }
+}
+
+function toStaticMcpServer(config: McpServerConfig): StaticMcpServer | null {
+  if (config.enabled === false) return null
+
+  if (config.type === "remote") {
+    const headers = config.headers
+      ? Object.fromEntries(Object.entries(config.headers).map(([key, value]) => [key, resolveEnvVars(value)]))
+      : undefined
+
+    return {
+      type: "http",
+      url: config.url,
+      ...(headers ? { headers } : {}),
+    }
+  }
+
+  const [command, ...args] = config.command ?? []
+  if (!command) return null
+
+  const env = config.environment
+    ? Object.fromEntries(Object.entries(config.environment).map(([key, value]) => [key, resolveEnvVars(value)]))
+    : undefined
+
+  return {
+    command,
+    ...(args.length > 0 ? { args } : {}),
+    ...(env ? { env } : {}),
+  }
+}
+
+export function buildStaticMcpJson(config: HiaiOpencodeConfig): StaticMcpJsonPayload {
+  const mcpServers: Record<string, StaticMcpServer> = {}
+
+  for (const [name, serverConfig] of Object.entries(config.mcp ?? {})) {
+    const converted = toStaticMcpServer(serverConfig)
+    if (converted) {
+      mcpServers[name] = converted
+    }
+  }
+
+  return {
+    _meta: {
+      generatedBy: MCP_EXPORT_MARKER,
+      version: 1,
+      generatedAt: new Date().toISOString(),
+    },
+    mcpServers,
+  }
+}
+
+export function isManagedStaticMcpFile(path: string): boolean {
+  if (!existsSync(path)) return false
+
+  try {
+    const raw = readFileSync(path, "utf-8")
+    const parsed = JSON.parse(raw) as StaticMcpJsonPayload
+    return parsed?._meta?.generatedBy === MCP_EXPORT_MARKER
+  } catch {
+    return false
+  }
+}
+
+export function autoExportStaticMcpJson(directory: string, config: HiaiOpencodeConfig): void {
+  const mode = process.env.HIAI_OPENCODE_AUTO_EXPORT_MCP?.trim().toLowerCase() || "if-missing"
+  if (mode === "0" || mode === "false" || mode === "no" || mode === "off") {
+    return
+  }
+
+  const outputPath = process.env.HIAI_OPENCODE_MCP_EXPORT_PATH?.trim() || join(directory, ".mcp.json")
+  if (mode === "if-missing" && existsSync(outputPath)) {
+    return
+  }
+
+  const isForceMode = mode === "force"
+  if (mode === "always" && existsSync(outputPath) && !isManagedStaticMcpFile(outputPath) && !isForceMode) {
+    console.warn(
+      `[hiai-opencode] WARNING: refusing to overwrite non-managed static MCP config at ${outputPath}. `
+      + "Set HIAI_OPENCODE_AUTO_EXPORT_MCP=force to override.",
+    )
+    return
+  }
+
+  try {
+    mkdirSync(dirname(outputPath), { recursive: true })
+    const payload = buildStaticMcpJson(config)
+    writeFileSync(outputPath, `${JSON.stringify(payload, null, 2)}\n`)
+    log("[hiai-opencode] exported static MCP config", {
+      outputPath,
+      servers: Object.keys(payload.mcpServers),
+    })
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    console.warn(`[hiai-opencode] WARNING: failed to export static MCP config to ${outputPath}: ${message}`)
+  }
+}

package/src/tools/ast-grep/constants.ts

@@ -1,5 +1,5 @@
 export type { EnvironmentCheckResult } from "./environment-check"
 export { checkEnvironment, formatEnvironmentCheck } from "./environment-check"
-export { CLI_LANGUAGES, NAPI_LANGUAGES, LANG_EXTENSIONS } from "./language-support"
+export { CLI_LANGUAGES, LANG_EXTENSIONS } from "./language-support"
 export { DEFAULT_TIMEOUT_MS, DEFAULT_MAX_OUTPUT_BYTES, DEFAULT_MAX_MATCHES } from "./language-support"
 export { findSgCliPathSync, getSgCliPath, setSgCliPath } from "./sg-cli-path"

package/src/tools/ast-grep/environment-check.ts

@@ -1,6 +1,6 @@
 import { existsSync } from "fs"
 
-import { CLI_LANGUAGES, NAPI_LANGUAGES } from "./language-support"
+import { CLI_LANGUAGES } from "./language-support"
 import { getSgCliPath } from "./sg-cli-path"
 
 export interface EnvironmentCheckResult {
@@ -9,14 +9,10 @@ export interface EnvironmentCheckResult {
 		path: string
 		error?: string
 	}
-	napi: {
-		available: boolean
-		error?: string
-	}
 }
 
 /**
- * Check if ast-grep CLI and NAPI are available.
+ * Check if ast-grep CLI is available.
  * Call this at startup to provide early feedback about missing dependencies.
  */
 export function checkEnvironment(): EnvironmentCheckResult {
@@ -26,9 +22,6 @@ export function checkEnvironment(): EnvironmentCheckResult {
 			available: false,
 			path: cliPath ?? "not found",
 		},
-		napi: {
-			available: false,
-		},
 	}
 
 	if (cliPath && existsSync(cliPath)) {
@@ -39,17 +32,6 @@ export function checkEnvironment(): EnvironmentCheckResult {
 		result.cli.error = `Binary not found: ${cliPath}`
 	}
 
-	// Check NAPI availability
-	try {
-		require("@ast-grep/napi")
-		result.napi.available = true
-	} catch (error) {
-		result.napi.available = false
-		result.napi.error = `@ast-grep/napi not installed: ${
-			error instanceof Error ? error.message : String(error)
-		}`
-	}
-
 	return result
 }
 
@@ -70,20 +52,8 @@ export function formatEnvironmentCheck(result: EnvironmentCheckResult): string {
 		lines.push("  Install: bun add -D @ast-grep/cli")
 	}
 
-	// NAPI status
-	if (result.napi.available) {
-		lines.push("[OK] NAPI: Available")
-	} else {
-		lines.push("[X] NAPI: Not available")
-		if (result.napi.error) {
-			lines.push(`  Error: ${result.napi.error}`)
-		}
-		lines.push("  Install: bun add -D @ast-grep/napi")
-	}
-
 	lines.push("")
 	lines.push(`CLI supports ${CLI_LANGUAGES.length} languages`)
-	lines.push(`NAPI supports ${NAPI_LANGUAGES.length} languages: ${NAPI_LANGUAGES.join(", ")}`)
 
 	return lines.join("\n")
 }

package/src/tools/ast-grep/language-support.ts

@@ -27,9 +27,6 @@ export const CLI_LANGUAGES = [
 	"yaml",
 ] as const
 
-// NAPI supported languages (5 total - native bindings)
-export const NAPI_LANGUAGES = ["html", "javascript", "tsx", "css", "typescript"] as const
-
 export const DEFAULT_TIMEOUT_MS = 300_000
 export const DEFAULT_MAX_OUTPUT_BYTES = 1 * 1024 * 1024
 export const DEFAULT_MAX_MATCHES = 500

package/src/tools/ast-grep/types.ts

@@ -1,7 +1,6 @@
-import type { CLI_LANGUAGES, NAPI_LANGUAGES } from "./constants"
+import type { CLI_LANGUAGES } from "./constants"
 
 export type CliLanguage = (typeof CLI_LANGUAGES)[number]
-export type NapiLanguage = (typeof NAPI_LANGUAGES)[number]
 
 export interface Position {
   line: number

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

@@ -0,0 +1,44 @@
+import { expect, test } from "bun:test"
+import type { ToolContext } from "@opencode-ai/plugin/tool"
+
+import { createSkillMcpTool } from "./tools"
+
+test("skill_mcp falls back to enabled builtin MCP when skill MCP is absent", async () => {
+  let callCaptured: { serverName: string; toolName: string } | null = null
+
+  const toolDef = createSkillMcpTool({
+    manager: {
+      async callTool(info, _context, toolName) {
+        callCaptured = { serverName: info.serverName, toolName }
+        return { ok: true }
+      },
+      async readResource() {
+        return { ok: true }
+      },
+      async getPrompt() {
+        return { ok: true }
+      },
+    } as any,
+    getLoadedSkills: () => [],
+    getSessionID: () => "session-test",
+    builtinMcp: {
+      firecrawl: {
+        enabled: true,
+        type: "local",
+        command: ["node", "firecrawl.mjs"],
+      },
+    },
+  })
+
+  const result = await toolDef.execute(
+    {
+      mcp_name: "firecrawl",
+      tool_name: "firecrawl_search",
+      arguments: { query: "test" },
+    } as any,
+    { sessionID: "session-test" } as ToolContext,
+  )
+
+  expect(callCaptured).toEqual({ serverName: "firecrawl", toolName: "firecrawl_search" })
+  expect(result).toContain("\"ok\": true")
+})

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/dist/config/loader.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/config/models.d.ts

@@ -1,13 +0,0 @@
-export declare const MODEL_ROLE_GUIDE: readonly ["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"];
-export declare const PROVIDER_MODEL_RULES: readonly ["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"];
-export declare const MODEL_PRESETS: {
-    readonly fast: "openrouter/google/gemini-2.0-flash";
-    readonly mid: "openrouter/anthropic/claude-3.5-sonnet";
-    readonly high: "openrouter/anthropic/claude-3.5-opus";
-    readonly ultrahigh: "openrouter/openai/gpt-4o";
-    readonly vision: "openrouter/google/gemini-2.0-pro-exp-02-05";
-    readonly reasoning: "openrouter/openai/o1";
-    readonly strategist: "openrouter/z-ai/glm-5.1";
-    readonly critic: "openrouter/qwen/qwen2.5-72b-instruct";
-    readonly writing: "openrouter/kimi/kimi-latest";
-};