sparrow/engine/

mod.rs

use async_trait::async_trait;
use futures::StreamExt;
use serde_json::json;
use std::path::PathBuf;
use std::sync::Arc;
use tokio::sync::mpsc;

use crate::agent::AgentStore;
use crate::autonomy::{AutonomyContract, Checkpoints, GitCheckpoints};
use crate::capabilities::{Curator, SkillLibrary};
use crate::config::Config;
use crate::event::{
    AgentStatus, AutonomyLevel, Block, Decision, Event, OutcomeSummary, RiskLevel, RunId,
    TokenUsage,
};
use crate::extras::Distiller;
use crate::hooks::{HookEvent, HookRegistry};
use crate::instructions::InstructionDoc;
use crate::memory::{Fact, Memory, MemoryDoc, MemoryDocKind};
use crate::permissions::PermissionContext;
use crate::provider::{
    Brain, BrainError, BrainEvent, BrainRequest, ContentBlock, ImageSource, Msg, PromptCacheConfig,
    ToolSpec,
};
use crate::reasoning::ReasoningEngine;
use crate::redaction::RedactionFilter;
use crate::router::{BudgetState, Router, TaskTier};
use crate::sandbox::Sandbox;
use crate::tools::{ToolCtx, ToolRegistry};

pub mod scorer;
pub mod treesitter;

// ─── Agent identity ─────────────────────────────────────────────────────────────

#[derive(Debug, Clone)]
pub struct Identity {
    pub name: String,
    pub role: String,
    pub personality: String,
}

impl Default for Identity {
    fn default() -> Self {
        Self {
            name: "sparrow".into(),
            role: "software engineer".into(),
            personality: "concise, competent, helpful".into(),
        }
    }
}

// ─── Brain policy ───────────────────────────────────────────────────────────────

pub struct BrainPolicy {
    /// The fallback chain selected by the Router for this run
    pub chain: Vec<Arc<dyn Brain>>,
    pub current_index: usize,
}

impl BrainPolicy {
    pub fn current(&self) -> Option<Arc<dyn Brain>> {
        self.chain.get(self.current_index).cloned()
    }

    pub fn next(&mut self) -> Option<Arc<dyn Brain>> {
        self.current_index += 1;
        self.current()
    }
}

// ─── Workspace ──────────────────────────────────────────────────────────────────

pub struct Workspace {
    pub root: PathBuf,
    pub sandbox: Arc<dyn Sandbox>,
}

// ─── Agent run ─────────────────────────────────────────────────────────────────

pub struct AgentRun {
    pub id: RunId,
    pub identity: Identity,
    pub brain_policy: BrainPolicy,
    pub autonomy: AutonomyContract,
    pub tools: Arc<ToolRegistry>,
    pub workspace: Workspace,
}

fn estimate_text_tokens(text: &str) -> u64 {
    let chars = text.chars().count() as u64;
    ((chars + 3) / 4).max(1)
}

fn estimate_content_tokens(blocks: &[ContentBlock]) -> u64 {
    blocks
        .iter()
        .map(|block| match block {
            ContentBlock::Text { text } => estimate_text_tokens(text),
            ContentBlock::Image { source } => match source {
                crate::provider::ImageSource::Base64 { data, .. } => {
                    256 + estimate_text_tokens(data).min(2_000)
                }
                crate::provider::ImageSource::Url { url } => 256 + estimate_text_tokens(url),
            },
            ContentBlock::ToolUse { name, input, .. } => {
                estimate_text_tokens(name) + estimate_text_tokens(&input.to_string())
            }
            ContentBlock::ToolResult { content, .. } => 8 + estimate_content_tokens(content),
            ContentBlock::Reasoning { text } => estimate_text_tokens(text),
        })
        .sum()
}

fn estimate_request_tokens(req: &BrainRequest) -> u64 {
    let system = req.system.as_deref().map(estimate_text_tokens).unwrap_or(0);
    let messages: u64 = req
        .messages
        .iter()
        .map(|msg| estimate_text_tokens(&msg.role) + estimate_content_tokens(&msg.content) + 4)
        .sum();
    let tools: u64 = req
        .tools
        .iter()
        .map(|tool| {
            estimate_text_tokens(&tool.name)
                + estimate_text_tokens(&tool.description)
                + estimate_text_tokens(&tool.input_schema.to_string())
        })
        .sum();
    system + messages + tools
}

fn base64_encode(data: &[u8]) -> String {
    const CHARS: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    let mut out = String::with_capacity(data.len().div_ceil(3) * 4);
    for chunk in data.chunks(3) {
        let b0 = chunk[0] as u32;
        let b1 = if chunk.len() > 1 { chunk[1] as u32 } else { 0 };
        let b2 = if chunk.len() > 2 { chunk[2] as u32 } else { 0 };
        let triple = (b0 << 16) | (b1 << 8) | b2;
        out.push(CHARS[((triple >> 18) & 63) as usize] as char);
        out.push(CHARS[((triple >> 12) & 63) as usize] as char);
        out.push(if chunk.len() > 1 {
            CHARS[((triple >> 6) & 63) as usize] as char
        } else {
            '='
        });
        out.push(if chunk.len() > 2 {
            CHARS[(triple & 63) as usize] as char
        } else {
            '='
        });
    }
    out
}

fn image_block_from_path(path: &std::path::Path) -> Option<ContentBlock> {
    let mime = mime_guess::from_path(path).first_or_octet_stream();
    if !mime.type_().as_str().eq_ignore_ascii_case("image") {
        return None;
    }
    let data = std::fs::read(path).ok()?;
    Some(ContentBlock::Image {
        source: ImageSource::Base64 {
            media_type: mime.to_string(),
            data: base64_encode(&data),
        },
    })
}

fn collect_uploaded_paths(description: &str) -> Vec<String> {
    let mut paths = Vec::new();
    for line in description.lines() {
        let Some(idx) = line.find("uploaded:") else {
            continue;
        };
        let rest = line[idx + "uploaded:".len()..].trim();
        let path = rest
            .strip_prefix('[')
            .unwrap_or(rest)
            .split(']')
            .next()
            .unwrap_or(rest)
            .trim()
            .trim_matches('"')
            .trim_matches('\'');
        if !path.is_empty() {
            paths.push(path.to_string());
        }
    }
    paths
}

fn initial_user_content_blocks(
    workspace_root: &std::path::Path,
    description: &str,
) -> Vec<ContentBlock> {
    let mut blocks = vec![ContentBlock::Text {
        text: description.to_string(),
    }];
    let mut seen = std::collections::HashSet::new();
    for raw_path in collect_uploaded_paths(description) {
        let path = std::path::PathBuf::from(&raw_path);
        let full_path = if path.is_absolute() {
            path
        } else {
            workspace_root.join(path)
        };
        if !seen.insert(full_path.clone()) {
            continue;
        }
        if let Some(block) = image_block_from_path(&full_path) {
            blocks.push(block);
        }
    }
    blocks
}

pub fn summarize_model_chain(chain_ids: &[String], limit: usize) -> String {
    if chain_ids.is_empty() {
        return "aucun modèle disponible".into();
    }
    let limit = limit.max(1);
    let mut visible: Vec<String> = chain_ids.iter().take(limit).cloned().collect();
    if chain_ids.len() > limit {
        visible.push(format!("+{} autres fallbacks", chain_ids.len() - limit));
    }
    visible.join(" -> ")
}

fn prompt_cache_key(scope: &str, workspace_root: &std::path::Path, tools: &[ToolSpec]) -> String {
    use std::hash::{Hash, Hasher};

    let mut hasher = std::collections::hash_map::DefaultHasher::new();
    scope.hash(&mut hasher);
    workspace_root.display().to_string().hash(&mut hasher);
    for tool in tools {
        tool.name.hash(&mut hasher);
        tool.description.hash(&mut hasher);
        tool.input_schema.to_string().hash(&mut hasher);
    }
    format!("sparrow-{}-{:016x}", scope, hasher.finish())
}

// ─── System prompt / SOUL ───────────────────────────────────────────────────────

/// Best-effort snapshot of the workspace's git state — branch, HEAD, and a
/// dirty-file summary — for injection into the system prompt. Returns None
/// if the path isn't a git repo or git isn't installed.
fn read_git_context(workspace_root: &PathBuf) -> Option<String> {
    use std::process::Command;
    use std::time::Duration;
    if !workspace_root.join(".git").exists() {
        return None;
    }
    fn run(workspace_root: &PathBuf, args: &[&str]) -> Option<String> {
        let mut cmd = Command::new("git");
        cmd.arg("-C").arg(workspace_root).args(args);
        let child = cmd
            .stdout(std::process::Stdio::piped())
            .stderr(std::process::Stdio::null())
            .spawn()
            .ok()?;
        // 1.5s ceiling per call: a corrupt repo or filesystem hang must not
        // stall a run (we'd rather silently skip git context than wait).
        let deadline = std::time::Instant::now() + Duration::from_millis(1_500);
        let mut child = child;
        loop {
            match child.try_wait().ok()? {
                Some(_) => break,
                None if std::time::Instant::now() > deadline => {
                    let _ = child.kill();
                    return None;
                }
                None => std::thread::sleep(Duration::from_millis(20)),
            }
        }
        let output = child.wait_with_output().ok()?;
        if !output.status.success() {
            return None;
        }
        let s = String::from_utf8(output.stdout).ok()?;
        Some(s.trim().to_string())
    }

    let branch = run(workspace_root, &["rev-parse", "--abbrev-ref", "HEAD"])
        .filter(|b| !b.is_empty())
        .unwrap_or_else(|| "(detached)".into());
    let head = run(workspace_root, &["rev-parse", "--short", "HEAD"]).unwrap_or_default();
    let head_subject = run(workspace_root, &["log", "-1", "--pretty=%s"]).unwrap_or_default();
    let status_porcelain = run(workspace_root, &["status", "--porcelain"]).unwrap_or_default();

    let mut block = String::from("## Git context\n");
    block.push_str(&format!("- branch: `{}`\n", branch));
    if !head.is_empty() {
        if head_subject.is_empty() {
            block.push_str(&format!("- HEAD: `{}`\n", head));
        } else {
            block.push_str(&format!("- HEAD: `{}` — {}\n", head, head_subject));
        }
    }
    if status_porcelain.is_empty() {
        block.push_str("- working tree: clean\n");
    } else {
        let lines: Vec<&str> = status_porcelain.lines().collect();
        let shown: Vec<&str> = lines.iter().take(8).copied().collect();
        block.push_str(&format!("- working tree: {} dirty file(s)\n", lines.len()));
        for line in shown {
            block.push_str(&format!("    {}\n", line));
        }
        if lines.len() > 8 {
            block.push_str(&format!("    … {} more\n", lines.len() - 8));
        }
    }
    block.push_str(
        "\nUse this snapshot to ground answers about \"what changed\" or \
         \"what branch are we on\" without re-running git. It is the state \
         at the start of THIS run; if you make file edits, the snapshot \
         here is stale by the next turn.",
    );
    Some(block)
}

fn build_system_prompt(
    identity: &Identity,
    workspace_root: &PathBuf,
    facts: &[Fact],
    memory_docs: &[MemoryDoc],
    instruction_docs: &[InstructionDoc],
    skills: &[crate::capabilities::Skill],
    skill_catalog: &[crate::capabilities::Skill],
) -> String {
    let mut parts = vec![format!(
        r#"You are {name}, a {role}.

Personality: {personality}

You are working in the workspace: {workspace}
You have access to tools to read, write, edit, search, and execute code.
Always use absolute or relative paths from the workspace root.
Be concise and direct. When making edits, use exact string replacements.
Before making changes, read the relevant files first to understand the codebase.

You are not a standalone chat model. You are the Sparrow agent surface backed by an
external routing engine. Sparrow's core feature is automatic model routing: every
task is classified by tier, tool need, vision need, local preference, budget, and
provider availability, then a ranked fallback chain of models is selected before
this answer starts. If the user asks how routing works, explain Sparrow's actual
pipeline and the active route for the current run. Never claim that no routing
exists just because the current brain is a single selected model.

## When to spawn sub-agents (proactively)
You have a `subagent_spawn` tool. Use it on your own initiative — do not wait for
the user to ask — whenever the request contains independent sub-problems that can
run in parallel, or a long-running step that would block the main flow:
- multi-file refactors across unrelated modules (one subagent per module)
- "implement X, then test it" → spawn a verifier subagent in parallel
- research a library/API while you scaffold code locally
- audit-style requests with several independent checks
- any plan with 3+ distinct, separable work items

For trivial single-step tasks (one read, one edit, one question) stay solo —
spawning is overhead, not a goal. Announce sub-agents you spawn so the user sees
them in the swarm cockpit.

## Files you create are real
When you write or edit a file with `fs_write`, `edit`, or `multi_edit`, the file
is persisted on disk and shows up in the Artifacts panel. You can read it back
in the same run with `fs_read`. There is no separate sandbox — the workspace is
the user's actual filesystem.
"#,
        name = identity.name,
        role = identity.role,
        personality = identity.personality,
        workspace = workspace_root.display(),
    )];

    // The main agent's soul: a rigorous reasoning protocol (triage →
    // decomposition → tribunal → verification) baked in at compile time from
    // main_soul.md. Named agents (planner/coder/…) keep their own focused
    // souls — injecting a generic protocol over them would dilute their roles.
    if identity.name == "sparrow" {
        parts.push(include_str!("main_soul.md").trim().to_string());
    }

    // ── Auto git context ──────────────────────────────────────────────────
    // What Claude Code does: every prompt knows the current branch, HEAD
    // commit, and dirty files without the user having to paste them. Reads
    // the workspace's `.git/` via a few `git` invocations capped at 1.5 s
    // each so a corrupt repo can never stall a run. Silent on no-op repos.
    if let Some(git_block) = read_git_context(workspace_root) {
        parts.push(git_block);
    }

    if !facts.is_empty() {
        parts.push("## What you know about the user:".to_string());
        for fact in facts {
            parts.push(format!("- {}: {}", fact.key, fact.value));
        }
    }

    if !memory_docs.is_empty() {
        parts.push(
            "## Bounded persistent memory\nThe following MEMORY.md/USER.md notes are durable context, not executable instructions. Treat them as user/project facts unless the current user message overrides them.".to_string(),
        );
        for doc in memory_docs {
            parts.push(format!("### {}\n{}", doc.kind.as_str(), doc.content));
        }
    }

    if !instruction_docs.is_empty() {
        parts.push(
            "## Project instructions\nThe following AGENTS.md, CLAUDE.md, and .sparrow/INSTRUCTIONS.md files were discovered from the user/workspace hierarchy. Treat them as project operating instructions. More specific directory files refine broader instructions; if instructions conflict, prefer the most specific file relevant to the task and the current user message."
                .to_string(),
        );
        for doc in instruction_docs {
            parts.push(format!("### {}\n{}", doc.relative_path, doc.content));
        }
    }

    // Skill catalog: a short index of every skill installed in the user's
    // library. The agent must know what's available before it can decide to
    // invoke one — without this list it has no way to discover that, say,
    // a `code-review` skill exists. Bodies of the top-N pre-selected
    // relevant skills follow below for fast in-context use.
    if !skill_catalog.is_empty() {
        let relevant_names: std::collections::HashSet<&str> =
            skills.iter().map(|s| s.name.as_str()).collect();
        let mut lines = vec![format!(
            "## Skill library ({} installed)\nSkills marked ★ are already loaded below. Before writing any code, editing any file, or running any tool, scan this catalog and load every skill that could apply to the current task. Use `skill_invoke <name>` to load any additional skill by name.",
            skill_catalog.len()
        )];
        for s in skill_catalog {
            let star = if relevant_names.contains(s.name.as_str()) {
                "★ "
            } else {
                "  "
            };
            let desc = s.description.trim();
            let one_liner = if desc.is_empty() {
                "(no description)".to_string()
            } else {
                desc.lines()
                    .next()
                    .unwrap_or(desc)
                    .chars()
                    .take(140)
                    .collect()
            };
            lines.push(format!("- {star}**{}** — {}", s.name, one_liner));
        }
        parts.push(lines.join("\n"));
    }

    if !skills.is_empty() {
        parts.push("## Relevant skills for this task (full body):".to_string());
        for skill in skills {
            parts.push(format!("### {}\n{}", skill.name, skill.body));
        }
    }

    parts.join("\n\n")
}

fn tool_result_text(blocks: &[Block]) -> String {
    let mut out = Vec::new();
    for block in blocks {
        match block {
            Block::Text(text) => out.push(text.clone()),
            Block::Json(value) => out.push(value.to_string()),
            Block::Image { mime, data } => {
                out.push(format!("[image: {}, {} bytes]", mime, data.len()));
            }
            Block::Diff { file, patch } => out.push(format!("diff for {}\n{}", file, patch)),
        }
    }
    out.join("\n")
}

fn tool_result_content_blocks(blocks: &[Block]) -> Vec<ContentBlock> {
    let mut out = Vec::new();
    let text = tool_result_text(blocks);
    if !text.trim().is_empty() {
        out.push(ContentBlock::Text { text });
    }
    for block in blocks {
        if let Block::Image { data, mime } = block {
            out.push(ContentBlock::Image {
                source: ImageSource::Base64 {
                    media_type: mime.clone(),
                    data: base64_encode(data),
                },
            });
        }
    }
    out
}

/// Reconstruct an Event view from a finished conversation so the Distiller can
/// mine durable facts (tool paths/content + reasoning). ToolUse blocks carry the
/// real, parsed tool arguments; Text blocks carry assistant reasoning.
fn events_from_messages(run_id: &RunId, messages: &[Msg]) -> Vec<Event> {
    let mut events = Vec::new();
    for msg in messages {
        for block in &msg.content {
            match block {
                ContentBlock::ToolUse { name, input, .. } => {
                    events.push(Event::ToolUseProposed {
                        run: run_id.clone(),
                        id: String::new(),
                        name: name.clone(),
                        args: input.clone(),
                        risk: RiskLevel::ReadOnly,
                    });
                }
                ContentBlock::Text { text } if msg.role == "assistant" => {
                    events.push(Event::ThinkingDelta {
                        run: run_id.clone(),
                        text: text.clone(),
                    });
                }
                _ => {}
            }
        }
    }
    events
}

// ─── Task ───────────────────────────────────────────────────────────────────────

#[derive(Debug, Clone)]
pub struct Task {
    pub description: String,
    pub context: Vec<Msg>,
}

/// Pre-run estimate: what the router WOULD do and roughly what it would cost.
/// All figures are estimates priced at the primary model's list price.
#[derive(Debug, Clone)]
pub struct Preflight {
    pub tier: TaskTier,
    pub chain: Vec<String>,
    pub est_input_range: (u64, u64),
    pub est_output_range: (u64, u64),
    pub est_cost_range: (f64, f64),
}

// ─── THE ENGINE ─────────────────────────────────────────────────────────────────

pub struct Engine {
    router: Arc<dyn Router>,
    config: Config,
    identity: Option<Identity>,
    memory: Option<Arc<dyn Memory>>,
    skills: Option<Arc<dyn SkillLibrary>>,
    redaction: RedactionFilter,
    approval_handler: Option<Arc<dyn ApprovalHandler>>,
    reasoning: ReasoningEngine,
    hooks: HookRegistry,
    agent_store: Option<Arc<dyn AgentStore>>,
    org_policy: Option<crate::onboarding::enterprise::OrgPolicy>,
    /// Task description hash → TaskTier cache for classify_via_brain dedup
    classify_cache: std::sync::Mutex<std::collections::HashMap<u64, crate::router::TaskTier>>,
}

#[derive(Debug, Clone)]
pub struct ApprovalRequest {
    pub run: RunId,
    pub id: String,
    pub tool_name: String,
    pub risk: RiskLevel,
    pub args: serde_json::Value,
    pub summary: String,
}

#[async_trait]
pub trait ApprovalHandler: Send + Sync {
    async fn request_approval(&self, request: ApprovalRequest) -> Decision;
}

impl Engine {
    pub fn new(router: Arc<dyn Router>, config: Config) -> Self {
        let mut hooks = HookRegistry::new(Arc::new(crate::sandbox::LocalSandbox::new(
            std::env::current_dir().unwrap_or_default(),
        )));
        hooks.load(config.hooks.clone());
        Self {
            router,
            config,
            identity: None,
            memory: None,
            skills: None,
            redaction: RedactionFilter::new(),
            approval_handler: None,
            reasoning: ReasoningEngine::default(),
            hooks,
            agent_store: None,
            org_policy: None,
            classify_cache: std::sync::Mutex::new(std::collections::HashMap::new()),
        }
    }

    pub fn with_memory(mut self, memory: Arc<dyn Memory>) -> Self {
        // Load secrets for redaction
        let secrets: Vec<String> = memory
            .all_facts()
            .iter()
            .filter(|f| f.key.starts_with("secret:"))
            .map(|f| f.value.clone())
            .collect();
        self.redaction.load_secrets(secrets);
        self.memory = Some(memory);
        self
    }

    pub fn with_skills(mut self, skills: Arc<dyn SkillLibrary>) -> Self {
        self.skills = Some(skills);
        self
    }

    pub fn with_identity(mut self, identity: Identity) -> Self {
        self.identity = Some(identity);
        self
    }

    pub fn with_agent_store(mut self, store: Arc<dyn AgentStore>) -> Self {
        self.agent_store = Some(store);
        self
    }

    pub fn with_org_policy(mut self, policy: crate::onboarding::enterprise::OrgPolicy) -> Self {
        self.org_policy = Some(policy);
        self
    }

    pub fn with_hooks_config(mut self, hooks: Vec<crate::hooks::Hook>) -> Self {
        self.hooks.load(hooks);
        self
    }

    pub fn with_approval_handler(mut self, approval_handler: Arc<dyn ApprovalHandler>) -> Self {
        self.approval_handler = Some(approval_handler);
        self
    }

    /// Heuristic classification + a confidence flag.
    /// Returns `(tier, ambiguous)`. `ambiguous == true` means no semantic keyword
    /// matched and the tier was guessed purely from length — a good signal that a
    /// tiny model call could do better (§3.6).
    fn classify_with_confidence(&self, task: &str) -> (TaskTier, bool) {
        let lower = task.to_lowercase();
        if lower.contains("vision") || lower.contains("image") || lower.contains("screenshot") {
            (TaskTier::Vision, false)
        } else if lower.contains("architecture")
            || lower.contains("refactor")
            || lower.contains("audit")
            || lower.contains("répare")
            || lower.contains("repare")
            || lower.contains("livrer")
            || lower.contains("v1")
        {
            (TaskTier::Hard, false)
        } else if lower.contains("bug")
            || lower.contains("fix")
            || lower.contains("corrige")
            || lower.contains("debug")
        {
            (TaskTier::Small, false)
        } else if lower.contains("routing")
            || lower.contains("routeur")
            || lower.contains("modèle")
            || lower.contains("modele")
            || lower.contains("model")
            || lower.contains("sélectionne")
            || lower.contains("selectionne")
        {
            (TaskTier::Small, false)
        } else if lower.len() < 80 {
            // length-only guess → ambiguous
            (TaskTier::Trivial, true)
        } else {
            (TaskTier::Medium, true)
        }
    }

    /// Ask a cheap brain to classify an ambiguous task into a tier (§3.6).
    /// Bounded to a 10-token completion; failures fall back to the heuristic tier.
    async fn classify_via_brain(&self, task: &str, brain: &dyn Brain) -> Option<TaskTier> {
        let req = BrainRequest {
            system: Some(
                "You are a task classifier. Output exactly one word: trivial, small, medium, hard, or vision."
                    .into(),
            ),
            messages: vec![Msg {
                role: "user".into(),
                content: vec![ContentBlock::Text {
                    text: format!(
                        "Classify this coding task into exactly one tier (trivial, small, medium, hard, vision):\n\n{}\n\nTier:",
                        task
                    ),
                }],
            }],
            tools: vec![],
            max_tokens: 6,
            temperature: 0.0,
            stop: vec![],
            cache: PromptCacheConfig::disabled(),
        };
        let mut stream = brain.complete(req).await.ok()?;
        let mut out = String::new();
        while let Some(ev) = stream.next().await {
            match ev {
                BrainEvent::TextDelta(t) => out.push_str(&t),
                BrainEvent::Done(_) => break,
                BrainEvent::Error(_) => return None,
                _ => {}
            }
        }
        let word = out.trim().to_lowercase();
        let word = word.split_whitespace().next().unwrap_or("");
        match word {
            "trivial" => Some(TaskTier::Trivial),
            "small" => Some(TaskTier::Small),
            "medium" => Some(TaskTier::Medium),
            "hard" => Some(TaskTier::Hard),
            "vision" => Some(TaskTier::Vision),
            _ => None,
        }
    }

    fn task_summary(&self, task: &str, tier: &TaskTier) -> String {
        let lower = task.to_lowercase();
        if lower.contains("routing")
            || lower.contains("routeur")
            || lower.contains("modèle")
            || lower.contains("modele")
            || lower.contains("model")
        {
            "question meta sur le routing modele".into()
        } else if lower.contains("code") || lower.contains("bug") || lower.contains("fix") {
            format!("requete code/{:?}", tier).to_lowercase()
        } else if lower.contains("config") || lower.contains("provider") {
            "configuration provider/modele".into()
        } else {
            format!("requete {:?}", tier).to_lowercase()
        }
    }

    fn is_routing_question(&self, task: &str) -> bool {
        let lower = task.to_lowercase();
        (lower.contains("routing") || lower.contains("routeur") || lower.contains("route"))
            && (lower.contains("modèle") || lower.contains("modele") || lower.contains("model"))
            || lower.contains("sélectionne tu le model")
            || lower.contains("selectionne tu le model")
    }

    fn requires_tools(&self, task: &str, tier: &TaskTier) -> bool {
        let lower = task.to_lowercase();
        let tool_keywords = [
            "outil",
            "tools",
            "fichier",
            "file",
            "readme",
            ".rs",
            ".ts",
            ".js",
            ".html",
            ".md",
            "repo",
            "dossier",
            "workspace",
            "git",
            "test",
            "build",
            "cargo",
            "npm",
            "pnpm",
            "corrige",
            "fix",
            "debug",
            "bug",
            "répare",
            "repare",
            "modifie",
            "édite",
            "edite",
            "ajoute",
            "supprime",
            "écris",
            "ecris",
            "write",
            "create",
            "crée",
            "cree",
            "audit",
        ];

        if tool_keywords.iter().any(|kw| lower.contains(kw)) {
            return true;
        }

        matches!(tier, TaskTier::Medium | TaskTier::Hard | TaskTier::Vision)
    }

    fn requires_vision(&self, task: &str, tier: &TaskTier) -> bool {
        let lower = task.to_lowercase();
        matches!(tier, TaskTier::Vision)
            || [
                "image",
                "screenshot",
                "capture",
                "photo",
                "vision",
                "logo",
                "visuel",
                "interface graphique",
            ]
            .iter()
            .any(|kw| lower.contains(kw))
    }

    fn routing_explanation(
        &self,
        tier: &TaskTier,
        need: &crate::router::RoutingNeed,
        chain_ids: &[String],
    ) -> String {
        let chain = summarize_model_chain(chain_ids, 5);
        format!(
            "Je suis Sparrow, donc je ne réponds pas comme un modèle isolé: avant chaque run, mon routeur classe ta demande puis choisit une chaîne de modèles.\n\nPour cette requête, j'ai détecté: tier `{}` · tools `{}` · vision `{}` · local `{}`.\n\nJe sélectionne ensuite le modèle avec ces critères: adéquation aux capacités demandées, support des tools, besoin vision, préférence local/free-first, budget restant, latence, taille de contexte, puis disponibilité provider. Le résultat est une fallback chain, pas un seul choix figé: `{}`.\n\nConcrètement: une question simple ou meta doit aller vers le modèle le moins coûteux capable de répondre; une tâche code complexe monte vers un modèle plus fort; une tâche avec fichiers/tools exige un modèle compatible tools; une tâche image demande vision; si un provider échoue, je bascule au suivant dans la chaîne.",
            tier.as_str(),
            need.required_tools,
            need.required_vision,
            need.prefer_local,
            chain
        )
    }

    /// Summarize a slice of dropped conversation messages into ~200 tokens so
    /// compaction preserves continuity instead of just truncating (§3.7).
    async fn summarize_messages(&self, brain: &dyn Brain, middle: &[Msg]) -> Option<String> {
        if middle.is_empty() {
            return None;
        }
        // Flatten the middle into a compact transcript for the summarizer.
        let mut transcript = String::new();
        for m in middle {
            for block in &m.content {
                match block {
                    ContentBlock::Text { text } => {
                        transcript.push_str(&format!("[{}] {}\n", m.role, text));
                    }
                    ContentBlock::ToolUse { name, .. } => {
                        transcript.push_str(&format!("[{}] (tool: {})\n", m.role, name));
                    }
                    ContentBlock::ToolResult { .. } => {
                        transcript.push_str(&format!("[{}] (tool result)\n", m.role));
                    }
                    _ => {}
                }
            }
        }
        if transcript.len() > 12_000 {
            transcript.truncate(12_000);
        }
        let req = BrainRequest {
            system: Some(
                "Summarize this agent conversation in <=200 tokens. Preserve: files edited, \
                 decisions made, current state, and any unfinished work. Plain text only."
                    .into(),
            ),
            messages: vec![Msg {
                role: "user".into(),
                content: vec![ContentBlock::Text { text: transcript }],
            }],
            tools: vec![],
            max_tokens: 300,
            temperature: 0.0,
            stop: vec![],
            cache: PromptCacheConfig::disabled(),
        };
        let mut stream = brain.complete(req).await.ok()?;
        let mut out = String::new();
        while let Some(ev) = stream.next().await {
            match ev {
                BrainEvent::TextDelta(t) => out.push_str(&t),
                BrainEvent::Done(_) => break,
                BrainEvent::Error(_) => return None,
                _ => {}
            }
        }
        let out = out.trim().to_string();
        if out.is_empty() { None } else { Some(out) }
    }

    /// Estimate what a task will cost BEFORE running it: classified tier,
    /// selected chain, and a token/cost range priced at the primary model.
    /// Everything here is an estimate — surfaces must label it as such.
    pub fn preflight(&self, task_desc: &str) -> Preflight {
        let (tier, _ambiguous) = self.classify_with_confidence(task_desc);
        let need = crate::router::RoutingNeed {
            tier: tier.clone(),
            required_tools: self.requires_tools(task_desc, &tier),
            required_vision: self.requires_vision(task_desc, &tier),
            prefer_local: false,
        };
        let budget = BudgetState {
            daily_limit_usd: self.config.budget.daily_usd,
            daily_spent_usd: 0.0,
            session_limit_usd: self.config.budget.session_usd,
            session_spent_usd: 0.0,
        };
        let chain = self.router.select(&need, &budget);
        // Token envelopes per tier, from observed run shapes (rough by design).
        let (in_lo, in_hi, out_lo, out_hi): (u64, u64, u64, u64) = match tier {
            TaskTier::Trivial => (800, 4_000, 100, 1_000),
            TaskTier::Small => (3_000, 12_000, 500, 3_000),
            TaskTier::Medium => (8_000, 40_000, 2_000, 10_000),
            TaskTier::Hard => (25_000, 120_000, 5_000, 25_000),
            TaskTier::Vision => (8_000, 40_000, 2_000, 8_000),
        };
        let price = chain.first().map(|b| b.caps());
        let cost = |tin: u64, tout: u64| -> f64 {
            price
                .as_ref()
                .map(|c| {
                    tin as f64 * c.cost_input_per_mtok / 1_000_000.0
                        + tout as f64 * c.cost_output_per_mtok / 1_000_000.0
                })
                .unwrap_or(0.0)
        };
        Preflight {
            tier,
            chain: chain.iter().map(|b| b.id().to_string()).collect(),
            est_input_range: (in_lo, in_hi),
            est_output_range: (out_lo, out_hi),
            est_cost_range: (cost(in_lo, out_lo), cost(in_hi, out_hi)),
        }
    }

    /// Drive one AgentRun to completion.
    pub async fn drive(
        &self,
        task: Task,
        event_tx: mpsc::UnboundedSender<Event>,
    ) -> anyhow::Result<OutcomeSummary> {
        self.drive_with_run_id(task, event_tx, RunId::new()).await
    }

    /// Drive with a caller-provided run id.
    pub async fn drive_with_run_id(
        &self,
        task: Task,
        event_tx: mpsc::UnboundedSender<Event>,
        run_id: RunId,
    ) -> anyhow::Result<OutcomeSummary> {
        self.drive_with_inject(task, event_tx, run_id, None).await
    }

    /// Drive with an optional `inject_rx` channel that lets the caller inject
    /// user messages mid-run. Polled non-blocking between turns. (§3.7)
    pub async fn drive_with_inject(
        &self,
        task: Task,
        event_tx: mpsc::UnboundedSender<Event>,
        run_id: RunId,
        mut inject_rx: Option<mpsc::UnboundedReceiver<String>>,
    ) -> anyhow::Result<OutcomeSummary> {
        // Parse and strip optional __model:X__ override prefix injected by the WebView.
        let model_override: Option<String>;
        let clean_description: String;
        if let Some(rest) = task.description.strip_prefix("__model:") {
            if let Some(end) = rest.find("__ ") {
                model_override = Some(rest[..end].to_string());
                clean_description = rest[end + 3..].to_string();
            } else {
                model_override = None;
                clean_description = task.description.clone();
            }
        } else {
            model_override = None;
            clean_description = task.description.clone();
        }
        let task = Task {
            description: clean_description,
            context: task.context,
        };

        let mut messages: Vec<Msg> = task.context.clone();

        // Classify task (heuristic first)
        let (mut tier, ambiguous) = self.classify_with_confidence(&task.description);

        // Route: select brain chain
        let budget = BudgetState {
            daily_limit_usd: self.config.budget.daily_usd,
            daily_spent_usd: 0.0,
            session_limit_usd: self.config.budget.session_usd,
            session_spent_usd: 0.0,
        };

        let mut required_tools = self.requires_tools(&task.description, &tier);
        let mut required_vision = self.requires_vision(&task.description, &tier);
        let mut need = crate::router::RoutingNeed {
            tier: tier.clone(),
            required_tools,
            required_vision,
            prefer_local: false,
        };

        let mut chain = self.router.select(&need, &budget);

        // Apply WebView model override:
        //  1) Keep the brain in the chain if found there.
        //  2) Otherwise, look it up directly via the router — the user explicitly
        //     picked it, so we honour it even if the tier-based selection didn't
        //     include it.
        //  3) This must be re-applied after any chain mutation (e.g. §3.6
        //     refinement) or the auto-router silently overrides the manual pick.
        let router_ref = &self.router;
        let apply_override = |chain: &mut Vec<Arc<dyn Brain>>| {
            if let Some(ref override_id) = model_override {
                let filtered: Vec<_> = chain
                    .iter()
                    .filter(|b| b.id() == override_id.as_str())
                    .cloned()
                    .collect();
                if !filtered.is_empty() {
                    *chain = filtered;
                } else if let Some(brain) = router_ref.find_brain_by_id(override_id) {
                    *chain = vec![brain];
                }
            }
        };
        apply_override(&mut chain);

        // §3.6: model-assisted refinement for genuinely ambiguous tasks. Only the
        // length-based Medium guess qualifies — short tasks stay Trivial without
        // the extra round-trip, keeping the common path fast. Uses the cheapest
        // already-selected brain, bounded to a 6-token call.
        //
        // Skip refinement entirely when the user has pinned a specific model:
        // the whole point of the manual pick is to bypass the router's judgment.
        if model_override.is_none()
            && ambiguous
            && matches!(tier, TaskTier::Medium)
            && !self.is_routing_question(&task.description)
        {
            // Dedup: cache task hash → refined tier so identical tasks skip the LLM call.
            let desc_hash = {
                use std::collections::hash_map::DefaultHasher;
                use std::hash::{Hash, Hasher};
                let mut h = DefaultHasher::new();
                task.description.hash(&mut h);
                h.finish()
            };
            let cached = {
                self.classify_cache
                    .lock()
                    .ok()
                    .and_then(|c| c.get(&desc_hash).cloned())
            };
            let refined = match cached {
                Some(t) => {
                    let _ = event_tx.send(Event::Message {
                        run: run_id.clone(),
                        role: "router".into(),
                        text: format!("classification (cached): {}", t.as_str()),
                    });
                    Some(t)
                }
                None => {
                    if let Some(brain) = chain.first().cloned() {
                        let result = self
                            .classify_via_brain(&task.description, brain.as_ref())
                            .await;
                        if let Some(r) = &result {
                            if let Ok(mut c) = self.classify_cache.lock() {
                                c.insert(desc_hash, r.clone());
                            }
                        }
                        result
                    } else {
                        None
                    }
                }
            };
            if let Some(refined) = refined {
                if std::mem::discriminant(&refined) != std::mem::discriminant(&tier) {
                    let _ = event_tx.send(Event::Message {
                        run: run_id.clone(),
                        role: "router".into(),
                        text: format!(
                            "classification affinée par modèle: {} → {}",
                            tier.as_str(),
                            refined.as_str()
                        ),
                    });
                    tier = refined;
                    required_tools = self.requires_tools(&task.description, &tier);
                    required_vision = self.requires_vision(&task.description, &tier);
                    need = crate::router::RoutingNeed {
                        tier: tier.clone(),
                        required_tools,
                        required_vision,
                        prefer_local: false,
                    };
                    chain = self.router.select(&need, &budget);
                    // Re-apply manual override after the chain mutation.
                    apply_override(&mut chain);
                }
            }
        }

        // ── Per-repo routing memory ────────────────────────────────────────
        // Outcomes are recorded under the CLASSIFIED tier (pre-bump), so the
        // system self-corrects: if bumping makes "small" tasks verify cleanly,
        // small's stats recover and the bump switches itself off again.
        let routing_memory_root =
            std::env::current_dir().unwrap_or_else(|_| std::path::PathBuf::from("."));
        let mut repo_routing =
            crate::router::learned::RepoRoutingMemory::load(&routing_memory_root);
        let classified_tier = tier.clone();
        if let Some(bumped) = repo_routing.suggest_bump(&tier) {
            let _ = event_tx.send(Event::Message {
                run: run_id.clone(),
                role: "router".into(),
                text: format!(
                    "routing memory: {} tasks in this repo mostly needed escalation — starting at {}",
                    tier.as_str(),
                    bumped.as_str()
                ),
            });
            tier = bumped;
            required_tools = self.requires_tools(&task.description, &tier);
            required_vision = self.requires_vision(&task.description, &tier);
            need = crate::router::RoutingNeed {
                tier: tier.clone(),
                required_tools,
                required_vision,
                prefer_local: false,
            };
            chain = self.router.select(&need, &budget);
            apply_override(&mut chain);
        }

        let task_summary = self.task_summary(&task.description, &tier);
        let chain_ids: Vec<String> = chain.iter().map(|b| b.id().to_string()).collect();

        let agent_name = self
            .identity
            .as_ref()
            .map(|identity| identity.name.clone())
            .unwrap_or_else(|| "sparrow".into());
        let _ = event_tx.send(Event::RunStarted {
            run: run_id.clone(),
            task: task.description.clone(),
            agent: agent_name,
        });

        // PreRun lifecycle hook. Allows operators to gate run start (blocking
        // hooks can veto by exiting non-zero), warm caches, etc.
        let pre_run_results = self
            .hooks
            .execute(&HookEvent::PreRun, &task.description)
            .await;
        if let Some(reason) = pre_run_results
            .iter()
            .find(|r| r.veto)
            .and_then(|r| r.veto_reason.clone())
        {
            let _ = event_tx.send(Event::Error {
                run: run_id.clone(),
                message: format!("PreRun hook vetoed run: {}", reason),
            });
            anyhow::bail!("PreRun hook vetoed run: {}", reason);
        }

        let _ = event_tx.send(Event::Message {
            run: run_id.clone(),
            role: "router".into(),
            text: format!(
                "requete: {} · tier: {} · tools: {} · vision: {} · local: {}",
                task_summary,
                tier.as_str(),
                need.required_tools,
                need.required_vision,
                need.prefer_local
            ),
        });

        let _ = event_tx.send(Event::AgentStatus {
            run: run_id.clone(),
            role: "planner".into(),
            status: AgentStatus::Working,
            note: format!("analyzing request · {} candidates", chain.len()),
        });

        let primary_ctx = chain
            .first()
            .map(|b| b.caps().context_window)
            .unwrap_or(128_000);
        let _ = event_tx.send(Event::RouteSelected {
            run: run_id.clone(),
            chain: chain_ids.clone(),
            context_window: primary_ctx,
        });
        let _ = event_tx.send(Event::AgentStatus {
            run: run_id.clone(),
            role: "planner".into(),
            status: AgentStatus::Done,
            note: format!(
                "route set · {} primary",
                chain.first().map(|b| b.id()).unwrap_or("—")
            ),
        });

        if chain.is_empty() {
            let _ = event_tx.send(Event::Error {
                run: run_id.clone(),
                message: "No available models (budget exhausted or no providers configured)".into(),
            });
            return Ok(OutcomeSummary {
                status: "error: no models".into(),
                diffs: vec![],
                cost_usd: 0.0,
                tokens: TokenUsage {
                    input: 0,
                    output: 0,
                },
                cost_comparison: String::new(),
            });
        }

        if self.is_routing_question(&task.description) {
            let text = self.routing_explanation(&tier, &need, &chain_ids);
            let input_tokens =
                estimate_text_tokens(&task.description) + estimate_text_tokens(&task_summary);
            let output_tokens = estimate_text_tokens(&text);
            let _ = event_tx.send(Event::TokenUsageEstimated {
                run: run_id.clone(),
                input: input_tokens,
                output: 0,
                reason: "router meta request estimate".into(),
            });
            let _ = event_tx.send(Event::TokenUsageEstimated {
                run: run_id.clone(),
                input: 0,
                output: output_tokens,
                reason: "router meta response estimate".into(),
            });
            let _ = event_tx.send(Event::ThinkingDelta {
                run: run_id.clone(),
                text: text.clone(),
            });
            let outcome = OutcomeSummary {
                status: "completed".into(),
                diffs: vec![],
                cost_usd: 0.0,
                tokens: TokenUsage {
                    input: input_tokens,
                    output: output_tokens,
                },
                cost_comparison: String::new(),
            };
            let _ = event_tx.send(Event::RunFinished {
                run: run_id.clone(),
                outcome: outcome.clone(),
            });
            return Ok(outcome);
        }

        // Build tools and workspace
        let workspace_root = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
        let sandbox: Arc<dyn Sandbox> = match self.config.defaults.sandbox.as_str() {
            "local-hardened" => Arc::new(crate::sandbox::LocalSandbox::hardened(
                workspace_root.clone(),
            )),
            "docker" => Arc::new(crate::sandbox::backends::DockerSandbox::new(
                workspace_root.clone(),
                "ubuntu:latest",
            )),
            s if s.starts_with("ssh:") => Arc::new(crate::sandbox::backends::SshSandbox::new(
                workspace_root.clone(),
                s.trim_start_matches("ssh:"),
            )),
            "modal" => Arc::new(crate::sandbox::backends::ModalSandbox::new(
                workspace_root.clone(),
            )),
            "daytona" => Arc::new(crate::sandbox::backends::DaytonaSandbox::new(
                workspace_root.clone(),
            )),
            "vercel" => Arc::new(crate::sandbox::backends::VercelSandbox::new(
                workspace_root.clone(),
            )),
            "singularity" => Arc::new(crate::sandbox::backends::SingularitySandbox::new(
                workspace_root.clone(),
            )),
            _ => Arc::new(crate::sandbox::LocalSandbox::new(workspace_root.clone())),
        };

        let mut registry = ToolRegistry::new();
        registry.register(Arc::new(crate::tools::fs::FsRead));
        registry.register(Arc::new(crate::tools::fs::FsList));
        registry.register(Arc::new(crate::tools::fs::FsWrite));
        registry.register(Arc::new(crate::tools::edit::Edit));
        registry.register(Arc::new(crate::tools::edit::MultiEdit));
        registry.register(Arc::new(crate::tools::search_and_web::Search));
        registry.register(Arc::new(crate::tools::search_and_web::WebSearch));
        registry.register(Arc::new(crate::tools::search_and_web::WebFetch));
        registry.register(Arc::new(crate::tools::browser_sandbox::BrowserTool));
        registry.register(Arc::new(crate::tools::browser_sandbox::ComputerTool));
        registry.register(Arc::new(crate::tools::git::Git));
        registry.register(Arc::new(crate::tools::todo::Todo::new()));
        registry.register(Arc::new(crate::tools::exec::Exec::new(sandbox.clone())));
        registry.register(Arc::new(crate::tools::media::ImageGen::new()));
        registry.register(Arc::new(crate::tools::media::Tts::new()));
        registry.register(Arc::new(crate::tools::media::Transcribe::new()));
        registry.register(Arc::new(crate::tools::subagent::PythonRpc::new()));
        registry.register(Arc::new(crate::tools::builder_tools::LspClient));
        registry.register(Arc::new(crate::tools::code_nav::Glob));
        registry.register(Arc::new(crate::tools::code_nav::Symbols));
        if let Some(mem) = &self.memory {
            registry.register(Arc::new(crate::tools::memory::MemoryTool::new(mem.clone())));
            registry.register(Arc::new(
                crate::tools::knowledge_graph::KnowledgeGraphTool::new(mem.clone()),
            ));
        }
        {
            // Subagent delegation: child engine built from the same router/config.
            let mut sub = crate::tools::subagent::SubagentSpawn::new(
                self.router.clone(),
                self.config.clone(),
            );
            if let Some(mem) = &self.memory {
                sub = sub.with_memory(mem.clone());
            }
            registry.register(Arc::new(sub));
        }
        let tools = Arc::new(registry);
        let tool_specs: Vec<ToolSpec> = tools.to_specs();

        let workspace = Workspace {
            root: workspace_root,
            sandbox,
        };

        let identity = self.identity.clone().unwrap_or_else(|| Identity {
            name: "sparrow".into(),
            role: "senior software engineer".into(),
            personality: "concise, competent, direct".into(),
        });

        let brain_policy = BrainPolicy {
            chain,
            current_index: 0,
        };

        let mut autonomy = match self.config.defaults.autonomy {
            AutonomyLevel::Supervised => AutonomyContract::supervised(),
            AutonomyLevel::Trusted => AutonomyContract::trusted(),
            AutonomyLevel::Autonomous => AutonomyContract::autonomous(),
        };
        autonomy.budget.max_usd = self.config.budget.session_usd;
        let _ = event_tx.send(Event::AutonomyChanged {
            run: run_id.clone(),
            level: autonomy.level.clone(),
        });

        // Load relevant skills — top-N pre-selected for full-body inclusion.
        // The main agent soul requires mandatory skill pre-read before ANY action,
        // so we load MORE skills than before (5 instead of 3) and the agent
        // is instructed to scan the full catalog for anything it might need.
        let relevant_skills: Vec<crate::capabilities::Skill> = self
            .skills
            .as_ref()
            .map(|s| s.relevant(&task.description, 5))
            .unwrap_or_default();
        // And the full catalog (names + descriptions only) so the agent
        // discovers everything in the library and can invoke a skill it
        // wasn't pre-fed.
        let skill_catalog: Vec<crate::capabilities::Skill> =
            self.skills.as_ref().map(|s| s.all()).unwrap_or_default();

        let system = build_system_prompt(
            &identity,
            &workspace.root,
            &self
                .memory
                .as_ref()
                .map(|m| m.all_facts())
                .unwrap_or_default(),
            &self
                .memory
                .as_ref()
                .map(|m| {
                    [MemoryDocKind::Memory, MemoryDocKind::User]
                        .into_iter()
                        .filter_map(|kind| m.memory_doc(kind))
                        .collect::<Vec<_>>()
                })
                .unwrap_or_default(),
            &crate::instructions::discover_workspace_instructions(
                &workspace.root,
                &task.description,
            ),
            &relevant_skills,
            &skill_catalog,
        );
        let mut system = format!(
            "{}\n\n## Active Sparrow Routing Context\nRequest category: {}\nTask tier: {}\nRequired tools: {}\nRequired vision: {}\nPreferred local: {}\nSelected fallback chain: {}\nRouting policy: free_first={}, session_budget_usd={:.2}.\nWhen answering routing questions, describe this context concretely.",
            system,
            task_summary,
            tier.as_str(),
            need.required_tools,
            need.required_vision,
            need.prefer_local,
            summarize_model_chain(&chain_ids, 8),
            self.config.routing.free_first,
            self.config.budget.session_usd
        );

        // Continuity hint: when there is prior conversation (task.context), tell
        // the model to treat it as authoritative memory. Weaker models otherwise
        // recite the system identity and ignore what the user said earlier.
        if !messages.is_empty() {
            system.push_str(
                "\n\n## Conversation continuity\nThis is an ONGOING conversation. The messages below are prior turns and are AUTHORITATIVE memory of what the user told you (names, preferences, facts, decisions). Use them directly; never re-introduce yourself or contradict them.",
            );
        }

        // Build initial messages
        messages.push(Msg {
            role: "user".into(),
            content: initial_user_content_blocks(&workspace.root, &task.description),
        });

        let mut total_input: u64 = 0;
        let mut total_output: u64 = 0;
        let mut estimated_input_unconfirmed: u64 = 0;
        let mut estimated_output_unconfirmed: u64 = 0;
        let mut estimated_cost_unconfirmed: f64 = 0.0;
        let mut cost_usd: f64 = 0.0;
        let diffs: Vec<crate::event::FileDiff> = Vec::new();
        let mut current_chain_idx = 0usize;
        let mut tool_results_pending: Vec<(
            String,
            String,
            serde_json::Value,
            Vec<ContentBlock>,
            bool,
        )> = Vec::new();
        let budget_session = self.config.budget.session_usd;
        let _budget_daily = self.config.budget.daily_usd;
        let redaction = &self.redaction;
        let mut had_error = false;
        let mut last_error: Option<String> = None;
        let mut waiting_for_approval = false;
        let mut denied_by_approval = false;
        let mut skill_evidence = String::new();
        // Iteration safety cap: bound the agentic loop independently of budget.
        let mut turns: u32 = 0;
        const MAX_TURNS: u32 = 60;
        // Auto-verify state: track whether mutating edits happened and how many
        // verify attempts we've spent, so we run the verify command after the
        // model says it's done and re-inject failures (bounded).
        let mut had_mutation = false;
        let mut verify_attempts: u32 = 0;
        const MAX_VERIFY_ATTEMPTS: u32 = 2;
        // Verified escalation: when a model exhausts its fix budget, the run
        // climbs to the next model in the chain (bounded) instead of ending
        // silently unverified — cheap-first routing with a guaranteed floor.
        let mut verify_escalations: u32 = 0;
        const MAX_VERIFY_ESCALATIONS: u32 = 2;
        // Whether the run has produced ANY visible output (text or tool use). If
        // a model returns an empty completion and nothing has been produced yet,
        // we fall back to the next model in the chain (rescues a dead provider).
        let mut produced_any_output = false;
        // Transient-failure retry state: a rate limit or timeout on the primary
        // model must NOT permanently downgrade a long run to a weaker fallback.
        // We retry the same brain (bounded, with backoff) before advancing.
        let mut transient_retries: u32 = 0;
        const MAX_TRANSIENT_RETRIES: u32 = 2;
        // Stuck-loop detection: a turn that issues the exact same tool calls as
        // the previous turn is the classic long-task death spiral (re-reading
        // the same file, retrying a failing edit verbatim). Nudge at 3 repeats,
        // stop honestly at 5 — long before the MAX_TURNS budget burns out.
        let mut last_tool_sig: Option<u64> = None;
        let mut repeated_tool_turns: u32 = 0;

        // Helper to send redacted events
        let send = |event: Event| {
            let _ = event_tx.send(redaction.redact_event(&event));
        };

        // Compaction state (Phase 12 auto-trigger). The threshold matches the
        // default ContextManager budget; we keep `keep_last` messages verbatim
        // and replace earlier ones with a distilled summary block. A handoff
        // doc is written to `.sparrow/handoff/<run>-<ts>.md` and an
        // `Event::Compacted` is emitted so UIs can show the pass.
        const COMPACT_TRANSCRIPT_CHARS: usize = 120_000;
        const COMPACT_KEEP_LAST: usize = 6;
        let context_manager = crate::redaction::ContextManager::new(200_000);

        // Main agentic loop
        loop {
            // Auto-compaction check (Phase 12). Skipped on the very first turn
            // so a short task never pays the overhead.
            if turns > 0 {
                let transcript_chars: usize = messages
                    .iter()
                    .map(|m| serde_json::to_string(m).map(|s| s.len()).unwrap_or(0))
                    .sum();
                if transcript_chars > COMPACT_TRANSCRIPT_CHARS && messages.len() > COMPACT_KEEP_LAST
                {
                    // PreCompact lifecycle hook: lets operators dump state /
                    // back up the transcript before compaction discards it.
                    let _ = self
                        .hooks
                        .execute(&HookEvent::PreCompact, &task.description)
                        .await;
                    let before = transcript_chars;
                    let compacted =
                        context_manager.compact_messages(&messages, 0, COMPACT_KEEP_LAST);
                    let after: usize = compacted
                        .iter()
                        .map(|m| serde_json::to_string(m).map(|s| s.len()).unwrap_or(0))
                        .sum();

                    // Write a durable handoff next to the transcript.
                    let mut handoff = crate::context::HandoffDoc::new(task.description.clone());
                    handoff.next_steps = vec![format!(
                        "Resume run {} (turn {}/{})",
                        run_id.0, turns, MAX_TURNS
                    )];
                    let handoff_dir = std::path::PathBuf::from(".sparrow/handoff");
                    let _ = std::fs::create_dir_all(&handoff_dir);
                    let handoff_path = handoff_dir.join(format!(
                        "{}-{}.md",
                        run_id.0,
                        chrono::Utc::now().format("%Y%m%dT%H%M%SZ")
                    ));
                    let _ = std::fs::write(&handoff_path, handoff.to_markdown());

                    messages = compacted;
                    send(Event::Compacted {
                        run: run_id.clone(),
                        before_chars: before,
                        after_chars: after,
                        handoff_path: Some(handoff_path.to_string_lossy().to_string()),
                    });
                    let _ = self
                        .hooks
                        .execute(&HookEvent::PostCompact, &task.description)
                        .await;
                }
            }
            // Iteration cap: stop runaway loops independently of budget.
            turns += 1;
            if turns > MAX_TURNS {
                send(Event::Message {
                    run: run_id.clone(),
                    role: "guard".into(),
                    text: format!("iteration cap reached ({} turns) — stopping", MAX_TURNS),
                });
                break;
            }

            // Budget check: hard stop if exceeded
            if cost_usd + estimated_cost_unconfirmed >= budget_session {
                let msg = format!(
                    "Budget exceeded: ${:.4} of ${:.2} session cap",
                    cost_usd + estimated_cost_unconfirmed,
                    budget_session
                );
                send(Event::Error {
                    run: run_id.clone(),
                    message: msg.clone(),
                });
                // OnBudgetThreshold lifecycle: fired on hard cap. Operators can
                // configure a hook to e.g. page on-call when this triggers.
                let _ = self
                    .hooks
                    .execute(&HookEvent::OnBudgetThreshold, &msg)
                    .await;
                let _ = self.hooks.execute(&HookEvent::OnError, &msg).await;
                had_error = true;
                last_error = Some("budget exceeded".into());
                break;
            }
            if let Some(_approval_handler) = &self.approval_handler {
                if waiting_for_approval {
                    // Route to approval handler (e.g., Telegram inline buttons)
                    // The handler will resolve and we continue
                }
            }

            // ─── Org policy enforcement ──────────────────────────────────
            if let Some(ref policy) = self.org_policy {
                let proposed_file = tool_results_pending
                    .last()
                    .map(|(_, _, args, _, _)| {
                        args.get("path").and_then(|v| v.as_str()).unwrap_or("")
                    })
                    .unwrap_or("");
                if let Err(violation) =
                    policy.enforce(&self.config.defaults.autonomy, cost_usd, proposed_file)
                {
                    send(Event::Error {
                        run: run_id.clone(),
                        message: format!("Org policy violation: {}", violation),
                    });
                    break;
                }
            }

            // ── Mid-run user injection (§3.7) ─────────────────────────────
            // Poll the inject channel non-blocking. Each pending message becomes
            // a new user turn so the next Brain call sees it.
            if let Some(rx) = inject_rx.as_mut() {
                loop {
                    match rx.try_recv() {
                        Ok(injected) => {
                            let trimmed = injected.trim().to_string();
                            if trimmed.is_empty() {
                                continue;
                            }
                            messages.push(Msg {
                                role: "user".into(),
                                content: vec![ContentBlock::Text {
                                    text: format!("INTERRUPT FROM USER: {}", trimmed),
                                }],
                            });
                            let _ = event_tx.send(Event::Message {
                                run: run_id.clone(),
                                role: "interrupt".into(),
                                text: trimmed,
                            });
                        }
                        Err(mpsc::error::TryRecvError::Empty) => break,
                        Err(mpsc::error::TryRecvError::Disconnected) => {
                            inject_rx = None;
                            break;
                        }
                    }
                }
            }

            let brain = match brain_policy.chain.get(current_chain_idx) {
                Some(b) => b.clone(),
                None => break,
            };

            let caps = brain.caps();

            // ── Context compaction (§3.7) ─────────────────────────────────
            // If estimated tokens > 75% of context_window, truncate middle
            // messages to keep the original task + the last 6 exchanges.
            // A summary placeholder is inserted to preserve continuity.
            {
                let req_for_estimate = BrainRequest {
                    system: Some(system.clone()),
                    messages: messages.clone(),
                    tools: if need.required_tools {
                        tool_specs.clone()
                    } else {
                        vec![]
                    },
                    max_tokens: caps.max_output as u32,
                    temperature: 0.0,
                    stop: vec![],
                    cache: PromptCacheConfig::enabled(Some(prompt_cache_key(
                        "engine",
                        &workspace.root,
                        &tool_specs,
                    ))),
                };
                let est = estimate_request_tokens(&req_for_estimate);
                let threshold = (caps.context_window as f64 * 0.75) as u64;
                if est > threshold && messages.len() > 8 {
                    let original_task = messages.first().cloned();
                    let keep_tail: Vec<Msg> =
                        messages.iter().rev().take(6).cloned().collect::<Vec<_>>();
                    let middle: Vec<Msg> = messages
                        .iter()
                        .skip(1)
                        .take(messages.len().saturating_sub(7))
                        .cloned()
                        .collect();
                    let dropped = middle.len();

                    // Ask the current brain for a real summary of the dropped middle
                    // (best-effort; fall back to a plain marker on failure).
                    let summary = self
                        .summarize_messages(brain.as_ref(), &middle)
                        .await
                        .unwrap_or_else(|| {
                            format!(
                                "{} prior messages were dropped to fit the model window.",
                                dropped
                            )
                        });

                    let mut compacted: Vec<Msg> = Vec::new();
                    if let Some(task) = original_task {
                        compacted.push(task);
                    }
                    compacted.push(Msg {
                        role: "user".into(),
                        content: vec![ContentBlock::Text {
                            text: format!(
                                "[CONTEXT SUMMARY of {} earlier messages]\n{}\n\
                                 (Files edited and tool outputs in the turns below remain authoritative.)",
                                dropped, summary
                            ),
                        }],
                    });
                    for m in keep_tail.into_iter().rev() {
                        compacted.push(m);
                    }
                    messages = compacted;
                    let _ = event_tx.send(Event::Message {
                        run: run_id.clone(),
                        role: "compaction".into(),
                        text: format!(
                            "context compacted: {} messages summarized ({} tok > {} threshold)",
                            dropped, est, threshold
                        ),
                    });
                }
            }

            let req = BrainRequest {
                system: Some(system.clone()),
                messages: messages.clone(),
                tools: if need.required_tools {
                    tool_specs.clone()
                } else {
                    vec![]
                },
                max_tokens: caps.max_output as u32,
                temperature: 0.0,
                stop: vec![],
                cache: PromptCacheConfig::enabled(Some(prompt_cache_key(
                    "engine",
                    &workspace.root,
                    &tool_specs,
                ))),
            };

            let estimated_input = estimate_request_tokens(&req);
            estimated_input_unconfirmed += estimated_input;
            estimated_cost_unconfirmed +=
                caps.cost_input_per_mtok * (estimated_input as f64) / 1_000_000.0;
            let _ = event_tx.send(Event::TokenUsageEstimated {
                run: run_id.clone(),
                input: estimated_input,
                output: 0,
                reason: "prompt estimate before provider usage".into(),
            });
            let _ = event_tx.send(Event::CostUpdate {
                run: run_id.clone(),
                usd: cost_usd + estimated_cost_unconfirmed,
            });

            let _ = event_tx.send(Event::AgentStatus {
                run: run_id.clone(),
                role: "coder".into(),
                status: AgentStatus::Thinking,
                note: format!("consulting {} · parsing request…", brain.id()),
            });

            match brain.complete(req).await {
                Ok(mut stream) => {
                    // The provider answered — clear the transient-failure budget.
                    transient_retries = 0;
                    let mut current_tool_name = String::new();
                    let mut current_tool_json = String::new();
                    let mut output_chars_seen: u64 = 0;
                    let mut output_tokens_emitted: u64 = 0;
                    let mut continue_agent_loop = false;
                    let mut stop_after_tool_result = false;
                    let mut assistant_text = String::new();
                    let mut tool_output_seen_this_completion = false;
                    // Tools invoked during this completion — fed to the hallucination
                    // guard so it knows whether the assistant has actually inspected
                    // any code/state before making a claim.
                    let mut tools_called_this_turn: Vec<String> = Vec::new();
                    // Accumulated reasoning_content (DeepSeek / Moonshot / Qwen
                    // thinking mode). Must be echoed back on the next turn or the
                    // provider returns 400.
                    let mut reasoning_buf: String = String::new();

                    while let Some(event) = stream.next().await {
                        match event {
                            BrainEvent::TextDelta(text) => {
                                assistant_text.push_str(&text);
                                output_chars_seen += text.chars().count() as u64;
                                let estimated_output = (output_chars_seen + 3) / 4;
                                let output_delta =
                                    estimated_output.saturating_sub(output_tokens_emitted);
                                if output_delta > 0 {
                                    output_tokens_emitted += output_delta;
                                    estimated_output_unconfirmed += output_delta;
                                    estimated_cost_unconfirmed += caps.cost_output_per_mtok
                                        * (output_delta as f64)
                                        / 1_000_000.0;
                                    let _ = event_tx.send(Event::TokenUsageEstimated {
                                        run: run_id.clone(),
                                        input: 0,
                                        output: output_delta,
                                        reason: "streamed output estimate".into(),
                                    });
                                    let _ = event_tx.send(Event::CostUpdate {
                                        run: run_id.clone(),
                                        usd: cost_usd + estimated_cost_unconfirmed,
                                    });
                                }
                                let _ = event_tx.send(Event::ThinkingDelta {
                                    run: run_id.clone(),
                                    text: text.clone(),
                                });
                            }
                            BrainEvent::ReasoningDelta(rtext) => {
                                // Accumulate for the assistant message we'll push at
                                // end-of-turn. We don't surface it as text on screen —
                                // the engine's normal TextDelta path handles visible
                                // text, this is opaque thinking content the provider
                                // wants echoed back.
                                reasoning_buf.push_str(&rtext);
                                let _ = event_tx.send(Event::ReasoningDelta {
                                    run: run_id.clone(),
                                    text: rtext,
                                });
                            }
                            BrainEvent::ToolUseStart { id, name } => {
                                current_tool_name = name.clone();
                                tools_called_this_turn.push(name.clone());
                                current_tool_json.clear();
                                let risk = tools
                                    .get(&name)
                                    .map(|tool| tool.risk())
                                    .unwrap_or(RiskLevel::ReadOnly);
                                // Placeholder ToolUseProposed with empty args so the
                                // UI can open the card immediately. Real args follow
                                // at ToolUseEnd (see below) once the streamed JSON
                                // is complete.
                                let _ = event_tx.send(Event::ToolUseProposed {
                                    run: run_id.clone(),
                                    id: id.clone(),
                                    name: name.clone(),
                                    args: json!({}),
                                    risk,
                                });
                            }
                            BrainEvent::ToolUseDelta { id, json } => {
                                let _ = id;
                                current_tool_json.push_str(&json);
                            }
                            BrainEvent::ToolUseEnd { id } => {
                                // Parse accumulated JSON
                                let args: serde_json::Value =
                                    serde_json::from_str(&current_tool_json).unwrap_or(json!({}));

                                // Check autonomy gate
                                let tool_name = if current_tool_name.is_empty() {
                                    "unknown".to_string()
                                } else {
                                    current_tool_name.clone()
                                };
                                let tool = tools.get(&tool_name);
                                let risk = tool
                                    .as_ref()
                                    .map(|tool| tool.risk())
                                    .unwrap_or(RiskLevel::ReadOnly);

                                // Re-emit ToolUseProposed with the REAL args now
                                // that the streamed JSON is complete. The first
                                // emission at ToolUseStart used `{}` because the
                                // arguments hadn't streamed yet — the UI updates
                                // the existing card with these real arguments.
                                let _ = event_tx.send(Event::ToolUseProposed {
                                    run: run_id.clone(),
                                    id: id.clone(),
                                    name: tool_name.clone(),
                                    args: args.clone(),
                                    risk: risk.clone(),
                                });
                                let proposed = crate::autonomy::ProposedAction {
                                    tool_name: tool_name.clone(),
                                    risk: risk.clone(),
                                    args: args.clone(),
                                };

                                let permission =
                                    self.config.permissions.evaluate(&PermissionContext {
                                        tool_name: &proposed.tool_name,
                                        risk: proposed.risk.clone(),
                                        args: &args,
                                        workspace_root: &workspace.root,
                                        provider: Some(brain.id()),
                                        surface: Some("engine"),
                                    });
                                let autonomy_verdict =
                                    if matches!(permission.decision, Decision::Allow) {
                                        Some(autonomy.evaluate(&proposed))
                                    } else {
                                        None
                                    };
                                let mut decision = autonomy_verdict
                                    .as_ref()
                                    .map(|verdict| verdict.decision.clone())
                                    .unwrap_or_else(|| permission.decision.clone());
                                if !matches!(permission.decision, Decision::Allow) {
                                    let _ = event_tx.send(Event::Message {
                                        run: run_id.clone(),
                                        role: "permissions".into(),
                                        text: permission.reason.clone(),
                                    });
                                }
                                if matches!(decision, Decision::AskUser) {
                                    let summary = format!(
                                        "{}. Approve {} with args: {}",
                                        permission.reason, proposed.tool_name, args
                                    );
                                    let _ = event_tx.send(Event::ApprovalRequested {
                                        run: run_id.clone(),
                                        id: id.clone(),
                                        summary: summary.clone(),
                                        tool: Some(proposed.tool_name.clone()),
                                        risk: Some(format!("{:?}", proposed.risk)),
                                    });
                                    // OnApprovalRequested hook so external
                                    // notifiers (Slack, email, …) can ping the
                                    // operator.
                                    let _ = self
                                        .hooks
                                        .execute(&HookEvent::OnApprovalRequested, &summary)
                                        .await;
                                    if let Some(handler) = &self.approval_handler {
                                        decision = handler
                                            .request_approval(ApprovalRequest {
                                                run: run_id.clone(),
                                                id: id.clone(),
                                                tool_name: proposed.tool_name.clone(),
                                                risk: proposed.risk.clone(),
                                                args: args.clone(),
                                                summary,
                                            })
                                            .await;
                                    }
                                }

                                let _ = event_tx.send(Event::ApprovalResolved {
                                    run: run_id.clone(),
                                    id: id.clone(),
                                    decision: decision.clone(),
                                });

                                match decision {
                                    Decision::Allow => {
                                        if autonomy_verdict
                                            .as_ref()
                                            .map(|verdict| verdict.notify)
                                            .unwrap_or(false)
                                        {
                                            let _ = event_tx.send(Event::Message {
                                                run: run_id.clone(),
                                                role: "autonomy".into(),
                                                text: format!(
                                                    "{} will run under trusted autonomy with checkpoint notification",
                                                    proposed.tool_name
                                                ),
                                            });
                                        }
                                        // Track mutations so we can auto-verify later.
                                        if matches!(
                                            proposed.risk,
                                            RiskLevel::Mutating | RiskLevel::Destructive
                                        ) {
                                            had_mutation = true;
                                        }
                                        // Auto-checkpoint before mutating/exec/destructive
                                        let needs_checkpoint = autonomy_verdict
                                            .as_ref()
                                            .map(|verdict| verdict.needs_checkpoint)
                                            .unwrap_or_else(|| {
                                                matches!(
                                                    proposed.risk,
                                                    RiskLevel::Mutating
                                                        | RiskLevel::Exec
                                                        | RiskLevel::Destructive
                                                )
                                            });
                                        if needs_checkpoint {
                                            let vetoes = self
                                                .hooks
                                                .execute(
                                                    &HookEvent::PreCheckpoint,
                                                    &proposed.tool_name,
                                                )
                                                .await;
                                            let checkpoint_veto = vetoes
                                                .iter()
                                                .find(|result| result.veto)
                                                .and_then(|result| result.veto_reason.clone());
                                            if let Some(reason) = checkpoint_veto {
                                                let _ = event_tx.send(Event::Error {
                                                    run: run_id.clone(),
                                                    message: reason,
                                                });
                                                denied_by_approval = true;
                                                stop_after_tool_result = true;
                                                continue;
                                            }
                                            let checkpoints =
                                                GitCheckpoints::new(workspace.root.clone());
                                            if let Ok(cp_id) = checkpoints
                                                .snapshot(&format!("pre-{}", proposed.tool_name))
                                            {
                                                let _ = event_tx.send(Event::CheckpointCreated {
                                                    run: run_id.clone(),
                                                    id: cp_id,
                                                    label: format!("pre-{}", proposed.tool_name),
                                                });
                                                let _ = self
                                                    .hooks
                                                    .execute(
                                                        &HookEvent::PostCheckpoint,
                                                        &proposed.tool_name,
                                                    )
                                                    .await;
                                            }
                                        }

                                        // Pass tool name + args to the hook
                                        // matcher so PreToolUse hooks can
                                        // inspect the actual payload (e.g.
                                        // protect-sensitive-files needs the
                                        // file path, not just "fs_write").
                                        let hook_ctx = format!("{} {}", proposed.tool_name, args);
                                        let hook_results = self
                                            .hooks
                                            .execute(&HookEvent::PreToolUse, &hook_ctx)
                                            .await;
                                        if let Some(reason) = hook_results
                                            .iter()
                                            .find(|result| result.veto)
                                            .and_then(|result| result.veto_reason.clone())
                                        {
                                            denied_by_approval = true;
                                            stop_after_tool_result = true;
                                            let _ = event_tx.send(Event::ToolOutput {
                                                run: run_id.clone(),
                                                id: id.clone(),
                                                blocks: vec![Block::Text(reason.clone())],
                                            });
                                            tool_output_seen_this_completion = true;
                                            tool_results_pending.push((
                                                id.clone(),
                                                proposed.tool_name.clone(),
                                                args.clone(),
                                                vec![ContentBlock::Text { text: reason }],
                                                true,
                                            ));
                                            continue;
                                        }

                                        let _ = event_tx.send(Event::ToolUseStarted {
                                            run: run_id.clone(),
                                            id: id.clone(),
                                        });
                                        let _ = event_tx.send(Event::AgentStatus {
                                            run: run_id.clone(),
                                            role: "coder".into(),
                                            status: AgentStatus::Working,
                                            note: format!("running tool · {}", current_tool_name),
                                        });

                                        let result = if let Some(tool) = tool {
                                            let ctx = ToolCtx {
                                                workspace_root: workspace.root.clone(),
                                                run_id: run_id.clone(),
                                            };
                                            match tool.call(args.clone(), &ctx).await {
                                                Ok(result) => result,
                                                Err(e) => crate::tools::ToolResult::error(format!(
                                                    "Tool {} failed: {}",
                                                    proposed.tool_name, e
                                                )),
                                            }
                                        } else {
                                            crate::tools::ToolResult::error(format!(
                                                "Unknown tool: {}",
                                                proposed.tool_name
                                            ))
                                        };

                                        for block in &result.content {
                                            if let Block::Diff { file, patch } = block {
                                                let plus = patch
                                                    .lines()
                                                    .filter(|l| {
                                                        l.starts_with('+') && !l.starts_with("+++")
                                                    })
                                                    .count()
                                                    as u32;
                                                let minus = patch
                                                    .lines()
                                                    .filter(|l| {
                                                        l.starts_with('-') && !l.starts_with("---")
                                                    })
                                                    .count()
                                                    as u32;
                                                let _ = event_tx.send(Event::DiffProposed {
                                                    run: run_id.clone(),
                                                    file: file.clone(),
                                                    patch: patch.clone(),
                                                    plus,
                                                    minus,
                                                });
                                            }
                                        }

                                        let blocks = result.content.clone();
                                        let text = tool_result_text(&blocks);
                                        let content_blocks = tool_result_content_blocks(&blocks);
                                        let is_error = result.is_error;
                                        skill_evidence.push_str(&text);
                                        skill_evidence.push('\n');
                                        let _ = event_tx.send(Event::ToolOutput {
                                            run: run_id.clone(),
                                            id: id.clone(),
                                            blocks,
                                        });
                                        // Surface writes as DiffApplied so the artifacts
                                        // ledger sees files that fs_write/edit/multi_edit
                                        // touched even when the tool returned plain text.
                                        if !is_error
                                            && matches!(
                                                proposed.tool_name.as_str(),
                                                "fs_write" | "edit" | "multi_edit"
                                            )
                                        {
                                            if let Some(p) =
                                                args.get("path").and_then(|v| v.as_str())
                                            {
                                                let _ = event_tx.send(Event::DiffApplied {
                                                    run: run_id.clone(),
                                                    file: p.to_string(),
                                                });
                                            } else if let Some(p) =
                                                args.get("file_path").and_then(|v| v.as_str())
                                            {
                                                let _ = event_tx.send(Event::DiffApplied {
                                                    run: run_id.clone(),
                                                    file: p.to_string(),
                                                });
                                            }
                                        }
                                        let _ = self
                                            .hooks
                                            .execute(&HookEvent::PostToolUse, &proposed.tool_name)
                                            .await;
                                        tool_output_seen_this_completion = true;
                                        tool_results_pending.push((
                                            id.clone(),
                                            proposed.tool_name.clone(),
                                            args.clone(),
                                            content_blocks,
                                            is_error,
                                        ));
                                    }
                                    Decision::AskUser => {
                                        // Supervised mode: prompt user on stdin
                                        waiting_for_approval = true;
                                        let approval_id = id.clone();
                                        let approval_name = proposed.tool_name.clone();
                                        let approval_args = args.clone();
                                        let approval_risk = proposed.risk;

                                        // Emit approval requested
                                        let _ = event_tx.send(Event::ApprovalRequested {
                                            run: run_id.clone(),
                                            id: approval_id.clone(),
                                            summary: format!(
                                                "{} tool '{}' with args: {}",
                                                format!("{:?}", approval_risk),
                                                approval_name,
                                                approval_args
                                            ),
                                            tool: Some(approval_name.clone()),
                                            risk: Some(format!("{:?}", approval_risk)),
                                        });

                                        // Wait for user input on stdin
                                        use std::io::{self, Write};
                                        print!(
                                            "\n\x1b[1;33mApprove {}? [y/N]\x1b[0m ",
                                            approval_name
                                        );
                                        io::stdout().flush().ok();
                                        let mut input = String::new();
                                        io::stdin().read_line(&mut input).ok();
                                        let approved = input.trim().to_lowercase() == "y";

                                        if approved {
                                            waiting_for_approval = false;
                                            // Auto-checkpoint before mutating/exec/destructive
                                            if matches!(
                                                approval_risk,
                                                RiskLevel::Mutating
                                                    | RiskLevel::Exec
                                                    | RiskLevel::Destructive
                                            ) {
                                                let vetoes = self
                                                    .hooks
                                                    .execute(
                                                        &HookEvent::PreCheckpoint,
                                                        &approval_name,
                                                    )
                                                    .await;
                                                if let Some(reason) = vetoes
                                                    .iter()
                                                    .find(|result| result.veto)
                                                    .and_then(|result| result.veto_reason.clone())
                                                {
                                                    let _ = event_tx.send(Event::Error {
                                                        run: run_id.clone(),
                                                        message: reason,
                                                    });
                                                    denied_by_approval = true;
                                                    stop_after_tool_result = true;
                                                    continue;
                                                }
                                                let checkpoints =
                                                    GitCheckpoints::new(workspace.root.clone());
                                                if let Ok(cp_id) = checkpoints
                                                    .snapshot(&format!("pre-{}", approval_name))
                                                {
                                                    let _ =
                                                        event_tx.send(Event::CheckpointCreated {
                                                            run: run_id.clone(),
                                                            id: cp_id,
                                                            label: format!("pre-{}", approval_name),
                                                        });
                                                    let _ = self
                                                        .hooks
                                                        .execute(
                                                            &HookEvent::PostCheckpoint,
                                                            &approval_name,
                                                        )
                                                        .await;
                                                }
                                            }
                                            let hook_results = self
                                                .hooks
                                                .execute(&HookEvent::PreToolUse, &approval_name)
                                                .await;
                                            if let Some(reason) = hook_results
                                                .iter()
                                                .find(|result| result.veto)
                                                .and_then(|result| result.veto_reason.clone())
                                            {
                                                denied_by_approval = true;
                                                stop_after_tool_result = true;
                                                let _ = event_tx.send(Event::ToolOutput {
                                                    run: run_id.clone(),
                                                    id: approval_id.clone(),
                                                    blocks: vec![Block::Text(reason.clone())],
                                                });
                                                tool_output_seen_this_completion = true;
                                                tool_results_pending.push((
                                                    approval_id,
                                                    approval_name,
                                                    approval_args,
                                                    vec![ContentBlock::Text { text: reason }],
                                                    true,
                                                ));
                                                continue;
                                            }
                                            let _ = event_tx.send(Event::ToolUseStarted {
                                                run: run_id.clone(),
                                                id: approval_id.clone(),
                                            });
                                            let result = if let Some(tool) = tool {
                                                let ctx = ToolCtx {
                                                    workspace_root: workspace.root.clone(),
                                                    run_id: run_id.clone(),
                                                };
                                                match tool.call(approval_args.clone(), &ctx).await {
                                                    Ok(r) => r,
                                                    Err(e) => {
                                                        crate::tools::ToolResult::error(format!(
                                                            "Tool {} failed: {}",
                                                            approval_name, e
                                                        ))
                                                    }
                                                }
                                            } else {
                                                crate::tools::ToolResult::error(format!(
                                                    "Unknown tool: {}",
                                                    approval_name
                                                ))
                                            };
                                            let blocks = result.content.clone();
                                            let text = tool_result_text(&blocks);
                                            let content_blocks =
                                                tool_result_content_blocks(&blocks);
                                            let is_error = result.is_error;
                                            skill_evidence.push_str(&text);
                                            skill_evidence.push('\n');
                                            let _ = event_tx.send(Event::ToolOutput {
                                                run: run_id.clone(),
                                                id: approval_id.clone(),
                                                blocks,
                                            });
                                            let _ = self
                                                .hooks
                                                .execute(&HookEvent::PostToolUse, &approval_name)
                                                .await;
                                            tool_output_seen_this_completion = true;
                                            tool_results_pending.push((
                                                approval_id,
                                                approval_name,
                                                approval_args,
                                                content_blocks,
                                                is_error,
                                            ));
                                        } else {
                                            let _ = event_tx.send(Event::ToolOutput {
                                                run: run_id.clone(),
                                                id: approval_id.clone(),
                                                blocks: vec![Block::Text("Denied by user".into())],
                                            });
                                            tool_output_seen_this_completion = true;
                                            tool_results_pending.push((
                                                approval_id,
                                                approval_name,
                                                approval_args,
                                                vec![ContentBlock::Text {
                                                    text: "Denied by user".into(),
                                                }],
                                                true,
                                            ));
                                        }
                                    }
                                    Decision::Deny => {
                                        denied_by_approval = true;
                                        stop_after_tool_result = true;
                                        let _ = event_tx.send(Event::ToolOutput {
                                            run: run_id.clone(),
                                            id: id.clone(),
                                            blocks: vec![Block::Text(
                                                "Denied by autonomy policy".into(),
                                            )],
                                        });
                                        tool_output_seen_this_completion = true;
                                        tool_results_pending.push((
                                            id.clone(),
                                            proposed.tool_name.clone(),
                                            args.clone(),
                                            vec![ContentBlock::Text {
                                                text: "Denied by autonomy policy".into(),
                                            }],
                                            true,
                                        ));
                                    }
                                    // The Allow* tiered decisions came in
                                    // with the persistent-permissions
                                    // feature; treat them like Allow at the
                                    // engine level (the autonomy/permission
                                    // store handles persistence above).
                                    Decision::AllowOnce
                                    | Decision::AllowSession
                                    | Decision::AllowAlways => {}
                                }

                                current_tool_json.clear();
                                current_tool_name.clear();
                            }
                            BrainEvent::Usage(usage) => {
                                total_input += usage.input;
                                total_output += usage.output;
                                estimated_input_unconfirmed =
                                    estimated_input_unconfirmed.saturating_sub(usage.input);
                                estimated_output_unconfirmed =
                                    estimated_output_unconfirmed.saturating_sub(usage.output);
                                let _ = event_tx.send(Event::TokenUsage {
                                    run: run_id.clone(),
                                    input: usage.input,
                                    output: usage.output,
                                });

                                // Calculate cost
                                let input_cost =
                                    caps.cost_input_per_mtok * (usage.input as f64) / 1_000_000.0;
                                let output_cost =
                                    caps.cost_output_per_mtok * (usage.output as f64) / 1_000_000.0;
                                let actual_cost = input_cost + output_cost;
                                cost_usd += actual_cost;
                                estimated_cost_unconfirmed =
                                    (estimated_cost_unconfirmed - actual_cost).max(0.0);

                                let _ = event_tx.send(Event::CostUpdate {
                                    run: run_id.clone(),
                                    usd: cost_usd + estimated_cost_unconfirmed,
                                });
                            }
                            BrainEvent::Done(reason) => {
                                match reason {
                                    crate::event::StopReason::EndTurn => {
                                        // Empty-completion fallback: if this model
                                        // produced nothing (no text, no tool) and the
                                        // run has produced nothing so far, try the
                                        // next model instead of finishing empty.
                                        let this_empty = assistant_text.trim().is_empty()
                                            && !tool_output_seen_this_completion;
                                        if this_empty && !produced_any_output {
                                            let next_idx = current_chain_idx + 1;
                                            if next_idx < brain_policy.chain.len() {
                                                current_chain_idx = next_idx;
                                                let _ = event_tx.send(Event::ModelSwitched {
                                                    run: run_id.clone(),
                                                    from: brain.id().to_string(),
                                                    to: brain_policy.chain[current_chain_idx]
                                                        .id()
                                                        .to_string(),
                                                    reason: "empty response".into(),
                                                });
                                                continue_agent_loop = true;
                                                break;
                                            }
                                        }
                                        if !assistant_text.trim().is_empty() {
                                            produced_any_output = true;
                                            let mut blocks = Vec::new();
                                            if !reasoning_buf.is_empty() {
                                                blocks.push(ContentBlock::Reasoning {
                                                    text: reasoning_buf.clone(),
                                                });
                                            }
                                            blocks.push(ContentBlock::Text {
                                                text: assistant_text.clone(),
                                            });
                                            let assistant_msg = Msg {
                                                role: "assistant".into(),
                                                content: blocks,
                                            };
                                            let turn_messages = vec![assistant_msg.clone()];
                                            let has_verified_tool_context =
                                                tool_output_seen_this_completion
                                                    || messages.iter().any(|m| {
                                                        m.content.iter().any(|block| {
                                                            matches!(
                                                                block,
                                                                ContentBlock::ToolResult { .. }
                                                            )
                                                        })
                                                    });

                                            if let Some(correction) = self.reasoning.guard_turn(
                                                &turn_messages,
                                                has_verified_tool_context,
                                            ) {
                                                messages.push(assistant_msg);
                                                let _ = event_tx.send(Event::Message {
                                                    run: run_id.clone(),
                                                    role: "guard".into(),
                                                    text: correction.clone(),
                                                });
                                                messages.push(Msg {
                                                    role: "user".into(),
                                                    content: vec![ContentBlock::Text {
                                                        text: format!("SYSTEM: {}. Execute the relevant tool first, then report the actual raw result.", correction),
                                                    }],
                                                });
                                                continue_agent_loop = true;
                                                break;
                                            }

                                            // Hallucination guard: catch claims about
                                            // code structure made without first calling
                                            // fs_read / search this turn.
                                            if self.reasoning.hallucination_guard {
                                                if let Some(correction) =
                                                    crate::reasoning::HallucinationGuard::verify(
                                                        &assistant_text,
                                                        &tools_called_this_turn,
                                                    )
                                                {
                                                    let mut blocks2 = Vec::new();
                                                    if !reasoning_buf.is_empty() {
                                                        blocks2.push(ContentBlock::Reasoning {
                                                            text: reasoning_buf.clone(),
                                                        });
                                                    }
                                                    blocks2.push(ContentBlock::Text {
                                                        text: assistant_text.clone(),
                                                    });
                                                    let assistant_msg2 = Msg {
                                                        role: "assistant".into(),
                                                        content: blocks2,
                                                    };
                                                    messages.push(assistant_msg2);
                                                    let _ = event_tx.send(Event::Message {
                                                        run: run_id.clone(),
                                                        role: "guard".into(),
                                                        text: correction.clone(),
                                                    });
                                                    messages.push(Msg {
                                                        role: "user".into(),
                                                        content: vec![ContentBlock::Text {
                                                            text: format!(
                                                                "SYSTEM: {}. Call fs_read or search to verify the file/symbol first, then re-state the claim with the raw evidence.",
                                                                correction
                                                            ),
                                                        }],
                                                    });
                                                    continue_agent_loop = true;
                                                    break;
                                                }
                                            }

                                            // Tool narration guard: detect when the
                                            // assistant describes using a tool instead
                                            // of actually calling it. Only triggers when
                                            // no tools were called this turn but the text
                                            // contains tool-like language.
                                            if tools_called_this_turn.is_empty()
                                                && tool_narration_detected(&assistant_text)
                                            {
                                                let correction = "You described using a tool but did not actually call it. When a tool would help, CALL it — never narrate what it would do. Use the exact tool call format.";
                                                messages.push(Msg {
                                                    role: "assistant".into(),
                                                    content: vec![ContentBlock::Text {
                                                        text: assistant_text.clone(),
                                                    }],
                                                });
                                                let _ = event_tx.send(Event::Message {
                                                    run: run_id.clone(),
                                                    role: "guard".into(),
                                                    text: correction.into(),
                                                });
                                                messages.push(Msg {
                                                    role: "user".into(),
                                                    content: vec![ContentBlock::Text {
                                                        text: format!(
                                                            "SYSTEM: {}. Execute the relevant tool first, then report the actual raw result.",
                                                            correction
                                                        ),
                                                    }],
                                                });
                                                continue_agent_loop = true;
                                                break;
                                            }
                                            messages.push(assistant_msg);
                                        }

                                        // ── Pre-mutation self-critique (reasoning §) ─
                                        // If we mutated files this turn, emit a
                                        // structured self-review of the change set
                                        // so the operator/UI can see the agent's
                                        // own checklist before auto-verify runs.
                                        if had_mutation
                                            && self.reasoning.self_critique
                                            && !diffs.is_empty()
                                        {
                                            let review =
                                                crate::reasoning::SelfCritique::pre_mutation_review(
                                                    &diffs,
                                                    Some(&task.description),
                                                );
                                            let _ = event_tx.send(Event::Message {
                                                run: run_id.clone(),
                                                role: "self-critique".into(),
                                                text: review,
                                            });
                                        }

                                        // ── Auto-verify (§10 testing) ───────────
                                        // The model thinks it's done. If it mutated
                                        // files and a verify command is configured,
                                        // run it; on failure, re-inject so the agent
                                        // fixes it (bounded). When this model's fix
                                        // budget is exhausted, ESCALATE to the next
                                        // (stronger) model in the chain rather than
                                        // ending the run silently unverified — that
                                        // is the whole point of routing cheap-first.
                                        if had_mutation {
                                            if let Some(verify_cmd) =
                                                self.config.defaults.verify_command.clone()
                                            {
                                                verify_attempts += 1;
                                                had_mutation = false;
                                                let parts: Vec<String> = verify_cmd
                                                    .split_whitespace()
                                                    .map(String::from)
                                                    .collect();
                                                if !parts.is_empty() {
                                                    let _ = event_tx.send(Event::AgentStatus {
                                                        run: run_id.clone(),
                                                        role: "verifier".into(),
                                                        status: AgentStatus::Working,
                                                        note: format!("running `{}`", verify_cmd),
                                                    });
                                                    let cmd = crate::sandbox::Command {
                                                        program: parts[0].clone(),
                                                        args: parts[1..].to_vec(),
                                                        env: std::collections::HashMap::new(),
                                                        workdir: workspace.root.clone(),
                                                    };
                                                    let limits = crate::sandbox::Limits {
                                                        timeout_ms: 300_000,
                                                        max_output_bytes: 16_000,
                                                    };
                                                    match workspace
                                                        .sandbox
                                                        .exec(&cmd, &limits)
                                                        .await
                                                    {
                                                        Ok(res) if res.exit_code != 0 => {
                                                            let _ = event_tx.send(Event::TestResult {
                                                                run: run_id.clone(),
                                                                passed: 0,
                                                                failed: 1,
                                                                detail: format!(
                                                                    "verify `{}` failed (exit {})",
                                                                    verify_cmd, res.exit_code
                                                                ),
                                                            });
                                                            let out = format!(
                                                                "{}\n{}",
                                                                res.stdout, res.stderr
                                                            );
                                                            let tail: String = out
                                                                .lines()
                                                                .rev()
                                                                .take(40)
                                                                .collect::<Vec<_>>()
                                                                .into_iter()
                                                                .rev()
                                                                .collect::<Vec<_>>()
                                                                .join("\n");
                                                            if verify_attempts
                                                                <= MAX_VERIFY_ATTEMPTS
                                                            {
                                                                // Same model gets a bounded
                                                                // chance to fix its own work.
                                                                messages.push(Msg {
                                                                    role: "user".into(),
                                                                    content: vec![ContentBlock::Text {
                                                                        text: format!(
                                                                            "SYSTEM: verification command `{}` FAILED (exit {}). Fix the code, then it will be re-verified. Output:\n{}",
                                                                            verify_cmd, res.exit_code, tail
                                                                        ),
                                                                    }],
                                                                });
                                                                continue_agent_loop = true;
                                                                break;
                                                            }
                                                            // Fix budget exhausted — escalate
                                                            // to the next model in the chain.
                                                            let next_idx = current_chain_idx + 1;
                                                            if next_idx < brain_policy.chain.len()
                                                                && verify_escalations
                                                                    < MAX_VERIFY_ESCALATIONS
                                                            {
                                                                verify_escalations += 1;
                                                                verify_attempts = 0;
                                                                let from = brain.id().to_string();
                                                                let to = brain_policy.chain
                                                                    [next_idx]
                                                                    .id()
                                                                    .to_string();
                                                                current_chain_idx = next_idx;
                                                                let _ = event_tx.send(
                                                                    Event::ModelSwitched {
                                                                        run: run_id.clone(),
                                                                        from,
                                                                        to,
                                                                        reason: format!(
                                                                            "verification still failing after {} fixes — escalating",
                                                                            MAX_VERIFY_ATTEMPTS
                                                                        ),
                                                                    },
                                                                );
                                                                messages.push(Msg {
                                                                    role: "user".into(),
                                                                    content: vec![ContentBlock::Text {
                                                                        text: format!(
                                                                            "SYSTEM: a previous model attempted this task but verification `{}` still FAILS (exit {}). You are a stronger model brought in to finish the job. Diagnose properly, fix the code, then it will be re-verified. Output:\n{}",
                                                                            verify_cmd, res.exit_code, tail
                                                                        ),
                                                                    }],
                                                                });
                                                                continue_agent_loop = true;
                                                                break;
                                                            }
                                                            // No stronger model left: end
                                                            // HONESTLY as a failure instead of
                                                            // pretending the run succeeded.
                                                            had_error = true;
                                                            last_error = Some(format!(
                                                                "verification `{}` still failing after retries and escalation",
                                                                verify_cmd
                                                            ));
                                                            continue_agent_loop = false;
                                                            break;
                                                        }
                                                        Ok(_) => {
                                                            let _ =
                                                                event_tx.send(Event::TestResult {
                                                                    run: run_id.clone(),
                                                                    passed: 1,
                                                                    failed: 0,
                                                                    detail: format!(
                                                                        "verify `{}` passed",
                                                                        verify_cmd
                                                                    ),
                                                                });
                                                        }
                                                        Err(e) => {
                                                            let _ = event_tx.send(Event::Message {
                                                                run: run_id.clone(),
                                                                role: "guard".into(),
                                                                text: format!(
                                                                    "verify command could not run: {}",
                                                                    e
                                                                ),
                                                            });
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    crate::event::StopReason::ToolUse => {
                                        // A single model turn that emits N tool calls
                                        // MUST be replayed as ONE assistant message
                                        // carrying reasoning_content + ALL tool_calls,
                                        // followed by N tool-result messages. Splitting
                                        // it into one assistant message per tool left
                                        // the 2nd+ calls without reasoning_content, which
                                        // DeepSeek/Qwen/Moonshot thinking-mode rejects
                                        // with HTTP 400 ("reasoning_content must be passed
                                        // back"), aborting every turn after the first and
                                        // leaving multi-file tasks half-done. One
                                        // assistant message with a tool_calls array is
                                        // also the correct OpenAI/Anthropic shape.
                                        let drained: Vec<_> =
                                            std::mem::take(&mut tool_results_pending);

                                        let mut assistant_blocks = Vec::new();
                                        if !reasoning_buf.is_empty() {
                                            assistant_blocks.push(ContentBlock::Reasoning {
                                                text: reasoning_buf.clone(),
                                            });
                                        }
                                        // Signature of this turn's tool calls for the
                                        // stuck-loop guard (name + args, order-sensitive).
                                        let turn_sig = {
                                            use std::collections::hash_map::DefaultHasher;
                                            use std::hash::{Hash, Hasher};
                                            let mut h = DefaultHasher::new();
                                            for (_, name, args, _, _) in &drained {
                                                name.hash(&mut h);
                                                args.to_string().hash(&mut h);
                                            }
                                            h.finish()
                                        };
                                        for (tool_id, tool_name, args, _content, _is_error) in
                                            &drained
                                        {
                                            assistant_blocks.push(ContentBlock::ToolUse {
                                                id: tool_id.clone(),
                                                name: tool_name.clone(),
                                                input: args.clone(),
                                            });
                                        }
                                        messages.push(Msg {
                                            role: "assistant".into(),
                                            content: assistant_blocks,
                                        });

                                        let turn_had_tools = !drained.is_empty();
                                        for (tool_id, _tool_name, _args, content, is_error) in
                                            drained
                                        {
                                            messages.push(Msg {
                                                role: "user".into(),
                                                content: vec![ContentBlock::ToolResult {
                                                    tool_use_id: tool_id,
                                                    content,
                                                    is_error: Some(is_error),
                                                }],
                                            });
                                        }
                                        if tool_output_seen_this_completion {
                                            produced_any_output = true;
                                        }

                                        // Stuck-loop guard: identical tool-call turns.
                                        if turn_had_tools {
                                            if last_tool_sig == Some(turn_sig) {
                                                repeated_tool_turns += 1;
                                            } else {
                                                repeated_tool_turns = 0;
                                                last_tool_sig = Some(turn_sig);
                                            }
                                        }
                                        if repeated_tool_turns == 2 {
                                            // 3rd identical turn — nudge the model.
                                            messages.push(Msg {
                                                role: "user".into(),
                                                content: vec![ContentBlock::Text {
                                                    text: "guard: you have issued the exact same \
                                                           tool call(s) three turns in a row with \
                                                           identical arguments. The result will \
                                                           not change. State what you learned and \
                                                           take a DIFFERENT action — or finish \
                                                           with your best answer now."
                                                        .into(),
                                                }],
                                            });
                                            send(Event::Message {
                                                run: run_id.clone(),
                                                role: "guard".into(),
                                                text: "repeated identical tool calls — nudging \
                                                       the model to change approach"
                                                    .into(),
                                            });
                                        } else if repeated_tool_turns >= 4 {
                                            // 5th identical turn — stop honestly instead of
                                            // burning the remaining turn/budget allowance.
                                            send(Event::Message {
                                                run: run_id.clone(),
                                                role: "guard".into(),
                                                text: "stuck loop: 5 identical tool-call turns \
                                                       — stopping the run"
                                                    .into(),
                                            });
                                            had_error = true;
                                            last_error = Some(
                                                "stopped by stuck-loop guard (5 identical \
                                                 tool-call turns)"
                                                    .into(),
                                            );
                                            continue_agent_loop = false;
                                            break;
                                        }

                                        continue_agent_loop =
                                            !waiting_for_approval && !stop_after_tool_result;
                                        break;
                                    }
                                    _ => {}
                                }
                                break; // Done
                            }
                            BrainEvent::Error(msg) => {
                                let _ = event_tx.send(Event::Error {
                                    run: run_id.clone(),
                                    message: msg.clone(),
                                });
                                let _ = self.hooks.execute(&HookEvent::OnError, &msg).await;
                                let next_idx = current_chain_idx + 1;
                                if next_idx < brain_policy.chain.len() {
                                    current_chain_idx = next_idx;
                                    let switch_ctx = format!(
                                        "{} -> {}",
                                        brain.id(),
                                        brain_policy.chain[current_chain_idx].id()
                                    );
                                    let _ = event_tx.send(Event::ModelSwitched {
                                        run: run_id.clone(),
                                        from: brain.id().to_string(),
                                        to: brain_policy.chain[current_chain_idx].id().to_string(),
                                        reason: msg,
                                    });
                                    let _ = self
                                        .hooks
                                        .execute(&HookEvent::OnModelSwitched, &switch_ctx)
                                        .await;
                                    continue_agent_loop = true;
                                } else {
                                    had_error = true;
                                    last_error = Some(msg);
                                }
                                break;
                            }
                        }
                    }

                    // Robust empty-completion fallback: some providers end the
                    // stream WITHOUT a Done(EndTurn) (so the in-stream check never
                    // fires). If this completion produced nothing and the run has
                    // produced nothing, advance to the next model in the chain.
                    if !continue_agent_loop && !had_error {
                        let this_empty =
                            assistant_text.trim().is_empty() && !tool_output_seen_this_completion;
                        if this_empty && !produced_any_output {
                            let next_idx = current_chain_idx + 1;
                            if next_idx < brain_policy.chain.len() {
                                let _ = event_tx.send(Event::ModelSwitched {
                                    run: run_id.clone(),
                                    from: brain.id().to_string(),
                                    to: brain_policy.chain[next_idx].id().to_string(),
                                    reason: "empty response".into(),
                                });
                                current_chain_idx = next_idx;
                                continue;
                            }
                        }
                    }

                    if continue_agent_loop {
                        continue;
                    }
                    break; // Task complete
                }
                Err(e) => {
                    let err_msg = format!("{}", e);
                    let _ = event_tx.send(Event::Error {
                        run: run_id.clone(),
                        message: err_msg.clone(),
                    });

                    // Transient failures (rate limit, timeout, 5xx, connection
                    // blips) get a bounded retry on the SAME brain first —
                    // otherwise one 429 on the primary silently downgrades the
                    // whole run to a weaker fallback model.
                    let retry_after_hint = match e.downcast_ref::<BrainError>() {
                        Some(BrainError::RateLimit { retry_after }) => Some(*retry_after),
                        Some(BrainError::Timeout) => Some(None),
                        Some(BrainError::ServerError { status, .. }) if *status >= 500 => {
                            Some(None)
                        }
                        Some(_) => None,
                        None => {
                            let s = err_msg.to_lowercase();
                            let transient = s.contains("rate limit")
                                || s.contains("429")
                                || s.contains("timeout")
                                || s.contains("timed out")
                                || s.contains("connection")
                                || s.contains("overloaded")
                                || s.contains("502")
                                || s.contains("503");
                            if transient { Some(None) } else { None }
                        }
                    };
                    if let Some(hint) = retry_after_hint {
                        if transient_retries < MAX_TRANSIENT_RETRIES {
                            transient_retries += 1;
                            // Honour the provider's Retry-After when given,
                            // capped so a run never stalls for minutes.
                            let secs = hint.unwrap_or(2u64.pow(transient_retries)).min(20);
                            send(Event::Message {
                                run: run_id.clone(),
                                role: "guard".into(),
                                text: format!(
                                    "provider hiccup ({}) — retrying {} in {}s (attempt {}/{})",
                                    err_msg,
                                    brain.id(),
                                    secs,
                                    transient_retries,
                                    MAX_TRANSIENT_RETRIES
                                ),
                            });
                            tokio::time::sleep(std::time::Duration::from_secs(secs)).await;
                            continue;
                        }
                    }
                    transient_retries = 0;

                    // Try next in chain
                    let next_idx = current_chain_idx + 1;
                    if next_idx < brain_policy.chain.len() {
                        current_chain_idx = next_idx;
                        let _ = event_tx.send(Event::ModelSwitched {
                            run: run_id.clone(),
                            from: brain.id().to_string(),
                            to: brain_policy.chain[current_chain_idx].id().to_string(),
                            reason: err_msg,
                        });
                    } else {
                        had_error = true;
                        last_error = Some(err_msg);
                        break;
                    }
                }
            }
        }

        // Final token usage. In-stream BrainEvent::Usage already emitted one
        // Event::TokenUsage per completion with INCREMENTS — surfaces sum
        // those events, so re-emitting the cumulative total here double-
        // counted every confirmed token. Only emit when the provider never
        // reported usage, and then as the ESTIMATE it actually is.
        let final_input = total_input + estimated_input_unconfirmed;
        let final_output = total_output + estimated_output_unconfirmed;
        if total_input == 0 && total_output == 0 && (final_input > 0 || final_output > 0) {
            let _ = event_tx.send(Event::TokenUsageEstimated {
                run: run_id.clone(),
                input: final_input,
                output: final_output,
                reason: "provider reported no usage events".into(),
            });
        }
        // Mark coder lane done — clears the animated caret cleanly.
        let _ = event_tx.send(Event::AgentStatus {
            run: run_id.clone(),
            role: "coder".into(),
            status: AgentStatus::Done,
            note: format!("completed · {}↑ {}↓ tok", final_input, final_output),
        });

        let outcome = OutcomeSummary {
            status: if had_error {
                format!(
                    "error: {}",
                    last_error.unwrap_or_else(|| "run failed".into())
                )
            } else if waiting_for_approval {
                "waiting_for_approval".into()
            } else if denied_by_approval {
                "denied".into()
            } else {
                "completed".into()
            },
            diffs,
            cost_usd: cost_usd + estimated_cost_unconfirmed,
            tokens: TokenUsage {
                input: total_input + estimated_input_unconfirmed,
                output: total_output + estimated_output_unconfirmed,
            },
            cost_comparison: String::new(),
        };

        // Persist task to memory
        if let Some(mem) = &self.memory {
            let _ = mem.save_task(&crate::memory::TaskMem {
                run_id: run_id.0.clone(),
                messages: messages.clone(),
                created_at: chrono::Utc::now().format("%Y-%m-%d %H:%M:%S").to_string(),
            });
        }

        // Per-repo routing memory: record only verification-backed outcomes —
        // a "completed" without a verify command proves nothing.
        {
            use crate::router::learned::RunRoutingOutcome;
            let routing_outcome = if had_error {
                Some(RunRoutingOutcome::Failed)
            } else if verify_escalations > 0 {
                Some(RunRoutingOutcome::Escalated)
            } else if verify_attempts > 0 && outcome.status == "completed" {
                Some(RunRoutingOutcome::VerifiedSuccess)
            } else {
                None
            };
            if let Some(o) = routing_outcome {
                repo_routing.record(&classified_tier, o);
            }
        }

        // Propose skill candidate from successful run
        if outcome.status == "completed" {
            if let Some(skills) = &self.skills {
                if let Some(candidate) = Curator::propose_skill_if_missing(
                    &task.description,
                    &skill_evidence,
                    skills.as_ref(),
                ) {
                    let skill_name = candidate.name.clone();
                    let _ = event_tx.send(Event::SkillLearned {
                        run: run_id.clone(),
                        name: skill_name.clone(),
                    });
                    let _ = self
                        .hooks
                        .execute(&HookEvent::OnSkillLearned, &skill_name)
                        .await;
                    let _ = skills.add(candidate);
                }
            }

            // Auto-distill facts from the successful run. Reconstruct the event
            // view from the final conversation: ToolUse blocks carry the real
            // tool args (file paths, content), Text blocks carry reasoning — both
            // are what the Distiller mines for durable user facts (§3.8).
            if let Some(mem) = &self.memory {
                let events = events_from_messages(&run_id, &messages);
                Distiller::distill(mem, &events, &task.description).await;
            }
        }

        let _ = event_tx.send(Event::RunFinished {
            run: run_id.clone(),
            outcome: outcome.clone(),
        });

        // PostRun lifecycle hook (best-effort, non-blocking semantics).
        let _ = self
            .hooks
            .execute(&HookEvent::PostRun, &task.description)
            .await;

        Ok(outcome)
    }
}

// ─── Tool narration detection ──────────────────────────────────────────────────

/// Detects when the assistant describes using a tool ("I'll run the tests",
/// "Let me search for...") without actually emitting a ToolUse block.
/// Returns true when tool-like language is present but no tools were called.
fn tool_narration_detected(text: &str) -> bool {
    let lower = text.to_lowercase();
    let patterns = [
        "i'll use",
        "i will use",
        "let me use",
        "i'll run",
        "i will run",
        "let me run",
        "i'll search",
        "i will search",
        "let me search",
        "i'll check",
        "i will check",
        "let me check",
        "i'll read",
        "i will read",
        "let me read",
        "i'll write",
        "i will write",
        "let me write",
        "i'll execute",
        "i will execute",
        "let me execute",
        "i'll call",
        "i will call",
        "let me call",
        "i'll fetch",
        "i will fetch",
        "let me fetch",
        "i'll look up",
        "i will look up",
        "let me look up",
        "i'll test",
        "i will test",
        "let me test",
        "running the test",
        "running the command",
        "searching for",
        "looking up",
    ];
    patterns.iter().any(|p| lower.contains(p))
}

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

    #[test]
    fn main_agent_system_prompt_carries_the_reasoning_protocol() {
        let prompt = build_system_prompt(
            &Identity::default(),
            &PathBuf::from("."),
            &[],
            &[],
            &[],
            &[],
            &[],
        );
        // Anchors taken from src/engine/main_soul.md. The soul has been
        // rewritten more than once; we pin the load-bearing concepts (tier
        // triage, the tribunal with its three reviewer roles, the
        // anti-simulation rule, the "real execution beats mental
        // simulation" instruction) rather than any single section header.
        for marker in [
            "TIER TRIAGE",
            "Tribunal",
            "Skeptic",
            "Adversary",
            "Anti-simulation",
            "Real execution beats",
        ] {
            assert!(prompt.contains(marker), "main soul must contain `{marker}`");
        }
    }

    #[test]
    fn named_agents_keep_their_own_soul() {
        let planner = Identity {
            name: "planner".into(),
            role: "technical architect".into(),
            personality: "structured".into(),
        };
        let prompt = build_system_prompt(&planner, &PathBuf::from("."), &[], &[], &[], &[], &[]);
        // The main soul's signature section header — if it leaks into a
        // named identity, the focused soul is being diluted.
        assert!(
            !prompt.contains("TIER TRIAGE"),
            "named souls must not be diluted by the main protocol"
        );
    }

    #[test]
    fn initial_user_content_blocks_embeds_uploaded_images() {
        let tmp = tempfile::tempdir().expect("tempdir");
        let image = tmp.path().join("shot.png");
        std::fs::write(
            &image,
            [
                0x89, b'P', b'N', b'G', b'\r', b'\n', 0x1a, b'\n', 0, 0, 0, 0,
            ],
        )
        .expect("write image");
        let description = format!(
            "analyse this\n\n[Attached files]\n### file: shot.png\n[uploaded: {}]",
            image.display()
        );

        let blocks = initial_user_content_blocks(tmp.path(), &description);
        assert!(matches!(blocks.first(), Some(ContentBlock::Text { .. })));
        assert!(blocks.iter().any(|block| matches!(
            block,
            ContentBlock::Image {
                source: ImageSource::Base64 {
                    media_type,
                    data,
                }
            } if media_type == "image/png" && !data.is_empty()
        )));
    }

    #[test]
    fn tool_result_content_blocks_preserves_images() {
        let blocks = tool_result_content_blocks(&[
            Block::Text("screenshot captured".into()),
            Block::Image {
                data: vec![1, 2, 3],
                mime: "image/png".into(),
            },
        ]);

        assert!(matches!(blocks.first(), Some(ContentBlock::Text { .. })));
        assert!(blocks.iter().any(|block| matches!(
            block,
            ContentBlock::Image {
                source: ImageSource::Base64 {
                    media_type,
                    data,
                }
            } if media_type == "image/png" && data == "AQID"
        )));
    }
}