anveesa 0.4.3 → 0.4.5

package/Cargo.lock

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

package/Cargo.toml

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anveesa",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "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/mcp.rs

@@ -102,17 +102,23 @@ impl McpServer {
         };
         self.send_msg(json!({ "jsonrpc": "2.0", "id": id, "method": method, "params": params })).await?;
 
-        // Drain notifications until we get our response id
-        loop {
-            let resp = self.recv_msg().await?;
-            if resp.get("id").and_then(|v| v.as_u64()) == Some(id) {
-                if let Some(err) = resp.get("error") {
-                    bail!("MCP error from '{}': {}", self.name, err);
+        // Wait for our response with a timeout
+        let timeout = tokio::time::Duration::from_secs(30);
+        let result = tokio::time::timeout(timeout, async {
+            loop {
+                let resp = self.recv_msg().await?;
+                if resp.get("id").and_then(|v| v.as_u64()) == Some(id) {
+                    if let Some(err) = resp.get("error") {
+                        anyhow::bail!("MCP error from '{}': {}", self.name, err);
+                    }
+                    return Ok(resp["result"].clone());
                 }
-                return Ok(resp["result"].clone());
+                // Drop unmatched messages (notifications, other ids)
             }
-            // Drop unmatched messages (notifications, other ids)
-        }
+        })
+        .await
+        .context(format!("MCP request to '{}' timed out after 30s", self.name))??;
+        Ok(result)
     }
 
     async fn notify(&self, method: &str, params: Value) -> Result<()> {

package/src/tools.rs

@@ -40,6 +40,12 @@ These actions can require the user to approve them, so explain what you intend t
         " For any multi-step task, start by calling set_plan with a list of the steps you will take. \
 After each step completes, call complete_task with the zero-based index of that step. \
 Do not describe your plan in prose — use set_plan instead.",
+    );
+    text.push_str(
+        " CRITICAL — avoid redundant tool calls: All previous tool results are in your context. \
+Do NOT re-read or re-list files and directories you have already inspected in this conversation. \
+Before calling read_file or list_dir, check your conversation history first. \
+Only call tools for information you do not yet have.",
     );
     text.push_str(
         " If a tool call fails or a command times out, do NOT retry it automatically. \
@@ -54,6 +60,8 @@ pub fn is_write_tool(name: &str) -> bool {
     matches!(
         name,
         "create_dir" | "write_file" | "edit_file" | "run_command"
+        | "delete_file" | "move_file" | "copy_file"
+        | "git_commit" | "git_stash" | "git_branch"
     )
 }
 
@@ -79,15 +87,28 @@ pub fn describe_call(name: &str, arguments: &str) -> String {
             field("root").if_empty(".")
         ),
         "read_file" => format!("read file {}", field("path")),
-        "web_search" => format!("web search `{}`", field("query")),
-        "fetch_url"  => format!("fetch {}", field("url")),
-        "git_status" => "git status".to_string(),
-        "git_diff"   => {
+        "web_search"  => format!("web search `{}`", field("query")),
+        "fetch_url"   => format!("fetch {}", field("url")),
+        "git_status"  => "git status".to_string(),
+        "git_diff"    => {
             let path = field("path");
             if path.is_empty() { "git diff".to_string() } else { format!("git diff {path}") }
         }
-        "git_log"    => "git log".to_string(),
-        "create_dir" => format!("create directory {}", field("path")),
+        "git_log"     => "git log".to_string(),
+        "git_blame"   => format!("git blame {}", field("path")),
+        "git_show"    => format!("git show {}", field("ref").if_empty("HEAD")),
+        "git_stash"   => format!("git stash {}", field("action").if_empty("list")),
+        "git_branch"  => {
+            if !field("create").is_empty() { format!("git branch -b {}", field("create")) }
+            else if !field("checkout").is_empty() { format!("git checkout {}", field("checkout")) }
+            else if !field("delete").is_empty() { format!("git branch -d {}", field("delete")) }
+            else { "git branch".to_string() }
+        }
+        "git_commit"  => format!("git commit {}", field("message")),
+        "delete_file" => format!("delete {}", field("path")),
+        "move_file"   => format!("move {} → {}", field("from"), field("to")),
+        "copy_file"   => format!("copy {} → {}", field("from"), field("to")),
+        "create_dir"  => format!("create directory {}", field("path")),
         "write_file" => format!("write file {}", field("path")),
         "edit_file" => format!("edit file {}", field("path")),
         "run_command" => format!("run command `{}`", field("command")),
@@ -261,8 +282,38 @@ pub fn definitions(include_write: bool) -> Vec<Value> {
                 "parameters": {
                     "type": "object",
                     "properties": {
-                        "n":    { "type": "integer", "description": "Number of commits to show (default 20, max 100)." },
-                        "path": { "type": "string",  "description": "Limit log to commits touching this path." }
+                        "n":    { "type": "integer", "description": "Number of commits (default 20, max 100)." },
+                        "path": { "type": "string",  "description": "Limit to commits touching this path." }
+                    }
+                }
+            }
+        }),
+        json!({
+            "type": "function",
+            "function": {
+                "name": "git_blame",
+                "description": "Show who last modified each line of a file (git blame).",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "path":       { "type": "string",  "description": "File path to blame." },
+                        "start_line": { "type": "integer", "description": "First line (1-based)." },
+                        "end_line":   { "type": "integer", "description": "Last line (1-based)." }
+                    },
+                    "required": ["path"]
+                }
+            }
+        }),
+        json!({
+            "type": "function",
+            "function": {
+                "name": "git_show",
+                "description": "Show the contents or diff of a specific commit or object.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "ref":  { "type": "string", "description": "Commit ref (e.g. HEAD, abc123, HEAD~2). Default HEAD." },
+                        "path": { "type": "string", "description": "Limit output to this file." }
                     }
                 }
             }
@@ -320,7 +371,7 @@ pub fn definitions(include_write: bool) -> Vec<Value> {
                 "type": "function",
                 "function": {
                     "name": "run_command",
-                    "description": "Run a shell command in the terminal cwd and return its output. Use for builds, tests, git, and similar tasks.",
+                    "description": "Run a shell command in the terminal cwd and return its output. Use for builds, tests, and tasks not covered by other tools.",
                     "parameters": {
                         "type": "object",
                         "properties": {
@@ -331,6 +382,94 @@ pub fn definitions(include_write: bool) -> Vec<Value> {
                     }
                 }
             }),
+            json!({
+                "type": "function",
+                "function": {
+                    "name": "delete_file",
+                    "description": "Delete a file or empty directory. Use with care — this is irreversible.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "path": { "type": "string", "description": "Path to delete." }
+                        },
+                        "required": ["path"]
+                    }
+                }
+            }),
+            json!({
+                "type": "function",
+                "function": {
+                    "name": "move_file",
+                    "description": "Move or rename a file or directory.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "from": { "type": "string", "description": "Source path." },
+                            "to":   { "type": "string", "description": "Destination path." }
+                        },
+                        "required": ["from", "to"]
+                    }
+                }
+            }),
+            json!({
+                "type": "function",
+                "function": {
+                    "name": "copy_file",
+                    "description": "Copy a file to a new location. Parent directories are created as needed.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "from": { "type": "string", "description": "Source file path." },
+                            "to":   { "type": "string", "description": "Destination path." }
+                        },
+                        "required": ["from", "to"]
+                    }
+                }
+            }),
+            json!({
+                "type": "function",
+                "function": {
+                    "name": "git_stash",
+                    "description": "Save or restore git stash. action: push|pop|list|drop.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "action":  { "type": "string",  "description": "push, pop, list, or drop." },
+                            "message": { "type": "string",  "description": "Stash message (only for push)." }
+                        }
+                    }
+                }
+            }),
+            json!({
+                "type": "function",
+                "function": {
+                    "name": "git_branch",
+                    "description": "List, create, checkout, or delete git branches.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "create":   { "type": "string", "description": "Create and switch to a new branch with this name." },
+                            "checkout": { "type": "string", "description": "Switch to an existing branch." },
+                            "delete":   { "type": "string", "description": "Delete a branch." }
+                        }
+                    }
+                }
+            }),
+            json!({
+                "type": "function",
+                "function": {
+                    "name": "git_commit",
+                    "description": "Create a git commit with the given message. Optionally stage all changes first.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "message": { "type": "string",  "description": "Commit message." },
+                            "add_all": { "type": "boolean", "description": "Run git add -A before committing." }
+                        },
+                        "required": ["message"]
+                    }
+                }
+            }),
         ]);
     }
 
@@ -345,10 +484,18 @@ pub async fn run(name: &str, arguments: &str) -> String {
         "read_file"  => read_file(arguments).await,
         "web_search" => web_search(arguments).await,
         "fetch_url"  => fetch_url(arguments).await,
-        "git_status" => git_status(arguments).await,
-        "git_diff"   => git_diff(arguments).await,
-        "git_log"    => git_log(arguments).await,
-        "create_dir" => create_dir(arguments).await,
+        "git_status"  => git_status(arguments).await,
+        "git_diff"    => git_diff(arguments).await,
+        "git_log"     => git_log(arguments).await,
+        "git_blame"   => git_blame(arguments).await,
+        "git_show"    => git_show(arguments).await,
+        "git_stash"   => git_stash(arguments).await,
+        "git_branch"  => git_branch(arguments).await,
+        "git_commit"  => git_commit(arguments).await,
+        "delete_file" => delete_file(arguments).await,
+        "move_file"   => move_file(arguments).await,
+        "copy_file"   => copy_file(arguments).await,
+        "create_dir"  => create_dir(arguments).await,
         "write_file" => write_file(arguments).await,
         "edit_file"  => edit_file(arguments).await,
         "run_command" => run_command(arguments).await,
@@ -535,41 +682,150 @@ fn http_client() -> &'static reqwest::Client {
 async fn web_search(arguments: &str) -> Result<Value> {
     let args: WebSearchArgs = parse_args(arguments)?;
     let query = args.query.trim();
-    if query.is_empty() {
-        bail!("query is empty");
-    }
+    if query.is_empty() { bail!("query is empty"); }
 
-    let url = format!(
+    // Try DuckDuckGo instant-answer API first
+    let api_url = format!(
         "https://api.duckduckgo.com/?q={}&format=json&no_html=1&skip_disambig=1",
         percent_encode(query)
     );
-    let response: Value = http_client()
-        .get(&url)
-        .send()
-        .await
-        .context("web search request failed")?
-        .json()
-        .await
-        .context("failed to parse web search response")?;
+    let mut results = Vec::new();
+    if let Ok(resp) = http_client().get(&api_url).send().await {
+        if let Ok(response) = resp.json::<Value>().await {
+            if let Some(abstract_text) = response.get("AbstractText").and_then(Value::as_str)
+                && !abstract_text.is_empty()
+            {
+                results.push(json!({
+                    "title": response.get("Heading").and_then(Value::as_str).unwrap_or(""),
+                    "snippet": abstract_text,
+                    "url": response.get("AbstractURL").and_then(Value::as_str).unwrap_or("")
+                }));
+            }
+            collect_related_topics(response.get("RelatedTopics"), &mut results);
+        }
+    }
+
+    // If instant answer had no results, try DuckDuckGo lite (text-only, more reliable)
+    if results.is_empty() {
+        let lite_url = format!(
+            "https://lite.duckduckgo.com/lite/?q={}",
+            percent_encode(query)
+        );
+        if let Ok(resp) = http_client()
+            .get(&lite_url)
+            .header("Accept-Language", "en-US,en;q=0.9")
+            .header("User-Agent", "Mozilla/5.0 (compatible; anveesa-cli)")
+            .send()
+            .await
+        {
+            if let Ok(body) = resp.text().await {
+                results = scrape_ddg_lite(&body, 8);
+            }
+        }
+    }
+
+    results.truncate(10);
+    Ok(json!({ "ok": true, "query": query, "results": results }))
+}
 
+/// Scrape DuckDuckGo lite (text-only) results page.
+fn scrape_ddg_lite(html: &str, max: usize) -> Vec<Value> {
     let mut results = Vec::new();
-    if let Some(abstract_text) = response.get("AbstractText").and_then(Value::as_str)
-        && !abstract_text.is_empty()
-    {
-        results.push(json!({
-            "title": response.get("Heading").and_then(Value::as_str).unwrap_or("DuckDuckGo"),
-            "snippet": abstract_text,
-            "url": response.get("AbstractURL").and_then(Value::as_str).unwrap_or("")
-        }));
+    let mut pos = 0;
+    while results.len() < max {
+        // DDG lite uses <a class="result-link"> for result links
+        let Some(a_pos) = html[pos..].find("class=\"result-link\"") else { break };
+        let block = pos + a_pos;
+
+        let url = extract_attr(&html[block..block.min(html.len()).min(block + 300)], "href")
+            .map(|u| clean_ddg_url(u))
+            .unwrap_or_default();
+        let title = extract_tag_text(&html[block..block.min(html.len()).min(block + 300)], "a")
+            .unwrap_or_default();
+
+        // Snippet is in the next table cell after the result
+        let snip_window_end = (block + 800).min(html.len());
+        let snippet = html[block..snip_window_end]
+            .find("result-snippet")
+            .and_then(|s| extract_tag_text(&html[block + s..snip_window_end], "td"))
+            .unwrap_or_default();
+
+        if !title.is_empty() && !url.is_empty() {
+            results.push(json!({ "title": title, "snippet": snippet, "url": url }));
+        }
+        pos = block + 10;
     }
-    collect_related_topics(response.get("RelatedTopics"), &mut results);
-    results.truncate(8);
+    results
+}
 
-    Ok(json!({
-        "ok": true,
-        "query": query,
-        "results": results
-    }))
+/// Scrape DuckDuckGo HTML search results page into structured results.
+fn scrape_ddg_html(html: &str, max: usize) -> Vec<Value> {
+    let mut results = Vec::new();
+    // DDG HTML results are in <div class="result"> blocks
+    // We extract title + snippet by simple string parsing
+    let mut pos = 0;
+    while results.len() < max {
+        // Find a result block
+        let Some(start) = html[pos..].find("class=\"result__a\"") else { break };
+        let block_start = pos + start;
+
+        // Extract href (URL)
+        let url = extract_attr(&html[block_start..block_start + 500], "href")
+            .map(|u| clean_ddg_url(u))
+            .unwrap_or_default();
+
+        // Extract link text (title)
+        let title = extract_tag_text(&html[block_start..block_start + 500], "a")
+            .unwrap_or_default();
+
+        // Find snippet nearby
+        let snippet_window = &html[block_start..std::cmp::min(block_start + 1000, html.len())];
+        let snippet = if let Some(s) = snippet_window.find("result__snippet") {
+            extract_tag_text(&snippet_window[s..std::cmp::min(s + 400, snippet_window.len())], "a")
+                .or_else(|| extract_tag_text(&snippet_window[s..std::cmp::min(s + 400, snippet_window.len())], "span"))
+                .unwrap_or_default()
+        } else {
+            String::new()
+        };
+
+        if !title.is_empty() && !url.is_empty() {
+            results.push(json!({ "title": title, "snippet": snippet, "url": url }));
+        }
+        pos = block_start + 10;
+    }
+    results
+}
+
+fn extract_attr<'a>(html: &'a str, attr: &str) -> Option<&'a str> {
+    let key = format!("{attr}=\"");
+    let start = html.find(&key)? + key.len();
+    let end = html[start..].find('"')? + start;
+    Some(&html[start..end])
+}
+
+fn extract_tag_text(html: &str, tag: &str) -> Option<String> {
+    let open = format!("<{tag}");
+    let start = html.find(&open)?;
+    let inner_start = html[start..].find('>')? + start + 1;
+    let close = format!("</{tag}>");
+    let end = html[inner_start..].find(&close)? + inner_start;
+    let raw = &html[inner_start..end];
+    let text = html_to_text(raw);
+    if text.trim().is_empty() { None } else { Some(text.trim().to_string()) }
+}
+
+fn clean_ddg_url(raw: &str) -> String {
+    // DDG wraps URLs in redirect: //duckduckgo.com/l/?uddg=https%3A%2F%2F...
+    if let Some(i) = raw.find("uddg=") {
+        let encoded = &raw[i + 5..];
+        let decoded = encoded.replace("%3A", ":").replace("%2F", "/")
+            .replace("%3F", "?").replace("%3D", "=").replace("%26", "&");
+        decoded.split('&').next().unwrap_or(&decoded).to_string()
+    } else if raw.starts_with("//") {
+        format!("https:{raw}")
+    } else {
+        raw.to_string()
+    }
 }
 
 // ── fetch_url ─────────────────────────────────────────────────────────────────
@@ -739,6 +995,183 @@ async fn git_log(arguments: &str) -> Result<Value> {
     }))
 }
 
+async fn git_blame(arguments: &str) -> Result<Value> {
+    #[derive(Deserialize)]
+    struct Args {
+        path: String,
+        #[serde(default)] start_line: Option<usize>,
+        #[serde(default)] end_line: Option<usize>,
+    }
+    let args: Args = parse_args(arguments)?;
+    let mut cmd = tokio::process::Command::new("git");
+    cmd.args(["blame", "-s"]).kill_on_drop(true);
+    if let (Some(s), Some(e)) = (args.start_line, args.end_line) {
+        cmd.arg(format!("-L{s},{e}"));
+    } else if let Some(s) = args.start_line {
+        cmd.arg(format!("-L{s},+50"));
+    }
+    cmd.arg(&args.path);
+    let out = cmd.output().await.context("failed to run git blame")?;
+    let text = String::from_utf8_lossy(&out.stdout).to_string();
+    let truncated = text.len() > 20_000;
+    Ok(json!({
+        "ok": out.status.success(),
+        "blame": if truncated { &text[..20_000] } else { &text },
+        "truncated": truncated,
+        "error": if !out.status.success() { Some(String::from_utf8_lossy(&out.stderr).trim().to_string()) } else { None },
+    }))
+}
+
+async fn git_show(arguments: &str) -> Result<Value> {
+    #[derive(Deserialize, Default)]
+    struct Args {
+        #[serde(rename = "ref", default)] refspec: Option<String>,
+        #[serde(default)] path: Option<String>,
+    }
+    let args: Args = serde_json::from_str(arguments).unwrap_or_default();
+    let mut cmd = tokio::process::Command::new("git");
+    cmd.arg("show").kill_on_drop(true);
+    cmd.arg(args.refspec.as_deref().unwrap_or("HEAD"));
+    if let Some(p) = &args.path { cmd.arg("--").arg(p); }
+    let out = cmd.output().await.context("failed to run git show")?;
+    let text = String::from_utf8_lossy(&out.stdout).to_string();
+    let truncated = text.len() > 20_000;
+    Ok(json!({
+        "ok": out.status.success(),
+        "output": if truncated { &text[..20_000] } else { &text },
+        "truncated": truncated,
+    }))
+}
+
+async fn git_stash(arguments: &str) -> Result<Value> {
+    #[derive(Deserialize, Default)]
+    struct Args {
+        #[serde(default)] action: Option<String>,
+        #[serde(default)] message: Option<String>,
+    }
+    let args: Args = serde_json::from_str(arguments).unwrap_or_default();
+    let action = args.action.as_deref().unwrap_or("list");
+    let mut cmd = tokio::process::Command::new("git");
+    cmd.arg("stash").kill_on_drop(true);
+    match action {
+        "push" => {
+            cmd.arg("push");
+            if let Some(m) = &args.message { cmd.arg("-m").arg(m); }
+        }
+        "pop"  => { cmd.arg("pop"); }
+        "drop" => { cmd.arg("drop"); }
+        _      => { cmd.arg("list"); }
+    }
+    let out = cmd.output().await.context("failed to run git stash")?;
+    Ok(json!({
+        "ok": out.status.success(),
+        "output": String::from_utf8_lossy(&out.stdout).trim().to_string(),
+        "error": if !out.status.success() { Some(String::from_utf8_lossy(&out.stderr).trim().to_string()) } else { None },
+    }))
+}
+
+async fn git_branch(arguments: &str) -> Result<Value> {
+    #[derive(Deserialize, Default)]
+    struct Args {
+        #[serde(default)] create:   Option<String>,
+        #[serde(default)] checkout: Option<String>,
+        #[serde(default)] delete:   Option<String>,
+    }
+    let args: Args = serde_json::from_str(arguments).unwrap_or_default();
+    let (git_args, key, val): (Vec<&str>, &str, &str) =
+        if let Some(name) = &args.create {
+            (vec!["checkout", "-b", name], "created", name)
+        } else if let Some(name) = &args.checkout {
+            (vec!["checkout", name], "checked_out", name)
+        } else if let Some(name) = &args.delete {
+            (vec!["branch", "-d", name], "deleted", name)
+        } else {
+            let out = tokio::process::Command::new("git").args(["branch", "-a"]).kill_on_drop(true).output().await.context("failed to run git branch")?;
+            return Ok(json!({ "ok": out.status.success(), "branches": String::from_utf8_lossy(&out.stdout).trim().to_string() }));
+        };
+    let out = tokio::process::Command::new("git").args(&git_args).kill_on_drop(true).output().await.context("failed to run git branch")?;
+    Ok(json!({
+        "ok": out.status.success(),
+        key: val,
+        "error": if !out.status.success() { Some(String::from_utf8_lossy(&out.stderr).trim().to_string()) } else { None },
+    }))
+}
+
+async fn git_commit(arguments: &str) -> Result<Value> {
+    #[derive(Deserialize)]
+    struct Args {
+        message: String,
+        #[serde(default)] add_all: bool,
+    }
+    let args: Args = parse_args(arguments)?;
+    if args.message.trim().is_empty() { bail!("commit message is required"); }
+    if args.add_all {
+        tokio::process::Command::new("git").args(["add", "-A"]).kill_on_drop(true).output().await.context("failed to git add")?;
+    }
+    let out = tokio::process::Command::new("git")
+        .args(["commit", "-m", &args.message])
+        .kill_on_drop(true)
+        .output()
+        .await
+        .context("failed to run git commit")?;
+    Ok(json!({
+        "ok": out.status.success(),
+        "output": String::from_utf8_lossy(&out.stdout).trim().to_string(),
+        "error": if !out.status.success() { Some(String::from_utf8_lossy(&out.stderr).trim().to_string()) } else { None },
+    }))
+}
+
+// ── file management ───────────────────────────────────────────────────────────
+
+async fn delete_file(arguments: &str) -> Result<Value> {
+    let args: PathArgs = parse_args(arguments)?;
+    let path = resolve_writable_path(&args.path.context("path is required")?)?;
+    if is_sensitive_path(&path) {
+        bail!("refusing to delete sensitive path {}", path.display());
+    }
+    if !path.exists() {
+        bail!("{} does not exist", path.display());
+    }
+    let was_dir = path.is_dir();
+    if was_dir {
+        fs::remove_dir_all(&path).with_context(|| format!("failed to delete {}", path.display()))?;
+    } else {
+        fs::remove_file(&path).with_context(|| format!("failed to delete {}", path.display()))?;
+    }
+    Ok(json!({ "ok": true, "path": path.display().to_string(), "was_dir": was_dir }))
+}
+
+async fn move_file(arguments: &str) -> Result<Value> {
+    #[derive(Deserialize)]
+    struct Args { from: String, to: String }
+    let args: Args = parse_args(arguments)?;
+    let from = resolve_writable_path(&args.from)?;
+    let to   = resolve_writable_path(&args.to)?;
+    if is_sensitive_path(&from) || is_sensitive_path(&to) {
+        bail!("refusing to move sensitive path");
+    }
+    if !from.exists() { bail!("{} does not exist", from.display()); }
+    if let Some(parent) = to.parent() { fs::create_dir_all(parent)?; }
+    fs::rename(&from, &to).with_context(|| format!("failed to move {} → {}", from.display(), to.display()))?;
+    Ok(json!({ "ok": true, "from": from.display().to_string(), "to": to.display().to_string() }))
+}
+
+async fn copy_file(arguments: &str) -> Result<Value> {
+    #[derive(Deserialize)]
+    struct Args { from: String, to: String }
+    let args: Args = parse_args(arguments)?;
+    let from_str = args.from.trim();
+    let from = resolve_path(from_str)?;
+    let to   = resolve_writable_path(&args.to)?;
+    if is_sensitive_path(&from) || is_sensitive_path(&to) {
+        bail!("refusing to copy sensitive path");
+    }
+    if !from.is_file() { bail!("{} is not a file", from.display()); }
+    if let Some(parent) = to.parent() { fs::create_dir_all(parent)?; }
+    let bytes = fs::copy(&from, &to).with_context(|| format!("failed to copy {} → {}", from.display(), to.display()))?;
+    Ok(json!({ "ok": true, "from": from.display().to_string(), "to": to.display().to_string(), "bytes": bytes }))
+}
+
 async fn create_dir(arguments: &str) -> Result<Value> {
     let args: CreateDirArgs = parse_args(arguments)?;
     let path = resolve_writable_path(&args.path)?;

package/src/tools_scenarios.rs

@@ -552,8 +552,8 @@ fn s7_is_write_tool() {
     assert!(!is_write_tool("EDIT_FILE"));
     assert!(!is_write_tool("RUN_COMMAND"));
     assert!(!is_write_tool("create_directory"));
-    assert!(!is_write_tool("delete_file"));
-    assert!(!is_write_tool("move_file"));
+    assert!(is_write_tool("delete_file"));
+    assert!(is_write_tool("move_file"));
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════

package/src/tui.rs

@@ -86,7 +86,9 @@ pub struct App {
     pending_prompt: String,
     streaming_started_at: Option<Instant>,
     tool_started_at: Option<Instant>,
-    unread_count: usize, // messages added while scrolled away
+    unread_count: usize,
+    // files/dirs already read this session — injected into workspace context each turn
+    seen_paths: std::collections::BTreeSet<String>,
 
     // input
     input: String,
@@ -173,6 +175,7 @@ impl App {
             streaming_started_at: None,
             tool_started_at: None,
             unread_count: 0,
+            seen_paths: std::collections::BTreeSet::new(),
 
             input: String::new(),
             input_cursor: 0,
@@ -511,6 +514,17 @@ async fn handle_key(app: &mut App, KeyEvent { code, modifiers, .. }: KeyEvent) -
             }
         }
 
+        // j/k vim-style scroll when input is empty
+        KeyCode::Char('j') if app.input.is_empty() => {
+            app.scroll = app.scroll.saturating_add(3);
+            if app.scroll >= app.total_lines { app.auto_scroll = true; app.unread_count = 0; }
+            else { app.auto_scroll = false; }
+        }
+        KeyCode::Char('k') if app.input.is_empty() => {
+            app.auto_scroll = false;
+            app.scroll = app.scroll.saturating_sub(3);
+        }
+
         // Printable characters
         KeyCode::Char(c) => {
             let s = c.to_string();
@@ -538,6 +552,7 @@ fn handle_slash_command(app: &mut App, text: &str) -> bool {
             app.accumulated_response.clear();
             app.usage = Usage::default();
             app.pending_image = None;
+            app.seen_paths.clear();
             app.input.clear();
             app.input_cursor = 0;
             if let Some(path) = &app.session_path {
@@ -547,11 +562,13 @@ fn handle_slash_command(app: &mut App, text: &str) -> bool {
         }
         "/help" => {
             app.messages.push(Msg::System(
-                "Commands: /clear  /copy  /export [path]  /model [name]  /provider [name]  /status  /exit\n\
+                "Commands: /clear  /compact  /copy  /export [path]\n\
+                 /model [name]  /provider [name]  /status  /exit\n\
+                 \n\
                  Keys: ↑/↓ history  ←/→ cursor  Home/End  Shift+Enter newline\n\
-                 Ctrl+W delete-word  Ctrl+U clear-line  Ctrl+V paste image\n\
-                 Ctrl+M toggle scroll/select mode  PageUp/Dn scroll\n\
-                 [scroll] = mouse wheel scrolls  [select] = mouse selects text to copy".into(),
+                 j/k scroll (when input empty)  PageUp/Dn scroll\n\
+                 Ctrl+W delete-word  Ctrl+U clear-line  Ctrl+V paste\n\
+                 Ctrl+M toggle scroll/select mode".into(),
             ));
             app.input.clear();
             app.input_cursor = 0;
@@ -590,6 +607,34 @@ fn handle_slash_command(app: &mut App, text: &str) -> bool {
             app.input_cursor = 0;
             true
         }
+        "/compact" => {
+            // Keep only the last 10 turns, drop older history to free context
+            let keep = 10usize;
+            let total_turns = app.history.len() / 2;
+            if total_turns <= keep {
+                app.messages.push(Msg::System(format!(
+                    "Conversation has {total_turns} turn(s) — nothing to compact yet (threshold: {keep})."
+                )));
+            } else {
+                let drop_turns = total_turns - keep;
+                let drop_msgs = drop_turns * 2;
+                app.history.drain(..drop_msgs);
+                // Also remove older messages from the display (keep separators and last N turns)
+                let msg_count = app.messages.len();
+                if msg_count > keep * 3 {
+                    app.messages.drain(..(msg_count - keep * 3));
+                }
+                app.seen_paths.clear(); // refresh seen paths for the new context window
+                app.messages.insert(0, Msg::System(format!(
+                    "Context compacted: dropped {drop_turns} older turn(s), keeping the last {keep}. \
+                     Use /clear to start fresh."
+                )));
+                app.messages.push(Msg::Separator);
+            }
+            app.input.clear();
+            app.input_cursor = 0;
+            true
+        }
         s if s.starts_with("/export") => {
             let arg = s.strip_prefix("/export").unwrap().trim();
             let path = if arg.is_empty() {
@@ -690,7 +735,11 @@ async fn submit_prompt(app: &mut App, text: String) -> Result<()> {
     let config = app.config.clone();
     let options = app.options.clone();
     let history = app.history.clone();
-    let workspace_context = app.workspace_context.clone();
+    // Augment workspace context with already-seen paths so the model doesn't re-scan them
+    let workspace_context = augmented_workspace_context(
+        app.workspace_context.as_deref(),
+        &app.seen_paths,
+    );
     let policy = app.policy;
     let mcp_arc = app.mcp.clone();
     let tui_tx = app.stream_tx.clone();
@@ -780,6 +829,8 @@ async fn handle_stream_event(app: &mut App, ev: TuiEvent) {
         }
         TuiEvent::ToolDone { summary, ok } => {
             let elapsed_ms = app.tool_started_at.take().map(|t| t.elapsed().as_millis());
+            // Record the inspected path so we can tell the model what it already knows
+            record_seen_path(&mut app.seen_paths, &summary);
             app.pending_tool = Some(PendingTool { summary });
             commit_pending_tool_timed(app, ok, elapsed_ms);
             app.tool_status = "Thinking".to_string();
@@ -819,6 +870,39 @@ async fn handle_stream_event(app: &mut App, ev: TuiEvent) {
     }
 }
 
+/// Extract a path from a tool call summary string and record it as "already seen".
+fn record_seen_path(seen: &mut std::collections::BTreeSet<String>, summary: &str) {
+    // Summaries look like "read file src/foo.ts" or "list directory src/bar"
+    // or "git status", "web search `...`" — only record file/dir paths
+    for prefix in &["read file ", "list directory "] {
+        if let Some(path) = summary.strip_prefix(prefix) {
+            let path = path.trim().to_string();
+            if !path.is_empty() {
+                seen.insert(path);
+            }
+            return;
+        }
+    }
+}
+
+/// Build an augmented workspace context that includes already-seen paths.
+fn augmented_workspace_context(
+    base: Option<&str>,
+    seen: &std::collections::BTreeSet<String>,
+) -> Option<String> {
+    if seen.is_empty() {
+        return base.map(str::to_string);
+    }
+    let seen_note = format!(
+        "\nAlready inspected this session (do NOT re-read these):\n{}",
+        seen.iter().map(|p| format!("  - {p}")).collect::<Vec<_>>().join("\n")
+    );
+    Some(match base {
+        Some(b) => format!("{b}{seen_note}"),
+        None => seen_note,
+    })
+}
+
 /// Flush streaming_buf to messages and accumulated_response.
 fn flush_streaming_buf(app: &mut App) {
     if !app.streaming_buf.is_empty() {
@@ -1042,13 +1126,25 @@ fn render_messages(frame: &mut Frame, area: Rect, app: &mut App) {
         lines.push(Line::from(""));
     }
 
+    // Add bottom padding so wrapped last lines are never cut off by viewport
+    for _ in 0..3 { lines.push(Line::from("")); }
+
+    // Estimate visual rows (accounting for line wrapping) for accurate auto-scroll
+    let visual_rows: usize = if width == 0 { lines.len() } else {
+        lines.iter().map(|l| {
+            let chars: usize = l.spans.iter().map(|s| s.content.chars().count()).sum();
+            if chars == 0 { 1 } else { chars.div_ceil(width) }
+        }).sum()
+    };
+
     let total = lines.len();
     app.total_lines = total;
     let visible = area.height as usize;
     let scroll = if app.auto_scroll || app.scroll == usize::MAX {
-        total.saturating_sub(visible)
+        // Use visual-row estimate to scroll accurately to the bottom
+        visual_rows.saturating_sub(visible)
     } else {
-        app.scroll.min(total.saturating_sub(visible))
+        app.scroll.min(total.saturating_sub(1))
     };
     app.scroll = scroll;