Implementation Plan

Phase 1: Minimal Conversation Loop

Done when: Multi-turn streaming conversation with Claude works in terminal

StreamEvent enum: TextDelta(String), InputTokens(u32), OutputTokens(u32), Done, Error(String)
UserAction enum (TUI → core channel): SendMessage(String), Quit
UIEvent enum (core → TUI channel): StreamDelta(String), TurnComplete, Error(String)
ConversationMessage struct: role: Role, content: String
All types derive Debug; all public types have doc comments

ModelProvider trait: async fn stream(&self, messages: &[ConversationMessage]) -> impl Stream<Item = StreamEvent>
ClaudeProvider struct: API key from env, reqwest HTTP client
Serialize messages to Anthropic Messages API JSON format
Parse SSE byte stream → StreamEvent (handle content_block_delta, message_delta for tokens, message_stop)
Unit tests: SSE parsing from hardcoded byte fixtures in #[cfg(test)]

ConversationHistory: Vec<ConversationMessage> with push and messages() (flat list, no tree yet)
Orchestrator struct holding history, provider, channel senders/receivers
Orchestrator loop:
1. Await UserAction from TUI channel
2. On SendMessage: append user message, call provider.stream()
3. Forward each StreamEvent as UIEvent to TUI
4. Accumulate deltas into assistant message; append to history on Done
5. On Quit: break loop

AppState struct: messages: Vec<(Role, String)>, input: String, scroll: u16
Ratatui layout: full-height Paragraph output area (scrollable) + single-line Paragraph input
Insert mode only — printable chars append to input, Enter sends UserAction::SendMessage, Backspace deletes
On UIEvent::StreamDelta: append to last assistant message in messages, re-render
On UIEvent::TurnComplete: finalize assistant message
Crossterm raw mode enter/exit; restore terminal on panic or clean exit

main.rs: parse --project-dir <path> CLI arg
Initialize tracing_subscriber (log to file, not stdout — avoids TUI interference)
Create tokio::sync::mpsc channel pair for UserAction and UIEvent
Spawn Orchestrator::run() as a tokio task
Run TUI event loop on main thread (Ratatui requires main thread for crossterm)
On UserAction::Quit or Ctrl-C: signal orchestrator shutdown, restore terminal, exit cleanly

Provider: SSE byte fixture → correct StreamEvent sequence
Provider: ConversationMessage vec → correct Anthropic API JSON shape
Core: ConversationHistory push/read roundtrip
Core: Orchestrator state transitions against mock StreamEvent sequence (no real API)

Tool trait, ToolRegistry, core tools (read_file, write_file, shell_exec)
Tool definitions in API requests, parse tool-use responses
Approval gate: core → TUI pending event → user approve/deny → result back
Working directory confinement + path validation (no Landlock yet)
Done when: Claude can read, modify files, and run commands with user approval