nou-cli 0.5.4 → 0.5.10

package/README.md

@@ -50,9 +50,11 @@ Needs **Node 22.12+** and an interactive terminal (Windows Terminal, PowerShell,
 | 🔀 **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. |
+| 🪟 **Workspaces** | Several projects in one window, a tab each in the header: click **+** (or `/workspace new ../api`) and the other folder opens beside this one with its own files, chats and agents. Click a tab (or `/workspace 2`) to switch; the ones in the background keep working, and a tab shows ● while its agent is busy. Quitting one (Ctrl+C twice) closes its tab. The first time, Nou installs a small pseudo-terminal package ([@lydell/node-pty](https://www.npmjs.com/package/@lydell/node-pty), prebuilt for macOS, Linux and Windows) and reopens as a workspaces window, with your conversation in the first tab. Or start that way: `nou --workspaces . ../api`. |
 | 🗂️ **Several agents at once** | `/new` (or **+** in the chat's title) opens another conversation tab while the first keeps working. Each tab has its own agent and history; a working tab shows ●, one waiting for your OK shows !, and a click (or `/tab 2`) switches. `/close` closes one; it stays in `/resume`. |
-| 🧑‍🏫 **Show me how** | `/showme add a --verbose flag` and Nou finds where the change goes, then walks you through typing it yourself: each step opens the file at the right line, says why, and shows the code to type dim ahead of your cursor, like autocomplete (<kbd>Tab</kbd> fills in a line). It moves on when what you typed matches, and saves as it goes. `/showme next` skips a step, `/showme stop` ends it. Works with every engine (Nou's, Claude Code, Codex and pi): any edit one makes anyway is put back. `/teach` does the same. |
-| 🎮 **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. Drag its top edge to make it taller or shorter. A game runs only while the panel has the keyboard: Esc goes back to your code and it waits. |
+| 👀 **Show me** | Ask how something works or where it happens (`/showme where do we check the login?`, or just ask) and Nou explains it with the code open: each place it talks about opens in the code view, highlighted, and they're listed in the chat to click. `/showme next` and `/showme back` step through them. Works with every engine: Nou's points at places with a tool, and Claude Code, Codex and pi are asked to list them at the end of their reply, which Nou reads and hides. |
+| 🧑‍🏫 **Teach me** | `/teach add a --verbose flag` and Nou finds where the change goes, then walks you through typing it yourself: each step opens the file at the right line, says why, and shows the code to type dim ahead of your cursor, like autocomplete (<kbd>Tab</kbd> fills in a line). It moves on when what you typed matches, and saves as it goes. `/teach next` skips a step, `/teach stop` ends it. Works with every engine (Nou's, Claude Code, Codex and pi): any edit one makes anyway is put back. |
+| 🎮 **Games for a break** | Add Pong, Snake, Breakout (it gets faster each wall you clear), Dodge, Hop and Pairs 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. Drag its top edge to make it taller or shorter. A game runs only while the panel has the keyboard: Esc goes back to your code and it waits. Your best score in each is kept, and a panel too small for a game says how much room it needs. |
 | 🧠 **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. |
@@ -64,9 +66,12 @@ Needs **Node 22.12+** and an interactive terminal (Windows Terminal, PowerShell,
 | 👀 **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`. |
 | 🔌 **Any model** | Local (Ollama, LM Studio, llama.cpp) or cloud (Claude, OpenAI, Gemini, OpenRouter, Groq, DeepSeek). Switch mid-conversation. |
+| 🎚️ **Speed vs smarts** | Pick how hard the model thinks in plain words: **Fastest** and **Fast** (cheaper + faster), **Balanced** (the default), **Smarter** and **Smartest** (thinks longer, costs more). In <kbd>s</kbd> settings, or `/effort smarter`. |
 | 🛞 **Pick your agent** | Nou's own, or Claude Code, Codex or pi, switchable like models, with the same diffs, approvals and undo. |
 | 🧩 **Plugins** | Add your own tools and slash commands with a single file. |
 | 🔎 **Quick open** | <kbd>Ctrl</kbd>+<kbd>P</kbd> fuzzy-finds any file. |
+| 🔋 **Easy on your battery** | Idle, Nou uses next to no CPU. When its window is in the background (in terminals that report focus: iTerm2, Terminal.app, kitty, Ghostty, WezTerm, Windows Terminal, VS Code), spinners and git polling pause until you come back, and TypeScript checks are incremental. |
+| 👓 **Easy to read** | Hints and secondary text keep at least 4.5:1 contrast. Nou asks your terminal whether its background is light or dark and picks matching colors (code switches to GitHub Light on a light background); set it yourself in <kbd>s</kbd> settings → **Nou's colors**. |
 
 Every change is reviewed like a code review:
 
@@ -100,12 +105,14 @@ Every change is reviewed like a code review:
 | <kbd>c</kbd> | in the file tree: show only changed files |
 | <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>`</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; drag its top border (or <kbd>Alt</kbd>+↑/↓) to make it taller or shorter. Commands run through your shell one at a time, so full-screen programs like vim don't draw there |
+| <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, × or `exit` closes it; drag its top border (or <kbd>Alt</kbd>+↑/↓) to make it taller or shorter. Commands run through your shell one at a time, so full-screen programs like vim don't draw there |
+| <kbd>z</kbd> | in the code view: fold every function and block to its first line, or open them all again (also `/fold`, `/unfold`); click a ▾/▸ beside a line number to fold or open just that one |
+| <kbd>Ctrl</kbd>+<kbd>L</kbd> | draw the whole screen again (also `/redraw`), if it ever looks shifted or clicks land a row off. Output from libraries goes to `~/.nou/nou.log` instead of the screen |
 | <kbd>Ctrl</kbd>+<kbd>O</kbd> | in the chat: open or fold every "▸ N steps" line (what the agent read and ran between replies folds into one; click one to open just it) |
-| <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>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; double-click copies a word, path or link, triple-click a paragraph) |
 | <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>Enter</kbd> while Nou works | queue the message: it goes when Nou finishes, together with anything else you queued, as one message; commands that only change the screen, like `/terminal`, `/games` or `/open`, run right away (<kbd>Alt</kbd>+<kbd>Enter</kbd>: stop Nou and send it now) |
+| <kbd>Enter</kbd> while Nou works | queue the message: it goes when Nou finishes, together with anything else you queued, as one message; commands that only change the screen, like `/terminal`, `/games` or `/open`, run right away. To send now instead of waiting: <kbd>Alt</kbd>+<kbd>Enter</kbd> (stops Nou and sends it), click the queued message, or `/now`; or turn on **Send while Nou works** in settings so <kbd>Enter</kbd> sends right away (<kbd>Alt</kbd>+<kbd>Enter</kbd> then queues) |
 | <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 |
 
@@ -123,11 +130,13 @@ 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` · `/resume [n|last]` · `/terminal` · `/showme <what you want>` · `/help`
+Chat commands: `/settings` · `/model [provider:model]` · `/models [provider]` · `/pull <model>` · `/engine [name]` · `/effort [fastest|fast|balanced|smarter|smartest]` · `/auto [ask|auto-edit|auto]` · `/copy [code|file]` · `/undo` · `/rewind` · `/history` · `/diff [file or n]` · `/sessions` · `/problems` · `/compact` · `/clear` · `/resume [n|last]` · `/terminal` · `/workspace [new <folder> | n]` · `/now` · `/showme <question>` · `/teach <change>` · `/help`
+
+A small typo in a command still works when it only changes the screen (`/termnial` opens the terminal); for others Nou asks "Did you mean...?" instead of guessing.
 
 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.
+Conversations are saved per folder after each reply. `/resume` opens a picker (↑↓ and Enter, type to filter, or type its number) 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
 
@@ -170,6 +179,8 @@ The engine is the agent that answers in the chat. Nou's own works with every mod
 | `pi` | your Nou model, local or cloud | ✅ |
 | `codex` (Codex SDK) | OpenAI; your API key or ChatGPT login | ❌ edits in its sandbox; review and undo after |
 
+Codex's sandbox can write to the project and the repo's `.git` (so it can commit, stash and pull) and reach the network.
+
 Other engines install on first use into `~/.nou/engines/`, so Nou itself stays small. Switching engines starts a new conversation. Compare them on the same tasks with `npm run eval -- --engine nou --engine claude-code`.
 
 ## 🔄 Updating

package/dist/src/agent/index.js

@@ -49,6 +49,7 @@ How to work:
 - 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.
+- When you explain how something works and it happens in more than one place, call show_places with each part (file, line range, a short note) in the order to read them: Nou opens them highlighted, one after another. Then explain in that order.
 - 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.
 

package/dist/src/cli.js

@@ -14,11 +14,45 @@ import { lsp } from "./lsp/index.js";
 import { App } from "./ui/App.js";
 import { installFastOutput } from "./ui/fast-output.js";
 import { RENDER_OPTIONS } from "./ui/render-options.js";
+import { setScreenClear } from "./ui/redraw.js";
+import { detectBackground } from "./ui/background.js";
+import { setPalette } from "./ui/theme.js";
+import { runHost, workspaceFolder } from "./workspaces/host.js";
+import { pendingWorkspaces } from "./workspaces/client.js";
+import { spawn } from "child_process";
+import { appendFileSync, mkdirSync } from "fs";
+import path from "path";
+import { format } from "util";
+import { NOU_HOME } from "./config/index.js";
+/**
+ * Sends console output and stderr to `file` instead of the terminal, until the returned function puts them
+ * back. Nou draws the whole screen; a stray line from a library would scroll it out from under the mouse.
+ */
+function quietConsole(file) {
+    const saved = { log: console.log, info: console.info, warn: console.warn, error: console.error, debug: console.debug, stderr: process.stderr.write };
+    const toFile = (text) => {
+        try {
+            mkdirSync(path.dirname(file), { recursive: true });
+            appendFileSync(file, text);
+        }
+        catch {
+            // nowhere to keep it: dropping it still beats scrambling the screen
+        }
+    };
+    for (const name of ["log", "info", "warn", "error", "debug"])
+        console[name] = (...args) => toFile(`${new Date().toISOString()} ${name}: ${format(...args)}\n`);
+    process.stderr.write = ((chunk) => (toFile(String(chunk)), true));
+    return () => {
+        Object.assign(console, { log: saved.log, info: saved.info, warn: saved.warn, error: saved.error, debug: saved.debug });
+        process.stderr.write = saved.stderr;
+    };
+}
 const HELP = `nou ${currentVersion()}: an AI coding assistant for your terminal
 
 Usage:
   nou              open Nou in the current folder
   nou --continue   pick up the last conversation in this folder (-c)
+  nou --workspaces . ../api   several projects in one window, a tab each
   nou --resume     list earlier conversations here to pick one up (-r)
   nou update       update to the latest version
   nou --version    print the version
@@ -48,6 +82,24 @@ async function main() {
             console.log("If that was a permissions error, run: sudo npm install -g nou-cli@latest");
         process.exit(1);
     }
+    // nou --workspaces <folder>... : several Nous in this window, a tab each (see src/workspaces).
+    const wsAt = args.indexOf("--workspaces");
+    if (wsAt >= 0) {
+        if (!process.stdin.isTTY) {
+            console.error("Nou needs an interactive terminal.");
+            process.exit(1);
+        }
+        const asked = args.slice(wsAt + 1).filter((a) => !a.startsWith("-"));
+        const folders = asked.map((f) => workspaceFolder(f, process.cwd())).filter((f) => !!f);
+        const missing = asked.filter((f) => !workspaceFolder(f, process.cwd()));
+        if (missing.length)
+            console.error(`Not a folder, so not opened: ${missing.join(", ")}`);
+        const uiTheme = loadSettings().uiTheme;
+        // Every workspace uses the colors found for this terminal (they can't ask it themselves from the background).
+        process.env.NOU_PALETTE = uiTheme === "dark" || uiTheme === "light" ? uiTheme : (await detectBackground()) ?? "dark";
+        const firstArgs = args.includes("--continue") || args.includes("-c") ? ["--continue"] : [];
+        process.exit(await runHost(folders.length ? folders : [process.cwd()], firstArgs));
+    }
     if (!process.stdin.isTTY) {
         console.error("Nou needs an interactive terminal (try Windows Terminal, PowerShell, or Terminal/iTerm on macOS).");
         process.exit(1);
@@ -108,9 +160,26 @@ async function main() {
     if ((settings.engine ?? "nou") === "nou")
         await ensureProjectContext(choice);
     const permContext = await loadPermanentContext();
+    // Colors that are readable on this terminal: a dark or a light set, from the setting or the background.
+    const uiTheme = loadSettings().uiTheme;
+    const fromHost = process.env.NOU_PALETTE;
+    setPalette(uiTheme === "dark" || uiTheme === "light" ? uiTheme : fromHost === "light" || fromHost === "dark" ? fromHost : (await detectBackground()) ?? "dark");
     await installFastOutput();
+    // While Nou is on screen, anything a library prints (console.log, warnings, stderr) goes to a log file:
+    // written into the terminal, it would scroll the screen out from under the mouse.
+    const restoreOutput = quietConsole(path.join(NOU_HOME, "nou.log"));
     const app = render(createElement(App, { initialModel: choice, permContext, ...(args.includes("--continue") || args.includes("-c") ? { resume: "last" } : args.includes("--resume") || args.includes("-r") ? { resume: "list" } : {}) }), RENDER_OPTIONS);
+    setScreenClear(() => app.clear());
     await app.waitUntilExit();
+    restoreOutput();
+    // /workspace new: Nou closes and opens again as a workspaces window, this conversation in the first tab.
+    const folders = pendingWorkspaces();
+    if (folders) {
+        lsp.stopAll();
+        const child = spawn(process.execPath, [process.argv[1], "--workspaces", ...folders, "--continue"], { stdio: "inherit" });
+        child.on("close", (code) => process.exit(code ?? 0));
+        return;
+    }
     lsp.stopAll();
     p.outro(chalk.cyan("Bye bye!"));
 }

package/dist/src/config/index.js

@@ -4,6 +4,23 @@ import path from "path";
 export const NOU_HOME = path.join(os.homedir(), ".nou");
 const CONFIG_PATH = path.join(NOU_HOME, "config.json");
 export const EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+/**
+ * What each effort means for you, since "xhigh" says little: a short name for the picker and what it trades.
+ * The saved value stays the effort itself (low...max), which is what the engines are given.
+ */
+export const EFFORT_LABELS = {
+    low: { name: "Fastest", tradeoff: "Cheapest + fastest: quick answers, little thinking. Good for small edits and questions." },
+    medium: { name: "Fast", tradeoff: "Cheaper + faster: some thinking, for everyday changes." },
+    high: { name: "Balanced", tradeoff: "Balanced: thinks things through without taking long. The default." },
+    xhigh: { name: "Smarter", tradeoff: "Smarter: thinks longer, for trickier bugs and bigger changes. Slower, costs more." },
+    max: { name: "Smartest", tradeoff: "Smartest: thinks as long as it needs, for the hardest problems. Slowest, costs the most." },
+};
+/** An effort from its name or its label ("smarter", "xhigh"), any case. */
+export function effortFrom(text) {
+    const t = text.trim().toLowerCase();
+    return EFFORTS.find((e) => e === t || EFFORT_LABELS[e].name.toLowerCase() === t) ?? null;
+}
+export const UI_THEMES = ["auto", "dark", "light"];
 export const AUTO_SAVE = ["delay", "focus", "off"];
 /** How fast follow mode replays what the agent does: a step every so often, or as it happens. */
 export const FOLLOW_SPEEDS = ["slow", "normal", "fast", "instant"];
@@ -18,8 +35,10 @@ export const DEFAULT_SETTINGS = {
     autoApproveEdits: false,
     autoApproveCommands: false,
     gitContext: true,
+    sendNowWhileBusy: false,
     autoSave: "delay",
     codeTheme: "one-dark",
+    uiTheme: "auto",
     mouse: true,
     reuseToolConfig: true,
     paneWidths: null,
@@ -28,6 +47,7 @@ export const DEFAULT_SETTINGS = {
     gameDock: "chat",
     terminalRows: null,
     gameRows: null,
+    gameBest: {},
     plugins: {},
     trustedPlugins: {},
 };

package/dist/src/conversations/external.js

@@ -29,11 +29,27 @@ function jsonLines(file, limit = Infinity) {
     return out;
 }
 /** The start of a file, for the line that says which folder a Codex session ran in. */
-function head(file, bytes = 8192) {
+/**
+ * The file's first line, however long (up to `max`): Codex puts its whole system prompt in a session's first
+ * line, tens of KB, and reading a fixed 8 KB cut it short, so no Codex session was ever found.
+ */
+function firstLine(file, max = 4 * 1024 * 1024) {
     const fd = openSync(file, "r");
     try {
-        const buf = Buffer.alloc(bytes);
-        return buf.subarray(0, readSync(fd, buf, 0, bytes, 0)).toString("utf-8");
+        const chunks = [];
+        let read = 0;
+        const buf = Buffer.alloc(64 * 1024);
+        while (read < max) {
+            const n = readSync(fd, buf, 0, buf.length, read);
+            if (n <= 0)
+                break;
+            const end = buf.subarray(0, n).indexOf(10); // \n
+            chunks.push(Buffer.from(buf.subarray(0, end >= 0 ? end : n)));
+            read += n;
+            if (end >= 0)
+                break;
+        }
+        return Buffer.concat(chunks).toString("utf-8");
     }
     finally {
         closeSync(fd);
@@ -90,28 +106,34 @@ function codexSessions(home, cwd) {
     if (!existsSync(root))
         return [];
     const files = [];
+    // By date: sessions/YYYY/MM/DD/rollout-*.jsonl. Anything else in there (a .DS_Store, a folder that can't
+    // be read) is skipped, rather than hiding every session.
     const walk = (dir, depth) => {
-        for (const name of readdirSync(dir).sort().reverse()) {
+        let names;
+        try {
+            names = readdirSync(dir).sort().reverse();
+        }
+        catch {
+            return;
+        }
+        for (const name of names) {
             if (files.length >= SCAN)
                 return;
             const full = path.join(dir, name);
-            if (depth < 3)
-                walk(full, depth + 1);
+            if (depth < 3) {
+                if (!name.startsWith("."))
+                    walk(full, depth + 1);
+            }
             else if (name.startsWith("rollout-") && name.endsWith(".jsonl"))
                 files.push(full);
         }
     };
-    try {
-        walk(root, 0);
-    }
-    catch {
-        return [];
-    }
+    walk(root, 0);
     const out = [];
     for (const file of files) {
         let meta;
         try {
-            meta = JSON.parse(head(file).split("\n")[0]);
+            meta = JSON.parse(firstLine(file));
         }
         catch {
             continue;

package/dist/src/diagnostics/providers.js

@@ -1,5 +1,7 @@
-import { existsSync } from "fs";
+import { createHash } from "crypto";
+import { existsSync, mkdirSync } from "fs";
 import path from "path";
+import { NOU_HOME } from "../config/index.js";
 import { onPath, projectBin, run } from "./process.js";
 const rel = (file) => path.relative(process.cwd(), path.resolve(process.cwd(), file)).replace(/\\/g, "/");
 /** ESLint, using the project's own install and config, so results match `npm run lint`. */
@@ -38,6 +40,18 @@ export const eslintProvider = {
     },
 };
 /** The TypeScript compiler over the whole project (type errors need the full picture). */
+/**
+ * tsc runs after every edit, and a full check of a mid-sized project is many CPU-seconds (on a laptop,
+ * battery). Incremental checks reuse what didn't change. The build info lives in ~/.nou/cache, one file per
+ * project, so the project's own files (and any tsBuildInfoFile it sets) are left alone.
+ */
+let incremental = true;
+function buildInfoFile() {
+    const id = createHash("sha1").update(process.cwd()).digest("hex").slice(0, 16);
+    const dir = path.join(NOU_HOME, "cache", "tsc");
+    mkdirSync(dir, { recursive: true });
+    return path.join(dir, `${id}.tsbuildinfo`);
+}
 export const typescriptProvider = {
     id: "typescript",
     name: "TypeScript",
@@ -49,7 +63,14 @@ export const typescriptProvider = {
         const bin = projectBin("typescript", "tsc");
         if (!bin)
             return [];
-        const result = await run(process.execPath, [bin, "--noEmit", "-p", ".", "--pretty", "false"], { timeout: 180_000 });
+        const args = [bin, "--noEmit", "-p", ".", "--pretty", "false"];
+        let result = await run(process.execPath, incremental ? [...args, "--incremental", "--tsBuildInfoFile", buildInfoFile()] : args, { timeout: 180_000 });
+        // An option this project's tsconfig rules out (a TS5xxx/TS6xxx error that names no file): check it the
+        // plain way from now on.
+        if (incremental && /^error TS[56]\d{3}:/m.test(result.stdout)) {
+            incremental = false;
+            result = await run(process.execPath, args, { timeout: 180_000 });
+        }
         const diagnostics = [];
         for (const line of result.stdout.split(/\r?\n/)) {
             const m = line.match(/^(.+?)\((\d+),(\d+)\): (error|warning) (TS\d+): (.*)$/);

package/dist/src/engines/codex.js

@@ -1,5 +1,6 @@
 import { execFileSync } from "child_process";
-import { statSync } from "fs";
+import { realpathSync, statSync } from "fs";
+import path from "path";
 import { transientMessage } from "../agent/index.js";
 import { listAllFiles } from "../ui/QuickOpen.js";
 import { ExternalEngine } from "./external.js";
@@ -9,6 +10,31 @@ const MAX_FILES = 5000;
 const MAX_BYTES = 512 * 1024;
 /** Times a turn that failed for a passing reason (a dropped stream, a failing server) is picked up again. */
 const RESUMES = 5;
+/**
+ * The repo's git folders. Codex's "workspace-write" sandbox keeps `.git` read-only inside the folder it may
+ * write to, so `git commit`, `git stash` and `git pull` fail ("cannot write to .git"). Handing it the git folder
+ * as a folder of its own makes it writable (the read-only rule is for a `.git` inside a writable folder).
+ * Worktrees keep their state in the main repo's git folder, so that one goes too.
+ */
+export function gitDirs(cwd = process.cwd()) {
+    try {
+        const out = execFileSync("git", ["rev-parse", "--absolute-git-dir", "--git-common-dir"], { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+        // Real paths, so one folder reached two ways (macOS's /var is /private/var, Windows' short RUNNER~1 names)
+        // is listed once.
+        const real = (d) => { try {
+            return realpathSync.native(d);
+        }
+        catch {
+            return d;
+        } };
+        const dirs = out.split("\n").map((d) => d.trim()).filter(Boolean).map((d) => real(path.resolve(cwd, d)));
+        const key = (d) => (process.platform === "win32" ? d.toLowerCase() : d);
+        return dirs.filter((d, i) => dirs.findIndex((e) => key(e) === key(d)) === i);
+    }
+    catch {
+        return []; // not a git repo, or git isn't installed
+    }
+}
 /** Project files small enough to keep a copy of (git's list when there is one, so ignored files are skipped). */
 function projectFiles() {
     let files;
@@ -79,6 +105,7 @@ export class CodexEngine extends ExternalEngine {
             // resolve registry.npmjs.org"); Nou's other engines can reach it, so Codex can too.
             networkAccessEnabled: true,
             approvalPolicy: "never",
+            additionalDirectories: gitDirs(),
             ...(this.choice.provider.id === "openai" ? { model: this.choice.model } : {}),
             ...(this.effort && EFFORTS.has(this.effort) ? { modelReasoningEffort: this.effort } : {}),
         };