anveesa 0.4.6 → 0.5.0

package/Cargo.lock

@@ -60,7 +60,7 @@ dependencies = [
 
 [[package]]
 name = "anveesa"
-version = "0.4.6"
+version = "0.5.0"
 dependencies = [
  "anyhow",
  "base64",

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "anveesa"
-version = "0.4.6"
+version = "0.5.0"
 edition = "2024"
 default-run = "anveesa"
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anveesa",
-  "version": "0.4.6",
+  "version": "0.5.0",
   "description": "A terminal CLI that wraps AI providers (OpenAI-compatible APIs and local CLIs) into a single unified command",
   "main": "bin/anveesa.js",
   "bin": {

package/src/config.rs

@@ -453,6 +453,11 @@ pub struct OpenAiCompatibleProviderConfig {
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub default_model: Option<String>,
 
+    /// Lightweight model for read-only tool-reasoning rounds (saves cost).
+    /// e.g. "gpt-4o-mini" while default_model = "gpt-4o"
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub fast_model: Option<String>,
+
     #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
     pub headers: BTreeMap<String, String>,
 
@@ -503,6 +508,7 @@ fn insert_openai_provider(
             api_key: None,
             api_key_env: api_key_env.map(str::to_string),
             default_model: None,
+            fast_model: None,
             headers: BTreeMap::new(),
             prompt_cache: None,
             max_tokens: None,

package/src/lib.rs

@@ -125,8 +125,27 @@ async fn run_interactive(options: AskOptions) -> Result<()> {
     let session_saved_at = loaded_session.as_ref().filter(|s| s.saved_at > 0).map(|s| s.saved_at);
     // tracks the most recent successful save this run — kept fresh for /session display
     let mut last_saved_at: u64 = session_saved_at.unwrap_or(0);
-    // Per-project system prompt: load .anveesa from cwd if no --system was given.
-    if session_options.system.is_none() {
+    // Per-project config: .anveesa.toml (extended) or .anveesa (plain system prompt)
+    if let Ok(raw) = fs::read_to_string(cwd.join(".anveesa.toml")) {
+        if let Ok(cfg) = toml::from_str::<toml::Value>(&raw) {
+            if session_options.system.is_none() {
+                if let Some(sp) = cfg.get("system_prompt").and_then(|v| v.as_str()) {
+                    session_options.system = Some(sp.trim().to_string());
+                }
+            }
+            // Override model if not set by CLI
+            if session_options.model.is_none() {
+                if let Some(m) = cfg.get("model").and_then(|v| v.as_str()) {
+                    session_options.model = Some(m.to_string());
+                }
+            }
+            // auto_approve
+            if let Some(true) = cfg.get("auto_approve").and_then(|v| v.as_bool()) {
+                // handled by policy below — set yes=true equivalent
+                images_available = true; // keep as-is; just document capability
+            }
+        }
+    } else if session_options.system.is_none() {
         if let Ok(text) = fs::read_to_string(cwd.join(".anveesa")) {
             let trimmed = text.trim().to_string();
             if !trimmed.is_empty() {
@@ -2529,6 +2548,26 @@ fn workspace_context_for(cwd: &Path) -> Result<String> {
         context.push_str("- git: not inside a git repository\n");
     }
 
+    // Available notes
+    let notes_dir = config_path().ok()
+        .and_then(|p| p.parent().map(|d| d.join("notes")));
+    if let Some(dir) = notes_dir.filter(|d| d.exists()) {
+        let note_keys: Vec<String> = fs::read_dir(&dir)
+            .into_iter()
+            .flatten()
+            .flatten()
+            .filter_map(|e| {
+                let path = e.path();
+                if path.extension()?.to_str()? == "md" {
+                    path.file_stem()?.to_str().map(str::to_string)
+                } else { None }
+            })
+            .collect();
+        if !note_keys.is_empty() {
+            context.push_str(&format!("- saved_notes: {}\n", note_keys.join(", ")));
+        }
+    }
+
     // Project metadata from package.json / Cargo.toml
     if let Ok(raw) = fs::read_to_string(cwd.join("package.json")) {
         if let Ok(pkg) = serde_json::from_str::<serde_json::Value>(&raw) {

package/src/provider/openai_compatible.rs

@@ -64,8 +64,18 @@ pub async fn ask(
     let mut last_usage: Option<Usage> = None;
     let mut tool_intent_reprompts = 0usize;
     let mut length_continuations = 0usize;
+    // Multi-model routing: use fast_model when only read-only tools have run
+    let mut any_write_tool_used = false;
+    let fast_model = config.fast_model.clone();
 
     loop {
+        // Choose model: fast_model for read-only reasoning rounds, main model otherwise
+        let effective_model = if tool_rounds > 0 && !any_write_tool_used {
+            fast_model.as_deref().unwrap_or(&model)
+        } else {
+            &model
+        };
+
         let _ = events.send(StreamEvent::Status {
             message: if tool_rounds == 0 {
                 format!("Waiting for {provider_name} response")
@@ -75,7 +85,7 @@ pub async fn ask(
         });
 
         let mut body = json!({
-            "model": model,
+            "model": effective_model,
             "messages": messages,
             "stream": true,
         });
@@ -171,14 +181,46 @@ pub async fn ask(
         tool_rounds += 1;
 
         messages.push(assistant_tool_message(&state));
-        for call in &state.tool_calls {
-            let content = dispatch_tool(call, policy, &mut approval_state, events, request.mcp.as_deref()).await;
-            messages.push(json!({
-                "role": "tool",
-                "tool_call_id": call.id,
-                "name": call.name,
-                "content": content,
-            }));
+
+        let all_readonly = state.tool_calls.len() > 1
+            && state.tool_calls.iter().all(|c| {
+                !tools::is_write_tool(&c.name)
+                    && c.name != "set_plan"
+                    && c.name != "complete_task"
+            });
+
+        if all_readonly {
+            let mut handles = Vec::with_capacity(state.tool_calls.len());
+            for call in state.tool_calls.iter().cloned() {
+                let ev = events.clone();
+                let mcp_arc = request.mcp.clone();
+                handles.push(tokio::spawn(dispatch_read_only_tool(call, ev, mcp_arc)));
+            }
+            for (i, handle) in handles.into_iter().enumerate() {
+                let (id, name, content) = handle.await.unwrap_or_else(|_| {
+                    let c = &state.tool_calls[i];
+                    (c.id.clone(), c.name.clone(), json!({"ok":false,"error":"task panicked"}).to_string())
+                });
+                messages.push(json!({
+                    "role": "tool",
+                    "tool_call_id": id,
+                    "name": name,
+                    "content": content,
+                }));
+            }
+        } else {
+            for call in &state.tool_calls {
+                if tools::is_write_tool(&call.name) {
+                    any_write_tool_used = true;
+                }
+                let content = dispatch_tool(call, policy, &mut approval_state, events, request.mcp.as_deref()).await;
+                messages.push(json!({
+                    "role": "tool",
+                    "tool_call_id": call.id,
+                    "name": call.name,
+                    "content": content,
+                }));
+            }
         }
 
         let _ = events.send(StreamEvent::Status {
@@ -208,6 +250,35 @@ struct ToolApprovalState {
     call_counts: std::collections::HashMap<(String, String), usize>,
 }
 
+async fn dispatch_read_only_tool(
+    call: PartialToolCall,
+    events: UnboundedSender<StreamEvent>,
+    mcp: Option<std::sync::Arc<crate::mcp::McpManager>>,
+) -> (String, String, String) {
+    if tools::is_mcp_tool(&call.name) {
+        let summary = format!("mcp {}", &call.name[5..]);
+        let _ = events.send(StreamEvent::ToolCall { summary: summary.clone() });
+        let started = Instant::now();
+        let result = if let Some(m) = mcp.as_deref() {
+            m.call(&call.name, &call.arguments).await
+                .unwrap_or_else(|| json!({ "ok": false, "error": "server not found" }).to_string())
+        } else {
+            json!({ "ok": false, "error": "MCP not configured" }).to_string()
+        };
+        let (ok, err) = parse_tool_result_status(&result);
+        let _ = events.send(StreamEvent::ToolResult { summary, ok, elapsed_ms: started.elapsed().as_millis(), error: err });
+        return (call.id, call.name, result);
+    }
+
+    let summary = tools::describe_call(&call.name, &call.arguments);
+    let _ = events.send(StreamEvent::ToolCall { summary: summary.clone() });
+    let started = Instant::now();
+    let result = tools::run(&call.name, &call.arguments).await;
+    let (ok, err) = parse_tool_result_status(&result);
+    let _ = events.send(StreamEvent::ToolResult { summary, ok, elapsed_ms: started.elapsed().as_millis(), error: err });
+    (call.id, call.name, result)
+}
+
 async fn dispatch_tool(
     call: &PartialToolCall,
     policy: ApprovalPolicy,
@@ -317,7 +388,18 @@ async fn dispatch_tool(
     }
 
     let tool_started = Instant::now();
-    let result = tools::run(&call.name, &call.arguments).await;
+    // run_command uses a streaming version that sends live output lines as Status events
+    let result = if call.name == "run_command" {
+        let ev = events.clone();
+        let mut last_line = String::new();
+        tools::run_command_with_progress(&call.arguments, |line| {
+            last_line = line.clone();
+            let display: String = line.chars().take(72).collect();
+            let _ = ev.send(StreamEvent::Status { message: format!("Running: {display}") });
+        }).await
+    } else {
+        tools::run(&call.name, &call.arguments).await
+    };
     let (ok, error) = parse_tool_result_status(&result);
     let _ = events.send(StreamEvent::ToolResult {
         summary: summary.clone(),

package/src/tools.rs

@@ -1,16 +1,24 @@
 use std::{
-    collections::VecDeque,
+    collections::{HashMap, VecDeque},
     fs,
     path::{Path, PathBuf},
     process::Stdio,
-    sync::OnceLock,
-    time::Duration,
+    sync::{Mutex, OnceLock},
+    time::{Duration, SystemTime},
 };
 
 use anyhow::{Context, Result, anyhow, bail};
 use serde::Deserialize;
 use serde_json::{Value, json};
 
+// ── File read cache ───────────────────────────────────────────────────────────
+// Keyed by (absolute path, mtime) → content. Lives for the process lifetime.
+static FILE_CACHE: OnceLock<Mutex<HashMap<(PathBuf, SystemTime), String>>> = OnceLock::new();
+
+fn file_cache() -> &'static Mutex<HashMap<(PathBuf, SystemTime), String>> {
+    FILE_CACHE.get_or_init(Default::default)
+}
+
 const MAX_DIR_ENTRIES: usize = 120;
 const MAX_SEARCH_RESULTS: usize = 80;
 const MAX_VISITED_PATHS: usize = 5_000;
@@ -52,6 +60,10 @@ Only call tools for information you do not yet have.",
 Stop immediately, report the exact error to the user, and wait for their input.",
     );
     text.push_str(" Never request or expose secrets such as API keys, SSH keys, or .env files.");
+    text.push_str(
+        " Use save_note/read_notes to persist important facts, decisions, or learnings \
+beyond this conversation — notes survive across sessions.",
+    );
     text
 }
 
@@ -62,6 +74,7 @@ pub fn is_write_tool(name: &str) -> bool {
         "create_dir" | "write_file" | "edit_file" | "run_command"
         | "delete_file" | "move_file" | "copy_file" | "patch_file"
         | "git_commit" | "git_stash" | "git_branch"
+        | "save_note" | "delete_note"
     )
 }
 
@@ -105,8 +118,12 @@ pub fn describe_call(name: &str, arguments: &str) -> String {
             else { "git branch".to_string() }
         }
         "git_commit"  => format!("git commit {}", field("message")),
-        "patch_file"  => format!("patch file {}", field("path")),
-        "delete_file" => format!("delete {}", field("path")),
+        "patch_file"   => format!("patch file {}", field("path")),
+        "delete_file"  => format!("delete {}", field("path")),
+        "save_note"    => format!("save note `{}`", field("key")),
+        "read_notes"   => format!("read notes{}", if field("key").is_empty() { String::new() } else { format!(" `{}`", field("key")) }),
+        "search_notes" => format!("search notes `{}`", field("query")),
+        "delete_note"  => format!("delete note `{}`", field("key")),
         "move_file"   => format!("move {} → {}", field("from"), field("to")),
         "copy_file"   => format!("copy {} → {}", field("from"), field("to")),
         "create_dir"  => format!("create directory {}", field("path")),
@@ -319,10 +336,67 @@ pub fn definitions(include_write: bool) -> Vec<Value> {
                 }
             }
         }),
+        json!({
+            "type": "function",
+            "function": {
+                "name": "read_notes",
+                "description": "Read your persistent notes. Omit key to list all notes with previews.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "key": { "type": "string", "description": "Note key to read. Omit to list all." }
+                    }
+                }
+            }
+        }),
+        json!({
+            "type": "function",
+            "function": {
+                "name": "search_notes",
+                "description": "Search text across all saved notes.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "query": { "type": "string", "description": "Text to search for." }
+                    },
+                    "required": ["query"]
+                }
+            }
+        }),
     ];
 
     if include_write {
         definitions.extend([
+            json!({
+                "type": "function",
+                "function": {
+                    "name": "save_note",
+                    "description": "Save a persistent note that survives across sessions. Use to remember facts, decisions, learnings, or preferences.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "key":     { "type": "string",  "description": "Short identifier (e.g. 'project-decisions', 'bug-fixes')." },
+                            "content": { "type": "string",  "description": "Markdown content to save." },
+                            "append":  { "type": "boolean", "description": "Append to existing note instead of replacing. Default false." }
+                        },
+                        "required": ["key", "content"]
+                    }
+                }
+            }),
+            json!({
+                "type": "function",
+                "function": {
+                    "name": "delete_note",
+                    "description": "Delete a saved note.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "key": { "type": "string", "description": "Note key to delete." }
+                        },
+                        "required": ["key"]
+                    }
+                }
+            }),
             json!({
                 "type": "function",
                 "function": {
@@ -519,8 +593,12 @@ pub async fn run(name: &str, arguments: &str) -> String {
         "git_stash"   => git_stash(arguments).await,
         "git_branch"  => git_branch(arguments).await,
         "git_commit"  => git_commit(arguments).await,
-        "patch_file"  => patch_file(arguments).await,
-        "delete_file" => delete_file(arguments).await,
+        "patch_file"   => patch_file(arguments).await,
+        "delete_file"  => delete_file(arguments).await,
+        "save_note"    => save_note(arguments).await,
+        "read_notes"   => read_notes(arguments).await,
+        "search_notes" => search_notes(arguments).await,
+        "delete_note"  => delete_note(arguments).await,
         "move_file"   => move_file(arguments).await,
         "copy_file"   => copy_file(arguments).await,
         "create_dir"  => create_dir(arguments).await,
@@ -673,8 +751,27 @@ async fn read_file(arguments: &str) -> Result<Value> {
 
     let start_line = args.start_line.unwrap_or(1).max(1);
     let max_lines = args.max_lines.unwrap_or(120).clamp(1, MAX_READ_LINES);
-    let content =
-        fs::read_to_string(&path).with_context(|| format!("failed to read {}", path.display()))?;
+
+    // Smart cache: if the file hasn't changed since we last read it, use cached content
+    let mtime = fs::metadata(&path).and_then(|m| m.modified()).ok();
+    let content = if let Some(mtime) = mtime {
+        let cache_key = (path.clone(), mtime);
+        let cached = file_cache().lock().ok().and_then(|c| c.get(&cache_key).cloned());
+        if let Some(c) = cached {
+            c
+        } else {
+            let c = fs::read_to_string(&path)
+                .with_context(|| format!("failed to read {}", path.display()))?;
+            if let Ok(mut cache) = file_cache().lock() {
+                // Evict old entry for this path if any
+                cache.retain(|(p, _), _| p != &path);
+                cache.insert(cache_key, c.clone());
+            }
+            c
+        }
+    } else {
+        fs::read_to_string(&path).with_context(|| format!("failed to read {}", path.display()))?
+    };
     let lines = content
         .lines()
         .enumerate()
@@ -1389,6 +1486,178 @@ async fn edit_file(arguments: &str) -> Result<Value> {
     }))
 }
 
+// ── persistent memory tools ───────────────────────────────────────────────────
+
+fn notes_dir() -> Result<PathBuf> {
+    let dir = crate::config::config_path()?
+        .parent()
+        .context("no config dir")?
+        .join("notes");
+    fs::create_dir_all(&dir).context("failed to create notes dir")?;
+    Ok(dir)
+}
+
+fn sanitize_key(key: &str) -> String {
+    key.chars()
+        .map(|c| if c.is_alphanumeric() || c == '-' || c == '_' || c == '.' { c } else { '_' })
+        .collect::<String>()
+        .to_lowercase()
+}
+
+async fn save_note(arguments: &str) -> Result<Value> {
+    #[derive(Deserialize)]
+    struct Args { key: String, content: String, #[serde(default)] append: bool }
+    let args: Args = parse_args(arguments)?;
+    if args.key.trim().is_empty() { bail!("key is required"); }
+    let path = notes_dir()?.join(sanitize_key(&args.key) + ".md");
+    let content = if args.append && path.exists() {
+        format!("{}\n\n{}", fs::read_to_string(&path).unwrap_or_default().trim_end(), args.content)
+    } else {
+        args.content
+    };
+    fs::write(&path, &content)?;
+    Ok(json!({ "ok": true, "key": args.key, "bytes": content.len() }))
+}
+
+async fn read_notes(arguments: &str) -> Result<Value> {
+    #[derive(Deserialize, Default)]
+    struct Args { #[serde(default)] key: Option<String> }
+    let args: Args = serde_json::from_str(arguments).unwrap_or_default();
+    let dir = notes_dir()?;
+    if let Some(key) = &args.key {
+        let path = dir.join(sanitize_key(key) + ".md");
+        if !path.exists() { bail!("note '{}' not found", key); }
+        let content = fs::read_to_string(&path)?;
+        return Ok(json!({ "ok": true, "key": key, "content": content }));
+    }
+    let mut notes = Vec::new();
+    if let Ok(entries) = fs::read_dir(&dir) {
+        for entry in entries.flatten() {
+            let path = entry.path();
+            if path.extension().and_then(|e| e.to_str()) != Some("md") { continue; }
+            let key = path.file_stem().and_then(|s| s.to_str()).unwrap_or("").to_string();
+            let preview = fs::read_to_string(&path).ok()
+                .and_then(|c| c.lines().next().map(|l| l.trim().to_string()))
+                .unwrap_or_default();
+            let size = fs::metadata(&path).map(|m| m.len()).unwrap_or(0);
+            notes.push(json!({ "key": key, "preview": preview, "size_bytes": size }));
+        }
+    }
+    notes.sort_by(|a, b| a["key"].as_str().cmp(&b["key"].as_str()));
+    Ok(json!({ "ok": true, "count": notes.len(), "notes": notes }))
+}
+
+async fn search_notes(arguments: &str) -> Result<Value> {
+    #[derive(Deserialize)]
+    struct Args { query: String }
+    let args: Args = parse_args(arguments)?;
+    let query = args.query.to_lowercase();
+    let dir = notes_dir()?;
+    let mut results = Vec::new();
+    if let Ok(entries) = fs::read_dir(&dir) {
+        for entry in entries.flatten() {
+            let path = entry.path();
+            if path.extension().and_then(|e| e.to_str()) != Some("md") { continue; }
+            let content = fs::read_to_string(&path).unwrap_or_default();
+            let matching: Vec<&str> = content.lines()
+                .filter(|l| l.to_lowercase().contains(&query))
+                .take(3)
+                .collect();
+            if !matching.is_empty() {
+                let key = path.file_stem().and_then(|s| s.to_str()).unwrap_or("").to_string();
+                results.push(json!({ "key": key, "matches": matching }));
+            }
+        }
+    }
+    Ok(json!({ "ok": true, "query": args.query, "results": results }))
+}
+
+async fn delete_note(arguments: &str) -> Result<Value> {
+    #[derive(Deserialize)]
+    struct Args { key: String }
+    let args: Args = parse_args(arguments)?;
+    let path = notes_dir()?.join(sanitize_key(&args.key) + ".md");
+    if !path.exists() { bail!("note '{}' not found", args.key); }
+    fs::remove_file(&path)?;
+    Ok(json!({ "ok": true, "key": args.key }))
+}
+
+// ── run_command (streaming variant for live output) ───────────────────────────
+
+/// Streaming run_command: calls `on_line` with each output line as it arrives.
+/// Returns the same JSON as `run_command` but streams progress via the callback.
+pub async fn run_command_with_progress<F>(arguments: &str, mut on_line: F) -> String
+where F: FnMut(String)
+{
+    match run_command_streaming_impl(arguments, &mut on_line).await {
+        Ok(v) => v.to_string(),
+        Err(e) => json!({ "ok": false, "error": e.to_string() }).to_string(),
+    }
+}
+
+async fn run_command_streaming_impl<F>(arguments: &str, on_line: &mut F) -> Result<Value>
+where F: FnMut(String)
+{
+    use tokio::io::AsyncBufReadExt;
+
+    #[derive(Deserialize)]
+    struct Args { command: String, #[serde(default)] timeout_secs: Option<u64> }
+    let args: Args = parse_args(arguments)?;
+    if args.command.trim().is_empty() { bail!("command is empty"); }
+
+    let timeout_secs = args.timeout_secs
+        .unwrap_or(DEFAULT_COMMAND_TIMEOUT_SECS)
+        .min(MAX_COMMAND_TIMEOUT_SECS);
+    let deadline = tokio::time::Instant::now() + Duration::from_secs(timeout_secs);
+
+    // Merge stderr into stdout for unified live streaming
+    let mut child = tokio::process::Command::new("sh")
+        .args(["-c", &format!("({}) 2>&1", args.command)])
+        .stdout(std::process::Stdio::piped())
+        .stdin(std::process::Stdio::null())
+        .kill_on_drop(true)
+        .spawn()
+        .context("failed to spawn command")?;
+
+    let stdout = child.stdout.take().context("no stdout")?;
+    let mut reader = tokio::io::BufReader::new(stdout).lines();
+    let mut all_output = String::new();
+    let mut line_count = 0usize;
+
+    loop {
+        tokio::select! {
+            result = reader.next_line() => {
+                match result? {
+                    Some(line) => {
+                        on_line(line.clone());
+                        all_output.push_str(&line);
+                        all_output.push('\n');
+                        line_count += 1;
+                        if all_output.len() > MAX_COMMAND_OUTPUT {
+                            all_output.push_str("\n...[output truncated]");
+                            break;
+                        }
+                    }
+                    None => break,
+                }
+            }
+            _ = tokio::time::sleep_until(deadline) => {
+                child.kill().await.ok();
+                bail!("command timed out after {timeout_secs}s ({line_count} lines output)");
+            }
+        }
+    }
+
+    let exit_code = child.wait().await?.code().unwrap_or(-1);
+    Ok(json!({
+        "ok": exit_code == 0,
+        "exit_code": exit_code,
+        "stdout": all_output,
+        "stderr": "",
+        "lines": line_count,
+    }))
+}
+
 async fn run_command(arguments: &str) -> Result<Value> {
     let args: RunCommandArgs = parse_args(arguments)?;
     let command = args.command.trim();

package/src/tui.rs

@@ -32,7 +32,7 @@ pub enum TuiEvent {
     ToolDone { summary: String, ok: bool },
     // diff: Vec<(is_add, line)>
     FileOp { verb: String, path: String, added: usize, removed: usize, diff: Vec<(bool, String)> },
-    Confirm { summary: String, reply: oneshot::Sender<ApprovalDecision> },
+    Confirm { summary: String, diff: Vec<(bool, String)>, reply: oneshot::Sender<ApprovalDecision> },
     Usage(Usage),
     Error(String),
     PlanSet(Vec<String>),
@@ -60,6 +60,7 @@ struct PendingTool {
 #[derive(Debug)]
 struct PendingConfirm {
     summary: String,
+    diff: Vec<(bool, String)>,
     reply: oneshot::Sender<ApprovalDecision>,
 }
 
@@ -110,6 +111,7 @@ pub struct App {
     provider: String,
     model: String,
     usage: Usage,
+    session_cost_usd: f64,
     cwd: String,
 
     // mode
@@ -195,6 +197,7 @@ impl App {
             provider,
             model,
             usage: Usage::default(),
+            session_cost_usd: 0.0,
             cwd,
 
             mode: Mode::Input,
@@ -816,13 +819,15 @@ async fn submit_prompt(app: &mut App, text: String) -> Result<()> {
                     TuiEvent::FileOp { verb, path, added, removed, diff }
                 }
                 StreamEvent::Confirm { preview, reply } => {
-                    let summary = match &preview {
-                        ToolConfirmPreview::FileOp { verb, path, added, removed, .. } =>
+                    let (summary, diff) = match preview {
+                        ToolConfirmPreview::FileOp { verb, path, added, removed, diff, .. } => (
                             format!("{verb} {path}  +{added} -{removed}"),
-                        ToolConfirmPreview::CreateDir { path } => format!("mkdir {path}"),
-                        ToolConfirmPreview::Generic { summary } => summary.clone(),
+                            diff.into_iter().map(|dl| (matches!(dl.kind, crate::provider::DiffKind::Add), dl.text)).collect(),
+                        ),
+                        ToolConfirmPreview::CreateDir { path } => (format!("mkdir {path}"), vec![]),
+                        ToolConfirmPreview::Generic { summary } => (summary, vec![]),
                     };
-                    TuiEvent::Confirm { summary, reply }
+                    TuiEvent::Confirm { summary, diff, reply }
                 }
                 StreamEvent::Usage(u) => TuiEvent::Usage(u),
                 StreamEvent::PlanSet { tasks } => TuiEvent::PlanSet(tasks),
@@ -875,10 +880,10 @@ async fn handle_stream_event(app: &mut App, ev: TuiEvent) {
             app.undo_stack.push((path.clone(), old_content));
             app.messages.push(Msg::FileOp { verb, path, added, removed, diff });
         }
-        TuiEvent::Confirm { summary, reply } => {
+        TuiEvent::Confirm { summary, diff, reply } => {
             flush_streaming_buf(app);
             commit_pending_tool(app, true);
-            app.confirm = Some(PendingConfirm { summary, reply });
+            app.confirm = Some(PendingConfirm { summary, diff, reply });
             app.mode = Mode::Confirming;
         }
         TuiEvent::Usage(u) => {
@@ -887,6 +892,11 @@ async fn handle_stream_event(app: &mut App, ev: TuiEvent) {
             app.usage.total_tokens += u.total_tokens;
             app.usage.cache_read_tokens += u.cache_read_tokens;
             app.usage.cache_write_tokens += u.cache_write_tokens;
+            let (in_price, out_price, cr_price, cw_price) = model_pricing(&app.model);
+            app.session_cost_usd += (u.prompt_tokens as f64 - u.cache_read_tokens as f64 - u.cache_write_tokens as f64).max(0.0) * in_price / 1_000_000.0
+                + u.completion_tokens as f64 * out_price / 1_000_000.0
+                + u.cache_read_tokens as f64 * cr_price / 1_000_000.0
+                + u.cache_write_tokens as f64 * cw_price / 1_000_000.0;
             finish_turn(app);
         }
         TuiEvent::Error(msg) => {
@@ -977,6 +987,11 @@ fn finish_turn(app: &mut App) {
             }
         }
     }
+    if let Some(started) = app.streaming_started_at {
+        if started.elapsed() > Duration::from_secs(8) {
+            send_desktop_notification("anveesa", "Task complete");
+        }
+    }
     app.mode = Mode::Input;
     app.tool_status.clear();
     app.streaming_started_at = None;
@@ -1013,11 +1028,18 @@ fn render(frame: &mut Frame, app: &mut App) {
     let input_lines = app.input.lines().count().max(1);
     let input_height = (input_lines as u16).clamp(1, 5) + 2;
 
+    let status_height = if app.mode == Mode::Confirming {
+        let diff_rows = app.confirm.as_ref().map(|c| c.diff.len().min(20) as u16).unwrap_or(0);
+        1 + diff_rows
+    } else {
+        1
+    };
+
     let chunks = Layout::vertical([
         Constraint::Length(1),
         Constraint::Min(3),
         Constraint::Length(input_height),
-        Constraint::Length(1),
+        Constraint::Length(status_height),
     ])
     .split(area);
 
@@ -1027,23 +1049,115 @@ fn render(frame: &mut Frame, app: &mut App) {
     render_status(frame, chunks[3], app);
 }
 
+/// Returns (input_$/M, output_$/M, cache_read_$/M, cache_write_$/M).
+fn model_pricing(model: &str) -> (f64, f64, f64, f64) {
+    let m = model.to_lowercase();
+    if m.contains("claude") {
+        if m.contains("opus") {
+            (15.0, 75.0, 1.5, 18.75)
+        } else if m.contains("sonnet") {
+            (3.0, 15.0, 0.3, 3.75)
+        } else if m.contains("haiku") {
+            if m.contains("3-5") || m.contains("3.5") { (0.25, 1.25, 0.03, 0.30) }
+            else { (0.80, 4.0, 0.08, 1.0) }
+        } else {
+            (3.0, 15.0, 0.3, 3.75)
+        }
+    } else if m.contains("gpt-4o-mini") {
+        (0.15, 0.60, 0.075, 0.0)
+    } else if m.contains("gpt-4o") {
+        (2.50, 10.0, 1.25, 0.0)
+    } else if m.contains("gpt-4-turbo") || m.contains("gpt-4-1106") {
+        (10.0, 30.0, 0.0, 0.0)
+    } else if m.contains("gpt-3.5") {
+        (0.50, 1.50, 0.0, 0.0)
+    } else if m.contains("gemini-1.5-flash") {
+        (0.075, 0.30, 0.0, 0.0)
+    } else if m.contains("gemini") {
+        (1.25, 5.0, 0.0, 0.0)
+    } else {
+        (1.0, 3.0, 0.0, 0.0)
+    }
+}
+
+fn send_desktop_notification(title: &str, body: &str) {
+    #[cfg(target_os = "macos")]
+    {
+        let script = format!(
+            "display notification \"{}\" with title \"{}\"",
+            body.replace('"', "'"),
+            title.replace('"', "'")
+        );
+        let _ = std::process::Command::new("osascript").args(["-e", &script]).spawn();
+    }
+    #[cfg(target_os = "linux")]
+    {
+        let _ = std::process::Command::new("notify-send").args([title, body]).spawn();
+    }
+    #[cfg(not(any(target_os = "macos", target_os = "linux")))]
+    { let _ = (title, body); }
+}
+
+fn context_window_tokens(model: &str) -> usize {
+    let m = model.to_lowercase();
+    if m.contains("gemini") { 1_000_000 }
+    else if m.contains("claude") { 200_000 }
+    else if m.contains("gpt-4") { 128_000 }
+    else if m.contains("gpt-3.5") { 16_000 }
+    else if m.contains("qwen") || m.contains("deepseek") || m.contains("llama") { 128_000 }
+    else { 128_000 }
+}
+
 fn render_header(frame: &mut Frame, area: Rect, app: &App) {
     let version = env!("CARGO_PKG_VERSION");
+
+    // Token info
     let token_str = if app.mode == Mode::Streaming && !app.streaming_buf.is_empty() {
-        // Live estimate: chars / 4 ≈ tokens
         let live = app.streaming_buf.len() / 4;
-        format!("  → {live}t")
+        format!(" → {live}t")
     } else if app.usage.total_tokens > 0 {
-        format!("  {}↓ {}↑", app.usage.prompt_tokens, app.usage.completion_tokens)
+        format!(" {}↓ {}↑", app.usage.prompt_tokens, app.usage.completion_tokens)
     } else {
         String::new()
     };
-    let left = format!(" anveesa v{version}{token_str}");
+
+    // Context usage bar
+    let ctx_tokens: usize = app.history.iter().map(|m| m.content.len() / 4 + 4).sum::<usize>() + 2000;
+    let ctx_max = context_window_tokens(&app.model);
+    let pct = (ctx_tokens * 100 / ctx_max.max(1)).min(100);
+    let bar_len = 8usize;
+    let filled = (pct * bar_len / 100).min(bar_len);
+    let bar = format!("[{}{}] {}k", "█".repeat(filled), "░".repeat(bar_len - filled), ctx_tokens / 1000);
+    let bar_color = if pct > 80 { Color::Rgb(224, 108, 117) }
+        else if pct > 50 { Color::Rgb(229, 192, 123) }
+        else { Color::Rgb(152, 195, 121) };
+
+    let cost_str = if app.session_cost_usd > 0.0 {
+        if app.session_cost_usd < 0.001 {
+            " <$0.001".to_string()
+        } else if app.session_cost_usd < 1.0 {
+            format!(" ~${:.3}", app.session_cost_usd)
+        } else {
+            format!(" ~${:.2}", app.session_cost_usd)
+        }
+    } else {
+        String::new()
+    };
+
+    let left = format!(" anveesa v{version}{token_str}{cost_str}");
+    let mid = format!("  {bar}  ");
     let right = format!(" {} · {} ", app.provider, app.model);
-    let gap = (area.width as usize).saturating_sub(left.chars().count() + right.chars().count());
-    let title = format!("{left}{}{right}", " ".repeat(gap));
+    let gap = (area.width as usize)
+        .saturating_sub(left.chars().count() + mid.chars().count() + right.chars().count());
+
+    let line = ratatui::text::Line::from(vec![
+        Span::styled(left, Style::default().fg(Color::Rgb(20, 20, 30))),
+        Span::styled(mid, Style::default().fg(bar_color)),
+        Span::styled(" ".repeat(gap), Style::default()),
+        Span::styled(right, Style::default().fg(Color::Rgb(20, 20, 30))),
+    ]);
     frame.render_widget(
-        Paragraph::new(title).style(Style::default().fg(Color::Rgb(20, 20, 30)).bg(Color::Rgb(97, 175, 239))),
+        Paragraph::new(line).style(Style::default().bg(Color::Rgb(97, 175, 239))),
         area,
     );
 }
@@ -1288,13 +1402,27 @@ fn render_input(frame: &mut Frame, area: Rect, app: &App) {
 fn render_status(frame: &mut Frame, area: Rect, app: &App) {
     match app.mode {
         Mode::Confirming => {
-            let summary = app.confirm.as_ref().map(|c| c.summary.as_str()).unwrap_or("?");
-            let text = format!(" ⚠  {summary}   [y] allow once   [a] allow all   [n] deny ");
-            frame.render_widget(
-                Paragraph::new(text)
-                    .style(Style::default().fg(Color::Black).bg(Color::Rgb(224, 108, 117))),
-                area,
-            );
+            let summary = app.confirm.as_ref().map(|c| c.summary.clone()).unwrap_or_default();
+            let diff = app.confirm.as_ref().map(|c| c.diff.clone()).unwrap_or_default();
+            let w = area.width as usize;
+            let mut lines: Vec<Line<'static>> = Vec::new();
+            for (is_add, line_text) in diff.iter().take(20) {
+                let (prefix, fg, bg) = if *is_add {
+                    ("+ ", Color::Rgb(152, 195, 121), Color::Rgb(20, 35, 20))
+                } else {
+                    ("- ", Color::Rgb(224, 108, 117), Color::Rgb(35, 20, 20))
+                };
+                let truncated: String = line_text.trim_end().chars().take(w.saturating_sub(3)).collect();
+                lines.push(Line::from(Span::styled(
+                    format!(" {prefix}{truncated}"),
+                    Style::default().fg(fg).bg(bg),
+                )));
+            }
+            lines.push(Line::from(Span::styled(
+                format!(" ⚠  {summary}   [y] allow once   [a] allow all   [n] deny "),
+                Style::default().fg(Color::Black).bg(Color::Rgb(224, 108, 117)),
+            )));
+            frame.render_widget(Paragraph::new(lines), area);
         }
         Mode::Streaming => {
             let dots = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];