chesspal 0.3.6 → 0.4.0

package/dist/cli/cli.js

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
-import { runCommandLine } from "./command-line.js";
 const args = process.argv.slice(2);
 // The table's own words (D-104): alone or open, its page; table, icon (--remove), play <host>. The host's: mcp, its server; listen, its doorbell; chat, how the chat
-// started. Everything else is a command.
+// started; prompt, the move the player wrote alone. Everything else is a command. Each loads only what it needs: prompt runs on every message of the chat.
 if (args.length === 0) {
     await openTableHere(true);
 }
@@ -40,7 +39,12 @@ else if (args.length === 1 && args[0] === "chat") {
     const { recordChatStart } = await import("./chat-hook.js");
     await recordChatStart();
 }
+else if (args.length === 1 && args[0] === "prompt") {
+    const { answerPrompt } = await import("./prompt-hook.js");
+    await answerPrompt();
+}
 else {
+    const { runCommandLine } = await import("./command-line.js");
     const { output, exitCode } = await runCommandLine(args);
     if (exitCode === 0) {
         console.log(output);
@@ -114,3 +118,4 @@ async function serveTable() {
         process.exitCode = 1;
     }
 }
+export {};

package/dist/cli/command-line.js

@@ -3,11 +3,12 @@ import { parseArgs } from "node:util";
 import { baseType, commandLineFieldProblem, commands, defaultContext, inputProblems, isBoolean, isList, takesNumbers } from "../commands/index.js";
 import { rerunIfChanged } from "../games/index.js";
 import { version } from "../version.js";
-// The commands that exist only on the command line: cli.ts starts the table, opens its page, puts its icon, starts the server, the doorbell or the chat's
-// note, when one comes alone.
+// The commands that exist only on the command line: cli.ts starts the table, opens its page, puts its icon, starts the server, the doorbell, the chat's
+// note or the move written alone, when one comes alone.
 const mcpDescription = "Start the MCP server for an AI host. Through it the host uses these commands as tools; the host starts it, with no options.";
 const listenDescription = "Wait for the player's move on the board page and wake the chat. Claude Code starts it at the end of each turn, and Codex with --codex, as init sets them up.";
 const chatDescription = "Note how the chat started: new, cleared, resumed or compacted. Claude Code and Codex run it when a chat starts, as init sets them up.";
+const promptDescription = "Play the move the player wrote alone in the chat, before the AI reads it, and tell the AI the position. Claude Code runs it on each message, as init sets it up.";
 const tableDescription = "Serve the board page with no chat, until no browser has had it open for five minutes. `chesspal` alone starts it apart and opens the page.";
 const openDescription = "Open the board page as `chesspal` alone does, without asking about the icon: what the icon runs.";
 const iconDescription = "Put Chesspal's icon on the desktop and in the menu: it opens the board page as `chesspal` alone does, with no terminal. `chesspal icon --remove` takes it away.";
@@ -16,7 +17,7 @@ const playDescription = "Start the AI in this terminal, in Claude Code or Codex,
 const initForPlayer = "Set up a folder of your own to play in, from Claude Code, Codex or the Claude desktop app.";
 const iconRemoveForPlayer = "Take Chesspal's icon away, before you uninstall it.";
 // Those of them that take no options, by name.
-const plainCommands = new Map([["mcp", mcpDescription], ["chat", chatDescription], ["table", tableDescription], ["open", openDescription], ["icon", iconDescription]]);
+const plainCommands = new Map([["mcp", mcpDescription], ["chat", chatDescription], ["prompt", promptDescription], ["table", tableDescription], ["open", openDescription], ["icon", iconDescription]]);
 /** The `chesspal` command line: finds the command, validates its input, runs it and renders the result. */
 export async function runCommandLine(argv, context = defaultContext(), list = commands) {
     const [commandName, ...args] = argv;
@@ -175,6 +176,7 @@ function generalHelp(list) {
         line("mcp", mcpDescription),
         line("listen", listenDescription),
         line("chat", chatDescription),
+        line("prompt", promptDescription),
         "",
         "Run `chesspal <command> --help` for its options.",
     ].join("\n");

package/dist/cli/prompt-hook.d.ts

@@ -0,0 +1,17 @@
+import type { Context } from "../commands/index.ts";
+/**
+ * Reads the hook's input, tells the chat's page the chat is at work and, when the prompt is a move Chesspal plays, writes what the AI is told; it never
+ * blocks the prompt.
+ */
+export declare function answerPrompt(input?: NodeJS.ReadableStream, sent?: Date): Promise<void>;
+/**
+ * What the hook writes, the JSON Claude Code reads, when the prompt is one move and Chesspal played it; undefined, with nothing changed, for any other
+ * prompt or a move refused. `contextOf` gives what the move is played with, in the chat's folder; it then notes there the position shown to the chat.
+ */
+export declare function promptAnswer(input: string, contextOf: (hook: HookInput) => Promise<Context>): Promise<string | undefined>;
+/** What the hook reads of Claude Code's input: the prompt trimmed, the chat's session and the folder it runs in. */
+export interface HookInput {
+    prompt?: string;
+    session?: string;
+    cwd?: string;
+}

package/dist/cli/prompt-hook.js

@@ -0,0 +1,100 @@
+/**
+ * Reads the hook's input, tells the chat's page the chat is at work and, when the prompt is a move Chesspal plays, writes what the AI is told; it never
+ * blocks the prompt.
+ */
+export async function answerPrompt(input = process.stdin, sent = new Date()) {
+    try {
+        const text = await textOf(input);
+        const [answer] = await Promise.all([promptAnswer(text, (hook) => hookContext(hook, sent)), tellPage(hookInput(text))]);
+        if (answer !== undefined) {
+            process.stdout.write(`${answer}\n`);
+        }
+    }
+    catch (error) {
+        process.stderr.write(`Chesspal could not play the move written in the chat: ${String(error.message ?? error).replace(/\s+/g, " ")}\n`);
+    }
+}
+/**
+ * What the hook writes, the JSON Claude Code reads, when the prompt is one move and Chesspal played it; undefined, with nothing changed, for any other
+ * prompt or a move refused. `contextOf` gives what the move is played with, in the chat's folder; it then notes there the position shown to the chat.
+ */
+export async function promptAnswer(input, contextOf) {
+    const hook = hookInput(input);
+    if (hook.prompt === undefined || !moveShape.test(hook.prompt) || hook.session === undefined) {
+        return undefined;
+    }
+    const [context, { playMoveSentAlone }, { hostProcess, notePositionShown }] = await Promise.all([contextOf(hook), import("../commands/index.js"), import("../games/index.js")]);
+    let played;
+    try {
+        played = playMoveSentAlone(hook.prompt, context);
+    }
+    catch (error) {
+        // Chesspal's refusals end so: the game as it was, the AI reads the prompt and answers it.
+        if (error instanceof Error && error.message.endsWith("Nothing changed.")) {
+            return undefined;
+        }
+        throw error;
+    }
+    try {
+        const { position, stamp, given } = played;
+        const host = hostProcess();
+        notePositionShown(context.folder, {
+            session: hook.session,
+            ...(host === undefined ? {} : { process: host }),
+            ...(stamp === undefined ? {} : { stamp }),
+            ...position,
+            at: context.now().toISOString(),
+            given,
+        });
+    }
+    catch (error) {
+        // The move is played: the AI hears it all the same, and its server asks it for status before its own, which may give the words again.
+        process.stderr.write(`Chesspal could not note the position it showed the chat: ${error.message}\n`);
+    }
+    return JSON.stringify({ hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: played.answer } });
+}
+// One move and nothing else, as player_move takes it: SAN with K, Q, R, B and N, small or as figurines, or with the letters of other languages that name
+// one piece (Cf3, Tf1, Dd1, e8=D), or as squares, or castling; a check or mate sign.
+const moveShape = /^(?:[KQRBNkqrbnCSAFLTDt♔-♟]?[a-h]?[1-8]?[-x:×–—−]?[a-h][1-8](?:=?[QRBNqrbnCSAFLTD])?|[0Oo]-[0Oo](?:-[0Oo])?)[+#]?$/u;
+/**
+ * Tells the chat's page that the prompt starts its turn: the doorbell lets the hook of the turn before go, and a new game asked on the page waits for
+ * the turn's end. A slash command or a shell line may start no turn, and so no Stop hook to end it: the page is not told.
+ */
+async function tellPage(hook) {
+    if (hook.prompt === undefined || /^[/!]/.test(hook.prompt)) {
+        return;
+    }
+    // A page not told leaves the doorbell as it was: the move, when the prompt is one, is played all the same.
+    await import("../server/ports/index.js").then(({ tellChatAtWork }) => tellChatAtWork(hook), () => false);
+}
+/** The context of the chat's folder: the data folder its server is given, the moment the player sent the move, and Claude Code, which runs this hook. */
+async function hookContext(hook, sent) {
+    const [{ defaultContext }, { chatFolder, serverHome }] = await Promise.all([import("../commands/index.js"), import("../server/ports/index.js")]);
+    const folder = chatFolder(hook);
+    const home = serverHome(folder);
+    // A playtest's data folder, which .mcp.json gives the server and not the hook.
+    if (home !== undefined) {
+        process.env.CHESSPAL_HOME = home;
+    }
+    return { ...defaultContext(), folder, now: () => sent, host: () => "claude-code" };
+}
+async function textOf(input) {
+    let text = "";
+    for await (const chunk of input) {
+        text += String(chunk);
+    }
+    return text;
+}
+function hookInput(text) {
+    try {
+        const { prompt, session_id: session, cwd } = JSON.parse(text);
+        return {
+            ...(typeof prompt === "string" ? { prompt: prompt.trim() } : {}),
+            ...(typeof session === "string" ? { session } : {}),
+            ...(typeof cwd === "string" ? { cwd } : {}),
+        };
+    }
+    catch {
+        return {};
+    }
+}

package/dist/commands/analysis/analyse.js

@@ -5,7 +5,7 @@ import { gameInAnalysis, isGameName, keepToStudy, lastChatStart, planOf, rewrite
 import { analystAgent, instructionsFile } from "../../host-files/index.js";
 import { activeProfile, gameFolder } from "../../profiles/index.js";
 import { pointsAtSite, siteGameName, siteOfGameName } from "../../sites/index.js";
-import { analystOf, anotherAnalyst, balanceText, bookOpening, bookReaches, colourName, gameToStudy, knownTag, moveNumbers, namedGame, noGameGoingOn, riskLine, shownMove, speechLine, speechOf, tacticsText, } from "../answers/index.js";
+import { analystOf, anotherAnalyst, balanceText, bookOpening, bookPlace, bookPlies, colourName, gameToStudy, knownTag, moveNumbers, namedGame, noGameGoingOn, riskLine, shownMove, speechLine, speechOf, tacticsText, } from "../answers/index.js";
 import { playerLine, siteText } from "../profiles/index.js";
 import { defineCommand } from "../registry/index.js";
 import { profileSiteGames } from "./site-games.js";
@@ -49,7 +49,7 @@ export const analyseGame = defineCommand({
         }
         const analysis = analysisOf(studied, activeProfile(context.home()));
         if (studied.name !== undefined) {
-            markBook(context, { record: studied.record, name: studied.name }, analysis.moves);
+            markBook(context, { record: studied.record, name: studied.name });
             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);
@@ -148,8 +148,8 @@ async function siteGamePgn(context, name) {
  * The opening book's moves marked as such in the game kept (D-69): a fact, not a judgment, so Chesspal puts the badge itself on each move from the start to the
  * last one the book knows, where the AI gave none; a game from another position has none.
  */
-function markBook(context, { record, name }, moves) {
-    const inBook = bookPliesOfFacts(record, moves);
+function markBook(context, { record, name }) {
+    const inBook = bookPlies(record);
     const unmarked = record.moves.slice(0, inBook).some((move) => reviewOf(move.comment)?.badge === undefined);
     if (!unmarked) {
         return;
@@ -160,11 +160,6 @@ function markBook(context, { record, name }, moves) {
     });
     rewriteGame(gameFolder(context.home()), name, { ...record, moves: marked });
 }
-/** How many plies from the start the opening book knows, as opening-book's bookPlies counts them, read from the facts already found: none from another position. */
-function bookPliesOfFacts(record, moves) {
-    const firstOut = moves.findIndex((move) => move.outOfBook);
-    return record.tags.FEN !== undefined ? 0 : firstOut >= 0 ? firstOut : moves.length;
-}
 function analysisOf({ record, name }, profile) {
     const { tags } = record;
     const ai = sideNamed(record, "AI");
@@ -186,7 +181,7 @@ function analysisOf({ record, name }, profile) {
         termination: ended?.termination,
         opening: opening === undefined ? undefined : `${opening.eco} ${opening.name}`,
         inBook: opening !== undefined && !moves.some((move) => move.outOfBook) ? true : undefined,
-        bookTo: opening === undefined ? undefined : moves[bookPliesOfFacts(record, moves) - 1]?.move,
+        bookTo: opening === undefined ? undefined : moves[bookPlies(record) - 1]?.move,
         review: [gameReviewOf(record), closingOf(record)].filter((word) => word !== undefined).join(" ") || undefined,
         name,
         start: tags.FEN === undefined ? undefined : { fen: tags.FEN, ...start },
@@ -200,7 +195,8 @@ function movesOf(record, ai) {
     const increment = timeControlOfTag(record.tags.TimeControl ?? "")?.increment;
     // The time each side had left after its last move: the first move of each side spends no time it can tell, as the sites start their clocks apart.
     const left = {};
-    let inBook = record.tags.FEN === undefined && bookReaches(game.position.fen);
+    // The first move no line of the book reaches is out of book (D-68); a game from another position has no book.
+    const leftBook = bookPlace(record)?.plies;
     let before = game.facts;
     let balance = materialOf(game.position.fen).balance;
     const start = { atRisk: riskLine(before), oneLegal: oneLegalMove(before), mates: matesOf(before), tactics: tacticsText(before, game.possibilities, true) };
@@ -212,8 +208,6 @@ function movesOf(record, ai) {
         if (!played.played) {
             throw new Error(`The game's move ${numbers[ply]}${san} cannot be played: ${played.message} Fix the game's PGN.`);
         }
-        const outOfBook = inBook && !bookReaches(game.position.fen);
-        inBook &&= !outOfBook;
         const facts = game.facts;
         const over = game.outcome.over;
         const now = materialOf(game.position.fen).balance;
@@ -230,7 +224,7 @@ function movesOf(record, ai) {
             oneLegal: over ? undefined : oneLegalMove(facts),
             mates: over ? undefined : matesOf(facts),
             tactics: over ? undefined : tacticsText(facts, game.possibilities, true),
-            outOfBook: outOfBook ? true : undefined,
+            outOfBook: ply === leftBook ? true : undefined,
             drawOffer: comment?.includes("(=)") === true ? true : undefined,
             said: side === ai ? saidIn(comment) : undefined,
             review: reviewOf(comment),

package/dist/commands/analysis/annotate.d.ts

@@ -14,6 +14,14 @@ interface Annotated {
     left: string[];
     /** The chat corrected a note of a review that already has its word on the game. */
     summaryStands: boolean;
+    /** Where this call wrote a move with another language's letters (5., your summary), and the first such move: the page shows them as plain text (D-87). */
+    lettered: {
+        where: string[];
+        first?: {
+            written: string;
+            san: string;
+        };
+    };
 }
 /** 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/registry.ts").Command<z.ZodObject<{

package/dist/commands/analysis/annotate.js

@@ -1,7 +1,7 @@
 // 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, gameReviewOf, leadOf, reviewed, reviewOf, withAnnotator, withGameReview, withLead } from "../../core/index.js";
+import { annotatorOf, badges, figurinesOf, foreignMovesIn, 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";
@@ -105,9 +105,10 @@ export const annotateGame = defineCommand({
             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,
+            lettered: letteredIn([...notes.map(({ move, note }) => [move, note]), ["your summary", summary], ["your last word", closing]]),
         };
     },
-    format: ({ game, marked, summary, closing, bookUnnoted, estimated, unestimated, left, summaryStands }) => {
+    format: ({ game, marked, summary, closing, bookUnnoted, estimated, unestimated, left, summaryStands, lettered }) => {
         const kept = [
             marked === 0 ? undefined : `${marked} ${marked === 1 ? "move" : "moves"} marked`,
             estimated === 0 ? undefined : `who is ahead after ${estimated} ${estimated === 1 ? "move" : "moves"}`,
@@ -129,9 +130,24 @@ export const annotateGame = defineCommand({
             : [`${left.join(" ")} ${one ? "keeps the note" : "keep the notes"} the AI wrote with the player: leave ${one ? "it" : "them"}, and don't contradict ${one ? "it" : "them"} in your summary${summary ? "; if this one does, give it again" : ""}.`];
         const head = kept.length === 0 ? `Nothing new kept in ${game}.` : `Kept in ${game}: ${[kept.slice(0, -1).join(", "), kept.at(-1)].filter((part) => part !== "").join(" and ")}. The board page shows them.`;
         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");
+        const single = lettered.where.length === 1;
+        const letters = lettered.first === undefined
+            ? []
+            : [
+                `${lettered.where.join(", ")} ${single ? "writes" : "write"} moves with another language's letters, which the page shows as plain text: give ${single ? "it" : "them"} `
+                    + `again with the figurines (${figurinesOf(lettered.first.san)} for ${lettered.first.written}).`,
+            ];
+        return [head, ...stands, ...corrected, ...letters, ...book, ...ahead].join("\n");
     },
 });
+/** Where the texts of a call write a move with another language's letters, by the move or the part they were given for, and the first such move. */
+function letteredIn(texts) {
+    const found = texts.flatMap(([where, text]) => {
+        const [first] = foreignMovesIn(text ?? "");
+        return first === undefined ? [] : [{ where, first }];
+    });
+    return { where: [...new Set(found.map(({ where }) => where))], ...(found[0] === undefined ? {} : { first: found[0].first }) };
+}
 /** 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, over) {
     return record.moves.flatMap((move, index) => leadOf(move.comment) !== undefined || (over && index === record.moves.length - 1) ? [] : [numbers[index]]);

package/dist/commands/answers/agents.d.ts

@@ -25,15 +25,15 @@ export declare function coachRuns(context: Context): boolean;
 /** Whether one of Chesspal's agents runs beside this chat: in a host that starts agents, with its file in the player's folder. */
 export declare function agentRuns(context: Context, agent: string): boolean;
 /**
- * Whether to start the coach after the player's own move has ended the game on the board, with the helps on: it judges that move too (D-88). Told again
- * until it starts, since a chat woken by the page may lose the line on its way to its words (Priya).
+ * Whether to start the coach once a move has ended the game on the board, with the helps on: it judges the player's last move, their own that ended it too
+ * (D-88). Told again until it starts, since a chat busy telling the end may lose the line on its way to its words (Priya).
  */
 export declare function coachOnEnd(context: Context, folder: string, current: CurrentGame): boolean;
 /**
- * How to start the coach on the player's move that ended the game: whatever the player asks, beside the analyst when the chat starts it too, since a chat on
- * a quick model started only the agent that answered the player (Priya).
+ * How to start the coach once a move ended the game, on the player's last move, theirs that ended it or the one before the AI's: whatever the player asks,
+ * beside the analyst when the chat starts it too, since a chat on a quick model started only the agent that answered the player (Priya).
  */
-export declare const coachOnEndLine: string;
+export declare function coachOnEndLine({ turn, ai }: GameSummary): string;
 /**
  * How to start the agents, in one message, the one that thinks first, since it needs the time (Priya), and that the player sees nothing of
  * them: their end needs no answer either. The end of the last move's agents, told just after, must not take their place (Priya).
@@ -49,5 +49,7 @@ export declare function goneOver(context: Context, game: string): boolean;
  * agent with it, or it has written nothing for half an hour, as one long dead (D-109): a quiet minute proves nothing, since an analyst may think long.
  */
 export declare function analystOf(context: Context, game: string): string | undefined;
+/** When the analyst that holds a game counts as gone if it writes nothing before: none while no analyst holds one. */
+export declare function analystQuietAt(context: Context): Date | undefined;
 /** What stops an analyst agent on a game another analyst has taken: the chat hears of the review from that one (Priya). */
 export declare const anotherAnalyst: string;

package/dist/commands/answers/agents.js

@@ -66,20 +66,22 @@ export function agentRuns(context, agent) {
     return host !== undefined && agentHosts.includes(host) && hasAgent(context.folder, agent, host);
 }
 /**
- * Whether to start the coach after the player's own move has ended the game on the board, with the helps on: it judges that move too (D-88). Told again
- * until it starts, since a chat woken by the page may lose the line on its way to its words (Priya).
+ * Whether to start the coach once a move has ended the game on the board, with the helps on: it judges the player's last move, their own that ended it too
+ * (D-88). Told again until it starts, since a chat busy telling the end may lose the line on its way to its words (Priya).
  */
 export function coachOnEnd(context, folder, current) {
-    const { game, ai } = current;
-    return game.outcome.over && game.position.turn === ai && helpsIn(folder) && coachRuns(context) && !coachStarted(folder, current);
+    return current.game.outcome.over && helpsIn(folder) && coachRuns(context) && !coachStarted(folder, current);
 }
 /**
- * How to start the coach on the player's move that ended the game: whatever the player asks, beside the analyst when the chat starts it too, since a chat on
- * a quick model started only the agent that answered the player (Priya).
+ * How to start the coach once a move ended the game, on the player's last move, theirs that ended it or the one before the AI's: whatever the player asks,
+ * beside the analyst when the chat starts it too, since a chat on a quick model started only the agent that answered the player (Priya).
  */
-export const coachOnEndLine = `Coach the player: start the ${coachAgent} agent in the background with the prompt "Coach.", whatever the player asks: it judges `
-    + "the move that ended the game, apart from the analyst; when you start the analyst too, start both in one message. Start it even when an agent of the move "
-    + "before has just ended, and write nothing about it in the chat, now or when it ends.";
+export function coachOnEndLine({ turn, ai }) {
+    const judged = turn === ai ? "the move that ended the game" : "the player's last move, the one before the end";
+    return `Coach the player: start the ${coachAgent} agent in the background with the prompt "Coach.", whatever the player asks: it judges ${judged}, apart `
+        + "from the analyst; when you start the analyst too, start both in one message. Start it even when an agent of the move before has just ended, and write "
+        + "nothing about it in the chat, now or when it ends.";
+}
 /**
  * How to start the agents, in one message, the one that thinks first, since it needs the time (Priya), and that the player sees nothing of
  * them: their end needs no answer either. The end of the last move's agents, told just after, must not take their place (Priya).
@@ -123,6 +125,11 @@ export function analystOf(context, game) {
     const quiet = analysis !== undefined && context.now().getTime() - Date.parse(analysis.at) > analystQuiet;
     return taken?.game === game && !restarted && !quiet ? taken.run : undefined;
 }
+/** When the analyst that holds a game counts as gone if it writes nothing before: none while no analyst holds one. */
+export function analystQuietAt(context) {
+    const analysis = gameInAnalysis(gameFolder(context.home()));
+    return analysis?.analyst === undefined ? undefined : new Date(Date.parse(analysis.at) + analystQuiet);
+}
 /** How long an analyst may write nothing before it counts as gone. */
 const analystQuiet = 30 * 60 * 1000;
 /** What stops an analyst agent on a game another analyst has taken: the chat hears of the review from that one (Priya). */

package/dist/commands/answers/clock.js

@@ -1,6 +1,7 @@
 // The clock in the commands (D-13): a flag that falls ends the game as soon as a command reads it, and the clock's line for the AI.
 import { canMate, clockText, Game, timeControlText, timeLeft } from "../../core/index.js";
 import { archiveEnded, endOf, loadGame, saveGame } from "../../games/index.js";
+import { openingTags } from "./opening-tags.js";
 import { colourName } from "./view.js";
 /** The current game of a folder `now`, or undefined: a game whose side to move has run out of time is over, saved and archived first. */
 export function gameAt(folder, now) {
@@ -15,7 +16,7 @@ export function gameAt(folder, now) {
     const ended = outOfTime(current, turn, now);
     saveGame(folder, ended);
     // An archive that cannot be written leaves the game in game.json, where status shows it, until a new game archives it.
-    archiveEnded(folder, ended);
+    archiveEnded(folder, ended, openingTags(ended.game.record));
     return ended;
 }
 /** The clock of a game `now`, as the AI reads it; none in a game without one. */

package/dist/commands/answers/drawings.js

@@ -12,10 +12,10 @@ export const noteInput = z.string().trim().min(1).max(noteLimit).regex(/^[^[\]{}
 const drawing = z.string().overwrite((text) => text.replace(/[\s-]+/g, ""));
 /** The arrows the AI draws, as their input reads them. */
 export const arrowsInput = z.array(drawing.regex(/^[GRYB][a-h][1-8][a-h][1-8]$/, "an arrow is a colour's letter and two squares: Gf6e4; a single square goes in squares")
-    .refine((arrow) => arrow.slice(1, 3) !== arrow.slice(3, 5), "an arrow goes from a square to another: a single square goes in squares")).max(drawLimit).optional()
+    .refine((arrow) => arrow.slice(1, 3) !== arrow.slice(3, 5), "an arrow goes from a square to another: a single square goes in squares")).max(drawLimit).optional().overwrite(noneIfEmpty)
     .describe("arrows on the board, as PGN's %cal writes them: Rf2e1. G green: the better move or the good idea; R red: a threat or the mistake; Y yellow: another way; B blue: a plan.");
 /** The squares the AI marks, as their input reads them. */
-export const squaresInput = z.array(drawing.regex(/^[GRYB][a-h][1-8]$/, "a square is a colour's letter and the square: Rf2")).max(drawLimit).optional()
+export const squaresInput = z.array(drawing.regex(/^[GRYB][a-h][1-8]$/, "a square is a colour's letter and the square: Rf2")).max(drawLimit).optional().overwrite(noneIfEmpty)
     .describe("squares to mark, as PGN's %csl writes them: Rf2; colours as for arrows");
 /** The arrows and squares drawn, those that read; none of either left out. */
 export function drawingsOf(arrows = [], squares = []) {
@@ -23,3 +23,7 @@ export function drawingsOf(arrows = [], squares = []) {
     const drawnSquares = squares.map(squareOf).filter((square) => square !== undefined);
     return { ...(drawnArrows.length === 0 ? {} : { arrows: drawnArrows }), ...(drawnSquares.length === 0 ? {} : { squares: drawnSquares }) };
 }
+// An empty list draws nothing, as one left out: a host may send every parameter of the schema (Priya).
+function noneIfEmpty(list) {
+    return list?.length === 0 ? undefined : list;
+}

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

@@ -1,12 +1,13 @@
-export { agentRuns, agentsLine, analystLine, analystOf, analystOnView, analystRuns, anotherAnalyst, coachOnEnd, coachOnEndLine, coachRuns, goneOver, reviewedLine, withAnalyst } from "./agents.ts";
+export { agentRuns, agentsLine, analystLine, analystOf, analystOnView, analystQuietAt, analystRuns, anotherAnalyst, coachOnEnd, coachOnEndLine, coachRuns, goneOver, reviewedLine, withAnalyst } from "./agents.ts";
 export { clockLine, clockSummaryOf, gameAt } from "./clock.ts";
 export { arrowsInput, drawingsOf, noteInput, squaresInput } from "./drawings.ts";
 export { aheadWords, leadFrom, leadInput } from "./lead-input.ts";
 export { closingLines, headLines, lastMoveText, moveLines, newGameStep, nextStep, positionLines, shownMove, shownMoves, sidesLine, wordLines } from "./lines.ts";
-export { bookOpening, bookPlies, bookReaches, knownMoves, openingLine, openingName } from "./opening-book.ts";
+export { bookOpening, bookPlace, bookPlies, knownMoves, openingLine, openingName } from "./opening-book.ts";
+export { openingTags } from "./opening-tags.ts";
 export { playMove, PositionChanged, positionIn, refuseOtherGame, refuseUnseenPosition, samePosition } from "./play-move.ts";
 export { give, newWords, say, unansweredWords, waitingWords, type Written } from "./say.ts";
 export { type Speech, speechLine, speechOf } from "./speech.ts";
 export { gameShown, gameToStudy, knownTag, moveIndex, moveNumbers, namedGame, noGameGoingOn, positionAfter, positionLine, shownPosition, type Studied, studyInput } from "./study.ts";
-export { gameGoingOn, type GameSummary, lastMoves, type MovePlayed, summaryOf, withThought } from "./summary.ts";
+export { endText, gameGoingOn, type GameSummary, lastMoves, type MovePlayed, summaryOf, withThought } from "./summary.ts";
 export { balanceText, boardView, colourName, compactView, fullView, materialText, riskLine, tacticsText } from "./view.ts";

package/dist/commands/answers/index.js

@@ -1,14 +1,15 @@
 // What the commands share to answer the AI: the lines it reads, the game's summary and view, the clock, the talk, the moves played, the games to study.
 // Above the registry only, below every other command folder.
-export { agentRuns, agentsLine, analystLine, analystOf, analystOnView, analystRuns, anotherAnalyst, coachOnEnd, coachOnEndLine, coachRuns, goneOver, reviewedLine, withAnalyst } from "./agents.js";
+export { agentRuns, agentsLine, analystLine, analystOf, analystOnView, analystQuietAt, analystRuns, anotherAnalyst, coachOnEnd, coachOnEndLine, coachRuns, goneOver, reviewedLine, withAnalyst } from "./agents.js";
 export { clockLine, clockSummaryOf, gameAt } from "./clock.js";
 export { arrowsInput, drawingsOf, noteInput, squaresInput } from "./drawings.js";
 export { aheadWords, leadFrom, leadInput } from "./lead-input.js";
 export { closingLines, headLines, lastMoveText, moveLines, newGameStep, nextStep, positionLines, shownMove, shownMoves, sidesLine, wordLines } from "./lines.js";
-export { bookOpening, bookPlies, bookReaches, knownMoves, openingLine, openingName } from "./opening-book.js";
+export { bookOpening, bookPlace, bookPlies, knownMoves, openingLine, openingName } from "./opening-book.js";
+export { openingTags } from "./opening-tags.js";
 export { playMove, PositionChanged, positionIn, refuseOtherGame, refuseUnseenPosition, samePosition } from "./play-move.js";
 export { give, newWords, say, unansweredWords, waitingWords } from "./say.js";
 export { speechLine, speechOf } from "./speech.js";
 export { gameShown, gameToStudy, knownTag, moveIndex, moveNumbers, namedGame, noGameGoingOn, positionAfter, positionLine, shownPosition, studyInput } from "./study.js";
-export { gameGoingOn, lastMoves, summaryOf, withThought } from "./summary.js";
+export { endText, gameGoingOn, lastMoves, summaryOf, withThought } from "./summary.js";
 export { balanceText, boardView, colourName, compactView, fullView, materialText, riskLine, tacticsText } from "./view.js";

package/dist/commands/answers/lines.d.ts

@@ -17,7 +17,7 @@ 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 Written[], pageClosed?: boolean): string[];
+export declare function closingLines(game: GameSummary | undefined, words?: readonly Written[], pageClosed?: boolean, doorbell?: 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.
@@ -25,9 +25,11 @@ export declare function closingLines(game: GameSummary | undefined, words?: read
 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.
+ * board page open in no browser, a new game starts there, never in the chat. In a host with no `doorbell`, the player tells the chat what they did on the page.
  */
-export declare function nextStep(game: GameSummary | undefined, words?: readonly Written[], pageClosed?: boolean): string;
+export declare function nextStep(game: GameSummary | undefined, words?: readonly Written[], pageClosed?: boolean, doorbell?: boolean): string;
+/** What the AI does with the player's move in a host with no doorbell: one played on the board page they tell it of, one written in the chat it plays. */
+export declare const toldMove = "when they tell you they moved on the board page, call status; when they write it here, call player_move with it.";
 /** 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/answers/lines.js

@@ -72,8 +72,8 @@ export function moveLines({ note, game, warning }) {
     return [...(note === undefined ? [] : [`Note: ${note}`]), ...positionLines(game, false), ...(warning === undefined ? [] : [warning])];
 }
 /** 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 function closingLines(game, words = [], pageClosed = false) {
-    return [...wordLines(words), nextStep(game, words, pageClosed)];
+export function closingLines(game, words = [], pageClosed = false, doorbell = true) {
+    return [...wordLines(words), nextStep(game, words, pageClosed, doorbell)];
 }
 /**
  * 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
@@ -84,9 +84,9 @@ export function wordLines(words) {
 }
 /**
  * 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.
+ * board page open in no browser, a new game starts there, never in the chat. In a host with no `doorbell`, the player tells the chat what they did on the page.
  */
-export function nextStep(game, words = [], pageClosed = false) {
+export function nextStep(game, words = [], pageClosed = false, doorbell = true) {
     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)) {
@@ -114,7 +114,9 @@ export function nextStep(game, words = [], pageClosed = false) {
             : `Next: answer the player with ai_say.${analysis} When they want another game, ${step}`;
     }
     if (game.turn === game.ai && game.clock?.waiting === true) {
-        return "Next: don't move yet: the player starts the game with Start on the board page, and the doorbell wakes you then. End your turn.";
+        return doorbell
+            ? "Next: don't move yet: the player starts the game with Start on the board page, and the doorbell wakes you then. End your turn."
+            : "Next: don't move yet: the player starts the game with Start on the board page. End your turn, and call status when they tell you they did.";
     }
     if (game.turn === game.ai) {
         return words.length === 0
@@ -124,8 +126,13 @@ export function nextStep(game, words = [], pageClosed = false) {
     if (game.drawOffer === "player") {
         return "Next: accept the draw with end_game draw_agreed, or answer with ai_say and wait for the player's move.";
     }
-    return words.length === 0 ? "Next: wait for the player's move, then call player_move with it." : "Next: answer the player with ai_say, then wait for their move.";
+    if (words.length > 0) {
+        return "Next: answer the player with ai_say, then wait for their move.";
+    }
+    return doorbell ? "Next: wait for the player's move, then call player_move with it." : `Next: wait for the player's move: ${toldMove}`;
 }
+/** What the AI does with the player's move in a host with no doorbell: one played on the board page they tell it of, one written in the chat it plays. */
+export const toldMove = "when they tell you they moved on the board page, call status; when they write it here, call player_move with it.";
 /** How a new game starts: the player chooses it in the board page's window, which new_game without choices opens (D-85). */
 export 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.";
 // With the page open in no browser the window cannot open: the player opens the page and presses New game.
@@ -165,7 +172,7 @@ function whereLine(game) {
     if (game.end !== undefined) {
         // Saved where the player's games are: the AI says so, never the file, which past_games names when it is needed.
         const archived = game.end.archive === undefined ? "" : " Saved with the player's games.";
-        return `Game over: ${endText(game.end)}.${archived}`;
+        return `Game over: ${endText(game.end, game.ai)}.${archived}`;
     }
     return `${game.turn === game.ai ? "You" : "Player"} (${colourName(game.turn)}) to move, move ${game.moveNumber}.`;
 }

package/dist/commands/answers/opening-book.d.ts

@@ -1,13 +1,19 @@
-import { type GameRecord, type Opening } from "../../core/index.ts";
-/** The game's opening as the AI reads it: ECO and name, and the move it left the book at; none outside the book, or where the build made no index. */
-export declare function openingLine(record: GameRecord): string | undefined;
+import { type BookPlace, Game, type GameRecord, type Opening } from "../../core/index.ts";
+/**
+ * The game's opening as the AI reads it: ECO and name, and the move it left the book at (D-68); none outside the book, or where the build made no index.
+ * A live game gives the positions it went through; a record alone is replayed.
+ */
+export declare function openingLine(game: Game | GameRecord): string | undefined;
 /** The moves the book knows from a position (D-15), for the AI at the master level; none out of the book, or where the build made no book. */
 export declare function knownMoves(fen: string): readonly string[];
-/** How many plies from the start the book knows, to the last before the game left it (D-69); none from another position. */
-export declare function bookPlies(record: GameRecord): number;
-/** Whether a line of Lichess's openings reaches a position, by any order of moves (D-68); never where the build made no book. */
-export declare function bookReaches(fen: string): boolean;
+/** How many plies from the start the book knows, to the last before the game left it (D-68, D-69); none from another position. */
+export declare function bookPlies(game: Game | GameRecord): number;
 /** The opening a game reached, ECO and name, without where it left the book: for the games in the archive. */
 export declare function openingName(record: GameRecord): string | undefined;
 /** The last named opening a game reached, and at which ply; none outside the book, or where the build made no index. */
 export declare function bookOpening(record: GameRecord): Opening | undefined;
+/**
+ * Where a game stands in the book, its opening and its plies the book knows, once per record: from the positions a live game went through, or a record
+ * replayed; none from another position, or where the build made no index.
+ */
+export declare function bookPlace(game: Game | GameRecord): BookPlace | undefined;