nou-cli 0.5.1 → 0.5.3

package/README.md

@@ -47,14 +47,17 @@ Needs **Node 22.12+** and an interactive terminal (Windows Terminal, PowerShell,
 | | |
 | --- | --- |
 | 🗂️ **File explorer** | Browse your project with file icons and git status (`M` modified, `?` new). Press <kbd>c</kbd> to see only changed files. |
-| 🔀 **Live diffs** | Every edit Nou proposes shows up side by side. <kbd>y</kbd> accepts, <kbd>n</kbd> rejects. Nothing touches disk without you. |
+| 🔀 **Live diffs** | Every edit Nou proposes shows up side by side, and the files it is editing shimmer in the file tree while it works. <kbd>y</kbd> accepts, <kbd>n</kbd> rejects. Nothing touches disk without you. |
 | ✍️ **Built-in editor** | Press <kbd>e</kbd> to edit the open file yourself, with undo/redo and **auto-save**. |
+| 📍 **Shows you where things are** | Ask "where is the LiveKit integration?" and Nou finds it and opens it in the middle panel, jumped to the exact lines and highlighted. Any file a reply mentions (`src/a.ts:12`) is a link: click it. `/open name[:line]` opens a file yourself. |
+| 🎮 **Games for a break** | Add Pong, Snake and Breakout in settings → Games, then `/games` opens a panel docked under the chat: it splits that column instead of covering anything. Drag its title onto the files, code or chat to dock it there, and × at its top right closes it. A game runs only while the panel has the keyboard: Esc goes back to your code and it waits. |
+| 🧠 **A capable engine** | Reads and searches in parallel, numbered reads for exact line references, edits that survive small whitespace mismatches, several edits to a file as one change, a plan for longer tasks, full command output (stderr too) with exit codes and timeouts, retries when a provider is overloaded or a connection drops (Codex too: it picks the turn back up instead of stopping at "Reconnecting..."), and conversation caching with Claude. It follows your repo's `AGENTS.md`, `CLAUDE.md` and `NOU.md` (and `~/.nou/NOU.md`). |
 | 🔎 **Finds its way around** | The agent searches your code (`grep`, `glob`) without asking, reads only what it needs, runs your tests to check its work, and summarizes long conversations to stay within the model's context (`/compact` does it on demand). |
 | ↶ **Undo anything** | Every change, Nou's or yours, is recorded. <kbd>u</kbd> undoes Nou's last edit, `/rewind` undoes its whole last turn, and your own later edits are kept. |
 | 🧾 **Session diffs** | `/diff` shows everything that changed this session, file by file (<kbd>[</kbd> <kbd>]</kbd> to step through). `/sessions` lists earlier sessions and `/diff 2` shows one. |
 | 🩺 **Problems, live** | Syntax errors instantly, plus ESLint, TypeScript, Ruff and language servers when your project has them. Shown in the gutter, inline, and in a <kbd>p</kbd> Problems panel. |
 | 🤖 **Self-correcting** | Nou checks its own edits: you see "⚠ +1 problem" *before* approving, and any problems it introduced are fed back so it fixes them. |
-| 🎨 **Real syntax highlighting** | tree-sitter parsing for 14 languages (TS, JS, Python, Go, Rust, Java, C, JSON, YAML…). |
+| 🎨 **Real syntax highlighting** | tree-sitter parsing for 14 languages (TS, JS, Python, Go, Rust, Java, C, JSON, YAML…), in your choice of theme: One Dark (default), Tokyo Night, GitHub Dark, Dracula, High Contrast or GitHub Light (settings → Preferences → Code colors, with a preview). |
 | 🧭 **Code intelligence** | <kbd>Ctrl</kbd>+<kbd>K</kbd> hover info and <kbd>Ctrl</kbd>+<kbd>G</kbd> go-to-definition via language servers (typescript-language-server, pyright, rust-analyzer, gopls, clangd). |
 | 👀 **Knows what you're looking at** | The open file, visible lines, your cursor and unsaved edits ride along with each message. "Fix this function" just works. |
 | 🌿 **Git aware** | Sees your branch, uncommitted changes and recent commits, and can diff on its own. Press <kbd>v</kbd> to diff any file against `HEAD`. |
@@ -78,21 +81,29 @@ Every change is reviewed like a code review:
 | --- | --- |
 | 🖱️ Mouse | wheel scrolls the pane under the pointer (<kbd>Shift</kbd>+wheel or a tilt wheel: sideways) · click or drag a scrollbar to jump · click a file to open it · **double-click in the code to edit right there** (in the editor: select a word), drag to select · drag a border between panes to resize them (press <kbd>m</kbd> to turn the mouse off and select text in your terminal) |
 | <kbd>PgUp</kbd>/<kbd>PgDn</kbd>, <kbd>Shift</kbd>+<kbd>↑</kbd>/<kbd>↓</kbd> | scroll the chat; scrolled up, new replies wait below instead of yanking the view (<kbd>Ctrl</kbd>+<kbd>End</kbd> jumps back) |
-| <kbd>/</kbd> | start a command from any pane |
+| <kbd>?</kbd> | **every action, searchable**, each with its shortcut (also <kbd>Ctrl</kbd>+<kbd>P</kbd> then `>`) |
+| <kbd>/</kbd> | start a command from any pane: a menu lists every command with what it does (<kbd>↑</kbd>/<kbd>↓</kbd> choose, <kbd>Tab</kbd> complete, <kbd>Enter</kbd> run) |
+| 🖱️ Status bar | click the mode to switch it, `follow` to toggle it, the ✖/▲ counts for the Problems panel, or any shortcut hint to do it · click the model in the header to change it |
 | <kbd>Tab</kbd> | switch between files, code and chat |
 | <kbd>Shift</kbd>+<kbd>Tab</kbd> | ask → auto-edit (edits apply without asking) → auto (commands too); everything stays undoable |
-| <kbd>Ctrl</kbd>+<kbd>P</kbd> | fuzzy-find a file |
+| <kbd>Ctrl</kbd>+<kbd>P</kbd> | fuzzy-find a file; the files you've opened are listed first |
+| <kbd>b</kbd> | back to the previous file (press again to flip back) |
+| <kbd>Ctrl</kbd>+<kbd>F</kbd> | find in the open file: matches are highlighted and counted; <kbd>Enter</kbd>/<kbd>↓</kbd> next, <kbd>↑</kbd> previous, <kbd>Esc</kbd> close |
+| 🗂️ Tabs | every file you open gets a tab over the code: click one to switch, any tab's × to close it, ‹ › for ones that don't fit · <kbd>[</kbd>/<kbd>]</kbd> previous/next · <kbd>x</kbd> or <kbd>Ctrl</kbd>+<kbd>W</kbd> close |
+| <kbd>Ctrl</kbd>+click | on a name in the code (or <kbd>Option</kbd>+click, or right-click): go to its definition; an imported name goes to its import, and the import's path opens that file |
 | <kbd>e</kbd> or a double-click | edit the open file (see the editor keys below) |
 | <kbd>p</kbd> | Problems panel: every error and warning, <kbd>Enter</kbd> jumps to it |
 | <kbd>u</kbd> | undo Nou's last edit |
 | <kbd>v</kbd> | diff the open file vs git `HEAD`, Nou's last edit, or this session · <kbd>n</kbd>/<kbd>N</kbd> jump between changes · <kbd>[</kbd>/<kbd>]</kbd> previous/next file in a session diff |
 | <kbd>c</kbd> | in the file tree: show only changed files |
-| <kbd>f</kbd> | follow mode (off by default): jump to files as Nou reads and edits them |
+| <kbd>f</kbd> | follow mode (off by default): watch along as Nou works. Each file it reads (the exact lines, highlighted) is shown a step at a time, a little behind it, and its edits as they happen. The status bar shows how many steps behind it is; set the speed in settings → Preferences (slow · normal · fast · instant) |
 | <kbd>&lt;</kbd> / <kbd>&gt;</kbd> / <kbd>=</kbd> | make the focused pane narrower / wider / reset the layout |
-| <kbd>m</kbd> | mouse on/off, so you can select and copy text in the terminal |
+| <kbd>`</kbd> | a terminal under the code, like VS Code's (also `/terminal`): Enter runs a command, Ctrl+C stops it, ↑↓ history, Esc back to the code, × closes it. Commands run through your shell one at a time, so full-screen programs like vim don't draw there |
+| <kbd>m</kbd> | mouse on/off, so you can select and copy text in the terminal (in the chat, just drag over the text: it's copied when you let go) |
 | <kbd>s</kbd> | settings: model, preferences, plugins |
 | <kbd>y</kbd> / <kbd>n</kbd> | accept / reject a proposed edit or command, from any pane; the rest of Nou keeps working while it waits (<kbd>o</kbd> shows the edit) |
-| <kbd>Esc</kbd> | stop Nou · close a diff · back to chat |
+| <kbd>Enter</kbd> while Nou works | queue the message: it goes when Nou finishes, together with anything else you queued, as one message (<kbd>Alt</kbd>+<kbd>Enter</kbd>: stop Nou and send it now) |
+| <kbd>Esc</kbd> | stop Nou (anything queued goes back in the input) · close a diff · back to chat |
 | <kbd>Ctrl</kbd>+<kbd>C</kbd> | stop Nou while it works · press twice to quit |
 
 In the editor:
@@ -109,7 +120,11 @@ In the editor:
 | <kbd>Ctrl</kbd>+<kbd>K</kbd> · <kbd>Ctrl</kbd>+<kbd>G</kbd> | hover info · go to definition (with a language server) |
 | <kbd>Esc</kbd> | clear the selection, or leave the editor |
 
-Chat commands: `/settings` · `/model [provider:model]` · `/models [provider]` · `/pull <model>` · `/engine [name]` · `/auto [ask|auto-edit|auto]` · `/copy [code|file]` · `/undo` · `/rewind` · `/history` · `/diff [file or n]` · `/sessions` · `/problems` · `/compact` · `/clear` · `/help`
+Chat commands: `/settings` · `/model [provider:model]` · `/models [provider]` · `/pull <model>` · `/engine [name]` · `/auto [ask|auto-edit|auto]` · `/copy [code|file]` · `/undo` · `/rewind` · `/history` · `/diff [file or n]` · `/sessions` · `/problems` · `/compact` · `/clear` · `/resume [n|last]` · `/terminal` · `/help`
+
+New lines in a message: <kbd>Shift</kbd>/<kbd>Ctrl</kbd>/<kbd>Cmd</kbd>+<kbd>Enter</kbd> in terminals that report them (kitty, Ghostty, WezTerm, iTerm2 and others with the kitty keyboard protocol), or type `\` and press <kbd>Enter</kbd> in any terminal.
+
+Conversations are saved per folder after each reply. `/resume` lists them and `/resume 2` (or `nou --continue` for the last one, `nou --resume` for the list) picks one back up with the engine it was on: Nou's own engine restores its messages, Claude Code its session and Codex its thread; pi is handed the conversation so far. Sessions you started in Claude Code's or Codex's own CLI in this folder are listed too (marked "CLI"), and resuming one carries it on in that engine inside Nou.
 
 ## 🧠 Models
 
@@ -165,6 +180,20 @@ nou --version
 
 Set `NOU_NO_UPDATE_CHECK=1` to turn the check off.
 
+## 🔌 MCP servers and browser control
+
+Nou's engine can use tools from [MCP](https://modelcontextprotocol.io) servers: a browser, GitHub, your database...
+
+- **Already use some?** Nou finds the MCP servers you've set up in Claude Code, Claude Desktop, Cursor, Windsurf, VS Code, Gemini CLI and Codex, and offers them on start: `/mcp import` brings them over, with their settings. (Your Claude Code and Codex API keys are picked up too; see *Use Claude Code / Codex keys* in settings.)
+- **Browser control:** `/mcp add browser` adds [Playwright's MCP server](https://github.com/microsoft/playwright-mcp), so you can ask Nou to open a page, click through it, fill a form or check what your app shows.
+- **Your own:** `/mcp add <name> <command and arguments>` or `/mcp add <name> <url>`; `/mcp` lists them and their status, `/mcp remove <name>` removes one. They live in `~/.nou/mcp.json` (same format as Claude Code and Cursor); a project's `.mcp.json` is used too, in folders you trust.
+
+Tools that say they only read run on their own; any other MCP tool asks you first, like Nou's edits and commands. A server's own output never reaches Nou's screen.
+
+## 🔒 Trusting a folder
+
+The first time you open a folder, Nou asks whether you trust its files: it reads them, and can run the folder's MCP servers and plugins. Say no and Nou doesn't open it. Trusted folders are listed in `~/.nou/config.json`.
+
 ## 🧩 Plugins *(early)*
 
 **Starter plugins** ship with Nou and are optional: open <kbd>s</kbd> settings → **Plugins** and press Enter on one, or type `/plugins add <name>`. Adding one copies it into `~/.nou/plugins/`, where it's yours to edit.
@@ -207,7 +236,17 @@ npm run screenshot   # regenerate docs/screenshot.svg
 npm run eval         # how well the agent does real tasks with a real model (see evals/)
 ```
 
-Releasing: bump `version` in `package.json`, merge to `master`, then run **Actions → Publish to npm**. It tests, publishes with provenance, and creates the git tag and GitHub Release. (Or publish a GitHub release tagged `vX.Y.Z`.) The token lives in the `production` environment as `NPM_TOKEN`.
+### Releasing
+
+**Always bump the version first.** npm never accepts the same version twice, so publishing without a bump fails with *"nou-cli@X.Y.Z is already published. Bump "version" in package.json first."* Every release goes:
+
+1. **Bump the version** in a PR: `npm version patch --no-git-tag-version` (or `minor` / `major`), which updates `package.json` and `package-lock.json` together. Patch (0.5.1 → 0.5.2) for fixes and small features, minor (0.5 → 0.6) for bigger ones.
+2. **Merge it** to `master` once CI is green.
+3. **Run Actions → Publish to npm** (Run workflow on `master`), then **approve** the `production` environment when GitHub asks. It tests, publishes with provenance, and creates the `vX.Y.Z` git tag and GitHub Release. (Publishing a GitHub release tagged `vX.Y.Z` does the same, taking the version from the tag.)
+
+The npm token lives in the `production` environment as `NPM_TOKEN`. Check what's live with `npm view nou-cli version`.
+
+The workflows run on the actions' Node 24 versions (`actions/checkout@v5`, `actions/setup-node@v5`, `codeql-action@v4`), so GitHub's Node 20 deprecation warning no longer applies; Dependabot keeps them current. Jobs run on `ubuntu-latest`, which GitHub moves to Ubuntu 26 from October 19, 2026: nothing to change for that.
 
 Upkeep runs on its own:
 - **CI** on every PR: type-check, lint, build, unit and end-to-end tests on Linux, macOS and Windows (Node 22.12 and 24 too), plus installing the packed tarball to check the package works.

package/dist/index.js

@@ -1,103 +1,13 @@
 #!/usr/bin/env node
 // Must stay the first import: loads .env before any provider reads its keys and URLs.
 import "./src/env.js";
-import { createElement } from "react";
-import { render } from "ink";
-import * as p from "@clack/prompts";
-import chalk from "chalk";
-import { artWork } from "./src/util/index.js";
-import { ensureProjectContext, loadPermanentContext } from "./src/context/index.js";
-import { describe, initialModel, resolveModel, saveModel } from "./src/providers/index.js";
-import { loadSettings } from "./src/config/index.js";
-import { loadCredentials } from "./src/config/credentials.js";
-import { borrowToolConfig, ensureLocalModel, pickStartingModel } from "./src/setup/index.js";
-import { checkForUpdate, currentVersion, installUpdate, relaunch } from "./src/update/index.js";
-import { lsp } from "./src/lsp/index.js";
-import { App } from "./src/ui/App.js";
-import { installFastOutput } from "./src/ui/fast-output.js";
-import { RENDER_OPTIONS } from "./src/ui/render-options.js";
-const HELP = `nou ${currentVersion()}: an AI coding assistant for your terminal
-
-Usage:
-  nou              open Nou in the current folder
-  nou update       update to the latest version
-  nou --version    print the version
-  nou --help       show this help
-
-Settings live in ~/.nou/config.json (or press s inside Nou); keys you enter there, or with /connect, in ~/.nou/credentials.json. Set NOU_NO_UPDATE_CHECK=1 to skip update checks.`;
-async function main() {
-    const args = process.argv.slice(2);
-    if (args.includes("--version") || args.includes("-v")) {
-        console.log(currentVersion());
-        return;
-    }
-    if (args.includes("--help") || args.includes("-h")) {
-        console.log(HELP);
-        return;
-    }
-    if (args[0] === "update") {
-        const latest = await checkForUpdate({ force: true, timeout: 10_000 });
-        if (!latest) {
-            console.log(`nou ${currentVersion()} is up to date.`);
-            return;
-        }
-        console.log(`Updating nou ${currentVersion()} → ${latest}...`);
-        if (await installUpdate(latest))
-            process.exit(0);
-        if (process.platform !== "win32")
-            console.log("If that was a permissions error, run: sudo npm install -g nou-cli@latest");
-        process.exit(1);
-    }
-    if (!process.stdin.isTTY) {
-        console.error("Nou needs an interactive terminal (try Windows Terminal, PowerShell, or Terminal/iTerm on macOS).");
-        process.exit(1);
-    }
-    p.intro(chalk.cyan(`${artWork} \n Hello I am Nou! 🌞  ${chalk.dim(`v${currentVersion()}`)}`));
-    const latest = await checkForUpdate();
-    if (latest) {
-        const update = await p.confirm({ message: `Nou ${chalk.green(latest)} is available (you have ${currentVersion()}). Update now?` });
-        if (update === true) {
-            const ok = await installUpdate(latest);
-            if (ok) {
-                p.log.success(`Updated to ${latest}. Restarting...`);
-                relaunch();
-                return;
-            }
-            p.log.warn(process.platform === "win32"
-                ? "The update failed. You can retry later with: npm install -g nou-cli@latest"
-                : "The update failed. If it was a permissions error, run: sudo npm install -g nou-cli@latest");
-        }
-    }
-    const settings = loadSettings();
-    loadCredentials(); // keys entered inside Nou, for whatever the environment and .env leave unset
-    const borrowed = settings.reuseToolConfig ? borrowToolConfig() : [];
-    for (const b of borrowed)
-        p.log.info(`Using the ${b.provider === "anthropic" ? "Anthropic" : "OpenAI"} API key from your ${b.tool} settings.`);
-    let choice = initialModel();
-    // First run: start with a model that's already here, if there is one.
-    if (!process.env.NOU_MODEL && !settings.model) {
-        const picked = await pickStartingModel(borrowed);
-        if (picked) {
-            choice = picked;
-            saveModel(picked);
-        }
-    }
-    const problem = choice.provider.unavailable();
-    if (problem) {
-        p.log.warn(`${choice.provider.label} isn't set up (${problem}), falling back to local Ollama.`);
-        choice = resolveModel("ollama");
-    }
-    const ready = await ensureLocalModel(choice);
-    if (ready !== choice)
-        saveModel(ready); // picked a model that's already installed instead
-    choice = ready;
-    p.log.info(`Model: ${chalk.yellow(describe(choice))}  (change it any time with /model)`);
-    await ensureProjectContext(choice);
-    const permContext = await loadPermanentContext();
-    await installFastOutput();
-    const app = render(createElement(App, { initialModel: choice, permContext }), RENDER_OPTIONS);
-    await app.waitUntilExit();
-    lsp.stopAll();
-    p.outro(chalk.cyan("Bye bye!"));
+import { installFastWidth } from "./src/ui/fast-width.js";
+// Answered before loading the rest, which takes most of a second.
+if (process.argv[2] === "--version" || process.argv[2] === "-v") {
+    const { currentVersion } = await import("./src/update/index.js");
+    console.log(currentVersion());
+    process.exit(0);
 }
-main().catch(console.error);
+// Ink's text measuring has to be swapped before Ink loads, so everything else is imported after it.
+installFastWidth();
+await import("./src/cli.js");

package/dist/src/agent/index.js

@@ -1,11 +1,29 @@
 import { randomUUID } from "crypto";
+import { existsSync, statSync } from "fs";
 import { toolDefs } from "../tools/index.js";
-import { applyChange, capOutput, fileTree, isInProject, proposeEdit, proposeWrite, readForModel, runCommand, toRelative, } from "../commands/index.js";
+import { applyChange, capOutput, fileTree, isInProject, proposeEdit, proposeEdits, proposeWrite, readForModel, runCommand, toRelative, } from "../commands/index.js";
 import { describe, keyHint } from "../providers/index.js";
 import { newCallId } from "../providers/ids.js";
 import { globFiles, grep } from "../search/index.js";
 /** Model requests per user message before stopping; real tasks (explore, edit, test, fix) take a few dozen. */
 const MAX_STEPS = 60;
+/** Tries per model request when it fails for a passing reason (see withRetries). */
+const RETRIES = 6;
+/** Errors worth retrying: overloaded, rate limited, a server error, a dropped or timed-out connection. */
+function transient(error) {
+    const status = Number(error?.status ?? error?.statusCode);
+    if (status === 408 || status === 409 || status === 429 || status >= 500)
+        return true;
+    if (status >= 400)
+        return false;
+    return transientMessage(String(error?.message ?? error));
+}
+/** Whether an error's text reads as a passing problem (a dropped stream, a busy or failing server). */
+export function transientMessage(text) {
+    if (/ECONNREFUSED|ENOTFOUND|EAI_AGAIN|Invalid URL|api key|unauthori[sz]ed|\b40[13]\b/i.test(text))
+        return false;
+    return /overloaded|rate.?limit|too many requests|ECONNRESET|socket hang up|ETIMEDOUT|timed? ?out|EPIPE|network|premature close|terminated|disconnected|server had an error|internal server error|service unavailable|bad gateway|try again|\b(429|5\d\d)\b/i.test(text);
+}
 /** Messages kept word for word when older ones are summarized. */
 const KEEP_RECENT = 8;
 const TRIMMED_OUTPUT = "\n[... trimmed to save context; run the tool again if you need it]";
@@ -24,6 +42,13 @@ How to work:
 4. Keep going until the task is done. The user approves each edit and command as it happens, so don't stop to ask permission between steps; ask only when the request is unclear or you need a decision.
 5. End with a short summary of what you changed and why. When the user only asks a question, answer it without editing anything.
 
+- Make independent calls together: several reads or searches in one response run at the same time.
+- Use grep, glob and read_file to look around, not run_command with grep, find or cat. Several edits to one file go in one multi_edit.
+- If an edit fails twice, read the file again before the next try.
+- For work with three or more steps, keep a plan with update_plan and update it as you go.
+- Don't commit, push, install packages or delete files unless the user asked. Don't add comments the code didn't need.
+- Before saying something works, check it (run the tests or the code). If you couldn't, say so.
+- When the user asks where something is, or to show, open or find something, search for it (grep, glob), read enough to be sure, then call open_file on the exact place (with line and end_line) so it opens in their code view, and answer in a sentence or two with path:line.
 - If the user rejects an edit or command, don't retry it: ask what they would like instead.
 - Keep replies short. Refer to code as path:line.
 
@@ -66,6 +91,11 @@ export class Agent {
         this.hooks = hooks;
     }
     configure(options) {
+        // A different system prompt or tool list (an MCP server connected, a plugin switched) changes what the
+        // earlier thinking was written against: newer Claude models reject replaying it, so it's dropped.
+        const toolsChanged = options.extraTools && options.extraTools.map((t) => t.definition.name).join() !== this.extraTools.map((t) => t.definition.name).join();
+        if (this.messages.length && ((options.system !== undefined && options.system !== this.system) || toolsChanged))
+            this.forgetThinking();
         if (options.system !== undefined)
             this.system = options.system;
         if (options.extraTools)
@@ -84,6 +114,24 @@ export class Agent {
         this.messages = [];
         this.notes = [];
     }
+    /** Forgets the last message you sent and everything after it, as if it was never sent. */
+    snapshot() {
+        return { messages: this.messages };
+    }
+    restore(state) {
+        if (!Array.isArray(state?.messages))
+            return false;
+        this.messages = state.messages;
+        this.forgetThinking(); // written in another run, maybe with another model
+        return true;
+    }
+    retractLast() {
+        const at = this.messages.findLastIndex((m) => m.role === "user");
+        if (at < 0)
+            return false;
+        this.messages = this.messages.slice(0, at);
+        return true;
+    }
     /** Something the model should know before the next message (e.g. the user undid its edit). */
     note(text) {
         this.notes.push(text);
@@ -123,6 +171,8 @@ export class Agent {
                 trimmed++;
             }
         }
+        if (trimmed)
+            this.forgetThinking();
         if (!force && this.requestSize() <= budget * 0.8) {
             this.hooks.onEntry({ kind: "info", text: `Trimmed ${trimmed} old tool outputs to fit the model's context.` });
             return true;
@@ -140,6 +190,7 @@ export class Agent {
                 throw error;
             summary = `(The earlier conversation was dropped to fit the context; summarizing it failed: ${error.message})`;
         }
+        this.forgetThinking();
         const intro = `[Summary of the conversation so far]\n${summary}`;
         const rest = this.messages.slice(split);
         const first = rest[0];
@@ -152,6 +203,26 @@ export class Agent {
         });
         return true;
     }
+    /**
+     * Drops Claude's thinking blocks from the history. Newer Claude models reject a conversation whose
+     * earlier turns were edited while it still carries their thinking blocks (they're tied to the exact
+     * history they were written in), and trimming or summarizing is such an edit. Without them the model
+     * carries on from the visible text and tool calls, which is what the trimmed history holds anyway.
+     */
+    forgetThinking() {
+        this.messages = this.messages.map((m) => {
+            if (m.role !== "assistant" || m.raw?.provider !== "anthropic" || !Array.isArray(m.raw.data))
+                return m;
+            const kept = m.raw.data.filter((b) => b.type !== "thinking" && b.type !== "redacted_thinking");
+            if (kept.length === m.raw.data.length)
+                return m;
+            if (kept.length)
+                return { ...m, raw: { ...m.raw, data: kept } };
+            const plain = { ...m };
+            delete plain.raw;
+            return plain;
+        });
+    }
     /**
      * Where to cut the history for a summary: as late as possible while keeping the last few messages, and
      * only before a user or assistant message, so no tool call is separated from its result.
@@ -198,22 +269,35 @@ export class Agent {
         this.controller = new AbortController();
         const { signal } = this.controller;
         try {
+            let cutOff = 0;
             for (let step = 0; step < MAX_STEPS; step++) {
                 if (this.requestSize() > this.contextBudget())
                     await this.compact(false, signal);
                 this.hooks.onBusy(`Pondering with ${describe(this.choice)}...`);
                 let streamed = "";
-                const result = await this.choice.provider.chat({
-                    model: this.choice.model,
-                    system: this.system,
-                    messages: this.messages,
-                    tools: this.tools,
-                    signal,
-                    ...(this.effort ? { effort: this.effort } : {}),
-                    onText: (delta) => {
-                        streamed += delta;
-                        this.hooks.onStream(streamed);
-                    },
+                let thought = "";
+                const result = await this.withRetries(signal, () => {
+                    streamed = "";
+                    thought = "";
+                    return this.choice.provider.chat({
+                        model: this.choice.model,
+                        system: this.system,
+                        messages: this.messages,
+                        tools: this.tools,
+                        signal,
+                        ...(this.effort ? { effort: this.effort } : {}),
+                        onText: (delta) => {
+                            streamed += delta;
+                            this.hooks.onStream(streamed);
+                        },
+                        // Its thinking shows on the one-line progress (the latest of it), so the chat doesn't jump.
+                        onThinking: (delta) => {
+                            thought = (thought + delta).slice(-400);
+                            const latest = thought.split("\n").map((l) => l.trim()).filter(Boolean).at(-1) ?? "";
+                            if (latest)
+                                this.hooks.onBusy(`Thinking: ${latest.length > 90 ? `…${latest.slice(-89)}` : latest}`);
+                        },
+                    });
                 });
                 this.hooks.onStream("");
                 // Tool-call ids must be unique across the conversation (results are matched by id, and some APIs
@@ -241,30 +325,51 @@ export class Agent {
                     return;
                 }
                 if (result.stop === "max_tokens") {
-                    this.hooks.onEntry({ kind: "error", text: "The response was cut off before its tool call finished. Try asking for a smaller change." });
-                    this.dropUnansweredCalls();
-                    return;
+                    // The reply ran out of room mid tool call (usually a whole file in one write): tell the model and
+                    // let it try in smaller pieces, a couple of times, before giving up.
+                    if (++cutOff > 2) {
+                        this.hooks.onEntry({ kind: "error", text: "The response was cut off before its tool call finished, again. Try asking for a smaller change." });
+                        this.dropUnansweredCalls();
+                        return;
+                    }
+                    for (const call of result.toolCalls) {
+                        this.messages.push({ role: "tool", callId: call.id, name: call.name, isError: true,
+                            content: "Not run: your response hit the output limit before this call was complete. Make the change in smaller steps (edit_file or multi_edit with only the lines that change, not the whole file)." });
+                    }
+                    continue;
                 }
                 if (result.toolCalls.length === 0)
                     return;
-                for (const call of result.toolCalls) {
-                    if (signal.aborted)
-                        break;
-                    this.hooks.onBusy(`Running ${call.name}...`);
-                    const problem = invalidArgs(call, this.tools);
-                    const output = problem ?? capOutput(await this.runTool(call));
-                    this.messages.push({
-                        role: "tool",
-                        callId: call.id,
-                        name: call.name,
-                        content: problem ? `Error: ${problem}` : output,
-                        ...(problem ? { isError: true } : {}),
+                // Calls that only look (reads, searches) run together; the rest run one at a time, in order,
+                // since they may ask you first or change what a later call sees. Results keep the calls' order.
+                const calls = result.toolCalls;
+                for (let i = 0; i < calls.length && !signal.aborted;) {
+                    let j = i + 1;
+                    if (this.onlyLooks(calls[i]))
+                        while (j < calls.length && this.onlyLooks(calls[j]))
+                            j++;
+                    const batch = calls.slice(i, j);
+                    this.hooks.onBusy(batch.length > 1 ? `Running ${batch.length} tools...` : `Running ${batch[0].name}...`);
+                    const outputs = await Promise.all(batch.map(async (call) => {
+                        const problem = invalidArgs(call, this.tools);
+                        return problem ? { error: `Error: ${problem}` } : { output: capOutput(await this.runTool(call)) };
+                    }));
+                    batch.forEach((call, k) => {
+                        const out = outputs[k];
+                        this.messages.push({
+                            role: "tool",
+                            callId: call.id,
+                            name: call.name,
+                            content: "error" in out ? out.error : out.output,
+                            ...("error" in out ? { isError: true } : {}),
+                        });
                     });
+                    i = j;
                 }
                 if (signal.aborted)
                     throw new Error("aborted");
             }
-            this.hooks.onEntry({ kind: "error", text: `Stopped after ${MAX_STEPS} steps.` });
+            this.hooks.onEntry({ kind: "error", text: `Paused after ${MAX_STEPS} steps so it doesn't run away. Say "continue" to let it carry on.` });
         }
         catch (error) {
             this.hooks.onStream("");
@@ -296,6 +401,40 @@ export class Agent {
             }
         }
     }
+    /**
+     * Runs a model request again when it failed for a passing reason (overloaded, rate limited, a server
+     * error, a dropped connection), waiting longer each time. Setup problems (a bad key, a URL that doesn't
+     * answer) fail straight away: waiting won't fix them, and the app shows where to.
+     */
+    async withRetries(signal, request) {
+        for (let attempt = 1;; attempt++) {
+            try {
+                return await request();
+            }
+            catch (error) {
+                if (signal.aborted || attempt >= RETRIES || !transient(error))
+                    throw error;
+                const after = Number(error?.headers?.get?.("retry-after") ?? error?.headers?.["retry-after"]);
+                const wait = Math.min(30_000, after > 0 ? after * 1000 : 1000 * 2 ** (attempt - 1) + Math.random() * 500);
+                this.hooks.onStream("");
+                this.hooks.onBusy(`${describe(this.choice)}: ${String(error?.message ?? error).slice(0, 60)}. Retrying in ${Math.ceil(wait / 1000)}s (${attempt}/${RETRIES - 1})...`);
+                await new Promise((resolve) => {
+                    const timer = setTimeout(resolve, wait);
+                    signal.addEventListener("abort", () => (clearTimeout(timer), resolve()), { once: true });
+                });
+                if (signal.aborted)
+                    throw error;
+            }
+        }
+    }
+    /** Tools that only read, which can run alongside each other. */
+    onlyLooks(call) {
+        if (["grep", "glob", "list_files", "get_file_tree"].includes(call.name))
+            return true;
+        if (call.name === "read_file")
+            return typeof call.args.path === "string" && isInProject(call.args.path);
+        return this.extraTools.some((t) => t.definition.name === call.name && t.readOnly);
+    }
     async runTool(call) {
         const { name, args } = call;
         try {
@@ -309,11 +448,25 @@ export class Agent {
                         }
                     }
                     else {
-                        this.hooks.onRead(toRelative(args.path));
+                        const from = Number(args.offset) > 1 ? Math.floor(Number(args.offset)) : undefined;
+                        const count = Number(args.limit) > 0 ? Math.floor(Number(args.limit)) : undefined;
+                        this.hooks.onRead(toRelative(args.path), from ?? (count ? 1 : undefined), count ? (from ?? 1) + count - 1 : undefined);
                     }
                     this.hooks.onEntry({ kind: "tool", text: `Read ${args.path}` });
                     return await readForModel(args.path, args.offset, args.limit);
                 }
+                case "open_file": {
+                    const file = toRelative(String(args.path));
+                    if (!isInProject(file))
+                        return "Error: only files in the project can be shown.";
+                    if (!existsSync(file) || !statSync(file).isFile())
+                        return `Error: ${file} is not a file. Find it with glob first.`;
+                    const line = Number(args.line) > 0 ? Math.floor(Number(args.line)) : undefined;
+                    const to = line && Number(args.end_line) >= line ? Math.floor(Number(args.end_line)) : line;
+                    this.hooks.onOpen?.(file, line, to);
+                    this.hooks.onEntry({ kind: "tool", text: `Opened ${file}${line ? `:${line}${to && to !== line ? `-${to}` : ""}` : ""}` });
+                    return this.hooks.onOpen ? "It is now open in the user's code view." : "This interface can't show files; give the user the path instead.";
+                }
                 case "list_files":
                 case "get_file_tree": {
                     this.hooks.onEntry({ kind: "tool", text: `Listed ${args.path ?? "."}` });
@@ -335,12 +488,21 @@ export class Agent {
                     return globFiles(String(args.pattern), typeof args.path === "string" ? args.path : ".");
                 }
                 case "edit_file":
+                case "multi_edit":
                 case "write_file": {
+                    if (name === "multi_edit" && (!Array.isArray(args.edits) || !args.edits.length))
+                        return "Error: edits must be a list of {old_string, new_string}.";
                     const change = name === "edit_file"
                         ? await proposeEdit(args.path, args.old_string, args.new_string, args.replace_all === true)
-                        : await proposeWrite(args.path, args.content ?? "");
+                        : name === "multi_edit" ? await proposeEdits(args.path, args.edits) : await proposeWrite(args.path, args.content ?? "");
                     return await this.reviewChange(change);
                 }
+                case "update_plan": {
+                    const steps = Array.isArray(args.steps) ? args.steps : [];
+                    const mark = { done: "✓", in_progress: "▸", pending: "○" };
+                    this.hooks.onEntry({ kind: "tool", text: `Plan:\n${steps.map((st) => `${mark[st.status] ?? "○"} ${st.step}`).join("\n")}` });
+                    return "Plan updated.";
+                }
                 case "run_command": {
                     const ok = await this.hooks.approve({ kind: "command", command: args.command });
                     if (!ok) {
@@ -348,7 +510,9 @@ export class Agent {
                         return "User denied permission to run this command.";
                     }
                     this.hooks.onEntry({ kind: "tool", text: `Ran: ${args.command}` });
-                    const output = await runCommand(args.command);
+                    // Timeouts are in seconds; a model that sends milliseconds still gets a sensible limit.
+                    const seconds = Number(args.timeout) > 0 ? Number(args.timeout) : 0;
+                    const output = await runCommand(args.command, seconds ? (seconds > 3600 ? seconds : seconds * 1000) : undefined, this.controller?.signal);
                     return output.trim() || "(no output)";
                 }
                 default: {
@@ -378,10 +542,12 @@ export class Agent {
             return "User rejected this change. Ask them what they would like instead.";
         }
         const result = await applyChange(change);
-        this.hooks.onChange(change, "applied", this.turnId);
         this.hooks.onEntry({ kind: "tool", text: result });
-        if (result.startsWith("Failed"))
+        if (result.startsWith("Failed")) {
+            this.hooks.onChange(change, "rejected", this.turnId);
             return result;
+        }
+        this.hooks.onChange(change, "applied", this.turnId);
         this.hooks.onBusy(`Checking ${change.path} for problems...`);
         const problems = await this.hooks.checkChange?.(change).catch(() => null);
         if (problems)