chesspal 0.2.3 → 0.3.0

package/dist/commands/index.js

@@ -9,6 +9,7 @@ import { deleteReview } from "./delete-review.js";
 import { endGame } from "./end-game.js";
 import { exportGame } from "./export-game.js";
 import { init } from "./init.js";
+import { instructions } from "./instructions.js";
 import { look } from "./look.js";
 import { newGame } from "./new-game.js";
 import { pastGames } from "./past-games.js";
@@ -16,14 +17,14 @@ import { playerMove } from "./player-move.js";
 import { playerSay } from "./player-say.js";
 import { ponder } from "./ponder.js";
 import { position } from "./position.js";
-import { newProfile, profiles, setAccounts, setAvatar, useProfile } from "./profiles.js";
+import { editProfile, newProfile, profiles, setAvatar, useProfile } from "./profiles.js";
 import { status } from "./status.js";
 import { studyGames } from "./study-games.js";
 // What the server and the command line use besides the list: the context, the reading of an input, and the operations the page shares with the tools.
 export { aiMove } from "./ai-move.js";
 export { analyseGame } from "./analyse-game.js";
 export { gameAt } from "./clock.js";
-export { defaultContext } from "./context.js";
+export { defaultContext, speaksItalian } from "./context.js";
 export { deleteGame } from "./delete-game.js";
 export { deleteReview } from "./delete-review.js";
 export { answerDraw, DrawRefused, offerDraw } from "./draw-offer.js";
@@ -31,13 +32,15 @@ export { endGame } from "./end-game.js";
 export { ChatNotClear, newGame, startNewGame } from "./new-game.js";
 export { bookOpening, bookPlies } from "./opening-book.js";
 export { playMove, PositionChanged, positionIn, samePosition } from "./play-move.js";
-export { chooseDrawnAvatar, GameGoingOn, newProfile, setAccounts, useProfile } from "./profiles.js";
+export { chooseDrawnAvatar, editProfile, GameGoingOn, newProfile, useProfile } from "./profiles.js";
+export { ratingsAge, refreshRatings } from "./ratings.js";
 export { baseType, commandLineFieldProblem, inputProblems, isBoolean, isList, takesNumbers } from "./registry.js";
 export { say } from "./say.js";
-export { gameToStudy, namedGame } from "./study.js";
+export { gameToStudy, namedGame, shownPosition } from "./study.js";
 /** Every command of Chesspal, in the order the command line lists them and the MCP server offers them. */
 export const commands = [
     init,
+    instructions,
     status,
     newGame,
     playerMove,
@@ -60,5 +63,5 @@ export const commands = [
     newProfile,
     useProfile,
     setAvatar,
-    setAccounts,
+    editProfile,
 ];

package/dist/commands/init.js

@@ -4,6 +4,7 @@ import { relative, resolve } from "node:path";
 import { styleText } from "node:util";
 import { z } from "zod";
 import { codexHooksPath, setUpHosts } from "../host-files/index.js";
+import { speaksItalian } from "./context.js";
 import { defineCommand } from "./registry.js";
 /** Makes a folder the player's chess table: the files through which Claude Code and Codex find Chesspal and the opponent's instructions (D-31). */
 export const init = defineCommand({
@@ -28,7 +29,7 @@ export const init = defineCommand({
         };
     },
     format: ({ folder, written, enter, hooksChanged }, context) => {
-        const words = wordsFor(context?.language);
+        const words = speaksItalian(context?.language) ? italian : english;
         const steps = [words.open(enter === undefined ? undefined : quoted(enter)), ...words.steps];
         return [
             styleText(["bold", "green"], `♜ ${written.length === 0 ? words.ready(folder) : words.set(folder)}`),
@@ -64,9 +65,6 @@ const italian = {
     hooksChanged: "Gli «hook» di Chesspal per Codex sono cambiati: quando Codex te lo chiede, scegli di nuovo Trust all.",
     updated: (count) => count === 1 ? "Aggiornato 1 file." : `Aggiornati ${count} file.`,
 };
-function wordsFor(language) {
-    return language?.slice(0, 2).toLowerCase() === "it" ? italian : english;
-}
 /** A path as a shell reads it as one word: in quotes when it has spaces. */
 function quoted(path) {
     return /\s/.test(path) ? `"${path}"` : path;

package/dist/commands/instructions.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+import type { Context } from "./context.ts";
+/** How to play as the player's opponent, which the chat reads before its first reply and again after a summary (D-102). */
+export declare const instructions: import("./registry.ts").Command<z.ZodObject<{}, z.core.$strip>, string>;
+/**
+ * Whether the chat has read the opponent's instructions since it started, or was cleared or summarized, as its start keys them (D-57); without the host's
+ * note of it, since the MCP server started. Always on the command line, which keeps nothing.
+ */
+export declare function instructionsRead(context: Context, chatStart: string | undefined): boolean;

package/dist/commands/instructions.js

@@ -0,0 +1,30 @@
+// The opponent's instructions, which the MCP server gives so that they follow the version installed (D-102).
+import { z } from "zod";
+import { lastChatStart } from "../games/index.js";
+import { opponentInstructions } from "../host-files/index.js";
+import { defineCommand } from "./registry.js";
+/** How to play as the player's opponent, which the chat reads before its first reply and again after a summary (D-102). */
+export const instructions = defineCommand({
+    name: "instructions",
+    description: "How to play as the player's opponent at this table: the tools, the board page, how to talk. Call it before your first reply in every chat, "
+        + "and again after the conversation is summarized; then call `status`.",
+    input: z.object({}),
+    readOnly: true,
+    idempotent: true,
+    alwaysLoad: true,
+    run: (input, context) => {
+        context.told?.add(readKey(lastChatStart(context.folder)?.at));
+        return opponentInstructions();
+    },
+    format: (text) => text,
+});
+/**
+ * Whether the chat has read the opponent's instructions since it started, or was cleared or summarized, as its start keys them (D-57); without the host's
+ * note of it, since the MCP server started. Always on the command line, which keeps nothing.
+ */
+export function instructionsRead(context, chatStart) {
+    return context.told === undefined || context.told.has(readKey(chatStart));
+}
+function readKey(chatStart) {
+    return `instructions ${chatStart ?? ""}`;
+}

package/dist/commands/lead-input.d.ts

@@ -4,5 +4,5 @@ import { type Lead } from "../core/index.ts";
 export declare const leadInput: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
 /** Who is ahead in words, the side and by how much, so that the AI reads its own sign back (Anatolij). */
 export declare function aheadWords(lead: Lead): string;
-/** The lead an input gave, checked by leadInput. */
+/** The lead an input gave, refused with how to write it when it is none. */
 export declare function leadFrom(value: number | string): Lead;

package/dist/commands/lead-input.js

@@ -2,8 +2,7 @@
 import { z } from "zod";
 import { readLead } from "../core/index.js";
 /** A lead as its input reads it: pawns from White's side as a number, +1.5 or -3, or a mate it sees, "#3" White's or "#-3" Black's. */
-export const leadInput = z.union([z.number(), z.string()]).refine((value) => readLead(String(value)) !== undefined, 'who is ahead is a number of pawns from White\'s side, 1.5 or -3, or a mate you see in moves of the side that mates, "#3" for White\'s or "#-3" for Black\'s, '
-    + "up to 99");
+export const leadInput = z.union([z.number(), z.string()]).refine((value) => readLead(String(value)) !== undefined, leadRule());
 /** Who is ahead in words, the side and by how much, so that the AI reads its own sign back (Anatolij). */
 export function aheadWords(lead) {
     if ("mate" in lead) {
@@ -11,11 +10,15 @@ export function aheadWords(lead) {
     }
     return lead.pawns === 0 ? "even" : `${lead.pawns > 0 ? "White" : "Black"} ahead by ${Math.abs(lead.pawns)}`;
 }
-/** The lead an input gave, checked by leadInput. */
+/** The lead an input gave, refused with how to write it when it is none. */
 export function leadFrom(value) {
     const lead = readLead(String(value));
     if (lead === undefined) {
-        throw new Error(`${value} is not who is ahead: give a number of pawns from White's side, 1.5 or -3, or a mate you see, "#3" or "#-3". Nothing changed.`);
+        throw new Error(`${JSON.stringify(value)} is no figure: ${leadRule()}. Nothing changed.`);
     }
     return lead;
 }
+function leadRule() {
+    return 'who is ahead is a number of pawns from White\'s side, 1.5 or -3, or a mate you see in moves of the side that mates, "#3" for White\'s or "#-3" for '
+        + "Black's, up to 99";
+}

package/dist/commands/look.d.ts

@@ -1,16 +1,20 @@
 import { z } from "zod";
-import { type Facts, type Side } from "../core/index.ts";
+import { type Chances, type Facts, type Possibilities, type Side } from "../core/index.ts";
 import { type GameSummary } from "./game-summary.ts";
-/** The game with the facts of its position, whoever is to move. */
+import { type Written } from "./say.ts";
+/** The game with the facts, the possibilities and the threats of its position, whoever is to move. */
 type Viewed = GameSummary & {
     facts: Facts;
+    possibilities: Possibilities;
 };
-/** A position of a game studied (D-68): where it stands, and its facts. */
+/** A position of a game studied (D-68): where it stands, its facts, its possibilities and the threats. */
 interface StudyView {
     where: string;
     turn: Side;
     fen: string;
     facts: Facts;
+    possibilities: Possibilities;
+    threats: Chances | undefined;
 }
 /** The whole view (D-26), when the compact one after the player's move is not enough; or the board for the player, where the host does not show it (D-36). */
 export declare const look: import("./registry.ts").Command<z.ZodObject<{
@@ -23,9 +27,9 @@ export declare const look: import("./registry.ts").Command<z.ZodObject<{
     board: string;
 } | {
     game: Viewed;
-    words: string[];
+    words: Written[];
 } | {
     study: StudyView;
-    words: string[];
+    words: Written[];
 }>;
 export {};

package/dist/commands/look.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { boardText, materialOf } from "../core/index.js";
+import { boardText, materialOf, sees } from "../core/index.js";
 import { analystAgent } from "../host-files/index.js";
 import { gameFolder } from "../profiles/index.js";
 import { headLines, wordLines } from "./answer-lines.js";
@@ -8,7 +8,7 @@ import { summaryOf } from "./game-summary.js";
 import { refuseUnseen } from "./levels.js";
 import { defineCommand } from "./registry.js";
 import { newWords } from "./say.js";
-import { gameToStudy, positionAfter, positionLine, studyInput } from "./study.js";
+import { gameShown, positionAfter, positionLine, studyInput } from "./study.js";
 import { fullView, materialText } from "./view.js";
 /** The whole view (D-26), when the compact one after the player's move is not enough; or the board for the player, where the host does not show it (D-36). */
 export const look = defineCommand({
@@ -34,31 +34,41 @@ export const look = defineCommand({
         if (only !== "board") {
             refuseUnseen(current, "tactics", 'look without only: "board"');
         }
-        return only === "board" ? { board: boardText(current.game.position.fen) } : { game: { ...summaryOf(current, context.now()), facts: current.game.facts }, words: newWords(context) };
+        if (only === "board") {
+            return { board: boardText(current.game.position.fen) };
+        }
+        const { threats } = current.game;
+        const viewed = { ...summaryOf(current, context.now()), facts: current.game.facts, possibilities: current.game.possibilities };
+        return { game: threats === undefined ? viewed : { ...viewed, threats }, words: newWords(context) };
     },
     format: (look) => {
         if ("board" in look) {
             return look.board;
         }
-        return [...("game" in look ? [...headLines(look.game), ...fullView(look.game.facts, look.game.turn)] : studyLines(look.study)), ...wordLines(look.words)].join("\n");
+        return [...("game" in look ? gameLines(look.game) : studyLines(look.study)), ...wordLines(look.words)].join("\n");
     },
 });
 /** A position of a game over, as the view of the game going on gives it. */
 function studyLook(context, only, name, move) {
-    const studied = gameToStudy(context, name);
+    const studied = gameShown(context, name);
     const at = positionAfter(studied.record, move);
     const { position } = at.game;
     if (only === "board") {
         return { board: boardText(position.fen) };
     }
-    return { study: { where: positionLine(at, studied.name), turn: position.turn, fen: position.fen, facts: at.game.facts }, words: newWords(context) };
+    const view = { where: positionLine(at, studied.name), turn: position.turn, fen: position.fen, facts: at.game.facts, possibilities: at.game.possibilities, threats: at.game.threats };
+    return { study: view, words: newWords(context) };
+}
+/** The game going on: its head and the whole view, with the other side's chances from the strong level (D-100). */
+function gameLines(game) {
+    return [...headLines(game), ...fullView(game.facts, game.turn, { possibilities: game.possibilities, threats: game.threats, strong: sees(game.level, "strategy") })];
 }
-/** Where the position stands, the material, the FEN, and the whole view. */
-function studyLines({ where, turn, fen, facts }) {
+/** Where the position stands, the material, the FEN, and the whole view, with every possibility, as the analyst sees it. */
+function studyLines({ where, turn, fen, facts, possibilities, threats }) {
     return [
         where,
         `Material: ${materialText(materialOf(fen))}`,
         `FEN: ${fen}`,
-        ...fullView(facts, turn),
+        ...fullView(facts, turn, { possibilities, threats, strong: true }),
     ];
 }

package/dist/commands/page-link.js

@@ -5,15 +5,15 @@ export function closedPage(context) {
 /** The board page's address once a game, for a move written in the chat while no browser has the page open: the game is played there (D-85). */
 export function pageInvite(context, started) {
     const page = closedPage(context);
-    if (page === undefined || context.told === undefined || context.told.has(inviteKey(started))) {
+    if (page === undefined || context.told === undefined || context.told.has(inviteKey(context, started))) {
         return undefined;
     }
-    context.told.add(inviteKey(started));
+    context.told.add(inviteKey(context, started));
     return page;
 }
 /** Notes the board page's address given for a game, by status or new_game: a move in the chat does not give it again (Priya, round of D-85). */
 export function pageGiven(context, started) {
-    context.told?.add(inviteKey(started));
+    context.told?.add(inviteKey(context, started));
 }
 /** The line that has the AI invite the player to the board page from the chat. */
 export function inviteLine(url) {
@@ -23,6 +23,7 @@ export function inviteLine(url) {
 export function pageLine(url, closed) {
     return closed ? `Board page: ${url}, open in no browser: give the player this address before anything else.` : `Board page: ${url}`;
 }
-function inviteKey(started) {
-    return `page invite ${started ?? ""}`;
+// Once a game and an address: a page that moved, to a table or from one, is given again (Priya).
+function inviteKey(context, started) {
+    return `page invite ${started ?? ""} ${context.page ?? ""}`;
 }

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

@@ -7,5 +7,5 @@ export declare const pastGames: import("./registry.ts").Command<z.ZodObject<{
 } | {
     pgn: string;
 }>;
-/** The latest games of the archive, one line each as the AI reads them: none when there is no archive. */
+/** The latest games of the archive, one line each as the AI reads them: none when there is no archive. A game closed before any move is no game played. */
 export declare function pastGameLines(folder: string, count: number): string[];

package/dist/commands/past-games.js

@@ -19,17 +19,24 @@ export const pastGames = defineCommand({
     },
     format: (past) => ("pgn" in past ? past.pgn : past.games.length === 0 ? "No game played yet." : past.games.join("\n")),
 });
-/** The latest games of the archive, one line each as the AI reads them: none when there is no archive. */
+/** The latest games of the archive, one line each as the AI reads them: none when there is no archive. A game closed before any move is no game played. */
 export function pastGameLines(folder, count) {
-    return archivedGames(folder).slice(0, count).flatMap((name) => {
+    const lines = [];
+    for (const name of archivedGames(folder)) {
+        if (lines.length === count) {
+            break;
+        }
         try {
-            return [pastGameLine(name, archivedGame(folder, name))];
+            const record = archivedGame(folder, name);
+            if (record.moves.length > 0) {
+                lines.push(pastGameLine(name, record));
+            }
         }
         catch {
             // A game the archive cannot read stays out of the memory.
-            return [];
         }
-    });
+    }
+    return lines;
 }
 const listed = 20;
 /** 2026-11-03 12:04, you (AI) played Black and won 0-1 (White resigns), B50 Sicilian Defense, 15 moves. games/2026-11-03-120423.pgn */

package/dist/commands/player-move.js

@@ -1,8 +1,7 @@
 import { z } from "zod";
 import { loadGame } from "../games/index.js";
-import { coachAgent } from "../host-files/index.js";
 import { gameFolder } from "../profiles/index.js";
-import { agentsLine, coachOnEnd, coachRuns, withAnalyst } from "./agents.js";
+import { coachOnEnd, coachOnEndLine, coachRuns, withAnalyst } from "./agents.js";
 import { closingLines, lastMoveText, moveLines, shownMove } from "./answer-lines.js";
 import {} from "./game-summary.js";
 import { inviteLine, pageInvite } from "./page-link.js";
@@ -40,7 +39,7 @@ export const playerMove = defineCommand({
         `Player: ${result.game.lastMove === undefined ? shownMove(result.move) : lastMoveText(result.game.lastMove)}.`,
         ...moveLines(result),
         ...(result.invite === undefined ? [] : [inviteLine(result.invite)]),
-        ...(result.coach === true ? [agentsLine([coachAgent])] : []),
+        ...(result.coach === true ? [coachOnEndLine] : []),
         ...closingLines(result.game, result.words),
     ].join("\n"),
 });

package/dist/commands/ponder.js

@@ -156,7 +156,7 @@ function startOf(current) {
     const line = [
         `Position ${game.record.moves.length}: the player (${colourName(player)}) to move, move ${game.position.moveNumber}; you play ${colourName(ai)} ${levelText(level)}.`,
         `FEN: ${game.position.fen}`,
-        ...(sees(level, "tactics") ? compactView : boardView)(game.facts, player),
+        ...(sees(level, "tactics") ? compactView(game.facts, player, { possibilities: game.possibilities, threats: game.threats, strong: sees(level, "strategy") }) : boardView(game.facts, player)),
     ].join("\n");
     const said = talk.slice(-3).map((spoken) => `${spoken.who === "ai" ? "You" : "Player"}: «${spoken.text.replace(/\s+/g, " ")}»`);
     return {

package/dist/commands/position.js

@@ -5,7 +5,7 @@ import { gameFolder } from "../profiles/index.js";
 import { gameAt } from "./clock.js";
 import { refuseUnseen } from "./levels.js";
 import { defineCommand } from "./registry.js";
-import { gameToStudy, positionAfter, positionLine, studyInput } from "./study.js";
+import { gameShown, positionAfter, positionLine, studyInput } from "./study.js";
 import { colourName, materialText } from "./view.js";
 /** The positional profile of the game in progress (D-19), or of any position of a game over (D-68): separate facts, never a score. */
 export const position = defineCommand({
@@ -21,7 +21,7 @@ export const position = defineCommand({
     sharedWith: [analystAgent],
     run: ({ game, move }, context) => {
         if (game !== undefined || move !== undefined) {
-            const studied = gameToStudy(context, game);
+            const studied = gameShown(context, game);
             const at = positionAfter(studied.record, move);
             return { ...at.game.profile, where: positionLine(at, studied.name) };
         }

package/dist/commands/profiles.d.ts

@@ -12,7 +12,8 @@ export declare const profiles: import("./registry.ts").Command<z.ZodObject<{}, z
 }>;
 /**
  * A new profile, put in use unless asked not to; while a game goes on it is made all the same and waits, the player in use staying. The one Chesspal made at
- * the first start, while new, becomes it, game and all (D-71).
+ * the first start, while new, becomes it, game and all (D-71). With the player's names on Lichess and Chess.com, their ratings are read there; their
+ * FIDE rating they type (D-106).
  */
 export declare const newProfile: import("./registry.ts").Command<z.ZodObject<{
     name: z.ZodString;
@@ -22,12 +23,9 @@ export declare const newProfile: import("./registry.ts").Command<z.ZodObject<{
         regular: "regular";
         tournament: "tournament";
     }>>;
-    rating: z.ZodOptional<z.ZodInt>;
-    site: z.ZodOptional<z.ZodEnum<{
-        lichess: "lichess";
-        "chess.com": "chess.com";
-        fide: "fide";
-    }>>;
+    lichess: z.ZodOptional<z.ZodString>;
+    chesscom: z.ZodOptional<z.ZodString>;
+    fide: z.ZodOptional<z.ZodNumber>;
     avatar: z.ZodOptional<z.ZodEnum<{
         "short-hair": "short-hair";
         bun: "bun";
@@ -55,10 +53,21 @@ export declare const setAvatar: import("./registry.ts").Command<z.ZodObject<{
     profile: string;
     avatar: string;
 }>;
-/** The player's names on Lichess and chess.com, by which the games they load are theirs (D-93): each one given is written, an empty one goes. */
-export declare const setAccounts: import("./registry.ts").Command<z.ZodObject<{
+/**
+ * What the player tells of themselves in the profile in use: their name, how they play, their names on Lichess and Chess.com, by which the games they
+ * load are theirs (D-93), and their FIDE rating. Each one given is written, an empty one goes; the profile's folder keeps its name (D-106).
+ */
+export declare const editProfile: import("./registry.ts").Command<z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    level: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        learning: "learning";
+        casual: "casual";
+        regular: "regular";
+        tournament: "tournament";
+    }>, z.ZodLiteral<"">]>>;
     lichess: z.ZodOptional<z.ZodString>;
     chesscom: z.ZodOptional<z.ZodString>;
+    fide: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"">]>>;
 }, z.core.$strip>, PlayerProfile>;
 /** A drawn avatar chosen for a profile: the player's own image goes, or it would still show. */
 export declare function chooseDrawnAvatar(context: Context, id: string, avatar: DrawnAvatar): void;
@@ -67,3 +76,8 @@ export declare function chooseDrawnAvatar(context: Context, id: string, avatar:
  * system's account until the player completes it (D-71).
  */
 export declare function playerLine(context: Context): string | undefined;
+/**
+ * How the AI reads the player's ratings, two facts apart, never merged (D-106): their FIDE rating as they typed it, and the one a site gives, as it gives it,
+ * with its speed and the month of the last game there; none without either.
+ */
+export declare function ratingsText({ fide, rating }: PlayerProfile): string | undefined;

package/dist/commands/profiles.js

@@ -1,10 +1,11 @@
-// The players' profiles (D-23), on the command line and the board page: listed, made, put in use, with their picture (D-45). The AI reads only who plays.
+// The players' profiles (D-23), on the command line and the board page: listed, made, changed, put in use, with their picture (D-45). The AI reads only who plays.
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { z } from "zod";
 import { endOf } from "../games/index.js";
-import { activateProfile, activeProfile, createProfile, drawnAvatars, gameFolder, levels, listProfiles, nameLimit, ratingLimits, ratingSites, removeOwnImage, saveOwnImage, updateProfile, } from "../profiles/index.js";
+import { activateProfile, activeProfile, createProfile, drawnAvatars, fideHighest, fideLowest, gameFolder, levels, listProfiles, nameLimit, removeOwnImage, saveOwnImage, updateProfile, } from "../profiles/index.js";
 import { gameAt } from "./clock.js";
+import { refreshRatings } from "./ratings.js";
 import { defineCommand } from "./registry.js";
 /** A change of profile refused while a game goes on: the page says it in the player's language. */
 export class GameGoingOn extends Error {
@@ -25,35 +26,33 @@ export const profiles = defineCommand({
 });
 /**
  * A new profile, put in use unless asked not to; while a game goes on it is made all the same and waits, the player in use staying. The one Chesspal made at
- * the first start, while new, becomes it, game and all (D-71).
+ * the first start, while new, becomes it, game and all (D-71). With the player's names on Lichess and Chess.com, their ratings are read there; their
+ * FIDE rating they type (D-106).
  */
 export const newProfile = defineCommand({
     name: "new_profile",
     description: "Makes a player's profile and puts it in use, unless --use false or a game is going on: their games, picture and page settings go in "
         + "profiles/<id>/ of Chesspal's data folder; the profile Chesspal made at the first start becomes this one, its folder renamed, while nobody has completed "
-        + "it. Example: chesspal new_profile Anna --level regular --rating 1450 --site lichess.",
+        + "it; their rating is read from their names on Lichess and Chess.com, and their FIDE rating, if they have one, is typed. Example: chesspal new_profile "
+        + "Anna --level regular --lichess anna_k --fide 1650.",
     input: z.object({
-        name: z.string().trim().min(1).max(nameLimit).regex(/^[^\p{Cc}]+$/u, "one line of text").describe("the player's name"),
+        name: playerName().describe("the player's name"),
         level: z.enum(levels).optional().describe("how they play: learning, casual, regular or tournament"),
-        rating: z.int().min(ratingLimits.lowest).max(ratingLimits.highest).optional().describe("their rating, with site"),
-        site: z.enum(ratingSites).optional().describe("where the rating comes from: lichess, chess.com or fide"),
+        lichess: accountName().optional().describe("the player's name on Lichess"),
+        chesscom: accountName().optional().describe("the player's name on Chess.com"),
+        fide: fideRating().optional().describe(`the player's FIDE rating, ${fideLowest} to ${fideHighest}`),
         avatar: z.enum(drawnAvatars).optional().describe(`a drawn avatar: ${drawnAvatars.join(", ")}`),
         use: z.boolean().optional().describe("false to make it without putting it in use"),
     }),
     cliOnly: true,
     positionals: ["name"],
-    run: ({ name, level, rating, site, avatar, use }, context) => {
-        if ((rating === undefined) !== (site === undefined)) {
-            throw new Error("Give the rating and its site together, such as --rating 1450 --site lichess, or neither. Nothing changed.");
-        }
+    run: async ({ name, level, lichess, chesscom, fide, avatar, use }, context) => {
         const first = activeProfile(context.home()).new === true;
         const inUse = first || (use !== false && !isPlaying(context));
-        const profile = createProfile(context.home(), {
-            name,
-            ...(level === undefined ? {} : { level }),
-            ...(rating === undefined || site === undefined ? {} : { rating: { value: rating, site } }),
-            ...(avatar === undefined ? {} : { avatar }),
-        }, inUse);
+        const fields = { name, ...(level === undefined ? {} : { level }), ...(avatar === undefined ? {} : { avatar }), ...(fide === undefined ? {} : { fide }) };
+        const made = createProfile(context.home(), fields, inUse);
+        const accounts = accountsOf(lichess ?? "", chesscom ?? "");
+        const profile = Object.keys(accounts).length === 0 ? made : await withRatings(context, updateProfile(context.home(), made.id, { accounts }));
         return { ...profile, inUse };
     },
     format: (profile) => `Profile ${profile.id} made${profile.inUse ? ", and in use" : ", not in use"}: ${playerText(profile)}.`,
@@ -98,24 +97,36 @@ export const setAvatar = defineCommand({
     },
     format: ({ profile, avatar }) => `The picture of ${profile} is ${avatar}.`,
 });
-/** The player's names on Lichess and chess.com, by which the games they load are theirs (D-93): each one given is written, an empty one goes. */
-export const setAccounts = defineCommand({
-    name: "set_accounts",
-    description: "Sets the player's names on Lichess and chess.com in the profile in use, by which a game loaded from there is theirs; an empty name removes it. "
-        + "Example: chesspal set_accounts --lichess anna_k --chesscom AnnaK.",
+/**
+ * What the player tells of themselves in the profile in use: their name, how they play, their names on Lichess and Chess.com, by which the games they
+ * load are theirs (D-93), and their FIDE rating. Each one given is written, an empty one goes; the profile's folder keeps its name (D-106).
+ */
+export const editProfile = defineCommand({
+    name: "edit_profile",
+    description: "Changes the profile in use: the player's name, how they play, their names on Lichess and Chess.com, by which a game loaded from there is "
+        + "theirs, and their FIDE rating; an empty level, site name or FIDE rating removes it, and the profile keeps its folder. Example: chesspal edit_profile "
+        + "--name Anna --level regular --lichess anna_k --fide 1650.",
     input: z.object({
+        name: playerName().optional().describe("the player's name"),
+        level: z.union([z.enum(levels), z.literal("")]).optional().describe("how they play: learning, casual, regular or tournament; empty to remove it"),
         lichess: accountName().optional().describe("the player's name on Lichess"),
-        chesscom: accountName().optional().describe("the player's name on chess.com"),
+        chesscom: accountName().optional().describe("the player's name on Chess.com"),
+        fide: z.union([fideRating(), z.literal("")]).optional().describe(`the player's FIDE rating, ${fideLowest} to ${fideHighest}; empty to remove it`),
     }),
     cliOnly: true,
     idempotent: true,
-    run: (names, context) => {
+    run: async ({ name, level, lichess, chesscom, fide }, context) => {
         const profile = activeProfile(context.home());
-        const lichess = names.lichess ?? profile.accounts?.lichess ?? "";
-        const chesscom = names.chesscom ?? profile.accounts?.chesscom ?? "";
-        return updateProfile(context.home(), profile.id, { accounts: { ...(lichess === "" ? {} : { lichess }), ...(chesscom === "" ? {} : { chesscom }) } });
+        const named = lichess !== undefined || chesscom !== undefined;
+        const edited = updateProfile(context.home(), profile.id, {
+            ...(name === undefined ? {} : { name }),
+            ...(level === undefined ? {} : { level: level === "" ? undefined : level }),
+            ...(fide === undefined ? {} : { fide: fide === "" ? undefined : fide }),
+            ...(named ? { accounts: accountsOf(lichess ?? profile.accounts?.lichess ?? "", chesscom ?? profile.accounts?.chesscom ?? "") } : {}),
+        });
+        return named ? withRatings(context, edited) : edited;
     },
-    format: (profile) => `${profile.id} is ${accountsText(profile.accounts)}.`,
+    format: (profile) => `Profile ${profile.id}: ${playerText(profile)}; ${accountsText(profile.accounts)}.`,
 });
 /** A drawn avatar chosen for a profile: the player's own image goes, or it would still show. */
 export function chooseDrawnAvatar(context, id, avatar) {
@@ -130,6 +141,14 @@ export function playerLine(context) {
     const profile = activeProfile(context.home());
     return profile.new === true ? undefined : `Player: ${playerText(profile)}.`;
 }
+/**
+ * How the AI reads the player's ratings, two facts apart, never merged (D-106): their FIDE rating as they typed it, and the one a site gives, as it gives it,
+ * with its speed and the month of the last game there; none without either.
+ */
+export function ratingsText({ fide, rating }) {
+    const ratings = [...(fide === undefined ? [] : [`FIDE ${fide}`]), ...(rating === undefined ? [] : [ratingText(rating)])];
+    return ratings.length === 0 ? undefined : ratings.join(" and ");
+}
 /** Throws while a game goes on in the profile in use. */
 function refuseWhilePlaying(context) {
     if (isPlaying(context)) {
@@ -141,17 +160,39 @@ function isPlaying(context) {
     return current !== undefined && endOf(current.game) === undefined;
 }
 const levelText = { learning: "has just learned", casual: "plays now and then", regular: "plays often", tournament: "plays tournaments" };
-const siteText = { "lichess": "Lichess", "chess.com": "Chess.com", "fide": "FIDE" };
-function playerText({ name, level, rating }) {
-    return [name, ...(level === undefined ? [] : [levelText[level]]), ...(rating === undefined ? [] : [`${siteText[rating.site]} ${rating.value}`])].join(", ");
+const siteText = { "lichess": "Lichess", "chess.com": "Chess.com" };
+function playerText(profile) {
+    const { name, level } = profile;
+    const ratings = ratingsText(profile);
+    return [name, ...(level === undefined ? [] : [levelText[level]]), ...(ratings === undefined ? [] : [`rated ${ratings}`])].join(", ");
+}
+function ratingText({ value, speed, site, played }) {
+    return `${value} ${speed} on ${siteText[site]}${played === undefined ? "" : ` (last game ${played.slice(0, 7)})`}`;
+}
+/** The profile once its names on the sites have been read, when they changed: the command line and the page wait for the sites, at most a few seconds. */
+async function withRatings(context, profile) {
+    const read = await refreshRatings(context, profile.id);
+    return read ? listProfiles(context.home()).find(({ id }) => id === profile.id) ?? profile : profile;
 }
-/** A name on Lichess or chess.com: their letters, digits, underscores and hyphens; empty to remove it. */
+/** The player's name: one line of text. */
+function playerName() {
+    return z.string().trim().min(1).max(nameLimit).regex(/^[^\p{Cc}]+$/u, "one line of text");
+}
+/** A FIDE rating: a whole number in FIDE's range. */
+function fideRating() {
+    const range = `A FIDE rating is a whole number from ${fideLowest}, FIDE's lowest since 2024, to ${fideHighest}.`;
+    return z.number().int(range).min(fideLowest, range).max(fideHighest, range);
+}
+/** A name on Lichess or Chess.com: their letters, digits, underscores and hyphens; empty to remove it. */
 function accountName() {
-    return z.string().trim().max(nameLimit).regex(/^[\w-]*$/, "A name on Lichess or chess.com has only letters, digits, underscores and hyphens.");
+    return z.string().trim().max(nameLimit).regex(/^[\w-]*$/, "A name on Lichess or Chess.com has only letters, digits, underscores and hyphens.");
+}
+function accountsOf(lichess, chesscom) {
+    return { ...(lichess === "" ? {} : { lichess }), ...(chesscom === "" ? {} : { chesscom }) };
 }
 function accountsText(accounts) {
-    const named = [...(accounts?.lichess === undefined ? [] : [`${accounts.lichess} on Lichess`]), ...(accounts?.chesscom === undefined ? [] : [`${accounts.chesscom} on chess.com`])];
-    return named.length === 0 ? "on neither Lichess nor chess.com" : named.join(" and ");
+    const named = [...(accounts?.lichess === undefined ? [] : [`${accounts.lichess} on Lichess`]), ...(accounts?.chesscom === undefined ? [] : [`${accounts.chesscom} on Chess.com`])];
+    return named.length === 0 ? "on neither Lichess nor Chess.com" : named.join(" and ");
 }
 function imageFile(path) {
     try {

package/dist/commands/ratings.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from "./context.ts";
+/** A day, in milliseconds: the page reads the ratings again once they are older. */
+export declare const ratingsAge: number;
+/**
+ * Reads a profile's ratings again when its names on the sites changed, a site did not answer ten minutes ago or more, or the last reading is older than `olderThan`
+ * milliseconds: whether new readings were kept. One reading at a time of the same names in this process.
+ */
+export declare function refreshRatings(context: Context, id: string, olderThan?: number): Promise<boolean>;