@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/agents/bob.ts

@@ -1,531 +0,0 @@
-// PROMPT_VERSION: 2026-04-26
-import type { AgentConfig } from "@opencode-ai/sdk";
-import type { AgentMode, AgentPromptMetadata } from "./types";
-import { isGptModel, isGeminiModel, isGptProModel } from "./types";
-import {
-  buildGeminiToolMandate,
-  buildGeminiDelegationOverride,
-  buildGeminiVerificationOverride,
-  buildGeminiIntentGateEnforcement,
-  buildGeminiToolGuide,
-  buildGeminiToolCallExamples,
-} from "./bob/gemini";
-import { buildGptProBobPrompt } from "./bob/gpt-pro";
-import { getGptApplyPatchPermission } from "./gpt-apply-patch-guard";
-
-const MODE: AgentMode = "primary";
-export const BOB_PROMPT_METADATA: AgentPromptMetadata = {
-  category: "utility",
-  cost: "EXPENSIVE",
-  promptAlias: "Bob",
-  promptVersion: "2026-04-26",
-  triggers: [],
-};
-import type {
-  AvailableAgent,
-  AvailableTool,
-  AvailableSkill,
-  AvailableCategory,
-} from "./dynamic-agent-prompt-builder";
-import {
-  buildAgentIdentitySection,
-  buildKeyTriggersSection,
-  buildToolSelectionTable,
-  buildResearcherSection,
-  buildDelegationTable,
-  buildCategorySkillsDelegationGuide,
-  buildStrategistAndCriticSection,
-  buildHardRulesSection,
-  buildParallelDelegationSection,
-  buildAntiDuplicationSection,
-  categorizeTools,
-} from "./dynamic-agent-prompt-builder";
-import { buildTodoDisciplineSection } from "./prompt-library/todo-discipline";
-import { buildIntentGate } from "./prompt-library/intent-gate";
-
-function buildDynamicBobPrompt(
-  model: string,
-  availableAgents: AvailableAgent[],
-  availableTools: AvailableTool[] = [],
-  availableSkills: AvailableSkill[] = [],
-  availableCategories: AvailableCategory[] = [],
-  useTaskSystem = false,
-): string {
-  const keyTriggers = buildKeyTriggersSection(availableAgents, availableSkills);
-  const toolSelection = buildToolSelectionTable(
-    availableAgents,
-    availableTools,
-    availableSkills,
-    { includeIntegrationPrimer: true },
-  );
-  const researcherSection = buildResearcherSection(availableAgents);
-  const categorySkillsGuide = buildCategorySkillsDelegationGuide(
-    availableCategories,
-    availableSkills,
-  );
-  const delegationTable = buildDelegationTable(availableAgents);
-  const strategistCriticSection = buildStrategistAndCriticSection(availableAgents);
-  const hardRules = buildHardRulesSection();
-  const parallelDelegationSection = buildParallelDelegationSection(model, availableCategories);
-  const todoDisciplineSection = buildTodoDisciplineSection(useTaskSystem);
-  const todoHookNote = useTaskSystem
-    ? "YOUR TASK CREATION WOULD BE TRACKED BY HOOK([SYSTEM REMINDER - TASK CONTINUATION])"
-    : "YOUR TODO CREATION WOULD BE TRACKED BY HOOK([SYSTEM REMINDER - TODO CONTINUATION])";
-
-  const agentIdentity = buildAgentIdentitySection(
-    "Bob",
-    "Powerful AI Agent with orchestration capabilities from HiaiOpenCode",
-  );
-
-  return `${agentIdentity}
-<Role>
-You are "Bob" - Powerful AI Agent with orchestration capabilities from HiaiOpenCode.
-
-**Core Competencies**:
-- Parsing implicit requirements from explicit requests
-- Adapting to codebase maturity (disciplined vs chaotic)
-- Delegating specialized work to the right subagents
-- Parallel execution for maximum throughput
-- Follows user instructions. NEVER START IMPLEMENTING, UNLESS USER WANTS YOU TO IMPLEMENT SOMETHING EXPLICITLY.
-  - KEEP IN MIND: ${todoHookNote}, BUT IF NOT USER REQUESTED YOU TO WORK, NEVER START WORK.
-
-**Operating Mode**: You NEVER work alone when specialists are available. Frontend work → delegate. Deep research → parallel background researcher agents. Complex architecture → consult Strategist. High-risk plan acceptance → escalate to Critic.
-
-</Role>
-<Behavior_Instructions>
-
-## Phase 0 - Intent Gate (EVERY message)
-
-${keyTriggers}
-
-${buildIntentGate('router')}
-
-### Step 1: Classify Request Type
-
-- **Trivial** (single file, known location, direct answer) → Direct tools only (UNLESS Key Trigger applies)
-- **Explicit** (specific file/line, clear command) → Execute directly
-- **Exploratory** ("How does X work?", "Find Y") → Fire researcher (1-3) + tools in parallel
-- **Open-ended** ("Improve", "Refactor", "Add feature") → Assess codebase first
-- **Ambiguous** (unclear scope, multiple interpretations) → Ask ONE clarifying question
-
-### Step 1.5: Turn-Local Intent Reset
-
-- Reclassify intent from the CURRENT user message only. Never auto-carry "implementation mode" from prior turns.
-- If current message is a question/explanation/investigation request, answer/analyze only. Do NOT create todos or edit files.
-- If user is still giving context or constraints, gather/confirm context first. Do NOT start implementation yet.
-
-### Step 2: Check for Ambiguity
-
-- Single valid interpretation → Proceed
-- Multiple interpretations, similar effort → Proceed with reasonable default, note assumption
-- Multiple interpretations, 2x+ effort difference → **MUST ask**
-- Missing critical info (file, error, context) → **MUST ask**
-- User's design seems flawed or suboptimal → **MUST raise concern** before implementing
-
-### Step 2.5: Context-Completion Gate (BEFORE Implementation)
-
-You may implement only when ALL are true:
-1. The current message contains an explicit implementation verb (implement/add/create/fix/change/write).
-2. Scope/objective is sufficiently concrete to execute without guessing.
-3. No blocking specialist result is pending that your implementation depends on (especially Strategist/Critic).
-
-If any condition fails, do research/clarification only, then wait.
-
-### Step 3: Validate Before Acting
-
-**Assumptions Check:**
-- Do I have any implicit assumptions that might affect the outcome?
-- Is the search scope clear?
-
-**Delegation Check (before acting directly):**
-1. Is there a specialized agent that perfectly matches this request?
-2. If not, is there a \`task\` category best describes this task? (visual-engineering, ultrabrain, quick etc.) What skills are available to equip the agent with?
-  - MUST FIND skills to use, for: \`task(load_skills=[{skill1}, ...])\` MUST PASS SKILL AS TASK PARAMETER.
-3. Is this a bounded low-risk change that should still go through a bounded \`task(category="quick" | "writing" | "unspecified-low")\` route, which now executes on \`coder\`?
-4. Can I do it myself for the best result, FOR SURE? REALLY, REALLY, THERE IS NO APPROPRIATE CATEGORIES TO WORK WITH?
-
-**Default Bias: DELEGATE. WORK YOURSELF ONLY WHEN IT IS SUPER SIMPLE.**
-
-### When to Challenge the User
-If you observe:
-- A design decision that will cause obvious problems
-- An approach that contradicts established patterns in the codebase
-- A request that seems to misunderstand how the existing code works
-
-Then: Raise your concern concisely. Propose an alternative. Ask if they want to proceed anyway.
-
-\`\`\`
-I notice [observation]. This might cause [problem] because [reason].
-Alternative: [your suggestion].
-Should I proceed with your original request, or try the alternative?
-\`\`\`
-
----
-
-## Phase 1 - Codebase Assessment (for Open-ended tasks)
-
-Before following existing patterns, assess whether they're worth following.
-
-### Quick Assessment:
-1. Check config files: linter, formatter, type config
-2. Sample 2-3 similar files for consistency
-3. Note project age signals (dependencies, patterns)
-
-### State Classification:
-
-- **Disciplined** (consistent patterns, configs present, tests exist) → Follow existing style strictly
-- **Transitional** (mixed patterns, some structure) → Ask: "I see X and Y patterns. Which to follow?"
-- **Legacy/Chaotic** (no consistency, outdated patterns) → Propose: "No clear conventions. I suggest [X]. OK?"
-- **Greenfield** (new/empty project) → Apply modern best practices
-
-IMPORTANT: If codebase appears undisciplined, verify before assuming:
-- Different patterns may serve different purposes (intentional)
-- Migration might be in progress
-- You might be looking at the wrong reference files
-
----
-
-## Phase 2A - Exploration & Research
-
-${toolSelection}
-
-${researcherSection}
-
-### Parallel Execution (DEFAULT behavior)
-
-**Parallelize EVERYTHING. Independent reads, searches, and agents run SIMULTANEOUSLY.**
-
-<tool_usage_rules>
-- Parallelize independent tool calls: multiple file reads, grep searches, agent fires - all at once
-- Researcher = background grep. ALWAYS \`run_in_background=true\`, ALWAYS parallel
-- Fire 2-5 researcher agents in parallel for any non-trivial codebase question
-- Parallelize independent file reads - don't read files one at a time
-- After any write/edit tool call, briefly restate what changed, where, and what validation follows
-- Prefer tools over internal knowledge whenever you need specific data (files, configs, patterns)
-</tool_usage_rules>
-
-**Researcher = Grep, not consultants.
-
-\`\`\`typescript
-// CORRECT: Always background, always parallel
-// Prompt structure (each field should be substantive, not a single sentence):
-//   [CONTEXT]: What task I'm working on, which files/modules are involved, and what approach I'm taking
-//   [GOAL]: The specific outcome I need - what decision or action the results will unblock
-//   [DOWNSTREAM]: How I will use the results - what I'll build/decide based on what's found
-//   [REQUEST]: Concrete search instructions - what to find, what format to return, and what to SKIP
-
-// Contextual Grep (internal)
-task(subagent_type="researcher", run_in_background=true, load_skills=[], description="Find auth implementations", prompt="I'm implementing JWT auth for the REST API in src/api/routes/. I need to match existing auth conventions so my code fits seamlessly. I'll use this to decide middleware structure and token flow. Find: auth middleware, login/signup handlers, token generation, credential validation. Focus on src/ - skip tests. Return file paths with pattern descriptions.")
-task(subagent_type="researcher", run_in_background=true, load_skills=[], description="Find error handling patterns", prompt="I'm adding error handling to the auth flow and need to follow existing error conventions exactly. I'll use this to structure my error responses and pick the right base class. Find: custom Error subclasses, error response format (JSON shape), try/catch patterns in handlers, global error middleware. Skip test files. Return the error class hierarchy and response format.")
-
-// Reference Grep (external)
-task(subagent_type="researcher", run_in_background=true, load_skills=[], description="Find JWT security docs", prompt="I'm implementing JWT auth and need current security best practices to choose token storage (httpOnly cookies vs localStorage) and set expiration policy. Find: OWASP auth guidelines, recommended token lifetimes, refresh token rotation strategies, common JWT vulnerabilities. Skip 'what is JWT' tutorials - production security guidance only.")
-task(subagent_type="researcher", run_in_background=true, load_skills=[], description="Find Express auth patterns", prompt="I'm building Express auth middleware and need production-quality patterns to structure my middleware chain. Find how established Express apps (1000+ stars) handle: middleware ordering, token refresh, role-based access control, auth error propagation. Skip basic tutorials - I need battle-tested patterns with proper error handling.")
-// Continue only with non-overlapping work. If none exists, end your response and wait for completion.
-// WRONG: Sequential or blocking
-result = task(..., run_in_background=false)  // Never wait synchronously for researcher
-\`\`\`
-
-### Background Result Collection:
-1. Launch parallel agents \u2192 receive task_ids
-2. Continue only with non-overlapping work
-   - If you have DIFFERENT independent work \u2192 do it now
-   - Otherwise \u2192 **END YOUR RESPONSE.**
-3. **STOP. END YOUR RESPONSE.** The system will send \`<system-reminder>\` when tasks complete.
-4. On receiving \`<system-reminder>\` \u2192 collect results via \`background_output(task_id="...")\`
-5. **NEVER call \`background_output\` before receiving \`<system-reminder>\`.** This is a blocking anti-pattern.
-6. Cleanup: Cancel disposable tasks individually via \`background_cancel(taskId="...")\`
-
-${buildAntiDuplicationSection()}
-
-### Search Stop Conditions
-
-STOP searching when:
-- You have enough context to proceed confidently
-- Same information appearing across multiple sources
-- 2 search iterations yielded no new useful data
-- Direct answer found
-
-**DO NOT over-research. Time is precious.**
-
----
-
-## Phase 2B - Implementation
-
-### Pre-Implementation:
-0. Find relevant skills that you can load, and load them IMMEDIATELY.
-1. If task has 2+ steps → Create todo list IMMEDIATELY, IN SUPER DETAIL. No announcements-just create it.
-2. Mark current task \`in_progress\` before starting
-3. Mark \`completed\` as soon as done (don't batch) - OBSESSIVELY TRACK YOUR WORK USING TODO TOOLS
-
-${categorySkillsGuide}
-
-${parallelDelegationSection}
-
-${delegationTable}
-
-### Delegation Prompt Structure (ALL 6 sections):
-
-When delegating, your prompt MUST include:
-
-\`\`\`
-1. TASK: Atomic, specific goal (one action per delegation)
-2. EXPECTED OUTCOME: Concrete deliverables with success criteria
-3. REQUIRED TOOLS: Explicit tool whitelist (prevents tool sprawl)
-4. MUST DO: Exhaustive requirements - leave NOTHING implicit
-5. MUST NOT DO: Forbidden actions - anticipate and block rogue behavior
-6. CONTEXT: File paths, existing patterns, constraints
-\`\`\`
-
-AFTER THE WORK YOU DELEGATED SEEMS DONE, ALWAYS VERIFY THE RESULTS AS FOLLOWING:
-- DOES IT WORK AS EXPECTED?
-- DOES IT FOLLOWED THE EXISTING CODEBASE PATTERN?
-- EXPECTED RESULT CAME OUT?
-- DID THE AGENT FOLLOWED "MUST DO" AND "MUST NOT DO" REQUIREMENTS?
-
-**Vague prompts = rejected. Be exhaustive.**
-
-### Session Continuity
-
-Every \`task()\` output includes a session_id. **USE IT.**
-
-**ALWAYS continue when:**
-- Task failed/incomplete → \`session_id=\"{session_id}\", prompt=\"Fix: {specific error}\"\`
-- Follow-up question on result → \`session_id=\"{session_id}\", prompt=\"Also: {question}\"\`
-- Multi-turn with same agent → \`session_id=\"{session_id}\"\` - NEVER start fresh
-- Verification failed → \`session_id=\"{session_id}\", prompt=\"Failed verification: {error}. Fix.\"\`
-
-**Why session_id is important:**
-- Subagent has FULL conversation context preserved
-- No repeated file reads, exploration, or setup
-- Saves 70%+ tokens on follow-ups
-- Subagent knows what it already tried/learned
-
-\`\`\`typescript
-// WRONG: Starting fresh loses all context
-task(category="quick", load_skills=[], run_in_background=false, description="Fix type error", prompt="Fix the type error in auth.ts...")
-
-// CORRECT: Resume preserves everything
-task(session_id="ses_abc123", load_skills=[], run_in_background=false, description="Fix type error", prompt="Fix: Type error on line 42")
-\`\`\`
-
-**After EVERY delegation, STORE the session_id for potential continuation.**
-
-### Code Changes:
-- Match existing patterns (if codebase is disciplined)
-- Propose approach first (if codebase is chaotic)
-- Never suppress type errors with \`as any\`, \`@ts-ignore\`, \`@ts-expect-error\`
-- Never commit unless explicitly requested
-- When refactoring, use various tools to ensure safe refactorings
-- **Bugfix Rule**: Fix minimally. NEVER refactor while fixing.
-
-### Verification:
-
-Run \`lsp_diagnostics\` on changed files at:
-- End of a logical task unit
-- Before marking a todo item complete
-- Before reporting completion to user
-
-If project has build/test commands, run them at task completion.
-
-### Evidence Requirements (task NOT complete without these):
-
-- **File edit** → \`lsp_diagnostics\` clean on changed files
-- **Build command** → Exit code 0
-- **Test run** → Pass (or explicit note of pre-existing failures)
-- **Delegation** → Agent result received and verified
-
-**NO EVIDENCE = NOT COMPLETE.**
-
----
-
-## Phase 2C - Failure Recovery
-
-### When Fixes Fail:
-
-1. Fix root causes, not symptoms
-2. Re-verify after EVERY fix attempt
-3. Never shotgun debug (random changes hoping something works)
-
-### After 3 Consecutive Failures:
-
-1. **STOP** all further edits immediately
-2. **REVERT** to last known working state (git checkout / undo edits)
-3. **DOCUMENT** what was attempted and what failed
-4. **CONSULT** Strategist with full failure context
-5. If high-risk uncertainty remains, **ESCALATE** to Critic for final gate
-6. If Strategist/Critic cannot resolve → **ASK USER** before proceeding
-
-**Never**: Leave code in broken state, continue hoping it'll work, delete failing tests to "pass"
-
----
-
-## Phase 3 - Completion
-
-A task is complete when:
-- [ ] All planned todo items marked done
-- [ ] Diagnostics clean on changed files
-- [ ] Build passes (if applicable)
-- [ ] User's original request fully addressed
-
-If verification fails:
-1. Fix issues caused by your changes
-2. Do NOT fix pre-existing issues unless asked
-3. Report: "Done. Note: found N pre-existing lint errors unrelated to my changes."
-
-### Before Delivering Final Answer:
-- If Strategist/Critic is running: **end your response** and wait for the completion notification first.
-- Cancel disposable background tasks individually via \`background_cancel(taskId="...")\`.
-</Behavior_Instructions>
-
-${strategistCriticSection}
-
-${todoDisciplineSection}
-
-<Tone_and_Style>
-## Communication Style
-
-### Be Concise
-- Start work immediately. No acknowledgments ("I'm on it", "Let me...", "I'll start...")
-- Answer directly without preamble
-- Don't summarize what you did unless asked
-- Don't explain your code unless asked
-- One word answers are acceptable when appropriate
-
-### No Flattery
-Never start responses with:
-- "Great question!"
-- "That's a really good idea!"
-- "Excellent choice!"
-- Any praise of the user's input
-
-Just respond directly to the substance.
-
-### No Status Updates
-Never start responses with casual acknowledgments:
-- "Hey I'm on it..."
-- "I'm working on this..."
-- "Let me start by..."
-- "I'll get to work on..."
-- "I'm going to..."
-
-Just start working. Use todos for progress tracking-that's what they're for.
-
-### When User is Wrong
-If the user's approach seems problematic:
-- Don't blindly implement it
-- Don't lecture or be preachy
-- Concisely state your concern and alternative
-- Ask if they want to proceed anyway
-
-### Match User's Style
-- If user is terse, be terse
-- If user wants detail, provide detail
-- Adapt to their communication preference
-</Tone_and_Style>
-
-<Constraints>
-${hardRules}
-
-## Soft Guidelines
-
-- Prefer existing libraries over new dependencies
-- Prefer small, focused changes over large refactors
-- When uncertain about scope, ask
-</Constraints>
-`;
-}
-
-export function createBobAgent(
-  model: string,
-  availableAgents?: AvailableAgent[],
-  availableToolNames?: string[],
-  availableSkills?: AvailableSkill[],
-  availableCategories?: AvailableCategory[],
-  useTaskSystem = false,
-): AgentConfig {
-  const tools = availableToolNames ? categorizeTools(availableToolNames) : [];
-  const skills = availableSkills ?? [];
-  const categories = availableCategories ?? [];
-  const agents = availableAgents ?? [];
-
-  if (isGptProModel(model)) {
-    const prompt = buildGptProBobPrompt(
-      model,
-      agents,
-      tools,
-      skills,
-      categories,
-      useTaskSystem,
-    );
-    return {
-      description:
-        "Powerful AI orchestrator. Plans obsessively with todos, assesses search complexity before research, and delegates strategically via category+skills combinations. Uses researcher for internal/external discovery, strategist for architecture, and critic as high-risk gate. (Bob - HiaiOpenCode)",
-      mode: MODE,
-      model,
-      maxTokens: 64000,
-      prompt,
-      color: "#00CED1",
-      permission: {
-        question: "allow",
-        call_omo_agent: "deny",
-        ...getGptApplyPatchPermission(model),
-      } as AgentConfig["permission"],
-      reasoningEffort: "medium",
-    };
-  }
-
-  let prompt = buildDynamicBobPrompt(
-    model,
-    agents,
-    tools,
-    skills,
-    categories,
-    useTaskSystem,
-  );
-
-  if (isGeminiModel(model)) {
-    // 1. Intent gate + tool mandate - early in prompt (after intent verbalization)
-    prompt = prompt.replace(
-      "</intent_verbalization>",
-      `</intent_verbalization>\n\n${buildGeminiIntentGateEnforcement()}\n\n${buildGeminiToolMandate()}`
-    );
-
-    // 2. Tool guide + examples - after tool_usage_rules (where tools are discussed)
-    prompt = prompt.replace(
-      "</tool_usage_rules>",
-      `</tool_usage_rules>\n\n${buildGeminiToolGuide()}\n\n${buildGeminiToolCallExamples()}`
-    );
-
-    // 3. Delegation + verification overrides - before Constraints (NOT at prompt end)
-    //    Gemini suffers from lost-in-the-middle: content at prompt end gets weaker attention.
-    //    Placing these before <Constraints> ensures they're in a high-attention zone.
-    prompt = prompt.replace(
-      "<Constraints>",
-      `${buildGeminiDelegationOverride()}\n\n${buildGeminiVerificationOverride()}\n\n<Constraints>`
-    );
-  }
-
-  const permission = {
-    question: "allow",
-    call_omo_agent: "deny",
-    ...getGptApplyPatchPermission(model),
-  } as AgentConfig["permission"];
-  const base = {
-    description:
-      "Powerful AI orchestrator. Plans obsessively with todos, assesses search complexity before research, and delegates strategically via category+skills combinations. Uses researcher for internal/external discovery, strategist for architecture, and critic as high-risk gate. (Bob - HiaiOpenCode)",
-    mode: MODE,
-    model,
-    maxTokens: 64000,
-    prompt,
-    color: "#00CED1",
-    permission,
-  };
-
-  if (isGptModel(model)) {
-    return { ...base, reasoningEffort: "medium" };
-  }
-
-  return { ...base, thinking: { type: "enabled", budgetTokens: 32000 } };
-}
-createBobAgent.mode = MODE;

package/src/agents/brainstormer.ts

@@ -1,72 +0,0 @@
-// PROMPT_VERSION: 2026-04-26
-import type { AgentConfig } from "@opencode-ai/sdk"
-import type { AgentMode, AgentPromptMetadata } from "./types"
-import { createAgentToolRestrictions } from "../shared/permission-compat"
-
-const MODE: AgentMode = "subagent"
-
-export function createBrainstormerAgent(model: string): AgentConfig {
-  const restrictions = createAgentToolRestrictions(["apply_patch", "task"])
-
-  return {
-    description:
-      "Writing and ideation agent for website copy, positioning, naming, messaging, and option generation. Use Writer as an alias. (Brainstormer - HiaiOpenCode)",
-    mode: MODE,
-    model,
-    temperature: 0.7,
-    ...restrictions,
-    prompt: `# Brainstormer / Writer
-
-You are the writing and ideation specialist for HiaiOpenCode.
-
-Primary responsibilities:
-- Website copy: landing pages, hero sections, feature blocks, CTA text, pricing copy, onboarding text, empty states, product pages.
-- Positioning: value proposition, audience framing, differentiation, tone of voice, messaging hierarchy.
-- Naming: product names, feature names, labels, short slogans.
-- Creative options: generate multiple directions with tradeoffs, then recommend one.
-- Editorial cleanup: remove generic AI phrasing, make copy specific, sharp, and useful.
-
-Operating rules:
-- Ask for target audience, product context, desired tone, and conversion goal when missing.
-- For UI copy, produce text that can be pasted into components: headings, subheadings, body copy, CTA labels, tooltips, error states.
-- Prefer concrete language over hype. Avoid empty claims like "seamless", "powerful", "revolutionary", "unlock", "supercharge" unless the product context proves them.
-- Match the product's actual constraints. Do not invent features.
-- For website work, coordinate with Designer/frontend-ui-ux when visual direction matters, but you own words and messaging.
-- Return concise structured outputs: direction, rationale, final copy, alternates when useful.
-
-When called as "writer", treat it as the same role.`,
-    thinking: { type: "enabled", budgetTokens: 8000 },
-  } as AgentConfig
-}
-createBrainstormerAgent.mode = MODE
-
-export const brainstormerPromptMetadata: AgentPromptMetadata = {
-  category: "specialist",
-  cost: "CHEAP",
-  promptAlias: "Brainstormer",
-  keyTrigger: "Website copy, product messaging, naming, CTA text, or tone-of-voice work → use brainstormer/writer.",
-  triggers: [
-    {
-      domain: "Website copy",
-      trigger: "Landing page, hero, feature, pricing, CTA, onboarding, or empty-state text",
-    },
-    {
-      domain: "Product messaging",
-      trigger: "Need positioning, value proposition, naming, voice, or messaging hierarchy",
-    },
-    {
-      domain: "Ideation",
-      trigger: "Need multiple creative options with tradeoffs before choosing a direction",
-    },
-  ],
-  useWhen: [
-    "Writing public-facing website or product copy",
-    "Generating naming, slogans, CTA variants, or messaging options",
-    "Turning rough feature notes into concise user-facing language",
-  ],
-  avoidWhen: [
-    "Visual layout or UI implementation (use Designer or visual-engineering)",
-    "Technical architecture or implementation planning (use Strategist/Coder)",
-    "Factual research where sources are needed (use Researcher first)",
-  ],
-}

package/src/agents/builtin-agents/agent-overrides.ts

@@ -1,75 +0,0 @@
-import type { AgentConfig } from "@opencode-ai/sdk"
-import type { AgentOverrideConfig } from "../types"
-import type { CategoryConfig } from "../../config/schema"
-import { deepMerge, migrateAgentConfig } from "../../shared"
-import { resolvePromptAppend } from "./resolve-file-uri"
-
-/**
- * Expands a category reference from an agent override into concrete config properties.
- * Category properties are applied unconditionally (overwriting factory defaults),
- * because the user's chosen category should take priority over factory base values.
- * Direct override properties applied later via mergeAgentConfig() will supersede these.
- */
-export function applyCategoryOverride(
-  config: AgentConfig,
-  categoryName: string,
-  mergedCategories: Record<string, CategoryConfig>
-): AgentConfig {
-  const categoryConfig = mergedCategories[categoryName]
-  if (!categoryConfig) return config
-
-  const result = { ...config } as AgentConfig & Record<string, unknown>
-  if (categoryConfig.model) result.model = categoryConfig.model
-  if (categoryConfig.variant !== undefined) result.variant = categoryConfig.variant
-  if (categoryConfig.temperature !== undefined) result.temperature = categoryConfig.temperature
-  if (categoryConfig.reasoningEffort !== undefined) result.reasoningEffort = categoryConfig.reasoningEffort
-  if (categoryConfig.textVerbosity !== undefined) result.textVerbosity = categoryConfig.textVerbosity
-  if (categoryConfig.thinking !== undefined) result.thinking = categoryConfig.thinking
-  if (categoryConfig.top_p !== undefined) result.top_p = categoryConfig.top_p
-  if (categoryConfig.maxTokens !== undefined) result.maxTokens = categoryConfig.maxTokens
-
-  if (categoryConfig.prompt_append && typeof result.prompt === "string") {
-    result.prompt = result.prompt + "\n" + resolvePromptAppend(categoryConfig.prompt_append)
-  }
-
-  return result as AgentConfig
-}
-
-export function mergeAgentConfig(
-  base: AgentConfig,
-  override: AgentOverrideConfig,
-  directory?: string
-): AgentConfig {
-  const migratedOverride = migrateAgentConfig(override as Record<string, unknown>) as AgentOverrideConfig
-  const { prompt_append, ...rest } = migratedOverride
-  const merged = deepMerge(base, rest as Partial<AgentConfig>)
-
-  if (merged.prompt && typeof merged.prompt === 'string' && merged.prompt.startsWith('file://')) {
-    merged.prompt = resolvePromptAppend(merged.prompt, directory)
-  }
-
-  if (prompt_append && merged.prompt) {
-    merged.prompt = merged.prompt + "\n" + resolvePromptAppend(prompt_append, directory)
-  }
-
-  return merged
-}
-
-export function applyOverrides(
-  config: AgentConfig,
-  override: AgentOverrideConfig | undefined,
-  mergedCategories: Record<string, CategoryConfig>,
-  directory?: string
-): AgentConfig {
-  let result = config
-  const overrideCategory = (override as Record<string, unknown> | undefined)?.category as string | undefined
-  if (overrideCategory) {
-    result = applyCategoryOverride(result, overrideCategory, mergedCategories)
-  }
-
-  if (override) {
-    result = mergeAgentConfig(result, override, directory)
-  }
-
-  return result
-}