nou-cli 0.5.6 → 0.5.10

package/README.md

@@ -50,8 +50,10 @@ 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. |
+| 👀 **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). |
@@ -64,10 +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:
 
@@ -101,14 +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 |
 
@@ -126,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 (then type a number to pick one) 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
 

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

@@ -15,6 +15,11 @@ 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";
@@ -47,6 +52,7 @@ 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
@@ -76,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);
@@ -136,6 +160,10 @@ 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.
@@ -144,6 +172,14 @@ async function main() {
     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,

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/guide/index.js

@@ -98,3 +98,78 @@ export function guideProgress(typed, expected) {
     }
     return j;
 }
+export const SHOW_PLACES = "show_places";
+/** Stops as the model gave them, kept when usable: a file in the project and a line. */
+export function tidyStops(raw) {
+    return (Array.isArray(raw) ? raw : [])
+        .filter((s) => typeof s?.file === "string" && s.file.trim() && Number(s.line) >= 1)
+        .map((s) => {
+        const line = Math.floor(Number(s.line));
+        const end = Math.max(line, Math.floor(Number(s.end_line ?? s.end ?? line)) || line);
+        return { file: path.relative(process.cwd(), path.resolve(s.file)).split(path.sep).join("/"), line, end, note: String(s.note ?? s.why ?? "").trim() };
+    })
+        .filter((s) => !s.file.startsWith(".."))
+        .slice(0, 12);
+}
+/** The tool Nou's own engine points at places with. `onStops` gets them. */
+export function showPlacesTool(onStops) {
+    return {
+        definition: {
+            name: SHOW_PLACES,
+            description: "When you explain how something works or where something happens in this project, point at the exact places so the user sees them: Nou opens each one in their code view, highlighted, in the order given. Call it once, after you've read the code, with the parts that matter (usually 1-6).",
+            parameters: {
+                type: "object",
+                properties: {
+                    places: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                file: { type: "string", description: "Project-relative path." },
+                                line: { type: "number", description: "First line of the part (1-based)." },
+                                end_line: { type: "number", description: "Last line of the part." },
+                                note: { type: "string", description: "One or two plain sentences: what this part does, in terms of the explanation." },
+                            },
+                            required: ["file", "line", "end_line", "note"],
+                        },
+                    },
+                },
+                required: ["places"],
+            },
+        },
+        readOnly: true,
+        source: "nou",
+        run: (args) => {
+            const stops = tidyStops(args.places);
+            if (!stops.length)
+                return "No usable places: each needs a project file and a line. Call show_places again.";
+            onStops(stops);
+            return `Shown to the user: ${stops.length} place${stops.length > 1 ? "s" : ""}, opening the first. Now explain in the order of the places, naming each as path:line.`;
+        },
+    };
+}
+/** The fenced block other engines (which can't call Nou's tools) list their places in. */
+const SHOW_BLOCK = /```nou-show\s*\n([\s\S]*?)\n```/;
+/**
+ * For Claude Code, Codex and pi, which can't call show_places: how to point at places, added to what they
+ * know about the project, so explaining "where does X happen" opens the files on any engine.
+ */
+export const SHOW_PLACES_NOTE = "When you explain how something in this project works or where something happens, end your reply with the exact places, in the order to read them, as a JSON array in a fenced block marked nou-show. The user's editor opens each one highlighted:\n```nou-show\n[{\"file\": \"src/auth/session.ts\", \"line\": 40, \"end_line\": 58, \"note\": \"Checks the token and refuses expired ones.\"}]\n```\nOnly for places in this project you've actually read; leave it out when nothing needs showing.";
+/** The message /showme sends: explain, and point at the places. */
+export function explainPrompt(question, withTool) {
+    const how = withTool ? `call ${SHOW_PLACES} with them` : "list them in a nou-show block at the end, as described";
+    return `[Show me] ${question}\n\nExplain this to me and show me where it happens in the code. Don't change any files. Read what you need, find the exact places (file and line range) that matter, ${how}, in the order to read them, and explain in that order, naming each as path:line.`;
+}
+/** Places from a reply's ```nou-show block, and the reply without it; null when there's none. */
+export function stopsFromReply(text) {
+    const m = SHOW_BLOCK.exec(text);
+    if (!m)
+        return null;
+    try {
+        const stops = tidyStops(JSON.parse(m[1]));
+        return { stops, rest: text.replace(m[0], "").trim() };
+    }
+    catch {
+        return null;
+    }
+}