chesspal 0.2.4 → 0.3.0

package/dist/commands/status.js

@@ -1,13 +1,14 @@
 import { z } from "zod";
 import { gameReviewOf, leadOf, reviewOf } from "../core/index.js";
 import { archivedName, cleanSince, endOf, gameInAnalysis, lastChatStart } from "../games/index.js";
-import { coachAgent, outdatedHostFiles } from "../host-files/index.js";
+import { outdatedHostFiles } from "../host-files/index.js";
 import { gameFolder } from "../profiles/index.js";
 import { version } from "../version.js";
-import { agentsLine, analystLine, analystRuns, coachOnEnd, coachRuns, reviewedLine, withAnalyst } from "./agents.js";
-import { closingLines, newGameStep, positionLines, sidesLine, wordLines } from "./answer-lines.js";
+import { analystLine, analystRuns, coachOnEnd, coachOnEndLine, coachRuns, goneOver, reviewedLine, withAnalyst } from "./agents.js";
+import { closingLines, newGameStep, positionLines, shownMoves, sidesLine, wordLines } from "./answer-lines.js";
 import { gameAt } from "./clock.js";
 import { summaryOf, withThought } from "./game-summary.js";
+import { instructionsRead } from "./instructions.js";
 import { levelText } from "./levels.js";
 import { closedPage, pageGiven, pageLine } from "./page-link.js";
 import { playerLine } from "./profiles.js";
@@ -19,7 +20,7 @@ import { namedGame } from "./study.js";
 export const status = defineCommand({
     name: "status",
     description: "Shows what Chesspal sees now: its version, the profile's folder and the game, with your next step. Call it at the start of every chat, "
-        + "before anything else.",
+        + "with `instructions`.",
     input: z.object({}),
     // Read only for the host: a flag that has fallen is written, as the time already decided.
     readOnly: true,
@@ -30,7 +31,10 @@ export const status = defineCommand({
         const folder = gameFolder(context.home());
         const player = playerLine(context);
         const speech = speechOf(folder, context.language);
-        const outdated = outdatedHostFiles(context.folder, context.platform);
+        const chatStart = lastChatStart(context.folder);
+        const first = firstInChat(context, chatStart?.at);
+        // An older init's files are told once a chat, at its first status: reading them all is the slowest part of a status.
+        const outdated = context.told === undefined || first ? outdatedHostFiles(context.folder, context.platform) : [];
         const status = { version, folder, ...(player === undefined ? {} : { player }), ...(speech === undefined ? {} : { speech }), ...(outdated.length === 0 ? {} : { outdated }) };
         if (context.page !== undefined) {
             status.page = context.page;
@@ -38,7 +42,9 @@ export const status = defineCommand({
         if (closedPage(context) !== undefined) {
             status.pageClosed = true;
         }
-        const first = firstInChat(context);
+        if (!instructionsRead(context, chatStart?.at)) {
+            status.unread = true;
+        }
         try {
             const current = gameAt(folder, context.now());
             // With no game the player may have written before the first (D-77).
@@ -51,7 +57,8 @@ export const status = defineCommand({
                 if (status.pageClosed === true) {
                     pageGiven(context, current.started);
                 }
-                if (first && endOf(current.game) === undefined && fromBeforeChat(context, current.started)) {
+                // A game a summarized or resumed chat still holds is its own; without the host's word of the chat's start, any game began before it.
+                if (first && endOf(current.game) === undefined && (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).
@@ -61,12 +68,12 @@ export const status = defineCommand({
             }
             const analysis = current === undefined || status.game?.end !== undefined ? gameInAnalysis(folder) : undefined;
             if (analysis !== undefined) {
-                // The analyst agent goes over a game the player brought, where it runs, and the chat over what it reviewed (D-89).
+                // The analyst agent goes over a game the player brought, or whose review was deleted, where it runs, and the chat over what it reviewed (D-89).
                 const review = analysis.brought === true ? undefined : reviewProgress(context, analysis.game);
                 status.analysis = {
                     game: analysis.game,
                     ...(analysis.brought === true ? { brought: true } : {}),
-                    ...(analystRuns(context) ? { analyst: true } : {}),
+                    ...(analystRuns(context) ? { analyst: goneOver(context, analysis.game) ? "done" : "offer" } : {}),
                     ...(review === undefined ? {} : { review }),
                 };
             }
@@ -76,8 +83,9 @@ export const status = defineCommand({
         }
         return status;
     },
-    format: ({ version, folder, page, pageClosed, player, speech, game, problem, words = [], analysis, fromBefore, coach, outdated }) => [
+    format: ({ version, folder, page, pageClosed, player, speech, game, problem, words = [], analysis, fromBefore, coach, outdated, unread }) => [
         `Chesspal ${version}. Folder: ${folder}`,
+        ...(unread === true ? [unreadLine] : []),
         ...(outdated === undefined ? [] : [outdatedLine(outdated)]),
         ...(page === undefined ? [] : [pageLine(page, pageClosed === true)]),
         ...(player === undefined ? [] : [player]),
@@ -92,48 +100,58 @@ function outdatedLine(files) {
     return `This folder was set up by an older Chesspal (${files.join(", ")}): tell the player, in their language, to close this chat, run "chesspal init" `
         + "in this folder and open a new chat. Until then the agents and your instructions are the old ones.";
 }
+// The opponent's instructions, which the chat reads before its first reply (D-102).
+const unreadLine = "Call `instructions` before you answer the player, if you have not called it since this chat started or was summarized.";
 // The game going on as a chat starts: the player may have come back for it, or want another.
 const fromBeforeLine = "A game from before this chat is going on: ask the player whether to go on with it. For a new one, " + newGameStep;
 /**
  * Whether this is the chat's first status: once a chat where the MCP server keeps what it told, again in a chat cleared or summarized, since its start keys
  * it (D-57); never on the command line.
  */
-function firstInChat(context) {
-    const key = `game before ${lastChatStart(context.folder)?.at ?? ""}`;
+function firstInChat(context, chatStart) {
+    const key = `game before ${chatStart ?? ""}`;
     if (context.told === undefined || context.told.has(key)) {
         return false;
     }
     context.told.add(key);
     return true;
 }
-/** Whether a game began before the chat: one a summarized or resumed chat still holds is its own; without the host's word, any game is. */
-function fromBeforeChat(context, started) {
-    const start = lastChatStart(context.folder);
-    return start === undefined || cleanSince(start, started);
-}
-/** 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. */
+/**
+ * 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).
+ */
 function analysisLine({ game, brought, analyst, review }) {
-    if (brought === true) {
-        return analyst === true
+    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: 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})`}`;
-    return analyst === true ? `${shown}. ${reviewedLine(game)}` : `${shown}; analyse_game {"game": "${game}"} goes over it with the player.`;
+    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.`;
 }
-/** 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. */
+/**
+ * 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.
+ */
 function reviewProgress(context, game) {
     try {
         const { record } = namedGame(context, game);
-        if (gameReviewOf(record) !== undefined) {
+        const worded = gameReviewOf(record) !== undefined;
+        const estimated = record.moves.filter(({ comment }) => leadOf(comment) !== undefined).length;
+        if (worded && estimated >= record.moves.length - 1) {
             return "its review is done";
         }
         const noted = record.moves.filter(({ comment }) => {
             const review = reviewOf(comment);
             return review !== undefined && (review.badge !== "book" || review.note !== undefined);
         }).length;
-        const estimated = record.moves.filter(({ comment }) => leadOf(comment) !== undefined).length;
-        return noted === 0 && estimated === 0 ? "no review yet" : `its review so far: notes on ${noted} moves, who is ahead after ${estimated} of ${record.moves.length}`;
+        const word = worded ? ", its word on the game written" : "";
+        return noted === 0 && estimated === 0 && !worded
+            ? "no review yet"
+            : `its review so far: notes on ${noted} moves, who is ahead after ${estimated} of ${record.moves.length}${word}`;
     }
     catch {
         return undefined;
@@ -144,10 +162,11 @@ function reviewProgress(context, game) {
  * the AI acts on it (Priya).
  */
 function gameLines(game, words, brought, pageClosed, coach) {
-    const closing = [...(coach ? [agentsLine([coachAgent])] : []), ...(brought ? wordLines(words) : closingLines(game, words, pageClosed))];
+    const closing = [...(coach ? [coachOnEndLine] : []), ...(brought ? wordLines(words) : closingLines(game, words, pageClosed))];
     if (game === undefined) {
         return ["No game.", ...closing];
     }
-    const moves = game.lastMoves === "" ? [] : [`Moves: ${game.lastMoves}`];
+    // With the figurines, as every answer writes moves: in letters the AI copied them into its message (Priya).
+    const moves = game.lastMoves === "" ? [] : [`Moves: ${shownMoves(game.lastMoves)}`];
     return [`Game: ${sidesLine(game.ai)}, ${levelText(game.level)}.`, ...moves, ...positionLines(game), ...closing];
 }

package/dist/commands/study.js

@@ -27,16 +27,19 @@ export function gameToStudy(context, name) {
     if (name !== undefined) {
         return namedGame(context, name);
     }
-    if (current !== undefined) {
+    // A game closed before any move has nothing to study: the one before it is the last played.
+    if (current !== undefined && current.game.record.moves.length > 0) {
         // The archive's record, which keeps the AI's review (D-69).
         const archived = archivedName(folder, current);
         return archived === undefined ? { record: current.game.record } : { record: archivedGame(folder, archived), name: archived };
     }
-    const [latest] = archivedGames(folder);
-    if (latest === undefined) {
-        throw new Error("There is no game to study: play one with new_game, or give analyse_game the PGN of a game played elsewhere.");
+    for (const latest of archivedGames(folder)) {
+        const record = archivedGame(folder, latest);
+        if (record.moves.length > 0) {
+            return { record, name: latest };
+        }
     }
-    return { record: archivedGame(folder, latest), name: latest };
+    throw new Error("There is no game to study: play one with new_game, or give analyse_game the PGN of a game played elsewhere.");
 }
 /**
  * The game look and position show: without a name, for the chat, the one in analysis on the board page, which the player's words there name by their move

package/dist/core/index.d.ts

@@ -18,4 +18,4 @@ export type { Capture, Chances, DoubleAttack, Possibilities, StalemateTrap } fro
 export type { BishopFacts, CentreSquare, KingFacts, Outpost, PawnFacts, PawnSquare, Phase, Profile, SideProfile } from "./profile.ts";
 export { movesOnly } from "./record.ts";
 export type { Annotation, GameRecord, RecordedMove } from "./record.ts";
-export { aiHostIn, type AiModel, aiModelIn, aiNameOf, annotatorOf, arrowOf, type Badge, badges, closingOf, type DrawColour, drawingsIn, drawingsText, type DrawnArrow, type DrawnSquare, gameReviewOf, isReviewed, type MoveReview, reviewed, reviewOf, squareOf, unreviewed, withAiHost, withAiModel, withAnnotator, withGameReview, } from "./review.ts";
+export { aiHostIn, type AiModel, aiModelIn, aiNameOf, annotatorOf, arrowOf, type Badge, badges, closingOf, type DrawColour, drawingsIn, drawingsText, type DrawnArrow, type DrawnSquare, gameReviewOf, isReviewed, type MoveReview, reviewed, reviewOf, squareOf, unreviewed, unsigned, withAiHost, withAiModel, withAnnotator, withGameReview, } from "./review.ts";

package/dist/core/index.js

@@ -9,4 +9,4 @@ export { endWithMood, moodAt, moodOf, moods, moodTag, withoutMoods } from "./moo
 export { bookMoves, indexBook, indexOpenings, inOpenings, openingOf, outOfBookMove } from "./openings.js";
 export { pgnDate, readPgn, writePgn } from "./pgn.js";
 export { movesOnly } from "./record.js";
-export { aiHostIn, aiModelIn, aiNameOf, annotatorOf, arrowOf, badges, closingOf, drawingsIn, drawingsText, gameReviewOf, isReviewed, reviewed, reviewOf, squareOf, unreviewed, withAiHost, withAiModel, withAnnotator, withGameReview, } from "./review.js";
+export { aiHostIn, aiModelIn, aiNameOf, annotatorOf, arrowOf, badges, closingOf, drawingsIn, drawingsText, gameReviewOf, isReviewed, reviewed, reviewOf, squareOf, unreviewed, unsigned, withAiHost, withAiModel, withAnnotator, withGameReview, } from "./review.js";

package/dist/core/review.d.ts

@@ -51,6 +51,8 @@ export declare function reviewed(move: RecordedMove, review: MoveReview): Record
  * the game and who signed it. What the comments held besides stays, as do the NAGs of moves without a badge and the Annotator of a game it never reviewed.
  */
 export declare function unreviewed(record: GameRecord): GameRecord;
+/** The tags without who signed a review, the Annotator and its effort: the same game whoever reviewed it. */
+export declare function unsigned(tags: Readonly<Record<string, string>>): Record<string, string>;
 /** The arrows and squares as PGN's [%cal] and [%csl] write them, for a comment; empty without any. */
 export declare function drawingsText({ arrows, squares }: Pick<MoveReview, "arrows" | "squares">): string;
 /** The record with who reviewed it (D-81): the model, else the host, as PGN's Annotator, and the effort only when known; an effort no longer known goes. */

package/dist/core/review.js

@@ -64,9 +64,13 @@ export function unreviewed(record) {
     });
     const comment = withoutReview(record.comment);
     // A game from elsewhere keeps its own Annotator.
-    const tags = carriesReview(record) ? Object.fromEntries(Object.entries(record.tags).filter(([name]) => name !== "Annotator" && name !== effortTag)) : record.tags;
+    const tags = carriesReview(record) ? unsigned(record.tags) : record.tags;
     return comment === "" ? { tags, moves } : { tags, comment, moves };
 }
+/** The tags without who signed a review, the Annotator and its effort: the same game whoever reviewed it. */
+export function unsigned(tags) {
+    return Object.fromEntries(Object.entries(tags).filter(([name]) => name !== "Annotator" && name !== effortTag));
+}
 /** The arrows and squares as PGN's [%cal] and [%csl] write them, for a comment; empty without any. */
 export function drawingsText({ arrows = [], squares = [] }) {
     const arrowList = arrows.map(({ colour, from, to }) => `${letterOf(colour)}${from}${to}`).join(",");

package/dist/games/ai-model.d.ts

@@ -3,7 +3,9 @@ import type { AiModel } from "../core/index.ts";
 export declare function noteAiModel(folder: string, noted: AiModel): boolean;
 /** The AI's model last noted for the games of a folder in this process; none on the command line, or before the AI's first move. */
 export declare function aiModelOf(folder: string): AiModel | undefined;
-/** Notes the host the AI plays in for the games of a folder, after its move (D-97), as the model. */
-export declare function noteAiHost(folder: string, host: string): void;
+/** Notes the host the AI plays in for the games of a folder, after its move (D-97), as the model. Whether it changed. */
+export declare function noteAiHost(folder: string, host: string): boolean;
+/** Forgets who played as the AI for the games of a folder: the chat that did has left the table (D-104), and the next may be another. */
+export declare function forgetTheAi(folder: string): void;
 /** The host the AI played its last move in, for the games of a folder in this process; none on the command line, or before the AI's first move. */
 export declare function aiHostOf(folder: string): string | undefined;

package/dist/games/ai-model.js

@@ -11,9 +11,18 @@ export function noteAiModel(folder, noted) {
 export function aiModelOf(folder) {
     return models.get(folder);
 }
-/** Notes the host the AI plays in for the games of a folder, after its move (D-97), as the model. */
+/** Notes the host the AI plays in for the games of a folder, after its move (D-97), as the model. Whether it changed. */
 export function noteAiHost(folder, host) {
+    if (hosts.get(folder) === host) {
+        return false;
+    }
     hosts.set(folder, host);
+    return true;
+}
+/** Forgets who played as the AI for the games of a folder: the chat that did has left the table (D-104), and the next may be another. */
+export function forgetTheAi(folder) {
+    models.delete(folder);
+    hosts.delete(folder);
 }
 /** The host the AI played its last move in, for the games of a folder in this process; none on the command line, or before the AI's first move. */
 export function aiHostOf(folder) {

package/dist/games/analysis.d.ts

@@ -1,15 +1,38 @@
 /**
  * The game in analysis: its name as the lists write it, when the analysis last changed it, whether the player brought it on the page and the AI has not
- * gone over it yet, and the moves whose note the chat corrected with the player, which the analyst leaves (D-101).
+ * gone over it yet, the moves whose note the chat corrected with the player, which the analyst leaves (D-101), and the run of the analyst that took it.
  */
 export interface Analysis {
     readonly game: string;
     readonly at: string;
     readonly brought?: true;
     readonly corrected?: readonly string[];
+    readonly analyst?: AnalystRun;
 }
-/** Names the game in analysis, over the one before; written again each time its review changes, so the page hears of it. The same game keeps its corrections. */
-export declare function startAnalysis(folder: string, game: string, now: Date, brought?: boolean, corrected?: readonly string[]): void;
+/** The run of the analyst agent that took a game, as the host names it, the game it took and when. */
+export interface AnalystRun {
+    readonly game: string;
+    readonly run: string;
+    readonly since: string;
+}
+/**
+ * How a game is named in analysis: brought to the page by the player, with the moves the chat just corrected, taken by a run of the analyst, or afresh,
+ * without the corrections and the analyst it had.
+ */
+export interface AnalysisStart {
+    readonly brought?: boolean;
+    readonly corrected?: readonly string[];
+    readonly analyst?: AnalystRun;
+    readonly afresh?: boolean;
+}
+/**
+ * Names the game in analysis, over the one before; written again each time its review changes, so the page hears of it. The same game keeps its corrections
+ * unless it starts afresh, in one write, so that the page never sees it leave the analysis; the analyst stays with the game it took, whichever the page
+ * opens meanwhile (Federico), and goes when that game starts afresh.
+ */
+export declare function startAnalysis(folder: string, game: string, now: Date, { brought, corrected, analyst, afresh }?: AnalysisStart): void;
+/** Lets the analyst go from the game it took, when that game's review is deleted while the page shows another. */
+export declare function forgetAnalyst(folder: string): void;
 /** The game in analysis, or none when there is none, or analysis.json cannot be read. */
 export declare function gameInAnalysis(folder: string): Analysis | undefined;
 /** Ends the analysis, when a new game starts or its review is deleted. */

package/dist/games/analysis.js

@@ -3,12 +3,31 @@
 import { readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { writeAtomically } from "./files.js";
-/** Names the game in analysis, over the one before; written again each time its review changes, so the page hears of it. The same game keeps its corrections. */
-export function startAnalysis(folder, game, now, brought = false, corrected = []) {
+/**
+ * Names the game in analysis, over the one before; written again each time its review changes, so the page hears of it. The same game keeps its corrections
+ * unless it starts afresh, in one write, so that the page never sees it leave the analysis; the analyst stays with the game it took, whichever the page
+ * opens meanwhile (Federico), and goes when that game starts afresh.
+ */
+export function startAnalysis(folder, game, now, { brought = false, corrected = [], analyst, afresh = false } = {}) {
     const before = gameInAnalysis(folder);
-    const kept = [...new Set([...(before?.game === game ? before.corrected ?? [] : []), ...corrected])];
-    const analysis = { game, at: now.toISOString(), ...(brought ? { brought } : {}), ...(kept.length === 0 ? {} : { corrected: kept }) };
-    writeAtomically(join(folder, fileName), `${JSON.stringify(analysis, null, 2)}\n`);
+    const same = !afresh && before?.game === game;
+    const kept = [...new Set([...(same ? before.corrected ?? [] : []), ...corrected])];
+    const held = afresh && before?.analyst?.game === game ? undefined : before?.analyst;
+    writeAnalysis(folder, {
+        game,
+        at: now.toISOString(),
+        ...(brought ? { brought: true } : {}),
+        ...(kept.length === 0 ? {} : { corrected: kept }),
+        ...withAnalyst(analyst ?? held),
+    });
+}
+/** Lets the analyst go from the game it took, when that game's review is deleted while the page shows another. */
+export function forgetAnalyst(folder) {
+    const analysis = gameInAnalysis(folder);
+    if (analysis?.analyst !== undefined) {
+        const { game, at, brought, corrected } = analysis;
+        writeAnalysis(folder, { game, at, ...(brought === undefined ? {} : { brought }), ...(corrected === undefined ? {} : { corrected }) });
+    }
 }
 /** The game in analysis, or none when there is none, or analysis.json cannot be read. */
 export function gameInAnalysis(folder) {
@@ -16,7 +35,13 @@ export function gameInAnalysis(folder) {
         const analysis = JSON.parse(readFileSync(join(folder, fileName), "utf8"));
         const corrected = Array.isArray(analysis.corrected) ? analysis.corrected.filter((move) => typeof move === "string") : [];
         return typeof analysis.game === "string" && typeof analysis.at === "string"
-            ? { game: analysis.game, at: analysis.at, ...(analysis.brought === true ? { brought: true } : {}), ...(corrected.length === 0 ? {} : { corrected }) }
+            ? {
+                game: analysis.game,
+                at: analysis.at,
+                ...(analysis.brought === true ? { brought: true } : {}),
+                ...(corrected.length === 0 ? {} : { corrected }),
+                ...withAnalyst(isAnalystRun(analysis.analyst) ? analysis.analyst : undefined),
+            }
             : undefined;
     }
     catch {
@@ -28,3 +53,13 @@ export function endAnalysis(folder) {
     rmSync(join(folder, fileName), { force: true });
 }
 const fileName = "analysis.json";
+function writeAnalysis(folder, analysis) {
+    writeAtomically(join(folder, fileName), `${JSON.stringify(analysis, null, 2)}\n`);
+}
+function withAnalyst(analyst) {
+    return analyst === undefined ? {} : { analyst: { game: analyst.game, run: analyst.run, since: analyst.since } };
+}
+function isAnalystRun(value) {
+    const run = value;
+    return typeof run?.game === "string" && typeof run.run === "string" && typeof run.since === "string";
+}

package/dist/games/archive.d.ts

@@ -11,10 +11,13 @@ export declare function isOverOnTable(folder: string, name: string): boolean;
 export declare function startOfNewGame(folder: string, now: Date, before?: CurrentGame): Date;
 /**
  * Writes the game to the archive, with the plans, how it ended and the AI's model and host last noted (D-82, D-97), and gives its name; the same game again rewrites the
- * same file.
+ * same file. A game closed before any move is not kept, as Lichess aborts it: none.
+ */
+export declare function archiveGame(folder: string, current: CurrentGame): string | undefined;
+/**
+ * Archives a game that has ended: its name in the archive, none for a game closed before any move, or, when that fails, a warning, since the game is saved in
+ * game.json all the same.
  */
-export declare function archiveGame(folder: string, current: CurrentGame): string;
-/** Archives a game that has ended: its name in the archive or, when that fails, a warning, since the game is saved in game.json all the same. */
 export declare function archiveEnded(folder: string, current: CurrentGame): {
     archive?: string;
     warning?: string;

package/dist/games/archive.js

@@ -1,7 +1,7 @@
 // The finished games, as PGN in games/ (D-9, D-41), with the AI's plans for the analyst (D-21); and the games played elsewhere, kept to study in study/ (D-68).
 import { existsSync, readdirSync, readFileSync, rmSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { movesOnly, pgnDate, readPgn, withAiHost, withAiModel, writePgn } from "../core/index.js";
+import { movesOnly, pgnDate, readPgn, unsigned, withAiHost, withAiModel, writePgn } from "../core/index.js";
 import { aiHostOf, aiModelOf } from "./ai-model.js";
 import { coachWords, withCoach } from "./coach.js";
 import { endOf, loadGame } from "./current-game.js";
@@ -35,9 +35,12 @@ export function startOfNewGame(folder, now, before) {
 }
 /**
  * Writes the game to the archive, with the plans, how it ended and the AI's model and host last noted (D-82, D-97), and gives its name; the same game again rewrites the
- * same file.
+ * same file. A game closed before any move is not kept, as Lichess aborts it: none.
  */
 export function archiveGame(folder, current) {
+    if (current.game.record.moves.length === 0) {
+        return undefined;
+    }
     const name = archiveName(current);
     const path = join(folder, name);
     try {
@@ -49,10 +52,14 @@ export function archiveGame(folder, current) {
     }
     return name;
 }
-/** Archives a game that has ended: its name in the archive or, when that fails, a warning, since the game is saved in game.json all the same. */
+/**
+ * Archives a game that has ended: its name in the archive, none for a game closed before any move, or, when that fails, a warning, since the game is saved in
+ * game.json all the same.
+ */
 export function archiveEnded(folder, current) {
     try {
-        return { archive: archiveGame(folder, current) };
+        const archive = archiveGame(folder, current);
+        return archive === undefined ? {} : { archive };
     }
     catch (error) {
         return { warning: `${error.message} The game is saved in game.json: it goes to the archive when a new game starts.` };
@@ -225,7 +232,8 @@ function gameNamed(folder, shelf, name) {
 }
 /** Whether two records are the same game: the same tags and the same moves, whatever their comments say. */
 function sameGame(one, other) {
-    const shape = (record) => JSON.stringify([record?.tags, record?.moves.map((move) => move.san)]);
+    // Who signed a review is not the game: one the AI reviewed, or brought again with Lichess's Annotator, is the one kept.
+    const shape = (record) => JSON.stringify([record === undefined ? undefined : unsigned(record.tags), record?.moves.map((move) => move.san)]);
     return one !== undefined && shape(one) === shape(other);
 }
 function nameAt(date, shelf = "games") {

package/dist/games/current-game.d.ts

@@ -41,8 +41,17 @@ export interface GameEnd {
 }
 /** The current game of a folder, as it is on disk, or undefined when there is none. A game.json Chesspal cannot read throws: nothing overwrites it. */
 export declare function loadGame(folder: string): CurrentGame | undefined;
-/** Writes the current game to game.json, whole or not at all; from then on it is the one kept in memory. */
+/**
+ * Writes the current game to game.json, whole or not at all; from then on it is the one kept in memory. Refused with GameChanged when another process wrote
+ * the file since this one read it: the change made on the game read before would lose theirs.
+ */
 export declare function saveGame(folder: string, current: CurrentGame): void;
+/** The refusal of a save on a game another process changed since this one read it: what wrote it reads it again and starts over, once (rerunIfChanged). */
+export declare class GameChanged extends Error {
+    constructor();
+}
+/** Runs a change of the game, and once more from the start when another process changed the game under it: a second refusal stands. */
+export declare function rerunIfChanged<T>(run: () => T): T;
 /** How the game ended, or undefined while it goes on: by the board, or by what the record says, such as a resignation. */
 export declare function endOf(game: Game): GameEnd | undefined;
 /** The draw offer that stands: none once the game is over (D-65). */

package/dist/games/current-game.js

@@ -4,7 +4,7 @@ import { readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
 import { Game, readPgn, writePgn } from "../core/index.js";
-import { stampOf, writeAtomically } from "./files.js";
+import { stampOf, whileLocked, writeAtomically } from "./files.js";
 /** The current game of a folder, as it is on disk, or undefined when there is none. A game.json Chesspal cannot read throws: nothing overwrites it. */
 export function loadGame(folder) {
     const path = join(folder, fileName);
@@ -21,27 +21,41 @@ export function loadGame(folder) {
     kept.set(path, { stamp, current });
     return current;
 }
-/** Writes the current game to game.json, whole or not at all; from then on it is the one kept in memory. */
+/**
+ * Writes the current game to game.json, whole or not at all; from then on it is the one kept in memory. Refused with GameChanged when another process wrote
+ * the file since this one read it: the change made on the game read before would lose theirs.
+ */
 export function saveGame(folder, current) {
     const path = join(folder, fileName);
-    const file = {
-        format: 1,
-        ai: current.ai,
-        started: current.started,
-        pgn: writePgn(current.game.record),
-        ...(current.talk.length === 0 ? {} : { talk: current.talk }),
-        ...(current.clock === undefined ? {} : { clock: savedClockOf(current.clock) }),
-        ...(drawOfferOf(current) === undefined ? {} : { drawOffer: current.drawOffer }),
+    whileLocked(path, () => {
+        if (stampOf(path) !== kept.get(path)?.stamp) {
+            kept.delete(path);
+            throw new GameChanged();
+        }
+        write(path, current);
+    });
+}
+/** The refusal of a save on a game another process changed since this one read it: what wrote it reads it again and starts over, once (rerunIfChanged). */
+export class GameChanged extends Error {
+    constructor() {
+        super("The game changed on disk while this call was changing it, in another chat or on the board page: call it again. Nothing changed.");
+    }
+}
+/** Runs a change of the game, and once more from the start when another process changed the game under it: a second refusal stands. */
+export function rerunIfChanged(run) {
+    const again = (error) => {
+        if (!(error instanceof GameChanged)) {
+            throw error;
+        }
+        return run();
     };
     try {
-        writeAtomically(path, `${JSON.stringify(file, null, 2)}\n`);
+        const result = run();
+        return result instanceof Promise ? result.catch(again) : result;
     }
     catch (error) {
-        // The live game may hold a move the file does not: the next call reads the file again.
-        kept.delete(path);
-        throw new Error(`Chesspal could not save the game: ${error.message} Nothing changed.`, { cause: error });
+        return again(error);
     }
-    kept.set(path, { stamp: stampOf(path) ?? "", current });
 }
 /** How the game ended, or undefined while it goes on: by the board, or by what the record says, such as a resignation. */
 export function endOf(game) {
@@ -100,6 +114,26 @@ const gameFile = z.object({
 });
 // The games read or written in this process, by their file, with the file's stamp then: a call reads a file again only when another process changed it.
 const kept = new Map();
+function write(path, current) {
+    const file = {
+        format: 1,
+        ai: current.ai,
+        started: current.started,
+        pgn: writePgn(current.game.record),
+        ...(current.talk.length === 0 ? {} : { talk: current.talk }),
+        ...(current.clock === undefined ? {} : { clock: savedClockOf(current.clock) }),
+        ...(drawOfferOf(current) === undefined ? {} : { drawOffer: current.drawOffer }),
+    };
+    try {
+        writeAtomically(path, `${JSON.stringify(file, null, 2)}\n`);
+    }
+    catch (error) {
+        // The live game may hold a move the file does not: the next call reads the file again.
+        kept.delete(path);
+        throw new Error(`Chesspal could not save the game: ${error.message} Nothing changed.`, { cause: error });
+    }
+    kept.set(path, { stamp: stampOf(path) ?? "", current });
+}
 function parsed(text, path) {
     try {
         const file = gameFile.parse(JSON.parse(text));

package/dist/games/files.d.ts

@@ -1,5 +1,10 @@
 /** Writes a file whole or not at all: a temporary file beside it, then renamed over it (D-27). A failure says what to do about it. */
 export declare function writeAtomically(path: string, text: string | Uint8Array): void;
+/**
+ * Runs `write` while this process alone holds the file's lock, a folder beside it made only if missing, cheaper than a file on Windows: another process
+ * waits, a second at most. A lock older than two seconds is of a process that stopped while it held it, and goes.
+ */
+export declare function whileLocked<T>(path: string, write: () => T): T;
 /** Makes a folder, and those above it, when missing. A failure says what to do about it. */
 export declare function makeFolder(path: string): void;
 /** A stamp of a file that changes whenever it is written, whoever writes it; undefined when there is none. */