chesspal 0.2.4 → 0.3.0

package/README.md

@@ -6,23 +6,21 @@ Play chess against an AI on a real board, or learn with one.
 
 ## Get started
 
-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:
+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), signed in with your own subscription: see [what you need](#what-you-need).
+
+Open a terminal, the window where you type commands, after installing Node.js: one opened before does not find `npm`. On Windows, open 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", until you type `Set-ExecutionPolicy -Scope CurrentUser RemoteSigned` there once and answer yes. On macOS, open Terminal. Then type:
 
 ```bash
 npm install -g chesspal
-chesspal init chess
-cd chess
-claude
+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.
-
-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.
+- `chesspal` opens the board page in your browser. The first time, it offers an icon on your desktop and in your menu of programs: with it, you open the board with a double click, with no terminal.
+- The first time, the board page asks who you are: fill it in and press **Start playing**.
+- Press **Claude Code** or **Codex**: the AI opens in a terminal of its own, at the table; keep it open while you play. The first time, it asks whether you trust the folder: choose **Yes** with the arrow keys and press Enter. With Codex, when it asks about Chesspal's two hooks, choose **Trust all and continue**; on Windows, it also offers to set up its sandbox: choose the first option, and answer yes when Windows asks for permission.
 
-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.
+Then press **New game**: you choose your colour, the clock and the AI's level, and play on the board. Talk with the AI on the board page or in its terminal.
 
 ## What it does
 
@@ -46,9 +44,10 @@ Chesspal works with any agent that supports MCP tools and can work with the file
 
 ## Good to know
 
-- **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.
+- **For the next game**, press New game: the AI the board page opened starts again with a clean chat by itself, once it has stopped working. In a chat you opened yourself, type `/clear` first: a long chat makes the AI slower and costs you more.
+- **To play in a folder of your own**, as with the Claude desktop app, type `chesspal init chess`, then open your agent in the folder `chess` and say hello: the AI answers with the link to the board page. Any name will do; your games are kept [elsewhere](#where-your-games-are).
 - **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.
+- **To update**, close the AI's terminal, run `npm install -g chesspal` again, then `chesspal`. In a folder of your own, run `chesspal init` there too: 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
 

package/dist/cli/cli.js

@@ -1,9 +1,25 @@
 #!/usr/bin/env node
 import { runCommandLine } from "./command-line.js";
 const args = process.argv.slice(2);
-// "chesspal mcp" turns the process into a server for an AI host, "chesspal listen" into the doorbell of Claude Code, or of Codex with --codex,
-// "chesspal chat" notes how the chat started; everything else is a command.
-if (args.length === 1 && args[0] === "mcp") {
+// The table's own words (D-104): alone or open, its page; table, icon, play <host>. The host's: mcp, its server; listen, its doorbell; chat, how the chat
+// started. Everything else is a command.
+if (args.length === 0) {
+    await openTableHere(true);
+}
+else if (args.length === 1 && args[0] === "open") {
+    // The icon's: its console has no window, where a question would hang unseen.
+    await openTableHere(false);
+}
+else if (args.length === 1 && args[0] === "table") {
+    await serveTable();
+}
+else if (args.length === 1 && args[0] === "icon") {
+    await putIconHere();
+}
+else if (args.length === 2 && args[0] === "play" && !args[1].startsWith("-")) {
+    await playHere(args[1]);
+}
+else if (args.length === 1 && args[0] === "mcp") {
     // The server and its SDK load only here: every other command starts faster without them.
     const { startMcpServer } = await import("../server/mcp.js");
     await startMcpServer();
@@ -26,3 +42,67 @@ else {
     }
     process.exitCode = exitCode;
 }
+/**
+ * Opens the table's page, the table started apart when none answers, and returns: the terminal stays free. From a terminal, the first time on a machine
+ * it asks first whether to put the icon on the desktop, before the page takes the screen; from the icon, which nobody reads, what went wrong is noted.
+ */
+async function openTableHere(fromTerminal) {
+    const [{ noteOpenFailed, openTable }, { defaultContext }, { offerIcon }] = await Promise.all([import("../server/table/index.js"), import("../commands/index.js"), import("./icon.js")]);
+    const context = defaultContext();
+    try {
+        const icon = fromTerminal ? await offerIcon(context) : undefined;
+        if (icon !== undefined) {
+            console.log(icon);
+        }
+        console.log(await openTable(context));
+    }
+    catch (error) {
+        console.error(error.message);
+        process.exitCode = 1;
+        if (!fromTerminal) {
+            noteOpenFailed(context, error.message);
+        }
+    }
+}
+/** Puts the icon on the desktop and in the menu. */
+async function putIconHere() {
+    const [{ defaultContext }, { iconsMade }] = await Promise.all([import("../commands/index.js"), import("./icon.js")]);
+    const { said, failed } = await iconsMade(defaultContext());
+    if (failed) {
+        console.error(said);
+        process.exitCode = 1;
+    }
+    else {
+        console.log(said);
+    }
+}
+/** A chat at the table in this terminal, in the host named, until it ends: what the table's buttons run. */
+async function playHere(host) {
+    const [{ isHostName, playHost }, { defaultContext }] = await Promise.all([import("../server/table/index.js"), import("../commands/index.js")]);
+    if (!isHostName(host)) {
+        console.error(`chesspal play takes claude or codex, not ${host}.`);
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        process.exitCode = await playHost(defaultContext(), host);
+    }
+    catch (error) {
+        console.error(error.message);
+        process.exitCode = 1;
+    }
+}
+/** The table, until it closes: `chesspal` alone starts it apart from the terminal. */
+async function serveTable() {
+    const [{ startTable, tableTimes, terminalChats }, { defaultContext }] = await Promise.all([import("../server/table/index.js"), import("../commands/index.js")]);
+    try {
+        const context = defaultContext();
+        const table = await startTable(context, tableTimes, terminalChats(context));
+        console.log(table === undefined ? "Another Chesspal table, started at the same time, is open: this one closes." : `Chesspal's table: ${table.url}`);
+        await table?.closed;
+    }
+    catch (error) {
+        console.error(error.message);
+        process.exitCode = 1;
+    }
+}

package/dist/cli/command-line.js

@@ -1,11 +1,19 @@
 // The `chesspal` command line: a command's input read from the arguments, its result written for a person.
 import { parseArgs } from "node:util";
 import { baseType, commandLineFieldProblem, commands, defaultContext, inputProblems, isBoolean, isList, takesNumbers } from "../commands/index.js";
+import { rerunIfChanged } from "../games/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.
+// The commands that exist only on the command line: cli.ts starts the table, opens its page, puts its icon, 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.";
 const listenDescription = "Wait for the player's move on the board page and wake the chat. Claude Code starts it at the end of each turn, and Codex with --codex, as init sets them up.";
 const chatDescription = "Note how the chat started: new, cleared, resumed or compacted. Claude Code and Codex run it when a chat starts, as init sets them up.";
+const tableDescription = "Serve the board page with no chat, until no browser has had it open for five minutes. `chesspal` alone starts it apart and opens the page.";
+const openDescription = "Open the board page as `chesspal` alone does, without asking about the icon: what the icon runs.";
+const iconDescription = "Put Chesspal's icon on the desktop and in the menu: it opens the board page as `chesspal` alone does, with no terminal.";
+const playDescription = "Play at the table in Claude Code or Codex, in this terminal: what the page's buttons open, with the model and effort chosen there; New game on the page starts the chat again, clean.";
+// Those of them that take no options, by name.
+const plainCommands = new Map([["mcp", mcpDescription], ["chat", chatDescription], ["table", tableDescription], ["open", openDescription], ["icon", iconDescription]]);
 /** The `chesspal` command line: finds the command, validates its input, runs it and renders the result. */
 export async function runCommandLine(argv, context = defaultContext(), list = commands) {
     const [commandName, ...args] = argv;
@@ -15,19 +23,21 @@ export async function runCommandLine(argv, context = defaultContext(), list = co
     if (commandName === "--version" || commandName === "-v") {
         return success(version);
     }
-    if (commandName === "mcp") {
-        // A host that adds options to it would get this text instead of the protocol: it must see the failure.
-        const help = `chesspal mcp\n\n${mcpDescription}`;
-        return args.length === 0 || args.includes("--help") || args.includes("-h") ? success(help) : failure(`chesspal mcp takes no options: ${args.join(" ")}.\n\n${help}`);
+    const plain = plainCommands.get(commandName);
+    if (plain !== undefined) {
+        // A host that adds options to mcp would get this text instead of the protocol: it must see the failure.
+        const help = `chesspal ${commandName}\n\n${plain}`;
+        return args.length === 0 || args.includes("--help") || args.includes("-h") ? success(help) : failure(`chesspal ${commandName} takes no options: ${args.join(" ")}.\n\n${help}`);
     }
     if (commandName === "listen") {
         const help = `chesspal listen [--codex]\n\n${listenDescription}`;
         const known = args.every((arg) => ["--codex", "--help", "-h"].includes(arg));
         return known ? success(help) : failure(`chesspal listen takes only --codex: ${args.join(" ")}.\n\n${help}`);
     }
-    if (commandName === "chat") {
-        const help = `chesspal chat\n\n${chatDescription}`;
-        return args.length === 0 || args.includes("--help") || args.includes("-h") ? success(help) : failure(`chesspal chat takes no options: ${args.join(" ")}.\n\n${help}`);
+    if (commandName === "play") {
+        // cli.ts runs `chesspal play <host>`; here come the help and what it refuses.
+        const help = `chesspal play <claude|codex>\n\n${playDescription}`;
+        return args.includes("--help") || args.includes("-h") ? success(help) : failure(`chesspal play takes one host, claude or codex: ${args.join(" ") || "none given"}.\n\n${help}`);
     }
     const command = list.find((candidate) => candidate.name === commandName);
     if (!command) {
@@ -51,7 +61,8 @@ async function runCommand(command, args, context) {
         const written = (name) => (positionals.includes(name) ? `<${name}>` : `--${name}`);
         throw refused(command, inputProblems(command.name, parsed.error.issues, input, written));
     }
-    const result = await command.run(parsed.data, context);
+    // A game another process changed under the command is read again, and the command run once more.
+    const result = await rerunIfChanged(() => command.run(parsed.data, context));
     return asJson ? JSON.stringify(result, null, 2) : command.format(result, context);
 }
 /** An input refused, in the words the MCP server uses (inputProblems), with the command's usage. */
@@ -145,8 +156,14 @@ function generalHelp(list) {
     return [
         `chesspal ${version}`,
         "",
+        "Run `chesspal` alone to open the board page in your browser.",
+        "",
         "Commands:",
         ...list.map((command) => line(command.name, command.description)),
+        line("table", tableDescription),
+        line("open", openDescription),
+        line("icon", iconDescription),
+        line("play", playDescription),
         line("mcp", mcpDescription),
         line("listen", listenDescription),
         line("chat", chatDescription),

package/dist/cli/icon.d.ts

@@ -0,0 +1,25 @@
+import { type Context } from "../commands/index.ts";
+import { type IconPlaces } from "../server/table/index.ts";
+/** Where `chesspal` alone runs: its input and output, which ask only when both are a terminal, and its environment. The tests give their own. */
+export interface Terminal {
+    readonly input: NodeJS.ReadableStream & {
+        readonly isTTY?: boolean;
+    };
+    readonly output: NodeJS.WritableStream & {
+        readonly isTTY?: boolean;
+    };
+    readonly env: NodeJS.ProcessEnv;
+}
+/**
+ * Asks once a machine, in a terminal on a screen, whether to put the icon on the desktop and in the menu, and puts it there on a yes: what to tell the
+ * player, if anything. Once asked, an icon made by another Node or script is made again, without a word; a playtest's data folder is never asked about.
+ */
+export declare function offerIcon(context: Context, terminal?: Terminal, places?: IconPlaces): Promise<string | undefined>;
+/**
+ * Puts the icon on the desktop and in the menu, and asks no more on this machine: what to tell the player, the files made or why there are none, and
+ * whether it failed.
+ */
+export declare function iconsMade(context: Context, places?: IconPlaces): Promise<{
+    said: string;
+    failed: boolean;
+}>;

package/dist/cli/icon.js

@@ -0,0 +1,80 @@
+// The icon from the command line (D-104): `chesspal` alone asks, in a terminal and once a machine, whether to put it on the desktop and in the menu;
+// `chesspal icon` puts it there whenever the player wants it.
+import { createInterface } from "node:readline/promises";
+import { styleText } from "node:util";
+import { speaksItalian } from "../commands/index.js";
+import { iconAsked, iconCommand, iconToRemake, makeIcons, noteIconAsked, noteIconMade } from "../server/table/index.js";
+/**
+ * Asks once a machine, in a terminal on a screen, whether to put the icon on the desktop and in the menu, and puts it there on a yes: what to tell the
+ * player, if anything. Once asked, an icon made by another Node or script is made again, without a word; a playtest's data folder is never asked about.
+ */
+export async function offerIcon(context, terminal = processTerminal(), places) {
+    const home = context.home();
+    // The icon would open the table of the player's Documents, not the playtest's.
+    if (terminal.env.CHESSPAL_HOME?.trim()) {
+        return undefined;
+    }
+    if (iconAsked(home)) {
+        if (iconToRemake(home, iconCommand(home))) {
+            await iconsMade(context, places);
+        }
+        return undefined;
+    }
+    if (!onScreen(context.platform, terminal)) {
+        return undefined;
+    }
+    const words = wordsFor(context);
+    const reader = createInterface({ input: terminal.input, output: terminal.output });
+    const answer = await reader.question(words.question).finally(() => reader.close());
+    noteIconAsked(home);
+    return yes(answer) ? (await iconsMade(context, places)).said : words.later;
+}
+/**
+ * Puts the icon on the desktop and in the menu, and asks no more on this machine: what to tell the player, the files made or why there are none, and
+ * whether it failed.
+ */
+export async function iconsMade(context, places) {
+    const words = wordsFor(context);
+    try {
+        const home = context.home();
+        const command = iconCommand(home);
+        const made = await makeIcons(context.platform, command, places);
+        noteIconMade(home, command, made);
+        return { said: `${styleText(["bold", "green"], `♜ ${words.made}`)}\n${styleText("dim", made.map((file) => `  ${file}`).join("\n"))}`, failed: false };
+    }
+    catch (error) {
+        return { said: words.failed(error.message), failed: true };
+    }
+}
+function processTerminal() {
+    return { input: process.stdin, output: process.stdout, env: process.env };
+}
+// A terminal the player sees: on Linux, one of a desktop, not one reached through SSH or WSL, where there is no desktop to put the icon on.
+function onScreen(platform, terminal) {
+    const desktop = platform !== "linux" || Boolean(terminal.env.DISPLAY || terminal.env.WAYLAND_DISPLAY);
+    return terminal.input.isTTY === true && terminal.output.isTTY === true && desktop;
+}
+// Yes unless it says no, in either language: Enter, "ok" and "sure" are yes, since the question is not asked again (Zoe).
+function yes(answer) {
+    return !answer.trim().toLowerCase().startsWith("n");
+}
+// The words for the player (Zoe), with the menu as their system names it.
+function wordsFor(context) {
+    const system = context.platform === "win32" ? "windows" : context.platform === "darwin" ? "mac" : "linux";
+    if (speaksItalian(context.language)) {
+        const where = { windows: "nel menu Start", mac: "in Applicazioni", linux: "nel menu delle applicazioni" }[system];
+        return {
+            question: `Vuoi l'icona di Chesspal sul desktop e ${where}? Con un doppio clic apre la scacchiera. (Invio = sì, n = no) `,
+            made: `Fatto: Chesspal è sul desktop e ${where}.`,
+            later: "Va bene, niente icona. Se la vuoi più avanti, scrivi chesspal icon.",
+            failed: (reason) => `Chesspal non è riuscito a mettere l'icona (${reason}). Riprova con chesspal icon.`,
+        };
+    }
+    const where = { windows: "your Start menu", mac: "Applications", linux: "your applications menu" }[system];
+    return {
+        question: `Add a Chesspal icon to your desktop and ${where}? Double-click it to open the board. [Y/n] `,
+        made: `Done: Chesspal is on your desktop and in ${where}.`,
+        later: "All right, no icon. To add it later, type chesspal icon.",
+        failed: (reason) => `Chesspal could not add its icon (${reason}). Try again with chesspal icon.`,
+    };
+}

package/dist/commands/agents.d.ts

@@ -1,11 +1,11 @@
 import { type CurrentGame } from "../games/index.ts";
 import type { Context } from "./context.ts";
-import type { GameSummary } from "./game-summary.ts";
+import { type GameSummary } from "./game-summary.ts";
 /** Whether an analyst agent goes over a game over when the player wants: in Claude Code or Codex, with its agent in the player's folder (D-89, D-98). */
 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).
+ * its end: once reviewed, or taken by the agent, the chat goes over that review and doesn't start the agent for it (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). */
@@ -21,8 +21,25 @@ export declare function agentRuns(context: Context, agent: string): boolean;
  * 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 coach on the player's move that ended the game: whatever the player asks, beside the analyst when the chat starts it too, since a chat on
+ * a quick model started only the agent that answered the player (Priya).
+ */
+export declare const coachOnEndLine: string;
 /**
  * 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;
+/**
+ * Whether a game is gone over already: reviewed, or taken by an analyst at work on it, whatever the page opened since (Federico); not once its review is
+ * deleted, for the analyst to write it again (Stefano).
+ */
+export declare function goneOver(context: Context, game: string): boolean;
+/**
+ * The run of the analyst agent at work on a game: the one that took it last, unless its chat has started again since, not only summarized, and took the
+ * agent with it.
+ */
+export declare function analystOf(context: Context, game: string): string | undefined;
+/** What stops an analyst agent on a game another analyst has taken: the chat hears of the review from that one (Priya). */
+export declare const anotherAnalyst: string;

package/dist/commands/agents.js

@@ -1,22 +1,26 @@
 // The agents that work beside the chat in Claude Code and Codex (D-98): 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 { archivedName, coachStarted, gameInAnalysis, lastChatStart } from "../games/index.js";
 import { agentHosts, analystAgent, coachAgent, hasAgent } from "../host-files/index.js";
 import { gameFolder, helpsIn } from "../profiles/index.js";
+import { unplayed } from "./game-summary.js";
+import { namedGame } from "./study.js";
 /** Whether an analyst agent goes over a game over when the player wants: in Claude Code or Codex, with its agent in the player's folder (D-89, D-98). */
 export function analystRuns(context) {
     return agentRuns(context, 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).
+ * its end: once reviewed, or taken by the agent, the chat goes over that review and doesn't start the agent for it (Stefano).
  */
 export function withAnalyst(summary, context, over) {
     const { end } = summary;
-    if (end === undefined || !analystRuns(context)) {
+    // A game closed before any move has nothing to go over.
+    if (end === undefined || unplayed(summary) || !analystRuns(context)) {
         return summary;
     }
-    return { ...summary, end: { ...end, analyst: over !== undefined && goneOver(context, over) ? "done" : "offer" } };
+    const archived = over === undefined ? undefined : archivedName(gameFolder(context.home()), over);
+    return { ...summary, end: { ...end, analyst: archived !== undefined && goneOver(context, archived) ? "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) {
@@ -26,7 +30,7 @@ export function analystLine(game) {
 }
 /** 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 "
+    return "The analyst agent has gone over this game, or is at it: don't start it for this review. 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 or Codex, with its agent in the player's folder (D-80, D-88, D-98). */
@@ -46,6 +50,13 @@ 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 coach on the player's move that ended the game: whatever the player asks, beside the analyst when the chat starts it too, since a chat on
+ * a quick model started only the agent that answered the player (Priya).
+ */
+export const coachOnEndLine = `Coach the player: start the ${coachAgent} agent in the background with the prompt "Coach.", whatever the player asks: it judges `
+    + "the move that ended the game, apart from the analyst; when you start the analyst too, start both in one message. 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.";
 /**
  * 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).
@@ -61,18 +72,33 @@ export function agentsLine(agents) {
     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;
+/**
+ * Whether a game is gone over already: reviewed, or taken by an analyst at work on it, whatever the page opened since (Federico); not once its review is
+ * deleted, for the analyst to write it again (Stefano).
+ */
+export function goneOver(context, game) {
+    if (analystOf(context, game) !== undefined) {
+        return true;
     }
     try {
-        return isReviewed(archivedGame(folder, archived));
+        return isReviewed(namedGame(context, game).record);
     }
     catch {
-        // A game the archive cannot read is offered as it would be: the analyst says what is wrong with it.
+        // A game that cannot be read is offered as it would be: the analyst says what is wrong with it.
         return false;
     }
 }
+/**
+ * The run of the analyst agent at work on a game: the one that took it last, unless its chat has started again since, not only summarized, and took the
+ * agent with it.
+ */
+export function analystOf(context, game) {
+    const taken = gameInAnalysis(gameFolder(context.home()))?.analyst;
+    const start = lastChatStart(context.folder);
+    const gone = taken !== undefined && start !== undefined && start.source !== "compact" && Date.parse(start.at) > Date.parse(taken.since);
+    return taken?.game === game && !gone ? taken.run : undefined;
+}
+/** What stops an analyst agent on a game another analyst has taken: the chat hears of the review from that one (Priya). */
+export const anotherAnalyst = "Stop now: another analyst is reviewing this game. End with one line for the AI that started you: its review is on its way to the "
+    + "board page, and its end comes to you by itself; meanwhile talk the game over with the player whenever they ask. Should it never come, the player has "
+    + "the game analysed again from the board page's list of analyses.";

package/dist/commands/ai-say.js

@@ -1,9 +1,8 @@
 import { z } from "zod";
 import { moods } from "../core/index.js";
 import { archivedName, talkLimits } from "../games/index.js";
-import { coachAgent } from "../host-files/index.js";
 import { gameFolder } from "../profiles/index.js";
-import { agentsLine, analystLine, coachOnEnd, reviewedLine, withAnalyst } from "./agents.js";
+import { analystLine, coachOnEnd, coachOnEndLine, 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";
@@ -16,7 +15,7 @@ export const aiSay = defineCommand({
         + "something you have to say; when you are to move, speak in ai_move's comment. Between games, and before the first, it speaks freely: about the game just over, or to start another. "
         + 'Example: ai_say {text: "Sure, I\'ll play faster."}.',
     input: z.object({
-        text: z.string().trim().min(1, "write what you say").max(talkLimits.aiHelps, `write ${talkLimits.aiHelps} characters at most`).describe(`your words for the player, one or two short sentences, ${talkLimits.ai} characters at most (${talkLimits.aiHelps} with the helps on): pieces and moves in `
+        text: z.string().trim().min(1, "write what you say").max(talkLimits.aiHelps, `write ${talkLimits.aiHelps} characters at most`).describe(`your words for the player, one or two short sentences, ${talkLimits.ai} characters at most (${talkLimits.aiHelps} with the helps on, or with no game going on): 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; **two asterisks** put a word or two in bold on the page`),
         mood: z.enum(moods).optional().describe("only after the game has ended: the face the board page keeps for its end"),
     }),
@@ -36,7 +35,7 @@ export const aiSay = defineCommand({
     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])] : []),
+        ...(coach === true ? [coachOnEndLine] : []),
         afterWords(game, words),
     ].join("\n"),
 });

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

@@ -13,6 +13,8 @@ interface MoveFacts {
     material?: string;
     /** After it, the pieces at risk of either side when they changed from the line before ("none" once no piece is), and the mates the side to move has; none once the board ends the game. */
     atRisk?: string;
+    /** After it, the only legal move of the side to move, when it has one alone: a rule, as a mate is, never a judgment (D-103). */
+    oneLegal?: string;
     mates?: readonly string[];
     /** After it, what the moves of the side to move would do (D-100): forks, double attacks, discovered and double checks, promotions, stalemates and traps. */
     tactics?: string;
@@ -33,6 +35,8 @@ interface Analysis {
     instructions?: string;
     /** The player's language, for the analyst's agent, which talks with no one (D-89). */
     speech?: string;
+    /** Who the player is, how they play and their rating, for the analyst's agent, which never reads status (D-66). */
+    profile?: string;
     white: string;
     black: string;
     /** In a game played here: the side the AI played, and its level. */