@hiai-gg/hiai-opencode 0.1.6 → 0.1.7

package/src/tools/delegate-task/openai-categories.ts

@@ -1,29 +1,33 @@
 import type { BuiltinCategoryDefinition } from "./builtin-category-definition"
 
 const ULTRABRAIN_CATEGORY_PROMPT_APPEND = `<Category_Context>
-You are working on DEEP LOGICAL REASONING / COMPLEX ARCHITECTURE tasks.
+You are working on DEEP LOGICAL REASONING / ARCHITECTURE / STRATEGY tasks.
 
 <Routing_Policy>
-Executor contour: coder (deep execution). Do not use this category for bounded quick edits.
+Executor contour: strategist (plan + analysis, read-only). This category produces a structured plan, NOT implementation. The caller is responsible for routing the implementation step to \`deep\`, \`bounded\`, or \`cross-module\` mode based on your plan.
 </Routing_Policy>
 
-**CRITICAL - CODE STYLE REQUIREMENTS (NON-NEGOTIABLE)**:
-1. BEFORE writing ANY code, SEARCH the existing codebase to find similar patterns/styles
-2. Your code MUST match the project's existing conventions - blend in seamlessly
-3. Write READABLE code that humans can easily understand - no clever tricks
-4. If unsure about style, explore more files until you find the pattern
-
-Strategic advisor mindset:
-- Bias toward simplicity: least complex solution that fulfills requirements
-- Leverage existing code/patterns over new components
-- Prioritize developer experience and maintainability
-- One clear recommendation with effort estimate (Quick/Short/Medium/Large)
-- Signal when advanced approach warranted
-
-Response format:
-- Bottom line (2-3 sentences)
-- Action plan (numbered steps)
-- Risks and mitigations (if relevant)
+<Output_Contract>
+Your output MUST contain:
+1. **Decomposition** - concrete tasks with bounded scope (each task small enough that one executor agent can complete it without further planning).
+2. **Dependency graph** - which tasks block which; identify parallel-safe tasks explicitly.
+3. **Tradeoffs** - at least 2 alternative approaches with cost/risk for each; recommend one and justify briefly.
+4. **Recommended next step** - explicit \`task(category=...)\` call the caller should make to start implementation.
+5. **Open questions** - assumptions the caller should confirm before kickoff (if any).
+
+You MUST NOT:
+- Write or edit code (you have no write/edit tools).
+- Mark task as done yourself; the caller verifies the plan and routes implementation.
+- Defer planning by asking clarifying questions when assumptions can be stated and surfaced as Open questions.
+</Output_Contract>
+
+<Reasoning_Discipline>
+- Bias toward simplicity: least complex solution that fulfills requirements.
+- Leverage existing code/patterns over new components - reference concrete files when relevant.
+- Surface assumptions explicitly as Open questions rather than guessing silently.
+- For unfamiliar domains, recommend a \`task(subagent_type="researcher", run_in_background=true, ...)\` exploration step before planning.
+- One clear recommendation with effort estimate (Quick / Short / Medium / Large).
+</Reasoning_Discipline>
 </Category_Context>`
 
 const DEEP_CATEGORY_PROMPT_APPEND = `<Category_Context>
@@ -55,7 +59,7 @@ const QUICK_CATEGORY_PROMPT_APPEND = `<Category_Context>
 You are working on SMALL / QUICK tasks.
 
 <Routing_Policy>
-Executor contour: coder (fast bounded execution). Keep the implementation narrow and escalate only when the task truly becomes deep or cross-system.
+Executor contour: sub (cheap fast-tier executor). Keep the implementation narrow and escalate only when the task truly becomes deep or cross-system.
 </Routing_Policy>
 
 Efficient execution mindset:
@@ -110,7 +114,7 @@ export const OPENAI_CATEGORIES: BuiltinCategoryDefinition[] = [
   {
     name: "ultrabrain",
     config: {},
-    description: "Hard logic and architecture tasks. Uses coder execution contour; avoid for quick bounded edits.",
+    description: "Hard logic, architecture, strategy. Returns structured plan (decomposition + dependency graph + tradeoffs), NOT implementation. Follow up with deep/bounded/cross-module mode for build.",
     promptAppend: ULTRABRAIN_CATEGORY_PROMPT_APPEND,
   },
   {
@@ -122,7 +126,7 @@ export const OPENAI_CATEGORIES: BuiltinCategoryDefinition[] = [
   {
     name: "quick",
     config: {},
-    description: "Fast bounded execution: single-file fixes, typos, and simple modifications. Uses coder execution contour.",
+    description: "Fast bounded execution: single-file fixes, typos, and simple modifications. Uses sub (cheap fast-tier) execution contour.",
     promptAppend: QUICK_CATEGORY_PROMPT_APPEND,
   },
 ]

package/src/tools/delegate-task/sub-agent.ts

@@ -21,6 +21,7 @@ export const CANONICAL_DELEGATE_AGENT_KEYS = [
 ] as const
 
 type CanonicalDelegateAgentKey = (typeof CANONICAL_DELEGATE_AGENT_KEYS)[number]
+export type { CanonicalDelegateAgentKey }
 const CANONICAL_DELEGATE_AGENT_KEY_SET = new Set<string>(CANONICAL_DELEGATE_AGENT_KEYS)
 
 const LEGACY_DELEGATE_AGENT_ALIASES: Record<string, CanonicalDelegateAgentKey> = {
@@ -44,8 +45,17 @@ const LEGACY_DELEGATE_AGENT_ALIASES: Record<string, CanonicalDelegateAgentKey> =
   "project-initializer": "platform-manager",
   mindmodel: "platform-manager",
   ui: "multimodal",
+  writer: "brainstormer",
+  copywriter: "brainstormer",
+  "content-writer": "brainstormer",
   subagent: "sub",
   "bob-junior": "sub",
+  oracle: "strategist",
+  hephaestus: "coder",
+  metis: "strategist",
+  momus: "critic",
+  "sisyphus-junior": "sub",
+  "multimodal-looker": "multimodal",
 }
 
 export function resolveCanonicalDelegateAgentKey(agentName: string): string {

package/src/tools/delegate-task/subagent-discovery.test.ts

@@ -0,0 +1,123 @@
+import { expect, test, describe } from "bun:test"
+import { sanitizeSubagentType, findPrimaryAgentMatch, findCallableAgentMatch, listCallableAgentNames, isTaskCallableAgentMode } from "./subagent-discovery"
+
+describe("sanitizeSubagentType", () => {
+  test("trims whitespace", () => {
+    expect(sanitizeSubagentType("  researcher  ")).toBe("researcher")
+  })
+
+  test("removes surrounding quotes", () => {
+    expect(sanitizeSubagentType('"researcher"')).toBe("researcher")
+    expect(sanitizeSubagentType("'researcher'")).toBe("researcher")
+  })
+
+  test("removes surrounding slashes", () => {
+    expect(sanitizeSubagentType("/researcher/")).toBe("researcher")
+  })
+
+  test("removes backslashes", () => {
+    expect(sanitizeSubagentType("\\researcher\\")).toBe("researcher")
+  })
+
+  test("handles mixed characters", () => {
+    expect(sanitizeSubagentType('  /"researcher"\\ ')).toBe("researcher")
+  })
+})
+
+describe("isTaskCallableAgentMode", () => {
+  test("returns true for subagent mode", () => {
+    expect(isTaskCallableAgentMode("subagent")).toBe(true)
+  })
+
+  test("returns true for all mode", () => {
+    expect(isTaskCallableAgentMode("all")).toBe(true)
+  })
+
+  test("returns false for primary mode", () => {
+    expect(isTaskCallableAgentMode("primary")).toBe(false)
+  })
+
+  test("returns false for undefined", () => {
+    expect(isTaskCallableAgentMode(undefined)).toBe(false)
+  })
+})
+
+describe("findPrimaryAgentMatch", () => {
+  const agents = [
+    { name: "Bob", mode: "primary" as const, model: "openrouter/test/bob" },
+    { name: "Coder", mode: "primary" as const, model: "openrouter/test/coder" },
+    { name: "Researcher", mode: "primary" as const, model: "openrouter/test/researcher" },
+    { name: "SubAgent", mode: "subagent" as const, model: "openrouter/test/sub" },
+  ]
+
+  test("finds primary agent by exact name", () => {
+    const result = findPrimaryAgentMatch(agents, "Bob")
+    expect(result?.name).toBe("Bob")
+  })
+
+  test("finds primary agent by canonical key", () => {
+    const result = findPrimaryAgentMatch(agents, "researcher")
+    expect(result?.name).toBe("Researcher")
+  })
+
+  test("returns undefined for non-existent agent", () => {
+    const result = findPrimaryAgentMatch(agents, "Nonexistent")
+    expect(result).toBeUndefined()
+  })
+
+  test("returns undefined when searching for subagent mode", () => {
+    const result = findPrimaryAgentMatch(agents, "SubAgent")
+    expect(result).toBeUndefined()
+  })
+})
+
+describe("findCallableAgentMatch", () => {
+  const agents = [
+    { name: "Bob", mode: "primary" as const, model: "openrouter/test/bob" },
+    { name: "Coder", mode: "primary" as const, model: "openrouter/test/coder" },
+    { name: "Researcher", mode: "subagent" as const, model: "openrouter/test/researcher" },
+    { name: "SubAgent", mode: "subagent" as const, model: "openrouter/test/sub" },
+    { name: "Vision", mode: "all" as const, model: "openrouter/test/vision" },
+  ]
+
+  test("finds callable agent by subagent mode", () => {
+    const result = findCallableAgentMatch(agents, "SubAgent")
+    expect(result?.name).toBe("SubAgent")
+  })
+
+  test("finds callable agent by all mode", () => {
+    const result = findCallableAgentMatch(agents, "Vision")
+    expect(result?.name).toBe("Vision")
+  })
+
+  test("finds callable agent by canonical researcher (subagent mode)", () => {
+    const result = findCallableAgentMatch(agents, "researcher")
+    expect(result?.name).toBe("Researcher")
+  })
+
+  test("returns undefined for primary-only agent", () => {
+    const result = findCallableAgentMatch(agents, "Bob")
+    expect(result).toBeUndefined()
+  })
+})
+
+describe("listCallableAgentNames", () => {
+  test("lists callable agents sorted alphabetically (subagent and all modes)", () => {
+    const agents = [
+      { name: "Vision", mode: "all" as const },
+      { name: "Researcher", mode: "subagent" as const },
+      { name: "Bob", mode: "primary" as const },
+    ]
+    const result = listCallableAgentNames(agents)
+    expect(result).toBe("Researcher, Vision")
+  })
+
+  test("returns empty string for no callable agents", () => {
+    const agents = [
+      { name: "Bob", mode: "primary" as const },
+      { name: "Coder", mode: "primary" as const },
+    ]
+    const result = listCallableAgentNames(agents)
+    expect(result).toBe("")
+  })
+})

package/src/tools/delegate-task/subagent-resolver.ts

@@ -73,6 +73,23 @@ Create the work plan directly - that's your job as the planning agent.`,
     }
   }
 
+  const ORCHESTRATOR_AGENTS: Set<string> = new Set(["bob"])
+  if (ORCHESTRATOR_AGENTS.has(requestedCanonicalAgentKey)) {
+    return {
+      agentToUse: "",
+      categoryModel: undefined,
+      error: `Cannot delegate to orchestrator agent "${requestedCanonicalAgentKey}". Bob is the entry-point orchestrator and is not callable as a subagent. Use a specific subagent (researcher/strategist/coder/...) or a mode (quick/deep/...).`,
+    }
+  }
+
+  if (canonicalParentAgent && canonicalParentAgent === requestedCanonicalAgentKey) {
+    return {
+      agentToUse: "",
+      categoryModel: undefined,
+      error: `Self-delegation not allowed: agent "${requestedCanonicalAgentKey}" cannot delegate to itself via task. Continue the work directly or use session_id=... to continue an existing subagent session.`,
+    }
+  }
+
   let agentToUse = requestedAgentName
   let categoryModel: DelegatedModelConfig | undefined
   let fallbackChain: FallbackEntry[] | undefined = undefined
@@ -84,8 +101,8 @@ Create the work plan directly - that's your job as the planning agent.`,
     })
 
     const mergedAgents = mergeWithClaudeCodeAgents(agents, executorCtx.directory)
-    const matchedPrimaryAgent = findPrimaryAgentMatch(mergedAgents, agentToUse)
 
+    const matchedPrimaryAgent = findPrimaryAgentMatch(mergedAgents, agentToUse)
     if (matchedPrimaryAgent) {
       return {
         agentToUse: "",

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

@@ -1,6 +1,6 @@
 export const SKILL_MCP_TOOL_NAME = "skill_mcp"
 
-export const SKILL_MCP_DESCRIPTION = `Invoke MCP server operations from skill-embedded MCPs. Requires mcp_name plus exactly one of: tool_name, resource_name, or prompt_name.`
+export const SKILL_MCP_DESCRIPTION = `Invoke MCP server operations from skill-embedded MCPs or enabled hiai-opencode builtin MCPs. Requires mcp_name plus exactly one of: tool_name, resource_name, or prompt_name.`
 
 export const BUILTIN_MCP_TOOL_HINTS: Record<string, string[]> = {
   context7: ["context7_resolve-library-id", "context7_query-docs"],

package/dist/config/schema/websearch.d.ts

@@ -1,13 +0,0 @@
-import { z } from "zod";
-export declare const WebsearchProviderSchema: z.ZodEnum<{
-    exa: "exa";
-    tavily: "tavily";
-}>;
-export declare const WebsearchConfigSchema: z.ZodObject<{
-    provider: z.ZodOptional<z.ZodEnum<{
-        exa: "exa";
-        tavily: "tavily";
-    }>>;
-}, z.core.$strip>;
-export type WebsearchProvider = z.infer<typeof WebsearchProviderSchema>;
-export type WebsearchConfig = z.infer<typeof WebsearchConfigSchema>;

package/dist/hooks/no-bob-gpt/hook.d.ts

@@ -1,16 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-export declare function createNoBobGptHook(ctx: PluginInput): {
-    "chat.message": (input: {
-        sessionID: string;
-        agent?: string;
-        model?: {
-            providerID: string;
-            modelID: string;
-        };
-    }, output?: {
-        message?: {
-            agent?: string;
-            [key: string]: unknown;
-        };
-    }) => Promise<void>;
-};

package/dist/hooks/no-bob-gpt/index.d.ts

@@ -1 +0,0 @@
-export { createNoBobGptHook } from "./hook";

package/dist/hooks/no-coder-non-gpt/hook.d.ts

@@ -1,20 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-type NoCoderNonGptHookOptions = {
-    allowNonGptModel?: boolean;
-};
-export declare function createNoCoderNonGptHook(ctx: PluginInput, options?: NoCoderNonGptHookOptions): {
-    "chat.message": (input: {
-        sessionID: string;
-        agent?: string;
-        model?: {
-            providerID: string;
-            modelID: string;
-        };
-    }, output?: {
-        message?: {
-            agent?: string;
-            [key: string]: unknown;
-        };
-    }) => Promise<void>;
-};
-export {};

package/dist/hooks/no-coder-non-gpt/index.d.ts

@@ -1 +0,0 @@
-export { createNoCoderNonGptHook } from "./hook";

package/dist/mcp/grep-app.d.ts

@@ -1,6 +0,0 @@
-export declare const grep_app: {
-    type: "remote";
-    url: string;
-    enabled: boolean;
-    oauth: false;
-};

package/dist/mcp/omo-mcp-index.d.ts

@@ -1,10 +0,0 @@
-import type { HiaiOpenCodeConfig } from "../config/schema";
-export { McpNameSchema, type McpName } from "./types";
-type RemoteMcpConfig = {
-    type: "remote";
-    url: string;
-    enabled: boolean;
-    headers?: Record<string, string>;
-    oauth?: false;
-};
-export declare function createBuiltinMcps(disabledMcps?: string[], config?: HiaiOpenCodeConfig): Record<string, RemoteMcpConfig>;

package/dist/mcp/websearch.d.ts

@@ -1,11 +0,0 @@
-import type { WebsearchConfig } from "../config/schema";
-type RemoteMcpConfig = {
-    type: "remote";
-    url: string;
-    enabled: boolean;
-    headers?: Record<string, string>;
-    oauth?: false;
-};
-export declare function createWebsearchConfig(config?: WebsearchConfig): RemoteMcpConfig | undefined;
-export declare const websearch: RemoteMcpConfig | undefined;
-export {};

package/src/config/schema/websearch.ts

@@ -1,15 +0,0 @@
-import { z } from "zod"
-
-export const WebsearchProviderSchema = z.enum(["exa", "tavily"])
-
-export const WebsearchConfigSchema = z.object({
-  /**
-   * Websearch provider to use.
-   * - "exa": Uses Exa websearch (default, works without API key)
-   * - "tavily": Uses Tavily websearch (requires TAVILY_API_KEY)
-   */
-  provider: WebsearchProviderSchema.optional(),
-})
-
-export type WebsearchProvider = z.infer<typeof WebsearchProviderSchema>
-export type WebsearchConfig = z.infer<typeof WebsearchConfigSchema>

package/src/hooks/no-bob-gpt/hook.ts

@@ -1,56 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { isGptModel, isGptProModel } from "../../agents/types"
-import {
-  getSessionAgent,
-  resolveRegisteredAgentName,
-  updateSessionAgent,
-} from "../../features/claude-code-session-state"
-import { log } from "../../shared"
-import { getAgentConfigKey } from "../../shared/agent-display-names"
-
-const TOAST_TITLE = "NEVER Use Bob with GPT"
-const TOAST_MESSAGE = [
-  "Bob works best with Claude Opus, and works fine with Kimi/GLM models.",
-  "Do NOT use Bob with GPT (except High-Tier Pro models which have specialized support).",
-  "For GPT models (other than Pro), always use Coder.",
-].join("\n")
-function showToast(ctx: PluginInput, sessionID: string): void {
-  ctx.client.tui.showToast({
-    body: {
-      title: TOAST_TITLE,
-      message: TOAST_MESSAGE,
-      variant: "error",
-      duration: 10000,
-    },
-  }).catch((error) => {
-    log("[no-bob-gpt] Failed to show toast", {
-      sessionID,
-      error,
-    })
-  })
-}
-
-export function createNoBobGptHook(ctx: PluginInput) {
-  return {
-    "chat.message": async (input: {
-      sessionID: string
-      agent?: string
-      model?: { providerID: string; modelID: string }
-    }, output?: {
-      message?: { agent?: string; [key: string]: unknown }
-    }): Promise<void> => {
-      const rawAgent = input.agent ?? getSessionAgent(input.sessionID) ?? ""
-      const agentKey = getAgentConfigKey(rawAgent)
-      const modelID = input.model?.modelID
-
-      if (agentKey === "bob" && modelID && isGptModel(modelID) && !isGptProModel(modelID)) {
-        showToast(ctx, input.sessionID)
-        input.agent = resolveRegisteredAgentName("coder") ?? "coder"
-        if (output?.message) {
-          output.message.agent = resolveRegisteredAgentName("coder") ?? "coder"
-        }
-        updateSessionAgent(input.sessionID, "coder")
-      }
-    },
-  }
-}

package/src/hooks/no-bob-gpt/index.ts

@@ -1 +0,0 @@
-export { createNoBobGptHook } from "./hook"

package/src/hooks/no-coder-non-gpt/hook.ts

@@ -1,67 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { isGptModel } from "../../agents/types"
-import {
-  getSessionAgent,
-  resolveRegisteredAgentName,
-  updateSessionAgent,
-} from "../../features/claude-code-session-state"
-import { log } from "../../shared"
-import { getAgentConfigKey } from "../../shared/agent-display-names"
-
-const TOAST_TITLE = "NEVER Use Coder with Non-GPT"
-const TOAST_MESSAGE = [
-  "Coder is designed exclusively for GPT models.",
-  "Coder is trash without GPT.",
-  "For Claude/Kimi/GLM models, always use Bob.",
-].join("\n")
-type NoCoderNonGptHookOptions = {
-  allowNonGptModel?: boolean
-}
-
-function showToast(ctx: PluginInput, sessionID: string, variant: "error" | "warning"): void {
-  ctx.client.tui.showToast({
-    body: {
-      title: TOAST_TITLE,
-      message: TOAST_MESSAGE,
-      variant,
-      duration: 10000,
-    },
-  }).catch((error) => {
-    log("[no-coder-non-gpt] Failed to show toast", {
-      sessionID,
-      error,
-    })
-  })
-}
-
-export function createNoCoderNonGptHook(
-  ctx: PluginInput,
-  options?: NoCoderNonGptHookOptions,
-) {
-  return {
-    "chat.message": async (input: {
-      sessionID: string
-      agent?: string
-      model?: { providerID: string; modelID: string }
-    }, output?: {
-      message?: { agent?: string; [key: string]: unknown }
-    }): Promise<void> => {
-      const rawAgent = input.agent ?? getSessionAgent(input.sessionID) ?? ""
-      const agentKey = getAgentConfigKey(rawAgent)
-      const modelID = input.model?.modelID
-      const allowNonGptModel = options?.allowNonGptModel === true
-
-      if (agentKey === "coder" && modelID && !isGptModel(modelID)) {
-        showToast(ctx, input.sessionID, allowNonGptModel ? "warning" : "error")
-        if (allowNonGptModel) {
-          return
-        }
-        input.agent = resolveRegisteredAgentName("bob") ?? "bob"
-        if (output?.message) {
-          output.message.agent = resolveRegisteredAgentName("bob") ?? "bob"
-        }
-        updateSessionAgent(input.sessionID, "bob")
-      }
-    },
-  }
-}

package/src/hooks/no-coder-non-gpt/index.ts

@@ -1 +0,0 @@
-export { createNoCoderNonGptHook } from "./hook"

package/src/mcp/grep-app.ts

@@ -1,6 +0,0 @@
-export const grep_app = {
-  type: "remote" as const,
-  url: "https://mcp.grep.app",
-  enabled: true,
-  oauth: false as const,
-}

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

@@ -1,30 +0,0 @@
-import { createWebsearchConfig } from "./websearch"
-import { grep_app } from "./grep-app"
-import type { HiaiOpenCodeConfig } from "../config/schema"
-
-export { McpNameSchema, type McpName } from "./types"
-
-type RemoteMcpConfig = {
-  type: "remote"
-  url: string
-  enabled: boolean
-  headers?: Record<string, string>
-  oauth?: false
-}
-
-export function createBuiltinMcps(disabledMcps: string[] = [], config?: HiaiOpenCodeConfig) {
-  const mcps: Record<string, RemoteMcpConfig> = {}
-
-  if (!disabledMcps.includes("websearch")) {
-    const websearchConfig = createWebsearchConfig(config?.websearch)
-    if (websearchConfig) {
-      mcps.websearch = websearchConfig
-    }
-  }
-
-  if (!disabledMcps.includes("grep_app")) {
-    mcps.grep_app = grep_app
-  }
-
-  return mcps
-}

package/src/mcp/websearch.ts

@@ -1,44 +0,0 @@
-import type { WebsearchConfig } from "../config/schema"
-import { log } from "../shared/logger"
-
-type RemoteMcpConfig = {
-  type: "remote"
-  url: string
-  enabled: boolean
-  headers?: Record<string, string>
-  oauth?: false
-}
-
-export function createWebsearchConfig(config?: WebsearchConfig): RemoteMcpConfig | undefined {
-  const provider = config?.provider || "exa"
-
-  if (provider === "tavily") {
-    const tavilyKey = process.env.TAVILY_API_KEY
-    if (!tavilyKey) {
-      log("[websearch] Tavily API key not found, skipping websearch MCP")
-      return undefined
-    }
-
-    return {
-      type: "remote" as const,
-      url: "https://mcp.tavily.com/mcp/",
-      enabled: true,
-      headers: {
-        Authorization: `Bearer ${tavilyKey}`,
-      },
-      oauth: false as const,
-    }
-  }
-
-  return {
-    type: "remote" as const,
-    url: process.env.EXA_API_KEY
-      ? `https://mcp.exa.ai/mcp?tools=web_search_exa&exaApiKey=${encodeURIComponent(process.env.EXA_API_KEY)}`
-      : "https://mcp.exa.ai/mcp?tools=web_search_exa",
-    enabled: true,
-    ...(process.env.EXA_API_KEY ? { headers: { "x-api-key": process.env.EXA_API_KEY } } : {}),
-    oauth: false as const,
-  }
-}
-
-export const websearch = createWebsearchConfig()