chesspal 0.2.4 → 0.3.0

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/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/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>;

package/dist/commands/ratings.js

@@ -0,0 +1,45 @@
+// The player's ratings read again from the sites (D-105, D-106): when their names there change, and when the page opens a day after the last reading;
+// never from a tool of the AI's.
+import { listProfiles, profileFolder, saveReadings } from "../profiles/index.js";
+import { readingsStale, readSites } from "../sites/index.js";
+/** A day, in milliseconds: the page reads the ratings again once they are older. */
+export const ratingsAge = 24 * 60 * 60 * 1000;
+/**
+ * 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 function refreshRatings(context, id, olderThan = Infinity) {
+    const home = context.home();
+    const profile = listProfiles(home).find((one) => one.id === id);
+    if (profile === undefined || context.fetch === undefined) {
+        return Promise.resolve(false);
+    }
+    const key = [home, id, profile.accounts?.lichess, profile.accounts?.chesscom].join("\n");
+    const going = reading.get(key);
+    if (going !== undefined) {
+        return going;
+    }
+    const read = readAgain(context, profile, context.fetch, olderThan).finally(() => reading.delete(key));
+    reading.set(key, read);
+    return read;
+}
+const reading = new Map();
+async function readAgain(context, { id, accounts, sites }, fetch, olderThan) {
+    const home = context.home();
+    const age = sites === undefined ? Infinity : context.now().getTime() - Date.parse(sites.read);
+    if (!readingsStale(sites, accounts, context.now()) && age < olderThan) {
+        return false;
+    }
+    if (accounts === undefined) {
+        saveReadings(profileFolder(home, id), undefined);
+        return true;
+    }
+    const read = await readSites(accounts, fetch, sites, context.now());
+    // The names may have changed while the sites answered: what they said of the names before is not kept, and the change reads its own.
+    const now = listProfiles(home).find((one) => one.id === id);
+    if (now?.accounts?.lichess !== accounts.lichess || now?.accounts?.chesscom !== accounts.chesscom) {
+        return false;
+    }
+    saveReadings(profileFolder(home, id), read);
+    return true;
+}

package/dist/commands/registry.d.ts

@@ -55,5 +55,5 @@ export declare function isBoolean(field: z.ZodType): boolean;
 export declare function isList(field: z.ZodType): boolean;
 /** The type of a field of a command's input, past optional, default and nullable: string, boolean, array… */
 export declare function baseType(field: z.ZodType): string;
-/** Whether a field takes numbers, alone or in a list: the command line reads them as text and turns them into numbers. */
+/** Whether a field takes numbers, alone, in a list or as one of its choices: the command line reads them as text and turns them into numbers. */
 export declare function takesNumbers(field: z.ZodType): boolean;

package/dist/commands/registry.js

@@ -37,10 +37,11 @@ export function isList(field) {
 export function baseType(field) {
     return baseDefinition(field).type;
 }
-/** Whether a field takes numbers, alone or in a list: the command line reads them as text and turns them into numbers. */
+/** Whether a field takes numbers, alone, in a list or as one of its choices: the command line reads them as text and turns them into numbers. */
 export function takesNumbers(field) {
     const definition = baseDefinition(field);
-    return definition.type === "number" || (definition.type === "array" && definition.element !== undefined && baseType(definition.element) === "number");
+    const numbers = (one) => one !== undefined && baseType(one) === "number";
+    return definition.type === "number" || (definition.type === "array" && numbers(definition.element)) || (definition.type === "union" && (definition.options ?? []).some(numbers));
 }
 function inputIssue(command, issue, given, written) {
     const path = issue.path.map(String).join(".");

package/dist/commands/say.d.ts

@@ -9,7 +9,7 @@ export declare function say(folder: string, who: Sayer, text: string, at: Date,
 /** Words of the player's as the AI is given them: their text, and in analysis the move the board page showed as they wrote, 52...♚f6 (D-101). */
 export interface Written {
     readonly text: string;
-    readonly at?: string;
+    readonly place?: string;
 }
 /** What the player wrote on the board page that the AI has not been given in this chat, given now: each game tool gives it once; never to an agent (D-89). */
 export declare function newWords(context: Context): Written[];

package/dist/commands/say.js

@@ -57,7 +57,7 @@ export function give(context, words) {
         context.heard?.();
     }
     const analysed = words.some((word) => word.shown !== undefined) ? gameInAnalysis(gameFolder(context.home()))?.game : undefined;
-    return words.map(({ text, shown }) => shown === undefined ? { text } : { text, at: placeOf(shown, analysed) });
+    return words.map(({ text, shown }) => shown === undefined ? { text } : { text, place: placeOf(shown, analysed) });
 }
 /** Where the page stood: the move shown, as the player saw it, or the start; with the game's name when the page shows another now. */
 function placeOf({ game, move }, analysed) {

package/dist/commands/status.d.ts

@@ -22,7 +22,7 @@ interface Status {
     analysis?: {
         game: string;
         brought?: true;
-        analyst?: true;
+        analyst?: "done" | "offer";
         review?: string;
     };
     /** A game going on from before this chat, told once a chat: the player says whether to go on with it. */
@@ -31,6 +31,8 @@ interface Status {
     coach?: true;
     /** The files an older init wrote in the player's folder, which this version would write otherwise. */
     outdated?: string[];
+    /** The chat has not read the opponent's instructions since it started, or was cleared or summarized (D-102). */
+    unread?: true;
 }
 /** What Chesspal sees now, the first call of a chat: a dashboard under 150 tokens while the player is to move, with the next step. */
 export declare const status: import("./registry.ts").Command<z.ZodObject<{}, z.core.$strip>, Status>;