nou-cli 0.5.16 → 0.5.19

package/README.md

@@ -50,8 +50,8 @@ 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 **+** and pick a folder (or `/workspace new ../api`): it 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. A tab's **×** closes it (so does quitting it, Ctrl+C twice). 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. A tab's **×** (or `/close`) closes it, even one in the background; it stays in `/resume`. |
+| 🪟 **Workspaces** | Several projects in one window, a tab each in the header: click **+** and pick a folder (or `/workspace new ../api`): it 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. A tab's **×** closes it (so does quitting it, Ctrl+C twice). `/workspace rename <name>` names a tab. With more tabs than fit, the ones around the current tab show and **‹ ›** step to the rest. 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. A tab's **×** (or `/close`) closes it, even one in the background; it stays in `/resume`. `/rename <name>` names a chat's tab (and its `/resume` entry). Many tabs: names shorten to fit, then **‹ ›** step to the ones that don't. |
 | 👀 **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, and `/showme stop` clears the highlights. While it shows, the code view and the file tree take its purple (◉ SHOWING 2/6, and each file's places), as they take green while you edit. 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. |
@@ -110,7 +110,7 @@ Every change is reviewed like a code review:
 | <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; double-click copies a word, path or link, triple-click a paragraph) |
+| <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>Ctrl</kbd>+<kbd>C</kbd> while it's highlighted copies it again rather than stopping Nou) |
 | <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. To send now instead of waiting: <kbd>Alt</kbd>+<kbd>Enter</kbd> (stops Nou and sends it), click the queued message, or `/now`. Nou answers it first, then finishes what it was working on, unless your message says to drop it; or turn on **Send while Nou works** in settings so <kbd>Enter</kbd> sends right away (<kbd>Alt</kbd>+<kbd>Enter</kbd> then queues) |
@@ -131,11 +131,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]` · `/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` · `/zoom` · `/workspace [new <folder> | n]` · `/files` · `/actions` · `/now` · `/showme <question>` · `/teach <change>` · `/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` · `/zoom` · `/workspace [new <folder> | n | rename <name>]` · `/rename [name]` · `/files` · `/actions` · `/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, which Nou checks for before it starts; also xterm's modifyOtherKeys form), or type `\` and press <kbd>Enter</kbd> in any terminal.
+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, which Nou checks for before it starts; also xterm's modifyOtherKeys form), or type `\` and press <kbd>Enter</kbd> in any terminal. On Windows, <kbd>Ctrl</kbd>+<kbd>Enter</kbd> works in every Windows Terminal and the console; <kbd>Shift</kbd>+<kbd>Enter</kbd> needs Windows Terminal 1.25 or later (older versions send it as a plain Enter).
 
 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.
 

package/dist/src/engines/claude.js

@@ -48,6 +48,7 @@ export class ClaudeCodeEngine extends ExternalEngine {
         super(choice, hooks, "Claude Code");
     }
     resetConversation() {
+        this.closeLive();
         this.claudeSession = undefined;
     }
     snapshot() {
@@ -57,6 +58,7 @@ export class ClaudeCodeEngine extends ExternalEngine {
     restore(state) {
         if (typeof state?.claudeSession !== "string")
             return false;
+        this.closeLive();
         this.claudeSession = state.claudeSession;
         return true;
     }
@@ -64,15 +66,45 @@ export class ClaudeCodeEngine extends ExternalEngine {
     setModel(choice) {
         this.choice = choice;
     }
-    async run(prompt, signal) {
-        const sdk = await loadPackage("@anthropic-ai/claude-agent-sdk");
-        const abortController = new AbortController();
-        signal.addEventListener("abort", () => abortController.abort());
+    dispose() {
+        this.closeLive();
+    }
+    /**
+     * One Claude Code process per conversation, kept running between messages: each message is fed into it
+     * and a turn is over at its result. A process per message didn't work: one that left something running
+     * (a dev server, a background command) never closed its stream, so the turn never ended, and the next
+     * message's process found the session still in use and ended without a word.
+     */
+    live = null;
+    /** The turn being waited on: settled at its result, or when the process ends. */
+    waiting = null;
+    streamed = "";
+    closeLive() {
+        const live = this.live;
+        this.live = null;
+        live?.close();
+    }
+    /** What the process was started with; a change (model, effort, project context) means a new one. */
+    liveKey() {
+        return JSON.stringify([this.choice.provider.id === "anthropic" ? this.choice.model : null, this.effort ?? null, this.extras]);
+    }
+    openLive(sdk, key) {
+        const queue = [];
+        let wake = null;
+        let closed = false;
+        const input = async function* () {
+            while (!closed) {
+                if (queue.length)
+                    yield queue.shift();
+                else
+                    await new Promise((resolve) => (wake = resolve));
+            }
+        };
         const allow = { hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "allow" } };
         const deny = (reason) => ({ hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason: reason } });
-        const preToolUse = async (input) => {
-            const tool = input.tool_name;
-            const args = (input.tool_input ?? {});
+        const preToolUse = async (hookInput) => {
+            const tool = hookInput.tool_name;
+            const args = (hookInput.tool_input ?? {});
             if (EDIT_TOOLS.has(tool) && args.file_path) {
                 const ok = await this.tracker.approve(args.file_path, proposedContent(tool, args), tool);
                 return ok ? allow : deny("The user rejected this change. Ask them what they would like instead.");
@@ -86,9 +118,9 @@ export class ClaudeCodeEngine extends ExternalEngine {
             // Reads and searches follow Claude Code's own rules; anything else that needs asking reaches canUseTool.
             return {};
         };
-        const postToolUse = async (input) => {
-            const tool = input.tool_name;
-            const args = (input.tool_input ?? {});
+        const postToolUse = async (hookInput) => {
+            const tool = hookInput.tool_name;
+            const args = (hookInput.tool_input ?? {});
             if (EDIT_TOOLS.has(tool) && args.file_path) {
                 const problems = await this.tracker.applied(args.file_path);
                 return problems
@@ -109,10 +141,9 @@ export class ClaudeCodeEngine extends ExternalEngine {
             return {};
         };
         const query = sdk.query({
-            prompt,
+            prompt: input(),
             options: {
                 cwd: process.cwd(),
-                abortController,
                 ...(this.claudeSession ? { resume: this.claudeSession } : {}),
                 ...(this.choice.provider.id === "anthropic" ? { model: this.choice.model } : {}),
                 ...(this.effort && EFFORTS.has(this.effort) ? { effort: this.effort } : {}),
@@ -122,45 +153,124 @@ export class ClaudeCodeEngine extends ExternalEngine {
                 settingSources: ["project"],
                 systemPrompt: { type: "preset", preset: "claude_code", append: this.extras.join("\n\n") },
                 hooks: { PreToolUse: [{ hooks: [preToolUse] }], PostToolUse: [{ hooks: [postToolUse] }] },
-                canUseTool: async (tool, input) => {
-                    const ok = await this.hooks.approve({ kind: "tool", name: tool, args: input });
+                canUseTool: async (tool, toolInput) => {
+                    const ok = await this.hooks.approve({ kind: "tool", name: tool, args: toolInput });
                     if (!ok)
-                        this.hooks.onEntry({ kind: "tool", text: `Denied: ${describeTool(tool, input)}` });
-                    return ok ? { behavior: "allow", updatedInput: input } : { behavior: "deny", message: "The user denied this." };
+                        this.hooks.onEntry({ kind: "tool", text: `Denied: ${describeTool(tool, toolInput)}` });
+                    return ok ? { behavior: "allow", updatedInput: toolInput } : { behavior: "deny", message: "The user denied this." };
                 },
             },
         });
-        let streamed = "";
-        for await (const message of query) {
-            if (message.type === "system" && message.subtype === "init") {
-                this.claudeSession = message.session_id;
-            }
-            else if (message.type === "stream_event" && !message.parent_tool_use_id) {
-                const event = message.event;
-                if (event.type === "content_block_delta" && event.delta?.type === "text_delta") {
-                    streamed += event.delta.text;
-                    this.hooks.onStream(streamed);
+        const live = {
+            key,
+            query,
+            push: (text) => {
+                queue.push({ type: "user", message: { role: "user", content: text }, parent_tool_use_id: null, session_id: this.claudeSession ?? "" });
+                wake?.();
+                wake = null;
+            },
+            close: () => {
+                process.off("exit", live.close);
+                closed = true;
+                wake?.();
+                try {
+                    query.close?.();
                 }
+                catch {
+                    // already gone
+                }
+            },
+        };
+        process.once("exit", live.close); // Claude Code doesn't outlive Nou
+        // Reads everything Claude Code says, for as long as the process runs. Between turns that's what a
+        // background task it started brings back (it may carry on by itself); it goes to the chat too.
+        void (async () => {
+            let failure;
+            try {
+                for await (const message of query)
+                    this.handle(message, live);
             }
-            else if (message.type === "assistant" && !message.parent_tool_use_id) {
-                const text = message.message.content.filter((b) => b.type === "text").map((b) => b.text).join("").trim();
-                streamed = "";
-                this.hooks.onStream("");
-                if (text)
-                    this.hooks.onEntry({ kind: "assistant", text });
-                this.hooks.onBusy("Claude Code is working...");
+            catch (error) {
+                failure = error instanceof Error ? error : new Error(String(error));
             }
-            else if (message.type === "result") {
-                this.claudeSession = message.session_id ?? this.claudeSession;
-                if (message.subtype !== "success" || message.is_error) {
-                    const detail = message.errors?.join("; ") || message.result || message.subtype;
-                    if (!signal.aborted)
-                        this.hooks.onEntry({ kind: "error", text: `Claude Code: ${detail}` });
-                }
-                // The turn is over: don't wait for Claude Code's process to close its stream as well. Something it
-                // left running (a background command, an MCP server) kept that open, and Nou "working" forever.
-                break;
+            finally {
+                if (this.live === live)
+                    this.live = null;
+                if (this.waiting?.live === live)
+                    this.waiting.done(failure ?? (closed ? undefined : new Error("Claude Code stopped before it answered.")));
             }
+        })();
+        return live;
+    }
+    handle(message, live) {
+        if (message.type === "system" && message.subtype === "init") {
+            this.claudeSession = message.session_id;
+        }
+        else if (message.type === "stream_event" && !message.parent_tool_use_id) {
+            const event = message.event;
+            if (event.type === "content_block_delta" && event.delta?.type === "text_delta") {
+                this.streamed += event.delta.text;
+                this.hooks.onStream(this.streamed);
+            }
+        }
+        else if (message.type === "assistant" && !message.parent_tool_use_id) {
+            const text = message.message.content.filter((b) => b.type === "text").map((b) => b.text).join("").trim();
+            this.streamed = "";
+            this.hooks.onStream("");
+            if (text)
+                this.hooks.onEntry({ kind: "assistant", text });
+            if (this.waiting)
+                this.hooks.onBusy("Claude Code is working...");
+        }
+        else if (message.type === "result") {
+            this.claudeSession = message.session_id ?? this.claudeSession;
+            this.streamed = "";
+            this.hooks.onStream("");
+            if (message.subtype !== "success" || message.is_error) {
+                const detail = message.errors?.join("; ") || message.result || message.subtype;
+                // A turn you stopped ends with an error result; that isn't news.
+                if (!this.stopping)
+                    this.hooks.onEntry({ kind: "error", text: `Claude Code: ${detail}` });
+            }
+            this.stopping = false;
+            if (this.waiting?.live === live)
+                this.waiting.done();
+        }
+    }
+    stopping = false;
+    async run(prompt, signal) {
+        const sdk = await loadPackage("@anthropic-ai/claude-agent-sdk");
+        const key = this.liveKey();
+        if (this.live && this.live.key !== key)
+            this.closeLive();
+        const live = (this.live ??= this.openLive(sdk, key));
+        this.streamed = "";
+        let settle;
+        const finished = new Promise((resolve, reject) => (settle = (error) => (error ? reject(error) : resolve())));
+        const waiting = { live, done: (error) => settle(error) };
+        this.waiting = waiting;
+        // Stopping: Claude Code interrupts the turn and ends it with a result; if it doesn't promptly, the
+        // process goes (the next message starts a new one, resuming the session).
+        const onAbort = () => {
+            this.stopping = true;
+            Promise.resolve(live.query.interrupt?.()).catch(() => { });
+            setTimeout(() => {
+                if (this.waiting !== waiting)
+                    return;
+                if (this.live === live)
+                    this.closeLive();
+                waiting.done();
+            }, 3000);
+        };
+        signal.addEventListener("abort", onAbort);
+        try {
+            live.push(prompt);
+            await finished;
+        }
+        finally {
+            signal.removeEventListener("abort", onAbort);
+            if (this.waiting === waiting)
+                this.waiting = null;
         }
         if (signal.aborted)
             throw new Error("aborted");

package/dist/src/ui/App.js

@@ -172,6 +172,11 @@ export function App({ initialModel, permContext, resume }) {
     }, [tour]);
     const shellRef = useRef(null);
     const beforeTerm = useRef("code");
+    /** Names you gave conversations (/rename), by conversation: their tab and /resume show them. */
+    const chatNames = useRef(new Map());
+    const [namesVersion, setNamesVersion] = useState(0);
+    /** What the header calls this workspace when it's the only one (/workspace rename). */
+    const [projectName, setProjectName] = useState(path.basename(process.cwd()));
     const [follow, setFollow] = useState(settings.followMode);
     // Follow mode replays what the agent reads a step at a time (it reads far faster than you can watch):
     // the steps waiting, and the timer that shows the next one.
@@ -378,7 +383,10 @@ export function App({ initialModel, permContext, resume }) {
             return w.has(change.path) ? w : new Set(w).add(change.path);
         });
         // Diffs awaiting approval are shown unless you're in the middle of editing a file (the chat says what's waiting).
-        if (!background && ((status === "pending" && !draftActiveRef.current) || followRef.current)) {
+        // A proposed edit opens only when it waits for your OK; approved by auto-edit, it's just Nou working,
+        // which follow mode shows if it's on (it used to open anyway, so follow off still followed edits).
+        const waitsForYou = status === "pending" && !settingsRef.current.autoApproveEdits && !guideAsk.current;
+        if (!background && ((waitsForYou && !draftActiveRef.current) || followRef.current)) {
             clearFollow(); // an edit is shown as it happens, ahead of reads still waiting
             setOpenFile(change.path);
             setContent(status === "applied" ? change.after : readText(change.path));
@@ -502,8 +510,8 @@ export function App({ initialModel, permContext, resume }) {
     /** The tabs as the chat's title row shows them: named for what you asked first, marked when working or waiting. */
     function chatTabItems() {
         return chatTabs.map((id, i) => {
-            const t = id === activeTab.current ? { entries, busy, approval } : tabStore.current.get(id);
-            const first = t?.entries.find((e) => e.kind === "user")?.text.replace(/\s+/g, " ");
+            const t = id === activeTab.current ? { entries, busy, approval, conversationId } : tabStore.current.get(id);
+            const first = chatNames.current.get(t?.conversationId ?? "") ?? t?.entries.find((e) => e.kind === "user")?.text.replace(/\s+/g, " ");
             const label = first ? (first.length > 14 ? `${first.slice(0, 13)}…` : first) : `chat ${i + 1}`;
             return { id, label, state: t?.approval ? "waiting" : t?.busy ? "busy" : "idle" };
         });
@@ -518,7 +526,7 @@ export function App({ initialModel, permContext, resume }) {
     function saveTab(t) {
         const first = t.entries.find((e) => e.kind === "user");
         if (first)
-            saveConversation({ id: t.conversationId, title: first.text.replace(/\s+/g, " ").slice(0, 80), updated: Date.now(), engine: t.agent.id, entries: t.entries, state: t.agent.snapshot?.() });
+            saveConversation({ id: t.conversationId, title: chatNames.current.get(t.conversationId) ?? first.text.replace(/\s+/g, " ").slice(0, 80), updated: Date.now(), engine: t.agent.id, entries: t.entries, state: t.agent.snapshot?.() });
     }
     if (!agentRef.current) {
         const saved = loadSettings().engine;
@@ -541,8 +549,8 @@ export function App({ initialModel, permContext, resume }) {
         if (busy || !first)
             return;
         const engine = agentRef.current;
-        saveConversation({ id: conversationId, title: first.text.replace(/\s+/g, " ").slice(0, 80), updated: Date.now(), engine: engine.id, entries, state: engine.snapshot?.() });
-    }, [!busy, entries.length, conversationId]);
+        saveConversation({ id: conversationId, title: chatNames.current.get(conversationId) ?? first.text.replace(/\s+/g, " ").slice(0, 80), updated: Date.now(), engine: engine.id, entries, state: engine.snapshot?.() });
+    }, [!busy, entries.length, conversationId, namesVersion]);
     /** Earlier conversations for the palette, read from disk when it opens. */
     const recentChats = useMemo(() => (quickOpen !== null ? resumable() : []), [quickOpen !== null]);
     useEffect(() => {
@@ -1106,7 +1114,7 @@ export function App({ initialModel, permContext, resume }) {
             return setView("settings");
         // Workspace tabs in the header: click one to switch to it, + to open another.
         if (event.kind === "click" && event.y === 0) {
-            const zone = headerZones(workspaceTabs()).find((z) => event.x >= z.from && event.x < z.to);
+            const zone = headerZones(workspaceTabs(), columns, modelLabel, choice.provider.local, update, projectName).find((z) => event.x >= z.from && event.x < z.to);
             if (zone?.tab === "new")
                 return pickWorkspaceFolder();
             if (typeof zone?.tab === "number")
@@ -1140,7 +1148,7 @@ export function App({ initialModel, permContext, resume }) {
         // The chat's title row holds the conversation tabs: a click switches, + opens a new one.
         if (event.kind === "click" && pane === "chat" && event.y === 2) {
             const at = event.x - treeWidth - codeWidth - 1;
-            const { zones, plus } = chatTabZones(chatTabItems());
+            const { zones, plus } = chatTabZones(chatTabItems(), activeTab.current, columns - treeWidth - codeWidth);
             if (Math.abs(at - plus) <= 1)
                 return newChatTab();
             const zone = zones.find((z) => at >= z.from && at < z.to);
@@ -1222,6 +1230,10 @@ export function App({ initialModel, permContext, resume }) {
             }
         }
     }, settings.mouse);
+    const chatSelecting = useRef(false);
+    const onChatSelecting = useEvent((selecting) => {
+        chatSelecting.current = selecting;
+    });
     // Ctrl+C: stop Nou if it's working; otherwise press twice to quit.
     useInput((input, key) => {
         if (!(key.ctrl && input === "c"))
@@ -1230,6 +1242,8 @@ export function App({ initialModel, permContext, resume }) {
             return; // the editor copies it
         if (focus === "terminal")
             return; // the terminal stops its command
+        if (chatSelecting.current)
+            return; // the chat copies what's highlighted
         if (busy || approval) {
             stop();
             approval?.resolve(false);
@@ -1580,7 +1594,7 @@ export function App({ initialModel, permContext, resume }) {
             setFocus("chat");
             setChatPrefill((p) => ({ text: "/", nonce: (p?.nonce ?? 0) + 1 }));
         }
-        else if (input === "f")
+        else if (input === "f" || input === "F")
             toggleFollow();
         else if (input === "m")
             toggleMouse();
@@ -1763,6 +1777,16 @@ ${snippet}
                     return info(`No file matches "${wanted}". To find where something is in the code, ask in the chat.`, "error");
                 return openRef({ path: file, ...(m[2] ? { line: Number(m[2]) } : {}), ...(m[3] ? { to: Number(m[3]) } : {}) });
             }
+            case "rename": {
+                // Names this conversation: its tab, and /resume, show the name (/rename alone: back to the first message).
+                const name = arg.trim().slice(0, 40);
+                if (name)
+                    chatNames.current.set(conversationId, name);
+                else
+                    chatNames.current.delete(conversationId);
+                setNamesVersion((v) => v + 1);
+                return info(name ? `This chat is now called ${name}. (/workspace rename <name> names the workspace.)` : "This chat is named by its first message again.");
+            }
             case "follow": {
                 const want = arg.trim().toLowerCase();
                 if (want && !/^(on|off)$/.test(want))
@@ -2450,8 +2474,16 @@ ${snippet}
                 return info(`There's no workspace ${n}. /workspace lists them.`, "error");
             return void sendToHost({ type: "switch", index: n - 1 });
         }
+        if (sub === "rename") {
+            const name = more.join(" ").trim().slice(0, 30);
+            if (isHosted())
+                sendToHost({ type: "rename", name });
+            else
+                setProjectName(name || path.basename(process.cwd()));
+            return info(name ? `This workspace is now called ${name}.` : "This workspace is called by its folder's name again.");
+        }
         if (sub !== "new")
-            return info("Try /workspace new <folder>, /workspace <n> or /workspace.", "error");
+            return info("Try /workspace new <folder>, /workspace <n>, /workspace rename <name> or /workspace.", "error");
         const wanted = more.join(" ");
         if (!wanted)
             return pickWorkspaceFolder();
@@ -2655,7 +2687,7 @@ ${snippet}
     }
     const modelLabel = agentRef.current.id === "nou" ? describe(choice) : `${engineInfo(agentRef.current.id).label} · ${engineInfo(agentRef.current.id).model(choice)}`;
     clickable.current = { status: zones, modelFrom: columns - (" LOCAL ".length + ` ${modelLabel} `.length + 1) };
-    return (_jsxs(Box, { flexDirection: "column", width: columns, height: rows, children: [_jsx(Header, { width: columns, branch: branch, changes: git.size, model: modelLabel, local: choice.provider.local, busy: busy, update: update, tabs: tabsOfWorkspaces }), _jsxs(Box, { flexDirection: "row", height: height, children: [_jsx(FileTree, { width: treeWidth, height: heights.tree, focused: focus === "tree", openFile: openFile, reveal: reveal, version: treeVersion, changed: edited, working: working, ...(tourFiles ? { showing: tourFiles } : {}), git: git, problemCounts: problemCounts, wheelPane: "tree", scrollTo: scrollFor("tree"), click: treeClick, onOpen: onTreeOpen, onHover: onTreeHover }), codePanel === "problems" && !pendingChange ? (_jsx(ProblemsView, { width: codeWidth, height: heights.code, focused: focus === "code", problems: diagnostics.all(), checking: checking, wheelPane: "code", onJump: onJump, onClose: onCloseProblems })) : showEditor ? (_jsx(Editor, { ...(tabStrip ? { tabs: tabStrip } : {}), width: codeWidth, height: heights.code, focused: focus === "code", filePath: openFile, initial: draft.current?.path === openFile ? draft.current.text : content, baseline: draft.current?.path === openFile ? draft.current.baseline : content, startLine: editorStart.line, ...(editorStart.col ? { startCol: editorStart.col } : {}), problems: fileProblems, autoSave: settings.autoSave, syntaxVersion: syntaxVersion, wheelPane: "code", scrollTo: scrollFor("code"), mouse: editorMouse, onHover: onEditorHover, onDefinition: onEditorDefinition, onSave: onEditorSave, onExit: onEditorExit, onState: onEditorState, ...(guideStep && openFile === guideStep.file ? { guide: { row: guideStep.line - 1, code: guideStep.code }, onGuideDone } : {}) }, `${openFile}:${editorStart.nonce}`)) : (_jsx(CodeView, { ...(tour && tour.stops[tour.at]?.file === openFile && !diff ? { showing: `${tour.at + 1}/${tour.stops.length}` } : {}), ...(tabStrip && !diff ? { tabs: tabStrip } : {}), width: codeWidth, height: heights.code, focused: focus === "code", filePath: openFile, content: content, diff: diff, diffLabel: diffMode === "git" ? "vs HEAD" : diffMode === "session" ? sessionView?.label ?? "this session" : "Nou's edit", pending: !!pendingChange && diff === pendingChange, marked: record?.lines ?? NO_LINES, problems: fileProblems, focusLine: focusLine, syntaxVersion: syntaxVersion, diffNote: pendingChange && diff === pendingChange ? pendingNote?.short ?? (checking.length ? "checking…" : null) : null, wheelPane: "code", scrollTo: scrollFor("code"), onViewport: onViewport, defineAt: codeDefine, onDefine: onCodeDefine, onFinding: onCodeFinding, findRequest: findRequest, foldClick: foldClick, foldAll: foldAll })), _jsx(Chat, { width: chatWidth, height: heights.chat, focused: focus === "chat", entries: entries, streaming: streaming, busy: busy, approval: approval?.request ?? null, approvalNote: pendingChange ? pendingNote?.detail ?? null : null, contextChip: contextChip, wheelPane: "chat", scrollTo: scrollFor("chat"), prefill: chatPrefill, extraCommands: pluginCommands, onMenu: onChatMenu, onSubmit: onSend, queued: queued, sendNowFirst: settings.sendNowWhileBusy, onSendNow: sendNow, onAnswer: onAnswer, click: chatClick, select: chatSelect, tabs: chatTabsProp(), onOpenRef: openRef })] }), _jsx(Box, { children: _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { backgroundColor: mode.color, color: C.onBadge, bold: true, children: ` ${mode.label} ` }), _jsx(Text, { backgroundColor: C.panel, color: autoMode === "ask" ? C.dim : C.orange, bold: autoMode !== "ask", children: ` ${autoMode === "ask" ? "ask" : autoMode} ` }), _jsx(Text, { backgroundColor: C.panel, color: follow ? C.green : C.dim, children: followChip }), _jsx(Text, { backgroundColor: C.panel, color: totals.errors ? C.red : C.dim, children: ` ✗ ${totals.errors}` }), _jsx(Text, { backgroundColor: C.panel, color: totals.warnings ? C.yellow : C.dim, children: ` ▲ ${totals.warnings} ` }), checking.length > 0 && _jsxs(Text, { color: C.accent2, children: [" \u27F3 ", checking.join(", ")] }), exitArmed
+    return (_jsxs(Box, { flexDirection: "column", width: columns, height: rows, children: [_jsx(Header, { width: columns, branch: branch, changes: git.size, model: modelLabel, local: choice.provider.local, busy: busy, update: update, tabs: tabsOfWorkspaces, project: projectName }), _jsxs(Box, { flexDirection: "row", height: height, children: [_jsx(FileTree, { width: treeWidth, height: heights.tree, focused: focus === "tree", openFile: openFile, reveal: reveal, version: treeVersion, changed: edited, working: working, ...(tourFiles ? { showing: tourFiles } : {}), git: git, problemCounts: problemCounts, wheelPane: "tree", scrollTo: scrollFor("tree"), click: treeClick, onOpen: onTreeOpen, onHover: onTreeHover }), codePanel === "problems" && !pendingChange ? (_jsx(ProblemsView, { width: codeWidth, height: heights.code, focused: focus === "code", problems: diagnostics.all(), checking: checking, wheelPane: "code", onJump: onJump, onClose: onCloseProblems })) : showEditor ? (_jsx(Editor, { ...(tabStrip ? { tabs: tabStrip } : {}), width: codeWidth, height: heights.code, focused: focus === "code", filePath: openFile, initial: draft.current?.path === openFile ? draft.current.text : content, baseline: draft.current?.path === openFile ? draft.current.baseline : content, startLine: editorStart.line, ...(editorStart.col ? { startCol: editorStart.col } : {}), problems: fileProblems, autoSave: settings.autoSave, syntaxVersion: syntaxVersion, wheelPane: "code", scrollTo: scrollFor("code"), mouse: editorMouse, onHover: onEditorHover, onDefinition: onEditorDefinition, onSave: onEditorSave, onExit: onEditorExit, onState: onEditorState, ...(guideStep && openFile === guideStep.file ? { guide: { row: guideStep.line - 1, code: guideStep.code }, onGuideDone } : {}) }, `${openFile}:${editorStart.nonce}`)) : (_jsx(CodeView, { ...(tour && tour.stops[tour.at]?.file === openFile && !diff ? { showing: `${tour.at + 1}/${tour.stops.length}` } : {}), ...(tabStrip && !diff ? { tabs: tabStrip } : {}), width: codeWidth, height: heights.code, focused: focus === "code", filePath: openFile, content: content, diff: diff, diffLabel: diffMode === "git" ? "vs HEAD" : diffMode === "session" ? sessionView?.label ?? "this session" : "Nou's edit", pending: !!pendingChange && diff === pendingChange, marked: record?.lines ?? NO_LINES, problems: fileProblems, focusLine: focusLine, syntaxVersion: syntaxVersion, diffNote: pendingChange && diff === pendingChange ? pendingNote?.short ?? (checking.length ? "checking…" : null) : null, wheelPane: "code", scrollTo: scrollFor("code"), onViewport: onViewport, defineAt: codeDefine, onDefine: onCodeDefine, onFinding: onCodeFinding, findRequest: findRequest, foldClick: foldClick, foldAll: foldAll })), _jsx(Chat, { width: chatWidth, height: heights.chat, focused: focus === "chat", entries: entries, streaming: streaming, busy: busy, approval: approval?.request ?? null, approvalNote: pendingChange ? pendingNote?.detail ?? null : null, contextChip: contextChip, wheelPane: "chat", scrollTo: scrollFor("chat"), prefill: chatPrefill, extraCommands: pluginCommands, onMenu: onChatMenu, onSubmit: onSend, queued: queued, sendNowFirst: settings.sendNowWhileBusy, onSendNow: sendNow, onSelecting: onChatSelecting, onAnswer: onAnswer, click: chatClick, select: chatSelect, tabs: chatTabsProp(), onOpenRef: openRef })] }), _jsx(Box, { children: _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { backgroundColor: mode.color, color: C.onBadge, bold: true, children: ` ${mode.label} ` }), _jsx(Text, { backgroundColor: C.panel, color: autoMode === "ask" ? C.dim : C.orange, bold: autoMode !== "ask", children: ` ${autoMode === "ask" ? "ask" : autoMode} ` }), _jsx(Text, { backgroundColor: C.panel, color: follow ? C.green : C.dim, children: followChip }), _jsx(Text, { backgroundColor: C.panel, color: totals.errors ? C.red : C.dim, children: ` ✗ ${totals.errors}` }), _jsx(Text, { backgroundColor: C.panel, color: totals.warnings ? C.yellow : C.dim, children: ` ▲ ${totals.warnings} ` }), checking.length > 0 && _jsxs(Text, { color: C.accent2, children: [" \u27F3 ", checking.join(", ")] }), exitArmed
                             ? _jsxs(Text, { color: C.yellow, bold: true, children: ["  ", "Press again to quit", draft.current && settings.autoSave === "off" ? ` (unsaved changes in ${draft.current.path} will be lost)` : ""] })
                             : shownHints.map(([key, action], i) => (_jsxs(Text, { children: [i === 0 ? "  " : _jsx(Text, { color: C.dim, children: " \u00B7 " }), _jsx(Text, { color: C.text, children: key }), _jsxs(Text, { color: C.dim, children: [" ", action] })] }, key)))] }) }), layout.current.terminal && shellRef.current && (_jsx(Box, { position: "absolute", marginLeft: layout.current.terminal.x, marginTop: layout.current.terminal.y, children: _jsx(Terminal, { shell: shellRef.current, version: termVersion, width: layout.current.terminal.width, height: layout.current.terminal.height, focused: focus === "terminal", wheelPane: "terminal", onLeave: leaveTerminal, onClose: () => toggleTerminal(false), onResize: resizeTerminal }) })), layout.current.game && (_jsx(Box, { position: "absolute", marginLeft: layout.current.game.x, marginTop: layout.current.game.y, children: _jsx(GameGuard, { children: _jsx(GamePanel, { width: layout.current.game.width, height: layout.current.game.height, focused: focus === "game", moving: !!gameDrag, installed: settings.games, best: settings.gameBest ?? {}, onScore: onGameScore, onLeave: leaveGames, onOpenSettings: gamesSettings }) }) })), quickOpen !== null && (_jsx(QuickOpen, { width: columns, top: 3, files: allFiles, recent: recent, actions: resumePicker ?? paletteActions, initialQuery: quickOpen, ...(resumePicker ? { placeholder: "type to filter", title: pickerTitle } : {}), onPick: (file) => {
                     setQuickOpen(null);

package/dist/src/ui/Chat.js

@@ -7,6 +7,7 @@ import path from "path";
 import { closeOpenMarkdown, linkAt, linkFileRefs, linkUrls, renderMarkdown, wrap } from "./text.js";
 import { ChatInput, inputHeight } from "./ChatInput.js";
 import { copyToClipboard } from "./clipboard.js";
+import { fitAround } from "./Tabs.js";
 import { C, SPINNER, ANIMATION_MS } from "./theme.js";
 import { useTerminalFocused } from "./focus.js";
 import { Pane } from "./Pane.js";
@@ -85,28 +86,49 @@ function cachedLines(entry, inner) {
 }
 /**
  * Where each tab sits in the chat's title row (columns from the pane's inner left edge), and the "+"
- * that opens a new one: shared by the drawing and the clicks.
+ * that opens a new one: shared by the drawing and the clicks. Only the tabs that fit are shown, around the
+ * active one; ‹ and › stand for the rest and go to the tab before or after.
  */
-export function chatTabZones(tabs) {
+export function chatTabZones(all, active, paneWidth = 10_000) {
     // One tab: just "Chat +", to leave the title row its room.
-    if (tabs.length === 1)
-        return { zones: [{ id: tabs[0].id, from: 3, to: 7 }], plus: 8, width: 9 };
+    if (all.length === 1)
+        return { zones: [{ id: all[0].id, from: 3, to: 7 }], plus: 8, width: 9, from: 0, to: 1, tabs: all };
+    const room = paneWidth - 2 - 3 - 3; // the borders, " ◆ " and " + "
+    const sizeOf = (t) => tabText(t).length + TAB_CLOSE.length + 1;
+    // Short of room, names are shortened first (down to a few letters each), so every tab stays in view;
+    // only then do the ones that still don't fit go behind ‹ ›.
+    let tabs = all;
+    for (let max = 14; max >= 6 && tabs.reduce((n, t) => n + sizeOf(t), 0) > room; max--) {
+        tabs = all.map((t) => (t.label.length > max ? { ...t, label: `${t.label.slice(0, max - 1)}…` } : t));
+    }
+    const sizes = tabs.map(sizeOf);
+    const { from, to } = fitAround(sizes, Math.max(0, tabs.findIndex((t) => t.id === active)), room, TAB_PREV.length + TAB_NEXT.length);
     let x = 3; // " ◆ "
+    const zones = [];
+    if (from > 0) {
+        zones.push({ id: tabs[from - 1].id, from: x, to: x + TAB_PREV.length });
+        x += TAB_PREV.length;
+    }
     // Each tab, then its × (which closes it).
-    const zones = tabs.flatMap((t) => {
+    for (const t of tabs.slice(from, to)) {
         const w = tabText(t).length;
-        const both = [{ id: t.id, from: x, to: x + w }, { id: t.id, from: x + w, to: x + w + TAB_CLOSE.length, close: true }];
+        zones.push({ id: t.id, from: x, to: x + w }, { id: t.id, from: x + w, to: x + w + TAB_CLOSE.length, close: true });
         x += w + TAB_CLOSE.length + 1;
-        return both;
-    });
-    return { zones, plus: x + 1, width: x + 3 };
+    }
+    if (to < tabs.length) {
+        zones.push({ id: tabs[to].id, from: x, to: x + TAB_NEXT.length });
+        x += TAB_NEXT.length;
+    }
+    return { zones, plus: x + 1, width: x + 3, from, to, tabs };
 }
+const TAB_PREV = "‹ ";
+const TAB_NEXT = "› ";
 const TAB_CLOSE = "× ";
 const tabText = (t) => ` ${t.state === "busy" ? "● " : t.state === "waiting" ? "! " : ""}${t.label} `;
 /** Characters of a word for a double-click: paths and web addresses come whole (src/a.ts, https://x.io/y). */
 const WORD_CHAR = /[\p{L}\p{N}_.\-/@:~#%?=&+]/u;
 const lineText = (line) => (line.spans ? line.spans.map((s) => s.text).join("") : line.text ?? "");
-export const Chat = memo(function Chat({ width, height, focused, entries, streaming, busy, approval, approvalNote, contextChip, wheelPane, scrollTo, prefill, extraCommands, onMenu, onSubmit, onAnswer, click, onOpenRef, select, tabs, queued = [], sendNowFirst = false, onSendNow }) {
+export const Chat = memo(function Chat({ width, height, focused, entries, streaming, busy, approval, approvalNote, contextChip, wheelPane, scrollTo, prefill, extraCommands, onMenu, onSubmit, onAnswer, click, onOpenRef, select, tabs, queued = [], sendNowFirst = false, onSendNow, onSelecting }) {
     const wheel = usePaneWheel(wheelPane);
     const [input, setInputText] = useState("");
     // Whether the chat has the keyboard right now: a key handler from a render before focus moved away can
@@ -343,6 +365,17 @@ export const Chat = memo(function Chat({ width, height, focused, entries, stream
             setTimeout(() => setFlash(null), 2000);
         });
     };
+    useEffect(() => {
+        onSelecting?.(!!selection);
+    }, [!!selection]);
+    // Ctrl+C with text highlighted copies it (again), as it does everywhere else, and clears the highlight:
+    // it doesn't stop Nou. With nothing highlighted, Ctrl+C stops Nou as before.
+    useInput((input, key) => {
+        if (!key.ctrl || input !== "c" || !selection)
+            return;
+        copySelection(selection);
+        setSelection(null);
+    }, { isActive: !!selection });
     // Typing or new messages leave the selection be; a new conversation clears it.
     useEffect(() => {
         if (!entries.length)
@@ -404,7 +437,8 @@ export const Chat = memo(function Chat({ width, height, focused, entries, stream
                 ? line.spans.map((span, i) => (_jsx(Text, { bold: !!span.bold || !!line.bold, italic: !!span.italic, dimColor: !!span.dim && !span.link, underline: !!span.link, ...(span.link ? { color: C.cyan } : span.code ? { color: C.yellow } : line.color ? { color: line.color } : { color: C.text }), children: span.text }, i)))
                 : _jsx(Text, { bold: !!line.bold, dimColor: !!line.dim, ...(line.color ? { color: line.color } : {}), children: line.text || " " })] }, key));
     const empty = entries.length === 0 && !streaming;
-    const title = (_jsxs(_Fragment, { children: [" ", _jsx(Text, { color: C.accent2, children: "\u25C6" }), " ", tabs && tabs.items.length > 1 ? (_jsxs(_Fragment, { children: [tabs.items.map((t) => (_jsxs(Text, { children: [_jsx(Text, { ...(t.id === tabs.active ? { backgroundColor: C.panel, color: C.text, bold: true } : { color: t.state === "waiting" ? C.yellow : C.dim }), children: tabText(t) }), _jsx(Text, { color: C.dim, ...(t.id === tabs.active ? { backgroundColor: C.panel } : {}), children: TAB_CLOSE }), " "] }, t.id))), _jsx(Text, { color: C.accent2, bold: true, children: " + " })] })) : _jsxs(_Fragment, { children: ["Chat", tabs ? _jsx(Text, { color: C.accent2, bold: true, children: " +" }) : null] }), flash ? _jsxs(Text, { color: C.green, bold: true, children: ["  ", flash] }) : back
+    const strip = tabs ? chatTabZones(tabs.items, tabs.active, width) : { from: 0, to: 0, tabs: [] };
+    const title = (_jsxs(_Fragment, { children: [" ", _jsx(Text, { color: C.accent2, children: "\u25C6" }), " ", tabs && tabs.items.length > 1 ? (_jsxs(_Fragment, { children: [strip.from > 0 ? _jsx(Text, { color: C.accent2, children: TAB_PREV }) : null, strip.tabs.slice(strip.from, strip.to).map((t) => (_jsxs(Text, { children: [_jsx(Text, { ...(t.id === tabs.active ? { backgroundColor: C.panel, color: C.text, bold: true } : { color: t.state === "waiting" ? C.yellow : C.dim }), children: tabText(t) }), _jsx(Text, { color: C.dim, ...(t.id === tabs.active ? { backgroundColor: C.panel } : {}), children: TAB_CLOSE }), " "] }, t.id))), strip.to < tabs.items.length ? _jsx(Text, { color: C.accent2, children: TAB_NEXT }) : null, _jsx(Text, { color: C.accent2, bold: true, children: " + " })] })) : _jsxs(_Fragment, { children: ["Chat", tabs ? _jsx(Text, { color: C.accent2, bold: true, children: " +" }) : null] }), flash ? _jsxs(Text, { color: C.green, bold: true, children: ["  ", flash] }) : back
                 ? unread
                     ? _jsxs(Text, { color: C.green, bold: true, children: ["  \u2193 ", unread, " new lines below", _jsx(Text, { color: C.dim, children: " \u00B7 PgDn / wheel / Ctrl+End" })] })
                     : _jsxs(Text, { color: C.yellow, children: ["  \u2191 scrolled ", back, " lines", _jsx(Text, { color: C.dim, children: " \u00B7 PgDn / wheel / Ctrl+End" })] })

package/dist/src/ui/Header.js

@@ -5,50 +5,77 @@ import { Box, Text, useAnimation } from "ink";
 import { C, gradient, ANIMATION_MS } from "./theme.js";
 import { useTerminalFocused } from "./focus.js";
 import { currentVersion } from "../update/index.js";
+import { fitAround } from "./Tabs.js";
 const VERSION = `v${currentVersion()}`;
 /** What comes before the project (or the workspace tabs): " ◆ NOU v1.2.3  │  ". */
 const LEAD = ` ◆ NOU ${VERSION}  │  `;
 const tabLabel = (t, i) => ` ${i + 1} ${t.name}${t.busy ? " ●" : ""} `;
 /** Each workspace tab ends with a × that closes it. */
 const CLOSE = "× ";
+/** The markers for workspace tabs that don't fit: click to go to the one before or after. */
+const PREV = "‹ ";
+const NEXT = "› ";
 /**
- * Where each workspace tab, and the + that opens one, sits in the header row: for clicks. With one workspace
- * (not hosted) there's just the project's name and the +.
+ * The header's right side: the update notice (when there's room), where the model runs and which. Plain
+ * characters only: symbols that are also emoji (☁, ⬆) are drawn two columns wide by some terminals.
+ */
+const rightSide = (width, model, local, update) => ({
+    notice: update && width >= 110 ? `↑ v${update} available · run \`nou update\`  ` : "",
+    badge: ` ${local ? "LOCAL" : "CLOUD"} `,
+    model: ` ${model} `,
+});
+/** Columns the left side of the header gets: what the right leaves, less a margin. */
+const leftWidth = (width, model, local, update) => {
+    const right = rightSide(width, model, local, update);
+    return Math.max(0, width - (right.notice.length + right.badge.length + right.model.length + 1) - 4);
+};
+/**
+ * Which workspace tabs the header shows, around the active one: as many as fit, with ‹ › for the rest (the
+ * + always shows). The drawing and the clicks both use it.
+ */
+export function headerLayout(tabs, width, model, local, update) {
+    const room = leftWidth(width, model, local, update) - LEAD.length - 3 - 2; // " + " and a little air
+    const sizes = tabs.map((t, i) => tabLabel(t, i).length + CLOSE.length + 1);
+    const { from, to } = fitAround(sizes, tabs.findIndex((t) => t.active), room, PREV.length + NEXT.length);
+    return { from, to, before: from > 0, after: to < tabs.length };
+}
+/**
+ * Where each workspace tab, its ×, the ‹ › and the + that opens one sit in the header row: for clicks. With
+ * one workspace (not hosted) there's just the project's name and the +.
  */
-export function headerZones(tabs) {
+export function headerZones(tabs, width = 10_000, model = "", local = true, update = null, project = path.basename(process.cwd())) {
     const zones = [];
     let x = LEAD.length;
     if (!tabs.length) {
-        x += path.basename(process.cwd()).length + 1;
+        x += project.length + 1;
     }
     else {
-        tabs.forEach((t, i) => {
-            const w = tabLabel(t, i).length;
+        const { from, to, before, after } = headerLayout(tabs, width, model, local, update);
+        if (before) {
+            zones.push({ from: x, to: x + PREV.length, tab: from - 1 });
+            x += PREV.length;
+        }
+        for (let i = from; i < to; i++) {
+            const w = tabLabel(tabs[i], i).length;
             zones.push({ from: x, to: x + w, tab: i });
             zones.push({ from: x + w, to: x + w + CLOSE.length, tab: i, close: true });
             x += w + CLOSE.length + 1;
-        });
+        }
+        if (after) {
+            zones.push({ from: x, to: x + NEXT.length, tab: to });
+            x += NEXT.length;
+        }
     }
     zones.push({ from: x, to: x + 3, tab: "new" });
     return zones;
 }
-/**
- * The header's right side: the update notice (when there's room), where the model runs and which. Plain
- * characters only: symbols that are also emoji (☁, ⬆) are drawn two columns wide by some terminals.
- */
-const rightSide = (width, model, local, update) => ({
-    notice: update && width >= 110 ? `↑ v${update} available · run \`nou update\`  ` : "",
-    badge: ` ${local ? "LOCAL" : "CLOUD"} `,
-    model: ` ${model} `,
-});
-export const Header = memo(function Header({ width, branch, changes, model, local, busy, update, tabs = [] }) {
+export const Header = memo(function Header({ width, branch, changes, model, local, busy, update, tabs = [], project = path.basename(process.cwd()) }) {
     // The spinner stops while Nou's window is in the background: nobody sees it, and each frame is a redraw.
     const windowFocused = useTerminalFocused();
     const { frame } = useAnimation({ interval: ANIMATION_MS, isActive: !!busy && windowFocused });
-    const project = path.basename(process.cwd());
     const right = rightSide(width, model, local, update);
-    const rightWidth = right.notice.length + right.badge.length + right.model.length + 1;
-    return (_jsxs(Box, { width: width, justifyContent: "space-between", children: [_jsx(Box, { width: Math.max(0, width - rightWidth - 4), flexShrink: 0, overflow: "hidden", children: _jsxs(Text, { wrap: "truncate-end", children: [" ", gradient("◆ NOU", busy ? frame : 0).map((g, i) => _jsx(Text, { bold: true, color: g.color, children: g.ch }, i)), _jsxs(Text, { color: C.dim, children: [" ", VERSION] }), _jsx(Text, { color: C.dim, children: "  \u2502  " }), tabs.length
-                            ? tabs.map((t, i) => (_jsxs(Text, { children: [_jsx(Text, { ...(t.active ? { backgroundColor: C.panel } : {}), color: t.active ? C.accent : C.text, bold: t.active, children: tabLabel(t, i) }), _jsx(Text, { ...(t.active ? { backgroundColor: C.panel } : {}), color: C.dim, children: CLOSE }), " "] }, t.id)))
+    const shown = headerLayout(tabs, width, model, local, update);
+    return (_jsxs(Box, { width: width, justifyContent: "space-between", children: [_jsx(Box, { width: leftWidth(width, model, local, update), flexShrink: 0, overflow: "hidden", children: _jsxs(Text, { wrap: "truncate-end", children: [" ", gradient("◆ NOU", busy ? frame : 0).map((g, i) => _jsx(Text, { bold: true, color: g.color, children: g.ch }, i)), _jsxs(Text, { color: C.dim, children: [" ", VERSION] }), _jsx(Text, { color: C.dim, children: "  \u2502  " }), tabs.length
+                            ? _jsxs(_Fragment, { children: [shown.before ? _jsx(Text, { color: C.accent, children: PREV }) : null, tabs.slice(shown.from, shown.to).map((t, j) => (_jsxs(Text, { children: [_jsx(Text, { ...(t.active ? { backgroundColor: C.panel } : {}), color: t.active ? C.accent : C.text, bold: t.active, children: tabLabel(t, shown.from + j) }), _jsx(Text, { ...(t.active ? { backgroundColor: C.panel } : {}), color: C.dim, children: CLOSE }), " "] }, t.id))), shown.after ? _jsx(Text, { color: C.accent, children: NEXT }) : null] })
                             : _jsxs(Text, { color: C.text, children: [project, " "] }), _jsx(Text, { color: C.accent2, children: " + " }), branch && (_jsxs(_Fragment, { children: [_jsx(Text, { color: C.dim, children: "  \u2502  " }), _jsxs(Text, { color: C.accent2, children: ["\u2387 ", branch] }), changes > 0 && _jsxs(Text, { color: C.yellow, children: [" \u00B1", changes] })] }))] }) }), _jsx(Box, { flexShrink: 0, children: _jsxs(Text, { wrap: "truncate-end", children: [right.notice && _jsx(Text, { color: C.green, bold: true, children: right.notice }), _jsx(Text, { backgroundColor: local ? C.green : C.accent2, color: C.onBadge, bold: true, children: right.badge }), _jsx(Text, { backgroundColor: C.panel, color: C.text, children: right.model }), " "] }) })] }));
 });

package/dist/src/ui/Tabs.js

@@ -11,6 +11,33 @@ function labels(tabs) {
         return twin ? `${path.posix.basename(path.posix.dirname(file))}/${name}` : name;
     });
 }
+/**
+ * Which of a row of tabs fit in `room` columns, kept around the active one: grows right, then left, while
+ * they fit, keeping `markers` columns for the ‹ › that stand for the ones left out. Returns [from, to).
+ */
+export function fitAround(sizes, active, room, markers = 2) {
+    const at = Math.max(0, Math.min(sizes.length - 1, active));
+    if (!sizes.length)
+        return { from: 0, to: 0 };
+    let from = at;
+    let to = at + 1;
+    let used = sizes[at];
+    const total = sizes.reduce((a, b) => a + b, 0);
+    if (total <= room)
+        return { from: 0, to: sizes.length };
+    for (let grew = true; grew;) {
+        grew = false;
+        if (to < sizes.length && used + sizes[to] <= room - markers) {
+            used += sizes[to++];
+            grew = true;
+        }
+        if (from > 0 && used + sizes[from - 1] <= room - markers) {
+            used += sizes[--from];
+            grew = true;
+        }
+    }
+    return { from, to };
+}
 /**
  * Lays out the tabs that fit in `width` columns, keeping the active one in view: the ones that don't fit
  * are left out at the ends, marked with ‹ ›.

package/dist/src/ui/commands.js

@@ -2,7 +2,7 @@
  * Commands that only change what's on screen (or handle a busy Nou themselves): they run right away
  * while Nou works instead of waiting in the queue behind it.
  */
-const INSTANT = new Set(["follow", "files", "actions", "palette", "zoom", "now", "fold", "unfold", "redraw", "new", "tab", "close", "terminal", "games", "open", "settings", "auto", "diff", "sessions", "history", "problems", "copy", "help", "version", "cancel"]);
+const INSTANT = new Set(["rename", "follow", "files", "actions", "palette", "zoom", "now", "fold", "unfold", "redraw", "new", "tab", "close", "terminal", "games", "open", "settings", "auto", "diff", "sessions", "history", "problems", "copy", "help", "version", "cancel"]);
 /** Whether a typed command runs right away while Nou works (see INSTANT); `/showme` counts only to look or step. */
 /**
  * The command a mistyped name means: the same letters in another order ("/termnial"), or one letter off
@@ -51,9 +51,10 @@ export const SLASH_COMMANDS = [
     { name: "models", args: "[provider]", description: "list the models a provider offers" },
     { name: "connect", args: "<provider>", description: "enter an API key (and URL) for a provider" },
     { name: "open", args: "<file>[:line]", description: "open a file in the code view (part of its name is enough)" },
+    { name: "rename", args: "[name]", description: "name this chat's tab (alone: back to its first message)" },
     { name: "follow", args: "[on|off]", description: "the code view shows each file the agent reads or edits as it works" },
     { name: "effort", args: "[fastest|fast|balanced|smarter|smartest]", description: "speed vs smarts: how hard the model thinks (cheaper + faster, or smarter)" },
-    { name: "workspace", args: "[new <folder> | n]", description: "several projects in this window, a tab each in the header: open one, or switch" },
+    { name: "workspace", args: "[new <folder> | n | rename <name>]", description: "several projects in this window, a tab each in the header: open one, or switch" },
     { name: "files", description: "find a file by part of its name (also Ctrl+P)" },
     { name: "actions", description: "every action Nou has, searchable, with its key (also ?)" },
     { name: "zoom", args: "in|out|reset", description: "make the code panel bigger or smaller (+ and - with the code focused, = resets)" },

package/dist/src/workspaces/host.js

@@ -33,7 +33,7 @@ export async function runHost(folders, firstArgs, command = [process.execPath, p
     let nextId = 1;
     const size = () => ({ cols: process.stdout.columns || 120, rows: process.stdout.rows || 40 });
     const send = (w, msg) => w.socket?.write(`${JSON.stringify(msg)}\n`);
-    const tabs = () => workspaces.map((w) => ({ id: w.id, name: tabName(w.folder), folder: w.folder, busy: w.busy, active: w === active }));
+    const tabs = () => workspaces.map((w) => ({ id: w.id, name: w.name || tabName(w.folder), folder: w.folder, busy: w.busy, active: w === active }));
     const broadcast = () => {
         const list = tabs();
         for (const w of workspaces)
@@ -63,6 +63,10 @@ export async function runHost(folders, firstArgs, command = [process.execPath, p
                 from.busy = msg.busy;
                 broadcast();
             }
+            else if (msg.type === "rename") {
+                from.name = msg.name.trim().slice(0, 30) || undefined;
+                broadcast();
+            }
             else if (msg.type === "switch") {
                 const to = workspaces[msg.index];
                 if (to && to !== active)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nou-cli",
-  "version": "0.5.16",
+  "version": "0.5.19",
   "description": "Nou: an IDE-style AI coding assistant for your terminal. Local (Ollama, LM Studio) and cloud (Claude, OpenAI, Gemini...) models, live diffs, git-aware, built-in editor.",
   "type": "module",
   "bin": {