feat(ecc2): implement agent status panel with Table widget (#773)

- Table widget with columns: ID, Agent, State, Branch, Tokens, Duration
- Color-coded states: green=Running, yellow=Idle, red=Failed, gray=Stopped, blue=Completed
- Summary bar with running/completed/failed counts
- Row selection highlighting

.gitignore

@@ -83,6 +83,9 @@ temp/
 *.bak
 *.backup
 
+# Rust build artifacts
+ecc2/target/
+
 # Bootstrap pipeline outputs
 # Generated lock files in tool subdirectories
 .opencode/package-lock.json

ecc2/Cargo.toml

@@ -0,0 +1,52 @@
+[package]
+name = "ecc-tui"
+version = "0.1.0"
+edition = "2021"
+description = "ECC 2.0 — Agentic IDE control plane with TUI dashboard"
+license = "MIT"
+authors = ["Affaan Mustafa <me@affaanmustafa.com>"]
+repository = "https://github.com/affaan-m/everything-claude-code"
+
+[dependencies]
+# TUI
+ratatui = "0.29"
+crossterm = "0.28"
+
+# Async runtime
+tokio = { version = "1", features = ["full"] }
+
+# State store
+rusqlite = { version = "0.32", features = ["bundled"] }
+
+# Git integration
+git2 = "0.19"
+
+# Serialization
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+toml = "0.8"
+
+# CLI
+clap = { version = "4", features = ["derive"] }
+
+# Logging & tracing
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+
+# Error handling
+anyhow = "1"
+thiserror = "2"
+
+# Time
+chrono = { version = "0.4", features = ["serde"] }
+
+# UUID for session IDs
+uuid = { version = "1", features = ["v4"] }
+
+# Directory paths
+dirs = "6"
+
+[profile.release]
+lto = true
+codegen-units = 1
+strip = true

ecc2/src/comms/mod.rs

@@ -0,0 +1,36 @@
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+
+use crate::session::store::StateStore;
+
+/// Message types for inter-agent communication.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum MessageType {
+    /// Task handoff from one agent to another
+    TaskHandoff { task: String, context: String },
+    /// Agent requesting information from another
+    Query { question: String },
+    /// Response to a query
+    Response { answer: String },
+    /// Notification of completion
+    Completed {
+        summary: String,
+        files_changed: Vec<String>,
+    },
+    /// Conflict detected (e.g., two agents editing the same file)
+    Conflict { file: String, description: String },
+}
+
+/// Send a structured message between sessions.
+pub fn send(db: &StateStore, from: &str, to: &str, msg: &MessageType) -> Result<()> {
+    let content = serde_json::to_string(msg)?;
+    let msg_type = match msg {
+        MessageType::TaskHandoff { .. } => "task_handoff",
+        MessageType::Query { .. } => "query",
+        MessageType::Response { .. } => "response",
+        MessageType::Completed { .. } => "completed",
+        MessageType::Conflict { .. } => "conflict",
+    };
+    db.send_message(from, to, &content, msg_type)?;
+    Ok(())
+}

ecc2/src/config/mod.rs

@@ -0,0 +1,54 @@
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Config {
+    pub db_path: PathBuf,
+    pub worktree_root: PathBuf,
+    pub max_parallel_sessions: usize,
+    pub max_parallel_worktrees: usize,
+    pub session_timeout_secs: u64,
+    pub heartbeat_interval_secs: u64,
+    pub default_agent: String,
+    pub theme: Theme,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum Theme {
+    Dark,
+    Light,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        let home = dirs::home_dir().unwrap_or_else(|| PathBuf::from("."));
+        Self {
+            db_path: home.join(".claude").join("ecc2.db"),
+            worktree_root: PathBuf::from("/tmp/ecc-worktrees"),
+            max_parallel_sessions: 8,
+            max_parallel_worktrees: 6,
+            session_timeout_secs: 3600,
+            heartbeat_interval_secs: 30,
+            default_agent: "claude".to_string(),
+            theme: Theme::Dark,
+        }
+    }
+}
+
+impl Config {
+    pub fn load() -> Result<Self> {
+        let config_path = dirs::home_dir()
+            .unwrap_or_else(|| PathBuf::from("."))
+            .join(".claude")
+            .join("ecc2.toml");
+
+        if config_path.exists() {
+            let content = std::fs::read_to_string(&config_path)?;
+            let config: Config = toml::from_str(&content)?;
+            Ok(config)
+        } else {
+            Ok(Config::default())
+        }
+    }
+}

ecc2/src/main.rs

@@ -0,0 +1,97 @@
+mod comms;
+mod config;
+mod observability;
+mod session;
+mod tui;
+mod worktree;
+
+use anyhow::Result;
+use clap::Parser;
+use tracing_subscriber::EnvFilter;
+
+#[derive(Parser, Debug)]
+#[command(name = "ecc", version, about = "ECC 2.0 — Agentic IDE control plane")]
+struct Cli {
+    #[command(subcommand)]
+    command: Option<Commands>,
+}
+
+#[derive(clap::Subcommand, Debug)]
+enum Commands {
+    /// Launch the TUI dashboard
+    Dashboard,
+    /// Start a new agent session
+    Start {
+        /// Task description for the agent
+        #[arg(short, long)]
+        task: String,
+        /// Agent type (claude, codex, custom)
+        #[arg(short, long, default_value = "claude")]
+        agent: String,
+        /// Create a dedicated worktree for this session
+        #[arg(short, long)]
+        worktree: bool,
+    },
+    /// List active sessions
+    Sessions,
+    /// Show session details
+    Status {
+        /// Session ID or alias
+        session_id: Option<String>,
+    },
+    /// Stop a running session
+    Stop {
+        /// Session ID or alias
+        session_id: String,
+    },
+    /// Run as background daemon
+    Daemon,
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .init();
+
+    let cli = Cli::parse();
+
+    let cfg = config::Config::load()?;
+    let db = session::store::StateStore::open(&cfg.db_path)?;
+
+    match cli.command {
+        Some(Commands::Dashboard) | None => {
+            tui::app::run(db, cfg).await?;
+        }
+        Some(Commands::Start {
+            task,
+            agent,
+            worktree: use_worktree,
+        }) => {
+            let session_id =
+                session::manager::create_session(&db, &cfg, &task, &agent, use_worktree).await?;
+            println!("Session started: {session_id}");
+        }
+        Some(Commands::Sessions) => {
+            let sessions = session::manager::list_sessions(&db)?;
+            for s in sessions {
+                println!("{} [{}] {}", s.id, s.state, s.task);
+            }
+        }
+        Some(Commands::Status { session_id }) => {
+            let id = session_id.unwrap_or_else(|| "latest".to_string());
+            let status = session::manager::get_status(&db, &id)?;
+            println!("{status}");
+        }
+        Some(Commands::Stop { session_id }) => {
+            session::manager::stop_session(&db, &session_id).await?;
+            println!("Session stopped: {session_id}");
+        }
+        Some(Commands::Daemon) => {
+            println!("Starting ECC daemon...");
+            session::daemon::run(db, cfg).await?;
+        }
+    }
+
+    Ok(())
+}

ecc2/src/observability/mod.rs

@@ -0,0 +1,54 @@
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+
+use crate::session::store::StateStore;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolCallEvent {
+    pub session_id: String,
+    pub tool_name: String,
+    pub input_summary: String,
+    pub output_summary: String,
+    pub duration_ms: u64,
+    pub risk_score: f64,
+}
+
+impl ToolCallEvent {
+    /// Compute risk score based on tool type and input patterns.
+    pub fn compute_risk(tool_name: &str, input: &str) -> f64 {
+        let mut score: f64 = 0.0;
+
+        // Destructive tools get higher base risk
+        match tool_name {
+            "Bash" => score += 0.3,
+            "Write" => score += 0.2,
+            "Edit" => score += 0.1,
+            _ => score += 0.05,
+        }
+
+        // Dangerous patterns in bash commands
+        if tool_name == "Bash" {
+            if input.contains("rm -rf") || input.contains("--force") {
+                score += 0.4;
+            }
+            if input.contains("git push") || input.contains("git reset") {
+                score += 0.3;
+            }
+            if input.contains("sudo") || input.contains("chmod 777") {
+                score += 0.5;
+            }
+        }
+
+        score.min(1.0)
+    }
+}
+
+pub fn log_tool_call(db: &StateStore, event: &ToolCallEvent) -> Result<()> {
+    db.send_message(
+        &event.session_id,
+        "observability",
+        &serde_json::to_string(event)?,
+        "tool_call",
+    )?;
+    Ok(())
+}

ecc2/src/session/daemon.rs

@@ -0,0 +1,46 @@
+use anyhow::Result;
+use std::time::Duration;
+use tokio::time;
+
+use super::store::StateStore;
+use super::SessionState;
+use crate::config::Config;
+
+/// Background daemon that monitors sessions, handles heartbeats,
+/// and cleans up stale resources.
+pub async fn run(db: StateStore, cfg: Config) -> Result<()> {
+    tracing::info!("ECC daemon started");
+
+    let heartbeat_interval = Duration::from_secs(cfg.heartbeat_interval_secs);
+    let timeout = Duration::from_secs(cfg.session_timeout_secs);
+
+    loop {
+        if let Err(e) = check_sessions(&db, timeout) {
+            tracing::error!("Session check failed: {e}");
+        }
+
+        time::sleep(heartbeat_interval).await;
+    }
+}
+
+fn check_sessions(db: &StateStore, timeout: Duration) -> Result<()> {
+    let sessions = db.list_sessions()?;
+
+    for session in sessions {
+        if session.state != SessionState::Running {
+            continue;
+        }
+
+        let elapsed = chrono::Utc::now()
+            .signed_duration_since(session.updated_at)
+            .to_std()
+            .unwrap_or(Duration::ZERO);
+
+        if elapsed > timeout {
+            tracing::warn!("Session {} timed out after {:?}", session.id, elapsed);
+            db.update_state(&session.id, &SessionState::Failed)?;
+        }
+    }
+
+    Ok(())
+}

ecc2/src/session/manager.rs

@@ -0,0 +1,76 @@
+use anyhow::Result;
+use std::fmt;
+
+use super::store::StateStore;
+use super::{Session, SessionMetrics, SessionState};
+use crate::config::Config;
+use crate::worktree;
+
+pub async fn create_session(
+    db: &StateStore,
+    cfg: &Config,
+    task: &str,
+    agent_type: &str,
+    use_worktree: bool,
+) -> Result<String> {
+    let id = uuid::Uuid::new_v4().to_string()[..8].to_string();
+    let now = chrono::Utc::now();
+
+    let wt = if use_worktree {
+        Some(worktree::create_for_session(&id, cfg)?)
+    } else {
+        None
+    };
+
+    let session = Session {
+        id: id.clone(),
+        task: task.to_string(),
+        agent_type: agent_type.to_string(),
+        state: SessionState::Pending,
+        worktree: wt,
+        created_at: now,
+        updated_at: now,
+        metrics: SessionMetrics::default(),
+    };
+
+    db.insert_session(&session)?;
+    Ok(id)
+}
+
+pub fn list_sessions(db: &StateStore) -> Result<Vec<Session>> {
+    db.list_sessions()
+}
+
+pub fn get_status(db: &StateStore, id: &str) -> Result<SessionStatus> {
+    let session = db
+        .get_session(id)?
+        .ok_or_else(|| anyhow::anyhow!("Session not found: {id}"))?;
+    Ok(SessionStatus(session))
+}
+
+pub async fn stop_session(db: &StateStore, id: &str) -> Result<()> {
+    db.update_state(id, &SessionState::Stopped)?;
+    Ok(())
+}
+
+pub struct SessionStatus(Session);
+
+impl fmt::Display for SessionStatus {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let s = &self.0;
+        writeln!(f, "Session: {}", s.id)?;
+        writeln!(f, "Task:    {}", s.task)?;
+        writeln!(f, "Agent:   {}", s.agent_type)?;
+        writeln!(f, "State:   {}", s.state)?;
+        if let Some(ref wt) = s.worktree {
+            writeln!(f, "Branch:  {}", wt.branch)?;
+            writeln!(f, "Worktree: {}", wt.path.display())?;
+        }
+        writeln!(f, "Tokens:  {}", s.metrics.tokens_used)?;
+        writeln!(f, "Tools:   {}", s.metrics.tool_calls)?;
+        writeln!(f, "Files:   {}", s.metrics.files_changed)?;
+        writeln!(f, "Cost:    ${:.4}", s.metrics.cost_usd)?;
+        writeln!(f, "Created: {}", s.created_at)?;
+        write!(f, "Updated: {}", s.updated_at)
+    }
+}

ecc2/src/session/mod.rs

@@ -0,0 +1,59 @@
+pub mod daemon;
+pub mod manager;
+pub mod store;
+
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use std::fmt;
+use std::path::PathBuf;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Session {
+    pub id: String,
+    pub task: String,
+    pub agent_type: String,
+    pub state: SessionState,
+    pub worktree: Option<WorktreeInfo>,
+    pub created_at: DateTime<Utc>,
+    pub updated_at: DateTime<Utc>,
+    pub metrics: SessionMetrics,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum SessionState {
+    Pending,
+    Running,
+    Idle,
+    Completed,
+    Failed,
+    Stopped,
+}
+
+impl fmt::Display for SessionState {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            SessionState::Pending => write!(f, "pending"),
+            SessionState::Running => write!(f, "running"),
+            SessionState::Idle => write!(f, "idle"),
+            SessionState::Completed => write!(f, "completed"),
+            SessionState::Failed => write!(f, "failed"),
+            SessionState::Stopped => write!(f, "stopped"),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct WorktreeInfo {
+    pub path: PathBuf,
+    pub branch: String,
+    pub base_branch: String,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct SessionMetrics {
+    pub tokens_used: u64,
+    pub tool_calls: u64,
+    pub files_changed: u32,
+    pub duration_secs: u64,
+    pub cost_usd: f64,
+}

ecc2/src/session/store.rs

@@ -0,0 +1,186 @@
+use anyhow::Result;
+use rusqlite::Connection;
+use std::path::Path;
+
+use super::{Session, SessionMetrics, SessionState};
+
+pub struct StateStore {
+    conn: Connection,
+}
+
+impl StateStore {
+    pub fn open(path: &Path) -> Result<Self> {
+        let conn = Connection::open(path)?;
+        let store = Self { conn };
+        store.init_schema()?;
+        Ok(store)
+    }
+
+    fn init_schema(&self) -> Result<()> {
+        self.conn.execute_batch(
+            "
+            CREATE TABLE IF NOT EXISTS sessions (
+                id TEXT PRIMARY KEY,
+                task TEXT NOT NULL,
+                agent_type TEXT NOT NULL,
+                state TEXT NOT NULL DEFAULT 'pending',
+                worktree_path TEXT,
+                worktree_branch TEXT,
+                worktree_base TEXT,
+                tokens_used INTEGER DEFAULT 0,
+                tool_calls INTEGER DEFAULT 0,
+                files_changed INTEGER DEFAULT 0,
+                duration_secs INTEGER DEFAULT 0,
+                cost_usd REAL DEFAULT 0.0,
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL
+            );
+
+            CREATE TABLE IF NOT EXISTS tool_log (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                session_id TEXT NOT NULL REFERENCES sessions(id),
+                tool_name TEXT NOT NULL,
+                input_summary TEXT,
+                output_summary TEXT,
+                duration_ms INTEGER,
+                risk_score REAL DEFAULT 0.0,
+                timestamp TEXT NOT NULL
+            );
+
+            CREATE TABLE IF NOT EXISTS messages (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                from_session TEXT NOT NULL,
+                to_session TEXT NOT NULL,
+                content TEXT NOT NULL,
+                msg_type TEXT NOT NULL DEFAULT 'info',
+                read INTEGER DEFAULT 0,
+                timestamp TEXT NOT NULL
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_sessions_state ON sessions(state);
+            CREATE INDEX IF NOT EXISTS idx_tool_log_session ON tool_log(session_id);
+            CREATE INDEX IF NOT EXISTS idx_messages_to ON messages(to_session, read);
+            ",
+        )?;
+        Ok(())
+    }
+
+    pub fn insert_session(&self, session: &Session) -> Result<()> {
+        self.conn.execute(
+            "INSERT INTO sessions (id, task, agent_type, state, worktree_path, worktree_branch, worktree_base, created_at, updated_at)
+             VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)",
+            rusqlite::params![
+                session.id,
+                session.task,
+                session.agent_type,
+                session.state.to_string(),
+                session.worktree.as_ref().map(|w| w.path.to_string_lossy().to_string()),
+                session.worktree.as_ref().map(|w| w.branch.clone()),
+                session.worktree.as_ref().map(|w| w.base_branch.clone()),
+                session.created_at.to_rfc3339(),
+                session.updated_at.to_rfc3339(),
+            ],
+        )?;
+        Ok(())
+    }
+
+    pub fn update_state(&self, session_id: &str, state: &SessionState) -> Result<()> {
+        self.conn.execute(
+            "UPDATE sessions SET state = ?1, updated_at = ?2 WHERE id = ?3",
+            rusqlite::params![
+                state.to_string(),
+                chrono::Utc::now().to_rfc3339(),
+                session_id,
+            ],
+        )?;
+        Ok(())
+    }
+
+    pub fn update_metrics(&self, session_id: &str, metrics: &SessionMetrics) -> Result<()> {
+        self.conn.execute(
+            "UPDATE sessions SET tokens_used = ?1, tool_calls = ?2, files_changed = ?3, duration_secs = ?4, cost_usd = ?5, updated_at = ?6 WHERE id = ?7",
+            rusqlite::params![
+                metrics.tokens_used,
+                metrics.tool_calls,
+                metrics.files_changed,
+                metrics.duration_secs,
+                metrics.cost_usd,
+                chrono::Utc::now().to_rfc3339(),
+                session_id,
+            ],
+        )?;
+        Ok(())
+    }
+
+    pub fn list_sessions(&self) -> Result<Vec<Session>> {
+        let mut stmt = self.conn.prepare(
+            "SELECT id, task, agent_type, state, worktree_path, worktree_branch, worktree_base,
+                    tokens_used, tool_calls, files_changed, duration_secs, cost_usd,
+                    created_at, updated_at
+             FROM sessions ORDER BY updated_at DESC",
+        )?;
+
+        let sessions = stmt
+            .query_map([], |row| {
+                let state_str: String = row.get(3)?;
+                let state = match state_str.as_str() {
+                    "running" => SessionState::Running,
+                    "idle" => SessionState::Idle,
+                    "completed" => SessionState::Completed,
+                    "failed" => SessionState::Failed,
+                    "stopped" => SessionState::Stopped,
+                    _ => SessionState::Pending,
+                };
+
+                let worktree_path: Option<String> = row.get(4)?;
+                let worktree = worktree_path.map(|p| super::WorktreeInfo {
+                    path: std::path::PathBuf::from(p),
+                    branch: row.get::<_, String>(5).unwrap_or_default(),
+                    base_branch: row.get::<_, String>(6).unwrap_or_default(),
+                });
+
+                let created_str: String = row.get(12)?;
+                let updated_str: String = row.get(13)?;
+
+                Ok(Session {
+                    id: row.get(0)?,
+                    task: row.get(1)?,
+                    agent_type: row.get(2)?,
+                    state,
+                    worktree,
+                    created_at: chrono::DateTime::parse_from_rfc3339(&created_str)
+                        .unwrap_or_default()
+                        .with_timezone(&chrono::Utc),
+                    updated_at: chrono::DateTime::parse_from_rfc3339(&updated_str)
+                        .unwrap_or_default()
+                        .with_timezone(&chrono::Utc),
+                    metrics: SessionMetrics {
+                        tokens_used: row.get(7)?,
+                        tool_calls: row.get(8)?,
+                        files_changed: row.get(9)?,
+                        duration_secs: row.get(10)?,
+                        cost_usd: row.get(11)?,
+                    },
+                })
+            })?
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok(sessions)
+    }
+
+    pub fn get_session(&self, id: &str) -> Result<Option<Session>> {
+        let sessions = self.list_sessions()?;
+        Ok(sessions
+            .into_iter()
+            .find(|s| s.id == id || s.id.starts_with(id)))
+    }
+
+    pub fn send_message(&self, from: &str, to: &str, content: &str, msg_type: &str) -> Result<()> {
+        self.conn.execute(
+            "INSERT INTO messages (from_session, to_session, content, msg_type, timestamp)
+             VALUES (?1, ?2, ?3, ?4, ?5)",
+            rusqlite::params![from, to, content, msg_type, chrono::Utc::now().to_rfc3339()],
+        )?;
+        Ok(())
+    }
+}

ecc2/src/tui/app.rs

@@ -0,0 +1,52 @@
+use anyhow::Result;
+use crossterm::{
+    event::{self, Event, KeyCode, KeyModifiers},
+    execute,
+    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
+};
+use ratatui::prelude::*;
+use std::io;
+use std::time::Duration;
+
+use super::dashboard::Dashboard;
+use crate::config::Config;
+use crate::session::store::StateStore;
+
+pub async fn run(db: StateStore, cfg: Config) -> Result<()> {
+    enable_raw_mode()?;
+    let mut stdout = io::stdout();
+    execute!(stdout, EnterAlternateScreen)?;
+
+    let backend = CrosstermBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+
+    let mut dashboard = Dashboard::new(db, cfg);
+
+    loop {
+        terminal.draw(|frame| dashboard.render(frame))?;
+
+        if event::poll(Duration::from_millis(250))? {
+            if let Event::Key(key) = event::read()? {
+                match (key.modifiers, key.code) {
+                    (KeyModifiers::CONTROL, KeyCode::Char('c')) => break,
+                    (_, KeyCode::Char('q')) => break,
+                    (_, KeyCode::Tab) => dashboard.next_pane(),
+                    (KeyModifiers::SHIFT, KeyCode::BackTab) => dashboard.prev_pane(),
+                    (_, KeyCode::Char('j')) | (_, KeyCode::Down) => dashboard.scroll_down(),
+                    (_, KeyCode::Char('k')) | (_, KeyCode::Up) => dashboard.scroll_up(),
+                    (_, KeyCode::Char('n')) => dashboard.new_session(),
+                    (_, KeyCode::Char('s')) => dashboard.stop_selected(),
+                    (_, KeyCode::Char('r')) => dashboard.refresh(),
+                    (_, KeyCode::Char('?')) => dashboard.toggle_help(),
+                    _ => {}
+                }
+            }
+        }
+
+        dashboard.tick().await;
+    }
+
+    disable_raw_mode()?;
+    execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
+    Ok(())
+}

ecc2/src/tui/dashboard.rs

@@ -0,0 +1,614 @@
+use ratatui::{
+    prelude::*,
+    widgets::{Block, Borders, Cell, HighlightSpacing, Paragraph, Row, Table, TableState, Tabs},
+};
+
+use crate::config::Config;
+use crate::session::store::StateStore;
+use crate::session::{Session, SessionState};
+
+pub struct Dashboard {
+    db: StateStore,
+    cfg: Config,
+    sessions: Vec<Session>,
+    selected_pane: Pane,
+    selected_session: usize,
+    show_help: bool,
+    scroll_offset: usize,
+}
+
+#[derive(Debug, Default, PartialEq, Eq)]
+struct SessionSummary {
+    total: usize,
+    pending: usize,
+    running: usize,
+    idle: usize,
+    completed: usize,
+    failed: usize,
+    stopped: usize,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+enum Pane {
+    Sessions,
+    Output,
+    Metrics,
+}
+
+impl Dashboard {
+    pub fn new(db: StateStore, cfg: Config) -> Self {
+        let sessions = db.list_sessions().unwrap_or_default();
+        Self {
+            db,
+            cfg,
+            sessions,
+            selected_pane: Pane::Sessions,
+            selected_session: 0,
+            show_help: false,
+            scroll_offset: 0,
+        }
+    }
+
+    pub fn render(&self, frame: &mut Frame) {
+        let chunks = Layout::default()
+            .direction(Direction::Vertical)
+            .constraints([
+                Constraint::Length(3), // Header
+                Constraint::Min(10),   // Main content
+                Constraint::Length(3), // Status bar
+            ])
+            .split(frame.area());
+
+        self.render_header(frame, chunks[0]);
+
+        if self.show_help {
+            self.render_help(frame, chunks[1]);
+        } else {
+            let main_chunks = Layout::default()
+                .direction(Direction::Horizontal)
+                .constraints([
+                    Constraint::Percentage(50), // Session table
+                    Constraint::Percentage(50), // Output/details
+                ])
+                .split(chunks[1]);
+
+            self.render_sessions(frame, main_chunks[0]);
+
+            let right_chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .constraints([
+                    Constraint::Percentage(70), // Output
+                    Constraint::Percentage(30), // Metrics
+                ])
+                .split(main_chunks[1]);
+
+            self.render_output(frame, right_chunks[0]);
+            self.render_metrics(frame, right_chunks[1]);
+        }
+
+        self.render_status_bar(frame, chunks[2]);
+    }
+
+    fn render_header(&self, frame: &mut Frame, area: Rect) {
+        let running = self
+            .sessions
+            .iter()
+            .filter(|s| s.state == SessionState::Running)
+            .count();
+        let total = self.sessions.len();
+
+        let title = format!(" ECC 2.0 | {running} running / {total} total ");
+        let tabs = Tabs::new(vec!["Sessions", "Output", "Metrics"])
+            .block(Block::default().borders(Borders::ALL).title(title))
+            .select(match self.selected_pane {
+                Pane::Sessions => 0,
+                Pane::Output => 1,
+                Pane::Metrics => 2,
+            })
+            .highlight_style(
+                Style::default()
+                    .fg(Color::Cyan)
+                    .add_modifier(Modifier::BOLD),
+            );
+
+        frame.render_widget(tabs, area);
+    }
+
+    fn render_sessions(&self, frame: &mut Frame, area: Rect) {
+        let border_style = if self.selected_pane == Pane::Sessions {
+            Style::default().fg(Color::Cyan)
+        } else {
+            Style::default()
+        };
+
+        let block = Block::default()
+            .borders(Borders::ALL)
+            .title(" Sessions ")
+            .border_style(border_style);
+        let inner_area = block.inner(area);
+        frame.render_widget(block, area);
+
+        if inner_area.is_empty() {
+            return;
+        }
+
+        let summary = SessionSummary::from_sessions(&self.sessions);
+        let chunks = Layout::default()
+            .direction(Direction::Vertical)
+            .constraints([Constraint::Length(1), Constraint::Min(3)])
+            .split(inner_area);
+
+        frame.render_widget(Paragraph::new(summary_line(&summary)), chunks[0]);
+
+        let rows = self.sessions.iter().map(session_row);
+        let header = Row::new(["ID", "Agent", "State", "Branch", "Tokens", "Duration"])
+            .style(Style::default().add_modifier(Modifier::BOLD));
+        let widths = [
+            Constraint::Length(8),
+            Constraint::Length(10),
+            Constraint::Length(10),
+            Constraint::Min(12),
+            Constraint::Length(8),
+            Constraint::Length(8),
+        ];
+
+        let table = Table::new(rows, widths)
+            .header(header)
+            .column_spacing(1)
+            .highlight_symbol(">> ")
+            .highlight_spacing(HighlightSpacing::Always)
+            .row_highlight_style(
+                Style::default()
+                    .bg(Color::DarkGray)
+                    .add_modifier(Modifier::BOLD),
+            );
+
+        let selected = if self.sessions.is_empty() {
+            None
+        } else {
+            Some(self.selected_session.min(self.sessions.len() - 1))
+        };
+        let mut table_state = TableState::default().with_selected(selected);
+
+        frame.render_stateful_widget(table, chunks[1], &mut table_state);
+    }
+
+    fn render_output(&self, frame: &mut Frame, area: Rect) {
+        let content = if let Some(session) = self.sessions.get(self.selected_session) {
+            format!(
+                "Agent output for session {}...\n\n(Live streaming coming soon)",
+                session.id
+            )
+        } else {
+            "No sessions. Press 'n' to start one.".to_string()
+        };
+
+        let border_style = if self.selected_pane == Pane::Output {
+            Style::default().fg(Color::Cyan)
+        } else {
+            Style::default()
+        };
+
+        let paragraph = Paragraph::new(content).block(
+            Block::default()
+                .borders(Borders::ALL)
+                .title(" Output ")
+                .border_style(border_style),
+        );
+        frame.render_widget(paragraph, area);
+    }
+
+    fn render_metrics(&self, frame: &mut Frame, area: Rect) {
+        let content = if let Some(session) = self.sessions.get(self.selected_session) {
+            let m = &session.metrics;
+            format!(
+                "Tokens: {} | Tools: {} | Files: {} | Cost: ${:.4} | Duration: {}s",
+                m.tokens_used, m.tool_calls, m.files_changed, m.cost_usd, m.duration_secs
+            )
+        } else {
+            "No metrics available".to_string()
+        };
+
+        let border_style = if self.selected_pane == Pane::Metrics {
+            Style::default().fg(Color::Cyan)
+        } else {
+            Style::default()
+        };
+
+        let paragraph = Paragraph::new(content).block(
+            Block::default()
+                .borders(Borders::ALL)
+                .title(" Metrics ")
+                .border_style(border_style),
+        );
+        frame.render_widget(paragraph, area);
+    }
+
+    fn render_status_bar(&self, frame: &mut Frame, area: Rect) {
+        let text = " [n]ew session  [s]top  [Tab] switch pane  [j/k] scroll  [?] help  [q]uit ";
+        let paragraph = Paragraph::new(text)
+            .style(Style::default().fg(Color::DarkGray))
+            .block(Block::default().borders(Borders::ALL));
+        frame.render_widget(paragraph, area);
+    }
+
+    fn render_help(&self, frame: &mut Frame, area: Rect) {
+        let help = vec![
+            "Keyboard Shortcuts:",
+            "",
+            "  n       New session",
+            "  s       Stop selected session",
+            "  Tab     Next pane",
+            "  S-Tab   Previous pane",
+            "  j/↓     Scroll down",
+            "  k/↑     Scroll up",
+            "  r       Refresh",
+            "  ?       Toggle help",
+            "  q/C-c   Quit",
+        ];
+
+        let paragraph = Paragraph::new(help.join("\n")).block(
+            Block::default()
+                .borders(Borders::ALL)
+                .title(" Help ")
+                .border_style(Style::default().fg(Color::Yellow)),
+        );
+        frame.render_widget(paragraph, area);
+    }
+
+    pub fn next_pane(&mut self) {
+        self.selected_pane = match self.selected_pane {
+            Pane::Sessions => Pane::Output,
+            Pane::Output => Pane::Metrics,
+            Pane::Metrics => Pane::Sessions,
+        };
+    }
+
+    pub fn prev_pane(&mut self) {
+        self.selected_pane = match self.selected_pane {
+            Pane::Sessions => Pane::Metrics,
+            Pane::Output => Pane::Sessions,
+            Pane::Metrics => Pane::Output,
+        };
+    }
+
+    pub fn scroll_down(&mut self) {
+        if self.selected_pane == Pane::Sessions && !self.sessions.is_empty() {
+            self.selected_session = (self.selected_session + 1).min(self.sessions.len() - 1);
+        } else {
+            self.scroll_offset = self.scroll_offset.saturating_add(1);
+        }
+    }
+
+    pub fn scroll_up(&mut self) {
+        if self.selected_pane == Pane::Sessions {
+            self.selected_session = self.selected_session.saturating_sub(1);
+        } else {
+            self.scroll_offset = self.scroll_offset.saturating_sub(1);
+        }
+    }
+
+    pub fn new_session(&mut self) {
+        // TODO: Open a dialog to create a new session
+        tracing::info!("New session dialog requested");
+    }
+
+    pub fn stop_selected(&mut self) {
+        if let Some(session) = self.sessions.get(self.selected_session) {
+            let _ = self.db.update_state(&session.id, &SessionState::Stopped);
+            self.refresh();
+        }
+    }
+
+    pub fn refresh(&mut self) {
+        self.sessions = self.db.list_sessions().unwrap_or_default();
+        self.sync_selection();
+    }
+
+    pub fn toggle_help(&mut self) {
+        self.show_help = !self.show_help;
+    }
+
+    pub async fn tick(&mut self) {
+        // Periodic refresh every few ticks
+        self.sessions = self.db.list_sessions().unwrap_or_default();
+        self.sync_selection();
+    }
+
+    fn sync_selection(&mut self) {
+        if self.sessions.is_empty() {
+            self.selected_session = 0;
+        } else {
+            self.selected_session = self.selected_session.min(self.sessions.len() - 1);
+        }
+    }
+}
+
+impl SessionSummary {
+    fn from_sessions(sessions: &[Session]) -> Self {
+        sessions.iter().fold(
+            Self {
+                total: sessions.len(),
+                ..Self::default()
+            },
+            |mut summary, session| {
+                match session.state {
+                    SessionState::Pending => summary.pending += 1,
+                    SessionState::Running => summary.running += 1,
+                    SessionState::Idle => summary.idle += 1,
+                    SessionState::Completed => summary.completed += 1,
+                    SessionState::Failed => summary.failed += 1,
+                    SessionState::Stopped => summary.stopped += 1,
+                }
+                summary
+            },
+        )
+    }
+}
+
+fn session_row(session: &Session) -> Row<'static> {
+    Row::new(vec![
+        Cell::from(format_session_id(&session.id)),
+        Cell::from(session.agent_type.clone()),
+        Cell::from(session_state_label(&session.state)).style(
+            Style::default()
+                .fg(session_state_color(&session.state))
+                .add_modifier(Modifier::BOLD),
+        ),
+        Cell::from(session_branch(session)),
+        Cell::from(session.metrics.tokens_used.to_string()),
+        Cell::from(format_duration(session.metrics.duration_secs)),
+    ])
+}
+
+fn summary_line(summary: &SessionSummary) -> Line<'static> {
+    Line::from(vec![
+        Span::styled(
+            format!("Total {}  ", summary.total),
+            Style::default().add_modifier(Modifier::BOLD),
+        ),
+        summary_span("Running", summary.running, Color::Green),
+        summary_span("Idle", summary.idle, Color::Yellow),
+        summary_span("Completed", summary.completed, Color::Blue),
+        summary_span("Failed", summary.failed, Color::Red),
+        summary_span("Stopped", summary.stopped, Color::DarkGray),
+        summary_span("Pending", summary.pending, Color::Reset),
+    ])
+}
+
+fn summary_span(label: &str, value: usize, color: Color) -> Span<'static> {
+    Span::styled(
+        format!("{label} {value}  "),
+        Style::default().fg(color).add_modifier(Modifier::BOLD),
+    )
+}
+
+fn session_state_label(state: &SessionState) -> &'static str {
+    match state {
+        SessionState::Pending => "Pending",
+        SessionState::Running => "Running",
+        SessionState::Idle => "Idle",
+        SessionState::Completed => "Completed",
+        SessionState::Failed => "Failed",
+        SessionState::Stopped => "Stopped",
+    }
+}
+
+fn session_state_color(state: &SessionState) -> Color {
+    match state {
+        SessionState::Running => Color::Green,
+        SessionState::Idle => Color::Yellow,
+        SessionState::Failed => Color::Red,
+        SessionState::Stopped => Color::DarkGray,
+        SessionState::Completed => Color::Blue,
+        SessionState::Pending => Color::Reset,
+    }
+}
+
+fn format_session_id(id: &str) -> String {
+    id.chars().take(8).collect()
+}
+
+fn session_branch(session: &Session) -> String {
+    session
+        .worktree
+        .as_ref()
+        .map(|worktree| worktree.branch.clone())
+        .unwrap_or_else(|| "-".to_string())
+}
+
+fn format_duration(duration_secs: u64) -> String {
+    let hours = duration_secs / 3600;
+    let minutes = (duration_secs % 3600) / 60;
+    let seconds = duration_secs % 60;
+    format!("{hours:02}:{minutes:02}:{seconds:02}")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::session::{SessionMetrics, WorktreeInfo};
+    use chrono::Utc;
+    use ratatui::{backend::TestBackend, Terminal};
+    use std::path::PathBuf;
+    use uuid::Uuid;
+
+    #[test]
+    fn session_state_color_matches_requested_palette() {
+        assert_eq!(session_state_color(&SessionState::Running), Color::Green);
+        assert_eq!(session_state_color(&SessionState::Idle), Color::Yellow);
+        assert_eq!(session_state_color(&SessionState::Failed), Color::Red);
+        assert_eq!(session_state_color(&SessionState::Stopped), Color::DarkGray);
+        assert_eq!(session_state_color(&SessionState::Completed), Color::Blue);
+    }
+
+    #[test]
+    fn session_summary_counts_each_state() {
+        let sessions = vec![
+            sample_session(
+                "run-12345678",
+                "planner",
+                SessionState::Running,
+                Some("feat/run"),
+                128,
+                15,
+            ),
+            sample_session(
+                "idle-12345678",
+                "reviewer",
+                SessionState::Idle,
+                Some("feat/idle"),
+                256,
+                30,
+            ),
+            sample_session(
+                "done-12345678",
+                "architect",
+                SessionState::Completed,
+                Some("feat/done"),
+                512,
+                45,
+            ),
+            sample_session(
+                "fail-12345678",
+                "worker",
+                SessionState::Failed,
+                Some("feat/fail"),
+                1024,
+                60,
+            ),
+            sample_session(
+                "stop-12345678",
+                "security",
+                SessionState::Stopped,
+                None,
+                64,
+                10,
+            ),
+            sample_session(
+                "pend-12345678",
+                "tdd",
+                SessionState::Pending,
+                Some("feat/pending"),
+                32,
+                5,
+            ),
+        ];
+
+        let summary = SessionSummary::from_sessions(&sessions);
+
+        assert_eq!(summary.total, 6);
+        assert_eq!(summary.running, 1);
+        assert_eq!(summary.idle, 1);
+        assert_eq!(summary.completed, 1);
+        assert_eq!(summary.failed, 1);
+        assert_eq!(summary.stopped, 1);
+        assert_eq!(summary.pending, 1);
+    }
+
+    #[test]
+    fn render_sessions_shows_summary_headers_and_selected_row() {
+        let dashboard = test_dashboard(
+            vec![
+                sample_session(
+                    "run-12345678",
+                    "planner",
+                    SessionState::Running,
+                    Some("feat/run"),
+                    128,
+                    15,
+                ),
+                sample_session(
+                    "done-87654321",
+                    "reviewer",
+                    SessionState::Completed,
+                    Some("release/v1"),
+                    2048,
+                    125,
+                ),
+            ],
+            1,
+        );
+
+        let rendered = render_dashboard_text(&dashboard, 150, 24);
+
+        assert!(rendered.contains("ID"));
+        assert!(rendered.contains("Agent"));
+        assert!(rendered.contains("State"));
+        assert!(rendered.contains("Branch"));
+        assert!(rendered.contains("Tokens"));
+        assert!(rendered.contains("Duration"));
+        assert!(rendered.contains("Total 2"));
+        assert!(rendered.contains("Running 1"));
+        assert!(rendered.contains("Completed 1"));
+        assert!(rendered.contains(">> done-876"));
+        assert!(rendered.contains("reviewer"));
+        assert!(rendered.contains("release/v1"));
+        assert!(rendered.contains("00:02:05"));
+    }
+
+    fn test_dashboard(sessions: Vec<Session>, selected_session: usize) -> Dashboard {
+        Dashboard {
+            db: test_store(),
+            cfg: Config::default(),
+            sessions,
+            selected_pane: Pane::Sessions,
+            selected_session,
+            show_help: false,
+            scroll_offset: 0,
+        }
+    }
+
+    fn test_store() -> StateStore {
+        let db_path =
+            std::env::temp_dir().join(format!("ecc-dashboard-test-{}.db", Uuid::new_v4()));
+        StateStore::open(&db_path).expect("open test db")
+    }
+
+    fn sample_session(
+        id: &str,
+        agent_type: &str,
+        state: SessionState,
+        branch: Option<&str>,
+        tokens_used: u64,
+        duration_secs: u64,
+    ) -> Session {
+        Session {
+            id: id.to_string(),
+            task: "Render dashboard rows".to_string(),
+            agent_type: agent_type.to_string(),
+            state,
+            worktree: branch.map(|branch| WorktreeInfo {
+                path: PathBuf::from(format!("/tmp/{branch}")),
+                branch: branch.to_string(),
+                base_branch: "main".to_string(),
+            }),
+            created_at: Utc::now(),
+            updated_at: Utc::now(),
+            metrics: SessionMetrics {
+                tokens_used,
+                tool_calls: 4,
+                files_changed: 2,
+                duration_secs,
+                cost_usd: 0.42,
+            },
+        }
+    }
+
+    fn render_dashboard_text(dashboard: &Dashboard, width: u16, height: u16) -> String {
+        let backend = TestBackend::new(width, height);
+        let mut terminal = Terminal::new(backend).expect("create terminal");
+
+        terminal
+            .draw(|frame| dashboard.render(frame))
+            .expect("render dashboard");
+
+        let buffer = terminal.backend().buffer();
+        buffer
+            .content
+            .chunks(buffer.area.width as usize)
+            .map(|cells| cells.iter().map(|cell| cell.symbol()).collect::<String>())
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
+}

ecc2/src/tui/mod.rs

@@ -0,0 +1,3 @@
+pub mod app;
+mod dashboard;
+mod widgets;

ecc2/src/tui/widgets.rs

@@ -0,0 +1,6 @@
+// Custom TUI widgets for ECC 2.0
+// TODO: Implement custom widgets:
+// - TokenMeter: visual token usage bar with budget threshold
+// - DiffViewer: side-by-side syntax-highlighted diff display
+// - ProgressTimeline: session timeline with tool call markers
+// - AgentTree: hierarchical view of parent/child agent sessions

ecc2/src/worktree/mod.rs

@@ -0,0 +1,84 @@
+use anyhow::{Context, Result};
+use std::path::PathBuf;
+use std::process::Command;
+
+use crate::config::Config;
+use crate::session::WorktreeInfo;
+
+/// Create a new git worktree for an agent session.
+pub fn create_for_session(session_id: &str, cfg: &Config) -> Result<WorktreeInfo> {
+    let branch = format!("ecc/{session_id}");
+    let path = cfg.worktree_root.join(session_id);
+
+    // Get current branch as base
+    let base = get_current_branch()?;
+
+    std::fs::create_dir_all(&cfg.worktree_root)
+        .context("Failed to create worktree root directory")?;
+
+    let output = Command::new("git")
+        .args(["worktree", "add", "-b", &branch])
+        .arg(&path)
+        .arg("HEAD")
+        .output()
+        .context("Failed to run git worktree add")?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        anyhow::bail!("git worktree add failed: {stderr}");
+    }
+
+    tracing::info!(
+        "Created worktree at {} on branch {}",
+        path.display(),
+        branch
+    );
+
+    Ok(WorktreeInfo {
+        path,
+        branch,
+        base_branch: base,
+    })
+}
+
+/// Remove a worktree and its branch.
+pub fn remove(path: &PathBuf) -> Result<()> {
+    let output = Command::new("git")
+        .args(["worktree", "remove", "--force"])
+        .arg(path)
+        .output()
+        .context("Failed to remove worktree")?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        tracing::warn!("Worktree removal warning: {stderr}");
+    }
+
+    Ok(())
+}
+
+/// List all active worktrees.
+pub fn list() -> Result<Vec<String>> {
+    let output = Command::new("git")
+        .args(["worktree", "list", "--porcelain"])
+        .output()
+        .context("Failed to list worktrees")?;
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let worktrees: Vec<String> = stdout
+        .lines()
+        .filter(|l| l.starts_with("worktree "))
+        .map(|l| l.trim_start_matches("worktree ").to_string())
+        .collect();
+
+    Ok(worktrees)
+}
+
+fn get_current_branch() -> Result<String> {
+    let output = Command::new("git")
+        .args(["rev-parse", "--abbrev-ref", "HEAD"])
+        .output()
+        .context("Failed to get current branch")?;
+
+    Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
+}