nou-cli 0.5.3 → 0.5.6

package/README.md

@@ -50,7 +50,9 @@ 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. |
-| 🎮 **Games for a break** | Add Pong, Snake and Breakout in settings → Games, then `/games` opens a panel docked under the chat: it splits that column instead of covering anything. Drag its title onto the files, code or chat to dock it there, and × at its top right closes it. A game runs only while the panel has the keyboard: Esc goes back to your code and it waits. |
+| 🗂️ **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, 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. |
@@ -65,6 +67,7 @@ Needs **Node 22.12+** and an interactive terminal (Windows Terminal, PowerShell,
 | 🛞 **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. |
 
 Every change is reviewed like a code review:
 
@@ -98,11 +101,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. 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, × 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>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 (<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 (<kbd>Alt</kbd>+<kbd>Enter</kbd>: stop Nou and send it now) |
 | <kbd>Esc</kbd> | stop Nou (anything queued goes back in the input) · close a diff · back to chat |
 | <kbd>Ctrl</kbd>+<kbd>C</kbd> | stop Nou while it works · press twice to quit |
 
@@ -120,11 +126,11 @@ In the editor:
 | <kbd>Ctrl</kbd>+<kbd>K</kbd> · <kbd>Ctrl</kbd>+<kbd>G</kbd> | hover info · go to definition (with a language server) |
 | <kbd>Esc</kbd> | clear the selection, or leave the editor |
 
-Chat commands: `/settings` · `/model [provider:model]` · `/models [provider]` · `/pull <model>` · `/engine [name]` · `/auto [ask|auto-edit|auto]` · `/copy [code|file]` · `/undo` · `/rewind` · `/history` · `/diff [file or n]` · `/sessions` · `/problems` · `/compact` · `/clear` · `/resume [n|last]` · `/terminal` · `/help`
+Chat commands: `/settings` · `/model [provider:model]` · `/models [provider]` · `/pull <model>` · `/engine [name]` · `/auto [ask|auto-edit|auto]` · `/copy [code|file]` · `/undo` · `/rewind` · `/history` · `/diff [file or n]` · `/sessions` · `/problems` · `/compact` · `/clear` · `/resume [n|last]` · `/terminal` · `/showme <what you want>` · `/help`
 
 New lines in a message: <kbd>Shift</kbd>/<kbd>Ctrl</kbd>/<kbd>Cmd</kbd>+<kbd>Enter</kbd> in terminals that report them (kitty, Ghostty, WezTerm, iTerm2 and others with the kitty keyboard protocol), or type `\` and press <kbd>Enter</kbd> in any terminal.
 
-Conversations are saved per folder after each reply. `/resume` lists them and `/resume 2` (or `nou --continue` for the last one, `nou --resume` for the list) picks one back up with the engine it was on: Nou's own engine restores its messages, Claude Code its session and Codex its thread; pi is handed the conversation so far. Sessions you started in Claude Code's or Codex's own CLI in this folder are listed too (marked "CLI"), and resuming one carries it on in that engine inside Nou.
+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.
 
 ## 🧠 Models
 
@@ -167,6 +173,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/cli.js

@@ -14,6 +14,34 @@ 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 { 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:
@@ -109,8 +137,13 @@ async function main() {
         await ensureProjectContext(choice);
     const permContext = await loadPermanentContext();
     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();
     lsp.stopAll();
     p.outro(chalk.cyan("Bye bye!"));
 }

package/dist/src/config/index.js

@@ -26,6 +26,9 @@ export const DEFAULT_SETTINGS = {
     trustedFolders: [],
     games: [],
     gameDock: "chat",
+    terminalRows: null,
+    gameRows: null,
+    gameBest: {},
     plugins: {},
     trustedPlugins: {},
 };

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 } : {}),
         };

package/dist/src/games/index.js

@@ -12,8 +12,13 @@ function rng(seed) {
         return (s >>> 0) / 4294967296;
     };
 }
-const blank = (w, h) => Array.from({ length: h }, () => Array(w).fill(" "));
+const blank = (w, h) => Array.from({ length: Math.max(0, h) }, () => Array(Math.max(0, w)).fill(" "));
 const clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+/** Draws a character if (x, y) is on the grid: games never write outside it, whatever its size. */
+const put = (grid, x, y, ch) => {
+    if (grid[y]?.[x] !== undefined)
+        grid[y][x] = ch;
+};
 const PADDLE = 3;
 const PONG_WIN = 7;
 function serve(s, toward) {
@@ -26,8 +31,11 @@ export const pong = {
     blurb: "The classic: you on the left, the computer on the right. First to 7.",
     controls: "↑↓ or w/s move",
     tickMs: 50,
+    minWidth: 16,
+    minHeight: 6,
     colors: { "█": "#61afef", "●": "#e5c07b", "┊": "#5c6370" },
     create(w, h, seed = Date.now()) {
+        [w, h] = [Math.max(w, this.minWidth), Math.max(h, this.minHeight)];
         const s = { w, h, you: Math.floor((h - PADDLE) / 2), them: Math.floor((h - PADDLE) / 2), bx: 0, by: 0, vx: 0, vy: 0, scores: [0, 0], random: rng(seed) };
         return serve(s, -1);
     },
@@ -65,18 +73,16 @@ export const pong = {
     view(s) {
         const grid = blank(s.w, s.h);
         for (let y = 0; y < s.h; y += 2)
-            grid[y][Math.floor(s.w / 2)] = "┊";
+            put(grid, Math.floor(s.w / 2), y, "┊");
         for (let k = 0; k < PADDLE; k++) {
-            grid[s.you + k][1] = "█";
-            grid[Math.round(s.them) + k][s.w - 2] = "█";
+            put(grid, 1, s.you + k, "█");
+            put(grid, s.w - 2, Math.round(s.them) + k, "█");
         }
-        const bx = Math.round(s.bx);
-        const by = Math.round(s.by);
-        if (grid[by]?.[bx] !== undefined)
-            grid[by][bx] = "●";
+        put(grid, Math.round(s.bx), Math.round(s.by), "●");
         const [a, b] = s.scores;
         return {
             lines: grid.map((r) => r.join("")),
+            score: a,
             status: `you ${a} · ${b} computer   ↑↓ move`,
             ...(a >= PONG_WIN ? { over: "You win! ✦" } : b >= PONG_WIN ? { over: "The computer wins." } : {}),
         };
@@ -98,8 +104,13 @@ export const snake = {
     blurb: "Eat, grow, don't bite yourself or the walls.",
     controls: "arrows or wasd steer",
     tickMs: 110,
+    minWidth: 10,
+    minHeight: 5,
+    // A little faster with every few eaten, down to a floor.
+    speed: (s) => Math.max(55, 110 - Math.floor(s.score / 3) * 8),
     colors: { "█": "#98c379", "▓": "#7ec16e", "◆": "#e06c75" },
     create(w, h, seed = Date.now()) {
+        [w, h] = [Math.max(w, this.minWidth), Math.max(h, this.minHeight)];
         const y = Math.floor(h / 2);
         const s = { w, h, body: [{ x: 4, y }, { x: 3, y }, { x: 2, y }], dir: "right", food: { x: 0, y: 0 }, score: 0, dead: false, random: rng(seed) };
         return { ...s, food: placeFood(s) };
@@ -110,7 +121,7 @@ export const snake = {
         let dir = s.dir;
         // One turn per tick (the first that isn't straight back), so quick double taps don't fold it onto itself.
         for (const i of inputs) {
-            if (i !== OPPOSITE[dir] && i !== dir) {
+            if (i !== "action" && i !== OPPOSITE[dir] && i !== dir) {
                 dir = i;
                 break;
             }
@@ -126,36 +137,42 @@ export const snake = {
     },
     view(s) {
         const grid = blank(s.w, s.h);
-        grid[s.food.y][s.food.x] = "◆";
-        s.body.forEach((b, i) => {
-            if (grid[b.y]?.[b.x] !== undefined)
-                grid[b.y][b.x] = i === 0 ? "█" : "▓";
-        });
-        return { lines: grid.map((r) => r.join("")), status: `length ${s.body.length} · score ${s.score}`, ...(s.dead ? { over: `Game over: ${s.score} eaten.` } : {}) };
+        put(grid, s.food.x, s.food.y, "◆");
+        s.body.forEach((b, i) => put(grid, b.x, b.y, i === 0 ? "█" : "▓"));
+        return { lines: grid.map((r) => r.join("")), score: s.score, status: `length ${s.body.length} · score ${s.score}`, ...(s.dead ? { over: `Game over: ${s.score} eaten.` } : {}) };
     },
 };
 const PAD = 7;
 const BRICK_ROWS = 4;
 function launch(s) {
-    return { ...s, bx: s.paddle + PAD / 2, by: s.h - 3, vx: (s.random() < 0.5 ? -1 : 1) * 0.6, vy: -0.6 };
+    // Each level the ball starts a little faster.
+    const pace = 0.6 * (1 + (s.level - 1) * 0.12);
+    return { ...s, bx: s.paddle + PAD / 2, by: s.h - 3, vx: (s.random() < 0.5 ? -1 : 1) * pace, vy: -pace };
 }
+const wall = (w) => Array.from({ length: BRICK_ROWS }, () => Array(Math.floor(w / 3)).fill(true));
 export const breakout = {
     id: "breakout",
     title: "Breakout",
-    blurb: "Knock out every brick with the ball. Three lives.",
+    blurb: "Knock out every brick with the ball; each wall you clear brings a faster one. Three lives.",
     controls: "←→ or a/d move",
     tickMs: 45,
+    minWidth: 18,
+    minHeight: 9,
     colors: { "▀": "#e06c75", "▄": "#d19a66", "▬": "#61afef", "●": "#e5c07b" },
     create(w, h, seed = Date.now()) {
+        [w, h] = [Math.max(w, this.minWidth), Math.max(h, this.minHeight)];
         const s = {
             w, h, paddle: Math.floor((w - PAD) / 2), bx: 0, by: 0, vx: 0, vy: 0,
-            bricks: Array.from({ length: BRICK_ROWS }, () => Array(Math.floor(w / 3)).fill(true)), lives: 3, score: 0, random: rng(seed),
+            bricks: wall(w), lives: 3, score: 0, level: 1, random: rng(seed),
         };
         return launch(s);
     },
     tick(s, inputs) {
-        if (s.lives <= 0 || s.bricks.every((r) => r.every((b) => !b)))
+        if (s.lives <= 0)
             return s;
+        // A cleared wall: the next level, a little faster.
+        if (s.bricks.every((r) => r.every((b) => !b)))
+            return launch({ ...s, bricks: wall(s.w), level: s.level + 1 });
         let paddle = s.paddle;
         for (const i of inputs)
             paddle += i === "left" ? -2 : i === "right" ? 2 : 0;
@@ -195,23 +212,196 @@ export const breakout = {
         s.bricks.forEach((r, y) => r.forEach((alive, x) => {
             if (alive)
                 for (let k = 0; k < 3; k++)
-                    if (x * 3 + k < s.w - 0)
-                        grid[y + 1][x * 3 + k] = y % 2 ? "▄" : "▀";
+                    put(grid, x * 3 + k, y + 1, y % 2 ? "▄" : "▀");
         }));
         for (let k = 0; k < PAD; k++)
-            grid[s.h - 1][s.paddle + k] = "▬";
-        const bx = Math.round(s.bx);
-        const by = Math.round(s.by);
-        if (s.lives > 0 && grid[by]?.[bx] !== undefined)
-            grid[by][bx] = "●";
-        const cleared = s.bricks.every((r) => r.every((b) => !b));
+            put(grid, s.paddle + k, s.h - 1, "▬");
+        if (s.lives > 0)
+            put(grid, Math.round(s.bx), Math.round(s.by), "●");
         return {
             lines: grid.map((r) => r.join("")),
-            status: `score ${s.score} · lives ${"♥".repeat(Math.max(0, s.lives))}`,
-            ...(cleared ? { over: `Cleared! ${s.score} points ✦` } : s.lives <= 0 ? { over: `Game over: ${s.score} points.` } : {}),
+            score: s.score,
+            status: `level ${s.level} · score ${s.score} · lives ${"♥".repeat(Math.max(0, s.lives))}`,
+            ...(s.lives <= 0 ? { over: `Game over: ${s.score} points, level ${s.level}.` } : {}),
         };
     },
 };
+/** Rocks fall; slide along the bottom to dodge them and catch the stars. It gets busier as you last. */
+export const dodge = {
+    id: "dodge",
+    title: "Dodge",
+    blurb: "Rocks fall faster and thicker the longer you last. Catch ★ for points.",
+    controls: "←→ or a/d move",
+    tickMs: 90,
+    minWidth: 12,
+    minHeight: 6,
+    speed: (s) => Math.max(45, 90 - Math.floor(s.ticks / 60) * 5),
+    colors: { "▲": "#61afef", "●": "#d19a66", "★": "#e5c07b" },
+    create(w, h, seed = Date.now()) {
+        [w, h] = [Math.max(w, this.minWidth), Math.max(h, this.minHeight)];
+        return { w, h, x: Math.floor(w / 2), rocks: [], stars: [], score: 0, ticks: 0, dead: false, random: rng(seed) };
+    },
+    tick(s, inputs) {
+        if (s.dead)
+            return s;
+        let x = s.x;
+        for (const i of inputs)
+            x += i === "left" ? -1 : i === "right" ? 1 : 0;
+        x = clamp(x, 0, s.w - 1);
+        const fall = (p) => ({ x: p.x, y: p.y + 1 });
+        const rocks = s.rocks.map(fall).filter((p) => p.y < s.h);
+        let stars = s.stars.map(fall).filter((p) => p.y < s.h);
+        // More rocks per row as the game goes on.
+        const chance = Math.min(0.55, 0.18 + s.ticks / 900);
+        if (s.random() < chance)
+            rocks.push({ x: Math.floor(s.random() * s.w), y: 0 });
+        if (s.random() < 0.05)
+            stars.push({ x: Math.floor(s.random() * s.w), y: 0 });
+        const at = (p) => p.x === x && p.y === s.h - 1;
+        let score = s.score + (s.ticks % 10 === 9 ? 1 : 0);
+        if (stars.some(at)) {
+            score += 10;
+            stars = stars.filter((p) => !at(p));
+        }
+        const dead = rocks.some(at);
+        return { ...s, x, rocks, stars, score, ticks: s.ticks + 1, dead };
+    },
+    view(s) {
+        const grid = blank(s.w, s.h);
+        for (const r of s.rocks)
+            put(grid, r.x, r.y, "●");
+        for (const r of s.stars)
+            put(grid, r.x, r.y, "★");
+        put(grid, s.x, s.h - 1, "▲");
+        return { lines: grid.map((r) => r.join("")), score: s.score, status: `score ${s.score}`, ...(s.dead ? { over: `Hit! ${s.score} points.` } : {}) };
+    },
+};
+const HOP_X = 3;
+/** Run along the ground and hop the walls that come at you; they come faster as you go. */
+export const hop = {
+    id: "hop",
+    title: "Hop",
+    blurb: "Run and hop over the walls coming at you. One hit and it's over.",
+    controls: "↑ or Enter hops",
+    tickMs: 70,
+    minWidth: 20,
+    minHeight: 6,
+    speed: (s) => Math.max(35, 70 - Math.floor(s.score / 5) * 4),
+    colors: { "◉": "#98c379", "█": "#c678dd", "▔": "#5c6370" },
+    create(w, h, seed = Date.now()) {
+        [w, h] = [Math.max(w, this.minWidth), Math.max(h, this.minHeight)];
+        return { w, h, y: 0, vy: 0, walls: [], score: 0, ticks: 0, dead: false, random: rng(seed) };
+    },
+    tick(s, inputs) {
+        if (s.dead)
+            return s;
+        // Height above the ground; a hop goes up and comes back down.
+        let { y, vy } = s;
+        if (y === 0 && inputs.some((i) => i === "up" || i === "action"))
+            vy = 1.15;
+        y = Math.max(0, y + vy);
+        vy = y === 0 ? 0 : vy - 0.22;
+        const walls = s.walls.map((wl) => ({ ...wl, x: wl.x - 1 })).filter((wl) => wl.x >= 0);
+        const passed = s.walls.length - walls.length;
+        const last = walls[walls.length - 1];
+        // A new wall, far enough from the last that every gap can be cleared.
+        if ((!last || last.x < s.w - 9) && s.random() < 0.12)
+            walls.push({ x: s.w - 1, tall: 1 + Math.floor(s.random() * Math.min(2, s.h - 3)) });
+        const dead = walls.some((wl) => wl.x === HOP_X && Math.round(y) < wl.tall);
+        return { ...s, y, vy, walls, score: s.score + passed, ticks: s.ticks + 1, dead };
+    },
+    view(s) {
+        const grid = blank(s.w, s.h);
+        const ground = s.h - 1;
+        for (let x = 0; x < s.w; x++)
+            put(grid, x, ground, "▔");
+        for (const wl of s.walls)
+            for (let k = 1; k <= wl.tall; k++)
+                put(grid, wl.x, ground - k, "█");
+        put(grid, HOP_X, ground - 1 - Math.round(s.y), "◉");
+        return { lines: grid.map((r) => r.join("")), score: s.score, status: `walls hopped ${s.score}`, ...(s.dead ? { over: `Bonk! ${s.score} hopped.` } : {}) };
+    },
+};
+const SYMBOLS = ["◆", "●", "▲", "■", "★", "♥", "♣", "♠", "☀", "☂", "♪", "✿"];
+/** Cards face down: flip two at a time and find every matching pair in as few moves as you can. */
+export const pairs = {
+    id: "pairs",
+    title: "Pairs",
+    blurb: "Flip two cards at a time; find every matching pair in as few moves as you can.",
+    controls: "arrows move · Enter flips",
+    tickMs: 100,
+    minWidth: 16,
+    minHeight: 5,
+    colors: { "◆": "#e06c75", "●": "#e5c07b", "▲": "#61afef", "■": "#98c379", "★": "#e5c07b", "♥": "#e06c75", "♣": "#98c379", "♠": "#c678dd", "☀": "#d19a66", "☂": "#56b6c2", "♪": "#c678dd", "✿": "#56b6c2", "▒": "#5c6370", "▸": "#e5c07b", "◂": "#e5c07b" },
+    create(w, h, seed = Date.now()) {
+        [w, h] = [Math.max(w, this.minWidth), Math.max(h, this.minHeight)];
+        // As many cards as fit (each 4 wide, rows 2 apart), an even number, up to every symbol twice.
+        const cols = Math.max(2, Math.min(6, Math.floor(w / 4)));
+        const rows = Math.max(2, Math.min(4, Math.floor((h + 1) / 2)));
+        const count = Math.min(SYMBOLS.length * 2, cols * rows - ((cols * rows) % 2));
+        const random = rng(seed);
+        const deck = SYMBOLS.slice(0, count / 2).flatMap((sym) => [sym, sym]);
+        for (let i = deck.length - 1; i > 0; i--) {
+            const j = Math.floor(random() * (i + 1));
+            [deck[i], deck[j]] = [deck[j], deck[i]];
+        }
+        return { cols, rows, w, h, cards: deck, found: deck.map(() => false), open: [], cursor: 0, moves: 0, wait: 0 };
+    },
+    tick(s, inputs) {
+        if (s.found.every(Boolean))
+            return s;
+        let { cursor, open, found, moves, wait } = s;
+        // Two face-up cards that don't match stay shown a moment, then turn back over.
+        if (open.length === 2 && wait > 0) {
+            wait--;
+            if (wait === 0)
+                open = [];
+            return { ...s, open, wait };
+        }
+        const n = s.cards.length;
+        for (const i of inputs) {
+            if (i === "left")
+                cursor = (cursor + n - 1) % n;
+            else if (i === "right")
+                cursor = (cursor + 1) % n;
+            else if (i === "up")
+                cursor = cursor - s.cols >= 0 ? cursor - s.cols : cursor;
+            else if (i === "down")
+                cursor = cursor + s.cols < n ? cursor + s.cols : cursor;
+            else if (i === "action" && !found[cursor] && !open.includes(cursor) && open.length < 2) {
+                open = [...open, cursor];
+                if (open.length === 2) {
+                    moves++;
+                    if (s.cards[open[0]] === s.cards[open[1]]) {
+                        found = found.map((f, k) => f || open.includes(k));
+                        open = [];
+                    }
+                    else
+                        wait = 8;
+                }
+            }
+        }
+        return { ...s, cursor, open, found, moves, wait };
+    },
+    view(s) {
+        const grid = blank(s.w, s.h);
+        s.cards.forEach((card, i) => {
+            const x = (i % s.cols) * 4;
+            const y = Math.floor(i / s.cols) * 2;
+            const shown = s.found[i] || s.open.includes(i);
+            if (i === s.cursor) {
+                put(grid, x, y, "▸");
+                put(grid, x + 2, y, "◂");
+            }
+            put(grid, x + 1, y, s.found[i] ? card : shown ? card : "▒");
+        });
+        const done = s.found.every(Boolean);
+        const pairsLeft = s.found.filter((f) => !f).length / 2;
+        // Fewer moves is better: the score counts what you saved.
+        const score = Math.max(0, s.cards.length * 2 - s.moves);
+        return { lines: grid.map((r) => r.join("")), score, status: `moves ${s.moves} · ${pairsLeft} pairs left`, ...(done ? { over: `All found in ${s.moves} moves ✦` } : {}) };
+    },
+};
 /** Every game Nou has, in the order settings lists them. */
-export const GAMES = [pong, snake, breakout];
+export const GAMES = [pong, snake, breakout, dodge, hop, pairs];
 export const gameById = (id) => GAMES.find((g) => g.id === id);