darq 0.1.0

#![allow(dead_code)]
// App state includes scaffolding fields reserved for future panels (shifts, blueprints,
// backlog, judges). They are wired into state updates but not yet rendered.

use std::collections::{HashMap, VecDeque};
use std::time::Instant;

use chrono::{DateTime, Utc};
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
use darq_core::types::{Run, RunStatus};
use ratatui::prelude::*;
use ratatui::widgets::*;

use crate::daemon::client::DaemonEvent;
use crate::tui::TuiEvent;

// ── Event-stream typed display state ──
//
// Populated by handle_daemon_event from all 12 RunEvent variants. Rendered by
// Phase-3 widgets (currently unused by the legacy 6-panel grid; that changes in
// Phase 3.2 when panels.rs is rewritten).

/// Max event lines kept in the visible waterfall buffer.
pub const WATERFALL_CAP: usize = 200;

/// Width of the agent-oscilloscope decay trace (samples).
/// One sample per render frame; at 30 Hz this gives ~6 seconds of history.
pub const SCOPE_WIDTH: usize = 200;

/// Per-frame multiplicative decay applied to each scope sample.
/// At 30 Hz, 0.985 → ~5 seconds for a unit spike to decay to ~0.1
/// (visibly fades over the full ~6s scope window).
pub const SCOPE_DECAY: f32 = 0.985;

/// Three-state agent classification used by the scope shape + suffix.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AgentPhase {
    /// No connected agent or heartbeat went stale (>30s).
    Idle,
    /// Agent is alive (recent heartbeat) but quiet (no tool_use in last 5s).
    /// On the scope, rendered as a sine carrier wave shaped by the active station.
    Thinking,
    /// Agent is actively producing — recent tool_use within 5s.
    /// Tall event spikes dominate the trace.
    Producing,
}

/// Per-station scope carrier — varies sine base/amplitude/period so each
/// workflow station has a recognizable shape on the oscilloscope.
#[derive(Debug, Clone, Copy)]
pub struct CarrierProfile {
    pub base: f32,
    pub amp: f32,
    pub period_ms: f32,
}

/// Event kind for color/glyph dispatch in the waterfall widget.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum EventKind {
    Heartbeat,
    StateTransition,
    ToolUse,
    SessionUpdate,
    Artifact,
    BlueprintsInjected,
    Routing,
    Warning,
    Error,
    Success,
}

/// A single displayable event in the waterfall.
#[derive(Debug, Clone)]
pub struct EventDisplayed {
    pub ts: DateTime<Utc>,
    pub kind: EventKind,
    pub text: String,
    pub run_id: Option<String>,
}

/// Per-persona SAT state — current displayed needle position, latest score target,
/// and a short note carrying the most recent qualitative feedback (if any).
#[derive(Debug, Clone, Default)]
pub struct SatPersonaState {
    pub current: f32, // 0..100, animated needle position (Phase 4.5)
    pub target: f32,  // 0..100, from most recent SatPersonaScore event
    pub last_updated: Option<DateTime<Utc>>,
    pub note: Option<String>,
}

/// Station state in the 7-step chain topology.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum StationState {
    Pending,
    Active,
    Completed,
    Failed,
    NotApplicable,
}

impl StationState {
    pub fn glyph(self) -> &'static str {
        match self {
            Self::Pending => "○",
            Self::Active => "●",
            Self::Completed => "✓",
            Self::Failed => "✖",
            Self::NotApplicable => "·",
        }
    }
}

/// Rolling chain of 7 stations (plan, implement, review, fix, merge, sat, learn).
#[derive(Debug, Clone)]
pub struct ChainState {
    pub stations: [StationState; 7],
    pub elapsed_ms: [Option<u64>; 7],
}

impl Default for ChainState {
    fn default() -> Self {
        Self {
            stations: [StationState::Pending; 7],
            elapsed_ms: [None; 7],
        }
    }
}

/// Map the workflow_kind string from a RunEvent to a station index (0..7).
/// Unknown kinds return None (skipped by the handler).
pub fn workflow_kind_to_station(kind: &str) -> Option<usize> {
    match kind {
        "plan_issue" | "plan" => Some(0),
        "implement_issue" | "implement" => Some(1),
        "review_pr" | "review" => Some(2),
        "fix_review" | "fix" => Some(3),
        "merge_pr" | "merge" => Some(4),
        "sat_verify" | "sat" => Some(5),
        "learn_update" | "learn" => Some(6),
        _ => None,
    }
}

/// Which secondary panel currently occupies the right column. Phase 6.
/// Default = `SatDials`. Toggles via single keystrokes from the footer.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum PanelMode {
    #[default]
    SatDials,
    Shifts,
    Blueprints,
    Backlog,
    Judges,
}

/// Waterfall filter mode. Phase 6.6 cycles via `[f]`.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum WaterfallFilter {
    #[default]
    All,
    Errors,
    Tools,
    Routing,
}

impl WaterfallFilter {
    pub fn next(self) -> Self {
        match self {
            Self::All => Self::Errors,
            Self::Errors => Self::Tools,
            Self::Tools => Self::Routing,
            Self::Routing => Self::All,
        }
    }
    pub fn label(self) -> &'static str {
        match self {
            Self::All => "all",
            Self::Errors => "errors",
            Self::Tools => "tools",
            Self::Routing => "routing",
        }
    }
    pub fn matches(self, kind: EventKind) -> bool {
        match self {
            Self::All => true,
            Self::Errors => matches!(kind, EventKind::Error | EventKind::Warning),
            Self::Tools => matches!(kind, EventKind::ToolUse),
            Self::Routing => matches!(kind, EventKind::Routing | EventKind::StateTransition),
        }
    }
}

/// Live agent thinking metrics, populated from AgentHeartbeat events.
/// Drives the waiting-invisibility fix: active station shows elapsed + output growth.
#[derive(Debug, Clone)]
pub struct AgentHeartbeatState {
    pub elapsed_secs: u64,
    pub output_chars: u64,
    /// When the most recent heartbeat frame arrived (wall-clock).
    pub last_frame_at: Instant,
    /// Output_chars from the previous frame, to compute the per-second growth rate.
    pub prev_output_chars: u64,
    /// Wall-clock of the previous frame, for the rate denominator.
    pub prev_frame_at: Instant,
}

impl AgentHeartbeatState {
    /// Chars-per-second since the last frame. Returns 0 on the first frame.
    pub fn rate_per_sec(&self) -> u64 {
        let dt = self
            .last_frame_at
            .duration_since(self.prev_frame_at)
            .as_secs_f32();
        if dt < 0.1 {
            return 0;
        }
        let delta = self.output_chars.saturating_sub(self.prev_output_chars) as f32;
        (delta / dt) as u64
    }
}

/// Marker for a recent station-completion — drives the single-shot trail animation
/// across the chain topology connector. Replaces the always-on packet (annoying).
#[derive(Debug, Clone, Copy)]
pub struct CompletionTrail {
    pub station_idx: usize,
    pub at: Instant,
}

/// Shift-end summary card. Captured when a focused shift hits a terminal status.
/// Fills the empty space below the waterfall with key stats — gives visual weight
/// to the climax of the run and uses the otherwise-wasted real estate.
#[derive(Debug, Clone)]
pub struct TerminalCard {
    pub run_id: String,
    pub final_status: String, // "completed" / "failed" / "cancelled"
    pub duration_secs: u64,
    pub verdict: Option<String>, // SAT verdict if any
    pub total_events: usize,
    pub blueprints: usize,
    pub tool_count: u32,
}

/// One retrieved blueprint, populated by `BlueprintsInjected` (Phase 5) events.
#[derive(Debug, Clone)]
pub struct BlueprintMatch {
    pub run_id: String,
    pub utility_name: String,
    pub similarity: f32,
    pub kind: BlueprintKind,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BlueprintKind {
    Reuse,
    Avoid,
}

// ── Panel Navigation ──

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Panel {
    Milestone,
    Runs,
    Approvals,
    PrState,
    SatStatus,
    Learnings,
}

impl Panel {
    pub fn next(self) -> Self {
        match self {
            Self::Milestone => Self::Runs,
            Self::Runs => Self::Approvals,
            Self::Approvals => Self::PrState,
            Self::PrState => Self::SatStatus,
            Self::SatStatus => Self::Learnings,
            Self::Learnings => Self::Milestone,
        }
    }

    pub fn prev(self) -> Self {
        match self {
            Self::Milestone => Self::Learnings,
            Self::Runs => Self::Milestone,
            Self::Approvals => Self::Runs,
            Self::PrState => Self::Approvals,
            Self::SatStatus => Self::PrState,
            Self::Learnings => Self::SatStatus,
        }
    }
}

// ── Actions ──

pub enum Action {
    Quit,
    ApproveRun(String),
    TriggerNext,
}

// ── Display Types ──

pub struct RunInfo {
    pub id: String,
    pub status: String,
    pub issue: String,
    pub duration: String,
}

pub struct PrInfo {
    pub number: u64,
    pub title: String,
    pub status: String,
}

// ── Confirmation State ──

pub struct Confirmation {
    pub action: Action,
    pub prompt: String,
}

// ── App State ──

pub struct App {
    pub focused: Panel,
    pub tick_count: u64,
    pub runs_state: TableState,
    pub approvals_state: ListState,
    pub milestone_name: Option<String>,
    pub runs: Vec<RunInfo>,
    pub approvals: Vec<RunInfo>,
    pub prs: Vec<PrInfo>,
    pub sat_summary: String,
    pub learnings: Vec<String>,
    pub confirmation: Option<Confirmation>,
    pub status_message: String,
    // ── Phase-2+ state (populated by handle_daemon_event from all 12 RunEvents) ──
    /// Rolling waterfall of displayable events (capped at WATERFALL_CAP).
    pub waterfall: VecDeque<EventDisplayed>,
    /// Currently-focused shift (used for chain state + sat scores).
    pub focus_run_id: Option<String>,
    /// 7-station chain state for the focused shift.
    pub chain_state: ChainState,
    /// Per-persona SAT state (key: persona name, lowercase).
    pub sat_scores: HashMap<String, SatPersonaState>,
    /// Most recent SAT verdict text ("PASS" / "FAIL").
    pub sat_verdict: Option<String>,
    /// Tool-use counter for the focused shift (incremented on `ToolUse` events once
    /// Phase 5 emits them; stays 0 until then).
    pub tool_count: u32,
    /// Blueprints retrieved during the focused shift's plan station. Populated by
    /// Phase 5's `BlueprintsInjected` event; empty until then.
    pub blueprints: Vec<BlueprintMatch>,
    /// Rolling throughput window (events per tick, max 32 entries → ~16 s at 2 Hz).
    pub throughput_window: VecDeque<u32>,
    /// Events received in the current tick bucket, reset on each `TuiEvent::Tick`.
    pub events_this_tick: u32,
    /// Wall-clock anchor for time-based animations (Phase 4).
    pub start_time: Instant,
    /// When the most recent render frame ran (for delta-time interpolation).
    pub last_render: Instant,
    /// Most recently failed station + when the glitch should clear (Phase 4.6).
    pub glitch: Option<(usize, Instant)>,
    /// Daemon uptime seconds, fetched periodically from Method::Stats (Phase 5.8).
    pub daemon_uptime_secs: u64,
    /// Total blueprint store size, from Method::Stats (Phase 5.8). 0 = "—" in TUI.
    pub daemon_blueprint_count: u64,
    /// Which panel currently occupies the right column (Phase 6.1).
    pub mode: PanelMode,
    /// Active waterfall filter (Phase 6.6).
    pub waterfall_filter: WaterfallFilter,
    /// Reduce-motion mode (Phase 7.2): set from `DARQ_TUI_REDUCE_MOTION` env var.
    /// When true, disable: breathing animation, waterfall fade-out, animated packet,
    /// needle interpolation. Heartbeat dot still pulses (essential signal).
    pub reduce_motion: bool,
    /// Transient red dot on the header heartbeat after a recent failure (Phase 7.5).
    pub failure_dot_until: Option<Instant>,
    /// Per-shift started_at timestamp, used to live-recompute durations each Tick.
    /// Captured from `status_changed → running` events, or from update_from_runs().
    pub run_started_at: HashMap<String, DateTime<Utc>>,
    /// Per-shift completed_at timestamp — freezes duration once a shift finishes.
    pub run_completed_at: HashMap<String, DateTime<Utc>>,
    /// Live agent heartbeat metrics for the focused shift. Cleared on focus change
    /// and on station transition. Populated from AgentHeartbeat events.
    pub agent_heartbeat: Option<AgentHeartbeatState>,
    /// Most recent station completion — fires a 250ms trail across the connector.
    /// Replaces the always-on animated packet.
    pub completion_trail: Option<CompletionTrail>,
    /// True when this App is driving a replay session (no daemon connection).
    /// Used by the header to hide daemon-only fields like `uptime`.
    pub is_replay: bool,
    /// Snapshot of a shift's terminal state — drives the "shift complete" callout
    /// card that fills the empty space below the waterfall when a run finishes.
    pub terminal_card: Option<TerminalCard>,
    /// Show the keybinding help modal (toggled by `?`).
    pub show_help: bool,
    /// Decay-trace samples for the chain-topology agent oscilloscope.
    /// Each render frame, all samples decay; on each event arrival, the rightmost
    /// sample spikes proportional to event intensity. Capped at SCOPE_WIDTH.
    pub scope_trace: VecDeque<f32>,
    /// Most recent tool name from a ToolUse event — drives the live-action line.
    pub last_tool: Option<String>,
    /// When the most recent ToolUse event arrived — used to detect "thinking"
    /// state on the scope (recent heartbeat AND no recent tool_use = thinking).
    pub last_tool_at: Option<Instant>,
    pub event_status: String,
    pub event_count: u64,
}

impl App {
    pub fn new() -> Self {
        let mut runs_state = TableState::default();
        runs_state.select(Some(0));

        let mut approvals_state = ListState::default();
        approvals_state.select(Some(0));

        Self {
            focused: Panel::Milestone,
            tick_count: 0,
            runs_state,
            approvals_state,
            milestone_name: Some("v1.0".into()),
            runs: vec![],
            approvals: vec![],
            prs: vec![],
            sat_summary: "No SAT runs yet".into(),
            learnings: vec![],
            confirmation: None,
            status_message: "Starting...".into(),
            event_status: "Events: not subscribed".into(),
            event_count: 0,
            waterfall: VecDeque::with_capacity(WATERFALL_CAP),
            focus_run_id: None,
            chain_state: ChainState::default(),
            sat_scores: HashMap::new(),
            sat_verdict: None,
            tool_count: 0,
            blueprints: Vec::new(),
            throughput_window: VecDeque::with_capacity(32),
            events_this_tick: 0,
            start_time: Instant::now(),
            last_render: Instant::now(),
            glitch: None,
            daemon_uptime_secs: 0,
            daemon_blueprint_count: 0,
            mode: PanelMode::default(),
            waterfall_filter: WaterfallFilter::default(),
            reduce_motion: std::env::var("DARQ_TUI_REDUCE_MOTION")
                .map(|v| v == "1" || v.eq_ignore_ascii_case("true"))
                .unwrap_or(false),
            failure_dot_until: None,
            run_started_at: HashMap::new(),
            run_completed_at: HashMap::new(),
            agent_heartbeat: None,
            completion_trail: None,
            is_replay: false,
            terminal_card: None,
            show_help: false,
            scope_trace: VecDeque::with_capacity(SCOPE_WIDTH),
            last_tool: None,
            last_tool_at: None,
        }
    }

    /// Classify the agent's current state for the scope shape.
    /// Now considers chain_state too: any active station = at least Thinking,
    /// even before the first heartbeat arrives. Eliminates the dead 10s window
    /// at the start of each station where the scope was flat.
    pub fn agent_phase(&self) -> AgentPhase {
        // Recent tool_use (<5s) → producing (highest priority).
        if let Some(t) = self.last_tool_at
            && t.elapsed().as_secs() < 5
        {
            return AgentPhase::Producing;
        }
        // Heartbeat fresh (<30s) → thinking.
        if let Some(hb) = &self.agent_heartbeat
            && hb.last_frame_at.elapsed().as_secs() <= 30
        {
            return AgentPhase::Thinking;
        }
        // Even with no heartbeat yet, an active station means the agent IS
        // working — show thinking carrier so the scope isn't dead during
        // station startup.
        if self.active_station_idx().is_some() {
            return AgentPhase::Thinking;
        }
        AgentPhase::Idle
    }

    /// Index of the currently-active station in chain_state (0..7), if any.
    pub fn active_station_idx(&self) -> Option<usize> {
        self.chain_state
            .stations
            .iter()
            .position(|s| matches!(s, StationState::Active))
    }

    /// Per-station carrier profile — gives each workflow station a recognizable
    /// scope signature. base = always-on amplitude, amp = sine wave amplitude,
    /// period_ms = sine period (slow = contemplative, fast = busy).
    pub fn station_carrier_profile(&self) -> CarrierProfile {
        match self.active_station_idx() {
            Some(0) => CarrierProfile {
                base: 0.20,
                amp: 0.15,
                period_ms: 6000.0,
            }, // PLAN — slow contemplation
            Some(1) => CarrierProfile {
                base: 0.40,
                amp: 0.25,
                period_ms: 3000.0,
            }, // IMPLEMENT — busy
            Some(2) => CarrierProfile {
                base: 0.30,
                amp: 0.20,
                period_ms: 4500.0,
            }, // REVIEW — measured
            Some(3) => CarrierProfile {
                base: 0.35,
                amp: 0.20,
                period_ms: 3500.0,
            }, // FIX — focused
            Some(4) => CarrierProfile {
                base: 0.15,
                amp: 0.05,
                period_ms: 8000.0,
            }, // MERGE — quiet automation
            Some(5) => CarrierProfile {
                base: 0.40,
                amp: 0.30,
                period_ms: 5000.0,
            }, // SAT — deliberation
            Some(6) => CarrierProfile {
                base: 0.25,
                amp: 0.10,
                period_ms: 7000.0,
            }, // LEARN — contemplative
            _ => CarrierProfile {
                base: 0.25,
                amp: 0.25,
                period_ms: 8000.0,
            }, // generic thinking
        }
    }

    /// Push a spike onto the scope trace at the rightmost sample.
    /// `intensity` is 0..=1 — different event kinds scale differently.
    fn scope_spike(&mut self, intensity: f32) {
        // Make sure the buffer has full width — pad with zeros first time.
        while self.scope_trace.len() < SCOPE_WIDTH {
            self.scope_trace.push_back(0.0);
        }
        // Bump the latest sample (rightmost) — additive so back-to-back events stack.
        if let Some(last) = self.scope_trace.back_mut() {
            *last = (*last + intensity).min(1.0);
        }
    }

    /// Advance the scope: decay all samples, shift left, append a fresh sample.
    /// Called once per render tick. The fresh sample is 0 by default — but in
    /// `Thinking` phase we inject a low-amplitude sine carrier so the operator
    /// can SEE the agent thinking (vs flatline = idle/disconnected).
    fn scope_step(&mut self) {
        if self.scope_trace.is_empty() {
            // Pre-fill the buffer once so render can downsample immediately.
            for _ in 0..SCOPE_WIDTH {
                self.scope_trace.push_back(0.0);
            }
        }
        for s in self.scope_trace.iter_mut() {
            *s *= SCOPE_DECAY;
        }
        if self.scope_trace.len() >= SCOPE_WIDTH {
            self.scope_trace.pop_front();
        }
        // Inject a thinking-carrier sample (0 in Idle/Producing, sine in Thinking).
        let carrier = self.thinking_carrier_sample();
        self.scope_trace.push_back(carrier);
    }

    /// Sine carrier — shape varies by active station so each of the 7 workflow
    /// stations has a recognizable signature on the oscilloscope:
    ///   PLAN      — slow contemplative roll
    ///   IMPLEMENT — busy mid-frequency wave (overridden by tool_use spikes)
    ///   REVIEW    — measured, slightly slower
    ///   FIX       — focused medium tempo
    ///   MERGE     — quiet, almost-flat automation
    ///   SAT       — long deliberation rolls
    ///   LEARN     — slow contemplation
    /// Returns 0.0 only when truly idle (no heartbeat, no active station).
    fn thinking_carrier_sample(&self) -> f32 {
        let phase = self.agent_phase();
        if phase == AgentPhase::Idle {
            return 0.0;
        }
        // In Producing phase, carrier still adds a baseline (event spikes
        // overshoot it). In Thinking phase, the carrier IS the signal.
        let prof = self.station_carrier_profile();
        use std::f32::consts::PI;
        let p = (self.elapsed_ms() as f32 / prof.period_ms) * 2.0 * PI;
        prof.base + prof.amp * p.sin()
    }

    /// Refresh the displayed `duration` field on each RunInfo from started_at.
    /// Called every Tick so the focused-shift / shifts-list "12m44s" counters
    /// actually count up while a shift is running.
    fn refresh_durations(&mut self) {
        let now = Utc::now();
        for run in self.runs.iter_mut().chain(self.approvals.iter_mut()) {
            let Some(started) = self.run_started_at.get(&run.id) else {
                continue;
            };
            let end = self.run_completed_at.get(&run.id).copied().unwrap_or(now);
            let secs = (end - *started).num_seconds().max(0) as u64;
            run.duration = format_short_secs(secs);
        }
    }

    /// Toggle a panel mode: pressing the same key twice returns to SatDials.
    pub fn toggle_mode(&mut self, target: PanelMode) {
        self.mode = if self.mode == target {
            PanelMode::SatDials
        } else {
            target
        };
    }

    /// Wall-clock elapsed since startup. Used for time-based animations
    /// (breathing, packet position, sparkline phase).
    pub fn elapsed_ms(&self) -> u64 {
        self.start_time.elapsed().as_millis() as u64
    }

    /// Step needle interpolation on each render frame: current += (target - current) * (1 - exp(-dt*rate)).
    /// Rate chosen so a 420ms settling time yields ~95% of target.
    /// Under reduce_motion, snaps current → target instead of interpolating.
    pub fn step_animations(&mut self) {
        let now = Instant::now();
        let dt = now.duration_since(self.last_render).as_secs_f32();
        self.last_render = now;
        if self.reduce_motion {
            for state in self.sat_scores.values_mut() {
                state.current = state.target;
            }
        } else {
            const RATE: f32 = 7.1;
            let factor = 1.0 - (-dt * RATE).exp();
            for state in self.sat_scores.values_mut() {
                state.current += (state.target - state.current) * factor;
            }
        }
        // Clear expired glitch.
        if let Some((_, expires_at)) = self.glitch
            && now >= expires_at
        {
            self.glitch = None;
        }
        // Clear expired failure dot.
        if let Some(until) = self.failure_dot_until
            && now >= until
        {
            self.failure_dot_until = None;
        }
        // Clear expired completion trail (250ms lifetime).
        if let Some(trail) = self.completion_trail
            && now.duration_since(trail.at) > std::time::Duration::from_millis(250)
        {
            self.completion_trail = None;
        }
    }

    /// Push a new event to the waterfall, dropping the oldest if at capacity.
    /// In replay mode, rewrite the ts to wall-clock now — captured timestamps
    /// can be days old and would clamp every line to max-fade. The fade-out is
    /// "age since the line appeared on the screen", not "age in the original run."
    fn push_waterfall(&mut self, mut ev: EventDisplayed) {
        if self.is_replay {
            ev.ts = Utc::now();
        }
        if self.waterfall.len() >= WATERFALL_CAP {
            self.waterfall.pop_front();
        }
        self.waterfall.push_back(ev);
    }

    /// Update focus to a given run_id, resetting per-shift state (chain + sat).
    fn refocus(&mut self, run_id: &str) {
        if self.focus_run_id.as_deref() != Some(run_id) {
            self.focus_run_id = Some(run_id.to_string());
            self.chain_state = ChainState::default();
            self.sat_scores.clear();
            self.sat_verdict = None;
            self.tool_count = 0;
            self.blueprints.clear();
            self.agent_heartbeat = None;
            self.completion_trail = None;
            self.last_tool = None;
            self.last_tool_at = None;
        }
    }

    pub fn handle_event(&mut self, event: TuiEvent) -> Option<Action> {
        match event {
            TuiEvent::Key(key) => {
                // If confirmation is active, handle y/n/esc
                if self.confirmation.is_some() {
                    return self.handle_confirmation(key);
                }
                self.handle_key(key)
            }
            TuiEvent::Tick => {
                self.tick_count += 1;
                // Roll the throughput window: commit this tick's count, reset bucket.
                if self.throughput_window.len() >= 32 {
                    self.throughput_window.pop_front();
                }
                self.throughput_window.push_back(self.events_this_tick);
                self.events_this_tick = 0;
                // Recompute live durations on each Tick (~2 Hz) so the counters
                // tick up while shifts are running.
                self.refresh_durations();
                self.status_message = format!(
                    "Tick #{} | Runs: {} | Waterfall: {} | {}",
                    self.tick_count,
                    self.runs.len(),
                    self.waterfall.len(),
                    self.event_status
                );
                None
            }
            TuiEvent::Render => None,
            TuiEvent::DaemonEvent(event) => {
                self.event_count += 1;
                self.event_status = format!("Events: {} received", self.event_count);
                self.status_message = format!("Last event: {}", event.event);
                self.handle_daemon_event(event);
                None
            }
        }
    }

    /// Handle an event pushed from the daemon. Dispatches every known RunEvent
    /// variant into typed state (waterfall, chain, sat, blueprints, tool count).
    /// See docs/stream-audit.md for the full variant catalog.
    fn handle_daemon_event(&mut self, event: DaemonEvent) {
        if event.event != "run_event" {
            return;
        }

        let data = &event.data;
        let event_type = data.get("type").and_then(|v| v.as_str()).unwrap_or("");
        let run_id = data.get("run_id").and_then(|v| v.as_str()).unwrap_or("");
        let ts = data
            .get("timestamp")
            .and_then(|v| v.as_str())
            .and_then(|s| s.parse::<DateTime<Utc>>().ok())
            .unwrap_or_else(Utc::now);

        // Count for the throughput sparkline (Phase 3.4 renders it).
        self.events_this_tick = self.events_this_tick.saturating_add(1);

        // Spike the agent oscilloscope per event kind. Intensities chosen so
        // tool_use bursts visually dominate (the "agent doing real work" signal),
        // heartbeats register as moderate pulses, and routine state changes as
        // small ticks.
        let intensity = match event_type {
            "tool_use" => 0.85,
            "agent_heartbeat" => 0.55,
            "sat_persona_score" => 0.7,
            "blueprints_injected" => 0.9,
            "artifact_added" => 0.6,
            "step_started" | "step_completed" | "step_failed" => 0.4,
            "log" => match data.get("level").and_then(|v| v.as_str()) {
                Some("error") => 1.0,
                Some("warn") => 0.7,
                _ => 0.25,
            },
            "sat_verdict" => 1.0,
            _ => 0.2,
        };
        self.scope_spike(intensity);

        match event_type {
            // ── status_changed ──
            "status_changed" => {
                let from = data.get("from").and_then(|v| v.as_str()).unwrap_or("?");
                let to = data.get("to").and_then(|v| v.as_str()).unwrap_or("?");

                // Track started_at when a shift transitions to running, completed_at
                // when it reaches a terminal state. Powers refresh_durations() in Tick.
                if to == "running" && !run_id.is_empty() {
                    self.run_started_at.entry(run_id.to_string()).or_insert(ts);
                }
                if matches!(
                    to,
                    "completed" | "failed" | "cancelled" | "merged" | "cooled"
                ) && !run_id.is_empty()
                {
                    self.run_completed_at.insert(run_id.to_string(), ts);
                    // Capture a "shift complete" callout for the waterfall when the
                    // focused shift reaches a terminal state.
                    if self.focus_run_id.as_deref() == Some(run_id) {
                        let started = self.run_started_at.get(run_id).copied();
                        let dur = match started {
                            Some(s) => (ts - s).num_seconds().max(0) as u64,
                            None => 0,
                        };
                        self.terminal_card = Some(TerminalCard {
                            run_id: run_id.to_string(),
                            final_status: to.to_string(),
                            duration_secs: dur,
                            verdict: self.sat_verdict.clone(),
                            total_events: self.waterfall.len(),
                            blueprints: self.blueprints.len(),
                            tool_count: self.tool_count,
                        });
                    }
                }

                // Legacy 6-panel state update (kept until Phase 3 rewrites panels.rs).
                if let Some(run) = self.runs.iter_mut().find(|r| r.id == run_id) {
                    run.status = to.to_string();
                } else if let Some(idx) = self.approvals.iter().position(|r| r.id == run_id) {
                    let mut info = self.approvals.remove(idx);
                    info.status = to.to_string();
                    self.runs.push(info);
                } else if !run_id.is_empty() {
                    // Pick the best-available issue label. Real status_changed events
                    // don't carry issue metadata — but synthetic captures may include
                    // it for replay fidelity. Falls back to the short run_id.
                    let issue_num = data.get("issue_number").and_then(|v| v.as_u64());
                    let issue_title = data
                        .get("issue_title")
                        .and_then(|v| v.as_str())
                        .map(|s| s.to_string());
                    let issue_label = match (issue_num, issue_title.as_deref()) {
                        (Some(n), Some(t)) => format!("#{n} {t}"),
                        (Some(n), None) => format!("#{n}"),
                        (None, Some(t)) => t.to_string(),
                        _ => format!("Run {}", &run_id[..8.min(run_id.len())]),
                    };
                    self.runs.push(RunInfo {
                        id: run_id.to_string(),
                        status: to.to_string(),
                        issue: issue_label,
                        duration: "0s".into(),
                    });
                }

                // Auto-focus the first run we see transitioning to running.
                if to == "running" && self.focus_run_id.is_none() {
                    self.refocus(run_id);
                }

                self.push_waterfall(EventDisplayed {
                    ts,
                    kind: EventKind::StateTransition,
                    text: format!("status · {from} → {to}"),
                    run_id: Some(run_id.to_string()),
                });
            }

            // ── step_started ──
            "step_started" => {
                let workflow_kind = data
                    .get("workflow_kind")
                    .and_then(|v| v.as_str())
                    .unwrap_or("");
                let workflow_name = data
                    .get("workflow_name")
                    .and_then(|v| v.as_str())
                    .unwrap_or(workflow_kind);

                if self.focus_run_id.as_deref() == Some(run_id)
                    && let Some(idx) = workflow_kind_to_station(workflow_kind)
                {
                    self.chain_state.stations[idx] = StationState::Active;
                }

                self.push_waterfall(EventDisplayed {
                    ts,
                    kind: EventKind::Routing,
                    text: format!("▸ station started · {workflow_name}"),
                    run_id: Some(run_id.to_string()),
                });
            }

            // ── step_completed ──
            "step_completed" => {
                let workflow_kind = data
                    .get("workflow_kind")
                    .and_then(|v| v.as_str())
                    .unwrap_or("");
                let workflow_name = data
                    .get("workflow_name")
                    .and_then(|v| v.as_str())
                    .unwrap_or(workflow_kind);
                let summary = data.get("summary").and_then(|v| v.as_str()).unwrap_or("");
                let duration_ms = data
                    .get("duration_ms")
                    .and_then(|v| v.as_u64())
                    .unwrap_or(0);

                if self.focus_run_id.as_deref() == Some(run_id)
                    && let Some(idx) = workflow_kind_to_station(workflow_kind)
                {
                    self.chain_state.stations[idx] = StationState::Completed;
                    self.chain_state.elapsed_ms[idx] = Some(duration_ms);
                    // Single-shot trail across the just-completed span (replaces
                    // the always-on packet animation, which was distracting).
                    self.completion_trail = Some(CompletionTrail {
                        station_idx: idx,
                        at: Instant::now(),
                    });
                    // Station transition — clear the per-station heartbeat state
                    // so the next station starts fresh.
                    self.agent_heartbeat = None;
                }

                // Cosmetic for replay mode: when learn_update finishes, its summary
                // says "N patterns extracted, M total in store". Parse the M to
                // populate `daemon_blueprint_count` since Method::Stats doesn't
                // fire when replaying. Live runs still get authoritative values
                // from Stats — this is a no-op pre-empted by the Stats fetch.
                if workflow_kind == "learn_update"
                    && let Some(total) = parse_total_in_store(summary)
                {
                    self.daemon_blueprint_count = total;
                }

                self.push_waterfall(EventDisplayed {
                    ts,
                    kind: EventKind::Success,
                    text: format!("✓ {workflow_name} · {summary}"),
                    run_id: Some(run_id.to_string()),
                });
            }

            // ── step_failed ──
            "step_failed" => {
                let workflow_kind = data
                    .get("workflow_kind")
                    .and_then(|v| v.as_str())
                    .unwrap_or("");
                let error = data.get("error").and_then(|v| v.as_str()).unwrap_or("?");

                if self.focus_run_id.as_deref() == Some(run_id)
                    && let Some(idx) = workflow_kind_to_station(workflow_kind)
                {
                    self.chain_state.stations[idx] = StationState::Failed;
                    // Trigger 120ms glitch on the failed station (Phase 4.6).
                    // Skipped under reduce_motion.
                    if !self.reduce_motion {
                        self.glitch =
                            Some((idx, Instant::now() + std::time::Duration::from_millis(120)));
                    }
                    // Phase 7.5: 5s transient red dot in the header.
                    self.failure_dot_until =
                        Some(Instant::now() + std::time::Duration::from_secs(5));
                }

                self.push_waterfall(EventDisplayed {
                    ts,
                    kind: EventKind::Error,
                    text: format!("✖ {workflow_kind} cooled · {error}"),
                    run_id: Some(run_id.to_string()),
                });
            }

            // ── contract_violation ──
            "contract_violation" => {
                let workflow_kind = data
                    .get("workflow_kind")
                    .and_then(|v| v.as_str())
                    .unwrap_or("");
                let error = data.get("error").and_then(|v| v.as_str()).unwrap_or("?");

                self.push_waterfall(EventDisplayed {
                    ts,
                    kind: EventKind::Error,
                    text: format!("✖ contract violation · {workflow_kind} · {error}"),
                    run_id: Some(run_id.to_string()),
                });
            }

            // ── agent_heartbeat ──
            "agent_heartbeat" => {
                let elapsed = data
                    .get("elapsed_secs")
                    .and_then(|v| v.as_u64())
                    .unwrap_or(0);
                let chars = data
                    .get("output_chars")
                    .and_then(|v| v.as_u64())
                    .unwrap_or(0);

                // Update live thinking state for the focused shift — feeds the
                // active station tile + footer status (waiting-invisibility fix).
                if self.focus_run_id.as_deref() == Some(run_id) {
                    let now = Instant::now();
                    let prev = self.agent_heartbeat.as_ref();
                    let (prev_chars, prev_at) = match prev {
                        Some(s) => (s.output_chars, s.last_frame_at),
                        None => (chars, now),
                    };
                    self.agent_heartbeat = Some(AgentHeartbeatState {
                        elapsed_secs: elapsed,
                        output_chars: chars,
                        last_frame_at: now,
                        prev_output_chars: prev_chars,
                        prev_frame_at: prev_at,
                    });
                }

                self.push_waterfall(EventDisplayed {
                    ts,
                    kind: EventKind::Heartbeat,
                    text: format!("▸ heartbeat · {elapsed}s · {chars} chars"),
                    run_id: Some(run_id.to_string()),
                });
            }

            // ── log ──
            "log" => {
                let level = data.get("level").and_then(|v| v.as_str()).unwrap_or("info");
                let message = data.get("message").and_then(|v| v.as_str()).unwrap_or("");

                let kind = match level {
                    "error" => EventKind::Error,
                    "warn" | "warning" => EventKind::Warning,
                    _ => EventKind::StateTransition,
                };
                let glyph = match level {
                    "error" => "✖",
                    "warn" | "warning" => "⚠",
                    _ => "▸",
                };

                self.push_waterfall(EventDisplayed {
                    ts,
                    kind,
                    text: format!("{glyph} {message}"),
                    run_id: Some(run_id.to_string()),
                });
            }

            // ── artifact_added ──
            "artifact_added" => {
                let artifact_kind = data.get("kind").and_then(|v| v.as_str()).unwrap_or("?");

                self.push_waterfall(EventDisplayed {
                    ts,
                    kind: EventKind::Artifact,
                    text: format!("▲ artifact · {artifact_kind}"),
                    run_id: Some(run_id.to_string()),
                });
            }

            // ── approval_recorded ──
            "approval_recorded" => {
                let decision = data.get("decision").and_then(|v| v.as_str()).unwrap_or("?");

                // Legacy panel state.
                if let Some(idx) = self.approvals.iter().position(|r| r.id == run_id) {
                    let mut info = self.approvals.remove(idx);
                    info.status = "running".into();
                    self.runs.push(info);
                }

                self.push_waterfall(EventDisplayed {
                    ts,
                    kind: EventKind::Routing,
                    text: format!("↺ approval · {decision}"),
                    run_id: Some(run_id.to_string()),
                });
            }

            // ── tool_use (Phase 5.1/5.2) ──
            "tool_use" => {
                let title = data.get("title").and_then(|v| v.as_str()).unwrap_or("");
                let kind = data.get("kind").and_then(|v| v.as_str()).unwrap_or("");

                if self.focus_run_id.as_deref() == Some(run_id) {
                    self.tool_count = self.tool_count.saturating_add(1);
                    // Capture for the live-action line in chain topology.
                    self.last_tool = Some(if !title.is_empty() {
                        title.to_string()
                    } else {
                        kind.to_string()
                    });
                    self.last_tool_at = Some(Instant::now());
                }

                self.push_waterfall(EventDisplayed {
                    ts,
                    kind: EventKind::ToolUse,
                    text: format!("⚡ tool_use · {kind} · {title}"),
                    run_id: Some(run_id.to_string()),
                });
            }

            // ── blueprints_injected (Phase 5.4/5.5) ──
            "blueprints_injected" => {
                let matches = data
                    .get("matches")
                    .and_then(|v| v.as_array())
                    .cloned()
                    .unwrap_or_default();

                // Hydrate App.blueprints state for the [b] toggle panel.
                if self.focus_run_id.as_deref() == Some(run_id) {
                    self.blueprints.clear();
                    for m in &matches {
                        if let (Some(rid), Some(util), Some(sim)) = (
                            m.get("run_id").and_then(|v| v.as_str()),
                            m.get("utility_name").and_then(|v| v.as_str()),
                            m.get("similarity").and_then(|v| v.as_f64()),
                        ) {
                            let kind_str =
                                m.get("kind").and_then(|v| v.as_str()).unwrap_or("reuse");
                            let bk = if kind_str == "avoid" {
                                BlueprintKind::Avoid
                            } else {
                                BlueprintKind::Reuse
                            };
                            self.blueprints.push(BlueprintMatch {
                                run_id: rid.into(),
                                utility_name: util.into(),
                                similarity: sim as f32,
                                kind: bk,
                            });
                        }
                    }
                }

                let top = matches
                    .iter()
                    .filter_map(|m| m.get("similarity").and_then(|v| v.as_f64()))
                    .fold(0.0_f64, f64::max);

                self.push_waterfall(EventDisplayed {
                    ts,
                    kind: EventKind::BlueprintsInjected,
                    text: format!(
                        "▼ blueprints injected · top {:.2} · {} matches",
                        top,
                        matches.len()
                    ),
                    run_id: Some(run_id.to_string()),
                });
            }

            // ── sat_started ──
            "sat_started" => {
                let parent = data
                    .get("parent_run_id")
                    .and_then(|v| v.as_str())
                    .unwrap_or("?");

                self.sat_verdict = Some("… judging".into());
                self.push_waterfall(EventDisplayed {
                    ts,
                    kind: EventKind::SessionUpdate,
                    text: format!("◆ sat started · parent {}", &parent[..8.min(parent.len())]),
                    run_id: Some(run_id.to_string()),
                });
            }

            // ── sat_persona_score ──
            "sat_persona_score" => {
                let persona = data
                    .get("persona")
                    .and_then(|v| v.as_str())
                    .unwrap_or("?")
                    .to_lowercase();
                let score = data.get("score").and_then(|v| v.as_f64()).unwrap_or(0.0) as f32;

                let entry = self.sat_scores.entry(persona.clone()).or_default();
                entry.target = score;
                entry.last_updated = Some(ts);
                // current will animate toward target via step_animations.

                // Phase 6.3: auto-return to SatDials when judging is happening.
                // Blueprints / other modes lose priority while scores are being recorded.
                if self.mode == PanelMode::Blueprints {
                    self.mode = PanelMode::SatDials;
                }

                self.push_waterfall(EventDisplayed {
                    ts,
                    kind: EventKind::SessionUpdate,
                    text: format!("◆ sat_persona · {persona} · score {score:.1}"),
                    run_id: Some(run_id.to_string()),
                });
            }

            // ── sat_verdict ──
            "sat_verdict" => {
                let verdict = data
                    .get("verdict")
                    .and_then(|v| v.as_str())
                    .unwrap_or("?")
                    .to_string();

                self.sat_verdict = Some(verdict.clone());

                let kind = if verdict.to_uppercase().contains("PASS") {
                    EventKind::Success
                } else {
                    EventKind::Error
                };
                let glyph = if verdict.to_uppercase().contains("PASS") {
                    "✓"
                } else {
                    "✖"
                };

                self.push_waterfall(EventDisplayed {
                    ts,
                    kind,
                    text: format!("{glyph} sat verdict · {verdict}"),
                    run_id: Some(run_id.to_string()),
                });
            }

            _ => {
                // Unknown variant — surface as a raw line so we notice schema drift.
                self.push_waterfall(EventDisplayed {
                    ts,
                    kind: EventKind::StateTransition,
                    text: format!("? unknown · {event_type}"),
                    run_id: Some(run_id.to_string()),
                });
            }
        }
    }

    fn handle_confirmation(&mut self, key: KeyEvent) -> Option<Action> {
        match key.code {
            KeyCode::Char('y') | KeyCode::Char('Y') => {
                let conf = self.confirmation.take().unwrap();
                match conf.action {
                    Action::ApproveRun(id) => Some(Action::ApproveRun(id)),
                    Action::TriggerNext => Some(Action::TriggerNext),
                    Action::Quit => Some(Action::Quit),
                }
            }
            KeyCode::Char('n') | KeyCode::Char('N') | KeyCode::Esc => {
                self.confirmation = None;
                None
            }
            _ => None,
        }
    }

    fn handle_key(&mut self, key: KeyEvent) -> Option<Action> {
        // Ctrl+C always quits
        if key.modifiers.contains(KeyModifiers::CONTROL) && key.code == KeyCode::Char('c') {
            return Some(Action::Quit);
        }

        match key.code {
            KeyCode::Char('q') => Some(Action::Quit),
            KeyCode::Char('?') => {
                self.show_help = !self.show_help;
                None
            }
            KeyCode::Esc if self.show_help => {
                self.show_help = false;
                None
            }
            // ── Phase 6 mode toggles ──
            KeyCode::Char('s') => {
                self.toggle_mode(PanelMode::Shifts);
                None
            }
            KeyCode::Char('b') => {
                self.toggle_mode(PanelMode::Blueprints);
                None
            }
            KeyCode::Char('k') => {
                self.toggle_mode(PanelMode::Backlog);
                None
            }
            KeyCode::Char('j') => {
                self.toggle_mode(PanelMode::Judges);
                None
            }
            KeyCode::Char('d') => {
                // Force back to dials regardless of current mode.
                self.mode = PanelMode::SatDials;
                None
            }
            KeyCode::Char('f') => {
                self.waterfall_filter = self.waterfall_filter.next();
                None
            }
            KeyCode::Enter => {
                // Approve focused shift if it's awaiting approval.
                if let Some(rid) = &self.focus_run_id
                    && self.approvals.iter().any(|r| r.id == *rid)
                {
                    return Some(Action::ApproveRun(rid.clone()));
                }
                None
            }
            KeyCode::Tab => {
                self.focused = self.focused.next();
                None
            }
            KeyCode::BackTab => {
                self.focused = self.focused.prev();
                None
            }
            KeyCode::Up => {
                self.move_selection(-1);
                None
            }
            KeyCode::Down => {
                self.move_selection(1);
                None
            }
            KeyCode::Esc => {
                self.deselect();
                None
            }
            KeyCode::Char('a') if self.focused == Panel::Approvals => {
                if let Some(idx) = self.approvals_state.selected()
                    && let Some(run) = self.approvals.get(idx)
                {
                    self.confirmation = Some(Confirmation {
                        action: Action::ApproveRun(run.id.clone()),
                        prompt: format!("Approve run {}? [y/n]", &run.id[..8.min(run.id.len())]),
                    });
                }
                None
            }
            KeyCode::Char('n') => {
                self.confirmation = Some(Confirmation {
                    action: Action::TriggerNext,
                    prompt: "Trigger next action? [y/n]".into(),
                });
                None
            }
            _ => None,
        }
    }

    fn move_selection(&mut self, delta: i32) {
        match self.focused {
            Panel::Runs => {
                if self.runs.is_empty() {
                    return;
                }
                let current = self.runs_state.selected().unwrap_or(0) as i32;
                let next = (current + delta).clamp(0, self.runs.len() as i32 - 1) as usize;
                self.runs_state.select(Some(next));
            }
            Panel::Approvals => {
                if self.approvals.is_empty() {
                    return;
                }
                let current = self.approvals_state.selected().unwrap_or(0) as i32;
                let next = (current + delta).clamp(0, self.approvals.len() as i32 - 1) as usize;
                self.approvals_state.select(Some(next));
            }
            _ => {}
        }
    }

    fn deselect(&mut self) {
        match self.focused {
            Panel::Runs => self.runs_state.select(None),
            Panel::Approvals => self.approvals_state.select(None),
            _ => {}
        }
    }

    /// Update all panel data from a list of runs.
    pub fn update_from_runs(&mut self, runs: Vec<Run>) {
        self.runs.clear();
        self.approvals.clear();

        for run in &runs {
            let issue = match (&run.issue_number, &run.issue_title) {
                (Some(num), Some(title)) => format!("#{} \u{2014} {}", num, title),
                (Some(num), None) => format!("#{}", num),
                _ => "-".into(),
            };
            // Capture timestamps so refresh_durations() can live-tick this row.
            if let Some(t) = run.started_at {
                self.run_started_at.entry(run.id.clone()).or_insert(t);
            }
            if let Some(t) = run.completed_at {
                self.run_completed_at.insert(run.id.clone(), t);
            }
            let duration = format_duration(run.started_at, run.completed_at);
            let info = RunInfo {
                id: run.id.clone(),
                status: run.status.to_string(),
                issue,
                duration,
            };

            match run.status {
                RunStatus::AwaitingApproval => self.approvals.push(info),
                _ => self.runs.push(info),
            }
        }

        // Keep selection in bounds
        if !self.runs.is_empty() && self.runs_state.selected().is_none() {
            self.runs_state.select(Some(0));
        }
        if !self.approvals.is_empty() && self.approvals_state.selected().is_none() {
            self.approvals_state.select(Some(0));
        }
    }

    pub fn render(&mut self, frame: &mut Frame) {
        // Step time-based animations before drawing.
        self.step_animations();
        // Advance the agent oscilloscope one sample.
        self.scope_step();
        crate::tui::panels::render_all(frame, self);
    }
}

fn format_duration(start: Option<DateTime<Utc>>, end: Option<DateTime<Utc>>) -> String {
    let start = match start {
        Some(s) => s,
        None => return "-".into(),
    };
    let end = end.unwrap_or_else(Utc::now);
    let secs = (end - start).num_seconds().max(0) as u64;
    format_short_secs(secs)
}

/// Parse "5 patterns extracted, 1248 total in store" → Some(1248).
/// Returns None if the pattern doesn't match — best-effort cosmetic helper.
fn parse_total_in_store(summary: &str) -> Option<u64> {
    let after = summary.split(',').nth(1)?.trim();
    // Expect "<N> total in store"
    let n_str = after.split_whitespace().next()?;
    n_str.parse::<u64>().ok()
}

/// Format a non-negative duration into the compact "Ns / Nm:SSs / NhMMm" form
/// the chain topology and shifts list use (`6s`, `8m22s`, `1h05m`).
fn format_short_secs(secs: u64) -> String {
    if secs < 60 {
        format!("{secs}s")
    } else if secs < 3600 {
        format!("{}m{:02}s", secs / 60, secs % 60)
    } else {
        format!("{}h{:02}m", secs / 3600, (secs % 3600) / 60)
    }
}