feat(tui): add usage overlay and sidebar for displaying usage statistics and tasks

feat(tui): implement status bar with connection and turn state indicators
feat(tui): create workflow panel for agent status and progress visualization
feat(web): introduce web frontend interface with static file serving
feat(ws): add WebSocket interface for real-time communication and session management

apps/interfaces/tui/src/run.rs

@@ -0,0 +1,158 @@
+//! TUI event loop — single-process mode entry point.
+//!
+//! Provides `run_single_process()` which sets up the terminal,
+//! creates a session, and enters the render/input loop.
+//!
+//! Flow: create session + lock → enable raw mode + alternate screen →
+//! run_loop (render → poll events → handle key → tick) →
+//! restore terminal → save settings → release lock.
+
+use anyhow::Result;
+use crossterm::execute;
+use crossterm::event::{DisableBracketedPaste, DisableMouseCapture, Event, KeyEventKind, MouseEventKind};
+use crossterm::terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen};
+use ratatui::backend::CrosstermBackend;
+use ratatui::Terminal;
+use std::io::{self, Write};
+use std::time::Duration;
+
+use crate::action::{apply_action, Action};
+use crate::controller::input::handle_key;
+use crate::state::AppStateRest;
+use crate::view;
+
+/// Run zesdex as a self-contained TUI + agent loop in one process.
+///
+/// Flow: build `AppStateRest` → enter raw mode / alternate screen →
+/// run the event loop → always restore the terminal (even on error) →
+/// save settings.
+pub fn run_single_process() -> Result<()> {
+    // Create session state
+    let (_store, mut state, _rt) = create_local_session()?;
+
+    // Enter raw mode and alternate screen for the TUI
+    enable_raw_mode()?;
+    let mut stdout = io::stdout();
+    execute!(stdout, EnterAlternateScreen)?;
+    execute!(stdout, crossterm::event::EnableBracketedPaste)?;
+    execute!(stdout, crossterm::event::EnableMouseCapture)?;
+    let backend = CrosstermBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+    terminal.clear()?;
+
+    let run_result = run_loop(&mut state, &mut terminal);
+
+    let mut restore_stdout = io::stdout();
+    let _ = execute!(restore_stdout, DisableBracketedPaste);
+    let _ = execute!(restore_stdout, DisableMouseCapture);
+    let _ = execute!(restore_stdout, LeaveAlternateScreen);
+    let _ = disable_raw_mode();
+
+    if let Err(e) = run_result {
+        let _ = writeln!(restore_stdout, "error: {e}");
+        let _ = restore_stdout.flush();
+    }
+
+    // Save settings
+    state.save_settings();
+
+    Ok(())
+}
+
+/// Run the event loop, guaranteeing terminal restoration on error.
+fn run_loop(
+    state: &mut AppStateRest,
+    terminal: &mut Terminal<CrosstermBackend<io::Stdout>>,
+) -> Result<()> {
+    let result = run_loop_inner(state, terminal);
+    if let Err(ref _e) = result {
+        let _ = terminal.clear();
+        let _ = disable_raw_mode();
+        let _ = execute!(io::stdout(), DisableBracketedPaste);
+        let _ = execute!(io::stdout(), DisableMouseCapture);
+        let _ = execute!(io::stdout(), LeaveAlternateScreen);
+    }
+    result
+}
+
+/// The core single-process render/input loop.
+fn run_loop_inner(
+    state: &mut AppStateRest,
+    terminal: &mut Terminal<CrosstermBackend<io::Stdout>>,
+) -> Result<()> {
+    loop {
+        if state.quit {
+            break;
+        }
+        let now_ms = chrono::Utc::now().timestamp_millis();
+        state.misc.drain_expired_toasts(now_ms);
+        terminal.draw(|f| {
+            view::draw(f, state);
+            state.dirty = false;
+        })?;
+
+        // Poll terminal with 50 ms timeout
+        if crossterm::event::poll(Duration::from_millis(50))? {
+            match crossterm::event::read()? {
+                Event::Key(key) => {
+                    if key.kind == KeyEventKind::Press || key.kind == KeyEventKind::Repeat {
+                        let actions = handle_key(key, state);
+                        for action in actions {
+                            apply_action(state, action);
+                        }
+                        if let Some(text) = state.misc.pending_clipboard_copy.take() {
+                            let _ = zesdex_infrastructure::utils::write_osc52(&mut io::stdout(), &text);
+                            state.push_toast(zesdex_infrastructure::Toast::new(
+                                zesdex_infrastructure::ToastKind::Success,
+                                "Copied to clipboard".to_string(),
+                            ));
+                        }
+                    }
+                }
+                Event::Paste(text) => {
+                    if state.input.autocomplete_visible {
+                        state.input.close_autocomplete();
+                    }
+                    state.input.buffer.insert_str(state.input.cursor, &text);
+                    state.input.cursor += text.len();
+                    if state.input.buffer.starts_with('/') {
+                        state.input.open_autocomplete();
+                    }
+                    state.dirty = true;
+                }
+                Event::Resize(w, h) => {
+                    apply_action(state, Action::Resize(w, h));
+                }
+                Event::Mouse(mouse_event) => {
+                    if mouse_event.kind == MouseEventKind::ScrollUp {
+                        apply_action(state, Action::ScrollUp);
+                    } else if mouse_event.kind == MouseEventKind::ScrollDown {
+                        apply_action(state, Action::ScrollDown);
+                    }
+                }
+                _ => {}
+            }
+        }
+        // Tick always fires each iteration
+        apply_action(state, Action::Tick);
+    }
+    terminal.clear()?;
+    Ok(())
+}
+
+/// Create session state for single-process mode.
+fn create_local_session() -> Result<(zesdex_domain::core::Store, AppStateRest, tokio::runtime::Runtime)> {
+    let store = zesdex_domain::core::Store::new();
+    store.ensure_dirs()?;
+
+    let session_id = uuid::Uuid::new_v4().to_string();
+    let session_dir = store.base_dir.join("sessions").join(&session_id);
+    std::fs::create_dir_all(&session_dir)?;
+
+    let workspace_roots = vec![std::env::current_dir()?];
+    let state = AppStateRest::new(workspace_roots, &session_dir, store.memory_dir.clone());
+
+    let rt = tokio::runtime::Runtime::new()?;
+
+    Ok((store, state, rt))
+}