@hiai-gg/hiai-opencode 0.1.2 → 0.1.4

package/src/config/schema/fast-apply.ts

@@ -3,10 +3,10 @@ import { z } from "zod"
 export const FastApplyConfigSchema = z.object({
   /** Enable fast-apply via Ollama (default: false) */
   enabled: z.boolean().optional().default(false),
-  /** Ollama API URL (default: http://localhost:11434) */
-  ollama_url: z.string().optional().default("http://localhost:11434"),
-  /** Model name for fast-apply (default: qwen3.5:9b) */
-  model: z.string().optional().default("qwen3.5:9b"),
+  /** Ollama API URL. Configure in hiai-opencode.json. */
+  ollama_url: z.string().optional().default(""),
+  /** Model name for fast-apply. Configure in hiai-opencode.json. */
+  model: z.string().optional().default(""),
   /** Timeout in milliseconds for Ollama request (default: 30000) */
   timeout: z.number().int().positive().optional().default(30000),
 })

package/src/config/schema/index.ts

@@ -44,6 +44,8 @@ export { BobAgentConfigSchema } from "./bob-agent"
 export type { BobAgentConfig } from "./bob-agent"
 export { SkillsConfigSchema } from "./skills"
 export type { SkillsConfig, SkillDefinition } from "./skills"
+export { SkillDiscoveryConfigSchema } from "./skill-discovery"
+export type { SkillDiscoveryConfig } from "./skill-discovery"
 export { StartWorkConfigSchema } from "./start-work"
 export type { StartWorkConfig } from "./start-work"
 export { TmuxConfigSchema, TmuxLayoutSchema, TmuxIsolationSchema } from "./tmux"

package/src/config/schema/oh-my-opencode-config.ts

@@ -17,6 +17,7 @@ import { ModelCapabilitiesConfigSchema } from "./model-capabilities"
 import { RalphLoopConfigSchema } from "./ralph-loop"
 import { RuntimeFallbackConfigSchema } from "./runtime-fallback"
 import { SkillsConfigSchema } from "./skills"
+import { SkillDiscoveryConfigSchema } from "./skill-discovery"
 import { BobConfigSchema } from "./bob"
 import { BobAgentConfigSchema } from "./bob-agent"
 import { TmuxConfigSchema } from "./tmux"
@@ -30,6 +31,7 @@ const AuthConfigSchema = z.object({
   openrouter: z.string().optional(),
   stitch: z.string().optional(),
   firecrawl: z.string().optional(),
+  context7: z.string().optional(),
 }).optional()
 
 export const HiaiOpenCodeConfigSchema = z.object({
@@ -60,6 +62,7 @@ export const HiaiOpenCodeConfigSchema = z.object({
   experimental: ExperimentalConfigSchema.optional(),
   auto_update: z.boolean().optional(),
   skills: SkillsConfigSchema.optional(),
+  skill_discovery: SkillDiscoveryConfigSchema.optional(),
   ralph_loop: RalphLoopConfigSchema.optional(),
   /**
    * Enable runtime fallback (default: false)

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

@@ -0,0 +1,25 @@
+import { z } from "zod"
+
+export const SkillDiscoveryConfigSchema = z.object({
+  /**
+   * Explicit skills.sources entries from hiai-opencode config.
+   * Safe by default because the user intentionally configured them.
+   */
+  config_sources: z.boolean().default(true),
+  /**
+   * Project-local OpenCode skills: .opencode/skills and .opencode/skill.
+   * Kept on by default because they are part of the current project contract.
+   */
+  project_opencode: z.boolean().default(true),
+  /**
+   * Global OpenCode skills from the user's OpenCode config directory.
+   * Off by default to keep clean installs deterministic.
+   */
+  global_opencode: z.boolean().default(false),
+  project_claude: z.boolean().default(false),
+  global_claude: z.boolean().default(false),
+  project_agents: z.boolean().default(false),
+  global_agents: z.boolean().default(false),
+})
+
+export type SkillDiscoveryConfig = z.infer<typeof SkillDiscoveryConfigSchema>

package/src/config/types.ts

@@ -32,6 +32,8 @@ export const LEGACY_AGENT_ALIAS_NAMES = [
   "zoe",
   "build",
   "pre-plan",
+  "manager",
+  "vision",
   "logician",
   "librarian",
   "explore",
@@ -54,6 +56,8 @@ export const LEGACY_AGENT_ALIAS_TO_CANONICAL: Record<
   zoe: "bob",
   build: "bob",
   "pre-plan": "strategist",
+  manager: "platform-manager",
+  vision: "multimodal",
   logician: "strategist",
   librarian: "researcher",
   explore: "researcher",
@@ -135,6 +139,16 @@ export interface SkillsConfig {
   disabled?: string[];
 }
 
+export interface SkillDiscoveryConfig {
+  config_sources?: boolean;
+  project_opencode?: boolean;
+  global_opencode?: boolean;
+  project_claude?: boolean;
+  global_claude?: boolean;
+  project_agents?: boolean;
+  global_agents?: boolean;
+}
+
 export interface PermissionsConfig {
   read?: Record<string, string>;
   edit?: Record<string, string>;
@@ -148,6 +162,7 @@ export interface AuthKeys {
   openrouter?: string;
   stitch?: string;
   firecrawl?: string;
+  context7?: string;
 }
 
 export interface OllamaConfig {
@@ -168,6 +183,7 @@ export interface HiaiOpencodeConfig {
   lsp?: Record<string, LspServerConfig>;
   subtask2?: Subtask2Config;
   skills?: SkillsConfig;
+  skill_discovery?: SkillDiscoveryConfig;
   permissions?: PermissionsConfig;
   auth?: AuthKeys;
   ollama?: OllamaConfig;

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

@@ -8,6 +8,7 @@ import { REFACTOR_TEMPLATE } from "./templates/refactor"
 import { START_WORK_TEMPLATE } from "./templates/start-work"
 import { HANDOFF_TEMPLATE } from "./templates/handoff"
 import { REMOVE_AI_SLOPS_TEMPLATE } from "./templates/remove-ai-slops"
+import { MCP_STATUS_TEMPLATE } from "./templates/mcp-status"
 
 interface LoadBuiltinCommandsOptions {
   useRegisteredAgents?: boolean
@@ -121,6 +122,12 @@ $ARGUMENTS
 </user-request>`,
       argumentHint: "[goal]",
     },
+    "mcp-status": {
+      description: "(builtin) Show hiai-opencode MCP server status, missing keys, and local runtime availability",
+      template: `<command-instruction>
+${MCP_STATUS_TEMPLATE}
+</command-instruction>`,
+    },
   }
 }
 

package/src/features/builtin-commands/templates/mcp-status.ts

@@ -0,0 +1,36 @@
+export const MCP_STATUS_TEMPLATE = `# MCP Status Command
+
+## Purpose
+
+Use /mcp-status to show the effective hiai-opencode MCP setup without relying on OpenCode's mcp list output.
+
+## Execute
+
+Run:
+
+\`\`\`bash
+hiai-opencode mcp-status
+\`\`\`
+
+If the binary is not on PATH, try the package-local fallback:
+
+\`\`\`bash
+node ./node_modules/@hiai-gg/hiai-opencode/assets/cli/hiai-opencode.mjs mcp-status
+\`\`\`
+
+## Report
+
+Summarize the output in a compact status table:
+
+- MCP server name
+- status: ok, warning, error, disabled
+- cause or next action
+
+Rules:
+
+- Do not print API key values.
+- If a key is missing, name the env var only.
+- If a runtime is missing, give the exact install hint from the command output or the shortest safe next command.
+- Do not edit config unless the user explicitly asks.
+- Do not run package installs unless the user explicitly asks.
+`

package/src/features/builtin-commands/types.ts

@@ -1,6 +1,6 @@
 import type { CommandDefinition } from "../claude-code-command-loader"
 
-export type BuiltinCommandName = "init-deep" | "ralph-loop" | "cancel-ralph" | "ulw-loop" | "refactor" | "start-work" | "stop-continuation" | "handoff" | "remove-ai-slops"
+export type BuiltinCommandName = "init-deep" | "ralph-loop" | "cancel-ralph" | "ulw-loop" | "refactor" | "start-work" | "stop-continuation" | "handoff" | "remove-ai-slops" | "mcp-status"
 
 export interface BuiltinCommandConfig {
   disabled_commands?: BuiltinCommandName[]

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

@@ -5,11 +5,33 @@ export const playwrightSkill: BuiltinSkill = {
   description: "MUST USE for any browser-related tasks. Browser automation via Playwright MCP - verification, browsing, information gathering, web scraping, testing, screenshots, and all browser interactions.",
   template: `# Playwright Browser Automation
 
-This skill provides browser automation capabilities via the Playwright MCP server.`,
+This skill provides browser automation capabilities via the Playwright MCP server.
+
+## Required workflow
+
+1. Load this skill before calling \`skill_mcp\`.
+2. Use \`skill_mcp\` with \`mcp_name="playwright"\` for browser navigation, interaction, screenshots, and visual verification.
+3. If the host says \`MCP server "playwright" not found\`, do not conclude that Playwright is impossible. First report that the skill was not loaded or the Playwright MCP server was not registered in this session.
+4. If Chromium starts but fails with missing Linux libraries such as \`libnspr4\`, \`libnss3\`, \`libatk-bridge\`, \`libgtk-3\`, or similar, distinguish browser OS dependencies from MCP availability.
+
+## Linux dependency fallback
+
+Playwright has two dependency layers:
+
+- Browser binary: installable without sudo with \`npx playwright install chromium\` or by setting \`HIAI_PLAYWRIGHT_INSTALL_BROWSERS=1\` before OpenCode starts.
+- System libraries: on minimal Linux images these usually require admin rights via \`sudo npx playwright install-deps chromium\` or OS package manager equivalents.
+
+If sudo is unavailable, try these alternatives before falling back to curl-only checks:
+
+- Use an already installed Chrome/Chromium/Edge by adding Playwright MCP args in \`hiai-opencode.json\`, for example \`--browser chrome\` or \`--browser msedge\`.
+- Use a remote/browser service or CDP-backed browser when available.
+- Switch the browser automation provider to \`agent-browser\` or \`playwright-cli\` if the workspace has those tools installed.
+
+Only use \`curl\` as a final degraded check. Clearly say that HTTP checks do not replace interactive browser verification.`,
   mcpConfig: {
     playwright: {
       command: "npx",
-      args: ["@playwright/mcp@latest"],
+      args: ["-y", "@playwright/mcp@latest"],
     },
   },
 }

package/src/features/opencode-skill-loader/loader.ts

@@ -62,6 +62,12 @@ export async function loadGlobalAgentsSkills(): Promise<Record<string, CommandDe
   return skillsToCommandDefinitionRecord(skills)
 }
 
+export async function loadManagedPluginSkills(): Promise<Record<string, CommandDefinition>> {
+  const skillsDir = join(getOpenCodeConfigDir({ binary: "opencode" }), ".hiai", "skills", "plugin")
+  const skills = await loadSkillsFromDir({ skillsDir, scope: "builtin" })
+  return skillsToCommandDefinitionRecord(skills)
+}
+
 export interface DiscoverSkillsOptions {
   includeClaudeCodePaths?: boolean
   directory?: string
@@ -170,3 +176,8 @@ export async function discoverGlobalAgentsSkills(): Promise<LoadedSkill[]> {
   const agentsGlobalDir = join(getAgentsConfigDir(), "skills")
   return loadSkillsFromDir({ skillsDir: agentsGlobalDir, scope: "user" })
 }
+
+export async function discoverManagedPluginSkills(): Promise<LoadedSkill[]> {
+  const skillsDir = join(getOpenCodeConfigDir({ binary: "opencode" }), ".hiai", "skills", "plugin")
+  return loadSkillsFromDir({ skillsDir, scope: "builtin" })
+}

package/src/index.ts

@@ -18,6 +18,7 @@ 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 { warnIfListPluginEntry, warnMissingRequiredMcpEnv } from "./shared/startup-diagnostics"
 import { startBackgroundCheck as startTmuxCheck } from "./tools/interactive-bash"
 import { lspManager } from "./tools/lsp/client"
 
@@ -56,6 +57,7 @@ function configureBundledBunPtyLibrary(): void {
   const candidates = [
     join(import.meta.dirname, "..", "node_modules", "bun-pty", "rust-pty", "target", "release", libraryName),
     join(import.meta.dirname, "..", "..", "bun-pty", "rust-pty", "target", "release", libraryName),
+    join(import.meta.dirname, "..", "..", "..", "bun-pty", "rust-pty", "target", "release", libraryName),
   ]
 
   const resolved = candidates.find((candidate) => existsSync(candidate))
@@ -68,6 +70,7 @@ const HiaiOpenCodePlugin: Plugin = async (ctx) => {
   log("[HiaiOpenCodePlugin] ENTRY - plugin loading", {
     directory: ctx.directory,
   })
+  warnIfListPluginEntry(ctx.directory)
 
   const skillPluginCheck = detectExternalSkillPlugin(ctx.directory)
   if (skillPluginCheck.detected && skillPluginCheck.pluginName) {
@@ -82,6 +85,10 @@ const HiaiOpenCodePlugin: Plugin = async (ctx) => {
     loadPluginConfig(ctx.directory, ctx),
     internalConfig,
   )
+  warnMissingRequiredMcpEnv({
+    pluginConfig,
+    platformConfig: internalConfig,
+  })
 
   materializeBuiltinSkills(
     createBuiltinSkills({
@@ -219,29 +226,24 @@ const HiaiOpenCodePlugin: Plugin = async (ctx) => {
     auth: {
       provider: "hiai-opencode",
       methods: [
-        { type: "api" as const, label: "Google API key" },
-        { type: "api" as const, label: "OpenAI API key" },
-        { type: "api" as const, label: "OpenRouter API key" },
+        { 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");
 
-        // Helper to get key from config or authData
-        const getKey = (label: string, configKey?: string) => {
-          const fromAuth = authData[label];
-          if (fromAuth) return fromAuth;
+        const getConfiguredKey = (configKey?: string) => {
           if (configKey) return resolveEnvVars(configKey);
           return undefined;
         };
 
-        const googleKey = getKey("Google API key", internalConfig.auth?.googleSearch);
-        const openaiKey = getKey("OpenAI API key", internalConfig.auth?.openai);
-        const openRouterKey = getKey("OpenRouter API key", internalConfig.auth?.openrouter);
+        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(googleKey));
-        if (openaiKey) registerGetAuth(OPENAI_PROVIDER_ID, () => Promise.resolve(openaiKey));
-        if (openRouterKey) registerGetAuth(OPENROUTER_PROVIDER_ID, () => Promise.resolve(openRouterKey));
+        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 {};
       },

package/src/mcp/index.ts

@@ -1,45 +1,12 @@
 export { createBuiltinMcps } from "./omo-mcp-index"
 export { McpNameSchema, type McpName, type AnyMcpName } from "./types"
 
-import { existsSync } from "node:fs";
-import { join } from "node:path";
 import type { McpServerConfig } from "../config/types.js";
 import { resolveEnvVars } from "../config/loader.js";
 
-const ASSETS_DIR = join(import.meta.dirname || __dirname, "..", "assets", "mcp");
-
-function resolveBundledMcp(name: string): string {
-  const script = join(ASSETS_DIR, name);
-  if (existsSync(script)) return script;
-  return "";
-}
-
 export function buildMcpConfig(mcp: Record<string, McpServerConfig>): Record<string, unknown> {
   const result: Record<string, unknown> = {};
 
-  const defaults: Record<string, McpServerConfig> = {
-    rag: {
-      enabled: true,
-      type: "local",
-      command: ["node", resolveBundledMcp("rag.mjs")].filter(Boolean),
-      environment: {
-        OPENCODE_RAG_URL: "http://localhost:9002/tools/search",
-      },
-    },
-    mempalace: {
-      enabled: true,
-      type: "local",
-      command: ["node", resolveBundledMcp("mempalace.mjs"), "--palace", "./.opencode/palace"].filter(Boolean),
-      timeout: 60000,
-    },
-  };
-
-  for (const [name, server] of Object.entries(defaults)) {
-    if (!(name in mcp) && server.command && server.command.length >= 2) {
-      mcp[name] = server;
-    }
-  }
-
   for (const [name, server] of Object.entries(mcp)) {
     if (!server.enabled) continue;
 

package/src/mcp/omo-mcp-index.ts

@@ -1,5 +1,4 @@
 import { createWebsearchConfig } from "./websearch"
-import { context7 } from "./context7"
 import { grep_app } from "./grep-app"
 import type { HiaiOpenCodeConfig } from "../config/schema"
 
@@ -23,10 +22,6 @@ export function createBuiltinMcps(disabledMcps: string[] = [], config?: HiaiOpen
     }
   }
 
-  if (!disabledMcps.includes("context7")) {
-    mcps.context7 = context7
-  }
-
   if (!disabledMcps.includes("grep_app")) {
     mcps.grep_app = grep_app
   }

package/src/mcp/registry.ts

@@ -0,0 +1,132 @@
+import { join } from "node:path"
+import type { McpServerConfig } from "../config/types.js"
+
+export type HiaiMcpName =
+  | "playwright"
+  | "stitch"
+  | "sequential-thinking"
+  | "firecrawl"
+  | "rag"
+  | "context7"
+  | "mempalace"
+
+export type HiaiMcpInstallKind = "bundled" | "npm" | "python" | "remote" | "user-service"
+
+export interface HiaiMcpRegistryEntry {
+  name: HiaiMcpName
+  enabledByDefault: boolean
+  install: HiaiMcpInstallKind
+  requiredEnv?: string[]
+  optionalEnv?: string[]
+  config: McpServerConfig
+}
+
+function resolveAssetScript(...segments: string[]): string {
+  return join(import.meta.dirname, "..", "assets", ...segments)
+}
+
+function createNpmPackageCommand(pkg: string, ...args: string[]): string[] {
+  return ["node", resolveAssetScript("runtime", "npm-package-runner.mjs"), pkg, ...args]
+}
+
+export const HIAI_MCP_REGISTRY: Record<HiaiMcpName, HiaiMcpRegistryEntry> = {
+  playwright: {
+    name: "playwright",
+    enabledByDefault: true,
+    install: "npm",
+    optionalEnv: ["HIAI_PLAYWRIGHT_INSTALL_BROWSERS"],
+    config: {
+      enabled: true,
+      command: ["node", resolveAssetScript("mcp", "playwright.mjs")],
+      timeout: 600000,
+    },
+  },
+  stitch: {
+    name: "stitch",
+    enabledByDefault: true,
+    install: "remote",
+    requiredEnv: ["STITCH_AI_API_KEY"],
+    config: {
+      enabled: true,
+      type: "remote",
+      url: "https://stitch.googleapis.com/mcp",
+      headers: { "X-Goog-Api-Key": "{env:STITCH_AI_API_KEY}" },
+      timeout: 600000,
+    },
+  },
+  "sequential-thinking": {
+    name: "sequential-thinking",
+    enabledByDefault: true,
+    install: "npm",
+    config: {
+      enabled: true,
+      command: createNpmPackageCommand("@modelcontextprotocol/server-sequential-thinking"),
+      timeout: 600000,
+    },
+  },
+  firecrawl: {
+    name: "firecrawl",
+    enabledByDefault: true,
+    install: "npm",
+    requiredEnv: ["FIRECRAWL_API_KEY"],
+    config: {
+      enabled: true,
+      command: createNpmPackageCommand("firecrawl-mcp"),
+      timeout: 600000,
+      environment: { FIRECRAWL_API_KEY: "{env:FIRECRAWL_API_KEY}" },
+    },
+  },
+  rag: {
+    name: "rag",
+    enabledByDefault: true,
+    install: "user-service",
+    optionalEnv: ["OPENCODE_RAG_URL"],
+    config: {
+      enabled: true,
+      type: "local",
+      command: ["node", resolveAssetScript("mcp", "rag.mjs")],
+      environment: {
+        OPENCODE_RAG_URL: "{env:OPENCODE_RAG_URL:-http://localhost:9002/tools/search}",
+      },
+      timeout: 600000,
+    },
+  },
+  context7: {
+    name: "context7",
+    enabledByDefault: true,
+    install: "remote",
+    optionalEnv: ["CONTEXT7_API_KEY"],
+    config: {
+      enabled: true,
+      type: "remote",
+      url: "https://mcp.context7.com/mcp",
+      headers: { "X-API-KEY": "{env:CONTEXT7_API_KEY}" },
+      timeout: 600000,
+    },
+  },
+  mempalace: {
+    name: "mempalace",
+    enabledByDefault: true,
+    install: "python",
+    optionalEnv: ["MEMPALACE_PYTHON", "MEMPALACE_PALACE_PATH", "HIAI_MCP_AUTO_INSTALL"],
+    config: {
+      enabled: true,
+      type: "local",
+      command: ["node", resolveAssetScript("mcp", "mempalace.mjs"), "--palace", "./.opencode/palace"],
+      timeout: 600000,
+    },
+  },
+}
+
+export function createDefaultMcpConfig(): Record<HiaiMcpName, McpServerConfig> {
+  return Object.fromEntries(
+    Object.entries(HIAI_MCP_REGISTRY).map(([name, entry]) => [
+      name,
+      { ...entry.config, enabled: entry.enabledByDefault },
+    ]),
+  ) as Record<HiaiMcpName, McpServerConfig>
+}
+
+export function getKnownMcpNames(): HiaiMcpName[] {
+  return Object.keys(HIAI_MCP_REGISTRY) as HiaiMcpName[]
+}

package/src/mcp/types.ts

@@ -1,6 +1,16 @@
 import { z } from "zod"
 
-export const McpNameSchema = z.enum(["websearch", "context7", "grep_app"])
+export const McpNameSchema = z.enum([
+  "playwright",
+  "stitch",
+  "sequential-thinking",
+  "firecrawl",
+  "rag",
+  "context7",
+  "mempalace",
+  "websearch",
+  "grep_app",
+])
 
 export type McpName = z.infer<typeof McpNameSchema>
 

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
+}