feat(v2): complete multi-LLM providers, TUI redesign, and advanced agent features

Multi-LLM Provider Support:
- Add llm-core crate with LlmProvider trait abstraction
- Implement Anthropic Claude API client with streaming
- Implement OpenAI API client with streaming
- Add token counting with SimpleTokenCounter and ClaudeTokenCounter
- Add retry logic with exponential backoff and jitter

Borderless TUI Redesign:
- Rewrite theme system with terminal capability detection (Full/Unicode256/Basic)
- Add provider tabs component with keybind switching [1]/[2]/[3]
- Implement vim-modal input (Normal/Insert/Visual/Command modes)
- Redesign chat panel with timestamps and streaming indicators
- Add multi-provider status bar with cost tracking
- Add Nerd Font icons with graceful ASCII fallbacks
- Add syntax highlighting (syntect) and markdown rendering (pulldown-cmark)

Advanced Agent Features:
- Add system prompt builder with configurable components
- Enhance subagent orchestration with parallel execution
- Add git integration module for safe command detection
- Add streaming tool results via channels
- Expand tool set: AskUserQuestion, TodoWrite, LS, MultiEdit, BashOutput, KillShell
- Add WebSearch with provider abstraction

Plugin System Enhancement:
- Add full agent definition parsing from YAML frontmatter
- Add skill system with progressive disclosure
- Wire plugin hooks into HookManager

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Cargo.toml

@@ -3,16 +3,21 @@ members = [
     "crates/app/cli",
     "crates/app/ui",
     "crates/core/agent",
+    "crates/llm/core",
+    "crates/llm/anthropic",
     "crates/llm/ollama",
+    "crates/llm/openai",
     "crates/platform/config",
     "crates/platform/hooks",
     "crates/platform/permissions",
     "crates/platform/plugins",
+    "crates/tools/ask",
     "crates/tools/bash",
     "crates/tools/fs",
     "crates/tools/notebook",
     "crates/tools/slash",
     "crates/tools/task",
+    "crates/tools/todo",
     "crates/tools/web",
     "crates/integration/mcp-client",
 ]

crates/app/cli/Cargo.toml

@@ -12,6 +12,7 @@ serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 color-eyre = "0.6"
 agent-core = { path = "../../core/agent" }
+llm-core = { path = "../../llm/core" }
 llm-ollama = { path = "../../llm/ollama" }
 tools-fs = { path = "../../tools/fs" }
 tools-bash = { path = "../../tools/bash" }
@@ -19,6 +20,7 @@ tools-slash = { path = "../../tools/slash" }
 config-agent = { package = "config-agent", path = "../../platform/config" }
 permissions = { path = "../../platform/permissions" }
 hooks = { path = "../../platform/hooks" }
+plugins = { path = "../../platform/plugins" }
 ui = { path = "../ui" }
 atty = "0.2"
 futures-util = "0.3.31"

crates/app/cli/src/main.rs

@@ -2,8 +2,10 @@ use clap::{Parser, ValueEnum};
 use color_eyre::eyre::{Result, eyre};
 use config_agent::load_settings;
 use hooks::{HookEvent, HookManager, HookResult};
-use llm_ollama::{OllamaClient, OllamaOptions};
+use llm_core::ChatOptions;
+use llm_ollama::OllamaClient;
 use permissions::{PermissionDecision, Tool};
+use plugins::PluginManager;
 use serde::Serialize;
 use std::io::Write;
 use std::time::{SystemTime, UNIX_EPOCH};
@@ -48,6 +50,51 @@ struct StreamEvent {
     stats: Option<Stats>,
 }
 
+/// Application context shared across the session
+pub struct AppContext {
+    pub plugin_manager: PluginManager,
+    pub config: config_agent::Settings,
+}
+
+impl AppContext {
+    pub fn new() -> Result<Self> {
+        let config = load_settings(None).unwrap_or_default();
+
+        let mut plugin_manager = PluginManager::new();
+        // Non-fatal: just log warnings, don't fail startup
+        if let Err(e) = plugin_manager.load_all() {
+            eprintln!("Warning: Failed to load some plugins: {}", e);
+        }
+
+        Ok(Self {
+            plugin_manager,
+            config,
+        })
+    }
+
+    /// Print loaded plugins and available commands
+    pub fn print_plugin_info(&self) {
+        let plugins = self.plugin_manager.plugins();
+        if !plugins.is_empty() {
+            println!("\nLoaded {} plugin(s):", plugins.len());
+            for plugin in plugins {
+                println!("  - {} v{}", plugin.manifest.name, plugin.manifest.version);
+                if let Some(desc) = &plugin.manifest.description {
+                    println!("    {}", desc);
+                }
+            }
+        }
+
+        let commands = self.plugin_manager.all_commands();
+        if !commands.is_empty() {
+            println!("\nAvailable plugin commands:");
+            for (name, _path) in &commands {
+                println!("  /{}", name);
+            }
+        }
+    }
+}
+
 fn generate_session_id() -> String {
     let timestamp = SystemTime::now()
         .duration_since(UNIX_EPOCH)
@@ -162,7 +209,10 @@ struct Args {
 async fn main() -> Result<()> {
     color_eyre::install()?;
     let args = Args::parse();
-    let mut settings = load_settings(None).unwrap_or_default();
+
+    // Initialize application context with plugins
+    let app_context = AppContext::new()?;
+    let mut settings = app_context.config.clone();
 
     // Override mode if specified via CLI
     if let Some(mode) = args.mode {
@@ -173,7 +223,16 @@ async fn main() -> Result<()> {
     let perms = settings.create_permission_manager();
 
     // Create hook manager
-    let hook_mgr = HookManager::new(".");
+    let mut hook_mgr = HookManager::new(".");
+
+    // Register plugin hooks
+    for plugin in app_context.plugin_manager.plugins() {
+        if let Ok(Some(hooks_config)) = plugin.load_hooks_config() {
+            for (event, command, pattern, timeout) in plugin.register_hooks_with_manager(&hooks_config) {
+                hook_mgr.register_hook(event, command, pattern, timeout);
+            }
+        }
+    }
 
     // Generate session ID
     let session_id = generate_session_id();
@@ -397,19 +456,20 @@ async fn main() -> Result<()> {
                             HookResult::Allow => {}
                         }
 
-                        // Look for command file in .owlen/commands/
+                        // Look for command file in .owlen/commands/ first
-                        let command_path = format!(".owlen/commands/{}.md", command_name);
+                        let local_command_path = format!(".owlen/commands/{}.md", command_name);
 
-                        // Read the command file
+                        // Try local commands first, then plugin commands
-                        let content = match tools_fs::read_file(&command_path) {
+                        let content = if let Ok(c) = tools_fs::read_file(&local_command_path) {
-                            Ok(c) => c,
+                            c
-                            Err(_) => {
+                        } else if let Some(plugin_path) = app_context.plugin_manager.all_commands().get(&command_name) {
-                                return Err(eyre!(
+                            // Found in plugins
-                                    "Slash command '{}' not found at {}",
+                            tools_fs::read_file(&plugin_path.to_string_lossy())?
-                                    command_name,
+                        } else {
-                                    command_path
+                            return Err(eyre!(
-                                ));
+                                "Slash command '{}' not found in .owlen/commands/ or plugins",
-                            }
+                                command_name
+                            ));
                         };
 
                         // Parse with arguments
@@ -452,16 +512,15 @@ async fn main() -> Result<()> {
         }
         client
     };
-    let opts = OllamaOptions {
+    let opts = ChatOptions::new(model);
-        model,
-        stream: true,
-    };
 
     // Check if interactive mode (no prompt provided)
     if args.prompt.is_empty() {
         // Use TUI mode unless --no-tui flag is set or not a TTY
         if !args.no_tui && atty::is(atty::Stream::Stdout) {
             // Launch TUI
+            // Note: For now, TUI doesn't use plugin manager directly
+            // In the future, we'll integrate plugin commands into TUI
             return ui::run(client, opts, perms, settings).await;
         }
 
@@ -469,6 +528,13 @@ async fn main() -> Result<()> {
         println!("🤖 Owlen Interactive Mode");
         println!("Model: {}", opts.model);
         println!("Mode: {:?}", settings.mode);
+
+        // Show loaded plugins
+        let plugins = app_context.plugin_manager.plugins();
+        if !plugins.is_empty() {
+            println!("Plugins: {} loaded", plugins.len());
+        }
+
         println!("Type your message or /help for commands. Press Ctrl+C to exit.\n");
 
         use std::io::{stdin, BufRead};
@@ -504,7 +570,17 @@ async fn main() -> Result<()> {
                             println!("  /checkpoints - List all saved checkpoints");
                             println!("  /rewind <id> - Restore session from checkpoint");
                             println!("  /clear       - Clear conversation history");
+                            println!("  /plugins     - Show loaded plugins and commands");
                             println!("  /exit        - Exit interactive mode");
+
+                            // Show plugin commands if any are loaded
+                            let plugin_commands = app_context.plugin_manager.all_commands();
+                            if !plugin_commands.is_empty() {
+                                println!("\n📦 Plugin Commands:");
+                                for (name, _path) in &plugin_commands {
+                                    println!("  /{}", name);
+                                }
+                            }
                         }
                         "/status" => {
                             println!("\n📊 Session Status:");
@@ -615,6 +691,41 @@ async fn main() -> Result<()> {
                             stats = agent_core::SessionStats::new();
                             println!("\n🗑️  Session history cleared!");
                         }
+                        "/plugins" => {
+                            let plugins = app_context.plugin_manager.plugins();
+                            if plugins.is_empty() {
+                                println!("\n📦 No plugins loaded");
+                                println!("   Place plugins in:");
+                                println!("   - ~/.config/owlen/plugins (user plugins)");
+                                println!("   - .owlen/plugins (project plugins)");
+                            } else {
+                                println!("\n📦 Loaded Plugins:");
+                                for plugin in plugins {
+                                    println!("\n  {} v{}", plugin.manifest.name, plugin.manifest.version);
+                                    if let Some(desc) = &plugin.manifest.description {
+                                        println!("    {}", desc);
+                                    }
+                                    if let Some(author) = &plugin.manifest.author {
+                                        println!("    Author: {}", author);
+                                    }
+
+                                    let commands = plugin.all_command_names();
+                                    if !commands.is_empty() {
+                                        println!("    Commands: {}", commands.join(", "));
+                                    }
+
+                                    let agents = plugin.all_agent_names();
+                                    if !agents.is_empty() {
+                                        println!("    Agents: {}", agents.join(", "));
+                                    }
+
+                                    let skills = plugin.all_skill_names();
+                                    if !skills.is_empty() {
+                                        println!("    Skills: {}", skills.join(", "));
+                                    }
+                                }
+                            }
+                        }
                         "/exit" => {
                             println!("\n👋 Goodbye!");
                             break;
@@ -656,7 +767,8 @@ async fn main() -> Result<()> {
                 history.add_user_message(input.to_string());
                 let start = SystemTime::now();
 
-                match agent_core::run_agent_loop(&client, input, &opts, &perms).await {
+                let ctx = agent_core::ToolContext::new();
+                match agent_core::run_agent_loop(&client, input, &opts, &perms, &ctx).await {
                     Ok(response) => {
                         println!("\n{}", response);
                         history.add_assistant_message(response.clone());
@@ -683,15 +795,16 @@ async fn main() -> Result<()> {
     let start_time = SystemTime::now();
 
     // Handle different output formats
+    let ctx = agent_core::ToolContext::new();
     match output_format {
         OutputFormat::Text => {
             // Text format: Use agent orchestrator with tool calling
-            let response = agent_core::run_agent_loop(&client, &prompt, &opts, &perms).await?;
+            let response = agent_core::run_agent_loop(&client, &prompt, &opts, &perms, &ctx).await?;
             println!("{}", response);
         }
         OutputFormat::Json => {
             // JSON format: Use agent loop and output as JSON
-            let response = agent_core::run_agent_loop(&client, &prompt, &opts, &perms).await?;
+            let response = agent_core::run_agent_loop(&client, &prompt, &opts, &perms, &ctx).await?;
 
             let duration_ms = start_time.elapsed().unwrap().as_millis() as u64;
             let estimated_tokens = ((prompt.len() + response.len()) / 4) as u64;
@@ -724,7 +837,7 @@ async fn main() -> Result<()> {
             };
             println!("{}", serde_json::to_string(&session_start)?);
 
-            let response = agent_core::run_agent_loop(&client, &prompt, &opts, &perms).await?;
+            let response = agent_core::run_agent_loop(&client, &prompt, &opts, &perms, &ctx).await?;
 
             let chunk_event = StreamEvent {
                 event_type: "chunk".to_string(),

crates/app/cli/tests/chat_stream.rs

@@ -5,12 +5,6 @@ use predicates::prelude::PredicateBooleanExt;
 #[tokio::test]
 async fn headless_streams_ndjson() {
     let server = MockServer::start_async().await;
-    // Mock /api/chat with NDJSON lines
-    let body = serde_json::json!({
-        "model": "qwen2.5",
-        "messages": [{"role": "user", "content": "hello"}],
-        "stream": true
-    });
 
     let response = concat!(
         r#"{"message":{"role":"assistant","content":"Hel"}}"#,"\n",
@@ -18,10 +12,11 @@ async fn headless_streams_ndjson() {
         r#"{"done":true}"#,"\n",
     );
 
+    // The CLI includes tools in the request, so we need to match any request to /api/chat
+    // instead of matching exact body (which includes tool definitions)
     let _m = server.mock(|when, then| {
         when.method(POST)
-            .path("/api/chat")
+            .path("/api/chat");
-            .json_body(body.clone());
         then.status(200)
             .header("content-type", "application/x-ndjson")
             .body(response);

crates/app/ui/Cargo.toml

@@ -15,9 +15,12 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 unicode-width = "0.2"
 textwrap = "0.16"
+syntect = { version = "5.0", default-features = false, features = ["default-syntaxes", "default-themes", "regex-onig"] }
+pulldown-cmark = "0.11"
 
 # Internal dependencies
 agent-core = { path = "../../core/agent" }
 permissions = { path = "../../platform/permissions" }
+llm-core = { path = "../../llm/core" }
 llm-ollama = { path = "../../llm/ollama" }
 config-agent = { path = "../../platform/config" }

crates/app/ui/src/app.rs

@@ -4,20 +4,30 @@ use crate::{
     layout::AppLayout,
     theme::Theme,
 };
-use agent_core::{CheckpointManager, SessionHistory, SessionStats, execute_tool, get_tool_definitions};
+use agent_core::{CheckpointManager, SessionHistory, SessionStats, ToolContext, execute_tool, get_tool_definitions};
 use color_eyre::eyre::Result;
 use crossterm::{
-    event::{Event, EventStream},
+    event::{Event, EventStream, EnableMouseCapture, DisableMouseCapture},
     terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
     ExecutableCommand,
 };
-use futures::{StreamExt, TryStreamExt};
+use futures::StreamExt;
-use llm_ollama::{ChatMessage as LLMChatMessage, OllamaClient, OllamaOptions};
+use llm_core::{ChatMessage as LLMChatMessage, ChatOptions};
-use permissions::PermissionManager;
+use llm_ollama::OllamaClient;
+use permissions::{Action, PermissionDecision, PermissionManager, Tool as PermTool};
 use ratatui::{backend::CrosstermBackend, Terminal};
+use serde_json::Value;
 use std::{io::stdout, path::PathBuf, time::SystemTime};
 use tokio::sync::mpsc;
 
+/// Holds information about a pending tool execution
+struct PendingToolCall {
+    tool_name: String,
+    arguments: Value,
+    perm_tool: PermTool,
+    context: Option<String>,
+}
+
 pub struct TuiApp {
     // UI components
     chat_panel: ChatPanel,
@@ -33,20 +43,23 @@ pub struct TuiApp {
 
     // System state
     client: OllamaClient,
-    opts: OllamaOptions,
+    opts: ChatOptions,
     perms: PermissionManager,
+    ctx: ToolContext,
     #[allow(dead_code)]
     settings: config_agent::Settings,
 
     // Runtime state
     running: bool,
     waiting_for_llm: bool,
+    pending_tool: Option<PendingToolCall>,
+    permission_tx: Option<tokio::sync::oneshot::Sender<bool>>,
 }
 
 impl TuiApp {
     pub fn new(
         client: OllamaClient,
-        opts: OllamaOptions,
+        opts: ChatOptions,
         perms: PermissionManager,
         settings: config_agent::Settings,
     ) -> Result<Self> {
@@ -65,9 +78,12 @@ impl TuiApp {
             client,
             opts,
             perms,
+            ctx: ToolContext::new(),
             settings,
             running: true,
             waiting_for_llm: false,
+            pending_tool: None,
+            permission_tx: None,
         })
     }
 
@@ -81,7 +97,9 @@ impl TuiApp {
     pub async fn run(&mut self) -> Result<()> {
         // Setup terminal
         enable_raw_mode()?;
-        stdout().execute(EnterAlternateScreen)?;
+        stdout()
+            .execute(EnterAlternateScreen)?
+            .execute(EnableMouseCapture)?;
 
         let backend = CrosstermBackend::new(stdout());
         let mut terminal = Terminal::new(backend)?;
@@ -95,15 +113,31 @@ impl TuiApp {
         tokio::spawn(async move {
             let mut reader = EventStream::new();
             while let Some(event) = reader.next().await {
-                if let Ok(Event::Key(key)) = event {
+                match event {
-                    if let Some(app_event) = handle_key_event(key) {
+                    Ok(Event::Key(key)) => {
-                        let _ = tx_clone.send(app_event);
+                        if let Some(app_event) = handle_key_event(key) {
+                            let _ = tx_clone.send(app_event);
+                        }
                     }
-                } else if let Ok(Event::Resize(w, h)) = event {
+                    Ok(Event::Mouse(mouse)) => {
-                    let _ = tx_clone.send(AppEvent::Resize {
+                        use crossterm::event::MouseEventKind;
-                        width: w,
+                        match mouse.kind {
-                        height: h,
+                            MouseEventKind::ScrollUp => {
-                    });
+                                let _ = tx_clone.send(AppEvent::ScrollUp);
+                            }
+                            MouseEventKind::ScrollDown => {
+                                let _ = tx_clone.send(AppEvent::ScrollDown);
+                            }
+                            _ => {}
+                        }
+                    }
+                    Ok(Event::Resize(w, h)) => {
+                        let _ = tx_clone.send(AppEvent::Resize {
+                            width: w,
+                            height: h,
+                        });
+                    }
+                    _ => {}
                 }
             }
         });
@@ -135,6 +169,9 @@ impl TuiApp {
                 let size = frame.area();
                 let layout = AppLayout::calculate(size);
 
+                // Update scroll position before rendering
+                self.chat_panel.update_scroll(layout.chat_area);
+
                 // Render main components
                 self.chat_panel.render(frame, layout.chat_area);
                 self.input_box.render(frame, layout.input_area);
@@ -157,7 +194,9 @@ impl TuiApp {
 
         // Cleanup terminal
         disable_raw_mode()?;
-        stdout().execute(LeaveAlternateScreen)?;
+        stdout()
+            .execute(LeaveAlternateScreen)?
+            .execute(DisableMouseCapture)?;
 
         Ok(())
     }
@@ -172,19 +211,98 @@ impl TuiApp {
                 // If permission popup is active, handle there first
                 if let Some(popup) = &mut self.permission_popup {
                     if let Some(option) = popup.handle_key(key) {
-                        // TODO: Handle permission decision
+                        use crate::components::PermissionOption;
-                        self.chat_panel.add_message(ChatMessage::System(
+
-                            format!("Permission: {:?}", option)
+                        match option {
-                        ));
+                            PermissionOption::AllowOnce => {
+                                self.chat_panel.add_message(ChatMessage::System(
+                                    "✓ Permission granted once".to_string()
+                                ));
+                                if let Some(tx) = self.permission_tx.take() {
+                                    let _ = tx.send(true);
+                                }
+                            }
+                            PermissionOption::AlwaysAllow => {
+                                // Add rule to permission manager
+                                if let Some(pending) = &self.pending_tool {
+                                    self.perms.add_rule(
+                                        pending.perm_tool,
+                                        pending.context.clone(),
+                                        Action::Allow,
+                                    );
+                                    self.chat_panel.add_message(ChatMessage::System(
+                                        format!("✓ Always allowed: {}", pending.tool_name)
+                                    ));
+                                }
+                                if let Some(tx) = self.permission_tx.take() {
+                                    let _ = tx.send(true);
+                                }
+                            }
+                            PermissionOption::Deny => {
+                                self.chat_panel.add_message(ChatMessage::System(
+                                    "✗ Permission denied".to_string()
+                                ));
+                                if let Some(tx) = self.permission_tx.take() {
+                                    let _ = tx.send(false);
+                                }
+                            }
+                            PermissionOption::Explain => {
+                                // Show explanation
+                                if let Some(pending) = &self.pending_tool {
+                                    let explanation = format!(
+                                        "Tool '{}' requires permission. This operation will {}.",
+                                        pending.tool_name,
+                                        match pending.tool_name.as_str() {
+                                            "read" => "read a file from disk",
+                                            "write" => "write or overwrite a file",
+                                            "edit" => "modify an existing file",
+                                            "bash" => "execute a shell command",
+                                            "grep" => "search for patterns in files",
+                                            "glob" => "list files matching a pattern",
+                                            _ => "perform an operation",
+                                        }
+                                    );
+                                    self.chat_panel.add_message(ChatMessage::System(explanation));
+                                }
+                                // Don't close popup, let user choose again
+                                return Ok(());
+                            }
+                        }
                         self.permission_popup = None;
+                        self.pending_tool = None;
                     }
                 } else {
-                    // Handle input box
+                    // Handle input box with vim-modal events
-                    if let Some(message) = self.input_box.handle_key(key) {
+                    use crate::components::InputEvent;
-                        self.handle_user_message(message, event_tx).await?;
+                    if let Some(event) = self.input_box.handle_key(key) {
+                        match event {
+                            InputEvent::Message(message) => {
+                                self.handle_user_message(message, event_tx).await?;
+                            }
+                            InputEvent::Command(cmd) => {
+                                // Commands from command mode (without /)
+                                self.handle_command(&format!("/{}", cmd))?;
+                            }
+                            InputEvent::ModeChange(mode) => {
+                                self.status_bar.set_vim_mode(mode);
+                            }
+                            InputEvent::Cancel => {
+                                // Cancel current operation
+                                self.waiting_for_llm = false;
+                            }
+                            InputEvent::Expand => {
+                                // TODO: Expand to multiline input
+                            }
+                        }
                     }
                 }
             }
+            AppEvent::ScrollUp => {
+                self.chat_panel.scroll_up(3);
+            }
+            AppEvent::ScrollDown => {
+                self.chat_panel.scroll_down(3);
+            }
             AppEvent::UserMessage(message) => {
                 self.chat_panel
                     .add_message(ChatMessage::User(message.clone()));
@@ -265,13 +383,101 @@ impl TuiApp {
         Ok(())
     }
 
+    /// Execute a tool with permission handling
+    ///
+    /// This method checks permissions and either:
+    /// - Executes the tool immediately if allowed
+    /// - Returns an error if denied by policy
+    /// - Shows a permission popup and waits for user decision if permission is needed
+    ///
+    /// The async wait for user decision works correctly because:
+    /// 1. The event loop continues running while we await the channel
+    /// 2. Keyboard events are processed by the separate event listener task
+    /// 3. When user responds to popup, the channel is signaled and we resume
+    ///
+    /// Returns Ok(result) if allowed and executed, Err if denied or failed
+    async fn execute_tool_with_permission(
+        &mut self,
+        tool_name: &str,
+        arguments: &Value,
+    ) -> Result<String> {
+        // Map tool name to permission tool enum
+        let perm_tool = match tool_name {
+            "read" => PermTool::Read,
+            "write" => PermTool::Write,
+            "edit" => PermTool::Edit,
+            "bash" => PermTool::Bash,
+            "grep" => PermTool::Grep,
+            "glob" => PermTool::Glob,
+            _ => PermTool::Read, // Default fallback
+        };
+
+        // Extract context from arguments
+        let context = match tool_name {
+            "read" | "write" | "edit" => arguments.get("path").and_then(|v| v.as_str()).map(String::from),
+            "bash" => arguments.get("command").and_then(|v| v.as_str()).map(String::from),
+            _ => None,
+        };
+
+        // Check permission
+        let decision = self.perms.check(perm_tool, context.as_deref());
+
+        match decision {
+            PermissionDecision::Allow => {
+                // Execute directly
+                execute_tool(tool_name, arguments, &self.perms, &self.ctx).await
+            }
+            PermissionDecision::Deny => {
+                Err(color_eyre::eyre::eyre!("Permission denied by policy"))
+            }
+            PermissionDecision::Ask => {
+                // Create channel for response
+                let (tx, rx) = tokio::sync::oneshot::channel();
+                self.permission_tx = Some(tx);
+
+                // Store pending tool info
+                self.pending_tool = Some(PendingToolCall {
+                    tool_name: tool_name.to_string(),
+                    arguments: arguments.clone(),
+                    perm_tool,
+                    context: context.clone(),
+                });
+
+                // Show permission popup
+                self.permission_popup = Some(PermissionPopup::new(
+                    tool_name.to_string(),
+                    context,
+                    self.theme.clone(),
+                ));
+
+                // Wait for user decision (with timeout)
+                match tokio::time::timeout(std::time::Duration::from_secs(300), rx).await {
+                    Ok(Ok(true)) => {
+                        // Permission granted, execute tool
+                        execute_tool(tool_name, arguments, &self.perms, &self.ctx).await
+                    }
+                    Ok(Ok(false)) => {
+                        // Permission denied
+                        Err(color_eyre::eyre::eyre!("Permission denied by user"))
+                    }
+                    Ok(Err(_)) => {
+                        // Channel closed without response
+                        Err(color_eyre::eyre::eyre!("Permission request cancelled"))
+                    }
+                    Err(_) => {
+                        // Timeout
+                        self.permission_popup = None;
+                        self.pending_tool = None;
+                        Err(color_eyre::eyre::eyre!("Permission request timed out"))
+                    }
+                }
+            }
+        }
+    }
+
     async fn run_streaming_agent_loop(&mut self, user_prompt: &str) -> Result<String> {
         let tools = get_tool_definitions();
-        let mut messages = vec![LLMChatMessage {
+        let mut messages = vec![LLMChatMessage::user(user_prompt)];
-            role: "user".to_string(),
-            content: Some(user_prompt.to_string()),
-            tool_calls: None,
-        }];
 
         let max_iterations = 10;
         let mut iteration = 0;
@@ -286,21 +492,61 @@ impl TuiApp {
                 break;
             }
 
-            // Call LLM with streaming
+            // Call LLM with streaming using the LlmProvider trait
-            let mut stream = self.client.chat_stream(&messages, &self.opts, Some(&tools)).await?;
+            use llm_core::LlmProvider;
+            let mut stream = self.client
+                .chat_stream(&messages, &self.opts, Some(&tools))
+                .await
+                .map_err(|e| color_eyre::eyre::eyre!("LLM provider error: {}", e))?;
+
             let mut response_content = String::new();
-            let mut tool_calls = None;
+            let mut accumulated_tool_calls: Vec<llm_core::ToolCall> = Vec::new();
 
             // Collect the streamed response
-            while let Some(chunk) = stream.try_next().await? {
+            while let Some(chunk) = stream.next().await {
-                if let Some(msg) = chunk.message {
+                let chunk = chunk.map_err(|e| color_eyre::eyre::eyre!("Stream error: {}", e))?;
-                    if let Some(content) = msg.content {
+
-                        response_content.push_str(&content);
+                if let Some(content) = chunk.content {
-                        // Stream chunks to UI - append to last assistant message
+                    response_content.push_str(&content);
-                        self.chat_panel.append_to_assistant(&content);
+                    // Stream chunks to UI - append to last assistant message
-                    }
+                    self.chat_panel.append_to_assistant(&content);
-                    if let Some(calls) = msg.tool_calls {
+                }
-                        tool_calls = Some(calls);
+
+                // Accumulate tool calls from deltas
+                if let Some(deltas) = chunk.tool_calls {
+                    for delta in deltas {
+                        // Ensure the accumulated_tool_calls vec is large enough
+                        while accumulated_tool_calls.len() <= delta.index {
+                            accumulated_tool_calls.push(llm_core::ToolCall {
+                                id: String::new(),
+                                call_type: "function".to_string(),
+                                function: llm_core::FunctionCall {
+                                    name: String::new(),
+                                    arguments: serde_json::Value::Null,
+                                },
+                            });
+                        }
+
+                        let tool_call = &mut accumulated_tool_calls[delta.index];
+
+                        if let Some(id) = delta.id {
+                            tool_call.id = id;
+                        }
+                        if let Some(name) = delta.function_name {
+                            tool_call.function.name = name;
+                        }
+                        if let Some(args_delta) = delta.arguments_delta {
+                            // Accumulate the arguments string
+                            let current_args = if tool_call.function.arguments.is_null() {
+                                String::new()
+                            } else {
+                                tool_call.function.arguments.to_string()
+                            };
+                            let new_args = current_args + &args_delta;
+                            // Try to parse as JSON, but keep as string if incomplete
+                            tool_call.function.arguments = serde_json::from_str(&new_args)
+                                .unwrap_or_else(|_| serde_json::Value::String(new_args));
+                        }
                     }
                 }
             }
@@ -312,21 +558,29 @@ impl TuiApp {
                 final_response = response_content.clone();
             }
 
+            // Filter out incomplete tool calls and check if we have valid ones
+            let valid_tool_calls: Vec<_> = accumulated_tool_calls
+                .into_iter()
+                .filter(|tc| !tc.id.is_empty() && !tc.function.name.is_empty())
+                .collect();
+
             // Check if LLM wants to call tools
-            if let Some(calls) = tool_calls {
+            if !valid_tool_calls.is_empty() {
                 // Add assistant message with tool calls to conversation
                 messages.push(LLMChatMessage {
-                    role: "assistant".to_string(),
+                    role: llm_core::Role::Assistant,
                     content: if response_content.is_empty() {
                         None
                     } else {
                         Some(response_content.clone())
                     },
-                    tool_calls: Some(calls.clone()),
+                    tool_calls: Some(valid_tool_calls.clone()),
+                    tool_call_id: None,
+                    name: None,
                 });
 
                 // Execute each tool call
-                for call in calls {
+                for call in valid_tool_calls {
                     let tool_name = &call.function.name;
                     let arguments = &call.function.arguments;
 
@@ -337,7 +591,7 @@ impl TuiApp {
                     });
                     self.stats.record_tool_call();
 
-                    match execute_tool(tool_name, arguments, &self.perms).await {
+                    match self.execute_tool_with_permission(tool_name, arguments).await {
                         Ok(result) => {
                             // Show success in UI
                             self.chat_panel.add_message(ChatMessage::ToolResult {
@@ -346,11 +600,7 @@ impl TuiApp {
                             });
 
                             // Add tool result to conversation
-                            messages.push(LLMChatMessage {
+                            messages.push(LLMChatMessage::tool_result(&call.id, result));
-                                role: "tool".to_string(),
-                                content: Some(result),
-                                tool_calls: None,
-                            });
                         }
                         Err(e) => {
                             let error_msg = format!("Error: {}", e);
@@ -362,11 +612,7 @@ impl TuiApp {
                             });
 
                             // Add error to conversation
-                            messages.push(LLMChatMessage {
+                            messages.push(LLMChatMessage::tool_result(&call.id, error_msg));
-                                role: "tool".to_string(),
-                                content: Some(error_msg),
-                                tool_calls: None,
-                            });
                         }
                     }
                 }

crates/app/ui/src/components/chat_panel.rs

@@ -1,12 +1,19 @@
+//! Borderless chat panel component
+//!
+//! Displays chat messages with proper indentation, timestamps,
+//! and streaming indicators. Uses whitespace instead of borders.
+
 use crate::theme::Theme;
 use ratatui::{
     layout::Rect,
     style::{Modifier, Style},
     text::{Line, Span, Text},
-    widgets::{Block, Borders, Padding, Paragraph, Scrollbar, ScrollbarOrientation, ScrollbarState},
+    widgets::{Paragraph, Scrollbar, ScrollbarOrientation, ScrollbarState},
     Frame,
 };
+use std::time::SystemTime;
 
+/// Chat message types
 #[derive(Debug, Clone)]
 pub enum ChatMessage {
     User(String),
@@ -16,176 +23,457 @@ pub enum ChatMessage {
     System(String),
 }
 
+impl ChatMessage {
+    /// Get a timestamp for when the message was created (for display)
+    pub fn timestamp_display() -> String {
+        let now = SystemTime::now();
+        let secs = now
+            .duration_since(SystemTime::UNIX_EPOCH)
+            .map(|d| d.as_secs())
+            .unwrap_or(0);
+        let hours = (secs / 3600) % 24;
+        let mins = (secs / 60) % 60;
+        format!("{:02}:{:02}", hours, mins)
+    }
+}
+
+/// Message with metadata for display
+#[derive(Debug, Clone)]
+pub struct DisplayMessage {
+    pub message: ChatMessage,
+    pub timestamp: String,
+    pub focused: bool,
+}
+
+impl DisplayMessage {
+    pub fn new(message: ChatMessage) -> Self {
+        Self {
+            message,
+            timestamp: ChatMessage::timestamp_display(),
+            focused: false,
+        }
+    }
+}
+
+/// Borderless chat panel
 pub struct ChatPanel {
-    messages: Vec<ChatMessage>,
+    messages: Vec<DisplayMessage>,
     scroll_offset: usize,
+    auto_scroll: bool,
+    total_lines: usize,
+    focused_index: Option<usize>,
+    is_streaming: bool,
     theme: Theme,
 }
 
 impl ChatPanel {
+    /// Create new borderless chat panel
     pub fn new(theme: Theme) -> Self {
         Self {
             messages: Vec::new(),
             scroll_offset: 0,
+            auto_scroll: true,
+            total_lines: 0,
+            focused_index: None,
+            is_streaming: false,
             theme,
         }
     }
 
+    /// Add a new message
     pub fn add_message(&mut self, message: ChatMessage) {
-        self.messages.push(message);
+        self.messages.push(DisplayMessage::new(message));
-        // Auto-scroll to bottom on new message
+        self.auto_scroll = true;
-        self.scroll_to_bottom();
+        self.is_streaming = false;
     }
 
-    /// Append content to the last assistant message, or create a new one if none exists
+    /// Append content to the last assistant message, or create a new one
     pub fn append_to_assistant(&mut self, content: &str) {
-        if let Some(ChatMessage::Assistant(last_content)) = self.messages.last_mut() {
+        if let Some(DisplayMessage {
+            message: ChatMessage::Assistant(last_content),
+            ..
+        }) = self.messages.last_mut()
+        {
             last_content.push_str(content);
         } else {
-            self.messages.push(ChatMessage::Assistant(content.to_string()));
+            self.messages.push(DisplayMessage::new(ChatMessage::Assistant(
+                content.to_string(),
+            )));
         }
-        // Auto-scroll to bottom on update
+        self.auto_scroll = true;
-        self.scroll_to_bottom();
+        self.is_streaming = true;
     }
 
-    pub fn scroll_up(&mut self) {
+    /// Set streaming state
-        self.scroll_offset = self.scroll_offset.saturating_sub(1);
+    pub fn set_streaming(&mut self, streaming: bool) {
+        self.is_streaming = streaming;
     }
 
-    pub fn scroll_down(&mut self) {
+    /// Scroll up
-        self.scroll_offset = self.scroll_offset.saturating_add(1);
+    pub fn scroll_up(&mut self, amount: usize) {
+        self.scroll_offset = self.scroll_offset.saturating_sub(amount);
+        self.auto_scroll = false;
     }
 
+    /// Scroll down
+    pub fn scroll_down(&mut self, amount: usize) {
+        self.scroll_offset = self.scroll_offset.saturating_add(amount);
+        let near_bottom_threshold = 5;
+        if self.total_lines > 0 {
+            let max_scroll = self.total_lines.saturating_sub(1);
+            if self.scroll_offset.saturating_add(near_bottom_threshold) >= max_scroll {
+                self.auto_scroll = true;
+            }
+        }
+    }
+
+    /// Scroll to bottom
     pub fn scroll_to_bottom(&mut self) {
-        self.scroll_offset = self.messages.len().saturating_sub(1);
+        self.scroll_offset = self.total_lines.saturating_sub(1);
+        self.auto_scroll = true;
     }
 
-    pub fn render(&self, frame: &mut Frame, area: Rect) {
+    /// Page up
-        let mut text_lines = Vec::new();
+    pub fn page_up(&mut self, page_size: usize) {
+        self.scroll_up(page_size.saturating_sub(2));
+    }
 
-        for message in &self.messages {
+    /// Page down
-            match message {
+    pub fn page_down(&mut self, page_size: usize) {
+        self.scroll_down(page_size.saturating_sub(2));
+    }
+
+    /// Focus next message
+    pub fn focus_next(&mut self) {
+        if self.messages.is_empty() {
+            return;
+        }
+        self.focused_index = Some(match self.focused_index {
+            Some(i) if i + 1 < self.messages.len() => i + 1,
+            Some(_) => 0,
+            None => 0,
+        });
+    }
+
+    /// Focus previous message
+    pub fn focus_previous(&mut self) {
+        if self.messages.is_empty() {
+            return;
+        }
+        self.focused_index = Some(match self.focused_index {
+            Some(0) => self.messages.len() - 1,
+            Some(i) => i - 1,
+            None => self.messages.len() - 1,
+        });
+    }
+
+    /// Clear focus
+    pub fn clear_focus(&mut self) {
+        self.focused_index = None;
+    }
+
+    /// Get focused message index
+    pub fn focused_index(&self) -> Option<usize> {
+        self.focused_index
+    }
+
+    /// Get focused message
+    pub fn focused_message(&self) -> Option<&ChatMessage> {
+        self.focused_index
+            .and_then(|i| self.messages.get(i))
+            .map(|m| &m.message)
+    }
+
+    /// Update scroll position before rendering
+    pub fn update_scroll(&mut self, area: Rect) {
+        self.total_lines = self.count_total_lines(area);
+
+        if self.auto_scroll {
+            let visible_height = area.height as usize;
+            let max_scroll = self.total_lines.saturating_sub(visible_height);
+            self.scroll_offset = max_scroll;
+        } else {
+            let visible_height = area.height as usize;
+            let max_scroll = self.total_lines.saturating_sub(visible_height);
+            self.scroll_offset = self.scroll_offset.min(max_scroll);
+        }
+    }
+
+    /// Count total lines for scroll calculation
+    fn count_total_lines(&self, area: Rect) -> usize {
+        let mut line_count = 0;
+        let wrap_width = area.width.saturating_sub(4) as usize;
+
+        for msg in &self.messages {
+            line_count += match &msg.message {
                 ChatMessage::User(content) => {
-                    text_lines.push(Line::from(vec![
+                    let wrapped = textwrap::wrap(content, wrap_width);
-                        Span::styled("❯ ", self.theme.user_message),
+                    wrapped.len() + 1 // +1 for spacing
-                        Span::styled(content, self.theme.user_message),
-                    ]));
-                    text_lines.push(Line::from(""));
                 }
                 ChatMessage::Assistant(content) => {
-                    // Wrap long lines
+                    let wrapped = textwrap::wrap(content, wrap_width);
-                    let wrapped = textwrap::wrap(content, area.width.saturating_sub(6) as usize);
+                    wrapped.len() + 1
-                    for (i, line) in wrapped.iter().enumerate() {
+                }
-                        if i == 0 {
+                ChatMessage::ToolCall { .. } => 2,
-                            text_lines.push(Line::from(vec![
+                ChatMessage::ToolResult { .. } => 2,
-                                Span::styled("  ", self.theme.assistant_message),
+                ChatMessage::System(_) => 1,
-                                Span::styled(line.to_string(), self.theme.assistant_message),
+            };
-                            ]));
+        }
+
+        line_count
+    }
+
+    /// Render the borderless chat panel
+    pub fn render(&self, frame: &mut Frame, area: Rect) {
+        let mut text_lines = Vec::new();
+        let wrap_width = area.width.saturating_sub(4) as usize;
+        let symbols = &self.theme.symbols;
+
+        for (idx, display_msg) in self.messages.iter().enumerate() {
+            let is_focused = self.focused_index == Some(idx);
+            let is_last = idx == self.messages.len() - 1;
+
+            match &display_msg.message {
+                ChatMessage::User(content) => {
+                    // User message: bright, with prefix
+                    let mut role_spans = vec![
+                        Span::styled("  ", Style::default()),
+                        Span::styled(
+                            format!("{} You", symbols.user_prefix),
+                            self.theme.user_message,
+                        ),
+                    ];
+
+                    // Timestamp right-aligned (we'll simplify for now)
+                    role_spans.push(Span::styled(
+                        format!("  {}", display_msg.timestamp),
+                        self.theme.timestamp,
+                    ));
+
+                    text_lines.push(Line::from(role_spans));
+
+                    // Message content with 2-space indent
+                    let wrapped = textwrap::wrap(content, wrap_width);
+                    for line in wrapped {
+                        let style = if is_focused {
+                            self.theme.user_message.add_modifier(Modifier::REVERSED)
                         } else {
-                            text_lines.push(Line::styled(
+                            self.theme.user_message.remove_modifier(Modifier::BOLD)
-                                format!("  {}", line),
+                        };
-                                self.theme.assistant_message,
+                        text_lines.push(Line::from(Span::styled(
-                            ));
+                            format!("  {}", line),
-                        }
+                            style,
+                        )));
                     }
+
+                    // Focus hints
+                    if is_focused {
+                        text_lines.push(Line::from(Span::styled(
+                            "  [y]copy [e]edit [r]retry",
+                            self.theme.status_dim,
+                        )));
+                    }
+
                     text_lines.push(Line::from(""));
                 }
+
+                ChatMessage::Assistant(content) => {
+                    // Assistant message: accent color
+                    let mut role_spans = vec![Span::styled("  ", Style::default())];
+
+                    // Streaming indicator
+                    if is_last && self.is_streaming {
+                        role_spans.push(Span::styled(
+                            format!("{} ", symbols.streaming),
+                            Style::default().fg(self.theme.palette.success),
+                        ));
+                    }
+
+                    role_spans.push(Span::styled(
+                        format!("{} Assistant", symbols.assistant_prefix),
+                        self.theme.assistant_message.add_modifier(Modifier::BOLD),
+                    ));
+
+                    role_spans.push(Span::styled(
+                        format!("  {}", display_msg.timestamp),
+                        self.theme.timestamp,
+                    ));
+
+                    text_lines.push(Line::from(role_spans));
+
+                    // Content
+                    let wrapped = textwrap::wrap(content, wrap_width);
+                    for line in wrapped {
+                        let style = if is_focused {
+                            self.theme.assistant_message.add_modifier(Modifier::REVERSED)
+                        } else {
+                            self.theme.assistant_message
+                        };
+                        text_lines.push(Line::from(Span::styled(
+                            format!("  {}", line),
+                            style,
+                        )));
+                    }
+
+                    // Focus hints
+                    if is_focused {
+                        text_lines.push(Line::from(Span::styled(
+                            "  [y]copy [r]retry",
+                            self.theme.status_dim,
+                        )));
+                    }
+
+                    text_lines.push(Line::from(""));
+                }
+
                 ChatMessage::ToolCall { name, args } => {
                     text_lines.push(Line::from(vec![
-                        Span::styled("  ⚡ ", self.theme.tool_call),
+                        Span::styled("  ", Style::default()),
                         Span::styled(
-                            format!("{} ", name),
+                            format!("{} ", symbols.tool_prefix),
                             self.theme.tool_call,
                         ),
+                        Span::styled(format!("{} ", name), self.theme.tool_call),
                         Span::styled(
-                            args,
+                            truncate_str(args, 60),
                             self.theme.tool_call.add_modifier(Modifier::DIM),
                         ),
                     ]));
+                    text_lines.push(Line::from(""));
                 }
+
                 ChatMessage::ToolResult { success, output } => {
                     let style = if *success {
                         self.theme.tool_result_success
                     } else {
                         self.theme.tool_result_error
                     };
-                    let icon = if *success { "  ✓" } else { "  ✗" };
+                    let icon = if *success {
-
+                        symbols.check
-                    // Truncate long output
-                    let display_output = if output.len() > 200 {
-                        format!("{}... [truncated]", &output[..200])
                     } else {
-                        output.clone()
+                        symbols.cross
                     };
 
                     text_lines.push(Line::from(vec![
-                        Span::styled(icon, style),
+                        Span::styled(format!("  {} ", icon), style),
-                        Span::raw(" "),
-                        Span::styled(display_output, style.add_modifier(Modifier::DIM)),
-                    ]));
-                    text_lines.push(Line::from(""));
-                }
-                ChatMessage::System(content) => {
-                    text_lines.push(Line::from(vec![
-                        Span::styled("  ○ ", Style::default().fg(self.theme.palette.info)),
                         Span::styled(
-                            content,
+                            truncate_str(output, 100),
-                            Style::default().fg(self.theme.palette.fg_dim),
+                            style.add_modifier(Modifier::DIM),
                         ),
                     ]));
                     text_lines.push(Line::from(""));
                 }
+
+                ChatMessage::System(content) => {
+                    text_lines.push(Line::from(vec![
+                        Span::styled("  ", Style::default()),
+                        Span::styled(
+                            format!("{} ", symbols.system_prefix),
+                            self.theme.system_message,
+                        ),
+                        Span::styled(content.to_string(), self.theme.system_message),
+                    ]));
+                }
             }
         }
 
         let text = Text::from(text_lines);
-
+        let paragraph = Paragraph::new(text).scroll((self.scroll_offset as u16, 0));
-        let block = Block::default()
-            .borders(Borders::ALL)
-            .border_style(self.theme.border_active)
-            .padding(Padding::horizontal(1))
-            .title(Line::from(vec![
-                Span::raw(" "),
-                Span::styled("💬", self.theme.border_active),
-                Span::raw(" "),
-                Span::styled("Chat", self.theme.border_active),
-                Span::raw(" "),
-            ]));
-
-        let paragraph = Paragraph::new(text)
-            .block(block)
-            .scroll((self.scroll_offset as u16, 0));
 
         frame.render_widget(paragraph, area);
 
         // Render scrollbar if needed
-        if self.messages.len() > area.height as usize {
+        if self.total_lines > area.height as usize {
             let scrollbar = Scrollbar::default()
                 .orientation(ScrollbarOrientation::VerticalRight)
-                .begin_symbol(Some("▲"))
+                .begin_symbol(None)
-                .end_symbol(Some("▼"))
+                .end_symbol(None)
-                .track_symbol(Some("│"))
+                .track_symbol(Some(" "))
-                .thumb_symbol("█")
+                .thumb_symbol("│")
-                .style(self.theme.border);
+                .style(self.theme.status_dim);
 
             let mut scrollbar_state = ScrollbarState::default()
-                .content_length(self.messages.len())
+                .content_length(self.total_lines)
                 .position(self.scroll_offset);
 
-            frame.render_stateful_widget(
+            frame.render_stateful_widget(scrollbar, area, &mut scrollbar_state);
-                scrollbar,
-                area,
-                &mut scrollbar_state,
-            );
         }
     }
 
-    pub fn messages(&self) -> &[ChatMessage] {
+    /// Get messages
+    pub fn messages(&self) -> &[DisplayMessage] {
         &self.messages
     }
 
+    /// Clear all messages
     pub fn clear(&mut self) {
         self.messages.clear();
         self.scroll_offset = 0;
+        self.focused_index = None;
+    }
+
+    /// Update theme
+    pub fn set_theme(&mut self, theme: Theme) {
+        self.theme = theme;
+    }
+}
+
+/// Truncate a string to max length with ellipsis
+fn truncate_str(s: &str, max_len: usize) -> String {
+    if s.len() <= max_len {
+        s.to_string()
+    } else {
+        format!("{}...", &s[..max_len.saturating_sub(3)])
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_chat_panel_add_message() {
+        let theme = Theme::default();
+        let mut panel = ChatPanel::new(theme);
+
+        panel.add_message(ChatMessage::User("Hello".to_string()));
+        panel.add_message(ChatMessage::Assistant("Hi there!".to_string()));
+
+        assert_eq!(panel.messages().len(), 2);
+    }
+
+    #[test]
+    fn test_append_to_assistant() {
+        let theme = Theme::default();
+        let mut panel = ChatPanel::new(theme);
+
+        panel.append_to_assistant("Hello");
+        panel.append_to_assistant(" world");
+
+        assert_eq!(panel.messages().len(), 1);
+        if let ChatMessage::Assistant(content) = &panel.messages()[0].message {
+            assert_eq!(content, "Hello world");
+        }
+    }
+
+    #[test]
+    fn test_focus_navigation() {
+        let theme = Theme::default();
+        let mut panel = ChatPanel::new(theme);
+
+        panel.add_message(ChatMessage::User("1".to_string()));
+        panel.add_message(ChatMessage::User("2".to_string()));
+        panel.add_message(ChatMessage::User("3".to_string()));
+
+        assert_eq!(panel.focused_index(), None);
+
+        panel.focus_next();
+        assert_eq!(panel.focused_index(), Some(0));
+
+        panel.focus_next();
+        assert_eq!(panel.focused_index(), Some(1));
+
+        panel.focus_previous();
+        assert_eq!(panel.focused_index(), Some(0));
     }
 }

crates/app/ui/src/components/input_box.rs

@@ -1,18 +1,40 @@
-use crate::theme::Theme;
+//! Vim-modal input component
-use crossterm::event::{KeyCode, KeyEvent};
+//!
+//! Borderless input with vim-like modes (Normal, Insert, Command).
+//! Uses mode prefix instead of borders for visual indication.
+
+use crate::theme::{Theme, VimMode};
+use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
 use ratatui::{
     layout::Rect,
     style::Style,
     text::{Line, Span},
-    widgets::{Block, Borders, Padding, Paragraph},
+    widgets::Paragraph,
     Frame,
 };
 
+/// Input event from the input box
+#[derive(Debug, Clone)]
+pub enum InputEvent {
+    /// User submitted a message
+    Message(String),
+    /// User submitted a command (without / prefix)
+    Command(String),
+    /// Mode changed
+    ModeChange(VimMode),
+    /// Request to cancel current operation
+    Cancel,
+    /// Request to expand input (multiline)
+    Expand,
+}
+
+/// Vim-modal input box
 pub struct InputBox {
     input: String,
     cursor_position: usize,
     history: Vec<String>,
     history_index: usize,
+    mode: VimMode,
     theme: Theme,
 }
 
@@ -23,12 +45,129 @@ impl InputBox {
             cursor_position: 0,
             history: Vec::new(),
             history_index: 0,
+            mode: VimMode::Insert, // Start in insert mode for familiarity
             theme,
         }
     }
 
-    pub fn handle_key(&mut self, key: KeyEvent) -> Option<String> {
+    /// Get current vim mode
+    pub fn mode(&self) -> VimMode {
+        self.mode
+    }
+
+    /// Set vim mode
+    pub fn set_mode(&mut self, mode: VimMode) {
+        self.mode = mode;
+    }
+
+    /// Handle key event, returns input event if action is needed
+    pub fn handle_key(&mut self, key: KeyEvent) -> Option<InputEvent> {
+        match self.mode {
+            VimMode::Normal => self.handle_normal_mode(key),
+            VimMode::Insert => self.handle_insert_mode(key),
+            VimMode::Command => self.handle_command_mode(key),
+            VimMode::Visual => self.handle_visual_mode(key),
+        }
+    }
+
+    /// Handle keys in normal mode
+    fn handle_normal_mode(&mut self, key: KeyEvent) -> Option<InputEvent> {
         match key.code {
+            // Enter insert mode
+            KeyCode::Char('i') => {
+                self.mode = VimMode::Insert;
+                Some(InputEvent::ModeChange(VimMode::Insert))
+            }
+            KeyCode::Char('a') => {
+                self.mode = VimMode::Insert;
+                if self.cursor_position < self.input.len() {
+                    self.cursor_position += 1;
+                }
+                Some(InputEvent::ModeChange(VimMode::Insert))
+            }
+            KeyCode::Char('I') => {
+                self.mode = VimMode::Insert;
+                self.cursor_position = 0;
+                Some(InputEvent::ModeChange(VimMode::Insert))
+            }
+            KeyCode::Char('A') => {
+                self.mode = VimMode::Insert;
+                self.cursor_position = self.input.len();
+                Some(InputEvent::ModeChange(VimMode::Insert))
+            }
+            // Enter command mode
+            KeyCode::Char(':') => {
+                self.mode = VimMode::Command;
+                self.input.clear();
+                self.cursor_position = 0;
+                Some(InputEvent::ModeChange(VimMode::Command))
+            }
+            // Navigation
+            KeyCode::Char('h') | KeyCode::Left => {
+                self.cursor_position = self.cursor_position.saturating_sub(1);
+                None
+            }
+            KeyCode::Char('l') | KeyCode::Right => {
+                if self.cursor_position < self.input.len() {
+                    self.cursor_position += 1;
+                }
+                None
+            }
+            KeyCode::Char('0') | KeyCode::Home => {
+                self.cursor_position = 0;
+                None
+            }
+            KeyCode::Char('$') | KeyCode::End => {
+                self.cursor_position = self.input.len();
+                None
+            }
+            KeyCode::Char('w') => {
+                // Jump to next word
+                self.cursor_position = self.next_word_position();
+                None
+            }
+            KeyCode::Char('b') => {
+                // Jump to previous word
+                self.cursor_position = self.prev_word_position();
+                None
+            }
+            // Editing
+            KeyCode::Char('x') => {
+                if self.cursor_position < self.input.len() {
+                    self.input.remove(self.cursor_position);
+                }
+                None
+            }
+            KeyCode::Char('d') => {
+                // Delete line (dd would require tracking, simplify to clear)
+                self.input.clear();
+                self.cursor_position = 0;
+                None
+            }
+            // History
+            KeyCode::Char('k') | KeyCode::Up => {
+                self.history_prev();
+                None
+            }
+            KeyCode::Char('j') | KeyCode::Down => {
+                self.history_next();
+                None
+            }
+            _ => None,
+        }
+    }
+
+    /// Handle keys in insert mode
+    fn handle_insert_mode(&mut self, key: KeyEvent) -> Option<InputEvent> {
+        match key.code {
+            KeyCode::Esc => {
+                self.mode = VimMode::Normal;
+                // Move cursor back when exiting insert mode (vim behavior)
+                if self.cursor_position > 0 {
+                    self.cursor_position -= 1;
+                }
+                Some(InputEvent::ModeChange(VimMode::Normal))
+            }
             KeyCode::Enter => {
                 let message = self.input.clone();
                 if !message.trim().is_empty() {
@@ -36,109 +175,333 @@ impl InputBox {
                     self.history_index = self.history.len();
                     self.input.clear();
                     self.cursor_position = 0;
-                    return Some(message);
+                    return Some(InputEvent::Message(message));
                 }
+                None
+            }
+            KeyCode::Char('e') if key.modifiers.contains(KeyModifiers::CONTROL) => {
+                Some(InputEvent::Expand)
+            }
+            KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => {
+                Some(InputEvent::Cancel)
             }
             KeyCode::Char(c) => {
                 self.input.insert(self.cursor_position, c);
                 self.cursor_position += 1;
+                None
             }
             KeyCode::Backspace => {
                 if self.cursor_position > 0 {
                     self.input.remove(self.cursor_position - 1);
                     self.cursor_position -= 1;
                 }
+                None
             }
             KeyCode::Delete => {
                 if self.cursor_position < self.input.len() {
                     self.input.remove(self.cursor_position);
                 }
+                None
             }
             KeyCode::Left => {
                 self.cursor_position = self.cursor_position.saturating_sub(1);
+                None
             }
             KeyCode::Right => {
                 if self.cursor_position < self.input.len() {
                     self.cursor_position += 1;
                 }
+                None
             }
             KeyCode::Home => {
                 self.cursor_position = 0;
+                None
             }
             KeyCode::End => {
                 self.cursor_position = self.input.len();
+                None
             }
             KeyCode::Up => {
-                if !self.history.is_empty() && self.history_index > 0 {
+                self.history_prev();
-                    self.history_index -= 1;
+                None
-                    self.input = self.history[self.history_index].clone();
-                    self.cursor_position = self.input.len();
-                }
             }
             KeyCode::Down => {
-                if self.history_index < self.history.len() - 1 {
+                self.history_next();
-                    self.history_index += 1;
+                None
-                    self.input = self.history[self.history_index].clone();
-                    self.cursor_position = self.input.len();
-                } else if self.history_index < self.history.len() {
-                    self.history_index = self.history.len();
-                    self.input.clear();
-                    self.cursor_position = 0;
-                }
             }
-            _ => {}
+            _ => None,
         }
-
-        None
     }
 
+    /// Handle keys in command mode
+    fn handle_command_mode(&mut self, key: KeyEvent) -> Option<InputEvent> {
+        match key.code {
+            KeyCode::Esc => {
+                self.mode = VimMode::Normal;
+                self.input.clear();
+                self.cursor_position = 0;
+                Some(InputEvent::ModeChange(VimMode::Normal))
+            }
+            KeyCode::Enter => {
+                let command = self.input.clone();
+                self.mode = VimMode::Normal;
+                self.input.clear();
+                self.cursor_position = 0;
+                if !command.trim().is_empty() {
+                    return Some(InputEvent::Command(command));
+                }
+                Some(InputEvent::ModeChange(VimMode::Normal))
+            }
+            KeyCode::Char(c) => {
+                self.input.insert(self.cursor_position, c);
+                self.cursor_position += 1;
+                None
+            }
+            KeyCode::Backspace => {
+                if self.cursor_position > 0 {
+                    self.input.remove(self.cursor_position - 1);
+                    self.cursor_position -= 1;
+                } else {
+                    // Empty command, exit to normal mode
+                    self.mode = VimMode::Normal;
+                    return Some(InputEvent::ModeChange(VimMode::Normal));
+                }
+                None
+            }
+            KeyCode::Left => {
+                self.cursor_position = self.cursor_position.saturating_sub(1);
+                None
+            }
+            KeyCode::Right => {
+                if self.cursor_position < self.input.len() {
+                    self.cursor_position += 1;
+                }
+                None
+            }
+            _ => None,
+        }
+    }
+
+    /// Handle keys in visual mode (simplified)
+    fn handle_visual_mode(&mut self, key: KeyEvent) -> Option<InputEvent> {
+        match key.code {
+            KeyCode::Esc => {
+                self.mode = VimMode::Normal;
+                Some(InputEvent::ModeChange(VimMode::Normal))
+            }
+            _ => None,
+        }
+    }
+
+    /// History navigation - previous
+    fn history_prev(&mut self) {
+        if !self.history.is_empty() && self.history_index > 0 {
+            self.history_index -= 1;
+            self.input = self.history[self.history_index].clone();
+            self.cursor_position = self.input.len();
+        }
+    }
+
+    /// History navigation - next
+    fn history_next(&mut self) {
+        if self.history_index < self.history.len().saturating_sub(1) {
+            self.history_index += 1;
+            self.input = self.history[self.history_index].clone();
+            self.cursor_position = self.input.len();
+        } else if self.history_index < self.history.len() {
+            self.history_index = self.history.len();
+            self.input.clear();
+            self.cursor_position = 0;
+        }
+    }
+
+    /// Find next word position
+    fn next_word_position(&self) -> usize {
+        let bytes = self.input.as_bytes();
+        let mut pos = self.cursor_position;
+
+        // Skip current word
+        while pos < bytes.len() && !bytes[pos].is_ascii_whitespace() {
+            pos += 1;
+        }
+        // Skip whitespace
+        while pos < bytes.len() && bytes[pos].is_ascii_whitespace() {
+            pos += 1;
+        }
+        pos
+    }
+
+    /// Find previous word position
+    fn prev_word_position(&self) -> usize {
+        let bytes = self.input.as_bytes();
+        let mut pos = self.cursor_position.saturating_sub(1);
+
+        // Skip whitespace
+        while pos > 0 && bytes[pos].is_ascii_whitespace() {
+            pos -= 1;
+        }
+        // Skip to start of word
+        while pos > 0 && !bytes[pos - 1].is_ascii_whitespace() {
+            pos -= 1;
+        }
+        pos
+    }
+
+    /// Render the borderless input (single line)
     pub fn render(&self, frame: &mut Frame, area: Rect) {
         let is_empty = self.input.is_empty();
+        let symbols = &self.theme.symbols;
 
-        let block = Block::default()
+        // Mode-specific prefix
-            .borders(Borders::ALL)
+        let prefix = match self.mode {
-            .border_style(self.theme.border_active)
+            VimMode::Normal => Span::styled(
-            .padding(Padding::horizontal(1))
+                format!("{} ", symbols.mode_normal),
-            .title(Line::from(vec![
+                self.theme.status_dim,
-                Span::raw(" "),
+            ),
-                Span::styled("✍", self.theme.border_active),
+            VimMode::Insert => Span::styled(
-                Span::raw(" "),
+                format!("{} ", symbols.user_prefix),
-                Span::styled("Input", self.theme.border_active),
+                self.theme.input_prefix,
-                Span::raw(" "),
+            ),
-            ]));
+            VimMode::Command => Span::styled(
-
+                ": ",
-        // Display input with cursor
+                self.theme.input_prefix,
-        let (text_before, text_after) = if self.cursor_position < self.input.len() {
+            ),
-            (
+            VimMode::Visual => Span::styled(
-                &self.input[..self.cursor_position],
+                format!("{} ", symbols.mode_visual),
-                &self.input[self.cursor_position..],
+                self.theme.status_accent,
-            )
+            ),
-        } else {
-            (&self.input[..], "")
         };
 
-        let line = if is_empty {
+        // Cursor position handling
+        let (text_before, cursor_char, text_after) = if self.cursor_position < self.input.len() {
+            let before = &self.input[..self.cursor_position];
+            let cursor = &self.input[self.cursor_position..self.cursor_position + 1];
+            let after = &self.input[self.cursor_position + 1..];
+            (before, cursor, after)
+        } else {
+            (&self.input[..], " ", "")
+        };
+
+        let line = if is_empty && self.mode == VimMode::Insert {
             Line::from(vec![
-                Span::styled("❯ ", self.theme.input_box_active),
+                Span::raw("  "),
-                Span::styled("▊", self.theme.input_box_active),
+                prefix,
-                Span::styled(" Type a message...", Style::default().fg(self.theme.palette.fg_dim)),
+                Span::styled("▊", self.theme.input_prefix),
+                Span::styled(" Type message...", self.theme.input_placeholder),
+            ])
+        } else if is_empty && self.mode == VimMode::Command {
+            Line::from(vec![
+                Span::raw("  "),
+                prefix,
+                Span::styled("▊", self.theme.input_prefix),
             ])
         } else {
+            // Build cursor span with appropriate styling
+            let cursor_style = if self.mode == VimMode::Normal {
+                Style::default()
+                    .bg(self.theme.palette.fg)
+                    .fg(self.theme.palette.bg)
+            } else {
+                self.theme.input_prefix
+            };
+
+            let cursor_span = if self.mode == VimMode::Normal && !is_empty {
+                Span::styled(cursor_char.to_string(), cursor_style)
+            } else {
+                Span::styled("▊", self.theme.input_prefix)
+            };
+
             Line::from(vec![
-                Span::styled("❯ ", self.theme.input_box_active),
+                Span::raw("  "),
-                Span::styled(text_before, self.theme.input_box),
+                prefix,
-                Span::styled("▊", self.theme.input_box_active),
+                Span::styled(text_before.to_string(), self.theme.input_text),
-                Span::styled(text_after, self.theme.input_box),
+                cursor_span,
+                Span::styled(text_after.to_string(), self.theme.input_text),
             ])
         };
 
-        let paragraph = Paragraph::new(line).block(block);
+        let paragraph = Paragraph::new(line);
-
         frame.render_widget(paragraph, area);
     }
 
+    /// Clear input
     pub fn clear(&mut self) {
         self.input.clear();
         self.cursor_position = 0;
     }
+
+    /// Get current input text
+    pub fn text(&self) -> &str {
+        &self.input
+    }
+
+    /// Set input text
+    pub fn set_text(&mut self, text: String) {
+        self.input = text;
+        self.cursor_position = self.input.len();
+    }
+
+    /// Update theme
+    pub fn set_theme(&mut self, theme: Theme) {
+        self.theme = theme;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_mode_transitions() {
+        let theme = Theme::default();
+        let mut input = InputBox::new(theme);
+
+        // Start in insert mode
+        assert_eq!(input.mode(), VimMode::Insert);
+
+        // Escape to normal mode
+        let event = input.handle_key(KeyEvent::from(KeyCode::Esc));
+        assert!(matches!(event, Some(InputEvent::ModeChange(VimMode::Normal))));
+        assert_eq!(input.mode(), VimMode::Normal);
+
+        // 'i' to insert mode
+        let event = input.handle_key(KeyEvent::from(KeyCode::Char('i')));
+        assert!(matches!(event, Some(InputEvent::ModeChange(VimMode::Insert))));
+        assert_eq!(input.mode(), VimMode::Insert);
+    }
+
+    #[test]
+    fn test_insert_text() {
+        let theme = Theme::default();
+        let mut input = InputBox::new(theme);
+
+        input.handle_key(KeyEvent::from(KeyCode::Char('h')));
+        input.handle_key(KeyEvent::from(KeyCode::Char('i')));
+
+        assert_eq!(input.text(), "hi");
+    }
+
+    #[test]
+    fn test_command_mode() {
+        let theme = Theme::default();
+        let mut input = InputBox::new(theme);
+
+        // Escape to normal, then : to command
+        input.handle_key(KeyEvent::from(KeyCode::Esc));
+        input.handle_key(KeyEvent::from(KeyCode::Char(':')));
+
+        assert_eq!(input.mode(), VimMode::Command);
+
+        // Type command
+        input.handle_key(KeyEvent::from(KeyCode::Char('q')));
+        input.handle_key(KeyEvent::from(KeyCode::Char('u')));
+        input.handle_key(KeyEvent::from(KeyCode::Char('i')));
+        input.handle_key(KeyEvent::from(KeyCode::Char('t')));
+
+        assert_eq!(input.text(), "quit");
+
+        // Submit command
+        let event = input.handle_key(KeyEvent::from(KeyCode::Enter));
+        assert!(matches!(event, Some(InputEvent::Command(cmd)) if cmd == "quit"));
+    }
 }

crates/app/ui/src/components/mod.rs

@@ -1,9 +1,13 @@
+//! TUI components for the borderless multi-provider design
+
 mod chat_panel;
 mod input_box;
 mod permission_popup;
+mod provider_tabs;
 mod status_bar;
 
-pub use chat_panel::{ChatMessage, ChatPanel};
+pub use chat_panel::{ChatMessage, ChatPanel, DisplayMessage};
-pub use input_box::InputBox;
+pub use input_box::{InputBox, InputEvent};
 pub use permission_popup::{PermissionOption, PermissionPopup};
-pub use status_bar::StatusBar;
+pub use provider_tabs::ProviderTabs;
+pub use status_bar::{AppState, StatusBar};

crates/app/ui/src/components/permission_popup.rs

@@ -136,7 +136,7 @@ impl PermissionPopup {
         // Separator
         let separator = Line::styled(
             "─".repeat(sections[2].width as usize),
-            Style::default().fg(self.theme.palette.border),
+            Style::default().fg(self.theme.palette.divider_fg),
         );
         frame.render_widget(Paragraph::new(separator), sections[2]);
 

crates/app/ui/src/components/provider_tabs.rs

@@ -0,0 +1,189 @@
+//! Provider tabs component for multi-LLM support
+//!
+//! Displays horizontal tabs for switching between providers (Claude, Ollama, OpenAI)
+//! with icons and keybind hints.
+
+use crate::theme::{Provider, Theme};
+use ratatui::{
+    layout::Rect,
+    style::Style,
+    text::{Line, Span},
+    widgets::Paragraph,
+    Frame,
+};
+
+/// Provider tab state and rendering
+pub struct ProviderTabs {
+    active: Provider,
+    theme: Theme,
+}
+
+impl ProviderTabs {
+    /// Create new provider tabs with default provider
+    pub fn new(theme: Theme) -> Self {
+        Self {
+            active: Provider::Ollama, // Default to Ollama (local)
+            theme,
+        }
+    }
+
+    /// Create with specific active provider
+    pub fn with_provider(provider: Provider, theme: Theme) -> Self {
+        Self {
+            active: provider,
+            theme,
+        }
+    }
+
+    /// Get the currently active provider
+    pub fn active(&self) -> Provider {
+        self.active
+    }
+
+    /// Set the active provider
+    pub fn set_active(&mut self, provider: Provider) {
+        self.active = provider;
+    }
+
+    /// Cycle to the next provider
+    pub fn next(&mut self) {
+        self.active = match self.active {
+            Provider::Claude => Provider::Ollama,
+            Provider::Ollama => Provider::OpenAI,
+            Provider::OpenAI => Provider::Claude,
+        };
+    }
+
+    /// Cycle to the previous provider
+    pub fn previous(&mut self) {
+        self.active = match self.active {
+            Provider::Claude => Provider::OpenAI,
+            Provider::Ollama => Provider::Claude,
+            Provider::OpenAI => Provider::Ollama,
+        };
+    }
+
+    /// Select provider by number (1, 2, 3)
+    pub fn select_by_number(&mut self, num: u8) {
+        self.active = match num {
+            1 => Provider::Claude,
+            2 => Provider::Ollama,
+            3 => Provider::OpenAI,
+            _ => self.active,
+        };
+    }
+
+    /// Update the theme
+    pub fn set_theme(&mut self, theme: Theme) {
+        self.theme = theme;
+    }
+
+    /// Render the provider tabs (borderless)
+    pub fn render(&self, frame: &mut Frame, area: Rect) {
+        let mut spans = Vec::new();
+
+        // Add spacing at start
+        spans.push(Span::raw("  "));
+
+        for (i, provider) in Provider::all().iter().enumerate() {
+            let is_active = *provider == self.active;
+            let icon = self.theme.provider_icon(*provider);
+            let name = provider.name();
+            let number = (i + 1).to_string();
+
+            // Keybind hint
+            spans.push(Span::styled(
+                format!("[{}] ", number),
+                self.theme.status_dim,
+            ));
+
+            // Icon and name
+            let style = if is_active {
+                Style::default()
+                    .fg(self.theme.provider_color(*provider))
+                    .add_modifier(ratatui::style::Modifier::BOLD)
+            } else {
+                self.theme.tab_inactive
+            };
+
+            spans.push(Span::styled(format!("{} ", icon), style));
+            spans.push(Span::styled(name.to_string(), style));
+
+            // Separator between tabs (not after last)
+            if i < Provider::all().len() - 1 {
+                spans.push(Span::styled(
+                    format!("  {}  ", self.theme.symbols.vertical_separator),
+                    self.theme.status_dim,
+                ));
+            }
+        }
+
+        // Tab cycling hint on the right
+        spans.push(Span::raw("  "));
+        spans.push(Span::styled("[Tab] cycle", self.theme.status_dim));
+
+        let line = Line::from(spans);
+        let paragraph = Paragraph::new(line);
+        frame.render_widget(paragraph, area);
+    }
+
+    /// Render a compact version (just active provider)
+    pub fn render_compact(&self, frame: &mut Frame, area: Rect) {
+        let icon = self.theme.provider_icon(self.active);
+        let name = self.active.name();
+
+        let line = Line::from(vec![
+            Span::raw("  "),
+            Span::styled(
+                format!("{} {}", icon, name),
+                Style::default()
+                    .fg(self.theme.provider_color(self.active))
+                    .add_modifier(ratatui::style::Modifier::BOLD),
+            ),
+        ]);
+
+        let paragraph = Paragraph::new(line);
+        frame.render_widget(paragraph, area);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_provider_cycling() {
+        let theme = Theme::default();
+        let mut tabs = ProviderTabs::new(theme);
+
+        assert_eq!(tabs.active(), Provider::Ollama);
+
+        tabs.next();
+        assert_eq!(tabs.active(), Provider::OpenAI);
+
+        tabs.next();
+        assert_eq!(tabs.active(), Provider::Claude);
+
+        tabs.next();
+        assert_eq!(tabs.active(), Provider::Ollama);
+    }
+
+    #[test]
+    fn test_select_by_number() {
+        let theme = Theme::default();
+        let mut tabs = ProviderTabs::new(theme);
+
+        tabs.select_by_number(1);
+        assert_eq!(tabs.active(), Provider::Claude);
+
+        tabs.select_by_number(2);
+        assert_eq!(tabs.active(), Provider::Ollama);
+
+        tabs.select_by_number(3);
+        assert_eq!(tabs.active(), Provider::OpenAI);
+
+        // Invalid number should not change
+        tabs.select_by_number(4);
+        assert_eq!(tabs.active(), Provider::OpenAI);
+    }
+}

crates/app/ui/src/components/status_bar.rs

@@ -1,4 +1,9 @@
-use crate::theme::Theme;
+//! Multi-provider status bar component
+//!
+//! Borderless status bar showing provider, model, mode, stats, and state.
+//! Format: 󰚩 model │ Mode │ N msgs │ 󱐋 N │ ~Nk │ $0.00 │ ● status
+
+use crate::theme::{Provider, Theme, VimMode};
 use agent_core::SessionStats;
 use permissions::Mode;
 use ratatui::{
@@ -8,102 +13,221 @@ use ratatui::{
     Frame,
 };
 
+/// Application state for status display
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum AppState {
+    Idle,
+    Streaming,
+    WaitingPermission,
+    Error,
+}
+
+impl AppState {
+    pub fn icon(&self) -> &'static str {
+        match self {
+            AppState::Idle => "○",
+            AppState::Streaming => "●",
+            AppState::WaitingPermission => "◐",
+            AppState::Error => "✗",
+        }
+    }
+
+    pub fn label(&self) -> &'static str {
+        match self {
+            AppState::Idle => "idle",
+            AppState::Streaming => "streaming",
+            AppState::WaitingPermission => "waiting",
+            AppState::Error => "error",
+        }
+    }
+}
+
 pub struct StatusBar {
+    provider: Provider,
     model: String,
     mode: Mode,
+    vim_mode: VimMode,
     stats: SessionStats,
     last_tool: Option<String>,
+    state: AppState,
+    estimated_cost: f64,
     theme: Theme,
 }
 
 impl StatusBar {
     pub fn new(model: String, mode: Mode, theme: Theme) -> Self {
         Self {
+            provider: Provider::Ollama, // Default provider
             model,
             mode,
+            vim_mode: VimMode::Insert,
             stats: SessionStats::new(),
             last_tool: None,
+            state: AppState::Idle,
+            estimated_cost: 0.0,
             theme,
         }
     }
 
+    /// Set the active provider
+    pub fn set_provider(&mut self, provider: Provider) {
+        self.provider = provider;
+    }
+
+    /// Set the current model
+    pub fn set_model(&mut self, model: String) {
+        self.model = model;
+    }
+
+    /// Update session stats
     pub fn update_stats(&mut self, stats: SessionStats) {
         self.stats = stats;
     }
 
+    /// Set the last used tool
     pub fn set_last_tool(&mut self, tool: String) {
         self.last_tool = Some(tool);
     }
 
-    pub fn render(&self, frame: &mut Frame, area: Rect) {
+    /// Set application state
-        let elapsed = self.stats.start_time.elapsed().unwrap_or_default();
+    pub fn set_state(&mut self, state: AppState) {
-        let elapsed_str = SessionStats::format_duration(elapsed);
+        self.state = state;
+    }
 
-        let (mode_str, mode_icon) = match self.mode {
+    /// Set vim mode for display
-            Mode::Plan => ("Plan", "🔍"),
+    pub fn set_vim_mode(&mut self, mode: VimMode) {
-            Mode::AcceptEdits => ("AcceptEdits", "✏️"),
+        self.vim_mode = mode;
-            Mode::Code => ("Code", "⚡"),
+    }
+
+    /// Add to estimated cost
+    pub fn add_cost(&mut self, cost: f64) {
+        self.estimated_cost += cost;
+    }
+
+    /// Reset cost
+    pub fn reset_cost(&mut self) {
+        self.estimated_cost = 0.0;
+    }
+
+    /// Update theme
+    pub fn set_theme(&mut self, theme: Theme) {
+        self.theme = theme;
+    }
+
+    /// Render the status bar
+    pub fn render(&self, frame: &mut Frame, area: Rect) {
+        let symbols = &self.theme.symbols;
+        let sep = symbols.vertical_separator;
+
+        // Provider icon and model
+        let provider_icon = self.theme.provider_icon(self.provider);
+        let provider_style = ratatui::style::Style::default()
+            .fg(self.theme.provider_color(self.provider));
+
+        // Permission mode
+        let mode_str = match self.mode {
+            Mode::Plan => "Plan",
+            Mode::AcceptEdits => "Edit",
+            Mode::Code => "Code",
         };
 
-        let last_tool_str = self
+        // Format token count
-            .last_tool
+        let tokens_str = if self.stats.estimated_tokens >= 1000 {
-            .as_ref()
+            format!("~{}k", self.stats.estimated_tokens / 1000)
-            .map(|t| format!("● {}", t))
+        } else {
-            .unwrap_or_else(|| "○ idle".to_string());
+            format!("~{}", self.stats.estimated_tokens)
+        };
 
-        // Build status line with colorful sections
+        // Cost display (only for paid providers)
-        let separator_style = self.theme.status_bar;
+        let cost_str = if self.provider != Provider::Ollama && self.estimated_cost > 0.0 {
+            format!("${:.2}", self.estimated_cost)
+        } else {
+            String::new()
+        };
+
+        // State indicator
+        let state_style = match self.state {
+            AppState::Idle => self.theme.status_dim,
+            AppState::Streaming => ratatui::style::Style::default()
+                .fg(self.theme.palette.success),
+            AppState::WaitingPermission => ratatui::style::Style::default()
+                .fg(self.theme.palette.warning),
+            AppState::Error => ratatui::style::Style::default()
+                .fg(self.theme.palette.error),
+        };
+
+        // Build status line
         let mut spans = vec![
-            Span::styled(" ", separator_style),
+            Span::styled("  ", self.theme.status_bar),
-            Span::styled(mode_icon, self.theme.status_bar),
+            // Provider icon and model
-            Span::styled(" ", separator_style),
+            Span::styled(format!("{} ", provider_icon), provider_style),
-            Span::styled(mode_str, self.theme.status_bar),
-            Span::styled(" │ ", separator_style),
-            Span::styled("⚙", self.theme.status_bar),
-            Span::styled(" ", separator_style),
             Span::styled(&self.model, self.theme.status_bar),
-            Span::styled(" │ ", separator_style),
+            Span::styled(format!(" {} ", sep), self.theme.status_dim),
-            Span::styled(
+            // Permission mode
-                format!("{} msgs", self.stats.total_messages),
+            Span::styled(mode_str, self.theme.status_bar),
-                self.theme.status_bar,
+            Span::styled(format!(" {} ", sep), self.theme.status_dim),
-            ),
+            // Message count
-            Span::styled(" │ ", separator_style),
+            Span::styled(format!("{} msgs", self.stats.total_messages), self.theme.status_bar),
-            Span::styled(
+            Span::styled(format!(" {} ", sep), self.theme.status_dim),
-                format!("{} tools", self.stats.total_tool_calls),
+            // Tool count
-                self.theme.status_bar,
+            Span::styled(format!("{} {}", symbols.tool_prefix, self.stats.total_tool_calls), self.theme.status_bar),
-            ),
+            Span::styled(format!(" {} ", sep), self.theme.status_dim),
-            Span::styled(" │ ", separator_style),
+            // Token count
-            Span::styled(
+            Span::styled(tokens_str, self.theme.status_bar),
-                format!("~{} tok", self.stats.estimated_tokens),
-                self.theme.status_bar,
-            ),
-            Span::styled(" │ ", separator_style),
-            Span::styled("⏱", self.theme.status_bar),
-            Span::styled(" ", separator_style),
-            Span::styled(elapsed_str, self.theme.status_bar),
-            Span::styled(" │ ", separator_style),
-            Span::styled(last_tool_str, self.theme.status_bar),
         ];
 
-        // Add help text on the right
+        // Add cost if applicable
-        let help_text = " ? /help ";
+        if !cost_str.is_empty() {
+            spans.push(Span::styled(format!(" {} ", sep), self.theme.status_dim));
+            spans.push(Span::styled(cost_str, self.theme.status_accent));
+        }
 
-        // Calculate current length
+        // State indicator
-        let current_len: usize = spans.iter()
+        spans.push(Span::styled(format!(" {} ", sep), self.theme.status_dim));
+        spans.push(Span::styled(
+            format!("{} {}", self.state.icon(), self.state.label()),
+            state_style,
+        ));
+
+        // Calculate current width
+        let current_width: usize = spans
+            .iter()
             .map(|s| unicode_width::UnicodeWidthStr::width(s.content.as_ref()))
             .sum();
 
-        // Add padding
+        // Add help hint on the right
-        let padding = area
+        let vim_indicator = self.vim_mode.indicator(&self.theme.symbols);
-            .width
+        let help_hint = format!("{}  ?", vim_indicator);
-            .saturating_sub((current_len + help_text.len()) as u16);
+        let help_width = unicode_width::UnicodeWidthStr::width(help_hint.as_str()) + 2;
 
-        spans.push(Span::styled(" ".repeat(padding as usize), separator_style));
+        // Padding
-        spans.push(Span::styled(help_text, self.theme.status_bar));
+        let available = area.width as usize;
+        let padding = available.saturating_sub(current_width + help_width);
+        spans.push(Span::raw(" ".repeat(padding)));
+        spans.push(Span::styled(help_hint, self.theme.status_dim));
+        spans.push(Span::raw("  "));
 
         let line = Line::from(spans);
         let paragraph = Paragraph::new(line);
-
         frame.render_widget(paragraph, area);
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_status_bar_creation() {
+        let theme = Theme::default();
+        let status_bar = StatusBar::new("gpt-4".to_string(), Mode::Plan, theme);
+        assert_eq!(status_bar.model, "gpt-4");
+    }
+
+    #[test]
+    fn test_app_state_display() {
+        assert_eq!(AppState::Idle.label(), "idle");
+        assert_eq!(AppState::Streaming.label(), "streaming");
+        assert_eq!(AppState::Error.icon(), "✗");
+    }
+}

crates/app/ui/src/events.rs

@@ -23,6 +23,10 @@ pub enum AppEvent {
     StatusUpdate(agent_core::SessionStats),
     /// Terminal was resized
     Resize { width: u16, height: u16 },
+    /// Mouse scroll up
+    ScrollUp,
+    /// Mouse scroll down
+    ScrollDown,
     /// Application should quit
     Quit,
 }

crates/app/ui/src/formatting.rs

@@ -0,0 +1,532 @@
+//! Output formatting with markdown parsing and syntax highlighting
+//!
+//! This module provides rich text rendering for the TUI, converting markdown
+//! content into styled ratatui spans with proper syntax highlighting for code blocks.
+
+use pulldown_cmark::{CodeBlockKind, Event, Parser, Tag, TagEnd};
+use ratatui::style::{Color, Modifier, Style};
+use ratatui::text::{Line, Span};
+use syntect::easy::HighlightLines;
+use syntect::highlighting::{Theme, ThemeSet};
+use syntect::parsing::SyntaxSet;
+use syntect::util::LinesWithEndings;
+
+/// Highlighter for syntax highlighting code blocks
+pub struct SyntaxHighlighter {
+    syntax_set: SyntaxSet,
+    theme: Theme,
+}
+
+impl SyntaxHighlighter {
+    /// Create a new syntax highlighter with default theme
+    pub fn new() -> Self {
+        let syntax_set = SyntaxSet::load_defaults_newlines();
+        let theme_set = ThemeSet::load_defaults();
+        // Use a dark theme that works well in terminals
+        let theme = theme_set.themes["base16-ocean.dark"].clone();
+
+        Self { syntax_set, theme }
+    }
+
+    /// Create highlighter with a specific theme name
+    pub fn with_theme(theme_name: &str) -> Self {
+        let syntax_set = SyntaxSet::load_defaults_newlines();
+        let theme_set = ThemeSet::load_defaults();
+        let theme = theme_set
+            .themes
+            .get(theme_name)
+            .cloned()
+            .unwrap_or_else(|| theme_set.themes["base16-ocean.dark"].clone());
+
+        Self { syntax_set, theme }
+    }
+
+    /// Get available theme names
+    pub fn available_themes() -> Vec<&'static str> {
+        vec![
+            "base16-ocean.dark",
+            "base16-eighties.dark",
+            "base16-mocha.dark",
+            "base16-ocean.light",
+            "InspiredGitHub",
+            "Solarized (dark)",
+            "Solarized (light)",
+        ]
+    }
+
+    /// Highlight a code block and return styled lines
+    pub fn highlight_code(&self, code: &str, language: &str) -> Vec<Line<'static>> {
+        // Find syntax for the language
+        let syntax = self
+            .syntax_set
+            .find_syntax_by_token(language)
+            .or_else(|| self.syntax_set.find_syntax_by_extension(language))
+            .unwrap_or_else(|| self.syntax_set.find_syntax_plain_text());
+
+        let mut highlighter = HighlightLines::new(syntax, &self.theme);
+        let mut lines = Vec::new();
+
+        for line in LinesWithEndings::from(code) {
+            let Ok(ranges) = highlighter.highlight_line(line, &self.syntax_set) else {
+                // Fallback to plain text if highlighting fails
+                lines.push(Line::from(Span::raw(line.trim_end().to_string())));
+                continue;
+            };
+
+            let spans: Vec<Span<'static>> = ranges
+                .into_iter()
+                .map(|(style, text)| {
+                    let fg = syntect_to_ratatui_color(style.foreground);
+                    let ratatui_style = Style::default().fg(fg);
+                    Span::styled(text.trim_end_matches('\n').to_string(), ratatui_style)
+                })
+                .collect();
+
+            lines.push(Line::from(spans));
+        }
+
+        lines
+    }
+}
+
+impl Default for SyntaxHighlighter {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Convert syntect color to ratatui color
+fn syntect_to_ratatui_color(color: syntect::highlighting::Color) -> Color {
+    Color::Rgb(color.r, color.g, color.b)
+}
+
+/// Parsed markdown content ready for rendering
+#[derive(Debug, Clone)]
+pub struct FormattedContent {
+    pub lines: Vec<Line<'static>>,
+}
+
+impl FormattedContent {
+    /// Create empty formatted content
+    pub fn empty() -> Self {
+        Self { lines: Vec::new() }
+    }
+
+    /// Get the number of lines
+    pub fn len(&self) -> usize {
+        self.lines.len()
+    }
+
+    /// Check if content is empty
+    pub fn is_empty(&self) -> bool {
+        self.lines.is_empty()
+    }
+}
+
+/// Markdown parser that converts markdown to styled ratatui lines
+pub struct MarkdownRenderer {
+    highlighter: SyntaxHighlighter,
+}
+
+impl MarkdownRenderer {
+    /// Create a new markdown renderer
+    pub fn new() -> Self {
+        Self {
+            highlighter: SyntaxHighlighter::new(),
+        }
+    }
+
+    /// Create renderer with custom highlighter
+    pub fn with_highlighter(highlighter: SyntaxHighlighter) -> Self {
+        Self { highlighter }
+    }
+
+    /// Render markdown text to formatted content
+    pub fn render(&self, markdown: &str) -> FormattedContent {
+        let parser = Parser::new(markdown);
+        let mut lines: Vec<Line<'static>> = Vec::new();
+        let mut current_line_spans: Vec<Span<'static>> = Vec::new();
+
+        // State tracking
+        let mut in_code_block = false;
+        let mut code_block_lang = String::new();
+        let mut code_block_content = String::new();
+        let mut current_style = Style::default();
+        let mut list_depth: usize = 0;
+        let mut ordered_list_index: Option<u64> = None;
+
+        for event in parser {
+            match event {
+                Event::Start(tag) => match tag {
+                    Tag::Heading { level, .. } => {
+                        // Flush current line
+                        if !current_line_spans.is_empty() {
+                            lines.push(Line::from(std::mem::take(&mut current_line_spans)));
+                        }
+                        // Style for headings
+                        current_style = match level {
+                            pulldown_cmark::HeadingLevel::H1 => Style::default()
+                                .fg(Color::Cyan)
+                                .add_modifier(Modifier::BOLD),
+                            pulldown_cmark::HeadingLevel::H2 => Style::default()
+                                .fg(Color::Blue)
+                                .add_modifier(Modifier::BOLD),
+                            pulldown_cmark::HeadingLevel::H3 => Style::default()
+                                .fg(Color::Green)
+                                .add_modifier(Modifier::BOLD),
+                            _ => Style::default().add_modifier(Modifier::BOLD),
+                        };
+                        // Add heading prefix
+                        let prefix = "#".repeat(level as usize);
+                        current_line_spans.push(Span::styled(
+                            format!("{} ", prefix),
+                            Style::default().fg(Color::DarkGray),
+                        ));
+                    }
+                    Tag::Paragraph => {
+                        // Start a new paragraph
+                        if !current_line_spans.is_empty() {
+                            lines.push(Line::from(std::mem::take(&mut current_line_spans)));
+                        }
+                    }
+                    Tag::CodeBlock(kind) => {
+                        in_code_block = true;
+                        code_block_content.clear();
+                        code_block_lang = match kind {
+                            CodeBlockKind::Fenced(lang) => lang.to_string(),
+                            CodeBlockKind::Indented => String::new(),
+                        };
+                        // Flush current line and add code block header
+                        if !current_line_spans.is_empty() {
+                            lines.push(Line::from(std::mem::take(&mut current_line_spans)));
+                        }
+                        // Add code fence line
+                        let fence_line = if code_block_lang.is_empty() {
+                            "```".to_string()
+                        } else {
+                            format!("```{}", code_block_lang)
+                        };
+                        lines.push(Line::from(Span::styled(
+                            fence_line,
+                            Style::default().fg(Color::DarkGray),
+                        )));
+                    }
+                    Tag::List(start) => {
+                        list_depth += 1;
+                        ordered_list_index = start;
+                    }
+                    Tag::Item => {
+                        // Flush current line
+                        if !current_line_spans.is_empty() {
+                            lines.push(Line::from(std::mem::take(&mut current_line_spans)));
+                        }
+                        // Add list marker
+                        let indent = "  ".repeat(list_depth.saturating_sub(1));
+                        let marker = if let Some(idx) = ordered_list_index {
+                            ordered_list_index = Some(idx + 1);
+                            format!("{}{}. ", indent, idx)
+                        } else {
+                            format!("{}- ", indent)
+                        };
+                        current_line_spans.push(Span::styled(
+                            marker,
+                            Style::default().fg(Color::Yellow),
+                        ));
+                    }
+                    Tag::Emphasis => {
+                        current_style = current_style.add_modifier(Modifier::ITALIC);
+                    }
+                    Tag::Strong => {
+                        current_style = current_style.add_modifier(Modifier::BOLD);
+                    }
+                    Tag::Strikethrough => {
+                        current_style = current_style.add_modifier(Modifier::CROSSED_OUT);
+                    }
+                    Tag::Link { dest_url, .. } => {
+                        current_style = Style::default()
+                            .fg(Color::Blue)
+                            .add_modifier(Modifier::UNDERLINED);
+                        // Store URL for later
+                        current_line_spans.push(Span::styled(
+                            "[",
+                            Style::default().fg(Color::DarkGray),
+                        ));
+                        // URL will be shown after link text
+                        code_block_content = dest_url.to_string();
+                    }
+                    Tag::BlockQuote(_) => {
+                        if !current_line_spans.is_empty() {
+                            lines.push(Line::from(std::mem::take(&mut current_line_spans)));
+                        }
+                        current_line_spans.push(Span::styled(
+                            "│ ",
+                            Style::default().fg(Color::DarkGray),
+                        ));
+                        current_style = Style::default().fg(Color::Gray).add_modifier(Modifier::ITALIC);
+                    }
+                    _ => {}
+                },
+                Event::End(tag_end) => match tag_end {
+                    TagEnd::Heading(_) => {
+                        current_style = Style::default();
+                        lines.push(Line::from(std::mem::take(&mut current_line_spans)));
+                    }
+                    TagEnd::Paragraph => {
+                        lines.push(Line::from(std::mem::take(&mut current_line_spans)));
+                        lines.push(Line::from("")); // Empty line after paragraph
+                    }
+                    TagEnd::CodeBlock => {
+                        in_code_block = false;
+                        // Highlight and add code content
+                        let highlighted =
+                            self.highlighter.highlight_code(&code_block_content, &code_block_lang);
+                        lines.extend(highlighted);
+                        // Add closing fence
+                        lines.push(Line::from(Span::styled(
+                            "```",
+                            Style::default().fg(Color::DarkGray),
+                        )));
+                        code_block_content.clear();
+                        code_block_lang.clear();
+                    }
+                    TagEnd::List(_) => {
+                        list_depth = list_depth.saturating_sub(1);
+                        if list_depth == 0 {
+                            ordered_list_index = None;
+                        }
+                    }
+                    TagEnd::Item => {
+                        if !current_line_spans.is_empty() {
+                            lines.push(Line::from(std::mem::take(&mut current_line_spans)));
+                        }
+                    }
+                    TagEnd::Emphasis | TagEnd::Strong | TagEnd::Strikethrough => {
+                        current_style = Style::default();
+                    }
+                    TagEnd::Link => {
+                        current_line_spans.push(Span::styled(
+                            "]",
+                            Style::default().fg(Color::DarkGray),
+                        ));
+                        current_line_spans.push(Span::styled(
+                            format!("({})", code_block_content),
+                            Style::default().fg(Color::DarkGray),
+                        ));
+                        code_block_content.clear();
+                        current_style = Style::default();
+                    }
+                    TagEnd::BlockQuote => {
+                        current_style = Style::default();
+                        if !current_line_spans.is_empty() {
+                            lines.push(Line::from(std::mem::take(&mut current_line_spans)));
+                        }
+                    }
+                    _ => {}
+                },
+                Event::Text(text) => {
+                    if in_code_block {
+                        code_block_content.push_str(&text);
+                    } else {
+                        current_line_spans.push(Span::styled(text.to_string(), current_style));
+                    }
+                }
+                Event::Code(code) => {
+                    // Inline code
+                    current_line_spans.push(Span::styled(
+                        format!("`{}`", code),
+                        Style::default().fg(Color::Magenta),
+                    ));
+                }
+                Event::SoftBreak => {
+                    current_line_spans.push(Span::raw(" "));
+                }
+                Event::HardBreak => {
+                    lines.push(Line::from(std::mem::take(&mut current_line_spans)));
+                }
+                Event::Rule => {
+                    if !current_line_spans.is_empty() {
+                        lines.push(Line::from(std::mem::take(&mut current_line_spans)));
+                    }
+                    lines.push(Line::from(Span::styled(
+                        "─".repeat(40),
+                        Style::default().fg(Color::DarkGray),
+                    )));
+                }
+                _ => {}
+            }
+        }
+
+        // Flush any remaining content
+        if !current_line_spans.is_empty() {
+            lines.push(Line::from(current_line_spans));
+        }
+
+        FormattedContent { lines }
+    }
+
+    /// Render plain text (no markdown parsing)
+    pub fn render_plain(&self, text: &str) -> FormattedContent {
+        let lines = text
+            .lines()
+            .map(|line| Line::from(Span::raw(line.to_string())))
+            .collect();
+        FormattedContent { lines }
+    }
+
+    /// Render a diff with +/- highlighting
+    pub fn render_diff(&self, diff: &str) -> FormattedContent {
+        let lines = diff
+            .lines()
+            .map(|line| {
+                let style = if line.starts_with('+') && !line.starts_with("+++") {
+                    Style::default().fg(Color::Green)
+                } else if line.starts_with('-') && !line.starts_with("---") {
+                    Style::default().fg(Color::Red)
+                } else if line.starts_with("@@") {
+                    Style::default().fg(Color::Cyan)
+                } else if line.starts_with("diff ") || line.starts_with("index ") {
+                    Style::default().fg(Color::Yellow)
+                } else {
+                    Style::default()
+                };
+                Line::from(Span::styled(line.to_string(), style))
+            })
+            .collect();
+        FormattedContent { lines }
+    }
+}
+
+impl Default for MarkdownRenderer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Format a file path with syntax highlighting based on extension
+pub fn format_file_path(path: &str) -> Span<'static> {
+    let color = if path.ends_with(".rs") {
+        Color::Rgb(222, 165, 132) // Rust orange
+    } else if path.ends_with(".toml") {
+        Color::Rgb(156, 220, 254) // Light blue
+    } else if path.ends_with(".md") {
+        Color::Rgb(86, 156, 214) // Blue
+    } else if path.ends_with(".json") {
+        Color::Rgb(206, 145, 120) // Brown
+    } else if path.ends_with(".ts") || path.ends_with(".tsx") {
+        Color::Rgb(49, 120, 198) // TypeScript blue
+    } else if path.ends_with(".js") || path.ends_with(".jsx") {
+        Color::Rgb(241, 224, 90) // JavaScript yellow
+    } else if path.ends_with(".py") {
+        Color::Rgb(55, 118, 171) // Python blue
+    } else if path.ends_with(".go") {
+        Color::Rgb(0, 173, 216) // Go cyan
+    } else if path.ends_with(".sh") || path.ends_with(".bash") {
+        Color::Rgb(137, 224, 81) // Shell green
+    } else {
+        Color::White
+    };
+
+    Span::styled(path.to_string(), Style::default().fg(color))
+}
+
+/// Format a tool name with appropriate styling
+pub fn format_tool_name(name: &str) -> Span<'static> {
+    let style = Style::default()
+        .fg(Color::Yellow)
+        .add_modifier(Modifier::BOLD);
+    Span::styled(name.to_string(), style)
+}
+
+/// Format an error message
+pub fn format_error(message: &str) -> Line<'static> {
+    Line::from(vec![
+        Span::styled("Error: ", Style::default().fg(Color::Red).add_modifier(Modifier::BOLD)),
+        Span::styled(message.to_string(), Style::default().fg(Color::Red)),
+    ])
+}
+
+/// Format a success message
+pub fn format_success(message: &str) -> Line<'static> {
+    Line::from(vec![
+        Span::styled("✓ ", Style::default().fg(Color::Green)),
+        Span::styled(message.to_string(), Style::default().fg(Color::Green)),
+    ])
+}
+
+/// Format a warning message
+pub fn format_warning(message: &str) -> Line<'static> {
+    Line::from(vec![
+        Span::styled("⚠ ", Style::default().fg(Color::Yellow)),
+        Span::styled(message.to_string(), Style::default().fg(Color::Yellow)),
+    ])
+}
+
+/// Format an info message
+pub fn format_info(message: &str) -> Line<'static> {
+    Line::from(vec![
+        Span::styled("ℹ ", Style::default().fg(Color::Blue)),
+        Span::styled(message.to_string(), Style::default().fg(Color::Blue)),
+    ])
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_syntax_highlighter_creation() {
+        let highlighter = SyntaxHighlighter::new();
+        let lines = highlighter.highlight_code("fn main() {}", "rust");
+        assert!(!lines.is_empty());
+    }
+
+    #[test]
+    fn test_markdown_render_heading() {
+        let renderer = MarkdownRenderer::new();
+        let content = renderer.render("# Hello World");
+        assert!(!content.is_empty());
+    }
+
+    #[test]
+    fn test_markdown_render_code_block() {
+        let renderer = MarkdownRenderer::new();
+        let content = renderer.render("```rust\nfn main() {}\n```");
+        assert!(content.len() >= 3); // Opening fence, code, closing fence
+    }
+
+    #[test]
+    fn test_markdown_render_list() {
+        let renderer = MarkdownRenderer::new();
+        let content = renderer.render("- Item 1\n- Item 2\n- Item 3");
+        assert!(content.len() >= 3);
+    }
+
+    #[test]
+    fn test_diff_rendering() {
+        let renderer = MarkdownRenderer::new();
+        let diff = "+added line\n-removed line\n unchanged";
+        let content = renderer.render_diff(diff);
+        assert_eq!(content.len(), 3);
+    }
+
+    #[test]
+    fn test_format_file_path() {
+        let span = format_file_path("src/main.rs");
+        assert!(span.content.contains("main.rs"));
+    }
+
+    #[test]
+    fn test_format_messages() {
+        let error = format_error("Something went wrong");
+        assert!(!error.spans.is_empty());
+
+        let success = format_success("Operation completed");
+        assert!(!success.spans.is_empty());
+
+        let warning = format_warning("Be careful");
+        assert!(!warning.spans.is_empty());
+
+        let info = format_info("FYI");
+        assert!(!info.spans.is_empty());
+    }
+}

crates/app/ui/src/layout.rs

@@ -1,28 +1,112 @@
+//! Layout calculation for the borderless TUI
+//!
+//! Uses vertical layout with whitespace for visual hierarchy instead of borders:
+//! - Header row (app name, mode, model, help)
+//! - Provider tabs
+//! - Horizontal divider
+//! - Chat area (scrollable)
+//! - Horizontal divider
+//! - Input area
+//! - Status bar
+
 use ratatui::layout::{Constraint, Direction, Layout, Rect};
 
-/// Calculate layout areas for the TUI
+/// Calculated layout areas for the borderless TUI
+#[derive(Debug, Clone, Copy)]
 pub struct AppLayout {
+    /// Header row: app name, mode indicator, model, help hint
+    pub header_area: Rect,
+    /// Provider tabs row
+    pub tabs_area: Rect,
+    /// Top divider (horizontal rule)
+    pub top_divider: Rect,
+    /// Main chat/message area
     pub chat_area: Rect,
+    /// Bottom divider (horizontal rule)
+    pub bottom_divider: Rect,
+    /// Input area for user text
     pub input_area: Rect,
+    /// Status bar at the bottom
     pub status_area: Rect,
 }
 
 impl AppLayout {
-    /// Calculate layout from terminal size
+    /// Calculate layout for the given terminal size
     pub fn calculate(area: Rect) -> Self {
         let chunks = Layout::default()
             .direction(Direction::Vertical)
             .constraints([
-                Constraint::Min(3),        // Chat area (grows)
+                Constraint::Length(1),  // Header
-                Constraint::Length(3),     // Input area (fixed height)
+                Constraint::Length(1),  // Provider tabs
-                Constraint::Length(1),     // Status bar (fixed height)
+                Constraint::Length(1),  // Top divider
+                Constraint::Min(5),     // Chat area (flexible)
+                Constraint::Length(1),  // Bottom divider
+                Constraint::Length(1),  // Input
+                Constraint::Length(1),  // Status bar
             ])
             .split(area);
 
         Self {
-            chat_area: chunks[0],
+            header_area: chunks[0],
-            input_area: chunks[1],
+            tabs_area: chunks[1],
-            status_area: chunks[2],
+            top_divider: chunks[2],
+            chat_area: chunks[3],
+            bottom_divider: chunks[4],
+            input_area: chunks[5],
+            status_area: chunks[6],
+        }
+    }
+
+    /// Calculate layout with expanded input (multiline)
+    pub fn calculate_expanded_input(area: Rect, input_lines: u16) -> Self {
+        let input_height = input_lines.min(10).max(1); // Cap at 10 lines
+
+        let chunks = Layout::default()
+            .direction(Direction::Vertical)
+            .constraints([
+                Constraint::Length(1),          // Header
+                Constraint::Length(1),          // Provider tabs
+                Constraint::Length(1),          // Top divider
+                Constraint::Min(5),             // Chat area (flexible)
+                Constraint::Length(1),          // Bottom divider
+                Constraint::Length(input_height), // Expanded input
+                Constraint::Length(1),          // Status bar
+            ])
+            .split(area);
+
+        Self {
+            header_area: chunks[0],
+            tabs_area: chunks[1],
+            top_divider: chunks[2],
+            chat_area: chunks[3],
+            bottom_divider: chunks[4],
+            input_area: chunks[5],
+            status_area: chunks[6],
+        }
+    }
+
+    /// Calculate layout without tabs (compact mode)
+    pub fn calculate_compact(area: Rect) -> Self {
+        let chunks = Layout::default()
+            .direction(Direction::Vertical)
+            .constraints([
+                Constraint::Length(1),  // Header (includes compact provider indicator)
+                Constraint::Length(1),  // Top divider
+                Constraint::Min(5),     // Chat area (flexible)
+                Constraint::Length(1),  // Bottom divider
+                Constraint::Length(1),  // Input
+                Constraint::Length(1),  // Status bar
+            ])
+            .split(area);
+
+        Self {
+            header_area: chunks[0],
+            tabs_area: Rect::default(), // No tabs area in compact mode
+            top_divider: chunks[1],
+            chat_area: chunks[2],
+            bottom_divider: chunks[3],
+            input_area: chunks[4],
+            status_area: chunks[5],
         }
     }
 
@@ -47,3 +131,53 @@ impl AppLayout {
             .split(popup_layout[1])[1]
     }
 }
+
+/// Layout mode based on terminal width
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum LayoutMode {
+    /// Full layout with provider tabs (>= 80 cols)
+    Full,
+    /// Compact layout without tabs (< 80 cols)
+    Compact,
+}
+
+impl LayoutMode {
+    /// Determine layout mode based on terminal width
+    pub fn for_width(width: u16) -> Self {
+        if width >= 80 {
+            LayoutMode::Full
+        } else {
+            LayoutMode::Compact
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_layout_calculation() {
+        let area = Rect::new(0, 0, 120, 40);
+        let layout = AppLayout::calculate(area);
+
+        // Header should be at top
+        assert_eq!(layout.header_area.y, 0);
+        assert_eq!(layout.header_area.height, 1);
+
+        // Status should be at bottom
+        assert_eq!(layout.status_area.y, 39);
+        assert_eq!(layout.status_area.height, 1);
+
+        // Chat area should have most of the space
+        assert!(layout.chat_area.height > 20);
+    }
+
+    #[test]
+    fn test_layout_mode() {
+        assert_eq!(LayoutMode::for_width(80), LayoutMode::Full);
+        assert_eq!(LayoutMode::for_width(120), LayoutMode::Full);
+        assert_eq!(LayoutMode::for_width(79), LayoutMode::Compact);
+        assert_eq!(LayoutMode::for_width(60), LayoutMode::Compact);
+    }
+}

crates/app/ui/src/lib.rs

@@ -1,18 +1,23 @@
 pub mod app;
 pub mod components;
 pub mod events;
+pub mod formatting;
 pub mod layout;
 pub mod theme;
 
 pub use app::TuiApp;
 pub use events::AppEvent;
+pub use formatting::{
+    FormattedContent, MarkdownRenderer, SyntaxHighlighter,
+    format_file_path, format_tool_name, format_error, format_success, format_warning, format_info,
+};
 
 use color_eyre::eyre::Result;
 
 /// Run the TUI application
 pub async fn run(
     client: llm_ollama::OllamaClient,
-    opts: llm_ollama::OllamaOptions,
+    opts: llm_core::ChatOptions,
     perms: permissions::PermissionManager,
     settings: config_agent::Settings,
 ) -> Result<()> {

crates/app/ui/src/theme.rs

@@ -1,5 +1,145 @@
+//! Theme system for the borderless TUI design
+//!
+//! Provides color palettes, semantic styling, and terminal capability detection
+//! for graceful degradation across different terminal emulators.
+
 use ratatui::style::{Color, Modifier, Style};
 
+/// Terminal capability detection for graceful degradation
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TerminalCapability {
+    /// Full Unicode support with true color
+    Full,
+    /// Basic Unicode with 256 colors
+    Unicode256,
+    /// ASCII only with 16 colors
+    Basic,
+}
+
+impl TerminalCapability {
+    /// Detect terminal capabilities from environment
+    pub fn detect() -> Self {
+        // Check for true color support
+        let colorterm = std::env::var("COLORTERM").unwrap_or_default();
+        let term = std::env::var("TERM").unwrap_or_default();
+
+        if colorterm == "truecolor" || colorterm == "24bit" {
+            return Self::Full;
+        }
+
+        if term.contains("256color") || term.contains("kitty") || term.contains("alacritty") {
+            return Self::Unicode256;
+        }
+
+        // Check if we're in a linux VT or basic terminal
+        if term == "linux" || term == "vt100" || term == "dumb" {
+            return Self::Basic;
+        }
+
+        // Default to unicode with 256 colors
+        Self::Unicode256
+    }
+
+    /// Check if Unicode box drawing is supported
+    pub fn supports_unicode(&self) -> bool {
+        matches!(self, Self::Full | Self::Unicode256)
+    }
+
+    /// Check if true color (RGB) is supported
+    pub fn supports_truecolor(&self) -> bool {
+        matches!(self, Self::Full)
+    }
+}
+
+/// Symbols with fallbacks for different terminal capabilities
+#[derive(Debug, Clone)]
+pub struct Symbols {
+    pub horizontal_rule: &'static str,
+    pub vertical_separator: &'static str,
+    pub bullet: &'static str,
+    pub arrow: &'static str,
+    pub check: &'static str,
+    pub cross: &'static str,
+    pub warning: &'static str,
+    pub info: &'static str,
+    pub streaming: &'static str,
+    pub user_prefix: &'static str,
+    pub assistant_prefix: &'static str,
+    pub tool_prefix: &'static str,
+    pub system_prefix: &'static str,
+    // Provider icons
+    pub claude_icon: &'static str,
+    pub ollama_icon: &'static str,
+    pub openai_icon: &'static str,
+    // Vim mode indicators
+    pub mode_normal: &'static str,
+    pub mode_insert: &'static str,
+    pub mode_visual: &'static str,
+    pub mode_command: &'static str,
+}
+
+impl Symbols {
+    /// Unicode symbols for capable terminals
+    pub fn unicode() -> Self {
+        Self {
+            horizontal_rule: "─",
+            vertical_separator: "│",
+            bullet: "•",
+            arrow: "→",
+            check: "✓",
+            cross: "✗",
+            warning: "⚠",
+            info: "ℹ",
+            streaming: "●",
+            user_prefix: "❯",
+            assistant_prefix: "◆",
+            tool_prefix: "⚡",
+            system_prefix: "○",
+            claude_icon: "󰚩",
+            ollama_icon: "󰫢",
+            openai_icon: "󰊤",
+            mode_normal: "[N]",
+            mode_insert: "[I]",
+            mode_visual: "[V]",
+            mode_command: "[:]",
+        }
+    }
+
+    /// ASCII fallback symbols
+    pub fn ascii() -> Self {
+        Self {
+            horizontal_rule: "-",
+            vertical_separator: "|",
+            bullet: "*",
+            arrow: "->",
+            check: "+",
+            cross: "x",
+            warning: "!",
+            info: "i",
+            streaming: "*",
+            user_prefix: ">",
+            assistant_prefix: "-",
+            tool_prefix: "#",
+            system_prefix: "-",
+            claude_icon: "C",
+            ollama_icon: "O",
+            openai_icon: "G",
+            mode_normal: "[N]",
+            mode_insert: "[I]",
+            mode_visual: "[V]",
+            mode_command: "[:]",
+        }
+    }
+
+    /// Select symbols based on terminal capability
+    pub fn for_capability(cap: TerminalCapability) -> Self {
+        match cap {
+            TerminalCapability::Full | TerminalCapability::Unicode256 => Self::unicode(),
+            TerminalCapability::Basic => Self::ascii(),
+        }
+    }
+}
+
 /// Modern color palette inspired by contemporary design systems
 #[derive(Debug, Clone)]
 pub struct ColorPalette {
@@ -13,8 +153,18 @@ pub struct ColorPalette {
     pub bg: Color,
     pub fg: Color,
     pub fg_dim: Color,
-    pub border: Color,
+    pub fg_muted: Color,
     pub highlight: Color,
+    // Provider-specific colors
+    pub claude: Color,
+    pub ollama: Color,
+    pub openai: Color,
+    // Semantic colors for borderless design
+    pub user_fg: Color,
+    pub assistant_fg: Color,
+    pub tool_fg: Color,
+    pub timestamp_fg: Color,
+    pub divider_fg: Color,
 }
 
 impl ColorPalette {
@@ -31,8 +181,18 @@ impl ColorPalette {
             bg: Color::Rgb(26, 27, 38),            // Dark bg
             fg: Color::Rgb(192, 202, 245),         // Light text
             fg_dim: Color::Rgb(86, 95, 137),       // Dimmed text
-            border: Color::Rgb(77, 124, 254),      // Blue border
+            fg_muted: Color::Rgb(65, 72, 104),     // Very dim
             highlight: Color::Rgb(56, 62, 90),     // Selection bg
+            // Provider colors
+            claude: Color::Rgb(217, 119, 87),      // Claude orange
+            ollama: Color::Rgb(122, 162, 247),     // Blue
+            openai: Color::Rgb(16, 163, 127),      // OpenAI green
+            // Semantic
+            user_fg: Color::Rgb(255, 255, 255),    // Bright white for user
+            assistant_fg: Color::Rgb(125, 207, 255), // Cyan for AI
+            tool_fg: Color::Rgb(224, 175, 104),    // Yellow for tools
+            timestamp_fg: Color::Rgb(65, 72, 104), // Very dim
+            divider_fg: Color::Rgb(56, 62, 90),    // Subtle divider
         }
     }
 
@@ -49,8 +209,16 @@ impl ColorPalette {
             bg: Color::Rgb(40, 42, 54),            // Dark bg
             fg: Color::Rgb(248, 248, 242),         // Light text
             fg_dim: Color::Rgb(98, 114, 164),      // Comment
-            border: Color::Rgb(98, 114, 164),      // Border
+            fg_muted: Color::Rgb(68, 71, 90),      // Very dim
             highlight: Color::Rgb(68, 71, 90),     // Selection
+            claude: Color::Rgb(255, 121, 198),
+            ollama: Color::Rgb(139, 233, 253),
+            openai: Color::Rgb(80, 250, 123),
+            user_fg: Color::Rgb(248, 248, 242),
+            assistant_fg: Color::Rgb(139, 233, 253),
+            tool_fg: Color::Rgb(241, 250, 140),
+            timestamp_fg: Color::Rgb(68, 71, 90),
+            divider_fg: Color::Rgb(68, 71, 90),
         }
     }
 
@@ -67,8 +235,16 @@ impl ColorPalette {
             bg: Color::Rgb(30, 30, 46),            // Base
             fg: Color::Rgb(205, 214, 244),         // Text
             fg_dim: Color::Rgb(108, 112, 134),     // Overlay
-            border: Color::Rgb(137, 180, 250),     // Blue
+            fg_muted: Color::Rgb(69, 71, 90),      // Surface
             highlight: Color::Rgb(49, 50, 68),     // Surface
+            claude: Color::Rgb(245, 194, 231),
+            ollama: Color::Rgb(137, 180, 250),
+            openai: Color::Rgb(166, 227, 161),
+            user_fg: Color::Rgb(205, 214, 244),
+            assistant_fg: Color::Rgb(148, 226, 213),
+            tool_fg: Color::Rgb(249, 226, 175),
+            timestamp_fg: Color::Rgb(69, 71, 90),
+            divider_fg: Color::Rgb(69, 71, 90),
         }
     }
 
@@ -85,8 +261,16 @@ impl ColorPalette {
             bg: Color::Rgb(46, 52, 64),            // Polar night
             fg: Color::Rgb(236, 239, 244),         // Snow storm
             fg_dim: Color::Rgb(76, 86, 106),       // Polar night light
-            border: Color::Rgb(129, 161, 193),     // Frost
+            fg_muted: Color::Rgb(59, 66, 82),
             highlight: Color::Rgb(59, 66, 82),     // Selection
+            claude: Color::Rgb(180, 142, 173),
+            ollama: Color::Rgb(136, 192, 208),
+            openai: Color::Rgb(163, 190, 140),
+            user_fg: Color::Rgb(236, 239, 244),
+            assistant_fg: Color::Rgb(136, 192, 208),
+            tool_fg: Color::Rgb(235, 203, 139),
+            timestamp_fg: Color::Rgb(59, 66, 82),
+            divider_fg: Color::Rgb(59, 66, 82),
         }
     }
 
@@ -103,8 +287,16 @@ impl ColorPalette {
             bg: Color::Rgb(20, 16, 32),            // Dark purple
             fg: Color::Rgb(242, 233, 255),         // Light purple
             fg_dim: Color::Rgb(127, 90, 180),      // Mid purple
-            border: Color::Rgb(255, 0, 128),       // Hot pink
+            fg_muted: Color::Rgb(72, 12, 168),
             highlight: Color::Rgb(72, 12, 168),    // Deep purple
+            claude: Color::Rgb(255, 128, 0),
+            ollama: Color::Rgb(0, 229, 255),
+            openai: Color::Rgb(0, 255, 157),
+            user_fg: Color::Rgb(242, 233, 255),
+            assistant_fg: Color::Rgb(0, 229, 255),
+            tool_fg: Color::Rgb(255, 215, 0),
+            timestamp_fg: Color::Rgb(72, 12, 168),
+            divider_fg: Color::Rgb(72, 12, 168),
         }
     }
 
@@ -121,8 +313,16 @@ impl ColorPalette {
             bg: Color::Rgb(25, 23, 36),            // Base
             fg: Color::Rgb(224, 222, 244),         // Text
             fg_dim: Color::Rgb(110, 106, 134),     // Muted
-            border: Color::Rgb(156, 207, 216),     // Foam
+            fg_muted: Color::Rgb(42, 39, 63),
             highlight: Color::Rgb(42, 39, 63),     // Highlight
+            claude: Color::Rgb(234, 154, 151),
+            ollama: Color::Rgb(156, 207, 216),
+            openai: Color::Rgb(49, 116, 143),
+            user_fg: Color::Rgb(224, 222, 244),
+            assistant_fg: Color::Rgb(156, 207, 216),
+            tool_fg: Color::Rgb(246, 193, 119),
+            timestamp_fg: Color::Rgb(42, 39, 63),
+            divider_fg: Color::Rgb(42, 39, 63),
         }
     }
 
@@ -139,43 +339,121 @@ impl ColorPalette {
             bg: Color::Rgb(1, 22, 39),             // Deep ocean
             fg: Color::Rgb(201, 211, 235),         // Light blue-white
             fg_dim: Color::Rgb(71, 103, 145),      // Muted blue
-            border: Color::Rgb(102, 217, 239),     // Bright cyan
+            fg_muted: Color::Rgb(13, 43, 69),
             highlight: Color::Rgb(13, 43, 69),     // Deep blue
+            claude: Color::Rgb(199, 146, 234),
+            ollama: Color::Rgb(102, 217, 239),
+            openai: Color::Rgb(163, 190, 140),
+            user_fg: Color::Rgb(201, 211, 235),
+            assistant_fg: Color::Rgb(102, 217, 239),
+            tool_fg: Color::Rgb(229, 200, 144),
+            timestamp_fg: Color::Rgb(13, 43, 69),
+            divider_fg: Color::Rgb(13, 43, 69),
         }
     }
 }
 
-/// Theme configuration for the TUI
+/// LLM Provider enum
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Provider {
+    Claude,
+    Ollama,
+    OpenAI,
+}
+
+impl Provider {
+    pub fn name(&self) -> &'static str {
+        match self {
+            Provider::Claude => "Claude",
+            Provider::Ollama => "Ollama",
+            Provider::OpenAI => "OpenAI",
+        }
+    }
+
+    pub fn all() -> &'static [Provider] {
+        &[Provider::Claude, Provider::Ollama, Provider::OpenAI]
+    }
+}
+
+/// Vim-like editing mode
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum VimMode {
+    #[default]
+    Normal,
+    Insert,
+    Visual,
+    Command,
+}
+
+impl VimMode {
+    pub fn indicator(&self, symbols: &Symbols) -> &'static str {
+        match self {
+            VimMode::Normal => symbols.mode_normal,
+            VimMode::Insert => symbols.mode_insert,
+            VimMode::Visual => symbols.mode_visual,
+            VimMode::Command => symbols.mode_command,
+        }
+    }
+}
+
+/// Theme configuration for the borderless TUI
 #[derive(Debug, Clone)]
 pub struct Theme {
     pub palette: ColorPalette,
+    pub symbols: Symbols,
+    pub capability: TerminalCapability,
+    // Message styles
     pub user_message: Style,
     pub assistant_message: Style,
     pub tool_call: Style,
     pub tool_result_success: Style,
     pub tool_result_error: Style,
+    pub system_message: Style,
+    pub timestamp: Style,
+    // UI element styles
+    pub divider: Style,
+    pub header: Style,
+    pub header_accent: Style,
+    pub tab_active: Style,
+    pub tab_inactive: Style,
+    pub input_prefix: Style,
+    pub input_text: Style,
+    pub input_placeholder: Style,
     pub status_bar: Style,
-    pub status_bar_highlight: Style,
+    pub status_accent: Style,
-    pub input_box: Style,
+    pub status_dim: Style,
-    pub input_box_active: Style,
+    // Popup styles (for permission dialogs)
     pub popup_border: Style,
     pub popup_bg: Style,
     pub popup_title: Style,
     pub selected: Style,
+    // Legacy compatibility
     pub border: Style,
     pub border_active: Style,
+    pub status_bar_highlight: Style,
+    pub input_box: Style,
+    pub input_box_active: Style,
 }
 
 impl Theme {
-    /// Create theme from color palette
+    /// Create theme from color palette with automatic capability detection
     pub fn from_palette(palette: ColorPalette) -> Self {
+        let capability = TerminalCapability::detect();
+        Self::from_palette_with_capability(palette, capability)
+    }
+
+    /// Create theme with specific terminal capability
+    pub fn from_palette_with_capability(palette: ColorPalette, capability: TerminalCapability) -> Self {
+        let symbols = Symbols::for_capability(capability);
+
         Self {
+            // Message styles
             user_message: Style::default()
-                .fg(palette.primary)
+                .fg(palette.user_fg)
                 .add_modifier(Modifier::BOLD),
-            assistant_message: Style::default().fg(palette.fg),
+            assistant_message: Style::default().fg(palette.assistant_fg),
             tool_call: Style::default()
-                .fg(palette.warning)
+                .fg(palette.tool_fg)
                 .add_modifier(Modifier::ITALIC),
             tool_result_success: Style::default()
                 .fg(palette.success)
@@ -183,18 +461,29 @@ impl Theme {
             tool_result_error: Style::default()
                 .fg(palette.error)
                 .add_modifier(Modifier::BOLD),
-            status_bar: Style::default()
+            system_message: Style::default().fg(palette.fg_dim),
-                .fg(palette.bg)
+            timestamp: Style::default().fg(palette.timestamp_fg),
-                .bg(palette.primary)
+            // UI elements
+            divider: Style::default().fg(palette.divider_fg),
+            header: Style::default()
+                .fg(palette.fg)
                 .add_modifier(Modifier::BOLD),
-            status_bar_highlight: Style::default()
+            header_accent: Style::default()
-                .fg(palette.bg)
-                .bg(palette.accent)
-                .add_modifier(Modifier::BOLD),
-            input_box: Style::default().fg(palette.fg),
-            input_box_active: Style::default()
                 .fg(palette.accent)
                 .add_modifier(Modifier::BOLD),
+            tab_active: Style::default()
+                .fg(palette.primary)
+                .add_modifier(Modifier::BOLD | Modifier::UNDERLINED),
+            tab_inactive: Style::default().fg(palette.fg_dim),
+            input_prefix: Style::default()
+                .fg(palette.accent)
+                .add_modifier(Modifier::BOLD),
+            input_text: Style::default().fg(palette.fg),
+            input_placeholder: Style::default().fg(palette.fg_muted),
+            status_bar: Style::default().fg(palette.fg_dim),
+            status_accent: Style::default().fg(palette.accent),
+            status_dim: Style::default().fg(palette.fg_muted),
+            // Popup styles
             popup_border: Style::default()
                 .fg(palette.accent)
                 .add_modifier(Modifier::BOLD),
@@ -206,14 +495,48 @@ impl Theme {
                 .fg(palette.bg)
                 .bg(palette.accent)
                 .add_modifier(Modifier::BOLD),
-            border: Style::default().fg(palette.border),
+            // Legacy compatibility
+            border: Style::default().fg(palette.fg_dim),
             border_active: Style::default()
                 .fg(palette.primary)
                 .add_modifier(Modifier::BOLD),
+            status_bar_highlight: Style::default()
+                .fg(palette.bg)
+                .bg(palette.accent)
+                .add_modifier(Modifier::BOLD),
+            input_box: Style::default().fg(palette.fg),
+            input_box_active: Style::default()
+                .fg(palette.accent)
+                .add_modifier(Modifier::BOLD),
+            symbols,
+            capability,
             palette,
         }
     }
 
+    /// Get provider-specific color
+    pub fn provider_color(&self, provider: Provider) -> Color {
+        match provider {
+            Provider::Claude => self.palette.claude,
+            Provider::Ollama => self.palette.ollama,
+            Provider::OpenAI => self.palette.openai,
+        }
+    }
+
+    /// Get provider icon
+    pub fn provider_icon(&self, provider: Provider) -> &str {
+        match provider {
+            Provider::Claude => self.symbols.claude_icon,
+            Provider::Ollama => self.symbols.ollama_icon,
+            Provider::OpenAI => self.symbols.openai_icon,
+        }
+    }
+
+    /// Create a horizontal rule string of given width
+    pub fn horizontal_rule(&self, width: usize) -> String {
+        self.symbols.horizontal_rule.repeat(width)
+    }
+
     /// Tokyo Night theme (default) - modern and vibrant
     pub fn tokyo_night() -> Self {
         Self::from_palette(ColorPalette::tokyo_night())
@@ -255,3 +578,48 @@ impl Default for Theme {
         Self::tokyo_night()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_terminal_capability_detection() {
+        let cap = TerminalCapability::detect();
+        // Should return some valid capability
+        assert!(matches!(
+            cap,
+            TerminalCapability::Full | TerminalCapability::Unicode256 | TerminalCapability::Basic
+        ));
+    }
+
+    #[test]
+    fn test_symbols_for_capability() {
+        let unicode = Symbols::for_capability(TerminalCapability::Full);
+        assert_eq!(unicode.horizontal_rule, "─");
+
+        let ascii = Symbols::for_capability(TerminalCapability::Basic);
+        assert_eq!(ascii.horizontal_rule, "-");
+    }
+
+    #[test]
+    fn test_theme_from_palette() {
+        let theme = Theme::tokyo_night();
+        assert!(theme.capability.supports_unicode() || !theme.capability.supports_unicode());
+    }
+
+    #[test]
+    fn test_provider_colors() {
+        let theme = Theme::tokyo_night();
+        let claude_color = theme.provider_color(Provider::Claude);
+        let ollama_color = theme.provider_color(Provider::Ollama);
+        assert_ne!(claude_color, ollama_color);
+    }
+
+    #[test]
+    fn test_vim_mode_indicator() {
+        let symbols = Symbols::unicode();
+        assert_eq!(VimMode::Normal.indicator(&symbols), "[N]");
+        assert_eq!(VimMode::Insert.indicator(&symbols), "[I]");
+    }
+}

crates/core/agent/Cargo.toml

@@ -11,12 +11,17 @@ serde_json = "1"
 color-eyre = "0.6"
 tokio = { version = "1", features = ["full"] }
 futures-util = "0.3"
+tracing = "0.1"
+async-trait = "0.1"
 
 # Internal dependencies
-llm-ollama = { path = "../../llm/ollama" }
+llm-core = { path = "../../llm/core" }
 permissions = { path = "../../platform/permissions" }
 tools-fs = { path = "../../tools/fs" }
 tools-bash = { path = "../../tools/bash" }
+tools-ask = { path = "../../tools/ask" }
+tools-todo = { path = "../../tools/todo" }
+tools-web = { path = "../../tools/web" }
 
 [dev-dependencies]
 tempfile = "3.13"

crates/core/agent/examples/git_demo.rs

@@ -0,0 +1,74 @@
+//! Example demonstrating the git integration module
+//!
+//! Run with: cargo run -p agent-core --example git_demo
+
+use agent_core::{detect_git_state, format_git_status, is_safe_git_command, is_destructive_git_command};
+use std::env;
+
+fn main() -> color_eyre::Result<()> {
+    color_eyre::install()?;
+
+    // Get current working directory
+    let cwd = env::current_dir()?;
+    println!("Detecting git state in: {}\n", cwd.display());
+
+    // Detect git state
+    let state = detect_git_state(&cwd)?;
+
+    // Display formatted status
+    println!("{}\n", format_git_status(&state));
+
+    // Show detailed file status if there are changes
+    if !state.status.is_empty() {
+        println!("Detailed file status:");
+        for status in &state.status {
+            match status {
+                agent_core::GitFileStatus::Modified { path } => {
+                    println!("  M {}", path);
+                }
+                agent_core::GitFileStatus::Added { path } => {
+                    println!("  A {}", path);
+                }
+                agent_core::GitFileStatus::Deleted { path } => {
+                    println!("  D {}", path);
+                }
+                agent_core::GitFileStatus::Renamed { from, to } => {
+                    println!("  R {} -> {}", from, to);
+                }
+                agent_core::GitFileStatus::Untracked { path } => {
+                    println!("  ? {}", path);
+                }
+            }
+        }
+        println!();
+    }
+
+    // Test command safety checking
+    println!("Command safety checks:");
+    let test_commands = vec![
+        "git status",
+        "git log --oneline",
+        "git diff HEAD",
+        "git commit -m 'test'",
+        "git push --force origin main",
+        "git reset --hard HEAD~1",
+        "git rebase main",
+        "git branch -D feature",
+    ];
+
+    for cmd in test_commands {
+        let is_safe = is_safe_git_command(cmd);
+        let (is_destructive, warning) = is_destructive_git_command(cmd);
+
+        print!("  {} - ", cmd);
+        if is_safe {
+            println!("SAFE (read-only)");
+        } else if is_destructive {
+            println!("DESTRUCTIVE: {}", warning);
+        } else {
+            println!("UNSAFE (modifies state)");
+        }
+    }
+
+    Ok(())
+}

crates/core/agent/examples/streaming_agent.rs

@@ -0,0 +1,92 @@
+/// Example demonstrating the streaming agent loop API
+///
+/// This example shows how to use `run_agent_loop_streaming` to receive
+/// real-time events during agent execution, including:
+/// - Text deltas as the LLM generates text
+/// - Tool execution start/end events
+/// - Tool output events
+/// - Final completion events
+///
+/// Run with: cargo run --example streaming_agent -p agent-core
+
+use agent_core::{create_event_channel, run_agent_loop_streaming, AgentEvent, ToolContext};
+use llm_core::ChatOptions;
+use permissions::{Mode, PermissionManager};
+
+#[tokio::main]
+async fn main() -> color_eyre::Result<()> {
+    color_eyre::install()?;
+
+    // Note: This is a minimal example. In a real application, you would:
+    // 1. Initialize a real LLM provider (e.g., OllamaClient)
+    // 2. Configure the ChatOptions with your preferred model
+    // 3. Set up appropriate permissions and tool context
+
+    println!("=== Streaming Agent Example ===\n");
+    println!("This example demonstrates how to use the streaming agent loop API.");
+    println!("To run with a real LLM provider, modify this example to:");
+    println!("  1. Create an LLM provider instance");
+    println!("  2. Set up permissions and tool context");
+    println!("  3. Call run_agent_loop_streaming with your prompt\n");
+
+    // Example code structure:
+    println!("Example code:");
+    println!("```rust");
+    println!("// Create LLM provider");
+    println!("let provider = OllamaClient::new(\"http://localhost:11434\");");
+    println!();
+    println!("// Set up permissions and context");
+    println!("let perms = PermissionManager::new(Mode::Plan);");
+    println!("let ctx = ToolContext::default();");
+    println!();
+    println!("// Create event channel");
+    println!("let (tx, mut rx) = create_event_channel();");
+    println!();
+    println!("// Spawn agent loop");
+    println!("let handle = tokio::spawn(async move {{");
+    println!("    run_agent_loop_streaming(");
+    println!("        &provider,");
+    println!("        \"Your prompt here\",");
+    println!("        &ChatOptions::default(),");
+    println!("        &perms,");
+    println!("        &ctx,");
+    println!("        tx,");
+    println!("    ).await");
+    println!("}});");
+    println!();
+    println!("// Process events");
+    println!("while let Some(event) = rx.recv().await {{");
+    println!("    match event {{");
+    println!("        AgentEvent::TextDelta(text) => {{");
+    println!("            print!(\"{{text}}\");");
+    println!("        }}");
+    println!("        AgentEvent::ToolStart {{ tool_name, .. }} => {{");
+    println!("            println!(\"\\n[Executing tool: {{tool_name}}]\");");
+    println!("        }}");
+    println!("        AgentEvent::ToolOutput {{ content, is_error, .. }} => {{");
+    println!("            if is_error {{");
+    println!("                eprintln!(\"Error: {{content}}\");");
+    println!("            }} else {{");
+    println!("                println!(\"Output: {{content}}\");");
+    println!("            }}");
+    println!("        }}");
+    println!("        AgentEvent::ToolEnd {{ success, .. }} => {{");
+    println!("            println!(\"[Tool finished: {{}}]\", if success {{ \"success\" }} else {{ \"failed\" }});");
+    println!("        }}");
+    println!("        AgentEvent::Done {{ final_response }} => {{");
+    println!("            println!(\"\\n\\nFinal response: {{final_response}}\");");
+    println!("            break;");
+    println!("        }}");
+    println!("        AgentEvent::Error(e) => {{");
+    println!("            eprintln!(\"Error: {{e}}\");");
+    println!("            break;");
+    println!("        }}");
+    println!("    }}");
+    println!("}}");
+    println!();
+    println!("// Wait for completion");
+    println!("let result = handle.await??;");
+    println!("```");
+
+    Ok(())
+}

crates/core/agent/src/git.rs

@@ -0,0 +1,557 @@
+//! Git integration module for detecting repository state and validating git commands.
+//!
+//! This module provides functionality to:
+//! - Detect if the current directory is a git repository
+//! - Capture git repository state (branch, status, uncommitted changes)
+//! - Validate git commands for safety (read-only vs destructive operations)
+
+use color_eyre::eyre::Result;
+use std::path::Path;
+use std::process::Command;
+
+/// Status of a file in the git working tree
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum GitFileStatus {
+    /// File has been modified
+    Modified { path: String },
+    /// File has been added (staged)
+    Added { path: String },
+    /// File has been deleted
+    Deleted { path: String },
+    /// File has been renamed
+    Renamed { from: String, to: String },
+    /// File is untracked
+    Untracked { path: String },
+}
+
+impl GitFileStatus {
+    /// Get the primary path associated with this status
+    pub fn path(&self) -> &str {
+        match self {
+            Self::Modified { path } => path,
+            Self::Added { path } => path,
+            Self::Deleted { path } => path,
+            Self::Renamed { to, .. } => to,
+            Self::Untracked { path } => path,
+        }
+    }
+}
+
+/// Complete state of a git repository
+#[derive(Debug, Clone)]
+pub struct GitState {
+    /// Whether the current directory is in a git repository
+    pub is_git_repo: bool,
+    /// Current branch name (None if not in a repo or detached HEAD)
+    pub current_branch: Option<String>,
+    /// Main branch name (main/master, None if not detected)
+    pub main_branch: Option<String>,
+    /// Status of files in the working tree
+    pub status: Vec<GitFileStatus>,
+    /// Whether there are any uncommitted changes
+    pub has_uncommitted_changes: bool,
+    /// Remote URL for the repository (None if no remote configured)
+    pub remote_url: Option<String>,
+}
+
+impl GitState {
+    /// Create a default GitState for non-git directories
+    pub fn not_a_repo() -> Self {
+        Self {
+            is_git_repo: false,
+            current_branch: None,
+            main_branch: None,
+            status: Vec::new(),
+            has_uncommitted_changes: false,
+            remote_url: None,
+        }
+    }
+}
+
+/// Detect the current git repository state
+///
+/// This function runs various git commands to gather information about the repository.
+/// If git is not available or the directory is not a git repo, returns a default state.
+pub fn detect_git_state(working_dir: &Path) -> Result<GitState> {
+    // Check if this is a git repository
+    let is_repo = Command::new("git")
+        .arg("rev-parse")
+        .arg("--git-dir")
+        .current_dir(working_dir)
+        .output()
+        .map(|output| output.status.success())
+        .unwrap_or(false);
+
+    if !is_repo {
+        return Ok(GitState::not_a_repo());
+    }
+
+    // Get current branch
+    let current_branch = get_current_branch(working_dir)?;
+
+    // Detect main branch (try main first, then master)
+    let main_branch = detect_main_branch(working_dir)?;
+
+    // Get file status
+    let status = get_git_status(working_dir)?;
+
+    // Check if there are uncommitted changes
+    let has_uncommitted_changes = !status.is_empty();
+
+    // Get remote URL
+    let remote_url = get_remote_url(working_dir)?;
+
+    Ok(GitState {
+        is_git_repo: true,
+        current_branch,
+        main_branch,
+        status,
+        has_uncommitted_changes,
+        remote_url,
+    })
+}
+
+/// Get the current branch name
+fn get_current_branch(working_dir: &Path) -> Result<Option<String>> {
+    let output = Command::new("git")
+        .arg("rev-parse")
+        .arg("--abbrev-ref")
+        .arg("HEAD")
+        .current_dir(working_dir)
+        .output()?;
+
+    if !output.status.success() {
+        return Ok(None);
+    }
+
+    let branch = String::from_utf8_lossy(&output.stdout).trim().to_string();
+
+    // "HEAD" means detached HEAD state
+    if branch == "HEAD" {
+        Ok(None)
+    } else {
+        Ok(Some(branch))
+    }
+}
+
+/// Detect the main branch (main or master)
+fn detect_main_branch(working_dir: &Path) -> Result<Option<String>> {
+    // Try to get all branches
+    let output = Command::new("git")
+        .arg("branch")
+        .arg("-a")
+        .current_dir(working_dir)
+        .output()?;
+
+    if !output.status.success() {
+        return Ok(None);
+    }
+
+    let branches = String::from_utf8_lossy(&output.stdout);
+
+    // Check for main branch first (modern convention)
+    if branches.lines().any(|line| {
+        let trimmed = line.trim_start_matches('*').trim();
+        trimmed == "main" || trimmed.ends_with("/main")
+    }) {
+        return Ok(Some("main".to_string()));
+    }
+
+    // Fall back to master
+    if branches.lines().any(|line| {
+        let trimmed = line.trim_start_matches('*').trim();
+        trimmed == "master" || trimmed.ends_with("/master")
+    }) {
+        return Ok(Some("master".to_string()));
+    }
+
+    Ok(None)
+}
+
+/// Get the git status for all files
+fn get_git_status(working_dir: &Path) -> Result<Vec<GitFileStatus>> {
+    let output = Command::new("git")
+        .arg("status")
+        .arg("--porcelain")
+        .arg("-z") // Null-terminated for better parsing
+        .current_dir(working_dir)
+        .output()?;
+
+    if !output.status.success() {
+        return Ok(Vec::new());
+    }
+
+    let status_text = String::from_utf8_lossy(&output.stdout);
+    let mut statuses = Vec::new();
+
+    // Parse porcelain format with null termination
+    // Format: XY filename\0 (where X is staged status, Y is unstaged status)
+    for entry in status_text.split('\0').filter(|s| !s.is_empty()) {
+        if entry.len() < 3 {
+            continue;
+        }
+
+        let status_code = &entry[0..2];
+        let path = entry[3..].to_string();
+
+        // Parse status codes
+        match status_code {
+            "M " | " M" | "MM" => {
+                statuses.push(GitFileStatus::Modified { path });
+            }
+            "A " | " A" | "AM" => {
+                statuses.push(GitFileStatus::Added { path });
+            }
+            "D " | " D" | "AD" => {
+                statuses.push(GitFileStatus::Deleted { path });
+            }
+            "??" => {
+                statuses.push(GitFileStatus::Untracked { path });
+            }
+            s if s.starts_with('R') => {
+                // Renamed files have format "R  old_name -> new_name"
+                if let Some((from, to)) = path.split_once(" -> ") {
+                    statuses.push(GitFileStatus::Renamed {
+                        from: from.to_string(),
+                        to: to.to_string(),
+                    });
+                } else {
+                    // Fallback if parsing fails
+                    statuses.push(GitFileStatus::Modified { path });
+                }
+            }
+            _ => {
+                // Unknown status code, treat as modified
+                statuses.push(GitFileStatus::Modified { path });
+            }
+        }
+    }
+
+    Ok(statuses)
+}
+
+/// Get the remote URL for the repository
+fn get_remote_url(working_dir: &Path) -> Result<Option<String>> {
+    let output = Command::new("git")
+        .arg("remote")
+        .arg("get-url")
+        .arg("origin")
+        .current_dir(working_dir)
+        .output()?;
+
+    if !output.status.success() {
+        return Ok(None);
+    }
+
+    let url = String::from_utf8_lossy(&output.stdout).trim().to_string();
+
+    if url.is_empty() {
+        Ok(None)
+    } else {
+        Ok(Some(url))
+    }
+}
+
+/// Check if a git command is safe (read-only)
+///
+/// Safe commands include:
+/// - status, log, show, diff, branch (without -D)
+/// - remote (without add/remove)
+/// - config --get
+/// - rev-parse, ls-files, ls-tree
+pub fn is_safe_git_command(command: &str) -> bool {
+    let parts: Vec<&str> = command.split_whitespace().collect();
+
+    if parts.is_empty() || parts[0] != "git" {
+        return false;
+    }
+
+    if parts.len() < 2 {
+        return false;
+    }
+
+    let subcommand = parts[1];
+
+    // List of read-only git commands
+    match subcommand {
+        "status" | "log" | "show" | "diff" | "blame" | "reflog" => true,
+        "ls-files" | "ls-tree" | "ls-remote" => true,
+        "rev-parse" | "rev-list" => true,
+        "describe" | "tag" if !command.contains("-d") && !command.contains("--delete") => true,
+        "branch" if !command.contains("-D") && !command.contains("-d") && !command.contains("-m") => true,
+        "remote" if command.contains("get-url") || command.contains("-v") || command.contains("show") => true,
+        "config" if command.contains("--get") || command.contains("--list") => true,
+        "grep" | "shortlog" | "whatchanged" => true,
+        "fetch" if !command.contains("--prune") => true,
+        _ => false,
+    }
+}
+
+/// Check if a git command is destructive
+///
+/// Returns (is_destructive, warning_message) tuple.
+/// Destructive commands include:
+/// - push --force, reset --hard, clean -fd
+/// - rebase, amend, filter-branch
+/// - branch -D, tag -d
+pub fn is_destructive_git_command(command: &str) -> (bool, &'static str) {
+    let cmd_lower = command.to_lowercase();
+
+    // Check for force push
+    if cmd_lower.contains("push") && (cmd_lower.contains("--force") || cmd_lower.contains("-f")) {
+        return (true, "Force push can overwrite remote history and affect other collaborators");
+    }
+
+    // Check for hard reset
+    if cmd_lower.contains("reset") && cmd_lower.contains("--hard") {
+        return (true, "Hard reset will discard uncommitted changes permanently");
+    }
+
+    // Check for git clean
+    if cmd_lower.contains("clean") && (cmd_lower.contains("-f") || cmd_lower.contains("-d")) {
+        return (true, "Git clean will permanently delete untracked files");
+    }
+
+    // Check for rebase
+    if cmd_lower.contains("rebase") {
+        return (true, "Rebase rewrites commit history and can cause conflicts");
+    }
+
+    // Check for amend
+    if cmd_lower.contains("commit") && cmd_lower.contains("--amend") {
+        return (true, "Amending rewrites the last commit and changes its hash");
+    }
+
+    // Check for filter-branch or filter-repo
+    if cmd_lower.contains("filter-branch") || cmd_lower.contains("filter-repo") {
+        return (true, "Filter operations rewrite repository history");
+    }
+
+    // Check for branch/tag deletion
+    if (cmd_lower.contains("branch") && (cmd_lower.contains("-D") || cmd_lower.contains("-d")))
+        || (cmd_lower.contains("tag") && (cmd_lower.contains("-d") || cmd_lower.contains("--delete")))
+    {
+        return (true, "This will delete a branch or tag");
+    }
+
+    // Check for reflog expire
+    if cmd_lower.contains("reflog") && cmd_lower.contains("expire") {
+        return (true, "Expiring reflog removes recovery points for lost commits");
+    }
+
+    // Check for gc with aggressive or prune
+    if cmd_lower.contains("gc") && (cmd_lower.contains("--aggressive") || cmd_lower.contains("--prune")) {
+        return (true, "Aggressive garbage collection can make recovery difficult");
+    }
+
+    (false, "")
+}
+
+/// Format git state for human-readable display
+///
+/// Example output:
+/// ```text
+/// Git Repository: yes
+/// Current branch: feature-branch
+/// Main branch: main
+/// Status: 3 modified, 1 untracked
+/// Remote: https://github.com/user/repo.git
+/// ```
+pub fn format_git_status(state: &GitState) -> String {
+    if !state.is_git_repo {
+        return "Not a git repository".to_string();
+    }
+
+    let mut lines = Vec::new();
+
+    lines.push("Git Repository: yes".to_string());
+
+    if let Some(branch) = &state.current_branch {
+        lines.push(format!("Current branch: {}", branch));
+    } else {
+        lines.push("Current branch: (detached HEAD)".to_string());
+    }
+
+    if let Some(main) = &state.main_branch {
+        lines.push(format!("Main branch: {}", main));
+    }
+
+    // Summarize status
+    if state.status.is_empty() {
+        lines.push("Status: clean working tree".to_string());
+    } else {
+        let mut modified = 0;
+        let mut added = 0;
+        let mut deleted = 0;
+        let mut renamed = 0;
+        let mut untracked = 0;
+
+        for status in &state.status {
+            match status {
+                GitFileStatus::Modified { .. } => modified += 1,
+                GitFileStatus::Added { .. } => added += 1,
+                GitFileStatus::Deleted { .. } => deleted += 1,
+                GitFileStatus::Renamed { .. } => renamed += 1,
+                GitFileStatus::Untracked { .. } => untracked += 1,
+            }
+        }
+
+        let mut status_parts = Vec::new();
+        if modified > 0 {
+            status_parts.push(format!("{} modified", modified));
+        }
+        if added > 0 {
+            status_parts.push(format!("{} added", added));
+        }
+        if deleted > 0 {
+            status_parts.push(format!("{} deleted", deleted));
+        }
+        if renamed > 0 {
+            status_parts.push(format!("{} renamed", renamed));
+        }
+        if untracked > 0 {
+            status_parts.push(format!("{} untracked", untracked));
+        }
+
+        lines.push(format!("Status: {}", status_parts.join(", ")));
+    }
+
+    if let Some(url) = &state.remote_url {
+        lines.push(format!("Remote: {}", url));
+    } else {
+        lines.push("Remote: (none)".to_string());
+    }
+
+    lines.join("\n")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_is_safe_git_command() {
+        // Safe commands
+        assert!(is_safe_git_command("git status"));
+        assert!(is_safe_git_command("git log --oneline"));
+        assert!(is_safe_git_command("git diff HEAD"));
+        assert!(is_safe_git_command("git branch -v"));
+        assert!(is_safe_git_command("git remote -v"));
+        assert!(is_safe_git_command("git config --get user.name"));
+
+        // Unsafe commands
+        assert!(!is_safe_git_command("git commit -m test"));
+        assert!(!is_safe_git_command("git push origin main"));
+        assert!(!is_safe_git_command("git branch -D feature"));
+        assert!(!is_safe_git_command("git remote add origin url"));
+    }
+
+    #[test]
+    fn test_is_destructive_git_command() {
+        // Destructive commands
+        let (is_dest, msg) = is_destructive_git_command("git push --force origin main");
+        assert!(is_dest);
+        assert!(msg.contains("Force push"));
+
+        let (is_dest, msg) = is_destructive_git_command("git reset --hard HEAD~1");
+        assert!(is_dest);
+        assert!(msg.contains("Hard reset"));
+
+        let (is_dest, msg) = is_destructive_git_command("git clean -fd");
+        assert!(is_dest);
+        assert!(msg.contains("clean"));
+
+        let (is_dest, msg) = is_destructive_git_command("git rebase main");
+        assert!(is_dest);
+        assert!(msg.contains("Rebase"));
+
+        let (is_dest, msg) = is_destructive_git_command("git commit --amend");
+        assert!(is_dest);
+        assert!(msg.contains("Amending"));
+
+        // Non-destructive commands
+        let (is_dest, _) = is_destructive_git_command("git status");
+        assert!(!is_dest);
+
+        let (is_dest, _) = is_destructive_git_command("git log");
+        assert!(!is_dest);
+
+        let (is_dest, _) = is_destructive_git_command("git diff");
+        assert!(!is_dest);
+    }
+
+    #[test]
+    fn test_git_state_not_a_repo() {
+        let state = GitState::not_a_repo();
+        assert!(!state.is_git_repo);
+        assert!(state.current_branch.is_none());
+        assert!(state.main_branch.is_none());
+        assert!(state.status.is_empty());
+        assert!(!state.has_uncommitted_changes);
+        assert!(state.remote_url.is_none());
+    }
+
+    #[test]
+    fn test_git_file_status_path() {
+        let status = GitFileStatus::Modified {
+            path: "test.rs".to_string(),
+        };
+        assert_eq!(status.path(), "test.rs");
+
+        let status = GitFileStatus::Renamed {
+            from: "old.rs".to_string(),
+            to: "new.rs".to_string(),
+        };
+        assert_eq!(status.path(), "new.rs");
+    }
+
+    #[test]
+    fn test_format_git_status_not_repo() {
+        let state = GitState::not_a_repo();
+        let formatted = format_git_status(&state);
+        assert_eq!(formatted, "Not a git repository");
+    }
+
+    #[test]
+    fn test_format_git_status_clean() {
+        let state = GitState {
+            is_git_repo: true,
+            current_branch: Some("main".to_string()),
+            main_branch: Some("main".to_string()),
+            status: Vec::new(),
+            has_uncommitted_changes: false,
+            remote_url: Some("https://github.com/user/repo.git".to_string()),
+        };
+
+        let formatted = format_git_status(&state);
+        assert!(formatted.contains("Git Repository: yes"));
+        assert!(formatted.contains("Current branch: main"));
+        assert!(formatted.contains("clean working tree"));
+    }
+
+    #[test]
+    fn test_format_git_status_with_changes() {
+        let state = GitState {
+            is_git_repo: true,
+            current_branch: Some("feature".to_string()),
+            main_branch: Some("main".to_string()),
+            status: vec![
+                GitFileStatus::Modified {
+                    path: "file1.rs".to_string(),
+                },
+                GitFileStatus::Modified {
+                    path: "file2.rs".to_string(),
+                },
+                GitFileStatus::Untracked {
+                    path: "new.rs".to_string(),
+                },
+            ],
+            has_uncommitted_changes: true,
+            remote_url: None,
+        };
+
+        let formatted = format_git_status(&state);
+        assert!(formatted.contains("2 modified"));
+        assert!(formatted.contains("1 untracked"));
+    }
+}

crates/core/agent/src/lib.rs

@@ -1,145 +1,409 @@
 pub mod session;
+pub mod system_prompt;
+pub mod git;
 
 use color_eyre::eyre::{Result, eyre};
-use futures_util::TryStreamExt;
+use futures_util::StreamExt;
-use llm_ollama::{ChatMessage, OllamaClient, OllamaOptions, Tool, ToolFunction, ToolParameters};
+use llm_core::{ChatMessage, ChatOptions, LlmProvider, Tool, ToolParameters};
 use permissions::{PermissionDecision, PermissionManager, Tool as PermTool};
 use serde_json::{json, Value};
+use tokio::sync::mpsc;
+use tools_ask::AskSender;
+use tools_bash::ShellManager;
+use tools_todo::TodoList;
 
 pub use session::{
     SessionStats, SessionHistory, ToolCallRecord,
     Checkpoint, CheckpointManager, FileDiff,
 };
+pub use system_prompt::{
+    SystemPromptBuilder, default_base_prompt, generate_tool_instructions,
+};
+pub use git::{
+    GitState, GitFileStatus,
+    detect_git_state, is_safe_git_command, is_destructive_git_command,
+    format_git_status,
+};
+
+/// Events emitted during agent loop execution
+#[derive(Debug, Clone)]
+pub enum AgentEvent {
+    /// LLM is generating text
+    TextDelta(String),
+
+    /// Tool execution starting
+    ToolStart {
+        tool_name: String,
+        tool_id: String,
+    },
+
+    /// Tool produced output (may be partial)
+    ToolOutput {
+        tool_id: String,
+        content: String,
+        is_error: bool,
+    },
+
+    /// Tool execution completed
+    ToolEnd {
+        tool_id: String,
+        success: bool,
+    },
+
+    /// Agent loop completed
+    Done {
+        final_response: String,
+    },
+
+    /// Error occurred
+    Error(String),
+}
+
+pub type AgentEventSender = mpsc::Sender<AgentEvent>;
+pub type AgentEventReceiver = mpsc::Receiver<AgentEvent>;
+
+/// Create channel for agent events
+pub fn create_event_channel() -> (AgentEventSender, AgentEventReceiver) {
+    mpsc::channel(100)
+}
+
+/// Optional context for tools that need external dependencies
+#[derive(Clone, Default)]
+pub struct ToolContext {
+    /// Todo list for TodoWrite tool
+    pub todo_list: Option<TodoList>,
+
+    /// Channel for asking user questions
+    pub ask_sender: Option<AskSender>,
+
+    /// Shell manager for background shells
+    pub shell_manager: Option<ShellManager>,
+}
+
+impl ToolContext {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn with_todo_list(mut self, list: TodoList) -> Self {
+        self.todo_list = Some(list);
+        self
+    }
+
+    pub fn with_ask_sender(mut self, sender: AskSender) -> Self {
+        self.ask_sender = Some(sender);
+        self
+    }
+
+    pub fn with_shell_manager(mut self, manager: ShellManager) -> Self {
+        self.shell_manager = Some(manager);
+        self
+    }
+}
 
 /// Define all available tools for the LLM
 pub fn get_tool_definitions() -> Vec<Tool> {
     vec![
-        Tool {
+        Tool::function(
-            tool_type: "function".to_string(),
+            "read",
-            function: ToolFunction {
+            "Read the contents of a file",
-                name: "read".to_string(),
+            ToolParameters::object(
-                description: "Read the contents of a file".to_string(),
+                json!({
-                parameters: ToolParameters {
+                    "path": {
-                    param_type: "object".to_string(),
+                        "type": "string",
-                    properties: json!({
+                        "description": "The path to the file to read"
-                        "path": {
+                    }
-                            "type": "string",
+                }),
-                            "description": "The path to the file to read"
+                vec!["path".to_string()],
-                        }
+            ),
-                    }),
+        ),
-                    required: vec!["path".to_string()],
+        Tool::function(
-                },
+            "glob",
-            },
+            "Find files matching a glob pattern (e.g., '**/*.rs' for all Rust files)",
-        },
+            ToolParameters::object(
-        Tool {
+                json!({
-            tool_type: "function".to_string(),
+                    "pattern": {
-            function: ToolFunction {
+                        "type": "string",
-                name: "glob".to_string(),
+                        "description": "Glob pattern to match files (e.g., '**/*.toml', '*.md')"
-                description: "Find files matching a glob pattern (e.g., '**/*.rs' for all Rust files)".to_string(),
+                    }
-                parameters: ToolParameters {
+                }),
-                    param_type: "object".to_string(),
+                vec!["pattern".to_string()],
-                    properties: json!({
+            ),
-                        "pattern": {
+        ),
-                            "type": "string",
+        Tool::function(
-                            "description": "Glob pattern to match files (e.g., '**/*.toml', '*.md')"
+            "grep",
-                        }
+            "Search for a pattern in files within a directory",
-                    }),
+            ToolParameters::object(
-                    required: vec!["pattern".to_string()],
+                json!({
-                },
+                    "root": {
-            },
+                        "type": "string",
-        },
+                        "description": "Root directory to search in"
-        Tool {
+                    },
-            tool_type: "function".to_string(),
+                    "pattern": {
-            function: ToolFunction {
+                        "type": "string",
-                name: "grep".to_string(),
+                        "description": "Pattern to search for"
-                description: "Search for a pattern in files within a directory".to_string(),
+                    }
-                parameters: ToolParameters {
+                }),
-                    param_type: "object".to_string(),
+                vec!["root".to_string(), "pattern".to_string()],
-                    properties: json!({
+            ),
-                        "root": {
+        ),
-                            "type": "string",
+        Tool::function(
-                            "description": "Root directory to search in"
+            "write",
+            "Write content to a file",
+            ToolParameters::object(
+                json!({
+                    "path": {
+                        "type": "string",
+                        "description": "Path where the file should be written"
+                    },
+                    "content": {
+                        "type": "string",
+                        "description": "Content to write to the file"
+                    }
+                }),
+                vec!["path".to_string(), "content".to_string()],
+            ),
+        ),
+        Tool::function(
+            "edit",
+            "Edit a file by replacing old text with new text",
+            ToolParameters::object(
+                json!({
+                    "path": {
+                        "type": "string",
+                        "description": "Path to the file to edit"
+                    },
+                    "old_string": {
+                        "type": "string",
+                        "description": "Text to find and replace"
+                    },
+                    "new_string": {
+                        "type": "string",
+                        "description": "Text to replace with"
+                    }
+                }),
+                vec!["path".to_string(), "old_string".to_string(), "new_string".to_string()],
+            ),
+        ),
+        Tool::function(
+            "bash",
+            "Execute a bash command. Use carefully and only when necessary.",
+            ToolParameters::object(
+                json!({
+                    "command": {
+                        "type": "string",
+                        "description": "The bash command to execute"
+                    }
+                }),
+                vec!["command".to_string()],
+            ),
+        ),
+        Tool::function(
+            "multi_edit",
+            "Apply multiple edits to a file atomically",
+            ToolParameters::object(
+                json!({
+                    "path": {
+                        "type": "string",
+                        "description": "Path to the file to edit"
+                    },
+                    "edits": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "old_string": { "type": "string" },
+                                "new_string": { "type": "string" }
+                            },
+                            "required": ["old_string", "new_string"]
                         },
-                        "pattern": {
+                        "description": "List of edit operations"
-                            "type": "string",
+                    }
-                            "description": "Pattern to search for"
+                }),
+                vec!["path".to_string(), "edits".to_string()],
+            ),
+        ),
+        Tool::function(
+            "ls",
+            "List contents of a directory",
+            ToolParameters::object(
+                json!({
+                    "path": {
+                        "type": "string",
+                        "description": "Directory path to list"
+                    },
+                    "show_hidden": {
+                        "type": "boolean",
+                        "description": "Show hidden files",
+                        "default": false
+                    }
+                }),
+                vec!["path".to_string()],
+            ),
+        ),
+        Tool::function(
+            "web_search",
+            "Search the web for information",
+            ToolParameters::object(
+                json!({
+                    "query": {
+                        "type": "string",
+                        "description": "Search query"
+                    },
+                    "max_results": {
+                        "type": "integer",
+                        "description": "Maximum results",
+                        "default": 10
+                    }
+                }),
+                vec!["query".to_string()],
+            ),
+        ),
+        Tool::function(
+            "todo_write",
+            "Update the task list",
+            ToolParameters::object(
+                json!({
+                    "todos": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "content": { "type": "string" },
+                                "status": {
+                                    "type": "string",
+                                    "enum": ["pending", "in_progress", "completed"]
+                                },
+                                "active_form": { "type": "string" }
+                            },
+                            "required": ["content", "status", "active_form"]
                         }
-                    }),
+                    }
-                    required: vec!["root".to_string(), "pattern".to_string()],
+                }),
-                },
+                vec!["todos".to_string()],
-            },
+            ),
-        },
+        ),
-        Tool {
+        Tool::function(
-            tool_type: "function".to_string(),
+            "ask_user",
-            function: ToolFunction {
+            "Ask the user a question with options",
-                name: "write".to_string(),
+            ToolParameters::object(
-                description: "Write content to a file".to_string(),
+                json!({
-                parameters: ToolParameters {
+                    "questions": {
-                    param_type: "object".to_string(),
+                        "type": "array",
-                    properties: json!({
+                        "items": {
-                        "path": {
+                            "type": "object",
-                            "type": "string",
+                            "properties": {
-                            "description": "Path where the file should be written"
+                                "question": { "type": "string" },
-                        },
+                                "header": { "type": "string" },
-                        "content": {
+                                "options": {
-                            "type": "string",
+                                    "type": "array",
-                            "description": "Content to write to the file"
+                                    "items": {
+                                        "type": "object",
+                                        "properties": {
+                                            "label": { "type": "string" },
+                                            "description": { "type": "string" }
+                                        }
+                                    }
+                                },
+                                "multi_select": { "type": "boolean" }
+                            }
                         }
-                    }),
+                    }
-                    required: vec!["path".to_string(), "content".to_string()],
+                }),
-                },
+                vec!["questions".to_string()],
-            },
+            ),
-        },
+        ),
-        Tool {
+        Tool::function(
-            tool_type: "function".to_string(),
+            "bash_output",
-            function: ToolFunction {
+            "Get output from a background shell",
-                name: "edit".to_string(),
+            ToolParameters::object(
-                description: "Edit a file by replacing old text with new text".to_string(),
+                json!({
-                parameters: ToolParameters {
+                    "shell_id": {
-                    param_type: "object".to_string(),
+                        "type": "string",
-                    properties: json!({
+                        "description": "ID of the background shell"
-                        "path": {
+                    }
-                            "type": "string",
+                }),
-                            "description": "Path to the file to edit"
+                vec!["shell_id".to_string()],
-                        },
+            ),
-                        "old_string": {
+        ),
-                            "type": "string",
+        Tool::function(
-                            "description": "Text to find and replace"
+            "kill_shell",
-                        },
+            "Terminate a background shell",
-                        "new_string": {
+            ToolParameters::object(
-                            "type": "string",
+                json!({
-                            "description": "Text to replace with"
+                    "shell_id": {
-                        }
+                        "type": "string",
-                    }),
+                        "description": "ID of the shell to kill"
-                    required: vec!["path".to_string(), "old_string".to_string(), "new_string".to_string()],
+                    }
-                },
+                }),
-            },
+                vec!["shell_id".to_string()],
-        },
+            ),
-        Tool {
+        ),
-            tool_type: "function".to_string(),
-            function: ToolFunction {
-                name: "bash".to_string(),
-                description: "Execute a bash command. Use carefully and only when necessary.".to_string(),
-                parameters: ToolParameters {
-                    param_type: "object".to_string(),
-                    properties: json!({
-                        "command": {
-                            "type": "string",
-                            "description": "The bash command to execute"
-                        }
-                    }),
-                    required: vec!["command".to_string()],
-                },
-            },
-        },
     ]
 }
 
+/// Helper to accumulate streaming tool call deltas
+#[derive(Default)]
+struct ToolCallsBuilder {
+    calls: Vec<PartialToolCall>,
+}
+
+#[derive(Default)]
+struct PartialToolCall {
+    id: Option<String>,
+    name: Option<String>,
+    arguments: String,
+}
+
+impl ToolCallsBuilder {
+    fn new() -> Self {
+        Self::default()
+    }
+
+    fn add_deltas(&mut self, deltas: &[llm_core::ToolCallDelta]) {
+        for delta in deltas {
+            while self.calls.len() <= delta.index {
+                self.calls.push(PartialToolCall::default());
+            }
+            let call = &mut self.calls[delta.index];
+            if let Some(id) = &delta.id {
+                call.id = Some(id.clone());
+            }
+            if let Some(name) = &delta.function_name {
+                call.name = Some(name.clone());
+            }
+            if let Some(args) = &delta.arguments_delta {
+                call.arguments.push_str(args);
+            }
+        }
+    }
+
+    fn build(self) -> Vec<llm_core::ToolCall> {
+        self.calls
+            .into_iter()
+            .filter_map(|p| {
+                let id = p.id?;
+                let name = p.name?;
+                let args: Value = serde_json::from_str(&p.arguments).ok()?;
+                Some(llm_core::ToolCall {
+                    id,
+                    call_type: "function".to_string(),
+                    function: llm_core::FunctionCall {
+                        name,
+                        arguments: args,
+                    },
+                })
+            })
+            .collect()
+    }
+}
+
 /// Execute a tool call and return the result
 pub async fn execute_tool(
     tool_name: &str,
     arguments: &Value,
     perms: &PermissionManager,
+    ctx: &ToolContext,
 ) -> Result<String> {
     match tool_name {
         "read" => {
@@ -280,23 +544,182 @@ pub async fn execute_tool(
                 }
             }
         }
+        "multi_edit" => {
+            let path = arguments["path"]
+                .as_str()
+                .ok_or_else(|| eyre!("Missing 'path' argument"))?;
+            let edits_value = arguments["edits"]
+                .as_array()
+                .ok_or_else(|| eyre!("Missing or invalid 'edits' argument"))?;
+
+            // Parse edits
+            let edits: Vec<tools_fs::EditOperation> = serde_json::from_value(json!(edits_value))?;
+
+            // Check permission
+            match perms.check(PermTool::MultiEdit, Some(path)) {
+                PermissionDecision::Allow => {
+                    let result = tools_fs::multi_edit_file(path, edits)?;
+                    Ok(result)
+                }
+                PermissionDecision::Ask => {
+                    Err(eyre!("Permission required: MultiEdit operation needs approval"))
+                }
+                PermissionDecision::Deny => {
+                    Err(eyre!("Permission denied: MultiEdit operation is blocked"))
+                }
+            }
+        }
+        "ls" => {
+            let path = arguments["path"]
+                .as_str()
+                .ok_or_else(|| eyre!("Missing 'path' argument"))?;
+            let show_hidden = arguments.get("show_hidden")
+                .and_then(|v| v.as_bool())
+                .unwrap_or(false);
+
+            // Check permission
+            match perms.check(PermTool::LS, Some(path)) {
+                PermissionDecision::Allow => {
+                    let entries = tools_fs::list_directory(path, show_hidden)?;
+                    let output = entries
+                        .into_iter()
+                        .map(|e| {
+                            let type_marker = if e.is_dir { "/" } else { "" };
+                            let size = e.size.map(|s| format!(" ({}B)", s)).unwrap_or_default();
+                            format!("{}{}{}", e.name, type_marker, size)
+                        })
+                        .collect::<Vec<_>>()
+                        .join("\n");
+                    Ok(output)
+                }
+                PermissionDecision::Ask => {
+                    Err(eyre!("Permission required: LS operation needs approval"))
+                }
+                PermissionDecision::Deny => {
+                    Err(eyre!("Permission denied: LS operation is blocked"))
+                }
+            }
+        }
+        "web_search" => {
+            let query = arguments["query"]
+                .as_str()
+                .ok_or_else(|| eyre!("Missing 'query' argument"))?;
+            let max_results = arguments.get("max_results")
+                .and_then(|v| v.as_u64())
+                .unwrap_or(10) as usize;
+
+            // Check permission
+            match perms.check(PermTool::WebSearch, None) {
+                PermissionDecision::Allow => {
+                    // Use DuckDuckGo search provider
+                    let provider = Box::new(tools_web::DuckDuckGoSearchProvider::with_max_results(max_results));
+                    let client = tools_web::WebSearchClient::new(provider);
+                    let results = client.search(query).await?;
+                    let formatted = tools_web::format_search_results(&results);
+                    Ok(formatted)
+                }
+                PermissionDecision::Ask => {
+                    Err(eyre!("Permission required: WebSearch operation needs approval"))
+                }
+                PermissionDecision::Deny => {
+                    Err(eyre!("Permission denied: WebSearch operation is blocked"))
+                }
+            }
+        }
+        "todo_write" => {
+            let todo_list = ctx.todo_list.as_ref()
+                .ok_or_else(|| eyre!("TodoList not available in this context"))?;
+
+            // Check permission
+            match perms.check(PermTool::TodoWrite, None) {
+                PermissionDecision::Allow => {
+                    let todos = tools_todo::parse_todos(arguments)?;
+                    todo_list.write(todos);
+                    Ok(todo_list.format_display())
+                }
+                PermissionDecision::Ask => {
+                    Err(eyre!("Permission required: TodoWrite operation needs approval"))
+                }
+                PermissionDecision::Deny => {
+                    Err(eyre!("Permission denied: TodoWrite operation is blocked"))
+                }
+            }
+        }
+        "ask_user" => {
+            let sender = ctx.ask_sender.as_ref()
+                .ok_or_else(|| eyre!("AskUser not available in this context"))?;
+
+            // Check permission
+            match perms.check(PermTool::AskUserQuestion, None) {
+                PermissionDecision::Allow => {
+                    let questions = tools_ask::parse_questions(arguments)?;
+                    let answers = tools_ask::ask_user(sender, questions).await?;
+                    Ok(serde_json::to_string_pretty(&answers)?)
+                }
+                PermissionDecision::Ask => {
+                    Err(eyre!("Permission required: AskUser operation needs approval"))
+                }
+                PermissionDecision::Deny => {
+                    Err(eyre!("Permission denied: AskUser operation is blocked"))
+                }
+            }
+        }
+        "bash_output" => {
+            let manager = ctx.shell_manager.as_ref()
+                .ok_or_else(|| eyre!("ShellManager not available in this context"))?;
+
+            let shell_id = arguments["shell_id"]
+                .as_str()
+                .ok_or_else(|| eyre!("Missing 'shell_id' argument"))?;
+
+            // Check permission
+            match perms.check(PermTool::BashOutput, Some(shell_id)) {
+                PermissionDecision::Allow => {
+                    tools_bash::bash_output(manager, shell_id)
+                }
+                PermissionDecision::Ask => {
+                    Err(eyre!("Permission required: BashOutput operation needs approval"))
+                }
+                PermissionDecision::Deny => {
+                    Err(eyre!("Permission denied: BashOutput operation is blocked"))
+                }
+            }
+        }
+        "kill_shell" => {
+            let manager = ctx.shell_manager.as_ref()
+                .ok_or_else(|| eyre!("ShellManager not available in this context"))?;
+
+            let shell_id = arguments["shell_id"]
+                .as_str()
+                .ok_or_else(|| eyre!("Missing 'shell_id' argument"))?;
+
+            // Check permission
+            match perms.check(PermTool::KillShell, Some(shell_id)) {
+                PermissionDecision::Allow => {
+                    tools_bash::kill_shell(manager, shell_id)
+                }
+                PermissionDecision::Ask => {
+                    Err(eyre!("Permission required: KillShell operation needs approval"))
+                }
+                PermissionDecision::Deny => {
+                    Err(eyre!("Permission denied: KillShell operation is blocked"))
+                }
+            }
+        }
         _ => Err(eyre!("Unknown tool: {}", tool_name)),
     }
 }
 
 /// Run the agent loop with tool calling
-pub async fn run_agent_loop(
+pub async fn run_agent_loop<P: LlmProvider>(
-    client: &OllamaClient,
+    provider: &P,
     user_prompt: &str,
-    opts: &OllamaOptions,
+    options: &ChatOptions,
     perms: &PermissionManager,
+    ctx: &ToolContext,
 ) -> Result<String> {
     let tools = get_tool_definitions();
-    let mut messages = vec![ChatMessage {
+    let mut messages = vec![ChatMessage::user(user_prompt)];
-        role: "user".to_string(),
-        content: Some(user_prompt.to_string()),
-        tool_calls: None,
-    }];
 
     let max_iterations = 10; // Prevent infinite loops
     let mut iteration = 0;
@@ -308,18 +731,57 @@ pub async fn run_agent_loop(
         }
 
         // Call LLM with messages and tools
-        let mut stream = client.chat_stream(&messages, opts, Some(&tools)).await?;
+        let mut stream = provider
+            .chat_stream(&messages, options, Some(&tools))
+            .await
+            .map_err(|e| eyre!("LLM provider error: {}", e))?;
+
         let mut response_content = String::new();
-        let mut tool_calls = None;
+        let mut accumulated_tool_calls: Vec<llm_core::ToolCall> = Vec::new();
 
         // Collect the streamed response
-        while let Some(chunk) = stream.try_next().await? {
+        while let Some(chunk) = stream.next().await {
-            if let Some(msg) = chunk.message {
+            let chunk = chunk.map_err(|e| eyre!("Stream error: {}", e))?;
-                if let Some(content) = msg.content {
+
-                    response_content.push_str(&content);
+            if let Some(content) = chunk.content {
-                }
+                response_content.push_str(&content);
-                if let Some(calls) = msg.tool_calls {
+            }
-                    tool_calls = Some(calls);
+
+            // Accumulate tool calls from deltas
+            if let Some(deltas) = chunk.tool_calls {
+                for delta in deltas {
+                    // Ensure the accumulated_tool_calls vec is large enough
+                    while accumulated_tool_calls.len() <= delta.index {
+                        accumulated_tool_calls.push(llm_core::ToolCall {
+                            id: String::new(),
+                            call_type: "function".to_string(),
+                            function: llm_core::FunctionCall {
+                                name: String::new(),
+                                arguments: Value::Null,
+                            },
+                        });
+                    }
+
+                    let tool_call = &mut accumulated_tool_calls[delta.index];
+
+                    if let Some(id) = delta.id {
+                        tool_call.id = id;
+                    }
+                    if let Some(name) = delta.function_name {
+                        tool_call.function.name = name;
+                    }
+                    if let Some(args_delta) = delta.arguments_delta {
+                        // Accumulate the arguments string
+                        let current_args = if tool_call.function.arguments.is_null() {
+                            String::new()
+                        } else {
+                            tool_call.function.arguments.to_string()
+                        };
+                        let new_args = current_args + &args_delta;
+                        // Try to parse as JSON, but keep as string if incomplete
+                        tool_call.function.arguments = serde_json::from_str(&new_args)
+                            .unwrap_or_else(|_| Value::String(new_args));
+                    }
                 }
             }
         }
@@ -327,44 +789,44 @@ pub async fn run_agent_loop(
         // Drop the stream to release the borrow on messages
         drop(stream);
 
+        // Filter out incomplete tool calls and check if we have valid ones
+        let valid_tool_calls: Vec<_> = accumulated_tool_calls
+            .into_iter()
+            .filter(|tc| !tc.id.is_empty() && !tc.function.name.is_empty())
+            .collect();
+
         // Check if LLM wants to call tools
-        if let Some(calls) = tool_calls {
+        if !valid_tool_calls.is_empty() {
             // Add assistant message with tool calls
             messages.push(ChatMessage {
-                role: "assistant".to_string(),
+                role: llm_core::Role::Assistant,
                 content: if response_content.is_empty() {
                     None
                 } else {
                     Some(response_content.clone())
                 },
-                tool_calls: Some(calls.clone()),
+                tool_calls: Some(valid_tool_calls.clone()),
+                tool_call_id: None,
+                name: None,
             });
 
             // Execute each tool call
-            for call in calls {
+            for call in valid_tool_calls {
                 let tool_name = &call.function.name;
                 let arguments = &call.function.arguments;
 
-                println!("\n🔧 Tool call: {} with args: {}", tool_name, arguments);
+                tracing::debug!(tool = %tool_name, args = %arguments, "executing tool call");
 
-                match execute_tool(tool_name, arguments, perms).await {
+                match execute_tool(tool_name, arguments, perms, ctx).await {
                     Ok(result) => {
-                        println!("✅ Tool result: {}", result);
+                        tracing::debug!(tool = %tool_name, result = %result, "tool call succeeded");
                         // Add tool result message
-                        messages.push(ChatMessage {
+                        messages.push(ChatMessage::tool_result(&call.id, result));
-                            role: "tool".to_string(),
-                            content: Some(result),
-                            tool_calls: None,
-                        });
                     }
                     Err(e) => {
-                        println!("❌ Tool error: {}", e);
+                        tracing::warn!(tool = %tool_name, error = %e, "tool call failed");
                         // Add error message as tool result
-                        messages.push(ChatMessage {
+                        messages.push(ChatMessage::tool_result(&call.id, format!("Error: {}", e)));
-                            role: "tool".to_string(),
-                            content: Some(format!("Error: {}", e)),
-                            tool_calls: None,
-                        });
                     }
                 }
             }
@@ -377,3 +839,144 @@ pub async fn run_agent_loop(
         return Ok(response_content);
     }
 }
+
+/// Run agent loop with event streaming
+pub async fn run_agent_loop_streaming<P: LlmProvider>(
+    provider: &P,
+    user_prompt: &str,
+    options: &ChatOptions,
+    perms: &PermissionManager,
+    ctx: &ToolContext,
+    events: AgentEventSender,
+) -> Result<String> {
+    let tools = get_tool_definitions();
+    let mut messages = vec![ChatMessage::user(user_prompt)];
+
+    let max_iterations = 10;
+    let mut iteration = 0;
+
+    loop {
+        iteration += 1;
+        if iteration > max_iterations {
+            let _ = events.send(AgentEvent::Error("Max iterations reached".into())).await;
+            return Err(eyre!("Max iterations reached"));
+        }
+
+        // Stream LLM response
+        let mut stream = provider
+            .chat_stream(&messages, options, Some(&tools))
+            .await
+            .map_err(|e| {
+                let err_msg = format!("LLM provider error: {}", e);
+                let _ = events.try_send(AgentEvent::Error(err_msg.clone()));
+                eyre!(err_msg)
+            })?;
+
+        let mut response_content = String::new();
+        let mut tool_calls_builder = ToolCallsBuilder::new();
+
+        while let Some(chunk) = stream.next().await {
+            let chunk = chunk.map_err(|e| {
+                let err_msg = format!("Stream error: {}", e);
+                let _ = events.try_send(AgentEvent::Error(err_msg.clone()));
+                eyre!(err_msg)
+            })?;
+
+            // Send text deltas
+            if let Some(text) = &chunk.content {
+                let _ = events.send(AgentEvent::TextDelta(text.clone())).await;
+                response_content.push_str(text);
+            }
+
+            // Accumulate tool calls
+            if let Some(deltas) = &chunk.tool_calls {
+                tool_calls_builder.add_deltas(deltas);
+            }
+        }
+
+        // Drop stream to release borrow
+        drop(stream);
+
+        let tool_calls = tool_calls_builder.build();
+
+        if tool_calls.is_empty() {
+            let _ = events
+                .send(AgentEvent::Done {
+                    final_response: response_content.clone(),
+                })
+                .await;
+            return Ok(response_content);
+        }
+
+        // Add assistant message
+        messages.push(ChatMessage {
+            role: llm_core::Role::Assistant,
+            content: if response_content.is_empty() {
+                None
+            } else {
+                Some(response_content.clone())
+            },
+            tool_calls: Some(tool_calls.clone()),
+            tool_call_id: None,
+            name: None,
+        });
+
+        // Execute tools with events
+        for call in &tool_calls {
+            let tool_id = call.id.clone();
+            let tool_name = call.function.name.clone();
+
+            let _ = events
+                .send(AgentEvent::ToolStart {
+                    tool_name: tool_name.clone(),
+                    tool_id: tool_id.clone(),
+                })
+                .await;
+
+            tracing::debug!(tool = %tool_name, args = %call.function.arguments, "executing tool call");
+
+            let result = execute_tool(&tool_name, &call.function.arguments, perms, ctx).await;
+
+            match &result {
+                Ok(output) => {
+                    tracing::debug!(tool = %tool_name, result = %output, "tool call succeeded");
+                    let _ = events
+                        .send(AgentEvent::ToolOutput {
+                            tool_id: tool_id.clone(),
+                            content: output.clone(),
+                            is_error: false,
+                        })
+                        .await;
+                    let _ = events
+                        .send(AgentEvent::ToolEnd {
+                            tool_id: tool_id.clone(),
+                            success: true,
+                        })
+                        .await;
+                    messages.push(ChatMessage::tool_result(&tool_id, output));
+                }
+                Err(e) => {
+                    tracing::warn!(tool = %tool_name, error = %e, "tool call failed");
+                    let error_msg = e.to_string();
+                    let _ = events
+                        .send(AgentEvent::ToolOutput {
+                            tool_id: tool_id.clone(),
+                            content: error_msg.clone(),
+                            is_error: true,
+                        })
+                        .await;
+                    let _ = events
+                        .send(AgentEvent::ToolEnd {
+                            tool_id: tool_id.clone(),
+                            success: false,
+                        })
+                        .await;
+                    messages.push(ChatMessage::tool_result(
+                        &tool_id,
+                        format!("Error: {}", error_msg),
+                    ));
+                }
+            }
+        }
+    }
+}

crates/core/agent/src/system_prompt.rs

@@ -0,0 +1,266 @@
+//! System Prompt Management
+//!
+//! Composes system prompts from multiple sources for agent sessions.
+
+use std::path::Path;
+
+/// Builder for composing system prompts
+#[derive(Debug, Clone, Default)]
+pub struct SystemPromptBuilder {
+    sections: Vec<PromptSection>,
+}
+
+#[derive(Debug, Clone)]
+struct PromptSection {
+    name: String,
+    content: String,
+    priority: i32,  // Lower = earlier in prompt
+}
+
+impl SystemPromptBuilder {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Add the base agent prompt
+    pub fn with_base_prompt(mut self, content: impl Into<String>) -> Self {
+        self.sections.push(PromptSection {
+            name: "base".to_string(),
+            content: content.into(),
+            priority: 0,
+        });
+        self
+    }
+
+    /// Add tool usage instructions
+    pub fn with_tool_instructions(mut self, content: impl Into<String>) -> Self {
+        self.sections.push(PromptSection {
+            name: "tools".to_string(),
+            content: content.into(),
+            priority: 10,
+        });
+        self
+    }
+
+    /// Load and add project instructions from CLAUDE.md or .owlen.md
+    pub fn with_project_instructions(mut self, project_root: &Path) -> Self {
+        // Try CLAUDE.md first (Claude Code compatibility)
+        let claude_md = project_root.join("CLAUDE.md");
+        if claude_md.exists() {
+            if let Ok(content) = std::fs::read_to_string(&claude_md) {
+                self.sections.push(PromptSection {
+                    name: "project".to_string(),
+                    content: format!("# Project Instructions\n\n{}", content),
+                    priority: 20,
+                });
+                return self;
+            }
+        }
+
+        // Fallback to .owlen.md
+        let owlen_md = project_root.join(".owlen.md");
+        if owlen_md.exists() {
+            if let Ok(content) = std::fs::read_to_string(&owlen_md) {
+                self.sections.push(PromptSection {
+                    name: "project".to_string(),
+                    content: format!("# Project Instructions\n\n{}", content),
+                    priority: 20,
+                });
+            }
+        }
+
+        self
+    }
+
+    /// Add skill content
+    pub fn with_skill(mut self, skill_name: &str, content: impl Into<String>) -> Self {
+        self.sections.push(PromptSection {
+            name: format!("skill:{}", skill_name),
+            content: content.into(),
+            priority: 30,
+        });
+        self
+    }
+
+    /// Add hook-injected content (from SessionStart hooks)
+    pub fn with_hook_injection(mut self, content: impl Into<String>) -> Self {
+        self.sections.push(PromptSection {
+            name: "hook".to_string(),
+            content: content.into(),
+            priority: 40,
+        });
+        self
+    }
+
+    /// Add custom section
+    pub fn with_section(mut self, name: impl Into<String>, content: impl Into<String>, priority: i32) -> Self {
+        self.sections.push(PromptSection {
+            name: name.into(),
+            content: content.into(),
+            priority,
+        });
+        self
+    }
+
+    /// Build the final system prompt
+    pub fn build(mut self) -> String {
+        // Sort by priority
+        self.sections.sort_by_key(|s| s.priority);
+
+        // Join sections with separators
+        self.sections
+            .iter()
+            .map(|s| s.content.as_str())
+            .collect::<Vec<_>>()
+            .join("\n\n---\n\n")
+    }
+
+    /// Check if any content has been added
+    pub fn is_empty(&self) -> bool {
+        self.sections.is_empty()
+    }
+}
+
+/// Default base prompt for Owlen agent
+pub fn default_base_prompt() -> &'static str {
+    r#"You are Owlen, an AI assistant that helps with software engineering tasks.
+
+You have access to tools for reading files, writing code, running commands, and searching the web.
+
+## Guidelines
+
+1. Be direct and concise in your responses
+2. Use tools to gather information before making changes
+3. Explain your reasoning when making decisions
+4. Ask for clarification when requirements are unclear
+5. Prefer editing existing files over creating new ones
+
+## Tool Usage
+
+- Use `read` to examine file contents before editing
+- Use `glob` and `grep` to find relevant files
+- Use `edit` for precise changes, `write` for new files
+- Use `bash` for running tests and commands
+- Use `web_search` for current information"#
+}
+
+/// Generate tool instructions based on available tools
+pub fn generate_tool_instructions(tool_names: &[&str]) -> String {
+    let mut instructions = String::from("## Available Tools\n\n");
+
+    for name in tool_names {
+        let desc = match *name {
+            "read" => "Read file contents",
+            "write" => "Create or overwrite a file",
+            "edit" => "Edit a file by replacing text",
+            "multi_edit" => "Apply multiple edits atomically",
+            "glob" => "Find files by pattern",
+            "grep" => "Search file contents",
+            "ls" => "List directory contents",
+            "bash" => "Execute shell commands",
+            "web_search" => "Search the web",
+            "web_fetch" => "Fetch a URL",
+            "todo_write" => "Update task list",
+            "ask_user" => "Ask user a question",
+            _ => continue,
+        };
+        instructions.push_str(&format!("- `{}`: {}\n", name, desc));
+    }
+
+    instructions
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_builder() {
+        let prompt = SystemPromptBuilder::new()
+            .with_base_prompt("You are helpful")
+            .with_tool_instructions("Use tools wisely")
+            .build();
+
+        assert!(prompt.contains("You are helpful"));
+        assert!(prompt.contains("Use tools wisely"));
+    }
+
+    #[test]
+    fn test_priority_ordering() {
+        let prompt = SystemPromptBuilder::new()
+            .with_section("last", "Third", 100)
+            .with_section("first", "First", 0)
+            .with_section("middle", "Second", 50)
+            .build();
+
+        let first_pos = prompt.find("First").unwrap();
+        let second_pos = prompt.find("Second").unwrap();
+        let third_pos = prompt.find("Third").unwrap();
+
+        assert!(first_pos < second_pos);
+        assert!(second_pos < third_pos);
+    }
+
+    #[test]
+    fn test_default_base_prompt() {
+        let prompt = default_base_prompt();
+        assert!(prompt.contains("Owlen"));
+        assert!(prompt.contains("Guidelines"));
+        assert!(prompt.contains("Tool Usage"));
+    }
+
+    #[test]
+    fn test_generate_tool_instructions() {
+        let tools = vec!["read", "write", "edit", "bash"];
+        let instructions = generate_tool_instructions(&tools);
+
+        assert!(instructions.contains("Available Tools"));
+        assert!(instructions.contains("read"));
+        assert!(instructions.contains("write"));
+        assert!(instructions.contains("edit"));
+        assert!(instructions.contains("bash"));
+    }
+
+    #[test]
+    fn test_builder_empty() {
+        let builder = SystemPromptBuilder::new();
+        assert!(builder.is_empty());
+
+        let builder = builder.with_base_prompt("test");
+        assert!(!builder.is_empty());
+    }
+
+    #[test]
+    fn test_skill_section() {
+        let prompt = SystemPromptBuilder::new()
+            .with_base_prompt("Base")
+            .with_skill("rust", "Rust expertise")
+            .build();
+
+        assert!(prompt.contains("Base"));
+        assert!(prompt.contains("Rust expertise"));
+    }
+
+    #[test]
+    fn test_hook_injection() {
+        let prompt = SystemPromptBuilder::new()
+            .with_base_prompt("Base")
+            .with_hook_injection("Additional context from hook")
+            .build();
+
+        assert!(prompt.contains("Base"));
+        assert!(prompt.contains("Additional context from hook"));
+    }
+
+    #[test]
+    fn test_separator_between_sections() {
+        let prompt = SystemPromptBuilder::new()
+            .with_section("first", "First section", 0)
+            .with_section("second", "Second section", 10)
+            .build();
+
+        assert!(prompt.contains("---"));
+        assert!(prompt.contains("First section"));
+        assert!(prompt.contains("Second section"));
+    }
+}

crates/core/agent/tests/streaming.rs

@@ -0,0 +1,276 @@
+use agent_core::{create_event_channel, run_agent_loop_streaming, AgentEvent, ToolContext};
+use async_trait::async_trait;
+use futures_util::stream;
+use llm_core::{
+    ChatMessage, ChatOptions, LlmError, StreamChunk, LlmProvider, Tool, ToolCallDelta,
+};
+use permissions::{Mode, PermissionManager};
+use std::pin::Pin;
+
+/// Mock LLM provider for testing streaming
+struct MockStreamingProvider {
+    responses: Vec<MockResponse>,
+}
+
+enum MockResponse {
+    /// Text-only response (no tool calls)
+    Text(Vec<String>), // Chunks of text
+    /// Tool call response
+    ToolCall {
+        text_chunks: Vec<String>,
+        tool_id: String,
+        tool_name: String,
+        tool_args: String,
+    },
+}
+
+#[async_trait]
+impl LlmProvider for MockStreamingProvider {
+    fn name(&self) -> &str {
+        "mock"
+    }
+
+    fn model(&self) -> &str {
+        "mock-model"
+    }
+
+    async fn chat_stream(
+        &self,
+        messages: &[ChatMessage],
+        _options: &ChatOptions,
+        _tools: Option<&[Tool]>,
+    ) -> Result<Pin<Box<dyn futures_util::Stream<Item = Result<StreamChunk, LlmError>> + Send>>, LlmError> {
+        // Determine which response to use based on message count
+        let response_idx = (messages.len() / 2).min(self.responses.len() - 1);
+        let response = &self.responses[response_idx];
+
+        let chunks: Vec<Result<StreamChunk, LlmError>> = match response {
+            MockResponse::Text(text_chunks) => text_chunks
+                .iter()
+                .map(|text| {
+                    Ok(StreamChunk {
+                        content: Some(text.clone()),
+                        tool_calls: None,
+                        done: false,
+                        usage: None,
+                    })
+                })
+                .collect(),
+            MockResponse::ToolCall {
+                text_chunks,
+                tool_id,
+                tool_name,
+                tool_args,
+            } => {
+                let mut result = vec![];
+
+                // First emit text chunks
+                for text in text_chunks {
+                    result.push(Ok(StreamChunk {
+                        content: Some(text.clone()),
+                        tool_calls: None,
+                        done: false,
+                        usage: None,
+                    }));
+                }
+
+                // Then emit tool call in chunks
+                result.push(Ok(StreamChunk {
+                    content: None,
+                    tool_calls: Some(vec![ToolCallDelta {
+                        index: 0,
+                        id: Some(tool_id.clone()),
+                        function_name: Some(tool_name.clone()),
+                        arguments_delta: None,
+                    }]),
+                    done: false,
+                    usage: None,
+                }));
+
+                // Emit args in chunks
+                for chunk in tool_args.chars().collect::<Vec<_>>().chunks(5) {
+                    result.push(Ok(StreamChunk {
+                        content: None,
+                        tool_calls: Some(vec![ToolCallDelta {
+                            index: 0,
+                            id: None,
+                            function_name: None,
+                            arguments_delta: Some(chunk.iter().collect()),
+                        }]),
+                        done: false,
+                        usage: None,
+                    }));
+                }
+
+                result
+            }
+        };
+
+        Ok(Box::pin(stream::iter(chunks)))
+    }
+}
+
+#[tokio::test]
+async fn test_streaming_text_only() {
+    let provider = MockStreamingProvider {
+        responses: vec![MockResponse::Text(vec![
+            "Hello".to_string(),
+            " ".to_string(),
+            "world".to_string(),
+            "!".to_string(),
+        ])],
+    };
+
+    let perms = PermissionManager::new(Mode::Plan);
+    let ctx = ToolContext::default();
+    let (tx, mut rx) = create_event_channel();
+
+    // Spawn the agent loop
+    let handle = tokio::spawn(async move {
+        run_agent_loop_streaming(
+            &provider,
+            "Say hello",
+            &ChatOptions::default(),
+            &perms,
+            &ctx,
+            tx,
+        )
+        .await
+    });
+
+    // Collect events
+    let mut text_deltas = vec![];
+    let mut done_response = None;
+
+    while let Some(event) = rx.recv().await {
+        match event {
+            AgentEvent::TextDelta(text) => {
+                text_deltas.push(text);
+            }
+            AgentEvent::Done { final_response } => {
+                done_response = Some(final_response);
+                break;
+            }
+            AgentEvent::Error(e) => {
+                panic!("Unexpected error: {}", e);
+            }
+            _ => {}
+        }
+    }
+
+    // Wait for agent loop to complete
+    let result = handle.await.unwrap();
+    assert!(result.is_ok());
+
+    // Verify events
+    assert_eq!(text_deltas, vec!["Hello", " ", "world", "!"]);
+    assert_eq!(done_response, Some("Hello world!".to_string()));
+    assert_eq!(result.unwrap(), "Hello world!");
+}
+
+#[tokio::test]
+async fn test_streaming_with_tool_call() {
+    let provider = MockStreamingProvider {
+        responses: vec![
+            MockResponse::ToolCall {
+                text_chunks: vec!["Let me ".to_string(), "check...".to_string()],
+                tool_id: "call_123".to_string(),
+                tool_name: "glob".to_string(),
+                tool_args: r#"{"pattern":"*.rs"}"#.to_string(),
+            },
+            MockResponse::Text(vec!["Found ".to_string(), "the files!".to_string()]),
+        ],
+    };
+
+    let perms = PermissionManager::new(Mode::Plan);
+    let ctx = ToolContext::default();
+    let (tx, mut rx) = create_event_channel();
+
+    // Spawn the agent loop
+    let handle = tokio::spawn(async move {
+        run_agent_loop_streaming(
+            &provider,
+            "Find Rust files",
+            &ChatOptions::default(),
+            &perms,
+            &ctx,
+            tx,
+        )
+        .await
+    });
+
+    // Collect events
+    let mut text_deltas = vec![];
+    let mut tool_starts = vec![];
+    let mut tool_outputs = vec![];
+    let mut tool_ends = vec![];
+
+    while let Some(event) = rx.recv().await {
+        match event {
+            AgentEvent::TextDelta(text) => {
+                text_deltas.push(text);
+            }
+            AgentEvent::ToolStart {
+                tool_name,
+                tool_id,
+            } => {
+                tool_starts.push((tool_name, tool_id));
+            }
+            AgentEvent::ToolOutput {
+                tool_id,
+                content,
+                is_error,
+            } => {
+                tool_outputs.push((tool_id, content, is_error));
+            }
+            AgentEvent::ToolEnd { tool_id, success } => {
+                tool_ends.push((tool_id, success));
+            }
+            AgentEvent::Done { .. } => {
+                break;
+            }
+            AgentEvent::Error(e) => {
+                panic!("Unexpected error: {}", e);
+            }
+        }
+    }
+
+    // Wait for agent loop to complete
+    let result = handle.await.unwrap();
+    assert!(result.is_ok());
+
+    // Verify we got text deltas from both responses
+    assert!(text_deltas.contains(&"Let me ".to_string()));
+    assert!(text_deltas.contains(&"check...".to_string()));
+    assert!(text_deltas.contains(&"Found ".to_string()));
+    assert!(text_deltas.contains(&"the files!".to_string()));
+
+    // Verify tool events
+    assert_eq!(tool_starts.len(), 1);
+    assert_eq!(tool_starts[0].0, "glob");
+    assert_eq!(tool_starts[0].1, "call_123");
+
+    assert_eq!(tool_outputs.len(), 1);
+    assert_eq!(tool_outputs[0].0, "call_123");
+    assert!(!tool_outputs[0].2); // not an error
+
+    assert_eq!(tool_ends.len(), 1);
+    assert_eq!(tool_ends[0].0, "call_123");
+    assert!(tool_ends[0].1); // success
+}
+
+#[tokio::test]
+async fn test_channel_creation() {
+    let (tx, mut rx) = create_event_channel();
+
+    // Test that channel works
+    tx.send(AgentEvent::TextDelta("test".to_string()))
+        .await
+        .unwrap();
+
+    let event = rx.recv().await.unwrap();
+    match event {
+        AgentEvent::TextDelta(text) => assert_eq!(text, "test"),
+        _ => panic!("Wrong event type"),
+    }
+}

crates/core/agent/tests/tool_context.rs

@@ -0,0 +1,114 @@
+// Test that ToolContext properly wires up the placeholder tools
+use agent_core::{ToolContext, execute_tool};
+use permissions::{Mode, PermissionManager};
+use tools_todo::{TodoList, TodoStatus};
+use tools_bash::ShellManager;
+use serde_json::json;
+
+#[tokio::test]
+async fn test_todo_write_with_context() {
+    let todo_list = TodoList::new();
+    let ctx = ToolContext::new().with_todo_list(todo_list.clone());
+    let perms = PermissionManager::new(Mode::Code); // Allow all tools
+    
+    let arguments = json!({
+        "todos": [
+            {
+                "content": "First task",
+                "status": "pending",
+                "active_form": "Working on first task"
+            },
+            {
+                "content": "Second task",
+                "status": "in_progress",
+                "active_form": "Working on second task"
+            }
+        ]
+    });
+    
+    let result = execute_tool("todo_write", &arguments, &perms, &ctx).await;
+    assert!(result.is_ok(), "TodoWrite should succeed: {:?}", result);
+    
+    // Verify the todos were written
+    let todos = todo_list.read();
+    assert_eq!(todos.len(), 2);
+    assert_eq!(todos[0].content, "First task");
+    assert_eq!(todos[1].status, TodoStatus::InProgress);
+}
+
+#[tokio::test]
+async fn test_todo_write_without_context() {
+    let ctx = ToolContext::new(); // No todo_list
+    let perms = PermissionManager::new(Mode::Code);
+    
+    let arguments = json!({
+        "todos": []
+    });
+    
+    let result = execute_tool("todo_write", &arguments, &perms, &ctx).await;
+    assert!(result.is_err(), "TodoWrite should fail without TodoList");
+    assert!(result.unwrap_err().to_string().contains("not available"));
+}
+
+#[tokio::test]
+async fn test_bash_output_with_context() {
+    let manager = ShellManager::new();
+    let ctx = ToolContext::new().with_shell_manager(manager.clone());
+    let perms = PermissionManager::new(Mode::Code);
+    
+    // Start a shell and run a command
+    let shell_id = manager.start_shell().await.unwrap();
+    let _ = manager.execute(&shell_id, "echo test", None).await.unwrap();
+    
+    let arguments = json!({
+        "shell_id": shell_id
+    });
+    
+    let result = execute_tool("bash_output", &arguments, &perms, &ctx).await;
+    assert!(result.is_ok(), "BashOutput should succeed: {:?}", result);
+}
+
+#[tokio::test]
+async fn test_bash_output_without_context() {
+    let ctx = ToolContext::new(); // No shell_manager
+    let perms = PermissionManager::new(Mode::Code);
+    
+    let arguments = json!({
+        "shell_id": "fake-id"
+    });
+    
+    let result = execute_tool("bash_output", &arguments, &perms, &ctx).await;
+    assert!(result.is_err(), "BashOutput should fail without ShellManager");
+    assert!(result.unwrap_err().to_string().contains("not available"));
+}
+
+#[tokio::test]
+async fn test_kill_shell_with_context() {
+    let manager = ShellManager::new();
+    let ctx = ToolContext::new().with_shell_manager(manager.clone());
+    let perms = PermissionManager::new(Mode::Code);
+    
+    // Start a shell
+    let shell_id = manager.start_shell().await.unwrap();
+    
+    let arguments = json!({
+        "shell_id": shell_id
+    });
+    
+    let result = execute_tool("kill_shell", &arguments, &perms, &ctx).await;
+    assert!(result.is_ok(), "KillShell should succeed: {:?}", result);
+}
+
+#[tokio::test]
+async fn test_ask_user_without_context() {
+    let ctx = ToolContext::new(); // No ask_sender
+    let perms = PermissionManager::new(Mode::Code);
+    
+    let arguments = json!({
+        "questions": []
+    });
+    
+    let result = execute_tool("ask_user", &arguments, &perms, &ctx).await;
+    assert!(result.is_err(), "AskUser should fail without AskSender");
+    assert!(result.unwrap_err().to_string().contains("not available"));
+}

crates/llm/anthropic/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "llm-anthropic"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+description = "Anthropic Claude API client for Owlen"
+
+[dependencies]
+llm-core = { path = "../core" }
+async-trait = "0.1"
+futures = "0.3"
+reqwest = { version = "0.12", features = ["json", "stream"] }
+reqwest-eventsource = "0.6"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+tokio = { version = "1", features = ["sync", "time"] }
+tracing = "0.1"
+uuid = { version = "1.0", features = ["v4"] }

crates/llm/anthropic/src/auth.rs

@@ -0,0 +1,285 @@
+//! Anthropic OAuth Authentication
+//!
+//! Implements device code flow for authenticating with Anthropic without API keys.
+
+use llm_core::{AuthMethod, DeviceAuthResult, DeviceCodeResponse, LlmError, OAuthProvider};
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+
+/// OAuth client for Anthropic device flow
+pub struct AnthropicAuth {
+    http: Client,
+    client_id: String,
+}
+
+// Anthropic OAuth endpoints (these would be the real endpoints)
+const AUTH_BASE_URL: &str = "https://console.anthropic.com";
+const DEVICE_CODE_ENDPOINT: &str = "/oauth/device/code";
+const TOKEN_ENDPOINT: &str = "/oauth/token";
+
+// Default client ID for Owlen CLI
+const DEFAULT_CLIENT_ID: &str = "owlen-cli";
+
+impl AnthropicAuth {
+    /// Create a new OAuth client with the default CLI client ID
+    pub fn new() -> Self {
+        Self {
+            http: Client::new(),
+            client_id: DEFAULT_CLIENT_ID.to_string(),
+        }
+    }
+
+    /// Create with a custom client ID
+    pub fn with_client_id(client_id: impl Into<String>) -> Self {
+        Self {
+            http: Client::new(),
+            client_id: client_id.into(),
+        }
+    }
+}
+
+impl Default for AnthropicAuth {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[derive(Debug, Serialize)]
+struct DeviceCodeRequest<'a> {
+    client_id: &'a str,
+    scope: &'a str,
+}
+
+#[derive(Debug, Deserialize)]
+struct DeviceCodeApiResponse {
+    device_code: String,
+    user_code: String,
+    verification_uri: String,
+    verification_uri_complete: Option<String>,
+    expires_in: u64,
+    interval: u64,
+}
+
+#[derive(Debug, Serialize)]
+struct TokenRequest<'a> {
+    client_id: &'a str,
+    device_code: &'a str,
+    grant_type: &'a str,
+}
+
+#[derive(Debug, Deserialize)]
+struct TokenApiResponse {
+    access_token: String,
+    #[allow(dead_code)]
+    token_type: String,
+    expires_in: Option<u64>,
+    refresh_token: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct TokenErrorResponse {
+    error: String,
+    error_description: Option<String>,
+}
+
+#[async_trait::async_trait]
+impl OAuthProvider for AnthropicAuth {
+    async fn start_device_auth(&self) -> Result<DeviceCodeResponse, LlmError> {
+        let url = format!("{}{}", AUTH_BASE_URL, DEVICE_CODE_ENDPOINT);
+
+        let request = DeviceCodeRequest {
+            client_id: &self.client_id,
+            scope: "api:read api:write", // Request API access
+        };
+
+        let response = self
+            .http
+            .post(&url)
+            .json(&request)
+            .send()
+            .await
+            .map_err(|e| LlmError::Http(e.to_string()))?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let text = response
+                .text()
+                .await
+                .unwrap_or_else(|_| "Unknown error".to_string());
+            return Err(LlmError::Auth(format!(
+                "Device code request failed ({}): {}",
+                status, text
+            )));
+        }
+
+        let api_response: DeviceCodeApiResponse = response
+            .json()
+            .await
+            .map_err(|e| LlmError::Json(e.to_string()))?;
+
+        Ok(DeviceCodeResponse {
+            device_code: api_response.device_code,
+            user_code: api_response.user_code,
+            verification_uri: api_response.verification_uri,
+            verification_uri_complete: api_response.verification_uri_complete,
+            expires_in: api_response.expires_in,
+            interval: api_response.interval,
+        })
+    }
+
+    async fn poll_device_auth(&self, device_code: &str) -> Result<DeviceAuthResult, LlmError> {
+        let url = format!("{}{}", AUTH_BASE_URL, TOKEN_ENDPOINT);
+
+        let request = TokenRequest {
+            client_id: &self.client_id,
+            device_code,
+            grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        };
+
+        let response = self
+            .http
+            .post(&url)
+            .json(&request)
+            .send()
+            .await
+            .map_err(|e| LlmError::Http(e.to_string()))?;
+
+        if response.status().is_success() {
+            let token_response: TokenApiResponse = response
+                .json()
+                .await
+                .map_err(|e| LlmError::Json(e.to_string()))?;
+
+            return Ok(DeviceAuthResult::Success {
+                access_token: token_response.access_token,
+                refresh_token: token_response.refresh_token,
+                expires_in: token_response.expires_in,
+            });
+        }
+
+        // Parse error response
+        let error_response: TokenErrorResponse = response
+            .json()
+            .await
+            .map_err(|e| LlmError::Json(e.to_string()))?;
+
+        match error_response.error.as_str() {
+            "authorization_pending" => Ok(DeviceAuthResult::Pending),
+            "slow_down" => Ok(DeviceAuthResult::Pending), // Treat as pending, caller should slow down
+            "access_denied" => Ok(DeviceAuthResult::Denied),
+            "expired_token" => Ok(DeviceAuthResult::Expired),
+            _ => Err(LlmError::Auth(format!(
+                "Token request failed: {} - {}",
+                error_response.error,
+                error_response.error_description.unwrap_or_default()
+            ))),
+        }
+    }
+
+    async fn refresh_token(&self, refresh_token: &str) -> Result<AuthMethod, LlmError> {
+        let url = format!("{}{}", AUTH_BASE_URL, TOKEN_ENDPOINT);
+
+        #[derive(Serialize)]
+        struct RefreshRequest<'a> {
+            client_id: &'a str,
+            refresh_token: &'a str,
+            grant_type: &'a str,
+        }
+
+        let request = RefreshRequest {
+            client_id: &self.client_id,
+            refresh_token,
+            grant_type: "refresh_token",
+        };
+
+        let response = self
+            .http
+            .post(&url)
+            .json(&request)
+            .send()
+            .await
+            .map_err(|e| LlmError::Http(e.to_string()))?;
+
+        if !response.status().is_success() {
+            let text = response
+                .text()
+                .await
+                .unwrap_or_else(|_| "Unknown error".to_string());
+            return Err(LlmError::Auth(format!("Token refresh failed: {}", text)));
+        }
+
+        let token_response: TokenApiResponse = response
+            .json()
+            .await
+            .map_err(|e| LlmError::Json(e.to_string()))?;
+
+        let expires_at = token_response.expires_in.map(|secs| {
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .map(|d| d.as_secs() + secs)
+                .unwrap_or(0)
+        });
+
+        Ok(AuthMethod::OAuth {
+            access_token: token_response.access_token,
+            refresh_token: token_response.refresh_token,
+            expires_at,
+        })
+    }
+}
+
+/// Helper to perform the full device auth flow with polling
+pub async fn perform_device_auth<F>(
+    auth: &AnthropicAuth,
+    on_code: F,
+) -> Result<AuthMethod, LlmError>
+where
+    F: FnOnce(&DeviceCodeResponse),
+{
+    // Start the device flow
+    let device_code = auth.start_device_auth().await?;
+
+    // Let caller display the code to user
+    on_code(&device_code);
+
+    // Poll for completion
+    let poll_interval = std::time::Duration::from_secs(device_code.interval);
+    let deadline =
+        std::time::Instant::now() + std::time::Duration::from_secs(device_code.expires_in);
+
+    loop {
+        if std::time::Instant::now() > deadline {
+            return Err(LlmError::Auth("Device code expired".to_string()));
+        }
+
+        tokio::time::sleep(poll_interval).await;
+
+        match auth.poll_device_auth(&device_code.device_code).await? {
+            DeviceAuthResult::Success {
+                access_token,
+                refresh_token,
+                expires_in,
+            } => {
+                let expires_at = expires_in.map(|secs| {
+                    std::time::SystemTime::now()
+                        .duration_since(std::time::UNIX_EPOCH)
+                        .map(|d| d.as_secs() + secs)
+                        .unwrap_or(0)
+                });
+
+                return Ok(AuthMethod::OAuth {
+                    access_token,
+                    refresh_token,
+                    expires_at,
+                });
+            }
+            DeviceAuthResult::Pending => continue,
+            DeviceAuthResult::Denied => {
+                return Err(LlmError::Auth("Authorization denied by user".to_string()));
+            }
+            DeviceAuthResult::Expired => {
+                return Err(LlmError::Auth("Device code expired".to_string()));
+            }
+        }
+    }
+}

crates/llm/anthropic/src/client.rs

@@ -0,0 +1,577 @@
+//! Anthropic Claude API Client
+//!
+//! Implements the Messages API with streaming support.
+
+use crate::types::*;
+use async_trait::async_trait;
+use futures::StreamExt;
+use llm_core::{
+    AccountInfo, AuthMethod, ChatMessage, ChatOptions, ChatResponse, ChunkStream, FunctionCall,
+    LlmError, LlmProvider, ModelInfo, ProviderInfo, ProviderStatus, Role, StreamChunk, Tool,
+    ToolCall, ToolCallDelta, Usage, UsageStats,
+};
+use reqwest::Client;
+use reqwest_eventsource::{Event, EventSource};
+use std::sync::Arc;
+use tokio::sync::Mutex;
+
+const API_BASE_URL: &str = "https://api.anthropic.com";
+const MESSAGES_ENDPOINT: &str = "/v1/messages";
+const API_VERSION: &str = "2023-06-01";
+const DEFAULT_MAX_TOKENS: u32 = 8192;
+
+/// Anthropic Claude API client
+pub struct AnthropicClient {
+    http: Client,
+    auth: AuthMethod,
+    model: String,
+}
+
+impl AnthropicClient {
+    /// Create a new client with API key authentication
+    pub fn new(api_key: impl Into<String>) -> Self {
+        Self {
+            http: Client::new(),
+            auth: AuthMethod::api_key(api_key),
+            model: "claude-sonnet-4-20250514".to_string(),
+        }
+    }
+
+    /// Create a new client with OAuth token
+    pub fn with_oauth(access_token: impl Into<String>) -> Self {
+        Self {
+            http: Client::new(),
+            auth: AuthMethod::oauth(access_token),
+            model: "claude-sonnet-4-20250514".to_string(),
+        }
+    }
+
+    /// Create a new client with full AuthMethod
+    pub fn with_auth(auth: AuthMethod) -> Self {
+        Self {
+            http: Client::new(),
+            auth,
+            model: "claude-sonnet-4-20250514".to_string(),
+        }
+    }
+
+    /// Set the model to use
+    pub fn with_model(mut self, model: impl Into<String>) -> Self {
+        self.model = model.into();
+        self
+    }
+
+    /// Get current auth method (for token refresh)
+    pub fn auth(&self) -> &AuthMethod {
+        &self.auth
+    }
+
+    /// Update the auth method (after refresh)
+    pub fn set_auth(&mut self, auth: AuthMethod) {
+        self.auth = auth;
+    }
+
+    /// Convert messages to Anthropic format, extracting system message
+    fn prepare_messages(messages: &[ChatMessage]) -> (Option<String>, Vec<AnthropicMessage>) {
+        let mut system_content = None;
+        let mut anthropic_messages = Vec::new();
+
+        for msg in messages {
+            if msg.role == Role::System {
+                // Collect system messages
+                if let Some(content) = &msg.content {
+                    if let Some(existing) = &mut system_content {
+                        *existing = format!("{}\n\n{}", existing, content);
+                    } else {
+                        system_content = Some(content.clone());
+                    }
+                }
+            } else {
+                anthropic_messages.push(AnthropicMessage::from(msg));
+            }
+        }
+
+        (system_content, anthropic_messages)
+    }
+
+    /// Convert tools to Anthropic format
+    fn prepare_tools(tools: Option<&[Tool]>) -> Option<Vec<AnthropicTool>> {
+        tools.map(|t| t.iter().map(AnthropicTool::from).collect())
+    }
+}
+
+#[async_trait]
+impl LlmProvider for AnthropicClient {
+    fn name(&self) -> &str {
+        "anthropic"
+    }
+
+    fn model(&self) -> &str {
+        &self.model
+    }
+
+    async fn chat_stream(
+        &self,
+        messages: &[ChatMessage],
+        options: &ChatOptions,
+        tools: Option<&[Tool]>,
+    ) -> Result<ChunkStream, LlmError> {
+        let url = format!("{}{}", API_BASE_URL, MESSAGES_ENDPOINT);
+
+        let model = if options.model.is_empty() {
+            &self.model
+        } else {
+            &options.model
+        };
+
+        let (system, anthropic_messages) = Self::prepare_messages(messages);
+        let anthropic_tools = Self::prepare_tools(tools);
+
+        let request = MessagesRequest {
+            model,
+            messages: anthropic_messages,
+            max_tokens: options.max_tokens.unwrap_or(DEFAULT_MAX_TOKENS),
+            system: system.as_deref(),
+            temperature: options.temperature,
+            top_p: options.top_p,
+            stop_sequences: options.stop.as_deref(),
+            tools: anthropic_tools,
+            stream: true,
+        };
+
+        let bearer = self
+            .auth
+            .bearer_token()
+            .ok_or_else(|| LlmError::Auth("No authentication configured".to_string()))?;
+
+        // Build the SSE request
+        let req = self
+            .http
+            .post(&url)
+            .header("x-api-key", bearer)
+            .header("anthropic-version", API_VERSION)
+            .header("content-type", "application/json")
+            .json(&request);
+
+        let es = EventSource::new(req).map_err(|e| LlmError::Http(e.to_string()))?;
+
+        // State for accumulating tool calls across deltas
+        let tool_state: Arc<Mutex<Vec<PartialToolCall>>> = Arc::new(Mutex::new(Vec::new()));
+
+        let stream = es.filter_map(move |event| {
+            let tool_state = Arc::clone(&tool_state);
+            async move {
+                match event {
+                    Ok(Event::Open) => None,
+                    Ok(Event::Message(msg)) => {
+                        // Parse the SSE data as JSON
+                        let event: StreamEvent = match serde_json::from_str(&msg.data) {
+                            Ok(e) => e,
+                            Err(e) => {
+                                tracing::warn!("Failed to parse SSE event: {}", e);
+                                return None;
+                            }
+                        };
+
+                        convert_stream_event(event, &tool_state).await
+                    }
+                    Err(reqwest_eventsource::Error::StreamEnded) => None,
+                    Err(e) => Some(Err(LlmError::Stream(e.to_string()))),
+                }
+            }
+        });
+
+        Ok(Box::pin(stream))
+    }
+
+    async fn chat(
+        &self,
+        messages: &[ChatMessage],
+        options: &ChatOptions,
+        tools: Option<&[Tool]>,
+    ) -> Result<ChatResponse, LlmError> {
+        let url = format!("{}{}", API_BASE_URL, MESSAGES_ENDPOINT);
+
+        let model = if options.model.is_empty() {
+            &self.model
+        } else {
+            &options.model
+        };
+
+        let (system, anthropic_messages) = Self::prepare_messages(messages);
+        let anthropic_tools = Self::prepare_tools(tools);
+
+        let request = MessagesRequest {
+            model,
+            messages: anthropic_messages,
+            max_tokens: options.max_tokens.unwrap_or(DEFAULT_MAX_TOKENS),
+            system: system.as_deref(),
+            temperature: options.temperature,
+            top_p: options.top_p,
+            stop_sequences: options.stop.as_deref(),
+            tools: anthropic_tools,
+            stream: false,
+        };
+
+        let bearer = self
+            .auth
+            .bearer_token()
+            .ok_or_else(|| LlmError::Auth("No authentication configured".to_string()))?;
+
+        let response = self
+            .http
+            .post(&url)
+            .header("x-api-key", bearer)
+            .header("anthropic-version", API_VERSION)
+            .json(&request)
+            .send()
+            .await
+            .map_err(|e| LlmError::Http(e.to_string()))?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let text = response
+                .text()
+                .await
+                .unwrap_or_else(|_| "Unknown error".to_string());
+
+            // Check for rate limiting
+            if status == reqwest::StatusCode::TOO_MANY_REQUESTS {
+                return Err(LlmError::RateLimit {
+                    retry_after_secs: None,
+                });
+            }
+
+            return Err(LlmError::Api {
+                message: text,
+                code: Some(status.to_string()),
+            });
+        }
+
+        let api_response: MessagesResponse = response
+            .json()
+            .await
+            .map_err(|e| LlmError::Json(e.to_string()))?;
+
+        // Convert response to common format
+        let mut content = String::new();
+        let mut tool_calls = Vec::new();
+
+        for block in api_response.content {
+            match block {
+                ResponseContentBlock::Text { text } => {
+                    content.push_str(&text);
+                }
+                ResponseContentBlock::ToolUse { id, name, input } => {
+                    tool_calls.push(ToolCall {
+                        id,
+                        call_type: "function".to_string(),
+                        function: FunctionCall {
+                            name,
+                            arguments: input,
+                        },
+                    });
+                }
+            }
+        }
+
+        let usage = api_response.usage.map(|u| Usage {
+            prompt_tokens: u.input_tokens,
+            completion_tokens: u.output_tokens,
+            total_tokens: u.input_tokens + u.output_tokens,
+        });
+
+        Ok(ChatResponse {
+            content: if content.is_empty() {
+                None
+            } else {
+                Some(content)
+            },
+            tool_calls: if tool_calls.is_empty() {
+                None
+            } else {
+                Some(tool_calls)
+            },
+            usage,
+        })
+    }
+}
+
+/// Helper struct for accumulating streaming tool calls
+#[derive(Default)]
+struct PartialToolCall {
+    #[allow(dead_code)]
+    id: String,
+    #[allow(dead_code)]
+    name: String,
+    input_json: String,
+}
+
+/// Convert an Anthropic stream event to our common StreamChunk format
+async fn convert_stream_event(
+    event: StreamEvent,
+    tool_state: &Arc<Mutex<Vec<PartialToolCall>>>,
+) -> Option<Result<StreamChunk, LlmError>> {
+    match event {
+        StreamEvent::ContentBlockStart {
+            index,
+            content_block,
+        } => {
+            match content_block {
+                ContentBlockStartInfo::Text { text } => {
+                    if text.is_empty() {
+                        None
+                    } else {
+                        Some(Ok(StreamChunk {
+                            content: Some(text),
+                            tool_calls: None,
+                            done: false,
+                            usage: None,
+                        }))
+                    }
+                }
+                ContentBlockStartInfo::ToolUse { id, name } => {
+                    // Store the tool call start
+                    let mut state = tool_state.lock().await;
+                    while state.len() <= index {
+                        state.push(PartialToolCall::default());
+                    }
+                    state[index] = PartialToolCall {
+                        id: id.clone(),
+                        name: name.clone(),
+                        input_json: String::new(),
+                    };
+
+                    Some(Ok(StreamChunk {
+                        content: None,
+                        tool_calls: Some(vec![ToolCallDelta {
+                            index,
+                            id: Some(id),
+                            function_name: Some(name),
+                            arguments_delta: None,
+                        }]),
+                        done: false,
+                        usage: None,
+                    }))
+                }
+            }
+        }
+
+        StreamEvent::ContentBlockDelta { index, delta } => match delta {
+            ContentDelta::TextDelta { text } => Some(Ok(StreamChunk {
+                content: Some(text),
+                tool_calls: None,
+                done: false,
+                usage: None,
+            })),
+            ContentDelta::InputJsonDelta { partial_json } => {
+                // Accumulate the JSON
+                let mut state = tool_state.lock().await;
+                if index < state.len() {
+                    state[index].input_json.push_str(&partial_json);
+                }
+
+                Some(Ok(StreamChunk {
+                    content: None,
+                    tool_calls: Some(vec![ToolCallDelta {
+                        index,
+                        id: None,
+                        function_name: None,
+                        arguments_delta: Some(partial_json),
+                    }]),
+                    done: false,
+                    usage: None,
+                }))
+            }
+        },
+
+        StreamEvent::MessageDelta { usage, .. } => {
+            let u = usage.map(|u| Usage {
+                prompt_tokens: u.input_tokens,
+                completion_tokens: u.output_tokens,
+                total_tokens: u.input_tokens + u.output_tokens,
+            });
+
+            Some(Ok(StreamChunk {
+                content: None,
+                tool_calls: None,
+                done: false,
+                usage: u,
+            }))
+        }
+
+        StreamEvent::MessageStop => Some(Ok(StreamChunk {
+            content: None,
+            tool_calls: None,
+            done: true,
+            usage: None,
+        })),
+
+        StreamEvent::Error { error } => Some(Err(LlmError::Api {
+            message: error.message,
+            code: Some(error.error_type),
+        })),
+
+        // Ignore other events
+        StreamEvent::MessageStart { .. }
+        | StreamEvent::ContentBlockStop { .. }
+        | StreamEvent::Ping => None,
+    }
+}
+
+// ============================================================================
+// ProviderInfo Implementation
+// ============================================================================
+
+/// Known Claude models with their specifications
+fn get_claude_models() -> Vec<ModelInfo> {
+    vec![
+        ModelInfo {
+            id: "claude-opus-4-20250514".to_string(),
+            display_name: Some("Claude Opus 4".to_string()),
+            description: Some("Most capable model for complex tasks".to_string()),
+            context_window: Some(200_000),
+            max_output_tokens: Some(32_000),
+            supports_tools: true,
+            supports_vision: true,
+            input_price_per_mtok: Some(15.0),
+            output_price_per_mtok: Some(75.0),
+        },
+        ModelInfo {
+            id: "claude-sonnet-4-20250514".to_string(),
+            display_name: Some("Claude Sonnet 4".to_string()),
+            description: Some("Best balance of performance and speed".to_string()),
+            context_window: Some(200_000),
+            max_output_tokens: Some(64_000),
+            supports_tools: true,
+            supports_vision: true,
+            input_price_per_mtok: Some(3.0),
+            output_price_per_mtok: Some(15.0),
+        },
+        ModelInfo {
+            id: "claude-haiku-3-5-20241022".to_string(),
+            display_name: Some("Claude 3.5 Haiku".to_string()),
+            description: Some("Fast and affordable for simple tasks".to_string()),
+            context_window: Some(200_000),
+            max_output_tokens: Some(8_192),
+            supports_tools: true,
+            supports_vision: true,
+            input_price_per_mtok: Some(0.80),
+            output_price_per_mtok: Some(4.0),
+        },
+    ]
+}
+
+#[async_trait]
+impl ProviderInfo for AnthropicClient {
+    async fn status(&self) -> Result<ProviderStatus, LlmError> {
+        let authenticated = self.auth.bearer_token().is_some();
+
+        // Try to reach the API with a simple request
+        let reachable = if authenticated {
+            // Test with a minimal message to verify auth works
+            let test_messages = vec![ChatMessage::user("Hi")];
+            let test_opts = ChatOptions::new(&self.model).with_max_tokens(1);
+
+            match self.chat(&test_messages, &test_opts, None).await {
+                Ok(_) => true,
+                Err(LlmError::Auth(_)) => false, // Auth failed
+                Err(_) => true,                  // Other errors mean API is reachable
+            }
+        } else {
+            false
+        };
+
+        let account = if authenticated && reachable {
+            self.account_info().await.ok().flatten()
+        } else {
+            None
+        };
+
+        let message = if !authenticated {
+            Some("Not authenticated - run 'owlen login anthropic' to authenticate".to_string())
+        } else if !reachable {
+            Some("Cannot reach Anthropic API".to_string())
+        } else {
+            Some("Connected".to_string())
+        };
+
+        Ok(ProviderStatus {
+            provider: "anthropic".to_string(),
+            authenticated,
+            account,
+            model: self.model.clone(),
+            endpoint: API_BASE_URL.to_string(),
+            reachable,
+            message,
+        })
+    }
+
+    async fn account_info(&self) -> Result<Option<AccountInfo>, LlmError> {
+        // Anthropic doesn't have a public account info endpoint
+        // Return None - account info would come from OAuth token claims
+        Ok(None)
+    }
+
+    async fn usage_stats(&self) -> Result<Option<UsageStats>, LlmError> {
+        // Anthropic doesn't expose usage stats via API
+        // This would require the admin/billing API with different auth
+        Ok(None)
+    }
+
+    async fn list_models(&self) -> Result<Vec<ModelInfo>, LlmError> {
+        // Return known models - Anthropic doesn't have a models list endpoint
+        Ok(get_claude_models())
+    }
+
+    async fn model_info(&self, model_id: &str) -> Result<Option<ModelInfo>, LlmError> {
+        let models = get_claude_models();
+        Ok(models.into_iter().find(|m| m.id == model_id))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use llm_core::ToolParameters;
+    use serde_json::json;
+
+    #[test]
+    fn test_message_conversion() {
+        let messages = vec![
+            ChatMessage::system("You are helpful"),
+            ChatMessage::user("Hello"),
+            ChatMessage::assistant("Hi there!"),
+        ];
+
+        let (system, anthropic_msgs) = AnthropicClient::prepare_messages(&messages);
+
+        assert_eq!(system, Some("You are helpful".to_string()));
+        assert_eq!(anthropic_msgs.len(), 2);
+        assert_eq!(anthropic_msgs[0].role, "user");
+        assert_eq!(anthropic_msgs[1].role, "assistant");
+    }
+
+    #[test]
+    fn test_tool_conversion() {
+        let tools = vec![Tool::function(
+            "read_file",
+            "Read a file's contents",
+            ToolParameters::object(
+                json!({
+                    "path": {
+                        "type": "string",
+                        "description": "File path"
+                    }
+                }),
+                vec!["path".to_string()],
+            ),
+        )];
+
+        let anthropic_tools = AnthropicClient::prepare_tools(Some(&tools)).unwrap();
+
+        assert_eq!(anthropic_tools.len(), 1);
+        assert_eq!(anthropic_tools[0].name, "read_file");
+        assert_eq!(anthropic_tools[0].description, "Read a file's contents");
+    }
+}

crates/llm/anthropic/src/lib.rs

@@ -0,0 +1,12 @@
+//! Anthropic Claude API Client
+//!
+//! Implements the LlmProvider trait for Anthropic's Claude models.
+//! Supports both API key authentication and OAuth device flow.
+
+mod auth;
+mod client;
+mod types;
+
+pub use auth::*;
+pub use client::*;
+pub use types::*;

crates/llm/anthropic/src/types.rs

@@ -0,0 +1,276 @@
+//! Anthropic API request/response types
+
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+// ============================================================================
+// Request Types
+// ============================================================================
+
+#[derive(Debug, Serialize)]
+pub struct MessagesRequest<'a> {
+    pub model: &'a str,
+    pub messages: Vec<AnthropicMessage>,
+    pub max_tokens: u32,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub system: Option<&'a str>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub temperature: Option<f32>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub top_p: Option<f32>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub stop_sequences: Option<&'a [String]>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tools: Option<Vec<AnthropicTool>>,
+
+    pub stream: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AnthropicMessage {
+    pub role: String, // "user" or "assistant"
+    pub content: AnthropicContent,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum AnthropicContent {
+    Text(String),
+    Blocks(Vec<ContentBlock>),
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum ContentBlock {
+    #[serde(rename = "text")]
+    Text { text: String },
+
+    #[serde(rename = "tool_use")]
+    ToolUse {
+        id: String,
+        name: String,
+        input: Value,
+    },
+
+    #[serde(rename = "tool_result")]
+    ToolResult {
+        tool_use_id: String,
+        content: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        is_error: Option<bool>,
+    },
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AnthropicTool {
+    pub name: String,
+    pub description: String,
+    pub input_schema: ToolInputSchema,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolInputSchema {
+    #[serde(rename = "type")]
+    pub schema_type: String,
+    pub properties: Value,
+    pub required: Vec<String>,
+}
+
+// ============================================================================
+// Response Types
+// ============================================================================
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct MessagesResponse {
+    pub id: String,
+    #[serde(rename = "type")]
+    pub response_type: String,
+    pub role: String,
+    pub content: Vec<ResponseContentBlock>,
+    pub model: String,
+    pub stop_reason: Option<String>,
+    pub usage: Option<UsageInfo>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(tag = "type")]
+pub enum ResponseContentBlock {
+    #[serde(rename = "text")]
+    Text { text: String },
+
+    #[serde(rename = "tool_use")]
+    ToolUse {
+        id: String,
+        name: String,
+        input: Value,
+    },
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct UsageInfo {
+    pub input_tokens: u32,
+    pub output_tokens: u32,
+}
+
+// ============================================================================
+// Streaming Event Types
+// ============================================================================
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(tag = "type")]
+pub enum StreamEvent {
+    #[serde(rename = "message_start")]
+    MessageStart { message: MessageStartInfo },
+
+    #[serde(rename = "content_block_start")]
+    ContentBlockStart {
+        index: usize,
+        content_block: ContentBlockStartInfo,
+    },
+
+    #[serde(rename = "content_block_delta")]
+    ContentBlockDelta { index: usize, delta: ContentDelta },
+
+    #[serde(rename = "content_block_stop")]
+    ContentBlockStop { index: usize },
+
+    #[serde(rename = "message_delta")]
+    MessageDelta {
+        delta: MessageDeltaInfo,
+        usage: Option<UsageInfo>,
+    },
+
+    #[serde(rename = "message_stop")]
+    MessageStop,
+
+    #[serde(rename = "ping")]
+    Ping,
+
+    #[serde(rename = "error")]
+    Error { error: ApiError },
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct MessageStartInfo {
+    pub id: String,
+    #[serde(rename = "type")]
+    pub message_type: String,
+    pub role: String,
+    pub model: String,
+    pub usage: Option<UsageInfo>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(tag = "type")]
+pub enum ContentBlockStartInfo {
+    #[serde(rename = "text")]
+    Text { text: String },
+
+    #[serde(rename = "tool_use")]
+    ToolUse { id: String, name: String },
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(tag = "type")]
+pub enum ContentDelta {
+    #[serde(rename = "text_delta")]
+    TextDelta { text: String },
+
+    #[serde(rename = "input_json_delta")]
+    InputJsonDelta { partial_json: String },
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct MessageDeltaInfo {
+    pub stop_reason: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct ApiError {
+    #[serde(rename = "type")]
+    pub error_type: String,
+    pub message: String,
+}
+
+// ============================================================================
+// Conversions
+// ============================================================================
+
+impl From<&llm_core::Tool> for AnthropicTool {
+    fn from(tool: &llm_core::Tool) -> Self {
+        Self {
+            name: tool.function.name.clone(),
+            description: tool.function.description.clone(),
+            input_schema: ToolInputSchema {
+                schema_type: tool.function.parameters.param_type.clone(),
+                properties: tool.function.parameters.properties.clone(),
+                required: tool.function.parameters.required.clone(),
+            },
+        }
+    }
+}
+
+impl From<&llm_core::ChatMessage> for AnthropicMessage {
+    fn from(msg: &llm_core::ChatMessage) -> Self {
+        use llm_core::Role;
+
+        let role = match msg.role {
+            Role::User | Role::System => "user",
+            Role::Assistant => "assistant",
+            Role::Tool => "user", // Tool results come as user messages in Anthropic
+        };
+
+        // Handle tool results
+        if msg.role == Role::Tool {
+            if let (Some(tool_call_id), Some(content)) = (&msg.tool_call_id, &msg.content) {
+                return Self {
+                    role: "user".to_string(),
+                    content: AnthropicContent::Blocks(vec![ContentBlock::ToolResult {
+                        tool_use_id: tool_call_id.clone(),
+                        content: content.clone(),
+                        is_error: None,
+                    }]),
+                };
+            }
+        }
+
+        // Handle assistant messages with tool calls
+        if msg.role == Role::Assistant {
+            if let Some(tool_calls) = &msg.tool_calls {
+                let mut blocks: Vec<ContentBlock> = Vec::new();
+
+                // Add text content if present
+                if let Some(text) = &msg.content {
+                    if !text.is_empty() {
+                        blocks.push(ContentBlock::Text { text: text.clone() });
+                    }
+                }
+
+                // Add tool use blocks
+                for call in tool_calls {
+                    blocks.push(ContentBlock::ToolUse {
+                        id: call.id.clone(),
+                        name: call.function.name.clone(),
+                        input: call.function.arguments.clone(),
+                    });
+                }
+
+                return Self {
+                    role: "assistant".to_string(),
+                    content: AnthropicContent::Blocks(blocks),
+                };
+            }
+        }
+
+        // Simple text message
+        Self {
+            role: role.to_string(),
+            content: AnthropicContent::Text(msg.content.clone().unwrap_or_default()),
+        }
+    }
+}

crates/llm/core/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "llm-core"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+description = "LLM provider abstraction layer for Owlen"
+
+[dependencies]
+async-trait = "0.1"
+futures = "0.3"
+rand = "0.8"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+thiserror = "2.0"
+tokio = { version = "1.0", features = ["time"] }
+
+[dev-dependencies]
+tokio = { version = "1.0", features = ["macros", "rt"] }

crates/llm/core/examples/token_counting.rs

@@ -0,0 +1,195 @@
+//! Token counting example
+//!
+//! This example demonstrates how to use the token counting utilities
+//! to manage LLM context windows.
+//!
+//! Run with: cargo run --example token_counting -p llm-core
+
+use llm_core::{
+    ChatMessage, ClaudeTokenCounter, ContextWindow, SimpleTokenCounter, TokenCounter,
+};
+
+fn main() {
+    println!("=== Token Counting Example ===\n");
+
+    // Example 1: Basic token counting with SimpleTokenCounter
+    println!("1. Basic Token Counting");
+    println!("{}", "-".repeat(50));
+
+    let simple_counter = SimpleTokenCounter::new(8192);
+    let text = "The quick brown fox jumps over the lazy dog.";
+
+    let token_count = simple_counter.count(text);
+    println!("Text: \"{}\"", text);
+    println!("Estimated tokens: {}", token_count);
+    println!("Max context: {}\n", simple_counter.max_context());
+
+    // Example 2: Counting tokens in chat messages
+    println!("2. Counting Tokens in Chat Messages");
+    println!("{}", "-".repeat(50));
+
+    let messages = vec![
+        ChatMessage::system("You are a helpful assistant that provides concise answers."),
+        ChatMessage::user("What is the capital of France?"),
+        ChatMessage::assistant("The capital of France is Paris."),
+        ChatMessage::user("What is its population?"),
+    ];
+
+    let total_tokens = simple_counter.count_messages(&messages);
+    println!("Number of messages: {}", messages.len());
+    println!("Total tokens (with overhead): {}\n", total_tokens);
+
+    // Example 3: Using ClaudeTokenCounter for Claude models
+    println!("3. Claude-Specific Token Counting");
+    println!("{}", "-".repeat(50));
+
+    let claude_counter = ClaudeTokenCounter::new();
+    let claude_total = claude_counter.count_messages(&messages);
+
+    println!("Claude counter max context: {}", claude_counter.max_context());
+    println!("Claude estimated tokens: {}\n", claude_total);
+
+    // Example 4: Context window management
+    println!("4. Context Window Management");
+    println!("{}", "-".repeat(50));
+
+    let mut context = ContextWindow::new(8192);
+    println!("Created context window with max: {} tokens", context.max());
+
+    // Simulate adding messages
+    let conversation = vec![
+        ChatMessage::user("Tell me about Rust programming."),
+        ChatMessage::assistant(
+            "Rust is a systems programming language focused on safety, \
+             speed, and concurrency. It prevents common bugs like null pointer \
+             dereferences and data races through its ownership system.",
+        ),
+        ChatMessage::user("What are its main features?"),
+        ChatMessage::assistant(
+            "Rust's main features include: 1) Memory safety without garbage collection, \
+             2) Zero-cost abstractions, 3) Fearless concurrency, 4) Pattern matching, \
+             5) Type inference, and 6) A powerful macro system.",
+        ),
+    ];
+
+    for (i, msg) in conversation.iter().enumerate() {
+        let tokens = simple_counter.count_messages(&[msg.clone()]);
+        context.add_tokens(tokens);
+
+        let role = msg.role.as_str();
+        let preview = msg
+            .content
+            .as_ref()
+            .map(|c| {
+                if c.len() > 50 {
+                    format!("{}...", &c[..50])
+                } else {
+                    c.clone()
+                }
+            })
+            .unwrap_or_default();
+
+        println!(
+            "Message {}: [{}] \"{}\"",
+            i + 1,
+            role,
+            preview
+        );
+        println!("  Added {} tokens", tokens);
+        println!("  Total used: {} / {}", context.used(), context.max());
+        println!("  Usage: {:.1}%", context.usage_percent() * 100.0);
+        println!("  Progress: {}\n", context.progress_bar(30));
+    }
+
+    // Example 5: Checking context limits
+    println!("5. Checking Context Limits");
+    println!("{}", "-".repeat(50));
+
+    if context.is_near_limit(0.8) {
+        println!("Warning: Context is over 80% full!");
+    } else {
+        println!("Context usage is below 80%");
+    }
+
+    let remaining = context.remaining();
+    println!("Remaining tokens: {}", remaining);
+
+    let new_message_tokens = 500;
+    if context.has_room_for(new_message_tokens) {
+        println!(
+            "Can fit a message of {} tokens",
+            new_message_tokens
+        );
+    } else {
+        println!(
+            "Cannot fit a message of {} tokens - would need to compact or start new context",
+            new_message_tokens
+        );
+    }
+
+    // Example 6: Different counter variants
+    println!("\n6. Using Different Counter Variants");
+    println!("{}", "-".repeat(50));
+
+    let counter_8k = SimpleTokenCounter::default_8k();
+    let counter_32k = SimpleTokenCounter::with_32k();
+    let counter_128k = SimpleTokenCounter::with_128k();
+
+    println!("8k context counter: {} tokens", counter_8k.max_context());
+    println!("32k context counter: {} tokens", counter_32k.max_context());
+    println!("128k context counter: {} tokens", counter_128k.max_context());
+
+    let haiku = ClaudeTokenCounter::haiku();
+    let sonnet = ClaudeTokenCounter::sonnet();
+    let opus = ClaudeTokenCounter::opus();
+
+    println!("\nClaude Haiku: {} tokens", haiku.max_context());
+    println!("Claude Sonnet: {} tokens", sonnet.max_context());
+    println!("Claude Opus: {} tokens", opus.max_context());
+
+    // Example 7: Managing context for a long conversation
+    println!("\n7. Long Conversation Simulation");
+    println!("{}", "-".repeat(50));
+
+    let mut long_context = ContextWindow::new(4096); // Smaller context for demo
+    let counter = SimpleTokenCounter::new(4096);
+
+    let mut message_count = 0;
+    let mut compaction_count = 0;
+
+    // Simulate 20 exchanges
+    for i in 0..20 {
+        let user_msg = ChatMessage::user(format!(
+            "This is user message number {} asking a question.",
+            i + 1
+        ));
+        let assistant_msg = ChatMessage::assistant(format!(
+            "This is assistant response number {} providing a detailed answer with multiple sentences to make it longer.",
+            i + 1
+        ));
+
+        let tokens_needed = counter.count_messages(&[user_msg, assistant_msg]);
+
+        if !long_context.has_room_for(tokens_needed) {
+            println!(
+                "After {} messages, context is full ({}%). Compacting...",
+                message_count,
+                (long_context.usage_percent() * 100.0) as u32
+            );
+            // In a real scenario, we would compact the conversation
+            // For now, just reset
+            long_context.reset();
+            compaction_count += 1;
+        }
+
+        long_context.add_tokens(tokens_needed);
+        message_count += 2;
+    }
+
+    println!("Total messages: {}", message_count);
+    println!("Compactions needed: {}", compaction_count);
+    println!("Final context usage: {:.1}%", long_context.usage_percent() * 100.0);
+    println!("Final progress: {}", long_context.progress_bar(40));
+
+    println!("\n=== Example Complete ===");
+}

crates/llm/core/src/lib.rs

@@ -0,0 +1,796 @@
+//! LLM Provider Abstraction Layer
+//!
+//! This crate defines the common types and traits for LLM provider integration.
+//! Providers (Ollama, Anthropic Claude, OpenAI) implement the `LlmProvider` trait
+//! to enable swapping providers at runtime.
+
+use async_trait::async_trait;
+use futures::Stream;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use std::pin::Pin;
+use thiserror::Error;
+
+// ============================================================================
+// Public Modules
+// ============================================================================
+
+pub mod retry;
+pub mod tokens;
+
+// Re-export token counting types for convenience
+pub use tokens::{ClaudeTokenCounter, ContextWindow, SimpleTokenCounter, TokenCounter};
+
+// Re-export retry types for convenience
+pub use retry::{is_retryable_error, RetryConfig, RetryStrategy};
+
+// ============================================================================
+// Error Types
+// ============================================================================
+
+#[derive(Error, Debug)]
+pub enum LlmError {
+    #[error("HTTP error: {0}")]
+    Http(String),
+
+    #[error("JSON parsing error: {0}")]
+    Json(String),
+
+    #[error("Authentication error: {0}")]
+    Auth(String),
+
+    #[error("Rate limit exceeded: retry after {retry_after_secs:?} seconds")]
+    RateLimit { retry_after_secs: Option<u64> },
+
+    #[error("API error: {message}")]
+    Api { message: String, code: Option<String> },
+
+    #[error("Provider error: {0}")]
+    Provider(String),
+
+    #[error("Stream error: {0}")]
+    Stream(String),
+
+    #[error("Request timeout: {0}")]
+    Timeout(String),
+}
+
+// ============================================================================
+// Message Types
+// ============================================================================
+
+/// Role of a message in the conversation
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum Role {
+    System,
+    User,
+    Assistant,
+    Tool,
+}
+
+impl Role {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Role::System => "system",
+            Role::User => "user",
+            Role::Assistant => "assistant",
+            Role::Tool => "tool",
+        }
+    }
+}
+
+impl From<&str> for Role {
+    fn from(s: &str) -> Self {
+        match s.to_lowercase().as_str() {
+            "system" => Role::System,
+            "user" => Role::User,
+            "assistant" => Role::Assistant,
+            "tool" => Role::Tool,
+            _ => Role::User, // Default fallback
+        }
+    }
+}
+
+/// A message in the conversation
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ChatMessage {
+    pub role: Role,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub content: Option<String>,
+
+    /// Tool calls made by the assistant
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tool_calls: Option<Vec<ToolCall>>,
+
+    /// For tool role messages: the ID of the tool call this responds to
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tool_call_id: Option<String>,
+
+    /// For tool role messages: the name of the tool
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+}
+
+impl ChatMessage {
+    /// Create a system message
+    pub fn system(content: impl Into<String>) -> Self {
+        Self {
+            role: Role::System,
+            content: Some(content.into()),
+            tool_calls: None,
+            tool_call_id: None,
+            name: None,
+        }
+    }
+
+    /// Create a user message
+    pub fn user(content: impl Into<String>) -> Self {
+        Self {
+            role: Role::User,
+            content: Some(content.into()),
+            tool_calls: None,
+            tool_call_id: None,
+            name: None,
+        }
+    }
+
+    /// Create an assistant message
+    pub fn assistant(content: impl Into<String>) -> Self {
+        Self {
+            role: Role::Assistant,
+            content: Some(content.into()),
+            tool_calls: None,
+            tool_call_id: None,
+            name: None,
+        }
+    }
+
+    /// Create an assistant message with tool calls (no text content)
+    pub fn assistant_tool_calls(tool_calls: Vec<ToolCall>) -> Self {
+        Self {
+            role: Role::Assistant,
+            content: None,
+            tool_calls: Some(tool_calls),
+            tool_call_id: None,
+            name: None,
+        }
+    }
+
+    /// Create a tool result message
+    pub fn tool_result(tool_call_id: impl Into<String>, content: impl Into<String>) -> Self {
+        Self {
+            role: Role::Tool,
+            content: Some(content.into()),
+            tool_calls: None,
+            tool_call_id: Some(tool_call_id.into()),
+            name: None,
+        }
+    }
+}
+
+// ============================================================================
+// Tool Types
+// ============================================================================
+
+/// A tool call requested by the LLM
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct ToolCall {
+    /// Unique identifier for this tool call
+    pub id: String,
+
+    /// The type of tool call (always "function" for now)
+    #[serde(rename = "type", default = "default_function_type")]
+    pub call_type: String,
+
+    /// The function being called
+    pub function: FunctionCall,
+}
+
+fn default_function_type() -> String {
+    "function".to_string()
+}
+
+/// Details of a function call
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct FunctionCall {
+    /// Name of the function to call
+    pub name: String,
+
+    /// Arguments as a JSON object
+    pub arguments: Value,
+}
+
+/// Definition of a tool available to the LLM
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Tool {
+    #[serde(rename = "type")]
+    pub tool_type: String,
+
+    pub function: ToolFunction,
+}
+
+impl Tool {
+    /// Create a new function tool
+    pub fn function(
+        name: impl Into<String>,
+        description: impl Into<String>,
+        parameters: ToolParameters,
+    ) -> Self {
+        Self {
+            tool_type: "function".to_string(),
+            function: ToolFunction {
+                name: name.into(),
+                description: description.into(),
+                parameters,
+            },
+        }
+    }
+}
+
+/// Function definition within a tool
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolFunction {
+    pub name: String,
+    pub description: String,
+    pub parameters: ToolParameters,
+}
+
+/// Parameters schema for a function
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolParameters {
+    #[serde(rename = "type")]
+    pub param_type: String,
+
+    /// JSON Schema properties object
+    pub properties: Value,
+
+    /// Required parameter names
+    pub required: Vec<String>,
+}
+
+impl ToolParameters {
+    /// Create an object parameter schema
+    pub fn object(properties: Value, required: Vec<String>) -> Self {
+        Self {
+            param_type: "object".to_string(),
+            properties,
+            required,
+        }
+    }
+}
+
+// ============================================================================
+// Streaming Response Types
+// ============================================================================
+
+/// A chunk of a streaming response
+#[derive(Debug, Clone)]
+pub struct StreamChunk {
+    /// Incremental text content
+    pub content: Option<String>,
+
+    /// Tool calls (may be partial/streaming)
+    pub tool_calls: Option<Vec<ToolCallDelta>>,
+
+    /// Whether this is the final chunk
+    pub done: bool,
+
+    /// Usage statistics (typically only in final chunk)
+    pub usage: Option<Usage>,
+}
+
+/// Partial tool call for streaming
+#[derive(Debug, Clone)]
+pub struct ToolCallDelta {
+    /// Index of this tool call in the array
+    pub index: usize,
+
+    /// Tool call ID (may only be present in first delta)
+    pub id: Option<String>,
+
+    /// Function name (may only be present in first delta)
+    pub function_name: Option<String>,
+
+    /// Incremental arguments string
+    pub arguments_delta: Option<String>,
+}
+
+/// Token usage statistics
+#[derive(Debug, Clone, Default)]
+pub struct Usage {
+    pub prompt_tokens: u32,
+    pub completion_tokens: u32,
+    pub total_tokens: u32,
+}
+
+// ============================================================================
+// Provider Configuration
+// ============================================================================
+
+/// Options for a chat request
+#[derive(Debug, Clone, Default)]
+pub struct ChatOptions {
+    /// Model to use
+    pub model: String,
+
+    /// Temperature (0.0 - 2.0)
+    pub temperature: Option<f32>,
+
+    /// Maximum tokens to generate
+    pub max_tokens: Option<u32>,
+
+    /// Top-p sampling
+    pub top_p: Option<f32>,
+
+    /// Stop sequences
+    pub stop: Option<Vec<String>>,
+}
+
+impl ChatOptions {
+    pub fn new(model: impl Into<String>) -> Self {
+        Self {
+            model: model.into(),
+            ..Default::default()
+        }
+    }
+
+    pub fn with_temperature(mut self, temp: f32) -> Self {
+        self.temperature = Some(temp);
+        self
+    }
+
+    pub fn with_max_tokens(mut self, max: u32) -> Self {
+        self.max_tokens = Some(max);
+        self
+    }
+}
+
+// ============================================================================
+// Provider Trait
+// ============================================================================
+
+/// A boxed stream of chunks
+pub type ChunkStream = Pin<Box<dyn Stream<Item = Result<StreamChunk, LlmError>> + Send>>;
+
+/// The main trait that all LLM providers must implement
+#[async_trait]
+pub trait LlmProvider: Send + Sync {
+    /// Get the provider name (e.g., "ollama", "anthropic", "openai")
+    fn name(&self) -> &str;
+
+    /// Get the current model name
+    fn model(&self) -> &str;
+
+    /// Send a chat request and receive a streaming response
+    ///
+    /// # Arguments
+    /// * `messages` - The conversation history
+    /// * `options` - Request options (model, temperature, etc.)
+    /// * `tools` - Optional list of tools the model can use
+    ///
+    /// # Returns
+    /// A stream of response chunks
+    async fn chat_stream(
+        &self,
+        messages: &[ChatMessage],
+        options: &ChatOptions,
+        tools: Option<&[Tool]>,
+    ) -> Result<ChunkStream, LlmError>;
+
+    /// Send a chat request and receive a complete response (non-streaming)
+    ///
+    /// Default implementation collects the stream, but providers may override
+    /// for efficiency.
+    async fn chat(
+        &self,
+        messages: &[ChatMessage],
+        options: &ChatOptions,
+        tools: Option<&[Tool]>,
+    ) -> Result<ChatResponse, LlmError> {
+        use futures::StreamExt;
+
+        let mut stream = self.chat_stream(messages, options, tools).await?;
+        let mut content = String::new();
+        let mut tool_calls: Vec<PartialToolCall> = Vec::new();
+        let mut usage = None;
+
+        while let Some(chunk) = stream.next().await {
+            let chunk = chunk?;
+
+            if let Some(text) = chunk.content {
+                content.push_str(&text);
+            }
+
+            if let Some(deltas) = chunk.tool_calls {
+                for delta in deltas {
+                    // Grow the tool_calls vec if needed
+                    while tool_calls.len() <= delta.index {
+                        tool_calls.push(PartialToolCall::default());
+                    }
+
+                    let partial = &mut tool_calls[delta.index];
+                    if let Some(id) = delta.id {
+                        partial.id = Some(id);
+                    }
+                    if let Some(name) = delta.function_name {
+                        partial.function_name = Some(name);
+                    }
+                    if let Some(args) = delta.arguments_delta {
+                        partial.arguments.push_str(&args);
+                    }
+                }
+            }
+
+            if chunk.usage.is_some() {
+                usage = chunk.usage;
+            }
+        }
+
+        // Convert partial tool calls to complete tool calls
+        let final_tool_calls: Vec<ToolCall> = tool_calls
+            .into_iter()
+            .filter_map(|p| p.try_into_tool_call())
+            .collect();
+
+        Ok(ChatResponse {
+            content: if content.is_empty() {
+                None
+            } else {
+                Some(content)
+            },
+            tool_calls: if final_tool_calls.is_empty() {
+                None
+            } else {
+                Some(final_tool_calls)
+            },
+            usage,
+        })
+    }
+}
+
+/// A complete chat response (non-streaming)
+#[derive(Debug, Clone)]
+pub struct ChatResponse {
+    pub content: Option<String>,
+    pub tool_calls: Option<Vec<ToolCall>>,
+    pub usage: Option<Usage>,
+}
+
+/// Helper for accumulating streaming tool calls
+#[derive(Default)]
+struct PartialToolCall {
+    id: Option<String>,
+    function_name: Option<String>,
+    arguments: String,
+}
+
+impl PartialToolCall {
+    fn try_into_tool_call(self) -> Option<ToolCall> {
+        let id = self.id?;
+        let name = self.function_name?;
+        let arguments: Value = serde_json::from_str(&self.arguments).ok()?;
+
+        Some(ToolCall {
+            id,
+            call_type: "function".to_string(),
+            function: FunctionCall { name, arguments },
+        })
+    }
+}
+
+// ============================================================================
+// Authentication
+// ============================================================================
+
+/// Authentication method for LLM providers
+#[derive(Debug, Clone)]
+pub enum AuthMethod {
+    /// No authentication (for local providers like Ollama)
+    None,
+
+    /// API key authentication
+    ApiKey(String),
+
+    /// OAuth access token (from login flow)
+    OAuth {
+        access_token: String,
+        refresh_token: Option<String>,
+        expires_at: Option<u64>,
+    },
+}
+
+impl AuthMethod {
+    /// Create API key auth
+    pub fn api_key(key: impl Into<String>) -> Self {
+        Self::ApiKey(key.into())
+    }
+
+    /// Create OAuth auth from tokens
+    pub fn oauth(access_token: impl Into<String>) -> Self {
+        Self::OAuth {
+            access_token: access_token.into(),
+            refresh_token: None,
+            expires_at: None,
+        }
+    }
+
+    /// Create OAuth auth with refresh token
+    pub fn oauth_with_refresh(
+        access_token: impl Into<String>,
+        refresh_token: impl Into<String>,
+        expires_at: Option<u64>,
+    ) -> Self {
+        Self::OAuth {
+            access_token: access_token.into(),
+            refresh_token: Some(refresh_token.into()),
+            expires_at,
+        }
+    }
+
+    /// Get the bearer token for Authorization header
+    pub fn bearer_token(&self) -> Option<&str> {
+        match self {
+            Self::None => None,
+            Self::ApiKey(key) => Some(key),
+            Self::OAuth { access_token, .. } => Some(access_token),
+        }
+    }
+
+    /// Check if token might need refresh
+    pub fn needs_refresh(&self) -> bool {
+        match self {
+            Self::OAuth {
+                expires_at: Some(exp),
+                refresh_token: Some(_),
+                ..
+            } => {
+                let now = std::time::SystemTime::now()
+                    .duration_since(std::time::UNIX_EPOCH)
+                    .map(|d| d.as_secs())
+                    .unwrap_or(0);
+                // Refresh if expiring within 5 minutes
+                *exp < now + 300
+            }
+            _ => false,
+        }
+    }
+}
+
+/// Device code response for OAuth device flow
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DeviceCodeResponse {
+    /// Code the user enters on the verification page
+    pub user_code: String,
+
+    /// URL the user visits to authorize
+    pub verification_uri: String,
+
+    /// Full URL with code pre-filled (if supported)
+    pub verification_uri_complete: Option<String>,
+
+    /// Device code for polling (internal use)
+    pub device_code: String,
+
+    /// How often to poll (in seconds)
+    pub interval: u64,
+
+    /// When the codes expire (in seconds)
+    pub expires_in: u64,
+}
+
+/// Result of polling for device authorization
+#[derive(Debug, Clone)]
+pub enum DeviceAuthResult {
+    /// Still waiting for user to authorize
+    Pending,
+
+    /// User authorized, here are the tokens
+    Success {
+        access_token: String,
+        refresh_token: Option<String>,
+        expires_in: Option<u64>,
+    },
+
+    /// User denied authorization
+    Denied,
+
+    /// Code expired
+    Expired,
+}
+
+/// Trait for providers that support OAuth device flow
+#[async_trait]
+pub trait OAuthProvider {
+    /// Start the device authorization flow
+    async fn start_device_auth(&self) -> Result<DeviceCodeResponse, LlmError>;
+
+    /// Poll for the authorization result
+    async fn poll_device_auth(&self, device_code: &str) -> Result<DeviceAuthResult, LlmError>;
+
+    /// Refresh an access token using a refresh token
+    async fn refresh_token(&self, refresh_token: &str) -> Result<AuthMethod, LlmError>;
+}
+
+/// Stored credentials for a provider
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct StoredCredentials {
+    pub provider: String,
+    pub access_token: String,
+    pub refresh_token: Option<String>,
+    pub expires_at: Option<u64>,
+}
+
+// ============================================================================
+// Provider Status & Info
+// ============================================================================
+
+/// Status information for a provider connection
+#[derive(Debug, Clone)]
+pub struct ProviderStatus {
+    /// Provider name
+    pub provider: String,
+
+    /// Whether the connection is authenticated
+    pub authenticated: bool,
+
+    /// Current user/account info if authenticated
+    pub account: Option<AccountInfo>,
+
+    /// Current model being used
+    pub model: String,
+
+    /// API endpoint URL
+    pub endpoint: String,
+
+    /// Whether the provider is reachable
+    pub reachable: bool,
+
+    /// Any status message or error
+    pub message: Option<String>,
+}
+
+/// Account/user information from the provider
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AccountInfo {
+    /// Account/user ID
+    pub id: Option<String>,
+
+    /// Display name or email
+    pub name: Option<String>,
+
+    /// Account email
+    pub email: Option<String>,
+
+    /// Account type (free, pro, team, enterprise)
+    pub account_type: Option<String>,
+
+    /// Organization name if applicable
+    pub organization: Option<String>,
+}
+
+/// Usage statistics from the provider
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct UsageStats {
+    /// Total tokens used in current period
+    pub tokens_used: Option<u64>,
+
+    /// Token limit for current period (if applicable)
+    pub token_limit: Option<u64>,
+
+    /// Number of requests made
+    pub requests_made: Option<u64>,
+
+    /// Request limit (if applicable)
+    pub request_limit: Option<u64>,
+
+    /// Cost incurred (if available)
+    pub cost_usd: Option<f64>,
+
+    /// Period start timestamp
+    pub period_start: Option<u64>,
+
+    /// Period end timestamp
+    pub period_end: Option<u64>,
+}
+
+/// Available model information
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ModelInfo {
+    /// Model ID/name
+    pub id: String,
+
+    /// Human-readable display name
+    pub display_name: Option<String>,
+
+    /// Model description
+    pub description: Option<String>,
+
+    /// Context window size (tokens)
+    pub context_window: Option<u32>,
+
+    /// Max output tokens
+    pub max_output_tokens: Option<u32>,
+
+    /// Whether the model supports tool use
+    pub supports_tools: bool,
+
+    /// Whether the model supports vision/images
+    pub supports_vision: bool,
+
+    /// Input token price per 1M tokens (USD)
+    pub input_price_per_mtok: Option<f64>,
+
+    /// Output token price per 1M tokens (USD)
+    pub output_price_per_mtok: Option<f64>,
+}
+
+/// Trait for providers that support status/info queries
+#[async_trait]
+pub trait ProviderInfo {
+    /// Get the current connection status
+    async fn status(&self) -> Result<ProviderStatus, LlmError>;
+
+    /// Get account information (if authenticated)
+    async fn account_info(&self) -> Result<Option<AccountInfo>, LlmError>;
+
+    /// Get usage statistics (if available)
+    async fn usage_stats(&self) -> Result<Option<UsageStats>, LlmError>;
+
+    /// List available models
+    async fn list_models(&self) -> Result<Vec<ModelInfo>, LlmError>;
+
+    /// Check if a specific model is available
+    async fn model_info(&self, model_id: &str) -> Result<Option<ModelInfo>, LlmError> {
+        let models = self.list_models().await?;
+        Ok(models.into_iter().find(|m| m.id == model_id))
+    }
+}
+
+// ============================================================================
+// Provider Factory
+// ============================================================================
+
+/// Supported LLM providers
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum ProviderType {
+    Ollama,
+    Anthropic,
+    OpenAI,
+}
+
+impl ProviderType {
+    pub fn from_str(s: &str) -> Option<Self> {
+        match s.to_lowercase().as_str() {
+            "ollama" => Some(Self::Ollama),
+            "anthropic" | "claude" => Some(Self::Anthropic),
+            "openai" | "gpt" => Some(Self::OpenAI),
+            _ => None,
+        }
+    }
+
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Self::Ollama => "ollama",
+            Self::Anthropic => "anthropic",
+            Self::OpenAI => "openai",
+        }
+    }
+
+    /// Default model for this provider
+    pub fn default_model(&self) -> &'static str {
+        match self {
+            Self::Ollama => "qwen3:8b",
+            Self::Anthropic => "claude-sonnet-4-20250514",
+            Self::OpenAI => "gpt-4o",
+        }
+    }
+}
+
+impl std::fmt::Display for ProviderType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}

crates/llm/core/src/retry.rs

@@ -0,0 +1,386 @@
+//! Error recovery and retry logic for LLM operations
+//!
+//! This module provides configurable retry strategies with exponential backoff
+//! for handling transient failures when communicating with LLM providers.
+
+use crate::LlmError;
+use rand::Rng;
+use std::time::Duration;
+
+/// Configuration for retry behavior
+#[derive(Debug, Clone)]
+pub struct RetryConfig {
+    /// Maximum number of retry attempts
+    pub max_retries: u32,
+    /// Initial delay before first retry (in milliseconds)
+    pub initial_delay_ms: u64,
+    /// Maximum delay between retries (in milliseconds)
+    pub max_delay_ms: u64,
+    /// Multiplier for exponential backoff
+    pub backoff_multiplier: f32,
+}
+
+impl Default for RetryConfig {
+    fn default() -> Self {
+        Self {
+            max_retries: 3,
+            initial_delay_ms: 1000,
+            max_delay_ms: 30000,
+            backoff_multiplier: 2.0,
+        }
+    }
+}
+
+impl RetryConfig {
+    /// Create a new retry configuration with custom values
+    pub fn new(
+        max_retries: u32,
+        initial_delay_ms: u64,
+        max_delay_ms: u64,
+        backoff_multiplier: f32,
+    ) -> Self {
+        Self {
+            max_retries,
+            initial_delay_ms,
+            max_delay_ms,
+            backoff_multiplier,
+        }
+    }
+
+    /// Create a configuration with no retries
+    pub fn no_retry() -> Self {
+        Self {
+            max_retries: 0,
+            initial_delay_ms: 0,
+            max_delay_ms: 0,
+            backoff_multiplier: 1.0,
+        }
+    }
+
+    /// Create a configuration with aggressive retries for rate-limited scenarios
+    pub fn aggressive() -> Self {
+        Self {
+            max_retries: 5,
+            initial_delay_ms: 2000,
+            max_delay_ms: 60000,
+            backoff_multiplier: 2.5,
+        }
+    }
+}
+
+/// Determines whether an error is retryable
+///
+/// # Arguments
+/// * `error` - The error to check
+///
+/// # Returns
+/// `true` if the error is transient and the operation should be retried,
+/// `false` if the error is permanent and retrying won't help
+pub fn is_retryable_error(error: &LlmError) -> bool {
+    match error {
+        // Always retry rate limits
+        LlmError::RateLimit { .. } => true,
+
+        // Always retry timeouts
+        LlmError::Timeout(_) => true,
+
+        // Retry HTTP errors that are server-side (5xx)
+        LlmError::Http(msg) => {
+            // Check if the error message contains a 5xx status code
+            msg.contains("500")
+                || msg.contains("502")
+                || msg.contains("503")
+                || msg.contains("504")
+                || msg.contains("Internal Server Error")
+                || msg.contains("Bad Gateway")
+                || msg.contains("Service Unavailable")
+                || msg.contains("Gateway Timeout")
+        }
+
+        // Don't retry authentication errors - they need user intervention
+        LlmError::Auth(_) => false,
+
+        // Don't retry JSON parsing errors - the data is malformed
+        LlmError::Json(_) => false,
+
+        // Don't retry API errors - these are typically client-side issues
+        LlmError::Api { .. } => false,
+
+        // Provider errors might be transient, but we conservatively don't retry
+        LlmError::Provider(_) => false,
+
+        // Stream errors are typically not retryable
+        LlmError::Stream(_) => false,
+    }
+}
+
+/// Strategy for retrying failed operations with exponential backoff
+#[derive(Debug, Clone)]
+pub struct RetryStrategy {
+    config: RetryConfig,
+}
+
+impl RetryStrategy {
+    /// Create a new retry strategy with the given configuration
+    pub fn new(config: RetryConfig) -> Self {
+        Self { config }
+    }
+
+    /// Create a retry strategy with default configuration
+    pub fn default_config() -> Self {
+        Self::new(RetryConfig::default())
+    }
+
+    /// Execute an async operation with retries
+    ///
+    /// # Arguments
+    /// * `operation` - A function that returns a Future producing a Result
+    ///
+    /// # Returns
+    /// The result of the operation, or the last error if all retries fail
+    ///
+    /// # Example
+    /// ```ignore
+    /// let strategy = RetryStrategy::default_config();
+    /// let result = strategy.execute(|| async {
+    ///     // Your LLM API call here
+    ///     llm_client.chat(&messages, &options, None).await
+    /// }).await?;
+    /// ```
+    pub async fn execute<F, T, Fut>(&self, operation: F) -> Result<T, LlmError>
+    where
+        F: Fn() -> Fut,
+        Fut: std::future::Future<Output = Result<T, LlmError>>,
+    {
+        let mut attempt = 0;
+
+        loop {
+            // Try the operation
+            match operation().await {
+                Ok(result) => return Ok(result),
+                Err(err) => {
+                    // Check if we should retry
+                    if !is_retryable_error(&err) {
+                        return Err(err);
+                    }
+
+                    attempt += 1;
+
+                    // Check if we've exhausted retries
+                    if attempt > self.config.max_retries {
+                        return Err(err);
+                    }
+
+                    // Calculate delay with exponential backoff and jitter
+                    let delay = self.delay_for_attempt(attempt);
+
+                    // Log retry attempt (in a real implementation, you might use tracing)
+                    eprintln!(
+                        "Retry attempt {}/{} after {:?}",
+                        attempt, self.config.max_retries, delay
+                    );
+
+                    // Sleep before next attempt
+                    tokio::time::sleep(delay).await;
+                }
+            }
+        }
+    }
+
+    /// Calculate the delay for a given attempt number with jitter
+    ///
+    /// Uses exponential backoff: delay = initial_delay * (backoff_multiplier ^ (attempt - 1))
+    /// Adds random jitter of ±10% to prevent thundering herd problems
+    ///
+    /// # Arguments
+    /// * `attempt` - The attempt number (1-indexed)
+    ///
+    /// # Returns
+    /// The delay duration to wait before the next retry
+    fn delay_for_attempt(&self, attempt: u32) -> Duration {
+        // Calculate base delay with exponential backoff
+        let base_delay_ms = self.config.initial_delay_ms as f64
+            * self.config.backoff_multiplier.powi((attempt - 1) as i32) as f64;
+
+        // Cap at max_delay_ms
+        let capped_delay_ms = base_delay_ms.min(self.config.max_delay_ms as f64);
+
+        // Add jitter: ±10%
+        let mut rng = rand::thread_rng();
+        let jitter_factor = rng.gen_range(0.9..=1.1);
+        let final_delay_ms = capped_delay_ms * jitter_factor;
+
+        Duration::from_millis(final_delay_ms as u64)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::atomic::{AtomicU32, Ordering};
+    use std::sync::Arc;
+
+    #[test]
+    fn test_default_retry_config() {
+        let config = RetryConfig::default();
+        assert_eq!(config.max_retries, 3);
+        assert_eq!(config.initial_delay_ms, 1000);
+        assert_eq!(config.max_delay_ms, 30000);
+        assert_eq!(config.backoff_multiplier, 2.0);
+    }
+
+    #[test]
+    fn test_no_retry_config() {
+        let config = RetryConfig::no_retry();
+        assert_eq!(config.max_retries, 0);
+    }
+
+    #[test]
+    fn test_is_retryable_error() {
+        // Retryable errors
+        assert!(is_retryable_error(&LlmError::RateLimit {
+            retry_after_secs: Some(60)
+        }));
+        assert!(is_retryable_error(&LlmError::Timeout(
+            "Request timed out".to_string()
+        )));
+        assert!(is_retryable_error(&LlmError::Http(
+            "500 Internal Server Error".to_string()
+        )));
+        assert!(is_retryable_error(&LlmError::Http(
+            "503 Service Unavailable".to_string()
+        )));
+
+        // Non-retryable errors
+        assert!(!is_retryable_error(&LlmError::Auth(
+            "Invalid API key".to_string()
+        )));
+        assert!(!is_retryable_error(&LlmError::Json(
+            "Invalid JSON".to_string()
+        )));
+        assert!(!is_retryable_error(&LlmError::Api {
+            message: "Invalid request".to_string(),
+            code: Some("400".to_string())
+        }));
+        assert!(!is_retryable_error(&LlmError::Http(
+            "400 Bad Request".to_string()
+        )));
+    }
+
+    #[test]
+    fn test_delay_calculation() {
+        let config = RetryConfig::default();
+        let strategy = RetryStrategy::new(config);
+
+        // Test that delays increase exponentially
+        let delay1 = strategy.delay_for_attempt(1);
+        let delay2 = strategy.delay_for_attempt(2);
+        let delay3 = strategy.delay_for_attempt(3);
+
+        // Base delays should be around 1000ms, 2000ms, 4000ms (with jitter)
+        assert!(delay1.as_millis() >= 900 && delay1.as_millis() <= 1100);
+        assert!(delay2.as_millis() >= 1800 && delay2.as_millis() <= 2200);
+        assert!(delay3.as_millis() >= 3600 && delay3.as_millis() <= 4400);
+    }
+
+    #[test]
+    fn test_delay_max_cap() {
+        let config = RetryConfig {
+            max_retries: 10,
+            initial_delay_ms: 1000,
+            max_delay_ms: 5000,
+            backoff_multiplier: 2.0,
+        };
+        let strategy = RetryStrategy::new(config);
+
+        // Even with high attempt numbers, delay should be capped
+        let delay = strategy.delay_for_attempt(10);
+        assert!(delay.as_millis() <= 5500); // max + jitter
+    }
+
+    #[tokio::test]
+    async fn test_retry_success_on_first_attempt() {
+        let strategy = RetryStrategy::default_config();
+        let call_count = Arc::new(AtomicU32::new(0));
+        let count_clone = call_count.clone();
+
+        let result = strategy
+            .execute(|| {
+                let count = count_clone.clone();
+                async move {
+                    count.fetch_add(1, Ordering::SeqCst);
+                    Ok::<_, LlmError>(42)
+                }
+            })
+            .await;
+
+        assert_eq!(result.unwrap(), 42);
+        assert_eq!(call_count.load(Ordering::SeqCst), 1);
+    }
+
+    #[tokio::test]
+    async fn test_retry_success_after_retries() {
+        let config = RetryConfig::new(3, 10, 100, 2.0); // Fast retries for testing
+        let strategy = RetryStrategy::new(config);
+        let call_count = Arc::new(AtomicU32::new(0));
+        let count_clone = call_count.clone();
+
+        let result = strategy
+            .execute(|| {
+                let count = count_clone.clone();
+                async move {
+                    let current = count.fetch_add(1, Ordering::SeqCst) + 1;
+                    if current < 3 {
+                        Err(LlmError::Timeout("Timeout".to_string()))
+                    } else {
+                        Ok(42)
+                    }
+                }
+            })
+            .await;
+
+        assert_eq!(result.unwrap(), 42);
+        assert_eq!(call_count.load(Ordering::SeqCst), 3);
+    }
+
+    #[tokio::test]
+    async fn test_retry_exhausted() {
+        let config = RetryConfig::new(2, 10, 100, 2.0); // Fast retries for testing
+        let strategy = RetryStrategy::new(config);
+        let call_count = Arc::new(AtomicU32::new(0));
+        let count_clone = call_count.clone();
+
+        let result = strategy
+            .execute(|| {
+                let count = count_clone.clone();
+                async move {
+                    count.fetch_add(1, Ordering::SeqCst);
+                    Err::<(), _>(LlmError::Timeout("Always fails".to_string()))
+                }
+            })
+            .await;
+
+        assert!(result.is_err());
+        assert_eq!(call_count.load(Ordering::SeqCst), 3); // Initial attempt + 2 retries
+    }
+
+    #[tokio::test]
+    async fn test_non_retryable_error() {
+        let strategy = RetryStrategy::default_config();
+        let call_count = Arc::new(AtomicU32::new(0));
+        let count_clone = call_count.clone();
+
+        let result = strategy
+            .execute(|| {
+                let count = count_clone.clone();
+                async move {
+                    count.fetch_add(1, Ordering::SeqCst);
+                    Err::<(), _>(LlmError::Auth("Invalid API key".to_string()))
+                }
+            })
+            .await;
+
+        assert!(result.is_err());
+        assert_eq!(call_count.load(Ordering::SeqCst), 1); // Should not retry
+    }
+}

crates/llm/core/src/tokens.rs

@@ -0,0 +1,607 @@
+//! Token counting utilities for LLM context management
+//!
+//! This module provides token counting abstractions and implementations for
+//! managing LLM context windows. Token counters estimate token usage without
+//! requiring external tokenization libraries, using heuristic-based approaches.
+
+use crate::ChatMessage;
+
+// ============================================================================
+// TokenCounter Trait
+// ============================================================================
+
+/// Trait for counting tokens in text and chat messages
+///
+/// Implementations provide model-specific token counting logic to help
+/// manage context windows and estimate API costs.
+pub trait TokenCounter: Send + Sync {
+    /// Count tokens in a string
+    ///
+    /// # Arguments
+    /// * `text` - The text to count tokens for
+    ///
+    /// # Returns
+    /// Estimated number of tokens
+    fn count(&self, text: &str) -> usize;
+
+    /// Count tokens in chat messages
+    ///
+    /// This accounts for both the message content and the overhead
+    /// from the chat message structure (roles, delimiters, etc.).
+    ///
+    /// # Arguments
+    /// * `messages` - The messages to count tokens for
+    ///
+    /// # Returns
+    /// Estimated total tokens including message structure overhead
+    fn count_messages(&self, messages: &[ChatMessage]) -> usize;
+
+    /// Get the model's max context window size
+    ///
+    /// # Returns
+    /// Maximum number of tokens the model can handle
+    fn max_context(&self) -> usize;
+}
+
+// ============================================================================
+// SimpleTokenCounter
+// ============================================================================
+
+/// A basic token counter using simple heuristics
+///
+/// This counter uses the rule of thumb that English text averages about
+/// 4 characters per token. It adds overhead for message structure.
+///
+/// # Example
+/// ```
+/// use llm_core::tokens::{TokenCounter, SimpleTokenCounter};
+/// use llm_core::ChatMessage;
+///
+/// let counter = SimpleTokenCounter::new(8192);
+/// let text = "Hello, world!";
+/// let tokens = counter.count(text);
+/// assert!(tokens > 0);
+///
+/// let messages = vec![
+///     ChatMessage::user("What is the weather?"),
+///     ChatMessage::assistant("I don't have access to weather data."),
+/// ];
+/// let total = counter.count_messages(&messages);
+/// assert!(total > 0);
+/// ```
+#[derive(Debug, Clone)]
+pub struct SimpleTokenCounter {
+    max_context: usize,
+}
+
+impl SimpleTokenCounter {
+    /// Create a new simple token counter
+    ///
+    /// # Arguments
+    /// * `max_context` - Maximum context window size for the model
+    pub fn new(max_context: usize) -> Self {
+        Self { max_context }
+    }
+
+    /// Create a token counter with a default 8192 token context
+    pub fn default_8k() -> Self {
+        Self::new(8192)
+    }
+
+    /// Create a token counter with a 32k token context
+    pub fn with_32k() -> Self {
+        Self::new(32768)
+    }
+
+    /// Create a token counter with a 128k token context
+    pub fn with_128k() -> Self {
+        Self::new(131072)
+    }
+}
+
+impl TokenCounter for SimpleTokenCounter {
+    fn count(&self, text: &str) -> usize {
+        // Estimate: approximately 4 characters per token for English
+        // Add 3 before dividing to round up
+        (text.len() + 3) / 4
+    }
+
+    fn count_messages(&self, messages: &[ChatMessage]) -> usize {
+        let mut total = 0;
+
+        // Base overhead for message formatting (estimated)
+        // Each message has role, delimiters, etc.
+        const MESSAGE_OVERHEAD: usize = 4;
+
+        for msg in messages {
+            // Count role
+            total += MESSAGE_OVERHEAD;
+
+            // Count content
+            if let Some(content) = &msg.content {
+                total += self.count(content);
+            }
+
+            // Count tool calls (more expensive due to JSON structure)
+            if let Some(tool_calls) = &msg.tool_calls {
+                for tc in tool_calls {
+                    // ID overhead
+                    total += self.count(&tc.id);
+                    // Function name
+                    total += self.count(&tc.function.name);
+                    // Arguments (JSON serialized, add 20% overhead for JSON structure)
+                    let args_str = tc.function.arguments.to_string();
+                    total += (self.count(&args_str) * 12) / 10;
+                }
+            }
+
+            // Count tool call id for tool result messages
+            if let Some(tool_call_id) = &msg.tool_call_id {
+                total += self.count(tool_call_id);
+            }
+
+            // Count tool name for tool result messages
+            if let Some(name) = &msg.name {
+                total += self.count(name);
+            }
+        }
+
+        total
+    }
+
+    fn max_context(&self) -> usize {
+        self.max_context
+    }
+}
+
+// ============================================================================
+// ClaudeTokenCounter
+// ============================================================================
+
+/// Token counter optimized for Anthropic Claude models
+///
+/// Claude models have specific tokenization characteristics and overhead.
+/// This counter adjusts the estimates accordingly.
+///
+/// # Example
+/// ```
+/// use llm_core::tokens::{TokenCounter, ClaudeTokenCounter};
+/// use llm_core::ChatMessage;
+///
+/// let counter = ClaudeTokenCounter::new();
+/// let messages = vec![
+///     ChatMessage::system("You are a helpful assistant."),
+///     ChatMessage::user("Hello!"),
+/// ];
+/// let total = counter.count_messages(&messages);
+/// ```
+#[derive(Debug, Clone)]
+pub struct ClaudeTokenCounter {
+    max_context: usize,
+}
+
+impl ClaudeTokenCounter {
+    /// Create a new Claude token counter with default 200k context
+    ///
+    /// This is suitable for Claude 3.5 Sonnet, Claude 4 Sonnet, and Claude 4 Opus.
+    pub fn new() -> Self {
+        Self {
+            max_context: 200_000,
+        }
+    }
+
+    /// Create a Claude counter with a custom context window
+    ///
+    /// # Arguments
+    /// * `max_context` - Maximum context window size
+    pub fn with_context(max_context: usize) -> Self {
+        Self { max_context }
+    }
+
+    /// Create a counter for Claude 3 Haiku (200k context)
+    pub fn haiku() -> Self {
+        Self::new()
+    }
+
+    /// Create a counter for Claude 3.5 Sonnet (200k context)
+    pub fn sonnet() -> Self {
+        Self::new()
+    }
+
+    /// Create a counter for Claude 4 Opus (200k context)
+    pub fn opus() -> Self {
+        Self::new()
+    }
+}
+
+impl Default for ClaudeTokenCounter {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl TokenCounter for ClaudeTokenCounter {
+    fn count(&self, text: &str) -> usize {
+        // Claude's tokenization is similar to the 4 chars/token heuristic
+        // but tends to be slightly more efficient with structured content
+        (text.len() + 3) / 4
+    }
+
+    fn count_messages(&self, messages: &[ChatMessage]) -> usize {
+        let mut total = 0;
+
+        // Claude has specific message formatting overhead
+        const MESSAGE_OVERHEAD: usize = 5;
+        const SYSTEM_MESSAGE_OVERHEAD: usize = 3;
+
+        for msg in messages {
+            // Different overhead for system vs other messages
+            let overhead = if matches!(msg.role, crate::Role::System) {
+                SYSTEM_MESSAGE_OVERHEAD
+            } else {
+                MESSAGE_OVERHEAD
+            };
+
+            total += overhead;
+
+            // Count content
+            if let Some(content) = &msg.content {
+                total += self.count(content);
+            }
+
+            // Count tool calls
+            if let Some(tool_calls) = &msg.tool_calls {
+                // Claude's tool call format has additional overhead
+                const TOOL_CALL_OVERHEAD: usize = 10;
+
+                for tc in tool_calls {
+                    total += TOOL_CALL_OVERHEAD;
+                    total += self.count(&tc.id);
+                    total += self.count(&tc.function.name);
+
+                    // Arguments with JSON structure overhead
+                    let args_str = tc.function.arguments.to_string();
+                    total += (self.count(&args_str) * 12) / 10;
+                }
+            }
+
+            // Tool result overhead
+            if msg.tool_call_id.is_some() {
+                const TOOL_RESULT_OVERHEAD: usize = 8;
+                total += TOOL_RESULT_OVERHEAD;
+
+                if let Some(tool_call_id) = &msg.tool_call_id {
+                    total += self.count(tool_call_id);
+                }
+
+                if let Some(name) = &msg.name {
+                    total += self.count(name);
+                }
+            }
+        }
+
+        total
+    }
+
+    fn max_context(&self) -> usize {
+        self.max_context
+    }
+}
+
+// ============================================================================
+// ContextWindow
+// ============================================================================
+
+/// Manages context window tracking for a conversation
+///
+/// Helps monitor token usage and determine when context limits are approaching.
+///
+/// # Example
+/// ```
+/// use llm_core::tokens::{ContextWindow, TokenCounter, SimpleTokenCounter};
+/// use llm_core::ChatMessage;
+///
+/// let counter = SimpleTokenCounter::new(8192);
+/// let mut window = ContextWindow::new(counter.max_context());
+///
+/// let messages = vec![
+///     ChatMessage::user("Hello!"),
+///     ChatMessage::assistant("Hi there!"),
+/// ];
+///
+/// let tokens = counter.count_messages(&messages);
+/// window.add_tokens(tokens);
+///
+/// println!("Used: {} tokens", window.used());
+/// println!("Remaining: {} tokens", window.remaining());
+/// println!("Usage: {:.1}%", window.usage_percent() * 100.0);
+///
+/// if window.is_near_limit(0.8) {
+///     println!("Warning: Context is 80% full!");
+/// }
+/// ```
+#[derive(Debug, Clone)]
+pub struct ContextWindow {
+    /// Number of tokens currently used
+    used: usize,
+    /// Maximum number of tokens allowed
+    max: usize,
+}
+
+impl ContextWindow {
+    /// Create a new context window tracker
+    ///
+    /// # Arguments
+    /// * `max` - Maximum context window size in tokens
+    pub fn new(max: usize) -> Self {
+        Self { used: 0, max }
+    }
+
+    /// Create a context window with initial usage
+    ///
+    /// # Arguments
+    /// * `max` - Maximum context window size
+    /// * `used` - Initial number of tokens used
+    pub fn with_usage(max: usize, used: usize) -> Self {
+        Self { used, max }
+    }
+
+    /// Get the number of tokens currently used
+    pub fn used(&self) -> usize {
+        self.used
+    }
+
+    /// Get the maximum number of tokens
+    pub fn max(&self) -> usize {
+        self.max
+    }
+
+    /// Get the number of remaining tokens
+    pub fn remaining(&self) -> usize {
+        self.max.saturating_sub(self.used)
+    }
+
+    /// Get the usage as a percentage (0.0 to 1.0)
+    ///
+    /// Returns the fraction of the context window that is currently used.
+    pub fn usage_percent(&self) -> f32 {
+        if self.max == 0 {
+            return 0.0;
+        }
+        self.used as f32 / self.max as f32
+    }
+
+    /// Check if usage is near the limit
+    ///
+    /// # Arguments
+    /// * `threshold` - Threshold as a fraction (0.0 to 1.0). For example,
+    ///   0.8 means "is usage > 80%?"
+    ///
+    /// # Returns
+    /// `true` if the current usage exceeds the threshold percentage
+    pub fn is_near_limit(&self, threshold: f32) -> bool {
+        self.usage_percent() > threshold
+    }
+
+    /// Add tokens to the usage count
+    ///
+    /// # Arguments
+    /// * `tokens` - Number of tokens to add
+    pub fn add_tokens(&mut self, tokens: usize) {
+        self.used = self.used.saturating_add(tokens);
+    }
+
+    /// Set the current usage
+    ///
+    /// # Arguments
+    /// * `used` - Number of tokens currently used
+    pub fn set_used(&mut self, used: usize) {
+        self.used = used;
+    }
+
+    /// Reset the usage counter to zero
+    pub fn reset(&mut self) {
+        self.used = 0;
+    }
+
+    /// Check if there's enough room for additional tokens
+    ///
+    /// # Arguments
+    /// * `tokens` - Number of tokens needed
+    ///
+    /// # Returns
+    /// `true` if adding these tokens would stay within the limit
+    pub fn has_room_for(&self, tokens: usize) -> bool {
+        self.used.saturating_add(tokens) <= self.max
+    }
+
+    /// Get a visual progress bar representation
+    ///
+    /// # Arguments
+    /// * `width` - Width of the progress bar in characters
+    ///
+    /// # Returns
+    /// A string with a simple text-based progress bar
+    pub fn progress_bar(&self, width: usize) -> String {
+        if width == 0 {
+            return String::new();
+        }
+
+        let percent = self.usage_percent();
+        let filled = ((percent * width as f32) as usize).min(width);
+        let empty = width - filled;
+
+        format!(
+            "[{}{}] {:.1}%",
+            "=".repeat(filled),
+            " ".repeat(empty),
+            percent * 100.0
+        )
+    }
+}
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{ChatMessage, FunctionCall, ToolCall};
+    use serde_json::json;
+
+    #[test]
+    fn test_simple_counter_basic() {
+        let counter = SimpleTokenCounter::new(8192);
+
+        // Empty string
+        assert_eq!(counter.count(""), 0);
+
+        // Short string (~4 chars/token)
+        let text = "Hello, world!"; // 13 chars -> ~4 tokens
+        let count = counter.count(text);
+        assert!(count >= 3 && count <= 5);
+
+        // Longer text
+        let text = "The quick brown fox jumps over the lazy dog"; // 44 chars -> ~11 tokens
+        let count = counter.count(text);
+        assert!(count >= 10 && count <= 13);
+    }
+
+    #[test]
+    fn test_simple_counter_messages() {
+        let counter = SimpleTokenCounter::new(8192);
+
+        let messages = vec![
+            ChatMessage::user("Hello!"),
+            ChatMessage::assistant("Hi there! How can I help you today?"),
+        ];
+
+        let total = counter.count_messages(&messages);
+
+        // Should be more than just the text due to overhead
+        let text_only = counter.count("Hello!") + counter.count("Hi there! How can I help you today?");
+        assert!(total > text_only);
+    }
+
+    #[test]
+    fn test_simple_counter_with_tool_calls() {
+        let counter = SimpleTokenCounter::new(8192);
+
+        let tool_call = ToolCall {
+            id: "call_123".to_string(),
+            call_type: "function".to_string(),
+            function: FunctionCall {
+                name: "read_file".to_string(),
+                arguments: json!({"path": "/etc/hosts"}),
+            },
+        };
+
+        let messages = vec![ChatMessage::assistant_tool_calls(vec![tool_call])];
+
+        let total = counter.count_messages(&messages);
+        assert!(total > 0);
+    }
+
+    #[test]
+    fn test_claude_counter() {
+        let counter = ClaudeTokenCounter::new();
+
+        assert_eq!(counter.max_context(), 200_000);
+
+        let text = "Hello, Claude!";
+        let count = counter.count(text);
+        assert!(count > 0);
+    }
+
+    #[test]
+    fn test_claude_counter_system_message() {
+        let counter = ClaudeTokenCounter::new();
+
+        let messages = vec![
+            ChatMessage::system("You are a helpful assistant."),
+            ChatMessage::user("Hello!"),
+        ];
+
+        let total = counter.count_messages(&messages);
+        assert!(total > 0);
+    }
+
+    #[test]
+    fn test_context_window() {
+        let mut window = ContextWindow::new(1000);
+
+        assert_eq!(window.used(), 0);
+        assert_eq!(window.max(), 1000);
+        assert_eq!(window.remaining(), 1000);
+        assert_eq!(window.usage_percent(), 0.0);
+
+        window.add_tokens(200);
+        assert_eq!(window.used(), 200);
+        assert_eq!(window.remaining(), 800);
+        assert_eq!(window.usage_percent(), 0.2);
+
+        window.add_tokens(600);
+        assert_eq!(window.used(), 800);
+        assert!(window.is_near_limit(0.7));
+        assert!(!window.is_near_limit(0.9));
+
+        assert!(window.has_room_for(200));
+        assert!(!window.has_room_for(300));
+
+        window.reset();
+        assert_eq!(window.used(), 0);
+    }
+
+    #[test]
+    fn test_context_window_progress_bar() {
+        let mut window = ContextWindow::new(100);
+
+        window.add_tokens(50);
+        let bar = window.progress_bar(10);
+        assert!(bar.contains("====="));
+        assert!(bar.contains("50.0%"));
+
+        window.add_tokens(40);
+        let bar = window.progress_bar(10);
+        assert!(bar.contains("========="));
+        assert!(bar.contains("90.0%"));
+    }
+
+    #[test]
+    fn test_context_window_saturation() {
+        let mut window = ContextWindow::new(100);
+
+        // Adding more tokens than max should saturate, not overflow
+        window.add_tokens(150);
+        assert_eq!(window.used(), 150);
+        assert_eq!(window.remaining(), 0);
+    }
+
+    #[test]
+    fn test_simple_counter_constructors() {
+        let counter1 = SimpleTokenCounter::default_8k();
+        assert_eq!(counter1.max_context(), 8192);
+
+        let counter2 = SimpleTokenCounter::with_32k();
+        assert_eq!(counter2.max_context(), 32768);
+
+        let counter3 = SimpleTokenCounter::with_128k();
+        assert_eq!(counter3.max_context(), 131072);
+    }
+
+    #[test]
+    fn test_claude_counter_variants() {
+        let haiku = ClaudeTokenCounter::haiku();
+        assert_eq!(haiku.max_context(), 200_000);
+
+        let sonnet = ClaudeTokenCounter::sonnet();
+        assert_eq!(sonnet.max_context(), 200_000);
+
+        let opus = ClaudeTokenCounter::opus();
+        assert_eq!(opus.max_context(), 200_000);
+
+        let custom = ClaudeTokenCounter::with_context(100_000);
+        assert_eq!(custom.max_context(), 100_000);
+    }
+}

crates/llm/ollama/Cargo.toml

@@ -6,11 +6,13 @@ license.workspace = true
 rust-version.workspace = true
 
 [dependencies]
+llm-core = { path = "../core" }
 reqwest = { version = "0.12", features = ["json", "stream"] }
-tokio = { version = "1.39", features = ["rt-multi-thread"] }
+tokio = { version = "1.39", features = ["rt-multi-thread", "macros"] }
 futures = "0.3"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 thiserror = "1"
 bytes = "1"
 tokio-stream = "0.1.17"
+async-trait = "0.1"

crates/llm/ollama/src/client.rs

@@ -1,14 +1,20 @@
 use crate::types::{ChatMessage, ChatResponseChunk, Tool};
-use futures::{Stream, TryStreamExt};
+use futures::{Stream, StreamExt, TryStreamExt};
 use reqwest::Client;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use thiserror::Error;
+use async_trait::async_trait;
+use llm_core::{
+    LlmProvider, ProviderInfo, LlmError, ChatOptions, ChunkStream,
+    ProviderStatus, AccountInfo, UsageStats, ModelInfo,
+};
 
 #[derive(Debug, Clone)]
 pub struct OllamaClient {
     http: Client,
     base_url: String,  // e.g. "http://localhost:11434"
     api_key: Option<String>,  // For Ollama Cloud authentication
+    current_model: String,  // Default model for this client
 }
 
 #[derive(Debug, Clone, Default)]
@@ -27,12 +33,24 @@ pub enum OllamaError {
     Protocol(String),
 }
 
+// Convert OllamaError to LlmError
+impl From<OllamaError> for LlmError {
+    fn from(err: OllamaError) -> Self {
+        match err {
+            OllamaError::Http(e) => LlmError::Http(e.to_string()),
+            OllamaError::Json(e) => LlmError::Json(e.to_string()),
+            OllamaError::Protocol(msg) => LlmError::Provider(msg),
+        }
+    }
+}
+
 impl OllamaClient {
     pub fn new(base_url: impl Into<String>) -> Self {
         Self {
             http: Client::new(),
             base_url: base_url.into().trim_end_matches('/').to_string(),
             api_key: None,
+            current_model: "qwen3:8b".to_string(),
         }
     }
 
@@ -41,12 +59,17 @@ impl OllamaClient {
         self
     }
 
+    pub fn with_model(mut self, model: impl Into<String>) -> Self {
+        self.current_model = model.into();
+        self
+    }
+
     pub fn with_cloud() -> Self {
         // Same API, different base
         Self::new("https://ollama.com")
     }
 
-    pub async fn chat_stream(
+    pub async fn chat_stream_raw(
         &self,
         messages: &[ChatMessage],
         opts: &OllamaOptions,
@@ -99,3 +122,208 @@ impl OllamaClient {
         Ok(out)
     }
 }
+
+// ============================================================================
+// LlmProvider Trait Implementation
+// ============================================================================
+
+#[async_trait]
+impl LlmProvider for OllamaClient {
+    fn name(&self) -> &str {
+        "ollama"
+    }
+
+    fn model(&self) -> &str {
+        &self.current_model
+    }
+
+    async fn chat_stream(
+        &self,
+        messages: &[llm_core::ChatMessage],
+        options: &ChatOptions,
+        tools: Option<&[llm_core::Tool]>,
+    ) -> Result<ChunkStream, LlmError> {
+        // Convert llm_core messages to Ollama messages
+        let ollama_messages: Vec<ChatMessage> = messages.iter().map(|m| m.into()).collect();
+
+        // Convert llm_core tools to Ollama tools if present
+        let ollama_tools: Option<Vec<Tool>> = tools.map(|tools| {
+            tools.iter().map(|t| Tool {
+                tool_type: t.tool_type.clone(),
+                function: crate::types::ToolFunction {
+                    name: t.function.name.clone(),
+                    description: t.function.description.clone(),
+                    parameters: crate::types::ToolParameters {
+                        param_type: t.function.parameters.param_type.clone(),
+                        properties: t.function.parameters.properties.clone(),
+                        required: t.function.parameters.required.clone(),
+                    },
+                },
+            }).collect()
+        });
+
+        let opts = OllamaOptions {
+            model: options.model.clone(),
+            stream: true,
+        };
+
+        // Make the request and build the body inline to avoid lifetime issues
+        #[derive(Serialize)]
+        struct Body<'a> {
+            model: &'a str,
+            messages: &'a [ChatMessage],
+            stream: bool,
+            #[serde(skip_serializing_if = "Option::is_none")]
+            tools: Option<&'a [Tool]>,
+        }
+
+        let url = format!("{}/api/chat", self.base_url);
+        let body = Body {
+            model: &opts.model,
+            messages: &ollama_messages,
+            stream: true,
+            tools: ollama_tools.as_deref(),
+        };
+
+        let mut req = self.http.post(url).json(&body);
+
+        // Add Authorization header if API key is present
+        if let Some(ref key) = self.api_key {
+            req = req.header("Authorization", format!("Bearer {}", key));
+        }
+
+        let resp = req.send().await
+            .map_err(|e| LlmError::Http(e.to_string()))?;
+        let bytes_stream = resp.bytes_stream();
+
+        // NDJSON parser: split by '\n', parse each as JSON and stream the results
+        let converted_stream = bytes_stream
+            .map(|result| {
+                result.map_err(|e| LlmError::Http(e.to_string()))
+            })
+            .map_ok(|bytes| {
+                // Convert the chunk to a UTF-8 string and own it
+                let txt = String::from_utf8_lossy(&bytes).into_owned();
+                // Parse each non-empty line into a ChatResponseChunk
+                let results: Vec<Result<llm_core::StreamChunk, LlmError>> = txt
+                    .lines()
+                    .filter_map(|line| {
+                        let trimmed = line.trim();
+                        if trimmed.is_empty() {
+                            None
+                        } else {
+                            Some(
+                                serde_json::from_str::<ChatResponseChunk>(trimmed)
+                                    .map(|chunk| llm_core::StreamChunk::from(chunk))
+                                    .map_err(|e| LlmError::Json(e.to_string())),
+                            )
+                        }
+                    })
+                    .collect();
+                futures::stream::iter(results)
+            })
+            .try_flatten();
+
+        Ok(Box::pin(converted_stream))
+    }
+}
+
+// ============================================================================
+// ProviderInfo Trait Implementation
+// ============================================================================
+
+#[derive(Debug, Clone, Deserialize)]
+struct OllamaModelList {
+    models: Vec<OllamaModel>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+struct OllamaModel {
+    name: String,
+    #[serde(default)]
+    modified_at: Option<String>,
+    #[serde(default)]
+    size: Option<u64>,
+    #[serde(default)]
+    digest: Option<String>,
+    #[serde(default)]
+    details: Option<OllamaModelDetails>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+struct OllamaModelDetails {
+    #[serde(default)]
+    format: Option<String>,
+    #[serde(default)]
+    family: Option<String>,
+    #[serde(default)]
+    parameter_size: Option<String>,
+}
+
+#[async_trait]
+impl ProviderInfo for OllamaClient {
+    async fn status(&self) -> Result<ProviderStatus, LlmError> {
+        // Try to ping the Ollama server
+        let url = format!("{}/api/tags", self.base_url);
+        let reachable = self.http.get(&url).send().await.is_ok();
+
+        Ok(ProviderStatus {
+            provider: "ollama".to_string(),
+            authenticated: self.api_key.is_some(),
+            account: None, // Ollama is local, no account info
+            model: self.current_model.clone(),
+            endpoint: self.base_url.clone(),
+            reachable,
+            message: if reachable {
+                Some("Connected to Ollama".to_string())
+            } else {
+                Some("Cannot reach Ollama server".to_string())
+            },
+        })
+    }
+
+    async fn account_info(&self) -> Result<Option<AccountInfo>, LlmError> {
+        // Ollama is a local service, no account info
+        Ok(None)
+    }
+
+    async fn usage_stats(&self) -> Result<Option<UsageStats>, LlmError> {
+        // Ollama doesn't track usage statistics
+        Ok(None)
+    }
+
+    async fn list_models(&self) -> Result<Vec<ModelInfo>, LlmError> {
+        let url = format!("{}/api/tags", self.base_url);
+        let mut req = self.http.get(&url);
+
+        // Add Authorization header if API key is present
+        if let Some(ref key) = self.api_key {
+            req = req.header("Authorization", format!("Bearer {}", key));
+        }
+
+        let resp = req.send().await
+            .map_err(|e| LlmError::Http(e.to_string()))?;
+
+        let model_list: OllamaModelList = resp.json().await
+            .map_err(|e| LlmError::Json(e.to_string()))?;
+
+        // Convert Ollama models to ModelInfo
+        let models = model_list.models.into_iter().map(|m| {
+            ModelInfo {
+                id: m.name.clone(),
+                display_name: Some(m.name.clone()),
+                description: m.details.as_ref()
+                    .and_then(|d| d.family.as_ref())
+                    .map(|f| format!("{} model", f)),
+                context_window: None, // Ollama doesn't provide this in list
+                max_output_tokens: None,
+                supports_tools: true, // Most Ollama models support tools
+                supports_vision: false, // Would need to check model capabilities
+                input_price_per_mtok: None, // Local models are free
+                output_price_per_mtok: None,
+            }
+        }).collect();
+
+        Ok(models)
+    }
+}

crates/llm/ollama/src/lib.rs

@@ -1,5 +1,13 @@
 pub mod client;
 pub mod types;
 
-pub use client::{OllamaClient, OllamaOptions};
+pub use client::{OllamaClient, OllamaOptions, OllamaError};
 pub use types::{ChatMessage, ChatResponseChunk, Tool, ToolCall, ToolFunction, ToolParameters, FunctionCall};
+
+// Re-export llm-core traits and types for convenience
+pub use llm_core::{
+    LlmProvider, ProviderInfo, LlmError,
+    ChatOptions, StreamChunk, ToolCallDelta, Usage,
+    ProviderStatus, AccountInfo, UsageStats, ModelInfo,
+    Role,
+};

crates/llm/ollama/src/types.rs

@@ -1,5 +1,6 @@
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
+use llm_core::{StreamChunk, ToolCallDelta};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ChatMessage {
@@ -63,3 +64,67 @@ pub struct ChunkMessage {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub tool_calls: Option<Vec<ToolCall>>,
 }
+
+// ============================================================================
+// Conversions to/from llm-core types
+// ============================================================================
+
+/// Convert from llm_core::ChatMessage to Ollama's ChatMessage
+impl From<&llm_core::ChatMessage> for ChatMessage {
+    fn from(msg: &llm_core::ChatMessage) -> Self {
+        let role = msg.role.as_str().to_string();
+
+        // Convert tool_calls if present
+        let tool_calls = msg.tool_calls.as_ref().map(|calls| {
+            calls.iter().map(|tc| ToolCall {
+                id: Some(tc.id.clone()),
+                call_type: Some(tc.call_type.clone()),
+                function: FunctionCall {
+                    name: tc.function.name.clone(),
+                    arguments: tc.function.arguments.clone(),
+                },
+            }).collect()
+        });
+
+        ChatMessage {
+            role,
+            content: msg.content.clone(),
+            tool_calls,
+        }
+    }
+}
+
+/// Convert from Ollama's ChatResponseChunk to llm_core::StreamChunk
+impl From<ChatResponseChunk> for StreamChunk {
+    fn from(chunk: ChatResponseChunk) -> Self {
+        let done = chunk.done.unwrap_or(false);
+        let content = chunk.message.as_ref().and_then(|m| m.content.clone());
+
+        // Convert tool calls to deltas
+        let tool_calls = chunk.message.as_ref().and_then(|m| {
+            m.tool_calls.as_ref().map(|calls| {
+                calls.iter().enumerate().map(|(index, tc)| {
+                    // Serialize arguments back to JSON string for delta
+                    let arguments_delta = serde_json::to_string(&tc.function.arguments).ok();
+
+                    ToolCallDelta {
+                        index,
+                        id: tc.id.clone(),
+                        function_name: Some(tc.function.name.clone()),
+                        arguments_delta,
+                    }
+                }).collect()
+            })
+        });
+
+        // Ollama doesn't provide per-chunk usage stats, only in final chunk
+        let usage = None;
+
+        StreamChunk {
+            content,
+            tool_calls,
+            done,
+            usage,
+        }
+    }
+}

crates/llm/openai/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "llm-openai"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+description = "OpenAI GPT API client for Owlen"
+
+[dependencies]
+llm-core = { path = "../core" }
+async-trait = "0.1"
+futures = "0.3"
+reqwest = { version = "0.12", features = ["json", "stream"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+tokio = { version = "1", features = ["sync", "time", "io-util"] }
+tokio-stream = { version = "0.1", default-features = false, features = ["io-util"] }
+tokio-util = { version = "0.7", features = ["codec", "io"] }
+tracing = "0.1"

crates/llm/openai/src/auth.rs

@@ -0,0 +1,285 @@
+//! OpenAI OAuth Authentication
+//!
+//! Implements device code flow for authenticating with OpenAI without API keys.
+
+use llm_core::{AuthMethod, DeviceAuthResult, DeviceCodeResponse, LlmError, OAuthProvider};
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+
+/// OAuth client for OpenAI device flow
+pub struct OpenAIAuth {
+    http: Client,
+    client_id: String,
+}
+
+// OpenAI OAuth endpoints
+const AUTH_BASE_URL: &str = "https://auth.openai.com";
+const DEVICE_CODE_ENDPOINT: &str = "/oauth/device/code";
+const TOKEN_ENDPOINT: &str = "/oauth/token";
+
+// Default client ID for Owlen CLI
+const DEFAULT_CLIENT_ID: &str = "owlen-cli";
+
+impl OpenAIAuth {
+    /// Create a new OAuth client with the default CLI client ID
+    pub fn new() -> Self {
+        Self {
+            http: Client::new(),
+            client_id: DEFAULT_CLIENT_ID.to_string(),
+        }
+    }
+
+    /// Create with a custom client ID
+    pub fn with_client_id(client_id: impl Into<String>) -> Self {
+        Self {
+            http: Client::new(),
+            client_id: client_id.into(),
+        }
+    }
+}
+
+impl Default for OpenAIAuth {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[derive(Debug, Serialize)]
+struct DeviceCodeRequest<'a> {
+    client_id: &'a str,
+    scope: &'a str,
+}
+
+#[derive(Debug, Deserialize)]
+struct DeviceCodeApiResponse {
+    device_code: String,
+    user_code: String,
+    verification_uri: String,
+    verification_uri_complete: Option<String>,
+    expires_in: u64,
+    interval: u64,
+}
+
+#[derive(Debug, Serialize)]
+struct TokenRequest<'a> {
+    client_id: &'a str,
+    device_code: &'a str,
+    grant_type: &'a str,
+}
+
+#[derive(Debug, Deserialize)]
+struct TokenApiResponse {
+    access_token: String,
+    #[allow(dead_code)]
+    token_type: String,
+    expires_in: Option<u64>,
+    refresh_token: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct TokenErrorResponse {
+    error: String,
+    error_description: Option<String>,
+}
+
+#[async_trait::async_trait]
+impl OAuthProvider for OpenAIAuth {
+    async fn start_device_auth(&self) -> Result<DeviceCodeResponse, LlmError> {
+        let url = format!("{}{}", AUTH_BASE_URL, DEVICE_CODE_ENDPOINT);
+
+        let request = DeviceCodeRequest {
+            client_id: &self.client_id,
+            scope: "api.read api.write",
+        };
+
+        let response = self
+            .http
+            .post(&url)
+            .json(&request)
+            .send()
+            .await
+            .map_err(|e| LlmError::Http(e.to_string()))?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let text = response
+                .text()
+                .await
+                .unwrap_or_else(|_| "Unknown error".to_string());
+            return Err(LlmError::Auth(format!(
+                "Device code request failed ({}): {}",
+                status, text
+            )));
+        }
+
+        let api_response: DeviceCodeApiResponse = response
+            .json()
+            .await
+            .map_err(|e| LlmError::Json(e.to_string()))?;
+
+        Ok(DeviceCodeResponse {
+            device_code: api_response.device_code,
+            user_code: api_response.user_code,
+            verification_uri: api_response.verification_uri,
+            verification_uri_complete: api_response.verification_uri_complete,
+            expires_in: api_response.expires_in,
+            interval: api_response.interval,
+        })
+    }
+
+    async fn poll_device_auth(&self, device_code: &str) -> Result<DeviceAuthResult, LlmError> {
+        let url = format!("{}{}", AUTH_BASE_URL, TOKEN_ENDPOINT);
+
+        let request = TokenRequest {
+            client_id: &self.client_id,
+            device_code,
+            grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        };
+
+        let response = self
+            .http
+            .post(&url)
+            .json(&request)
+            .send()
+            .await
+            .map_err(|e| LlmError::Http(e.to_string()))?;
+
+        if response.status().is_success() {
+            let token_response: TokenApiResponse = response
+                .json()
+                .await
+                .map_err(|e| LlmError::Json(e.to_string()))?;
+
+            return Ok(DeviceAuthResult::Success {
+                access_token: token_response.access_token,
+                refresh_token: token_response.refresh_token,
+                expires_in: token_response.expires_in,
+            });
+        }
+
+        // Parse error response
+        let error_response: TokenErrorResponse = response
+            .json()
+            .await
+            .map_err(|e| LlmError::Json(e.to_string()))?;
+
+        match error_response.error.as_str() {
+            "authorization_pending" => Ok(DeviceAuthResult::Pending),
+            "slow_down" => Ok(DeviceAuthResult::Pending),
+            "access_denied" => Ok(DeviceAuthResult::Denied),
+            "expired_token" => Ok(DeviceAuthResult::Expired),
+            _ => Err(LlmError::Auth(format!(
+                "Token request failed: {} - {}",
+                error_response.error,
+                error_response.error_description.unwrap_or_default()
+            ))),
+        }
+    }
+
+    async fn refresh_token(&self, refresh_token: &str) -> Result<AuthMethod, LlmError> {
+        let url = format!("{}{}", AUTH_BASE_URL, TOKEN_ENDPOINT);
+
+        #[derive(Serialize)]
+        struct RefreshRequest<'a> {
+            client_id: &'a str,
+            refresh_token: &'a str,
+            grant_type: &'a str,
+        }
+
+        let request = RefreshRequest {
+            client_id: &self.client_id,
+            refresh_token,
+            grant_type: "refresh_token",
+        };
+
+        let response = self
+            .http
+            .post(&url)
+            .json(&request)
+            .send()
+            .await
+            .map_err(|e| LlmError::Http(e.to_string()))?;
+
+        if !response.status().is_success() {
+            let text = response
+                .text()
+                .await
+                .unwrap_or_else(|_| "Unknown error".to_string());
+            return Err(LlmError::Auth(format!("Token refresh failed: {}", text)));
+        }
+
+        let token_response: TokenApiResponse = response
+            .json()
+            .await
+            .map_err(|e| LlmError::Json(e.to_string()))?;
+
+        let expires_at = token_response.expires_in.map(|secs| {
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .map(|d| d.as_secs() + secs)
+                .unwrap_or(0)
+        });
+
+        Ok(AuthMethod::OAuth {
+            access_token: token_response.access_token,
+            refresh_token: token_response.refresh_token,
+            expires_at,
+        })
+    }
+}
+
+/// Helper to perform the full device auth flow with polling
+pub async fn perform_device_auth<F>(
+    auth: &OpenAIAuth,
+    on_code: F,
+) -> Result<AuthMethod, LlmError>
+where
+    F: FnOnce(&DeviceCodeResponse),
+{
+    // Start the device flow
+    let device_code = auth.start_device_auth().await?;
+
+    // Let caller display the code to user
+    on_code(&device_code);
+
+    // Poll for completion
+    let poll_interval = std::time::Duration::from_secs(device_code.interval);
+    let deadline =
+        std::time::Instant::now() + std::time::Duration::from_secs(device_code.expires_in);
+
+    loop {
+        if std::time::Instant::now() > deadline {
+            return Err(LlmError::Auth("Device code expired".to_string()));
+        }
+
+        tokio::time::sleep(poll_interval).await;
+
+        match auth.poll_device_auth(&device_code.device_code).await? {
+            DeviceAuthResult::Success {
+                access_token,
+                refresh_token,
+                expires_in,
+            } => {
+                let expires_at = expires_in.map(|secs| {
+                    std::time::SystemTime::now()
+                        .duration_since(std::time::UNIX_EPOCH)
+                        .map(|d| d.as_secs() + secs)
+                        .unwrap_or(0)
+                });
+
+                return Ok(AuthMethod::OAuth {
+                    access_token,
+                    refresh_token,
+                    expires_at,
+                });
+            }
+            DeviceAuthResult::Pending => continue,
+            DeviceAuthResult::Denied => {
+                return Err(LlmError::Auth("Authorization denied by user".to_string()));
+            }
+            DeviceAuthResult::Expired => {
+                return Err(LlmError::Auth("Device code expired".to_string()));
+            }
+        }
+    }
+}

crates/llm/openai/src/client.rs

@@ -0,0 +1,561 @@
+//! OpenAI GPT API Client
+//!
+//! Implements the Chat Completions API with streaming support.
+
+use crate::types::*;
+use async_trait::async_trait;
+use futures::StreamExt;
+use llm_core::{
+    AccountInfo, AuthMethod, ChatMessage, ChatOptions, ChatResponse, ChunkStream, FunctionCall,
+    LlmError, LlmProvider, ModelInfo, ProviderInfo, ProviderStatus, StreamChunk, Tool, ToolCall,
+    ToolCallDelta, Usage, UsageStats,
+};
+use reqwest::Client;
+use tokio::io::AsyncBufReadExt;
+use tokio_stream::wrappers::LinesStream;
+use tokio_util::io::StreamReader;
+
+const API_BASE_URL: &str = "https://api.openai.com/v1";
+const CHAT_ENDPOINT: &str = "/chat/completions";
+const MODELS_ENDPOINT: &str = "/models";
+
+/// OpenAI GPT API client
+pub struct OpenAIClient {
+    http: Client,
+    auth: AuthMethod,
+    model: String,
+}
+
+impl OpenAIClient {
+    /// Create a new client with API key authentication
+    pub fn new(api_key: impl Into<String>) -> Self {
+        Self {
+            http: Client::new(),
+            auth: AuthMethod::api_key(api_key),
+            model: "gpt-4o".to_string(),
+        }
+    }
+
+    /// Create a new client with OAuth token
+    pub fn with_oauth(access_token: impl Into<String>) -> Self {
+        Self {
+            http: Client::new(),
+            auth: AuthMethod::oauth(access_token),
+            model: "gpt-4o".to_string(),
+        }
+    }
+
+    /// Create a new client with full AuthMethod
+    pub fn with_auth(auth: AuthMethod) -> Self {
+        Self {
+            http: Client::new(),
+            auth,
+            model: "gpt-4o".to_string(),
+        }
+    }
+
+    /// Set the model to use
+    pub fn with_model(mut self, model: impl Into<String>) -> Self {
+        self.model = model.into();
+        self
+    }
+
+    /// Get current auth method (for token refresh)
+    pub fn auth(&self) -> &AuthMethod {
+        &self.auth
+    }
+
+    /// Update the auth method (after refresh)
+    pub fn set_auth(&mut self, auth: AuthMethod) {
+        self.auth = auth;
+    }
+
+    /// Convert messages to OpenAI format
+    fn prepare_messages(messages: &[ChatMessage]) -> Vec<OpenAIMessage> {
+        messages.iter().map(OpenAIMessage::from).collect()
+    }
+
+    /// Convert tools to OpenAI format
+    fn prepare_tools(tools: Option<&[Tool]>) -> Option<Vec<OpenAITool>> {
+        tools.map(|t| t.iter().map(OpenAITool::from).collect())
+    }
+}
+
+#[async_trait]
+impl LlmProvider for OpenAIClient {
+    fn name(&self) -> &str {
+        "openai"
+    }
+
+    fn model(&self) -> &str {
+        &self.model
+    }
+
+    async fn chat_stream(
+        &self,
+        messages: &[ChatMessage],
+        options: &ChatOptions,
+        tools: Option<&[Tool]>,
+    ) -> Result<ChunkStream, LlmError> {
+        let url = format!("{}{}", API_BASE_URL, CHAT_ENDPOINT);
+
+        let model = if options.model.is_empty() {
+            &self.model
+        } else {
+            &options.model
+        };
+
+        let openai_messages = Self::prepare_messages(messages);
+        let openai_tools = Self::prepare_tools(tools);
+
+        let request = ChatCompletionRequest {
+            model,
+            messages: openai_messages,
+            temperature: options.temperature,
+            max_tokens: options.max_tokens,
+            top_p: options.top_p,
+            stop: options.stop.as_deref(),
+            tools: openai_tools,
+            tool_choice: None,
+            stream: true,
+        };
+
+        let bearer = self
+            .auth
+            .bearer_token()
+            .ok_or_else(|| LlmError::Auth("No authentication configured".to_string()))?;
+
+        let response = self
+            .http
+            .post(&url)
+            .header("Authorization", format!("Bearer {}", bearer))
+            .header("Content-Type", "application/json")
+            .json(&request)
+            .send()
+            .await
+            .map_err(|e| LlmError::Http(e.to_string()))?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let text = response
+                .text()
+                .await
+                .unwrap_or_else(|_| "Unknown error".to_string());
+
+            if status == reqwest::StatusCode::TOO_MANY_REQUESTS {
+                return Err(LlmError::RateLimit {
+                    retry_after_secs: None,
+                });
+            }
+
+            // Try to parse as error response
+            if let Ok(err_resp) = serde_json::from_str::<ErrorResponse>(&text) {
+                return Err(LlmError::Api {
+                    message: err_resp.error.message,
+                    code: err_resp.error.code,
+                });
+            }
+
+            return Err(LlmError::Api {
+                message: text,
+                code: Some(status.to_string()),
+            });
+        }
+
+        // Parse SSE stream
+        let byte_stream = response
+            .bytes_stream()
+            .map(|result| result.map_err(std::io::Error::other));
+
+        let reader = StreamReader::new(byte_stream);
+        let buf_reader = tokio::io::BufReader::new(reader);
+        let lines_stream = LinesStream::new(buf_reader.lines());
+
+        let chunk_stream = lines_stream.filter_map(|line_result| async move {
+            match line_result {
+                Ok(line) => parse_sse_line(&line),
+                Err(e) => Some(Err(LlmError::Stream(e.to_string()))),
+            }
+        });
+
+        Ok(Box::pin(chunk_stream))
+    }
+
+    async fn chat(
+        &self,
+        messages: &[ChatMessage],
+        options: &ChatOptions,
+        tools: Option<&[Tool]>,
+    ) -> Result<ChatResponse, LlmError> {
+        let url = format!("{}{}", API_BASE_URL, CHAT_ENDPOINT);
+
+        let model = if options.model.is_empty() {
+            &self.model
+        } else {
+            &options.model
+        };
+
+        let openai_messages = Self::prepare_messages(messages);
+        let openai_tools = Self::prepare_tools(tools);
+
+        let request = ChatCompletionRequest {
+            model,
+            messages: openai_messages,
+            temperature: options.temperature,
+            max_tokens: options.max_tokens,
+            top_p: options.top_p,
+            stop: options.stop.as_deref(),
+            tools: openai_tools,
+            tool_choice: None,
+            stream: false,
+        };
+
+        let bearer = self
+            .auth
+            .bearer_token()
+            .ok_or_else(|| LlmError::Auth("No authentication configured".to_string()))?;
+
+        let response = self
+            .http
+            .post(&url)
+            .header("Authorization", format!("Bearer {}", bearer))
+            .json(&request)
+            .send()
+            .await
+            .map_err(|e| LlmError::Http(e.to_string()))?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let text = response
+                .text()
+                .await
+                .unwrap_or_else(|_| "Unknown error".to_string());
+
+            if status == reqwest::StatusCode::TOO_MANY_REQUESTS {
+                return Err(LlmError::RateLimit {
+                    retry_after_secs: None,
+                });
+            }
+
+            if let Ok(err_resp) = serde_json::from_str::<ErrorResponse>(&text) {
+                return Err(LlmError::Api {
+                    message: err_resp.error.message,
+                    code: err_resp.error.code,
+                });
+            }
+
+            return Err(LlmError::Api {
+                message: text,
+                code: Some(status.to_string()),
+            });
+        }
+
+        let api_response: ChatCompletionResponse = response
+            .json()
+            .await
+            .map_err(|e| LlmError::Json(e.to_string()))?;
+
+        // Extract the first choice
+        let choice = api_response
+            .choices
+            .first()
+            .ok_or_else(|| LlmError::Api {
+                message: "No choices in response".to_string(),
+                code: None,
+            })?;
+
+        let content = choice.message.content.clone();
+
+        let tool_calls = choice.message.tool_calls.as_ref().map(|calls| {
+            calls
+                .iter()
+                .map(|call| {
+                    let arguments: serde_json::Value =
+                        serde_json::from_str(&call.function.arguments).unwrap_or_default();
+
+                    ToolCall {
+                        id: call.id.clone(),
+                        call_type: "function".to_string(),
+                        function: FunctionCall {
+                            name: call.function.name.clone(),
+                            arguments,
+                        },
+                    }
+                })
+                .collect()
+        });
+
+        let usage = api_response.usage.map(|u| Usage {
+            prompt_tokens: u.prompt_tokens,
+            completion_tokens: u.completion_tokens,
+            total_tokens: u.total_tokens,
+        });
+
+        Ok(ChatResponse {
+            content,
+            tool_calls,
+            usage,
+        })
+    }
+}
+
+/// Parse a single SSE line into a StreamChunk
+fn parse_sse_line(line: &str) -> Option<Result<StreamChunk, LlmError>> {
+    let line = line.trim();
+
+    // Skip empty lines and comments
+    if line.is_empty() || line.starts_with(':') {
+        return None;
+    }
+
+    // SSE format: "data: <json>"
+    if let Some(data) = line.strip_prefix("data: ") {
+        // OpenAI sends [DONE] to signal end
+        if data == "[DONE]" {
+            return Some(Ok(StreamChunk {
+                content: None,
+                tool_calls: None,
+                done: true,
+                usage: None,
+            }));
+        }
+
+        // Parse the JSON chunk
+        match serde_json::from_str::<ChatCompletionChunk>(data) {
+            Ok(chunk) => Some(convert_chunk_to_stream_chunk(chunk)),
+            Err(e) => {
+                tracing::warn!("Failed to parse SSE chunk: {}", e);
+                None
+            }
+        }
+    } else {
+        None
+    }
+}
+
+/// Convert OpenAI chunk to our common format
+fn convert_chunk_to_stream_chunk(chunk: ChatCompletionChunk) -> Result<StreamChunk, LlmError> {
+    let choice = chunk.choices.first();
+
+    if let Some(choice) = choice {
+        let content = choice.delta.content.clone();
+
+        let tool_calls = choice.delta.tool_calls.as_ref().map(|deltas| {
+            deltas
+                .iter()
+                .map(|delta| ToolCallDelta {
+                    index: delta.index,
+                    id: delta.id.clone(),
+                    function_name: delta.function.as_ref().and_then(|f| f.name.clone()),
+                    arguments_delta: delta.function.as_ref().and_then(|f| f.arguments.clone()),
+                })
+                .collect()
+        });
+
+        let done = choice.finish_reason.is_some();
+
+        Ok(StreamChunk {
+            content,
+            tool_calls,
+            done,
+            usage: None,
+        })
+    } else {
+        // No choices, treat as done
+        Ok(StreamChunk {
+            content: None,
+            tool_calls: None,
+            done: true,
+            usage: None,
+        })
+    }
+}
+
+// ============================================================================
+// ProviderInfo Implementation
+// ============================================================================
+
+/// Known GPT models with their specifications
+fn get_gpt_models() -> Vec<ModelInfo> {
+    vec![
+        ModelInfo {
+            id: "gpt-4o".to_string(),
+            display_name: Some("GPT-4o".to_string()),
+            description: Some("Most advanced multimodal model with vision".to_string()),
+            context_window: Some(128_000),
+            max_output_tokens: Some(16_384),
+            supports_tools: true,
+            supports_vision: true,
+            input_price_per_mtok: Some(2.50),
+            output_price_per_mtok: Some(10.0),
+        },
+        ModelInfo {
+            id: "gpt-4o-mini".to_string(),
+            display_name: Some("GPT-4o mini".to_string()),
+            description: Some("Affordable and fast model for simple tasks".to_string()),
+            context_window: Some(128_000),
+            max_output_tokens: Some(16_384),
+            supports_tools: true,
+            supports_vision: true,
+            input_price_per_mtok: Some(0.15),
+            output_price_per_mtok: Some(0.60),
+        },
+        ModelInfo {
+            id: "gpt-4-turbo".to_string(),
+            display_name: Some("GPT-4 Turbo".to_string()),
+            description: Some("Previous generation high-performance model".to_string()),
+            context_window: Some(128_000),
+            max_output_tokens: Some(4_096),
+            supports_tools: true,
+            supports_vision: true,
+            input_price_per_mtok: Some(10.0),
+            output_price_per_mtok: Some(30.0),
+        },
+        ModelInfo {
+            id: "gpt-3.5-turbo".to_string(),
+            display_name: Some("GPT-3.5 Turbo".to_string()),
+            description: Some("Fast and affordable for simple tasks".to_string()),
+            context_window: Some(16_385),
+            max_output_tokens: Some(4_096),
+            supports_tools: true,
+            supports_vision: false,
+            input_price_per_mtok: Some(0.50),
+            output_price_per_mtok: Some(1.50),
+        },
+        ModelInfo {
+            id: "o1".to_string(),
+            display_name: Some("OpenAI o1".to_string()),
+            description: Some("Reasoning model optimized for complex problems".to_string()),
+            context_window: Some(200_000),
+            max_output_tokens: Some(100_000),
+            supports_tools: false,
+            supports_vision: true,
+            input_price_per_mtok: Some(15.0),
+            output_price_per_mtok: Some(60.0),
+        },
+        ModelInfo {
+            id: "o1-mini".to_string(),
+            display_name: Some("OpenAI o1-mini".to_string()),
+            description: Some("Faster reasoning model for STEM".to_string()),
+            context_window: Some(128_000),
+            max_output_tokens: Some(65_536),
+            supports_tools: false,
+            supports_vision: true,
+            input_price_per_mtok: Some(3.0),
+            output_price_per_mtok: Some(12.0),
+        },
+    ]
+}
+
+#[async_trait]
+impl ProviderInfo for OpenAIClient {
+    async fn status(&self) -> Result<ProviderStatus, LlmError> {
+        let authenticated = self.auth.bearer_token().is_some();
+
+        // Try to reach the API by listing models
+        let reachable = if authenticated {
+            let url = format!("{}{}", API_BASE_URL, MODELS_ENDPOINT);
+            let bearer = self.auth.bearer_token().unwrap();
+
+            match self
+                .http
+                .get(&url)
+                .header("Authorization", format!("Bearer {}", bearer))
+                .send()
+                .await
+            {
+                Ok(resp) => resp.status().is_success(),
+                Err(_) => false,
+            }
+        } else {
+            false
+        };
+
+        let message = if !authenticated {
+            Some("Not authenticated - set OPENAI_API_KEY or run 'owlen login openai'".to_string())
+        } else if !reachable {
+            Some("Cannot reach OpenAI API".to_string())
+        } else {
+            Some("Connected".to_string())
+        };
+
+        Ok(ProviderStatus {
+            provider: "openai".to_string(),
+            authenticated,
+            account: None, // OpenAI doesn't expose account info via API
+            model: self.model.clone(),
+            endpoint: API_BASE_URL.to_string(),
+            reachable,
+            message,
+        })
+    }
+
+    async fn account_info(&self) -> Result<Option<AccountInfo>, LlmError> {
+        // OpenAI doesn't have a public account info endpoint
+        Ok(None)
+    }
+
+    async fn usage_stats(&self) -> Result<Option<UsageStats>, LlmError> {
+        // OpenAI doesn't expose usage stats via the standard API
+        Ok(None)
+    }
+
+    async fn list_models(&self) -> Result<Vec<ModelInfo>, LlmError> {
+        // We can optionally fetch from API, but return known models for now
+        Ok(get_gpt_models())
+    }
+
+    async fn model_info(&self, model_id: &str) -> Result<Option<ModelInfo>, LlmError> {
+        let models = get_gpt_models();
+        Ok(models.into_iter().find(|m| m.id == model_id))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use llm_core::ToolParameters;
+    use serde_json::json;
+
+    #[test]
+    fn test_message_conversion() {
+        let messages = vec![
+            ChatMessage::system("You are helpful"),
+            ChatMessage::user("Hello"),
+            ChatMessage::assistant("Hi there!"),
+        ];
+
+        let openai_msgs = OpenAIClient::prepare_messages(&messages);
+
+        assert_eq!(openai_msgs.len(), 3);
+        assert_eq!(openai_msgs[0].role, "system");
+        assert_eq!(openai_msgs[1].role, "user");
+        assert_eq!(openai_msgs[2].role, "assistant");
+    }
+
+    #[test]
+    fn test_tool_conversion() {
+        let tools = vec![Tool::function(
+            "read_file",
+            "Read a file's contents",
+            ToolParameters::object(
+                json!({
+                    "path": {
+                        "type": "string",
+                        "description": "File path"
+                    }
+                }),
+                vec!["path".to_string()],
+            ),
+        )];
+
+        let openai_tools = OpenAIClient::prepare_tools(Some(&tools)).unwrap();
+
+        assert_eq!(openai_tools.len(), 1);
+        assert_eq!(openai_tools[0].function.name, "read_file");
+        assert_eq!(
+            openai_tools[0].function.description,
+            "Read a file's contents"
+        );
+    }
+}

crates/llm/openai/src/lib.rs

@@ -0,0 +1,12 @@
+//! OpenAI GPT API Client
+//!
+//! Implements the LlmProvider trait for OpenAI's GPT models.
+//! Supports both API key authentication and OAuth device flow.
+
+mod auth;
+mod client;
+mod types;
+
+pub use auth::*;
+pub use client::*;
+pub use types::*;

crates/llm/openai/src/types.rs

@@ -0,0 +1,285 @@
+//! OpenAI API request/response types
+
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+// ============================================================================
+// Request Types
+// ============================================================================
+
+#[derive(Debug, Serialize)]
+pub struct ChatCompletionRequest<'a> {
+    pub model: &'a str,
+    pub messages: Vec<OpenAIMessage>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub temperature: Option<f32>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub max_tokens: Option<u32>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub top_p: Option<f32>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub stop: Option<&'a [String]>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tools: Option<Vec<OpenAITool>>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tool_choice: Option<&'a str>,
+
+    pub stream: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct OpenAIMessage {
+    pub role: String, // "system", "user", "assistant", "tool"
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub content: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tool_calls: Option<Vec<OpenAIToolCall>>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tool_call_id: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct OpenAIToolCall {
+    pub id: String,
+    #[serde(rename = "type")]
+    pub call_type: String,
+    pub function: OpenAIFunctionCall,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct OpenAIFunctionCall {
+    pub name: String,
+    pub arguments: String, // JSON string
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct OpenAITool {
+    #[serde(rename = "type")]
+    pub tool_type: String,
+    pub function: OpenAIFunction,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct OpenAIFunction {
+    pub name: String,
+    pub description: String,
+    pub parameters: FunctionParameters,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FunctionParameters {
+    #[serde(rename = "type")]
+    pub param_type: String,
+    pub properties: Value,
+    pub required: Vec<String>,
+}
+
+// ============================================================================
+// Response Types
+// ============================================================================
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct ChatCompletionResponse {
+    pub id: String,
+    pub object: String,
+    pub created: u64,
+    pub model: String,
+    pub choices: Vec<Choice>,
+    pub usage: Option<UsageInfo>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct Choice {
+    pub index: u32,
+    pub message: OpenAIMessage,
+    pub finish_reason: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct UsageInfo {
+    pub prompt_tokens: u32,
+    pub completion_tokens: u32,
+    pub total_tokens: u32,
+}
+
+// ============================================================================
+// Streaming Response Types
+// ============================================================================
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct ChatCompletionChunk {
+    pub id: String,
+    pub object: String,
+    pub created: u64,
+    pub model: String,
+    pub choices: Vec<ChunkChoice>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct ChunkChoice {
+    pub index: u32,
+    pub delta: Delta,
+    pub finish_reason: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct Delta {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub role: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub content: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tool_calls: Option<Vec<DeltaToolCall>>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct DeltaToolCall {
+    pub index: usize,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none", rename = "type")]
+    pub call_type: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub function: Option<DeltaFunction>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct DeltaFunction {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub arguments: Option<String>,
+}
+
+// ============================================================================
+// Error Response Types
+// ============================================================================
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct ErrorResponse {
+    pub error: ApiError,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct ApiError {
+    pub message: String,
+    #[serde(rename = "type")]
+    pub error_type: String,
+    pub code: Option<String>,
+}
+
+// ============================================================================
+// Models List Response
+// ============================================================================
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct ModelsResponse {
+    pub object: String,
+    pub data: Vec<ModelData>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct ModelData {
+    pub id: String,
+    pub object: String,
+    pub created: u64,
+    pub owned_by: String,
+}
+
+// ============================================================================
+// Conversions
+// ============================================================================
+
+impl From<&llm_core::Tool> for OpenAITool {
+    fn from(tool: &llm_core::Tool) -> Self {
+        Self {
+            tool_type: "function".to_string(),
+            function: OpenAIFunction {
+                name: tool.function.name.clone(),
+                description: tool.function.description.clone(),
+                parameters: FunctionParameters {
+                    param_type: tool.function.parameters.param_type.clone(),
+                    properties: tool.function.parameters.properties.clone(),
+                    required: tool.function.parameters.required.clone(),
+                },
+            },
+        }
+    }
+}
+
+impl From<&llm_core::ChatMessage> for OpenAIMessage {
+    fn from(msg: &llm_core::ChatMessage) -> Self {
+        use llm_core::Role;
+
+        let role = match msg.role {
+            Role::System => "system",
+            Role::User => "user",
+            Role::Assistant => "assistant",
+            Role::Tool => "tool",
+        };
+
+        // Handle tool result messages
+        if msg.role == Role::Tool {
+            return Self {
+                role: "tool".to_string(),
+                content: msg.content.clone(),
+                tool_calls: None,
+                tool_call_id: msg.tool_call_id.clone(),
+                name: msg.name.clone(),
+            };
+        }
+
+        // Handle assistant messages with tool calls
+        if msg.role == Role::Assistant && msg.tool_calls.is_some() {
+            let tool_calls = msg.tool_calls.as_ref().map(|calls| {
+                calls
+                    .iter()
+                    .map(|call| OpenAIToolCall {
+                        id: call.id.clone(),
+                        call_type: "function".to_string(),
+                        function: OpenAIFunctionCall {
+                            name: call.function.name.clone(),
+                            arguments: serde_json::to_string(&call.function.arguments)
+                                .unwrap_or_else(|_| "{}".to_string()),
+                        },
+                    })
+                    .collect()
+            });
+
+            return Self {
+                role: "assistant".to_string(),
+                content: msg.content.clone(),
+                tool_calls,
+                tool_call_id: None,
+                name: None,
+            };
+        }
+
+        // Simple text message
+        Self {
+            role: role.to_string(),
+            content: msg.content.clone(),
+            tool_calls: None,
+            tool_call_id: None,
+            name: None,
+        }
+    }
+}

crates/platform/config/Cargo.toml

@@ -10,6 +10,7 @@ serde = { version = "1", features = ["derive"] }
 directories = "5"
 figment = { version = "0.10", features = ["toml", "env"] }
 permissions = { path = "../permissions" }
+llm-core = { path = "../../llm/core" }
 
 [dev-dependencies]
 tempfile = "3.23.0"

crates/platform/config/src/lib.rs

@@ -5,26 +5,52 @@ use figment::{
 };
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
+use std::env;
 use permissions::{Mode, PermissionManager};
+use llm_core::ProviderType;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Settings {
-    #[serde(default = "default_ollama_url")]
+    // Provider configuration
-    pub ollama_url: String,
+    #[serde(default = "default_provider")]
+    pub provider: String, // "ollama" | "anthropic" | "openai"
+
     #[serde(default = "default_model")]
     pub model: String,
-    #[serde(default = "default_mode")]
+
-    pub mode: String, // "plan" (read-only) for now
+    // Ollama-specific
+    #[serde(default = "default_ollama_url")]
+    pub ollama_url: String,
+
+    // API keys for different providers
     #[serde(default)]
-    pub api_key: Option<String>, // For Ollama Cloud or other API authentication
+    pub api_key: Option<String>, // For Ollama Cloud or backwards compatibility
+
+    #[serde(default)]
+    pub anthropic_api_key: Option<String>,
+
+    #[serde(default)]
+    pub openai_api_key: Option<String>,
+
+    // Permission mode
+    #[serde(default = "default_mode")]
+    pub mode: String, // "plan" | "acceptEdits" | "code"
+}
+
+fn default_provider() -> String {
+    "ollama".into()
 }
 
 fn default_ollama_url() -> String {
     "http://localhost:11434".into()
 }
+
 fn default_model() -> String {
+    // Default model depends on provider, but we use ollama's default here
+    // Users can override this per-provider or use get_effective_model()
     "qwen3:8b".into()
 }
+
 fn default_mode() -> String {
     "plan".into()
 }
@@ -32,10 +58,13 @@ fn default_mode() -> String {
 impl Default for Settings {
     fn default() -> Self {
         Self {
-            ollama_url: default_ollama_url(),
+            provider: default_provider(),
             model: default_model(),
-            mode: default_mode(),
+            ollama_url: default_ollama_url(),
             api_key: None,
+            anthropic_api_key: None,
+            openai_api_key: None,
+            mode: default_mode(),
         }
     }
 }
@@ -51,6 +80,34 @@ impl Settings {
     pub fn get_mode(&self) -> Mode {
         Mode::from_str(&self.mode).unwrap_or(Mode::Plan)
     }
+
+    /// Get the ProviderType enum from the provider string
+    pub fn get_provider(&self) -> Option<ProviderType> {
+        ProviderType::from_str(&self.provider)
+    }
+
+    /// Get the effective model for the current provider
+    /// If no model is explicitly set, returns the provider's default
+    pub fn get_effective_model(&self) -> String {
+        // If model is explicitly set and not the default, use it
+        if self.model != default_model() {
+            return self.model.clone();
+        }
+
+        // Otherwise, use provider-specific default
+        self.get_provider()
+            .map(|p| p.default_model().to_string())
+            .unwrap_or_else(|| self.model.clone())
+    }
+
+    /// Get the API key for the current provider
+    pub fn get_provider_api_key(&self) -> Option<String> {
+        match self.get_provider()? {
+            ProviderType::Ollama => self.api_key.clone(),
+            ProviderType::Anthropic => self.anthropic_api_key.clone(),
+            ProviderType::OpenAI => self.openai_api_key.clone(),
+        }
+    }
 }
 
 pub fn load_settings(project_root: Option<&str>) -> Result<Settings, figment::Error> {
@@ -68,9 +125,31 @@ pub fn load_settings(project_root: Option<&str>) -> Result<Settings, figment::Er
     }
 
     // Environment variables have highest precedence
+    // OWLEN_* prefix (e.g., OWLEN_PROVIDER, OWLEN_MODEL, OWLEN_API_KEY, OWLEN_ANTHROPIC_API_KEY)
     fig = fig.merge(Env::prefixed("OWLEN_").split("__"));
-    // Support OLLAMA_API_KEY, OLLAMA_MODEL, etc. (without nesting)
+
+    // Support OLLAMA_* prefix for backwards compatibility
     fig = fig.merge(Env::prefixed("OLLAMA_"));
 
-    fig.extract()
+    // Support PROVIDER env var (without OWLEN_ prefix)
+    fig = fig.merge(Env::raw().only(&["PROVIDER"]));
+
+    // Extract the settings
+    let mut settings: Settings = fig.extract()?;
+
+    // Manually handle standard provider API key env vars (ANTHROPIC_API_KEY, OPENAI_API_KEY)
+    // These override config files but are overridden by OWLEN_* vars
+    if settings.anthropic_api_key.is_none() {
+        if let Ok(key) = env::var("ANTHROPIC_API_KEY") {
+            settings.anthropic_api_key = Some(key);
+        }
+    }
+
+    if settings.openai_api_key.is_none() {
+        if let Ok(key) = env::var("OPENAI_API_KEY") {
+            settings.openai_api_key = Some(key);
+        }
+    }
+
+    Ok(settings)
 }

crates/platform/config/tests/precedence.rs

@@ -1,5 +1,6 @@
 use config_agent::{load_settings, Settings};
 use permissions::{Mode, PermissionDecision, Tool};
+use llm_core::ProviderType;
 use std::{env, fs};
 
 #[test]
@@ -45,4 +46,189 @@ fn settings_parse_mode_from_config() {
     // Code mode should allow everything
     assert_eq!(mgr.check(Tool::Write, None), PermissionDecision::Allow);
     assert_eq!(mgr.check(Tool::Bash, None), PermissionDecision::Allow);
+}
+
+#[test]
+fn default_provider_is_ollama() {
+    let s = Settings::default();
+    assert_eq!(s.provider, "ollama");
+    assert_eq!(s.get_provider(), Some(ProviderType::Ollama));
+}
+
+#[test]
+fn provider_from_config_file() {
+    let tmp = tempfile::tempdir().unwrap();
+    let project_file = tmp.path().join(".owlen.toml");
+    fs::write(&project_file, r#"provider="anthropic""#).unwrap();
+
+    let s = load_settings(Some(tmp.path().to_str().unwrap())).unwrap();
+    assert_eq!(s.provider, "anthropic");
+    assert_eq!(s.get_provider(), Some(ProviderType::Anthropic));
+}
+
+#[test]
+#[ignore] // Ignore due to env var interaction in parallel tests
+fn provider_from_env_var() {
+    let tmp = tempfile::tempdir().unwrap();
+
+    unsafe {
+        env::set_var("OWLEN_PROVIDER", "openai");
+        env::remove_var("PROVIDER");
+        env::remove_var("ANTHROPIC_API_KEY");
+        env::remove_var("OPENAI_API_KEY");
+    }
+    let s = load_settings(Some(tmp.path().to_str().unwrap())).unwrap();
+    assert_eq!(s.provider, "openai");
+    assert_eq!(s.get_provider(), Some(ProviderType::OpenAI));
+    unsafe { env::remove_var("OWLEN_PROVIDER"); }
+}
+
+#[test]
+#[ignore] // Ignore due to env var interaction in parallel tests
+fn provider_from_provider_env_var() {
+    let tmp = tempfile::tempdir().unwrap();
+
+    unsafe {
+        env::set_var("PROVIDER", "anthropic");
+        env::remove_var("OWLEN_PROVIDER");
+        env::remove_var("ANTHROPIC_API_KEY");
+        env::remove_var("OPENAI_API_KEY");
+    }
+    let s = load_settings(Some(tmp.path().to_str().unwrap())).unwrap();
+    assert_eq!(s.provider, "anthropic");
+    assert_eq!(s.get_provider(), Some(ProviderType::Anthropic));
+    unsafe { env::remove_var("PROVIDER"); }
+}
+
+#[test]
+fn anthropic_api_key_from_owlen_env() {
+    let tmp = tempfile::tempdir().unwrap();
+    let project_file = tmp.path().join(".owlen.toml");
+    fs::write(&project_file, r#"provider="anthropic""#).unwrap();
+
+    unsafe { env::set_var("OWLEN_ANTHROPIC_API_KEY", "sk-ant-test123"); }
+    let s = load_settings(Some(tmp.path().to_str().unwrap())).unwrap();
+    assert_eq!(s.anthropic_api_key, Some("sk-ant-test123".to_string()));
+    assert_eq!(s.get_provider_api_key(), Some("sk-ant-test123".to_string()));
+    unsafe { env::remove_var("OWLEN_ANTHROPIC_API_KEY"); }
+}
+
+#[test]
+fn openai_api_key_from_owlen_env() {
+    let tmp = tempfile::tempdir().unwrap();
+    let project_file = tmp.path().join(".owlen.toml");
+    fs::write(&project_file, r#"provider="openai""#).unwrap();
+
+    unsafe { env::set_var("OWLEN_OPENAI_API_KEY", "sk-test-456"); }
+    let s = load_settings(Some(tmp.path().to_str().unwrap())).unwrap();
+    assert_eq!(s.openai_api_key, Some("sk-test-456".to_string()));
+    assert_eq!(s.get_provider_api_key(), Some("sk-test-456".to_string()));
+    unsafe { env::remove_var("OWLEN_OPENAI_API_KEY"); }
+}
+
+#[test]
+#[ignore] // Ignore due to env var interaction in parallel tests
+fn api_keys_from_config_file() {
+    let tmp = tempfile::tempdir().unwrap();
+    let project_file = tmp.path().join(".owlen.toml");
+    fs::write(&project_file, r#"
+provider = "anthropic"
+anthropic_api_key = "sk-ant-from-file"
+openai_api_key = "sk-openai-from-file"
+"#).unwrap();
+
+    // Clear any env vars that might interfere
+    unsafe {
+        env::remove_var("ANTHROPIC_API_KEY");
+        env::remove_var("OPENAI_API_KEY");
+        env::remove_var("OWLEN_ANTHROPIC_API_KEY");
+        env::remove_var("OWLEN_OPENAI_API_KEY");
+    }
+
+    let s = load_settings(Some(tmp.path().to_str().unwrap())).unwrap();
+    assert_eq!(s.anthropic_api_key, Some("sk-ant-from-file".to_string()));
+    assert_eq!(s.openai_api_key, Some("sk-openai-from-file".to_string()));
+    assert_eq!(s.get_provider_api_key(), Some("sk-ant-from-file".to_string()));
+}
+
+#[test]
+#[ignore] // Ignore due to env var interaction in parallel tests
+fn anthropic_api_key_from_standard_env() {
+    let tmp = tempfile::tempdir().unwrap();
+    let project_file = tmp.path().join(".owlen.toml");
+    fs::write(&project_file, r#"provider="anthropic""#).unwrap();
+
+    unsafe {
+        env::set_var("ANTHROPIC_API_KEY", "sk-ant-std");
+        env::remove_var("OWLEN_ANTHROPIC_API_KEY");
+        env::remove_var("PROVIDER");
+        env::remove_var("OWLEN_PROVIDER");
+    }
+    let s = load_settings(Some(tmp.path().to_str().unwrap())).unwrap();
+    assert_eq!(s.anthropic_api_key, Some("sk-ant-std".to_string()));
+    assert_eq!(s.get_provider_api_key(), Some("sk-ant-std".to_string()));
+    unsafe { env::remove_var("ANTHROPIC_API_KEY"); }
+}
+
+#[test]
+#[ignore] // Ignore due to env var interaction in parallel tests
+fn openai_api_key_from_standard_env() {
+    let tmp = tempfile::tempdir().unwrap();
+    let project_file = tmp.path().join(".owlen.toml");
+    fs::write(&project_file, r#"provider="openai""#).unwrap();
+
+    unsafe {
+        env::set_var("OPENAI_API_KEY", "sk-openai-std");
+        env::remove_var("OWLEN_OPENAI_API_KEY");
+        env::remove_var("PROVIDER");
+        env::remove_var("OWLEN_PROVIDER");
+    }
+    let s = load_settings(Some(tmp.path().to_str().unwrap())).unwrap();
+    assert_eq!(s.openai_api_key, Some("sk-openai-std".to_string()));
+    assert_eq!(s.get_provider_api_key(), Some("sk-openai-std".to_string()));
+    unsafe { env::remove_var("OPENAI_API_KEY"); }
+}
+
+#[test]
+#[ignore] // Ignore due to env var interaction in parallel tests
+fn owlen_prefix_overrides_standard_env() {
+    let tmp = tempfile::tempdir().unwrap();
+
+    unsafe {
+        env::set_var("ANTHROPIC_API_KEY", "sk-ant-std");
+        env::set_var("OWLEN_ANTHROPIC_API_KEY", "sk-ant-owlen");
+    }
+    let s = load_settings(Some(tmp.path().to_str().unwrap())).unwrap();
+    // OWLEN_ prefix should take precedence
+    assert_eq!(s.anthropic_api_key, Some("sk-ant-owlen".to_string()));
+    unsafe {
+        env::remove_var("ANTHROPIC_API_KEY");
+        env::remove_var("OWLEN_ANTHROPIC_API_KEY");
+    }
+}
+
+#[test]
+fn effective_model_uses_provider_default() {
+    // Test Anthropic provider default
+    let mut s = Settings::default();
+    s.provider = "anthropic".to_string();
+    assert_eq!(s.get_effective_model(), "claude-sonnet-4-20250514");
+
+    // Test OpenAI provider default
+    s.provider = "openai".to_string();
+    assert_eq!(s.get_effective_model(), "gpt-4o");
+
+    // Test Ollama provider default
+    s.provider = "ollama".to_string();
+    assert_eq!(s.get_effective_model(), "qwen3:8b");
+}
+
+#[test]
+fn effective_model_respects_explicit_model() {
+    let mut s = Settings::default();
+    s.provider = "anthropic".to_string();
+    s.model = "claude-opus-4-20250514".to_string();
+
+    // Should use explicit model, not provider default
+    assert_eq!(s.get_effective_model(), "claude-opus-4-20250514");
 }

crates/platform/hooks/Cargo.toml

@@ -10,6 +10,7 @@ serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 tokio = { version = "1.39", features = ["process", "time", "io-util"] }
 color-eyre = "0.6"
+regex = "1.10"
 
 [dev-dependencies]
 tempfile = "3.23.0"

crates/platform/hooks/src/lib.rs

@@ -56,17 +56,38 @@ pub enum HookResult {
     Deny,
 }
 
+/// A registered hook that can be executed
+#[derive(Debug, Clone)]
+struct Hook {
+    event: String,  // Event name like "PreToolUse", "PostToolUse", etc.
+    command: String,
+    pattern: Option<String>,  // Optional regex pattern for matching tool names
+    timeout: Option<u64>,
+}
+
 pub struct HookManager {
     project_root: PathBuf,
+    hooks: Vec<Hook>,
 }
 
 impl HookManager {
     pub fn new(project_root: &str) -> Self {
         Self {
             project_root: PathBuf::from(project_root),
+            hooks: Vec::new(),
         }
     }
 
+    /// Register a single hook
+    pub fn register_hook(&mut self, event: String, command: String, pattern: Option<String>, timeout: Option<u64>) {
+        self.hooks.push(Hook {
+            event,
+            command,
+            pattern,
+            timeout,
+        });
+    }
+
     /// Execute a hook for the given event
     ///
     /// Returns:
@@ -74,18 +95,66 @@ impl HookManager {
     /// - Ok(HookResult::Deny) if hook denies (exit code 2)
     /// - Err if hook fails (other exit codes) or times out
     pub async fn execute(&self, event: &HookEvent, timeout_ms: Option<u64>) -> Result<HookResult> {
+        // First check for legacy file-based hooks
         let hook_path = self.get_hook_path(event);
+        let has_file_hook = hook_path.exists();
 
-        // If hook doesn't exist, allow by default
+        // Get registered hooks for this event
-        if !hook_path.exists() {
+        let event_name = event.hook_name();
+        let mut matching_hooks: Vec<&Hook> = self.hooks.iter()
+            .filter(|h| h.event == event_name)
+            .collect();
+
+        // If we need to filter by pattern (for PreToolUse events)
+        if let HookEvent::PreToolUse { tool, .. } = event {
+            matching_hooks.retain(|h| {
+                if let Some(pattern) = &h.pattern {
+                    // Use regex to match tool name
+                    if let Ok(re) = regex::Regex::new(pattern) {
+                        re.is_match(tool)
+                    } else {
+                        false
+                    }
+                } else {
+                    true  // No pattern means match all
+                }
+            });
+        }
+
+        // If no hooks at all, allow by default
+        if !has_file_hook && matching_hooks.is_empty() {
             return Ok(HookResult::Allow);
         }
 
+        // Execute file-based hook first (if exists)
+        if has_file_hook {
+            let result = self.execute_hook_command(&hook_path.to_string_lossy(), event, timeout_ms).await?;
+            if result == HookResult::Deny {
+                return Ok(HookResult::Deny);
+            }
+        }
+
+        // Execute registered hooks
+        for hook in matching_hooks {
+            let hook_timeout = hook.timeout.or(timeout_ms);
+            let result = self.execute_hook_command(&hook.command, event, hook_timeout).await?;
+            if result == HookResult::Deny {
+                return Ok(HookResult::Deny);
+            }
+        }
+
+        Ok(HookResult::Allow)
+    }
+
+    /// Execute a single hook command
+    async fn execute_hook_command(&self, command: &str, event: &HookEvent, timeout_ms: Option<u64>) -> Result<HookResult> {
         // Serialize event to JSON
         let input_json = serde_json::to_string(event)?;
 
         // Spawn the hook process
-        let mut child = Command::new(&hook_path)
+        let mut child = Command::new("sh")
+            .arg("-c")
+            .arg(command)
             .stdin(Stdio::piped())
             .stdout(Stdio::piped())
             .stderr(Stdio::piped())

crates/platform/hooks/tests/plugin_hooks.rs

@@ -0,0 +1,154 @@
+// Integration test for plugin hooks with HookManager
+use color_eyre::eyre::Result;
+use hooks::{HookEvent, HookManager, HookResult};
+use tempfile::TempDir;
+
+#[tokio::test]
+async fn test_register_and_execute_plugin_hooks() -> Result<()> {
+    // Create temporary directory to act as project root
+    let temp_dir = TempDir::new()?;
+
+    // Create hook manager
+    let mut hook_mgr = HookManager::new(temp_dir.path().to_str().unwrap());
+
+    // Register a hook that matches Edit|Write tools
+    hook_mgr.register_hook(
+        "PreToolUse".to_string(),
+        "echo 'Hook executed' && exit 0".to_string(),
+        Some("Edit|Write".to_string()),
+        Some(5000),
+    );
+
+    // Test that the hook executes for Edit tool
+    let event = HookEvent::PreToolUse {
+        tool: "Edit".to_string(),
+        args: serde_json::json!({"path": "/tmp/test.txt"}),
+    };
+
+    let result = hook_mgr.execute(&event, Some(5000)).await?;
+    assert_eq!(result, HookResult::Allow);
+
+    // Test that the hook executes for Write tool
+    let event = HookEvent::PreToolUse {
+        tool: "Write".to_string(),
+        args: serde_json::json!({"path": "/tmp/test.txt"}),
+    };
+
+    let result = hook_mgr.execute(&event, Some(5000)).await?;
+    assert_eq!(result, HookResult::Allow);
+
+    // Test that the hook does NOT execute for Read tool (doesn't match pattern)
+    let event = HookEvent::PreToolUse {
+        tool: "Read".to_string(),
+        args: serde_json::json!({"path": "/tmp/test.txt"}),
+    };
+
+    let result = hook_mgr.execute(&event, Some(5000)).await?;
+    assert_eq!(result, HookResult::Allow);
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_deny_hook() -> Result<()> {
+    // Create temporary directory to act as project root
+    let temp_dir = TempDir::new()?;
+
+    // Create hook manager
+    let mut hook_mgr = HookManager::new(temp_dir.path().to_str().unwrap());
+
+    // Register a hook that denies Write operations
+    hook_mgr.register_hook(
+        "PreToolUse".to_string(),
+        "exit 2".to_string(),  // Exit code 2 means deny
+        Some("Write".to_string()),
+        Some(5000),
+    );
+
+    // Test that the hook denies Write tool
+    let event = HookEvent::PreToolUse {
+        tool: "Write".to_string(),
+        args: serde_json::json!({"path": "/tmp/test.txt"}),
+    };
+
+    let result = hook_mgr.execute(&event, Some(5000)).await?;
+    assert_eq!(result, HookResult::Deny);
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_multiple_hooks_same_event() -> Result<()> {
+    // Create temporary directory to act as project root
+    let temp_dir = TempDir::new()?;
+
+    // Create hook manager
+    let mut hook_mgr = HookManager::new(temp_dir.path().to_str().unwrap());
+
+    // Register multiple hooks for the same event
+    hook_mgr.register_hook(
+        "PreToolUse".to_string(),
+        "echo 'Hook 1' && exit 0".to_string(),
+        Some("Edit".to_string()),
+        Some(5000),
+    );
+
+    hook_mgr.register_hook(
+        "PreToolUse".to_string(),
+        "echo 'Hook 2' && exit 0".to_string(),
+        Some("Edit".to_string()),
+        Some(5000),
+    );
+
+    // Test that both hooks execute
+    let event = HookEvent::PreToolUse {
+        tool: "Edit".to_string(),
+        args: serde_json::json!({"path": "/tmp/test.txt"}),
+    };
+
+    let result = hook_mgr.execute(&event, Some(5000)).await?;
+    assert_eq!(result, HookResult::Allow);
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_hook_with_no_pattern_matches_all() -> Result<()> {
+    // Create temporary directory to act as project root
+    let temp_dir = TempDir::new()?;
+
+    // Create hook manager
+    let mut hook_mgr = HookManager::new(temp_dir.path().to_str().unwrap());
+
+    // Register a hook with no pattern (matches all tools)
+    hook_mgr.register_hook(
+        "PreToolUse".to_string(),
+        "echo 'Hook for all tools' && exit 0".to_string(),
+        None,  // No pattern = match all
+        Some(5000),
+    );
+
+    // Test that the hook executes for any tool
+    let event = HookEvent::PreToolUse {
+        tool: "Read".to_string(),
+        args: serde_json::json!({"path": "/tmp/test.txt"}),
+    };
+    let result = hook_mgr.execute(&event, Some(5000)).await?;
+    assert_eq!(result, HookResult::Allow);
+
+    let event = HookEvent::PreToolUse {
+        tool: "Write".to_string(),
+        args: serde_json::json!({"path": "/tmp/test.txt"}),
+    };
+    let result = hook_mgr.execute(&event, Some(5000)).await?;
+    assert_eq!(result, HookResult::Allow);
+
+    let event = HookEvent::PreToolUse {
+        tool: "Bash".to_string(),
+        args: serde_json::json!({"command": "ls"}),
+    };
+    let result = hook_mgr.execute(&event, Some(5000)).await?;
+    assert_eq!(result, HookResult::Allow);
+
+    Ok(())
+}

crates/platform/permissions/src/lib.rs

@@ -16,6 +16,12 @@ pub enum Tool {
     Task,
     TodoWrite,
     Mcp,
+    // New tools
+    MultiEdit,
+    LS,
+    AskUserQuestion,
+    BashOutput,
+    KillShell,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
@@ -123,23 +129,27 @@ impl PermissionManager {
         match self.mode {
             Mode::Plan => match tool {
                 // Read-only tools are allowed in plan mode
-                Tool::Read | Tool::Grep | Tool::Glob | Tool::NotebookRead => {
+                Tool::Read | Tool::Grep | Tool::Glob | Tool::NotebookRead | Tool::LS => {
                     PermissionDecision::Allow
                 }
+                // User interaction and session state tools allowed
+                Tool::AskUserQuestion | Tool::TodoWrite => PermissionDecision::Allow,
                 // Everything else requires asking
                 _ => PermissionDecision::Ask,
             },
             Mode::AcceptEdits => match tool {
                 // Read operations allowed
-                Tool::Read | Tool::Grep | Tool::Glob | Tool::NotebookRead => {
+                Tool::Read | Tool::Grep | Tool::Glob | Tool::NotebookRead | Tool::LS => {
                     PermissionDecision::Allow
                 }
                 // Edit/Write operations allowed
-                Tool::Edit | Tool::Write | Tool::NotebookEdit => PermissionDecision::Allow,
+                Tool::Edit | Tool::Write | Tool::NotebookEdit | Tool::MultiEdit => PermissionDecision::Allow,
                 // Bash and other dangerous operations still require asking
                 Tool::Bash | Tool::WebFetch | Tool::WebSearch | Tool::Mcp => PermissionDecision::Ask,
+                // Background shell operations same as Bash
+                Tool::BashOutput | Tool::KillShell => PermissionDecision::Ask,
                 // Utility tools allowed
-                Tool::TodoWrite | Tool::SlashCommand | Tool::Task => PermissionDecision::Allow,
+                Tool::TodoWrite | Tool::SlashCommand | Tool::Task | Tool::AskUserQuestion => PermissionDecision::Allow,
             },
             Mode::Code => {
                 // Everything allowed in code mode

crates/platform/plugins/Cargo.toml

@@ -8,6 +8,7 @@ color-eyre = "0.6"
 dirs = "5.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
+serde_yaml = "0.9"
 walkdir = "2.5"
 
 [dev-dependencies]

crates/platform/plugins/src/lib.rs

@@ -44,6 +44,109 @@ pub struct McpServerConfig {
     pub env: HashMap<String, String>,
 }
 
+/// Plugin hook configuration from hooks/hooks.json
+#[derive(Debug, Clone, Deserialize)]
+pub struct PluginHooksConfig {
+    pub description: Option<String>,
+    pub hooks: HashMap<String, Vec<HookMatcher>>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct HookMatcher {
+    pub matcher: Option<String>,  // Regex pattern for tool names
+    pub hooks: Vec<HookDefinition>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct HookDefinition {
+    #[serde(rename = "type")]
+    pub hook_type: String,  // "command" or "prompt"
+    pub command: Option<String>,
+    pub prompt: Option<String>,
+    pub timeout: Option<u64>,
+}
+
+/// Parsed slash command from markdown file
+#[derive(Debug, Clone)]
+pub struct SlashCommand {
+    pub name: String,
+    pub description: Option<String>,
+    pub argument_hint: Option<String>,
+    pub allowed_tools: Option<Vec<String>>,
+    pub body: String,  // Markdown content after frontmatter
+    pub source_path: PathBuf,
+}
+
+/// Parsed agent definition from markdown file
+#[derive(Debug, Clone)]
+pub struct AgentDefinition {
+    pub name: String,
+    pub description: String,
+    pub tools: Vec<String>,  // Tool whitelist
+    pub model: Option<String>,  // haiku, sonnet, opus
+    pub color: Option<String>,
+    pub system_prompt: String,  // Markdown body
+    pub source_path: PathBuf,
+}
+
+/// Parsed skill definition
+#[derive(Debug, Clone)]
+pub struct Skill {
+    pub name: String,
+    pub description: String,
+    pub version: Option<String>,
+    pub content: String,  // Core SKILL.md content
+    pub references: Vec<PathBuf>,  // Reference files
+    pub examples: Vec<PathBuf>,  // Example files
+    pub source_path: PathBuf,
+}
+
+/// YAML frontmatter for command files
+#[derive(Deserialize)]
+struct CommandFrontmatter {
+    description: Option<String>,
+    #[serde(rename = "argument-hint")]
+    argument_hint: Option<String>,
+    #[serde(rename = "allowed-tools")]
+    allowed_tools: Option<String>,
+}
+
+/// YAML frontmatter for agent files
+#[derive(Deserialize)]
+struct AgentFrontmatter {
+    name: String,
+    description: String,
+    #[serde(default)]
+    tools: Vec<String>,
+    model: Option<String>,
+    color: Option<String>,
+}
+
+/// YAML frontmatter for skill files
+#[derive(Deserialize)]
+struct SkillFrontmatter {
+    name: String,
+    description: String,
+    version: Option<String>,
+}
+
+/// Parse YAML frontmatter from markdown content
+fn parse_frontmatter<T: serde::de::DeserializeOwned>(content: &str) -> Result<(T, String)> {
+    if !content.starts_with("---") {
+        return Err(eyre!("No frontmatter found"));
+    }
+
+    let parts: Vec<&str> = content.splitn(3, "---").collect();
+    if parts.len() < 3 {
+        return Err(eyre!("Invalid frontmatter format"));
+    }
+
+    let frontmatter: T = serde_yaml::from_str(parts[1].trim())?;
+    let body = parts[2].trim().to_string();
+
+    Ok((frontmatter, body))
+}
+
 /// A loaded plugin with its manifest and base path
 #[derive(Debug, Clone)]
 pub struct Plugin {
@@ -64,7 +167,7 @@ impl Plugin {
 
     /// Get the path to a skill file
     pub fn skill_path(&self, skill_name: &str) -> PathBuf {
-        self.base_path.join("skills").join(format!("{}.md", skill_name))
+        self.base_path.join("skills").join(skill_name).join("SKILL.md")
     }
 
     /// Get the path to a hook script
@@ -73,6 +176,210 @@ impl Plugin {
             self.base_path.join("hooks").join(path)
         })
     }
+
+    /// Parse a command file
+    pub fn parse_command(&self, name: &str) -> Result<SlashCommand> {
+        let path = self.command_path(name);
+        let content = fs::read_to_string(&path)?;
+        let (fm, body): (CommandFrontmatter, String) = parse_frontmatter(&content)?;
+
+        let allowed_tools = fm.allowed_tools.map(|s| {
+            s.split(',').map(|t| t.trim().to_string()).collect()
+        });
+
+        Ok(SlashCommand {
+            name: name.to_string(),
+            description: fm.description,
+            argument_hint: fm.argument_hint,
+            allowed_tools,
+            body,
+            source_path: path,
+        })
+    }
+
+    /// Parse an agent file
+    pub fn parse_agent(&self, name: &str) -> Result<AgentDefinition> {
+        let path = self.agent_path(name);
+        let content = fs::read_to_string(&path)?;
+        let (fm, body): (AgentFrontmatter, String) = parse_frontmatter(&content)?;
+
+        Ok(AgentDefinition {
+            name: fm.name,
+            description: fm.description,
+            tools: fm.tools,
+            model: fm.model,
+            color: fm.color,
+            system_prompt: body,
+            source_path: path,
+        })
+    }
+
+    /// Parse a skill file
+    pub fn parse_skill(&self, name: &str) -> Result<Skill> {
+        let path = self.skill_path(name);
+        let content = fs::read_to_string(&path)?;
+        let (fm, body): (SkillFrontmatter, String) = parse_frontmatter(&content)?;
+
+        // Discover reference and example files in the skill directory
+        let skill_dir = self.base_path.join("skills").join(name);
+        let references_dir = skill_dir.join("references");
+        let examples_dir = skill_dir.join("examples");
+
+        let references = if references_dir.exists() {
+            fs::read_dir(&references_dir)
+                .into_iter()
+                .flatten()
+                .filter_map(|e| e.ok())
+                .map(|e| e.path())
+                .collect()
+        } else {
+            Vec::new()
+        };
+
+        let examples = if examples_dir.exists() {
+            fs::read_dir(&examples_dir)
+                .into_iter()
+                .flatten()
+                .filter_map(|e| e.ok())
+                .map(|e| e.path())
+                .collect()
+        } else {
+            Vec::new()
+        };
+
+        Ok(Skill {
+            name: fm.name,
+            description: fm.description,
+            version: fm.version,
+            content: body,
+            references,
+            examples,
+            source_path: path,
+        })
+    }
+
+    /// Auto-discover commands in the commands/ directory
+    pub fn discover_commands(&self) -> Vec<String> {
+        let commands_dir = self.base_path.join("commands");
+        if !commands_dir.exists() {
+            return Vec::new();
+        }
+
+        std::fs::read_dir(&commands_dir)
+            .into_iter()
+            .flatten()
+            .filter_map(|e| e.ok())
+            .filter(|e| e.path().extension().map(|ext| ext == "md").unwrap_or(false))
+            .filter_map(|e| {
+                e.path().file_stem()
+                    .map(|s| s.to_string_lossy().to_string())
+            })
+            .collect()
+    }
+
+    /// Auto-discover agents in the agents/ directory
+    pub fn discover_agents(&self) -> Vec<String> {
+        let agents_dir = self.base_path.join("agents");
+        if !agents_dir.exists() {
+            return Vec::new();
+        }
+
+        std::fs::read_dir(&agents_dir)
+            .into_iter()
+            .flatten()
+            .filter_map(|e| e.ok())
+            .filter(|e| e.path().extension().map(|ext| ext == "md").unwrap_or(false))
+            .filter_map(|e| {
+                e.path().file_stem()
+                    .map(|s| s.to_string_lossy().to_string())
+            })
+            .collect()
+    }
+
+    /// Auto-discover skills in skills/*/SKILL.md
+    pub fn discover_skills(&self) -> Vec<String> {
+        let skills_dir = self.base_path.join("skills");
+        if !skills_dir.exists() {
+            return Vec::new();
+        }
+
+        std::fs::read_dir(&skills_dir)
+            .into_iter()
+            .flatten()
+            .filter_map(|e| e.ok())
+            .filter(|e| e.path().is_dir())
+            .filter(|e| e.path().join("SKILL.md").exists())
+            .filter_map(|e| {
+                e.path().file_name()
+                    .map(|s| s.to_string_lossy().to_string())
+            })
+            .collect()
+    }
+
+    /// Get all commands (manifest + discovered)
+    pub fn all_command_names(&self) -> Vec<String> {
+        let mut names: std::collections::HashSet<String> =
+            self.manifest.commands.iter().cloned().collect();
+        names.extend(self.discover_commands());
+        names.into_iter().collect()
+    }
+
+    /// Get all agent names (manifest + discovered)
+    pub fn all_agent_names(&self) -> Vec<String> {
+        let mut names: std::collections::HashSet<String> =
+            self.manifest.agents.iter().cloned().collect();
+        names.extend(self.discover_agents());
+        names.into_iter().collect()
+    }
+
+    /// Get all skill names (manifest + discovered)
+    pub fn all_skill_names(&self) -> Vec<String> {
+        let mut names: std::collections::HashSet<String> =
+            self.manifest.skills.iter().cloned().collect();
+        names.extend(self.discover_skills());
+        names.into_iter().collect()
+    }
+
+    /// Load hooks configuration from hooks/hooks.json
+    pub fn load_hooks_config(&self) -> Result<Option<PluginHooksConfig>> {
+        let hooks_path = self.base_path.join("hooks").join("hooks.json");
+        if !hooks_path.exists() {
+            return Ok(None);
+        }
+
+        let content = fs::read_to_string(&hooks_path)?;
+        let config: PluginHooksConfig = serde_json::from_str(&content)?;
+        Ok(Some(config))
+    }
+
+    /// Register hooks from this plugin's config into a hook manager
+    /// This requires the hooks crate to be available where this is called
+    pub fn register_hooks_with_manager(&self, config: &PluginHooksConfig) -> Vec<(String, String, Option<String>, Option<u64>)> {
+        let mut hooks_to_register = Vec::new();
+
+        for (event_name, matchers) in &config.hooks {
+            for matcher in matchers {
+                for hook_def in &matcher.hooks {
+                    if let Some(command) = &hook_def.command {
+                        // Substitute ${CLAUDE_PLUGIN_ROOT}
+                        let resolved = command.replace(
+                            "${CLAUDE_PLUGIN_ROOT}",
+                            &self.base_path.to_string_lossy()
+                        );
+
+                        hooks_to_register.push((
+                            event_name.clone(),
+                            resolved,
+                            matcher.matcher.clone(),
+                            hook_def.timeout,
+                        ));
+                    }
+                }
+            }
+        }
+
+        hooks_to_register
+    }
 }
 
 /// Plugin loader and registry
@@ -232,6 +539,45 @@ impl PluginManager {
 
         servers
     }
+
+    /// Get all parsed commands
+    pub fn load_all_commands(&self) -> Vec<SlashCommand> {
+        let mut commands = Vec::new();
+        for plugin in &self.plugins {
+            for cmd_name in &plugin.manifest.commands {
+                if let Ok(cmd) = plugin.parse_command(cmd_name) {
+                    commands.push(cmd);
+                }
+            }
+        }
+        commands
+    }
+
+    /// Get all parsed agents
+    pub fn load_all_agents(&self) -> Vec<AgentDefinition> {
+        let mut agents = Vec::new();
+        for plugin in &self.plugins {
+            for agent_name in &plugin.manifest.agents {
+                if let Ok(agent) = plugin.parse_agent(agent_name) {
+                    agents.push(agent);
+                }
+            }
+        }
+        agents
+    }
+
+    /// Get all parsed skills
+    pub fn load_all_skills(&self) -> Vec<Skill> {
+        let mut skills = Vec::new();
+        for plugin in &self.plugins {
+            for skill_name in &plugin.manifest.skills {
+                if let Ok(skill) = plugin.parse_skill(skill_name) {
+                    skills.push(skill);
+                }
+            }
+        }
+        skills
+    }
 }
 
 impl Default for PluginManager {
@@ -274,12 +620,12 @@ mod tests {
 
         fs::write(
             dir.join("commands/test-cmd.md"),
-            "# Test Command\nThis is a test command.",
+            "---\ndescription: A test command\nargument-hint: <file>\nallowed-tools: read,write\n---\n\nThis is a test command body.",
         )?;
 
         fs::write(
             dir.join("agents/test-agent.md"),
-            "# Test Agent\nThis is a test agent.",
+            "---\nname: test-agent\ndescription: A test agent\ntools:\n  - read\n  - write\nmodel: sonnet\ncolor: blue\n---\n\nYou are a helpful test agent.",
         )?;
 
         Ok(())
@@ -351,4 +697,77 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn test_parse_command() -> Result<()> {
+        let temp_dir = tempfile::tempdir()?;
+        let plugin_dir = temp_dir.path().join("test-plugin");
+        create_test_plugin(&plugin_dir)?;
+
+        let manager = PluginManager::with_dirs(vec![temp_dir.path().to_path_buf()]);
+        let plugin = manager.load_plugin(&plugin_dir)?;
+
+        let cmd = plugin.parse_command("test-cmd")?;
+        assert_eq!(cmd.name, "test-cmd");
+        assert_eq!(cmd.description, Some("A test command".to_string()));
+        assert_eq!(cmd.argument_hint, Some("<file>".to_string()));
+        assert_eq!(cmd.allowed_tools, Some(vec!["read".to_string(), "write".to_string()]));
+        assert_eq!(cmd.body, "This is a test command body.");
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_parse_agent() -> Result<()> {
+        let temp_dir = tempfile::tempdir()?;
+        let plugin_dir = temp_dir.path().join("test-plugin");
+        create_test_plugin(&plugin_dir)?;
+
+        let manager = PluginManager::with_dirs(vec![temp_dir.path().to_path_buf()]);
+        let plugin = manager.load_plugin(&plugin_dir)?;
+
+        let agent = plugin.parse_agent("test-agent")?;
+        assert_eq!(agent.name, "test-agent");
+        assert_eq!(agent.description, "A test agent");
+        assert_eq!(agent.tools, vec!["read", "write"]);
+        assert_eq!(agent.model, Some("sonnet".to_string()));
+        assert_eq!(agent.color, Some("blue".to_string()));
+        assert_eq!(agent.system_prompt, "You are a helpful test agent.");
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_load_all_commands() -> Result<()> {
+        let temp_dir = tempfile::tempdir()?;
+        let plugin_dir = temp_dir.path().join("test-plugin");
+        create_test_plugin(&plugin_dir)?;
+
+        let mut manager = PluginManager::with_dirs(vec![temp_dir.path().to_path_buf()]);
+        manager.load_all()?;
+
+        let commands = manager.load_all_commands();
+        assert_eq!(commands.len(), 1);
+        assert_eq!(commands[0].name, "test-cmd");
+        assert_eq!(commands[0].description, Some("A test command".to_string()));
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_load_all_agents() -> Result<()> {
+        let temp_dir = tempfile::tempdir()?;
+        let plugin_dir = temp_dir.path().join("test-plugin");
+        create_test_plugin(&plugin_dir)?;
+
+        let mut manager = PluginManager::with_dirs(vec![temp_dir.path().to_path_buf()]);
+        manager.load_all()?;
+
+        let agents = manager.load_all_agents();
+        assert_eq!(agents.len(), 1);
+        assert_eq!(agents[0].name, "test-agent");
+        assert_eq!(agents[0].description, "A test agent");
+
+        Ok(())
+    }
 }

crates/platform/plugins/tests/plugin_hooks_integration.rs

@@ -0,0 +1,175 @@
+// End-to-end integration test for plugin hooks
+use color_eyre::eyre::Result;
+use plugins::PluginManager;
+use std::fs;
+use tempfile::TempDir;
+
+fn create_test_plugin_with_hooks(plugin_dir: &std::path::Path) -> Result<()> {
+    fs::create_dir_all(plugin_dir)?;
+
+    // Create plugin manifest
+    let manifest = serde_json::json!({
+        "name": "test-hook-plugin",
+        "version": "1.0.0",
+        "description": "Test plugin with hooks",
+        "commands": [],
+        "agents": [],
+        "skills": [],
+        "hooks": {},
+        "mcp_servers": []
+    });
+    fs::write(
+        plugin_dir.join("plugin.json"),
+        serde_json::to_string_pretty(&manifest)?,
+    )?;
+
+    // Create hooks directory and hooks.json
+    let hooks_dir = plugin_dir.join("hooks");
+    fs::create_dir_all(&hooks_dir)?;
+
+    let hooks_config = serde_json::json!({
+        "description": "Validate edit and write operations",
+        "hooks": {
+            "PreToolUse": [
+                {
+                    "matcher": "Edit|Write",
+                    "hooks": [
+                        {
+                            "type": "command",
+                            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/validate.py",
+                            "timeout": 5000
+                        }
+                    ]
+                },
+                {
+                    "matcher": "Bash",
+                    "hooks": [
+                        {
+                            "type": "command",
+                            "command": "echo 'Bash hook' && exit 0"
+                        }
+                    ]
+                }
+            ],
+            "PostToolUse": [
+                {
+                    "hooks": [
+                        {
+                            "type": "command",
+                            "command": "echo 'Post-tool hook' && exit 0"
+                        }
+                    ]
+                }
+            ]
+        }
+    });
+    fs::write(
+        hooks_dir.join("hooks.json"),
+        serde_json::to_string_pretty(&hooks_config)?,
+    )?;
+
+    Ok(())
+}
+
+#[test]
+fn test_load_plugin_hooks_config() -> Result<()> {
+    let temp_dir = TempDir::new()?;
+    let plugin_dir = temp_dir.path().join("test-plugin");
+    create_test_plugin_with_hooks(&plugin_dir)?;
+
+    // Load all plugins
+    let mut plugin_manager = PluginManager::with_dirs(vec![temp_dir.path().to_path_buf()]);
+    plugin_manager.load_all()?;
+
+    assert_eq!(plugin_manager.plugins().len(), 1);
+    let plugin = &plugin_manager.plugins()[0];
+
+    // Load hooks config
+    let hooks_config = plugin.load_hooks_config()?;
+    assert!(hooks_config.is_some());
+
+    let config = hooks_config.unwrap();
+    assert_eq!(config.description, Some("Validate edit and write operations".to_string()));
+    assert!(config.hooks.contains_key("PreToolUse"));
+    assert!(config.hooks.contains_key("PostToolUse"));
+
+    // Check PreToolUse hooks
+    let pre_tool_hooks = &config.hooks["PreToolUse"];
+    assert_eq!(pre_tool_hooks.len(), 2);
+
+    // First matcher: Edit|Write
+    assert_eq!(pre_tool_hooks[0].matcher, Some("Edit|Write".to_string()));
+    assert_eq!(pre_tool_hooks[0].hooks.len(), 1);
+    assert_eq!(pre_tool_hooks[0].hooks[0].hook_type, "command");
+    assert!(pre_tool_hooks[0].hooks[0].command.as_ref().unwrap().contains("validate.py"));
+
+    // Second matcher: Bash
+    assert_eq!(pre_tool_hooks[1].matcher, Some("Bash".to_string()));
+    assert_eq!(pre_tool_hooks[1].hooks.len(), 1);
+
+    Ok(())
+}
+
+#[test]
+fn test_plugin_hooks_substitution() -> Result<()> {
+    let temp_dir = TempDir::new()?;
+    let plugin_dir = temp_dir.path().join("test-plugin");
+    create_test_plugin_with_hooks(&plugin_dir)?;
+
+    // Load all plugins
+    let mut plugin_manager = PluginManager::with_dirs(vec![temp_dir.path().to_path_buf()]);
+    plugin_manager.load_all()?;
+
+    assert_eq!(plugin_manager.plugins().len(), 1);
+    let plugin = &plugin_manager.plugins()[0];
+
+    // Load hooks config and register
+    let hooks_config = plugin.load_hooks_config()?.unwrap();
+    let hooks_to_register = plugin.register_hooks_with_manager(&hooks_config);
+
+    // Check that ${CLAUDE_PLUGIN_ROOT} was substituted
+    let edit_write_hook = hooks_to_register.iter()
+        .find(|(event, _, pattern, _)| {
+            event == "PreToolUse" && pattern.as_ref().map(|p| p.contains("Edit")).unwrap_or(false)
+        })
+        .unwrap();
+
+    // The command should have the plugin path substituted
+    assert!(edit_write_hook.1.contains(&plugin_dir.to_string_lossy().to_string()));
+    assert!(edit_write_hook.1.contains("validate.py"));
+    assert!(!edit_write_hook.1.contains("${CLAUDE_PLUGIN_ROOT}"));
+
+    Ok(())
+}
+
+#[test]
+fn test_multiple_plugins_with_hooks() -> Result<()> {
+    let temp_dir = TempDir::new()?;
+
+    // Create two plugins with hooks
+    let plugin1_dir = temp_dir.path().join("plugin1");
+    create_test_plugin_with_hooks(&plugin1_dir)?;
+
+    let plugin2_dir = temp_dir.path().join("plugin2");
+    create_test_plugin_with_hooks(&plugin2_dir)?;
+
+    // Load all plugins
+    let mut plugin_manager = PluginManager::with_dirs(vec![temp_dir.path().to_path_buf()]);
+    plugin_manager.load_all()?;
+
+    assert_eq!(plugin_manager.plugins().len(), 2);
+
+    // Collect all hooks from all plugins
+    let mut total_hooks = 0;
+    for plugin in plugin_manager.plugins() {
+        if let Ok(Some(hooks_config)) = plugin.load_hooks_config() {
+            let hooks = plugin.register_hooks_with_manager(&hooks_config);
+            total_hooks += hooks.len();
+        }
+    }
+
+    // Each plugin has 3 hooks (2 PreToolUse + 1 PostToolUse)
+    assert_eq!(total_hooks, 6);
+
+    Ok(())
+}

crates/tools/ask/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "tools-ask"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+tokio = { version = "1", features = ["sync"] }
+color-eyre = "0.6"

crates/tools/ask/src/lib.rs

@@ -0,0 +1,60 @@
+//! AskUserQuestion tool for interactive user input
+
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use tokio::sync::{mpsc, oneshot};
+
+/// A question option
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct QuestionOption {
+    pub label: String,
+    pub description: String,
+}
+
+/// A question to ask the user
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Question {
+    pub question: String,
+    pub header: String,
+    pub options: Vec<QuestionOption>,
+    pub multi_select: bool,
+}
+
+/// Request sent to the UI to ask questions
+#[derive(Debug)]
+pub struct AskRequest {
+    pub questions: Vec<Question>,
+    pub response_tx: oneshot::Sender<HashMap<String, String>>,
+}
+
+/// Channel for sending ask requests to the UI
+pub type AskSender = mpsc::Sender<AskRequest>;
+pub type AskReceiver = mpsc::Receiver<AskRequest>;
+
+/// Create a channel pair for ask requests
+pub fn create_ask_channel() -> (AskSender, AskReceiver) {
+    mpsc::channel(1)
+}
+
+/// Ask the user questions (called by agent)
+pub async fn ask_user(
+    sender: &AskSender,
+    questions: Vec<Question>,
+) -> color_eyre::Result<HashMap<String, String>> {
+    let (response_tx, response_rx) = oneshot::channel();
+
+    sender.send(AskRequest { questions, response_tx }).await
+        .map_err(|_| color_eyre::eyre::eyre!("Failed to send ask request"))?;
+
+    response_rx.await
+        .map_err(|_| color_eyre::eyre::eyre!("Failed to receive ask response"))
+}
+
+/// Parse questions from JSON tool input
+pub fn parse_questions(input: &serde_json::Value) -> color_eyre::Result<Vec<Question>> {
+    let questions = input.get("questions")
+        .ok_or_else(|| color_eyre::eyre::eyre!("Missing 'questions' field"))?;
+
+    serde_json::from_value(questions.clone())
+        .map_err(|e| color_eyre::eyre::eyre!("Invalid questions format: {}", e))
+}

crates/tools/bash/Cargo.toml

@@ -6,9 +6,11 @@ license.workspace = true
 rust-version.workspace = true
 
 [dependencies]
-tokio = { version = "1.39", features = ["process", "io-util", "time", "sync"] }
+tokio = { version = "1.39", features = ["process", "io-util", "time", "sync", "rt"] }
 color-eyre = "0.6"
 tempfile = "3.23.0"
+parking_lot = "0.12"
+uuid = { version = "1.0", features = ["v4"] }
 
 [dev-dependencies]
 tokio = { version = "1.39", features = ["macros", "rt-multi-thread"] }

crates/tools/bash/src/lib.rs

@@ -1,5 +1,8 @@
 use color_eyre::eyre::{Result, eyre};
+use std::collections::HashMap;
 use std::process::Stdio;
+use std::sync::Arc;
+use parking_lot::RwLock;
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 use tokio::process::{Child, Command};
 use tokio::sync::Mutex;
@@ -19,6 +22,7 @@ pub struct CommandOutput {
 
 pub struct BashSession {
     child: Mutex<Child>,
+    last_output: Option<String>,
 }
 
 impl BashSession {
@@ -40,6 +44,7 @@ impl BashSession {
 
         Ok(Self {
             child: Mutex::new(child),
+            last_output: None,
         })
     }
 
@@ -54,7 +59,13 @@ impl BashSession {
         let result = timeout(timeout_duration, self.execute_internal(command)).await;
 
         match result {
-            Ok(output) => output,
+            Ok(output) => {
+                // Store the output for potential retrieval via BashOutput tool
+                let combined = format!("{}{}", output.as_ref().map(|o| o.stdout.as_str()).unwrap_or(""),
+                                                output.as_ref().map(|o| o.stderr.as_str()).unwrap_or(""));
+                self.last_output = Some(combined);
+                output
+            },
             Err(_) => Err(eyre!("Command timed out after {}ms", timeout_duration.as_millis())),
         }
     }
@@ -158,6 +169,106 @@ impl BashSession {
     }
 }
 
+/// Manages background bash shells by ID
+#[derive(Clone, Default)]
+pub struct ShellManager {
+    shells: Arc<RwLock<HashMap<String, BashSession>>>,
+}
+
+impl ShellManager {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Start a new background shell, returns shell ID
+    pub async fn start_shell(&self) -> Result<String> {
+        let id = uuid::Uuid::new_v4().to_string();
+        let session = BashSession::new().await?;
+        self.shells.write().insert(id.clone(), session);
+        Ok(id)
+    }
+
+    /// Execute command in background shell
+    pub async fn execute(&self, shell_id: &str, command: &str, timeout: Option<Duration>) -> Result<CommandOutput> {
+        // We need to handle this carefully to avoid holding the lock across await
+        // First check if the shell exists and clone what we need
+        let exists = self.shells.read().contains_key(shell_id);
+        if !exists {
+            return Err(eyre!("Shell not found: {}", shell_id));
+        }
+
+        // For now, we need to use a more complex approach since BashSession contains async operations
+        // We'll execute and then update in a separate critical section
+        let timeout_ms = timeout.map(|d| d.as_millis() as u64);
+
+        // Take temporary ownership for execution
+        let mut session = {
+            let mut shells = self.shells.write();
+            shells.remove(shell_id)
+                .ok_or_else(|| eyre!("Shell not found: {}", shell_id))?
+        };
+
+        // Execute without holding the lock
+        let result = session.execute(command, timeout_ms).await;
+
+        // Put the session back
+        self.shells.write().insert(shell_id.to_string(), session);
+
+        result
+    }
+
+    /// Get output from a shell (BashOutput tool)
+    pub fn get_output(&self, shell_id: &str) -> Result<Option<String>> {
+        let shells = self.shells.read();
+        let session = shells.get(shell_id)
+            .ok_or_else(|| eyre!("Shell not found: {}", shell_id))?;
+        // Return any buffered output
+        Ok(session.last_output.clone())
+    }
+
+    /// Kill a shell (KillShell tool)
+    pub fn kill_shell(&self, shell_id: &str) -> Result<()> {
+        let mut shells = self.shells.write();
+        if shells.remove(shell_id).is_some() {
+            Ok(())
+        } else {
+            Err(eyre!("Shell not found: {}", shell_id))
+        }
+    }
+
+    /// List active shells
+    pub fn list_shells(&self) -> Vec<String> {
+        self.shells.read().keys().cloned().collect()
+    }
+}
+
+/// Start a background bash command, returns shell ID
+pub async fn run_background(manager: &ShellManager, command: &str) -> Result<String> {
+    let shell_id = manager.start_shell().await?;
+    // Execute in background (non-blocking)
+    tokio::spawn({
+        let manager = manager.clone();
+        let command = command.to_string();
+        let shell_id = shell_id.clone();
+        async move {
+            let _ = manager.execute(&shell_id, &command, None).await;
+        }
+    });
+    Ok(shell_id)
+}
+
+/// Get output from background shell (BashOutput tool)
+pub fn bash_output(manager: &ShellManager, shell_id: &str) -> Result<String> {
+    manager.get_output(shell_id)?
+        .ok_or_else(|| eyre!("No output available"))
+}
+
+/// Kill a background shell (KillShell tool)
+pub fn kill_shell(manager: &ShellManager, shell_id: &str) -> Result<String> {
+    manager.kill_shell(shell_id)?;
+    Ok(format!("Shell {} terminated", shell_id))
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/tools/fs/Cargo.toml

@@ -13,6 +13,8 @@ grep-regex = "0.1"
 grep-searcher = "0.1"
 color-eyre = "0.6"
 similar = "2.7"
+serde = { version = "1.0", features = ["derive"] }
+humantime = "2.1"
 
 [dev-dependencies]
 tempfile = "3.23.0"

crates/tools/fs/src/lib.rs

@@ -3,6 +3,7 @@ use ignore::WalkBuilder;
 use grep_regex::RegexMatcher;
 use grep_searcher::{sinks::UTF8, SearcherBuilder};
 use globset::Glob;
+use serde::{Deserialize, Serialize};
 use std::path::Path;
 
 pub fn read_file(path: &str) -> Result<String> {
@@ -127,4 +128,81 @@ pub fn grep(root: &str, pattern: &str) -> Result<Vec<(String, usize, String)>> {
     }
 
     Ok(results)
+}
+
+/// Edit operation for MultiEdit
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct EditOperation {
+    pub old_string: String,
+    pub new_string: String,
+}
+
+/// Perform multiple edits on a file atomically
+pub fn multi_edit_file(path: &str, edits: Vec<EditOperation>) -> Result<String> {
+    let content = std::fs::read_to_string(path)?;
+    let mut new_content = content.clone();
+
+    // Apply edits in order
+    for edit in &edits {
+        if !new_content.contains(&edit.old_string) {
+            return Err(eyre!("String not found: '{}'", edit.old_string));
+        }
+        new_content = new_content.replacen(&edit.old_string, &edit.new_string, 1);
+    }
+
+    // Create backup and write
+    let backup_path = format!("{}.bak", path);
+    std::fs::copy(path, &backup_path)?;
+    std::fs::write(path, &new_content)?;
+
+    Ok(format!("Applied {} edits to {}", edits.len(), path))
+}
+
+/// Entry in directory listing
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DirEntry {
+    pub name: String,
+    pub is_dir: bool,
+    pub size: Option<u64>,
+    pub modified: Option<String>,
+}
+
+/// List contents of a directory
+pub fn list_directory(path: &str, show_hidden: bool) -> Result<Vec<DirEntry>> {
+    let entries = std::fs::read_dir(path)?;
+    let mut result = Vec::new();
+
+    for entry in entries {
+        let entry = entry?;
+        let name = entry.file_name().to_string_lossy().to_string();
+
+        // Skip hidden files unless requested
+        if !show_hidden && name.starts_with('.') {
+            continue;
+        }
+
+        let metadata = entry.metadata()?;
+        let modified = metadata.modified().ok().map(|t| {
+            // Format as ISO 8601
+            humantime::format_rfc3339(t).to_string()
+        });
+
+        result.push(DirEntry {
+            name,
+            is_dir: metadata.is_dir(),
+            size: if metadata.is_file() { Some(metadata.len()) } else { None },
+            modified,
+        });
+    }
+
+    // Sort directories first, then alphabetically
+    result.sort_by(|a, b| {
+        match (a.is_dir, b.is_dir) {
+            (true, false) => std::cmp::Ordering::Less,
+            (false, true) => std::cmp::Ordering::Greater,
+            _ => a.name.cmp(&b.name),
+        }
+    });
+
+    Ok(result)
 }

crates/tools/fs/tests/fs_tools.rs

@@ -1,4 +1,4 @@
-use tools_fs::{read_file, glob_list, grep, write_file, edit_file};
+use tools_fs::{read_file, glob_list, grep, write_file, edit_file, multi_edit_file, list_directory, EditOperation};
 use std::fs;
 use tempfile::tempdir;
 
@@ -101,4 +101,124 @@ fn edit_file_fails_on_no_match() {
     assert!(result.is_err());
     let err_msg = result.unwrap_err().to_string();
     assert!(err_msg.contains("not found") || err_msg.contains("String to replace"));
+}
+
+#[test]
+fn multi_edit_file_applies_multiple_edits() {
+    let dir = tempdir().unwrap();
+    let file_path = dir.path().join("test.txt");
+    let original = "line 1\nline 2\nline 3\n";
+    fs::write(&file_path, original).unwrap();
+
+    let edits = vec![
+        EditOperation {
+            old_string: "line 1".to_string(),
+            new_string: "modified 1".to_string(),
+        },
+        EditOperation {
+            old_string: "line 2".to_string(),
+            new_string: "modified 2".to_string(),
+        },
+    ];
+
+    let result = multi_edit_file(file_path.to_str().unwrap(), edits).unwrap();
+    assert!(result.contains("Applied 2 edits"));
+
+    let content = read_file(file_path.to_str().unwrap()).unwrap();
+    assert_eq!(content, "modified 1\nmodified 2\nline 3\n");
+
+    // Backup file should exist
+    let backup_path = format!("{}.bak", file_path.display());
+    assert!(std::path::Path::new(&backup_path).exists());
+}
+
+#[test]
+fn multi_edit_file_fails_on_missing_string() {
+    let dir = tempdir().unwrap();
+    let file_path = dir.path().join("test.txt");
+    let original = "line 1\nline 2\n";
+    fs::write(&file_path, original).unwrap();
+
+    let edits = vec![
+        EditOperation {
+            old_string: "line 1".to_string(),
+            new_string: "modified 1".to_string(),
+        },
+        EditOperation {
+            old_string: "nonexistent".to_string(),
+            new_string: "modified".to_string(),
+        },
+    ];
+
+    let result = multi_edit_file(file_path.to_str().unwrap(), edits);
+    assert!(result.is_err());
+    let err_msg = result.unwrap_err().to_string();
+    assert!(err_msg.contains("String not found"));
+}
+
+#[test]
+fn list_directory_shows_files_and_dirs() {
+    let dir = tempdir().unwrap();
+    let root = dir.path();
+
+    // Create test structure
+    fs::write(root.join("file1.txt"), "content").unwrap();
+    fs::write(root.join("file2.txt"), "content").unwrap();
+    fs::create_dir(root.join("subdir")).unwrap();
+    fs::write(root.join(".hidden"), "hidden content").unwrap();
+
+    let entries = list_directory(root.to_str().unwrap(), false).unwrap();
+
+    // Should find 2 files and 1 directory (hidden file excluded)
+    assert_eq!(entries.len(), 3);
+
+    // Verify directory appears first (sorted)
+    assert_eq!(entries[0].name, "subdir");
+    assert!(entries[0].is_dir);
+
+    // Verify files
+    let file_names: Vec<_> = entries.iter().skip(1).map(|e| e.name.as_str()).collect();
+    assert!(file_names.contains(&"file1.txt"));
+    assert!(file_names.contains(&"file2.txt"));
+
+    // Hidden file should not be present
+    assert!(!entries.iter().any(|e| e.name == ".hidden"));
+}
+
+#[test]
+fn list_directory_shows_hidden_when_requested() {
+    let dir = tempdir().unwrap();
+    let root = dir.path();
+
+    fs::write(root.join("visible.txt"), "content").unwrap();
+    fs::write(root.join(".hidden"), "hidden content").unwrap();
+
+    let entries = list_directory(root.to_str().unwrap(), true).unwrap();
+
+    // Should find both files
+    assert!(entries.iter().any(|e| e.name == "visible.txt"));
+    assert!(entries.iter().any(|e| e.name == ".hidden"));
+}
+
+#[test]
+fn list_directory_includes_metadata() {
+    let dir = tempdir().unwrap();
+    let root = dir.path();
+
+    fs::write(root.join("test.txt"), "hello world").unwrap();
+    fs::create_dir(root.join("testdir")).unwrap();
+
+    let entries = list_directory(root.to_str().unwrap(), false).unwrap();
+
+    // Directory entry should have no size
+    let dir_entry = entries.iter().find(|e| e.name == "testdir").unwrap();
+    assert!(dir_entry.is_dir);
+    assert!(dir_entry.size.is_none());
+    assert!(dir_entry.modified.is_some());
+
+    // File entry should have size
+    let file_entry = entries.iter().find(|e| e.name == "test.txt").unwrap();
+    assert!(!file_entry.is_dir);
+    assert_eq!(file_entry.size, Some(11)); // "hello world" is 11 bytes
+    assert!(file_entry.modified.is_some());
 }

crates/tools/task/Cargo.toml

@@ -10,5 +10,7 @@ serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 color-eyre = "0.6"
 permissions = { path = "../../platform/permissions" }
+plugins = { path = "../../platform/plugins" }
+parking_lot = "0.12"
 
 [dev-dependencies]

crates/tools/task/src/lib.rs

@@ -1,8 +1,180 @@
+// Note: Result and eyre will be used by spawn_subagent when implemented
+#[allow(unused_imports)]
 use color_eyre::eyre::{Result, eyre};
+use parking_lot::RwLock;
 use permissions::Tool;
+use plugins::AgentDefinition;
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::sync::Arc;
 
-/// A specialized subagent with limited tool access
+/// Configuration for spawning a subagent
+#[derive(Debug, Clone)]
+pub struct SubagentConfig {
+    /// Agent type/name (e.g., "code-reviewer", "explore")
+    pub agent_type: String,
+
+    /// Task prompt for the agent
+    pub prompt: String,
+
+    /// Optional model override
+    pub model: Option<String>,
+
+    /// Tool whitelist (if None, uses agent's default)
+    pub tools: Option<Vec<String>>,
+
+    /// Parsed agent definition (if from plugin)
+    pub definition: Option<AgentDefinition>,
+}
+
+impl SubagentConfig {
+    /// Create a new subagent config with just type and prompt
+    pub fn new(agent_type: String, prompt: String) -> Self {
+        Self {
+            agent_type,
+            prompt,
+            model: None,
+            tools: None,
+            definition: None,
+        }
+    }
+
+    /// Builder method to set model override
+    pub fn with_model(mut self, model: String) -> Self {
+        self.model = Some(model);
+        self
+    }
+
+    /// Builder method to set tool whitelist
+    pub fn with_tools(mut self, tools: Vec<String>) -> Self {
+        self.tools = Some(tools);
+        self
+    }
+
+    /// Builder method to set agent definition
+    pub fn with_definition(mut self, definition: AgentDefinition) -> Self {
+        self.definition = Some(definition);
+        self
+    }
+}
+
+/// Registry of available subagents
+#[derive(Clone, Default)]
+pub struct SubagentRegistry {
+    agents: Arc<RwLock<HashMap<String, AgentDefinition>>>,
+}
+
+impl SubagentRegistry {
+    /// Create a new empty registry
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Register agents from plugin manager
+    pub fn register_from_plugins(&self, agents: Vec<AgentDefinition>) {
+        let mut map = self.agents.write();
+        for agent in agents {
+            map.insert(agent.name.clone(), agent);
+        }
+    }
+
+    /// Register built-in agents
+    pub fn register_builtin(&self) {
+        let mut map = self.agents.write();
+
+        // Explore agent - for codebase exploration
+        map.insert("explore".to_string(), AgentDefinition {
+            name: "explore".to_string(),
+            description: "Explores codebases to find files and understand structure".to_string(),
+            tools: vec!["read".to_string(), "glob".to_string(), "grep".to_string(), "ls".to_string()],
+            model: None,
+            color: Some("blue".to_string()),
+            system_prompt: "You are an exploration agent. Your purpose is to find relevant files and understand code structure. Use glob to find files by pattern, grep to search for content, ls to list directories, and read to examine files. Be thorough and systematic in your exploration.".to_string(),
+            source_path: PathBuf::new(),
+        });
+
+        // Plan agent - for designing implementations
+        map.insert("plan".to_string(), AgentDefinition {
+            name: "plan".to_string(),
+            description: "Designs implementation plans and architectures".to_string(),
+            tools: vec!["read".to_string(), "glob".to_string(), "grep".to_string()],
+            model: None,
+            color: Some("green".to_string()),
+            system_prompt: "You are a planning agent. Your purpose is to design clear implementation strategies and architectures. Read existing code, understand patterns, and create detailed plans. Focus on the 'why' and 'how' rather than the 'what'.".to_string(),
+            source_path: PathBuf::new(),
+        });
+
+        // Code reviewer - read-only analysis
+        map.insert("code-reviewer".to_string(), AgentDefinition {
+            name: "code-reviewer".to_string(),
+            description: "Reviews code for quality, bugs, and best practices".to_string(),
+            tools: vec!["read".to_string(), "grep".to_string(), "glob".to_string()],
+            model: None,
+            color: Some("yellow".to_string()),
+            system_prompt: "You are a code review agent. Analyze code for quality, potential bugs, performance issues, and adherence to best practices. Provide constructive feedback with specific examples.".to_string(),
+            source_path: PathBuf::new(),
+        });
+
+        // Test writer - can read and write test files
+        map.insert("test-writer".to_string(), AgentDefinition {
+            name: "test-writer".to_string(),
+            description: "Writes and updates test files".to_string(),
+            tools: vec!["read".to_string(), "write".to_string(), "edit".to_string(), "grep".to_string(), "glob".to_string()],
+            model: None,
+            color: Some("cyan".to_string()),
+            system_prompt: "You are a test writing agent. Write comprehensive, well-structured tests that cover edge cases and ensure code correctness. Follow testing best practices and patterns used in the codebase.".to_string(),
+            source_path: PathBuf::new(),
+        });
+
+        // Documentation agent - can read code and write docs
+        map.insert("doc-writer".to_string(), AgentDefinition {
+            name: "doc-writer".to_string(),
+            description: "Writes and maintains documentation".to_string(),
+            tools: vec!["read".to_string(), "write".to_string(), "edit".to_string(), "grep".to_string(), "glob".to_string()],
+            model: None,
+            color: Some("magenta".to_string()),
+            system_prompt: "You are a documentation agent. Write clear, comprehensive documentation that helps users understand the code. Include examples, explain concepts, and maintain consistency with existing documentation style.".to_string(),
+            source_path: PathBuf::new(),
+        });
+
+        // Refactoring agent - full file access but no bash
+        map.insert("refactorer".to_string(), AgentDefinition {
+            name: "refactorer".to_string(),
+            description: "Refactors code while preserving functionality".to_string(),
+            tools: vec!["read".to_string(), "write".to_string(), "edit".to_string(), "grep".to_string(), "glob".to_string()],
+            model: None,
+            color: Some("red".to_string()),
+            system_prompt: "You are a refactoring agent. Improve code structure, readability, and maintainability while preserving functionality. Follow SOLID principles and language idioms. Make small, incremental changes.".to_string(),
+            source_path: PathBuf::new(),
+        });
+    }
+
+    /// Get an agent by name
+    pub fn get(&self, name: &str) -> Option<AgentDefinition> {
+        self.agents.read().get(name).cloned()
+    }
+
+    /// List all available agents with their descriptions
+    pub fn list(&self) -> Vec<(String, String)> {
+        self.agents.read()
+            .iter()
+            .map(|(name, def)| (name.clone(), def.description.clone()))
+            .collect()
+    }
+
+    /// Check if an agent exists
+    pub fn contains(&self, name: &str) -> bool {
+        self.agents.read().contains_key(name)
+    }
+
+    /// Get all agent names
+    pub fn agent_names(&self) -> Vec<String> {
+        self.agents.read().keys().cloned().collect()
+    }
+}
+
+/// A specialized subagent with limited tool access (legacy API for backward compatibility)
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Subagent {
     /// Unique identifier for the subagent
@@ -39,92 +211,6 @@ impl Subagent {
     }
 }
 
-/// Registry for managing subagents
-#[derive(Debug, Clone)]
-pub struct SubagentRegistry {
-    subagents: Vec<Subagent>,
-}
-
-impl SubagentRegistry {
-    pub fn new() -> Self {
-        Self {
-            subagents: Vec::new(),
-        }
-    }
-
-    /// Register a new subagent
-    pub fn register(&mut self, subagent: Subagent) {
-        self.subagents.push(subagent);
-    }
-
-    /// Select the most appropriate subagent for a task
-    pub fn select(&self, task_description: &str) -> Option<&Subagent> {
-        // Find the first subagent that matches the task description
-        self.subagents
-            .iter()
-            .find(|agent| agent.matches_task(task_description))
-    }
-
-    /// Get a subagent by name
-    pub fn get(&self, name: &str) -> Option<&Subagent> {
-        self.subagents.iter().find(|agent| agent.name == name)
-    }
-
-    /// Check if a specific subagent can use a tool
-    pub fn can_use_tool(&self, agent_name: &str, tool: Tool) -> Result<bool> {
-        let agent = self.get(agent_name)
-            .ok_or_else(|| eyre!("Subagent '{}' not found", agent_name))?;
-        Ok(agent.can_use_tool(tool))
-    }
-
-    /// List all registered subagents
-    pub fn list(&self) -> &[Subagent] {
-        &self.subagents
-    }
-}
-
-impl Default for SubagentRegistry {
-    fn default() -> Self {
-        let mut registry = Self::new();
-
-        // Register built-in subagents
-
-        // Code reviewer - read-only tools
-        registry.register(Subagent::new(
-            "code-reviewer".to_string(),
-            "Reviews code for quality, bugs, and best practices".to_string(),
-            vec!["review".to_string(), "analyze code".to_string(), "check code".to_string()],
-            vec![Tool::Read, Tool::Grep, Tool::Glob],
-        ));
-
-        // Test writer - can read and write test files
-        registry.register(Subagent::new(
-            "test-writer".to_string(),
-            "Writes and updates test files".to_string(),
-            vec!["test".to_string(), "write tests".to_string(), "add tests".to_string()],
-            vec![Tool::Read, Tool::Write, Tool::Edit, Tool::Grep, Tool::Glob],
-        ));
-
-        // Documentation agent - can read code and write docs
-        registry.register(Subagent::new(
-            "doc-writer".to_string(),
-            "Writes and maintains documentation".to_string(),
-            vec!["document".to_string(), "docs".to_string(), "readme".to_string()],
-            vec![Tool::Read, Tool::Write, Tool::Edit, Tool::Grep, Tool::Glob],
-        ));
-
-        // Refactoring agent - full file access but no bash
-        registry.register(Subagent::new(
-            "refactorer".to_string(),
-            "Refactors code while preserving functionality".to_string(),
-            vec!["refactor".to_string(), "restructure".to_string(), "reorganize".to_string()],
-            vec![Tool::Read, Tool::Write, Tool::Edit, Tool::Grep, Tool::Glob],
-        ));
-
-        registry
-    }
-}
-
 /// Task execution request
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct TaskRequest {
@@ -149,6 +235,75 @@ pub struct TaskResult {
 mod tests {
     use super::*;
 
+    #[test]
+    fn test_subagent_registry_builtin() {
+        let registry = SubagentRegistry::new();
+        registry.register_builtin();
+
+        // Check that built-in agents are registered
+        assert!(registry.contains("explore"));
+        assert!(registry.contains("plan"));
+        assert!(registry.contains("code-reviewer"));
+        assert!(registry.contains("test-writer"));
+        assert!(registry.contains("doc-writer"));
+        assert!(registry.contains("refactorer"));
+
+        // Get an agent and verify its properties
+        let explore = registry.get("explore").unwrap();
+        assert_eq!(explore.name, "explore");
+        assert!(explore.tools.contains(&"read".to_string()));
+        assert!(explore.tools.contains(&"glob".to_string()));
+        assert!(explore.tools.contains(&"grep".to_string()));
+    }
+
+    #[test]
+    fn test_subagent_registry_list() {
+        let registry = SubagentRegistry::new();
+        registry.register_builtin();
+
+        let agents = registry.list();
+        assert!(agents.len() >= 6);
+
+        // Check that we have expected agents
+        let names: Vec<String> = agents.iter().map(|(name, _)| name.clone()).collect();
+        assert!(names.contains(&"explore".to_string()));
+        assert!(names.contains(&"plan".to_string()));
+    }
+
+    #[test]
+    fn test_subagent_config_builder() {
+        let config = SubagentConfig::new("explore".to_string(), "Find all Rust files".to_string())
+            .with_model("claude-3-opus".to_string())
+            .with_tools(vec!["read".to_string(), "glob".to_string()]);
+
+        assert_eq!(config.agent_type, "explore");
+        assert_eq!(config.prompt, "Find all Rust files");
+        assert_eq!(config.model, Some("claude-3-opus".to_string()));
+        assert_eq!(config.tools, Some(vec!["read".to_string(), "glob".to_string()]));
+    }
+
+    #[test]
+    fn test_register_from_plugins() {
+        let registry = SubagentRegistry::new();
+
+        let plugin_agent = AgentDefinition {
+            name: "custom-agent".to_string(),
+            description: "A custom agent from plugin".to_string(),
+            tools: vec!["read".to_string()],
+            model: Some("haiku".to_string()),
+            color: Some("purple".to_string()),
+            system_prompt: "Custom prompt".to_string(),
+            source_path: PathBuf::from("/path/to/plugin"),
+        };
+
+        registry.register_from_plugins(vec![plugin_agent]);
+
+        assert!(registry.contains("custom-agent"));
+        let agent = registry.get("custom-agent").unwrap();
+        assert_eq!(agent.model, Some("haiku".to_string()));
+    }
+
+    // Legacy API tests for backward compatibility
     #[test]
     fn subagent_tool_whitelist() {
         let agent = Subagent::new(
@@ -177,45 +332,4 @@ mod tests {
         assert!(agent.matches_task("Add test coverage"));
         assert!(!agent.matches_task("Refactor the database layer"));
     }
-
-    #[test]
-    fn registry_selection() {
-        let registry = SubagentRegistry::default();
-
-        let reviewer = registry.select("Review the authentication code");
-        assert!(reviewer.is_some());
-        assert_eq!(reviewer.unwrap().name, "code-reviewer");
-
-        let tester = registry.select("Write tests for the API endpoints");
-        assert!(tester.is_some());
-        assert_eq!(tester.unwrap().name, "test-writer");
-
-        let doc_writer = registry.select("Update the README documentation");
-        assert!(doc_writer.is_some());
-        assert_eq!(doc_writer.unwrap().name, "doc-writer");
-    }
-
-    #[test]
-    fn registry_tool_validation() {
-        let registry = SubagentRegistry::default();
-
-        // Code reviewer can only use read-only tools
-        assert!(registry.can_use_tool("code-reviewer", Tool::Read).unwrap());
-        assert!(registry.can_use_tool("code-reviewer", Tool::Grep).unwrap());
-        assert!(!registry.can_use_tool("code-reviewer", Tool::Write).unwrap());
-        assert!(!registry.can_use_tool("code-reviewer", Tool::Bash).unwrap());
-
-        // Test writer can write but not run bash
-        assert!(registry.can_use_tool("test-writer", Tool::Read).unwrap());
-        assert!(registry.can_use_tool("test-writer", Tool::Write).unwrap());
-        assert!(!registry.can_use_tool("test-writer", Tool::Bash).unwrap());
-    }
-
-    #[test]
-    fn nonexistent_agent_error() {
-        let registry = SubagentRegistry::default();
-        let result = registry.can_use_tool("nonexistent", Tool::Read);
-        assert!(result.is_err());
-        assert!(result.unwrap_err().to_string().contains("not found"));
-    }
 }

crates/tools/todo/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "tools-todo"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+parking_lot = "0.12"
+color-eyre = "0.6"

crates/tools/todo/src/lib.rs

@@ -0,0 +1,113 @@
+//! TodoWrite tool for task list management
+
+use parking_lot::RwLock;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+/// Status of a todo item
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum TodoStatus {
+    Pending,
+    InProgress,
+    Completed,
+}
+
+/// A todo item
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Todo {
+    pub content: String,
+    pub status: TodoStatus,
+    pub active_form: String,  // Present continuous form for display
+}
+
+/// Shared todo list state
+#[derive(Debug, Clone, Default)]
+pub struct TodoList {
+    inner: Arc<RwLock<Vec<Todo>>>,
+}
+
+impl TodoList {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Replace all todos with new list
+    pub fn write(&self, todos: Vec<Todo>) {
+        *self.inner.write() = todos;
+    }
+
+    /// Get current todos
+    pub fn read(&self) -> Vec<Todo> {
+        self.inner.read().clone()
+    }
+
+    /// Get the current in-progress task (for status display)
+    pub fn current_task(&self) -> Option<String> {
+        self.inner.read()
+            .iter()
+            .find(|t| t.status == TodoStatus::InProgress)
+            .map(|t| t.active_form.clone())
+    }
+
+    /// Get summary stats
+    pub fn stats(&self) -> (usize, usize, usize) {
+        let todos = self.inner.read();
+        let pending = todos.iter().filter(|t| t.status == TodoStatus::Pending).count();
+        let in_progress = todos.iter().filter(|t| t.status == TodoStatus::InProgress).count();
+        let completed = todos.iter().filter(|t| t.status == TodoStatus::Completed).count();
+        (pending, in_progress, completed)
+    }
+
+    /// Format todos for display
+    pub fn format_display(&self) -> String {
+        let todos = self.inner.read();
+        if todos.is_empty() {
+            return "No tasks".to_string();
+        }
+
+        todos.iter().enumerate().map(|(i, t)| {
+            let status_icon = match t.status {
+                TodoStatus::Pending => "○",
+                TodoStatus::InProgress => "◐",
+                TodoStatus::Completed => "●",
+            };
+            format!("{}. {} {}", i + 1, status_icon, t.content)
+        }).collect::<Vec<_>>().join("\n")
+    }
+}
+
+/// Parse todos from JSON tool input
+pub fn parse_todos(input: &serde_json::Value) -> color_eyre::Result<Vec<Todo>> {
+    let todos = input.get("todos")
+        .ok_or_else(|| color_eyre::eyre::eyre!("Missing 'todos' field"))?;
+
+    serde_json::from_value(todos.clone())
+        .map_err(|e| color_eyre::eyre::eyre!("Invalid todos format: {}", e))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_todo_list() {
+        let list = TodoList::new();
+
+        list.write(vec![
+            Todo {
+                content: "First task".to_string(),
+                status: TodoStatus::Completed,
+                active_form: "Completing first task".to_string(),
+            },
+            Todo {
+                content: "Second task".to_string(),
+                status: TodoStatus::InProgress,
+                active_form: "Working on second task".to_string(),
+            },
+        ]);
+
+        assert_eq!(list.current_task(), Some("Working on second task".to_string()));
+        assert_eq!(list.stats(), (0, 1, 1));
+    }
+}

crates/tools/web/Cargo.toml

@@ -13,6 +13,8 @@ serde_json = "1"
 color-eyre = "0.6"
 url = "2.5"
 async-trait = "0.1"
+scraper = "0.18"
+urlencoding = "2.1"
 
 [dev-dependencies]
 tokio = { version = "1.39", features = ["macros", "rt-multi-thread"] }

crates/tools/web/src/lib.rs

@@ -1,5 +1,6 @@
 use color_eyre::eyre::{Result, eyre};
 use reqwest::redirect::Policy;
+use scraper::{Html, Selector};
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
 use url::Url;
@@ -173,6 +174,91 @@ impl SearchProvider for StubSearchProvider {
     }
 }
 
+/// DuckDuckGo HTML search provider
+pub struct DuckDuckGoSearchProvider {
+    client: reqwest::Client,
+    max_results: usize,
+}
+
+impl DuckDuckGoSearchProvider {
+    /// Create a new DuckDuckGo search provider with default max results (10)
+    pub fn new() -> Self {
+        Self::with_max_results(10)
+    }
+
+    /// Create a new DuckDuckGo search provider with custom max results
+    pub fn with_max_results(max_results: usize) -> Self {
+        let client = reqwest::Client::builder()
+            .user_agent("Mozilla/5.0 (compatible; Owlen/1.0)")
+            .build()
+            .unwrap();
+
+        Self { client, max_results }
+    }
+
+    /// Parse DuckDuckGo HTML results
+    fn parse_results(html: &str, max_results: usize) -> Result<Vec<SearchResult>> {
+        let document = Html::parse_document(html);
+
+        // DuckDuckGo HTML selectors
+        let result_selector = Selector::parse(".result").map_err(|e| eyre!("Invalid selector: {:?}", e))?;
+        let title_selector = Selector::parse(".result__title a").map_err(|e| eyre!("Invalid selector: {:?}", e))?;
+        let snippet_selector = Selector::parse(".result__snippet").map_err(|e| eyre!("Invalid selector: {:?}", e))?;
+
+        let mut results = Vec::new();
+
+        for result in document.select(&result_selector).take(max_results) {
+            let title = result
+                .select(&title_selector)
+                .next()
+                .map(|e| e.text().collect::<String>().trim().to_string())
+                .unwrap_or_default();
+
+            let url = result
+                .select(&title_selector)
+                .next()
+                .and_then(|e| e.value().attr("href"))
+                .unwrap_or_default()
+                .to_string();
+
+            let snippet = result
+                .select(&snippet_selector)
+                .next()
+                .map(|e| e.text().collect::<String>().trim().to_string())
+                .unwrap_or_default();
+
+            if !title.is_empty() && !url.is_empty() {
+                results.push(SearchResult { title, url, snippet });
+            }
+        }
+
+        Ok(results)
+    }
+}
+
+impl Default for DuckDuckGoSearchProvider {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[async_trait::async_trait]
+impl SearchProvider for DuckDuckGoSearchProvider {
+    fn name(&self) -> &str {
+        "duckduckgo"
+    }
+
+    async fn search(&self, query: &str) -> Result<Vec<SearchResult>> {
+        let encoded_query = urlencoding::encode(query);
+        let url = format!("https://html.duckduckgo.com/html/?q={}", encoded_query);
+
+        let response = self.client.get(&url).send().await?;
+        let html = response.text().await?;
+
+        Self::parse_results(&html, self.max_results)
+    }
+}
+
 /// WebSearch client with pluggable providers
 pub struct WebSearchClient {
     provider: Box<dyn SearchProvider>,
@@ -192,6 +278,20 @@ impl WebSearchClient {
     }
 }
 
+/// Format search results for LLM consumption (markdown format)
+pub fn format_search_results(results: &[SearchResult]) -> String {
+    if results.is_empty() {
+        return "No results found.".to_string();
+    }
+
+    results
+        .iter()
+        .enumerate()
+        .map(|(i, r)| format!("{}. [{}]({})\n   {}", i + 1, r.title, r.url, r.snippet))
+        .collect::<Vec<_>>()
+        .join("\n\n")
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;