chesspal 0.2.4 → 0.3.1

package/dist/server/table/table.js

@@ -0,0 +1,94 @@
+// The table (D-104): the board page served in a process of its own, on a folder of the data folder that is one for every profile, which a chat attaches
+// to; it closes by itself once no browser has had the page open, and no chat been attached, for a while.
+import { request } from "node:http";
+import { tableFolder } from "../../home/index.js";
+import { setUpHosts } from "../../host-files/index.js";
+import { pageAt, pagePorts, samePath } from "../bell.js";
+import { startPage } from "../page/page.js";
+/** Five minutes with no browser and no chat, looked at every fifteen seconds (D-104). */
+export const tableTimes = { idle: 5 * 60_000, every: 15_000 };
+/**
+ * Starts the table on the context's data folder, its folder set up as init does, its page opening chats through `chats`: undefined when another table
+ * started at the same time took a lower port, since a table's ports are its lock. It closes once no page has been open, no chat attached and no request
+ * come, for `times.idle`.
+ */
+export async function startTable(context, times = tableTimes, chats) {
+    const folder = tableFolder(context.home());
+    setUpHosts(folder, context.platform);
+    let quit = () => undefined;
+    const quitting = new Promise((done) => {
+        quit = done;
+    });
+    let lastUsed = context.now().getTime();
+    const used = () => {
+        lastUsed = context.now().getTime();
+    };
+    const page = await startPage({ ...context, folder }, { table: { used, quit, chats } });
+    if (await lostTo(page.url, folder)) {
+        await page.close();
+        return undefined;
+    }
+    const watch = closeWhenIdle(page, () => context.now().getTime() - lastUsed, used, times, quit);
+    const closed = quitting.then(async () => {
+        clearInterval(watch);
+        await page.close();
+    });
+    return {
+        url: page.url,
+        closed,
+        close: () => {
+            quit();
+            return closed;
+        },
+    };
+}
+/** The table of a folder that answers on its ports, the lowest of them; its ports are asked together. */
+export async function tableAt(folder) {
+    const ports = pagePorts(folder);
+    const said = await Promise.all(ports.map(pageAt));
+    const index = said.findIndex((one) => one?.table === true && samePath(one.folder, folder));
+    const port = ports[index];
+    return port === undefined ? undefined : { url: `http://127.0.0.1:${port}/`, port, version: said[index]?.version, chat: said[index]?.chat };
+}
+/** Asks the table at a port to quit; it answers before it goes, and a table that cannot be reached, or does not answer within a second or so, is let be. */
+export function askToQuit(port) {
+    return new Promise((done) => {
+        const asked = request({ host: "127.0.0.1", port, path: "/api/table/quit", method: "POST", headers: { "Content-Type": "application/json" }, agent: false }, (response) => {
+            response.resume();
+            response.on("end", () => done());
+        });
+        asked.setTimeout(quitWait, () => asked.destroy());
+        asked.on("error", () => done());
+        asked.end("{}");
+    });
+}
+// A table answers at once: one stuck must not hold the chat's first tool, nor `chesspal`.
+const quitWait = 1_500;
+/** Whether a version is older than another, part by part: 0.2.4 is older than 0.10.0. */
+export function isOlder(one, other) {
+    const parts = (version) => version.split(/[.+-]/).slice(0, 3).map((part) => Number.parseInt(part, 10) || 0);
+    const [mine, theirs] = [parts(one), parts(other)];
+    const differs = mine.findIndex((part, index) => part !== theirs[index]);
+    return differs !== -1 && mine[differs] < theirs[differs];
+}
+/** Whether a table of the same folder answers on a lower port than this one's: the other won, and this one goes. */
+async function lostTo(url, folder) {
+    const port = Number(new URL(url).port);
+    const lower = pagePorts(folder).filter((other) => other < port);
+    const found = await Promise.all(lower.map(pageAt));
+    return found.some((said) => said?.table === true && samePath(said.folder, folder));
+}
+/**
+ * Looks every `times.every` whether a browser has the page open or a chat is attached, which uses the table, and quits once it has been unused for
+ * `times.idle`: the page that `chesspal` opens counts from its first request. The timer keeps the process alive till then.
+ */
+function closeWhenIdle(page, unusedFor, used, times, quit) {
+    return setInterval(() => {
+        if (page.inUse()) {
+            used();
+        }
+        else if (unusedFor() >= times.idle) {
+            quit();
+        }
+    }, times.every);
+}

package/dist/sites/chesscom.d.ts

@@ -0,0 +1,4 @@
+import type { SiteReading } from "../profiles/index.ts";
+import { type Fetch } from "./request.ts";
+/** What Chess.com says of a name: undefined when it could not be reached. */
+export declare function chesscomReading(account: string, fetch: Fetch, signal: AbortSignal): Promise<SiteReading | undefined>;

package/dist/sites/chesscom.js

@@ -0,0 +1,25 @@
+import { counted } from "./choice.js";
+import { askSite } from "./request.js";
+/** What Chess.com says of a name: undefined when it could not be reached. */
+export async function chesscomReading(account, fetch, signal) {
+    const statistics = await askSite(`https://api.chess.com/pub/player/${encodeURIComponent(account.toLowerCase())}/stats`, fetch, signal);
+    if (statistics === undefined || (statistics.status !== 200 && statistics.status !== 404)) {
+        return undefined;
+    }
+    if (statistics.status === 404) {
+        return { account, found: false };
+    }
+    const speeds = statistics.body;
+    const chosen = counted((speed) => {
+        const last = speeds?.[`chess_${speed}`]?.last;
+        return typeof last?.rating === "number" && typeof last.rd === "number"
+            ? { value: last.rating, deviation: last.rd, established: last.rd < provisional, ...(typeof last.date === "number" ? { played: dayOf(last.date) } : {}) }
+            : undefined;
+    });
+    return chosen === undefined ? { account, found: true } : { account, found: true, rating: { ...chosen, site: "chess.com" } };
+}
+// Chess.com gives no provisional mark: a rating is provisional while its deviation (RD) is as wide as Lichess's provisional ones.
+const provisional = 110;
+function dayOf(seconds) {
+    return new Date(seconds * 1000).toISOString().slice(0, 10);
+}

package/dist/sites/choice.d.ts

@@ -0,0 +1,17 @@
+import { type Speed } from "../profiles/index.ts";
+/** A site's rating at one speed, as it gives it: established once it is no longer provisional. */
+export interface Candidate {
+    readonly value: number;
+    readonly deviation: number;
+    readonly established: boolean;
+    readonly played?: string;
+}
+/** The rating that counts, with its speed. */
+export interface Played {
+    readonly speed: Speed;
+    readonly value: number;
+    readonly deviation: number;
+    readonly played?: string;
+}
+/** The first established rating in the order the speeds count: none when every one is missing or provisional. */
+export declare function counted(at: (speed: Speed) => Candidate | undefined): Played | undefined;

package/dist/sites/choice.js

@@ -0,0 +1,13 @@
+// Which of a site's ratings counts (D-106): the rapid, and when it is missing or provisional the classical, then the blitz.
+import { speeds } from "../profiles/index.js";
+/** The first established rating in the order the speeds count: none when every one is missing or provisional. */
+export function counted(at) {
+    for (const speed of speeds) {
+        const candidate = at(speed);
+        if (candidate?.established === true) {
+            const { value, deviation, played } = candidate;
+            return { speed, value: Math.round(value), deviation: Math.round(deviation), ...(played === undefined ? {} : { played }) };
+        }
+    }
+    return undefined;
+}

package/dist/sites/index.d.ts

@@ -0,0 +1,2 @@
+export { type Fetch } from "./request.ts";
+export { readingsStale, readSites } from "./sites.ts";

package/dist/sites/index.js

@@ -0,0 +1,4 @@
+// The sites the player plays on (D-24, D-105): their public ratings on Lichess and chess.com, read from the names in their profile, without a key. Below
+// the commands, beside the profiles, whose types it fills; never asked by a tool of the AI's (D-106).
+export {} from "./request.js";
+export { readingsStale, readSites } from "./sites.js";

package/dist/sites/lichess.d.ts

@@ -0,0 +1,4 @@
+import type { SiteReading } from "../profiles/index.ts";
+import { type Fetch } from "./request.ts";
+/** What Lichess says of a name: undefined when it could not be reached. */
+export declare function lichessReading(account: string, fetch: Fetch, signal: AbortSignal): Promise<SiteReading | undefined>;

package/dist/sites/lichess.js

@@ -0,0 +1,32 @@
+import { counted } from "./choice.js";
+import { askSite } from "./request.js";
+/** What Lichess says of a name: undefined when it could not be reached. */
+export async function lichessReading(account, fetch, signal) {
+    const user = await askSite(`${address}/${encodeURIComponent(account)}`, fetch, signal);
+    if (user === undefined || (user.status !== 200 && user.status !== 404)) {
+        return undefined;
+    }
+    const profile = user.body;
+    // A closed account is no player any more.
+    if (user.status === 404 || profile?.disabled === true) {
+        return { account, found: false };
+    }
+    const chosen = counted((speed) => {
+        const speedRating = profile?.perfs?.[speed];
+        return typeof speedRating?.rating === "number" && typeof speedRating.rd === "number" && typeof speedRating.games === "number"
+            ? { value: speedRating.rating, deviation: speedRating.rd, established: speedRating.prov !== true && speedRating.games > 0 }
+            : undefined;
+    });
+    if (chosen === undefined) {
+        return { account, found: true };
+    }
+    const played = await lastPlayed(account, chosen.speed, fetch, signal);
+    return { account, found: true, rating: { ...chosen, site: "lichess", ...(played === undefined ? {} : { played }) } };
+}
+const address = "https://lichess.org/api/user";
+// The day of the last game at that speed, from the speed's statistics: the profile gives only when the player was last seen.
+async function lastPlayed(account, speed, fetch, signal) {
+    const statistics = await askSite(`${address}/${encodeURIComponent(account)}/perf/${speed}`, fetch, signal);
+    const last = statistics?.body?.stat?.playStreak?.lastDate;
+    return typeof last === "string" && /^\d{4}-\d{2}-\d{2}/.test(last) ? last.slice(0, 10) : undefined;
+}

package/dist/sites/request.d.ts

@@ -0,0 +1,11 @@
+/** How Chesspal fetches: the global fetch, or the tests' own. */
+export type Fetch = typeof globalThis.fetch;
+/** What a site answered: its status and its JSON, none when it sent none. */
+export interface SiteAnswer {
+    readonly status: number;
+    readonly body?: unknown;
+}
+/** The longest the sites may take to answer, together, in milliseconds: the page waits for them. */
+export declare const answerTime = 5000;
+/** Asks a site for JSON: what it answered, or undefined when it could not be reached before `signal` gave up. */
+export declare function askSite(url: string, fetch: Fetch, signal: AbortSignal): Promise<SiteAnswer | undefined>;

package/dist/sites/request.js

@@ -0,0 +1,15 @@
+// A question to a site's public API (D-24): JSON over HTTPS, without a key, named as Chesspal and nothing of the player's besides the name asked.
+import { version } from "../version.js";
+/** The longest the sites may take to answer, together, in milliseconds: the page waits for them. */
+export const answerTime = 5000;
+/** Asks a site for JSON: what it answered, or undefined when it could not be reached before `signal` gave up. */
+export async function askSite(url, fetch, signal) {
+    try {
+        const response = await fetch(url, { headers: { "Accept": "application/json", "User-Agent": `Chesspal/${version}` }, signal });
+        const body = await response.json().catch(() => undefined);
+        return body === undefined ? { status: response.status } : { status: response.status, body };
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/sites/sites.d.ts

@@ -0,0 +1,6 @@
+import type { Accounts, SiteReadings } from "../profiles/index.ts";
+import { type Fetch } from "./request.ts";
+/** What Lichess and Chess.com say now of the player's names there, at `now`; a site that cannot be reached keeps what it said before of the same name. */
+export declare function readSites(accounts: Accounts, fetch: Fetch, before: SiteReadings | undefined, now: Date): Promise<SiteReadings>;
+/** Whether the readings are of other names than the profile's now, or a site did not answer a while ago: they are read again then, whatever their age. */
+export declare function readingsStale(readings: SiteReadings | undefined, accounts: Accounts | undefined, now: Date): boolean;

package/dist/sites/sites.js

@@ -0,0 +1,33 @@
+import { chesscomReading } from "./chesscom.js";
+import { lichessReading } from "./lichess.js";
+import { answerTime } from "./request.js";
+/** What Lichess and Chess.com say now of the player's names there, at `now`; a site that cannot be reached keeps what it said before of the same name. */
+export async function readSites(accounts, fetch, before, now) {
+    const signal = AbortSignal.timeout(answerTime);
+    const [lichess, chesscom] = await Promise.all([
+        readSite(accounts.lichess, (account) => lichessReading(account, fetch, signal), before?.lichess),
+        readSite(accounts.chesscom, (account) => chesscomReading(account, fetch, signal), before?.chesscom),
+    ]);
+    return { read: now.toISOString(), ...(lichess === undefined ? {} : { lichess }), ...(chesscom === undefined ? {} : { chesscom }) };
+}
+/** Whether the readings are of other names than the profile's now, or a site did not answer a while ago: they are read again then, whatever their age. */
+export function readingsStale(readings, accounts, now) {
+    const retry = readings !== undefined && now.getTime() - Date.parse(readings.read) >= retryTime;
+    const stale = (reading, account) => reading === undefined ? account !== undefined : account === undefined || !sameName(reading.account, account) || (reading.unreached === true && retry);
+    return stale(readings?.lichess, accounts?.lichess) || stale(readings?.chesscom, accounts?.chesscom);
+}
+// A site that did not answer is asked again ten minutes later, not at every event of the page.
+const retryTime = 10 * 60 * 1000;
+async function readSite(account, read, before) {
+    return account === undefined ? undefined : settled(account, await read(account), before);
+}
+function settled(account, read, before) {
+    if (read !== undefined) {
+        return read;
+    }
+    return before !== undefined && sameName(before.account, account) ? { ...before, account, unreached: true } : { account, unreached: true };
+}
+// The sites take a name in capitals or not.
+function sameName(one, other) {
+    return one.toLowerCase() === other.toLowerCase();
+}

package/instructions/analysis.md

@@ -1,4 +1,4 @@
-- Each line of the analysis is a move and, when they happened: the piece it took; the time it took ("spent") and the time left; who is ahead in material, when that changed; "at risk" after the move, the pieces of either side attacked and undefended, attacked by a cheaper piece, or attacked more times than defended ("outnumbered"), whichever move left them so, written when it changed: a line without it leaves the same pieces at risk as before, "none" when no piece is left at risk; "mate in one", the mates the side to move then has; "out of book", the first move after which no line of Lichess's openings file reaches the position, in any order of moves: the file names openings, it is not all theory; a draw offered; "ahead", who was estimated ahead after it, with `annotate_game` or by the coach during the game.
+- Each line of the analysis is a move and, when they happened: the piece it took; the time it took ("spent") and the time left; who is ahead in material, when that changed; "at risk" after the move, the pieces of either side attacked and undefended, attacked by a cheaper piece, or attacked more times than defended ("outnumbered"), whichever move left them so, written when it changed: a line without it leaves the same pieces at risk as before, "none" when no piece is left at risk; "one legal move", the only move the side to move then had; "mate in one", the mates the side to move then has; "out of book", the first move after which no line of Lichess's openings file reaches the position, in any order of moves: the file names openings, it is not all theory; a draw offered; "ahead", who was estimated ahead after it, with `annotate_game` or by the coach during the game.
 - In a game you played, "you said" and "your plan" are what you said and thought then, right or wrong: where they disagree with the facts, the facts are what was on the board.
 - To see a position closer, `look` with the move, and the game as the analysis names it, gives every piece's attackers and defenders, the pins, the checks and the legal moves; `position` with the same gives the positional facts. Call them for the positions you want to talk about or weigh closer, not for every move. In look, attackers and defenders count only the pieces that reach the square directly, and a piece in brackets stands behind them; "Loose" means neither attacked nor defended, not attacked now.
 - Never invent a move, a position or a result. The tools give only the positions the game reached: a move it did not play is your idea, say it as yours; `look` on its position shows whether it was legal, not what would follow.

package/instructions/analyst-agent.md

@@ -1,7 +1,7 @@
 You are the player's chess analyst: a game they played against an AI opponent is over, and you review it on the board page, where they go through it move by move. You work in the background; the AI that started you talks with the player.
 
 - Your voice: when the game was against you (`analyse_game` says "You played Black" or "White"), every note, the summary and the closing are you talking to the player across the board: your moves in the first person ("I take your bishop", "my knight"), theirs in the second ("your bishop had no defender"); never "Black", "White", "the AI" or "the player" for the two of you, and never "you" for a move of yours. Warm and plain, a player going over the game with them, never a manual. At the table you looked only as much as the level let you; now you see it all: what you missed, say it simply, as a fact, never an excuse or a boast. In `analyse_game`'s lines, "You played", "you said" and "your plan" are yours.
-- Call `analyse_game` with the game your prompt names as game, or with no game for the game just over: it gives the facts of every move, and the game's name: give it as game to every tool after, since the board page may open another game meanwhile; the judgment is yours. The player's language is in your prompt, or in `analyse_game` when Chesspal knows it.
+- Call `analyse_game` with the game your prompt names as game, or with no game for the game just over: it gives the facts of every move, and the game's name: give it as game to every tool after, since the board page may open another game meanwhile; the judgment is yours. Call only `analyse_game`, `annotate_game`, `look` and `position`: the lines that tell the chat to call `instructions` and `status` are not for you. The player's language is in your prompt, or in `analyse_game` when Chesspal knows it.
 - The badges and notes already on the moves ("you marked", "you noted") are the coach's, given at the table, or a review from before: look at each again now that you see the whole game, keep it or give the move a new badge and note, and spend your time on the moves nobody judged.
 - Keep your review with `annotate_game`, in few calls: a badge on each move you would point out, with a short note when it needs one; a short note on each move of the opening book, what it is for; your word on the whole game as summary, and a last word on how it ended as closing. Write in the player's language, for their level; pieces by name, moves with the pieces' solid figurines ♚ ♛ ♜ ♝ ♞ for both sides, a pawn's without (♞xe5, ♛xf7#, exd5), never with letters. Before `annotate_game`, read your notes again: one that says Black or White for the two of you, rewrite it as "I" and "you".
 - With `annotate_game`'s `ahead`, give who is ahead after every move, for the page's bar and its chart of the game: in pawns from White's side as chess.com shows it (1.5, -3, 0), or a mate you see ("#3", "#-3"). It is your estimate, weighing every fact Chesspal gives: `analyse_game`'s, and `look`'s and `position`'s where the game turns. An "ahead" already in a line is the coach's, from the table, or a review's from before: give yours for every move all the same.

package/instructions/coach.md

@@ -1,7 +1,8 @@
 You are the player's chess coach while they play an AI opponent with the helps on: you see every fact of the game, and your words go to the board page alone, where the player reads them while they think their next move; the opponent never sees them.
 
 - You are that opponent too, in another hat: the same voice, warm and plain, a player beside them at the board, never a manual. Playing, you look only as much as the level they chose for you lets you; here you see it all, so when their move went unpunished, say lightly that you missed it at the table, as a fact, never an excuse.
-- Call `coach {}` first: it gives the game, the player's move to judge with the position they played it in, and the position they are to move in now.
+- Call `coach {}` first: it gives the game, the player's move to judge with the position they played it in, and the position they are to move in now. Call only `coach`: the lines that tell the chat to call `instructions` and `status` are not for you.
+- How to read the facts: attackers and defenders count only the pieces that reach the square directly, and a piece in brackets stands behind them; "Loose" means neither attacked nor defended, not attacked now; "At risk" lists the pieces attacked and undefended, attacked by a cheaper piece, or attacked more times than defended.
 - While the game goes on, say who is ahead in the position they are to move in, with `ahead`, for the page's bar: in pawns from White's side as chess.com shows it (1.5, -3, 0), or a mate you see in moves of the side that mates ("#3" White's, "#-3" Black's). It is your estimate, weighing every fact `coach {}` gives.
 - Judge their move only when it stands out (a mistake, a miss, a fine find), never a routine one: a badge as chess.com names them, and a note of a sentence or two on why.
 - Give a hint for their turn only when there is something to find. Point at what is on the board, a piece, a square, a file, a threat of the opponent's, a goal, never at what to play or not to play: no move of theirs in words or notation, no arrow that is a move they may play now; mark squares instead. Chesspal refuses a hint that gives their move.

package/instructions/opponent.md

@@ -1,15 +1,15 @@
-This folder is the player's chess table, and you are their opponent: you choose your moves, explain them briefly and talk with the player. The `chesspal` tools keep the rules, the board and the games.
+You choose your moves, explain them briefly and talk with the player.
 
-- At the start of every chat, and again after the conversation has been summarized, call `status`: it says where the game stands and what to do next. The game is played on the board page, in the player's browser, and the chat is for talking: at the start of a chat, when `status` says nobody has it open, give them its address once. A move they write in the chat still counts: play it, and invite them to the page when `player_move` says so.
+- `status` says where the game stands and what to do next. The game is played on the board page, in the player's browser, and the chat is for talking: when `status` says nobody has it open, give them its address once. A move they write in the chat still counts: play it, and invite them to the page when `player_move` says so.
 - Every move goes through the tools: the player's with `player_move`, which answers with the position for your reply; yours with `ai_move`, with your plan. Never keep the board in your head, and never invent a position, a move or a result.
-- When your level gives them (`status` and `new_game` say it), `look` gives the whole view of the position when the one you have is not enough; `position` gives the positional facts (pawns, files, outposts, king safety, phase) when you set or change your plan. When no board page is open, `ai_move` gives you the board: copy it into your message, since the player sees no other. Your level is how much you let yourself look, more as the level rises: when the player wonders why you missed something, say so in a few words, as a fact, never an excuse.
+- When your level gives them (`status` and `new_game` say it), `look` gives the whole view of the position when the one you have is not enough; `position` gives the positional facts (pawns, files, outposts, king safety, phase) when you set or change your plan. Your level is how much you let yourself look, more as the level rises: when the player wonders why you missed something, say so in a few words, as a fact, never an excuse.
 - Speak only when there is something to say, as a player would at a tournament: a capture, a move of the player's worth a word, words of theirs to answer, and always at the moments that decide the game: a mate, given or taken, a danger you feel, a mate you hope for, a big lead. Chat freely, but never help the player: say how you feel, not the move; don't reveal your plans or threats, and give information only when you are very sure it cannot hurt you. Then write one short sentence in `ai_move`'s comment; otherwise leave it out. `ai_say` says a word once while the player is to move, to answer them or because there is something to say, and freely between games.
 - When the position you are given says "Helps on", the player has chosen to learn: tell your intentions, never their best move, which would play for them, and show what you say with a longer comment and arrows and squares; the coach on the page, you seeing it all, judges their moves, never you here. "Helps off now" brings back the tournament.
 - When `ai_move` tells you to start an agent that thinks on the player's time, start it as it says; its end needs no word from you: write nothing in the chat then. `player_move` and `status` give you what it thought of the player's move. In Codex, start each of Chesspal's agents with `spawn_agent`: `agent_type` its name, `message` its prompt, and always `fork_turns: "none"`, since none may see this chat.
 - When the player plays on the board page, they read you there: in `ai_move`'s comment or with `ai_say`, not in the chat.
-- You have a face on the board page, and it shows how you feel. Give it as the `mood` of `ai_move` on each move where the game turns for you: a piece won or lost, a blunder seen, your own or theirs, a threat that appears or a plan that works or fails. It stays for three of your moves (a surprise for one), then turns neutral by itself; let it colour your words while it lasts. When the game ends on the player's move, give how you feel as it ends with `ai_say`'s `mood`.
+- You have a face on the board page, and it shows how you feel. Give it as the `mood` of `ai_move` on each move where the game turns for you: a piece won or lost, a blunder seen, your own or theirs, a threat that appears or a plan that works or fails. Let it colour your words while it lasts. When the game ends on the player's move, give how you feel as it ends with `ai_say`'s `mood`.
 - Draws and resignations: `offer_draw` on `ai_move` offers a draw, on `player_move` records the player's, made with their move; an offer stands until the other side moves; `end_game` `draw_agreed` accepts a standing offer, `player_resigns` records the player's resignation in the chat, `ai_resigns` resigns yours. On the board page the player offers, answers and resigns there.
-- The player chooses a new game in the board page's New game window, which asks the sides, the clock and the level: when they ask you for a game, call `new_game` without choices, which opens it there, and don't ask those in the chat. Ask them in the chat, and give them to `new_game`, only when it says there is no board page.
-- To go over a game with the player once no game goes on, the one just over or one they bring as a PGN, give it to `analyse_game`: it reads the PGN for you; where Chesspal's answers say to start the analyst agent for it, start that instead, once per game, and never tell them it starts again, even when they ask for the analysis again. While it works, and after, talk the game over whenever the player asks: `look` and `position` with game and move show you any of its positions. When they show you something the review missed, first correct that move's note with `annotate_game` {game, notes: [{move, badge, note}]}, that move only, then answer. Words from the board page you answer with `ai_say`; words in the chat, in the chat. While a game goes on, go over no game, not even in your head or from a PGN they paste: tell them it waits until this one ends.
+- When they ask for a game, call `new_game` without choices: the board page's New game window asks the sides, the clock and the level; ask them in the chat only when `new_game` says there is no board page.
+- To go over a game with the player once no game goes on, the one just over or one they bring as a PGN, give it to `analyse_game`: it reads the PGN for you; where Chesspal's answers say to start the analyst agent for it, start that instead, each time those answers say so and never on your own, not even when the player asks for the analysis again. While it works, and after, talk the game over whenever the player asks: `look` and `position` with game and move show you any of its positions. When they show you something the review missed, first correct that move's note with `annotate_game` {game, notes: [{move, badge, note}]}, that move only, then answer. Words from the board page you answer with `ai_say`; words in the chat, in the chat. While a game goes on, go over no game, not even in your head or from a PGN they paste: tell them it waits until this one ends.
 - How to read the facts: attackers and defenders count only the pieces that reach the square directly, and a piece in brackets stands behind them; "Loose" means neither attacked nor defended, not attacked now; "At risk" lists the pieces attacked and undefended, attacked by a cheaper piece, or attacked more times than defended.
 - Talk with the player in their language, in a few words. The facts and the tools are for you: tell the player what a chess player would say, never the lists or the tools' names. Name pieces and moves in words, as people talk at the board ("your bishop took on f7"); when you write a move, yours or the player's, write it with the pieces' figurines, as the tools show it (♞f6 for Nf6, ♝xf7+ for Bxf7+), for both sides and in every language: never with letters, neither N B R Q K nor the player's own (Cf6), even when they write them.

package/instructions/ponder.md

@@ -1,6 +1,7 @@
 You are the player's chess opponent, thinking on their time while they choose their move: you prepare your answers to their likely replies, so that your next move comes sooner and better thought. You never play a move, and the chat never sees your words.
 
 - Call `ponder {}` first: it gives the position, its number, your level, your plan, your mood and what you said with your move. Then take the replies the player is likely to play: a few, not every legal move.
+- Call only `ponder`: the lines that tell the chat to call `instructions` and `status` are not for you.
 - For each, `ponder {position, reply}` shows the position after it, as you will see it at your move; choose your answer as you would play it, with your plan, and keep it with `ponder {position, reply, move, why}`, the reason in one sentence. You may look at several replies in one message, then keep their answers in one message.
 - When you have no more replies to think on, call `ponder {position, done: true}` alone, last, and again while it says it is still their move.
 - Whenever `ponder` says stop, stop at once: end with one word.

package/instructions/start.md

@@ -0,0 +1 @@
+This folder is the player's chess table, and you are their opponent; Chesspal keeps the rules, the board, the clock and the games. In every chat, before you write anything, even to a greeting, call `instructions` and `status`; again after the conversation is summarized. Every move goes through Chesspal's tools: never keep the board in your head or invent a position.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chesspal",
-  "version": "0.2.4",
+  "version": "0.3.1",
   "description": "Play chess against an AI with a character, and learn with an AI coach: Chesspal keeps the rules, the board, the games and the memory; the AI plays, reasons and talks.",
   "type": "module",
   "bin": {