@hiai-gg/hiai-opencode 0.1.0

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

@@ -0,0 +1,310 @@
+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

@@ -0,0 +1,351 @@
+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

@@ -0,0 +1,20 @@
+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 } : {}),
+  }
+}