@ridit/lens 0.2.0 → 0.2.2

package/dist/index.mjs

@@ -44302,6 +44302,8 @@ function fetchFileTree(repoPath) {
   });
 }
 function readImportantFiles(repoPath, files) {
+  if (files.length > 100)
+    return [];
   return files.filter(isImportantFile).flatMap((filePath) => {
     try {
       const content = readFileSync2(path2.join(repoPath, filePath), "utf-8");
@@ -48630,15 +48632,16 @@ var TaskCommand = ({
 };
 
 // src/commands/chat.tsx
-import { existsSync as existsSync12 } from "fs";
-import path17 from "path";
+import { existsSync as existsSync14 } from "fs";
+import path19 from "path";
 
 // src/components/chat/ChatRunner.tsx
 var import_react48 = __toESM(require_react(), 1);
-import path16 from "path";
-import os7 from "os";
+var import_react49 = __toESM(require_react(), 1);
+import path18 from "path";
+import os9 from "os";
 
-// src/utils/chat.ts
+// src/tools/files.ts
 import path14 from "path";
 import {
   existsSync as existsSync10,
@@ -48648,576 +48651,1009 @@ import {
   statSync as statSync4,
   writeFileSync as writeFileSync6
 } from "fs";
-function buildSystemPrompt(files, historySummary = "") {
-  const fileList = files.map((f) => `### ${f.path}
-\`\`\`
-${f.content.slice(0, 2000)}
-\`\`\``).join(`
-
-`);
-  return `You are an expert software engineer assistant with access to the user's codebase and eleven tools.
-
-## TOOLS
-
-You have exactly eleven tools. To use a tool you MUST wrap it in the exact XML tags shown below — no other format will work.
-
-### 1. fetch — load a URL
-<fetch>https://example.com</fetch>
-
-### 2. shell — run a terminal command
-<shell>node -v</shell>
-
-### 3. read-file — read a file from the repo
-<read-file>src/foo.ts</read-file>
-
-### 4. read-folder — list contents of a folder (files + subfolders, one level deep)
-<read-folder>src/components</read-folder>
-
-### 5. grep — search for a pattern across files in the repo (cross-platform, no shell needed)
-<grep>
-{"pattern": "ChatRunner", "glob": "src/**/*.tsx"}
-</grep>
-
-### 6. write-file — create or overwrite a file
-<write-file>
-{"path": "data/output.csv", "content": "col1,col2
-val1,val2"}
-</write-file>
-
-### 7. delete-file — permanently delete a single file
-<delete-file>src/old-component.tsx</delete-file>
-
-### 8. delete-folder — permanently delete a folder and all its contents
-<delete-folder>src/legacy</delete-folder>
-
-### 9. open-url — open a URL in the user's default browser
-<open-url>https://github.com/owner/repo</open-url>
-
-### 10. generate-pdf — generate a PDF file from markdown-style content
-<generate-pdf>
-{"path": "output/report.pdf", "content": "# Title
-
-Some body text.
-
-## Section
-
-More content."}
-</generate-pdf>
-
-### 11. search — search the internet for anything you are unsure about
-<search>how to use React useEffect cleanup function</search>
-
-### 12. clone — clone a GitHub repo so you can explore and discuss it
-<clone>https://github.com/owner/repo</clone>
+var SKIP_DIRS4 = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  "out",
+  "coverage",
+  "__pycache__",
+  ".venv",
+  "venv"
+]);
+function walkDir3(dir, base2 = dir, results = []) {
+  let entries;
+  try {
+    entries = readdirSync3(dir, { encoding: "utf-8" });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    if (results.length >= 100)
+      return results;
+    if (SKIP_DIRS4.has(entry))
+      continue;
+    const full = path14.join(dir, entry);
+    const rel = path14.relative(base2, full).replace(/\\/g, "/");
+    let isDir = false;
+    try {
+      isDir = statSync4(full).isDirectory();
+    } catch {
+      continue;
+    }
+    if (isDir)
+      walkDir3(full, base2, results);
+    else
+      results.push(rel);
+  }
+  return results;
+}
+function applyPatches3(repoPath, patches) {
+  for (const patch of patches) {
+    const fullPath = path14.join(repoPath, patch.path);
+    const dir = path14.dirname(fullPath);
+    if (!existsSync10(dir))
+      mkdirSync4(dir, { recursive: true });
+    writeFileSync6(fullPath, patch.content, "utf-8");
+  }
+}
+function readFile(filePath, repoPath) {
+  const candidates = path14.isAbsolute(filePath) ? [filePath] : [filePath, path14.join(repoPath, filePath)];
+  for (const candidate of candidates) {
+    if (existsSync10(candidate)) {
+      try {
+        const content = readFileSync10(candidate, "utf-8");
+        const lines = content.split(`
+`).length;
+        return `File: ${candidate} (${lines} lines)
 
-### 13. changes — propose code edits (shown as a diff for user approval)
-<changes>
-{"summary": "what changed and why", "patches": [{"path": "src/foo.ts", "content": "COMPLETE file content", "isNew": false}]}
-</changes>
+${content.slice(0, 8000)}${content.length > 8000 ? `
 
-## RULES
+… (truncated)` : ""}`;
+      } catch (err) {
+        return `Error reading file: ${err instanceof Error ? err.message : String(err)}`;
+      }
+    }
+  }
+  return `File not found: ${filePath}. If reading from a cloned repo, use the full absolute path e.g. C:\\Users\\...\\repo\\file.ts`;
+}
+function readFolder(folderPath, repoPath) {
+  const sanitized = folderPath.replace(/^(ls|dir|find|tree|cat|read|ls -la?|ls -al?)\s+/i, "").trim();
+  const candidates = path14.isAbsolute(sanitized) ? [sanitized] : [sanitized, path14.join(repoPath, sanitized)];
+  for (const candidate of candidates) {
+    if (!existsSync10(candidate))
+      continue;
+    let stat;
+    try {
+      stat = statSync4(candidate);
+    } catch {
+      continue;
+    }
+    if (!stat.isDirectory()) {
+      return `Not a directory: ${candidate}. Use read-file to read a file.`;
+    }
+    let entries;
+    try {
+      entries = readdirSync3(candidate, { encoding: "utf-8" });
+    } catch (err) {
+      return `Error reading folder: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    const files = [];
+    const subfolders = [];
+    for (const entry of entries) {
+      if (entry.startsWith(".") && entry !== ".env")
+        continue;
+      const full = path14.join(candidate, entry);
+      try {
+        if (statSync4(full).isDirectory())
+          subfolders.push(`${entry}/`);
+        else
+          files.push(entry);
+      } catch {}
+    }
+    const total = files.length + subfolders.length;
+    const lines = [`Folder: ${candidate} (${total} entries)`, ""];
+    if (files.length > 0) {
+      lines.push("Files:");
+      files.forEach((f) => lines.push(`  ${f}`));
+    }
+    if (subfolders.length > 0) {
+      if (files.length > 0)
+        lines.push("");
+      lines.push("Subfolders:");
+      subfolders.forEach((d) => lines.push(`  ${d}`));
+    }
+    if (total === 0)
+      lines.push("(empty folder)");
+    return lines.join(`
+`);
+  }
+  return `Folder not found: ${sanitized}`;
+}
+function grepFiles(pattern, glob, repoPath) {
+  let regex2;
+  try {
+    regex2 = new RegExp(pattern, "i");
+  } catch {
+    regex2 = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
+  }
+  const globToFilter = (g) => {
+    const cleaned = g.replace(/^\*\*\//, "");
+    const parts = cleaned.split("/");
+    const ext = parts[parts.length - 1];
+    const prefix = parts.slice(0, -1).join("/");
+    return (rel) => {
+      if (ext?.startsWith("*.")) {
+        if (!rel.endsWith(ext.slice(1)))
+          return false;
+      } else if (ext && !ext.includes("*")) {
+        if (!rel.endsWith(ext))
+          return false;
+      }
+      if (prefix && !prefix.includes("*")) {
+        if (!rel.startsWith(prefix))
+          return false;
+      }
+      return true;
+    };
+  };
+  const filter2 = globToFilter(glob);
+  const allFiles = walkDir3(repoPath);
+  const matchedFiles = allFiles.filter(filter2);
+  if (matchedFiles.length === 0)
+    return `No files matched glob: ${glob}`;
+  const results = [];
+  let totalMatches = 0;
+  for (const relPath of matchedFiles) {
+    const fullPath = path14.join(repoPath, relPath);
+    let content;
+    try {
+      content = readFileSync10(fullPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const fileLines = content.split(`
+`);
+    const fileMatches = [];
+    fileLines.forEach((line, i) => {
+      if (regex2.test(line)) {
+        fileMatches.push(`  ${i + 1}: ${line.trimEnd()}`);
+        totalMatches++;
+      }
+    });
+    if (fileMatches.length > 0)
+      results.push(`${relPath}
+${fileMatches.join(`
+`)}`);
+    if (totalMatches >= 200) {
+      results.push("(truncated — too many matches)");
+      break;
+    }
+  }
+  if (results.length === 0)
+    return `No matches for /${pattern}/ in ${matchedFiles.length} file(s) matching ${glob}`;
+  return `grep /${pattern}/ ${glob} — ${totalMatches} match(es) in ${results.length} file(s)
 
-1. When you need to use a tool, output ONLY the XML tag — nothing before or after it in that response
-2. ONE tool per response — emit the tag, then stop completely
-3. After the user approves and you get the result, continue your analysis in the next response
-4. NEVER print a URL, command, filename, or JSON blob as plain text when you should be using a tool
-5. NEVER say "I'll fetch" / "run this command" / "here's the write-file" — just emit the tag
-6. NEVER use shell to run git clone — always use the clone tag instead
-7. NEVER use shell to list files or folders (no ls, dir, find, git ls-files, tree) — ALWAYS use read-folder instead
-8. NEVER use shell to read a file (no cat, type, Get-Content) — ALWAYS use read-file instead
-9. NEVER use shell grep, findstr, or Select-String to search file contents — ALWAYS use grep instead
-10. shell is ONLY for running code, installing packages, building, testing — not for filesystem inspection
-11. write-file content field must be the COMPLETE file content, never empty or placeholder
-12. After a write-file succeeds, do NOT repeat it — trust the result and move on
-13. After a write-file succeeds, tell the user it is done immediately — do NOT auto-read the file back to verify
-14. NEVER apologize and redo a tool call you already made — if write-file or shell ran and returned a result, it worked, do not run it again
-15. NEVER say "I made a mistake" and repeat the same tool — one attempt is enough, trust the output
-16. NEVER second-guess yourself mid-response — commit to your answer
-17. If a read-folder or read-file returns "not found", accept it and move on — do NOT retry the same path
-18. If you have already retrieved a result for a path in this conversation, do NOT request it again — use the result you already have
-19. Every shell command runs from the repo root — \`cd\` has NO persistent effect. NEVER use \`cd\` alone. Use full paths or combine with && e.g. \`cd list && bun run index.ts\`
-20. write-file paths are relative to the repo root — if creating files in a subfolder write the full relative path e.g. \`list/src/index.tsx\` NOT \`src/index.tsx\`
-21. When scaffolding a new project in a subfolder, ALL write-file paths must start with that subfolder name e.g. \`list/package.json\`, \`list/src/index.tsx\`
-22. For JSX/TSX files always use \`.tsx\` extension and include \`/** @jsxImportSource react */\` or ensure tsconfig has jsx set — bun needs this to parse JSX
-23. When explaining how to use a tool in text, use [tag] bracket notation or a fenced code block — NEVER emit a real XML tool tag as part of an explanation or example
-24. NEVER chain tool calls unless the user's request explicitly requires multiple steps
-25. NEVER read files, list folders, or run tools that were not asked for in the current user message
-26. NEVER use markdown formatting in plain text responses — no **bold**, no *italics*, no # headings, no bullet points with -, *, or +, no numbered lists, no backtick inline code. Write in plain prose. Only use fenced \`\`\` code blocks when showing actual code.
+${results.join(`
 
-## CRITICAL: READ BEFORE YOU WRITE
-
-These rules are mandatory whenever you plan to edit or create a file:
+`)}`;
+}
+function writeFile(filePath, content, repoPath) {
+  const fullPath = path14.isAbsolute(filePath) ? filePath : path14.join(repoPath, filePath);
+  try {
+    const dir = path14.dirname(fullPath);
+    if (!existsSync10(dir))
+      mkdirSync4(dir, { recursive: true });
+    writeFileSync6(fullPath, content, "utf-8");
+    const lines = content.split(`
+`).length;
+    return `Written: ${fullPath} (${lines} lines, ${content.length} bytes)`;
+  } catch (err) {
+    return `Error writing file: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+function deleteFile(filePath, repoPath) {
+  const fullPath = path14.isAbsolute(filePath) ? filePath : path14.join(repoPath, filePath);
+  try {
+    if (!existsSync10(fullPath))
+      return `File not found: ${fullPath}`;
+    const { unlinkSync } = __require("fs");
+    unlinkSync(fullPath);
+    return `Deleted: ${fullPath}`;
+  } catch (err) {
+    return `Error deleting file: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+function deleteFolder(folderPath, repoPath) {
+  const fullPath = path14.isAbsolute(folderPath) ? folderPath : path14.join(repoPath, folderPath);
+  try {
+    if (!existsSync10(fullPath))
+      return `Folder not found: ${fullPath}`;
+    const { rmSync } = __require("fs");
+    rmSync(fullPath, { recursive: true, force: true });
+    return `Deleted folder: ${fullPath}`;
+  } catch (err) {
+    return `Error deleting folder: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+// src/tools/shell.ts
+async function runShell(command, cwd2) {
+  return new Promise((resolve) => {
+    const { spawn: spawn2 } = __require("child_process");
+    const isWin = process.platform === "win32";
+    const shell = isWin ? "cmd.exe" : "/bin/sh";
+    const shellFlag = isWin ? "/c" : "-c";
+    const proc = spawn2(shell, [shellFlag, command], {
+      cwd: cwd2,
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const chunks = [];
+    const errChunks = [];
+    proc.stdout.on("data", (d) => chunks.push(d));
+    proc.stderr.on("data", (d) => errChunks.push(d));
+    const killTimer = setTimeout(() => {
+      proc.kill();
+      resolve("(command timed out after 5 minutes)");
+    }, 5 * 60 * 1000);
+    proc.on("close", (code) => {
+      clearTimeout(killTimer);
+      const stdout = Buffer.concat(chunks).toString("utf-8").trim();
+      const stderr = Buffer.concat(errChunks).toString("utf-8").trim();
+      const combined = [stdout, stderr].filter(Boolean).join(`
+`);
+      resolve(combined || (code === 0 ? "(no output)" : `exit code ${code}`));
+    });
+    proc.on("error", (err) => {
+      clearTimeout(killTimer);
+      resolve(`Error: ${err.message}`);
+    });
+  });
+}
+function openUrl(url) {
+  try {
+    const { execSync: exec5 } = __require("child_process");
+    const platform2 = process.platform;
+    if (platform2 === "win32") {
+      exec5(`start "" "${url}"`, { stdio: "ignore" });
+    } else if (platform2 === "darwin") {
+      exec5(`open "${url}"`, { stdio: "ignore" });
+    } else {
+      exec5(`xdg-open "${url}"`, { stdio: "ignore" });
+    }
+    return `Opened: ${url}`;
+  } catch (err) {
+    return `Error opening URL: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+// src/tools/web.ts
+function stripTags(html) {
+  return html.replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#\d+;/g, " ").replace(/\s+/g, " ").trim();
+}
+function extractTables(html) {
+  const tables = [];
+  const tableRe = /<table[\s\S]*?<\/table>/gi;
+  let tMatch;
+  while ((tMatch = tableRe.exec(html)) !== null) {
+    const tableHtml = tMatch[0];
+    const rows = [];
+    const rowRe = /<tr[\s\S]*?<\/tr>/gi;
+    let rMatch;
+    while ((rMatch = rowRe.exec(tableHtml)) !== null) {
+      const cells = [];
+      const cellRe = /<t[dh][^>]*>([\s\S]*?)<\/t[dh]>/gi;
+      let cMatch;
+      while ((cMatch = cellRe.exec(rMatch[0])) !== null) {
+        cells.push(stripTags(cMatch[1] ?? ""));
+      }
+      if (cells.length > 0)
+        rows.push(cells);
+    }
+    if (rows.length < 2)
+      continue;
+    const cols = Math.max(...rows.map((r) => r.length));
+    const padded = rows.map((r) => {
+      while (r.length < cols)
+        r.push("");
+      return r;
+    });
+    const widths = Array.from({ length: cols }, (_, ci) => Math.max(...padded.map((r) => (r[ci] ?? "").length), 3));
+    const fmt = (r) => r.map((c, ci) => c.padEnd(widths[ci] ?? 0)).join(" | ");
+    const header = fmt(padded[0]);
+    const sep = widths.map((w) => "-".repeat(w)).join("-|-");
+    const body = padded.slice(1).map(fmt).join(`
+`);
+    tables.push(`${header}
+${sep}
+${body}`);
+  }
+  return tables.length > 0 ? `=== TABLES (${tables.length}) ===
 
-### Before modifying ANY existing file:
-1. ALWAYS use read-file on the exact file you plan to change FIRST
-2. Study the full current content — understand every import, every export, every type, every existing feature
-3. Your changes patch MUST preserve ALL existing functionality — do not remove or rewrite things that were not part of the request
-4. If you are unsure what other files import from the file you are editing, use read-folder on the parent directory first to see what exists nearby, then read-file the relevant ones
+${tables.join(`
 
-### Before adding a feature that touches multiple files:
-1. Use read-folder on the relevant directory to see what files exist
-2. Use read-file on each file you plan to touch
-3. Only then emit a changes tag — with patches that are surgical additions, not wholesale rewrites
+---
 
-### The golden rule for write-file and changes:
-- The output file must contain EVERYTHING the original had, PLUS your new additions
-- NEVER produce a file that is shorter than the original unless you are explicitly asked to delete things
-- If you catch yourself rewriting a file from scratch, STOP — go back and read the original first
+`)}` : "";
+}
+function extractLists(html) {
+  const lists = [];
+  const listRe = /<[ou]l[\s\S]*?<\/[ou]l>/gi;
+  let lMatch;
+  while ((lMatch = listRe.exec(html)) !== null) {
+    const items = [];
+    const itemRe = /<li[^>]*>([\s\S]*?)<\/li>/gi;
+    let iMatch;
+    while ((iMatch = itemRe.exec(lMatch[0])) !== null) {
+      const text = stripTags(iMatch[1] ?? "");
+      if (text.length > 2)
+        items.push(`• ${text}`);
+    }
+    if (items.length > 1)
+      lists.push(items.join(`
+`));
+  }
+  return lists.length > 0 ? `=== LISTS ===
 
-## WHEN TO USE read-folder:
-- Before editing files in an unfamiliar directory — list it first to understand the structure
-- When a feature spans multiple files and you are not sure what exists
-- When the user asks you to explore or explain a part of the codebase
-
-## SCAFFOLDING A NEW PROJECT (follow this exactly)
-
-When the user asks to create a new CLI/app in a subfolder (e.g. "make a todo app called list"):
-1. Create all files first using write-file with paths like \`list/package.json\`, \`list/src/index.tsx\`
-2. Then run \`cd list && bun install\` (or npm/pnpm) in one shell command
-3. Then run the project with \`cd list && bun run index.ts\` or whatever the entry point is
-4. NEVER run \`bun init\` — it is interactive and will hang. Create package.json manually with write-file instead
-5. TSX files need either tsconfig.json with \`"jsx": "react-jsx"\` or \`/** @jsxImportSource react */\` at the top
-
-## FETCH → WRITE FLOW (follow this exactly when saving fetched data)
-
-1. fetch the URL
-2. Analyze the result — count the rows, identify columns, check completeness
-3. Tell the user what you found: "Found X rows with columns: A, B, C. Writing now."
-4. emit write-file with correctly structured, complete content
-5. After write-file confirms success, emit read-file to verify
-6. Only after read-file confirms content is correct, tell the user it is done
-
-## WHEN TO USE TOOLS
-
-- User shares any URL → fetch it immediately
-- User asks to run anything → shell it immediately
-- User asks to open a link, open a URL, or visit a website → open-url it immediately, do NOT use fetch
-- User asks to delete a file → delete-file it immediately (requires approval)
-- User asks to delete a folder or directory → delete-folder it immediately (requires approval)
-- User asks to search for a pattern in files, find usages, find where something is defined → grep it immediately, NEVER use shell grep/findstr/Select-String
-- User asks to read a file → read-file it immediately, NEVER use shell cat/type
-- User asks what files are in a folder, or to explore/list a directory → read-folder it immediately, NEVER use shell ls/dir/find/git ls-files
-- User asks to explore a folder or directory → read-folder it immediately
-- User asks to save/create/write a file → write-file it immediately, then read-file to verify
-- User asks to modify/edit/add to an existing file → read-file it FIRST, then emit changes
-- User shares a GitHub URL and wants to clone/explore/discuss it → use clone immediately, NEVER use shell git clone
-- After clone succeeds, you will see context about the clone in the conversation. Wait for the user to ask a specific question before using any tools. Do NOT auto-read files, do NOT emit any tool tags until the user asks.
-- You are unsure about an API, library, error, concept, or piece of code → search it immediately
-- User asks about something recent or that you might not know → search it immediately
-- You are about to say "I'm not sure" or "I don't know" → search instead of guessing
-
-## shell IS ONLY FOR:
-- Running code: \`node script.js\`, \`bun run dev\`, \`python main.py\`
-- Installing packages: \`npm install\`, \`pip install\`
-- Building/testing: \`npm run build\`, \`bun test\`
-- Git operations other than clone: \`git status\`, \`git log\`, \`git diff\`
-- Anything that EXECUTES — not reads or lists
+${lists.slice(0, 5).join(`
 
-## CODEBASE
+`)}` : "";
+}
+async function fetchUrl(url) {
+  const res = await fetch(url, {
+    headers: {
+      "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+      Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+      "Accept-Language": "en-US,en;q=0.5"
+    },
+    signal: AbortSignal.timeout(15000)
+  });
+  if (!res.ok)
+    throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+  const contentType = res.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    const json = await res.json();
+    return JSON.stringify(json, null, 2).slice(0, 8000);
+  }
+  const html = await res.text();
+  const titleMatch = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  const title = titleMatch ? stripTags(titleMatch[1]) : "No title";
+  const tables = extractTables(html);
+  const lists = extractLists(html);
+  const bodyText = stripTags(html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<nav[\s\S]*?<\/nav>/gi, "").replace(/<footer[\s\S]*?<\/footer>/gi, "").replace(/<header[\s\S]*?<\/header>/gi, "")).replace(/\s{3,}/g, `
 
-${fileList.length > 0 ? fileList : "(no files indexed)"}
+`).slice(0, 3000);
+  const parts = [`PAGE: ${title}`, `URL: ${url}`];
+  if (tables)
+    parts.push(tables);
+  if (lists)
+    parts.push(lists);
+  parts.push(`=== TEXT ===
+${bodyText}`);
+  return parts.join(`
 
-${historySummary}`;
+`);
 }
-var FEW_SHOT_MESSAGES = [
-  {
-    role: "user",
-    content: "delete src/old-component.tsx"
-  },
-  {
-    role: "assistant",
-    content: "<delete-file>src/old-component.tsx</delete-file>"
-  },
-  {
-    role: "user",
-    content: `Here is the output from delete-file of src/old-component.tsx:
-
-Deleted: /repo/src/old-component.tsx
+async function searchWeb(query) {
+  const encoded = encodeURIComponent(query);
+  const ddgUrl = `https://api.duckduckgo.com/?q=${encoded}&format=json&no_html=1&skip_disambig=1`;
+  try {
+    const res = await fetch(ddgUrl, {
+      headers: { "User-Agent": "Lens/1.0" },
+      signal: AbortSignal.timeout(8000)
+    });
+    if (res.ok) {
+      const data = await res.json();
+      const parts = [`Search: ${query}`];
+      if (data.Answer)
+        parts.push(`Answer: ${data.Answer}`);
+      if (data.AbstractText) {
+        parts.push(`Summary: ${data.AbstractText}`);
+        if (data.AbstractURL)
+          parts.push(`Source: ${data.AbstractURL}`);
+      }
+      if (data.Infobox?.content?.length) {
+        const fields = data.Infobox.content.slice(0, 8).map((f) => `  ${f.label}: ${f.value}`).join(`
+`);
+        parts.push(`Info:
+${fields}`);
+      }
+      if (data.RelatedTopics?.length) {
+        const topics = data.RelatedTopics.filter((t) => t.Text).slice(0, 5).map((t) => `  - ${t.Text}`).join(`
+`);
+        if (topics)
+          parts.push(`Related:
+${topics}`);
+      }
+      const result2 = parts.join(`
 
-Please continue your response based on this output.`
-  },
-  {
-    role: "assistant",
-    content: "Done — `src/old-component.tsx` has been deleted."
-  },
-  {
-    role: "user",
-    content: "delete the legacy folder"
-  },
-  {
-    role: "assistant",
-    content: "<delete-folder>src/legacy</delete-folder>"
-  },
-  {
-    role: "user",
-    content: `Here is the output from delete-folder of src/legacy:
+`);
+      if (result2.length > 60)
+        return result2;
+    }
+  } catch {}
+  try {
+    const htmlUrl = `https://html.duckduckgo.com/html/?q=${encoded}`;
+    const res = await fetch(htmlUrl, {
+      headers: {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        Accept: "text/html"
+      },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok)
+      throw new Error(`HTTP ${res.status}`);
+    const html = await res.text();
+    const snippets = [];
+    const snippetRe = /class="result__snippet"[^>]*>([\s\S]*?)<\/a>/g;
+    let m;
+    while ((m = snippetRe.exec(html)) !== null && snippets.length < 6) {
+      const text = m[1].replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/\s+/g, " ").trim();
+      if (text.length > 20)
+        snippets.push(`- ${text}`);
+    }
+    const links = [];
+    const linkRe = /class="result__a"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/g;
+    while ((m = linkRe.exec(html)) !== null && links.length < 5) {
+      const title = m[2].replace(/<[^>]+>/g, "").trim();
+      const href = m[1];
+      if (title && href)
+        links.push(`  ${title} — ${href}`);
+    }
+    if (snippets.length === 0 && links.length === 0)
+      return `No results found for: ${query}`;
+    const parts = [`Search results for: ${query}`];
+    if (snippets.length > 0)
+      parts.push(`Snippets:
+${snippets.join(`
+`)}`);
+    if (links.length > 0)
+      parts.push(`Links:
+${links.join(`
+`)}`);
+    return parts.join(`
 
-Deleted folder: /repo/src/legacy
+`);
+  } catch (err) {
+    return `Search failed: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+// src/tools/pdf.ts
+import path15 from "path";
+import os6 from "os";
+import { existsSync as existsSync11, mkdirSync as mkdirSync5, writeFileSync as writeFileSync7 } from "fs";
+function generatePdf(filePath, content, repoPath) {
+  const fullPath = path15.isAbsolute(filePath) ? filePath : path15.join(repoPath, filePath);
+  try {
+    const dir = path15.dirname(fullPath);
+    if (!existsSync11(dir))
+      mkdirSync5(dir, { recursive: true });
+    const escaped = content.replace(/\\/g, "\\\\").replace(/"""/g, "\\\"\\\"\\\"").replace(/\r/g, "");
+    const script = `
+import sys
+try:
+    from reportlab.lib.pagesizes import letter
+    from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, HRFlowable
+    from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+    from reportlab.lib.units import inch
+    from reportlab.lib import colors
+except ImportError:
+    import subprocess
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "reportlab", "--break-system-packages", "-q"])
+    from reportlab.lib.pagesizes import letter
+    from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, HRFlowable
+    from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+    from reportlab.lib.units import inch
+    from reportlab.lib import colors
 
-Please continue your response based on this output.`
-  },
-  {
-    role: "assistant",
-    content: "Done — the `src/legacy` folder and all its contents have been deleted."
-  },
-  {
-    role: "user",
-    content: "open https://github.com/microsoft/typescript"
-  },
-  {
-    role: "assistant",
-    content: "<open-url>https://github.com/microsoft/typescript</open-url>"
-  },
-  {
-    role: "user",
-    content: `Here is the output from open-url https://github.com/microsoft/typescript:
+doc = SimpleDocTemplate(
+    r"""${fullPath}""",
+    pagesize=letter,
+    rightMargin=inch,
+    leftMargin=inch,
+    topMargin=inch,
+    bottomMargin=inch,
+)
 
-Opened: https://github.com/microsoft/typescript
+styles = getSampleStyleSheet()
+styles.add(ParagraphStyle(name="H1", parent=styles["Heading1"], fontSize=22, spaceAfter=10))
+styles.add(ParagraphStyle(name="H2", parent=styles["Heading2"], fontSize=16, spaceAfter=8))
+styles.add(ParagraphStyle(name="H3", parent=styles["Heading3"], fontSize=13, spaceAfter=6))
+styles.add(ParagraphStyle(name="Body", parent=styles["Normal"], fontSize=11, leading=16, spaceAfter=8))
+styles.add(ParagraphStyle(name="Bullet", parent=styles["Normal"], fontSize=11, leading=16, leftIndent=20, spaceAfter=4, bulletIndent=10))
 
-Please continue your response based on this output.`
-  },
-  {
-    role: "assistant",
-    content: "Opened the TypeScript GitHub page in your browser."
-  },
-  {
-    role: "user",
-    content: "generate a PDF report about the project and save it to docs/report.pdf"
-  },
-  {
-    role: "assistant",
-    content: `<generate-pdf>
-{"path": "docs/report.pdf", "content": "# Project Report\\n\\n## Overview\\n\\nThis document summarizes the project.\\n\\n## Details\\n\\nMore content here."}
-</generate-pdf>`
-  },
-  {
-    role: "user",
-    content: `Here is the output from generate-pdf to docs/report.pdf:
+raw = """${escaped}"""
 
-PDF generated: /repo/docs/report.pdf
+story = []
+for line in raw.split("\\n"):
+    s = line.rstrip()
+    if s.startswith("### "):
+        story.append(Paragraph(s[4:], styles["H3"]))
+    elif s.startswith("## "):
+        story.append(Spacer(1, 6))
+        story.append(Paragraph(s[3:], styles["H2"]))
+        story.append(HRFlowable(width="100%", thickness=0.5, color=colors.grey, spaceAfter=4))
+    elif s.startswith("# "):
+        story.append(Paragraph(s[2:], styles["H1"]))
+        story.append(HRFlowable(width="100%", thickness=1, color=colors.black, spaceAfter=6))
+    elif s.startswith("- ") or s.startswith("* "):
+        story.append(Paragraph(u"\\u2022  " + s[2:], styles["Bullet"]))
+    elif s.startswith("---"):
+        story.append(HRFlowable(width="100%", thickness=0.5, color=colors.grey, spaceAfter=4))
+    elif s == "":
+        story.append(Spacer(1, 6))
+    else:
+        import re
+        s = re.sub(r"\\*\\*(.+?)\\*\\*", r"<b>\\1</b>", s)
+        s = re.sub(r"\\*(.+?)\\*", r"<i>\\1</i>", s)
+        s = re.sub(r"\`(.+?)\`", r"<font name='Courier'>\\1</font>", s)
+        story.append(Paragraph(s, styles["Body"]))
 
-Please continue your response based on this output.`
-  },
-  {
-    role: "assistant",
-    content: "Done — the PDF report has been saved to `docs/report.pdf`."
-  },
-  {
-    role: "user",
-    content: 'grep -R "ChatRunner" -n src'
-  },
-  {
-    role: "assistant",
-    content: `<grep>
-{"pattern": "ChatRunner", "glob": "src/**/*"}
-</grep>`
-  },
-  {
-    role: "user",
-    content: `Here is the output from grep for "ChatRunner":
+doc.build(story)
+print("OK")
+`.replace("${fullPath}", fullPath.replace(/\\/g, "/")).replace("${escaped}", escaped);
+    const tmpFile = path15.join(os6.tmpdir(), `lens_pdf_${Date.now()}.py`);
+    writeFileSync7(tmpFile, script, "utf-8");
+    const { execSync: execSync2 } = __require("child_process");
+    execSync2(`python "${tmpFile}"`, { stdio: "pipe" });
+    try {
+      __require("fs").unlinkSync(tmpFile);
+    } catch {}
+    return `PDF generated: ${fullPath}`;
+  } catch (err) {
+    return `Error generating PDF: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+// src/prompts/system.ts
+function buildSystemPrompt(files, memorySummary = "", toolsSection) {
+  const fileList = files.map((f) => `### ${f.path}
+\`\`\`
+${f.content.slice(0, 2000)}
+\`\`\``).join(`
 
-grep /ChatRunner/ src/**/* — 3 match(es) in 2 file(s)
+`);
+  const tools = toolsSection ?? BUILTIN_TOOLS_SECTION;
+  return `You are an expert software engineer assistant with access to the user's codebase and tools.
 
-src/index.tsx
-  12: import { ChatRunner } from "./components/chat/ChatRunner";
+${tools}
 
-src/components/chat/ChatRunner.tsx
-  1: export const ChatRunner = ...
+## MEMORY OPERATIONS
 
-Please continue your response based on this output.`
-  },
-  {
-    role: "assistant",
-    content: "`ChatRunner` is defined in `src/components/chat/ChatRunner.tsx` and imported in `src/index.tsx`."
-  },
-  {
-    role: "user",
-    content: "find all usages of useInput in the codebase"
-  },
-  {
-    role: "assistant",
-    content: `<grep>
-{"pattern": "useInput", "glob": "src/**/*.tsx"}
-</grep>`
-  },
-  {
-    role: "user",
-    content: `Here is the output from grep for "useInput":
+You can save and delete memories at any time by emitting these tags alongside your normal response.
+They are stripped before display — the user will not see the raw tags.
 
-grep /useInput/ src/**/*.tsx — 2 match(es) in 1 file(s)
+### memory-add — save something important to long-term memory for this repo
+<memory-add>User prefers TypeScript strict mode in all new files</memory-add>
 
-src/components/chat/ChatRunner.tsx
-  5: import { useInput } from "ink";
-  210: useInput((input, key) => {
+### memory-delete — delete a memory by its ID (shown in brackets like [abc123])
+<memory-delete>abc123</memory-delete>
 
-Please continue your response based on this output.`
-  },
-  {
-    role: "assistant",
-    content: "`useInput` is used in `src/components/chat/ChatRunner.tsx` — imported on line 5 and called on line 210."
-  },
-  {
-    role: "user",
-    content: "show me how to use the read-file tool"
-  },
-  {
-    role: "assistant",
-    content: "To read a file, emit the tag alone in your response — nothing else on that turn:\n\n```text\n[read-file]src/components/Header.tsx[/read-file]\n```\n\nThe result comes back as the next user message and you can then analyze it."
-  },
-  {
-    role: "user",
-    content: "show me an example of the shell tool"
-  },
-  {
-    role: "assistant",
-    content: "To run a shell command, emit only the tag:\n\n```text\n[shell]node -v[/shell]\n```\n\nThe stdout/stderr is returned and you can read it in the next turn."
-  },
-  {
-    role: "user",
-    content: "read src folder"
-  },
-  {
-    role: "assistant",
-    content: "<read-folder>src</read-folder>"
-  },
-  {
-    role: "user",
-    content: `Here is the output from read-folder of src:
+Use memory-add when:
+- The user explicitly asks you to remember something ("remember that...", "don't forget...")
+- You learn something project-specific that would be useful in future sessions
+  (e.g. preferred patterns, architecture decisions, known gotchas, user preferences)
 
-Folder: src (4 entries)
+Use memory-delete when:
+- The user asks you to forget something
+- A memory is outdated or wrong and you are replacing it with a new one
 
-Files:
-  index.ts
-  App.tsx
+You may emit multiple memory operations in a single response alongside normal content.
 
-Subfolders:
-  components/
-  utils/
+## RULES
 
-Please continue your response based on this output.`
-  },
-  {
-    role: "assistant",
-    content: "The `src` folder contains `index.ts`, `App.tsx`, plus subfolders `components/` and `utils/`."
-  },
+1. When you need to use a tool, output ONLY the XML tag — nothing before or after it in that response
+2. ONE tool per response — emit the tag, then stop completely
+3. After the user approves and you get the result, continue your analysis in the next response
+4. NEVER print a URL, command, filename, or JSON blob as plain text when you should be using a tool
+5. NEVER say "I'll fetch" / "run this command" / "here's the write-file" — just emit the tag
+6. NEVER use shell to run git clone — always use the clone tag instead
+7. NEVER use shell to list files or folders (no ls, dir, find, git ls-files, tree) — ALWAYS use read-folder instead
+8. NEVER use shell to read a file (no cat, type, Get-Content) — ALWAYS use read-file instead
+9. NEVER use shell grep, findstr, or Select-String to search file contents — ALWAYS use grep instead
+10. shell is ONLY for running code, installing packages, building, testing — not for filesystem inspection
+11. write-file content field must be the COMPLETE file content, never empty or placeholder
+12. After a write-file succeeds, do NOT repeat it — trust the result and move on
+13. After a write-file succeeds, tell the user it is done immediately — do NOT auto-read the file back to verify
+14. NEVER apologize and redo a tool call you already made — if write-file or shell ran and returned a result, it worked, do not run it again
+15. NEVER say "I made a mistake" and repeat the same tool — one attempt is enough, trust the output
+16. NEVER second-guess yourself mid-response — commit to your answer
+17. If a read-folder or read-file returns "not found", accept it and move on — do NOT retry the same path
+18. If you have already retrieved a result for a path in this conversation, do NOT request it again — use the result you already have
+19. Every shell command runs from the repo root — \`cd\` has NO persistent effect. NEVER use \`cd\` alone. Use full paths or combine with && e.g. \`cd list && bun run index.ts\`
+20. write-file paths are relative to the repo root — if creating files in a subfolder write the full relative path e.g. \`list/src/index.tsx\` NOT \`src/index.tsx\`
+21. When scaffolding a new project in a subfolder, ALL write-file paths must start with that subfolder name e.g. \`list/package.json\`, \`list/src/index.tsx\`
+22. When scaffolding a multi-file project, after each write-file succeeds, immediately proceed to writing the NEXT file — NEVER rewrite a file you already wrote in this session. Each file is written ONCE and ONLY ONCE.
+23. For JSX/TSX files always use \`.tsx\` extension and include \`/** @jsxImportSource react */\` or ensure tsconfig has jsx set — bun needs this to parse JSX
+24. When explaining how to use a tool in text, use [tag] bracket notation or a fenced code block — NEVER emit a real XML tool tag as part of an explanation or example
+25. NEVER read files, list folders, or run tools that were not asked for in the current user message
+26. NEVER use markdown formatting in plain text responses — no **bold**, no *italics*, no # headings, no bullet points with -, *, or +, no numbered lists, no backtick inline code. Write in plain prose. Only use fenced \`\`\` code blocks when showing actual code.
+
+## SCAFFOLDING — CHAINING WRITE-FILE CALLS
+
+When creating multiple files (e.g. scaffolding a project or creating 10 files), emit ALL of them
+in a single response by chaining the tags back-to-back with no text between them:
+
+<write-file>
+{"path": "test/file1.txt", "content": "File 1 content"}
+</write-file>
+<write-file>
+{"path": "test/file2.txt", "content": "File 2 content"}
+</write-file>
+<write-file>
+{"path": "test/file3.txt", "content": "File 3 content"}
+</write-file>
+
+The system processes each tag sequentially and automatically continues to the next one.
+Do NOT wait for a user message between files — emit all tags at once.
+
+## CRITICAL: READ BEFORE YOU WRITE
+
+These rules are mandatory whenever you plan to edit or create a file:
+
+### Before modifying ANY existing file:
+1. ALWAYS use read-file on the exact file you plan to change FIRST
+2. Study the full current content — understand every import, every export, every type, every existing feature
+3. Your changes patch MUST preserve ALL existing functionality — do not remove or rewrite things that were not part of the request
+4. If you are unsure what other files import from the file you are editing, use read-folder on the parent directory first to see what exists nearby, then read-file the relevant ones
+
+### Before adding a feature that touches multiple files:
+1. Use read-folder on the relevant directory to see what files exist
+2. Use read-file on each file you plan to touch
+3. Only then emit a changes tag — with patches that are surgical additions, not wholesale rewrites
+
+### The golden rule for write-file and changes:
+- The output file must contain EVERYTHING the original had, PLUS your new additions
+- NEVER produce a file that is shorter than the original unless you are explicitly asked to delete things
+- If you catch yourself rewriting a file from scratch, STOP — go back and read the original first
+
+## CODEBASE
+
+${fileList.length > 0 ? fileList : "(no files indexed)"}
+
+${memorySummary}`;
+}
+var BUILTIN_TOOLS_SECTION = `## TOOLS
+
+You have exactly thirteen tools. To use a tool you MUST wrap it in the exact XML tags shown below — no other format will work.
+
+### 1. fetch — load a URL
+<fetch>https://example.com</fetch>
+
+### 2. shell — run a terminal command
+<shell>node -v</shell>
+
+### 3. read-file — read a file from the repo
+<read-file>src/foo.ts</read-file>
+
+### 4. read-folder — list contents of a folder (files + subfolders, one level deep)
+<read-folder>src/components</read-folder>
+
+### 5. grep — search for a pattern across files in the repo (cross-platform, no shell needed)
+<grep>
+{"pattern": "ChatRunner", "glob": "src/**/*.tsx"}
+</grep>
+
+### 6. write-file — create or overwrite a file
+<write-file>
+{"path": "data/output.csv", "content": "col1,col2\\nval1,val2"}
+</write-file>
+
+### 7. delete-file — permanently delete a single file
+<delete-file>src/old-component.tsx</delete-file>
+
+### 8. delete-folder — permanently delete a folder and all its contents
+<delete-folder>src/legacy</delete-folder>
+
+### 9. open-url — open a URL in the user's default browser
+<open-url>https://github.com/owner/repo</open-url>
+
+### 10. generate-pdf — generate a PDF file from markdown-style content
+<generate-pdf>
+{"path": "output/report.pdf", "content": "# Title\\n\\nSome body text.\\n\\n## Section\\n\\nMore content."}
+</generate-pdf>
+
+### 11. search — search the internet for anything you are unsure about
+<search>how to use React useEffect cleanup function</search>
+
+### 12. clone — clone a GitHub repo so you can explore and discuss it
+<clone>https://github.com/owner/repo</clone>
+
+### 13. changes — propose code edits (shown as a diff for user approval)
+<changes>
+{"summary": "what changed and why", "patches": [{"path": "src/foo.ts", "content": "COMPLETE file content", "isNew": false}]}
+</changes>`;
+// src/prompts/fewshot.ts
+var FEW_SHOT_MESSAGES = [
   {
     role: "user",
-    content: "list src folder"
+    content: "delete src/old-component.tsx"
   },
   {
     role: "assistant",
-    content: "<read-folder>src</read-folder>"
+    content: "<delete-file>src/old-component.tsx</delete-file>"
   },
   {
     role: "user",
-    content: `Here is the output from read-folder of src:
-
-Folder: src (4 entries)
-
-Files:
-  index.ts
-  App.tsx
+    content: `Here is the output from delete-file of src/old-component.tsx:
 
-Subfolders:
-  components/
-  utils/
+Deleted: /repo/src/old-component.tsx
 
 Please continue your response based on this output.`
   },
   {
     role: "assistant",
-    content: "The `src` folder contains `index.ts`, `App.tsx`, plus subfolders `components/` and `utils/`."
+    content: "Done — `src/old-component.tsx` has been deleted."
   },
   {
     role: "user",
-    content: "what files are in src/components?"
+    content: "delete the legacy folder"
   },
   {
     role: "assistant",
-    content: "<read-folder>src/components</read-folder>"
+    content: "<delete-folder>src/legacy</delete-folder>"
   },
   {
     role: "user",
-    content: `Here is the output from read-folder of src/components:
-
-Folder: src/components (5 entries)
-
-Files:
-  Header.tsx
-  Footer.tsx
-  Button.tsx
+    content: `Here is the output from delete-folder of src/legacy:
 
-Subfolders:
-  ui/
-  forms/
+Deleted folder: /repo/src/legacy
 
 Please continue your response based on this output.`
   },
   {
     role: "assistant",
-    content: "The `src/components` folder has 3 files — `Header.tsx`, `Footer.tsx`, `Button.tsx` — plus two subfolders: `ui/` and `forms/`."
+    content: "Done — the `src/legacy` folder and all its contents have been deleted."
   },
   {
     role: "user",
-    content: "list the files in src/utils"
+    content: "open https://github.com/microsoft/typescript"
   },
   {
     role: "assistant",
-    content: "<read-folder>src/utils</read-folder>"
+    content: "<open-url>https://github.com/microsoft/typescript</open-url>"
   },
   {
     role: "user",
-    content: `Here is the output from read-folder of src/utils:
-
-Folder: src/utils (3 entries)
+    content: `Here is the output from open-url https://github.com/microsoft/typescript:
 
-Files:
-  api.ts
-  helpers.ts
-  format.ts
+Opened: https://github.com/microsoft/typescript
 
 Please continue your response based on this output.`
   },
   {
     role: "assistant",
-    content: "The `src/utils` folder contains 3 files: `api.ts`, `helpers.ts`, and `format.ts`."
+    content: "Opened the TypeScript GitHub page in your browser."
   },
   {
     role: "user",
-    content: "show me what's in the src directory"
+    content: "generate a PDF report about the project and save it to docs/report.pdf"
   },
   {
     role: "assistant",
-    content: "<read-folder>src</read-folder>"
+    content: `<generate-pdf>
+{"path": "docs/report.pdf", "content": "# Project Report\\n\\n## Overview\\n\\nThis document summarizes the project.\\n\\n## Details\\n\\nMore content here."}
+</generate-pdf>`
   },
   {
     role: "user",
-    content: `Here is the output from read-folder of src:
-
-Folder: src (4 entries)
-
-Files:
-  index.ts
-  App.tsx
+    content: `Here is the output from generate-pdf to docs/report.pdf:
 
-Subfolders:
-  components/
-  utils/
+PDF generated: /repo/docs/report.pdf
 
 Please continue your response based on this output.`
   },
   {
     role: "assistant",
-    content: "The `src` directory has 2 files (`index.ts`, `App.tsx`) and 2 subfolders (`components/`, `utils/`)."
+    content: "Done — the PDF report has been saved to `docs/report.pdf`."
   },
   {
     role: "user",
-    content: "show me the project structure"
+    content: 'grep -R "ChatRunner" -n src'
   },
   {
     role: "assistant",
-    content: "<read-folder>.</read-folder>"
+    content: `<grep>
+{"pattern": "ChatRunner", "glob": "src/**/*"}
+</grep>`
   },
   {
     role: "user",
-    content: `Here is the output from read-folder of .:
+    content: `Here is the output from grep for "ChatRunner":
 
-Folder: . (5 entries)
+grep /ChatRunner/ src/**/* — 3 match(es) in 2 file(s)
 
-Files:
-  package.json
-  tsconfig.json
-  README.md
+src/index.tsx
+  12: import { ChatRunner } from "./components/chat/ChatRunner";
 
-Subfolders:
-  src/
-  node_modules/
+src/components/chat/ChatRunner.tsx
+  1: export const ChatRunner = ...
 
 Please continue your response based on this output.`
   },
   {
     role: "assistant",
-    content: "The project root has 3 files (`package.json`, `tsconfig.json`, `README.md`) and the `src/` folder for source code."
+    content: "`ChatRunner` is defined in `src/components/chat/ChatRunner.tsx` and imported in `src/index.tsx`."
   },
   {
     role: "user",
-    content: "what does the project look like?"
+    content: "find all usages of useInput in the codebase"
   },
   {
     role: "assistant",
-    content: "<read-folder>.</read-folder>"
+    content: `<grep>
+{"pattern": "useInput", "glob": "src/**/*.tsx"}
+</grep>`
   },
   {
     role: "user",
-    content: `Here is the output from read-folder of .:
-
-Folder: . (4 entries)
+    content: `Here is the output from grep for "useInput":
 
-Files:
-  package.json
-  README.md
+grep /useInput/ src/**/*.tsx — 2 match(es) in 1 file(s)
 
-Subfolders:
-  src/
-  dist/
+src/components/chat/ChatRunner.tsx
+  5: import { useInput } from "ink";
+  210: useInput((input, key) => {
 
 Please continue your response based on this output.`
   },
   {
     role: "assistant",
-    content: "The repo root contains `package.json` and `README.md`, with source code in `src/` and compiled output in `dist/`."
+    content: "`useInput` is used in `src/components/chat/ChatRunner.tsx` — imported on line 5 and called on line 210."
   },
   {
     role: "user",
-    content: "fetch https://api.github.com/repos/microsoft/typescript"
+    content: "show me how to use the read-file tool"
   },
   {
     role: "assistant",
-    content: "<fetch>https://api.github.com/repos/microsoft/typescript</fetch>"
+    content: "To read a file, emit the tag alone in your response — nothing else on that turn:\n\n```text\n[read-file]src/components/Header.tsx[/read-file]\n```\n\nThe result comes back as the next user message and you can then analyze it."
   },
   {
     role: "user",
-    content: `Here is the output from fetch of https://api.github.com/repos/microsoft/typescript:
-
-{"name":"TypeScript","stargazers_count":100000}
-
-Please continue your response based on this output.`
+    content: "show me an example of the shell tool"
   },
   {
     role: "assistant",
-    content: "Found 1 object with fields: name, stargazers_count. Writing to ts-info.json now."
+    content: "To run a shell command, emit only the tag:\n\n```text\n[shell]node -v[/shell]\n```\n\nThe stdout/stderr is returned and you can read it in the next turn."
   },
   {
     role: "user",
-    content: "ok go ahead"
+    content: "read src folder"
   },
   {
     role: "assistant",
-    content: `<write-file>
-{"path": "ts-info.json", "content": "{"name":"TypeScript","stars":100000}"}
-</write-file>`
+    content: "<read-folder>src</read-folder>"
   },
   {
     role: "user",
-    content: `Here is the output from write-file to ts-info.json:
+    content: `Here is the output from read-folder of src:
 
-Written: /repo/ts-info.json (1 lines, 44 bytes)
+Folder: src (4 entries)
+
+Files:
+  index.ts
+  App.tsx
+
+Subfolders:
+  components/
+  utils/
 
 Please continue your response based on this output.`
   },
   {
     role: "assistant",
-    content: "Done — `ts-info.json` has been saved."
+    content: "The `src` folder contains `index.ts`, `App.tsx`, plus subfolders `components/` and `utils/`."
   },
   {
     role: "user",
-    content: "write it to a file called hello.py"
+    content: "what files are in src/components?"
   },
   {
     role: "assistant",
-    content: `<write-file>
-{"path": "hello.py", "content": "# hello.py\\nprint('hello')"}
-</write-file>`
+    content: "<read-folder>src/components</read-folder>"
+  },
+  {
+    role: "user",
+    content: `Here is the output from read-folder of src/components:
+
+Folder: src/components (5 entries)
+
+Files:
+  Header.tsx
+  Footer.tsx
+  Button.tsx
+
+Subfolders:
+  ui/
+  forms/
+
+Please continue your response based on this output.`
+  },
+  {
+    role: "assistant",
+    content: "The `src/components` folder has 3 files — `Header.tsx`, `Footer.tsx`, `Button.tsx` — plus two subfolders: `ui/` and `forms/`."
+  },
+  {
+    role: "user",
+    content: "show me the project structure"
+  },
+  {
+    role: "assistant",
+    content: "<read-folder>.</read-folder>"
+  },
+  {
+    role: "user",
+    content: `Here is the output from read-folder of .:
+
+Folder: . (5 entries)
+
+Files:
+  package.json
+  tsconfig.json
+  README.md
+
+Subfolders:
+  src/
+  node_modules/
+
+Please continue your response based on this output.`
+  },
+  {
+    role: "assistant",
+    content: "The project root has 3 files (`package.json`, `tsconfig.json`, `README.md`) and the `src/` folder for source code."
+  },
+  {
+    role: "user",
+    content: "fetch https://api.github.com/repos/microsoft/typescript"
+  },
+  {
+    role: "assistant",
+    content: "<fetch>https://api.github.com/repos/microsoft/typescript</fetch>"
+  },
+  {
+    role: "user",
+    content: `Here is the output from fetch of https://api.github.com/repos/microsoft/typescript:
+
+{"name":"TypeScript","stargazers_count":100000}
+
+Please continue your response based on this output.`
+  },
+  {
+    role: "assistant",
+    content: "Found 1 object with fields: name, stargazers_count. Writing to ts-info.json now."
+  },
+  {
+    role: "user",
+    content: "ok go ahead"
+  },
+  {
+    role: "assistant",
+    content: `<write-file>
+{"path": "ts-info.json", "content": "{"name":"TypeScript","stars":100000}"}
+</write-file>`
+  },
+  {
+    role: "user",
+    content: `Here is the output from write-file to ts-info.json:
+
+Written: /repo/ts-info.json (1 lines, 44 bytes)
+
+Please continue your response based on this output.`
+  },
+  {
+    role: "assistant",
+    content: "Done — `ts-info.json` has been saved."
+  },
+  {
+    role: "user",
+    content: "write it to a file called hello.py"
+  },
+  {
+    role: "assistant",
+    content: `<write-file>
+{"path": "hello.py", "content": "# hello.py\\nprint('hello')"}
+</write-file>`
   },
   {
     role: "user",
@@ -49314,770 +49750,351 @@ Please continue your response based on this output.`
   },
   {
     role: "user",
-    content: "what does this project do?"
+    content: "scaffold a new project called myapp with package.json and src/index.ts"
   },
   {
     role: "assistant",
-    content: "This project is a CLI coding assistant that lets you chat with an AI model about your codebase. It can read and write files, run shell commands, search the web, and propose diffs for your approval."
-  }
-];
-function parseResponse(text) {
-  const scanText = text.replace(/```[\s\S]*?```/g, (m) => " ".repeat(m.length));
-  const candidates = [];
-  const patterns = [
-    { kind: "fetch", re: /<fetch>([\s\S]*?)<\/fetch>/g },
-    { kind: "shell", re: /<shell>([\s\S]*?)<\/shell>/g },
-    { kind: "read-file", re: /<read-file>([\s\S]*?)<\/read-file>/g },
-    { kind: "read-folder", re: /<read-folder>([\s\S]*?)<\/read-folder>/g },
-    { kind: "grep", re: /<grep>([\s\S]*?)<\/grep>/g },
-    { kind: "delete-file", re: /<delete-file>([\s\S]*?)<\/delete-file>/g },
-    {
-      kind: "delete-folder",
-      re: /<delete-folder>([\s\S]*?)<\/delete-folder>/g
-    },
-    { kind: "open-url", re: /<open-url>([\s\S]*?)<\/open-url>/g },
-    { kind: "generate-pdf", re: /<generate-pdf>([\s\S]*?)<\/generate-pdf>/g },
-    { kind: "write-file", re: /<write-file>([\s\S]*?)<\/write-file>/g },
-    { kind: "search", re: /<search>([\s\S]*?)<\/search>/g },
-    { kind: "clone", re: /<clone>([\s\S]*?)<\/clone>/g },
-    { kind: "changes", re: /<changes>([\s\S]*?)<\/changes>/g },
-    { kind: "fetch", re: /```fetch\r?\n([\s\S]*?)\r?\n```/g },
-    { kind: "shell", re: /```shell\r?\n([\s\S]*?)\r?\n```/g },
-    { kind: "read-file", re: /```read-file\r?\n([\s\S]*?)\r?\n```/g },
-    { kind: "read-folder", re: /```read-folder\r?\n([\s\S]*?)\r?\n```/g },
-    { kind: "write-file", re: /```write-file\r?\n([\s\S]*?)\r?\n```/g },
-    { kind: "search", re: /```search\r?\n([\s\S]*?)\r?\n```/g },
-    { kind: "changes", re: /```changes\r?\n([\s\S]*?)\r?\n```/g }
-  ];
-  for (const { kind: kind2, re } of patterns) {
-    re.lastIndex = 0;
-    const m = re.exec(scanText);
-    if (m) {
-      const originalRe = new RegExp(re.source, re.flags.replace("g", ""));
-      const originalMatch = originalRe.exec(text.slice(m.index));
-      if (originalMatch) {
-        const fakeMatch = Object.assign([
-          text.slice(m.index, m.index + originalMatch[0].length),
-          originalMatch[1]
-        ], { index: m.index, input: text, groups: undefined });
-        candidates.push({ index: m.index, kind: kind2, match: fakeMatch });
-      }
-    }
-  }
-  if (candidates.length === 0)
-    return { kind: "text", content: text.trim() };
-  candidates.sort((a, b) => a.index - b.index);
-  const { kind, match } = candidates[0];
-  const before2 = text.slice(0, match.index).replace(/<(fetch|shell|read-file|read-folder|write-file|search|clone|changes)[^>]*>[\s\S]*?<\/\1>/g, "").trim();
-  const body = (match[1] ?? "").trim();
-  if (kind === "changes") {
-    try {
-      const parsed = JSON.parse(body);
-      const display = [before2, parsed.summary].filter(Boolean).join(`
-
-`);
-      return { kind: "changes", content: display, patches: parsed.patches };
-    } catch {}
-  }
-  if (kind === "shell")
-    return { kind: "shell", content: before2, command: body };
-  if (kind === "fetch") {
-    const url = body.replace(/^<|>$/g, "").trim();
-    return { kind: "fetch", content: before2, url };
-  }
-  if (kind === "read-file")
-    return { kind: "read-file", content: before2, filePath: body };
-  if (kind === "read-folder")
-    return { kind: "read-folder", content: before2, folderPath: body };
-  if (kind === "delete-file")
-    return { kind: "delete-file", content: before2, filePath: body };
-  if (kind === "delete-folder")
-    return { kind: "delete-folder", content: before2, folderPath: body };
-  if (kind === "open-url") {
-    const url = body.replace(/^<|>$/g, "").trim();
-    return { kind: "open-url", content: before2, url };
-  }
-  if (kind === "generate-pdf") {
-    try {
-      const parsed = JSON.parse(body);
-      return {
-        kind: "generate-pdf",
-        content: before2,
-        filePath: parsed.path ?? parsed.filePath ?? "output.pdf",
-        pdfContent: parsed.content ?? ""
-      };
-    } catch {
-      return { kind: "text", content: text };
-    }
-  }
-  if (kind === "grep") {
-    try {
-      const parsed = JSON.parse(body);
-      return {
-        kind: "grep",
-        content: before2,
-        pattern: parsed.pattern,
-        glob: parsed.glob ?? "**/*"
-      };
-    } catch {
-      return { kind: "grep", content: before2, pattern: body, glob: "**/*" };
-    }
-  }
-  if (kind === "write-file") {
-    try {
-      const parsed = JSON.parse(body);
-      return {
-        kind: "write-file",
-        content: before2,
-        filePath: parsed.path,
-        fileContent: parsed.content
-      };
-    } catch {}
-  }
-  if (kind === "search")
-    return { kind: "search", content: before2, query: body };
-  if (kind === "clone") {
-    const url = body.replace(/^<|>$/g, "").trim();
-    return { kind: "clone", content: before2, repoUrl: url };
-  }
-  return { kind: "text", content: text.trim() };
-}
-function extractGithubUrl(text) {
-  const match = text.match(/https?:\/\/github\.com\/[\w.-]+\/[\w.-]+/);
-  return match ? match[0] : null;
-}
-function toCloneUrl(url) {
-  const clean = url.replace(/\/+$/, "");
-  return clean.endsWith(".git") ? clean : `${clean}.git`;
-}
-function buildApiMessages(messages) {
-  return messages.map((m) => {
-    if (m.type === "tool") {
-      if (!m.approved) {
-        return {
-          role: "user",
-          content: "The tool call was denied by the user. Please respond without using that tool."
-        };
-      }
-      const label = m.toolName === "shell" ? `shell command \`${m.content}\`` : m.toolName === "fetch" ? `fetch of ${m.content}` : m.toolName === "read-file" ? `read-file of ${m.content}` : m.toolName === "read-folder" ? `read-folder of ${m.content}` : m.toolName === "grep" ? `grep for "${m.content}"` : m.toolName === "delete-file" ? `delete-file of ${m.content}` : m.toolName === "delete-folder" ? `delete-folder of ${m.content}` : m.toolName === "open-url" ? `open-url ${m.content}` : m.toolName === "generate-pdf" ? `generate-pdf to ${m.content}` : m.toolName === "search" ? `web search for "${m.content}"` : `write-file to ${m.content}`;
-      return {
-        role: "user",
-        content: `Here is the output from the ${label}:
+    content: `<write-file>
+{"path": "myapp/package.json", "content": "{"name":"myapp","version":"1.0.0"}"}
+</write-file>`
+  },
+  {
+    role: "user",
+    content: `Here is the output from write-file to myapp/package.json:
 
-${m.result}
+Written: /repo/myapp/package.json (1 lines, 38 bytes)
 
 Please continue your response based on this output.`
-      };
-    }
-    return { role: m.role, content: m.content };
-  });
-}
-async function callChat(provider, systemPrompt, messages, abortSignal) {
-  const apiMessages = [...FEW_SHOT_MESSAGES, ...buildApiMessages(messages)];
-  let url;
-  let headers;
-  let body;
-  if (provider.type === "anthropic") {
-    url = "https://api.anthropic.com/v1/messages";
-    headers = {
-      "Content-Type": "application/json",
-      "x-api-key": provider.apiKey ?? "",
-      "anthropic-version": "2023-06-01"
-    };
-    body = {
-      model: provider.model,
-      max_tokens: 4096,
-      system: systemPrompt,
-      messages: apiMessages
-    };
-  } else {
-    const base2 = provider.baseUrl ?? "https://api.openai.com/v1";
-    url = `${base2}/chat/completions`;
-    headers = {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${provider.apiKey}`
-    };
-    body = {
-      model: provider.model,
-      max_tokens: 4096,
-      messages: [{ role: "system", content: systemPrompt }, ...apiMessages]
-    };
-  }
-  const controller = new AbortController;
-  const timer = setTimeout(() => controller.abort(), 60000);
-  abortSignal?.addEventListener("abort", () => controller.abort());
-  const res = await fetch(url, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body),
-    signal: controller.signal
-  });
-  clearTimeout(timer);
-  if (!res.ok)
-    throw new Error(`API error ${res.status}: ${await res.text()}`);
-  const data = await res.json();
-  if (provider.type === "anthropic") {
-    const content = data.content;
-    return content.filter((b) => b.type === "text").map((b) => b.text).join("");
-  } else {
-    const choices = data.choices;
-    return choices[0]?.message.content ?? "";
-  }
-}
-var SKIP_DIRS4 = new Set([
-  "node_modules",
-  ".git",
-  "dist",
-  "build",
-  ".next",
-  "out",
-  "coverage",
-  "__pycache__",
-  ".venv",
-  "venv"
-]);
-function walkDir3(dir, base2 = dir) {
-  const results = [];
-  let entries;
-  try {
-    entries = readdirSync3(dir, { encoding: "utf-8" });
-  } catch {
-    return results;
-  }
-  for (const entry of entries) {
-    if (SKIP_DIRS4.has(entry))
-      continue;
-    const full = path14.join(dir, entry);
-    const rel = path14.relative(base2, full).replace(/\\/g, "/");
-    let isDir = false;
-    try {
-      isDir = statSync4(full).isDirectory();
-    } catch {
-      continue;
-    }
-    if (isDir)
-      results.push(...walkDir3(full, base2));
-    else
-      results.push(rel);
-  }
-  return results;
-}
-function applyPatches3(repoPath, patches) {
-  for (const patch of patches) {
-    const fullPath = path14.join(repoPath, patch.path);
-    const dir = path14.dirname(fullPath);
-    if (!existsSync10(dir))
-      mkdirSync4(dir, { recursive: true });
-    writeFileSync6(fullPath, patch.content, "utf-8");
-  }
-}
-async function runShell(command, cwd2) {
-  return new Promise((resolve) => {
-    const { spawn: spawn2 } = __require("child_process");
-    const isWin = process.platform === "win32";
-    const shell = isWin ? "cmd.exe" : "/bin/sh";
-    const shellFlag = isWin ? "/c" : "-c";
-    const proc = spawn2(shell, [shellFlag, command], {
-      cwd: cwd2,
-      env: process.env,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    const chunks = [];
-    const errChunks = [];
-    proc.stdout.on("data", (d) => chunks.push(d));
-    proc.stderr.on("data", (d) => errChunks.push(d));
-    const killTimer = setTimeout(() => {
-      proc.kill();
-      resolve("(command timed out after 5 minutes)");
-    }, 5 * 60 * 1000);
-    proc.on("close", (code) => {
-      clearTimeout(killTimer);
-      const stdout = Buffer.concat(chunks).toString("utf-8").trim();
-      const stderr = Buffer.concat(errChunks).toString("utf-8").trim();
-      const combined = [stdout, stderr].filter(Boolean).join(`
-`);
-      resolve(combined || (code === 0 ? "(no output)" : `exit code ${code}`));
-    });
-    proc.on("error", (err) => {
-      clearTimeout(killTimer);
-      resolve(`Error: ${err.message}`);
-    });
-  });
-}
-function stripTags(html) {
-  return html.replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#\d+;/g, " ").replace(/\s+/g, " ").trim();
-}
-function extractTables(html) {
-  const tables = [];
-  const tableRe = /<table[\s\S]*?<\/table>/gi;
-  let tMatch;
-  while ((tMatch = tableRe.exec(html)) !== null) {
-    const tableHtml = tMatch[0];
-    const rows = [];
-    const rowRe = /<tr[\s\S]*?<\/tr>/gi;
-    let rMatch;
-    while ((rMatch = rowRe.exec(tableHtml)) !== null) {
-      const cells = [];
-      const cellRe = /<t[dh][^>]*>([\s\S]*?)<\/t[dh]>/gi;
-      let cMatch;
-      while ((cMatch = cellRe.exec(rMatch[0])) !== null) {
-        cells.push(stripTags(cMatch[1] ?? ""));
-      }
-      if (cells.length > 0)
-        rows.push(cells);
-    }
-    if (rows.length < 2)
-      continue;
-    const cols = Math.max(...rows.map((r) => r.length));
-    const padded = rows.map((r) => {
-      while (r.length < cols)
-        r.push("");
-      return r;
-    });
-    const widths = Array.from({ length: cols }, (_, ci) => Math.max(...padded.map((r) => (r[ci] ?? "").length), 3));
-    const fmt = (r) => r.map((c, ci) => c.padEnd(widths[ci] ?? 0)).join(" | ");
-    const header = fmt(padded[0]);
-    const sep = widths.map((w) => "-".repeat(w)).join("-|-");
-    const body = padded.slice(1).map(fmt).join(`
-`);
-    tables.push(`${header}
-${sep}
-${body}`);
-  }
-  return tables.length > 0 ? `=== TABLES (${tables.length}) ===
-
-${tables.join(`
-
----
-
-`)}` : "";
-}
-function extractLists(html) {
-  const lists = [];
-  const listRe = /<[ou]l[\s\S]*?<\/[ou]l>/gi;
-  let lMatch;
-  while ((lMatch = listRe.exec(html)) !== null) {
-    const items = [];
-    const itemRe = /<li[^>]*>([\s\S]*?)<\/li>/gi;
-    let iMatch;
-    while ((iMatch = itemRe.exec(lMatch[0])) !== null) {
-      const text = stripTags(iMatch[1] ?? "");
-      if (text.length > 2)
-        items.push(`• ${text}`);
-    }
-    if (items.length > 1)
-      lists.push(items.join(`
-`));
-  }
-  return lists.length > 0 ? `=== LISTS ===
-
-${lists.slice(0, 5).join(`
-
-`)}` : "";
-}
-async function fetchUrl(url) {
-  const res = await fetch(url, {
-    headers: {
-      "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
-      Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-      "Accept-Language": "en-US,en;q=0.5"
-    },
-    signal: AbortSignal.timeout(15000)
-  });
-  if (!res.ok)
-    throw new Error(`HTTP ${res.status}: ${res.statusText}`);
-  const contentType = res.headers.get("content-type") ?? "";
-  if (contentType.includes("application/json")) {
-    const json = await res.json();
-    return JSON.stringify(json, null, 2).slice(0, 8000);
-  }
-  const html = await res.text();
-  const titleMatch = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
-  const title = titleMatch ? stripTags(titleMatch[1]) : "No title";
-  const tables = extractTables(html);
-  const lists = extractLists(html);
-  const bodyText = stripTags(html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<nav[\s\S]*?<\/nav>/gi, "").replace(/<footer[\s\S]*?<\/footer>/gi, "").replace(/<header[\s\S]*?<\/header>/gi, "")).replace(/\s{3,}/g, `
-
-`).slice(0, 3000);
-  const parts = [`PAGE: ${title}`, `URL: ${url}`];
-  if (tables)
-    parts.push(tables);
-  if (lists)
-    parts.push(lists);
-  parts.push(`=== TEXT ===
-${bodyText}`);
-  return parts.join(`
-
-`);
-}
-async function searchWeb(query) {
-  const encoded = encodeURIComponent(query);
-  const ddgUrl = `https://api.duckduckgo.com/?q=${encoded}&format=json&no_html=1&skip_disambig=1`;
-  try {
-    const res = await fetch(ddgUrl, {
-      headers: { "User-Agent": "Lens/1.0" },
-      signal: AbortSignal.timeout(8000)
-    });
-    if (res.ok) {
-      const data = await res.json();
-      const parts = [`Search: ${query}`];
-      if (data.Answer)
-        parts.push(`Answer: ${data.Answer}`);
-      if (data.AbstractText) {
-        parts.push(`Summary: ${data.AbstractText}`);
-        if (data.AbstractURL)
-          parts.push(`Source: ${data.AbstractURL}`);
-      }
-      if (data.Infobox?.content?.length) {
-        const fields = data.Infobox.content.slice(0, 8).map((f) => `  ${f.label}: ${f.value}`).join(`
-`);
-        parts.push(`Info:
-${fields}`);
-      }
-      if (data.RelatedTopics?.length) {
-        const topics = data.RelatedTopics.filter((t) => t.Text).slice(0, 5).map((t) => `  - ${t.Text}`).join(`
-`);
-        if (topics)
-          parts.push(`Related:
-${topics}`);
-      }
-      const result2 = parts.join(`
-
-`);
-      if (result2.length > 60)
-        return result2;
-    }
-  } catch {}
-  try {
-    const htmlUrl = `https://html.duckduckgo.com/html/?q=${encoded}`;
-    const res = await fetch(htmlUrl, {
-      headers: {
-        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
-        Accept: "text/html"
-      },
-      signal: AbortSignal.timeout(1e4)
-    });
-    if (!res.ok)
-      throw new Error(`HTTP ${res.status}`);
-    const html = await res.text();
-    const snippets = [];
-    const snippetRe = /class="result__snippet"[^>]*>([\s\S]*?)<\/a>/g;
-    let m;
-    while ((m = snippetRe.exec(html)) !== null && snippets.length < 6) {
-      const text = m[1].replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/\s+/g, " ").trim();
-      if (text.length > 20)
-        snippets.push(`- ${text}`);
-    }
-    const links = [];
-    const linkRe = /class="result__a"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/g;
-    while ((m = linkRe.exec(html)) !== null && links.length < 5) {
-      const title = m[2].replace(/<[^>]+>/g, "").trim();
-      const href = m[1];
-      if (title && href)
-        links.push(`  ${title} — ${href}`);
-    }
-    if (snippets.length === 0 && links.length === 0) {
-      return `No results found for: ${query}`;
-    }
-    const parts = [`Search results for: ${query}`];
-    if (snippets.length > 0)
-      parts.push(`Snippets:
-${snippets.join(`
-`)}`);
-    if (links.length > 0)
-      parts.push(`Links:
-${links.join(`
-`)}`);
-    return parts.join(`
+  },
+  {
+    role: "assistant",
+    content: `<write-file>
+{"path": "myapp/src/index.ts", "content": "console.log('hello')"}
+</write-file>`
+  },
+  {
+    role: "user",
+    content: `Here is the output from write-file to myapp/src/index.ts:
 
-`);
-  } catch (err) {
-    return `Search failed: ${err instanceof Error ? err.message : String(err)}`;
-  }
-}
-function readFile(filePath, repoPath) {
-  const candidates = path14.isAbsolute(filePath) ? [filePath] : [filePath, path14.join(repoPath, filePath)];
-  for (const candidate of candidates) {
-    if (existsSync10(candidate)) {
-      try {
-        const content = readFileSync10(candidate, "utf-8");
-        const lines = content.split(`
-`).length;
-        return `File: ${candidate} (${lines} lines)
+Written: /repo/myapp/src/index.ts (1 lines, 20 bytes)
 
-${content.slice(0, 8000)}${content.length > 8000 ? `
+Please continue your response based on this output.`
+  },
+  {
+    role: "assistant",
+    content: "Done — scaffolded `myapp/package.json` and `myapp/src/index.ts`. Run `cd myapp && npm install` to get started."
+  },
+  {
+    role: "user",
+    content: "remember that we always use bun in this project"
+  },
+  {
+    role: "assistant",
+    content: `<memory-add>Project uses bun as the package manager and runtime, not npm or node</memory-add>
 
-… (truncated)` : ""}`;
-      } catch (err) {
-        return `Error reading file: ${err instanceof Error ? err.message : String(err)}`;
-      }
-    }
+Got it — I'll always use bun for this project.`
+  },
+  {
+    role: "user",
+    content: "forget the bun preference"
+  },
+  {
+    role: "assistant",
+    content: `<memory-delete>MEMORY_ID</memory-delete>
+
+Done — removed that memory.`
   }
-  return `File not found: ${filePath}. If reading from a cloned repo, use the full absolute path e.g. C:\\Users\\...\\repo\\file.ts`;
-}
-function readFolder(folderPath, repoPath) {
-  const sanitized = folderPath.replace(/^(ls|dir|find|tree|cat|read|ls -la?|ls -al?)\s+/i, "").trim();
-  const candidates = path14.isAbsolute(sanitized) ? [sanitized] : [sanitized, path14.join(repoPath, sanitized)];
-  for (const candidate of candidates) {
-    if (!existsSync10(candidate))
-      continue;
-    let stat;
-    try {
-      stat = statSync4(candidate);
-    } catch {
-      continue;
-    }
-    if (!stat.isDirectory()) {
-      return `Not a directory: ${candidate}. Use read-file to read a file.`;
-    }
-    let entries;
-    try {
-      entries = readdirSync3(candidate, { encoding: "utf-8" });
-    } catch (err) {
-      return `Error reading folder: ${err instanceof Error ? err.message : String(err)}`;
-    }
-    const files = [];
-    const subfolders = [];
-    for (const entry of entries) {
-      if (entry.startsWith(".") && entry !== ".env")
-        continue;
-      const full = path14.join(candidate, entry);
-      try {
-        if (statSync4(full).isDirectory()) {
-          subfolders.push(`${entry}/`);
-        } else {
-          files.push(entry);
-        }
-      } catch {}
-    }
-    const total = files.length + subfolders.length;
-    const lines = [`Folder: ${candidate} (${total} entries)`, ""];
-    if (files.length > 0) {
-      lines.push("Files:");
-      files.forEach((f) => lines.push(`  ${f}`));
-    }
-    if (subfolders.length > 0) {
-      if (files.length > 0)
-        lines.push("");
-      lines.push("Subfolders:");
-      subfolders.forEach((d) => lines.push(`  ${d}`));
+];
+// src/utils/tools/registry.ts
+class ToolRegistry {
+  tools = new Map;
+  register(tool) {
+    if (this.tools.has(tool.name)) {
+      console.warn(`[ToolRegistry] Overwriting existing tool: "${tool.name}"`);
     }
-    if (total === 0) {
-      lines.push("(empty folder)");
+    this.tools.set(tool.name, tool);
+  }
+  unregister(name) {
+    this.tools.delete(name);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  all() {
+    return Array.from(this.tools.values());
+  }
+  names() {
+    return Array.from(this.tools.keys());
+  }
+  buildSystemPromptSection() {
+    const lines = [`## TOOLS
+`];
+    lines.push("You have exactly " + this.tools.size + ` tools. To use a tool you MUST wrap it in the exact XML tags shown below — no other format will work.
+`);
+    let i = 1;
+    for (const tool of this.tools.values()) {
+      lines.push(tool.systemPromptEntry(i++));
     }
     return lines.join(`
 `);
   }
-  return `Folder not found: ${sanitized}`;
 }
-function grepFiles(pattern, glob, repoPath) {
-  let regex2;
-  try {
-    regex2 = new RegExp(pattern, "i");
-  } catch {
-    regex2 = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
-  }
-  const globToFilter = (g) => {
-    const cleaned = g.replace(/^\*\*\//, "");
-    const parts = cleaned.split("/");
-    const ext = parts[parts.length - 1];
-    const prefix = parts.slice(0, -1).join("/");
-    return (rel) => {
-      if (ext?.startsWith("*.")) {
-        const extSuffix = ext.slice(1);
-        if (!rel.endsWith(extSuffix))
-          return false;
-      } else if (ext && !ext.includes("*")) {
-        if (!rel.endsWith(ext))
-          return false;
+var registry = new ToolRegistry;
+
+// src/utils/chat.ts
+function parseResponse(text) {
+  const scanText = text.replace(/```[\s\S]*?```/g, (m) => " ".repeat(m.length));
+  const candidates = [];
+  for (const toolName2 of registry.names()) {
+    const escaped = toolName2.replace(/[-]/g, "\\-");
+    const xmlRe = new RegExp(`<${escaped}>([\\s\\S]*?)<\\/${escaped}>`, "g");
+    xmlRe.lastIndex = 0;
+    const xmlM = xmlRe.exec(scanText);
+    if (xmlM) {
+      const orig = new RegExp(xmlRe.source);
+      const origM = orig.exec(text.slice(xmlM.index));
+      if (origM) {
+        candidates.push({
+          index: xmlM.index,
+          toolName: toolName2,
+          match: Object.assign([
+            text.slice(xmlM.index, xmlM.index + origM[0].length),
+            origM[1]
+          ], { index: xmlM.index, input: text, groups: undefined })
+        });
       }
-      if (prefix && !prefix.includes("*")) {
-        if (!rel.startsWith(prefix))
-          return false;
+    }
+    const fencedRe = new RegExp(`\`\`\`${escaped}\\r?\\n([\\s\\S]*?)\\r?\\n\`\`\``, "g");
+    fencedRe.lastIndex = 0;
+    const fencedM = fencedRe.exec(scanText);
+    if (fencedM) {
+      const orig = new RegExp(fencedRe.source);
+      const origM = orig.exec(text.slice(fencedM.index));
+      if (origM) {
+        candidates.push({
+          index: fencedM.index,
+          toolName: toolName2,
+          match: Object.assign([
+            text.slice(fencedM.index, fencedM.index + origM[0].length),
+            origM[1]
+          ], { index: fencedM.index, input: text, groups: undefined })
+        });
       }
-      return true;
-    };
-  };
-  const filter2 = globToFilter(glob);
-  const allFiles = walkDir3(repoPath);
-  const matchedFiles = allFiles.filter(filter2);
-  if (matchedFiles.length === 0) {
-    return `No files matched glob: ${glob}`;
+    }
   }
-  const results = [];
-  let totalMatches = 0;
-  for (const relPath of matchedFiles) {
-    const fullPath = path14.join(repoPath, relPath);
-    let content;
+  if (candidates.length === 0)
+    return { kind: "text", content: text.trim() };
+  candidates.sort((a, b) => a.index - b.index);
+  const { toolName, match } = candidates[0];
+  const before2 = text.slice(0, match.index).trim();
+  const body = (match[1] ?? "").trim();
+  const afterMatch = text.slice(match.index + match[0].length).trim();
+  const remainder = afterMatch.length > 0 ? afterMatch : undefined;
+  if (toolName === "changes") {
     try {
-      content = readFileSync10(fullPath, "utf-8");
-    } catch {
-      continue;
-    }
-    const lines = content.split(`
+      const parsed = JSON.parse(body);
+      const display = [before2, parsed.summary].filter(Boolean).join(`
+
 `);
-    const fileMatches = [];
-    lines.forEach((line, i) => {
-      if (regex2.test(line)) {
-        fileMatches.push(`  ${i + 1}: ${line.trimEnd()}`);
-        totalMatches++;
-      }
-    });
-    if (fileMatches.length > 0) {
-      results.push(`${relPath}
-${fileMatches.join(`
-`)}`);
-    }
-    if (totalMatches >= 200) {
-      results.push("(truncated — too many matches)");
-      break;
+      return {
+        kind: "changes",
+        content: display,
+        patches: parsed.patches,
+        remainder
+      };
+    } catch {
+      return { kind: "text", content: text.trim() };
     }
   }
-  if (results.length === 0) {
-    return `No matches for /${pattern}/ in ${matchedFiles.length} file(s) matching ${glob}`;
+  if (toolName === "clone") {
+    return {
+      kind: "clone",
+      content: before2,
+      repoUrl: body.replace(/^<|>$/g, "").trim(),
+      remainder
+    };
   }
-  return `grep /${pattern}/ ${glob} — ${totalMatches} match(es) in ${results.length} file(s)
+  const tool = registry.get(toolName);
+  if (!tool)
+    return { kind: "text", content: text.trim() };
+  const input = tool.parseInput(body);
+  if (input === null)
+    return { kind: "text", content: text.trim() };
+  return {
+    kind: "tool",
+    toolName,
+    input,
+    rawInput: body,
+    content: before2,
+    remainder
+  };
+}
+function extractGithubUrl(text) {
+  const match = text.match(/https?:\/\/github\.com\/[\w.-]+\/[\w.-]+/);
+  return match ? match[0] : null;
+}
+function toCloneUrl(url) {
+  const clean = url.replace(/\/+$/, "");
+  return clean.endsWith(".git") ? clean : `${clean}.git`;
+}
+function buildApiMessages(messages) {
+  return messages.map((m) => {
+    if (m.type === "tool") {
+      if (!m.approved) {
+        return {
+          role: "user",
+          content: "The tool call was denied by the user. Please respond without using that tool."
+        };
+      }
+      return {
+        role: "user",
+        content: `Here is the output from the ${m.toolName} of ${m.content}:
 
-${results.join(`
+${m.result}
 
-`)}`;
+Please continue your response based on this output.`
+      };
+    }
+    return { role: m.role, content: m.content };
+  });
 }
-function writeFile(filePath, content, repoPath) {
-  const fullPath = path14.isAbsolute(filePath) ? filePath : path14.join(repoPath, filePath);
-  try {
-    const dir = path14.dirname(fullPath);
-    if (!existsSync10(dir))
-      mkdirSync4(dir, { recursive: true });
-    writeFileSync6(fullPath, content, "utf-8");
-    const lines = content.split(`
-`).length;
-    return `Written: ${fullPath} (${lines} lines, ${content.length} bytes)`;
-  } catch (err) {
-    return `Error writing file: ${err instanceof Error ? err.message : String(err)}`;
+async function callChat(provider, systemPrompt, messages, abortSignal) {
+  const apiMessages = [...FEW_SHOT_MESSAGES, ...buildApiMessages(messages)];
+  let url;
+  let headers;
+  let body;
+  if (provider.type === "anthropic") {
+    url = "https://api.anthropic.com/v1/messages";
+    headers = {
+      "Content-Type": "application/json",
+      "x-api-key": provider.apiKey ?? "",
+      "anthropic-version": "2023-06-01"
+    };
+    body = {
+      model: provider.model,
+      max_tokens: 4096,
+      system: systemPrompt,
+      messages: apiMessages
+    };
+  } else {
+    const base2 = provider.baseUrl ?? "https://api.openai.com/v1";
+    url = `${base2}/chat/completions`;
+    headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${provider.apiKey}`
+    };
+    body = {
+      model: provider.model,
+      max_tokens: 4096,
+      messages: [{ role: "system", content: systemPrompt }, ...apiMessages]
+    };
+  }
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), 60000);
+  abortSignal?.addEventListener("abort", () => controller.abort());
+  const res = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+    signal: controller.signal
+  });
+  clearTimeout(timer);
+  if (!res.ok)
+    throw new Error(`API error ${res.status}: ${await res.text()}`);
+  const data = await res.json();
+  if (provider.type === "anthropic") {
+    const content = data.content;
+    return content.filter((b) => b.type === "text").map((b) => b.text).join("");
+  } else {
+    const choices = data.choices;
+    return choices[0]?.message.content ?? "";
   }
 }
-function deleteFile(filePath, repoPath) {
-  const fullPath = path14.isAbsolute(filePath) ? filePath : path14.join(repoPath, filePath);
-  try {
-    if (!existsSync10(fullPath))
-      return `File not found: ${fullPath}`;
-    const { unlinkSync } = __require("fs");
-    unlinkSync(fullPath);
-    return `Deleted: ${fullPath}`;
-  } catch (err) {
-    return `Error deleting file: ${err instanceof Error ? err.message : String(err)}`;
-  }
+
+// src/utils/chatHistory.ts
+import {
+  existsSync as existsSync12,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync11,
+  readdirSync as readdirSync4,
+  writeFileSync as writeFileSync8,
+  unlinkSync
+} from "fs";
+import path16 from "path";
+import os7 from "os";
+var LENS_DIR = path16.join(os7.homedir(), ".lens");
+var CHATS_DIR = path16.join(LENS_DIR, "chats");
+function ensureChatsDir() {
+  if (!existsSync12(CHATS_DIR))
+    mkdirSync6(CHATS_DIR, { recursive: true });
 }
-function deleteFolder(folderPath, repoPath) {
-  const fullPath = path14.isAbsolute(folderPath) ? folderPath : path14.join(repoPath, folderPath);
-  try {
-    if (!existsSync10(fullPath))
-      return `Folder not found: ${fullPath}`;
-    const { rmSync } = __require("fs");
-    rmSync(fullPath, { recursive: true, force: true });
-    return `Deleted folder: ${fullPath}`;
-  } catch (err) {
-    return `Error deleting folder: ${err instanceof Error ? err.message : String(err)}`;
-  }
+function chatFilePath(name) {
+  const safe = name.replace(/[^a-z0-9_-]/gi, "-").toLowerCase();
+  return path16.join(CHATS_DIR, `${safe}.json`);
 }
-function openUrl(url) {
+function saveChat(name, repoPath, messages) {
+  ensureChatsDir();
+  const data = {
+    name,
+    repoPath,
+    messages,
+    savedAt: new Date().toISOString(),
+    userMessageCount: messages.filter((m) => m.role === "user").length
+  };
+  writeFileSync8(chatFilePath(name), JSON.stringify(data, null, 2), "utf-8");
+}
+function loadChat(name) {
+  const filePath = chatFilePath(name);
+  if (!existsSync12(filePath))
+    return null;
   try {
-    const { execSync: execSync2 } = __require("child_process");
-    const platform2 = process.platform;
-    if (platform2 === "win32") {
-      execSync2(`start "" "${url}"`, { stdio: "ignore" });
-    } else if (platform2 === "darwin") {
-      execSync2(`open "${url}"`, { stdio: "ignore" });
-    } else {
-      execSync2(`xdg-open "${url}"`, { stdio: "ignore" });
-    }
-    return `Opened: ${url}`;
-  } catch (err) {
-    return `Error opening URL: ${err instanceof Error ? err.message : String(err)}`;
+    return JSON.parse(readFileSync11(filePath, "utf-8"));
+  } catch {
+    return null;
   }
 }
-function generatePdf(filePath, content, repoPath) {
-  const fullPath = path14.isAbsolute(filePath) ? filePath : path14.join(repoPath, filePath);
-  try {
-    const dir = path14.dirname(fullPath);
-    if (!existsSync10(dir))
-      mkdirSync4(dir, { recursive: true });
-    const escaped = content.replace(/\\/g, "\\\\").replace(/"""/g, "\\\"\\\"\\\"").replace(/\r/g, "");
-    const script = `
-import sys
-try:
-    from reportlab.lib.pagesizes import letter
-    from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, HRFlowable
-    from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
-    from reportlab.lib.units import inch
-    from reportlab.lib import colors
-except ImportError:
-    import subprocess
-    subprocess.check_call([sys.executable, "-m", "pip", "install", "reportlab", "--break-system-packages", "-q"])
-    from reportlab.lib.pagesizes import letter
-    from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, HRFlowable
-    from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
-    from reportlab.lib.units import inch
-    from reportlab.lib import colors
-
-doc = SimpleDocTemplate(
-    r"""${fullPath}""",
-    pagesize=letter,
-    rightMargin=inch,
-    leftMargin=inch,
-    topMargin=inch,
-    bottomMargin=inch,
-)
-
-styles = getSampleStyleSheet()
-styles.add(ParagraphStyle(name="H1", parent=styles["Heading1"], fontSize=22, spaceAfter=10))
-styles.add(ParagraphStyle(name="H2", parent=styles["Heading2"], fontSize=16, spaceAfter=8))
-styles.add(ParagraphStyle(name="H3", parent=styles["Heading3"], fontSize=13, spaceAfter=6))
-styles.add(ParagraphStyle(name="Body", parent=styles["Normal"], fontSize=11, leading=16, spaceAfter=8))
-styles.add(ParagraphStyle(name="Bullet", parent=styles["Normal"], fontSize=11, leading=16, leftIndent=20, spaceAfter=4, bulletIndent=10))
-
-raw = """${escaped}"""
-
-story = []
-for line in raw.split("\\n"):
-    s = line.rstrip()
-    if s.startswith("### "):
-        story.append(Paragraph(s[4:], styles["H3"]))
-    elif s.startswith("## "):
-        story.append(Spacer(1, 6))
-        story.append(Paragraph(s[3:], styles["H2"]))
-        story.append(HRFlowable(width="100%", thickness=0.5, color=colors.grey, spaceAfter=4))
-    elif s.startswith("# "):
-        story.append(Paragraph(s[2:], styles["H1"]))
-        story.append(HRFlowable(width="100%", thickness=1, color=colors.black, spaceAfter=6))
-    elif s.startswith("- ") or s.startswith("* "):
-        story.append(Paragraph(u"\\u2022  " + s[2:], styles["Bullet"]))
-    elif s.startswith("---"):
-        story.append(HRFlowable(width="100%", thickness=0.5, color=colors.grey, spaceAfter=4))
-    elif s == "":
-        story.append(Spacer(1, 6))
-    else:
-        import re
-        s = re.sub(r"\\*\\*(.+?)\\*\\*", r"<b>\\1</b>", s)
-        s = re.sub(r"\\*(.+?)\\*", r"<i>\\1</i>", s)
-        s = re.sub(r"\`(.+?)\`", r"<font name='Courier'>\\1</font>", s)
-        story.append(Paragraph(s, styles["Body"]))
-
-doc.build(story)
-print("OK")
-`.replace("${fullPath}", fullPath.replace(/\\/g, "/")).replace("${escaped}", escaped);
-    const os6 = __require("os");
-    const tmpFile = path14.join(os6.tmpdir(), `lens_pdf_${Date.now()}.py`);
-    writeFileSync6(tmpFile, script, "utf-8");
-    const { execSync: execSync2 } = __require("child_process");
-    execSync2(`python "${tmpFile}"`, { stdio: "pipe" });
+function listChats(repoPath) {
+  ensureChatsDir();
+  const files = readdirSync4(CHATS_DIR).filter((f) => f.endsWith(".json"));
+  const chats = [];
+  for (const file of files) {
     try {
-      __require("fs").unlinkSync(tmpFile);
+      const data = JSON.parse(readFileSync11(path16.join(CHATS_DIR, file), "utf-8"));
+      if (!repoPath || data.repoPath === repoPath)
+        chats.push(data);
     } catch {}
-    return `PDF generated: ${fullPath}`;
-  } catch (err) {
-    return `Error generating PDF: ${err instanceof Error ? err.message : String(err)}`;
   }
+  return chats.sort((a, b) => new Date(b.savedAt).getTime() - new Date(a.savedAt).getTime());
+}
+function deleteChat(name) {
+  const filePath = chatFilePath(name);
+  if (!existsSync12(filePath))
+    return false;
+  try {
+    unlinkSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getChatNameSuggestions(messages) {
+  const userMsgs = messages.filter((m) => m.role === "user").map((m) => m.content.toLowerCase().trim());
+  const date = new Date().toISOString().slice(0, 10);
+  if (userMsgs.length === 0) {
+    return [`chat-${date}`, `session-${date}`, `new-chat`];
+  }
+  const suggestions = [];
+  const toSlug = (s) => s.replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter(Boolean).slice(0, 4).join("-");
+  const firstSlug = toSlug(userMsgs[0]);
+  if (firstSlug)
+    suggestions.push(firstSlug);
+  if (userMsgs.length > 1) {
+    const lastSlug = toSlug(userMsgs[userMsgs.length - 1]);
+    if (lastSlug && lastSlug !== firstSlug)
+      suggestions.push(lastSlug);
+  }
+  suggestions.push(`session-${date}`);
+  return suggestions.slice(0, 3);
 }
 
 // src/components/chat/ChatMessage.tsx
@@ -50182,6 +50199,19 @@ function MessageBody({ content }) {
     })
   }, undefined, false, undefined, this);
 }
+function summarizeToolContent(toolName, content) {
+  if (toolName === "write-file" || toolName === "read-file") {
+    const pathMatch = content.match(/"path"\s*:\s*"([^"]+)"/);
+    if (pathMatch)
+      return pathMatch[1];
+  }
+  if (content.includes('"summary"')) {
+    const summaryMatch = content.match(/"summary"\s*:\s*"([^"]+)"/);
+    if (summaryMatch)
+      return summaryMatch[1];
+  }
+  return content.length > 120 ? content.slice(0, 120) + "…" : content;
+}
 function StaticMessage({ msg }) {
   if (msg.role === "user") {
     return /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Box_default, {
@@ -50212,7 +50242,7 @@ function StaticMessage({ msg }) {
       search: "?"
     };
     const icon = icons[msg.toolName] ?? "·";
-    const label = msg.toolName === "shell" ? msg.content : msg.toolName === "search" ? `"${msg.content}"` : msg.content;
+    const label = msg.toolName === "shell" ? msg.content : msg.toolName === "search" ? `"${msg.content}"` : summarizeToolContent(msg.toolName, msg.content);
     return /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Box_default, {
       flexDirection: "column",
       marginBottom: 1,
@@ -50417,50 +50447,71 @@ function PermissionPrompt({
   let icon;
   let label;
   let value;
-  if (tool.type === "shell") {
-    icon = "$";
-    label = "run";
-    value = tool.command;
-  } else if (tool.type === "fetch") {
-    icon = "~>";
-    label = "fetch";
-    value = tool.url;
-  } else if (tool.type === "read-file") {
-    icon = "r";
-    label = "read";
-    value = tool.filePath;
-  } else if (tool.type === "read-folder") {
-    icon = "d";
-    label = "folder";
-    value = tool.folderPath;
-  } else if (tool.type === "grep") {
-    icon = "/";
-    label = "grep";
-    value = `${tool.pattern}  ${tool.glob}`;
-  } else if (tool.type === "delete-file") {
-    icon = "x";
-    label = "delete";
-    value = tool.filePath;
-  } else if (tool.type === "delete-folder") {
-    icon = "X";
-    label = "delete folder";
-    value = tool.folderPath;
-  } else if (tool.type === "open-url") {
-    icon = "↗";
-    label = "open";
-    value = tool.url;
-  } else if (tool.type === "generate-pdf") {
-    icon = "P";
-    label = "pdf";
-    value = tool.filePath;
-  } else if (tool.type === "write-file") {
-    icon = "w";
-    label = "write";
-    value = `${tool.filePath} (${tool.fileContent.length} bytes)`;
+  if ("_label" in tool) {
+    const iconMap = {
+      run: "$",
+      fetch: "~>",
+      read: "r",
+      write: "w",
+      delete: "x",
+      "delete folder": "X",
+      open: "↗",
+      pdf: "P",
+      search: "?",
+      folder: "d",
+      grep: "/",
+      clone: "↓",
+      query: "⌗"
+    };
+    icon = iconMap[tool._label] ?? "·";
+    label = tool._label;
+    value = tool._display;
   } else {
-    icon = "?";
-    label = "search";
-    value = tool.query;
+    if (tool.type === "shell") {
+      icon = "$";
+      label = "run";
+      value = tool.command;
+    } else if (tool.type === "fetch") {
+      icon = "~>";
+      label = "fetch";
+      value = tool.url;
+    } else if (tool.type === "read-file") {
+      icon = "r";
+      label = "read";
+      value = tool.filePath;
+    } else if (tool.type === "read-folder") {
+      icon = "d";
+      label = "folder";
+      value = tool.folderPath;
+    } else if (tool.type === "grep") {
+      icon = "/";
+      label = "grep";
+      value = `${tool.pattern}  ${tool.glob}`;
+    } else if (tool.type === "delete-file") {
+      icon = "x";
+      label = "delete";
+      value = tool.filePath;
+    } else if (tool.type === "delete-folder") {
+      icon = "X";
+      label = "delete folder";
+      value = tool.folderPath;
+    } else if (tool.type === "open-url") {
+      icon = "↗";
+      label = "open";
+      value = tool.url;
+    } else if (tool.type === "generate-pdf") {
+      icon = "P";
+      label = "pdf";
+      value = tool.filePath;
+    } else if (tool.type === "write-file") {
+      icon = "w";
+      label = "write";
+      value = `${tool.filePath} (${tool.fileContent.length} bytes)`;
+    } else {
+      icon = "?";
+      label = "search";
+      value = tool.query ?? "";
+    }
   }
   return /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
     flexDirection: "column",
@@ -50497,7 +50548,8 @@ function PermissionPrompt({
 function InputBox({
   value,
   onChange,
-  onSubmit
+  onSubmit,
+  inputKey
 }) {
   return /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
     marginTop: 1,
@@ -50518,7 +50570,7 @@ function InputBox({
           value,
           onChange,
           onSubmit
-        }, undefined, false, undefined, this)
+        }, inputKey, false, undefined, this)
       ]
     }, undefined, true, undefined, this)
   }, undefined, false, undefined, this);
@@ -52283,53 +52335,96 @@ function TimelineRunner({
   }, undefined, true, undefined, this);
 }
 
-// src/utils/history.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "fs";
-import path15 from "path";
-import os6 from "os";
-var LENS_DIR = path15.join(os6.homedir(), ".lens");
-var HISTORY_PATH = path15.join(LENS_DIR, "history.json");
-function loadHistory() {
-  if (!existsSync11(HISTORY_PATH))
-    return { entries: [] };
+// src/utils/memory.ts
+import { existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "fs";
+import path17 from "path";
+import os8 from "os";
+var LENS_DIR2 = path17.join(os8.homedir(), ".lens");
+var MEMORY_PATH = path17.join(LENS_DIR2, "memory.json");
+function loadMemoryFile() {
+  if (!existsSync13(MEMORY_PATH))
+    return { entries: [], memories: [] };
   try {
-    return JSON.parse(readFileSync11(HISTORY_PATH, "utf-8"));
+    const data = JSON.parse(readFileSync12(MEMORY_PATH, "utf-8"));
+    return {
+      entries: data.entries ?? [],
+      memories: data.memories ?? []
+    };
   } catch {
-    return { entries: [] };
+    return { entries: [], memories: [] };
   }
 }
-function saveHistory(h) {
-  if (!existsSync11(LENS_DIR))
-    mkdirSync5(LENS_DIR, { recursive: true });
-  writeFileSync7(HISTORY_PATH, JSON.stringify(h, null, 2), "utf-8");
+function saveMemoryFile(m) {
+  if (!existsSync13(LENS_DIR2))
+    mkdirSync7(LENS_DIR2, { recursive: true });
+  writeFileSync9(MEMORY_PATH, JSON.stringify(m, null, 2), "utf-8");
 }
-function appendHistory(entry) {
-  const h = loadHistory();
-  h.entries.push({ ...entry, timestamp: new Date().toISOString() });
-  if (h.entries.length > 500)
-    h.entries = h.entries.slice(-500);
-  saveHistory(h);
+function appendMemory(entry) {
+  const m = loadMemoryFile();
+  m.entries.push({ ...entry, timestamp: new Date().toISOString() });
+  if (m.entries.length > 500)
+    m.entries = m.entries.slice(-500);
+  saveMemoryFile(m);
 }
-function buildHistorySummary(repoPath) {
-  const h = loadHistory();
-  const relevant = h.entries.filter((e) => e.repoPath === repoPath).slice(-50);
-  if (relevant.length === 0)
-    return "";
-  const lines = relevant.map((e) => {
-    const ts = new Date(e.timestamp).toLocaleString();
-    return `[${ts}] ${e.kind}: ${e.detail} — ${e.summary}`;
-  });
-  return `## WHAT YOU HAVE ALREADY DONE IN THIS REPO
+function buildMemorySummary(repoPath) {
+  const m = loadMemoryFile();
+  const relevant = m.entries.filter((e) => e.repoPath === repoPath).slice(-50);
+  const memories = m.memories.filter((mem) => mem.repoPath === repoPath);
+  const parts = [];
+  if (memories.length > 0) {
+    parts.push(`## MEMORIES ABOUT THIS REPO
+
+${memories.map((mem) => `- [${mem.id}] ${mem.content}`).join(`
+`)}`);
+  }
+  if (relevant.length > 0) {
+    const lines = relevant.map((e) => {
+      const ts = new Date(e.timestamp).toLocaleString();
+      return `[${ts}] ${e.kind}: ${e.detail} — ${e.summary}`;
+    });
+    parts.push(`## WHAT YOU HAVE ALREADY DONE IN THIS REPO
 
 The following actions have already been completed. Do NOT repeat them unless the user explicitly asks you to redo something:
 
 ${lines.join(`
-`)}`;
+`)}`);
+  }
+  return parts.join(`
+
+`);
+}
+function clearRepoMemory(repoPath) {
+  const m = loadMemoryFile();
+  m.entries = m.entries.filter((e) => e.repoPath !== repoPath);
+  m.memories = m.memories.filter((mem) => mem.repoPath !== repoPath);
+  saveMemoryFile(m);
 }
-function clearRepoHistory(repoPath) {
-  const h = loadHistory();
-  h.entries = h.entries.filter((e) => e.repoPath !== repoPath);
-  saveHistory(h);
+function generateId() {
+  return Math.random().toString(36).slice(2, 8);
+}
+function addMemory(content, repoPath) {
+  const m = loadMemoryFile();
+  const memory = {
+    id: generateId(),
+    content,
+    timestamp: new Date().toISOString(),
+    repoPath
+  };
+  m.memories.push(memory);
+  saveMemoryFile(m);
+  return memory;
+}
+function deleteMemory(id, repoPath) {
+  const m = loadMemoryFile();
+  const before2 = m.memories.length;
+  m.memories = m.memories.filter((mem) => !(mem.id === id && mem.repoPath === repoPath));
+  if (m.memories.length === before2)
+    return false;
+  saveMemoryFile(m);
+  return true;
+}
+function listMemories(repoPath) {
+  return loadMemoryFile().memories.filter((mem) => mem.repoPath === repoPath);
 }
 
 // src/components/chat/ChatRunner.tsx
@@ -52337,74 +52432,121 @@ var jsx_dev_runtime22 = __toESM(require_jsx_dev_runtime(), 1);
 var COMMANDS = [
   { cmd: "/timeline", desc: "browse commit history" },
   { cmd: "/clear history", desc: "wipe session memory for this repo" },
-  { cmd: "/review", desc: "review current codebsae" },
-  { cmd: "/auto", desc: "toggle auto-approve for read/search tools" }
+  { cmd: "/review", desc: "review current codebase" },
+  { cmd: "/auto", desc: "toggle auto-approve for read/search tools" },
+  { cmd: "/chat", desc: "chat history commands" },
+  { cmd: "/chat list", desc: "list saved chats for this repo" },
+  { cmd: "/chat load", desc: "load a saved chat by name" },
+  { cmd: "/chat rename", desc: "rename the current chat" },
+  { cmd: "/chat delete", desc: "delete a saved chat by name" },
+  { cmd: "/memory", desc: "memory commands" },
+  { cmd: "/memory list", desc: "list all memories for this repo" },
+  { cmd: "/memory add", desc: "add a memory" },
+  { cmd: "/memory delete", desc: "delete a memory by id" },
+  { cmd: "/memory clear", desc: "clear all memories for this repo" }
 ];
 function CommandPalette({
   query,
-  onSelect
+  onSelect,
+  recentChats
 }) {
   const q = query.toLowerCase();
+  const isChatLoad = q.startsWith("/chat load") || q.startsWith("/chat delete");
+  const chatFilter = isChatLoad ? q.startsWith("/chat load") ? q.slice("/chat load".length).trim() : q.slice("/chat delete".length).trim() : "";
+  const filteredChats = chatFilter ? recentChats.filter((n) => n.toLowerCase().includes(chatFilter)) : recentChats;
   const matches2 = COMMANDS.filter((c) => c.cmd.startsWith(q));
-  if (!matches2.length)
+  if (!matches2.length && !isChatLoad)
+    return null;
+  if (!matches2.length && isChatLoad && filteredChats.length === 0)
     return null;
   return /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Box_default, {
     flexDirection: "column",
     marginBottom: 1,
     marginLeft: 2,
-    children: matches2.map((c, i) => {
-      const isExact = c.cmd === query;
-      return /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Box_default, {
-        gap: 2,
+    children: [
+      matches2.map((c, i) => {
+        const isExact = c.cmd === query;
+        return /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Box_default, {
+          gap: 2,
+          children: [
+            /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Text, {
+              color: isExact ? ACCENT : "white",
+              bold: isExact,
+              children: c.cmd
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Text, {
+              color: "gray",
+              dimColor: true,
+              children: c.desc
+            }, undefined, false, undefined, this)
+          ]
+        }, i, true, undefined, this);
+      }),
+      isChatLoad && filteredChats.length > 0 && /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Box_default, {
+        flexDirection: "column",
+        marginTop: matches2.length ? 1 : 0,
         children: [
-          /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Text, {
-            color: isExact ? ACCENT : "white",
-            bold: isExact,
-            children: c.cmd
-          }, undefined, false, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Text, {
             color: "gray",
             dimColor: true,
-            children: c.desc
-          }, undefined, false, undefined, this)
+            children: chatFilter ? `matching "${chatFilter}":` : "recent chats:"
+          }, undefined, false, undefined, this),
+          filteredChats.map((name, i) => /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Box_default, {
+            gap: 1,
+            marginLeft: 2,
+            children: [
+              /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Text, {
+                color: ACCENT,
+                children: "·"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Text, {
+                color: "white",
+                children: name
+              }, undefined, false, undefined, this)
+            ]
+          }, i, true, undefined, this))
         ]
-      }, i, true, undefined, this);
-    })
-  }, undefined, false, undefined, this);
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
 }
 var ChatRunner = ({ repoPath }) => {
-  const [stage, setStage] = import_react48.useState({ type: "picking-provider" });
-  const [committed, setCommitted] = import_react48.useState([]);
-  const [provider, setProvider] = import_react48.useState(null);
-  const [systemPrompt, setSystemPrompt] = import_react48.useState("");
-  const [inputValue, setInputValue] = import_react48.useState("");
-  const [pendingMsgIndex, setPendingMsgIndex] = import_react48.useState(null);
-  const [allMessages, setAllMessages] = import_react48.useState([]);
-  const [clonedUrls, setClonedUrls] = import_react48.useState(new Set);
-  const [showTimeline, setShowTimeline] = import_react48.useState(false);
-  const [showReview, setShowReview] = import_react48.useState(false);
-  const [autoApprove, setAutoApprove] = import_react48.useState(false);
-  const abortControllerRef = import_react48.useRef(null);
-  const toolResultCache = import_react48.useRef(new Map);
-  const inputBuffer = import_react48.useRef("");
-  const flushTimer = import_react48.useRef(null);
-  const thinkingPhrase = useThinkingPhrase(stage.type === "thinking");
-  const flushBuffer = () => {
-    const buf = inputBuffer.current;
-    if (!buf)
-      return;
-    inputBuffer.current = "";
-    setInputValue((v) => v + buf);
-  };
-  const scheduleFlush = () => {
-    if (flushTimer.current !== null)
-      return;
-    flushTimer.current = setTimeout(() => {
-      flushTimer.current = null;
-      flushBuffer();
-    }, 16);
+  const [stage, setStage] = import_react49.useState({ type: "picking-provider" });
+  const [committed, setCommitted] = import_react49.useState([]);
+  const [provider, setProvider] = import_react49.useState(null);
+  const [systemPrompt, setSystemPrompt] = import_react49.useState("");
+  const [inputValue, setInputValue] = import_react49.useState("");
+  const [pendingMsgIndex, setPendingMsgIndex] = import_react49.useState(null);
+  const [allMessages, setAllMessages] = import_react49.useState([]);
+  const [clonedUrls, setClonedUrls] = import_react49.useState(new Set);
+  const [showTimeline, setShowTimeline] = import_react49.useState(false);
+  const [showReview, setShowReview] = import_react49.useState(false);
+  const [autoApprove, setAutoApprove] = import_react49.useState(false);
+  const [chatName, setChatName] = import_react49.useState(null);
+  const chatNameRef = import_react49.useRef(null);
+  const [recentChats, setRecentChats] = import_react49.useState([]);
+  const inputHistoryRef = import_react49.useRef([]);
+  const historyIndexRef = import_react49.useRef(-1);
+  const [inputKey, setInputKey] = import_react49.useState(0);
+  const updateChatName = (name) => {
+    chatNameRef.current = name;
+    setChatName(name);
   };
+  const abortControllerRef = import_react49.useRef(null);
+  const toolResultCache = import_react49.useRef(new Map);
+  const batchApprovedRef = import_react49.useRef(false);
+  const thinkingPhrase = useThinkingPhrase(stage.type === "thinking");
+  import_react48.default.useEffect(() => {
+    const chats = listChats(repoPath);
+    setRecentChats(chats.slice(0, 10).map((c) => c.name));
+  }, [repoPath]);
+  import_react48.default.useEffect(() => {
+    if (chatNameRef.current && allMessages.length > 1) {
+      saveChat(chatNameRef.current, repoPath, allMessages);
+    }
+  }, [allMessages]);
   const handleError = (currentAll) => (err) => {
+    batchApprovedRef.current = false;
     if (err instanceof Error && err.name === "AbortError") {
       setStage({ type: "idle" });
       return;
@@ -52420,180 +52562,63 @@ var ChatRunner = ({ repoPath }) => {
   };
   const processResponse = (raw, currentAll, signal) => {
     if (signal.aborted) {
+      batchApprovedRef.current = false;
       setStage({ type: "idle" });
       return;
     }
-    const parsed = parseResponse(raw);
+    const memAddMatches = [
+      ...raw.matchAll(/<memory-add>([\s\S]*?)<\/memory-add>/g)
+    ];
+    const memDelMatches = [
+      ...raw.matchAll(/<memory-delete>([\s\S]*?)<\/memory-delete>/g)
+    ];
+    for (const match of memAddMatches) {
+      const content = match[1].trim();
+      if (content)
+        addMemory(content, repoPath);
+    }
+    for (const match of memDelMatches) {
+      const id = match[1].trim();
+      if (id)
+        deleteMemory(id, repoPath);
+    }
+    const cleanRaw = raw.replace(/<memory-add>[\s\S]*?<\/memory-add>/g, "").replace(/<memory-delete>[\s\S]*?<\/memory-delete>/g, "").trim();
+    const parsed = parseResponse(cleanRaw);
     if (parsed.kind === "changes") {
+      batchApprovedRef.current = false;
       if (parsed.patches.length === 0) {
-        const msg2 = {
-          role: "assistant",
-          content: parsed.content,
-          type: "text"
-        };
-        setAllMessages([...currentAll, msg2]);
-        setCommitted((prev) => [...prev, msg2]);
-        setStage({ type: "idle" });
-        return;
-      }
-      const assistantMsg = {
-        role: "assistant",
-        content: parsed.content,
-        type: "plan",
-        patches: parsed.patches,
-        applied: false
-      };
-      const withAssistant = [...currentAll, assistantMsg];
-      setAllMessages(withAssistant);
-      setPendingMsgIndex(withAssistant.length - 1);
-      const diffLines = buildDiffs(repoPath, parsed.patches);
-      setStage({
-        type: "preview",
-        patches: parsed.patches,
-        diffLines,
-        scrollOffset: 0,
-        pendingMessages: currentAll
-      });
-      return;
-    }
-    if (parsed.kind === "shell" || parsed.kind === "fetch" || parsed.kind === "read-file" || parsed.kind === "read-folder" || parsed.kind === "grep" || parsed.kind === "write-file" || parsed.kind === "delete-file" || parsed.kind === "delete-folder" || parsed.kind === "open-url" || parsed.kind === "generate-pdf" || parsed.kind === "search") {
-      let tool;
-      if (parsed.kind === "shell") {
-        tool = { type: "shell", command: parsed.command };
-      } else if (parsed.kind === "fetch") {
-        tool = { type: "fetch", url: parsed.url };
-      } else if (parsed.kind === "read-file") {
-        tool = { type: "read-file", filePath: parsed.filePath };
-      } else if (parsed.kind === "read-folder") {
-        tool = { type: "read-folder", folderPath: parsed.folderPath };
-      } else if (parsed.kind === "grep") {
-        tool = { type: "grep", pattern: parsed.pattern, glob: parsed.glob };
-      } else if (parsed.kind === "delete-file") {
-        tool = { type: "delete-file", filePath: parsed.filePath };
-      } else if (parsed.kind === "delete-folder") {
-        tool = { type: "delete-folder", folderPath: parsed.folderPath };
-      } else if (parsed.kind === "open-url") {
-        tool = { type: "open-url", url: parsed.url };
-      } else if (parsed.kind === "generate-pdf") {
-        tool = {
-          type: "generate-pdf",
-          filePath: parsed.filePath,
-          content: parsed.pdfContent
-        };
-      } else if (parsed.kind === "search") {
-        tool = { type: "search", query: parsed.query };
-      } else {
-        tool = {
-          type: "write-file",
-          filePath: parsed.filePath,
-          fileContent: parsed.fileContent
-        };
-      }
-      if (parsed.content) {
-        const preambleMsg = {
+        const msg = {
           role: "assistant",
           content: parsed.content,
           type: "text"
         };
-        setAllMessages([...currentAll, preambleMsg]);
-        setCommitted((prev) => [...prev, preambleMsg]);
-      }
-      const isSafeTool = parsed.kind === "read-file" || parsed.kind === "read-folder" || parsed.kind === "grep" || parsed.kind === "fetch" || parsed.kind === "open-url" || parsed.kind === "search";
-      const executeAndContinue = async (approved) => {
-        let result2 = "(denied by user)";
-        if (approved) {
-          const cacheKey = parsed.kind === "read-file" ? `read-file:${parsed.filePath}` : parsed.kind === "read-folder" ? `read-folder:${parsed.folderPath}` : parsed.kind === "grep" ? `grep:${parsed.pattern}:${parsed.glob}` : null;
-          if (cacheKey && toolResultCache.current.has(cacheKey)) {
-            result2 = toolResultCache.current.get(cacheKey) + `
-
-[NOTE: This result was already retrieved earlier. Do not request it again.]`;
-          } else {
-            try {
-              setStage({ type: "thinking" });
-              if (parsed.kind === "shell") {
-                result2 = await runShell(parsed.command, repoPath);
-              } else if (parsed.kind === "fetch") {
-                result2 = await fetchUrl(parsed.url);
-              } else if (parsed.kind === "read-file") {
-                result2 = readFile(parsed.filePath, repoPath);
-              } else if (parsed.kind === "read-folder") {
-                result2 = readFolder(parsed.folderPath, repoPath);
-              } else if (parsed.kind === "grep") {
-                result2 = grepFiles(parsed.pattern, parsed.glob, repoPath);
-              } else if (parsed.kind === "delete-file") {
-                result2 = deleteFile(parsed.filePath, repoPath);
-              } else if (parsed.kind === "delete-folder") {
-                result2 = deleteFolder(parsed.folderPath, repoPath);
-              } else if (parsed.kind === "open-url") {
-                result2 = openUrl(parsed.url);
-              } else if (parsed.kind === "generate-pdf") {
-                result2 = generatePdf(parsed.filePath, parsed.pdfContent, repoPath);
-              } else if (parsed.kind === "write-file") {
-                result2 = writeFile(parsed.filePath, parsed.fileContent, repoPath);
-              } else if (parsed.kind === "search") {
-                result2 = await searchWeb(parsed.query);
-              }
-              if (cacheKey) {
-                toolResultCache.current.set(cacheKey, result2);
-              }
-            } catch (err) {
-              result2 = `Error: ${err instanceof Error ? err.message : "failed"}`;
-            }
-          }
-        }
-        if (approved && !result2.startsWith("Error:")) {
-          const kindMap2 = {
-            shell: "shell-run",
-            fetch: "url-fetched",
-            "read-file": "file-read",
-            "read-folder": "file-read",
-            grep: "file-read",
-            "delete-file": "file-written",
-            "delete-folder": "file-written",
-            "open-url": "url-fetched",
-            "generate-pdf": "file-written",
-            "write-file": "file-written",
-            search: "url-fetched"
-          };
-          appendHistory({
-            kind: kindMap2[parsed.kind] ?? "shell-run",
-            detail: parsed.kind === "shell" ? parsed.command : parsed.kind === "fetch" ? parsed.url : parsed.kind === "search" ? parsed.query : parsed.kind === "read-folder" ? parsed.folderPath : parsed.kind === "grep" ? `${parsed.pattern} ${parsed.glob}` : parsed.kind === "delete-file" ? parsed.filePath : parsed.kind === "delete-folder" ? parsed.folderPath : parsed.kind === "open-url" ? parsed.url : parsed.kind === "generate-pdf" ? parsed.filePath : parsed.filePath,
-            summary: result2.split(`
-`)[0]?.slice(0, 120) ?? "",
-            repoPath
-          });
-        }
-        const toolName = parsed.kind === "shell" ? "shell" : parsed.kind === "fetch" ? "fetch" : parsed.kind === "read-file" ? "read-file" : parsed.kind === "read-folder" ? "read-folder" : parsed.kind === "grep" ? "grep" : parsed.kind === "delete-file" ? "delete-file" : parsed.kind === "delete-folder" ? "delete-folder" : parsed.kind === "open-url" ? "open-url" : parsed.kind === "generate-pdf" ? "generate-pdf" : parsed.kind === "search" ? "search" : "write-file";
-        const toolContent = parsed.kind === "shell" ? parsed.command : parsed.kind === "fetch" ? parsed.url : parsed.kind === "search" ? parsed.query : parsed.kind === "read-folder" ? parsed.folderPath : parsed.kind === "grep" ? `${parsed.pattern} — ${parsed.glob}` : parsed.kind === "delete-file" ? parsed.filePath : parsed.kind === "delete-folder" ? parsed.folderPath : parsed.kind === "open-url" ? parsed.url : parsed.kind === "generate-pdf" ? parsed.filePath : parsed.filePath;
-        const toolMsg = {
-          role: "assistant",
-          type: "tool",
-          toolName,
-          content: toolContent,
-          result: result2,
-          approved
-        };
-        const withTool = [...currentAll, toolMsg];
-        setAllMessages(withTool);
-        setCommitted((prev) => [...prev, toolMsg]);
-        const nextAbort = new AbortController;
-        abortControllerRef.current = nextAbort;
-        setStage({ type: "thinking" });
-        callChat(provider, systemPrompt, withTool, nextAbort.signal).then((r) => processResponse(r, withTool, nextAbort.signal)).catch(handleError(withTool));
-      };
-      if (autoApprove && isSafeTool) {
-        executeAndContinue(true);
+        setAllMessages([...currentAll, msg]);
+        setCommitted((prev) => [...prev, msg]);
+        setStage({ type: "idle" });
         return;
       }
+      const assistantMsg = {
+        role: "assistant",
+        content: parsed.content,
+        type: "plan",
+        patches: parsed.patches,
+        applied: false
+      };
+      const withAssistant = [...currentAll, assistantMsg];
+      setAllMessages(withAssistant);
+      setPendingMsgIndex(withAssistant.length - 1);
+      const diffLines = buildDiffs(repoPath, parsed.patches);
       setStage({
-        type: "permission",
-        tool,
-        pendingMessages: currentAll,
-        resolve: executeAndContinue
+        type: "preview",
+        patches: parsed.patches,
+        diffLines,
+        scrollOffset: 0,
+        pendingMessages: currentAll
       });
       return;
     }
     if (parsed.kind === "clone") {
+      batchApprovedRef.current = false;
       if (parsed.content) {
         const preambleMsg = {
           role: "assistant",
@@ -52610,23 +52635,116 @@ var ChatRunner = ({ repoPath }) => {
       });
       return;
     }
-    const msg = {
-      role: "assistant",
-      content: parsed.content,
-      type: "text"
-    };
-    const withMsg = [...currentAll, msg];
-    setAllMessages(withMsg);
-    setCommitted((prev) => [...prev, msg]);
-    const lastUserMsg = [...currentAll].reverse().find((m) => m.role === "user");
-    const githubUrl = lastUserMsg ? extractGithubUrl(lastUserMsg.content) : null;
-    if (githubUrl && !clonedUrls.has(githubUrl)) {
-      setTimeout(() => {
-        setStage({ type: "clone-offer", repoUrl: githubUrl });
-      }, 80);
-    } else {
+    if (parsed.kind === "text") {
+      batchApprovedRef.current = false;
+      const msg = {
+        role: "assistant",
+        content: parsed.content,
+        type: "text"
+      };
+      const withMsg = [...currentAll, msg];
+      setAllMessages(withMsg);
+      setCommitted((prev) => [...prev, msg]);
+      const lastUserMsg = [...currentAll].reverse().find((m) => m.role === "user");
+      const githubUrl = lastUserMsg ? extractGithubUrl(lastUserMsg.content) : null;
+      if (githubUrl && !clonedUrls.has(githubUrl)) {
+        setTimeout(() => setStage({ type: "clone-offer", repoUrl: githubUrl }), 80);
+      } else {
+        setStage({ type: "idle" });
+      }
+      return;
+    }
+    const tool = registry.get(parsed.toolName);
+    if (!tool) {
+      batchApprovedRef.current = false;
       setStage({ type: "idle" });
+      return;
+    }
+    if (parsed.content) {
+      const preambleMsg = {
+        role: "assistant",
+        content: parsed.content,
+        type: "text"
+      };
+      setAllMessages([...currentAll, preambleMsg]);
+      setCommitted((prev) => [...prev, preambleMsg]);
+    }
+    const remainder = parsed.remainder;
+    const isSafe = tool.safe ?? false;
+    const executeAndContinue = async (approved) => {
+      if (approved && remainder) {
+        batchApprovedRef.current = true;
+      }
+      let result2 = "(denied by user)";
+      if (approved) {
+        const cacheKey = isSafe ? `${parsed.toolName}:${parsed.rawInput}` : null;
+        if (cacheKey && toolResultCache.current.has(cacheKey)) {
+          result2 = toolResultCache.current.get(cacheKey) + `
+
+[NOTE: This result was already retrieved earlier. Do not request it again.]`;
+        } else {
+          try {
+            setStage({ type: "thinking" });
+            const toolResult = await tool.execute(parsed.input, {
+              repoPath,
+              messages: currentAll
+            });
+            result2 = toolResult.value;
+            if (cacheKey && toolResult.kind === "text") {
+              toolResultCache.current.set(cacheKey, result2);
+            }
+          } catch (err) {
+            result2 = `Error: ${err instanceof Error ? err.message : "failed"}`;
+          }
+        }
+      }
+      if (approved && !result2.startsWith("Error:")) {
+        appendMemory({
+          kind: "shell-run",
+          detail: tool.summariseInput ? String(tool.summariseInput(parsed.input)) : parsed.rawInput,
+          summary: result2.split(`
+`)[0]?.slice(0, 120) ?? "",
+          repoPath
+        });
+      }
+      const displayContent = tool.summariseInput ? String(tool.summariseInput(parsed.input)) : parsed.rawInput;
+      const toolMsg = {
+        role: "assistant",
+        type: "tool",
+        toolName: parsed.toolName,
+        content: displayContent,
+        result: result2,
+        approved
+      };
+      const withTool = [...currentAll, toolMsg];
+      setAllMessages(withTool);
+      setCommitted((prev) => [...prev, toolMsg]);
+      if (approved && remainder && remainder.length > 0) {
+        processResponse(remainder, withTool, signal);
+        return;
+      }
+      batchApprovedRef.current = false;
+      const nextAbort = new AbortController;
+      abortControllerRef.current = nextAbort;
+      setStage({ type: "thinking" });
+      callChat(provider, systemPrompt, withTool, nextAbort.signal).then((r) => processResponse(r, withTool, nextAbort.signal)).catch(handleError(withTool));
+    };
+    if (autoApprove && isSafe || batchApprovedRef.current) {
+      executeAndContinue(true);
+      return;
     }
+    const permLabel = tool.permissionLabel ?? tool.name;
+    const permValue = tool.summariseInput ? String(tool.summariseInput(parsed.input)) : parsed.rawInput;
+    setStage({
+      type: "permission",
+      tool: {
+        type: parsed.toolName,
+        _display: permValue,
+        _label: permLabel
+      },
+      pendingMessages: currentAll,
+      resolve: executeAndContinue
+    });
   };
   const sendMessage = (text) => {
     if (!provider)
@@ -52644,7 +52762,7 @@ var ChatRunner = ({ repoPath }) => {
       setAutoApprove(next);
       const msg = {
         role: "assistant",
-        content: next ? "Auto-approve ON — read, search, grep and folder tools will run without asking. Write and code changes still require approval." : "Auto-approve OFF — all tools will ask for permission.",
+        content: next ? "Auto-approve ON — safe tools (read, search, fetch) will run without asking." : "Auto-approve OFF — all tools will ask for permission.",
         type: "text"
       };
       setCommitted((prev) => [...prev, msg]);
@@ -52652,14 +52770,204 @@ var ChatRunner = ({ repoPath }) => {
       return;
     }
     if (text.trim().toLowerCase() === "/clear history") {
-      clearRepoHistory(repoPath);
-      const clearedMsg = {
+      clearRepoMemory(repoPath);
+      const msg = {
         role: "assistant",
         content: "History cleared for this repo.",
         type: "text"
       };
-      setCommitted((prev) => [...prev, clearedMsg]);
-      setAllMessages((prev) => [...prev, clearedMsg]);
+      setCommitted((prev) => [...prev, msg]);
+      setAllMessages((prev) => [...prev, msg]);
+      return;
+    }
+    if (text.trim().toLowerCase() === "/chat") {
+      const msg = {
+        role: "assistant",
+        content: "Chat commands: `/chat list` · `/chat load <n>` · `/chat rename <n>` · `/chat delete <n>`",
+        type: "text"
+      };
+      setCommitted((prev) => [...prev, msg]);
+      setAllMessages((prev) => [...prev, msg]);
+      return;
+    }
+    if (text.trim().toLowerCase().startsWith("/chat rename")) {
+      const parts = text.trim().split(/\s+/);
+      const newName = parts.slice(2).join("-");
+      if (!newName) {
+        const msg2 = {
+          role: "assistant",
+          content: "Usage: `/chat rename <new-name>`",
+          type: "text"
+        };
+        setCommitted((prev) => [...prev, msg2]);
+        setAllMessages((prev) => [...prev, msg2]);
+        return;
+      }
+      const oldName = chatNameRef.current;
+      if (oldName)
+        deleteChat(oldName);
+      updateChatName(newName);
+      saveChat(newName, repoPath, allMessages);
+      setRecentChats((prev) => [newName, ...prev.filter((n) => n !== newName && n !== oldName)].slice(0, 10));
+      const msg = {
+        role: "assistant",
+        content: `Chat renamed to **${newName}**.`,
+        type: "text"
+      };
+      setCommitted((prev) => [...prev, msg]);
+      setAllMessages((prev) => [...prev, msg]);
+      return;
+    }
+    if (text.trim().toLowerCase().startsWith("/chat delete")) {
+      const parts = text.trim().split(/\s+/);
+      const name = parts.slice(2).join("-");
+      if (!name) {
+        const msg2 = {
+          role: "assistant",
+          content: "Usage: `/chat delete <n>`",
+          type: "text"
+        };
+        setCommitted((prev) => [...prev, msg2]);
+        setAllMessages((prev) => [...prev, msg2]);
+        return;
+      }
+      const deleted = deleteChat(name);
+      if (!deleted) {
+        const msg2 = {
+          role: "assistant",
+          content: `Chat **${name}** not found.`,
+          type: "text"
+        };
+        setCommitted((prev) => [...prev, msg2]);
+        setAllMessages((prev) => [...prev, msg2]);
+        return;
+      }
+      if (chatNameRef.current === name) {
+        chatNameRef.current = null;
+        setChatName(null);
+      }
+      setRecentChats((prev) => prev.filter((n) => n !== name));
+      const msg = {
+        role: "assistant",
+        content: `Chat **${name}** deleted.`,
+        type: "text"
+      };
+      setCommitted((prev) => [...prev, msg]);
+      setAllMessages((prev) => [...prev, msg]);
+      return;
+    }
+    if (text.trim().toLowerCase() === "/chat list") {
+      const chats = listChats(repoPath);
+      const content = chats.length === 0 ? "No saved chats for this repo yet." : `Saved chats:
+
+${chats.map((c) => `- **${c.name}** · ${c.userMessageCount} messages · ${new Date(c.savedAt).toLocaleString()}`).join(`
+`)}`;
+      const msg = { role: "assistant", content, type: "text" };
+      setCommitted((prev) => [...prev, msg]);
+      setAllMessages((prev) => [...prev, msg]);
+      return;
+    }
+    if (text.trim().toLowerCase().startsWith("/chat load")) {
+      const parts = text.trim().split(/\s+/);
+      const name = parts.slice(2).join("-");
+      if (!name) {
+        const chats = listChats(repoPath);
+        const content = chats.length === 0 ? "No saved chats found." : `Specify a chat name. Recent chats:
+
+${chats.slice(0, 10).map((c) => `- **${c.name}**`).join(`
+`)}`;
+        const msg = { role: "assistant", content, type: "text" };
+        setCommitted((prev) => [...prev, msg]);
+        setAllMessages((prev) => [...prev, msg]);
+        return;
+      }
+      const saved = loadChat(name);
+      if (!saved) {
+        const msg = {
+          role: "assistant",
+          content: `Chat **${name}** not found. Use \`/chat list\` to see saved chats.`,
+          type: "text"
+        };
+        setCommitted((prev) => [...prev, msg]);
+        setAllMessages((prev) => [...prev, msg]);
+        return;
+      }
+      updateChatName(name);
+      setAllMessages(saved.messages);
+      setCommitted(saved.messages);
+      const notice = {
+        role: "assistant",
+        content: `Loaded chat **${name}** · ${saved.userMessageCount} messages · saved ${new Date(saved.savedAt).toLocaleString()}`,
+        type: "text"
+      };
+      setCommitted((prev) => [...prev, notice]);
+      setAllMessages((prev) => [...prev, notice]);
+      return;
+    }
+    if (text.trim().toLowerCase() === "/memory list" || text.trim().toLowerCase() === "/memory") {
+      const mems = listMemories(repoPath);
+      const content = mems.length === 0 ? "No memories stored for this repo yet." : `Memories for this repo:
+
+${mems.map((m) => `- [${m.id}] ${m.content}`).join(`
+`)}`;
+      const msg = { role: "assistant", content, type: "text" };
+      setCommitted((prev) => [...prev, msg]);
+      setAllMessages((prev) => [...prev, msg]);
+      return;
+    }
+    if (text.trim().toLowerCase().startsWith("/memory add")) {
+      const content = text.trim().slice("/memory add".length).trim();
+      if (!content) {
+        const msg2 = {
+          role: "assistant",
+          content: "Usage: `/memory add <content>`",
+          type: "text"
+        };
+        setCommitted((prev) => [...prev, msg2]);
+        setAllMessages((prev) => [...prev, msg2]);
+        return;
+      }
+      const mem = addMemory(content, repoPath);
+      const msg = {
+        role: "assistant",
+        content: `Memory saved **[${mem.id}]**: ${mem.content}`,
+        type: "text"
+      };
+      setCommitted((prev) => [...prev, msg]);
+      setAllMessages((prev) => [...prev, msg]);
+      return;
+    }
+    if (text.trim().toLowerCase().startsWith("/memory delete")) {
+      const id = text.trim().split(/\s+/)[2];
+      if (!id) {
+        const msg2 = {
+          role: "assistant",
+          content: "Usage: `/memory delete <id>`",
+          type: "text"
+        };
+        setCommitted((prev) => [...prev, msg2]);
+        setAllMessages((prev) => [...prev, msg2]);
+        return;
+      }
+      const deleted = deleteMemory(id, repoPath);
+      const msg = {
+        role: "assistant",
+        content: deleted ? `Memory **[${id}]** deleted.` : `Memory **[${id}]** not found.`,
+        type: "text"
+      };
+      setCommitted((prev) => [...prev, msg]);
+      setAllMessages((prev) => [...prev, msg]);
+      return;
+    }
+    if (text.trim().toLowerCase() === "/memory clear") {
+      clearRepoMemory(repoPath);
+      const msg = {
+        role: "assistant",
+        content: "All memories cleared for this repo.",
+        type: "text"
+      };
+      setCommitted((prev) => [...prev, msg]);
+      setAllMessages((prev) => [...prev, msg]);
       return;
     }
     const userMsg = { role: "user", content: text, type: "text" };
@@ -52667,6 +52975,18 @@ var ChatRunner = ({ repoPath }) => {
     setCommitted((prev) => [...prev, userMsg]);
     setAllMessages(nextAll);
     toolResultCache.current.clear();
+    batchApprovedRef.current = false;
+    inputHistoryRef.current = [
+      text,
+      ...inputHistoryRef.current.filter((m) => m !== text)
+    ].slice(0, 50);
+    historyIndexRef.current = -1;
+    if (!chatName) {
+      const name = getChatNameSuggestions(nextAll)[0] ?? `chat-${new Date().toISOString().slice(0, 10)}`;
+      updateChatName(name);
+      setRecentChats((prev) => [name, ...prev.filter((n) => n !== name)].slice(0, 10));
+      saveChat(name, repoPath, nextAll);
+    }
     const abort = new AbortController;
     abortControllerRef.current = abort;
     setStage({ type: "thinking" });
@@ -52678,6 +52998,7 @@ var ChatRunner = ({ repoPath }) => {
     if (stage.type === "thinking" && key.escape) {
       abortControllerRef.current?.abort();
       abortControllerRef.current = null;
+      batchApprovedRef.current = false;
       setStage({ type: "idle" });
       return;
     }
@@ -52686,6 +53007,20 @@ var ChatRunner = ({ repoPath }) => {
         process.exit(0);
         return;
       }
+      if (key.upArrow && inputHistoryRef.current.length > 0) {
+        const next = Math.min(historyIndexRef.current + 1, inputHistoryRef.current.length - 1);
+        historyIndexRef.current = next;
+        setInputValue(inputHistoryRef.current[next]);
+        setInputKey((k) => k + 1);
+        return;
+      }
+      if (key.downArrow) {
+        const next = historyIndexRef.current - 1;
+        historyIndexRef.current = next;
+        setInputValue(next < 0 ? "" : inputHistoryRef.current[next]);
+        setInputKey((k) => k + 1);
+        return;
+      }
       if (key.tab && inputValue.startsWith("/")) {
         const q = inputValue.toLowerCase();
         const match = COMMANDS.find((c) => c.cmd.startsWith(q));
@@ -52704,9 +53039,9 @@ var ChatRunner = ({ repoPath }) => {
         startCloneRepo(cloneUrl).then((result2) => {
           if (result2.done) {
             const repoName = cloneUrl.split("/").pop()?.replace(/\.git$/, "") ?? "repo";
-            const destPath = path16.join(os7.tmpdir(), repoName);
+            const destPath = path18.join(os9.tmpdir(), repoName);
             const fileCount = walkDir3(destPath).length;
-            appendHistory({
+            appendMemory({
               kind: "url-fetched",
               detail: repoUrl,
               summary: `Cloned ${repoName} — ${fileCount} files`,
@@ -52742,16 +53077,14 @@ var ChatRunner = ({ repoPath }) => {
     if (stage.type === "clone-exists") {
       if (input === "y" || input === "Y") {
         const { repoUrl, repoPath: existingPath } = stage;
-        const cloneUrl = toCloneUrl(repoUrl);
         setStage({ type: "cloning", repoUrl });
-        startCloneRepo(cloneUrl, { forceReclone: true }).then((result2) => {
+        startCloneRepo(toCloneUrl(repoUrl), { forceReclone: true }).then((result2) => {
           if (result2.done) {
-            const fileCount = walkDir3(existingPath).length;
             setStage({
               type: "clone-done",
               repoUrl,
               destPath: existingPath,
-              fileCount
+              fileCount: walkDir3(existingPath).length
             });
           } else {
             setStage({
@@ -52764,12 +53097,11 @@ var ChatRunner = ({ repoPath }) => {
       }
       if (input === "n" || input === "N") {
         const { repoUrl, repoPath: existingPath } = stage;
-        const fileCount = walkDir3(existingPath).length;
         setStage({
           type: "clone-done",
           repoUrl,
           destPath: existingPath,
-          fileCount
+          fileCount: walkDir3(existingPath).length
         });
         return;
       }
@@ -52791,7 +53123,7 @@ Ask me anything about it — I can read files, explain how it works, or suggest
             type: "tool",
             toolName: "fetch",
             content: stage.repoUrl,
-            result: `Clone complete. Repo: ${repoName}. Local path: ${stage.destPath}. ${stage.fileCount} files. Use read-file with full path e.g. read-file ${stage.destPath}/README.md`,
+            result: `Clone complete. Repo: ${repoName}. Local path: ${stage.destPath}. ${stage.fileCount} files.`,
             approved: true
           };
           const withClone = [...allMessages, contextMsg, summaryMsg];
@@ -52812,6 +53144,7 @@ Ask me anything about it — I can read files, explain how it works, or suggest
         return;
       }
       if (input === "n" || input === "N" || key.escape) {
+        batchApprovedRef.current = false;
         stage.resolve(false);
         return;
       }
@@ -52834,7 +53167,7 @@ Ask me anything about it — I can read files, explain how it works, or suggest
           const msg = allMessages[pendingMsgIndex];
           if (msg?.type === "plan") {
             setCommitted((prev) => [...prev, { ...msg, applied: false }]);
-            appendHistory({
+            appendMemory({
               kind: "code-skipped",
               detail: msg.patches.map((p) => p.path).join(", "),
               summary: `Skipped changes to ${msg.patches.length} file(s)`,
@@ -52849,7 +53182,7 @@ Ask me anything about it — I can read files, explain how it works, or suggest
       if (key.return || input === "a" || input === "A") {
         try {
           applyPatches3(repoPath, stage.patches);
-          appendHistory({
+          appendMemory({
             kind: "code-applied",
             detail: stage.patches.map((p) => p.path).join(", "),
             summary: `Applied changes to ${stage.patches.length} file(s)`,
@@ -52892,7 +53225,7 @@ Ask me anything about it — I can read files, explain how it works, or suggest
     setStage({ type: "loading" });
     fetchFileTree(repoPath).catch(() => walkDir3(repoPath)).then((fileTree) => {
       const importantFiles = readImportantFiles(repoPath, fileTree);
-      const historySummary = buildHistorySummary(repoPath);
+      const historySummary = buildMemorySummary(repoPath);
       const lensFile = readLensFile(repoPath);
       const lensContext = lensFile ? `
 
@@ -52901,17 +53234,16 @@ ${lensFile.overview}
 
 Important folders: ${lensFile.importantFolders.join(", ")}
 Suggestions: ${lensFile.suggestions.slice(0, 3).join("; ")}` : "";
-      setSystemPrompt(buildSystemPrompt(importantFiles, historySummary) + lensContext);
-      const historyNote = historySummary ? `
-
-I have memory of previous actions in this repo.` : "";
-      const lensGreetNote = lensFile ? `
-
-Found LENS.md — I have context from a previous analysis of this repo.` : "";
+      const toolsSection = registry.buildSystemPromptSection();
+      setSystemPrompt(buildSystemPrompt(importantFiles, historySummary, toolsSection) + lensContext);
       const greeting = {
         role: "assistant",
-        content: `Welcome to Lens 
-Codebase loaded — ${importantFiles.length} files indexed.${historyNote}${lensGreetNote}
+        content: `Welcome to Lens
+Codebase loaded — ${importantFiles.length} files indexed.${historySummary ? `
+
+I have memory of previous actions in this repo.` : ""}${lensFile ? `
+
+Found LENS.md — I have context from a previous analysis of this repo.` : ""}
 Ask me anything, tell me what to build, share a URL, or ask me to read/write files.
 
 Tip: type /timeline to browse commit history.`,
@@ -52926,7 +53258,7 @@ Tip: type /timeline to browse commit history.`,
     return /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(ProviderPicker, {
       onDone: handleProviderDone
     }, undefined, false, undefined, this);
-  if (stage.type === "loading") {
+  if (stage.type === "loading")
     return /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Box_default, {
       gap: 1,
       marginTop: 1,
@@ -52946,19 +53278,16 @@ Tip: type /timeline to browse commit history.`,
         }, undefined, false, undefined, this)
       ]
     }, undefined, true, undefined, this);
-  }
-  if (showTimeline) {
+  if (showTimeline)
     return /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(TimelineRunner, {
       repoPath,
       onExit: () => setShowTimeline(false)
     }, undefined, false, undefined, this);
-  }
-  if (showReview) {
+  if (showReview)
     return /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(ReviewCommand, {
       path: repoPath,
       onExit: () => setShowReview(false)
     }, undefined, false, undefined, this);
-  }
   if (stage.type === "clone-offer")
     return /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(CloneOfferView, {
       stage,
@@ -53029,18 +53358,21 @@ Tip: type /timeline to browse commit history.`,
         children: [
           inputValue.startsWith("/") && /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(CommandPalette, {
             query: inputValue,
-            onSelect: (cmd) => {
-              setInputValue(cmd);
-            }
+            onSelect: (cmd) => setInputValue(cmd),
+            recentChats
           }, undefined, false, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(InputBox, {
             value: inputValue,
-            onChange: setInputValue,
+            onChange: (v) => {
+              historyIndexRef.current = -1;
+              setInputValue(v);
+            },
             onSubmit: (val) => {
               if (val.trim())
                 sendMessage(val.trim());
               setInputValue("");
-            }
+            },
+            inputKey
           }, undefined, false, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(ShortcutBar, {
             autoApprove
@@ -53054,8 +53386,8 @@ Tip: type /timeline to browse commit history.`,
 // src/commands/chat.tsx
 var jsx_dev_runtime23 = __toESM(require_jsx_dev_runtime(), 1);
 var ChatCommand = ({ path: inputPath }) => {
-  const resolvedPath = path17.resolve(inputPath);
-  if (!existsSync12(resolvedPath)) {
+  const resolvedPath = path19.resolve(inputPath);
+  if (!existsSync14(resolvedPath)) {
     return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
       marginTop: 1,
       children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text, {
@@ -53074,12 +53406,12 @@ var ChatCommand = ({ path: inputPath }) => {
 };
 
 // src/commands/timeline.tsx
-import { existsSync as existsSync13 } from "fs";
-import path18 from "path";
+import { existsSync as existsSync15 } from "fs";
+import path20 from "path";
 var jsx_dev_runtime24 = __toESM(require_jsx_dev_runtime(), 1);
 var TimelineCommand = ({ path: inputPath }) => {
-  const resolvedPath = path18.resolve(inputPath);
-  if (!existsSync13(resolvedPath)) {
+  const resolvedPath = path20.resolve(inputPath);
+  if (!existsSync15(resolvedPath)) {
     return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
       marginTop: 1,
       children: /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Text, {
@@ -53096,9 +53428,259 @@ var TimelineCommand = ({ path: inputPath }) => {
     repoPath: resolvedPath
   }, undefined, false, undefined, this);
 };
+// src/utils/tools/builtins.ts
+var fetchTool = {
+  name: "fetch",
+  description: "load a URL",
+  safe: true,
+  permissionLabel: "fetch",
+  systemPromptEntry: (i) => `### ${i}. fetch — load a URL
+<fetch>https://example.com</fetch>`,
+  parseInput: (body) => body.replace(/^<|>$/g, "").trim() || null,
+  summariseInput: (url) => url,
+  execute: async (url) => {
+    try {
+      const value = await fetchUrl(url);
+      return { kind: "text", value };
+    } catch (err) {
+      return {
+        kind: "error",
+        value: `Fetch failed: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  }
+};
+var shellTool = {
+  name: "shell",
+  description: "run a terminal command",
+  safe: false,
+  permissionLabel: "run",
+  systemPromptEntry: (i) => `### ${i}. shell — run a terminal command
+<shell>node -v</shell>`,
+  parseInput: (body) => body || null,
+  summariseInput: (cmd) => cmd,
+  execute: async (cmd, ctx) => {
+    const value = await runShell(cmd, ctx.repoPath);
+    return { kind: "text", value };
+  }
+};
+var readFileTool = {
+  name: "read-file",
+  description: "read a file from the repo",
+  safe: true,
+  permissionLabel: "read",
+  systemPromptEntry: (i) => `### ${i}. read-file — read a file from the repo
+<read-file>src/foo.ts</read-file>`,
+  parseInput: (body) => body || null,
+  summariseInput: (p) => p,
+  execute: (filePath, ctx) => ({
+    kind: "text",
+    value: readFile(filePath, ctx.repoPath)
+  })
+};
+var readFolderTool = {
+  name: "read-folder",
+  description: "list contents of a folder (files + subfolders, one level deep)",
+  safe: true,
+  permissionLabel: "folder",
+  systemPromptEntry: (i) => `### ${i}. read-folder — list contents of a folder (files + subfolders, one level deep)
+<read-folder>src/components</read-folder>`,
+  parseInput: (body) => body || null,
+  summariseInput: (p) => p,
+  execute: (folderPath, ctx) => ({
+    kind: "text",
+    value: readFolder(folderPath, ctx.repoPath)
+  })
+};
+var grepTool = {
+  name: "grep",
+  description: "search for a pattern across files in the repo",
+  safe: true,
+  permissionLabel: "grep",
+  systemPromptEntry: (i) => `### ${i}. grep — search for a pattern across files in the repo (cross-platform, no shell needed)
+<grep>
+{"pattern": "ChatRunner", "glob": "src/**/*.tsx"}
+</grep>`,
+  parseInput: (body) => {
+    try {
+      const parsed = JSON.parse(body);
+      return { pattern: parsed.pattern, glob: parsed.glob ?? "**/*" };
+    } catch {
+      return { pattern: body, glob: "**/*" };
+    }
+  },
+  summariseInput: ({ pattern, glob }) => `${pattern} — ${glob}`,
+  execute: ({ pattern, glob }, ctx) => ({
+    kind: "text",
+    value: grepFiles(pattern, glob, ctx.repoPath)
+  })
+};
+var writeFileTool = {
+  name: "write-file",
+  description: "create or overwrite a file",
+  safe: false,
+  permissionLabel: "write",
+  systemPromptEntry: (i) => `### ${i}. write-file — create or overwrite a file
+<write-file>
+{"path": "data/output.csv", "content": "col1,col2\\nval1,val2"}
+</write-file>`,
+  parseInput: (body) => {
+    try {
+      const parsed = JSON.parse(body);
+      if (!parsed.path)
+        return null;
+      return parsed;
+    } catch {
+      return null;
+    }
+  },
+  summariseInput: ({ path: path21, content }) => `${path21} (${content.length} bytes)`,
+  execute: ({ path: filePath, content }, ctx) => ({
+    kind: "text",
+    value: writeFile(filePath, content, ctx.repoPath)
+  })
+};
+var deleteFileTool = {
+  name: "delete-file",
+  description: "permanently delete a single file",
+  safe: false,
+  permissionLabel: "delete",
+  systemPromptEntry: (i) => `### ${i}. delete-file — permanently delete a single file
+<delete-file>src/old-component.tsx</delete-file>`,
+  parseInput: (body) => body || null,
+  summariseInput: (p) => p,
+  execute: (filePath, ctx) => ({
+    kind: "text",
+    value: deleteFile(filePath, ctx.repoPath)
+  })
+};
+var deleteFolderTool = {
+  name: "delete-folder",
+  description: "permanently delete a folder and all its contents",
+  safe: false,
+  permissionLabel: "delete folder",
+  systemPromptEntry: (i) => `### ${i}. delete-folder — permanently delete a folder and all its contents
+<delete-folder>src/legacy</delete-folder>`,
+  parseInput: (body) => body || null,
+  summariseInput: (p) => p,
+  execute: (folderPath, ctx) => ({
+    kind: "text",
+    value: deleteFolder(folderPath, ctx.repoPath)
+  })
+};
+var openUrlTool = {
+  name: "open-url",
+  description: "open a URL in the user's default browser",
+  safe: true,
+  permissionLabel: "open",
+  systemPromptEntry: (i) => `### ${i}. open-url — open a URL in the user's default browser
+<open-url>https://github.com/owner/repo</open-url>`,
+  parseInput: (body) => body.replace(/^<|>$/g, "").trim() || null,
+  summariseInput: (url) => url,
+  execute: (url) => ({ kind: "text", value: openUrl(url) })
+};
+var generatePdfTool = {
+  name: "generate-pdf",
+  description: "generate a PDF file from markdown-style content",
+  safe: false,
+  permissionLabel: "pdf",
+  systemPromptEntry: (i) => `### ${i}. generate-pdf — generate a PDF file from markdown-style content
+<generate-pdf>
+{"path": "output/report.pdf", "content": "# Title\\n\\nSome body text."}
+</generate-pdf>`,
+  parseInput: (body) => {
+    try {
+      const parsed = JSON.parse(body);
+      return {
+        filePath: parsed.path ?? parsed.filePath ?? "output.pdf",
+        content: parsed.content ?? ""
+      };
+    } catch {
+      return null;
+    }
+  },
+  summariseInput: ({ filePath }) => filePath,
+  execute: ({ filePath, content }, ctx) => ({
+    kind: "text",
+    value: generatePdf(filePath, content, ctx.repoPath)
+  })
+};
+var searchTool = {
+  name: "search",
+  description: "search the internet for anything you are unsure about",
+  safe: true,
+  permissionLabel: "search",
+  systemPromptEntry: (i) => `### ${i}. search — search the internet for anything you are unsure about
+<search>how to use React useEffect cleanup function</search>`,
+  parseInput: (body) => body || null,
+  summariseInput: (q) => `"${q}"`,
+  execute: async (query) => {
+    try {
+      const value = await searchWeb(query);
+      return { kind: "text", value };
+    } catch (err) {
+      return {
+        kind: "error",
+        value: `Search failed: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  }
+};
+var cloneTool = {
+  name: "clone",
+  description: "clone a GitHub repo so you can explore and discuss it",
+  safe: false,
+  permissionLabel: "clone",
+  systemPromptEntry: (i) => `### ${i}. clone — clone a GitHub repo so you can explore and discuss it
+<clone>https://github.com/owner/repo</clone>`,
+  parseInput: (body) => body.replace(/^<|>$/g, "").trim() || null,
+  summariseInput: (url) => url,
+  execute: (repoUrl) => ({
+    kind: "text",
+    value: `Clone of ${repoUrl} was handled by the UI.`
+  })
+};
+var changesTool = {
+  name: "changes",
+  description: "propose code edits (shown as a diff for user approval)",
+  safe: false,
+  permissionLabel: "changes",
+  systemPromptEntry: (i) => `### ${i}. changes — propose code edits (shown as a diff for user approval)
+<changes>
+{"summary": "what changed and why", "patches": [{"path": "src/foo.ts", "content": "COMPLETE file content", "isNew": false}]}
+</changes>`,
+  parseInput: (body) => {
+    try {
+      return JSON.parse(body);
+    } catch {
+      return null;
+    }
+  },
+  summariseInput: ({ summary }) => summary,
+  execute: ({ summary }) => ({
+    kind: "text",
+    value: `Changes proposed: ${summary}`
+  })
+};
+function registerBuiltins() {
+  registry.register(fetchTool);
+  registry.register(shellTool);
+  registry.register(readFileTool);
+  registry.register(readFolderTool);
+  registry.register(grepTool);
+  registry.register(writeFileTool);
+  registry.register(deleteFileTool);
+  registry.register(deleteFolderTool);
+  registry.register(openUrlTool);
+  registry.register(generatePdfTool);
+  registry.register(searchTool);
+  registry.register(cloneTool);
+  registry.register(changesTool);
+}
 
 // src/index.tsx
 var jsx_dev_runtime25 = __toESM(require_jsx_dev_runtime(), 1);
+registerBuiltins();
 var program2 = new Command;
 program2.command("repo <url>").description("Analyze a remote repository").action((url) => {
   render_default(/* @__PURE__ */ jsx_dev_runtime25.jsxDEV(RepoCommand, {