chesspal 0.2.4 → 0.3.0

package/dist/commands/analyse-game.js

@@ -1,21 +1,21 @@
 // The analyst's tool (D-21, D-68): a game over, move by move in one call, facts only and never a judgment, with the analyst's instructions once in a chat.
 import { z } from "zod";
 import { clockOfComment, clockText, closingOf, Game, gameReviewOf, isReviewed, leadOf, leadText, levelOf, materialOf, readPgn, reviewed, reviewOf, timeControlOfTag, timeControlText, withGameReview, withLead, } from "../core/index.js";
-import { isGameName, keepToStudy, lastChatStart, planOf, rewriteGame, startAnalysis } from "../games/index.js";
-import { analystAgent, instructions } from "../host-files/index.js";
+import { gameInAnalysis, isGameName, keepToStudy, lastChatStart, planOf, rewriteGame, startAnalysis } from "../games/index.js";
+import { analystAgent, instructionsFile } from "../host-files/index.js";
 import { activeProfile, gameFolder } from "../profiles/index.js";
+import { analystOf, anotherAnalyst } from "./agents.js";
 import { bookOpening, bookReaches } from "./opening-book.js";
+import { playerLine } from "./profiles.js";
 import { defineCommand } from "./registry.js";
 import { speechLine, speechOf } from "./speech.js";
 import { gameToStudy, knownTag, moveNumbers, namedGame, noGameGoingOn } from "./study.js";
 import { balanceText, colourName, riskLine, tacticsText } from "./view.js";
-// The analyst's instructions, read at the first analysis.
-let analystText;
 /** A game over move by move, for the analyst (D-68): the current one, one of the archive or kept to study, or one the player brings as a PGN, kept to study. */
 export const analyseGame = defineCommand({
     name: "analyse_game",
     description: "Gives a game that is over move by move, to comment it with the player: each move with what it took and the time it took, the material "
-        + "when it changes, the pieces at risk, the mates in one and what the next moves would do after it (forks, double attacks, discovered checks, "
+        + "when it changes, the pieces at risk, the only legal move when there is one alone, the mates in one and what the next moves would do after it (forks, double attacks, discovered checks, "
         + "promotions, stalemates and stalemate traps), where the game left the opening book, and your comments and plans. Facts "
         + "only: the judgment is yours. Without game or pgn, the game just over, or else the last one played; game: a name as past_games or study_games "
         + "writes it; pgn: a game the player brings from elsewhere, kept to study in the profile. Never while a game goes on. The first time in a chat "
@@ -32,19 +32,20 @@ export const analyseGame = defineCommand({
         // A game's name given as pgn, as an AI often gives it, is that game (Priya).
         const named = pgn !== undefined && isGameName(pgn) ? pgn.trim() : game;
         const studied = pgn === undefined || named !== game ? gameToStudy(context, named) : importedGame(context, pgn);
-        // One analyst a game: the chat goes over the review there is (Stefano).
-        if (context.agent === analystAgent && isReviewed(studied.record)) {
-            throw new Error("Stop now: this game has its review already. End with one line for the AI that started you: go over that review with the player.");
+        if (context.agent === analystAgent) {
+            oneAnalyst(context, studied);
         }
         const analysis = analysisOf(studied, activeProfile(context.home()).name);
         if (studied.name !== undefined) {
             markBook(context, { record: studied.record, name: studied.name }, analysis.moves);
             startAnalysis(gameFolder(context.home()), studied.name, context.now());
         }
-        // The analyst's agent has its instructions in its own file, and the player's language in its prompt or, when Chesspal knows it, here (D-89).
+        // The analyst's agent has its instructions in its own file, and the player's language in its prompt or, when Chesspal knows it, here (D-89);
+        // who the player is, which the chat reads in status, here too, so that it writes for their level.
         if (context.agent === analystAgent) {
             const speech = speechOf(gameFolder(context.home()), context.language);
-            return speech === undefined ? analysis : { ...analysis, speech: speechLine(speech) };
+            const profile = playerLine(context);
+            return { ...analysis, ...(speech === undefined ? {} : { speech: speechLine(speech) }), ...(profile === undefined ? {} : { profile }) };
         }
         const told = analystInstructions(context);
         return told === undefined ? analysis : { instructions: told, ...analysis };
@@ -52,10 +53,36 @@ export const analyseGame = defineCommand({
     format: (analysis) => [
         ...(analysis.instructions === undefined ? [] : [analysis.instructions, ""]),
         ...(analysis.speech === undefined ? [] : [analysis.speech]),
+        ...(analysis.profile === undefined ? [] : [analysis.profile]),
         ...analysisHead(analysis),
         ...analysis.moves.map(moveLine),
     ].join("\n"),
 });
+/**
+ * One analyst a game: one started on a game reviewed already, or that another analyst has taken, stops, and the chat goes over that review (Stefano); the
+ * analyst that took it may call again, its review half written. The game is taken at once, before the long reading of it, and read again: of two analysts
+ * started together in two processes, as Codex runs them, one goes on (Federico).
+ */
+function oneAnalyst(context, studied) {
+    const { name } = studied;
+    const holder = name === undefined ? undefined : analystOf(context, name);
+    if (holder !== undefined && holder === context.agentRun) {
+        return;
+    }
+    if (isReviewed(studied.record)) {
+        throw new Error("Stop now: this game has its review already. End with one line for the AI that started you: go over that review with the player.");
+    }
+    if (holder !== undefined) {
+        throw new Error(anotherAnalyst);
+    }
+    if (name !== undefined && context.agentRun !== undefined) {
+        const folder = gameFolder(context.home());
+        startAnalysis(folder, name, context.now(), { analyst: { game: name, run: context.agentRun, since: context.now().toISOString() } });
+        if (gameInAnalysis(folder)?.analyst?.run !== context.agentRun) {
+            throw new Error(anotherAnalyst);
+        }
+    }
+}
 /** A game the player brings as a PGN, checked move by move and kept to study with its clock and Chesspal's own review: no other comment, no engine's evaluation (D-6). */
 function importedGame(context, pgn) {
     noGameGoingOn(context);
@@ -146,7 +173,7 @@ function movesOf(record, ai) {
     let inBook = record.tags.FEN === undefined && bookReaches(game.position.fen);
     let before = game.facts;
     let balance = materialOf(game.position.fen).balance;
-    const start = { atRisk: riskLine(before), mates: matesOf(before), tactics: tacticsText(before, game.possibilities, true) };
+    const start = { atRisk: riskLine(before), oneLegal: oneLegalMove(before), mates: matesOf(before), tactics: tacticsText(before, game.possibilities, true) };
     // What was at risk on the line before: a move tells it only when it changed.
     let risk = start.atRisk;
     const moves = record.moves.map(({ san, comment }, ply) => {
@@ -170,6 +197,7 @@ function movesOf(record, ai) {
             left: clock,
             material: now === balance ? undefined : balanceText(now),
             atRisk: over || risks === risk ? undefined : (risks ?? "none"),
+            oneLegal: over ? undefined : oneLegalMove(facts),
             mates: over ? undefined : matesOf(facts),
             tactics: over ? undefined : tacticsText(facts, game.possibilities, true),
             outOfBook: outOfBook ? true : undefined,
@@ -216,6 +244,7 @@ function moveLine(move) {
         move.spent === undefined ? left : `spent ${clockText(move.spent)}, ${left}`,
         move.material === undefined ? undefined : `material ${move.material}`,
         move.atRisk === undefined ? undefined : `at risk: ${move.atRisk}`,
+        move.oneLegal === undefined ? undefined : `one legal move: ${move.oneLegal}`,
         move.mates === undefined ? undefined : `mate in one: ${move.mates.join(" ")}`,
         move.tactics === undefined ? undefined : `tactics: ${move.tactics}`,
         move.outOfBook ? "out of book" : undefined,
@@ -238,14 +267,18 @@ function analystInstructions(context) {
         return undefined;
     }
     context.told.add(key);
-    analystText ??= `${instructions("analyst")}\n${instructions("analysis")}`;
-    return analystText;
+    return `${instructionsFile("analyst")}\n${instructionsFile("analysis")}`;
 }
 /** Who is ahead after a move, as the AI estimated it with annotate_game or the coach during the game (D-90). */
 function estimateOf(comment) {
     const lead = leadOf(comment);
     return lead === undefined ? undefined : leadText(lead);
 }
+/** The only legal move of the side to move, when it has one alone (D-103). */
+function oneLegalMove(facts) {
+    const moves = facts.pieces.flatMap((piece) => piece.moves ?? []);
+    return moves.length === 1 ? moves[0] : undefined;
+}
 /** The mates in one the side to move has; none when it has none. */
 function matesOf(facts) {
     const mates = facts.checks.filter((check) => check.endsWith("#"));

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

@@ -12,6 +12,8 @@ interface Annotated {
     unestimated: string[];
     /** The moves whose note the chat corrected with the player, told the analyst at each call: its notes leave them as they are (D-101). */
     left: string[];
+    /** The chat corrected a note of a review that already has its word on the game. */
+    summaryStands: boolean;
 }
 /** The AI's badges and notes on a game over, and its word on the whole game, written into the game's PGN (D-69). */
 export declare const annotateGame: import("./registry.ts").Command<z.ZodObject<{

package/dist/commands/annotate-game.js

@@ -1,13 +1,13 @@
 // The AI's review of a game over (D-69): a badge on each move that matters, as chess.com marks them, with a note when it needs one, and its word on the
 // whole game, kept in the game's PGN for the board page. The judgment is the AI's alone: Chesspal gives no criteria (D-6, D-43).
 import { z } from "zod";
-import { annotatorOf, badges, Game, leadOf, reviewed, reviewOf, withAnnotator, withGameReview, withLead } from "../core/index.js";
+import { annotatorOf, badges, Game, gameReviewOf, leadOf, reviewed, reviewOf, withAnnotator, withGameReview, withLead } from "../core/index.js";
 import { gameInAnalysis, rewriteGame, startAnalysis } from "../games/index.js";
 import { analystAgent } from "../host-files/index.js";
 import { gameFolder } from "../profiles/index.js";
-import { analystRuns } from "./agents.js";
+import { analystOf, analystRuns, anotherAnalyst } from "./agents.js";
 import { arrowsInput, drawingsOf, noteInput, squaresInput } from "./drawings.js";
-import { leadFrom, leadInput } from "./lead-input.js";
+import { leadFrom } from "./lead-input.js";
 import { defineCommand } from "./registry.js";
 import { moveIndex, moveNumbers, namedGame, noGameGoingOn } from "./study.js";
 const summaryLimit = 1500;
@@ -31,9 +31,10 @@ export const annotateGame = defineCommand({
             arrows: arrowsInput,
             squares: squaresInput,
         })).optional().describe("the moves that matter, each with its badge, its note, or both"),
-        ahead: z.record(z.string(), leadInput).optional().describe("who is ahead after each move, by the move as analyse_game numbers it: pawns from White's side as chess.com shows it, 1.5 for White, -3 for Black, 0 for "
-            + 'even, or a mate you see in moves of the side that mates, "#3" for White\'s, "#-3" for Black\'s; every move, in one call or a few; a move given again '
-            + "takes its new figure"),
+        // Checked in run, which leaves out a figure after the move that ended the game on the board.
+        ahead: z.record(z.string(), z.union([z.number(), z.string()])).optional().describe("who is ahead after each move, by the move as analyse_game numbers it: pawns from White's side as chess.com shows it, 1.5 for White, -3 for Black, 0 for "
+            + 'even, or a mate you see in moves of the side that mates, "#3" for White\'s, "#-3" for Black\'s; every move but the last when it mates or draws '
+            + "on the board, which says it, in one call or a few; a move given again takes its new figure"),
         summary: z.string().max(summaryLimit).optional().describe("your word on the whole game: a short paragraph, with a few points as lines starting with - if it helps; the moves have their own notes"),
         closing: z.string().max(closingLimit).optional().describe("your last word on how the game ended, its win or loss, in a sentence or two: the page shows it at the end"),
     }),
@@ -49,14 +50,21 @@ export const annotateGame = defineCommand({
         // would be lost (Federico).
         const caller = await context.caller?.();
         const studied = game === undefined ? gameAnalysed(context) : namedGame(context, game);
+        // An analyst whose game another has taken since, the review started again, writes no more (Priya).
+        const holder = context.agent === analystAgent ? analystOf(context, studied.name) : undefined;
+        if (holder !== undefined && holder !== context.agentRun) {
+            throw new Error(`${anotherAnalyst} Nothing changed.`);
+        }
         const folder = gameFolder(context.home());
         const numbers = moveNumbers(studied.record);
         // Where the analyst reviews the games, the chat's notes are corrections it made with the player: the analyst, at work then or later, leaves those notes
         // and is told of them at each call, and the chat is not asked for the analyst's work (D-101, Priya). Only a call the host ties to the chat is its own.
-        const correction = context.chat === true && analystRuns(context) && estimates.length === 0 && summary === undefined && closing === undefined;
+        const correction = context.chat === true && analystRuns(context) && notes.length > 0 && summary === undefined && closing === undefined;
         const analysis = gameInAnalysis(folder);
         const corrected = context.chat !== true && analysis?.game === studied.name ? analysis.corrected ?? [] : [];
         let skipped = 0;
+        // The moves noted, as analyse_game numbers them: the chat's corrections.
+        const noted = [];
         // Every move is checked before the game is written: all or nothing.
         const moves = [...studied.record.moves];
         for (const { move, badge, note, arrows = [], squares = [] } of notes) {
@@ -64,6 +72,7 @@ export const annotateGame = defineCommand({
                 throw new Error(`Give ${move} a badge, a note, or both: arrows and squares go with them. Nothing changed.`);
             }
             const index = indexIn(studied.record, move, "notes");
+            noted.push(numbers[index]);
             if (corrected.includes(numbers[index])) {
                 skipped += 1;
                 continue;
@@ -72,15 +81,17 @@ export const annotateGame = defineCommand({
             const kept = badge ?? (reviewOf(moves[index].comment)?.badge === "book" ? "book" : undefined);
             moves[index] = reviewed(moves[index], { ...(kept === undefined ? {} : { badge: kept }), ...(note === undefined ? {} : { note }), ...drawingsOf(arrows, squares) });
         }
-        for (const [move, lead] of estimates) {
-            const index = indexIn(studied.record, move, "ahead");
-            moves[index] = withLead(moves[index], leadFrom(lead));
+        // After the move that ended the game on the board, which says it, a figure is left out rather than refused, "#0" too (Priya).
+        const over = new Game(studied.record).outcome.over;
+        const leads = estimates.map(([move, lead]) => ({ index: indexIn(studied.record, move, "ahead"), move, lead })).filter(({ index }) => !over || index < moves.length - 1);
+        for (const { index, move, lead } of leads) {
+            moves[index] = withLead(moves[index], leadAfter(move, lead));
         }
         // Who reviewed it, as far as the host says it for certain (D-81): on the command line, or by a host that names no model over one that did, as it was.
         const kept = caller === undefined || (caller.hostOnly === true && annotatorOf(studied.record) !== undefined);
         const marked = { ...(kept ? studied.record : withAnnotator(studied.record, caller)), moves };
         rewriteGame(folder, studied.name, summary === undefined && closing === undefined ? marked : withGameReview(marked, { ...(summary === undefined ? {} : { summary }), ...(closing === undefined ? {} : { closing }) }));
-        startAnalysis(folder, studied.name, context.now(), false, correction ? notes.map(({ move }) => numbers[indexIn(studied.record, move, "notes")]) : []);
+        startAnalysis(folder, studied.name, context.now(), { corrected: correction ? noted : [] });
         const bookUnnoted = moves.flatMap((move, index) => {
             const review = reviewOf(move.comment);
             return review?.badge === "book" && review.note === undefined ? [numbers[index]] : [];
@@ -91,13 +102,15 @@ export const annotateGame = defineCommand({
             summary: summary !== undefined,
             closing: closing !== undefined,
             bookUnnoted: correction ? [] : bookUnnoted,
-            estimated: estimates.length,
+            estimated: leads.length,
             // Asked every time, of an older review too: an analyst whose instructions predate the estimates learns of them here.
-            unestimated: correction ? [] : unestimatedMoves(marked, numbers),
+            unestimated: correction ? [] : unestimatedMoves(marked, numbers, over),
             left: [...corrected],
+            // A correction after the review's word on the game: that word may now say otherwise (Priya).
+            summaryStands: correction && gameReviewOf(studied.record) !== undefined,
         };
     },
-    format: ({ game, marked, summary, closing, bookUnnoted, estimated, unestimated, left }) => {
+    format: ({ game, marked, summary, closing, bookUnnoted, estimated, unestimated, left, summaryStands }) => {
         const kept = [
             marked === 0 ? undefined : `${marked} ${marked === 1 ? "move" : "moves"} marked`,
             estimated === 0 ? undefined : `who is ahead after ${estimated} ${estimated === 1 ? "move" : "moves"}`,
@@ -118,13 +131,22 @@ export const annotateGame = defineCommand({
             ? []
             : [`${left.join(" ")} ${one ? "keeps the note" : "keep the notes"} the AI wrote with the player: leave ${one ? "it" : "them"}, and don't contradict ${one ? "it" : "them"} in your summary${summary ? "; if this one does, give it again" : ""}.`];
         const head = kept.length === 0 ? `Nothing new kept in ${game}.` : `Kept in ${game}: ${[kept.slice(0, -1).join(", "), kept.at(-1)].filter((part) => part !== "").join(" and ")}. The board page shows them.`;
-        return [head, ...corrected, ...book, ...ahead].join("\n");
+        const stands = summaryStands ? ["The review's word on the game stays as written: if it says otherwise, give summary again."] : [];
+        return [head, ...stands, ...corrected, ...book, ...ahead].join("\n");
     },
 });
 /** The moves without who is ahead after them, as analyse_game numbers them: all but the last when the board ended the game there, which says it. */
-function unestimatedMoves(record, numbers) {
-    const ended = new Game(record).outcome.over;
-    return record.moves.flatMap((move, index) => leadOf(move.comment) !== undefined || (ended && index === record.moves.length - 1) ? [] : [numbers[index]]);
+function unestimatedMoves(record, numbers, over) {
+    return record.moves.flatMap((move, index) => leadOf(move.comment) !== undefined || (over && index === record.moves.length - 1) ? [] : [numbers[index]]);
+}
+/** Who is ahead after a move given in ahead, refused with the move it was given for. */
+function leadAfter(move, value) {
+    try {
+        return leadFrom(value);
+    }
+    catch (error) {
+        throw new Error(`In ahead, after ${move}, ${error.message}`);
+    }
 }
 /** A move given in notes or in ahead, as analyse_game numbers it, refused with where it was given (Priya). */
 function indexIn(record, move, field) {

package/dist/commands/answer-lines.d.ts

@@ -12,6 +12,8 @@ export declare function lastMoveText({ move, from, to }: LastMove): string;
  * (Priya, test of D-86): 4.Ng5 is 4.♞g5.
  */
 export declare function shownMove(move: string): string;
+/** Numbered moves as the player is shown them, with the pieces' figurines (D-86): 4...g6 5.Nxe5 Bxd1 is 4...g6 5.♞xe5 ♝xd1. */
+export declare function shownMoves(moves: string): string;
 /** The lines after a move, which the line before named: its note, where the game stands, a warning. closingLines end them. */
 export declare function moveLines({ note, game, warning }: MovePlayed): string[];
 /** The last lines of a tool's answer: the player's words from the board page, then the next step, which stays the last line. */

package/dist/commands/answer-lines.js

@@ -4,7 +4,7 @@ import { talkLimits } from "../games/index.js";
 import { onQuickModel } from "../host-files/index.js";
 import { analystLine, reviewedLine } from "./agents.js";
 import { clockLine } from "./clock.js";
-import { endText } from "./game-summary.js";
+import { endText, unplayed } from "./game-summary.js";
 import { boardView, colourName, compactView, materialText } from "./view.js";
 /** Where the game stands: the AI's position to decide on, with its last move unless the lines before named it; the player's turn; or how it ended. */
 export function positionLines(game, withLastMove = true) {
@@ -63,6 +63,10 @@ export function shownMove(move) {
     const [, number = "", san = move] = /^(\d+\.+)(.+)$/.exec(move) ?? [];
     return `${number}${figurinesOf(san)}`;
 }
+/** Numbered moves as the player is shown them, with the pieces' figurines (D-86): 4...g6 5.Nxe5 Bxd1 is 4...g6 5.♞xe5 ♝xd1. */
+export function shownMoves(moves) {
+    return moves.split(" ").map(shownMove).join(" ");
+}
 /** The lines after a move, which the line before named: its note, where the game stands, a warning. closingLines end them. */
 export function moveLines({ note, game, warning }) {
     return [...(note === undefined ? [] : [`Note: ${note}`]), ...positionLines(game, false), ...(warning === undefined ? [] : [warning])];
@@ -76,7 +80,7 @@ export function closingLines(game, words = [], pageClosed = false) {
  * theirs reads as one of Chesspal's.
  */
 export function wordLines(words) {
-    return words.map(({ text, at }) => `Player wrote on the board page${at === undefined ? "" : `, at ${at}`}: «${text.replace(/\s+/g, " ")}»`);
+    return words.map(({ text, place }) => `Player wrote on the board page${place === undefined ? "" : `, at ${place}`}: «${text.replace(/\s+/g, " ")}»`);
 }
 /**
  * What the AI does next: the one line every host reads, even where the server's instructions are not shown. Words of the player's ask for an answer. With the
@@ -85,13 +89,19 @@ export function wordLines(words) {
 export function nextStep(game, words = [], pageClosed = false) {
     const step = pageClosed ? closedPageGameStep : newGameStep;
     // Words written on a game in analysis: the chat answers them there, and corrects the review where they show it wrong (D-101).
-    if (words.some((word) => word.at !== undefined) && (game === undefined || game.end !== undefined)) {
+    if (words.some((word) => word.place !== undefined) && (game === undefined || game.end !== undefined)) {
         return "Next: answer the player with ai_say, about the move they were looking at. When they show you something the review missed, first correct that move's "
             + "note with annotate_game, that move only.";
     }
     if (game === undefined) {
         return words.length === 0 ? `Next: when the player wants a game, ${step}` : `Next: answer the player with ai_say. When they want a game, ${step}`;
     }
+    if (game.end !== undefined && unplayed(game)) {
+        return words.length === 0
+            ? "Next: tell the player how the game ended, with ai_say and how you feel as its mood if they play on the board page; then offer them, in words, another "
+                + `game. For another, ${step}`
+            : `Next: answer the player with ai_say. When they want another game, ${step}`;
+    }
     if (game.end !== undefined) {
         const analysis = game.end.analyst === "offer"
             ? ` To go over it, on their yes, ${analystLine(game.end.archive)}`

package/dist/commands/coach.js

@@ -10,6 +10,7 @@ import { aheadWords, leadFrom, leadInput } from "./lead-input.js";
 import { knownMoves, openingLine } from "./opening-book.js";
 import { waitForPlayer, wordsOf } from "./ponder.js";
 import { profileLines } from "./position.js";
+import { ratingsText } from "./profiles.js";
 import { defineCommand } from "./registry.js";
 import { speechLine, speechOf } from "./speech.js";
 import { colourName, compactView, materialText, riskLine } from "./view.js";
@@ -237,8 +238,9 @@ function nowLines(current, folder, player) {
 }
 /** How the player says they play, and their rating, when their profile says so. */
 function playerLines(context) {
-    const { level, rating } = activeProfile(context.home());
-    const parts = [level === undefined ? undefined : `plays at the ${level} level`, rating === undefined ? undefined : `is rated ${rating.value} on ${rating.site}`];
+    const profile = activeProfile(context.home());
+    const ratings = ratingsText(profile);
+    const parts = [profile.level === undefined ? undefined : `plays at the ${profile.level} level`, ratings === undefined ? undefined : `is rated ${ratings}`];
     const said = parts.filter((part) => part !== undefined);
     return said.length === 0 ? [] : [`The player ${said.join(" and ")}.`];
 }

package/dist/commands/context.d.ts

@@ -20,6 +20,8 @@ export interface Context {
     pageOpen?: () => boolean;
     /** Opens a folder in the system's file manager: the data folder, from the board page; whether it could; none in the tests. */
     openFolder?: (folder: string) => Promise<boolean>;
+    /** Asks the sites the player plays on for their ratings (D-105): only the page and the command line, never a tool of the AI's (D-106); none in the tests. */
+    fetch?: typeof globalThis.fetch;
     /** Opens the New game window on the board pages open now, where the player chooses the game: whether one was open. */
     askNewGame?: () => boolean;
     /** The AI host, as it names itself to the MCP server: claude-code, which notes how each chat starts (D-57); none on the command line. */
@@ -29,7 +31,9 @@ export interface Context {
     /** Told when the board page has news that no file holds: words the AI was given, which it shows read (D-53), and the AI's model (D-82). */
     heard?: () => void;
     /** Told when the chat calls a tool, before it runs: the board page hears the chat listens, and the AI's clock, held while nobody did, starts. */
-    calls?: () => void;
+    calls?: () => void | Promise<void>;
+    /** Told when a tool of the chat's has ended: the table the chat is attached to gets a copy of what it saw, else the chat looks for one (D-104). */
+    toolEnded?: () => void;
     /** The game the chat saw when its last tool ended, its folder and its stamp: the doorbell wakes it only for a game changed since. */
     seen?: string | undefined;
     /**
@@ -43,6 +47,8 @@ export interface Context {
     caller?: () => Promise<Caller | undefined>;
     /** The agent that makes this call of a tool it shares with the chat, as the analyst (D-89); none for the chat, or when it cannot be told. */
     agent?: string;
+    /** Which run of that agent makes the call, as the host tells it: two analysts started on one game are two runs. */
+    agentRun?: string;
     /** The chat makes this call of a tool it shares with an agent, as the host tells it: a caller that cannot be told is not the chat here (Federico). */
     chat?: true;
 }
@@ -63,5 +69,7 @@ export interface SeenPosition {
 }
 /** The context of a process started in the player's folder: the data folder is found at the first command that needs it, once. */
 export declare function defaultContext(): Context;
+/** Whether the player's language is Italian: the command line speaks Italian to them then, English otherwise (D-32). */
+export declare function speaksItalian(language: string | undefined): boolean;
 /** A data folder with a profile in it, the first made when there is none, named after the system's account (D-71). */
 export declare function withProfile(folder: string, account: string): string;

package/dist/commands/context.js

@@ -15,8 +15,13 @@ export function defaultContext() {
         language: systemLanguage(),
         given: new Set(),
         openFolder: (folder) => openFolder(folder, process.platform),
+        fetch: globalThis.fetch,
     };
 }
+/** Whether the player's language is Italian: the command line speaks Italian to them then, English otherwise (D-32). */
+export function speaksItalian(language) {
+    return language?.slice(0, 2).toLowerCase() === "it";
+}
 /** A data folder with a profile in it, the first made when there is none, named after the system's account (D-71). */
 export function withProfile(folder, account) {
     ensureProfile(folder, account);

package/dist/commands/delete-review.js

@@ -2,7 +2,7 @@
 // delete, never the AI.
 import { z } from "zod";
 import { isReviewed, unreviewed } from "../core/index.js";
-import { endAnalysis, forgetCoach, gameInAnalysis, isOverOnTable, rewriteGame, startAnalysis } from "../games/index.js";
+import { forgetAnalyst, forgetCoach, gameInAnalysis, isOverOnTable, rewriteGame, startAnalysis } from "../games/index.js";
 import { gameFolder } from "../profiles/index.js";
 import { defineCommand } from "./registry.js";
 import { namedGame } from "./study.js";
@@ -24,10 +24,14 @@ export const deleteReview = defineCommand({
         if (isOverOnTable(folder, name)) {
             forgetCoach(folder);
         }
-        // The page showing the game hears of it, and shows it without its review; the chat's corrections go with it.
-        if (gameInAnalysis(folder)?.game === name) {
-            endAnalysis(folder);
-            startAnalysis(folder, name, context.now());
+        // The page showing the game hears of it, and shows it without its review; the chat's corrections and the analyst that took it go with it, the
+        // analyst also while the page shows another game.
+        const analysis = gameInAnalysis(folder);
+        if (analysis?.game === name) {
+            startAnalysis(folder, name, context.now(), { afresh: true });
+        }
+        else if (analysis?.analyst?.game === name) {
+            forgetAnalyst(folder);
         }
         return { game: name, reviewed: isReviewed(record) };
     },

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

@@ -74,6 +74,8 @@ export declare function summaryOf(current: CurrentGame, now: Date, archive?: str
 export declare function withThought(summary: GameSummary, folder: string, current: CurrentGame, coached: boolean): GameSummary;
 /** The current game `now`, refused when there is none or when it is over, on time too. */
 export declare function gameGoingOn(folder: string, now: Date): CurrentGame;
+/** Whether a game has no move yet, or was closed before any: nothing to go over. */
+export declare function unplayed(summary: GameSummary): boolean;
 /** How a game ended, in words: its result, and how it came when known. */
 export declare function endText({ result, termination }: {
     result: string;

package/dist/commands/game-summary.js

@@ -62,6 +62,10 @@ export function gameGoingOn(folder, now) {
     }
     return current;
 }
+/** Whether a game has no move yet, or was closed before any: nothing to go over. */
+export function unplayed(summary) {
+    return summary.lastMoves === "";
+}
 /** How a game ended, in words: its result, and how it came when known. */
 export function endText({ result, termination }) {
     return termination === undefined ? result : `${result}, ${termination}`;

package/dist/commands/index.d.ts

@@ -2,7 +2,7 @@ import type { AnyCommand } from "./registry.ts";
 export { aiMove } from "./ai-move.ts";
 export { analyseGame } from "./analyse-game.ts";
 export { gameAt } from "./clock.ts";
-export { type Caller, type Context, defaultContext, type SeenPosition } from "./context.ts";
+export { type Caller, type Context, defaultContext, type SeenPosition, speaksItalian } from "./context.ts";
 export { deleteGame } from "./delete-game.ts";
 export { deleteReview } from "./delete-review.ts";
 export { answerDraw, DrawRefused, offerDraw } from "./draw-offer.ts";
@@ -10,7 +10,8 @@ export { endGame } from "./end-game.ts";
 export { ChatNotClear, newGame, startNewGame } from "./new-game.ts";
 export { bookOpening, bookPlies } from "./opening-book.ts";
 export { playMove, PositionChanged, positionIn, samePosition } from "./play-move.ts";
-export { chooseDrawnAvatar, GameGoingOn, newProfile, setAccounts, useProfile } from "./profiles.ts";
+export { chooseDrawnAvatar, editProfile, GameGoingOn, newProfile, useProfile } from "./profiles.ts";
+export { ratingsAge, refreshRatings } from "./ratings.ts";
 export { type AnyCommand, baseType, type Command, commandLineFieldProblem, inputProblems, isBoolean, isList, takesNumbers } from "./registry.ts";
 export { say } from "./say.ts";
 export { gameToStudy, namedGame, shownPosition } from "./study.ts";

package/dist/commands/index.js

@@ -9,6 +9,7 @@ import { deleteReview } from "./delete-review.js";
 import { endGame } from "./end-game.js";
 import { exportGame } from "./export-game.js";
 import { init } from "./init.js";
+import { instructions } from "./instructions.js";
 import { look } from "./look.js";
 import { newGame } from "./new-game.js";
 import { pastGames } from "./past-games.js";
@@ -16,14 +17,14 @@ import { playerMove } from "./player-move.js";
 import { playerSay } from "./player-say.js";
 import { ponder } from "./ponder.js";
 import { position } from "./position.js";
-import { newProfile, profiles, setAccounts, setAvatar, useProfile } from "./profiles.js";
+import { editProfile, newProfile, profiles, setAvatar, useProfile } from "./profiles.js";
 import { status } from "./status.js";
 import { studyGames } from "./study-games.js";
 // What the server and the command line use besides the list: the context, the reading of an input, and the operations the page shares with the tools.
 export { aiMove } from "./ai-move.js";
 export { analyseGame } from "./analyse-game.js";
 export { gameAt } from "./clock.js";
-export { defaultContext } from "./context.js";
+export { defaultContext, speaksItalian } from "./context.js";
 export { deleteGame } from "./delete-game.js";
 export { deleteReview } from "./delete-review.js";
 export { answerDraw, DrawRefused, offerDraw } from "./draw-offer.js";
@@ -31,13 +32,15 @@ export { endGame } from "./end-game.js";
 export { ChatNotClear, newGame, startNewGame } from "./new-game.js";
 export { bookOpening, bookPlies } from "./opening-book.js";
 export { playMove, PositionChanged, positionIn, samePosition } from "./play-move.js";
-export { chooseDrawnAvatar, GameGoingOn, newProfile, setAccounts, useProfile } from "./profiles.js";
+export { chooseDrawnAvatar, editProfile, GameGoingOn, newProfile, useProfile } from "./profiles.js";
+export { ratingsAge, refreshRatings } from "./ratings.js";
 export { baseType, commandLineFieldProblem, inputProblems, isBoolean, isList, takesNumbers } from "./registry.js";
 export { say } from "./say.js";
 export { gameToStudy, namedGame, shownPosition } from "./study.js";
 /** Every command of Chesspal, in the order the command line lists them and the MCP server offers them. */
 export const commands = [
     init,
+    instructions,
     status,
     newGame,
     playerMove,
@@ -60,5 +63,5 @@ export const commands = [
     newProfile,
     useProfile,
     setAvatar,
-    setAccounts,
+    editProfile,
 ];

package/dist/commands/init.js

@@ -4,6 +4,7 @@ import { relative, resolve } from "node:path";
 import { styleText } from "node:util";
 import { z } from "zod";
 import { codexHooksPath, setUpHosts } from "../host-files/index.js";
+import { speaksItalian } from "./context.js";
 import { defineCommand } from "./registry.js";
 /** Makes a folder the player's chess table: the files through which Claude Code and Codex find Chesspal and the opponent's instructions (D-31). */
 export const init = defineCommand({
@@ -28,7 +29,7 @@ export const init = defineCommand({
         };
     },
     format: ({ folder, written, enter, hooksChanged }, context) => {
-        const words = wordsFor(context?.language);
+        const words = speaksItalian(context?.language) ? italian : english;
         const steps = [words.open(enter === undefined ? undefined : quoted(enter)), ...words.steps];
         return [
             styleText(["bold", "green"], `♜ ${written.length === 0 ? words.ready(folder) : words.set(folder)}`),
@@ -64,9 +65,6 @@ const italian = {
     hooksChanged: "Gli «hook» di Chesspal per Codex sono cambiati: quando Codex te lo chiede, scegli di nuovo Trust all.",
     updated: (count) => count === 1 ? "Aggiornato 1 file." : `Aggiornati ${count} file.`,
 };
-function wordsFor(language) {
-    return language?.slice(0, 2).toLowerCase() === "it" ? italian : english;
-}
 /** A path as a shell reads it as one word: in quotes when it has spaces. */
 function quoted(path) {
     return /\s/.test(path) ? `"${path}"` : path;

package/dist/commands/instructions.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+import type { Context } from "./context.ts";
+/** How to play as the player's opponent, which the chat reads before its first reply and again after a summary (D-102). */
+export declare const instructions: import("./registry.ts").Command<z.ZodObject<{}, z.core.$strip>, string>;
+/**
+ * Whether the chat has read the opponent's instructions since it started, or was cleared or summarized, as its start keys them (D-57); without the host's
+ * note of it, since the MCP server started. Always on the command line, which keeps nothing.
+ */
+export declare function instructionsRead(context: Context, chatStart: string | undefined): boolean;

package/dist/commands/instructions.js

@@ -0,0 +1,30 @@
+// The opponent's instructions, which the MCP server gives so that they follow the version installed (D-102).
+import { z } from "zod";
+import { lastChatStart } from "../games/index.js";
+import { opponentInstructions } from "../host-files/index.js";
+import { defineCommand } from "./registry.js";
+/** How to play as the player's opponent, which the chat reads before its first reply and again after a summary (D-102). */
+export const instructions = defineCommand({
+    name: "instructions",
+    description: "How to play as the player's opponent at this table: the tools, the board page, how to talk. Call it before your first reply in every chat, "
+        + "and again after the conversation is summarized; then call `status`.",
+    input: z.object({}),
+    readOnly: true,
+    idempotent: true,
+    alwaysLoad: true,
+    run: (input, context) => {
+        context.told?.add(readKey(lastChatStart(context.folder)?.at));
+        return opponentInstructions();
+    },
+    format: (text) => text,
+});
+/**
+ * Whether the chat has read the opponent's instructions since it started, or was cleared or summarized, as its start keys them (D-57); without the host's
+ * note of it, since the MCP server started. Always on the command line, which keeps nothing.
+ */
+export function instructionsRead(context, chatStart) {
+    return context.told === undefined || context.told.has(readKey(chatStart));
+}
+function readKey(chatStart) {
+    return `instructions ${chatStart ?? ""}`;
+}

package/dist/commands/lead-input.d.ts

@@ -4,5 +4,5 @@ import { type Lead } from "../core/index.ts";
 export declare const leadInput: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
 /** Who is ahead in words, the side and by how much, so that the AI reads its own sign back (Anatolij). */
 export declare function aheadWords(lead: Lead): string;
-/** The lead an input gave, checked by leadInput. */
+/** The lead an input gave, refused with how to write it when it is none. */
 export declare function leadFrom(value: number | string): Lead;