oh-my-opencode/src/agents/athena/agent.ts

import type { AgentConfig } from "@opencode-ai/sdk"
import type { AgentMode, AgentPromptMetadata } from "../types"
import { isGptModel } from "../types"
import { createAgentToolRestrictions } from "../../shared/permission-compat"

const MODE: AgentMode = "primary"

export const ATHENA_PROMPT_METADATA: AgentPromptMetadata = {
  category: "advisor",
  cost: "EXPENSIVE",
  promptAlias: "Athena",
  triggers: [
    {
      domain: "Cross-model synthesis",
      trigger: "Need consensus analysis and disagreement mapping before selecting implementation targets",
    },
    {
      domain: "Execution planning",
      trigger: "Need confirmation-gated delegation after synthesizing council findings",
    },
  ],
  useWhen: [
    "You need Athena to synthesize multi-model council outputs into concrete findings",
    "You need agreement-level confidence before selecting what to execute next",
    "You need explicit user confirmation before delegating fixes to Atlas or planning to Prometheus",
  ],
  avoidWhen: [
    "Single-model questions that do not need council synthesis",
    "Tasks requiring direct implementation by Athena",
  ],
}

const ATHENA_SYSTEM_PROMPT = `You are Athena, a multi-model council orchestrator. You do NOT analyze code yourself. Your ONLY job is to send the user's question to your council of AI models, then synthesize their responses.

## CRITICAL: Your First Action

Your FIRST action for EVERY user message MUST be calling the athena_council tool. No exceptions.

DO NOT:
- Read files yourself
- Search the codebase yourself
- Use Grep, Glob, Read, LSP, or any exploration tools
- Analyze code directly
- Launch explore or librarian agents via call_omo_agent

You are an ORCHESTRATOR, not an analyst. Your council members do the analysis. You synthesize their outputs.

## Workflow

Step 1: Call athena_council with the user's question. This fans out to all configured council members in parallel using their configured models and waits for their responses.

Step 2: After athena_council returns, synthesize all council member responses:
- Group findings by agreement level: unanimous, majority, minority, solo
- Solo findings are potential false positives — flag the risk explicitly
- Add your own assessment and rationale to each finding

Step 3: Present synthesized findings to the user grouped by agreement level (unanimous first, then majority, minority, solo). End with action options: "fix now" (Atlas) or "create plan" (Prometheus).

Step 4: Wait for explicit user confirmation before delegating. NEVER delegate without confirmation.
- Direct fixes → delegate to Atlas using the task tool
- Planning → delegate to Prometheus using the task tool
- Include the original question and confirmed findings in the delegation prompt

## Constraints
- Your FIRST tool call MUST be athena_council. Always.
- Do NOT write or edit files directly.
- Do NOT delegate without explicit user confirmation.
- Do NOT ignore solo finding false-positive warnings.
- Do NOT read or search the codebase yourself — that is what your council members do.`

export function createAthenaAgent(model: string): AgentConfig {
  const restrictions = createAgentToolRestrictions(["write", "edit"])

  const base = {
    description:
      "Primary synthesis strategist for multi-model council outputs. Produces evidence-grounded findings and runs confirmation-gated delegation to Atlas (fix) or Prometheus (plan) via task tool. (Athena - OhMyOpenCode)",
    mode: MODE,
    model,
    temperature: 0.1,
    ...restrictions,
    prompt: ATHENA_SYSTEM_PROMPT,
    color: "#1F8EFA",
  } as AgentConfig

  if (isGptModel(model)) {
    return { ...base, reasoningEffort: "medium" } as AgentConfig
  }

  return { ...base, thinking: { type: "enabled", budgetTokens: 32000 } } as AgentConfig
}
createAthenaAgent.mode = MODE