chesspal 0.2.3 → 0.3.0

package/dist/commands/analyse-game.js

@@ -1,21 +1,22 @@
 // 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 } from "./view.js";
-// The analyst's instructions, read at the first analysis.
-let analystText;
+import { balanceText, colourName, riskLine, tacticsText } from "./view.js";
 /** 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 and the mates in one after it, where the game left the opening book, and your comments and plans. Facts "
+        + "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 "
         + "it also says how to analyse. annotate_game then keeps your badges and notes for the board page. Example: analyse_game {}.",
@@ -31,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 };
@@ -51,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);
@@ -145,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) };
+    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) => {
@@ -169,7 +197,9 @@ 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,
             drawOffer: comment?.includes("(=)") === true ? true : undefined,
             said: side === ai ? saidIn(comment) : undefined,
@@ -206,7 +236,7 @@ function analysisHead(analysis) {
     const review = analysis.review === undefined ? [] : [`Your review: ${analysis.review}`];
     return [head, ...opening, ...review, `${name}.`, ...start];
 }
-/** 12...Nxe5: took P; spent 0:12, 4:32 left; material White +1; at risk: undefended Black Nf6; mate in one: Qh7#; out of book; you said "…"; your plan: …; ahead -1.5 */
+/** 12...Nxe5: took P; spent 0:12, 4:32 left; material White +1; at risk: undefended Black Nf6; mate in one: Qh7#; tactics: fork Nc7+ (Ke8 Ra8); out of book; you said "…"; your plan: …; ahead -1.5 */
 function moveLine(move) {
     const left = move.left === undefined ? undefined : `${clockText(move.left)} left`;
     const parts = [
@@ -214,7 +244,9 @@ 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,
         move.drawOffer ? "offers a draw" : undefined,
         move.said === undefined ? undefined : `you said "${move.said}"`,
@@ -235,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

@@ -10,6 +10,10 @@ interface Annotated {
     /** How many moves took who is ahead after them, and those still without it, as analyse_game numbers them (D-90). */
     estimated: number;
     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,12 +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 { 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;
@@ -30,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"),
     }),
@@ -48,6 +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) && 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) {
@@ -55,36 +72,45 @@ 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;
+            }
             // A note alone on a move of the book keeps its book badge: a fact Chesspal put there, not the AI's judgment.
             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(gameFolder(context.home()), studied.name, summary === undefined && closing === undefined ? marked : withGameReview(marked, { ...(summary === undefined ? {} : { summary }), ...(closing === undefined ? {} : { closing }) }));
-        startAnalysis(gameFolder(context.home()), studied.name, context.now());
-        const numbers = moveNumbers(marked);
+        rewriteGame(folder, studied.name, summary === undefined && closing === undefined ? marked : withGameReview(marked, { ...(summary === undefined ? {} : { summary }), ...(closing === undefined ? {} : { closing }) }));
+        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]] : [];
         });
         return {
             game: studied.name,
-            marked: notes.length,
+            marked: notes.length - skipped,
             summary: summary !== undefined,
             closing: closing !== undefined,
-            bookUnnoted,
-            estimated: estimates.length,
+            bookUnnoted: correction ? [] : bookUnnoted,
+            estimated: leads.length,
             // Asked every time, of an older review too: an analyst whose instructions predate the estimates learns of them here.
-            unestimated: 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 }) => {
+    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"}`,
@@ -100,13 +126,27 @@ export const annotateGame = defineCommand({
         const shown = unestimated.slice(0, unestimatedShown).join(" ");
         const more = unestimated.length > unestimatedShown ? ` and ${unestimated.length - unestimatedShown} more` : "";
         const ahead = unestimated.length === 0 ? [] : [`Who is ahead is still missing after ${shown}${more}: give it with ahead, for the page's bar and chart.`];
-        return [`Kept in ${game}: ${[kept.slice(0, -1).join(", "), kept.at(-1)].filter((part) => part !== "").join(" and ")}. The board page shows them.`, ...book, ...ahead].join("\n");
+        const one = left.length === 1;
+        const corrected = left.length === 0
+            ? []
+            : [`${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.`;
+        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

@@ -1,5 +1,6 @@
 import { type Side } from "../core/index.ts";
 import { type GameSummary, type LastMove, type MovePlayed } from "./game-summary.ts";
+import type { Written } from "./say.ts";
 /** 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 declare function positionLines(game: GameSummary, withLastMove?: boolean): string[];
 /** The head of a view: where the game stands, the last move unless the lines before named it, the opening, the material as the player sees it, and the FEN. */
@@ -11,17 +12,22 @@ 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. */
-export declare function closingLines(game: GameSummary | undefined, words?: readonly string[], pageClosed?: boolean): string[];
-/** The player's words from the board page, one line each: lines they broke are joined, so no line of theirs reads as one of Chesspal's. */
-export declare function wordLines(words: readonly string[]): string[];
+export declare function closingLines(game: GameSummary | undefined, words?: readonly Written[], pageClosed?: boolean): string[];
+/**
+ * The player's words from the board page, one line each, in analysis with the move the page showed (D-101): lines they broke are joined, so no line of
+ * theirs reads as one of Chesspal's.
+ */
+export declare function wordLines(words: readonly Written[]): string[];
 /**
  * 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
  * board page open in no browser, a new game starts there, never in the chat.
  */
-export declare function nextStep(game: GameSummary | undefined, words?: readonly string[], pageClosed?: boolean): string;
+export declare function nextStep(game: GameSummary | undefined, words?: readonly Written[], pageClosed?: boolean): string;
 /** How a new game starts: the player chooses it in the board page's window, which new_game without choices opens (D-85). */
 export declare const newGameStep = "call new_game without choices: it opens the board page's New game window, where the player chooses the colour, the clock and the level.";
 /** Who plays what, from the AI's side. */

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) {
@@ -13,7 +13,7 @@ export function positionLines(game, withLastMove = true) {
     }
     return [
         ...headLines(game, withLastMove),
-        ...(game.facts === undefined ? [] : (sees(game.level, "tactics") ? compactView : boardView)(game.facts, game.turn)),
+        ...(game.facts === undefined ? [] : viewLines(game.facts, game)),
         ...(game.book === undefined ? [] : [`Book moves, most named lines first: ${game.book.join(", ")}`]),
         ...(game.plan === undefined ? [] : [`Plan: ${game.plan}`]),
         ...(game.thought === undefined ? [] : [thoughtLine(game.thought, game.level)]),
@@ -21,6 +21,14 @@ export function positionLines(game, withLastMove = true) {
         ...(game.helps === "coached" ? [`${helpsLine} ${coachLine}`] : game.helps === "on" ? [helpsLine] : game.helps === "off now" ? [helpsOffLine] : []),
     ];
 }
+/** The view of the AI's position as its level sees it (D-60, D-100): the tactical facts from the club level, the other side's chances from the strong level. */
+function viewLines(facts, game) {
+    if (!sees(game.level, "tactics")) {
+        return boardView(facts, game.turn);
+    }
+    const possible = game.possibilities === undefined ? undefined : { possibilities: game.possibilities, threats: game.threats, strong: sees(game.level, "strategy") };
+    return compactView(facts, game.turn, possible);
+}
 /** The helps turned on: the AI may teach as the analyst does (D-62, D-78), never playing for the player. */
 const helpsLine = "Helps on: the player wants to learn. Tell your intentions, never their best move; draw arrows and squares to show what you say, and write up to "
     + `${talkLimits.aiHelps} characters.`;
@@ -55,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])];
@@ -63,9 +75,12 @@ export function moveLines({ note, game, warning }) {
 export function closingLines(game, words = [], pageClosed = false) {
     return [...wordLines(words), nextStep(game, words, pageClosed)];
 }
-/** The player's words from the board page, one line each: lines they broke are joined, so no line of theirs reads as one of Chesspal's. */
+/**
+ * The player's words from the board page, one line each, in analysis with the move the page showed (D-101): lines they broke are joined, so no line of
+ * theirs reads as one of Chesspal's.
+ */
 export function wordLines(words) {
-    return words.map((text) => `Player wrote on the board page: «${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
@@ -73,9 +88,20 @@ 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.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";
@@ -202,7 +203,7 @@ function judgedLines({ game }, ply, player) {
         `Their move to judge: ${lastMoves(played, 1)}. The position they played it in:`,
         `FEN: ${before.position.fen}`,
         `Material: ${materialText(materialOf(before.position.fen))}`,
-        ...compactView(before.facts, player),
+        ...compactView(before.facts, player, { possibilities: before.possibilities, threats: before.threats, strong: true }),
         ...(book.length === 0 ? [] : [`Book moves there, most named lines first: ${book.join(", ")}`]),
     ];
     if (ply === record.moves.length) {
@@ -229,7 +230,7 @@ function nowLines(current, folder, player) {
     return [
         "Now, for who is ahead and your hint:",
         `FEN: ${game.position.fen}`,
-        ...compactView(game.facts, player),
+        ...compactView(game.facts, player, { possibilities: game.possibilities, threats: game.threats, strong: true }),
         ...profileLines(game.profile),
         ...(lead === undefined ? [] : [`Who you saw ahead on their turn before: ${leadText(lead)}, ${aheadWords(lead)}`]),
         ...(hint === undefined || hint.position !== plies - 2 ? [] : [`Your hint on their turn before: «${hint.text}»`]),
@@ -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,10 @@ 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;
 }
 /** Who made a tool call: the model, else the host's name, never what the AI says of itself; the effort only when the host gives it. */
 export interface Caller {
@@ -61,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 { 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,9 +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.
-        if (gameInAnalysis(folder)?.game === name) {
-            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

@@ -1,6 +1,7 @@
-import { type AiLevel, type Facts, type GameRecord, type MoodNow, type Side, type Square } from "../core/index.ts";
+import { type AiLevel, type Chances, type Facts, type GameRecord, type MoodNow, type Possibilities, type Side, type Square } from "../core/index.ts";
 import { type CurrentGame, type Speaker, type Thought } from "../games/index.ts";
 import { type ClockSummary } from "./clock.ts";
+import type { Written } from "./say.ts";
 /** The current game, as the commands give it. */
 export interface GameSummary {
     ai: Side;
@@ -17,6 +18,10 @@ export interface GameSummary {
     opening?: string;
     /** When the AI is to move: the facts of the position (D-26); below the club level, only the check and the legal moves of each piece are shown. */
     facts?: Facts;
+    /** When the AI is to move, from the club level up: what the moves would do (D-100). */
+    possibilities?: Possibilities;
+    /** With the possibilities, out of check: what the player's moves would do if they were to move. */
+    threats?: Chances;
     /** When the AI is to move at the master level, in the book: the moves it knows from the position (D-15, D-60). */
     book?: readonly string[];
     /** When the AI is to move: the plan it wrote last. */
@@ -58,7 +63,7 @@ export interface MovePlayed {
     /** What went wrong after the move was saved, such as the archive not written. */
     warning?: string;
     /** What the player wrote on the board page that the AI has not been given yet. */
-    words?: string[];
+    words?: Written[];
 }
 /** The game as the commands tell it; a game over with the name it has in the archive, when it is there. */
 export declare function summaryOf(current: CurrentGame, now: Date, archive?: string): GameSummary;
@@ -69,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}`;
@@ -90,6 +94,13 @@ function judgedBefore(current) {
 function addAiFacts(summary, { game }) {
     const plan = currentPlan(game.record);
     summary.facts = game.facts;
+    if (sees(summary.level, "tactics")) {
+        summary.possibilities = game.possibilities;
+        const { threats } = game;
+        if (threats !== undefined) {
+            summary.threats = threats;
+        }
+    }
     if (sees(summary.level, "theory")) {
         const book = knownMoves(summary.fen);
         if (book.length > 0) {

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,9 +10,10 @@ 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 } from "./study.ts";
+export { gameToStudy, namedGame, shownPosition } from "./study.ts";
 /** Every command of Chesspal, in the order the command line lists them and the MCP server offers them. */
 export declare const commands: AnyCommand[];