@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

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

@@ -1,310 +0,0 @@
-import type { ModelFallbackInfo } from "../../features/task-toast-manager/types"
-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"
-import { normalizeFallbackModels, flattenToFallbackModelStrings } from "../../shared/model-resolver"
-import { buildFallbackChainFromModels, findMostSpecificFallbackEntry } from "../../shared/fallback-chain-from-models"
-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 type { CategoryConfig } from "../../config/schema"
-import type { DelegatedModelConfig } from "./types"
-
-function applyCategoryParams(base: DelegatedModelConfig, config: CategoryConfig): DelegatedModelConfig {
-  const result = { ...base }
-  if (config.temperature !== undefined) result.temperature = config.temperature
-  if (config.top_p !== undefined) result.top_p = config.top_p
-  if (config.maxTokens !== undefined) result.maxTokens = config.maxTokens
-  if (config.reasoningEffort !== undefined) result.reasoningEffort = config.reasoningEffort
-  if (config.thinking !== undefined) result.thinking = config.thinking
-  return result
-}
-
-export interface CategoryResolutionResult {
-  agentToUse: string
-  categoryModel: DelegatedModelConfig | undefined
-  categoryPromptAppend: string | undefined
-  maxPromptTokens?: number
-  modelInfo: ModelFallbackInfo | undefined
-  actualModel: string | undefined
-  isUnstableAgent: boolean
-  fallbackChain?: FallbackEntry[]  // For runtime retry on model errors
-  error?: string
-}
-
-function resolveCategoryExecutorAgentKey(
-  _categoryName: string,
-  config: CategoryConfig,
-): typeof CODER_AGENT_CONFIG_KEY {
-  void config
-  return CODER_AGENT_CONFIG_KEY
-}
-
-export async function resolveCategoryExecution(
-  args: DelegateTaskArgs,
-  executorCtx: ExecutorContext,
-  inheritedModel: string | undefined,
-  systemDefaultModel: string | undefined
-): Promise<CategoryResolutionResult> {
-  const { client, userCategories, agentOverrides } = executorCtx
-
-  const categoryName = args.category!
-  const enabledCategories = mergeCategories(userCategories)
-  const categoryExists = enabledCategories[categoryName] !== undefined
-
-  if (!categoryExists) {
-    const allCategoryNames = Object.keys(enabledCategories).join(", ")
-    return {
-      agentToUse: "",
-      categoryModel: undefined,
-      categoryPromptAppend: undefined,
-      maxPromptTokens: undefined,
-      modelInfo: undefined,
-      actualModel: undefined,
-      isUnstableAgent: false,
-      error: `Unknown category: "${categoryName}". Available: ${allCategoryNames}`,
-    }
-  }
-
-  const availableModels = await getAvailableModelsForDelegateTask(client)
-
-  const resolved = resolveCategoryConfig(categoryName, {
-    userCategories,
-    inheritedModel,
-    systemDefaultModel,
-    availableModels,
-  })
-
-  if (!resolved) {
-    const requirement = CATEGORY_MODEL_REQUIREMENTS[categoryName]
-    const allCategoryNames = Object.keys(enabledCategories).join(", ")
-
-    if (categoryExists && requirement?.requiresModel) {
-      return {
-        agentToUse: "",
-        categoryModel: undefined,
-        categoryPromptAppend: undefined,
-        maxPromptTokens: undefined,
-        modelInfo: undefined,
-        actualModel: undefined,
-        isUnstableAgent: false,
-        error: `Category "${categoryName}" requires model "${requirement.requiresModel}" which is not available.
-
-To use this category:
-1. Connect a provider with this model: ${requirement.requiresModel}
-2. Or configure an alternative model in your ${CONFIG_BASENAME}.json for this category
-
-Available categories: ${allCategoryNames}`,
-      }
-    }
-
-    return {
-      agentToUse: "",
-      categoryModel: undefined,
-      categoryPromptAppend: undefined,
-      maxPromptTokens: undefined,
-      modelInfo: undefined,
-      actualModel: undefined,
-      isUnstableAgent: false,
-      error: `Unknown category: "${categoryName}". Available: ${allCategoryNames}`,
-    }
-  }
-
-  const categoryExecutorAgentKey = resolveCategoryExecutorAgentKey(categoryName, resolved.config)
-  const categoryExecutorAgentName = getAgentDisplayName(CODER_AGENT_CONFIG_KEY)
-  const categoryExecutorOverride = agentOverrides?.[categoryExecutorAgentKey as keyof typeof agentOverrides]
-    ?? (agentOverrides
-      ? Object.entries(agentOverrides).find(([key]) => key.toLowerCase() === categoryExecutorAgentKey)?.[1]
-      : undefined)
-
-  const requirement = CATEGORY_MODEL_REQUIREMENTS[args.category!]
-  const normalizedConfiguredFallbackModels = normalizeFallbackModels(
-    categoryExecutorOverride?.fallback_models ?? resolved.config.fallback_models
-  )
-  let actualModel: string | undefined
-  let modelInfo: ModelFallbackInfo | undefined
-  let categoryModel: DelegatedModelConfig | undefined
-  let isModelResolutionSkipped = false
-  let fallbackEntry: FallbackEntry | undefined
-  let matchedFallback = false
-
-  const overrideModel = categoryExecutorOverride?.model
-  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.
-    actualModel = explicitCategoryModel ?? overrideModel ?? resolved.model
-    if (actualModel) {
-      modelInfo = explicitCategoryModel || overrideModel
-        ? { model: actualModel, type: "user-defined", source: "override" }
-        : { model: actualModel, type: "system-default", source: "system-default" }
-      const parsedModel = parseModelString(actualModel)
-      const variantToUse = userCategories?.[args.category!]?.variant
-        ?? categoryExecutorOverride?.variant
-        ?? resolved.config.variant
-      categoryModel = parsedModel
-        ? applyCategoryParams({ ...parsedModel, variant: variantToUse ?? parsedModel.variant }, resolved.config)
-        : undefined
-    }
-  } else {
-    const resolution = resolveModelForDelegateTask({
-      userModel: explicitCategoryModel ?? overrideModel,
-      userFallbackModels: flattenToFallbackModelStrings(normalizedConfiguredFallbackModels),
-      categoryDefaultModel: resolved.model,
-      isUserConfiguredCategoryModel: resolved.isUserConfiguredModel,
-      fallbackChain: requirement.fallbackChain,
-      availableModels,
-      systemDefaultModel,
-    })
-
-    if (resolution && "skipped" in resolution) {
-      isModelResolutionSkipped = true
-      const userModelOverride = explicitCategoryModel ?? overrideModel
-      if (userModelOverride) {
-        actualModel = userModelOverride
-        const parsedModel = parseModelString(userModelOverride)
-        const variantToUse = userCategories?.[args.category!]?.variant
-          ?? categoryExecutorOverride?.variant
-          ?? resolved.config.variant
-        categoryModel = parsedModel
-          ? applyCategoryParams({ ...parsedModel, variant: variantToUse ?? parsedModel.variant }, resolved.config)
-          : undefined
-        modelInfo = { model: userModelOverride, type: "user-defined", source: "override" }
-      }
-    } else if (resolution) {
-      const {
-        model: resolvedModel,
-        variant: resolvedVariant,
-        fallbackEntry: resolvedFallbackEntry,
-        matchedFallback: resolvedMatchedFallback,
-      } = resolution
-      fallbackEntry = resolvedFallbackEntry
-      matchedFallback = resolvedMatchedFallback === true
-      actualModel = resolvedModel
-
-      if (!parseModelString(actualModel)) {
-        return {
-          agentToUse: "",
-          categoryModel: undefined,
-          categoryPromptAppend: undefined,
-          maxPromptTokens: undefined,
-          modelInfo: undefined,
-          actualModel: undefined,
-          isUnstableAgent: false,
-          error: `Invalid model format "${actualModel}". Expected "provider/model" format (e.g., "anthropic/claude-3-5-sonnet-latest").`,
-        }
-      }
-
-      const type: "user-defined" | "inherited" | "category-default" | "system-default" =
-        (explicitCategoryModel || overrideModel)
-          ? "user-defined"
-          : (systemDefaultModel && actualModel === systemDefaultModel)
-              ? "system-default"
-              : "category-default"
-
-      const source: "override" | "category-default" | "system-default" =
-        type === "user-defined"
-          ? "override"
-          : type === "system-default"
-              ? "system-default"
-              : "category-default"
-
-      modelInfo = { model: actualModel, type, source }
-
-      const parsedModel = parseModelString(actualModel)
-      const variantToUse = userCategories?.[args.category!]?.variant
-        ?? categoryExecutorOverride?.variant
-        ?? resolvedVariant
-        ?? resolved.config.variant
-      categoryModel = parsedModel
-        ? applyCategoryParams({ ...parsedModel, variant: variantToUse ?? parsedModel.variant }, resolved.config)
-        : undefined
-    }
-  }
-
-  if (!categoryModel && actualModel) {
-    const parsedModel = parseModelString(actualModel)
-    categoryModel = parsedModel ?? undefined
-  }
-  const categoryPromptAppend = resolved.promptAppend || undefined
-
-  if (!categoryModel && !actualModel && !isModelResolutionSkipped) {
-    const categoryNames = Object.keys(enabledCategories)
-    return {
-      agentToUse: "",
-      categoryModel: undefined,
-      categoryPromptAppend: undefined,
-      maxPromptTokens: undefined,
-      modelInfo: undefined,
-      actualModel: undefined,
-      isUnstableAgent: false,
-      error: `Model not configured for category "${args.category}".
-
-Configure in one of:
-1. OpenCode: Set "model" in opencode.json
-2. Oh-My-OpenCode: Set category model in ${CONFIG_BASENAME}.json
-3. Provider: Connect a provider with available models
-
-Current category: ${args.category}
-Available categories: ${categoryNames.join(", ")}`,
-    }
-  }
-
-  const resolvedModel = actualModel?.toLowerCase()
-  const isUnstableAgent = resolved.config.is_unstable_agent ?? (resolvedModel ? resolvedModel.includes("gemini") || resolvedModel.includes("minimax") : false)
-
-  const defaultProviderID = categoryModel?.providerID
-    ?? parseModelString(actualModel ?? "")?.providerID
-    ?? "opencode"
-  const configuredFallbackChain = buildFallbackChainFromModels(
-    normalizedConfiguredFallbackModels,
-    defaultProviderID,
-  )
-
-  // Only promote fallback-only settings when resolution actually selected a fallback model.
-  const effectiveEntry = matchedFallback && categoryModel
-    ? (
-        fallbackEntry
-        ?? (configuredFallbackChain
-          ? findMostSpecificFallbackEntry(categoryModel.providerID, categoryModel.modelID, configuredFallbackChain)
-          : undefined)
-      )
-    : undefined
-
-  if (categoryModel && effectiveEntry) {
-    categoryModel = {
-      ...categoryModel,
-      variant: userCategories?.[args.category!]?.variant
-        ?? categoryExecutorOverride?.variant
-        ?? effectiveEntry.variant
-        ?? categoryModel.variant,
-      reasoningEffort: effectiveEntry.reasoningEffort ?? categoryModel.reasoningEffort,
-      temperature: effectiveEntry.temperature ?? categoryModel.temperature,
-      top_p: effectiveEntry.top_p ?? categoryModel.top_p,
-      maxTokens: effectiveEntry.maxTokens ?? categoryModel.maxTokens,
-      thinking: effectiveEntry.thinking ?? categoryModel.thinking,
-    }
-  }
-
-  return {
-    agentToUse: categoryExecutorAgentName,
-    categoryModel,
-    categoryPromptAppend,
-    maxPromptTokens: resolved.config.max_prompt_tokens,
-    modelInfo,
-    actualModel,
-    isUnstableAgent,
-    // Don't use hardcoded fallback chain when resolution was skipped (cold cache)
-    fallbackChain: configuredFallbackChain ?? ((isModelResolutionSkipped || explicitCategoryModel || overrideModel) ? undefined : requirement?.fallbackChain),
-  }
-}

package/src/tools/delegate-task/constants.ts

@@ -1,351 +0,0 @@
-import type {
-   AvailableCategory,
-   AvailableSkill,
- } from "../../agents/dynamic-agent-prompt-builder"
-import { getAgentConfigKey } from "../../shared/agent-display-names"
-import { truncateDescription } from "../../shared/truncate-description"
-export {
-  CATEGORY_DESCRIPTIONS,
-  CATEGORY_PROMPT_APPENDS,
-  DEFAULT_CATEGORIES,
-} from "./builtin-categories"
-
-/**
- * System prompt prepended to plan agent invocations.
- * Instructs the plan agent to first gather context via researcher agents,
- * then summarize user requirements and clarify uncertainties before proceeding.
- * Also MANDATES dependency graphs, parallel execution analysis, and category+skill recommendations.
- */
-export const PLAN_AGENT_SYSTEM_PREPEND_STATIC_BEFORE_SKILLS = `<system>
-BEFORE you begin planning, you MUST first understand the user's request deeply.
-
-MANDATORY CONTEXT GATHERING PROTOCOL:
-1. Launch background agents to gather context:
-   - call_omo_agent(description="Explore codebase patterns", subagent_type="researcher", run_in_background=true, prompt="<search for relevant patterns, files, and implementations in the codebase related to user's request>")
-   - call_omo_agent(description="Research documentation", subagent_type="researcher", run_in_background=true, prompt="<search for external documentation, examples, and best practices related to user's request>")
-
-2. After gathering context, ALWAYS present:
-   - **User Request Summary**: Concise restatement of what the user is asking for
-   - **Uncertainties**: List of unclear points, ambiguities, or assumptions you're making
-   - **Clarifying Questions**: Specific questions to resolve the uncertainties
-
-3. ITERATE until ALL requirements are crystal clear:
-   - Do NOT proceed to planning until you have 100% clarity
-   - Ask the user to confirm your understanding
-   - Resolve every ambiguity before generating the work plan
-
-REMEMBER: Vague requirements lead to failed implementations. Take the time to understand thoroughly.
-</system>
-
-<CRITICAL_REQUIREMENT_DEPENDENCY_PARALLEL_EXECUTION_CATEGORY_SKILLS>
-#####################################################################
-#                                                                   #
-#   ██████╗ ███████╗ ██████╗ ██╗   ██╗██╗██████╗ ███████╗██████╗    #
-#   ██╔══██╗██╔════╝██╔═══██╗██║   ██║██║██╔══██╗██╔════╝██╔══██╗   #
-#   ██████╔╝█████╗  ██║   ██║██║   ██║██║██████╔╝█████╗  ██║  ██║   #
-#   ██╔══██╗██╔══╝  ██║▄▄ ██║██║   ██║██║██╔══██╗██╔══╝  ██║  ██║   #
-#   ██��  ██║███████╗╚██████╔╝╚██████╔╝██║██║  ██║███████╗██████╔╝   #
-#   ╚═╝  ╚═╝╚══════╝ ╚══▀▀═╝  ╚═════╝ ╚═╝╚═╝  ╚═╝╚══════╝╚═════╝    #
-#                                                                   #
-#####################################################################
-
-YOU MUST INCLUDE THE FOLLOWING SECTIONS IN YOUR PLAN OUTPUT.
-THIS IS NON-NEGOTIABLE. FAILURE TO INCLUDE THESE SECTIONS = INCOMPLETE PLAN.
-
-═══════════════════════════════════════════════════════════════════
-█ SECTION 1: TASK DEPENDENCY GRAPH (MANDATORY)                    █
-═══════════════════════════════════════════════════════════════════
-
-YOU MUST ANALYZE AND DOCUMENT TASK DEPENDENCIES.
-
-For EVERY task in your plan, you MUST specify:
-- Which tasks it DEPENDS ON (blockers)
-- Which tasks DEPEND ON IT (dependents)
-- The REASON for each dependency
-
-Example format:
-\`\`\`
-## Task Dependency Graph
-
-| Task | Depends On | Reason |
-|------|------------|--------|
-| Task 1 | None | Starting point, no prerequisites |
-| Task 2 | Task 1 | Requires output/artifact from Task 1 |
-| Task 3 | Task 1 | Uses same foundation established in Task 1 |
-| Task 4 | Task 2, Task 3 | Integrates results from both tasks |
-\`\`\`
-
-WHY THIS MATTERS:
-- Executors need to know execution ORDER
-- Prevents blocked work from starting prematurely
-- Identifies critical path for project timeline
-
-
-═══════════════════════════════════════════════════════════════════
-█ SECTION 2: PARALLEL EXECUTION GRAPH (MANDATORY)                 █
-═══════════════════════════════════════════════════════════════════
-
-YOU MUST IDENTIFY WHICH TASKS CAN RUN IN PARALLEL.
-
-Analyze your dependency graph and group tasks into PARALLEL EXECUTION WAVES:
-
-Example format:
-\`\`\`
-## Parallel Execution Graph
-
-Wave 1 (Start immediately):
-├── Task 1: [description] (no dependencies)
-└── Task 5: [description] (no dependencies)
-
-Wave 2 (After Wave 1 completes):
-├── Task 2: [description] (depends: Task 1)
-├── Task 3: [description] (depends: Task 1)
-└── Task 6: [description] (depends: Task 5)
-
-Wave 3 (After Wave 2 completes):
-└── Task 4: [description] (depends: Task 2, Task 3)
-
-Critical Path: Task 1 → Task 2 → Task 4
-Estimated Parallel Speedup: 40% faster than sequential
-\`\`\`
-
-WHY THIS MATTERS:
-- MASSIVE time savings through parallelization
-- Executors can dispatch multiple agents simultaneously
-- Identifies bottlenecks in the execution plan
-
-
-═══════════════════════════════════════════════════════════════════
-█ SECTION 3: CATEGORY + SKILLS RECOMMENDATIONS (MANDATORY)        █
-═══════════════════════════════════════════════════════════════════
-
-FOR EVERY TASK, YOU MUST RECOMMEND:
-1. Which CATEGORY to use for delegation
-2. Which SKILLS to load for the delegated agent
-3. Which EXECUTOR contour is expected from that category:
-   - quick/writing/unspecified-low -> coder (fast bounded execution)
-   - deep/ultrabrain/visual-engineering/artistry/unspecified-high -> coder (deep execution)
-   - use subagent_type="critic" explicitly for review-gate passes
-`
-
-export const PLAN_AGENT_SYSTEM_PREPEND_STATIC_AFTER_SKILLS = `### REQUIRED OUTPUT FORMAT
-
-For EACH task, include a recommendation block:
-
-\`\`\`
-### Task N: [Task Title]
-
-**Delegation Recommendation:**
-- Category: \`[category-name]\` - [reason for choice]
-- Skills: [\`skill-1\`, \`skill-2\`] - [reason each skill is needed]
-
-**Skills Evaluation:**
-- INCLUDED \`skill-name\`: [reason]
-- OMITTED \`other-skill\`: [reason domain doesn't overlap]
-\`\`\`
-
-WHY THIS MATTERS:
-- Category determines the MODEL used for execution
-- Skills inject SPECIALIZED KNOWLEDGE into the executor
-- Missing a relevant skill = suboptimal execution
-- Wrong category = wrong model = poor results
-
-
-═══════════════════════════════════════════════════════════════════
-█ RESPONSE FORMAT SPECIFICATION (MANDATORY)                       █
-═══════════════════════════════════════════════════════════════════
-
-YOUR PLAN OUTPUT MUST FOLLOW THIS EXACT STRUCTURE:
-
-\`\`\`markdown
-# [Plan Title]
-
-## Context
-[User request summary, interview findings, research results]
-
-## Task Dependency Graph
-[Dependency table - see Section 1]
-
-## Parallel Execution Graph  
-[Wave structure - see Section 2]
-
-## Tasks
-
-### Task 1: [Title]
-**Description**: [What to do]
-**Delegation Recommendation**:
-- Category: \`[category]\` - [reason]
-- Skills: [\`skill-1\`] - [reason]
-**Skills Evaluation**: [✅ included / ❌ omitted with reasons]
-**Depends On**: [Task IDs or "None"]
-**Acceptance Criteria**: [Verifiable conditions]
-
-### Task 2: [Title]
-[Same structure...]
-
-## Commit Strategy
-[How to commit changes atomically]
-
-## Success Criteria
-[Final verification steps]
-\`\`\`
-
-#####################################################################
-#                                                                   #
-#   FAILURE TO INCLUDE THESE SECTIONS = PLAN WILL BE REJECTED      #
-#   BY MOMUS REVIEW. DO NOT SKIP. DO NOT ABBREVIATE.               #
-#                                                                   #
-#####################################################################
-</CRITICAL_REQUIREMENT_DEPENDENCY_PARALLEL_EXECUTION_CATEGORY_SKILLS>
-
-<FINAL_OUTPUT_FOR_CALLER>
-═══════════════════════════════════════════════════════════════════
-█ SECTION 4: ACTIONABLE TODO LIST FOR CALLER (MANDATORY)          █
-═══════════════════════════════════════════════════════════════════
-
-YOU MUST END YOUR RESPONSE WITH THIS SECTION.
-
-\`\`\`markdown
-## TODO List (ADD THESE)
-
-> CALLER: Add these TODOs using TodoWrite/TaskCreate and execute by wave.
-
-### Wave 1 (Start Immediately - No Dependencies)
-
-- [ ] **1. [Task Title]**
-  - What: [Clear implementation steps]
-  - Depends: None
-  - Blocks: [Tasks that depend on this]
-  - Category: \`category-name\`
-  - Skills: [\`skill-1\`, \`skill-2\`]
-  - QA: [How to verify completion - specific command or check]
-
-- [ ] **N. [Task Title]**
-  - What: [Steps]
-  - Depends: None
-  - Blocks: [...]
-  - Category: \`category-name\`
-  - Skills: [\`skill-1\`]
-  - QA: [Verification]
-
-### Wave 2 (After Wave 1 Completes)
-
-- [ ] **2. [Task Title]**
-  - What: [Steps]
-  - Depends: 1
-  - Blocks: [4]
-  - Category: \`category-name\`
-  - Skills: [\`skill-1\`]
-  - QA: [Verification]
-
-[Continue for all waves...]
-
-## Execution Instructions
-
-1. **Wave 1**: Fire these tasks IN PARALLEL (no dependencies)
-   \`\`\`
-   task(category="...", load_skills=[...], run_in_background=false, prompt="Task 1: ...")
-   task(category="...", load_skills=[...], run_in_background=false, prompt="Task N: ...")
-   \`\`\`
-
-2. **Wave 2**: After Wave 1 completes, fire next wave IN PARALLEL
-   \`\`\`
-   task(category="...", load_skills=[...], run_in_background=false, prompt="Task 2: ...")
-   \`\`\`
-
-3. Continue until all waves complete
-
-4. Final QA: Verify all tasks pass their QA criteria
-\`\`\`
-
-WHY THIS FORMAT IS MANDATORY:
-- Caller can directly copy TODO items
-- Wave grouping enables parallel execution
-- Each task has clear task parameters
-- QA criteria ensure verifiable completion
-</FINAL_OUTPUT_FOR_CALLER>
-
-`
-
-function renderPlanAgentCategoryRows(categories: AvailableCategory[]): string[] {
-  const sorted = [...categories].sort((a, b) => a.name.localeCompare(b.name))
-  return sorted.map((category) => {
-    const bestFor = category.description || category.name
-    const model = category.model || ""
-    return `| \`${category.name}\` | ${bestFor} | ${model} |`
-  })
-}
-
-function renderPlanAgentSkillRows(skills: AvailableSkill[]): string[] {
-   const sorted = [...skills].sort((a, b) => a.name.localeCompare(b.name))
-   return sorted.map((skill) => {
-     const domain = truncateDescription(skill.description).trim() || skill.name
-     return `| \`${skill.name}\` | ${domain} |`
-   })
- }
-
-export function buildPlanAgentSkillsSection(
-  categories: AvailableCategory[] = [],
-  skills: AvailableSkill[] = []
-): string {
-  const categoryRows = renderPlanAgentCategoryRows(categories)
-  const skillRows = renderPlanAgentSkillRows(skills)
-
-  return `### AVAILABLE CATEGORIES
-
-| Category | Best For | Model |
-|----------|----------|-------|
-${categoryRows.join("\n")}
-
-### AVAILABLE SKILLS (ALWAYS EVALUATE ALL)
-
-Skills inject specialized expertise into the delegated agent.
-YOU MUST evaluate EVERY skill and justify inclusions/omissions.
-
-| Skill | Domain |
-|-------|--------|
-${skillRows.join("\n")}`
-}
-
-export function buildPlanAgentSystemPrepend(
-  categories: AvailableCategory[] = [],
-  skills: AvailableSkill[] = []
-): string {
-  return [
-    PLAN_AGENT_SYSTEM_PREPEND_STATIC_BEFORE_SKILLS,
-    buildPlanAgentSkillsSection(categories, skills),
-    PLAN_AGENT_SYSTEM_PREPEND_STATIC_AFTER_SKILLS,
-  ].join("\n\n")
-}
-
-/**
- * List of agent names that should be treated as plan agents (receive plan system prompt).
- * Case-insensitive matching is used.
- */
-export const PLAN_AGENT_NAMES = ["plan"]
-
-/**
- * Check if the given agent name is a plan agent (receives plan system prompt).
- */
-export function isPlanAgent(agentName: string | undefined): boolean {
-  if (!agentName) return false
-  const lowerName = agentName.toLowerCase().trim()
-  return PLAN_AGENT_NAMES.some(name => lowerName === name)
-}
-
-/**
- * Plan family: plan + strategist. Shares mutual delegation blocking and task tool permission.
- * Does NOT share system prompt (only isPlanAgent controls that).
- */
-export const PLAN_FAMILY_NAMES = ["plan", "strategist"]
-
-/**
- * Check if the given agent belongs to the plan family (blocking + task permission).
- */
-export function isPlanFamily(category: string): boolean
-export function isPlanFamily(category: string | undefined): boolean
-export function isPlanFamily(category: string | undefined): boolean {
-  if (!category) return false
-  const lowerCategory = getAgentConfigKey(category).toLowerCase().trim()
-  return PLAN_FAMILY_NAMES.some((name) => lowerCategory === name)
-}

package/src/tools/delegate-task/delegated-model-config.ts

@@ -1,20 +0,0 @@
-import type { CategoryConfig } from "../../config/schema"
-import type { DelegatedModelConfig } from "./types"
-
-export function applyCategoryParams(
-  base: DelegatedModelConfig,
-  config: CategoryConfig | undefined,
-): DelegatedModelConfig {
-  if (!config) {
-    return base
-  }
-
-  return {
-    ...base,
-    ...(config.reasoningEffort !== undefined ? { reasoningEffort: config.reasoningEffort } : {}),
-    ...(config.temperature !== undefined ? { temperature: config.temperature } : {}),
-    ...(config.top_p !== undefined ? { top_p: config.top_p } : {}),
-    ...(config.maxTokens !== undefined ? { maxTokens: config.maxTokens } : {}),
-    ...(config.thinking !== undefined ? { thinking: config.thinking } : {}),
-  }
-}