@hiai-gg/hiai-opencode 0.1.5 → 0.1.7

package/src/shared/mcp-static-export.ts

@@ -0,0 +1,119 @@
+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, logWarn } 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) {
+    logWarn(`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)
+    logWarn(`failed to export static MCP config to ${outputPath}: ${message}`)
+  }
+}

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

@@ -64,6 +64,13 @@ export const AGENT_NAME_MAP: Record<string, string> = {
   // Designer
   designer: "designer",
 
+  // Writer/copywriter aliases are handled by Brainstormer.
+  writer: "brainstormer",
+  copywriter: "brainstormer",
+  "content-writer": "brainstormer",
+  "content writer": "brainstormer",
+  "website-writer": "brainstormer",
+
   // Multimodal / Vision
   ui: "multimodal",
   vision: "multimodal",
@@ -80,6 +87,7 @@ export const BUILTIN_AGENT_NAMES = new Set([
   "multimodal",
   "platform-manager",
   "guard",
+  "brainstormer",
 ])
 
 export function migrateAgentNames(

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

@@ -5,7 +5,7 @@ export const HOOK_NAME_MAP: Record<string, string | null> = {
   "anthropic-auto-compact": "anthropic-context-window-limit-recovery",
   "bob-orchestrator": "guard",
 
-  "bob-gpt-coder-reminder": "no-bob-gpt",
+  "bob-gpt-coder-reminder": null,
 
   // Removed hooks (v3.0.0) - will be filtered out and user warned
   "empty-message-sanitizer": null,

package/src/shared/mode-routing.test.ts

@@ -0,0 +1,88 @@
+import { expect, test } from "bun:test"
+import { normalizeMode, resolveModeAgent, MODE_TO_AGENT, MODE_NAMES } from "./mode-routing"
+
+test("normalizeMode returns legacy aliases mapped to new names", () => {
+  expect(normalizeMode("unspecified-low")).toBe("bounded")
+  expect(normalizeMode("unspecified-high")).toBe("cross-module")
+})
+
+test("normalizeMode returns same name when not a legacy alias", () => {
+  expect(normalizeMode("quick")).toBe("quick")
+  expect(normalizeMode("deep")).toBe("deep")
+  expect(normalizeMode("writing")).toBe("writing")
+})
+
+test("resolveModeAgent maps quick to sub", () => {
+  expect(resolveModeAgent("quick")).toBe("sub")
+})
+
+test("resolveModeAgent maps writing to brainstormer", () => {
+  expect(resolveModeAgent("writing")).toBe("brainstormer")
+})
+
+test("resolveModeAgent maps deep to coder", () => {
+  expect(resolveModeAgent("deep")).toBe("coder")
+})
+
+test("resolveModeAgent maps ultrabrain to strategist", () => {
+  expect(resolveModeAgent("ultrabrain")).toBe("strategist")
+})
+
+test("resolveModeAgent maps visual-engineering to designer", () => {
+  expect(resolveModeAgent("visual-engineering")).toBe("designer")
+})
+
+test("resolveModeAgent maps artistry to designer", () => {
+  expect(resolveModeAgent("artistry")).toBe("designer")
+})
+
+test("resolveModeAgent maps git to platform-manager", () => {
+  expect(resolveModeAgent("git")).toBe("platform-manager")
+})
+
+test("resolveModeAgent maps git-ops to platform-manager", () => {
+  expect(resolveModeAgent("git-ops")).toBe("platform-manager")
+})
+
+test("resolveModeAgent maps bounded to sub", () => {
+  expect(resolveModeAgent("bounded")).toBe("sub")
+})
+
+test("resolveModeAgent maps cross-module to coder", () => {
+  expect(resolveModeAgent("cross-module")).toBe("coder")
+})
+
+test("resolveModeAgent falls back to coder for unknown mode", () => {
+  expect(resolveModeAgent("unknown-mode")).toBe("coder")
+})
+
+test("resolveModeAgent handles legacy aliases", () => {
+  expect(resolveModeAgent("unspecified-low")).toBe("sub")
+  expect(resolveModeAgent("unspecified-high")).toBe("coder")
+})
+
+test("MODE_NAMES contains all mode names", () => {
+  expect(MODE_NAMES).toContain("quick")
+  expect(MODE_NAMES).toContain("writing")
+  expect(MODE_NAMES).toContain("deep")
+  expect(MODE_NAMES).toContain("ultrabrain")
+  expect(MODE_NAMES).toContain("visual-engineering")
+  expect(MODE_NAMES).toContain("artistry")
+  expect(MODE_NAMES).toContain("git")
+  expect(MODE_NAMES).toContain("git-ops")
+  expect(MODE_NAMES).toContain("bounded")
+  expect(MODE_NAMES).toContain("cross-module")
+})
+
+test("MODE_TO_AGENT has correct mapping", () => {
+  expect(MODE_TO_AGENT.quick).toBe("sub")
+  expect(MODE_TO_AGENT.writing).toBe("brainstormer")
+  expect(MODE_TO_AGENT.deep).toBe("coder")
+  expect(MODE_TO_AGENT.ultrabrain).toBe("strategist")
+  expect(MODE_TO_AGENT["visual-engineering"]).toBe("designer")
+  expect(MODE_TO_AGENT.artistry).toBe("designer")
+  expect(MODE_TO_AGENT.git).toBe("platform-manager")
+  expect(MODE_TO_AGENT["git-ops"]).toBe("platform-manager")
+  expect(MODE_TO_AGENT.bounded).toBe("sub")
+  expect(MODE_TO_AGENT["cross-module"]).toBe("coder")
+})

package/src/shared/mode-routing.ts

@@ -0,0 +1,30 @@
+import type { CanonicalDelegateAgentKey } from "../tools/delegate-task/sub-agent"
+
+export const MODE_TO_AGENT: Record<string, CanonicalDelegateAgentKey> = {
+  quick: "sub",
+  writing: "brainstormer",
+  deep: "coder",
+  ultrabrain: "strategist",
+  "visual-engineering": "designer",
+  artistry: "designer",
+  git: "platform-manager",
+  "git-ops": "platform-manager",
+  bounded: "sub",
+  "cross-module": "coder",
+}
+
+const LEGACY_MODE_ALIASES: Record<string, string> = {
+  "unspecified-low": "bounded",
+  "unspecified-high": "cross-module",
+}
+
+export type ModeName = keyof typeof MODE_TO_AGENT
+export const MODE_NAMES = Object.keys(MODE_TO_AGENT) as ModeName[]
+
+export function normalizeMode(modeName: string): string {
+  return LEGACY_MODE_ALIASES[modeName] ?? modeName
+}
+
+export function resolveModeAgent(modeName: string): CanonicalDelegateAgentKey {
+  return MODE_TO_AGENT[normalizeMode(modeName)] ?? "coder"
+}

package/src/shared/startup-diagnostics.ts

@@ -5,6 +5,7 @@ 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 { logWarn } from "./logger"
 import { PLUGIN_NAME } from "./plugin-identity"
 
 interface OpenCodeConfig {
@@ -38,9 +39,9 @@ export function warnIfListPluginEntry(directory: string): void {
     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}"]`)
+    logWarn(`${configPath} contains plugin: ["list"].`)
+    logWarn("This can prevent hiai-opencode MCP servers from loading from that config scope.")
+    logWarn(`Update it to: plugin: ["${PLUGIN_NAME}"]`)
   }
 }
 
@@ -69,9 +70,7 @@ export function warnMissingRequiredMcpEnv(args: {
 
     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.",
-    )
+    logWarn(`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/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/call-omo-agent/tools.ts

@@ -10,6 +10,7 @@ import type { DelegatedModelConfig } from "../../shared/model-resolution-types"
 import type { FallbackEntry } from "../../shared/model-requirements"
 import { AGENT_MODEL_REQUIREMENTS } from "../../shared/model-requirements"
 import { getAgentConfigKey, stripInvisibleAgentCharacters } from "../../shared/agent-display-names"
+import { resolveCanonicalDelegateAgentKey } from "../../tools/delegate-task/sub-agent"
 import { normalizeFallbackModels } from "../../shared/model-resolver"
 import { buildFallbackChainFromModels } from "../../shared/fallback-chain-from-models"
 import { log } from "../../shared"
@@ -139,22 +140,28 @@ export function createCallOmoAgent(
     async execute(args: CallOmoAgentArgs, toolContext) {
       const toolCtx = toolContext as ToolContextWithMetadata;
       log(
-        `[call_omo_agent] Starting with agent: ${args.subagent_type}, background: ${args.run_in_background}`,
+        `[call_omo_agent] DEPRECATED: call_omo_agent is deprecated. Use task(agent="...", load_skills=[], run_in_background=...) instead.`,
       );
 
       const callableAgents = await resolveCallableAgents(ctx.client);
 
       // Strip ZWSP and case-insensitive agent validation - allows canonical names and compatibility aliases.
       const strippedAgentType = stripInvisibleAgentCharacters(args.subagent_type)
+      const preCanonicalAgentType = getAgentConfigKey(strippedAgentType)
+      const canonicalAgentType = resolveCanonicalDelegateAgentKey(preCanonicalAgentType)
+      const wasLegacyAlias = canonicalAgentType !== preCanonicalAgentType.toLowerCase()
+      if (wasLegacyAlias) {
+        log("[call_omo_agent] Legacy agent alias resolved", { from: preCanonicalAgentType, to: canonicalAgentType })
+      }
       if (
         !callableAgents.some(
-          (name) => name.toLowerCase() === strippedAgentType.toLowerCase(),
+          (name) => name.toLowerCase() === canonicalAgentType.toLowerCase(),
         )
       ) {
-        return `Error: Invalid agent type "${args.subagent_type}". Only ${callableAgents.join(", ")} are allowed.`;
+        return `Error: Invalid agent type "${args.subagent_type}". Available agents: ${callableAgents.join(", ")}. Legacy aliases: oracle→strategist, hephaestus→coder, metis→strategist, momus→critic, sisyphus-junior→sub, multimodal-looker→multimodal, librarian→researcher, explore→researcher.`;
       }
 
-      const normalizedAgent = strippedAgentType.toLowerCase();
+      const normalizedAgent = canonicalAgentType.toLowerCase();
       args = { ...args, subagent_type: normalizedAgent };
 
       // Check if agent is disabled

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

@@ -4,7 +4,7 @@ const UNSPECIFIED_LOW_CATEGORY_PROMPT_APPEND = `<Category_Context>
 You are working on tasks that don't fit specific categories but require moderate effort.
 
 <Routing_Policy>
-Executor contour: coder (fast bounded execution). Keep the scope bounded unless the task clearly requires deep or cross-system work.
+Executor contour: sub (cheap fast-tier executor). Keep the scope bounded unless the task clearly requires deep or cross-system work; in that case escalate to unspecified-high or deep.
 </Routing_Policy>
 
 <Selection_Gate>
@@ -50,13 +50,13 @@ export const ANTHROPIC_CATEGORIES: BuiltinCategoryDefinition[] = [
   {
     name: "unspecified-low",
     config: {},
-    description: "Unclassifiable moderate tasks with bounded scope. Uses coder execution contour.",
+    description: "Unclassifiable moderate tasks with bounded scope. Uses sub (cheap fast-tier) execution contour.",
     promptAppend: UNSPECIFIED_LOW_CATEGORY_PROMPT_APPEND,
   },
   {
     name: "unspecified-high",
     config: {},
-    description: "Unclassifiable substantial tasks across modules. Uses coder execution contour.",
+    description: "Unclassifiable substantial tasks across modules. Uses coder (deep execution) with max-variant model.",
     promptAppend: UNSPECIFIED_HIGH_CATEGORY_PROMPT_APPEND,
   },
 ]

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

@@ -1,6 +1,7 @@
 import type { CategoryConfig } from "../../config/schema"
 import { ANTHROPIC_CATEGORIES } from "./anthropic-categories"
 import type { BuiltinCategoryDefinition } from "./builtin-category-definition"
+import { GIT_CATEGORIES } from "./git-categories"
 import { GOOGLE_CATEGORIES } from "./google-categories"
 import { KIMI_CATEGORIES } from "./kimi-categories"
 import { OPENAI_CATEGORIES } from "./openai-categories"
@@ -10,6 +11,7 @@ const BUILTIN_CATEGORIES: BuiltinCategoryDefinition[] = [
   ...OPENAI_CATEGORIES,
   ...ANTHROPIC_CATEGORIES,
   ...KIMI_CATEGORIES,
+  ...GIT_CATEGORIES,
 ]
 
 function buildCategoryRecord<TValue>(

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

@@ -0,0 +1,87 @@
+import { expect, test } from "bun:test"
+import { resolveCategoryConfig } from "./categories"
+
+test("resolveCategoryConfig returns null for unknown category with no config", () => {
+  const result = resolveCategoryConfig("nonexistent-category", {
+    userCategories: {},
+    availableModels: new Set(["openrouter/minimax/minimax-m2.7"]),
+  })
+  expect(result).toBeNull()
+})
+
+test("resolveCategoryConfig returns null when category is disabled", () => {
+  const result = resolveCategoryConfig("quick", {
+    userCategories: { quick: { disable: true } },
+  })
+  expect(result).toBeNull()
+})
+
+test("resolveCategoryConfig merges default config with user config", () => {
+  const result = resolveCategoryConfig("quick", {
+    userCategories: { quick: { temperature: 0.9 } },
+    availableModels: new Set(["openrouter/minimax/minimax-m2.7"]),
+  })
+  expect(result).not.toBeNull()
+  expect(result!.config.temperature).toBe(0.9)
+})
+
+test("resolveCategoryConfig user model takes precedence over default", () => {
+  const result = resolveCategoryConfig("quick", {
+    userCategories: { quick: { model: "openrouter/deepseek/deepseek-v4-flash" } },
+    availableModels: new Set(["openrouter/deepseek/deepseek-v4-flash"]),
+  })
+  expect(result).not.toBeNull()
+  expect(result!.model).toBe("openrouter/deepseek/deepseek-v4-flash")
+})
+
+test("resolveCategoryConfig returns promptAppend for category", () => {
+  const result = resolveCategoryConfig("deep", {
+    userCategories: {},
+    availableModels: new Set(["openrouter/minimax/minimax-m2.7"]),
+  })
+  expect(result).not.toBeNull()
+  expect(result!.promptAppend).toBeDefined()
+})
+
+test("resolveCategoryConfig isUserConfiguredModel true when user provides model", () => {
+  const result = resolveCategoryConfig("quick", {
+    userCategories: { quick: { model: "openrouter/deepseek/deepseek-v4-flash" } },
+    availableModels: new Set(["openrouter/deepseek/deepseek-v4-flash"]),
+  })
+  expect(result).not.toBeNull()
+  expect(result!.isUserConfiguredModel).toBe(true)
+})
+
+test("resolveCategoryConfig isUserConfiguredModel false when no user model", () => {
+  const result = resolveCategoryConfig("quick", {
+    userCategories: { quick: {} },
+    availableModels: new Set(["openrouter/minimax/minimax-m2.7"]),
+  })
+  expect(result).not.toBeNull()
+  expect(result!.isUserConfiguredModel).toBe(false)
+})
+
+test("resolveCategoryConfig concatenates prompt_append with default", () => {
+  const result = resolveCategoryConfig("quick", {
+    userCategories: { quick: { prompt_append: "Extra instructions" } },
+    availableModels: new Set(["openrouter/minimax/minimax-m2.7"]),
+  })
+  expect(result).not.toBeNull()
+  expect(result!.promptAppend).toContain("Extra instructions")
+})
+
+test("resolveCategoryConfig returns null when category not in defaults or user config", () => {
+  const result = resolveCategoryConfig("nonexistent", {
+    userCategories: {},
+  })
+  expect(result).toBeNull()
+})
+
+test("resolveCategoryConfig applies user variant over default variant", () => {
+  const result = resolveCategoryConfig("deep", {
+    userCategories: { deep: { variant: "high" } },
+    availableModels: new Set(["openrouter/minimax/minimax-m2.7"]),
+  })
+  expect(result).not.toBeNull()
+  expect(result!.config.variant).toBe("high")
+})

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

@@ -3,9 +3,6 @@ import type { DelegateTaskArgs } from "./types"
 import type { ExecutorContext } from "./executor-types"
 import type { FallbackEntry } from "../../shared/model-requirements"
 import { mergeCategories } from "../../shared/merge-categories"
-import {
-  CODER_AGENT_CONFIG_KEY,
-} from "./sub-agent"
 import { resolveCategoryConfig } from "./categories"
 import { parseModelString } from "./model-string-parser"
 import { CATEGORY_MODEL_REQUIREMENTS } from "../../shared/model-requirements"
@@ -15,6 +12,7 @@ import { CONFIG_BASENAME } from "../../shared/plugin-identity"
 import { getAvailableModelsForDelegateTask } from "./available-models"
 import { resolveModelForDelegateTask } from "./model-selection"
 import { getAgentDisplayName } from "../../shared/agent-display-names"
+import { resolveModeAgent } from "../../shared/mode-routing"
 
 import type { CategoryConfig } from "../../config/schema"
 import type { DelegatedModelConfig } from "./types"
@@ -42,11 +40,11 @@ export interface CategoryResolutionResult {
 }
 
 function resolveCategoryExecutorAgentKey(
-  _categoryName: string,
+  categoryName: string,
   config: CategoryConfig,
-): typeof CODER_AGENT_CONFIG_KEY {
+): string {
   void config
-  return CODER_AGENT_CONFIG_KEY
+  return resolveModeAgent(categoryName)
 }
 
 export async function resolveCategoryExecution(
@@ -120,7 +118,7 @@ Available categories: ${allCategoryNames}`,
   }
 
   const categoryExecutorAgentKey = resolveCategoryExecutorAgentKey(categoryName, resolved.config)
-  const categoryExecutorAgentName = getAgentDisplayName(CODER_AGENT_CONFIG_KEY)
+  const categoryExecutorAgentName = getAgentDisplayName(categoryExecutorAgentKey)
   const categoryExecutorOverride = agentOverrides?.[categoryExecutorAgentKey as keyof typeof agentOverrides]
     ?? (agentOverrides
       ? Object.entries(agentOverrides).find(([key]) => key.toLowerCase() === categoryExecutorAgentKey)?.[1]
@@ -141,8 +139,9 @@ Available categories: ${allCategoryNames}`,
   const explicitCategoryModel = userCategories?.[args.category!]?.model
 
   if (!requirement) {
-    // Precedence: explicit category model > routed executor override model > category resolved model.
-    // This preserves per-category overrides while allowing category routing to stay on coder.
+    // Precedence: explicit category model > routed executor agent's override model > category resolved model.
+    // The routed executor agent is selected per-mode via resolveModeAgent (see shared/mode-routing.ts);
+    // its agentOverrides[<agent>].model serves as the fallback when no explicit category model is set.
     actualModel = explicitCategoryModel ?? overrideModel ?? resolved.model
     if (actualModel) {
       modelInfo = explicitCategoryModel || overrideModel

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

@@ -0,0 +1,30 @@
+import type { BuiltinCategoryDefinition } from "./builtin-category-definition"
+
+const GIT_CATEGORY_PROMPT_APPEND = `<Category_Context>
+You are working on GIT / VERSION CONTROL tasks.
+
+<Routing_Policy>
+Executor contour: platform-manager (git operations specialist).
+</Routing_Policy>
+
+Git operations mindset:
+- Atomic commits with clear messages
+- Clean history: rebase/squash before push
+- Safe operations: never force-push to main/master
+- Clear handoff notes for session continuity
+
+Approach:
+- Understand the current branch state
+- Plan atomic commit strategy
+- Execute with minimal noise
+- Verify state after operation
+</Category_Context>`
+
+export const GIT_CATEGORIES: BuiltinCategoryDefinition[] = [
+  {
+    name: "git",
+    config: {},
+    description: "Git operations: commits, branching, history, rebasing. Uses platform-manager execution contour.",
+    promptAppend: GIT_CATEGORY_PROMPT_APPEND,
+  },
+]