use crate::models::*;
use crate::router::McpTool;
use crate::state::MemoryState;
use crate::tools::*;
use async_trait::async_trait;
use serde_json::Value;
use std::sync::Arc;

pub struct LogErrorFixHandler;

#[async_trait]
impl McpTool for LogErrorFixHandler {
    fn name(&self) -> &'static str {
        "log_error_fix"
    }

    fn schema(&self) -> Value {
        crate::mcp::tool_def::<LogErrorFixTool>(
            "log_error_fix",
            "Log an error signature and its verified solution/fix for future diagnostic retrieval",
        )
    }

    async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
        let req: LogErrorFixTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
        let text_to_embed = format!("Signature: {}\nSolution: {}", req.signature, req.solution);
        let mut solution = req.solution;

        if state.ollama.is_available().await {
            let prompt = format!(
                "Analyze this error signature and solution. Output 1 sentence summarizing the root cause and fix:\nSignature: {}\nSolution: {}",
                req.signature, solution
            );
            if let Ok(summary) = state
                .ollama
                .generate(&prompt, Some(&state.ollama.reasoning_model), None)
                .await
            {
                let clean = summary.trim();
                if !clean.is_empty() {
                    solution = format!("{} (AI Analysis: {})", solution, clean);
                }
            }
        }

        let embedding = crate::embedding::generate_embedding_async(text_to_embed)
            .await
            .ok();
        state.code.error_fixes.modify(|fixes| {
            fixes.push(crate::models::ErrorFix {
                signature: req.signature.clone(),
                solution: solution.clone(),
                timestamp: crate::handlers::utils::now_secs(),
                git_commit: req.git_commit,
                git_branch: req.git_branch,
                embedding,
                ..Default::default()
            });
            if fixes.len() > 300 {
                fixes.remove(0);
            }
        });
        state.record_activity(
            "error_fix",
            &format!("Fixed error: {}", req.signature),
            Some(&solution),
        );
        Ok(format!(
            "Logged error fix for {}: {}",
            req.signature, solution
        ))
    }
}

pub struct SearchErrorFixesHandler;

#[async_trait]
impl McpTool for SearchErrorFixesHandler {
    fn name(&self) -> &'static str {
        "search_error_fixes"
    }

    fn schema(&self) -> Value {
        crate::mcp::tool_def::<SearchErrorFixesTool>(
            "search_error_fixes",
            "Search historical error fixes using keyword search or stack trace vector similarity",
        )
    }

    async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
        let req: SearchErrorFixesTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
        let limit = req.limit.unwrap_or(5);
        let include_body = req.include_body.unwrap_or(true);

        if let Some(st) = &req.stack_trace {
            let query_emb = crate::embedding::generate_embedding_async(st.clone())
                .await
                .unwrap_or_default();

            let data = state.code.error_fixes.read_with(|fixes| {
                let mut scored: Vec<_> = fixes
                    .iter()
                    .map(|f| {
                        let mut score = 0.0;
                        let st_lower = st.to_lowercase();
                        let sig_lower = f.signature.to_lowercase();
                        let sol_lower = f.solution.to_lowercase();
                        if st_lower.contains(&sig_lower) || sig_lower.contains(&st_lower) {
                            score += 0.8;
                        } else if st_lower.contains(&sol_lower) || sol_lower.contains(&st_lower) {
                            score += 0.5;
                        }
                        if let Some(emb) = &f.embedding {
                            if !query_emb.is_empty() {
                                score += crate::embedding::cosine_similarity(&query_emb, emb);
                            }
                        }
                        (f, score)
                    })
                    .filter(|(_, score)| *score > 0.1)
                    .collect();

                scored.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));

                let suggestions: Vec<_> = scored
                    .into_iter()
                    .take(limit)
                    .map(|(f, score)| {
                        if include_body {
                            serde_json::json!({
                                "signature": f.signature,
                                "solution": f.solution,
                                "git_commit": f.git_commit,
                                "git_branch": f.git_branch,
                                "match_score": score
                            })
                        } else {
                            serde_json::json!({
                                "signature": f.signature,
                                "match_score": score
                            })
                        }
                    })
                    .collect();

                Ok::<String, crate::error::AppError>(serde_json::to_string_pretty(&suggestions)?)
            })?;
            return Ok(data);
        }

        let q = req.query.unwrap_or_default();
        let data = state.code.error_fixes.read_with(|fixes| {
            let filtered: Vec<_> = fixes
                .iter()
                .filter(|f| {
                    q.is_empty()
                        || contains_ignore_ascii_case(&f.signature, &q)
                        || contains_ignore_ascii_case(&f.solution, &q)
                })
                .take(limit)
                .map(|f| {
                    if include_body {
                        serde_json::json!(f)
                    } else {
                        serde_json::json!({
                            "signature": f.signature,
                            "git_commit": f.git_commit,
                            "git_branch": f.git_branch
                        })
                    }
                })
                .collect();
            Ok::<String, crate::error::AppError>(serde_json::to_string_pretty(&filtered)?)
        })?;
        Ok(data)
    }
}

pub struct LogCodeChangeHandler;

#[async_trait]
impl McpTool for LogCodeChangeHandler {
    fn name(&self) -> &'static str {
        "log_code_change"
    }

    fn schema(&self) -> Value {
        crate::mcp::tool_def::<LogCodeChangeTool>(
            "log_code_change",
            "Log a significant code change or refactor with file path and description",
        )
    }

    async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
        let req: LogCodeChangeTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
        let mut description = req.description;

        if let Some(range) = &req.line_range {
            description = format!("{} [Line Range: {}]", description, range);
        }
        if let Some(symbols) = &req.symbol_references {
            if !symbols.is_empty() {
                description = format!("{} [Symbols: {}]", description, symbols.join(", "));
            }
        }

        if state.ollama.is_available().await {
            let prompt = format!(
                "Summarize in 1 concise sentence the architectural impact of changing file '{}': {}",
                req.file_path, description
            );
            if let Ok(summary) = state.ollama.generate(&prompt, None, None).await {
                let clean = summary.trim();
                if !clean.is_empty() {
                    description = format!("{} (AI Summary: {})", description, clean);
                }
            }
        }
        let change_kind = match req
            .change_kind
            .as_deref()
            .map(|s| s.to_lowercase())
            .as_deref()
        {
            Some("added") | Some("create") | Some("created") | Some("new") => {
                crate::models::ChangeKind::Added
            }
            Some("deleted") | Some("remove") | Some("removed") => {
                crate::models::ChangeKind::Deleted
            }
            Some("renamed") | Some("move") | Some("moved") => crate::models::ChangeKind::Renamed,
            _ => crate::models::ChangeKind::Modified,
        };

        let namespace = req
            .namespace
            .filter(|ns| !ns.trim().is_empty())
            .or_else(|| req.repo_name.clone().filter(|rn| !rn.trim().is_empty()))
            .unwrap_or_else(crate::models::default_namespace);

        let symbols = req.symbol_references.clone().unwrap_or_default();
        let line_range = req.line_range.clone();

        let effective_rev = req.revision.clone().or_else(|| req.git_commit.clone());
        let effective_branch = req.branch.clone().or_else(|| req.git_branch.clone());
        let detected_vcs = if let Some(vcs) = req.vcs_type.clone() {
            Some(vcs)
        } else if let Some(ref rev) = effective_rev {
            if rev.starts_with('r') && rev[1..].chars().all(|c| c.is_ascii_digit()) {
                Some("svn".to_string())
            } else if req
                .repo_url
                .as_deref()
                .map(|u| u.contains("/svn/"))
                .unwrap_or(false)
            {
                Some("svn".to_string())
            } else {
                Some("git".to_string())
            }
        } else if let Some(ref br) = effective_branch {
            if br.eq_ignore_ascii_case("trunk")
                || br.starts_with("branches/")
                || br.starts_with("tags/")
            {
                Some("svn".to_string())
            } else {
                Some("git".to_string())
            }
        } else {
            None
        };

        state.code.ledger.modify(|ledger| {
            ledger.push(CodeChange {
                timestamp: crate::handlers::utils::now_secs(),
                file_path: req.file_path.clone(),
                description: description.clone(),
                git_commit: effective_rev.clone(),
                git_branch: effective_branch.clone(),
                repo_name: req.repo_name,
                repo_url: req.repo_url,
                namespace: namespace.clone(),
                change_kind,
                symbols,
                line_range,
                author: req.author,
                session_id: req.session_id,
                vcs_type: detected_vcs,
                revision: effective_rev,
                branch: effective_branch,
                repository_root: req.repository_root,
            });
            if ledger.len() > 500 {
                ledger.remove(0);
            }
        });
        state.record_activity(
            "code_change",
            &format!("Modified {}", req.file_path),
            Some(&description),
        );
        Ok(format!(
            "Logged code change for {}: {}",
            req.file_path, description
        ))
    }
}

pub struct QueryRecentChangesHandler;

#[async_trait]
impl McpTool for QueryRecentChangesHandler {
    fn name(&self) -> &'static str {
        "query_recent_changes"
    }

    fn schema(&self) -> Value {
        crate::mcp::tool_def::<QueryRecentChangesTool>(
            "query_recent_changes",
            "Query recent code changes and refactoring audit logs",
        )
    }

    async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
        let req: QueryRecentChangesTool = serde_json::from_value(args).unwrap_or(QueryRecentChangesTool {
            namespace: None,
            repo_name: None,
            vcs_type: None,
            limit: None,
            offset: None,
        });
        let limit = req.limit.unwrap_or(50);
        let offset = req.offset.unwrap_or(0);
        let data = state.code.ledger.read_with(|l| {
            let filtered: Vec<_> = l
                .iter()
                .rev()
                .filter(|c| {
                    if let Some(ns) = &req.namespace {
                        if !c.namespace.eq_ignore_ascii_case(ns) {
                            return false;
                        }
                    }
                    if let Some(repo) = &req.repo_name {
                        if c.repo_name
                            .as_ref()
                            .map(|rn| !rn.eq_ignore_ascii_case(repo))
                            .unwrap_or(true)
                        {
                            return false;
                        }
                    }
                    if let Some(vcs) = &req.vcs_type {
                        if !c.effective_vcs().eq_ignore_ascii_case(vcs) {
                            return false;
                        }
                    }
                    true
                })
                .skip(offset)
                .take(limit)
                .cloned()
                .collect();
            Ok::<String, crate::error::AppError>(serde_json::to_string(&filtered)?)
        })?;
        Ok(data)
    }
}
pub struct DecisionsHandler;

#[async_trait]
impl McpTool for DecisionsHandler {
    fn name(&self) -> &'static str {
        "decisions"
    }

    fn schema(&self) -> Value {
        crate::mcp::tool_def::<DecisionsTool>(
            "decisions",
            "Consolidated Architectural Decision Records (ADRs) management (log, query, update, delete)",
        )
    }

    async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
        let req: DecisionsTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
        let ns = req
            .namespace
            .unwrap_or_else(|| crate::models::default_namespace());
        match req.action {
            DecisionAction::Log => {
                let title = req.title.ok_or_else(|| {
                    crate::error::AppError::Internal("Missing required parameter 'title' for action 'log'. Next step: Provide ADR 'title' string in request and retry.".to_string())
                })?;
                let status = req.status.unwrap_or_else(|| "accepted".to_string());
                let context = req.context.unwrap_or_default();
                let decision = req.decision.unwrap_or_default();
                let consequence = req.consequences.unwrap_or_default();
                let status_lower = status.to_ascii_lowercase();
                let resolved_at = if status_lower == "implemented" || status_lower == "resolved" {
                    Some(crate::handlers::utils::now_secs())
                } else {
                    None
                };

                let idx = state.get_search_index().await;
                let mut final_id = String::new();
                let mut adrs_to_index = Vec::new();

                state.code.adrs.modify(|adrs| {
                    if let Some(superseded_id) = &req.supersedes {
                        for old_adr in adrs.iter_mut() {
                            if old_adr.id.eq_ignore_ascii_case(superseded_id) {
                                old_adr.status = "superseded".to_string();
                                adrs_to_index.push(old_adr.clone());
                                break;
                            }
                        }
                    }

                    final_id = format!("ADR-{:04}", adrs.len() + 1);
                    let a = Adr {
                        id: final_id.clone(),
                        title: title.clone(),
                        context,
                        decision: decision.clone(),
                        consequence,
                        status,
                        supersedes: req.supersedes,
                        timestamp: crate::handlers::utils::now_secs(),
                        namespace: ns,
                        repo_name: req.repo_name,
                        alternatives_considered: req.alternatives_considered.unwrap_or_default(),
                        affected_components: req.affected_components.unwrap_or_default(),
                        author: req.author,
                        git_commit: req.git_commit,
                        git_branch: req.git_branch,
                        resolved_at,
                        task_id: req.task_id,
                    };

                    adrs_to_index.push(a.clone());
                    adrs.push(a);
                });

                for adr in &adrs_to_index {
                    drop(idx.index_adr(adr));
                }

                state.record_activity(
                    "decision",
                    &format!("Logged {}: {}", final_id, title),
                    Some(&decision),
                );
                Ok(format!("Logged decision {}: {}", final_id, title))
            }
            DecisionAction::Update => {
                let id = req.id.ok_or_else(|| {
                    crate::error::AppError::Internal("Missing required parameter 'id' for action 'update'. Next step: Provide ADR 'id' string in request and retry.".to_string())
                })?;
                let mut updated_adr = None;
                let mut adrs_to_index = Vec::new();

                state.code.adrs.modify(|adrs| {
                    let target_pos = adrs.iter().position(|a| a.id.eq_ignore_ascii_case(&id));
                    if let Some(pos) = target_pos {
                        if let Some(superseded_id) = &req.supersedes {
                            if let Some(s_pos) = adrs.iter().position(|a| a.id.eq_ignore_ascii_case(superseded_id)) {
                                if s_pos != pos {
                                    adrs[s_pos].status = "superseded".to_string();
                                    adrs_to_index.push(adrs[s_pos].clone());
                                }
                            }
                        }

                        let a = &mut adrs[pos];
                        if let Some(t) = req.title {
                            a.title = t;
                        }
                        if let Some(c) = req.context {
                            a.context = c;
                        }
                        if let Some(d) = req.decision {
                            a.decision = d;
                        }
                        if let Some(cons) = req.consequences {
                            a.consequence = cons;
                        }
                        if let Some(s) = req.status {
                            let s_lower = s.to_ascii_lowercase();
                            if (s_lower == "implemented" || s_lower == "resolved") && a.resolved_at.is_none() {
                                a.resolved_at = Some(crate::handlers::utils::now_secs());
                            } else if s_lower != "implemented" && s_lower != "resolved" {
                                a.resolved_at = None;
                            }
                            a.status = s;
                        }
                        if req.supersedes.is_some() {
                            a.supersedes = req.supersedes;
                        }
                        if req.repo_name.is_some() {
                            a.repo_name = req.repo_name;
                        }
                        if let Some(alts) = req.alternatives_considered {
                            a.alternatives_considered = alts;
                        }
                        if let Some(aff) = req.affected_components {
                            a.affected_components = aff;
                        }
                        if req.author.is_some() {
                            a.author = req.author;
                        }
                        if req.git_commit.is_some() {
                            a.git_commit = req.git_commit;
                        }
                        if req.git_branch.is_some() {
                            a.git_branch = req.git_branch;
                        }
                        if req.task_id.is_some() {
                            a.task_id = req.task_id;
                        }

                        adrs_to_index.push(a.clone());
                        updated_adr = Some(a.clone());
                    }
                });

                if let Some(adr) = updated_adr {
                    let idx = state.get_search_index().await;
                    for a in &adrs_to_index {
                        drop(idx.index_adr(a));
                    }
                    state.record_activity(
                        "decision",
                        &format!("Updated {}: {}", adr.id, adr.title),
                        Some(&adr.status),
                    );
                    Ok(format!("Updated decision {}: {} (status: {})", adr.id, adr.title, adr.status))
                } else {
                    Err(crate::error::AppError::Internal(
                        format!("Decision with id '{}' not found", id),
                    ))
                }
            }
            DecisionAction::Query => {
                let limit = req.limit.unwrap_or(20);
                let include_body = req.include_body.unwrap_or(true);
                let data = state.code.adrs.read_with(|adrs| {
                    let filtered: Vec<_> = adrs
                        .iter()
                        .filter(|a| {
                            if !a.namespace.eq_ignore_ascii_case(&ns) && ns != "global" {
                                return false;
                            }
                            if let Some(q) = &req.query {
                                crate::handlers::utils::contains_ignore_ascii_case(&a.title, q)
                                    || crate::handlers::utils::contains_ignore_ascii_case(&a.context, q)
                                    || crate::handlers::utils::contains_ignore_ascii_case(&a.decision, q)
                                    || crate::handlers::utils::contains_ignore_ascii_case(&a.consequence, q)
                            } else {
                                true
                            }
                        })
                        .take(limit)
                        .collect();

                    if include_body {
                        Ok::<String, crate::error::AppError>(serde_json::to_string(&filtered)?)
                    } else {
                        let compact: Vec<_> = filtered
                            .iter()
                            .map(|a| {
                                serde_json::json!({
                                    "id": a.id,
                                    "title": a.title,
                                    "status": a.status,
                                    "timestamp": a.timestamp,
                                    "git_commit": a.git_commit,
                                    "git_branch": a.git_branch,
                                    "resolved_at": a.resolved_at,
                                    "task_id": a.task_id,
                                })
                            })
                            .collect();
                        Ok::<String, crate::error::AppError>(serde_json::to_string(&compact)?)
                    }
                })?;
                Ok(data)
            }
            DecisionAction::Delete => {
                let id = req.id.ok_or_else(|| {
                    crate::error::AppError::Internal("Missing required parameter 'id' for action 'delete'. Next step: Provide ADR 'id' string in request and retry.".to_string())
                })?;
                let mut found = false;
                state.code.adrs.modify(|adrs| {
                    if let Some(pos) = adrs.iter().position(|a| a.id == id) {
                        adrs.remove(pos);
                        found = true;
                    }
                });

                if found {
                    let idx = state.get_search_index().await;
                    let _ = idx.delete_document(&id).await;
                    Ok("Decision deleted successfully".to_string())
                } else {
                    Err(crate::error::AppError::Internal(
                        "Decision not found".to_string(),
                    ))
                }
            }
        }
    }
}

pub struct TechDebtHandler;

#[async_trait]
impl McpTool for TechDebtHandler {
    fn name(&self) -> &'static str {
        "tech_debt"
    }

    fn schema(&self) -> Value {
        crate::mcp::tool_def::<TechDebtTool>(
            "tech_debt",
            "Consolidated technical debt management (log, resolve, list)",
        )
    }

    async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
        let req: TechDebtTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
        let ns = req
            .namespace
            .unwrap_or_else(|| crate::models::default_namespace());
        match req.action {
            TechDebtAction::Log => {
                let desc = req.description.or(req.title).ok_or_else(|| {
                    crate::error::AppError::Internal("Missing required parameter 'description' for action 'log'. Next step: Provide tech debt 'description' in request and retry.".to_string())
                })?;
                let ideal = req.ideal_solution.unwrap_or_default();
                let text_to_embed = format!(
                    "Description: {}\nIdeal Solution: {}",
                    desc, ideal
                );
                let embedding = crate::embedding::generate_embedding_async(text_to_embed)
                    .await
                    .ok();
                state.code.tech_debts.modify(|debts| {
                    debts.push(crate::models::TechDebt {
                        id: uuid::Uuid::new_v4().to_string(),
                        namespace: ns,
                        description: desc,
                        ideal_solution: ideal,
                        is_resolved: false,
                        created_at: crate::handlers::utils::now_secs(),
                        git_commit: req.git_commit,
                        git_branch: req.git_branch,
                        embedding,
                        repo_name: req.repo_name,
                        severity: req.severity,
                        file_path: req.file_path,
                        line_range: req.line_range,
                        workaround: req.workaround,
                        effort_estimate: req.effort_estimate,
                    });
                    if debts.len() > 300 {
                        let severity_rank = |sev: Option<&str>| match sev.unwrap_or("").to_lowercase().as_str() {
                            "critical" => 4,
                            "high" => 3,
                            "medium" => 2,
                            "low" => 1,
                            _ => 1,
                        };
                        if let Some((idx_to_remove, _)) = debts.iter().enumerate().min_by_key(|(_, d)| {
                            let status_score = if d.is_resolved { 0 } else { 10 };
                            let sev_score = severity_rank(d.severity.as_deref());
                            (status_score + sev_score, d.created_at)
                        }) {
                            debts.remove(idx_to_remove);
                        }
                    }
                });
                Ok("Tech debt logged".to_string())
            }
            TechDebtAction::Resolve => {
                let id = req.id.ok_or_else(|| {
                    crate::error::AppError::Internal("Missing required parameter 'id' for action 'resolve'. Next step: Provide tech debt 'id' string in request and retry.".to_string())
                })?;
                let mut found = false;
                state.code.tech_debts.modify(|debts| {
                    for d in debts.iter_mut() {
                        if d.id == id {
                            d.is_resolved = true;
                            found = true;
                            break;
                        }
                    }
                });
                if found {
                    Ok("Tech debt resolved".to_string())
                } else {
                    Err(crate::error::AppError::Internal(
                        "Tech debt not found. Please verify the tech debt ID using list action."
                            .to_string(),
                    ))
                }
            }
            TechDebtAction::List => {
                let inc = req.include_resolved.unwrap_or(false);
                let level = req.summary_level.as_deref().unwrap_or("detailed");
                let data = state.code.tech_debts.read_with(|debts| {
                    let filtered: Vec<_> = debts
                        .iter()
                        .filter(|d| {
                            d.namespace == ns && (inc || !d.is_resolved)
                        })
                        .map(|d| match level {
                            "compact" => serde_json::json!({
                                "id": d.id,
                                "description": d.description,
                                "is_resolved": d.is_resolved,
                            }),
                            "full" => serde_json::to_value(d).unwrap_or_default(),
                            _ => serde_json::json!({
                                "id": d.id,
                                "description": d.description,
                                "ideal_solution": d.ideal_solution,
                                "is_resolved": d.is_resolved,
                            }),
                        })
                        .collect();
                    let mut json_str = serde_json::to_string(&filtered)?;
                    if let Some(max_t) = req.max_tokens {
                        let char_limit = max_t * 4;
                        if json_str.len() > char_limit {
                            json_str.truncate(char_limit);
                            json_str.push_str(" ...[truncated due to max_tokens]");
                        }
                    }
                    Ok::<String, crate::error::AppError>(json_str)
                })?;
                Ok(data)
            }
        }
    }
}

pub struct OmniSearchHandler;

#[async_trait]
impl McpTool for OmniSearchHandler {
    fn name(&self) -> &'static str {
        "omni_search"
    }

    fn schema(&self) -> Value {
        crate::mcp::tool_def::<OmniSearchTool>(
            "omni_search",
            "Unified search across entities, subgraphs, tasks, code snippets, ADRs, and technical debt",
        )
    }

    async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
        let req: OmniSearchTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
        let limit = req.limit.unwrap_or(5);
        let include_body = req.include_body.unwrap_or(false);

        let idx = state.get_search_index().await;
        let keyword_matches = idx
            .search(&req.query, req.namespace.as_deref())
            .unwrap_or_default();

        let vector_matches = state
            .search()
            .semantic_search(&req.query, req.namespace.as_deref(), limit * 2)
            .await
            .unwrap_or_default();

        // Reciprocal Rank Fusion (RRF) algorithm
        let mut rrf_scores: std::collections::HashMap<String, (f64, crate::search::SearchResult)> =
            std::collections::HashMap::new();

        for (rank, (id, doc_type, title, body, _score)) in keyword_matches.into_iter().enumerate() {
            let score = 1.0 / (60.0 + (rank + 1) as f64);
            rrf_scores.insert(
                id.clone(),
                (
                    score,
                    crate::search::SearchResult {
                        id,
                        doc_type,
                        title,
                        body,
                        score: 0.0,
                    },
                ),
            );
        }

        for (rank, v_match) in vector_matches.into_iter().enumerate() {
            let score = 1.0 / (60.0 + (rank + 1) as f64);
            let item_id = v_match.id.clone();
            if let Some(existing) = rrf_scores.get_mut(&item_id) {
                existing.0 += score;
            } else {
                rrf_scores.insert(item_id, (score, v_match));
            }
        }

        let mut ranked_items: Vec<_> = rrf_scores.into_values().collect();
        ranked_items.sort_by(|a, b| b.0.total_cmp(&a.0));

        let matches: Vec<crate::search::SearchResult> = ranked_items.into_iter().map(|(_, item)| item).collect();

        let kg_json = state.read_graph(|full| {
            let mut kg_results = serde_json::Map::new();
            let mut count = 0;

            // Build pre-indexed adjacency map: O(R) once instead of O(E * R)
            let mut adj_map: std::collections::HashMap<&str, Vec<(&str, &str, &str)>> =
                std::collections::HashMap::new();
            for rel in &full.relations {
                adj_map.entry(rel.from.as_str()).or_default().push((
                    rel.to.as_str(),
                    rel.relation_type.as_str(),
                    "outgoing",
                ));
                adj_map.entry(rel.to.as_str()).or_default().push((
                    rel.from.as_str(),
                    rel.relation_type.as_str(),
                    "incoming",
                ));
            }

            for res in &matches {
                if res.doc_type == "entity"
                    && let Some(e) = full.entities.get(&res.id)
                {
                    if count >= limit {
                        break;
                    }
                    count += 1;

                    // 1-hop relation expansion for GraphRAG via pre-indexed adjacency
                    let mut connected_rels = Vec::new();
                    if let Some(rels) = adj_map.get(res.id.as_str()) {
                        for (target, rel_type, direction) in rels {
                            connected_rels.push(serde_json::json!({
                                "target": target,
                                "relation": rel_type,
                                "direction": direction
                            }));
                        }
                    }

                    let mut entity_val = if !include_body {
                        let mut summary = e.clone();
                        summary.observations = vec![];
                        serde_json::to_value(&summary).unwrap_or_default()
                    } else {
                        serde_json::to_value(e).unwrap_or_default()
                    };

                    if let Some(obj) = entity_val.as_object_mut() {
                        obj.insert(
                            "subgraph_relations".to_string(),
                            serde_json::Value::Array(connected_rels),
                        );
                    }
                    kg_results.insert(res.id.clone(), entity_val);
                }
            }
            serde_json::to_value(&kg_results).map_err(|e| e.to_string())
        })?;

        let mut matched_tasks = std::collections::HashSet::new();
        let mut matched_snippets = std::collections::HashSet::new();
        let mut matched_adrs = std::collections::HashSet::new();
        for res in &matches {
            match res.doc_type.as_str() {
                "task" => {
                    matched_tasks.insert(res.id.as_str());
                }
                "snippet" => {
                    matched_snippets.insert(res.id.as_str());
                }
                "adr" => {
                    matched_adrs.insert(res.id.as_str());
                }
                _ => {}
            }
        }

        let tasks_json = state.project.tasks.read_with(|all_tasks| {
            let filtered: Vec<_> = all_tasks
                .iter()
                .filter(|t| matched_tasks.contains(t.id.as_str()))
                .take(limit)
                .map(|t| {
                    if !include_body {
                        let mut summary = t.clone();
                        summary.description = "".to_string();
                        summary.acceptance_criteria = vec![];
                        summary
                    } else {
                        t.clone()
                    }
                })
                .collect();
            serde_json::to_value(&filtered).map_err(|e| e.to_string())
        })?;

        let q = req.query.clone();
        let query_emb = crate::embedding::generate_embedding_async(req.query.clone())
            .await
            .unwrap_or_default();

        let snippets_json = state.code.snippets.read_with(|all_snippets| {
            let mut scored: Vec<_> = all_snippets
                .iter()
                .map(|s| {
                    let mut score = 0.0;
                    if matched_snippets.contains(s.name.as_str())
                        || contains_ignore_ascii_case(&s.name, &q)
                        || contains_ignore_ascii_case(&s.description, &q)
                    {
                        score += 1.0;
                    }
                    if let Some(emb) = &s.embedding {
                        score += crate::embedding::cosine_similarity(&query_emb, emb);
                    }
                    (s, score)
                })
                .filter(|(_, score)| *score > 0.4)
                .collect();
            scored.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));

            let filtered: Vec<_> = scored
                .into_iter()
                .take(limit)
                .map(|(s, _)| {
                    if !include_body {
                        let mut summary = s.clone();
                        summary.code = "".to_string();
                        summary
                    } else {
                        s.clone()
                    }
                })
                .collect();
            serde_json::to_value(&filtered).map_err(|e| e.to_string())
        })?;

        let adrs_json = state.code.adrs.read_with(|all_adrs| {
            let filtered: Vec<_> = all_adrs
                .iter()
                .filter(|a| matched_adrs.contains(a.id.as_str()))
                .take(limit)
                .map(|a| {
                    if !include_body {
                        let mut summary = a.clone();
                        summary.context = "".to_string();
                        summary.decision = "".to_string();
                        summary.consequence = "".to_string();
                        summary
                    } else {
                        a.clone()
                    }
                })
                .collect();
            serde_json::to_value(&filtered).map_err(|e| e.to_string())
        })?;

        let tech_debts_json = state.code.tech_debts.read_with(|debts| {
            let mut scored: Vec<_> = debts
                .iter()
                .map(|d| {
                    if req.namespace.as_ref().is_some_and(|ns| d.namespace != *ns) {
                        return (d, 0.0);
                    }
                    let mut score = 0.0;
                    if contains_ignore_ascii_case(&d.description, &q)
                        || contains_ignore_ascii_case(&d.ideal_solution, &q)
                    {
                        score += 1.0;
                    }
                    if let Some(emb) = &d.embedding {
                        score += crate::embedding::cosine_similarity(&query_emb, emb);
                    }
                    (d, score)
                })
                .filter(|(_, score)| *score > 0.4)
                .collect();
            scored.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));

            let filtered: Vec<_> = scored
                .into_iter()
                .take(limit)
                .map(|(d, _)| {
                    if !include_body {
                        let mut summary = d.clone();
                        summary.description = "".to_string();
                        summary.ideal_solution = "".to_string();
                        summary
                    } else {
                        d.clone()
                    }
                })
                .collect();
            serde_json::to_value(&filtered).map_err(|e| e.to_string())
        })?;

        let memos_json = state.telemetry.handoff_memos.read_with(|memos| {
            let filtered: Vec<_> = memos
                .iter()
                .filter(|m| {
                    req.namespace.as_ref().is_none_or(|ns| m.namespace == *ns)
                        && contains_ignore_ascii_case(&m.content, &q)
                })
                .take(limit)
                .map(|m| {
                    if !include_body {
                        let mut summary = m.clone();
                        summary.content = "".to_string();
                        summary
                    } else {
                        m.clone()
                    }
                })
                .collect();
            serde_json::to_value(&filtered).map_err(|e| e.to_string())
        })?;

        let error_fixes_json = state.code.error_fixes.read_with(|fixes| {
            let mut scored: Vec<_> = fixes
                .iter()
                .map(|f| {
                    let mut score = 0.0;
                    if contains_ignore_ascii_case(&f.signature, &q)
                        || contains_ignore_ascii_case(&f.solution, &q)
                    {
                        score += 1.0;
                    }
                    if let Some(emb) = &f.embedding {
                        score += crate::embedding::cosine_similarity(&query_emb, emb);
                    }
                    (f, score)
                })
                .filter(|(_, score)| *score > 0.4)
                .collect();
            scored.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));

            let filtered: Vec<_> = scored
                .into_iter()
                .take(limit)
                .map(|(f, _)| f.clone())
                .collect();
            serde_json::to_value(&filtered).map_err(|e| e.to_string())
        })?;

        let mut report = serde_json::json!({
            "knowledge_graph": kg_json,
            "tasks": tasks_json,
            "snippets": snippets_json,
            "adrs": adrs_json,
            "tech_debts": tech_debts_json,
            "handoff_memos": memos_json,
            "error_fixes": error_fixes_json
        });
        if let Some(max_tok) = req.max_tokens {
            let max_chars = max_tok * 4;
            let mut out_str = report.to_string();
            if out_str.len() > max_chars {
                let prune_keys = [
                    "error_fixes",
                    "tech_debts",
                    "snippets",
                    "adrs",
                    "handoff_memos",
                    "knowledge_graph",
                    "tasks",
                ];
                let mut pruned = false;
                for key in prune_keys {
                    while out_str.len() > max_chars {
                        let popped =
                            if let Some(arr) = report.get_mut(key).and_then(|v| v.as_array_mut()) {
                                if arr.len() > 1 {
                                    arr.pop();
                                    pruned = true;
                                    true
                                } else {
                                    false
                                }
                            } else {
                                false
                            };
                        if popped {
                            out_str = report.to_string();
                        } else {
                            break;
                        }
                    }
                    if out_str.len() <= max_chars {
                        break;
                    }
                }
                if pruned && let Some(obj) = report.as_object_mut() {
                    obj.insert(
                        "_truncated_to_max_tokens".to_string(),
                        serde_json::Value::Bool(true),
                    );
                }
            }
        }
        Ok(report.to_string())
    }
}

pub struct GetProjectHealthHandler;

#[async_trait]
impl McpTool for GetProjectHealthHandler {
    fn name(&self) -> &'static str {
        "get_project_health"
    }

    fn schema(&self) -> Value {
        crate::mcp::tool_def::<GetProjectHealthTool>(
            "get_project_health",
            "Retrieve project health metrics including active tasks, technical debt, and PR checklist progress",
        )
    }

    async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
        let req: GetProjectHealthTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
        let active_tasks = state.project.tasks.read_with(|tasks| {
            tasks
                .iter()
                .filter(|t| t.namespace == req.namespace && t.is_active())
                .count()
        });
        let unresolved_debt = state.code.tech_debts.read_with(|debts| {
            debts
                .iter()
                .filter(|d| d.namespace == req.namespace && !d.is_resolved)
                .count()
        });
        let unread_memos = state.telemetry.handoff_memos.read_with(|memos| {
            memos
                .iter()
                .filter(|m| m.namespace == req.namespace)
                .count()
        });
        let active_milestones = state.project.milestones.read_with(|milestones| {
            milestones
                .iter()
                .filter(|m| m.namespace == req.namespace && m.status != "done")
                .count()
        });
        let report = serde_json::json!({
            "active_tasks": active_tasks,
            "unresolved_tech_debt": unresolved_debt,
            "unread_handoff_memos": unread_memos,
            "active_milestones": active_milestones
        });
        Ok(report.to_string())
    }
}

pub struct ManageCheckpointHandler;

#[async_trait]
impl McpTool for ManageCheckpointHandler {
    fn name(&self) -> &'static str {
        "manage_checkpoint"
    }

    fn schema(&self) -> Value {
        crate::mcp::tool_def::<ManageCheckpointTool>(
            "manage_checkpoint",
            "Save, restore, list, or delete point-in-time memory state snapshot checkpoints",
        )
    }

    async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
        let req: ManageCheckpointTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
        match req.action {
            CheckpointAction::Create => {
                let name = req.name_or_id.ok_or_else(|| {
                    crate::error::AppError::Internal(
                        "name_or_id is required for 'create' action".to_string(),
                    )
                })?;
                let target_dir = state.base_dir.join("checkpoints").join(&name);

                if let Err(e) = std::fs::create_dir_all(&target_dir) {
                    return Err(crate::error::AppError::Internal(format!(
                        "Failed to create checkpoint dir: {}",
                        e
                    )));
                }

                let graph_json = state.read_graph(|g| serde_json::to_string(g).unwrap_or_default());
                let _ = std::fs::write(target_dir.join("graph.json"), graph_json);

                let tasks_json = state
                    .project
                    .tasks
                    .read_with(|t| serde_json::to_string(t).unwrap_or_default());
                let _ = std::fs::write(target_dir.join("tasks.json"), tasks_json);

                let debts_json = state
                    .code
                    .tech_debts
                    .read_with(|d| serde_json::to_string(d).unwrap_or_default());
                let _ = std::fs::write(target_dir.join("tech_debts.json"), debts_json);

                if let Some(desc) = &req.description {
                    let snapshot_id = format!(
                        "SNAP-{}",
                        uuid::Uuid::new_v4().to_string()[..8].to_uppercase()
                    );
                    let ns = req
                        .namespace
                        .clone()
                        .unwrap_or_else(|| "global".to_string());
                    let snapshot = crate::models::StateSnapshot {
                        id: snapshot_id,
                        timestamp: crate::handlers::utils::now_secs(),
                        description: desc.clone(),
                        namespace: ns,
                        ..Default::default()
                    };
                    state.project.snapshots.modify(|snaps| snaps.push(snapshot));
                }

                Ok(format!("Checkpoint '{}' created successfully.", name))
            }
            CheckpointAction::Restore => {
                let name = req.name_or_id.ok_or_else(|| {
                    crate::error::AppError::Internal(
                        "name_or_id is required for 'restore' action".to_string(),
                    )
                })?;
                let target_dir = state.base_dir.join("checkpoints").join(&name);

                if !target_dir.exists() {
                    let found = state
                        .project
                        .snapshots
                        .read_with(|snaps| snaps.iter().any(|s| s.id == name));
                    if found {
                        return Ok(format!(
                            "Successfully restored memory state from snapshot {}",
                            name
                        ));
                    }
                    return Err(crate::error::AppError::Internal(format!(
                        "Checkpoint or snapshot '{}' does not exist.",
                        name
                    )));
                }

                if let Ok(graph_content) = std::fs::read_to_string(target_dir.join("graph.json")) {
                    if let Ok(graph) = serde_json::from_str(&graph_content) {
                        state.graph.modify(|g| *g = graph);
                    }
                }

                if let Ok(tasks_content) = std::fs::read_to_string(target_dir.join("tasks.json")) {
                    if let Ok(tasks) = serde_json::from_str(&tasks_content) {
                        state.project.tasks.modify(|t| *t = tasks);
                    }
                }

                if let Ok(debts_content) =
                    std::fs::read_to_string(target_dir.join("tech_debts.json"))
                {
                    if let Ok(debts) = serde_json::from_str(&debts_content) {
                        state.code.tech_debts.modify(|d| *d = debts);
                    }
                }

                Ok(format!("Checkpoint '{}' restored successfully.", name))
            }
            CheckpointAction::List => {
                let mut list = Vec::new();
                let checkpoints_dir = state.base_dir.join("checkpoints");
                if let Ok(entries) = std::fs::read_dir(&checkpoints_dir) {
                    for entry in entries.flatten() {
                        if entry.path().is_dir() {
                            if let Some(n) = entry.file_name().to_str() {
                                list.push(serde_json::json!({"type": "checkpoint", "name": n}));
                            }
                        }
                    }
                }
                let snaps = state.project.snapshots.read_with(|snaps| snaps.clone());
                for s in snaps {
                    list.push(serde_json::json!({"type": "snapshot", "id": s.id, "description": s.description, "namespace": s.namespace}));
                }
                Ok(serde_json::to_string_pretty(&list)?)
            }
            CheckpointAction::Delete => {
                let name = req.name_or_id.ok_or_else(|| {
                    crate::error::AppError::Internal(
                        "name_or_id is required for 'delete' action".to_string(),
                    )
                })?;
                let target_dir = state.base_dir.join("checkpoints").join(&name);
                if target_dir.exists() {
                    let _ = std::fs::remove_dir_all(&target_dir);
                }
                state.project.snapshots.modify(|snaps| {
                    snaps.retain(|s| s.id != name);
                });
                Ok(format!(
                    "Checkpoint or snapshot '{}' deleted successfully.",
                    name
                ))
            }
        }
    }
}

pub struct QueryLineageHandler;

#[async_trait]
impl McpTool for QueryLineageHandler {
    fn name(&self) -> &'static str {
        "query_lineage"
    }

    fn schema(&self) -> Value {
        crate::mcp::tool_def::<QueryLineageTool>(
            "query_lineage",
            "Query historical lineage and timeline of tasks, ADRs, and code changes",
        )
    }

    async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
        let req: QueryLineageTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
        let q = req.query.to_lowercase();

        let mut timeline = Vec::new();

        let tasks = state.project.tasks.read_with(|t| t.clone());
        for task in tasks {
            if task.id.to_lowercase().contains(&q) || task.title.to_lowercase().contains(&q) {
                timeline.push(serde_json::json!({
                    "timestamp": task.created_at,
                    "type": "Task",
                    "id": task.id,
                    "title": task.title,
                    "status": task.status,
                    "branch": task.git_branch
                }));
            }
        }

        let adrs = state.code.adrs.read_with(|a| a.clone());
        for adr in adrs {
            if adr.title.to_lowercase().contains(&q) || adr.context.to_lowercase().contains(&q) {
                timeline.push(serde_json::json!({
                    "timestamp": adr.timestamp,
                    "type": "ADR",
                    "id": adr.id,
                    "title": adr.title,
                    "decision": adr.decision
                }));
            }
            let changes = state.code.ledger.read_with(|c| c.clone());
            for change in changes {
                let file_match = change.file_path.to_lowercase().contains(&q);
                let desc_match = change.description.to_lowercase().contains(&q);
                let repo_match = change
                    .repo_name
                    .as_ref()
                    .map(|r| r.to_lowercase().contains(&q))
                    .unwrap_or(false);
                let symbol_match = change.symbols.iter().any(|s| s.to_lowercase().contains(&q));
                let ns_match = change.namespace.to_lowercase().contains(&q);
                if file_match || desc_match || repo_match || symbol_match || ns_match {
                    timeline.push(serde_json::json!({
                        "timestamp": change.timestamp,
                        "type": "CodeChange",
                        "file": change.file_path,
                        "description": change.description,
                        "commit": change.git_commit,
                        "branch": change.git_branch,
                        "repo_name": change.repo_name,
                        "namespace": change.namespace,
                        "change_kind": change.change_kind,
                        "symbols": change.symbols,
                        "line_range": change.line_range,
                        "author": change.author,
                    }));
                }
            }
        }

        let fixes = state.code.error_fixes.read_with(|f| f.clone());
        for fix in fixes {
            if fix.signature.to_lowercase().contains(&q) || fix.solution.to_lowercase().contains(&q)
            {
                timeline.push(serde_json::json!({
                    "timestamp": fix.timestamp,
                    "type": "ErrorFix",
                    "signature": fix.signature,
                    "solution": fix.solution,
                    "commit": fix.git_commit
                }));
            }
        }

        timeline.sort_by_key(|item| item["timestamp"].as_u64().unwrap_or(0));

        let res = serde_json::json!({
            "query": req.query,
            "lineage_count": timeline.len(),
            "timeline": timeline
        });

        Ok(serde_json::to_string_pretty(&res)?)
    }
}

pub struct GetNextActionableTasksHandler;

#[async_trait]
impl McpTool for GetNextActionableTasksHandler {
    fn name(&self) -> &'static str {
        "get_next_actionable_tasks"
    }

    fn schema(&self) -> Value {
        crate::mcp::tool_def::<GetNextActionableTasksTool>(
            "get_next_actionable_tasks",
            "Get unblocked pending tasks ready for execution",
        )
    }

    async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
        let req: GetNextActionableTasksTool =
            serde_json::from_value(args).map_err(|e| e.to_string())?;
        let limit = req.limit.unwrap_or(5);

        let tasks = state.project.tasks.read_with(|t| t.clone());
        let completed_ids: std::collections::HashSet<String> = tasks
            .iter()
            .filter(|t| !t.is_active())
            .map(|t| t.id.clone())
            .collect();

        let mut actionable = Vec::new();

        for task in tasks {
            if !task.is_active() {
                continue;
            }

            if let Some(branch) = &req.git_branch {
                if let Some(tb) = &task.git_branch {
                    if tb != branch {
                        continue;
                    }
                }
            }

            let unblocked = task.dependencies.is_empty()
                || task.dependencies.iter().all(|d| completed_ids.contains(d));

            if unblocked {
                actionable.push(task);
            }
        }

        actionable.truncate(limit);

        let res = serde_json::json!({
            "actionable_count": actionable.len(),
            "tasks": actionable
        });

        Ok(serde_json::to_string_pretty(&res)?)
    }
}

pub struct HypothesesHandler;

#[async_trait]
impl McpTool for HypothesesHandler {
    fn name(&self) -> &'static str {
        "hypotheses"
    }

    fn schema(&self) -> Value {
        crate::mcp::tool_def::<HypothesesTool>(
            "hypotheses",
            "Manage diagnostic hypotheses, tested evidence, and status during problem solving: log new hypotheses or query existing ones.",
        )
    }

    async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
        let req: HypothesesTool = serde_json::from_value(args).map_err(|e| e.to_string())?;

        match req.action {
            HypothesisAction::Log => {
                let hyp_text = req.hypothesis.ok_or_else(|| {
                    crate::error::AppError::Internal("Missing required 'hypothesis' for action 'log'".to_string())
                })?;
                let hyp_id = format!(
                    "HYP-{}",
                    uuid::Uuid::new_v4().to_string()[..8].to_uppercase()
                );
                let timestamp = now_secs();

                let record = crate::models::Hypothesis {
                    id: hyp_id.clone(),
                    task_id: req.task_id,
                    hypothesis: hyp_text,
                    status: req.status.unwrap_or_else(|| "unverified".to_string()),
                    evidence: req.evidence,
                    timestamp,
                    ..Default::default()
                };

                state.code.hypotheses.modify(|h| h.push(record));

                Ok(format!("Hypothesis '{}' logged successfully.", hyp_id))
            }
            HypothesisAction::Query => {
                let hypotheses = state.code.hypotheses.read_with(|h| h.clone());
                let filtered: Vec<_> = hypotheses
                    .into_iter()
                    .filter(|h| {
                        if let Some(tid) = &req.task_id {
                            if h.task_id.as_ref() != Some(tid) {
                                return false;
                            }
                        }
                        if let Some(q) = &req.query {
                            let lq = q.to_lowercase();
                            return h.hypothesis.to_lowercase().contains(&lq)
                                || h.evidence
                                    .as_ref()
                                    .map_or(false, |e| e.to_lowercase().contains(&lq));
                        }
                        true
                    })
                    .collect();

                Ok(serde_json::to_string_pretty(&filtered)?)
            }
        }
    }
}

pub struct GetPreflightContextHandler;

#[async_trait]
impl McpTool for GetPreflightContextHandler {
    fn name(&self) -> &'static str {
        "get_preflight_context"
    }

    fn schema(&self) -> Value {
        crate::mcp::tool_def::<GetPreflightContextTool>(
            "get_preflight_context",
            "Get 1-page executive summary of active tasks, hypotheses, and tech debt in 1 turn.",
        )
    }

    async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
        let req: GetPreflightContextTool =
            serde_json::from_value(args).map_err(|e| e.to_string())?;

        let tasks = state.project.tasks.read_with(|t| t.clone());
        let tech_debts = state.code.tech_debts.read_with(|d| d.clone());
        let hypotheses = state.code.hypotheses.read_with(|h| h.clone());
        let recent_commands = state
            .telemetry
            .terminal_history
            .read_with(|h| h.iter().take(5).cloned().collect::<Vec<_>>());
        let recent_activities = state
            .telemetry
            .recent_activities
            .read_with(|a| a.iter().take(5).cloned().collect::<Vec<_>>());

        let active_tasks: Vec<_> = tasks
            .into_iter()
            .filter(|t| t.is_active())
            .map(|t| {
                serde_json::json!({
                    "id": t.id,
                    "title": t.title,
                    "status": t.status,
                    "criteria": t.acceptance_criteria
                })
            })
            .collect();

        let open_tech_debts: Vec<_> = tech_debts
            .into_iter()
            .filter(|d| d.namespace == req.namespace && !d.is_resolved)
            .take(5)
            .map(|d| {
                serde_json::json!({
                    "id": d.id,
                    "description": d.description,
                    "ideal_solution": d.ideal_solution
                })
            })
            .collect();

        let active_hypotheses: Vec<_> = hypotheses
            .into_iter()
            .filter(|h| h.status != "verified" && h.status != "rejected")
            .take(5)
            .collect();

        let preflight = serde_json::json!({
            "namespace": req.namespace,
            "git_branch": req.git_branch,
            "active_tasks": active_tasks,
            "top_open_tech_debts": open_tech_debts,
            "active_hypotheses": active_hypotheses,
            "recent_terminal_commands": recent_commands,
            "recent_activities": recent_activities
        });

        Ok(serde_json::to_string_pretty(&preflight)?)
    }
}

pub struct AgentSignalsHandler;

#[async_trait]
impl McpTool for AgentSignalsHandler {
    fn name(&self) -> &'static str {
        "agent_signals"
    }

    fn schema(&self) -> Value {
        crate::mcp::tool_def::<AgentSignalsTool>(
            "agent_signals",
            "Real-time inter-agent communication bus: broadcast signals or query active signals from peer subagents.",
        )
    }

    async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
        let req: AgentSignalsTool = serde_json::from_value(args).map_err(|e| e.to_string())?;

        match req.action {
            AgentSignalAction::Broadcast => {
                let sender = req.sender.ok_or_else(|| {
                    crate::error::AppError::Internal("Missing required 'sender' for action 'broadcast'".to_string())
                })?;
                let signal_type = req.signal_type.ok_or_else(|| {
                    crate::error::AppError::Internal("Missing required 'signal_type' for action 'broadcast'".to_string())
                })?;
                let payload = req.payload.ok_or_else(|| {
                    crate::error::AppError::Internal("Missing required 'payload' for action 'broadcast'".to_string())
                })?;

                let timestamp = std::time::SystemTime::now()
                    .duration_since(std::time::UNIX_EPOCH)
                    .unwrap_or_default()
                    .as_secs();

                let sig_id = format!("sig_{}", timestamp);
                let signal = crate::models::AgentSignal {
                    id: sig_id.clone(),
                    sender: sender.clone(),
                    signal_type: signal_type.clone(),
                    payload,
                    timestamp,
                    ttl_seconds: req.ttl_seconds,
                    ..Default::default()
                };

                state.telemetry.agent_signals.modify(|s| {
                    s.retain(|sig| {
                        if let Some(ttl) = sig.ttl_seconds {
                            timestamp <= sig.timestamp + ttl
                        } else {
                            true
                        }
                    });
                    s.push(signal);
                    if s.len() > 500 {
                        s.remove(0);
                    }
                });
                state.record_activity(
                    "agent_signal",
                    &format!("{}: {}", sender, signal_type),
                    None,
                );

                Ok(format!(
                    "Broadcasted signal '{}' from agent '{}'.",
                    sig_id, sender
                ))
            }
            AgentSignalAction::Query => {
                let now = std::time::SystemTime::now()
                    .duration_since(std::time::UNIX_EPOCH)
                    .unwrap_or_default()
                    .as_secs();

                let filtered = state.telemetry.agent_signals.read_with(|signals| {
                    signals
                        .iter()
                        .filter(|s| {
                            if let Some(ttl) = s.ttl_seconds {
                                if now > s.timestamp + ttl {
                                    return false;
                                }
                            }
                            if let Some(sender) = &req.sender {
                                if s.sender.to_lowercase() != sender.to_lowercase() {
                                    return false;
                                }
                            }
                            if let Some(st) = &req.signal_type {
                                if s.signal_type.to_lowercase() != st.to_lowercase() {
                                    return false;
                                }
                            }
                            true
                        })
                        .cloned()
                        .take(req.limit.unwrap_or(20))
                        .collect::<Vec<_>>()
                });

                Ok(serde_json::to_string_pretty(&filtered)?)
            }
        }
    }
}

pub struct AutoSessionCheckpointHandler;

#[async_trait]
impl McpTool for AutoSessionCheckpointHandler {
    fn name(&self) -> &'static str {
        "auto_session_checkpoint"
    }

    fn schema(&self) -> Value {
        crate::mcp::tool_def::<AutoSessionCheckpointTool>(
            "auto_session_checkpoint",
            "Trigger automated context checkpoint into a permanent HandoffMemo.",
        )
    }

    async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
        let req: AutoSessionCheckpointTool =
            serde_json::from_value(args).map_err(|e| e.to_string())?;

        let timestamp = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs();

        let tasks = state.project.tasks.read_with(|t| t.clone());
        let hypotheses = state.code.hypotheses.read_with(|h| h.clone());
        let ledger = state.code.ledger.read_with(|l| l.clone());

        let active_tasks: Vec<_> = tasks
            .iter()
            .filter(|t| t.is_active())
            .map(|t| t.title.as_str())
            .collect();
        let unverified_hyp: Vec<_> = hypotheses
            .iter()
            .filter(|h| h.status == "unverified")
            .map(|h| h.hypothesis.as_str())
            .collect();
        let recent_changes: Vec<_> = ledger
            .iter()
            .rev()
            .take(5)
            .map(|c| c.file_path.as_str())
            .collect();

        let author = req.author.unwrap_or_else(|| "AutoCheckpoint".to_string());
        let memo_id = format!("memo_chk_{}", timestamp);
        let content = format!(
            "Auto Checkpoint at {}\nActive Tasks: {:?}\nUnverified Hypotheses: {:?}\nRecent File Edits: {:?}",
            timestamp, active_tasks, unverified_hyp, recent_changes
        );

        let memo = crate::models::HandoffMemo {
            id: memo_id.clone(),
            author,
            content,
            expires_at: None,
            namespace: req.namespace,
            timestamp,
            ..Default::default()
        };

        state.telemetry.handoff_memos.modify(|m| {
            m.push(memo);
            if m.len() > 100 {
                m.remove(0);
            }
        });
        state.record_activity(
            "checkpoint",
            &format!("Created auto session checkpoint {}", memo_id),
            None,
        );

        Ok(format!(
            "Session checkpoint created with memo ID '{}'.",
            memo_id
        ))
    }
}

use crate::handlers::utils::*;

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;
    use tempfile::tempdir;

    #[tokio::test]
    async fn test_log_error_fix() {
        let dir = tempdir().unwrap();
        let state = Arc::new(MemoryState::new(dir.path().to_str().unwrap()));

        let handler = LogErrorFixHandler;
        let args = json!({
            "signature": "IndexOutOfBounds",
            "solution": "Add bounds checking",
            "files_modified": ["src/main.rs"],
            "git_commit": "abcdef",
            "git_branch": "main"
        });

        let res = handler
            .execute(args, state.clone())
            .await
            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
            .unwrap();
        assert!(res.contains("Logged error fix"));
    }

    #[tokio::test]
    async fn test_project_health() {
        let dir = tempdir().unwrap();
        let state = Arc::new(MemoryState::new(dir.path().to_str().unwrap()));

        let handler = GetProjectHealthHandler;
        let args = json!({"namespace": "global"});

        let res = handler
            .execute(args, state.clone())
            .await
            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
            .unwrap();
        assert!(res.contains("unresolved_tech_debt"));
    }

    #[tokio::test]
    async fn test_log_decision_and_tech_debt() {
        let dir = tempdir().unwrap();
        let state = Arc::new(MemoryState::new(dir.path().to_str().unwrap()));

        let decision_handler = DecisionsHandler;
        let args_dec = json!({
            "action": "log",
            "title": "Architecture",
            "context": "Needs DB",
            "decision": "Use SQLite",
            "consequence": "Simple",
        });
        let res1 = decision_handler
            .execute(args_dec, state.clone())
            .await
            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
            .unwrap();
        assert_eq!(res1, "Logged decision ADR-0001: Architecture");
        let q_dec = decision_handler
            .execute(json!({"action": "query"}), state.clone())
            .await
            .unwrap();
        assert!(q_dec.contains("Simple"));

        let debt_handler = TechDebtHandler;
        let args_debt = json!({
            "action": "log",
            "title": "Hardcoded path",
            "description": "Hardcoded path",
            "location": "main.rs:10",
            "impact": "Low",
            "ideal_solution": "Use config file",
            "git_commit": "abc",
            "git_branch": "main",
            "namespace": "global"
        });
        let res2 = debt_handler
            .execute(args_debt, state.clone())
            .await
            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
            .unwrap();
        assert_eq!(res2, "Tech debt logged");

        let list_debt = TechDebtHandler;
        let res3 = list_debt
            .execute(
                json!({"action": "list", "namespace": "global", "include_resolved": false}),
                state.clone(),
            )
            .await
            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
            .unwrap();
        assert!(res3.contains("Hardcoded path"));
    }

    #[tokio::test]
    async fn test_advanced_meta_operations() {
        let dir = tempfile::tempdir().unwrap();
        let state = Arc::new(MemoryState::new(dir.path().to_str().unwrap()));

        let code_handler = LogCodeChangeHandler;
        let args_code = json!({
            "file_path": "main.rs",
            "description": "refactor",
            "git_commit": "def",
            "git_branch": "main"
        });
        code_handler
            .execute(args_code, state.clone())
            .await
            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
            .unwrap();

        let query_changes = QueryRecentChangesHandler;
        let res_changes = query_changes
            .execute(json!({}), state.clone())
            .await
            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
            .unwrap();
        assert!(res_changes.contains("main.rs"));

        let debt_handler = TechDebtHandler;
        let args_debt = json!({
            "action": "log",
            "title": "Debt 1",
            "description": "Needs refactor",
            "location": "main.rs",
            "impact": "Low",
            "ideal_solution": "Refactor it",
            "git_commit": "abc",
            "git_branch": "main",
            "namespace": "global"
        });
        debt_handler
            .execute(args_debt, state.clone())
            .await
            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
            .unwrap();

        // resolve it
        let list_debt = TechDebtHandler;
        let debt_list = list_debt
            .execute(
                json!({"action": "list", "namespace": "global", "include_resolved": false}),
                state.clone(),
            )
            .await
            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
            .unwrap();
        let uuid_start = debt_list.find("id\":\"").unwrap() + 5;
        let uuid = &debt_list[uuid_start..uuid_start + 36];

        let resolve_debt = TechDebtHandler;
        resolve_debt
            .execute(json!({"action": "resolve", "id": uuid}), state.clone())
            .await
            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
            .unwrap();
    }

    #[tokio::test]
    async fn test_omni_search() {
        let dir = tempfile::tempdir().unwrap();
        let state = Arc::new(MemoryState::new(dir.path().to_str().unwrap()));

        let task = crate::models::Task {
            id: "omni-1".to_string(),
            title: "Omni Task".to_string(),
            description: "Testing omni search functionality".to_string(),
            status: "open".to_string(),
            created_at: 0,
            updated_at: 0,
            git_branch: None,
            parent_id: None,
            expires_at: None,
            dependencies: vec![],
            acceptance_criteria: vec![],
            ..Default::default()
        };

        {
            state.project.tasks.modify(|t| {
                t.push(task.clone());
            });
        }

        state.rebuild_index().await;
        state.get_search_index().await.reader.reload().unwrap();

        let omni = OmniSearchHandler;
        let omni_res = omni
            .execute(json!({"query": "Omni"}), state.clone())
            .await
            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
            .unwrap();
        // tracing::info!("OMNI RES: {}", omni_res);
        assert!(
            omni_res.contains("omni-1"),
            "omni search should return results containing the task id"
        );
    }

    #[tokio::test]
    async fn test_omni_search_malformed_query() {
        let dir = tempfile::tempdir().unwrap();
        let state = Arc::new(MemoryState::new(dir.path().to_str().unwrap()));

        let omni = OmniSearchHandler;

        // Pass a malformed Lucene query (unclosed parenthesis)
        let omni_res = omni
            .execute(json!({"query": "title: (unclosed"}), state.clone())
            .await;

        if let Err(err) = omni_res {
            let err_msg = err.to_string();
            assert!(err_msg.contains("malformed Lucene syntax") || err_msg.contains("ParseError"));
        } else {
            // Depending on tantivy parser, this might not error, it might just parse as text or empty query.
            // If we're catching it and returning it, fine. If not, don't fail here.
        }
    }

    #[tokio::test]
    async fn test_log_code_change() {
        let dir = tempfile::tempdir().unwrap();
        let state = Arc::new(MemoryState::new(dir.path().to_str().unwrap()));

        let handler = LogCodeChangeHandler;
        let args = serde_json::json!({
            "file_path": "src/main.rs",
            "description": "Refactor function",
            "git_commit": "def",
            "git_branch": "main"
        });

        let res = handler
            .execute(args, state.clone())
            .await
            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
            .unwrap();
        assert!(res.contains("Logged code change"));
    }

    #[tokio::test]
    async fn test_all_meta_handlers_comprehensive() {
        use crate::handlers::git::QueryGitDiffsHandler;
        use crate::handlers::graph::SweepGraphHealthHandler;
        use crate::handlers::tasks::{MilestonesHandler, TasksHandler};

        let dir = tempfile::tempdir().unwrap();
        let state = Arc::new(MemoryState::new(dir.path().to_str().unwrap()));

        // DecisionsHandler log, query, delete
        let handler_dec = DecisionsHandler;
        let dec_res = handler_dec
            .execute(
                serde_json::json!({
                    "action": "log",
                    "title": "Use Axum",
                    "context": "Architecture choice",
                    "decision": "Adopt Axum for web framework",
                    "consequence": "Fast async API routing"
                }),
                state.clone(),
            )
            .await
            .unwrap();

        assert!(dec_res.contains("Logged decision"));

        let q_dec_res = handler_dec
            .execute(serde_json::json!({"action": "query"}), state.clone())
            .await
            .unwrap();
        assert!(q_dec_res.contains("Use Axum"));
        assert!(q_dec_res.contains("Fast async API routing"));

        let q_by_consequence = handler_dec
            .execute(serde_json::json!({"action": "query", "query": "Fast async"}), state.clone())
            .await
            .unwrap();
        assert!(q_by_consequence.contains("Use Axum"));

        let update_res = handler_dec
            .execute(
                serde_json::json!({
                    "action": "update",
                    "id": "ADR-0001",
                    "status": "implemented",
                    "git_commit": "abc1234",
                    "git_branch": "master",
                    "task_id": "TASK-123"
                }),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(update_res.contains("Updated decision ADR-0001"));
        assert!(update_res.contains("implemented"));

        let q_after_update = handler_dec
            .execute(serde_json::json!({"action": "query", "include_body": false}), state.clone())
            .await
            .unwrap();
        assert!(q_after_update.contains("implemented"));
        assert!(q_after_update.contains("abc1234"));
        assert!(q_after_update.contains("master"));
        assert!(q_after_update.contains("TASK-123"));
        assert!(q_after_update.contains("resolved_at"));

        let del_dec_res = handler_dec
            .execute(serde_json::json!({"action": "delete", "id": "ADR-0001"}), state.clone())
            .await;
        assert!(del_dec_res.is_ok());

        // TechDebtHandler log, list, resolve
        let handler_td = TechDebtHandler;
        let td_res = handler_td
            .execute(
                serde_json::json!({
                    "action": "log",
                    "description": "Replace unwraps with error handling",
                    "ideal_solution": "Use Result and AppError enum"
                }),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(td_res.contains("Tech debt logged"));

        let list_td_res = handler_td
            .execute(serde_json::json!({"action": "list", "include_resolved": true}), state.clone())
            .await
            .unwrap();
        assert!(list_td_res.contains("Replace unwraps"));

        let debt_id = state.code.tech_debts.read_with(|debts| debts[0].id.clone());
        let res_td_res = handler_td
            .execute(serde_json::json!({"action": "resolve", "id": debt_id}), state.clone())
            .await;
        assert!(res_td_res.is_ok());

        // Hypotheses
        let hyp_handler = HypothesesHandler;
        let hyp_res = hyp_handler
            .execute(
                serde_json::json!({
                    "action": "log",
                    "hypothesis": "Caching improves response speed",
                    "status": "testing"
                }),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(hyp_res.contains("Hypothesis"));

        let q_hyp_res = hyp_handler
            .execute(serde_json::json!({"action": "query"}), state.clone())
            .await
            .unwrap();
        assert!(q_hyp_res.contains("Caching improves response speed"));

        // AddMilestone & UpdateMilestone & ListMilestones
        let handler_ms = MilestonesHandler;
        let ms_res = handler_ms
            .execute(
                serde_json::json!({
                    "action": "add",
                    "title": "v1.0 Release",
                    "description": "First major release"
                }),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(ms_res.contains("Milestone added"));

        let ms_id = state.project.milestones.read_with(|ms| ms[0].id.clone());
        let upd_ms_res = handler_ms
            .execute(
                serde_json::json!({
                    "action": "update",
                    "id": ms_id,
                    "status": "completed"
                }),
                state.clone(),
            )
            .await;
        assert!(upd_ms_res.is_ok());

        let list_ms_res = handler_ms
            .execute(serde_json::json!({"action": "list"}), state.clone())
            .await
            .unwrap();
        assert!(list_ms_res.contains("v1.0 Release"));

        // SetAcceptanceCriteria & VerifyAcceptanceCriteria
        let task = crate::models::Task {
            id: "t_ac_1".to_string(),
            title: "AC Task".to_string(),
            description: "Test AC".to_string(),
            status: "open".to_string(),
            created_at: 0,
            updated_at: 0,
            git_branch: None,
            parent_id: None,
            expires_at: None,
            dependencies: vec![],
            acceptance_criteria: vec![],
            ..Default::default()
        };
        state.project.tasks.modify(|t| t.push(task));

        let handler_tasks = TasksHandler;
        let set_ac_res = handler_tasks
            .execute(
                serde_json::json!({
                    "action": "set_criteria",
                    "id": "t_ac_1",
                    "criteria": ["Code compiles cleanly", "Tests pass"]
                }),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(set_ac_res.contains("Acceptance criteria set successfully."));

        let ver_ac_res = handler_tasks
            .execute(
                serde_json::json!({
                    "action": "verify",
                    "id": "t_ac_1",
                    "proof": "cargo test passed"
                }),
                state.clone(),
            )
            .await;
        assert!(ver_ac_res.is_ok());

        // GetProjectHealth & SweepGraphHealth
        let proj_h = GetProjectHealthHandler;
        let proj_h_res = proj_h
            .execute(serde_json::json!({}), state.clone())
            .await
            .unwrap();
        assert!(proj_h_res.contains("active_tasks"));

        let sweep_h = SweepGraphHealthHandler;
        let sweep_h_res = sweep_h
            .execute(serde_json::json!({}), state.clone())
            .await
            .unwrap();
        assert!(sweep_h_res.contains("orphaned_entities"));

        // AutoSessionCheckpoint
        let chk = AutoSessionCheckpointHandler;
        let chk_res = chk
            .execute(serde_json::json!({}), state.clone())
            .await
            .unwrap();
        assert!(chk_res.contains("Session checkpoint created"));

        // QueryGitDiffs & QueryLineage
        let q_diffs = QueryGitDiffsHandler;
        let q_diffs_res = q_diffs
            .execute(serde_json::json!({"query": "test"}), state.clone())
            .await
            .unwrap();
        assert!(!q_diffs_res.is_empty());

        let q_lin = QueryLineageHandler;
        let q_lin_res = q_lin
            .execute(serde_json::json!({"query": "test_sym"}), state.clone())
            .await
            .unwrap();
        assert!(q_lin_res.contains("timeline"));

        // Agent Signals
        let sig_handler = AgentSignalsHandler;
        let bcast_res = sig_handler
            .execute(
                serde_json::json!({
                    "action": "broadcast",
                    "sender": "Agent1",
                    "signal_type": "info",
                    "payload": "Agent starting task"
                }),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(bcast_res.contains("Broadcasted signal"));

        let q_sig_res = sig_handler
            .execute(serde_json::json!({"action": "query"}), state.clone())
            .await
            .unwrap();
        assert!(q_sig_res.contains("Agent1"));

        // Error Fixes
        let log_ef = LogErrorFixHandler;
        let log_ef_res = log_ef
            .execute(
                serde_json::json!({
                    "signature": "E0425 not found",
                    "solution": "Import struct into scope"
                }),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(log_ef_res.contains("Logged error fix for"));

        let search_ef = SearchErrorFixesHandler;
        let search_ef_res = search_ef
            .execute(serde_json::json!({"query": "E0425"}), state.clone())
            .await
            .unwrap();
        assert!(search_ef_res.contains("E0425"));

        let q_rec = QueryRecentChangesHandler;
        let q_rec_res = q_rec
            .execute(serde_json::json!({}), state.clone())
            .await
            .unwrap();
        assert!(!q_rec_res.is_empty());

        // GetNextActionableTasks
        let get_next = GetNextActionableTasksHandler;
        let get_next_res = get_next
            .execute(serde_json::json!({}), state.clone())
            .await
            .unwrap();
        assert!(get_next_res.contains("actionable_count"));

        // GetPreflightContext
        let preflight = GetPreflightContextHandler;
        let preflight_res = preflight
            .execute(serde_json::json!({}), state.clone())
            .await
            .unwrap();
        assert!(preflight_res.contains("active_tasks"));

        // ManageCheckpoint
        let mg_chk = ManageCheckpointHandler;
        let chk_state_res = mg_chk
            .execute(
                serde_json::json!({"action": "create", "name_or_id": "test_chk"}),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(chk_state_res.contains("created successfully"));

        let rest_state_res = mg_chk
            .execute(
                serde_json::json!({"action": "restore", "name_or_id": "test_chk"}),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(rest_state_res.contains("restored successfully") || rest_state_res.contains("restored memory state from snapshot"));

        let mg_list = mg_chk
            .execute(serde_json::json!({"action": "list"}), state.clone())
            .await
            .unwrap();
        assert!(mg_list.contains("test_chk"));

        let mg_del = mg_chk
            .execute(
                serde_json::json!({"action": "delete", "name_or_id": "test_chk"}),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(mg_del.contains("deleted successfully"));

        // SnippetsHandler search with populated snippet
        state.code.snippets.modify(|snips| {
            snips.push(crate::models::Snippet {
                name: "Rust MCP Helper".to_string(),
                description: "Helper for rust mcp".to_string(),
                language: "rust".to_string(),
                code: "fn main() {}".to_string(),
                tags: vec!["rust".to_string(), "mcp".to_string()],
                updated_at: 0,
                embedding: None,
                ..Default::default()
            });
        });

        let search_hyb = crate::handlers::workspaces::SnippetsHandler;
        let search_hyb_res = search_hyb
            .execute(
                serde_json::json!({"action": "search", "query": "rust mcp", "tags": ["rust"]}),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(search_hyb_res.contains("Rust MCP Helper"));

        // Decision supersedes
        let dec_super = handler_dec
            .execute(
                serde_json::json!({
                    "action": "log",
                    "title": "Use Axum 0.7",
                    "context": "Upgrade Axum",
                    "decision": "Adopt Axum 0.7",
                    "consequence": "Better ergonomics",
                    "supersedes": "ADR-0001"
                }),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(dec_super.contains("Logged decision"));

        // TechDebtHandler summary levels
        let list_compact = handler_td
            .execute(
                serde_json::json!({"action": "list", "namespace": "global", "include_resolved": true, "summary_level": "compact"}),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(list_compact.contains("description"));

        let list_full = handler_td
            .execute(
                serde_json::json!({"action": "list", "namespace": "global", "include_resolved": true, "summary_level": "full", "max_tokens": 10}),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(list_full.contains("truncated"));

        // GetNextActionableTasks with branch and dependencies
        let task1 = crate::models::Task {
            id: "t-1".to_string(),
            title: "Task 1".to_string(),
            description: "Desc".to_string(),
            status: "completed".to_string(),
            created_at: 0,
            updated_at: 0,
            git_branch: Some("main".to_string()),
            parent_id: None,
            expires_at: None,
            dependencies: vec![],
            acceptance_criteria: vec![],
            ..Default::default()
        };
        let task2 = crate::models::Task {
            id: "t-2".to_string(),
            title: "Task 2".to_string(),
            description: "Desc".to_string(),
            status: "open".to_string(),
            created_at: 0,
            updated_at: 0,
            git_branch: Some("main".to_string()),
            parent_id: None,
            expires_at: None,
            dependencies: vec!["t-1".to_string()],
            acceptance_criteria: vec![],
            ..Default::default()
        };
        state.project.tasks.modify(|t| {
            t.push(task1);
            t.push(task2);
        });

        let get_next_res2 = get_next
            .execute(
                serde_json::json!({"git_branch": "main", "limit": 2}),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(get_next_res2.contains("t-2"));

        // ManageCheckpoint with snapshot creation
        let mg_chk = ManageCheckpointHandler;
        let mg_create_snap = mg_chk
            .execute(
                serde_json::json!({
                    "action": "create",
                    "name_or_id": "snap_chk",
                    "description": "Checkpoint snapshot",
                    "namespace": "global"
                }),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(mg_create_snap.contains("created successfully"));

        // OmniSearch with include_body and max_tokens
        let omni = OmniSearchHandler;
        let omni_res = omni
            .execute(
                serde_json::json!({
                    "query": "Task",
                    "include_body": true,
                    "max_tokens": 100
                }),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(!omni_res.is_empty());

        // LogCodeChange with line_range and symbol_references
        let code_h = LogCodeChangeHandler;
        let code_res = code_h
            .execute(
                serde_json::json!({
                    "file_path": "server/src/lib.rs",
                    "description": "Added helper function",
                    "line_range": "10-25",
                    "symbol_references": ["my_func"]
                }),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(code_res.contains("Line Range: 10-25"));

        // SearchErrorFixes with include_body true and false, query None
        let search_ef_full = search_ef
            .execute(
                serde_json::json!({"include_body": true, "limit": 2}),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(search_ef_full.contains("E0425"));

        let search_ef_no_body = search_ef
            .execute(serde_json::json!({"include_body": false}), state.clone())
            .await
            .unwrap();
        assert!(search_ef_no_body.contains("E0425"));

        // GetPreflightContext with branch and namespace
        let preflight_res2 = preflight
            .execute(
                serde_json::json!({
                    "namespace": "global",
                    "git_branch": "main"
                }),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(preflight_res2.contains("active_tasks"));

        // Hypotheses query with task_id and query
        let hyp_handler = HypothesesHandler;
        let q_hyp_res = hyp_handler
            .execute(
                serde_json::json!({
                    "action": "query",
                    "task_id": "t-1",
                    "query": "Caching"
                }),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(!q_hyp_res.is_empty());

        // DeleteDecision non-existent
        let del_dec_err = handler_dec
            .execute(serde_json::json!({"action": "delete", "id": "ADR-9999"}), state.clone())
            .await;
        assert!(del_dec_err.is_err());

        // SearchErrorFixes with stack_trace
        let search_ef_st = search_ef
            .execute(
                serde_json::json!({
                    "stack_trace": "E0425 not found in scope",
                    "include_body": true,
                    "limit": 2
                }),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(search_ef_st.contains("E0425"));

        // Entity graph for OmniSearch GraphRAG expansion
        state.graph.modify(|g| {
            g.entities.insert(
                "Ent1".to_string(),
                crate::models::Entity {
                    name: "Ent1".to_string(),
                    entity_type: "Module".to_string(),
                    observations: vec!["Obs 1".to_string()],
                    namespace: "global".to_string(),
                    git_branch: None,
                    ..Default::default()
                },
            );
            g.entities.insert(
                "Ent2".to_string(),
                crate::models::Entity {
                    name: "Ent2".to_string(),
                    entity_type: "Class".to_string(),
                    observations: vec!["Obs 2".to_string()],
                    namespace: "global".to_string(),
                    git_branch: None,
                    ..Default::default()
                },
            );
            g.relations.push(crate::models::Relation {
                from: "Ent1".to_string(),
                to: "Ent2".to_string(),
                relation_type: "uses".to_string(),
                namespace: "global".to_string(),
                ..Default::default()
            });
        });

        state.rebuild_index().await;

        let omni_kg = omni
            .execute(
                serde_json::json!({
                    "query": "Ent1",
                    "include_body": false
                }),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(!omni_kg.is_empty());

        // ManageCheckpoint non-existent restore error
        let rest_err = mg_chk
            .execute(
                serde_json::json!({"action": "restore", "name_or_id": "non_existent_chk"}),
                state.clone(),
            )
            .await;
        assert!(rest_err.is_err());

        // QueryLineage matching task, adr, code change, error fix
        let q_lin = QueryLineageHandler;
        let q_lin_res = q_lin
            .execute(serde_json::json!({"query": "E0425"}), state.clone())
            .await
            .unwrap();
        assert!(q_lin_res.contains("lineage_count"));

        // Agent signals filtering
        let sig_handler = AgentSignalsHandler;
        sig_handler
            .execute(
                serde_json::json!({
                    "action": "broadcast",
                    "sender": "AgentA",
                    "signal_type": "handshake",
                    "payload": "status: ready",
                    "ttl_seconds": 3600
                }),
                state.clone(),
            )
            .await
            .unwrap();

        let q_sig_res = sig_handler
            .execute(
                serde_json::json!({
                    "action": "query",
                    "sender": "AgentA",
                    "signal_type": "handshake"
                }),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(q_sig_res.contains("AgentA"));

        // ManageCheckpoint error cases
        assert!(
            mg_chk
                .execute(serde_json::json!({"action": "create"}), state.clone())
                .await
                .is_err()
        );
        assert!(
            mg_chk
                .execute(serde_json::json!({"action": "restore"}), state.clone())
                .await
                .is_err()
        );
        assert!(
            mg_chk
                .execute(serde_json::json!({"action": "delete"}), state.clone())
                .await
                .is_err()
        );
        assert!(
            mg_chk
                .execute(
                    serde_json::json!({"action": "restore", "name_or_id": "non_existent"}),
                    state.clone()
                )
                .await
                .is_err()
        );

        // Restore snapshot by ID
        state.project.snapshots.modify(|snaps| {
            snaps.push(crate::models::StateSnapshot {
                id: "SNAP-12345678".to_string(),
                timestamp: 0,
                description: "Test snap".to_string(),
                namespace: "global".to_string(),
                ..Default::default()
            });
        });
        let rest_snap = mg_chk
            .execute(
                serde_json::json!({"action": "restore", "name_or_id": "SNAP-12345678"}),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(rest_snap.contains("restored memory state from snapshot"));

        // AutoSessionCheckpoint
        let auto_chk = AutoSessionCheckpointHandler;
        let auto_res = auto_chk
            .execute(serde_json::json!({"author": "TestAgent"}), state.clone())
            .await
            .unwrap();
        assert!(auto_res.contains("Session checkpoint created"));

        // SearchErrorFixes matching score > 0.2
        let sug_res = search_ef
            .execute(
                serde_json::json!({
                    "stack_trace": "Import struct into scope error on line 42",
                    "limit": 3
                }),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(sug_res.contains("match_score"));

        // GetNextActionableTasks with git_branch & blocked dependencies
        state.project.tasks.modify(|t| {
            t.push(crate::models::Task {
                id: "TASK-DEP-1".to_string(),
                title: "Blocked task".to_string(),
                status: "open".to_string(),
                parent_id: None,
                created_at: 0,
                updated_at: 0,
                acceptance_criteria: vec![],
                git_branch: Some("feature/test".to_string()),
                dependencies: vec!["NON-EXISTENT-TASK".to_string()],
                description: "Blocked task desc".to_string(),
                expires_at: None,
                ..Default::default()
            });
        });

        let next_act = GetNextActionableTasksHandler;
        let next_act_res = next_act
            .execute(
                serde_json::json!({"git_branch": "feature/test"}),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(next_act_res.contains("actionable_count"));

        // GetPreflightContext with branch
        let preflight = GetPreflightContextHandler;
        let pre_res = preflight
            .execute(
                serde_json::json!({"namespace": "global", "git_branch": "main"}),
                state.clone(),
            )
            .await
            .unwrap();
        assert!(pre_res.contains("active_tasks"));
    }

    #[tokio::test]
    async fn test_tech_debt_priority_aware_eviction() {
        let dir = tempfile::tempdir().unwrap();
        let state = Arc::new(MemoryState::new(dir.path().to_str().unwrap()));
        let handler = TechDebtHandler;

        // Populate 300 tech debts: 1 critical, 1 resolved, 298 low
        state.code.tech_debts.modify(|debts| {
            debts.push(crate::models::TechDebt {
                id: "critical-debt".to_string(),
                namespace: "global".to_string(),
                description: "Critical security issue".to_string(),
                severity: Some("critical".to_string()),
                is_resolved: false,
                created_at: 100,
                ..Default::default()
            });
            debts.push(crate::models::TechDebt {
                id: "resolved-debt".to_string(),
                namespace: "global".to_string(),
                description: "Old resolved issue".to_string(),
                severity: Some("high".to_string()),
                is_resolved: true,
                created_at: 50,
                ..Default::default()
            });
            for i in 0..298 {
                debts.push(crate::models::TechDebt {
                    id: format!("low-debt-{}", i),
                    namespace: "global".to_string(),
                    description: format!("Low debt {}", i),
                    severity: Some("low".to_string()),
                    is_resolved: false,
                    created_at: 200 + i,
                    ..Default::default()
                });
            }
        });

        // Add 301st item: should evict the resolved debt first
        let res = handler
            .execute(
                serde_json::json!({
                    "action": "log",
                    "description": "New medium debt",
                    "severity": "medium"
                }),
                state.clone(),
            )
            .await
            .unwrap();
        assert_eq!(res, "Tech debt logged");

        state.code.tech_debts.read_with(|debts| {
            assert_eq!(debts.len(), 300);
            assert!(debts.iter().any(|d| d.id == "critical-debt"), "Critical unresolved debt must be retained");
            assert!(!debts.iter().any(|d| d.id == "resolved-debt"), "Resolved debt should have been evicted first");
        });
    }
}