@hiai-gg/hiai-opencode 0.1.4 → 0.1.6

package/src/config/defaults.ts

@@ -1,23 +1,61 @@
 /**
  * Runtime defaults for hiai-opencode.
  *
- * Model defaults are intentionally not defined in TypeScript.
- * The bundled hiai-opencode.json file is the single source of truth for:
- * - agent models
- * - category models
- * - user-editable runtime defaults
+ * The user-facing config owns model choice through 10 primary agent slots.
+ * Internal routing derives hidden agents and task categories from those slots.
  */
 import { existsSync, readFileSync } from "node:fs"
 import { dirname, join, normalize } from "node:path"
-import type { HiaiOpencodeConfig } from "./types.js"
+import { createDefaultMcpConfig } from "../mcp/registry.js"
+import type { HiaiOpencodeConfig, LspServerConfig } from "./types.js"
+
+const REQUIRED_MODEL_SLOTS = [
+  "bob",
+  "coder",
+  "strategist",
+  "guard",
+  "critic",
+  "designer",
+  "researcher",
+  "manager",
+  "brainstormer",
+  "vision",
+] as const
+
+type ModelSlot = (typeof REQUIRED_MODEL_SLOTS)[number]
+
+const DEFAULT_LSP: Record<string, LspServerConfig> = {
+  typescript: {
+    enabled: true,
+    command: ["typescript-language-server", "--stdio"],
+    extensions: [".ts", ".tsx", ".mts", ".cts"],
+  },
+  svelte: {
+    enabled: true,
+    command: ["svelteserver", "--stdio"],
+    extensions: [".svelte"],
+  },
+  eslint: {
+    enabled: true,
+    command: ["node", "{pluginRoot}/assets/runtime/npm-package-runner.mjs", "eslint-lsp", "--stdio"],
+    extensions: [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".svelte"],
+  },
+  bash: {
+    enabled: true,
+    command: ["node", "{pluginRoot}/assets/runtime/npm-package-runner.mjs", "bash-language-server", "start"],
+    extensions: [".sh", ".bash"],
+  },
+  pyright: {
+    enabled: true,
+    command: ["pyright-langserver", "--stdio"],
+    extensions: [".py"],
+  },
+}
 
 function findPluginRoot(): string {
   const candidates = [
-    // Source tree: src/config/defaults.ts -> repo root
     join(import.meta.dirname, "..", ".."),
-    // Built package: dist/index.js bundle -> package root
     join(import.meta.dirname, ".."),
-    // Non-bundled compiled output: dist/config/defaults.js -> package root
     join(import.meta.dirname, "..", ".."),
     dirname(process.argv[1] ?? ""),
     process.cwd(),
@@ -25,35 +63,135 @@ function findPluginRoot(): string {
 
   for (const candidate of candidates) {
     const root = normalize(candidate)
-    if (existsSync(join(root, "hiai-opencode.json"))) {
-      return root
-    }
+    if (existsSync(join(root, "hiai-opencode.json"))) return root
   }
 
-  throw new Error(
-    "[hiai-opencode] Cannot find bundled hiai-opencode.json. The package is incomplete.",
-  )
+  throw new Error("[hiai-opencode] Cannot find bundled hiai-opencode.json. The package is incomplete.")
 }
 
 function expandPluginRootPlaceholders(value: unknown, pluginRoot: string): unknown {
-  if (typeof value === "string") {
-    return value.replaceAll("{pluginRoot}", pluginRoot)
+  if (typeof value === "string") return value.replaceAll("{pluginRoot}", pluginRoot)
+  if (Array.isArray(value)) return value.map((item) => expandPluginRootPlaceholders(item, pluginRoot))
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [key, expandPluginRootPlaceholders(entry, pluginRoot)]),
+    )
   }
+  return value
+}
 
-  if (Array.isArray(value)) {
-    return value.map((item) => expandPluginRootPlaceholders(item, pluginRoot))
+function requireModelSlots(config: HiaiOpencodeConfig): Record<ModelSlot, string> {
+  const models = config.models ?? {}
+  const resolved = Object.fromEntries(
+    REQUIRED_MODEL_SLOTS.map((slot) => {
+      const value = models[slot]
+      const model = typeof value === "string" ? value : value?.model
+      return [slot, model?.trim() ?? ""]
+    }),
+  ) as Record<ModelSlot, string>
+
+  const missing = REQUIRED_MODEL_SLOTS.filter((slot) => !resolved[slot])
+  if (missing.length > 0) {
+    throw new Error(`[hiai-opencode] Missing required model slot(s) in hiai-opencode.json: ${missing.join(", ")}`)
   }
+  return resolved
+}
 
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).map(([key, entry]) => [
-        key,
-        expandPluginRootPlaceholders(entry, pluginRoot),
-      ]),
-    )
+function deriveAgents(models: Record<ModelSlot, string>): HiaiOpencodeConfig["agents"] {
+  return {
+    bob: { model: models.bob },
+    coder: { model: models.coder },
+    strategist: { model: models.strategist },
+    guard: { model: models.guard },
+    critic: { model: models.critic },
+    designer: { model: models.designer },
+    researcher: { model: models.researcher },
+    "platform-manager": { model: models.manager },
+    brainstormer: { model: models.brainstormer },
+    multimodal: { model: models.vision },
+    sub: { model: models.coder },
+    "quality-guardian": { model: models.critic },
+    "agent-skills": { model: models.manager },
+  }
+}
+
+function deriveCategories(models: Record<ModelSlot, string>): HiaiOpencodeConfig["categories"] {
+  return {
+    "visual-engineering": { model: models.designer, variant: "high" },
+    artistry: { model: models.designer, variant: "high" },
+    ultrabrain: { model: models.strategist, variant: "xhigh" },
+    deep: { model: models.coder, variant: "medium" },
+    quick: { model: models.researcher },
+    writing: { model: models.brainstormer },
+    git: { model: models.manager },
+    "unspecified-low": { model: models.coder },
+    "unspecified-high": { model: models.bob, variant: "max" },
   }
+}
 
-  return value
+function deriveMcp(config: HiaiOpencodeConfig): HiaiOpencodeConfig["mcp"] {
+  const defaults = createDefaultMcpConfig()
+  const userMcp = config.mcp ?? {}
+  return Object.fromEntries(
+    Object.entries(defaults).map(([name, entry]) => {
+      const override = userMcp[name] ?? {}
+      const merged = { ...entry, ...override }
+
+      if (name === "mempalace" && typeof merged.pythonPath === "string" && merged.pythonPath.trim()) {
+        merged.environment = {
+          ...(entry.environment ?? {}),
+          ...(merged.environment ?? {}),
+          MEMPALACE_PYTHON: merged.pythonPath.trim(),
+        }
+      }
+
+      // Internal launcher hint; do not leak unknown keys into final OpenCode MCP server config.
+      delete merged.pythonPath
+
+      return [name, merged]
+    }),
+  )
+}
+
+function deriveLsp(config: HiaiOpencodeConfig): HiaiOpencodeConfig["lsp"] {
+  const userLsp = config.lsp ?? {}
+  return Object.fromEntries(
+    Object.entries(DEFAULT_LSP).map(([name, entry]) => {
+      const override = userLsp[name] ?? {}
+      return [name, { ...entry, ...override }]
+    }),
+  )
+}
+
+function materializeConfig(rawConfig: HiaiOpencodeConfig): HiaiOpencodeConfig {
+  const models = requireModelSlots(rawConfig)
+  return {
+    ...rawConfig,
+    agents: deriveAgents(models),
+    agentRequirements: {},
+    categories: deriveCategories(models),
+    categoryRequirements: {},
+    modelFamilies: [],
+    mcp: deriveMcp(rawConfig),
+    lsp: deriveLsp(rawConfig),
+    subtask2: {
+      replace_generic: true,
+      generic_return: null,
+      ...(rawConfig.subtask2 ?? {}),
+    },
+    skills: {
+      enabled: true,
+      disabled: [],
+      ...(rawConfig.skills ?? {}),
+    },
+    permissions: {
+      read: { "*": "allow", "*.env": "deny", "*.env.*": "deny", "*.env.example": "allow" },
+      edit: { "*": "allow" },
+      bash: { "*": "allow" },
+      deny_paths: ["**/backup/**", "**/secrets.*", "**/.env", "**/.env.*"],
+      ...(rawConfig.permissions ?? {}),
+    },
+  }
 }
 
 function loadBundledDefaultConfig(): HiaiOpencodeConfig {
@@ -61,8 +199,13 @@ function loadBundledDefaultConfig(): HiaiOpencodeConfig {
   const configPath = join(pluginRoot, "hiai-opencode.json")
   const raw = readFileSync(configPath, "utf-8")
   const parsed = JSON.parse(raw) as HiaiOpencodeConfig
+  const materialized = materializeConfig(parsed)
+
+  return expandPluginRootPlaceholders(materialized, pluginRoot) as HiaiOpencodeConfig
+}
 
-  return expandPluginRootPlaceholders(parsed, pluginRoot) as HiaiOpencodeConfig
+export function applyModelSlots(config: HiaiOpencodeConfig): HiaiOpencodeConfig {
+  return materializeConfig(config)
 }
 
 export const defaultConfig: HiaiOpencodeConfig = loadBundledDefaultConfig()

package/src/config/loader.test.ts

@@ -28,9 +28,23 @@ function withTempProject(
   }
 }
 
+const requiredModels = {
+  bob: { model: "openrouter/test/bob", recommended: "xhigh" },
+  coder: { model: "openrouter/test/coder", recommended: "high" },
+  strategist: { model: "openrouter/test/strategist", recommended: "high" },
+  guard: "openrouter/test/guard",
+  critic: "openrouter/test/critic",
+  designer: "openrouter/test/designer",
+  researcher: "openrouter/test/researcher",
+  manager: "openrouter/test/manager",
+  brainstormer: "openrouter/test/brainstormer",
+  vision: "openrouter/test/vision",
+};
+
 test("loadConfig accepts compact enabled-only LSP entries for builtin servers", () => {
   withTempProject(
     {
+      models: requiredModels,
       lsp: {
         typescript: {
           enabled: true,
@@ -42,7 +56,7 @@ test("loadConfig accepts compact enabled-only LSP entries for builtin servers",
       const tsServer = loaded.lsp?.typescript;
 
       expect(tsServer).toBeDefined();
-      expect(tsServer?.command.length).toBeGreaterThan(0);
+      expect(tsServer?.command?.length).toBeGreaterThan(0);
       expect(tsServer?.extensions).toContain(".ts");
     },
   );
@@ -51,6 +65,7 @@ test("loadConfig accepts compact enabled-only LSP entries for builtin servers",
 test("loadConfig ignores unknown compact enabled-only LSP entries", () => {
   withTempProject(
     {
+      models: requiredModels,
       lsp: {
         "custom-server": {
           enabled: true,

package/src/config/loader.ts

@@ -2,7 +2,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { parse } from "jsonc-parser";
 import { HiaiOpencodeConfigSchema } from "./platform-schema.js";
-import { defaultConfig } from "./defaults.js";
+import { applyModelSlots, defaultConfig } from "./defaults.js";
 import {
   LEGACY_AGENT_ALIAS_TO_CANONICAL,
   type CanonicalAgentName,
@@ -157,10 +157,12 @@ export function loadConfig(projectDir: string): HiaiOpencodeConfig {
   const validated = HiaiOpencodeConfigSchema.parse(normalizedParsed);
   const normalized = normalizeAgentAliases(validated);
 
-  return deepMerge(
+  const merged = deepMerge(
     BASE_CONFIG as unknown as Record<string, unknown>,
     normalized as unknown as Record<string, unknown>,
   ) as HiaiOpencodeConfig;
+
+  return applyModelSlots(merged);
 }
 
 export function resolveEnvVars(value: string): string {

package/src/config/model-slots-and-export.test.ts

@@ -0,0 +1,55 @@
+import { expect, test } from "bun:test"
+
+import { applyModelSlots } from "./defaults"
+import type { HiaiOpencodeConfig } from "./types"
+import { buildStaticMcpJson, MCP_EXPORT_MARKER } from "../shared/mcp-static-export"
+import { buildHiaiIntegrationPrimerSection } from "../agents/dynamic-agent-core-sections"
+
+const baseConfig: HiaiOpencodeConfig = {
+  models: {
+    bob: { model: "openrouter/test/bob", recommended: "xhigh" },
+    coder: { model: "openrouter/test/coder", recommended: "high" },
+    strategist: { model: "openrouter/test/strategist", recommended: "high" },
+    guard: { model: "openrouter/test/guard", recommended: "middle" },
+    critic: { model: "openrouter/test/critic", recommended: "high" },
+    designer: { model: "openrouter/test/designer", recommended: "design" },
+    researcher: { model: "openrouter/test/researcher", recommended: "fast" },
+    manager: { model: "openrouter/test/manager", recommended: "fast" },
+    brainstormer: { model: "openrouter/test/brainstormer", recommended: "writing" },
+    vision: { model: "openrouter/test/vision", recommended: "vision" },
+  },
+  mcp: {
+    mempalace: { enabled: true, pythonPath: "/opt/venv/bin/python" },
+  },
+}
+
+test("model slots derive canonical agents and categories", () => {
+  const resolved = applyModelSlots(baseConfig)
+  expect(resolved.agents?.bob?.model).toBe("openrouter/test/bob")
+  expect(resolved.agents?.coder?.model).toBe("openrouter/test/coder")
+  expect(resolved.agents?.["platform-manager"]?.model).toBe("openrouter/test/manager")
+  expect(resolved.agents?.sub?.model).toBe("openrouter/test/coder")
+  expect(resolved.categories?.artistry?.model).toBe("openrouter/test/designer")
+  expect(resolved.categories?.ultrabrain?.model).toBe("openrouter/test/strategist")
+  expect(resolved.categories?.writing?.model).toBe("openrouter/test/brainstormer")
+})
+
+test("compact MCP mempalace pythonPath is materialized into environment", () => {
+  const resolved = applyModelSlots(baseConfig)
+  expect(resolved.mcp?.mempalace?.environment?.MEMPALACE_PYTHON).toBe("/opt/venv/bin/python")
+})
+
+test("static MCP export includes marker metadata and servers", () => {
+  const resolved = applyModelSlots(baseConfig)
+  const exported = buildStaticMcpJson(resolved)
+
+  expect(exported._meta?.generatedBy).toBe(MCP_EXPORT_MARKER)
+  expect(exported._meta?.version).toBe(1)
+  expect(exported.mcpServers.playwright).toBeDefined()
+  expect(exported.mcpServers.mempalace).toBeDefined()
+})
+
+test("integration primer does not request model provider API keys", () => {
+  const primer = buildHiaiIntegrationPrimerSection()
+  expect(primer).toContain("Do not ask for `OPENROUTER_API_KEY`, `OPENAI_API_KEY`, or `ANTHROPIC_API_KEY`")
+})

package/src/config/platform-schema.ts

@@ -8,6 +8,37 @@ export const AgentConfigSchema = z.object({
   description: z.string().optional(),
 });
 
+export const ModelRecommendationSchema = z.enum([
+  "xhigh",
+  "high",
+  "middle",
+  "fast",
+  "vision",
+  "writing",
+  "design",
+]);
+
+export const ModelSlotConfigSchema = z.union([
+  z.string(),
+  z.object({
+    model: z.string(),
+    recommended: ModelRecommendationSchema.optional(),
+  }),
+]);
+
+export const ModelSlotsConfigSchema = z.object({
+  bob: ModelSlotConfigSchema.optional(),
+  coder: ModelSlotConfigSchema.optional(),
+  strategist: ModelSlotConfigSchema.optional(),
+  guard: ModelSlotConfigSchema.optional(),
+  critic: ModelSlotConfigSchema.optional(),
+  designer: ModelSlotConfigSchema.optional(),
+  researcher: ModelSlotConfigSchema.optional(),
+  manager: ModelSlotConfigSchema.optional(),
+  brainstormer: ModelSlotConfigSchema.optional(),
+  vision: ModelSlotConfigSchema.optional(),
+});
+
 export const FallbackEntrySchema = z.object({
   providers: z.array(z.string()),
   model: z.string(),
@@ -45,11 +76,13 @@ export const McpServerConfigSchema = z.object({
   command: z.array(z.string()).optional(),
   timeout: z.number().optional(),
   environment: z.record(z.string(), z.string()).optional(),
+  pythonPath: z.string().optional(),
 });
 
 export const LspServerConfigSchema = z.object({
-  command: z.array(z.string()),
-  extensions: z.array(z.string()),
+  enabled: z.boolean().optional(),
+  command: z.array(z.string()).optional(),
+  extensions: z.array(z.string()).optional(),
   initialization: z.record(z.string(), z.unknown()).optional(),
 });
 
@@ -97,11 +130,9 @@ export const PermissionsConfigSchema = z.object({
 });
 
 export const AuthKeysSchema = z.object({
-  googleSearch: z.string().optional(),
-  openai: z.string().optional(),
-  openrouter: z.string().optional(),
   stitch: z.string().optional(),
   firecrawl: z.string().optional(),
+  context7: z.string().optional(),
 });
 
 export const OllamaConfigSchema = z.object({
@@ -190,6 +221,7 @@ const AgentRequirementsConfigSchema = z.object({
 
 export const HiaiOpencodeConfigSchema = z.object({
   $schema: z.string().optional(),
+  models: ModelSlotsConfigSchema.optional(),
   agents: AgentsConfigSchema.optional(),
   agentRequirements: AgentRequirementsConfigSchema.optional(),
   categories: z.record(z.string(), CategoryConfigSchema).optional(),

package/src/config/schema/commands.ts

@@ -10,6 +10,7 @@ export const BuiltinCommandNameSchema = z.enum([
   "stop-continuation",
   "remove-ai-slops",
   "mcp-status",
+  "doctor",
 ])
 
 export type BuiltinCommandName = z.infer<typeof BuiltinCommandNameSchema>

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

@@ -26,9 +26,6 @@ import { FastApplyConfigSchema } from "./fast-apply"
 import { WebsearchConfigSchema } from "./websearch"
 
 const AuthConfigSchema = z.object({
-  googleSearch: z.string().optional(),
-  openai: z.string().optional(),
-  openrouter: z.string().optional(),
   stitch: z.string().optional(),
   firecrawl: z.string().optional(),
   context7: z.string().optional(),

package/src/config/types.ts

@@ -7,6 +7,35 @@ export interface AgentConfig {
   description?: string;
 }
 
+export type ModelRecommendation =
+  | "xhigh"
+  | "high"
+  | "middle"
+  | "fast"
+  | "vision"
+  | "writing"
+  | "design";
+
+export type ModelSlotConfig =
+  | string
+  | {
+      model: string;
+      recommended?: ModelRecommendation;
+    };
+
+export interface ModelSlotsConfig {
+  bob?: ModelSlotConfig;
+  coder?: ModelSlotConfig;
+  strategist?: ModelSlotConfig;
+  guard?: ModelSlotConfig;
+  critic?: ModelSlotConfig;
+  designer?: ModelSlotConfig;
+  researcher?: ModelSlotConfig;
+  manager?: ModelSlotConfig;
+  brainstormer?: ModelSlotConfig;
+  vision?: ModelSlotConfig;
+}
+
 // Canonical 12-agent model exposed by schema/default config.
 export const CANONICAL_AGENT_NAMES = [
   "bob",
@@ -121,11 +150,13 @@ export interface McpServerConfig {
   command?: string[];
   timeout?: number;
   environment?: Record<string, string>;
+  pythonPath?: string;
 }
 
 export interface LspServerConfig {
-  command: string[];
-  extensions: string[];
+  enabled?: boolean;
+  command?: string[];
+  extensions?: string[];
   initialization?: Record<string, unknown>;
 }
 
@@ -157,9 +188,6 @@ export interface PermissionsConfig {
 }
 
 export interface AuthKeys {
-  googleSearch?: string;
-  openai?: string;
-  openrouter?: string;
   stitch?: string;
   firecrawl?: string;
   context7?: string;
@@ -174,6 +202,7 @@ export interface OllamaConfig {
 
 export interface HiaiOpencodeConfig {
   $schema?: string;
+  models?: ModelSlotsConfig;
   agents?: AgentConfigMap;
   agentRequirements?: AgentRequirementMap;
   categories?: Record<string, CategoryConfig>;

package/src/create-tools.ts

@@ -1,5 +1,6 @@
 import type { AvailableCategory, AvailableSkill } from "./agents/dynamic-agent-prompt-builder"
 import type { HiaiOpenCodeConfig } from "./config"
+import type { HiaiOpencodeConfig } from "./config/types"
 import type { BrowserAutomationProvider } from "./config/schema/browser-automation"
 import type { LoadedSkill } from "./features/opencode-skill-loader/types"
 import type { PluginContext, ToolsRecord } from "./plugin/types"
@@ -22,9 +23,10 @@ type CreateToolsResult = {
 export async function createTools(args: {
   ctx: PluginContext
   pluginConfig: HiaiOpenCodeConfig
+  platformConfig?: HiaiOpencodeConfig
   managers: Pick<Managers, "backgroundManager" | "tmuxSessionManager" | "skillMcpManager">
 }): Promise<CreateToolsResult> {
-  const { ctx, pluginConfig, managers } = args
+  const { ctx, pluginConfig, platformConfig, managers } = args
 
   const skillContext = await createSkillContext({
     directory: ctx.directory,
@@ -39,6 +41,7 @@ export async function createTools(args: {
     managers,
     skillContext,
     availableCategories,
+    builtinMcp: platformConfig?.mcp,
   })
 
   return {

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

@@ -9,6 +9,7 @@ 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"
+import { DOCTOR_TEMPLATE } from "./templates/doctor"
 
 interface LoadBuiltinCommandsOptions {
   useRegisteredAgents?: boolean
@@ -126,6 +127,12 @@ $ARGUMENTS
       description: "(builtin) Show hiai-opencode MCP server status, missing keys, and local runtime availability",
       template: `<command-instruction>
 ${MCP_STATUS_TEMPLATE}
+</command-instruction>`,
+    },
+    doctor: {
+      description: "(builtin) Run hiai-opencode install/runtime diagnostics and explain setup issues",
+      template: `<command-instruction>
+${DOCTOR_TEMPLATE}
 </command-instruction>`,
     },
   }

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

@@ -0,0 +1,43 @@
+export const DOCTOR_TEMPLATE = `# Hiai OpenCode Doctor Command
+
+## Purpose
+
+Use /doctor to run the hiai-opencode install/runtime diagnostic and report actionable setup issues.
+
+## Execute
+
+Run:
+
+\`\`\`bash
+hiai-opencode doctor
+\`\`\`
+
+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 doctor
+\`\`\`
+
+## Report
+
+Summarize:
+
+- config path
+- enabled and disabled MCP servers
+- missing env vars by name only
+- static \`.mcp.json\` freshness and whether it is managed by hiai-opencode
+- OpenCode Connect visibility for configured model providers
+- OpenCode plugin registration sanity (including \`plugin: ["list"]\` misconfiguration warning)
+- skill materialization status from skill registry
+- agent count and naming summary
+- LSP runtime availability
+- MemPalace python source and selected interpreter (env/config/auto)
+- MCP tool probes (real connect + tools/list) for stdio and basic endpoint probes for remote MCP
+
+Rules:
+
+- Do not print API key values.
+- Do not ask for model provider env vars such as OPENROUTER_API_KEY or OPENAI_API_KEY; normal model auth belongs to OpenCode Connect.
+- If \`opencode mcp list\` is empty but doctor/mcp-status sees servers, explain the runtime-vs-static config distinction and run \`hiai-opencode export-mcp .mcp.json\` if the user wants static visibility.
+- 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" | "mcp-status"
+export type BuiltinCommandName = "init-deep" | "ralph-loop" | "cancel-ralph" | "ulw-loop" | "refactor" | "start-work" | "stop-continuation" | "handoff" | "remove-ai-slops" | "mcp-status" | "doctor"
 
 export interface BuiltinCommandConfig {
   disabled_commands?: BuiltinCommandName[]