//! Classify raw claude stream-json values into [`crate::term_msg::TermMsg`]
//! rows before SSE delivery.
//!
//! [`classify_stream_value`] is the entry point — it walks one raw claude
//! `stream-json` line (the payload of a [`crate::events::LiveEvent::Stream`])
//! and returns zero or more terminal rows. Applied at SSE-emit time in
//! `crate::web_ui::stream` so both the live tail (`events/stream`) and the
//! history replay (`events/history`) endpoints deliver the same classified
//! shape — the sqlite event log stores the raw, unclassified event, so the
//! DB never needs migration when classification logic changes.
//!
//! The per-tool icon/summary formatting below (`tool_icon`, `fmt_tool_use`
//! and its per-family helpers, `rich_tool_body`) is reused as-is from
//! before mara's terminal-message redesign — that logic (what does
//! `mcp__hyperhive__send`'s row say, which tools get an expandable body)
//! didn't change; only the shape it gets packed into did.

use crate::term_msg::{BodyFormat, ClassifyCtx, Level, TermMsg};
use serde_json::{Value, json};

/// Classify one raw claude stream-json line into zero or more terminal rows.
///
/// Dispatch order mirrors the old client-side `classifyEvent.ts` (before
/// this classification moved server-side):
/// top-level drop-noise types first, then `type="system"`, then task events
/// (matched on `subtype` regardless of `type`), then `assistant`/`user`
/// content, with an unrecognised shape falling through to a loud
/// warn-level catch-all so a silently-dropped event type stays visible.
pub fn classify_stream_value(v: &Value, ctx: &mut ClassifyCtx) -> Vec<TermMsg> {
    let vtype = v.get("type").and_then(Value::as_str).unwrap_or("");
    if matches!(vtype, "result" | "rate_limit_event") {
        return vec![];
    }
    if vtype == "system" {
        return classify_system(v);
    }
    let subtype = v.get("subtype").and_then(Value::as_str);
    if matches!(subtype, Some("task_started" | "task_notification")) {
        return classify_task_event(v).into_iter().collect();
    }
    if vtype == "assistant" {
        return v
            .get("message")
            .and_then(|m| m.get("content"))
            .and_then(Value::as_array)
            .map_or_else(Vec::new, |content| classify_assistant_content(content, ctx));
    }
    if vtype == "user" {
        return v
            .get("message")
            .and_then(|m| m.get("content"))
            .and_then(Value::as_array)
            .map_or_else(Vec::new, |content| classify_user_content(content, ctx));
    }
    vec![TermMsg::new(Level::Warn, trim_str(&v.to_string(), 200)).icon("!")]
}

// ---------------------------------------------------------------------------
// system events
// ---------------------------------------------------------------------------

fn classify_system(v: &Value) -> Vec<TermMsg> {
    let subtype = v.get("subtype").and_then(Value::as_str).unwrap_or("");
    let (category, summary, body) = system_fields(v, subtype);
    match category {
        "drop" => vec![],
        "thinking_tok" => vec![
            TermMsg::new(
                Level::Debug,
                summary.unwrap_or_else(|| "thinking…".to_owned()),
            )
            .icon("🧠")
            .coalesce("thinking-tok"),
        ],
        "details" => {
            let mut m = TermMsg::new(Level::Debug, summary.unwrap_or_default());
            if let Some(b) = body {
                m = m.body(b, None);
            }
            vec![m]
        }
        // "note" category — ambient harness/system chatter. Level + coalesce
        // key vary by subtype; everything else defaults to a plain debug note.
        _ => {
            let s = summary.unwrap_or_default();
            let m = match subtype {
                "api_error" => TermMsg::new(Level::Error, s),
                "api_retry" => TermMsg::new(Level::Warn, s),
                "plugin_install" => TermMsg::new(Level::Debug, s).coalesce("plugin-install"),
                "status" => TermMsg::new(Level::Debug, s).coalesce("status-tick"),
                _ => TermMsg::new(Level::Debug, s),
            };
            vec![m]
        }
    }
}

/// Compute `(category, summary, body)` for a `type="system"` event.
///
/// Categories understood by the frontend:
/// - `"drop"` — client discards without rendering (noise)
/// - `"thinking_tok"` — client updates a single in-place counter row
/// - `"note"` — client renders `_summary` as a terminal note line
/// - `"details"` — client renders a collapsible `<details>` with `_summary`
///   as the header and `_body` as the expanded text
fn system_fields(v: &Value, subtype: &str) -> (&'static str, Option<String>, Option<String>) {
    match subtype {
        // Silent startup / stream-end noise — drop.
        "init" | "result" | "rate_limit_event" => ("drop", None, None),

        // Live thinking-token counter.
        "thinking_tokens" => {
            let n = v.get("estimated_tokens").and_then(Value::as_u64);
            let s = n.map_or_else(
                || "thinking…".to_owned(),
                |n| format!("thinking… ~{n} tokens"),
            );
            ("thinking_tok", Some(s), None)
        }

        // API retry back-off.
        "api_retry" => {
            let mut parts = vec!["⚠ api retry".to_owned()];
            if let (Some(a), Some(m)) = (
                v.get("attempt").and_then(Value::as_u64),
                v.get("max_retries").and_then(Value::as_u64),
            ) {
                parts.push(format!("{a}/{m}"));
            }
            if let Some(e) = v.get("error").and_then(Value::as_str) {
                parts.push(e.to_owned());
            } else if let Some(s) = v.get("error_status").and_then(Value::as_u64) {
                parts.push(format!("HTTP {s}"));
            }
            if let Some(ms) = v.get("retry_delay_ms").and_then(Value::as_f64) {
                parts.push(format!("{:.0}ms", ms.round()));
            }
            ("note", Some(parts.join(" · ")), None)
        }

        // Hard API error.
        "api_error" => {
            let msg = v
                .get("error")
                .or_else(|| v.get("message"))
                .and_then(Value::as_str)
                .map_or_else(
                    || {
                        v.get("error_status")
                            .and_then(Value::as_u64)
                            .map_or("unknown".to_owned(), |s| format!("HTTP {s}"))
                    },
                    str::to_owned,
                );
            ("note", Some(format!("✗ api error · {msg}")), None)
        }

        // Plugin (MCP server / slash-command provider) load progress.
        "plugin_install" => {
            let status = v.get("status").and_then(Value::as_str).unwrap_or("?");
            let label = match status {
                "completed" => "✓ done",
                "started" => "loading…",
                other => other,
            };
            ("note", Some(format!("⚙ plugin install · {label}")), None)
        }

        // Available slash-command set changed — expandable list.
        "commands_changed" => {
            let cmds = v.get("commands").and_then(Value::as_array);
            let count = cmds.map_or(0, Vec::len);
            let summary = format!("⚙ commands changed · {count} available");
            let body = cmds.map(|cmds| {
                cmds.iter()
                    .filter_map(|c| c.get("name").and_then(Value::as_str))
                    .map(|n| format!("/{n}"))
                    .collect::<Vec<_>>()
                    .join("\n")
            });
            ("details", Some(summary), body)
        }

        // Compaction complete — pre/post token counts + duration.
        "compact_boundary" => {
            let m = v
                .get("compact_metadata")
                .cloned()
                .unwrap_or_else(|| json!({}));
            let mut parts = vec!["⚙ compact".to_owned()];
            if let Some(t) = m.get("trigger").and_then(Value::as_str) {
                parts.push(t.to_owned());
            }
            if let (Some(pre), Some(post)) = (
                m.get("pre_tokens").and_then(Value::as_u64),
                m.get("post_tokens").and_then(Value::as_u64),
            ) {
                parts.push(format!("{}→{} tokens", fmt_tok(pre), fmt_tok(post)));
            }
            if let Some(ms) = m.get("duration_ms").and_then(Value::as_u64) {
                let dur = if ms < 1000 {
                    format!("{ms}ms")
                } else {
                    #[allow(clippy::cast_precision_loss)]
                    let s_f = ms as f64 / 1_000.0;
                    format!("{s_f:.1}s")
                };
                parts.push(dur);
            }
            ("note", Some(parts.join(" · ")), None)
        }

        // Generic "still working" heartbeat tick.
        "status" => ("note", Some("⚙ status".to_owned()), None),

        // Unknown subtype — render with the subtype label as a muted note.
        other => ("note", Some(format!("⚙ {other}")), None),
    }
}

// ---------------------------------------------------------------------------
// assistant events (claude's own output: text / thinking / tool calls)
// ---------------------------------------------------------------------------

fn classify_assistant_content(content: &[Value], ctx: &mut ClassifyCtx) -> Vec<TermMsg> {
    let mut rows = Vec::new();
    for c in content {
        match c.get("type").and_then(Value::as_str) {
            Some("text") => {
                let text = c.get("text").and_then(Value::as_str).unwrap_or("");
                if !text.trim().is_empty() {
                    // No separate summary line — the markdown body is the
                    // whole row, matching the old `.text` row shape.
                    rows.push(
                        TermMsg::new(Level::Info, String::new())
                            .body(text.to_owned(), Some(BodyFormat::Markdown)),
                    );
                }
            }
            Some("thinking") => {
                let txt = c
                    .get("thinking")
                    .or_else(|| c.get("text"))
                    .and_then(Value::as_str)
                    .unwrap_or("")
                    .trim()
                    .to_owned();
                let summary = if txt.is_empty() {
                    "thinking …".to_owned()
                } else {
                    txt
                };
                rows.push(TermMsg::new(Level::Debug, summary).icon("💭"));
            }
            Some("tool_use") => {
                if let (Some(id), Some(name)) = (
                    c.get("id").and_then(Value::as_str),
                    c.get("name").and_then(Value::as_str),
                ) {
                    ctx.record_tool_use(id, name);
                }
                rows.push(classify_tool_use(c));
            }
            _ => {}
        }
    }
    rows
}

/// `_category === 'rich'` tools used to get an expandable row (diff body
/// for Edit, markdown body for send, plain for everything else with a
/// body). That's now just "does this row have a body" — `body.is_some()`
/// on the returned [`TermMsg`] *is* the expandable signal, no separate
/// flag.
fn classify_tool_use(c: &Value) -> TermMsg {
    let name = c.get("name").and_then(Value::as_str).unwrap_or("");
    let input = c.get("input").cloned().unwrap_or_else(|| json!({}));
    let mut m = TermMsg::new(Level::Info, fmt_tool_use(name, &input)).icon(tool_icon(name));
    if let Some((body, body_type)) = rich_tool_body(name, &input) {
        let format = match body_type {
            "diff" => Some(BodyFormat::Diff),
            "markdown" => Some(BodyFormat::Markdown),
            _ => None, // "plain"
        };
        m = m.body(body, format);
    }
    m
}

// ---------------------------------------------------------------------------
// user events (tool_result — claude's own tool calls answered)
// ---------------------------------------------------------------------------

fn classify_user_content(content: &[Value], ctx: &ClassifyCtx) -> Vec<TermMsg> {
    content
        .iter()
        .filter(|c| c.get("type").and_then(Value::as_str) == Some("tool_result"))
        .map(|c| classify_tool_result(c, ctx))
        .collect()
}

/// `<tool_use_error>…</tool_use_error>` is claude's own wrapper on failed
/// tool calls — implementation detail, adds nothing for the operator.
fn strip_tool_use_error_wrapper(s: &str) -> String {
    let trimmed = s.trim();
    trimmed
        .strip_prefix("<tool_use_error>")
        .and_then(|rest| rest.strip_suffix("</tool_use_error>"))
        .map_or_else(|| trimmed.to_owned(), |inner| inner.trim().to_owned())
}

fn classify_tool_result(c: &Value, ctx: &ClassifyCtx) -> TermMsg {
    let raw_txt = match c.get("content") {
        Some(Value::Array(parts)) => parts
            .iter()
            .filter_map(|p| p.get("text").and_then(Value::as_str))
            .collect::<String>(),
        Some(Value::String(s)) => s.clone(),
        _ => String::new(),
    };
    let is_error = c.get("is_error").and_then(Value::as_bool).unwrap_or(false);
    let txt = if is_error {
        strip_tool_use_error_wrapper(&raw_txt)
    } else {
        raw_txt
    };

    let tool_use_id = c.get("tool_use_id").and_then(Value::as_str);
    let source_name = tool_use_id.and_then(|id| ctx.tool_name(id));
    let is_message_bearing = source_name == Some("mcp__hyperhive__recv");

    let trimmed: String = txt.split_whitespace().collect::<Vec<_>>().join(" ");
    let summary = summarize_tool_result(&txt, &trimmed);
    let short = txt.trim().is_empty() || txt.chars().count() <= 120;

    if is_error {
        let m = TermMsg::new(Level::Error, summary);
        return if short {
            m.icon("✗")
        } else {
            m.body(txt, None)
        };
    }
    if is_message_bearing && !txt.trim().is_empty() {
        return TermMsg::new(Level::Info, format!("recv ← {summary}"))
            .body(txt, Some(BodyFormat::Markdown));
    }
    let m = TermMsg::new(Level::Info, summary);
    if short {
        m.icon("←")
    } else {
        m.body(txt, None)
    }
}

/// `(empty)` / a short trimmed line / `"NL · headline…"` for a long one —
/// matches the old client-side `summaryBody` computation exactly.
fn summarize_tool_result(txt: &str, trimmed: &str) -> String {
    if trimmed.is_empty() {
        return "(empty)".to_owned();
    }
    if trimmed.chars().count() <= 120 {
        return trimmed.to_owned();
    }
    let lines = txt.lines().filter(|l| !l.is_empty()).count();
    let headline: String = trimmed.chars().take(90).collect();
    format!("{lines}L · {headline}…")
}

// ---------------------------------------------------------------------------
// subagent (claude Task-tool) activity — dead path for agents today (`Task`
// is omitted from the allow-list) but kept for parity with the old
// client-side `classifyTaskEvent`.
// ---------------------------------------------------------------------------

fn classify_task_event(v: &Value) -> Option<TermMsg> {
    let id: String = v
        .get("task_id")
        .and_then(Value::as_str)
        .unwrap_or("")
        .chars()
        .take(8)
        .collect();
    let kind = v
        .get("task_type")
        .and_then(Value::as_str)
        .map(|t| format!(" [{t}]"))
        .unwrap_or_default();
    let desc = v
        .get("description")
        .or_else(|| v.get("summary"))
        .and_then(Value::as_str)
        .unwrap_or("(no description)");
    match v.get("subtype").and_then(Value::as_str) {
        Some("task_started") => {
            Some(TermMsg::new(Level::Info, format!("task {id} started · {desc}{kind}")).icon("⌁"))
        }
        Some("task_notification") => {
            let status = v.get("status").and_then(Value::as_str).unwrap_or("unknown");
            let (glyph, level) = match status {
                "completed" => ("✓", Level::Info),
                "failed" => ("✗", Level::Error),
                _ => ("◌", Level::Info),
            };
            let out = v
                .get("output_file")
                .and_then(Value::as_str)
                .map(|f| format!(" · → {f}"))
                .unwrap_or_default();
            Some(TermMsg::new(level, format!("task {id} {glyph} {status} · {desc}{out}")).icon("⌁"))
        }
        _ => None,
    }
}

// ---------------------------------------------------------------------------
// tool helpers
// ---------------------------------------------------------------------------

/// Pre-compute the expandable body for rich tool entries.
///
/// Returns `Some((body, body_type))` where `body_type` becomes the
/// `TermMsg`'s `body_format` and tells the frontend which renderer to use:
/// - `"diff"` → colour-coded `+`/`-` lines
/// - `"plain"` (`None` on the wire) → a plain `<pre>` block
/// - `"markdown"` → rendered via `marked` + `DOMPurify`; used for
///   message-bearing tools: `send`
///
/// Returns `None` for tools that have no body at all.
///
/// **`Write` is intentionally absent**: its `content` field can be megabytes
/// and is one-sided (no `old_string` to diff against), making it too large to
/// inline in every SSE event. The flat `"Write /path"` summary row is
/// sufficient — the operator can open the file directly if they need to inspect
/// the written content.
fn rich_tool_body(name: &str, input: &Value) -> Option<(String, &'static str)> {
    match name {
        // Edit diff: old lines prefixed `- `, new lines prefixed `+ `.
        // The summary already carries `-N +M` counts (from `fmt_builtin_tool`),
        // so the body is the full colour-coded diff.
        "Edit" => {
            let old = input
                .get("old_string")
                .and_then(Value::as_str)
                .unwrap_or("");
            let new = input
                .get("new_string")
                .and_then(Value::as_str)
                .unwrap_or("");
            let mut body = String::new();
            for line in old.lines() {
                body.push_str("- ");
                body.push_str(line);
                body.push('\n');
            }
            for line in new.lines() {
                body.push_str("+ ");
                body.push_str(line);
                body.push('\n');
            }
            Some((body, "diff"))
        }
        // Full bash command — first line is already in `_summary`; the full
        // `cmd` (prefixed with `$ `) is the body so multi-line scripts are
        // readable on expand.
        "mcp__bash__run" => {
            let cmd = input.get("cmd").and_then(Value::as_str).unwrap_or("");
            if cmd.is_empty() {
                None
            } else {
                Some((format!("$ {cmd}"), "plain"))
            }
        }
        // Message-bearing tool: body is markdown text rendered by the client.
        "mcp__hyperhive__send" => {
            let body = input.get("body").and_then(Value::as_str).unwrap_or("");
            if body.is_empty() {
                None
            } else {
                Some((body.to_owned(), "markdown"))
            }
        }
        _ => None,
    }
}

fn tool_icon(name: &str) -> &'static str {
    // Exact-match table first, then prefix/contains fallbacks.
    match name {
        "mcp__hyperhive__send" => "📤",
        "mcp__hyperhive__recv" => "📥",
        "mcp__hyperhive__remind" => "⏰",
        "mcp__hyperhive__set_status" => "🏷️",
        "mcp__hyperhive__get_loose_ends" => "🪢",
        "mcp__hyperhive__cancel_loose_end" => "✂️",
        "mcp__hyperhive__ack_until" => "✅",
        "mcp__hyperhive__get_agent_meta" => "ℹ️",
        "mcp__hyperhive__restart" => "↻",
        "mcp__hyperhive__kill" => "⏹️",
        "mcp__hyperhive__start" => "▶️",
        "mcp__hyperhive__update" => "🔄",
        "mcp__hyperhive__list_containers"
        | "mcp__matrix__list_rooms"
        | "mcp__matrix__list_room_members"
        | "mcp__matrix__list_invites" => "📋",
        "mcp__hyperhive__get_logs" | "mcp__hyperhive__get_host_journal" => "📜",
        "mcp__matrix__read_room" | "Read" => "📖",
        "mcp__matrix__mark_read" => "👁️",
        "mcp__bash__kill" => "🛑",
        "Write" => "💾",
        "Edit" => "✏️",
        "Glob" | "Grep" => "🔍",
        _ => tool_icon_fallback(name),
    }
}

fn tool_icon_fallback(name: &str) -> &'static str {
    if name.starts_with("mcp__matrix__") {
        "💬"
    } else if name.starts_with("mcp__bash__") {
        "🖥️"
    } else if name.contains("schedule") {
        "⏱️"
    } else if name.starts_with("mcp__hyperhive__request_") {
        "📦"
    } else {
        "🔧"
    }
}

// ---------------------------------------------------------------------------
// tool_use summary formatter — dispatch to per-family sub-functions
// ---------------------------------------------------------------------------

fn fmt_tool_use(name: &str, input: &Value) -> String {
    // Short name: strip the MCP server prefix for display.
    let short = if let Some(rest) = name.strip_prefix("mcp__hyperhive__") {
        format!("{rest}*")
    } else if let Some(rest) = name.strip_prefix("mcp__bash__") {
        format!("{rest}*")
    } else if let Some(rest) = name.strip_prefix("mcp__matrix__") {
        format!("{rest}*")
    } else {
        name.to_owned()
    };

    if name.starts_with("mcp__hyperhive__") {
        fmt_hyperhive_tool(name, &short, input)
    } else if name.starts_with("mcp__bash__") {
        fmt_bash_tool(name, &short, input)
    } else if name.starts_with("mcp__matrix__") {
        fmt_matrix_tool(name, &short, input)
    } else {
        fmt_builtin_tool(name, &short, input)
    }
}

/// Built-in claude tools: Read/Write/Edit/Glob/Grep/Bash/TodoWrite and any
/// unknown tool that doesn't carry a known MCP server prefix.
fn fmt_builtin_tool(name: &str, short: &str, input: &Value) -> String {
    match name {
        "Read" | "Write" => format!("{short} {}", sv(input, "file_path")),
        "Edit" => {
            let path = sv(input, "file_path");
            let old = input
                .get("old_string")
                .and_then(Value::as_str)
                .unwrap_or("");
            let new_n = input
                .get("new_string")
                .and_then(Value::as_str)
                .unwrap_or("")
                .lines()
                .count();
            if old.is_empty() {
                format!("{short} {path} · +{new_n}")
            } else {
                let old_n = old.lines().count();
                format!("{short} {path} · -{old_n} +{new_n}")
            }
        }
        "Glob" | "Grep" => format!("{short} {}", sv(input, "pattern")),
        "Bash" => {
            let bg = if input
                .get("run_in_background")
                .and_then(Value::as_bool)
                .unwrap_or(false)
            {
                " [bg]"
            } else {
                ""
            };
            format!("{short}{bg} $ {}", sv(input, "command"))
        }
        "TodoWrite" => {
            let n = input
                .get("todos")
                .and_then(Value::as_array)
                .map_or(0, Vec::len);
            format!("{short} ({n} items)")
        }
        _ => fmt_args_generic(short, input),
    }
}

/// Summary for `send`, the one message-bearing hyperhive tool.
///
/// Format: `"{short} → {recipient}"` with ` · NL` appended when the body
/// spans multiple lines.
fn fmt_hyperhive_message_tool(name: &str, short: &str, input: &Value) -> String {
    match name {
        "mcp__hyperhive__send" => {
            let to = sv(input, "to");
            let lines = sv(input, "body").lines().count();
            if lines > 1 {
                format!("{short} → {to} · {lines}L")
            } else {
                format!("{short} → {to}")
            }
        }
        _ => fmt_args_generic(short, input),
    }
}

/// `mcp__hyperhive__*` tools.
fn fmt_hyperhive_tool(name: &str, short: &str, input: &Value) -> String {
    match name {
        "mcp__hyperhive__send" => fmt_hyperhive_message_tool(name, short, input),
        "mcp__hyperhive__recv" => {
            let mut parts = Vec::new();
            if let Some(w) = input.get("wait_seconds").and_then(Value::as_u64) {
                parts.push(format!("wait {w}s"));
            }
            if let Some(m) = input.get("max").and_then(Value::as_u64) {
                parts.push(format!("max {m}"));
            }
            if parts.is_empty() {
                format!("{short}()")
            } else {
                format!("{short} {}", parts.join(" · "))
            }
        }
        "mcp__hyperhive__kill"
        | "mcp__hyperhive__restart"
        | "mcp__hyperhive__start"
        | "mcp__hyperhive__update"
        | "mcp__hyperhive__request_init_config" => format!("{short} {}", sv(input, "name")),
        "mcp__hyperhive__ack_until" => {
            let up_to = input
                .get("up_to")
                .and_then(Value::as_u64)
                .map_or_else(|| "?".to_owned(), |n| n.to_string());
            format!("{short} ≤{up_to}")
        }
        "mcp__hyperhive__get_logs" => {
            let lines = input
                .get("lines")
                .and_then(Value::as_u64)
                .map(|n| format!(" · {n}L"))
                .unwrap_or_default();
            format!("{short} {}{lines}", sv(input, "agent"))
        }
        "mcp__hyperhive__get_host_journal" => {
            let mut parts = Vec::new();
            if let Some(c) = input.get("container").and_then(Value::as_str) {
                parts.push(c.to_owned());
            } else if let Some(u) = input.get("unit").and_then(Value::as_str) {
                parts.push(u.to_owned());
            }
            if let Some(g) = input.get("grep").and_then(Value::as_str) {
                parts.push(format!("/{g}/"));
            }
            if let Some(l) = input.get("lines").and_then(Value::as_u64) {
                parts.push(format!("{l}L"));
            }
            if parts.is_empty() {
                format!("{short}()")
            } else {
                format!("{short} {}", parts.join(" · "))
            }
        }
        "mcp__hyperhive__remind" => fmt_hyperhive_remind(short, input),
        "mcp__hyperhive__request_update_meta_inputs"
        | "mcp__hyperhive__list_schedules"
        | "mcp__hyperhive__cancel_schedule"
        | "mcp__hyperhive__fire_schedule_now"
        | "mcp__hyperhive__edit_schedule"
        | "mcp__hyperhive__request_schedule_prompt" => {
            fmt_hyperhive_schedule_tool(name, short, input)
        }
        "mcp__hyperhive__set_status" => {
            format!("{short} \"{}\"", trim_str(&sv(input, "text"), 60))
        }
        "mcp__hyperhive__get_loose_ends" => {
            let agent = input
                .get("agent")
                .and_then(Value::as_str)
                .map_or_else(|| "()".to_owned(), |a| format!(" [{a}]"));
            format!("{short}{agent}")
        }
        "mcp__hyperhive__get_agent_meta" => {
            let name_part = input
                .get("name")
                .and_then(Value::as_str)
                .map_or_else(|| "()".to_owned(), |n| format!(" {n}"));
            format!("{short}{name_part}")
        }
        "mcp__hyperhive__cancel_loose_end" => {
            let id = input
                .get("id")
                .and_then(Value::as_u64)
                .map_or_else(|| "?".to_owned(), |n| n.to_string());
            format!("{short} {} #{id}", sv(input, "kind"))
        }
        "mcp__hyperhive__mark_todos_done" => fmt_hyperhive_mark_todos_done(short, input),
        _ => fmt_args_generic(short, input),
    }
}

/// `mark_todos_done` — renders the acked ids so the terminal shows which
/// todos a bulk-clear call actually covered, not just a bracketed count
/// (`fmt_args_generic`'s generic array handling collapses to `ids: [N]`,
/// the count alone, which isn't useful here).
fn fmt_hyperhive_mark_todos_done(short: &str, input: &Value) -> String {
    let ids = match input.get("ids").and_then(Value::as_array) {
        Some(arr) if !arr.is_empty() => {
            let nums: Vec<String> = arr
                .iter()
                .filter_map(Value::as_u64)
                .take(8)
                .map(|n| n.to_string())
                .collect();
            let tail = if arr.len() > 8 { ", …" } else { "" };
            format!("[{}{tail}]", nums.join(", "))
        }
        _ => "[]".to_owned(),
    };
    format!("{short} {ids}")
}

fn fmt_hyperhive_remind(short: &str, input: &Value) -> String {
    let when = if let Some(s) = input.get("delay_seconds").and_then(Value::as_u64) {
        if s < 60 {
            format!("+{s}s")
        } else if s < 3_600 {
            format!("+{}m", s / 60)
        } else {
            #[allow(clippy::cast_precision_loss)]
            let h_f = s as f64 / 3_600.0;
            format!("+{h_f:.1}h")
        }
    } else if let Some(ts) = input.get("at_unix_timestamp").and_then(Value::as_u64) {
        let h = (ts % 86_400) / 3_600;
        let m = (ts % 3_600) / 60;
        format!("at {h:02}:{m:02}Z")
    } else {
        String::new()
    };
    let msg_raw = input
        .get("message")
        .or_else(|| input.get("file_path"))
        .and_then(Value::as_str)
        .unwrap_or("");
    let msg = trim_str(&msg_raw.replace(char::is_whitespace, " "), 60);
    let when_part = if when.is_empty() {
        String::new()
    } else {
        format!(" {when}")
    };
    let msg_part = if msg.is_empty() {
        String::new()
    } else {
        format!(" \"{msg}\"")
    };
    format!("{short}{when_part}{msg_part}")
}

fn fmt_hyperhive_edit_schedule(short: &str, input: &Value) -> String {
    let id = input
        .get("id")
        .and_then(Value::as_u64)
        .map_or_else(|| "?".to_owned(), |n| n.to_string());
    let mut parts = vec![format!("#{id}")];
    if input.get("body").is_some() {
        parts.push("body".to_owned());
    }
    if input.get("interval_seconds").is_some() {
        parts.push("interval".to_owned());
    }
    if input.get("next_fire_at_unix").is_some() {
        parts.push("next".to_owned());
    }
    if let Some(a) = input.get("targets_add").and_then(Value::as_array)
        && !a.is_empty()
    {
        parts.push(format!("+{} tgt", a.len()));
    }
    if let Some(r) = input.get("targets_remove").and_then(Value::as_array)
        && !r.is_empty()
    {
        parts.push(format!("-{} tgt", r.len()));
    }
    format!("{short} {}", parts.join(" · "))
}

/// Schedule-management hyperhive tools (list/cancel/fire/edit/request).
fn fmt_hyperhive_schedule_tool(name: &str, short: &str, input: &Value) -> String {
    match name {
        "mcp__hyperhive__request_update_meta_inputs" => {
            let ins = match input.get("inputs").and_then(Value::as_array) {
                Some(arr) if !arr.is_empty() => {
                    let names: Vec<&str> = arr.iter().filter_map(Value::as_str).take(4).collect();
                    let tail = if arr.len() > 4 { ", …" } else { "" };
                    format!("[{}{}]", names.join(", "), tail)
                }
                _ => "all".to_owned(),
            };
            format!("{short} {ins}")
        }
        "mcp__hyperhive__list_schedules" => format!("{short}()"),
        "mcp__hyperhive__cancel_schedule" => {
            let id = input
                .get("id")
                .and_then(Value::as_u64)
                .map_or_else(|| "?".to_owned(), |n| n.to_string());
            let tgts = match input.get("targets").and_then(Value::as_array) {
                Some(arr) if !arr.is_empty() => {
                    let names: Vec<&str> = arr.iter().filter_map(Value::as_str).collect();
                    format!(" [{}]", names.join(", "))
                }
                _ => " all".to_owned(),
            };
            format!("{short} #{id}{tgts}")
        }
        "mcp__hyperhive__fire_schedule_now" => {
            let id = input
                .get("id")
                .and_then(Value::as_u64)
                .map_or_else(|| "?".to_owned(), |n| n.to_string());
            format!("{short} #{id}")
        }
        "mcp__hyperhive__edit_schedule" => fmt_hyperhive_edit_schedule(short, input),
        "mcp__hyperhive__request_schedule_prompt" => {
            let tgts = match input.get("targets").and_then(Value::as_array) {
                Some(arr) => arr
                    .iter()
                    .filter_map(Value::as_str)
                    .collect::<Vec<_>>()
                    .join(", "),
                None => "?".to_owned(),
            };
            let when = input
                .get("first_fire_at_unix")
                .and_then(Value::as_u64)
                .map_or_else(
                    || "?".to_owned(),
                    |ts| {
                        let h = (ts % 86_400) / 3_600;
                        let m = (ts % 3_600) / 60;
                        format!("{h:02}:{m:02}Z")
                    },
                );
            let recur = input
                .get("interval_seconds")
                .and_then(Value::as_u64)
                .map(|s| format!(" +{s}s"))
                .unwrap_or_default();
            format!("{short} → {tgts} at {when}{recur}")
        }
        _ => fmt_args_generic(short, input),
    }
}

/// `mcp__bash__*` tools.
fn fmt_bash_tool(name: &str, short: &str, input: &Value) -> String {
    match name {
        "mcp__bash__run" => {
            let cmd = sv(input, "cmd");
            let first = cmd.lines().next().unwrap_or("").trim().to_owned();
            format!("{short} $ {}", trim_str(&first, 72))
        }
        "mcp__bash__status" => {
            let wait = input
                .get("wait_seconds")
                .and_then(Value::as_u64)
                .map(|w| format!(" · wait {w}s"))
                .unwrap_or_default();
            format!("{short} id:{}{wait}", sv(input, "id"))
        }
        "mcp__bash__kill" => {
            let force = if input.get("force").and_then(Value::as_bool).unwrap_or(false) {
                " [force]"
            } else {
                ""
            };
            format!("{short} {}{force}", sv(input, "id"))
        }
        _ => fmt_args_generic(short, input),
    }
}

/// `mcp__matrix__*` tools.
fn fmt_matrix_tool(name: &str, short: &str, input: &Value) -> String {
    match name {
        "mcp__matrix__read_room" => {
            let limit = input
                .get("limit")
                .and_then(Value::as_u64)
                .map(|l| format!(" [{l}]"))
                .unwrap_or_default();
            format!("{short} {}{limit}", fmt_room(&sv(input, "room")))
        }
        "mcp__matrix__mark_read" | "mcp__matrix__join_room" | "mcp__matrix__download_file" => {
            format!("{short} {}", fmt_room(&sv(input, "room")))
        }
        "mcp__matrix__send_message" | "mcp__matrix__send_reply" => format!(
            "{short} → {}: {}",
            fmt_room(&sv(input, "room")),
            json_str(&trim_str(&sv(input, "body"), 50))
        ),
        "mcp__matrix__send_dm" => format!(
            "{short} → {}: {}",
            fmt_user(&sv(input, "user_id")),
            json_str(&trim_str(&sv(input, "body"), 50))
        ),
        "mcp__matrix__send_reaction" => format!(
            "{short} {} {}",
            fmt_room(&sv(input, "room")),
            sv(input, "key")
        ),
        "mcp__matrix__open_dm" => format!("{short} {}", fmt_user(&sv(input, "user_id"))),
        "mcp__matrix__invite_user" => format!(
            "{short} {} → {}",
            fmt_user(&sv(input, "user_id")),
            fmt_room(&sv(input, "room"))
        ),
        _ => fmt_args_generic(short, input),
    }
}

// ---------------------------------------------------------------------------
// generic fallback formatter (port of JS fmtArgsGeneric)
// ---------------------------------------------------------------------------

fn fmt_args_generic(name: &str, input: &Value) -> String {
    let Some(obj) = input.as_object() else {
        return format!("{name}()");
    };
    if obj.is_empty() {
        return format!("{name}()");
    }
    let keys: Vec<&String> = obj.keys().collect();
    if keys.len() == 1 {
        let k = keys[0];
        let v = &obj[k];
        if let Some(s) = v.as_str() {
            return format!("{name} {k}: {}", json_str(&trim_str(s, 100)));
        }
        if v.is_number() || v.is_boolean() {
            return format!("{name} {k}: {v}");
        }
    }
    let pretty: Vec<String> = keys
        .iter()
        .take(4)
        .map(|k| {
            let v = &obj[*k];
            if v.is_null() {
                format!("{k}: null")
            } else if let Some(s) = v.as_str() {
                format!("{k}: {}", json_str(&trim_str(s, 40)))
            } else if v.is_number() || v.is_boolean() {
                format!("{k}: {v}")
            } else if let Some(arr) = v.as_array() {
                format!("{k}: [{}]", arr.len())
            } else {
                format!("{k}: {{…}}")
            }
        })
        .collect();
    let tail = if keys.len() > 4 {
        format!(" …+{}", keys.len() - 4)
    } else {
        String::new()
    };
    format!("{name} {}{tail}", pretty.join(" · "))
}

// ---------------------------------------------------------------------------
// string utilities
// ---------------------------------------------------------------------------

/// Format a token count as "1k", "1.2M", etc. (mirrors JS `fmtTok`).
fn fmt_tok(n: u64) -> String {
    if n >= 1_000_000 {
        // Divide before casting to keep the value in a range where f64
        // has enough precision for one decimal place (≤ ~9×10^12 tokens).
        #[allow(clippy::cast_precision_loss)]
        let m = (n / 1_000) as f64 / 1_000.0;
        format!("{m:.1}M")
    } else if n >= 1_000 {
        format!("{}k", n / 1_000)
    } else {
        n.to_string()
    }
}

/// Shorten a matrix room id/alias for display.
fn fmt_room(r: &str) -> String {
    if r.starts_with('!') {
        // Room id: keep only the local part before the colon (up to 9 chars).
        // Both halves of that are character counts — `find` returns a byte
        // offset, and spending it as a character budget lets a multi-byte
        // local part buy extra characters from the server half.
        let local = r.split(':').next().unwrap_or(r);
        local.chars().take(9).collect()
    } else if r.starts_with('#') {
        // Alias: keep `#name` part before the server.
        r.split(':').next().unwrap_or(r).to_owned()
    } else {
        trim_str(r, 20)
    }
}

/// Shorten `@user:server` → `@user`.
fn fmt_user(u: &str) -> String {
    let end = u.find(':').unwrap_or(u.len());
    u[..end].to_owned()
}

/// Extract a string field from a JSON object, defaulting to `""`.
fn sv(v: &Value, key: &str) -> String {
    v.get(key).and_then(Value::as_str).unwrap_or("").to_owned()
}

/// Trim to `max` *characters* (not bytes), collapsing whitespace first.
fn trim_str(s: &str, max: usize) -> String {
    let collapsed: String = s.split_whitespace().collect::<Vec<_>>().join(" ");
    let mut chars = collapsed.chars();
    let trimmed: String = chars.by_ref().take(max).collect();
    if chars.next().is_some() {
        format!("{trimmed}…")
    } else {
        trimmed
    }
}

/// Serialize a string as a JSON string literal (e.g. `"hello"`) for display
/// in summary lines. Falls back to the raw string if serialization fails.
fn json_str(s: &str) -> String {
    serde_json::to_string(s).unwrap_or_else(|_| s.to_owned())
}

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

    fn one(v: &Value) -> TermMsg {
        let mut ctx = ClassifyCtx::default();
        let rows = classify_stream_value(v, &mut ctx);
        assert_eq!(rows.len(), 1, "expected exactly one row for {v}");
        rows.into_iter().next().unwrap()
    }

    // -----------------------------------------------------------------
    // dispatch
    // -----------------------------------------------------------------

    #[test]
    fn terminal_event_types_render_nothing() {
        for t in ["result", "rate_limit_event"] {
            let mut ctx = ClassifyCtx::default();
            assert!(
                classify_stream_value(&json!({ "type": t }), &mut ctx).is_empty(),
                "{t} should be dropped"
            );
        }
    }

    /// The catch-all exists so a claude event shape nobody anticipated stays
    /// *visible* rather than vanishing. Losing it is silent, which is why it
    /// gets a test rather than a comment.
    #[test]
    fn unrecognised_shape_falls_through_loudly() {
        let m = one(&json!({ "type": "something_new", "detail": "x" }));
        assert_eq!(m.level, Level::Warn);
        assert_eq!(m.icon.as_deref(), Some("!"));
        assert!(m.summary.contains("something_new"));
    }

    #[test]
    fn catch_all_truncates_a_huge_payload() {
        let m = one(&json!({ "type": "unknown", "blob": "x".repeat(5_000) }));
        assert_eq!(
            m.summary.chars().count(),
            201,
            "200 chars plus the ellipsis"
        );
        assert!(m.summary.ends_with('…'));
    }

    /// Task events are matched on `subtype` *regardless of `type`* — a
    /// deliberate asymmetry with every other arm, and one a refactor that
    /// "tidies" the dispatch into a single match on `type` would silently
    /// break.
    #[test]
    fn task_events_dispatch_on_subtype_not_type() {
        let m = one(&json!({
            "type": "assistant",
            "subtype": "task_started",
            "task_id": "abcdef1234567890",
            "description": "do a thing",
        }));
        assert!(
            m.summary.starts_with("task abcdef12 started"),
            "{}",
            m.summary
        );
        assert!(
            !m.summary.contains("1234567890"),
            "task id is truncated to 8 chars"
        );
    }

    #[test]
    fn a_failed_task_notification_is_an_error_row() {
        let m = one(&json!({
            "type": "x", "subtype": "task_notification",
            "task_id": "t1", "status": "failed",
        }));
        assert_eq!(m.level, Level::Error);
    }

    // -----------------------------------------------------------------
    // system events
    // -----------------------------------------------------------------

    #[test]
    fn startup_noise_is_dropped_but_an_unknown_subtype_is_not() {
        let mut ctx = ClassifyCtx::default();
        assert!(
            classify_stream_value(&json!({ "type": "system", "subtype": "init" }), &mut ctx)
                .is_empty()
        );
        // The pairing is the point: "init produces nothing" only means
        // something if a *different* subtype produces something.
        let m = one(&json!({ "type": "system", "subtype": "brand_new" }));
        assert_eq!(m.summary, "⚙ brand_new");
    }

    #[test]
    fn system_severity_is_carried_by_subtype() {
        let cases = [
            ("api_error", Level::Error),
            ("api_retry", Level::Warn),
            ("status", Level::Debug),
        ];
        for (subtype, want) in cases {
            let m = one(&json!({ "type": "system", "subtype": subtype }));
            assert_eq!(m.level, want, "{subtype}");
        }
    }

    /// Coalescing is what stops a heartbeat from flooding the terminal: rows
    /// sharing a key collapse into one. A missing key is invisible in every
    /// unit except the rendered stream.
    #[test]
    fn repeating_rows_carry_a_coalesce_key() {
        let tick = one(&json!({ "type": "system", "subtype": "status" }));
        assert_eq!(tick.coalesce_key.as_deref(), Some("status-tick"));

        let think = one(&json!({
            "type": "system", "subtype": "thinking_tokens", "estimated_tokens": 1234,
        }));
        assert_eq!(think.coalesce_key.as_deref(), Some("thinking-tok"));
        assert_eq!(think.summary, "thinking… ~1234 tokens");

        // Same subtype, no count: still coalesces, still says something.
        let bare = one(&json!({ "type": "system", "subtype": "thinking_tokens" }));
        assert_eq!(bare.summary, "thinking…");
        assert_eq!(bare.coalesce_key.as_deref(), Some("thinking-tok"));
    }

    #[test]
    fn commands_changed_expands_into_the_command_list() {
        let m = one(&json!({
            "type": "system", "subtype": "commands_changed",
            "commands": [{ "name": "compact" }, { "name": "loop" }],
        }));
        assert_eq!(m.summary, "⚙ commands changed · 2 available");
        assert_eq!(m.body.as_deref(), Some("/compact\n/loop"));
    }

    #[test]
    fn api_retry_summarises_every_field_it_was_given() {
        let m = one(&json!({
            "type": "system", "subtype": "api_retry",
            "attempt": 2, "max_retries": 5,
            "error_status": 529, "retry_delay_ms": 1500.4,
        }));
        assert_eq!(m.summary, "⚠ api retry · 2/5 · HTTP 529 · 1500ms");
    }

    /// `error` wins over `error_status` — the operator gets the message, not
    /// the number, whenever there is one.
    #[test]
    fn api_error_prefers_the_message_over_the_status() {
        let with_msg = one(&json!({
            "type": "system", "subtype": "api_error",
            "error": "overloaded", "error_status": 529,
        }));
        assert_eq!(with_msg.summary, "✗ api error · overloaded");

        let status_only =
            one(&json!({ "type": "system", "subtype": "api_error", "error_status": 529 }));
        assert_eq!(status_only.summary, "✗ api error · HTTP 529");

        let neither = one(&json!({ "type": "system", "subtype": "api_error" }));
        assert_eq!(neither.summary, "✗ api error · unknown");
    }

    // -----------------------------------------------------------------
    // tool results
    // -----------------------------------------------------------------

    /// The 120-char boundary decides between an inline summary and an
    /// expandable body, and it counts *characters*, so a multi-byte result is
    /// the case that would break a byte-based rewrite.
    #[test]
    fn tool_result_summary_boundary_counts_characters() {
        let at = "a".repeat(120);
        assert_eq!(summarize_tool_result(&at, &at), at);

        let over = "a".repeat(121);
        let s = summarize_tool_result(&over, &over);
        assert!(s.starts_with("1L · "), "{s}");
        assert!(s.ends_with('…'));

        // 120 non-ASCII chars is 240 bytes: byte-length would call this long.
        let wide = "é".repeat(120);
        assert_eq!(summarize_tool_result(&wide, &wide), wide);
    }

    #[test]
    fn an_empty_tool_result_says_so() {
        assert_eq!(summarize_tool_result("", ""), "(empty)");
        assert_eq!(summarize_tool_result("  \n\t ", ""), "(empty)");
    }

    #[test]
    fn a_long_tool_result_reports_its_line_count() {
        let txt = "line\n".repeat(40);
        let trimmed: String = txt.split_whitespace().collect::<Vec<_>>().join(" ");
        assert!(summarize_tool_result(&txt, &trimmed).starts_with("40L · "));
    }

    /// Only a *matched* pair is claude's wrapper. A result that merely starts
    /// with the opening tag is real output and must survive intact.
    #[test]
    fn the_error_wrapper_is_stripped_only_when_balanced() {
        assert_eq!(
            strip_tool_use_error_wrapper("<tool_use_error>boom</tool_use_error>"),
            "boom"
        );
        assert_eq!(
            strip_tool_use_error_wrapper("  <tool_use_error> boom </tool_use_error>  "),
            "boom"
        );
        let unbalanced = "<tool_use_error>boom";
        assert_eq!(strip_tool_use_error_wrapper(unbalanced), unbalanced);
        assert_eq!(strip_tool_use_error_wrapper("plain"), "plain");
    }

    fn tool_result(text: &str, is_error: bool, id: &str) -> Value {
        json!({
            "type": "user",
            "message": { "content": [{
                "type": "tool_result",
                "tool_use_id": id,
                "is_error": is_error,
                "content": [{ "type": "text", "text": text }],
            }]},
        })
    }

    /// `classify_tool_result` has its **own** `<= 120`, separate from the one
    /// in `summarize_tool_result`, and the two have to agree: one picks the
    /// summary text, the other picks icon-vs-body. A result that summarises as
    /// short but renders with a body is the inconsistency this pins.
    /// Added because mutation testing found the gap — the case below uses 2
    /// and 500 characters, so neither arm goes near the boundary and moving it
    /// to 119 changed nothing.
    #[test]
    fn the_icon_or_body_choice_turns_on_the_same_120_boundary() {
        let at = one(&tool_result(&"a".repeat(120), false, "t1"));
        assert_eq!(at.icon.as_deref(), Some("←"), "120 chars is still short");
        assert!(at.body.is_none());

        let over = one(&tool_result(&"a".repeat(121), false, "t1"));
        assert!(over.icon.is_none(), "121 chars stops being short");
        assert_eq!(over.body.as_deref().map(str::len), Some(121));
    }

    #[test]
    fn a_short_result_gets_an_icon_and_a_long_one_gets_a_body() {
        let short = one(&tool_result("ok", false, "t1"));
        assert_eq!(short.icon.as_deref(), Some("←"));
        assert!(short.body.is_none(), "short results are not expandable");

        let long = one(&tool_result(&"x".repeat(500), false, "t1"));
        assert!(long.icon.is_none());
        assert_eq!(long.body.as_deref().map(str::len), Some(500));
    }

    #[test]
    fn an_error_result_is_an_error_row_with_the_wrapper_gone() {
        let m = one(&tool_result(
            "<tool_use_error>file not found</tool_use_error>",
            true,
            "t1",
        ));
        assert_eq!(m.level, Level::Error);
        assert_eq!(m.icon.as_deref(), Some("✗"));
        assert_eq!(m.summary, "file not found");
    }

    /// The one piece of *cross-event* state in this module: the tool name is
    /// learned from the assistant event and read back on the user event that
    /// answers it. Nothing but a test spanning both events can catch it
    /// breaking — and when it does, an inbox message silently renders as
    /// plain text instead of markdown.
    #[test]
    fn a_recv_result_is_markdown_only_because_the_tool_use_was_seen_first() {
        let mut ctx = ClassifyCtx::default();
        let body = "**bold** message from a peer";

        // Without the correlation, it is an ordinary result.
        let cold = classify_stream_value(&tool_result(body, false, "call-1"), &mut ctx);
        assert_eq!(cold[0].body_format, None);
        assert!(!cold[0].summary.starts_with("recv ←"));

        // Feed the assistant event that names the tool, then the same result.
        classify_stream_value(
            &json!({
                "type": "assistant",
                "message": { "content": [{
                    "type": "tool_use", "id": "call-1",
                    "name": "mcp__hyperhive__recv", "input": {},
                }]},
            }),
            &mut ctx,
        );
        let warm = classify_stream_value(&tool_result(body, false, "call-1"), &mut ctx);
        assert!(
            warm[0].summary.starts_with("recv ← "),
            "{}",
            warm[0].summary
        );
        assert_eq!(warm[0].body_format, Some(BodyFormat::Markdown));
        assert_eq!(warm[0].body.as_deref(), Some(body));
    }

    #[test]
    fn a_recv_result_with_no_content_stays_an_ordinary_row() {
        let mut ctx = ClassifyCtx::default();
        ctx.record_tool_use("call-1", "mcp__hyperhive__recv");
        let m = one_with(&tool_result("   ", false, "call-1"), &mut ctx);
        assert!(!m.summary.starts_with("recv ←"));
        assert_eq!(m.summary, "(empty)");
    }

    fn one_with(v: &Value, ctx: &mut ClassifyCtx) -> TermMsg {
        let rows = classify_stream_value(v, ctx);
        assert_eq!(rows.len(), 1, "expected exactly one row for {v}");
        rows.into_iter().next().unwrap()
    }

    // -----------------------------------------------------------------
    // assistant content
    // -----------------------------------------------------------------

    #[test]
    fn assistant_text_becomes_a_markdown_body_with_no_summary() {
        let m = one(&json!({
            "type": "assistant",
            "message": { "content": [{ "type": "text", "text": "# hi" }]},
        }));
        assert_eq!(m.summary, "");
        assert_eq!(m.body.as_deref(), Some("# hi"));
        assert_eq!(m.body_format, Some(BodyFormat::Markdown));
    }

    #[test]
    fn blank_assistant_text_produces_no_row_at_all() {
        let mut ctx = ClassifyCtx::default();
        let rows = classify_stream_value(
            &json!({
                "type": "assistant",
                "message": { "content": [{ "type": "text", "text": "   \n " }]},
            }),
            &mut ctx,
        );
        assert!(rows.is_empty());
    }

    #[test]
    fn one_assistant_event_can_produce_several_rows() {
        let mut ctx = ClassifyCtx::default();
        let rows = classify_stream_value(
            &json!({
                "type": "assistant",
                "message": { "content": [
                    { "type": "text", "text": "doing it" },
                    { "type": "thinking", "thinking": "hmm" },
                    { "type": "tool_use", "id": "t1", "name": "Bash",
                      "input": { "command": "ls" } },
                    { "type": "something_else" },
                ]},
            }),
            &mut ctx,
        );
        assert_eq!(rows.len(), 3, "the unknown content block is skipped");
        assert_eq!(rows[1].icon.as_deref(), Some("💭"));
        // The tool_use was recorded for later correlation as a side effect.
        assert_eq!(ctx.tool_name("t1"), Some("Bash"));
    }

    // -----------------------------------------------------------------
    // string helpers
    // -----------------------------------------------------------------

    #[test]
    fn token_counts_shorten_at_each_threshold() {
        assert_eq!(fmt_tok(0), "0");
        assert_eq!(fmt_tok(999), "999");
        assert_eq!(fmt_tok(1_000), "1k");
        assert_eq!(fmt_tok(999_999), "999k");
        assert_eq!(fmt_tok(1_000_000), "1.0M");
        assert_eq!(fmt_tok(1_250_000), "1.2M");
    }

    #[test]
    fn trim_str_collapses_whitespace_and_counts_characters() {
        assert_eq!(trim_str("a  b\n\tc", 99), "a b c");
        assert_eq!(trim_str("abcdef", 3), "abc…");
        // Exactly at the limit: no ellipsis.
        assert_eq!(trim_str("abc", 3), "abc");
        // 4 chars / 8 bytes — a byte-based limit would cut this at 2.
        assert_eq!(trim_str("éééé", 4), "éééé");
    }

    #[test]
    fn matrix_ids_shorten_to_something_recognisable() {
        assert_eq!(fmt_user("@mara:pr1ma.darkest.space"), "@mara");
        assert_eq!(fmt_user("@mara"), "@mara");
        assert_eq!(fmt_room("#hive-chat:pr1ma.darkest.space"), "#hive-chat");
        assert_eq!(fmt_room("!abcdefghijkl:server"), "!abcdefgh");
        assert_eq!(fmt_room("plain name"), "plain name");
    }

    /// A short room id keeps its whole local part and stops at the colon.
    /// The non-ASCII case is the one that used to leak: `find(':')` is a
    /// *byte* offset and it was being spent as a *character* budget, so a
    /// multi-byte local part bought extra characters from the server half.
    #[test]
    fn a_room_id_never_shows_part_of_the_server() {
        assert_eq!(fmt_room("!short:server"), "!short");
        assert_eq!(fmt_room("!ÄÖÜ:server"), "!ÄÖÜ");
        assert_eq!(fmt_room("!ÄÖÜ"), "!ÄÖÜ");
    }
}