chesspal 0.3.5 → 0.4.0

package/dist/commands/game/export.d.ts

@@ -6,9 +6,9 @@ interface Exported {
 /** The game as PGN or its position as FEN, for the player to copy or keep: the plans stay hidden while it goes on (D-29); the moves alone for another site. */
 export declare const exportGame: import("../registry/registry.ts").Command<z.ZodObject<{
     format: z.ZodEnum<{
-        fen: "fen";
         moves: "moves";
         pgn: "pgn";
+        fen: "fen";
     }>;
 }, z.core.$strip>, Exported>;
 export {};

package/dist/commands/game/index.d.ts

@@ -5,7 +5,7 @@ export { endGame } from "./end.ts";
 export { exportGame } from "./export.ts";
 export { look } from "./look.ts";
 export { ChatNotClear, newGame, startNewGame } from "./new.ts";
-export { playerMove } from "./player-move.ts";
+export { type MoveSentAlone, playerMove, playMoveSentAlone } from "./player-move.ts";
 export { ponder } from "./ponder.ts";
 export { position } from "./position.ts";
 export { status } from "./status.ts";

package/dist/commands/game/index.js

@@ -7,7 +7,7 @@ export { endGame } from "./end.js";
 export { exportGame } from "./export.js";
 export { look } from "./look.js";
 export { ChatNotClear, newGame, startNewGame } from "./new.js";
-export { playerMove } from "./player-move.js";
+export { playerMove, playMoveSentAlone } from "./player-move.js";
 export { ponder } from "./ponder.js";
 export { position } from "./position.js";
 export { status } from "./status.js";

package/dist/commands/game/look.d.ts

@@ -24,11 +24,15 @@ export declare const look: import("../registry/registry.ts").Command<z.ZodObject
     }>>;
 }, z.core.$strip>, {
     board: string;
-} | {
+} | ({
     game: Viewed;
     words: Written[];
-} | {
+} & {
+    analyst?: string;
+}) | ({
     study: StudyView;
     words: Written[];
-}>;
+} & {
+    analyst?: string;
+})>;
 export {};

package/dist/commands/game/look.js

@@ -1,8 +1,9 @@
 import { z } from "zod";
 import { boardText, materialOf, sees } from "../../core/index.js";
+import { archivedName, endOf } from "../../games/index.js";
 import { analystAgent } from "../../host-files/index.js";
 import { gameFolder } from "../../profiles/index.js";
-import { fullView, gameAt, gameShown, headLines, materialText, newWords, positionAfter, positionLine, studyInput, summaryOf, wordLines } from "../answers/index.js";
+import { analystOnView, fullView, gameAt, gameShown, headLines, materialText, newWords, positionAfter, positionLine, studyInput, summaryOf, wordLines } from "../answers/index.js";
 import { defineCommand } from "../registry/index.js";
 import { refuseUnseen } from "./levels.js";
 /** The whole view (D-26), when the compact one after the player's move is not enough; or the board for the player, where the host does not show it (D-36). */
@@ -34,13 +35,14 @@ export const look = defineCommand({
         }
         const { threats } = current.game;
         const viewed = { ...summaryOf(current, context.now()), facts: current.game.facts, possibilities: current.game.possibilities };
-        return { game: threats === undefined ? viewed : { ...viewed, threats }, words: newWords(context) };
+        const over = endOf(current.game) === undefined ? undefined : archivedName(gameFolder(context.home()), current);
+        return withAnalystLine({ game: threats === undefined ? viewed : { ...viewed, threats }, words: newWords(context) }, analystOnView(context, over));
     },
     format: (look) => {
         if ("board" in look) {
             return look.board;
         }
-        return [...("game" in look ? gameLines(look.game) : studyLines(look.study)), ...wordLines(look.words)].join("\n");
+        return [...("game" in look ? gameLines(look.game) : studyLines(look.study)), ...wordLines(look.words), ...(look.analyst === undefined ? [] : [look.analyst])].join("\n");
     },
 });
 /** A position of a game over, as the view of the game going on gives it. */
@@ -52,7 +54,10 @@ function studyLook(context, only, name, move) {
         return { board: boardText(position.fen) };
     }
     const view = { where: positionLine(at, studied.name), turn: position.turn, fen: position.fen, facts: at.game.facts, possibilities: at.game.possibilities, threats: at.game.threats };
-    return { study: view, words: newWords(context) };
+    return withAnalystLine({ study: view, words: newWords(context) }, analystOnView(context, studied.name));
+}
+function withAnalystLine(look, analyst) {
+    return analyst === undefined ? look : { ...look, analyst };
 }
 /** The game going on: its head and the whole view, with the other side's chances from the strong level (D-100). */
 function gameLines(game) {

package/dist/commands/game/new.js

@@ -1,8 +1,11 @@
+import { existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
 import { z } from "zod";
 import { aiLevels, Game, levelTag, pgnDate, readPgn, startClock, timeControlOf, timeControlTag, withoutMoods } from "../../core/index.js";
-import { archivedName, archiveGame, cleanSince, endAnalysis, endOf, endTableTalk, lastChatStart, loadGame, saveGame, startOfNewGame, withoutPlans } from "../../games/index.js";
+import { archivedName, archiveGame, archiveName, cleanSince, endAnalysis, endOf, endTableTalk, lastChatStart, loadGame, saveGame, startOfNewGame, withoutPlans } from "../../games/index.js";
+import { hasDoorbell } from "../../host-files/index.js";
 import { gameFolder, gameFolders } from "../../profiles/index.js";
-import { coachRuns, gameAt, nextStep, positionLines, refuseUnseenPosition, sidesLine, speechLine, speechOf, summaryOf, withThought } from "../answers/index.js";
+import { coachRuns, gameAt, nextStep, openingTags, positionLines, refuseUnseenPosition, sidesLine, speechLine, speechOf, summaryOf, withThought } from "../answers/index.js";
 import { pastGameLines, playerLine } from "../profiles/index.js";
 import { defineCommand } from "../registry/index.js";
 import { levelText, levelToPlay } from "./levels.js";
@@ -37,7 +40,7 @@ export const newGame = defineCommand({
         }
         return startNewGame(input, context, "chat");
     },
-    format: (result) => "window" in result ? askedLine(result) : startedLines(result),
+    format: (result, context) => "window" in result ? askedLine(result, hasDoorbell(context?.host?.())) : startedLines(result, hasDoorbell(context?.host?.())),
 });
 /**
  * Starts the new game with the player's choices: those the AI asked in the chat, or the page's window gave (D-76). Only the chat's is refused on a game
@@ -71,8 +74,7 @@ export function startNewGame({ ai_colour: colour, from, clock, level: chosen, re
     const current = control === undefined
         ? { game, ai, started: started.toISOString(), talk: [] }
         : { game, ai, started: started.toISOString(), talk: [], clock: startClock(control, now, context.pageOpen?.() === true) };
-    const archived = before === undefined || (going === undefined && archivedName(folder, before) !== undefined) ? undefined : archiveBefore(folder, before);
-    saveGame(folder, current);
+    const archived = replaceGame(folder, current, before, going !== undefined);
     endAnalysis(folder);
     endTableTalk(folder);
     const past = pastGameLines(folder, remembered);
@@ -92,16 +94,16 @@ export function startNewGame({ ai_colour: colour, from, clock, level: chosen, re
     };
 }
 /** The new game's lines for the AI. */
-function startedLines({ game, archived, past, player, speech, closedPage: closed }) {
+function startedLines({ game, archived, past, player, speech, closedPage: closed }, doorbell) {
     return [
         `New game: ${sidesLine(game.ai)}, ${levelText(game.level)}.`,
         ...(player === undefined ? [] : [player]),
         ...(speech === undefined ? [] : [speechLine(speech)]),
-        ...(archived === undefined ? [] : [`The game before is in ${archived.name}${archived.finished ? "" : ", unfinished"}.`]),
+        ...(archived === undefined ? [] : [`The game before is saved with the player's games${archived.finished ? "" : ", unfinished"}.`]),
         ...(past.length === 0 ? [] : ["Last games with this player (past_games gives more, and their moves):", ...past]),
         ...positionLines(game),
         ...(closed === undefined ? [] : [pageLine(closed, true)]),
-        nextStep(game),
+        nextStep(game, [], false, doorbell),
     ].join("\n");
 }
 /**
@@ -131,11 +133,16 @@ function justBegun(context) {
     const current = gameAt(gameFolder(context.home()), context.now());
     return current !== undefined && endOf(current.game) === undefined && current.game.record.moves.length === 0;
 }
-function askedLine({ window, page }) {
-    return window === "opened"
+function askedLine({ window, page }, doorbell) {
+    // A host with no doorbell hears of the game from the player, in its window.
+    const told = "End your turn, and call status when they tell you the game started.";
+    if (window !== "opened") {
+        return `Nobody has the board page open: give the player its address, ${page}, and tell them to start the game there with its New game button. ${doorbell ? "End your turn." : told}`;
+    }
+    return doorbell
         ? "The New game window is open on the board page: the player chooses the game there. Don't ask in the chat; end your turn, the doorbell wakes you when "
             + "the game starts."
-        : `Nobody has the board page open: give the player its address, ${page}, and tell them to start the game there with its New game button. End your turn.`;
+        : `The New game window is open on the board page: the player chooses the game there. Don't ask in the chat. ${told}`;
 }
 /** The refusal of a new game in a chat that still holds the game before (D-57): the board page says it in the player's language. */
 export class ChatNotClear extends Error {
@@ -164,9 +171,32 @@ function chatToClear(context) {
 }
 // The hosts whose SessionStart hook, written by init, notes how each chat starts: Claude Code and Codex, by the names they give the server.
 const hostsNotingChats = new Set(["claude-code", "codex-mcp-client"]);
+/**
+ * Writes the new game over the one before, archived first: both under game.json's lock, on the game before as read, so a game another process changed
+ * since is neither archived stale nor lost. When game.json cannot be written, an archive this call made goes: nothing changed.
+ */
+function replaceGame(folder, current, before, going) {
+    let archived;
+    let made = false;
+    try {
+        saveGame(folder, current, () => {
+            if (before !== undefined && (going || archivedName(folder, before) === undefined)) {
+                made = !existsSync(join(folder, archiveName(before)));
+                archived = archiveBefore(folder, before);
+            }
+        });
+    }
+    catch (error) {
+        if (made && archived !== undefined) {
+            rmSync(join(folder, archived), { force: true });
+        }
+        throw error;
+    }
+    return archived;
+}
 function archiveBefore(folder, before) {
     try {
-        return archiveGame(folder, before);
+        return archiveGame(folder, before, openingTags(before.game.record));
     }
     catch (error) {
         throw new Error(`${error.message} Nothing changed.`, { cause: error });

package/dist/commands/game/player-move.d.ts

@@ -1,10 +1,26 @@
 import { z } from "zod";
 import { type MovePlayed } from "../answers/index.ts";
+import { type Context, type SeenPosition } from "../registry/index.ts";
 /** The player's move, written in the chat and given by the AI: it answers with the position the AI decides on (D-34). */
 export declare const playerMove: import("../registry/registry.ts").Command<z.ZodObject<{
     move: z.ZodString;
     offer_draw: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>, PlayerMove>;
+/**
+ * A move the player sent alone in the chat, played by Chesspal before the AI reads it: what the AI is told, the position it then sees, the stamp of
+ * game.json after it, and the keys of the player's words on the board page given with it, for the chat's server to count them as given.
+ */
+export interface MoveSentAlone {
+    answer: string;
+    position: SeenPosition;
+    stamp?: string;
+    given: string[];
+}
+/**
+ * Plays the move the player sent alone in the chat, before the AI reads it (D-36): at the moment they sent it, so with no allowance, and answered as
+ * player_move answers, with the player's words on the board page the AI has not answered. Refused as player_move refuses it: the AI reads the prompt then.
+ */
+export declare function playMoveSentAlone(move: string, context: Context): MoveSentAlone;
 /** The player's move, with the board page's address once a game while no browser has it open (D-85), and the coach to start when it ended the game (D-88). */
 interface PlayerMove extends MovePlayed {
     invite?: string;

package/dist/commands/game/player-move.js

@@ -1,5 +1,7 @@
 import { z } from "zod";
-import { loadGame } from "../../games/index.js";
+import { withSanPieces } from "../../core/index.js";
+import { endOf, gameStamp, loadGame, rerunIfChanged } from "../../games/index.js";
+import { hasDoorbell } from "../../host-files/index.js";
 import { gameFolder } from "../../profiles/index.js";
 import { closingLines, coachOnEnd, coachOnEndLine, coachRuns, lastMoveText, moveLines, newWords, playMove, positionIn, refuseUnseenPosition, shownMove, withAnalyst } from "../answers/index.js";
 import { defineCommand } from "../registry/index.js";
@@ -17,30 +19,78 @@ export const playerMove = defineCommand({
     alwaysLoad: true,
     showsGame: true,
     positionals: ["move"],
-    run: ({ move, offer_draw: offerDraw = false }, context) => {
-        const folder = gameFolder(context.home());
-        // A chat that has seen no game yet, new or resumed, plays the player's own move: its answer shows the game the AI decides on (D-71).
-        if (context.positionSeen !== null) {
-            refuseUnseenPosition(context, folder);
-        }
-        const started = context.positionSeen === null ? positionIn(folder).started : context.positionSeen?.started;
-        const played = playMove(folder, context.now(), "player", move, (message) => `${message} Ask the player again. Nothing changed.`, { allowance: chatAllowance, offerDraw, coached: coachRuns(context) });
-        // A game over by this move has no more moves to play there: the next game's window gives the address (Federico, round of D-85).
-        const invite = played.game.end === undefined ? pageInvite(context, started) : undefined;
-        const ended = played.game.end === undefined ? undefined : loadGame(folder);
-        const coach = ended !== undefined && coachOnEnd(context, folder, ended);
-        return { ...played, game: withAnalyst(played.game, context), words: newWords(context), ...(invite === undefined ? {} : { invite }), ...(coach ? { coach } : {}) };
-    },
-    format: (result) => [
+    run: (input, context) => playersMove(input, context, chatAllowance),
+    format: (result, context) => [
         `Player: ${result.game.lastMove === undefined ? shownMove(result.move) : lastMoveText(result.game.lastMove)}.`,
         ...moveLines(result),
         ...(result.invite === undefined ? [] : [inviteLine(result.invite)]),
-        ...(result.coach === true ? [coachOnEndLine] : []),
-        ...closingLines(result.game, result.words),
+        ...(result.coach === true ? [coachOnEndLine(result.game)] : []),
+        ...closingLines(result.game, result.words, false, hasDoorbell(context?.host?.())),
     ].join("\n"),
 });
+/**
+ * Plays the move the player sent alone in the chat, before the AI reads it (D-36): at the moment they sent it, so with no allowance, and answered as
+ * player_move answers, with the player's words on the board page the AI has not answered. Refused as player_move refuses it: the AI reads the prompt then.
+ */
+export function playMoveSentAlone(move, context) {
+    const folder = gameFolder(context.home());
+    const before = new Set(context.given);
+    const played = rerunIfChanged(() => playersMove({ move }, context, 0));
+    const stamp = gameStamp(folder);
+    return {
+        answer: `Chesspal has already played the move the player wrote alone in the chat: don't call player_move for it.\n${playerMove.format(played, context)}`,
+        position: positionIn(folder),
+        ...(stamp === undefined ? {} : { stamp }),
+        given: [...context.given].filter((key) => !before.has(key)),
+    };
+}
 /**
  * The time a move in the chat leaves off the player's clock (D-36): the AI writing after its move and reading the player's, about 10 s as Priya measured.
- * Claude Code's hooks will time it exactly; the board page's moves need none.
+ * The board page's moves need none, nor those Chesspal plays as the player sends them.
  */
 const chatAllowance = 10_000;
+function playersMove({ move, offer_draw: offerDraw = false }, context, allowance) {
+    const folder = gameFolder(context.home());
+    // A chat that has seen no game yet, new or resumed, plays the player's own move: its answer shows the game the AI decides on (D-71).
+    if (context.positionSeen !== null) {
+        refuseUnseenPosition(context, folder);
+    }
+    refuseKingAsRook(move, folder);
+    // A piece's letter of another language is read as SAN's (D-113): Cf3 is the knight's move, Tf1 the rook's.
+    const read = withSanPieces(move);
+    const readAs = read === move ? "" : `${move.trim()} is read as ${read.trim()}. `;
+    const started = context.positionSeen === null ? positionIn(folder).started : context.positionSeen?.started;
+    const played = playMove(folder, context.now(), "player", read, (message) => `${readAs}${message} Ask the player again. Nothing changed.`, { allowance, offerDraw, coached: coachRuns(context) });
+    // A game over by this move has no more moves to play there: the next game's window gives the address (Federico, round of D-85).
+    const invite = played.game.end === undefined ? pageInvite(context, started) : undefined;
+    const ended = played.game.end === undefined ? undefined : loadGame(folder);
+    const coach = ended !== undefined && coachOnEnd(context, folder, ended);
+    return { ...played, game: withAnalyst(played.game, context), words: newWords(context), ...(invite === undefined ? {} : { invite }), ...(coach ? { coach } : {}) };
+}
+/**
+ * Refuses a move written R and a square when the player's king could go there: R is the king in Italian, French and Spanish, and only the player's words
+ * tell which. A rook's move that names its file or rank, or given as squares, is never the king's.
+ */
+function refuseKingAsRook(move, folder) {
+    const written = move.trim().replace(/^\d+\s*(?:\.[\s.]*|…\s*)/, "").replace(/\s+/g, "");
+    const target = /^[Rr][x:]?([a-h][1-8])[+#]*[!?]*$/.exec(written)?.[1];
+    const current = target === undefined ? undefined : loadGame(folder);
+    // Another side to move, or a game over, is refused by the move itself.
+    if (current === undefined || current.game.position.turn === current.ai || endOf(current.game) !== undefined) {
+        return;
+    }
+    const there = current.game.legalMoves().filter((legal) => legal.to === target);
+    const rooks = there.filter((legal) => legal.san.startsWith("R")).map(squaresOf);
+    const king = there.find((legal) => legal.san.startsWith("K"));
+    if (rooks.length > 0 && king !== undefined) {
+        throw new Error(`${written} may be the rook's move, ${rooks.join(" or ")}, or the king's, ${squaresOf(king)}: R is the king in Italian, French and Spanish. `
+            + "Unless the player's words name the piece, ask them which; then give it as squares. Nothing changed.");
+    }
+    if (rooks.length === 0 && king !== undefined) {
+        throw new Error(`${written} is not legal: R is the rook in SAN, and no rook can go to ${target}. The king can, ${king.san}, and R is the king in Italian, French and Spanish: `
+            + `ask the player whether they meant the king, and give ${king.san} only once they say so. Nothing changed.`);
+    }
+}
+function squaresOf(move) {
+    return `${move.from}${move.to}`;
+}

package/dist/commands/game/ponder.js

@@ -26,7 +26,10 @@ export const ponder = defineCommand({
     }),
     byAgents: ponderAgents,
     hosts: agentHosts,
-    run: async ({ position, reply, move, why, say, done = false }, context) => {
+    run: async (input, context) => {
+        const { reply, move, why, say, done = false } = input;
+        // A quick model writes ponder {} as ponder {position: 0}, and was told to stop: alone, it asks for the position too (Priya).
+        const position = input.position === 0 && Object.keys(input).length === 1 ? undefined : input.position;
         const folder = gameFolder(context.home());
         const current = toPonder(folder, context.now(), position);
         if (current === undefined) {
@@ -36,7 +39,7 @@ export const ponder = defineCommand({
             if (reply !== undefined || move !== undefined || why !== undefined || say !== undefined || done) {
                 throw new Error("Give the position's number with it: call ponder {} first, which gives it. Nothing changed.");
             }
-            notePondering(folder, thoughtKey(current), true);
+            notePondering(folder, thoughtKey(current), true, context.now());
             return { start: startOf(current) };
         }
         if ((say !== undefined || done) && (reply !== undefined || move !== undefined || why !== undefined || (say !== undefined && done))) {
@@ -47,7 +50,7 @@ export const ponder = defineCommand({
             return { said: position };
         }
         if (done) {
-            notePondering(folder, thoughtKey(current), false);
+            notePondering(folder, thoughtKey(current), false, context.now());
             return await waitForMove(folder, context, current);
         }
         if (reply === undefined) {
@@ -71,7 +74,7 @@ export const ponder = defineCommand({
         if (!answer.played) {
             throw new Error(`${answer.message} Your legal moves after ${played.move.san}: ${answer.legal.join(" ")}. Nothing changed.`);
         }
-        return { kept: keepThought(folder, thoughtKey(current), { reply: played.move.san, move: answer.move.san, why }), position };
+        return { kept: keepThought(folder, thoughtKey(current), { reply: played.move.san, move: answer.move.san, why }, context.now()), position };
     },
     format: (pondered) => {
         if ("stop" in pondered) {

package/dist/commands/game/position.d.ts

@@ -1,8 +1,9 @@
 import { z } from "zod";
 import { type Profile } from "../../core/index.ts";
-/** The positional profile of a position: of a game studied, with where it stands. */
+/** The positional profile of a position: of a game studied, with where it stands; with the analyst's line for a game in analysis without its review. */
 type Described = Profile & {
     where?: string;
+    analyst?: string;
 };
 /** The positional profile of the game in progress (D-19), or of any position of a game over (D-68): separate facts, never a score. */
 export declare const position: import("../registry/registry.ts").Command<z.ZodObject<{

package/dist/commands/game/position.js

@@ -1,8 +1,9 @@
 import { z } from "zod";
 import {} from "../../core/index.js";
+import { archivedName, endOf } from "../../games/index.js";
 import { analystAgent } from "../../host-files/index.js";
 import { gameFolder } from "../../profiles/index.js";
-import { colourName, gameAt, gameShown, materialText, positionAfter, positionLine, studyInput } from "../answers/index.js";
+import { analystOnView, colourName, gameAt, gameShown, materialText, positionAfter, positionLine, studyInput } from "../answers/index.js";
 import { defineCommand } from "../registry/index.js";
 import { refuseUnseen } from "./levels.js";
 /** The positional profile of the game in progress (D-19), or of any position of a game over (D-68): separate facts, never a score. */
@@ -21,17 +22,21 @@ export const position = defineCommand({
         if (game !== undefined || move !== undefined) {
             const studied = gameShown(context, game);
             const at = positionAfter(studied.record, move);
-            return { ...at.game.profile, where: positionLine(at, studied.name) };
+            return withAnalystLine({ ...at.game.profile, where: positionLine(at, studied.name) }, analystOnView(context, studied.name));
         }
         const current = gameAt(gameFolder(context.home()), context.now());
         if (current === undefined) {
             throw new Error("There is no game to describe: start one with new_game.");
         }
         refuseUnseen(current, "strategy", "position");
-        return current.game.profile;
+        const over = endOf(current.game) === undefined ? undefined : archivedName(gameFolder(context.home()), current);
+        return withAnalystLine(current.game.profile, analystOnView(context, over));
     },
-    format: (described) => [...(described.where === undefined ? [] : [described.where]), ...profileLines(described)].join("\n"),
+    format: (described) => [...(described.where === undefined ? [] : [described.where]), ...profileLines(described), ...(described.analyst === undefined ? [] : [described.analyst])].join("\n"),
 });
+function withAnalystLine(described, analyst) {
+    return analyst === undefined ? described : { ...described, analyst };
+}
 /** The profile as lines for the AI, White's facts before Black's; a line with nothing to say is left out. */
 export function profileLines(profile) {
     const sides = [["white", profile.white], ["black", profile.black]];

package/dist/commands/game/status.d.ts

@@ -16,16 +16,18 @@ interface Status {
     problem?: string;
     /** What the player wrote on the board page that the AI has not answered yet, all of it. */
     words?: Written[];
-    /** The game in analysis on the board page once none goes on (D-69), which the player may have brought there. */
+    /** The game in analysis on the board page once none goes on (D-69), which the player may have brought there, for a new review too. */
     analysis?: {
         game: string;
         brought?: true;
+        redo?: true;
         analyst?: "done" | "offer";
+        codex?: true;
         review?: string;
     };
     /** A game going on from before this chat, told once a chat: the player says whether to go on with it. */
     fromBefore?: true;
-    /** The coach to start, once, for the player's move that ended the game (D-88). */
+    /** The coach to start, once a move ended the game, for the player's last move (D-88). */
     coach?: true;
     /** The files an older init wrote in the player's folder, which this version would write otherwise. */
     outdated?: string[];

package/dist/commands/game/status.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { gameReviewOf, leadOf, reviewOf } from "../../core/index.js";
+import { Game, gameReviewOf, leadOf, reviewOf } from "../../core/index.js";
 import { archivedName, cleanSince, endOf, gameInAnalysis, lastChatStart } from "../../games/index.js";
-import { outdatedHostFiles } from "../../host-files/index.js";
+import { hasDoorbell, isCodex, outdatedHostFiles } from "../../host-files/index.js";
 import { gameFolder } from "../../profiles/index.js";
 import { version } from "../../version.js";
 import { analystLine, analystRuns, closingLines, coachOnEnd, coachOnEndLine, coachRuns, gameAt, goneOver, namedGame, newGameStep, positionLines, reviewedLine, shownMoves, sidesLine, speechLine, speechOf, summaryOf, unansweredWords, withAnalyst, withThought, wordLines, } from "../answers/index.js";
@@ -56,7 +56,7 @@ export const status = defineCommand({
                 if (first && endOf(current.game) === undefined && current.game.record.moves.length > 0 && (chatStart === undefined || cleanSince(chatStart, current.started))) {
                     status.fromBefore = true;
                 }
-                // The player's move on the board page that ended the game: the coach judges it too (D-88).
+                // A move that ended the game: the coach judges the player's last move, told until it starts (D-88).
                 if (coachOnEnd(context, folder, current)) {
                     status.coach = true;
                 }
@@ -68,7 +68,9 @@ export const status = defineCommand({
                 status.analysis = {
                     game: analysis.game,
                     ...(analysis.brought === true ? { brought: true } : {}),
+                    ...(analysis.redo === true ? { redo: true } : {}),
                     ...(analystRuns(context) ? { analyst: goneOver(context, analysis.game) ? "done" : "offer" } : {}),
+                    ...(analystRuns(context) && isCodex(context.host?.()) ? { codex: true } : {}),
                     ...(review === undefined ? {} : { review }),
                 };
             }
@@ -78,7 +80,7 @@ export const status = defineCommand({
         }
         return status;
     },
-    format: ({ version, folder, page, pageClosed, player, speech, game, problem, words = [], analysis, fromBefore, coach, outdated, unread }) => [
+    format: ({ version, folder, page, pageClosed, player, speech, game, problem, words = [], analysis, fromBefore, coach, outdated, unread }, context) => [
         `Chesspal ${version}. Folder: ${folder}`,
         ...(unread === true ? [unreadLine] : []),
         ...(outdated === undefined ? [] : [outdatedLine(outdated)]),
@@ -86,7 +88,7 @@ export const status = defineCommand({
         ...(player === undefined ? [] : [player]),
         ...(speech === undefined ? [] : [speechLine(speech)]),
         ...(fromBefore === true ? [fromBeforeLine] : []),
-        ...(problem !== undefined ? [problem] : gameLines(game, words, analysis?.brought === true, pageClosed === true, coach === true)),
+        ...(problem !== undefined ? [problem] : gameLines(game, words, analysis?.brought === true, pageClosed === true, coach === true, hasDoorbell(context?.host?.()))),
         ...(analysis === undefined ? [] : [analysisLine(analysis)]),
     ].join("\n"),
 });
@@ -113,30 +115,38 @@ function firstInChat(context, chatStart) {
 }
 /**
  * The game in analysis, with how far its review has got; the next step when the player has just brought it on the board page, unless an analyst is at it
- * already; the analyst agent for a game whose review was deleted, where it runs (Stefano).
+ * already, at once when they asked for a new review (Priya); the analyst agent for a game whose review was deleted, where it runs (Stefano).
  */
-function analysisLine({ game, brought, analyst, review }) {
+function analysisLine({ game, brought, redo, analyst, codex, review }) {
+    // A chat that remembered the old review put its notes back with annotate_game, and its corrections stand over every review after (Priya).
+    if (redo === true && analyst === "offer") {
+        return `The player asked on the board page for a new review of ${game}. Next, at once, even if an analyst was stopped before: ${analystLine(game, codex === true)} `
+            + "The new review replaces the old one: correct a note with annotate_game only when the player shows it wrong.";
+    }
     if (brought === true && analyst !== "done") {
         return analyst === "offer"
-            ? `The player brought ${game} on the board page to analyse it. Next: ${analystLine(game)}`
+            ? `The player brought ${game} on the board page to analyse it. Next: ${analystLine(game, codex === true)}`
             : `The player brought ${game} on the board page to analyse it. Next: call analyse_game {"game": "${game}"}, then keep your review on that page with annotate_game, and go over it with them.`;
     }
     const shown = `In analysis on the board page: ${game}${review === undefined ? "" : ` (${review})`}`;
     if (analyst === "done") {
         return `${shown}. ${reviewedLine(game)}`;
     }
-    return analyst === "offer" ? `${shown}. When the player wants it gone over, ${analystLine(game)}` : `${shown}; analyse_game {"game": "${game}"} goes over it with the player.`;
+    return analyst === "offer" ? `${shown}. When the player wants it gone over, ${analystLine(game, codex === true)}` : `${shown}; analyse_game {"game": "${game}"} goes over it with the player.`;
 }
 /**
- * How far the review of a game has got, as the board page shows it (Priya): done once it holds the word on the whole game and who is ahead after every move
- * but the last; the analyst may still write notes after its word, so that alone is not the end.
+ * How far the review of a game has got, as the board page shows it (Priya): done once it holds the word on the whole game and who is ahead after every move,
+ * but the last when the board ended the game there, which says it; the analyst may still write notes after its word, so that alone is not the end.
  */
 function reviewProgress(context, game) {
     try {
         const { record } = namedGame(context, game);
         const worded = gameReviewOf(record) !== undefined;
         const estimated = record.moves.filter(({ comment }) => leadOf(comment) !== undefined).length;
-        if (worded && estimated >= record.moves.length - 1) {
+        // A game resigned or lost on time needs who is ahead after its last move too; the game is played over only when that is the one estimate missing.
+        const all = record.moves.length;
+        const done = estimated >= all || (estimated === all - 1 && new Game(record).outcome.over);
+        if (worded && done) {
             return "its review is done";
         }
         const noted = record.moves.filter(({ comment }) => {
@@ -156,8 +166,8 @@ function reviewProgress(context, game) {
  * The game's lines; a game the player brought to analyse takes the place of the next step. The coach to start goes just before the next step, where
  * the AI acts on it (Priya).
  */
-function gameLines(game, words, brought, pageClosed, coach) {
-    const closing = [...(coach ? [coachOnEndLine] : []), ...(brought ? wordLines(words) : closingLines(game, words, pageClosed))];
+function gameLines(game, words, brought, pageClosed, coach, doorbell) {
+    const closing = [...(coach && game !== undefined ? [coachOnEndLine(game)] : []), ...(brought ? wordLines(words) : closingLines(game, words, pageClosed, doorbell))];
     if (game === undefined) {
         return ["No game.", ...closing];
     }

package/dist/commands/index.d.ts

@@ -1,8 +1,8 @@
 import type { AnyCommand } from "./registry/index.ts";
 export { analyseGame, deleteReview, siteGames, SiteGamesRefused } from "./analysis/index.ts";
-export { analystOf, bookOpening, bookPlies, gameAt, gameToStudy, namedGame, playMove, PositionChanged, positionIn, samePosition, say, shownPosition } from "./answers/index.ts";
-export { aiMove, answerDraw, ChatNotClear, DrawRefused, endGame, newGame, offerDraw, startNewGame } from "./game/index.ts";
+export { analystOf, analystQuietAt, bookOpening, bookPlies, gameAt, gameToStudy, namedGame, playMove, PositionChanged, positionIn, samePosition, say, shownPosition } from "./answers/index.ts";
+export { aiMove, answerDraw, ChatNotClear, DrawRefused, endGame, type MoveSentAlone, newGame, offerDraw, playMoveSentAlone, startNewGame } from "./game/index.ts";
 export { chooseDrawnAvatar, deleteGame, editProfile, GameGoingOn, newProfile, ratingsAge, refreshRatings, useProfile } from "./profiles/index.ts";
-export { type AnyCommand, baseType, type Caller, type Command, commandLineFieldProblem, type Context, defaultContext, inputProblems, isBoolean, isList, type SeenPosition, speaksItalian, takesNumbers } from "./registry/index.ts";
+export { type AnyCommand, baseType, type Caller, type Command, commandLineFieldProblem, type Context, defaultContext, homeForOneCall, inputProblems, isBoolean, isList, type SeenPosition, speaksItalian, takesNumbers, } from "./registry/index.ts";
 /** Every command of Chesspal, in the order the command line lists them and the MCP server offers them. */
 export declare const commands: AnyCommand[];

package/dist/commands/index.js

@@ -6,10 +6,10 @@ import { init, instructions } from "./setup/index.js";
 import { aiSay, playerSay } from "./talk/index.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 { analyseGame, deleteReview, siteGames, SiteGamesRefused } from "./analysis/index.js";
-export { analystOf, bookOpening, bookPlies, gameAt, gameToStudy, namedGame, playMove, PositionChanged, positionIn, samePosition, say, shownPosition } from "./answers/index.js";
-export { aiMove, answerDraw, ChatNotClear, DrawRefused, endGame, newGame, offerDraw, startNewGame } from "./game/index.js";
+export { analystOf, analystQuietAt, bookOpening, bookPlies, gameAt, gameToStudy, namedGame, playMove, PositionChanged, positionIn, samePosition, say, shownPosition } from "./answers/index.js";
+export { aiMove, answerDraw, ChatNotClear, DrawRefused, endGame, newGame, offerDraw, playMoveSentAlone, startNewGame } from "./game/index.js";
 export { chooseDrawnAvatar, deleteGame, editProfile, GameGoingOn, newProfile, ratingsAge, refreshRatings, useProfile } from "./profiles/index.js";
-export { baseType, commandLineFieldProblem, defaultContext, inputProblems, isBoolean, isList, speaksItalian, takesNumbers } from "./registry/index.js";
+export { baseType, commandLineFieldProblem, defaultContext, homeForOneCall, inputProblems, isBoolean, isList, speaksItalian, takesNumbers, } from "./registry/index.js";
 /** Every command of Chesspal, in the order the command line lists them and the MCP server offers them. */
 export const commands = [
     init,

package/dist/commands/profiles/past-games.d.ts

@@ -1,11 +1,16 @@
 import { z } from "zod";
 /** The AI's memory of the games played (D-57): how the latest went, one line each, or one game whole from the archive. */
 export declare const pastGames: import("../registry/registry.ts").Command<z.ZodObject<{
+    search: z.ZodOptional<z.ZodString>;
     game: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, {
     games: string[];
+    searched: true | undefined;
 } | {
     pgn: string;
 }>;
-/** The latest games of the archive, one line each as the AI reads them: none when there is no archive. A game closed before any move is no game played. */
-export declare function pastGameLines(folder: string, count: number): string[];
+/**
+ * The latest games of the archive, one line each as the AI reads them, those holding every word searched: none when there is no archive. A game closed
+ * before any move is no game played. A game is read from its tags alone when the archive wrote the opening's and the plies', or else whole.
+ */
+export declare function pastGameLines(folder: string, count: number, search?: string): string[];