@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/config/platform-schema.ts

@@ -1,242 +0,0 @@
-/**
- * hiai-opencode.json Zod schema validation
- */
-import { z } from "zod";
-
-export const AgentConfigSchema = z.object({
-  model: z.string(),
-  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(),
-  sub: ModelSlotConfigSchema.optional(),
-});
-
-export const FallbackEntrySchema = z.object({
-  providers: z.array(z.string()),
-  model: z.string(),
-  variant: z.string().optional(),
-  reasoningEffort: z.string().optional(),
-  temperature: z.number().optional(),
-  top_p: z.number().optional(),
-  maxTokens: z.number().optional(),
-  thinking: z.object({
-    type: z.enum(["enabled", "disabled"]),
-    budgetTokens: z.number().optional(),
-  }).optional(),
-});
-
-export const ModelRequirementSchema = z.object({
-  fallbackChain: z.array(FallbackEntrySchema),
-  variant: z.string().optional(),
-  requiresModel: z.string().optional(),
-  requiresAnyModel: z.boolean().optional(),
-  requiresProvider: z.array(z.string()).optional(),
-});
-
-export const CategoryConfigSchema = z.object({
-  model: z.string(),
-  variant: z.string().optional(),
-  description: z.string().optional(),
-  fallbackChain: z.array(FallbackEntrySchema).optional(),
-});
-
-export const McpServerConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  type: z.enum(["remote", "local"]).optional(),
-  provider: z.enum(["exa", "tavily"]).optional(),
-  url: z.string().optional(),
-  headers: z.record(z.string(), z.string()).optional(),
-  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({
-  enabled: z.boolean().optional(),
-  command: z.array(z.string()).optional(),
-  extensions: z.array(z.string()).optional(),
-  initialization: z.record(z.string(), z.unknown()).optional(),
-});
-
-export const Subtask2ConfigSchema = z.object({
-  replace_generic: z.boolean().optional(),
-  generic_return: z.string().nullable().optional(),
-});
-
-export const SkillsConfigSchema = z.object({
-  enabled: z.boolean().optional(),
-  disabled: z.array(z.string()).optional(),
-});
-
-export const SkillDiscoveryConfigSchema = z.object({
-  config_sources: z.boolean().optional(),
-  project_opencode: z.boolean().optional(),
-  global_opencode: z.boolean().optional(),
-  project_claude: z.boolean().optional(),
-  global_claude: z.boolean().optional(),
-  project_agents: z.boolean().optional(),
-  global_agents: z.boolean().optional(),
-});
-
-export const PermissionsConfigSchema = z.object({
-  read: z.record(z.string(), z.string()).optional(),
-  edit: z.record(z.string(), z.string()).optional(),
-  bash: z.record(z.string(), z.string()).optional(),
-  deny_paths: z.array(z.string()).optional(),
-  doom_loop: z.enum(["allow", "deny"]).optional(),
-  question: z.enum(["allow", "deny"]).optional(),
-  plan_enter: z.enum(["allow", "deny"]).optional(),
-  plan_exit: z.enum(["allow", "deny"]).optional(),
-  list: z.enum(["allow", "deny"]).optional(),
-  glob: z.enum(["allow", "deny"]).optional(),
-  grep: z.enum(["allow", "deny"]).optional(),
-  skill: z.enum(["allow", "deny"]).optional(),
-  task: z.enum(["allow", "deny"]).optional(),
-  todoread: z.enum(["allow", "deny"]).optional(),
-  todowrite: z.enum(["allow", "deny"]).optional(),
-  webfetch: z.enum(["allow", "deny"]).optional(),
-  websearch: z.enum(["allow", "deny"]).optional(),
-  codesearch: z.enum(["allow", "deny"]).optional(),
-  external_directory: z.record(z.string(), z.string()).optional(),
-  ["*"]: z.record(z.string(), z.enum(["allow", "deny"])).optional(),
-});
-
-export const AuthKeysSchema = z.object({
-  stitch: z.string().optional(),
-  firecrawl: z.string().optional(),
-  context7: z.string().optional(),
-});
-
-export const OllamaConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  model: z.string().default(""),
-  baseUrl: z.string().default(""),
-  purpose: z.enum(["verification", "helper", "fallback"]).default("helper"),
-});
-
-export const ModelFamilySchema = z.object({
-  family: z.string(),
-  includes: z.array(z.string()).optional(),
-  pattern: z.string().optional(),
-  variants: z.array(z.string()).optional(),
-  reasoningEfforts: z.array(z.string()).optional(),
-  supportsThinking: z.boolean().optional(),
-});
-
-const AgentsConfigSchema = z.object({
-  // Canonical 12 agents
-  bob: AgentConfigSchema.optional(),
-  guard: AgentConfigSchema.optional(),
-  strategist: AgentConfigSchema.optional(),
-  critic: AgentConfigSchema.optional(),
-  coder: AgentConfigSchema.optional(),
-  designer: AgentConfigSchema.optional(),
-  sub: AgentConfigSchema.optional(),
-  researcher: AgentConfigSchema.optional(),
-  multimodal: AgentConfigSchema.optional(),
-  "quality-guardian": AgentConfigSchema.optional(),
-  "platform-manager": AgentConfigSchema.optional(),
-  brainstormer: AgentConfigSchema.optional(),
-  "agent-skills": AgentConfigSchema.optional(),
-  // Legacy aliases kept for config compatibility only
-  general: AgentConfigSchema.optional(),
-  zoe: AgentConfigSchema.optional(),
-  build: AgentConfigSchema.optional(),
-  "pre-plan": AgentConfigSchema.optional(),
-  manager: AgentConfigSchema.optional(),
-  vision: AgentConfigSchema.optional(),
-  logician: AgentConfigSchema.optional(),
-  librarian: AgentConfigSchema.optional(),
-  explore: AgentConfigSchema.optional(),
-  ui: AgentConfigSchema.optional(),
-  "code-reviewer": AgentConfigSchema.optional(),
-  "systematic-debugger": AgentConfigSchema.optional(),
-  mindmodel: AgentConfigSchema.optional(),
-  "ledger-creator": AgentConfigSchema.optional(),
-  bootstrapper: AgentConfigSchema.optional(),
-  "project-initializer": AgentConfigSchema.optional(),
-}).catchall(AgentConfigSchema);
-
-const AgentRequirementsConfigSchema = z.object({
-  // Canonical 12 agents
-  bob: ModelRequirementSchema.optional(),
-  guard: ModelRequirementSchema.optional(),
-  strategist: ModelRequirementSchema.optional(),
-  critic: ModelRequirementSchema.optional(),
-  coder: ModelRequirementSchema.optional(),
-  designer: ModelRequirementSchema.optional(),
-  sub: ModelRequirementSchema.optional(),
-  researcher: ModelRequirementSchema.optional(),
-  multimodal: ModelRequirementSchema.optional(),
-  "quality-guardian": ModelRequirementSchema.optional(),
-  "platform-manager": ModelRequirementSchema.optional(),
-  brainstormer: ModelRequirementSchema.optional(),
-  "agent-skills": ModelRequirementSchema.optional(),
-  // Legacy aliases kept for config compatibility only
-  general: ModelRequirementSchema.optional(),
-  zoe: ModelRequirementSchema.optional(),
-  build: ModelRequirementSchema.optional(),
-  "pre-plan": ModelRequirementSchema.optional(),
-  manager: ModelRequirementSchema.optional(),
-  vision: ModelRequirementSchema.optional(),
-  logician: ModelRequirementSchema.optional(),
-  librarian: ModelRequirementSchema.optional(),
-  explore: ModelRequirementSchema.optional(),
-  ui: ModelRequirementSchema.optional(),
-  "code-reviewer": ModelRequirementSchema.optional(),
-  "systematic-debugger": ModelRequirementSchema.optional(),
-  mindmodel: ModelRequirementSchema.optional(),
-  "ledger-creator": ModelRequirementSchema.optional(),
-  bootstrapper: ModelRequirementSchema.optional(),
-  "project-initializer": ModelRequirementSchema.optional(),
-}).catchall(ModelRequirementSchema);
-
-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(),
-  categoryRequirements: z.record(z.string(), ModelRequirementSchema).optional(),
-  modelFamilies: z.array(ModelFamilySchema).optional(),
-  mcp: z.record(z.string(), McpServerConfigSchema).optional(),
-  lsp: z.record(z.string(), LspServerConfigSchema).optional(),
-  subtask2: Subtask2ConfigSchema.optional(),
-  skills: SkillsConfigSchema.optional(),
-  skill_discovery: SkillDiscoveryConfigSchema.optional(),
-  permissions: PermissionsConfigSchema.optional(),
-  auth: AuthKeysSchema.optional(),
-  ollama: OllamaConfigSchema.optional(),
-});
-
-export type HiaiOpencodeConfigValidated = z.infer<typeof HiaiOpencodeConfigSchema>;

package/src/config/schema/agent-definitions.ts

@@ -1,5 +0,0 @@
-import { z } from "zod"
-
-export const AgentDefinitionPathSchema = z.string().min(1)
-
-export const AgentDefinitionsConfigSchema = z.array(AgentDefinitionPathSchema).optional()

package/src/config/schema/agent-names.ts

@@ -1,66 +0,0 @@
-import { z } from "zod"
-
-export const BuiltinAgentNameSchema = z.enum([
-  "bob",
-  "guard",
-  "strategist",
-  "critic",
-  "coder",
-  "designer",
-  "sub",
-  "researcher",
-  "multimodal",
-  "quality-guardian",
-  "platform-manager",
-  "brainstormer",
-  "agent-skills",
-])
-
-export const BuiltinSkillNameSchema = z.enum([
-  "playwright",
-  "agent-browser",
-  "dev-browser",
-  "frontend-ui-ux",
-  "git-master",
-  "review-work",
-  "ai-slop-remover",
-])
-
-export const OverridableAgentNameSchema = z.enum([
-  // Canonical 12 agents
-  "bob",
-  "guard",
-  "strategist",
-  "critic",
-  "coder",
-  "designer",
-  "sub",
-  "researcher",
-  "multimodal",
-  "quality-guardian",
-  "platform-manager",
-  "brainstormer",
-  "agent-skills",
-  // Compatibility aliases
-  "build",
-  "plan",
-  "OpenCode-Builder",
-  "pre-plan",
-  "general",
-  "zoe",
-  "logician",
-  "librarian",
-  "explore",
-  "ui",
-  "code-reviewer",
-  "systematic-debugger",
-  "mindmodel",
-  "ledger-creator",
-  "bootstrapper",
-  "project-initializer",
-])
-
-export const AgentNameSchema = BuiltinAgentNameSchema
-export type AgentName = z.infer<typeof AgentNameSchema>
-
-export type BuiltinSkillName = z.infer<typeof BuiltinSkillNameSchema>

package/src/config/schema/agent-overrides.ts

@@ -1,97 +0,0 @@
-import { z } from "zod"
-import { FallbackModelsSchema } from "./fallback-models"
-import { AgentPermissionSchema } from "./internal/permission"
-
-export const AgentOverrideConfigSchema = z.object({
-  /** @deprecated Use `category` instead. Model is inherited from category defaults. */
-  model: z.string().optional(),
-  fallback_models: FallbackModelsSchema.optional(),
-  variant: z.string().optional(),
-  /** Category name to inherit model and other settings from CategoryConfig */
-  category: z.string().optional(),
-  /** Skill names to inject into agent prompt */
-  skills: z.array(z.string()).optional(),
-  temperature: z.number().min(0).max(2).optional(),
-  top_p: z.number().min(0).max(1).optional(),
-  prompt: z.string().optional(),
-  /** Text to append to agent prompt. Supports file:// URIs (file:///abs, file://./rel, file://~/home) */
-  prompt_append: z.string().optional(),
-  tools: z.record(z.string(), z.boolean()).optional(),
-  disable: z.boolean().optional(),
-  description: z.string().optional(),
-  mode: z.enum(["subagent", "primary", "all"]).optional(),
-  color: z
-    .string()
-    .regex(/^#[0-9A-Fa-f]{6}$/)
-    .optional(),
-  permission: AgentPermissionSchema.optional(),
-  /** Maximum tokens for response. Passed directly to OpenCode SDK. */
-  maxTokens: z.number().optional(),
-  /** Extended thinking configuration (Anthropic). Overrides category and default settings. */
-  thinking: z
-    .object({
-      type: z.enum(["enabled", "disabled"]),
-      budgetTokens: z.number().optional(),
-    })
-    .optional(),
-  /** Reasoning effort level (OpenAI). Overrides category and default settings. */
-  reasoningEffort: z.enum(["none", "minimal", "low", "medium", "high", "xhigh"]).optional(),
-  /** Text verbosity level. */
-  textVerbosity: z.enum(["low", "medium", "high"]).optional(),
-  /** Provider-specific options. Passed directly to OpenCode SDK. */
-  providerOptions: z.record(z.string(), z.unknown()).optional(),
-  /** Per-message ultrawork override model/variant when ultrawork keyword is detected. */
-  ultrawork: z
-    .object({
-      model: z.string().optional(),
-      variant: z.string().optional(),
-    })
-    .optional(),
-  compaction: z
-    .object({
-      model: z.string().optional(),
-      variant: z.string().optional(),
-    })
-    .optional(),
-})
-
-export const AgentOverridesSchema = z.object({
-  // Canonical 12 agents
-  "bob": AgentOverrideConfigSchema.optional(),
-  "guard": AgentOverrideConfigSchema.optional(),
-  "strategist": AgentOverrideConfigSchema.optional(),
-  "critic": AgentOverrideConfigSchema.optional(),
-  "coder": AgentOverrideConfigSchema.extend({
-    allow_non_gpt_model: z.boolean().optional(),
-  }).optional(),
-  "designer": AgentOverrideConfigSchema.optional(),
-  "sub": AgentOverrideConfigSchema.optional(),
-  researcher: AgentOverrideConfigSchema.optional(),
-  "multimodal": AgentOverrideConfigSchema.optional(),
-  "quality-guardian": AgentOverrideConfigSchema.optional(),
-  "platform-manager": AgentOverrideConfigSchema.optional(),
-  brainstormer: AgentOverrideConfigSchema.optional(),
-  "agent-skills": AgentOverrideConfigSchema.optional(),
-  // Compatibility aliases
-  build: AgentOverrideConfigSchema.optional(),
-  plan: AgentOverrideConfigSchema.optional(),
-  "OpenCode-Builder": AgentOverrideConfigSchema.optional(),
-  general: AgentOverrideConfigSchema.optional(),
-  zoe: AgentOverrideConfigSchema.optional(),
-  "pre-plan": AgentOverrideConfigSchema.optional(),
-  manager: AgentOverrideConfigSchema.optional(),
-  vision: AgentOverrideConfigSchema.optional(),
-  "logician": AgentOverrideConfigSchema.optional(),
-  librarian: AgentOverrideConfigSchema.optional(),
-  explore: AgentOverrideConfigSchema.optional(),
-  ui: AgentOverrideConfigSchema.optional(),
-  "code-reviewer": AgentOverrideConfigSchema.optional(),
-  "systematic-debugger": AgentOverrideConfigSchema.optional(),
-  mindmodel: AgentOverrideConfigSchema.optional(),
-  "ledger-creator": AgentOverrideConfigSchema.optional(),
-  bootstrapper: AgentOverrideConfigSchema.optional(),
-  "project-initializer": AgentOverrideConfigSchema.optional(),
-})
-
-export type AgentOverrideConfig = z.infer<typeof AgentOverrideConfigSchema>
-export type AgentOverrides = z.infer<typeof AgentOverridesSchema>

package/src/config/schema/babysitting.ts

@@ -1,7 +0,0 @@
-import { z } from "zod"
-
-export const BabysittingConfigSchema = z.object({
-  timeout_ms: z.number().default(120000),
-})
-
-export type BabysittingConfig = z.infer<typeof BabysittingConfigSchema>

package/src/config/schema/background-task.ts

@@ -1,29 +0,0 @@
-import { z } from "zod"
-
-const CircuitBreakerConfigSchema = z.object({
-  enabled: z.boolean().optional(),
-  maxToolCalls: z.number().int().min(10).optional(),
-  consecutiveThreshold: z.number().int().min(5).optional(),
-})
-
-export const BackgroundTaskConfigSchema = z.object({
-  defaultConcurrency: z.number().min(1).optional(),
-  providerConcurrency: z.record(z.string(), z.number().min(0)).optional(),
-  modelConcurrency: z.record(z.string(), z.number().min(0)).optional(),
-  maxDepth: z.number().int().min(1).optional(),
-  maxDescendants: z.number().int().min(1).optional(),
-  /** Stale timeout in milliseconds - interrupt tasks with no activity for this duration (default: 180000 = 3 minutes, minimum: 60000 = 1 minute) */
-  staleTimeoutMs: z.number().min(60000).optional(),
-  /** Timeout for tasks that never received any progress update, falling back to startedAt (default: 1800000 = 30 minutes, minimum: 60000 = 1 minute) */
-  messageStalenessTimeoutMs: z.number().min(60000).optional(),
-  /** Absolute TTL for non-terminal tasks in milliseconds (default: 1800000 = 30 minutes, minimum: 300000 = 5 minutes). Tasks exceeding this age from their last activity (or startedAt if no progress) are pruned. */
-  taskTtlMs: z.number().min(300000).optional(),
-  /** Timeout for tasks whose session has completely disappeared from the status registry (default: 60000 = 1 minute, minimum: 10000 = 10 seconds). When a session is gone (likely crashed), this shorter timeout is used instead of the normal stale timeout. */
-  sessionGoneTimeoutMs: z.number().min(10000).optional(),
-  syncPollTimeoutMs: z.number().min(60000).optional(),
-  /** Maximum tool calls per subagent task before circuit breaker triggers (default: 200, minimum: 10). Prevents runaway loops from burning unlimited tokens. */
-  maxToolCalls: z.number().int().min(10).optional(),
-  circuitBreaker: CircuitBreakerConfigSchema.optional(),
-})
-
-export type BackgroundTaskConfig = z.infer<typeof BackgroundTaskConfigSchema>

package/src/config/schema/bob-agent.ts

@@ -1,11 +0,0 @@
-import { z } from "zod"
-
-export const BobAgentConfigSchema = z.object({
-  disabled: z.boolean().optional(),
-  default_builder_enabled: z.boolean().optional(),
-  planner_enabled: z.boolean().optional(),
-  replace_plan: z.boolean().optional(),
-  tdd: z.boolean().default(true).optional(),
-})
-
-export type BobAgentConfig = z.infer<typeof BobAgentConfigSchema>

package/src/config/schema/bob.ts

@@ -1,17 +0,0 @@
-import { z } from "zod"
-
-export const BobTasksConfigSchema = z.object({
-  /** Absolute or relative storage path override. When set, bypasses global config dir. */
-  storage_path: z.string().optional(),
-  /** Force task list ID (alternative to env ULTRAWORK_TASK_LIST_ID) */
-  task_list_id: z.string().optional(),
-  /** Enable Claude Code path compatibility mode */
-  claude_code_compat: z.boolean().default(false),
-})
-
-export const BobConfigSchema = z.object({
-  tasks: BobTasksConfigSchema.optional(),
-})
-
-export type BobTasksConfig = z.infer<typeof BobTasksConfigSchema>
-export type BobConfig = z.infer<typeof BobConfigSchema>

package/src/config/schema/browser-automation.ts

@@ -1,24 +0,0 @@
-import { z } from "zod"
-
-export const BrowserAutomationProviderSchema = z.enum([
-  "playwright",
-  "agent-browser",
-  "dev-browser",
-  "playwright-cli",
-])
-
-export const BrowserAutomationConfigSchema = z.object({
-  /**
-   * Browser automation provider to use for the "playwright" skill.
-   * - "playwright": Uses Playwright MCP server (@playwright/mcp) - default
-   * - "agent-browser": Uses Vercel's agent-browser CLI (requires: bun add -g agent-browser)
-   * - "dev-browser": Uses dev-browser skill with persistent browser state
-   * - "playwright-cli": Uses Playwright CLI (@playwright/cli) - token-efficient CLI alternative
-   */
-  provider: BrowserAutomationProviderSchema.default("playwright"),
-})
-
-export type BrowserAutomationProvider = z.infer<
-  typeof BrowserAutomationProviderSchema
->
-export type BrowserAutomationConfig = z.infer<typeof BrowserAutomationConfigSchema>

package/src/config/schema/categories.ts

@@ -1,45 +0,0 @@
-import { z } from "zod"
-import { FallbackModelsSchema } from "./fallback-models"
-
-export const CategoryConfigSchema = z.object({
-  /** Human-readable description of the category's purpose. Shown in task prompt. */
-  description: z.string().optional(),
-  model: z.string().optional(),
-  fallback_models: FallbackModelsSchema.optional(),
-  variant: z.string().optional(),
-  temperature: z.number().min(0).max(2).optional(),
-  top_p: z.number().min(0).max(1).optional(),
-  maxTokens: z.number().optional(),
-  thinking: z
-    .object({
-      type: z.enum(["enabled", "disabled"]),
-      budgetTokens: z.number().optional(),
-    })
-    .optional(),
-  reasoningEffort: z.enum(["none", "minimal", "low", "medium", "high", "xhigh"]).optional(),
-  textVerbosity: z.enum(["low", "medium", "high"]).optional(),
-  tools: z.record(z.string(), z.boolean()).optional(),
-  prompt_append: z.string().optional(),
-  max_prompt_tokens: z.number().int().positive().optional(),
-  /** Mark agent as unstable - forces background mode for monitoring. Auto-enabled for gemini/minimax models. */
-  is_unstable_agent: z.boolean().optional(),
-  /** Disable this category. Disabled categories are excluded from task delegation. */
-  disable: z.boolean().optional(),
-})
-
-export const BuiltinCategoryNameSchema = z.enum([
-  "visual-engineering",
-  "ultrabrain",
-  "deep",
-  "artistry",
-  "quick",
-  "unspecified-low",
-  "unspecified-high",
-  "writing",
-])
-
-export const CategoriesConfigSchema = z.record(z.string(), CategoryConfigSchema)
-
-export type CategoryConfig = z.infer<typeof CategoryConfigSchema>
-export type CategoriesConfig = z.infer<typeof CategoriesConfigSchema>
-export type BuiltinCategoryName = z.infer<typeof BuiltinCategoryNameSchema>

package/src/config/schema/claude-code.ts

@@ -1,13 +0,0 @@
-import { z } from "zod"
-
-export const ClaudeCodeConfigSchema = z.object({
-  mcp: z.boolean().optional(),
-  commands: z.boolean().optional(),
-  skills: z.boolean().optional(),
-  agents: z.boolean().optional(),
-  hooks: z.boolean().optional(),
-  plugins: z.boolean().optional(),
-  plugins_override: z.record(z.string(), z.boolean()).optional(),
-})
-
-export type ClaudeCodeConfig = z.infer<typeof ClaudeCodeConfigSchema>

package/src/config/schema/commands.ts

@@ -1,16 +0,0 @@
-import { z } from "zod"
-
-export const BuiltinCommandNameSchema = z.enum([
-  "init-deep",
-  "ralph-loop",
-  "ulw-loop",
-  "cancel-ralph",
-  "refactor",
-  "start-work",
-  "stop-continuation",
-  "remove-ai-slops",
-  "mcp-status",
-  "doctor",
-])
-
-export type BuiltinCommandName = z.infer<typeof BuiltinCommandNameSchema>

package/src/config/schema/comment-checker.ts

@@ -1,8 +0,0 @@
-import { z } from "zod"
-
-export const CommentCheckerConfigSchema = z.object({
-  /** Custom prompt to replace the default warning message. Use {{comments}} placeholder for detected comments XML. */
-  custom_prompt: z.string().optional(),
-})
-
-export type CommentCheckerConfig = z.infer<typeof CommentCheckerConfigSchema>

package/src/config/schema/dynamic-context-pruning.ts

@@ -1,53 +0,0 @@
-import { z } from "zod"
-
-export const DynamicContextPruningConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  notification: z.enum(["off", "minimal", "detailed"]).default("detailed"),
-  /** Turn protection - prevent pruning recent tool outputs */
-  turn_protection: z
-    .object({
-      enabled: z.boolean().default(true),
-      turns: z.number().min(1).max(10).default(3),
-    })
-    .optional(),
-  /** Tools that should never be pruned */
-  protected_tools: z.array(z.string()).default([
-    "task",
-    "todowrite",
-    "todoread",
-    "lsp_rename",
-    "session_read",
-    "session_write",
-    "session_search",
-  ]),
-  /** Pruning strategies configuration */
-  strategies: z
-    .object({
-      /** Remove duplicate tool calls (same tool + same args) */
-      deduplication: z
-        .object({
-          enabled: z.boolean().default(true),
-        })
-        .optional(),
-      /** Prune write inputs when file subsequently read */
-      supersede_writes: z
-        .object({
-          enabled: z.boolean().default(true),
-          /** Aggressive mode: prune any write if ANY subsequent read */
-          aggressive: z.boolean().default(false),
-        })
-        .optional(),
-      /** Prune errored tool inputs after N turns */
-      purge_errors: z
-        .object({
-          enabled: z.boolean().default(true),
-          turns: z.number().min(1).max(20).default(5),
-        })
-        .optional(),
-    })
-    .optional(),
-})
-
-export type DynamicContextPruningConfig = z.infer<
-  typeof DynamicContextPruningConfigSchema
->

package/src/config/schema/experimental.ts

@@ -1,27 +0,0 @@
-import { z } from "zod"
-import { DynamicContextPruningConfigSchema } from "./dynamic-context-pruning"
-
-export const ExperimentalConfigSchema = z.object({
-  aggressive_truncation: z.boolean().optional(),
-  auto_resume: z.boolean().optional(),
-  preemptive_compaction: z.boolean().optional(),
-  truncate_all_tool_outputs: z.boolean().optional(),
-  /** Dynamic context pruning configuration */
-  dynamic_context_pruning: DynamicContextPruningConfigSchema.optional(),
-  /** Enable experimental task system for Todowrite disabler hook */
-  task_system: z.boolean().optional(),
-  /** Timeout in ms for loadAllPluginComponents during config handler init (default: 10000, min: 1000) */
-  plugin_load_timeout_ms: z.number().min(1000).optional(),
-  /** Wrap hook creation in try/catch to prevent one failing hook from crashing the plugin (default: true at call site) */
-  safe_hook_creation: z.boolean().optional(),
-  /** Disable auto-injected <omo-env> context in prompts (experimental) */
-  disable_omo_env: z.boolean().optional(),
-  /** Enable hashline_edit tool for improved file editing with hash-based line anchors */
-  hashline_edit: z.boolean().optional(),
-  /** Append fallback model info to session title when a runtime fallback occurs (default: false) */
-  model_fallback_title: z.boolean().optional(),
-  /** Maximum number of tools to register. When set, lower-priority tools are excluded to stay within provider limits (e.g., OpenAI's 128-tool cap). Accounts for ~20 OpenCode built-in tools. */
-  max_tools: z.number().int().min(1).optional(),
-})
-
-export type ExperimentalConfig = z.infer<typeof ExperimentalConfigSchema>