bn/

prompt.rs

//! Structured agent prompt builder.
//!
//! Constructs a multi-section system prompt that gives agents the context
//! they need to implement a bean successfully. Ports the 11-section
//! architecture from the pi extension `prompt.ts` into Rust.
//!
//! Sections (in order):
//! 1. Project Rules
//! 2. Parent Context
//! 3. Sibling Discoveries
//! 4. Bean Assignment
//! 5. Concurrent Modification Warning
//! 6. Referenced Files
//! 7. Acceptance Criteria
//! 8. Pre-flight Check
//! 9. Previous Attempts
//! 10. Approach
//! 11. Verify Gate
//! 12. Constraints
//! 13. Tool Strategy

use std::path::{Path, PathBuf};

use anyhow::Result;
use regex::Regex;
use std::sync::LazyLock;

use crate::bean::{AttemptOutcome, Bean, Status};
use crate::config::Config;
use crate::ctx_assembler::{extract_paths, read_file};
use crate::discovery::find_bean_file;
use crate::index::Index;

// ---------------------------------------------------------------------------
// Public types
// ---------------------------------------------------------------------------

/// Result of building an agent prompt.
pub struct PromptResult {
    /// The full system prompt containing all context sections.
    pub system_prompt: String,
    /// The user message instructing the agent what to do.
    pub user_message: String,
    /// Path to the bean file, for @file injection by the caller.
    pub file_ref: String,
}

/// Options for prompt construction.
pub struct PromptOptions {
    /// Path to the `.beans/` directory.
    pub beans_dir: PathBuf,
    /// Optional instructions to prepend to the user message.
    pub instructions: Option<String>,
    /// Beans running concurrently that share files with this bean.
    pub concurrent_overlaps: Option<Vec<FileOverlap>>,
}

/// Describes a concurrent bean that overlaps on files.
pub struct FileOverlap {
    /// ID of the overlapping bean.
    pub bean_id: String,
    /// Title of the overlapping bean.
    pub title: String,
    /// File paths shared between the two beans.
    pub shared_files: Vec<String>,
}

// ---------------------------------------------------------------------------
// Constants
// ---------------------------------------------------------------------------

/// Max characters per parent body.
const PARENT_CHAR_CAP: usize = 2000;

/// Max total characters across all ancestors.
const TOTAL_ANCESTOR_CHAR_CAP: usize = 3000;

/// Max total characters from sibling discovery notes.
const DISCOVERY_CHAR_CAP: usize = 1500;

/// Max total characters of file content to embed in the prompt.
const FILE_CONTENT_CHAR_CAP: usize = 8000;

/// Pattern to detect discovery notes in bean notes.
static DISCOVERY_PATTERN: LazyLock<Regex> =
    LazyLock::new(|| Regex::new(r"(?i)discover").expect("Invalid discovery regex"));

/// Keywords near a path that hint the file is a modify/create target.
static PRIORITY_KEYWORDS: LazyLock<Regex> = LazyLock::new(|| {
    Regex::new(r"(?i)\b(modify|create|add|edit|update|change|implement|write)\b")
        .expect("Invalid priority keywords regex")
});

// ---------------------------------------------------------------------------
// Public API
// ---------------------------------------------------------------------------

/// Build the full structured agent prompt for a bean.
///
/// Returns a [`PromptResult`] containing the system prompt, user message,
/// and bean file path. The system prompt is assembled from up to 13 sections
/// that give the agent everything it needs to implement the bean.
pub fn build_agent_prompt(bean: &Bean, options: &PromptOptions) -> Result<PromptResult> {
    let beans_dir = &options.beans_dir;
    let mut sections: Vec<String> = Vec::new();

    // 1. Project Rules
    if let Some(rules) = load_rules(beans_dir) {
        sections.push(format!("# Project Rules\n\n{}", rules));
    }

    // 2. Parent Context
    let parent_sections = collect_parent_context(bean, beans_dir);
    for section in parent_sections {
        sections.push(section);
    }

    // 3. Sibling Discoveries
    if let Some(discoveries) = collect_sibling_discoveries(bean, beans_dir) {
        sections.push(discoveries);
    }

    // 4. Bean Assignment
    sections.push(format!(
        "# Bean Assignment\n\nYou are implementing bean {}: {}",
        bean.id, bean.title
    ));

    // 5. Concurrent Modification Warning
    if let Some(ref overlaps) = options.concurrent_overlaps {
        if !overlaps.is_empty() {
            sections.push(format_concurrent_warning(overlaps));
        }
    }

    // 6. Referenced Files
    let project_dir = beans_dir.parent().unwrap_or(Path::new("."));
    let description = bean.description.as_deref().unwrap_or("");
    if let Some(file_context) = assemble_file_context(description, project_dir) {
        sections.push(file_context);
    }

    // 7. Acceptance Criteria
    if let Some(ref acceptance) = bean.acceptance {
        sections.push(format!(
            "# Acceptance Criteria (must ALL be true)\n\n{}",
            acceptance
        ));
    }

    // 8. Pre-flight Check
    if let Some(ref verify) = bean.verify {
        sections.push(format!(
            "# Pre-flight Check\n\n\
             Before implementing, run the verify command to confirm it currently FAILS:\n\
             ```\n{}\n```\n\
             If it errors for infrastructure reasons (missing deps, wrong path), fix that first.",
            verify
        ));
    }

    // 9. Previous Attempts
    if bean.attempts > 0 {
        sections.push(format_previous_attempts(bean));
    }

    // 10. Approach
    sections.push(format_approach(&bean.id));

    // 11. Verify Gate
    sections.push(format_verify_gate(bean));

    // 12. Constraints
    sections.push(format_constraints(&bean.id));

    // 13. Tool Strategy
    sections.push(format_tool_strategy());

    // Assemble system prompt
    let system_prompt = sections.join("\n\n---\n\n");

    // User message
    let mut user_message = String::new();
    if let Some(ref instructions) = options.instructions {
        user_message.push_str(instructions);
        user_message.push_str("\n\n");
    }
    user_message.push_str(&format!(
        "implement this bean and run bn close {} when done",
        bean.id
    ));

    // File reference
    let file_ref = find_bean_file(beans_dir, &bean.id)
        .map(|p| format!("@{}", p.display()))
        .unwrap_or_default();

    Ok(PromptResult {
        system_prompt,
        user_message,
        file_ref,
    })
}

// ---------------------------------------------------------------------------
// Section builders
// ---------------------------------------------------------------------------

/// Load project rules from `.beans/RULES.md` (or configured path).
fn load_rules(beans_dir: &Path) -> Option<String> {
    let config = Config::load(beans_dir).ok()?;
    let rules_path = config.rules_path(beans_dir);
    let content = std::fs::read_to_string(&rules_path).ok()?;
    let trimmed = content.trim();
    if trimmed.is_empty() {
        return None;
    }
    Some(content)
}

/// Walk up the parent chain and collect context sections.
///
/// Returns sections in outermost-first order (grandparent before parent).
/// Each parent body is capped at [`PARENT_CHAR_CAP`]; total ancestor
/// context is capped at [`TOTAL_ANCESTOR_CHAR_CAP`].
fn collect_parent_context(bean: &Bean, beans_dir: &Path) -> Vec<String> {
    let Some(ref first_parent) = bean.parent else {
        return Vec::new();
    };

    let mut sections = Vec::new();
    let mut total_chars: usize = 0;
    let mut current_id = Some(first_parent.clone());

    while let Some(id) = current_id {
        if total_chars >= TOTAL_ANCESTOR_CHAR_CAP {
            break;
        }

        let parent = match load_bean(beans_dir, &id) {
            Some(b) => b,
            None => break,
        };

        let body = match parent.description {
            Some(ref d) if !d.trim().is_empty() => d.clone(),
            _ => break,
        };

        let remaining = TOTAL_ANCESTOR_CHAR_CAP - total_chars;
        let char_limit = PARENT_CHAR_CAP.min(remaining);
        let trimmed = truncate_text(&body, char_limit);

        sections.push(format!(
            "# Parent Context (bean {}: {})\n\n{}",
            parent.id, parent.title, trimmed
        ));

        total_chars += trimmed.len();
        current_id = parent.parent.clone();
    }

    // Reverse so grandparent appears before parent (outermost context first)
    sections.reverse();
    sections
}

/// Collect discovery notes from closed sibling beans.
///
/// Reads siblings (children of the same parent) and extracts notes
/// containing "discover" from closed siblings. Caps total context
/// at [`DISCOVERY_CHAR_CAP`].
fn collect_sibling_discoveries(bean: &Bean, beans_dir: &Path) -> Option<String> {
    let parent_id = bean.parent.as_ref()?;

    let index = Index::load_or_rebuild(beans_dir).ok()?;

    // Find closed siblings (same parent, not self)
    let closed_siblings: Vec<_> = index
        .beans
        .iter()
        .filter(|e| {
            e.id != bean.id && e.parent.as_deref() == Some(parent_id) && e.status == Status::Closed
        })
        .collect();

    if closed_siblings.is_empty() {
        return None;
    }

    let mut parts = Vec::new();
    let mut total_chars: usize = 0;

    for sibling in &closed_siblings {
        if total_chars >= DISCOVERY_CHAR_CAP {
            break;
        }

        let sibling_bean = match load_bean(beans_dir, &sibling.id) {
            Some(b) => b,
            None => continue,
        };

        let notes = match sibling_bean.notes {
            Some(ref n) if !n.trim().is_empty() => n.clone(),
            _ => continue,
        };

        if !DISCOVERY_PATTERN.is_match(&notes) {
            continue;
        }

        let remaining = DISCOVERY_CHAR_CAP - total_chars;
        let trimmed = truncate_text(&notes, remaining);

        parts.push(format!(
            "## From bean {} ({}):\n{}",
            sibling.id, sibling.title, trimmed
        ));
        total_chars += trimmed.len();
    }

    if parts.is_empty() {
        return None;
    }

    Some(format!(
        "# Discoveries from completed siblings\n\n{}",
        parts.join("\n\n")
    ))
}

/// Format the concurrent modification warning section.
fn format_concurrent_warning(overlaps: &[FileOverlap]) -> String {
    let mut lines = Vec::new();
    for overlap in overlaps {
        let files = overlap.shared_files.join(", ");
        lines.push(format!(
            "- Bean {} ({}) may also be modifying: {}",
            overlap.bean_id, overlap.title, files
        ));
    }

    format!(
        "# Concurrent Modification Warning\n\n\
         The following beans are running in parallel and share files with your bean:\n\n\
         {}\n\n\
         Be careful with overwrites. Prefer surgical Edit operations over full Write.\n\
         If you must rewrite a file, read it immediately before writing to avoid clobbering concurrent changes.",
        lines.join("\n")
    )
}

/// Assemble referenced file contents from the bean description.
///
/// Extracts file paths from the description text, reads their contents
/// from the project directory, and assembles them into a markdown section.
/// Files near priority keywords (modify, create, etc.) are listed first.
/// Total content is capped at [`FILE_CONTENT_CHAR_CAP`].
fn assemble_file_context(description: &str, project_dir: &Path) -> Option<String> {
    let paths = extract_prioritized_paths(description);
    if paths.is_empty() {
        return None;
    }

    let canonical_base = project_dir.canonicalize().ok()?;
    let mut file_sections = Vec::new();
    let mut total_chars: usize = 0;

    for file_path in &paths {
        if total_chars >= FILE_CONTENT_CHAR_CAP {
            break;
        }

        let full_path = project_dir.join(file_path);
        let canonical = match full_path.canonicalize() {
            Ok(c) => c,
            Err(_) => continue, // file doesn't exist
        };

        // Stay within project directory
        if !canonical.starts_with(&canonical_base) {
            continue;
        }

        // Skip directories
        if canonical.is_dir() {
            continue;
        }

        let content = match read_file(&canonical) {
            Ok(c) => c,
            Err(_) => continue,
        };

        let remaining = FILE_CONTENT_CHAR_CAP - total_chars;
        let content = if content.len() > remaining {
            let mut truncated = content[..remaining].to_string();
            truncated.push_str("\n\n[…truncated]");
            truncated
        } else {
            content
        };

        let lang = detect_language(file_path);
        file_sections.push(format!("## {}\n```{}\n{}\n```", file_path, lang, content));
        total_chars += content.len();
    }

    if file_sections.is_empty() {
        return None;
    }

    Some(format!(
        "# Referenced Files\n\n{}",
        file_sections.join("\n\n")
    ))
}

/// Format the previous attempts section.
fn format_previous_attempts(bean: &Bean) -> String {
    let mut section = format!("# Previous Attempts ({} so far)", bean.attempts);

    // Include bean notes
    if let Some(ref notes) = bean.notes {
        let trimmed = notes.trim();
        if !trimmed.is_empty() {
            section.push_str(&format!("\n\n{}", trimmed));
        }
    }

    // Include per-attempt notes from attempt_log
    for attempt in &bean.attempt_log {
        if let Some(ref notes) = attempt.notes {
            let trimmed = notes.trim();
            if !trimmed.is_empty() {
                let outcome = match attempt.outcome {
                    AttemptOutcome::Success => "success",
                    AttemptOutcome::Failed => "failed",
                    AttemptOutcome::Abandoned => "abandoned",
                };
                let agent_str = attempt
                    .agent
                    .as_deref()
                    .map(|a| format!(" ({})", a))
                    .unwrap_or_default();
                section.push_str(&format!(
                    "\n\nAttempt #{}{} [{}]: {}",
                    attempt.num, agent_str, outcome, trimmed
                ));
            }
        }
    }

    section.push_str(
        "\n\nIMPORTANT: Do NOT repeat the same approach. \
         The notes above explain what was tried.\n\
         Read them carefully before starting.",
    );

    section
}

/// Format the approach section with numbered workflow.
fn format_approach(bean_id: &str) -> String {
    format!(
        "# Approach\n\n\
         1. Read the bean description carefully — it IS your spec\n\
         2. Understand the acceptance criteria before writing code\n\
         3. Read referenced files to understand existing patterns\n\
         4. Implement changes file by file\n\
         5. Run the verify command to check your work\n\
         6. If verify passes, run: bn close {id}\n\
         7. After closing, share what you learned:\n   \
            bn update {id} --note \"Discoveries: <brief notes about patterns, conventions, \
            or gotchas you found that might help sibling beans>\"\n\
         8. If verify fails, fix and retry\n\
         9. If stuck after 3 attempts, run: bn update {id} --note \"Stuck: <explanation>\"",
        id = bean_id
    )
}

/// Format the verify gate section.
fn format_verify_gate(bean: &Bean) -> String {
    if let Some(ref verify) = bean.verify {
        format!(
            "# Verify Gate\n\n\
             Your verify command is:\n\
             ```\n{}\n```\n\
             This MUST exit 0 for the bean to close. Test it before declaring done.",
            verify
        )
    } else {
        format!(
            "# Verify Gate\n\n\
             No verify command is set for this bean.\n\
             When all acceptance criteria are met, run: bn close {}",
            bean.id
        )
    }
}

/// Format the constraints section.
fn format_constraints(bean_id: &str) -> String {
    format!(
        "# Constraints\n\n\
         - Only modify files mentioned in the description unless clearly necessary\n\
         - Don't add dependencies without justification\n\
         - Preserve existing tests\n\
         - Run the project's test/build commands before closing\n\
         - When complete, run: bn close {}",
        bean_id
    )
}

/// Format the tool strategy section.
fn format_tool_strategy() -> String {
    "# Tool Strategy\n\n\
     - Use probe_search for semantic code search, rg for exact text matching\n\
     - Read files before editing — never edit blind\n\
     - Use Edit for surgical changes, Write for new files\n\
     - Use Bash to run tests and verify commands"
        .to_string()
}

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

/// Truncate text to a character limit, appending an ellipsis if trimmed.
fn truncate_text(text: &str, limit: usize) -> String {
    if text.len() <= limit {
        return text.to_string();
    }
    let mut result = text[..limit].to_string();
    result.push_str("\n\n[…truncated]");
    result
}

/// Extract file paths from description text, prioritized by action keywords.
///
/// Paths on lines containing words like "modify", "create", "add" come first,
/// followed by other referenced paths.
fn extract_prioritized_paths(description: &str) -> Vec<String> {
    let mut seen = std::collections::HashSet::new();
    let mut prioritized = Vec::new();
    let mut normal = Vec::new();

    for line in description.lines() {
        let line_paths = extract_paths(line);
        let is_priority = PRIORITY_KEYWORDS.is_match(line);

        for p in line_paths {
            if seen.insert(p.clone()) {
                if is_priority {
                    prioritized.push(p);
                } else {
                    normal.push(p);
                }
            }
        }
    }

    prioritized.extend(normal);
    prioritized
}

/// Detect programming language from file extension for code fence tagging.
fn detect_language(path: &str) -> &'static str {
    match Path::new(path).extension().and_then(|e| e.to_str()) {
        Some("rs") => "rust",
        Some("ts") => "typescript",
        Some("tsx") => "typescript",
        Some("js") => "javascript",
        Some("jsx") => "javascript",
        Some("py") => "python",
        Some("md") => "markdown",
        Some("json") => "json",
        Some("toml") => "toml",
        Some("yaml") | Some("yml") => "yaml",
        Some("sh") => "bash",
        Some("go") => "go",
        Some("java") => "java",
        Some("css") => "css",
        Some("html") => "html",
        Some("sql") => "sql",
        Some("c") => "c",
        Some("cpp") => "cpp",
        Some("h") => "c",
        Some("hpp") => "cpp",
        Some("rb") => "ruby",
        Some("php") => "php",
        Some("swift") => "swift",
        Some("kt") => "kotlin",
        _ => "",
    }
}

/// Load a bean by ID, returning None on any error.
fn load_bean(beans_dir: &Path, id: &str) -> Option<Bean> {
    let path = find_bean_file(beans_dir, id).ok()?;
    Bean::from_file(&path).ok()
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

#[cfg(test)]
mod tests {
    use super::*;
    use crate::bean::{AttemptOutcome, AttemptRecord, Bean};
    use std::fs;
    use tempfile::TempDir;

    /// Create a test environment with .beans/ directory and minimal config.
    fn setup_test_env() -> (TempDir, PathBuf) {
        let dir = TempDir::new().unwrap();
        let beans_dir = dir.path().join(".beans");
        fs::create_dir(&beans_dir).unwrap();
        fs::write(
            beans_dir.join("config.yaml"),
            "project: test\nnext_id: 100\n",
        )
        .unwrap();
        (dir, beans_dir)
    }

    /// Write a bean to the .beans/ directory with standard naming.
    fn write_test_bean(beans_dir: &Path, bean: &Bean) {
        let slug = crate::util::title_to_slug(&bean.title);
        let path = beans_dir.join(format!("{}-{}.md", bean.id, slug));
        bean.to_file(&path).unwrap();
    }

    // -- truncate_text --

    #[test]
    fn truncate_text_short() {
        assert_eq!(truncate_text("hello", 100), "hello");
    }

    #[test]
    fn truncate_text_at_limit() {
        assert_eq!(truncate_text("hello", 5), "hello");
    }

    #[test]
    fn truncate_text_over_limit() {
        let result = truncate_text("hello world", 5);
        assert!(result.starts_with("hello"));
        assert!(result.contains("[…truncated]"));
    }

    // -- detect_language --

    #[test]
    fn detect_language_known_extensions() {
        assert_eq!(detect_language("src/main.rs"), "rust");
        assert_eq!(detect_language("index.ts"), "typescript");
        assert_eq!(detect_language("app.tsx"), "typescript");
        assert_eq!(detect_language("script.py"), "python");
        assert_eq!(detect_language("config.json"), "json");
        assert_eq!(detect_language("Cargo.toml"), "toml");
        assert_eq!(detect_language("config.yaml"), "yaml");
        assert_eq!(detect_language("config.yml"), "yaml");
        assert_eq!(detect_language("deploy.sh"), "bash");
        assert_eq!(detect_language("main.go"), "go");
        assert_eq!(detect_language("Main.java"), "java");
        assert_eq!(detect_language("style.css"), "css");
        assert_eq!(detect_language("page.html"), "html");
        assert_eq!(detect_language("query.sql"), "sql");
    }

    #[test]
    fn detect_language_unknown_extension() {
        assert_eq!(detect_language("file.xyz"), "");
        assert_eq!(detect_language("Makefile"), "");
    }

    // -- extract_prioritized_paths --

    #[test]
    fn prioritized_paths_modify_first() {
        let desc = "Read src/lib.rs for context\nModify src/main.rs to add feature";
        let paths = extract_prioritized_paths(desc);
        assert_eq!(paths, vec!["src/main.rs", "src/lib.rs"]);
    }

    #[test]
    fn prioritized_paths_create_first() {
        let desc = "Check src/old.rs\nCreate src/new.rs with the new module";
        let paths = extract_prioritized_paths(desc);
        assert_eq!(paths, vec!["src/new.rs", "src/old.rs"]);
    }

    #[test]
    fn prioritized_paths_deduplicates() {
        let desc = "Modify src/main.rs\nAlso read src/main.rs for context";
        let paths = extract_prioritized_paths(desc);
        assert_eq!(paths, vec!["src/main.rs"]);
    }

    #[test]
    fn prioritized_paths_no_keywords() {
        let desc = "See src/foo.rs and src/bar.rs";
        let paths = extract_prioritized_paths(desc);
        assert_eq!(paths, vec!["src/foo.rs", "src/bar.rs"]);
    }

    #[test]
    fn prioritized_paths_empty() {
        let paths = extract_prioritized_paths("No files here");
        assert!(paths.is_empty());
    }

    // -- load_rules --

    #[test]
    fn load_rules_returns_none_when_missing() {
        let (_dir, beans_dir) = setup_test_env();
        let result = load_rules(&beans_dir);
        assert!(result.is_none());
    }

    #[test]
    fn load_rules_returns_none_when_empty() {
        let (_dir, beans_dir) = setup_test_env();
        fs::write(beans_dir.join("RULES.md"), "   \n  ").unwrap();
        let result = load_rules(&beans_dir);
        assert!(result.is_none());
    }

    #[test]
    fn load_rules_returns_content() {
        let (_dir, beans_dir) = setup_test_env();
        fs::write(beans_dir.join("RULES.md"), "# Rules\nNo unwrap.\n").unwrap();
        let result = load_rules(&beans_dir);
        assert!(result.is_some());
        assert!(result.unwrap().contains("No unwrap."));
    }

    // -- collect_parent_context --

    #[test]
    fn parent_context_no_parent() {
        let (_dir, beans_dir) = setup_test_env();
        let bean = Bean::new("1", "No parent");
        let sections = collect_parent_context(&bean, &beans_dir);
        assert!(sections.is_empty());
    }

    #[test]
    fn parent_context_single_parent() {
        let (_dir, beans_dir) = setup_test_env();

        // Create parent bean
        let mut parent = Bean::new("1", "Parent Task");
        parent.description = Some("This is the parent goal.".to_string());
        write_test_bean(&beans_dir, &parent);

        // Create child referencing parent
        let mut child = Bean::new("1.1", "Child Task");
        child.parent = Some("1".to_string());
        write_test_bean(&beans_dir, &child);

        let sections = collect_parent_context(&child, &beans_dir);
        assert_eq!(sections.len(), 1);
        assert!(sections[0].contains("Parent Context"));
        assert!(sections[0].contains("bean 1: Parent Task"));
        assert!(sections[0].contains("parent goal"));
    }

    #[test]
    fn parent_context_grandparent_appears_first() {
        let (_dir, beans_dir) = setup_test_env();

        // Grandparent
        let mut grandparent = Bean::new("1", "Grandparent");
        grandparent.description = Some("Grand context.".to_string());
        write_test_bean(&beans_dir, &grandparent);

        // Parent
        let mut parent = Bean::new("1.1", "Parent");
        parent.parent = Some("1".to_string());
        parent.description = Some("Parent context.".to_string());
        write_test_bean(&beans_dir, &parent);

        // Child
        let mut child = Bean::new("1.1.1", "Child");
        child.parent = Some("1.1".to_string());

        let sections = collect_parent_context(&child, &beans_dir);
        assert_eq!(sections.len(), 2);
        // Grandparent should appear first (reversed order)
        assert!(sections[0].contains("Grandparent"));
        assert!(sections[1].contains("Parent"));
    }

    #[test]
    fn parent_context_caps_total_chars() {
        let (_dir, beans_dir) = setup_test_env();

        // Create a parent with a very long description
        let mut parent = Bean::new("1", "Verbose Parent");
        parent.description = Some("x".repeat(5000));
        write_test_bean(&beans_dir, &parent);

        let mut child = Bean::new("1.1", "Child");
        child.parent = Some("1".to_string());

        let sections = collect_parent_context(&child, &beans_dir);
        assert_eq!(sections.len(), 1);
        // Body should be truncated
        assert!(sections[0].contains("[…truncated]"));
        // Total chars should respect PARENT_CHAR_CAP
        let body_start = sections[0].find("\n\n").unwrap() + 2;
        let body = &sections[0][body_start..];
        // Truncated body should be roughly PARENT_CHAR_CAP + truncation marker
        assert!(body.len() < PARENT_CHAR_CAP + 50);
    }

    // -- collect_sibling_discoveries --

    #[test]
    fn sibling_discoveries_no_parent() {
        let (_dir, beans_dir) = setup_test_env();
        let bean = Bean::new("1", "No parent");
        let result = collect_sibling_discoveries(&bean, &beans_dir);
        assert!(result.is_none());
    }

    #[test]
    fn sibling_discoveries_finds_closed_with_discover() {
        let (_dir, beans_dir) = setup_test_env();

        // Create parent
        let parent = Bean::new("1", "Parent");
        write_test_bean(&beans_dir, &parent);

        // Create closed sibling with discovery notes
        let mut sibling = Bean::new("1.1", "Sibling A");
        sibling.parent = Some("1".to_string());
        sibling.status = Status::Closed;
        sibling.notes = Some("Discoveries: the API uses snake_case".to_string());
        write_test_bean(&beans_dir, &sibling);

        // The bean under test
        let mut bean = Bean::new("1.2", "Current Bean");
        bean.parent = Some("1".to_string());
        write_test_bean(&beans_dir, &bean);

        // Need to rebuild index
        let _ = Index::build(&beans_dir).unwrap().save(&beans_dir);

        let result = collect_sibling_discoveries(&bean, &beans_dir);
        assert!(result.is_some());
        let text = result.unwrap();
        assert!(text.contains("Discoveries from completed siblings"));
        assert!(text.contains("snake_case"));
    }

    #[test]
    fn sibling_discoveries_skips_non_discover_notes() {
        let (_dir, beans_dir) = setup_test_env();

        let parent = Bean::new("1", "Parent");
        write_test_bean(&beans_dir, &parent);

        // Closed sibling without "discover" in notes
        let mut sibling = Bean::new("1.1", "Sibling");
        sibling.parent = Some("1".to_string());
        sibling.status = Status::Closed;
        sibling.notes = Some("Just regular notes about the task".to_string());
        write_test_bean(&beans_dir, &sibling);

        let mut bean = Bean::new("1.2", "Current");
        bean.parent = Some("1".to_string());
        write_test_bean(&beans_dir, &bean);

        let _ = Index::build(&beans_dir).unwrap().save(&beans_dir);

        let result = collect_sibling_discoveries(&bean, &beans_dir);
        assert!(result.is_none());
    }

    #[test]
    fn sibling_discoveries_skips_open_siblings() {
        let (_dir, beans_dir) = setup_test_env();

        let parent = Bean::new("1", "Parent");
        write_test_bean(&beans_dir, &parent);

        // Open sibling with discovery notes — should be skipped
        let mut sibling = Bean::new("1.1", "Open Sibling");
        sibling.parent = Some("1".to_string());
        sibling.status = Status::Open;
        sibling.notes = Some("Discoveries: something useful".to_string());
        write_test_bean(&beans_dir, &sibling);

        let mut bean = Bean::new("1.2", "Current");
        bean.parent = Some("1".to_string());
        write_test_bean(&beans_dir, &bean);

        let _ = Index::build(&beans_dir).unwrap().save(&beans_dir);

        let result = collect_sibling_discoveries(&bean, &beans_dir);
        assert!(result.is_none());
    }

    // -- format_concurrent_warning --

    #[test]
    fn concurrent_warning_single_overlap() {
        let overlaps = vec![FileOverlap {
            bean_id: "5".to_string(),
            title: "Other Task".to_string(),
            shared_files: vec!["src/main.rs".to_string()],
        }];
        let result = format_concurrent_warning(&overlaps);
        assert!(result.contains("Concurrent Modification Warning"));
        assert!(result.contains("Bean 5 (Other Task)"));
        assert!(result.contains("src/main.rs"));
    }

    #[test]
    fn concurrent_warning_multiple_overlaps() {
        let overlaps = vec![
            FileOverlap {
                bean_id: "5".to_string(),
                title: "Task A".to_string(),
                shared_files: vec!["src/a.rs".to_string(), "src/b.rs".to_string()],
            },
            FileOverlap {
                bean_id: "6".to_string(),
                title: "Task B".to_string(),
                shared_files: vec!["src/c.rs".to_string()],
            },
        ];
        let result = format_concurrent_warning(&overlaps);
        assert!(result.contains("Bean 5"));
        assert!(result.contains("Bean 6"));
        assert!(result.contains("src/a.rs, src/b.rs"));
    }

    // -- assemble_file_context --

    #[test]
    fn file_context_reads_existing_files() {
        let dir = TempDir::new().unwrap();
        let project_dir = dir.path();

        // Create a source file
        let src = project_dir.join("src");
        fs::create_dir(&src).unwrap();
        fs::write(src.join("main.rs"), "fn main() {}").unwrap();

        let desc = "Modify src/main.rs to add feature";
        let result = assemble_file_context(desc, project_dir);
        assert!(result.is_some());
        let text = result.unwrap();
        assert!(text.contains("# Referenced Files"));
        assert!(text.contains("## src/main.rs"));
        assert!(text.contains("```rust"));
        assert!(text.contains("fn main() {}"));
    }

    #[test]
    fn file_context_skips_missing_files() {
        let dir = TempDir::new().unwrap();
        let desc = "Read src/nonexistent.rs";
        let result = assemble_file_context(desc, dir.path());
        assert!(result.is_none());
    }

    #[test]
    fn file_context_caps_total_chars() {
        let dir = TempDir::new().unwrap();
        let project_dir = dir.path();
        let src = project_dir.join("src");
        fs::create_dir(&src).unwrap();

        // Create a large file
        fs::write(src.join("big.rs"), "x".repeat(20000)).unwrap();

        let desc = "Read src/big.rs";
        let result = assemble_file_context(desc, project_dir);
        assert!(result.is_some());
        let text = result.unwrap();
        assert!(text.contains("[…truncated]"));
        // Total content should be around FILE_CONTENT_CHAR_CAP
        assert!(text.len() < FILE_CONTENT_CHAR_CAP + 500);
    }

    #[test]
    fn file_context_no_paths() {
        let dir = TempDir::new().unwrap();
        let result = assemble_file_context("No file paths here", dir.path());
        assert!(result.is_none());
    }

    // -- format_previous_attempts --

    #[test]
    fn previous_attempts_with_notes() {
        let mut bean = Bean::new("1", "Test");
        bean.attempts = 2;
        bean.notes = Some("Tried approach X, it broke Y.".to_string());
        bean.attempt_log = vec![AttemptRecord {
            num: 1,
            outcome: AttemptOutcome::Failed,
            notes: Some("First try failed due to Z".to_string()),
            agent: Some("agent-1".to_string()),
            started_at: None,
            finished_at: None,
        }];

        let result = format_previous_attempts(&bean);
        assert!(result.contains("Previous Attempts (2 so far)"));
        assert!(result.contains("Tried approach X"));
        assert!(result.contains("Attempt #1 (agent-1) [failed]"));
        assert!(result.contains("First try failed"));
        assert!(result.contains("Do NOT repeat"));
    }

    #[test]
    fn previous_attempts_no_notes() {
        let mut bean = Bean::new("1", "Test");
        bean.attempts = 1;

        let result = format_previous_attempts(&bean);
        assert!(result.contains("Previous Attempts (1 so far)"));
        assert!(result.contains("Do NOT repeat"));
    }

    // -- format_approach --

    #[test]
    fn approach_contains_bean_id() {
        let result = format_approach("42");
        assert!(result.contains("bn close 42"));
        assert!(result.contains("bn update 42"));
    }

    // -- format_verify_gate --

    #[test]
    fn verify_gate_with_command() {
        let mut bean = Bean::new("1", "Test");
        bean.verify = Some("cargo test".to_string());
        let result = format_verify_gate(&bean);
        assert!(result.contains("cargo test"));
        assert!(result.contains("MUST exit 0"));
    }

    #[test]
    fn verify_gate_without_command() {
        let bean = Bean::new("1", "Test");
        let result = format_verify_gate(&bean);
        assert!(result.contains("No verify command"));
        assert!(result.contains("bn close 1"));
    }

    // -- format_constraints --

    #[test]
    fn constraints_contains_bean_id() {
        let result = format_constraints("7");
        assert!(result.contains("bn close 7"));
        assert!(result.contains("Don't add dependencies"));
    }

    // -- format_tool_strategy --

    #[test]
    fn tool_strategy_mentions_key_tools() {
        let result = format_tool_strategy();
        assert!(result.contains("probe_search"));
        assert!(result.contains("rg"));
        assert!(result.contains("Edit"));
        assert!(result.contains("Write"));
    }

    // -- build_agent_prompt integration --

    #[test]
    fn build_prompt_minimal_bean() {
        let (_dir, beans_dir) = setup_test_env();

        let mut bean = Bean::new("1", "Simple Task");
        bean.description = Some("Just do the thing.".to_string());
        bean.verify = Some("cargo test".to_string());
        write_test_bean(&beans_dir, &bean);

        let options = PromptOptions {
            beans_dir: beans_dir.clone(),
            instructions: None,
            concurrent_overlaps: None,
        };

        let result = build_agent_prompt(&bean, &options).unwrap();

        // System prompt should contain key sections
        assert!(result.system_prompt.contains("Bean Assignment"));
        assert!(result.system_prompt.contains("bean 1: Simple Task"));
        assert!(result.system_prompt.contains("Pre-flight Check"));
        assert!(result.system_prompt.contains("cargo test"));
        assert!(result.system_prompt.contains("Verify Gate"));
        assert!(result.system_prompt.contains("Approach"));
        assert!(result.system_prompt.contains("Constraints"));
        assert!(result.system_prompt.contains("Tool Strategy"));

        // Sections should be separated by ---
        assert!(result.system_prompt.contains("---"));

        // User message should contain close instruction
        assert!(result.user_message.contains("bn close 1"));

        // File ref should point to the bean file
        assert!(result.file_ref.contains("1-simple-task.md"));
    }

    #[test]
    fn build_prompt_with_instructions() {
        let (_dir, beans_dir) = setup_test_env();

        let bean = Bean::new("1", "Task");
        write_test_bean(&beans_dir, &bean);

        let options = PromptOptions {
            beans_dir: beans_dir.clone(),
            instructions: Some("Focus on performance".to_string()),
            concurrent_overlaps: None,
        };

        let result = build_agent_prompt(&bean, &options).unwrap();
        assert!(result.user_message.starts_with("Focus on performance"));
        assert!(result.user_message.contains("bn close 1"));
    }

    #[test]
    fn build_prompt_with_rules() {
        let (_dir, beans_dir) = setup_test_env();
        fs::write(beans_dir.join("RULES.md"), "# Style\nUse snake_case.\n").unwrap();

        let bean = Bean::new("1", "Task");
        write_test_bean(&beans_dir, &bean);

        let options = PromptOptions {
            beans_dir: beans_dir.clone(),
            instructions: None,
            concurrent_overlaps: None,
        };

        let result = build_agent_prompt(&bean, &options).unwrap();
        assert!(result.system_prompt.contains("Project Rules"));
        assert!(result.system_prompt.contains("snake_case"));
    }

    #[test]
    fn build_prompt_with_acceptance_criteria() {
        let (_dir, beans_dir) = setup_test_env();

        let mut bean = Bean::new("1", "Task");
        bean.acceptance = Some("All tests pass\nNo warnings".to_string());
        write_test_bean(&beans_dir, &bean);

        let options = PromptOptions {
            beans_dir: beans_dir.clone(),
            instructions: None,
            concurrent_overlaps: None,
        };

        let result = build_agent_prompt(&bean, &options).unwrap();
        assert!(result.system_prompt.contains("Acceptance Criteria"));
        assert!(result.system_prompt.contains("All tests pass"));
        assert!(result.system_prompt.contains("No warnings"));
    }

    #[test]
    fn build_prompt_with_concurrent_overlaps() {
        let (_dir, beans_dir) = setup_test_env();

        let bean = Bean::new("1", "Task");
        write_test_bean(&beans_dir, &bean);

        let options = PromptOptions {
            beans_dir: beans_dir.clone(),
            instructions: None,
            concurrent_overlaps: Some(vec![FileOverlap {
                bean_id: "2".to_string(),
                title: "Other".to_string(),
                shared_files: vec!["src/shared.rs".to_string()],
            }]),
        };

        let result = build_agent_prompt(&bean, &options).unwrap();
        assert!(result
            .system_prompt
            .contains("Concurrent Modification Warning"));
        assert!(result.system_prompt.contains("Bean 2 (Other)"));
    }

    #[test]
    fn build_prompt_with_previous_attempts() {
        let (_dir, beans_dir) = setup_test_env();

        let mut bean = Bean::new("1", "Retry Task");
        bean.attempts = 2;
        bean.notes = Some("Tried X, failed due to Y.".to_string());
        write_test_bean(&beans_dir, &bean);

        let options = PromptOptions {
            beans_dir: beans_dir.clone(),
            instructions: None,
            concurrent_overlaps: None,
        };

        let result = build_agent_prompt(&bean, &options).unwrap();
        assert!(result.system_prompt.contains("Previous Attempts"));
        assert!(result.system_prompt.contains("Tried X"));
        assert!(result.system_prompt.contains("Do NOT repeat"));
    }

    #[test]
    fn build_prompt_no_verify() {
        let (_dir, beans_dir) = setup_test_env();

        let bean = Bean::new("1", "No Verify");
        write_test_bean(&beans_dir, &bean);

        let options = PromptOptions {
            beans_dir: beans_dir.clone(),
            instructions: None,
            concurrent_overlaps: None,
        };

        let result = build_agent_prompt(&bean, &options).unwrap();
        // Should not have pre-flight check
        assert!(!result.system_prompt.contains("Pre-flight Check"));
        // Verify gate should say no command
        assert!(result.system_prompt.contains("No verify command"));
    }

    #[test]
    fn build_prompt_with_file_references() {
        let (dir, beans_dir) = setup_test_env();
        let project_dir = dir.path();

        // Create source files
        let src = project_dir.join("src");
        fs::create_dir(&src).unwrap();
        fs::write(src.join("lib.rs"), "pub mod utils;").unwrap();
        fs::write(src.join("utils.rs"), "pub fn helper() {}").unwrap();

        let mut bean = Bean::new("1", "Task");
        bean.description =
            Some("Modify src/lib.rs to export new module\nRead src/utils.rs".to_string());
        write_test_bean(&beans_dir, &bean);

        let options = PromptOptions {
            beans_dir: beans_dir.clone(),
            instructions: None,
            concurrent_overlaps: None,
        };

        let result = build_agent_prompt(&bean, &options).unwrap();
        assert!(result.system_prompt.contains("Referenced Files"));
        assert!(result.system_prompt.contains("src/lib.rs"));
        assert!(result.system_prompt.contains("pub mod utils;"));
    }

    #[test]
    fn build_prompt_section_order() {
        let (dir, beans_dir) = setup_test_env();
        let project_dir = dir.path();

        // Write rules
        fs::write(beans_dir.join("RULES.md"), "# Rules\nBe nice.").unwrap();

        // Create parent
        let mut parent = Bean::new("1", "Parent");
        parent.description = Some("Parent goal.".to_string());
        write_test_bean(&beans_dir, &parent);

        // Create source file
        let src = project_dir.join("src");
        fs::create_dir(&src).unwrap();
        fs::write(src.join("main.rs"), "fn main() {}").unwrap();

        // Create child bean with all features
        let mut bean = Bean::new("1.1", "Child Task");
        bean.parent = Some("1".to_string());
        bean.description = Some("Modify src/main.rs".to_string());
        bean.acceptance = Some("Tests pass".to_string());
        bean.verify = Some("cargo test".to_string());
        bean.attempts = 1;
        bean.notes = Some("Tried something".to_string());
        write_test_bean(&beans_dir, &bean);

        let _ = Index::build(&beans_dir).unwrap().save(&beans_dir);

        let options = PromptOptions {
            beans_dir: beans_dir.clone(),
            instructions: None,
            concurrent_overlaps: None,
        };

        let result = build_agent_prompt(&bean, &options).unwrap();
        let prompt = &result.system_prompt;

        // Verify section ordering by finding positions
        let rules_pos = prompt.find("# Project Rules").unwrap();
        let parent_pos = prompt.find("# Parent Context").unwrap();
        let assignment_pos = prompt.find("# Bean Assignment").unwrap();
        let files_pos = prompt.find("# Referenced Files").unwrap();
        let acceptance_pos = prompt.find("# Acceptance Criteria").unwrap();
        let preflight_pos = prompt.find("# Pre-flight Check").unwrap();
        let attempts_pos = prompt.find("# Previous Attempts").unwrap();
        let approach_pos = prompt.find("# Approach").unwrap();
        let verify_pos = prompt.find("# Verify Gate").unwrap();
        let constraints_pos = prompt.find("# Constraints").unwrap();
        let tools_pos = prompt.find("# Tool Strategy").unwrap();

        assert!(rules_pos < parent_pos, "Rules before Parent");
        assert!(parent_pos < assignment_pos, "Parent before Assignment");
        assert!(assignment_pos < files_pos, "Assignment before Files");
        assert!(files_pos < acceptance_pos, "Files before Acceptance");
        assert!(
            acceptance_pos < preflight_pos,
            "Acceptance before Preflight"
        );
        assert!(preflight_pos < attempts_pos, "Preflight before Attempts");
        assert!(attempts_pos < approach_pos, "Attempts before Approach");
        assert!(approach_pos < verify_pos, "Approach before Verify");
        assert!(verify_pos < constraints_pos, "Verify before Constraints");
        assert!(constraints_pos < tools_pos, "Constraints before Tools");
    }
}