edda-pack 0.6.2

use edda_index::{fetch_store_line, read_index_tail, IndexRecordV1};
use edda_ledger::view::DecisionView;
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, HashMap, HashSet};
use std::path::Path;

const DEFAULT_INDEX_TAIL_LINES: usize = 5000;
const DEFAULT_INDEX_TAIL_MAX_BYTES: u64 = 8 * 1024 * 1024; // 8MB
const DEFAULT_PACK_TURNS: usize = 12;
const DEFAULT_PACK_BUDGET_CHARS: usize = 12000;

// ── Turn + ToolUse structs ──

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Turn {
    pub user_uuid: String,
    pub assistant_uuid: String,
    pub user_text: String,
    pub assistant_texts: Vec<String>,
    pub tool_uses: Vec<ToolUse>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ToolUse {
    pub id: Option<String>,
    pub name: String,
    pub command: Option<String>,
    pub description: Option<String>,
    pub file_path: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PackMetadata {
    pub project_id: String,
    pub session_id: String,
    pub git_branch: String,
    pub turn_count: usize,
    pub budget_chars: usize,
}

// ── Turn alignment via uuid/parentUuid ──

/// Build turns from index records by matching assistant.parentUuid → user.uuid.
pub fn build_turns(
    project_dir: &Path,
    session_id: &str,
    max_turns: usize,
) -> anyhow::Result<Vec<Turn>> {
    let tail_lines: usize = std::env::var("EDDA_INDEX_TAIL_LINES")
        .ok()
        .and_then(|v| v.parse().ok())
        .unwrap_or(DEFAULT_INDEX_TAIL_LINES);
    let tail_bytes: u64 = std::env::var("EDDA_INDEX_TAIL_MAX_BYTES")
        .ok()
        .and_then(|v| v.parse().ok())
        .unwrap_or(DEFAULT_INDEX_TAIL_MAX_BYTES);
    let pack_turns: usize = std::env::var("EDDA_PACK_TURNS")
        .ok()
        .and_then(|v| v.parse().ok())
        .unwrap_or(DEFAULT_PACK_TURNS);
    let max_turns = max_turns.min(pack_turns);

    let index_path = project_dir
        .join("index")
        .join(format!("{session_id}.jsonl"));
    let records = read_index_tail(&index_path, tail_lines, tail_bytes)?;

    if records.is_empty() {
        return Ok(vec![]);
    }

    // Build lookup by uuid
    let by_uuid: HashMap<String, &IndexRecordV1> =
        records.iter().map(|r| (r.uuid.clone(), r)).collect();

    // Collect assistant records in order
    let assistants: Vec<&IndexRecordV1> = records
        .iter()
        .filter(|r| r.record_type == "assistant")
        .collect();

    let store_path = project_dir
        .join("transcripts")
        .join(format!("{session_id}.jsonl"));

    let mut turns = Vec::new();
    let mut seen_user_uuids = HashSet::new();

    // Process newest assistant first
    for asst_rec in assistants.iter().rev() {
        if turns.len() >= max_turns {
            break;
        }

        // Walk UP the parentUuid chain to find the real user prompt.
        // Claude Code transcript structure:
        //   user(STRING) → assistant(tool_use) → user(tool_result) → assistant(tool_use) → ... → assistant(text)
        // We start from the leaf assistant and walk up to find the root user with STRING content.
        let mut current_parent = asst_rec.parent_uuid.as_deref();
        let mut chain_tool_uses: Vec<ToolUse> = Vec::new();
        let mut real_user_uuid = String::new();
        let mut real_user_text = String::new();

        let mut depth = 0;
        const MAX_CHAIN_DEPTH: usize = 50;

        while let Some(parent_id) = current_parent {
            if depth >= MAX_CHAIN_DEPTH {
                break;
            }
            depth += 1;

            let parent_rec = match by_uuid.get(parent_id) {
                Some(r) => r,
                None => break,
            };

            if parent_rec.record_type == "user" {
                // Try to extract user text from this record
                if let Ok(raw) =
                    fetch_store_line(&store_path, parent_rec.store_offset, parent_rec.store_len)
                {
                    if let Ok(json) = serde_json::from_slice::<serde_json::Value>(&raw) {
                        let text = extract_user_text(&json);
                        if !text.is_empty() {
                            real_user_uuid = parent_rec.uuid.clone();
                            real_user_text = text;
                            break; // Found the real user prompt
                        }
                    }
                }
                // Content is array (tool_result) or empty → keep walking up
                current_parent = parent_rec.parent_uuid.as_deref();
            } else if parent_rec.record_type == "assistant" {
                // Intermediate assistant → collect its tool_uses
                if let Ok(raw) =
                    fetch_store_line(&store_path, parent_rec.store_offset, parent_rec.store_len)
                {
                    if let Ok(json) = serde_json::from_slice::<serde_json::Value>(&raw) {
                        let (_, tus) = parse_assistant_content(&json);
                        chain_tool_uses.extend(tus);
                    }
                }
                current_parent = parent_rec.parent_uuid.as_deref();
            } else {
                break; // unexpected record type
            }
        }

        if real_user_text.is_empty() || real_user_uuid.is_empty() {
            continue;
        }

        // Dedup: only one turn per real user prompt
        if !seen_user_uuids.insert(real_user_uuid.clone()) {
            continue;
        }

        // Parse final (leaf) assistant content
        let asst_raw =
            match fetch_store_line(&store_path, asst_rec.store_offset, asst_rec.store_len) {
                Ok(r) => r,
                Err(_) => continue,
            };
        let asst_json: serde_json::Value = match serde_json::from_slice(&asst_raw) {
            Ok(v) => v,
            Err(_) => continue,
        };
        let (assistant_texts, final_tool_uses) = parse_assistant_content(&asst_json);

        // Merge tool_uses: chain (reversed to chronological) + final assistant's
        chain_tool_uses.reverse();
        chain_tool_uses.extend(final_tool_uses);

        turns.push(Turn {
            user_uuid: real_user_uuid,
            assistant_uuid: asst_rec.uuid.clone(),
            user_text: real_user_text,
            assistant_texts,
            tool_uses: chain_tool_uses,
        });
    }

    Ok(turns)
}

/// Extract user text from a transcript user record.
/// Returns non-empty string only for real user prompts (STRING content).
/// Returns empty for tool_result arrays (these are tool execution results, not user input).
fn extract_user_text(user_json: &serde_json::Value) -> String {
    let content = match user_json.get("message").and_then(|m| m.get("content")) {
        Some(c) => c,
        None => return String::new(),
    };

    // String content → real user prompt
    if let Some(s) = content.as_str() {
        return s.to_string();
    }

    // Array content → check block types
    if let Some(arr) = content.as_array() {
        // If any block is tool_result, this is NOT a real user prompt
        let has_tool_result = arr
            .iter()
            .any(|b| b.get("type").and_then(|t| t.as_str()) == Some("tool_result"));
        if has_tool_result {
            return String::new();
        }

        // Extract text from text blocks (handles ARRAY(text) format)
        let texts: Vec<&str> = arr
            .iter()
            .filter_map(|b| {
                if b.get("type").and_then(|t| t.as_str()) == Some("text") {
                    b.get("text").and_then(|t| t.as_str())
                } else {
                    None
                }
            })
            .collect();
        if !texts.is_empty() {
            return texts.join(" ");
        }
    }

    String::new()
}

fn parse_assistant_content(asst_json: &serde_json::Value) -> (Vec<String>, Vec<ToolUse>) {
    let mut texts = Vec::new();
    let mut tool_uses = Vec::new();

    let content = asst_json.get("message").and_then(|m| m.get("content"));

    if let Some(arr) = content.and_then(|c| c.as_array()) {
        for block in arr {
            let block_type = block.get("type").and_then(|v| v.as_str()).unwrap_or("");
            match block_type {
                "text" => {
                    if let Some(text) = block.get("text").and_then(|v| v.as_str()) {
                        texts.push(text.to_string());
                    }
                }
                "tool_use" => {
                    let name = block
                        .get("name")
                        .and_then(|v| v.as_str())
                        .unwrap_or("")
                        .to_string();
                    let id = block.get("id").and_then(|v| v.as_str()).map(|s| s.into());
                    let input = block.get("input");
                    let command = input
                        .and_then(|i| i.get("command"))
                        .and_then(|c| c.as_str())
                        .map(|s| s.into());
                    let description = input
                        .and_then(|i| i.get("description"))
                        .and_then(|d| d.as_str())
                        .map(|s| s.into());
                    let file_path = input
                        .and_then(|i| i.get("file_path"))
                        .and_then(|f| f.as_str())
                        .map(|s| s.into());

                    tool_uses.push(ToolUse {
                        id,
                        name,
                        command,
                        description,
                        file_path,
                    });
                }
                _ => {}
            }
        }
    } else if let Some(text) = content.and_then(|c| c.as_str()) {
        texts.push(text.to_string());
    }

    (texts, tool_uses)
}

// ── Pack rendering ──

/// The stable section order for neutral memory-pack items.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum PackSection {
    Goals,
    BindingDecisions,
    UnratifiedDecisions,
    OpenCheckpoints,
    Constraints,
    Coordination,
    FileStateDeltas,
    RecentTurns,
}

impl PackSection {
    fn title(self) -> &'static str {
        match self {
            Self::Goals => "Goals",
            Self::BindingDecisions => "Binding Decisions",
            Self::UnratifiedDecisions => "Unratified Decisions",
            Self::OpenCheckpoints => "Open Checkpoints",
            Self::Constraints => "Constraints",
            Self::Coordination => "Coordination",
            Self::FileStateDeltas => "File-State Deltas",
            Self::RecentTurns => "Recent Turns (deterministic)",
        }
    }
}

/// A complete, neutral item in a memory pack.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PackItem {
    pub section: PackSection,
    pub key: String,
    pub body: String,
    pub salience: u64,
}

/// Convert checkpoint events into neutral hot-pack items.
pub fn checkpoint_items(events: &[edda_core::Event]) -> Vec<PackItem> {
    events
        .iter()
        .rev()
        .enumerate()
        .filter_map(|(index, event)| {
            let payload: edda_core::event::CheckpointPayload =
                serde_json::from_value(event.payload.clone()).ok()?;
            let rejected = payload
                .rejected
                .iter()
                .map(|item| format!("{} — {}", item.hypothesis, item.reason))
                .collect::<Vec<_>>();
            let body = format!(
                "- hypotheses: {}\n- rejected: {}\n- open: {}\n- next: {}\n",
                payload.hypotheses.join(" | "),
                rejected.join(" | "),
                payload.open.join(" | "),
                payload.next,
            );
            Some(PackItem {
                section: PackSection::OpenCheckpoints,
                key: format!("Checkpoint {}", event.event_id),
                body,
                salience: 90 + (events.len() - index) as u64,
            })
        })
        .collect()
}

fn latest_registered_checkpoint_items(project_id: &str) -> Vec<PackItem> {
    let Some(project) = edda_store::registry::get_project(project_id) else {
        return Vec::new();
    };
    let Ok(ledger) = edda_ledger::Ledger::open(project.path) else {
        return Vec::new();
    };
    let Ok(branch) = ledger.head_branch() else {
        return Vec::new();
    };
    let Ok(events) = ledger.iter_events_by_type("checkpoint") else {
        return Vec::new();
    };
    let events: Vec<_> = events
        .into_iter()
        .filter(|event| event.branch == branch)
        .collect();
    checkpoint_items(&events).into_iter().take(1).collect()
}

fn pack_budget(budget_chars: usize) -> usize {
    if budget_chars == 0 {
        std::env::var("EDDA_PACK_BUDGET_CHARS")
            .ok()
            .and_then(|v| v.parse().ok())
            .unwrap_or(DEFAULT_PACK_BUDGET_CHARS)
    } else {
        budget_chars
    }
}

fn render_pack_header(metadata: &PackMetadata, dropped_items: usize) -> String {
    format!(
        "# edda memory pack (hot)\n\n- project_id: {}\n- session_id: {}\n- git_branch: {}\n- turns: {}\n- dropped_items: {}\n\n",
        metadata.project_id,
        metadata.session_id,
        metadata.git_branch,
        metadata.turn_count,
        dropped_items,
    )
}

fn render_selected_items(
    metadata: &PackMetadata,
    items: &[PackItem],
    selected: &[usize],
    dropped_items: usize,
) -> String {
    let mut ordered = selected.to_vec();
    ordered.sort_by(|a, b| {
        items[*a]
            .section
            .cmp(&items[*b].section)
            .then_with(|| items[*a].key.cmp(&items[*b].key))
            .then_with(|| a.cmp(b))
    });

    let mut out = render_pack_header(metadata, dropped_items);
    let mut section = None;
    for index in ordered {
        let item = &items[index];
        if section != Some(item.section) {
            out.push_str(&format!("## {}\n\n", item.section.title()));
            section = Some(item.section);
        }
        out.push_str(&format!("### {}\n", item.key));
        out.push_str(&item.body);
        if !item.body.ends_with('\n') {
            out.push('\n');
        }
        out.push('\n');
    }
    out
}

fn select_items(
    metadata: &PackMetadata,
    items: &[PackItem],
    budget: usize,
    dropped_items: usize,
) -> Vec<usize> {
    let mut ranked: Vec<usize> = (0..items.len()).collect();
    ranked.sort_by(|a, b| {
        items[*b]
            .salience
            .cmp(&items[*a].salience)
            .then_with(|| items[*a].section.cmp(&items[*b].section))
            .then_with(|| items[*a].key.cmp(&items[*b].key))
            .then_with(|| a.cmp(b))
    });

    let mut selected = Vec::new();
    for index in ranked {
        selected.push(index);
        if render_selected_items(metadata, items, &selected, dropped_items).len() > budget {
            selected.pop();
        }
    }
    selected
}

/// Render neutral items in deterministic section and salience order.
///
/// Items are selected by salience, with stable tie-breakers, and are either
/// included in full or omitted. The dropped count is part of the pack header.
pub fn render_ordered_pack(
    items: &[PackItem],
    metadata: &PackMetadata,
    budget_chars: usize,
) -> String {
    let budget = pack_budget(budget_chars);
    let mut dropped_items = items.len();
    let mut selected = Vec::new();

    // The count is in the header, so a digit-boundary change can affect fit.
    for _ in 0..4 {
        selected = select_items(metadata, items, budget, dropped_items);
        let next_dropped = items.len() - selected.len();
        if next_dropped == dropped_items {
            break;
        }
        dropped_items = next_dropped;
    }

    render_selected_items(metadata, items, &selected, items.len() - selected.len())
}

fn render_turn_body(turn: &Turn) -> String {
    let mut body = format!("- User: {}\n", turn.user_text);
    for tu in &turn.tool_uses {
        let cmd_str = tu
            .command
            .as_deref()
            .map(|c| format!(" `{c}`"))
            .unwrap_or_default();
        let desc_str = tu
            .description
            .as_deref()
            .map(|d| format!(" ({d})"))
            .unwrap_or_default();
        let file_str = tu
            .file_path
            .as_deref()
            .map(|f| format!(" file={f}"))
            .unwrap_or_default();
        body.push_str(&format!(
            "  - ToolUse: {}{}{}{}\n",
            tu.name, cmd_str, desc_str, file_str
        ));
    }
    for text in &turn.assistant_texts {
        body.push_str(&format!("  - Assistant: {text}\n"));
    }
    body
}

/// Render turns into a hot pack without truncating any turn item.
pub fn render_pack(turns: &[Turn], metadata: &PackMetadata, budget_chars: usize) -> String {
    let mut items: Vec<PackItem> = turns
        .iter()
        .enumerate()
        .map(|(index, turn)| PackItem {
            section: PackSection::RecentTurns,
            key: format!("Turn {} (newest first)", index + 1),
            body: render_turn_body(turn),
            salience: (turns.len() - index) as u64,
        })
        .collect();
    items.extend(latest_registered_checkpoint_items(&metadata.project_id));
    render_ordered_pack(&items, metadata, budget_chars)
}

/// Write hot.md and hot.meta.json to the packs directory.
pub fn write_pack(project_dir: &Path, pack_md: &str, meta: &PackMetadata) -> anyhow::Result<()> {
    let packs_dir = project_dir.join("packs");
    std::fs::create_dir_all(&packs_dir)?;

    edda_store::write_atomic(&packs_dir.join("hot.md"), pack_md.as_bytes())?;

    let meta_json = serde_json::to_string_pretty(meta)?;
    edda_store::write_atomic(&packs_dir.join("hot.meta.json"), meta_json.as_bytes())?;

    Ok(())
}

// ── Doctrine Pack (judgment layer) ──

const DEFAULT_DOCTRINE_FILE: &str = ".havamal-pack.md";

/// Read the project's doctrine hot pack (judgment layer).
///
/// Contract with havamal (github.com/fagemx/havamal): the project curates
/// judgment — ideology, failure memory, taste — as doctrine files and
/// generates a compressed pack via `havamal pack --out .havamal-pack.md`.
/// edda transports that pack into the session. edda never generates judgment
/// itself: machine-extracted judgment without curation is noise; facts flow
/// automatically, judgment enters signed.
///
/// Resolution order:
/// 1. `EDDA_DOCTRINE_PATH` env var (absolute, or relative to `repo_root`)
/// 2. `<repo_root>/.havamal-pack.md`
///
/// Returns `None` when no doctrine source exists or the file is empty.
/// Content is truncated at `budget` bytes on a char boundary.
pub fn read_doctrine_pack(repo_root: &Path, budget: usize) -> Option<String> {
    let path = match std::env::var("EDDA_DOCTRINE_PATH") {
        Ok(p) if !p.trim().is_empty() => {
            let pb = std::path::PathBuf::from(p.trim());
            if pb.is_absolute() {
                pb
            } else {
                repo_root.join(pb)
            }
        }
        _ => repo_root.join(DEFAULT_DOCTRINE_FILE),
    };

    let raw = std::fs::read_to_string(&path).ok()?;
    let trimmed = raw.trim();
    if trimmed.is_empty() {
        return None;
    }

    let mut body = trimmed.to_string();
    if body.len() > budget {
        let mut end = budget;
        while end > 0 && !body.is_char_boundary(end) {
            end -= 1;
        }
        body.truncate(end);
        body.push_str("\n<!-- doctrine truncated by EDDA_DOCTRINE_BUDGET_CHARS -->");
    }

    Some(format!("## Doctrine (judgment layer)\n\n{body}"))
}

// ── Decision Pack ──

/// A pack of active decisions grouped by domain, ready for session injection.
#[derive(Debug, Clone)]
pub struct DecisionPack {
    /// Decisions grouped by domain (e.g., "db", "error", "auth")
    pub groups: Vec<DecisionGroup>,
    /// Total number of decisions included
    pub total: usize,
    /// Branch these decisions are scoped to
    pub branch: String,
}

/// A group of decisions sharing the same domain prefix.
#[derive(Debug, Clone)]
pub struct DecisionGroup {
    /// Domain name (e.g., "db", "error", "auth")
    pub domain: String,
    /// Decisions in this domain, sorted by key
    pub decisions: Vec<DecisionSummary>,
}

/// Minimal decision summary for pack rendering (avoids carrying full DecisionView).
#[derive(Debug, Clone)]
pub struct DecisionSummary {
    pub key: String,
    pub value: String,
    pub reason: String,
    pub status: String,
    pub authority: String,
    pub reversibility: String,
    pub affected_paths: Vec<String>,
    /// Ratified by the operator or the cited-authority sweep (GH-401, GH-1063).
    /// Derived from `decision_ratify` events at build time — `From<&DecisionView>`
    /// alone cannot know it, so callers with ratified-state must set it explicitly.
    pub ratified: bool,
}

impl From<&DecisionView> for DecisionSummary {
    fn from(v: &DecisionView) -> Self {
        Self {
            key: v.key.clone(),
            value: v.value.clone(),
            reason: v.reason.clone(),
            status: v.status.clone(),
            authority: v.authority.clone(),
            reversibility: v.reversibility.clone(),
            affected_paths: v.affected_paths.clone(),
            ratified: false,
        }
    }
}

/// Build a decision pack from active decisions in the ledger.
///
/// Queries active decisions (status IN active, experimental) on the given
/// branch, groups by domain, and limits to `max_items` total decisions.
///
/// Returns a pack with 0 groups if no active decisions exist.
pub fn build_decision_pack(repo_root: &Path, branch: &str, max_items: usize) -> DecisionPack {
    let (mut views, ratified): (Vec<DecisionView>, std::collections::BTreeSet<String>) =
        match edda_ledger::Ledger::open(repo_root) {
            // Fetch ALL active decisions (not SQL-limited): active_decisions is
            // not branch-filtered, so a SQL LIMIT applied before the branch
            // retain below could be entirely consumed by other branches and
            // drop every decision for this branch. Filter by branch first,
            // then cap at max_items.
            Ok(ledger) => (
                ledger
                    .active_decisions(None, None, None, None)
                    .unwrap_or_default(),
                // GH-401: ratified decision event_ids, derived by rowid order.
                ledger.ratified_decision_events().unwrap_or_default(),
            ),
            Err(_) => (Vec::new(), std::collections::BTreeSet::new()),
        };
    // Keep only this branch's decisions (see above), then cap at max_items so
    // a decision — and its ratified-state — from another branch is never
    // rendered under this branch's header.
    views.retain(|v| v.branch == branch);
    views.truncate(max_items);

    if views.is_empty() {
        return DecisionPack {
            groups: Vec::new(),
            total: 0,
            branch: branch.to_string(),
        };
    }

    // Group by domain, limit to max_items total
    let mut by_domain: BTreeMap<String, Vec<DecisionSummary>> = BTreeMap::new();
    let mut count = 0;

    for d in &views {
        if count >= max_items {
            break;
        }
        let mut summary = DecisionSummary::from(d);
        summary.ratified = edda_ledger::view::is_decision_ratified(d, &ratified);
        by_domain.entry(d.domain.clone()).or_default().push(summary);
        count += 1;
    }

    let groups = by_domain
        .into_iter()
        .map(|(domain, mut decisions)| {
            decisions.sort_by(|a, b| a.key.cmp(&b.key));
            DecisionGroup { domain, decisions }
        })
        .collect();

    DecisionPack {
        groups,
        total: count,
        branch: branch.to_string(),
    }
}

/// Render a decision pack as a markdown section, split into an
/// operator-ratified (binding) tier and an unratified tier (GH-401).
///
/// Binding status comes from `decision_ratify` events (carried on each
/// summary as `ratified`), never from the authority string — so the pack
/// can never launder agent inference into operator authority. Each domain
/// group is preserved within its tier; unratified lines are annotated with
/// their authorship. Returns an empty string if the pack has 0 decisions.
pub fn render_decision_pack_md(pack: &DecisionPack) -> String {
    if pack.total == 0 {
        return String::new();
    }

    let ratified_count = pack
        .groups
        .iter()
        .flat_map(|g| &g.decisions)
        .filter(|d| d.ratified)
        .count();
    let unratified_count = pack.total.saturating_sub(ratified_count);

    let mut sections: Vec<String> = Vec::new();
    if ratified_count > 0 {
        sections.push(render_decision_tier(
            pack,
            true,
            &format!(
                "## Ratified Decisions ({} on `{}`)",
                ratified_count, pack.branch
            ),
        ));
    }
    if unratified_count > 0 {
        sections.push(render_decision_tier(
            pack,
            false,
            &format!(
                "## Unratified Decisions ({} on `{}`) — recorded, not binding until `edda ratify`",
                unratified_count, pack.branch
            ),
        ));
    }
    sections.join("\n\n")
}

/// Render one tier (ratified or not) of a decision pack, preserving domain
/// grouping. Unratified lines carry an authorship tag; ratified lines do not.
fn render_decision_tier(pack: &DecisionPack, want_ratified: bool, header: &str) -> String {
    let mut lines = vec![header.to_string()];
    for group in &pack.groups {
        let decs: Vec<&DecisionSummary> = group
            .decisions
            .iter()
            .filter(|d| d.ratified == want_ratified)
            .collect();
        if decs.is_empty() {
            continue;
        }
        lines.push(format!("\n### {}", group.domain));
        for d in decs {
            let mut entry = if want_ratified {
                format!("- **`{}={}`**", d.key, d.value)
            } else {
                format!(
                    "- [{}] **`{}={}`**",
                    edda_core::types::authorship_tag(&d.authority),
                    d.key,
                    d.value
                )
            };
            if !d.reason.is_empty() {
                entry.push_str(&format!(" — {}", d.reason));
            }
            if !d.affected_paths.is_empty() {
                entry.push_str(&format!("\n  paths: `{}`", d.affected_paths.join("`, `")));
            }
            lines.push(entry);
        }
    }
    lines.join("\n")
}

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

    #[test]
    fn render_pack_basic() {
        let turns = vec![Turn {
            user_uuid: "u1".into(),
            assistant_uuid: "a1".into(),
            user_text: "How do I sort a list?".into(),
            assistant_texts: vec!["Use the sort() method.".into()],
            tool_uses: vec![ToolUse {
                id: Some("tu1".into()),
                name: "Bash".into(),
                command: Some("ls -la".into()),
                description: Some("List files".into()),
                file_path: None,
            }],
        }];

        let meta = PackMetadata {
            project_id: "abc123".into(),
            session_id: "s1".into(),
            git_branch: "main".into(),
            turn_count: 1,
            budget_chars: 12000,
        };

        let md = render_pack(&turns, &meta, 12000);
        assert!(md.contains("# edda memory pack (hot)"));
        assert!(md.contains("How do I sort a list?"));
        assert!(md.contains("ToolUse: Bash"));
        assert!(md.contains("Use the sort() method."));
    }

    #[test]
    fn checkpoint_items_join_the_hot_pack_schema() {
        let checkpoint = edda_core::event::CheckpointPayload {
            hypotheses: vec!["cache invalidation is the cause".to_string()],
            rejected: vec![edda_core::event::RejectedHypothesis {
                hypothesis: "database corruption".to_string(),
                reason: "integrity check passes".to_string(),
            }],
            open: vec!["confirm the next rebuild".to_string()],
            next: "run the rebuild check".to_string(),
        };
        let event =
            edda_core::event::new_checkpoint_event("main", None, "agent", &checkpoint).unwrap();
        let items = checkpoint_items(&[event]);
        let meta = PackMetadata {
            project_id: "abc".into(),
            session_id: "s1".into(),
            git_branch: "main".into(),
            turn_count: 0,
            budget_chars: 12000,
        };

        let md = render_ordered_pack(&items, &meta, 12000);

        assert!(md.contains("## Open Checkpoints"));
        assert!(md.contains("cache invalidation is the cause"));
        assert!(md.contains("integrity check passes"));
        assert!(md.contains("run the rebuild check"));
    }

    #[test]
    fn render_pack_drops_whole_items_at_budget() {
        let turns: Vec<Turn> = (0..20)
            .map(|i| Turn {
                user_uuid: format!("u{i}"),
                assistant_uuid: format!("a{i}"),
                user_text: format!("Question {i} with some extra text padding to fill space"),
                assistant_texts: vec![format!(
                    "Answer {i} with a reasonably long response text to consume budget"
                )],
                tool_uses: vec![],
            })
            .collect();

        let meta = PackMetadata {
            project_id: "abc".into(),
            session_id: "s1".into(),
            git_branch: "main".into(),
            turn_count: 20,
            budget_chars: 500,
        };

        let md = render_pack(&turns, &meta, 500);
        assert!(md.contains("- dropped_items: "));
        assert!(!md.contains("truncated by budget"));
        assert!(md.len() <= 500);
    }

    #[test]
    fn write_pack_creates_files() {
        let tmp = tempfile::tempdir().unwrap();
        let meta = PackMetadata {
            project_id: "test".into(),
            session_id: "s1".into(),
            git_branch: "main".into(),
            turn_count: 0,
            budget_chars: 12000,
        };

        write_pack(tmp.path(), "# pack content", &meta).unwrap();

        let hot = tmp.path().join("packs").join("hot.md");
        assert!(hot.exists());
        assert_eq!(std::fs::read_to_string(&hot).unwrap(), "# pack content");

        let meta_path = tmp.path().join("packs").join("hot.meta.json");
        assert!(meta_path.exists());
    }

    // ── Doctrine Pack tests ──

    #[test]
    fn doctrine_pack_missing_returns_none() {
        let tmp = tempfile::tempdir().unwrap();
        assert!(read_doctrine_pack(tmp.path(), 4000).is_none());
    }

    #[test]
    fn doctrine_pack_reads_default_file() {
        let tmp = tempfile::tempdir().unwrap();
        std::fs::write(
            tmp.path().join(".havamal-pack.md"),
            "## L1 — MUST STAY TRUE\nClaims never close work.",
        )
        .unwrap();
        let md = read_doctrine_pack(tmp.path(), 4000).unwrap();
        assert!(md.starts_with("## Doctrine (judgment layer)"));
        assert!(md.contains("Claims never close work."));
    }

    #[test]
    fn doctrine_pack_empty_file_returns_none() {
        let tmp = tempfile::tempdir().unwrap();
        std::fs::write(tmp.path().join(".havamal-pack.md"), "  \n\n").unwrap();
        assert!(read_doctrine_pack(tmp.path(), 4000).is_none());
    }

    #[test]
    fn doctrine_pack_truncates_at_budget() {
        let tmp = tempfile::tempdir().unwrap();
        let long = "x".repeat(500);
        std::fs::write(tmp.path().join(".havamal-pack.md"), &long).unwrap();
        let md = read_doctrine_pack(tmp.path(), 100).unwrap();
        assert!(md.contains("doctrine truncated"));
        assert!(md.len() < 300);
    }

    // ── Decision Pack tests ──

    fn make_summary(key: &str, value: &str, reason: &str, paths: Vec<&str>) -> DecisionSummary {
        DecisionSummary {
            key: key.to_string(),
            value: value.to_string(),
            reason: reason.to_string(),
            status: "active".to_string(),
            authority: "agent".to_string(),
            reversibility: "medium".to_string(),
            affected_paths: paths.into_iter().map(|s| s.to_string()).collect(),
            ratified: false,
        }
    }

    fn make_ratified(key: &str, value: &str, reason: &str) -> DecisionSummary {
        let mut s = make_summary(key, value, reason, vec![]);
        s.authority = "operator".to_string();
        s.ratified = true;
        s
    }

    fn make_pack(groups: Vec<(&str, Vec<DecisionSummary>)>, branch: &str) -> DecisionPack {
        let total: usize = groups.iter().map(|(_, ds)| ds.len()).sum();
        DecisionPack {
            groups: groups
                .into_iter()
                .map(|(domain, decisions)| DecisionGroup {
                    domain: domain.to_string(),
                    decisions,
                })
                .collect(),
            total,
            branch: branch.to_string(),
        }
    }

    #[test]
    fn test_empty_pack() {
        let pack = DecisionPack {
            groups: Vec::new(),
            total: 0,
            branch: "main".to_string(),
        };
        let md = render_decision_pack_md(&pack);
        assert!(md.is_empty());
    }

    #[test]
    fn test_full_pack_grouped_by_domain() {
        let pack = make_pack(
            vec![
                (
                    "auth",
                    vec![make_summary("auth.strategy", "JWT", "stateless", vec![])],
                ),
                (
                    "db",
                    vec![
                        make_summary("db.engine", "sqlite", "embedded", vec![]),
                        make_summary("db.pool", "r2d2", "connection pooling", vec![]),
                    ],
                ),
                (
                    "error",
                    vec![
                        make_summary("error.lib", "thiserror", "typed errors", vec![]),
                        make_summary("error.pattern", "enum", "exhaustive", vec![]),
                    ],
                ),
            ],
            "main",
        );

        assert_eq!(pack.groups.len(), 3);
        assert_eq!(pack.total, 5);

        let md = render_decision_pack_md(&pack);
        // All make_summary decisions are unratified → Unratified section.
        assert!(md.contains("## Unratified Decisions (5 on `main`)"));
        assert!(!md.contains("## Ratified Decisions"));
        assert!(md.contains("### auth"));
        assert!(md.contains("### db"));
        assert!(md.contains("### error"));
    }

    #[test]
    fn two_tier_splits_ratified_and_unratified() {
        let pack = make_pack(
            vec![
                ("db", vec![make_ratified("db.engine", "postgres", "JSONB")]),
                (
                    "api",
                    vec![make_summary("api.style", "REST", "compat", vec![])],
                ),
            ],
            "main",
        );
        let md = render_decision_pack_md(&pack);
        assert!(md.contains("## Ratified Decisions (1 on `main`)"));
        assert!(md.contains("## Unratified Decisions (1 on `main`)"));
        // Ratified renders before unratified.
        let r = md.find("## Ratified Decisions").unwrap();
        let u = md.find("## Unratified Decisions").unwrap();
        assert!(r < u, "ratified tier must render first");
        // Ratified line has no authorship tag; unratified line is tagged.
        assert!(md.contains("**`db.engine=postgres`**"));
        assert!(md.contains("[agent] **`api.style=REST`**"));
    }

    #[test]
    fn all_ratified_omits_unratified_section() {
        let pack = make_pack(
            vec![("db", vec![make_ratified("db.engine", "pg", "r")])],
            "main",
        );
        let md = render_decision_pack_md(&pack);
        assert!(md.contains("## Ratified Decisions (1 on `main`)"));
        assert!(!md.contains("## Unratified Decisions"));
    }

    #[test]
    fn test_domain_grouping_order() {
        let pack = make_pack(
            vec![
                ("a_first", vec![make_summary("a_first.x", "1", "r", vec![])]),
                (
                    "m_middle",
                    vec![make_summary("m_middle.x", "2", "r", vec![])],
                ),
                ("z_test", vec![make_summary("z_test.x", "3", "r", vec![])]),
            ],
            "main",
        );

        let md = render_decision_pack_md(&pack);
        let a_pos = md.find("### a_first").unwrap();
        let m_pos = md.find("### m_middle").unwrap();
        let z_pos = md.find("### z_test").unwrap();
        assert!(a_pos < m_pos);
        assert!(m_pos < z_pos);
    }

    #[test]
    fn test_render_with_paths() {
        let pack = make_pack(
            vec![(
                "db",
                vec![make_summary(
                    "db.engine",
                    "sqlite",
                    "embedded",
                    vec!["crates/foo/**", "src/**"],
                )],
            )],
            "main",
        );

        let md = render_decision_pack_md(&pack);
        assert!(md.contains("paths: `crates/foo/**`, `src/**`"));
    }

    #[test]
    fn test_render_without_reason() {
        let pack = make_pack(
            vec![("db", vec![make_summary("db.engine", "sqlite", "", vec![])])],
            "main",
        );

        let md = render_decision_pack_md(&pack);
        assert!(md.contains("**`db.engine=sqlite`**"));
        // The decision line itself carries no reason separator (the header may).
        let decision_line = md.lines().find(|l| l.contains("db.engine=sqlite")).unwrap();
        assert!(!decision_line.contains(" — "));
    }

    #[test]
    fn test_build_decision_pack_nonexistent_repo() {
        // Non-existent path should return empty pack
        let pack = build_decision_pack(Path::new("/nonexistent/path"), "main", 7);
        assert_eq!(pack.total, 0);
        assert!(pack.groups.is_empty());
        assert_eq!(render_decision_pack_md(&pack), "");
    }

    #[test]
    fn build_decision_pack_derives_ratified_from_real_ledger() {
        // End-to-end: a real ledger with two decisions and one ratify event
        // must split into ratified/unratified through the full
        // ledger → ratified_decision_events → is_decision_ratified → render
        // chain. The ratify is given an EARLIER timestamp than the decisions
        // but appended last (highest rowid) — so a green result proves rowid,
        // not the timestamp, is authoritative.
        let tmp = tempfile::tempdir().unwrap();
        let root = tmp.path();
        let ledger = edda_ledger::Ledger::open_or_init(root).unwrap();

        let decide = |key: &str, value: &str| {
            let parent = ledger.last_event_hash().unwrap();
            let dp = edda_core::types::DecisionPayload {
                key: key.into(),
                value: value.into(),
                reason: None,
                scope: None,
                authority: Some("agent".into()),
                affected_paths: None,
                tags: None,
                review_after: None,
                reversibility: None,
                village_id: None,
                cites: None,
            };
            let ev = edda_core::event::new_decision_event("main", parent.as_deref(), "worker", &dp)
                .unwrap();
            ledger.append_event(&ev).unwrap();
        };
        decide("db.engine", "postgres");
        decide("api.style", "REST");

        // Ratify db.engine, appended LAST but with an EARLIER timestamp than
        // the decisions — a timestamp model would call it stale/unratified;
        // the rowid model correctly binds it.
        let parent = ledger.last_event_hash().unwrap();
        let mut rat = edda_core::event::new_decision_ratify_event(
            "main",
            parent.as_deref(),
            "db.engine",
            "operator",
            None,
        )
        .unwrap();
        rat.ts = "2000-01-01T00:00:00Z".into();
        edda_core::event::finalize_event(&mut rat).unwrap();
        ledger.append_event(&rat).unwrap();

        let pack = build_decision_pack(root, "main", 10);
        let md = render_decision_pack_md(&pack);

        assert!(md.contains("## Ratified Decisions (1 on `main`)"));
        assert!(md.contains("**`db.engine=postgres`**"));
        assert!(md.contains("## Unratified Decisions (1 on `main`)"));
        assert!(md.contains("[agent] **`api.style=REST`**"));
    }
}