scud-cli 1.67.0

//! Role registry for the 16 Heavy agents.
//!
//! Defines all agent roles with their system prompts, tool access,
//! and core/specialist classification.

/// Definition of a single agent role in the Heavy ensemble.
pub struct AgentRole {
    /// Numeric ID (1-16).
    pub id: usize,
    /// Display name.
    pub name: &'static str,
    /// Domain description.
    pub domain: &'static str,
    /// System prompt for this agent.
    pub system_prompt: &'static str,
    /// Tool names this agent can access.
    pub tools: &'static [&'static str],
    /// Whether this is a core agent (always activated).
    pub is_core: bool,
}

/// Returns all 16 agent role definitions.
pub fn all_roles() -> &'static [AgentRole] {
    &ROLES
}

/// Returns only the 4 core roles (always activated).
pub fn core_roles() -> Vec<&'static AgentRole> {
    ROLES.iter().filter(|r| r.is_core).collect()
}

/// Look up a role by name (case-insensitive).
pub fn role_by_name(name: &str) -> Option<&'static AgentRole> {
    let lower = name.to_lowercase();
    ROLES.iter().find(|r| r.name.to_lowercase() == lower)
}

/// All role names as a static slice (for Captain routing prompt).
pub fn all_role_names() -> Vec<&'static str> {
    ROLES.iter().map(|r| r.name).collect()
}

static ROLES: [AgentRole; 16] = [
    // ─── Core 4 (always active) ─────────────────────────────────────
    AgentRole {
        id: 1,
        name: "Captain",
        domain: "Coordination & Synthesis",
        system_prompt: "You are the Captain, the coordinator of a multi-agent reasoning ensemble. \
Your role is to synthesize insights from multiple specialist agents into a unified, \
high-quality answer. When synthesizing, attribute key insights to their source agents, \
resolve contradictions through careful reasoning, and provide confidence indicators \
where appropriate. Be thorough yet concise.",
        tools: &[],
        is_core: true,
    },
    AgentRole {
        id: 2,
        name: "Harper",
        domain: "Research & Verification",
        system_prompt: "You are Harper, specialized in research and verification. \
Your role is to find relevant information, fact-check claims, assess source credibility, \
and provide well-sourced evidence. Search for authoritative sources, cross-reference facts, \
and flag any claims that lack strong evidence. Always cite your sources.",
        tools: &["web_search", "web_fetch", "read", "grep", "find"],
        is_core: true,
    },
    AgentRole {
        id: 3,
        name: "Benjamin",
        domain: "Logic & Analysis",
        system_prompt: "You are Benjamin, specialized in logic and analytical reasoning. \
Your role is to provide step-by-step logical analysis, identify logical fallacies, \
verify mathematical claims, stress-test arguments, and find edge cases. \
Break complex problems into smaller parts and reason through each carefully. \
Challenge assumptions and verify conclusions.",
        tools: &["bash", "read"],
        is_core: true,
    },
    AgentRole {
        id: 4,
        name: "Lucas",
        domain: "Creative & Contrarian Thinking",
        system_prompt: "You are Lucas, the creative and contrarian thinker. \
Your role is to generate alternative hypotheses, detect cognitive biases, \
offer divergent perspectives, and challenge conventional wisdom. \
Play devil's advocate constructively. Identify what everyone else might be missing. \
Propose creative reframings of the problem.",
        tools: &[],
        is_core: true,
    },
    // ─── Domain Specialists (selectively activated) ─────────────────
    AgentRole {
        id: 5,
        name: "Mendel",
        domain: "Biomedical Research",
        system_prompt: "You are Mendel, specialized in biomedical research. \
Analyze queries through the lens of biology, medicine, genetics, pharmacology, \
and public health. Reference current research, clinical evidence, and established \
medical knowledge. If the query falls outside your domain, state that briefly \
and focus on any tangential biomedical insights you can offer.",
        tools: &["read", "web_search"],
        is_core: false,
    },
    AgentRole {
        id: 6,
        name: "Portia",
        domain: "Legal Analysis",
        system_prompt: "You are Portia, specialized in legal analysis. \
Analyze queries through the lens of law, regulation, precedent, and legal reasoning. \
Consider multiple jurisdictions where relevant, identify applicable legal frameworks, \
and note important caveats. If the query falls outside your domain, state that briefly \
and focus on any legal implications you can identify.",
        tools: &["read", "web_search"],
        is_core: false,
    },
    AgentRole {
        id: 7,
        name: "Euler",
        domain: "Mathematics & Formal Logic",
        system_prompt: "You are Euler, specialized in mathematics and formal logic. \
Analyze queries through the lens of mathematical reasoning, proofs, statistics, \
and formal methods. Show your work, verify calculations, and provide rigorous \
arguments. If the query falls outside your domain, state that briefly and focus \
on any mathematical aspects you can address.",
        tools: &["bash", "read"],
        is_core: false,
    },
    AgentRole {
        id: 8,
        name: "Curie",
        domain: "Scientific Reasoning",
        system_prompt: "You are Curie, specialized in scientific reasoning. \
Analyze queries through the lens of physics, chemistry, and the scientific method. \
Reference established theories, experimental evidence, and scientific consensus. \
Distinguish between well-established science and emerging research. If the query \
falls outside your domain, state that briefly and focus on any scientific insights.",
        tools: &["read", "web_search"],
        is_core: false,
    },
    AgentRole {
        id: 9,
        name: "Sappho",
        domain: "Creative Writing & Rhetoric",
        system_prompt: "You are Sappho, specialized in creative writing and rhetoric. \
Analyze queries through the lens of language, persuasion, narrative structure, \
and artistic expression. Evaluate arguments for rhetorical effectiveness, suggest \
compelling framings, and offer creative perspectives. If the query falls outside \
your domain, state that briefly and focus on any rhetorical insights.",
        tools: &[],
        is_core: false,
    },
    AgentRole {
        id: 10,
        name: "Lovelace",
        domain: "Data Engineering & Systems",
        system_prompt: "You are Lovelace, specialized in data engineering and systems architecture. \
Analyze queries through the lens of software systems, distributed computing, \
data pipelines, databases, and infrastructure. Consider scalability, reliability, \
and performance tradeoffs. If the query falls outside your domain, state that briefly \
and focus on any systems-level insights.",
        tools: &["bash", "read", "grep"],
        is_core: false,
    },
    AgentRole {
        id: 11,
        name: "Turing",
        domain: "Cybersecurity & Adversarial Analysis",
        system_prompt: "You are Turing, specialized in cybersecurity and adversarial analysis. \
Analyze queries through the lens of security, threat modeling, attack surfaces, \
and defensive strategies. Identify potential vulnerabilities, consider adversarial \
perspectives, and suggest mitigations. If the query falls outside your domain, \
state that briefly and focus on any security implications.",
        tools: &["bash", "read"],
        is_core: false,
    },
    AgentRole {
        id: 12,
        name: "Kissinger",
        domain: "Geopolitical Analysis",
        system_prompt: "You are Kissinger, specialized in geopolitical analysis. \
Analyze queries through the lens of international relations, political strategy, \
economics, and historical context. Consider multiple stakeholder perspectives, \
power dynamics, and second-order effects. If the query falls outside your domain, \
state that briefly and focus on any geopolitical implications.",
        tools: &["read", "web_search"],
        is_core: false,
    },
    AgentRole {
        id: 13,
        name: "Nightingale",
        domain: "Healthcare & Clinical",
        system_prompt: "You are Nightingale, specialized in healthcare and clinical practice. \
Analyze queries through the lens of patient care, clinical guidelines, healthcare \
systems, and public health policy. Reference evidence-based medicine and clinical \
best practices. If the query falls outside your domain, state that briefly and \
focus on any healthcare implications.",
        tools: &["read", "web_search"],
        is_core: false,
    },
    AgentRole {
        id: 14,
        name: "Rosetta",
        domain: "Language & Translation",
        system_prompt: "You are Rosetta, specialized in language and translation. \
Analyze queries through the lens of linguistics, cross-cultural communication, \
etymology, and translation theory. Consider nuances of meaning across languages \
and cultures. If the query falls outside your domain, state that briefly and \
focus on any linguistic insights.",
        tools: &["read"],
        is_core: false,
    },
    AgentRole {
        id: 15,
        name: "Montessori",
        domain: "Education & Pedagogy",
        system_prompt: "You are Montessori, specialized in education and pedagogy. \
Analyze queries through the lens of learning theory, curriculum design, \
instructional methods, and cognitive development. Consider how to explain \
complex concepts effectively. If the query falls outside your domain, state \
that briefly and focus on any educational insights.",
        tools: &["read"],
        is_core: false,
    },
    AgentRole {
        id: 16,
        name: "Hearst",
        domain: "Media, Journalism & Communications",
        system_prompt: "You are Hearst, specialized in media, journalism, and communications. \
Analyze queries through the lens of media literacy, information ecosystems, \
narrative framing, and public discourse. Evaluate information sources and \
communication strategies. If the query falls outside your domain, state that \
briefly and focus on any media-related insights.",
        tools: &["read", "web_search"],
        is_core: false,
    },
];

/// Build the routing prompt for Captain to select agents.
pub fn routing_prompt(query: &str) -> String {
    let mut prompt = String::from(
        "You are the Captain coordinator for a multi-agent reasoning ensemble. \
Analyze the following query and determine which specialist agents should be activated.\n\n\
The core four agents (Captain, Harper, Benjamin, Lucas) are ALWAYS active.\n\
Select additional domain specialists ONLY when their expertise is clearly relevant.\n\n\
Available domain specialists:\n",
    );

    for role in ROLES.iter().filter(|r| !r.is_core) {
        prompt.push_str(&format!("- {} ({})\n", role.name, role.domain));
    }

    prompt.push_str(&format!(
        "\nQuery: {}\n\n\
Return ONLY a JSON array of agent names to activate (including the core four). Example:\n\
[\"Captain\", \"Harper\", \"Benjamin\", \"Lucas\", \"Curie\", \"Lovelace\"]\n\n\
Do not include any other text, just the JSON array.",
        query
    ));
    prompt
}

/// Build the synthesis prompt for Captain.
pub fn synthesis_prompt(query: &str, agent_outputs: &[(String, String, String)]) -> String {
    let mut prompt = format!(
        "You are the Captain synthesizer. Multiple specialist agents have analyzed the following query. \
Synthesize their insights into a unified, comprehensive answer.\n\n\
Original query: {}\n\n\
Agent outputs:\n\n",
        query
    );

    for (name, domain, output) in agent_outputs {
        prompt.push_str(&format!("## {} ({})\n{}\n\n", name, domain, output));
    }

    prompt.push_str(
        "Synthesize these perspectives into a single, well-structured answer. \
Attribute key insights to their source agents where appropriate. \
Resolve any contradictions through careful reasoning. \
Indicate confidence levels where relevant.",
    );
    prompt
}

/// Build the debate/critique prompt.
pub fn critique_prompt(query: &str, synthesis: &str) -> String {
    format!(
        "The following synthesis was produced for the query below. \
Critically evaluate it: identify weaknesses, missing perspectives, errors, \
or areas that need more nuance. Be constructive and specific.\n\n\
Original query: {}\n\n\
Synthesis:\n{}\n\n\
Provide your critique concisely.",
        query, synthesis
    )
}

/// Build the re-synthesis prompt after debate.
pub fn resynthesis_prompt(
    query: &str,
    original_synthesis: &str,
    critiques: &[(String, String)],
) -> String {
    let mut prompt = format!(
        "You previously synthesized an answer for the query below. \
Multiple agents have critiqued your synthesis. Incorporate their feedback \
to produce an improved final answer.\n\n\
Original query: {}\n\n\
Your previous synthesis:\n{}\n\n\
Critiques:\n\n",
        query, original_synthesis
    );

    for (name, critique) in critiques {
        prompt.push_str(&format!("## {} critique\n{}\n\n", name, critique));
    }

    prompt.push_str("Produce an improved final answer incorporating the valid critiques.");
    prompt
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_all_roles_count() {
        assert_eq!(all_roles().len(), 16);
    }

    #[test]
    fn test_core_roles_count() {
        assert_eq!(core_roles().len(), 4);
    }

    #[test]
    fn test_role_by_name() {
        assert!(role_by_name("Captain").is_some());
        assert!(role_by_name("captain").is_some());
        assert!(role_by_name("Harper").is_some());
        assert!(role_by_name("nonexistent").is_none());
    }

    #[test]
    fn test_core_roles_are_correct() {
        let cores: Vec<&str> = core_roles().iter().map(|r| r.name).collect();
        assert!(cores.contains(&"Captain"));
        assert!(cores.contains(&"Harper"));
        assert!(cores.contains(&"Benjamin"));
        assert!(cores.contains(&"Lucas"));
    }

    #[test]
    fn test_unique_ids() {
        let ids: Vec<usize> = all_roles().iter().map(|r| r.id).collect();
        for i in 1..=16 {
            assert!(ids.contains(&i), "Missing ID {}", i);
        }
    }

    #[test]
    fn test_routing_prompt_contains_query() {
        let prompt = routing_prompt("test query");
        assert!(prompt.contains("test query"));
        assert!(prompt.contains("JSON array"));
    }
}