chesspal 0.1.0 → 0.2.1

package/README.md

@@ -1,99 +1,71 @@
 # Chesspal
 
-Play chess against an AI, or learn with one.
+Play chess against an AI on a real board, or learn with one.
 
-You can already play chess with an AI in a chat, but it forgets the position, plays illegal moves, sees no board and remembers nothing of yesterday's
-game. Chesspal is what it lacks: it **keeps the rules, the board, the clock, the games and the memory**; the AI **plays, reasons, judges and talks**. A
-move is legal because Chesspal checked it, not because the AI says so.
+![The board page during a game: the AI's words on the left, the board in the middle, the opening's name and the moves on the right](https://raw.githubusercontent.com/stefanocaronia/chesspal/main/docs/screenshot.png)
 
-Chesspal does not use a chess engine such as Stockfish, in any way: every judgment of a move or a position is the AI's own. Chesspal hands it facts
-instead, which a program finds in microseconds and an AI only by reasoning at length: the legal moves, the pieces attacked and defended, the pins and
-the checks, the positional facts, the opening's name.
+## Get started
 
-## What you can do
+You need [Node.js](https://nodejs.org) 22.13 or newer and an AI agent on your computer, [Claude Code](https://code.claude.com/docs/en/setup) or [Codex](https://developers.openai.com/codex): see [what you need](#what-you-need). Open a new terminal, after installing Node.js (one opened before does not find `npm`), and type:
 
-- **Play against the AI** on the board page in your browser, and talk with it there or in the chat.
-- **Choose its level**, from beginner to master: the higher, the more facts of the position the AI sees, and the master knows the opening book.
-- **Play with a clock**, with an AI that knows how much time it has left; offer a draw, resign, export the game as PGN.
-- **Keep a profile** for each player at the same computer, with their games.
-
-Coming later: an AI coach that helps you grow, the discursive analysis of your games, exercises chosen on your weak points, a rating worked out from your
-games, and an opponent with a character and moods of its own.
-
-## Status
-
-Chesspal is in early development: the version on npm is a first one to try, and it may change from one release to the next. It works with any AI agent that uses MCP tools and can work with the files on your computer;
-we develop it with Claude Code, and Codex is connected too. Chesspal never uses an API key: the AI runs on your agent's own plan, or on your computer
-with a local model.
-
-## Play
-
-**What you need**
-
-- [Node.js](https://nodejs.org) 22.13 or newer: download the version marked LTS and install it like any program.
-- An AI agent on your computer: [Claude Code](https://code.claude.com/docs/en/setup), in a terminal or in the Code tab of the Claude desktop app, or
-  [Codex](https://developers.openai.com/codex). The AI runs on what you already pay for your agent, such as your Claude or ChatGPT subscription:
-  Chesspal asks for no API key.
-- A terminal, opened after installing Node.js: on Windows, Command Prompt (press Start, type `cmd`, press Enter), since PowerShell refuses npm's
-  commands until its scripts are allowed (there, `npm.cmd` and `chesspal.cmd` work in their place); on a Mac, Terminal, in Applications › Utilities.
-
-**Your first game**
+```bash
+npm install -g chesspal
+chesspal init chess
+cd chess
+claude
+```
 
-1. **Install Chesspal**:
+- `npm install -g` installs the `chesspal` command for the whole computer, where your agent finds it.
+- `chesspal init chess` makes the folder `chess` to play in. Any name will do; your games are kept [elsewhere](#where-your-games-are).
+- `claude` opens Claude Code in that folder (in the Claude desktop app, choose the folder in the Code tab). With Codex, type `codex`, and when it asks about Chesspal's two hooks, choose **Trust all and continue**.
+- The first time, your agent asks whether you trust the folder: say yes.
 
-   ```bash
-   npm install -g chesspal
-   ```
+Then **say hello**. The AI answers with the link to the board page: open it in your browser, tell it who you are, and ask for a game. You choose your colour, the clock and the AI's level, and play on the board.
 
-2. **Make a folder to play in**: this makes the folder `chess`, with the few files that tell your agent where Chesspal is and how to play. Any name
-   will do; your games are not kept there but in [one folder for all](#where-your-games-are).
+On Windows, use Command Prompt (press Start, type `cmd`, press Enter). PowerShell, on a new computer, refuses npm's commands with "running scripts is disabled on this system"; there, type `Set-ExecutionPolicy -Scope CurrentUser RemoteSigned` once and answer yes, or use Command Prompt. Codex on Windows also offers to set up its sandbox the first time: choose the first option, and answer yes when Windows asks for permission.
 
-   ```bash
-   chesspal init chess
-   ```
+## What it does
 
-3. **Open your agent in that folder**: type `cd chess`, which takes the terminal into it, then `claude` or `codex`; in the Claude desktop app, choose
-   the folder in the Code tab. The first time, it asks whether to trust the folder: say yes. In Codex, also type `/hooks` and allow Chesspal's two
-   hooks: small helpers that let it notice your moves on the board page.
+An AI in a plain chat forgets the position, plays illegal moves and sees no board. Chesspal is what it lacks: it **keeps the rules, the board, the clock and your games**; the AI **plays, reasons and talks**. Every move is checked by Chesspal, and no chess engine plays for the AI: every judgment is its own, made from the facts Chesspal hands it, such as the legal moves, the pieces attacked and defended, the pins and the opening's name.
 
-4. **Say hello**: the AI gives you the link to the board page, a page on your own computer; open it in your browser. No link? Ask the AI for the
-   board. The first time, the page asks who you are: your name, a picture, how well you play.
+- **Play on a board** in your browser, and talk with the AI there or in the chat.
+- **Choose its level**, from beginner to master: the higher, the more of the position the AI sees.
+- **Play with a clock**, against an AI that knows how much time it has left; offer a draw, resign, save the game as PGN.
+- **Go over a game** with the AI when it is over: its notes show on the board page, in Analyses. Games from other sites come in as PGN files.
+- **Keep a profile** for each player at the same computer, with their games.
 
-5. **Ask for a game**: the New game window opens on the page, where you choose your colour, the clock and the AI's level. Play on the board: that is
-   where the game is. A move written in the chat counts too, `e4`, `Nf3`, in the international notation (K Q R B N in every language), or in words.
+Coming later: an AI coach that helps you grow, exercises chosen on your weak points, a rating worked out from your games, an opponent with a character and moods of its own, and local models.
 
-6. **For the next game**, type `/clear` in the chat, or start a new chat: a long chat makes the AI slower and costs you more.
+## What you need
 
-When a game is over, ask the AI to go over it with you: its notes show on the board page, in Analyses. A game you played on another site comes in
-there too: download it from that site as a PGN file and open it in Analyses.
+- **Node.js 22.13** or newer: download the version marked LTS and install it like any program.
+- **An AI agent** with your own subscription: Claude Code, with a paid Claude plan, or Codex, with a ChatGPT account. Chesspal never uses an API key, which is paid by the call: sign your agent in with your account.
+- **A web browser**, for the board page.
 
-**To update Chesspal**, close the chat, run `npm install -g chesspal` again, then `chesspal init` in your folder: it updates its own lines and keeps
-what you wrote there. In Codex, when `chesspal init` says so, allow Chesspal's hooks again in `/hooks`.
+Chesspal works with any agent that supports MCP tools and can work with the files on your computer: we develop it with Claude Code, and Codex is connected too.
 
-## How it works
+## Good to know
 
-Chesspal is an MCP server, a command line, `chesspal`, and a board page, all made from the same commands. `chesspal init` sets up a folder to play in:
-the few files that tell the AI agent where Chesspal is, and its instructions as an opponent. Your profiles, games and analyses live in one folder for
-every folder you play in ([where your games are](#where-your-games-are)), or in the folder `CHESSPAL_HOME` names, for tests. Only Chesspal's commands
-change them: they check every move with [chess.js](https://github.com/jhlywa/chess.js) and write atomically.
+- **For the next game**, type `/clear` in the chat or start a new one: a long chat makes the AI slower and costs you more.
+- **A move written in the chat** counts too: `e4`, `Nf3`, in the international notation (K Q R B N in every language), or in words.
+- **To update**, close the chat, run `npm install -g chesspal` again, then `chesspal init` in your folder: it updates its own lines and keeps what you wrote there. In Codex, allow the hooks again when it says so.
 
 ## Where your games are
 
-Your players and their games are in one folder, the same whatever folder you open the chat in:
+In one folder for every folder you play in:
+
+- Windows: `Documents › My Games › Chesspal`, inside OneDrive if you use it;
+- macOS: `Documents › Chesspal`; Linux: `Chesspal` in your Documents folder.
 
-- on Windows, `Documents › My Games › Chesspal`. Explorer may show Documents in your language, such as Documenti. With OneDrive, it is inside
-  OneDrive, which also keeps a copy online;
-- on macOS, `Documents › Chesspal`; on Linux, `Chesspal` in your Documents folder, whatever its name in your language.
+The board page shows where, and its **Open the folder** button opens it. To back up your games, copy that whole folder; to move them to another computer, put the copy in the same place there. Do it with the chat and the board page closed.
 
-The board page says where it is, on its welcome page and in "Who's playing?", and its **Open the folder** button opens it.
+## Try it, and tell us
 
-**A backup** is a copy of the whole `Chesspal` folder, on a USB stick for example. **To move to another computer**, install Chesspal there and put the
-copied `Chesspal` folder in the same place, replacing the one Chesspal may have made already: your players, their games and a game left unfinished all
-come with it. Copy it with the chat and the board page closed.
+Chesspal is in early development: the version on npm is a first one to try, and it may change from one release to the next. When something breaks, confuses you or could work better, open an [issue on GitHub](https://github.com/stefanocaronia/chesspal/issues): what you did, what you expected, what happened.
 
 ## Development
 
-You need Node.js 22.13 or newer.
+Chesspal is an MCP server, a command line and a board page, all made from the same commands, which check every move with [chess.js](https://github.com/jhlywa/chess.js) and write the games atomically.
 
 ```bash
 git clone https://github.com/stefanocaronia/chesspal.git
@@ -103,28 +75,19 @@ npm run build
 npm test
 ```
 
-- `npm run lint` checks the formatting and the types, as CI does; `npm run format` formats the code.
-- `npm run page -- <folder>` serves the board page of a player's folder, with the data of `CHESSPAL_HOME` or Documents, to look at it while it is built.
-- `npm run endings` shows the ends of a game on the board: checkmate, resignation, a flag fallen, the draws.
-- `npm run bench` times the commands against their budgets.
-- `npm run smoke`, after the build, packs the package, installs it in a temporary folder and runs it as a player would: its version, `chesspal init`
-  and its MCP server, as CI does.
-
-[AGENTS.md](AGENTS.md) is the guide for development: the layout, the architecture's rules, performance, the coding guidelines. It is written for AI
-coding agents and people alike.
+[The guide for development](https://github.com/stefanocaronia/chesspal/blob/main/AGENTS.md), for people and AI coding agents alike, holds the other scripts, the layout, the architecture's rules and the coding guidelines.
 
 ## Credits
 
 - The rules: [chess.js](https://github.com/jhlywa/chess.js), under the BSD 2-Clause license.
 - The openings' names: Lichess's [chess-openings](https://github.com/lichess-org/chess-openings), under CC0.
-- The pieces: the Torretta and Nitida sets are Chesspal's own; cburnett is by Colin M.L. Burnett, under the BSD 3-Clause license.
-  [The piece sets' credits](src/page/pieces/CREDITS.md) name every author, licence and source.
+- The pieces: Nitida, Torretta and Capablanca are Chesspal's own, the last after the diagrams of Capablanca's *Chess Fundamentals* (1921), in the public domain; they are free to use under CC BY 4.0, crediting "Stefano Caronia, Chesspal". [The piece sets' credits](https://github.com/stefanocaronia/chesspal/blob/main/src/page/pieces/CREDITS.md).
 
 Chesspal ships only original or open-licensed content, and no GPL dependency.
 
 ## License
 
-[MIT](LICENSE).
+[MIT](https://github.com/stefanocaronia/chesspal/blob/main/LICENSE).
 
 ## Development notes
 
@@ -136,4 +99,4 @@ Fight corporate control of technology, not our right to use it.
 
 ---
 
-© 2026 [Stefano Caronia](https://stefanocaronia.it) · [GitHub](https://github.com/stefanocaronia/chesspal)
+© 2026 [Stefano Caronia](https://stefanocaronia.it) · [GitHub](https://github.com/stefanocaronia/chesspal) · [npm](https://www.npmjs.com/package/chesspal)

package/dist/cli/chat-hook.js

@@ -1,4 +1,4 @@
-// `chesspal chat`, the SessionStart hook of Claude Code and Codex (D-57, T-104): it writes how the chat started, new, cleared, resumed or compacted, for new_game to read.
+// `chesspal chat`, the SessionStart hook of Claude Code and Codex (D-57): it writes how the chat started, new, cleared, resumed or compacted, for new_game to read.
 import { saveChatStart } from "../games/index.js";
 /** Reads the hook's input and writes how the chat started; a failure is told on stderr and never stops the chat. */
 export async function recordChatStart(input = process.stdin, folder = process.cwd(), now = new Date()) {

package/dist/cli/command-line.d.ts

@@ -1,5 +1,4 @@
-import { type Context } from "../commands/context.ts";
-import { type AnyCommand } from "../commands/registry.ts";
+import { type AnyCommand, type Context } from "../commands/index.ts";
 export interface CommandLineResult {
     output: string;
     exitCode: number;

package/dist/cli/command-line.js

@@ -1,7 +1,6 @@
+// The `chesspal` command line: a command's input read from the arguments, its result written for a person.
 import { parseArgs } from "node:util";
-import { defaultContext } from "../commands/context.js";
-import { commands } from "../commands/index.js";
-import { baseType, commandLineFieldProblem, inputProblems, isBoolean, isList, takesNumbers } from "../commands/registry.js";
+import { baseType, commandLineFieldProblem, commands, defaultContext, inputProblems, isBoolean, isList, takesNumbers } from "../commands/index.js";
 import { version } from "../version.js";
 // The commands that exist only on the command line: cli.ts starts the server, the doorbell or the chat's note, when one comes alone.
 const mcpDescription = "Start the MCP server for an AI host. Through it the host uses these commands as tools; the host starts it, with no options.";

package/dist/commands/agents.d.ts

@@ -0,0 +1,26 @@
+import { type CurrentGame } from "../games/index.ts";
+import type { Context } from "./context.ts";
+import type { GameSummary } from "./game-summary.ts";
+/** Whether an analyst agent goes over a game over when the player wants: in Claude Code, with its agent in the player's folder (D-89). */
+export declare function analystRuns(context: Context): boolean;
+/**
+ * The game over, with the analyst agent that goes over it when the player wants, where it runs (D-89); over, the game from status and ai_say, which come after
+ * its end: once it is in analysis, by the agent or the chat, or reviewed, the chat goes over that review and never starts the agent again (Stefano).
+ */
+export declare function withAnalyst(summary: GameSummary, context: Context, over?: CurrentGame): GameSummary;
+/** How the chat has a game over gone over by the analyst agent, on the player's yes or for the game they brought (D-89). */
+export declare function analystLine(game?: string): string;
+/** How the chat goes over a game the analyst agent has reviewed, or is reviewing: from that review, never with another agent (Stefano). */
+export declare function reviewedLine(game?: string): string;
+/** Whether a coach judges the player's moves when the helps are on: in Claude Code, with its agent in the player's folder (D-80, D-88). */
+export declare function coachRuns(context: Context): boolean;
+/**
+ * Whether to start the coach after the player's own move has ended the game on the board, with the helps on: it judges that move too (D-88). Told again
+ * until it starts, since a chat woken by the page may lose the line on its way to its words (Priya).
+ */
+export declare function coachOnEnd(context: Context, folder: string, current: CurrentGame): boolean;
+/**
+ * How to start the agents, in one message, the one that thinks first, since it needs the time (Priya), and that the player sees nothing of
+ * them: their end needs no answer either. The end of the last move's agents, told just after, must not take their place (Priya).
+ */
+export declare function agentsLine(agents: readonly string[]): string;

package/dist/commands/agents.js

@@ -0,0 +1,72 @@
+// The agents that work beside the chat in Claude Code: the analyst that goes over a game over (D-89) and the coach that judges the player's moves (D-88).
+import { isReviewed } from "../core/index.js";
+import { archivedGame, archivedName, coachStarted, gameInAnalysis } from "../games/index.js";
+import { analystAgent, coachAgent, hasAgent } from "../host-files/index.js";
+import { gameFolder, helpsIn } from "../profiles/index.js";
+/** Whether an analyst agent goes over a game over when the player wants: in Claude Code, with its agent in the player's folder (D-89). */
+export function analystRuns(context) {
+    return context.host?.() === "claude-code" && hasAgent(context.folder, analystAgent);
+}
+/**
+ * The game over, with the analyst agent that goes over it when the player wants, where it runs (D-89); over, the game from status and ai_say, which come after
+ * its end: once it is in analysis, by the agent or the chat, or reviewed, the chat goes over that review and never starts the agent again (Stefano).
+ */
+export function withAnalyst(summary, context, over) {
+    const { end } = summary;
+    if (end === undefined || !analystRuns(context)) {
+        return summary;
+    }
+    return { ...summary, end: { ...end, analyst: over !== undefined && goneOver(context, over) ? "done" : "offer" } };
+}
+/** How the chat has a game over gone over by the analyst agent, on the player's yes or for the game they brought (D-89). */
+export function analystLine(game) {
+    return `start the chesspal-analyst agent in the background with the prompt "Analyse${game === undefined ? "" : ` ${game}`}. The player speaks <their language>.": it writes its review on the board `
+        + "page, which shows it at work; tell the player in a word, and when it ends go over the game with them from what it tells you.";
+}
+/** How the chat goes over a game the analyst agent has reviewed, or is reviewing: from that review, never with another agent (Stefano). */
+export function reviewedLine(game) {
+    return "The analyst agent has gone over this game, or is at it: never start it again. When the player wants it gone over, go over it with them from what "
+        + `it told you, or, in a chat without it, from its review on the board page, which analyse_game ${game === undefined ? "" : `{"game": "${game}"} `}gives.`;
+}
+/** Whether a coach judges the player's moves when the helps are on: in Claude Code, with its agent in the player's folder (D-80, D-88). */
+export function coachRuns(context) {
+    return context.host?.() === "claude-code" && hasAgent(context.folder, coachAgent);
+}
+/**
+ * Whether to start the coach after the player's own move has ended the game on the board, with the helps on: it judges that move too (D-88). Told again
+ * until it starts, since a chat woken by the page may lose the line on its way to its words (Priya).
+ */
+export function coachOnEnd(context, folder, current) {
+    const { game, ai } = current;
+    return game.outcome.over && game.position.turn === ai && helpsIn(folder) && coachRuns(context) && !coachStarted(folder, current);
+}
+/**
+ * How to start the agents, in one message, the one that thinks first, since it needs the time (Priya), and that the player sees nothing of
+ * them: their end needs no answer either. The end of the last move's agents, told just after, must not take their place (Priya).
+ */
+export function agentsLine(agents) {
+    const prompt = (agent) => `the prompt "${agent === coachAgent ? "Coach." : "Ponder."}"`;
+    const [first = "", second] = agents;
+    if (second === undefined) {
+        const why = first === coachAgent ? "Coach the player" : "Think on the player's time";
+        return `${why}: start the ${first} agent in the background with ${prompt(first)}; start it even when an agent of the move before has just ended, `
+            + "and write nothing about it in the chat, now or when it ends.";
+    }
+    return `Think on the player's time and coach them: in one message, start two agents in the background, ${first} with ${prompt(first)} and ${second} with `
+        + `${prompt(second)}; start them even when an agent of the move before has just ended, and write nothing about them in the chat, now or when they end.`;
+}
+/** Whether the game over is gone over already: in analysis now, by the analyst agent or the chat, or reviewed, whatever the page opened since (Federico). */
+function goneOver(context, over) {
+    const folder = gameFolder(context.home());
+    const archived = archivedName(folder, over);
+    if (archived === undefined || gameInAnalysis(folder)?.game === archived) {
+        return archived !== undefined;
+    }
+    try {
+        return isReviewed(archivedGame(folder, archived));
+    }
+    catch {
+        // A game the archive cannot read is offered as it would be: the analyst says what is wrong with it.
+        return false;
+    }
+}

package/dist/commands/ai-move.d.ts

@@ -5,18 +5,6 @@ export declare const aiMove: import("./registry.ts").Command<z.ZodObject<{
     move: z.ZodString;
     plan: z.ZodString;
     comment: z.ZodOptional<z.ZodString>;
-    badge: z.ZodOptional<z.ZodEnum<{
-        brilliant: "brilliant";
-        great: "great";
-        best: "best";
-        excellent: "excellent";
-        good: "good";
-        inaccuracy: "inaccuracy";
-        mistake: "mistake";
-        miss: "miss";
-        blunder: "blunder";
-    }>>;
-    note: z.ZodOptional<z.ZodString>;
     arrows: z.ZodOptional<z.ZodArray<z.ZodString>>;
     squares: z.ZodOptional<z.ZodArray<z.ZodString>>;
     offer_draw: z.ZodOptional<z.ZodBoolean>;
@@ -29,9 +17,12 @@ export declare const aiMove: import("./registry.ts").Command<z.ZodObject<{
         sad: "sad";
     }>>;
 }, z.core.$strip>, Played>;
-/** The AI's move, the agent that thinks on the player's time when the host runs one (D-72), and whether the player sees no board page, so the AI copies the board (D-85). */
+/**
+ * The AI's move, the agents to start on the player's time when the host runs them (D-72, D-88), and whether the player sees no board page, so the AI
+ * copies the board (D-85).
+ */
 type Played = MovePlayed & {
-    ponder?: string;
+    agents?: string[];
     board?: true;
 };
 export {};

package/dist/commands/ai-move.js

@@ -1,15 +1,15 @@
 import { z } from "zod";
-import { badges, boardText, drawingsText, moods, moodTag } from "../core/index.js";
+import { boardText, drawingsText, moods, moodTag } from "../core/index.js";
 import { commentWithPlan, talkLimits } from "../games/index.js";
-import { hasPonderAgent, ponderAgentFor } from "../host-files/index.js";
+import { coachAgent, hasAgent, ponderAgentFor } from "../host-files/index.js";
 import { gameFolder, helpsIn } from "../profiles/index.js";
-import { arrowsInput, drawingsOf, noteInput, squaresInput } from "./drawings.js";
-import { closingLines, moveLines, shownMove } from "./game-summary.js";
+import { agentsLine, coachRuns, withAnalyst } from "./agents.js";
+import { closingLines, moveLines, shownMove } from "./answer-lines.js";
+import { arrowsInput, drawingsOf, squaresInput } from "./drawings.js";
+import {} from "./game-summary.js";
 import { playMove, refuseUnseenPosition } from "./play-move.js";
 import { defineCommand, sentence } from "./registry.js";
 import { give, waitingWords } from "./say.js";
-// The badges the opponent gives: the book's is Chesspal's, never its own judgment (D-69).
-const judgments = badges.filter((badge) => badge !== "book");
 /** The AI's move, with its plan, kept hidden (D-29), and its comment for the player when it has something to say (D-12, D-54). */
 export const aiMove = defineCommand({
     name: "ai_move",
@@ -23,11 +23,8 @@ export const aiMove = defineCommand({
         comment: sentence(talkLimits.aiHelps).optional().describe(`your words for the player, in one sentence of ${talkLimits.ai} characters at most, only when there is something to say: pieces and moves in words ("your `
             + `knight takes on f6"), a move you write with the pieces' figurines, as the tools show it (♞xf6+ for Nxf6+); your plans and threats only with the helps on, and then as long as a note of ${talkLimits.aiHelps} `
             + "characters, to teach; **two asterisks** put a word or two in bold on the page"),
-        badge: z.enum(judgments).optional().describe("only with the helps on: your badge on the player's last move, as chess.com names them, only on a move that stands out (a mistake, a miss, a fine find), "
-            + "never on a routine one"),
-        note: noteInput.optional().describe("only with the helps on: why, on the player's last move, in a sentence or two"),
-        arrows: arrowsInput.describe("only with the helps on: arrows on the board after your move, to show what your comment says, never your move itself: Rf2e1; G green: the better move or "
-            + "the good idea; R red: a threat or the mistake; Y yellow: another way; B blue: a plan"),
+        arrows: arrowsInput.describe("only with the helps on: arrows on the board after your move, to show what your comment says, never your move itself: Rf2e1; G green: a good idea; "
+            + "R red: a threat or the mistake; Y yellow: another way; B blue: a plan"),
         squares: squaresInput.describe("only with the helps on: squares to mark after your move, as PGN's %csl writes them: Rf2; colours as for arrows"),
         offer_draw: z.boolean().optional().describe("true offers the player a draw with this move: it stands until their move"),
         mood: z.enum(moods).optional().describe("how you feel, on a move where the game turns for you: your face on the board page shows it for three of your moves, this one included (a surprise for this one "
@@ -36,25 +33,21 @@ export const aiMove = defineCommand({
     alwaysLoad: true,
     showsGame: true,
     positionals: ["move"],
-    run: ({ move, plan, comment, offer_draw: offerDraw = false, mood, badge, note, arrows, squares }, context) => {
+    run: ({ move, plan, comment, offer_draw: offerDraw = false, mood, arrows, squares }, context) => {
         const folder = gameFolder(context.home());
         refuseUnseenPosition(context, folder);
-        refuseWithoutHelps(folder, { comment, badge, note, arrows, squares });
+        refuseWithoutHelps(folder, { comment, arrows, squares });
         const drawings = drawingsOf(arrows, squares);
         // The player's words are read before the move, which would count as the answer to them; a move refused leaves them for the next call.
         const waiting = waitingWords(context);
         const words = [commentWithPlan(comment, plan), drawingsText(drawings), mood === undefined ? "" : moodTag(mood)].filter((part) => part !== "").join(" ");
-        const played = playMove(folder, context.now(), "ai", move, (message, legal) => `${message} Legal: ${legal.join(" ")}. Nothing changed.`, {
-            comment: words,
-            offerDraw,
-            ...(badge === undefined && note === undefined ? {} : { judged: { ...(badge === undefined ? {} : { badge }), ...(note === undefined ? {} : { note }) } }),
-        });
-        const agent = ponderAgent(context, played);
+        const played = playMove(folder, context.now(), "ai", move, (message, legal) => `${message} Legal: ${legal.join(" ")}. Nothing changed.`, { comment: words, offerDraw });
+        const agents = agentsAfter(context, folder, played);
         const board = context.pageOpen?.() === true ? {} : { board: true };
-        return { ...played, words: give(context, waiting), ...(agent === undefined ? {} : { ponder: agent }), ...board };
+        return { ...played, game: withAnalyst(played.game, context), words: give(context, waiting), ...(agents.length === 0 ? {} : { agents }), ...board };
     },
     format: (result) => {
-        // The mood the AI has just given is not told back: player_move and status tell it while it lasts (Priya, round of T-107).
+        // The mood the AI has just given is not told back: player_move and status tell it while it lasts (Priya).
         const game = { ...result.game };
         delete game.mood;
         // The board goes before the player's words and the next step, which stays the last line.
@@ -62,15 +55,14 @@ export const aiMove = defineCommand({
             `Played ${shownMove(result.move)}.`,
             ...moveLines({ ...result, game }),
             ...(result.board === true ? ["No board page is open: copy this board into your message.", boardText(result.game.fen)] : []),
-            ...(result.ponder === undefined ? [] : [ponderLine(result.ponder)]),
+            ...(result.agents === undefined ? [] : [agentsLine(result.agents)]),
             ...closingLines(result.game, result.words),
         ].join("\n");
     },
 });
-/** A comment as long as a note, a badge, a note and drawings, only with the helps on (D-78): the player who has them off plays as at a tournament. */
-function refuseWithoutHelps(folder, { comment, badge, note, arrows, squares }) {
+/** A comment as long as a note, and drawings, only with the helps on (D-78): the player who has them off plays as at a tournament. */
+function refuseWithoutHelps(folder, { comment, arrows, squares }) {
     const asked = [
-        badge === undefined && note === undefined ? "" : "without badge and note",
         arrows === undefined && squares === undefined ? "" : "without arrows and squares",
         comment === undefined || comment.length <= talkLimits.ai ? "" : `with the comment in ${talkLimits.ai} characters at most`,
     ].filter((part) => part !== "");
@@ -78,15 +70,16 @@ function refuseWithoutHelps(folder, { comment, badge, note, arrows, squares }) {
         throw new Error(`The player has the helps off: play ${asked.join(", ")}. Nothing changed.`);
     }
 }
-/** The agent to start after the move: in Claude Code, in a folder init set up with it, while the game goes on (D-72). */
-function ponderAgent(context, played) {
-    if (context.host?.() !== "claude-code" || played.game.end !== undefined) {
-        return undefined;
+/**
+ * The agents to start after the move, in Claude Code, in a folder init set up with them: the one that thinks for the AI while the game goes on (D-72), then
+ * the coach with the helps on, which judges the player's move even when the AI's ends the game (D-88).
+ */
+function agentsAfter(context, folder, played) {
+    if (context.host?.() !== "claude-code") {
+        return [];
     }
-    const agent = ponderAgentFor(played.game.level);
-    return hasPonderAgent(context.folder, agent) ? agent : undefined;
-}
-/** How to start the agent, and that the player sees nothing of it: its end needs no answer either. */
-function ponderLine(agent) {
-    return `Think on the player's time: start the ${agent} agent in the background with the prompt "Ponder."; write nothing about it in the chat, now or when it ends.`;
+    const ponder = ponderAgentFor(played.game.level);
+    const thinks = played.game.end === undefined && hasAgent(context.folder, ponder);
+    const coaches = helpsIn(folder) && coachRuns(context);
+    return [...(thinks ? [ponder] : []), ...(coaches ? [coachAgent] : [])];
 }

package/dist/commands/ai-say.d.ts

@@ -4,8 +4,10 @@ interface Said {
     /** The game, none when the AI spoke before the first (D-77). */
     game?: GameSummary;
     words: string[];
+    /** The coach yet to start on the player's move that ended the game (D-88). */
+    coach?: true;
 }
-/** The AI's words on the board page without a move (T-65), read only there, on the player's time: an answer, or a word it has to say (D-54, D-72). */
+/** The AI's words on the board page without a move, read only there, on the player's time: an answer, or a word it has to say (D-54, D-72). */
 export declare const aiSay: import("./registry.ts").Command<z.ZodObject<{
     text: z.ZodString;
     mood: z.ZodOptional<z.ZodEnum<{

package/dist/commands/ai-say.js

@@ -1,12 +1,15 @@
 import { z } from "zod";
 import { moods } from "../core/index.js";
-import { talkLimits } from "../games/index.js";
+import { archivedName, talkLimits } from "../games/index.js";
+import { coachAgent } from "../host-files/index.js";
 import { gameFolder } from "../profiles/index.js";
-import { newGameStep, nextStep, summaryOf, wordLines } from "./game-summary.js";
+import { agentsLine, analystLine, coachOnEnd, reviewedLine, withAnalyst } from "./agents.js";
+import { newGameStep, nextStep, wordLines } from "./answer-lines.js";
+import { summaryOf } from "./game-summary.js";
 import { refuseOtherGame } from "./play-move.js";
 import { defineCommand } from "./registry.js";
 import { give, say, waitingWords } from "./say.js";
-/** The AI's words on the board page without a move (T-65), read only there, on the player's time: an answer, or a word it has to say (D-54, D-72). */
+/** The AI's words on the board page without a move, read only there, on the player's time: an answer, or a word it has to say (D-54, D-72). */
 export const aiSay = defineCommand({
     name: "ai_say",
     description: "Says a word on the board page without a move, once while the player is to move: an answer to what they wrote or to their draw offer, or "
@@ -24,14 +27,29 @@ export const aiSay = defineCommand({
         const waiting = waitingWords(context);
         const current = say(folder, "ai", text, context.now(), mood);
         const words = give(context, waiting);
-        return "game" in current ? { game: summaryOf(current, context.now()), words } : { words };
+        if (!("game" in current)) {
+            return { words };
+        }
+        // The chat woken by the player's ending move on the page may have gone to its words without the coach (Priya).
+        return { game: withAnalyst(summaryOf(current, context.now(), archivedName(folder, current)), context, current), words, ...(coachOnEnd(context, folder, current) ? { coach: true } : {}) };
     },
-    format: ({ game, words }) => ["Said on the board page, where the player reads it: don't write it again in the chat.", ...wordLines(words), afterWords(game, words)].join("\n"),
+    format: ({ game, words, coach }) => [
+        "Said on the board page, where the player reads it: don't write it again in the chat.",
+        ...wordLines(words),
+        ...(coach === true ? [agentsLine([coachAgent])] : []),
+        afterWords(game, words),
+    ].join("\n"),
 });
 /** The next step once the AI has spoken: the end of a game over has been told already, and the player's draw offer answered in words. */
 function afterWords(game, words) {
     if (words.length === 0 && game?.end !== undefined) {
-        return `Next: when the player wants another game, ${newGameStep}`;
+        // The offer to go over the game, made in the AI's words, waits for the player's yes (D-89).
+        if (game.end.analyst === "done") {
+            return `Next: ${reviewedLine(game.end.archive)} When they want another game, ${newGameStep}`;
+        }
+        return game.end.analyst === "offer"
+            ? `Next: when the player wants this game gone over, ${analystLine(game.end.archive)} When they want another game, ${newGameStep}`
+            : `Next: when the player wants another game, ${newGameStep}`;
     }
     if (words.length === 0 && game?.drawOffer === "player" && game.turn !== game.ai) {
         return "Next: accept the draw with end_game draw_agreed, or wait for the player's move.";

package/dist/commands/analyse-game.d.ts

@@ -22,11 +22,15 @@ interface MoveFacts {
     plan?: string;
     /** The badge and note the AI gave it with annotate_game (D-69). */
     review?: MoveReview;
+    /** Who is ahead after it, as the AI estimated it (D-90). */
+    lead?: string;
 }
 /** A game as the analysis gives it. */
 interface Analysis {
     /** How to analyse, the first time in a chat (D-68). */
     instructions?: string;
+    /** The player's language, for the analyst's agent, which talks with no one (D-89). */
+    speech?: string;
     white: string;
     black: string;
     /** In a game played here: the side the AI played, and its level. */