The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
feat(ecc2): implement live output streaming per agent (#774)
Affaan Mustafa44c2bf6f7bb2
diff --git a/ecc2/src/main.rs b/ecc2/src/main.rsindex afa50a2ff..476c2d3bb 100644--- a/ecc2/src/main.rs+++ b/ecc2/src/main.rs@@ -7,6 +7,7 @@ mod worktree;use anyhow::Result;use clap::Parser;+use std::path::PathBuf;use tracing_subscriber::EnvFilter;#[derive(Parser, Debug)]@@ -46,6 +47,17 @@ enum Commands {},/// Run as background daemonDaemon,+ #[command(hide = true)]+ RunSession {+ #[arg(long)]+ session_id: String,+ #[arg(long)]+ task: String,+ #[arg(long)]+ agent: String,+ #[arg(long)]+ cwd: PathBuf,+ },}#[tokio::main]@@ -91,6 +103,14 @@ async fn main() -> Result<()> {println!("Starting ECC daemon...");session::daemon::run(db, cfg).await?;}+ Some(Commands::RunSession {+ session_id,+ task,+ agent,+ cwd,+ }) => {+ session::manager::run_session(&cfg, &session_id, &task, &agent, &cwd).await?;+ }}Ok(())diff --git a/ecc2/src/session/manager.rs b/ecc2/src/session/manager.rsindex 2c8bd1bc8..7d00d7fc4 100644--- a/ecc2/src/session/manager.rs+++ b/ecc2/src/session/manager.rs@@ -4,6 +4,8 @@ use std::path::{Path, PathBuf};use std::process::Stdio;use tokio::process::Command;+use super::output::SessionOutputStore;+use super::runtime::capture_command_output;use super::store::StateStore;use super::{Session, SessionMetrics, SessionState};use crate::config::Config;@@ -18,18 +20,7 @@ pub async fn create_session() -> Result<String> {let repo_root =std::env::current_dir().context("Failed to resolve current working directory")?;- let agent_program = agent_program(agent_type)?;-- create_session_in_dir(- db,- cfg,- task,- agent_type,- use_worktree,- &repo_root,- &agent_program,- )- .await+ queue_session_in_dir(db, cfg, task, agent_type, use_worktree, &repo_root).await}pub fn list_sessions(db: &StateStore) -> Result<Vec<Session>> {@@ -62,35 +53,107 @@ fn resolve_session(db: &StateStore, id: &str) -> Result<Session> {session.ok_or_else(|| anyhow::anyhow!("Session not found: {id}"))}-async fn create_session_in_dir(+pub async fn run_session(+ cfg: &Config,+ session_id: &str,+ task: &str,+ agent_type: &str,+ working_dir: &Path,+) -> Result<()> {+ let db = StateStore::open(&cfg.db_path)?;+ let session = resolve_session(&db, session_id)?;++ if session.state != SessionState::Pending {+ tracing::info!(+ "Skipping run_session for {} because state is {}",+ session_id,+ session.state+ );+ return Ok(());+ }++ let agent_program = agent_program(agent_type)?;+ let command = build_agent_command(&agent_program, task, session_id, working_dir);+ capture_command_output(+ cfg.db_path.clone(),+ session_id.to_string(),+ command,+ SessionOutputStore::default(),+ )+ .await?;+ Ok(())+}++async fn queue_session_in_dir(db: &StateStore,cfg: &Config,task: &str,agent_type: &str,use_worktree: bool,repo_root: &Path,- agent_program: &Path,) -> Result<String> {+ let session = build_session_record(task, agent_type, use_worktree, cfg, repo_root)?;+ db.insert_session(&session)?;++ let working_dir = session+ .worktree+ .as_ref()+ .map(|worktree| worktree.path.as_path())+ .unwrap_or(repo_root);++ match spawn_session_runner(task, &session.id, agent_type, working_dir).await {+ Ok(()) => Ok(session.id),+ Err(error) => {+ db.update_state(&session.id, &SessionState::Failed)?;++ if let Some(worktree) = session.worktree.as_ref() {+ let _ = crate::worktree::remove(&worktree.path);+ }++ Err(error.context(format!("Failed to queue session {}", session.id)))+ }+ }+}++fn build_session_record(+ task: &str,+ agent_type: &str,+ use_worktree: bool,+ cfg: &Config,+ repo_root: &Path,+) -> Result<Session> {let id = uuid::Uuid::new_v4().to_string()[..8].to_string();let now = chrono::Utc::now();- let wt = if use_worktree {+ let worktree = if use_worktree {Some(worktree::create_for_session_in_repo(&id, cfg, repo_root)?)} else {None};- let session = Session {- id: id.clone(),+ Ok(Session {+ id,task: task.to_string(),agent_type: agent_type.to_string(),state: SessionState::Pending,pid: None,- worktree: wt,+ worktree,created_at: now,updated_at: now,metrics: SessionMetrics::default(),- };+ })+}++async fn create_session_in_dir(+ db: &StateStore,+ cfg: &Config,+ task: &str,+ agent_type: &str,+ use_worktree: bool,+ repo_root: &Path,+ agent_program: &Path,+) -> Result<String> {+ let session = build_session_record(task, agent_type, use_worktree, cfg, repo_root)?;db.insert_session(&session)?;@@ -118,19 +181,60 @@ async fn create_session_in_dir(}}-async fn spawn_claude_code(- agent_program: &Path,+async fn spawn_session_runner(task: &str,session_id: &str,+ agent_type: &str,working_dir: &Path,-) -> Result<u32> {- let child = Command::new(agent_program)+) -> Result<()> {+ let current_exe = std::env::current_exe().context("Failed to resolve ECC executable path")?;+ let child = Command::new(¤t_exe)+ .arg("run-session")+ .arg("--session-id")+ .arg(session_id)+ .arg("--task")+ .arg(task)+ .arg("--agent")+ .arg(agent_type)+ .arg("--cwd")+ .arg(working_dir)+ .stdin(Stdio::null())+ .stdout(Stdio::null())+ .stderr(Stdio::null())+ .spawn()+ .with_context(|| {+ format!(+ "Failed to spawn ECC runner from {}",+ current_exe.display()+ )+ })?;++ child+ .id()+ .ok_or_else(|| anyhow::anyhow!("ECC runner did not expose a process id"))?;+ Ok(())+}++fn build_agent_command(agent_program: &Path, task: &str, session_id: &str, working_dir: &Path) -> Command {+ let mut command = Command::new(agent_program);+ command.arg("--print").arg("--name").arg(format!("ecc-{session_id}")).arg(task).current_dir(working_dir)- .stdin(Stdio::null())+ .stdin(Stdio::null());+ command+}++async fn spawn_claude_code(+ agent_program: &Path,+ task: &str,+ session_id: &str,+ working_dir: &Path,+) -> Result<u32> {+ let mut command = build_agent_command(agent_program, task, session_id, working_dir);+ let child = command.stdout(Stdio::null()).stderr(Stdio::null()).spawn()diff --git a/ecc2/src/session/mod.rs b/ecc2/src/session/mod.rsindex 9f8d2b2f9..0e256e48e 100644--- a/ecc2/src/session/mod.rs+++ b/ecc2/src/session/mod.rs@@ -1,5 +1,7 @@pub mod daemon;pub mod manager;+pub mod output;+pub mod runtime;pub mod store;use chrono::{DateTime, Utc};diff --git a/ecc2/src/session/output.rs b/ecc2/src/session/output.rsnew file mode 100644index 000000000..6cae21f35--- /dev/null+++ b/ecc2/src/session/output.rs@@ -0,0 +1,149 @@+use std::collections::{HashMap, VecDeque};+use std::sync::{Arc, Mutex, MutexGuard};++use serde::{Deserialize, Serialize};+use tokio::sync::broadcast;++pub const OUTPUT_BUFFER_LIMIT: usize = 1000;++#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]+pub enum OutputStream {+ Stdout,+ Stderr,+}++impl OutputStream {+ pub fn as_str(self) -> &'static str {+ match self {+ Self::Stdout => "stdout",+ Self::Stderr => "stderr",+ }+ }++ pub fn from_db_value(value: &str) -> Self {+ match value {+ "stderr" => Self::Stderr,+ _ => Self::Stdout,+ }+ }+}++#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]+pub struct OutputLine {+ pub stream: OutputStream,+ pub text: String,+}++#[derive(Debug, Clone, PartialEq, Eq)]+pub struct OutputEvent {+ pub session_id: String,+ pub line: OutputLine,+}++#[derive(Clone)]+pub struct SessionOutputStore {+ capacity: usize,+ buffers: Arc<Mutex<HashMap<String, VecDeque<OutputLine>>>>,+ tx: broadcast::Sender<OutputEvent>,+}++impl Default for SessionOutputStore {+ fn default() -> Self {+ Self::new(OUTPUT_BUFFER_LIMIT)+ }+}++impl SessionOutputStore {+ pub fn new(capacity: usize) -> Self {+ let capacity = capacity.max(1);+ let (tx, _) = broadcast::channel(capacity.max(16));++ Self {+ capacity,+ buffers: Arc::new(Mutex::new(HashMap::new())),+ tx,+ }+ }++ pub fn subscribe(&self) -> broadcast::Receiver<OutputEvent> {+ self.tx.subscribe()+ }++ pub fn push_line(&self, session_id: &str, stream: OutputStream, text: impl Into<String>) {+ let line = OutputLine {+ stream,+ text: text.into(),+ };++ {+ let mut buffers = self.lock_buffers();+ let buffer = buffers.entry(session_id.to_string()).or_default();+ buffer.push_back(line.clone());++ while buffer.len() > self.capacity {+ let _ = buffer.pop_front();+ }+ }++ let _ = self.tx.send(OutputEvent {+ session_id: session_id.to_string(),+ line,+ });+ }++ pub fn replace_lines(&self, session_id: &str, lines: Vec<OutputLine>) {+ let mut buffer: VecDeque<OutputLine> = lines.into_iter().collect();++ while buffer.len() > self.capacity {+ let _ = buffer.pop_front();+ }++ self.lock_buffers().insert(session_id.to_string(), buffer);+ }++ pub fn lines(&self, session_id: &str) -> Vec<OutputLine> {+ self.lock_buffers()+ .get(session_id)+ .map(|buffer| buffer.iter().cloned().collect())+ .unwrap_or_default()+ }++ fn lock_buffers(&self) -> MutexGuard<'_, HashMap<String, VecDeque<OutputLine>>> {+ self.buffers+ .lock()+ .unwrap_or_else(|poisoned| poisoned.into_inner())+ }+}++#[cfg(test)]+mod tests {+ use super::{OutputStream, SessionOutputStore};++ #[test]+ fn ring_buffer_keeps_most_recent_lines() {+ let store = SessionOutputStore::new(3);++ store.push_line("session-1", OutputStream::Stdout, "line-1");+ store.push_line("session-1", OutputStream::Stdout, "line-2");+ store.push_line("session-1", OutputStream::Stdout, "line-3");+ store.push_line("session-1", OutputStream::Stdout, "line-4");++ let lines = store.lines("session-1");+ let texts: Vec<_> = lines.iter().map(|line| line.text.as_str()).collect();++ assert_eq!(texts, vec!["line-2", "line-3", "line-4"]);+ }++ #[tokio::test]+ async fn pushing_output_broadcasts_events() {+ let store = SessionOutputStore::new(8);+ let mut rx = store.subscribe();++ store.push_line("session-1", OutputStream::Stderr, "problem");++ let event = rx.recv().await.expect("broadcast event");+ assert_eq!(event.session_id, "session-1");+ assert_eq!(event.line.stream, OutputStream::Stderr);+ assert_eq!(event.line.text, "problem");+ }+}diff --git a/ecc2/src/session/runtime.rs b/ecc2/src/session/runtime.rsnew file mode 100644index 000000000..87da7b89a--- /dev/null+++ b/ecc2/src/session/runtime.rs@@ -0,0 +1,290 @@+use std::path::PathBuf;+use std::process::{ExitStatus, Stdio};++use anyhow::{Context, Result};+use tokio::io::{AsyncBufReadExt, AsyncRead, BufReader};+use tokio::process::Command;+use tokio::sync::{mpsc, oneshot};++use super::output::{OutputStream, SessionOutputStore};+use super::store::StateStore;+use super::SessionState;++type DbAck = std::result::Result<(), String>;++enum DbMessage {+ UpdateState {+ state: SessionState,+ ack: oneshot::Sender<DbAck>,+ },+ UpdatePid {+ pid: Option<u32>,+ ack: oneshot::Sender<DbAck>,+ },+ AppendOutputLine {+ stream: OutputStream,+ line: String,+ ack: oneshot::Sender<DbAck>,+ },+}++#[derive(Clone)]+struct DbWriter {+ tx: mpsc::UnboundedSender<DbMessage>,+}++impl DbWriter {+ fn start(db_path: PathBuf, session_id: String) -> Self {+ let (tx, rx) = mpsc::unbounded_channel();+ std::thread::spawn(move || run_db_writer(db_path, session_id, rx));+ Self { tx }+ }++ async fn update_state(&self, state: SessionState) -> Result<()> {+ self.send(|ack| DbMessage::UpdateState { state, ack }).await+ }++ async fn update_pid(&self, pid: Option<u32>) -> Result<()> {+ self.send(|ack| DbMessage::UpdatePid { pid, ack }).await+ }++ async fn append_output_line(&self, stream: OutputStream, line: String) -> Result<()> {+ self.send(|ack| DbMessage::AppendOutputLine { stream, line, ack })+ .await+ }++ async fn send<F>(&self, build: F) -> Result<()>+ where+ F: FnOnce(oneshot::Sender<DbAck>) -> DbMessage,+ {+ let (ack_tx, ack_rx) = oneshot::channel();+ self.tx+ .send(build(ack_tx))+ .map_err(|_| anyhow::anyhow!("DB writer channel closed"))?;++ match ack_rx.await {+ Ok(Ok(())) => Ok(()),+ Ok(Err(error)) => Err(anyhow::anyhow!(error)),+ Err(_) => Err(anyhow::anyhow!("DB writer acknowledgement dropped")),+ }+ }+}++fn run_db_writer(+ db_path: PathBuf,+ session_id: String,+ mut rx: mpsc::UnboundedReceiver<DbMessage>,+) {+ let (opened, open_error) = match StateStore::open(&db_path) {+ Ok(db) => (Some(db), None),+ Err(error) => (None, Some(error.to_string())),+ };++ while let Some(message) = rx.blocking_recv() {+ match message {+ DbMessage::UpdateState { state, ack } => {+ let result = match opened.as_ref() {+ Some(db) => db.update_state(&session_id, &state).map_err(|error| error.to_string()),+ None => Err(open_error+ .clone()+ .unwrap_or_else(|| "Failed to open state store".to_string())),+ };+ let _ = ack.send(result);+ }+ DbMessage::UpdatePid { pid, ack } => {+ let result = match opened.as_ref() {+ Some(db) => db.update_pid(&session_id, pid).map_err(|error| error.to_string()),+ None => Err(open_error+ .clone()+ .unwrap_or_else(|| "Failed to open state store".to_string())),+ };+ let _ = ack.send(result);+ }+ DbMessage::AppendOutputLine { stream, line, ack } => {+ let result = match opened.as_ref() {+ Some(db) => db+ .append_output_line(&session_id, stream, &line)+ .map_err(|error| error.to_string()),+ None => Err(open_error+ .clone()+ .unwrap_or_else(|| "Failed to open state store".to_string())),+ };+ let _ = ack.send(result);+ }+ }+ }+}++pub async fn capture_command_output(+ db_path: PathBuf,+ session_id: String,+ mut command: Command,+ output_store: SessionOutputStore,+) -> Result<ExitStatus> {+ let db_writer = DbWriter::start(db_path, session_id.clone());++ let result = async {+ let mut child = command+ .stdout(Stdio::piped())+ .stderr(Stdio::piped())+ .spawn()+ .with_context(|| format!("Failed to start process for session {}", session_id))?;++ let stdout = match child.stdout.take() {+ Some(stdout) => stdout,+ None => {+ let _ = child.kill().await;+ let _ = child.wait().await;+ anyhow::bail!("Child stdout was not piped");+ }+ };+ let stderr = match child.stderr.take() {+ Some(stderr) => stderr,+ None => {+ let _ = child.kill().await;+ let _ = child.wait().await;+ anyhow::bail!("Child stderr was not piped");+ }+ };++ let pid = child+ .id()+ .ok_or_else(|| anyhow::anyhow!("Spawned process did not expose a process id"))?;+ db_writer.update_pid(Some(pid)).await?;+ db_writer.update_state(SessionState::Running).await?;++ let stdout_task = tokio::spawn(capture_stream(+ session_id.clone(),+ stdout,+ OutputStream::Stdout,+ output_store.clone(),+ db_writer.clone(),+ ));+ let stderr_task = tokio::spawn(capture_stream(+ session_id.clone(),+ stderr,+ OutputStream::Stderr,+ output_store,+ db_writer.clone(),+ ));++ let status = child.wait().await?;+ stdout_task.await??;+ stderr_task.await??;++ let final_state = if status.success() {+ SessionState::Completed+ } else {+ SessionState::Failed+ };+ db_writer.update_pid(None).await?;+ db_writer.update_state(final_state).await?;++ Ok(status)+ }+ .await;++ if result.is_err() {+ let _ = db_writer.update_pid(None).await;+ let _ = db_writer.update_state(SessionState::Failed).await;+ }++ result+}++async fn capture_stream<R>(+ session_id: String,+ reader: R,+ stream: OutputStream,+ output_store: SessionOutputStore,+ db_writer: DbWriter,+) -> Result<()>+where+ R: AsyncRead + Unpin,+{+ let mut lines = BufReader::new(reader).lines();++ while let Some(line) = lines.next_line().await? {+ db_writer+ .append_output_line(stream, line.clone())+ .await?;+ output_store.push_line(&session_id, stream, line);+ }++ Ok(())+}++#[cfg(test)]+mod tests {+ use std::collections::HashSet;+ use std::env;++ use anyhow::Result;+ use chrono::Utc;+ use tokio::process::Command;+ use uuid::Uuid;++ use super::capture_command_output;+ use crate::session::output::{SessionOutputStore, OUTPUT_BUFFER_LIMIT};+ use crate::session::store::StateStore;+ use crate::session::{Session, SessionMetrics, SessionState};++ #[tokio::test]+ async fn capture_command_output_persists_lines_and_events() -> Result<()> {+ let db_path = env::temp_dir().join(format!("ecc2-runtime-{}.db", Uuid::new_v4()));+ let db = StateStore::open(&db_path)?;+ let session_id = "session-1".to_string();+ let now = Utc::now();++ db.insert_session(&Session {+ id: session_id.clone(),+ task: "stream output".to_string(),+ agent_type: "test".to_string(),+ state: SessionState::Pending,+ pid: None,+ worktree: None,+ created_at: now,+ updated_at: now,+ metrics: SessionMetrics::default(),+ })?;++ let output_store = SessionOutputStore::default();+ let mut rx = output_store.subscribe();+ let mut command = Command::new("/bin/sh");+ command+ .arg("-c")+ .arg("printf 'alpha\\n'; printf 'beta\\n' >&2");++ let status =+ capture_command_output(db_path.clone(), session_id.clone(), command, output_store)+ .await?;++ assert!(status.success());++ let db = StateStore::open(&db_path)?;+ let session = db+ .get_session(&session_id)?+ .expect("session should still exist");+ assert_eq!(session.state, SessionState::Completed);+ assert_eq!(session.pid, None);++ let lines = db.get_output_lines(&session_id, OUTPUT_BUFFER_LIMIT)?;+ let texts: HashSet<_> = lines.iter().map(|line| line.text.as_str()).collect();+ assert_eq!(lines.len(), 2);+ assert!(texts.contains("alpha"));+ assert!(texts.contains("beta"));++ let mut events = Vec::new();+ while let Ok(event) = rx.try_recv() {+ events.push(event.line.text);+ }++ assert_eq!(events.len(), 2);+ assert!(events.iter().any(|line| line == "alpha"));+ assert!(events.iter().any(|line| line == "beta"));++ let _ = std::fs::remove_file(db_path);++ Ok(())+ }+}diff --git a/ecc2/src/session/store.rs b/ecc2/src/session/store.rsindex 60d2a5b2f..1a3131000 100644--- a/ecc2/src/session/store.rs+++ b/ecc2/src/session/store.rs@@ -1,7 +1,9 @@use anyhow::{Context, Result};use rusqlite::{Connection, OptionalExtension};-use std::path::Path;+use std::path::{Path, PathBuf};+use std::time::Duration;+use super::output::{OutputLine, OutputStream, OUTPUT_BUFFER_LIMIT};use super::{Session, SessionMetrics, SessionState};pub struct StateStore {@@ -11,6 +13,8 @@ pub struct StateStore {impl StateStore {pub fn open(path: &Path) -> Result<Self> {let conn = Connection::open(path)?;+ conn.execute_batch("PRAGMA foreign_keys = ON;")?;+ conn.busy_timeout(Duration::from_secs(5))?;let store = Self { conn };store.init_schema()?;Ok(store)@@ -58,9 +62,19 @@ impl StateStore {timestamp TEXT NOT NULL);+ CREATE TABLE IF NOT EXISTS session_output (+ id INTEGER PRIMARY KEY AUTOINCREMENT,+ session_id TEXT NOT NULL REFERENCES sessions(id),+ stream TEXT NOT NULL,+ line TEXT NOT NULL,+ 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);+ CREATE INDEX IF NOT EXISTS idx_session_output_session+ ON session_output(session_id, id);",)?;self.ensure_session_columns()?;@@ -97,7 +111,10 @@ impl StateStore {session.agent_type,session.state.to_string(),session.pid.map(i64::from),- session.worktree.as_ref().map(|w| w.path.to_string_lossy().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(),@@ -190,8 +207,8 @@ impl StateStore {let state = SessionState::from_db_value(&state_str);let worktree_path: Option<String> = row.get(5)?;- let worktree = worktree_path.map(|p| super::WorktreeInfo {- path: std::path::PathBuf::from(p),+ let worktree = worktree_path.map(|path| super::WorktreeInfo {+ path: PathBuf::from(path),branch: row.get::<_, String>(6).unwrap_or_default(),base_branch: row.get::<_, String>(7).unwrap_or_default(),});@@ -234,8 +251,9 @@ impl StateStore {let sessions = self.list_sessions()?;Ok(sessions.into_iter()- .find(|s| s.id == id || s.id.starts_with(id)))+ .find(|session| session.id == id || session.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)@@ -244,15 +262,76 @@ impl StateStore {)?;Ok(())}++ pub fn append_output_line(+ &self,+ session_id: &str,+ stream: OutputStream,+ line: &str,+ ) -> Result<()> {+ let now = chrono::Utc::now().to_rfc3339();++ self.conn.execute(+ "INSERT INTO session_output (session_id, stream, line, timestamp)+ VALUES (?1, ?2, ?3, ?4)",+ rusqlite::params![session_id, stream.as_str(), line, now],+ )?;++ self.conn.execute(+ "DELETE FROM session_output+ WHERE session_id = ?1+ AND id NOT IN (+ SELECT id+ FROM session_output+ WHERE session_id = ?1+ ORDER BY id DESC+ LIMIT ?2+ )",+ rusqlite::params![session_id, OUTPUT_BUFFER_LIMIT as i64],+ )?;++ self.conn.execute(+ "UPDATE sessions SET updated_at = ?1 WHERE id = ?2",+ rusqlite::params![chrono::Utc::now().to_rfc3339(), session_id],+ )?;++ Ok(())+ }++ pub fn get_output_lines(&self, session_id: &str, limit: usize) -> Result<Vec<OutputLine>> {+ let mut stmt = self.conn.prepare(+ "SELECT stream, line+ FROM (+ SELECT id, stream, line+ FROM session_output+ WHERE session_id = ?1+ ORDER BY id DESC+ LIMIT ?2+ )+ ORDER BY id ASC",+ )?;++ let lines = stmt+ .query_map(rusqlite::params![session_id, limit as i64], |row| {+ let stream: String = row.get(0)?;+ let text: String = row.get(1)?;++ Ok(OutputLine {+ stream: OutputStream::from_db_value(&stream),+ text,+ })+ })?+ .collect::<Result<Vec<_>, _>>()?;++ Ok(lines)+ }}#[cfg(test)]mod tests {use super::*;- use crate::session::{Session, SessionMetrics, SessionState};- use chrono::{Duration, Utc};+ use chrono::{Duration as ChronoDuration, Utc};use std::fs;- use std::path::{Path, PathBuf};struct TestDir {path: PathBuf,@@ -286,7 +365,7 @@ mod tests {state,pid: None,worktree: None,- created_at: now - Duration::minutes(1),+ created_at: now - ChronoDuration::minutes(1),updated_at: now,metrics: SessionMetrics::default(),}@@ -346,4 +425,37 @@ mod tests {assert!(column_names.iter().any(|column| column == "pid"));Ok(())}++ #[test]+ fn append_output_line_keeps_latest_buffer_window() -> Result<()> {+ let tempdir = TestDir::new("store-output")?;+ let db = StateStore::open(&tempdir.path().join("state.db"))?;+ let now = Utc::now();++ db.insert_session(&Session {+ id: "session-1".to_string(),+ task: "buffer output".to_string(),+ agent_type: "claude".to_string(),+ state: SessionState::Running,+ pid: None,+ worktree: None,+ created_at: now,+ updated_at: now,+ metrics: SessionMetrics::default(),+ })?;++ for index in 0..(OUTPUT_BUFFER_LIMIT + 5) {+ db.append_output_line("session-1", OutputStream::Stdout, &format!("line-{index}"))?;+ }++ let lines = db.get_output_lines("session-1", OUTPUT_BUFFER_LIMIT)?;+ let texts: Vec<_> = lines.iter().map(|line| line.text.as_str()).collect();++ assert_eq!(lines.len(), OUTPUT_BUFFER_LIMIT);+ assert_eq!(texts.first().copied(), Some("line-5"));+ let expected_last_line = format!("line-{}", OUTPUT_BUFFER_LIMIT + 4);+ assert_eq!(texts.last().copied(), Some(expected_last_line.as_str()));++ Ok(())+ }}diff --git a/ecc2/src/tui/dashboard.rs b/ecc2/src/tui/dashboard.rsindex 59f78f4ea..17efafc32 100644--- a/ecc2/src/tui/dashboard.rs+++ b/ecc2/src/tui/dashboard.rs@@ -1,23 +1,33 @@+use std::collections::HashMap;+use std::path::{Path, PathBuf};+use ratatui::{prelude::*,widgets::{Block, Borders, Cell, HighlightSpacing, Paragraph, Row, Table, TableState, Tabs, Wrap,},};+use tokio::sync::broadcast;use super::widgets::{budget_state, format_currency, format_token_count, BudgetState, TokenMeter};use crate::config::Config;+use crate::session::output::{OutputEvent, OutputLine, SessionOutputStore, OutputStream, OUTPUT_BUFFER_LIMIT};use crate::session::store::StateStore;-use crate::session::{Session, SessionState};+use crate::session::{Session, SessionMetrics, SessionState, WorktreeInfo};pub struct Dashboard {db: StateStore,cfg: Config,+ output_store: SessionOutputStore,+ output_rx: broadcast::Receiver<OutputEvent>,sessions: Vec<Session>,+ session_output_cache: HashMap<String, Vec<OutputLine>>,selected_pane: Pane,selected_session: usize,show_help: bool,- scroll_offset: usize,+ output_follow: bool,+ output_scroll_offset: usize,+ last_output_height: usize,session_table_state: TableState,}@@ -50,22 +60,34 @@ struct AggregateUsage {impl Dashboard {pub fn new(db: StateStore, cfg: Config) -> Self {+ Self::with_output_store(db, cfg, SessionOutputStore::default())+ }++ pub fn with_output_store(db: StateStore, cfg: Config, output_store: SessionOutputStore) -> Self {let sessions = db.list_sessions().unwrap_or_default();+ let output_rx = output_store.subscribe();let mut session_table_state = TableState::default();if !sessions.is_empty() {session_table_state.select(Some(0));}- Self {+ let mut dashboard = Self {db,cfg,+ output_store,+ output_rx,sessions,+ session_output_cache: HashMap::new(),selected_pane: Pane::Sessions,selected_session: 0,show_help: false,- scroll_offset: 0,+ output_follow: true,+ output_scroll_offset: 0,+ last_output_height: 0,session_table_state,- }+ };+ dashboard.sync_selected_output();+ dashboard}pub fn render(&mut self, frame: &mut Frame) {@@ -188,12 +210,21 @@ impl Dashboard {frame.render_stateful_widget(table, chunks[1], &mut self.session_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- )+ fn render_output(&mut self, frame: &mut Frame, area: Rect) {+ self.sync_output_scroll(area.height.saturating_sub(2) as usize);++ let content = if self.sessions.get(self.selected_session).is_some() {+ let lines = self.selected_output_lines();++ if lines.is_empty() {+ "Waiting for session output...".to_string()+ } else {+ lines+ .iter()+ .map(|line| line.text.as_str())+ .collect::<Vec<_>>()+ .join("\n")+ }} else {"No sessions. Press 'n' to start one.".to_string()};@@ -204,12 +235,14 @@ impl Dashboard {Style::default()};- let paragraph = Paragraph::new(content).block(- Block::default()- .borders(Borders::ALL)- .title(" Output ")- .border_style(border_style),- );+ let paragraph = Paragraph::new(content)+ .block(+ Block::default()+ .borders(Borders::ALL)+ .title(" Output ")+ .border_style(border_style),+ )+ .scroll((self.output_scroll_offset as u16, 0));frame.render_widget(paragraph, area);}@@ -264,7 +297,7 @@ impl Dashboard {}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 text = " [n]ew session [s]top [r]efresh [Tab] switch pane [j/k] scroll [?] help [q]uit ";let aggregate = self.aggregate_usage();let (summary_text, summary_style) = self.aggregate_cost_summary();let block = Block::default()@@ -338,22 +371,48 @@ impl Dashboard {}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);- self.session_table_state.select(Some(self.selected_session));- } else {- self.scroll_offset = self.scroll_offset.saturating_add(1);+ match self.selected_pane {+ Pane::Sessions if !self.sessions.is_empty() => {+ self.selected_session = (self.selected_session + 1).min(self.sessions.len() - 1);+ self.sync_selection();+ self.reset_output_view();+ self.sync_selected_output();+ }+ Pane::Output => {+ let max_scroll = self.max_output_scroll();+ if self.output_follow {+ return;+ }++ if self.output_scroll_offset >= max_scroll.saturating_sub(1) {+ self.output_follow = true;+ self.output_scroll_offset = max_scroll;+ } else {+ self.output_scroll_offset = self.output_scroll_offset.saturating_add(1);+ }+ }+ Pane::Metrics => {}+ Pane::Sessions => {}}}pub fn scroll_up(&mut self) {- if self.selected_pane == Pane::Sessions {- self.selected_session = self.selected_session.saturating_sub(1);- if !self.sessions.is_empty() {- self.session_table_state.select(Some(self.selected_session));+ match self.selected_pane {+ Pane::Sessions => {+ self.selected_session = self.selected_session.saturating_sub(1);+ self.sync_selection();+ self.reset_output_view();+ self.sync_selected_output();}- } else {- self.scroll_offset = self.scroll_offset.saturating_sub(1);+ Pane::Output => {+ if self.output_follow {+ self.output_follow = false;+ self.output_scroll_offset = self.max_output_scroll();+ }++ self.output_scroll_offset = self.output_scroll_offset.saturating_sub(1);+ }+ Pane::Metrics => {}}}@@ -363,14 +422,16 @@ impl Dashboard {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);+ if let Err(error) = self.db.update_state(&session.id, &SessionState::Stopped) {+ tracing::warn!("Failed to stop session {}: {error}", session.id);+ return;+ }self.refresh();}}pub fn refresh(&mut self) {- self.sessions = self.db.list_sessions().unwrap_or_default();- self.sync_selection();+ self.sync_from_store();}pub fn toggle_help(&mut self) {@@ -378,8 +439,29 @@ impl Dashboard {}pub async fn tick(&mut self) {- self.sessions = self.db.list_sessions().unwrap_or_default();- self.sync_selection();+ loop {+ match self.output_rx.try_recv() {+ Ok(_event) => {}+ Err(broadcast::error::TryRecvError::Empty) => break,+ Err(broadcast::error::TryRecvError::Lagged(_)) => continue,+ Err(broadcast::error::TryRecvError::Closed) => break,+ }+ }++ self.sync_from_store();+ }++ fn sync_from_store(&mut self) {+ let selected_id = self.selected_session_id().map(ToOwned::to_owned);+ self.sessions = match self.db.list_sessions() {+ Ok(sessions) => sessions,+ Err(error) => {+ tracing::warn!("Failed to refresh sessions: {error}");+ Vec::new()+ }+ };+ self.sync_selection_by_id(selected_id.as_deref());+ self.sync_selected_output();}fn sync_selection(&mut self) {@@ -392,6 +474,68 @@ impl Dashboard {}}+ fn sync_selection_by_id(&mut self, selected_id: Option<&str>) {+ if let Some(selected_id) = selected_id {+ if let Some(index) = self.sessions.iter().position(|session| session.id == selected_id) {+ self.selected_session = index;+ }+ }+ self.sync_selection();+ }++ fn sync_selected_output(&mut self) {+ let Some(session_id) = self.selected_session_id().map(ToOwned::to_owned) else {+ self.output_scroll_offset = 0;+ self.output_follow = true;+ return;+ };++ match self.db.get_output_lines(&session_id, OUTPUT_BUFFER_LIMIT) {+ Ok(lines) => {+ self.output_store.replace_lines(&session_id, lines.clone());+ self.session_output_cache.insert(session_id, lines);+ }+ Err(error) => {+ tracing::warn!("Failed to load session output: {error}");+ }+ }+ }++ fn selected_session_id(&self) -> Option<&str> {+ self.sessions+ .get(self.selected_session)+ .map(|session| session.id.as_str())+ }++ fn selected_output_lines(&self) -> &[OutputLine] {+ self.selected_session_id()+ .and_then(|session_id| self.session_output_cache.get(session_id))+ .map(Vec::as_slice)+ .unwrap_or(&[])+ }++ fn sync_output_scroll(&mut self, viewport_height: usize) {+ self.last_output_height = viewport_height.max(1);+ let max_scroll = self.max_output_scroll();++ if self.output_follow {+ self.output_scroll_offset = max_scroll;+ } else {+ self.output_scroll_offset = self.output_scroll_offset.min(max_scroll);+ }+ }++ fn max_output_scroll(&self) -> usize {+ self.selected_output_lines()+ .len()+ .saturating_sub(self.last_output_height.max(1))+ }++ fn reset_output_view(&mut self) {+ self.output_follow = true;+ self.output_scroll_offset = 0;+ }+fn aggregate_usage(&self) -> AggregateUsage {let total_tokens = self.sessions@@ -457,9 +601,19 @@ impl Dashboard {(text, aggregate.overall_state.style())}+ #[cfg(test)]fn aggregate_cost_summary_text(&self) -> String {self.aggregate_cost_summary().0}++ #[cfg(test)]+ fn selected_output_text(&self) -> String {+ self.selected_output_lines()+ .iter()+ .map(|line| line.text.clone())+ .collect::<Vec<_>>()+ .join("\n")+ }}impl SessionSummary {@@ -564,89 +718,12 @@ fn format_duration(duration_secs: u64) -> String {#[cfg(test)]mod tests {- use std::path::{Path, PathBuf};-+ use anyhow::Result;use chrono::Utc;- use ratatui::{backend::TestBackend, widgets::TableState, Terminal};+ use ratatui::{backend::TestBackend, Terminal};+ use uuid::Uuid;use super::*;- use crate::config::Config;- use crate::session::store::StateStore;- use crate::session::{SessionMetrics, WorktreeInfo};- use crate::tui::widgets::BudgetState;-- #[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() {@@ -673,7 +750,6 @@ mod tests {);let rendered = render_dashboard_text(dashboard, 150, 24);-assert!(rendered.contains("ID"));assert!(rendered.contains("Agent"));assert!(rendered.contains("State"));@@ -690,96 +766,158 @@ mod tests {}#[test]- fn sync_selection_preserves_table_offset_for_selected_rows() {- let mut 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,+ fn aggregate_cost_summary_mentions_total_cost() {+ let db = StateStore::open(Path::new(":memory:")).unwrap();+ let mut cfg = Config::default();+ cfg.cost_budget_usd = 10.0;++ let mut dashboard = Dashboard::new(db, cfg);+ dashboard.sessions = vec![budget_session("sess-1", 3_500, 8.25)];++ assert_eq!(+ dashboard.aggregate_cost_summary_text(),+ "Aggregate cost $8.25 / $10.00 | Budget warning");- *dashboard.session_table_state.offset_mut() = 3;+ }++ #[test]+ fn refresh_preserves_selected_session_by_id() -> Result<()> {+ let db_path = std::env::temp_dir().join(format!("ecc2-dashboard-{}.db", Uuid::new_v4()));+ let db = StateStore::open(&db_path)?;+ let now = Utc::now();++ db.insert_session(&Session {+ id: "older".to_string(),+ task: "older".to_string(),+ agent_type: "claude".to_string(),+ state: SessionState::Idle,+ pid: None,+ worktree: None,+ created_at: now,+ updated_at: now,+ metrics: SessionMetrics::default(),+ })?;++ db.insert_session(&Session {+ id: "newer".to_string(),+ task: "newer".to_string(),+ agent_type: "claude".to_string(),+ state: SessionState::Running,+ pid: None,+ worktree: None,+ created_at: now,+ updated_at: now + chrono::Duration::seconds(1),+ metrics: SessionMetrics::default(),+ })?;+ let mut dashboard = Dashboard::new(db, Config::default());+ dashboard.selected_session = 1;dashboard.sync_selection();+ dashboard.refresh();- assert_eq!(dashboard.session_table_state.selected(), Some(1));- assert_eq!(dashboard.session_table_state.offset(), 3);+ assert_eq!(dashboard.selected_session_id(), Some("older"));+ let _ = std::fs::remove_file(db_path);+ Ok(())}#[test]- fn aggregate_usage_sums_tokens_and_cost_with_warning_state() {- let db = StateStore::open(Path::new(":memory:")).unwrap();- let mut cfg = Config::default();- cfg.token_budget = 10_000;- cfg.cost_budget_usd = 10.0;+ fn metrics_scroll_does_not_mutate_output_scroll() -> Result<()> {+ let db_path = std::env::temp_dir().join(format!("ecc2-dashboard-{}.db", Uuid::new_v4()));+ let db = StateStore::open(&db_path)?;+ let now = Utc::now();- let mut dashboard = Dashboard::new(db, cfg);- dashboard.sessions = vec![- budget_session("sess-1", 4_000, 3.50),- budget_session("sess-2", 4_500, 4.80),- ];+ db.insert_session(&Session {+ id: "session-1".to_string(),+ task: "inspect output".to_string(),+ agent_type: "claude".to_string(),+ state: SessionState::Running,+ pid: None,+ worktree: None,+ created_at: now,+ updated_at: now,+ metrics: SessionMetrics::default(),+ })?;- let aggregate = dashboard.aggregate_usage();+ for index in 0..6 {+ db.append_output_line("session-1", OutputStream::Stdout, &format!("line {index}"))?;+ }++ let mut dashboard = Dashboard::new(db, Config::default());+ dashboard.selected_pane = Pane::Output;+ dashboard.refresh();+ dashboard.sync_output_scroll(3);+ dashboard.scroll_up();+ let previous_scroll = dashboard.output_scroll_offset;++ dashboard.selected_pane = Pane::Metrics;+ dashboard.scroll_up();+ dashboard.scroll_down();- assert_eq!(aggregate.total_tokens, 8_500);- assert!((aggregate.total_cost_usd - 8.30).abs() < 1e-9);- assert_eq!(aggregate.token_state, BudgetState::Warning);- assert_eq!(aggregate.cost_state, BudgetState::Warning);- assert_eq!(aggregate.overall_state, BudgetState::Warning);+ assert_eq!(dashboard.output_scroll_offset, previous_scroll);+ let _ = std::fs::remove_file(db_path);+ Ok(())}#[test]- fn aggregate_cost_summary_mentions_total_cost() {- let db = StateStore::open(Path::new(":memory:")).unwrap();- let mut cfg = Config::default();- cfg.cost_budget_usd = 10.0;+ fn refresh_loads_selected_session_output_and_follows_tail() -> Result<()> {+ let db_path = std::env::temp_dir().join(format!("ecc2-dashboard-{}.db", Uuid::new_v4()));+ let db = StateStore::open(&db_path)?;+ let now = Utc::now();- let mut dashboard = Dashboard::new(db, cfg);- dashboard.sessions = vec![budget_session("sess-1", 3_500, 8.25)];+ db.insert_session(&Session {+ id: "session-1".to_string(),+ task: "tail output".to_string(),+ agent_type: "claude".to_string(),+ state: SessionState::Running,+ pid: None,+ worktree: None,+ created_at: now,+ updated_at: now,+ metrics: SessionMetrics::default(),+ })?;- assert_eq!(- dashboard.aggregate_cost_summary_text(),- "Aggregate cost $8.25 / $10.00 | Budget warning"- );+ for index in 0..12 {+ db.append_output_line("session-1", OutputStream::Stdout, &format!("line {index}"))?;+ }++ let mut dashboard = Dashboard::new(db, Config::default());+ dashboard.selected_pane = Pane::Output;+ dashboard.refresh();+ dashboard.sync_output_scroll(4);++ assert_eq!(dashboard.output_scroll_offset, 8);+ assert!(dashboard.selected_output_text().contains("line 11"));++ let _ = std::fs::remove_file(db_path);+ Ok(())}fn test_dashboard(sessions: Vec<Session>, selected_session: usize) -> Dashboard {let selected_session = selected_session.min(sessions.len().saturating_sub(1));+ let output_store = SessionOutputStore::default();+ let output_rx = output_store.subscribe();let mut session_table_state = TableState::default();if !sessions.is_empty() {session_table_state.select(Some(selected_session));}Dashboard {- db: test_store(),+ db: StateStore::open(Path::new(":memory:")).expect("open test db"),cfg: Config::default(),+ output_store,+ output_rx,sessions,+ session_output_cache: HashMap::new(),selected_pane: Pane::Sessions,selected_session,show_help: false,- scroll_offset: 0,+ output_follow: true,+ output_scroll_offset: 0,+ last_output_height: 0,session_table_state,}}- fn test_store() -> StateStore {- StateStore::open(Path::new(":memory:")).expect("open test db")- }-fn sample_session(id: &str,agent_type: &str,