chesspal 0.1.0 → 0.2.0

package/dist/commands/play-move.js

@@ -1,5 +1,5 @@
 // A move of the AI or of the player on the current game: played, timed by the clock, saved, and archived when it ends the game.
-import { clockAfterMove, clockTag, reviewed } from "../core/index.js";
+import { clockAfterMove, clockTag } from "../core/index.js";
 import { archiveEnded, endOf, loadGame, saveGame, talkLine } from "../games/index.js";
 import { gameGoingOn, summaryOf, withThought } from "./game-summary.js";
 import { colourName } from "./view.js";
@@ -7,7 +7,7 @@ import { colourName } from "./view.js";
  * Plays a move for one side `now` and saves the game, with the time it took and the clock after it in its comment ([%clk]). A refused move, or words refused
  * with it, change nothing: it throws the message `refused` writes from the core's.
  */
-export function playMove(folder, now, mover, text, refused, { comment, said, offerDraw = false, allowance = 0, judged } = {}) {
+export function playMove(folder, now, mover, text, refused, { comment, said, offerDraw = false, allowance = 0, coached = false } = {}) {
     // A flag falls only past the allowance.
     const before = gameToMove(folder, mover, new Date(now.getTime() - allowance));
     const { game } = before;
@@ -20,19 +20,10 @@ export function playMove(folder, now, mover, text, refused, { comment, said, off
     if (offerDraw && game.record.moves.length === 0) {
         throw new Error("A draw can be offered once each side has made a move: play the move without offer_draw. Nothing changed.");
     }
-    if (judged !== undefined && game.record.moves.length === 0) {
-        throw new Error("The player has made no move yet: play without badge and note. Nothing changed.");
-    }
     const played = game.play(text);
     if (!played.played) {
         throw new Error(refused(played.message, played.legal));
     }
-    if (judged !== undefined) {
-        // The player's move is the one before the move just played: its badge and note sit in its comment, beside its clock.
-        const judging = game.record.moves.length - 1;
-        const { nags, comment: judgedComment } = reviewed(game.record.moves[judging - 1], judged);
-        game.annotate(judging, { nags, comment: judgedComment ?? "" });
-    }
     const clock = before.clock === undefined ? undefined : clockAfterMove(before.clock, position.turn, now, allowance, mover === "player");
     // A move declines the other side's draw offer; the mover's own stands, and the move carries it in the record as FIDE writes it, (=) (D-65). A move that
     // ends the game leaves no offer.
@@ -47,7 +38,7 @@ export function playMove(folder, now, mover, text, refused, { comment, said, off
     }
     saveGame(folder, current);
     const { archive, warning } = endOf(game) === undefined ? {} : archiveEnded(folder, current);
-    const result = { move: `${position.moveNumber}${position.turn === "white" ? "." : "..."}${played.move.san}`, game: withThought(summaryOf(current, now, archive), folder, current) };
+    const result = { move: `${position.moveNumber}${position.turn === "white" ? "." : "..."}${played.move.san}`, game: withThought(summaryOf(current, now, archive), folder, current, coached) };
     if (played.note !== undefined) {
         result.note = played.note;
     }
@@ -85,7 +76,8 @@ export function refuseOtherGame(context, folder) {
         throw new PositionChanged();
     }
 }
-function samePosition(one, other) {
+/** Whether two positions a chat may see are the same: the same game, as many plies. */
+export function samePosition(one, other) {
     return one.started === other.started && one.plies === other.plies;
 }
 function gameToMove(folder, mover, now) {

package/dist/commands/player-move.d.ts

@@ -5,13 +5,9 @@ export declare const playerMove: import("./registry.ts").Command<z.ZodObject<{
     move: z.ZodString;
     offer_draw: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>, PlayerMove>;
-/** The player's move, with the board page's address once a game while no browser has it open (D-85). */
+/** The player's move, with the board page's address once a game while no browser has it open (D-85), and the coach to start when it ended the game (D-88). */
 interface PlayerMove extends MovePlayed {
     invite?: string;
+    coach?: true;
 }
-/**
- * The time a move in the chat leaves off the player's clock (D-36): the AI writing after its move and reading the player's, about 10 s as Priya measured.
- * Claude Code's hooks will time it exactly (T-53); the board page's moves need none.
- */
-export declare const chatAllowance = 10000;
 export {};

package/dist/commands/player-move.js

@@ -1,6 +1,10 @@
 import { z } from "zod";
+import { loadGame } from "../games/index.js";
+import { coachAgent } from "../host-files/index.js";
 import { gameFolder } from "../profiles/index.js";
-import { closingLines, lastMoveText, moveLines, shownMove } from "./game-summary.js";
+import { agentsLine, coachOnEnd, 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";
 import { playMove, positionIn, refuseUnseenPosition } from "./play-move.js";
 import { defineCommand } from "./registry.js";
@@ -20,25 +24,28 @@ export const playerMove = defineCommand({
     positionals: ["move"],
     run: ({ move, offer_draw: offerDraw = false }, context) => {
         const folder = gameFolder(context.home());
-        // A chat that has seen no game yet, new or resumed, plays the player's own move: its answer shows the game the AI decides on (D-71, T-129).
+        // A chat that has seen no game yet, new or resumed, plays the player's own move: its answer shows the game the AI decides on (D-71).
         if (context.positionSeen !== null) {
             refuseUnseenPosition(context, folder);
         }
         const started = context.positionSeen === null ? positionIn(folder).started : context.positionSeen?.started;
-        const played = playMove(folder, context.now(), "player", move, (message) => `${message} Ask the player again. Nothing changed.`, { allowance: chatAllowance, offerDraw });
+        const played = playMove(folder, context.now(), "player", move, (message) => `${message} Ask the player again. Nothing changed.`, { allowance: chatAllowance, offerDraw, coached: coachRuns(context) });
         // A game over by this move has no more moves to play there: the next game's window gives the address (Federico, round of D-85).
         const invite = played.game.end === undefined ? pageInvite(context, started) : undefined;
-        return { ...played, words: newWords(context), ...(invite === undefined ? {} : { invite }) };
+        const ended = played.game.end === undefined ? undefined : loadGame(folder);
+        const coach = ended !== undefined && coachOnEnd(context, folder, ended);
+        return { ...played, game: withAnalyst(played.game, context), words: newWords(context), ...(invite === undefined ? {} : { invite }), ...(coach ? { coach } : {}) };
     },
     format: (result) => [
         `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])] : []),
         ...closingLines(result.game, result.words),
     ].join("\n"),
 });
 /**
  * The time a move in the chat leaves off the player's clock (D-36): the AI writing after its move and reading the player's, about 10 s as Priya measured.
- * Claude Code's hooks will time it exactly (T-53); the board page's moves need none.
+ * Claude Code's hooks will time it exactly; the board page's moves need none.
  */
-export const chatAllowance = 10_000;
+const chatAllowance = 10_000;

package/dist/commands/player-say.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-/** The player's words to the AI, as the board page sends them (T-65): on the command line only, since the AI never writes for the player. */
+/** The player's words to the AI, as the board page sends them: on the command line only, since the AI never writes for the player. */
 export declare const playerSay: import("./registry.ts").Command<z.ZodObject<{
     text: z.ZodString;
 }, z.core.$strip>, string>;

package/dist/commands/player-say.js

@@ -3,7 +3,7 @@ import { talkLimits } from "../games/index.js";
 import { gameFolder } from "../profiles/index.js";
 import { defineCommand } from "./registry.js";
 import { say } from "./say.js";
-/** The player's words to the AI, as the board page sends them (T-65): on the command line only, since the AI never writes for the player. */
+/** The player's words to the AI, as the board page sends them: on the command line only, since the AI never writes for the player. */
 export const playerSay = defineCommand({
     name: "player_say",
     description: "Writes the player's words to the AI, as the board page does: the AI reads them at its next call. "

package/dist/commands/ponder.d.ts

@@ -39,4 +39,14 @@ export declare const ponder: import("./registry.ts").Command<z.ZodObject<{
     say: z.ZodOptional<z.ZodString>;
     done: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>, Pondered>;
+/**
+ * Waits for the player's move, for an agent that works on their time (D-72, D-88): moved once `gone` says so, waited once the agent has waited long enough in
+ * all since `since`, else still waiting after a while.
+ */
+export declare function waitForPlayer(context: {
+    now: () => Date;
+    pause?: (milliseconds: number) => Promise<void>;
+}, since: Date, gone: () => boolean): Promise<"moved" | "waited" | "waiting">;
+/** The words of the AI's move for the player: its comment without the plan, the mood, the clock and the draw offer it carries. */
+export declare function wordsOf(comment: string | undefined): string | undefined;
 export {};

package/dist/commands/ponder.js

@@ -1,8 +1,10 @@
 import { z } from "zod";
 import { Game, levelOf, moodAt, sees, timeLeft } from "../core/index.js";
 import { currentPlan, endOf, keepThought, loadGame, talkLimits, thoughtKey, waitingSince } from "../games/index.js";
+import { ponderAgents } from "../host-files/index.js";
 import { gameFolder } from "../profiles/index.js";
-import { positionLines, summaryOf } from "./game-summary.js";
+import { positionLines } from "./answer-lines.js";
+import { summaryOf } from "./game-summary.js";
 import { levelText } from "./levels.js";
 import { defineCommand, sentence } from "./registry.js";
 import { say as sayWords } from "./say.js";
@@ -25,7 +27,7 @@ export const ponder = defineCommand({
         say: z.string().trim().min(1).max(talkLimits.ai).optional().describe("your words for the player on the board page, once, in one short sentence, of what has happened: pieces and moves in words, never in notation"),
         done: z.boolean().optional().describe("true when you have no more replies to think on: it waits for the player's move"),
     }),
-    byAgent: true,
+    byAgents: ponderAgents,
     host: "claude-code",
     run: async ({ position, reply, move, why, say, done = false }, context) => {
         const folder = gameFolder(context.home());
@@ -37,6 +39,7 @@ export const ponder = defineCommand({
             if (reply !== undefined || move !== undefined || why !== undefined || say !== undefined || done) {
                 throw new Error("Give the position's number with it: call ponder {} first, which gives it. Nothing changed.");
             }
+            context.ponders?.({ started: current.started, plies: current.game.record.moves.length });
             return { start: startOf(current) };
         }
         if ((say !== undefined || done) && (reply !== undefined || move !== undefined || why !== undefined || (say !== undefined && done))) {
@@ -47,6 +50,7 @@ export const ponder = defineCommand({
             return { said: position };
         }
         if (done) {
+            context.ponders?.(undefined);
             return await waitForMove(folder, context, current);
         }
         if (reply === undefined) {
@@ -96,17 +100,38 @@ export const ponder = defineCommand({
     },
 });
 /**
- * How long one call waits for the player's move at most, under the minute a host may give a tool (Priya, T-109), how often it looks, and how long the agent
- * waits in all before it stops: a player who leaves the game open must not keep it asking (Priya, round of T-109).
+ * Waits for the player's move, for an agent that works on their time (D-72, D-88): moved once `gone` says so, waited once the agent has waited long enough in
+ * all since `since`, else still waiting after a while.
  */
-const ponderWait = { most: 50_000, every: 500, inAll: 10 * 60_000 };
+export async function waitForPlayer(context, since, gone) {
+    const pause = context.pause ?? ((milliseconds) => new Promise((done) => setTimeout(done, milliseconds)));
+    const start = context.now().getTime();
+    const end = Math.min(start + playerWait.most, since.getTime() + playerWait.inAll);
+    while (context.now().getTime() < end) {
+        await pause(playerWait.every);
+        if (gone()) {
+            return "moved";
+        }
+    }
+    return end < start + playerWait.most ? "waited" : "waiting";
+}
+/** The words of the AI's move for the player: its comment without the plan, the mood, the clock and the draw offer it carries. */
+export function wordsOf(comment) {
+    const words = comment?.replace(/\[%[^\]]*\]/g, "").replace("(=)", "").replace(/\s+/g, " ").trim();
+    return words === undefined || words === "" ? undefined : words;
+}
+/**
+ * How long one call waits for the player's move at most, under the minute a host may give a tool (Priya), how often it looks, and how long the agent
+ * waits in all before it stops: a player who leaves the game open must not keep it asking (Priya).
+ */
+const playerWait = { most: 50_000, every: 500, inAll: 10 * 60_000 };
 /** The game whose position the AI thinks on, read and never written: none once the player has moved, the game is over or their flag has fallen, or the position given is another. */
 function toPonder(folder, now, position) {
     const current = loadGame(folder);
     if (current === undefined || endOf(current.game) !== undefined || current.game.position.turn === current.ai) {
         return undefined;
     }
-    // A flag fallen is the page's or the chat's to write, so that the doorbell rings it (Federico, round of T-109).
+    // A flag fallen is the page's or the chat's to write, so that the doorbell rings it (Federico).
     const { turn } = current.game.position;
     if (current.clock !== undefined && timeLeft(current.clock, turn, now)[turn] <= 0) {
         return undefined;
@@ -115,17 +140,9 @@ function toPonder(folder, now, position) {
 }
 /** Waits for the player's move: stop once they have moved or the agent has waited long enough in all, else still their move after a while. */
 async function waitForMove(folder, context, current) {
-    const pause = context.pause ?? ((milliseconds) => new Promise((done) => setTimeout(done, milliseconds)));
     const position = current.game.record.moves.length;
-    const start = context.now().getTime();
-    const end = Math.min(start + ponderWait.most, waitingSince(folder, thoughtKey(current), context.now()).getTime() + ponderWait.inAll);
-    while (context.now().getTime() < end) {
-        await pause(ponderWait.every);
-        if (toPonder(folder, context.now(), position) === undefined) {
-            return { stop: "moved" };
-        }
-    }
-    return end < start + ponderWait.most ? { stop: "waited" } : { waiting: position };
+    const waited = await waitForPlayer(context, waitingSince(folder, thoughtKey(current), context.now()), () => toPonder(folder, context.now(), position) === undefined);
+    return waited === "waiting" ? { waiting: position } : { stop: waited };
 }
 function startOf(current) {
     const { game, ai, talk } = current;
@@ -160,8 +177,3 @@ function startLines({ position, line, plan, mood, comment, talk }) {
             + `your answer; ponder {position: ${position}, done: true} when you have no more.`,
     ];
 }
-/** The words of the AI's move for the player: its comment without the plan, the mood, the clock and the draw offer it carries. */
-function wordsOf(comment) {
-    const words = comment?.replace(/\[%[^\]]*\]/g, "").replace("(=)", "").replace(/\s+/g, " ").trim();
-    return words === undefined || words === "" ? undefined : words;
-}

package/dist/commands/position.d.ts

@@ -4,7 +4,7 @@ import { type Profile } from "../core/index.ts";
 type Described = Profile & {
     where?: string;
 };
-/** The positional profile of the game in progress (D-19, T-12), or of any position of a game over (D-68): separate facts, never a score. */
+/** 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 declare const position: import("./registry.ts").Command<z.ZodObject<{
     game: z.ZodOptional<z.ZodString>;
     move: z.ZodOptional<z.ZodString>;

package/dist/commands/position.js

@@ -1,12 +1,13 @@
 import { z } from "zod";
 import {} from "../core/index.js";
+import { analystAgent } from "../host-files/index.js";
 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 { colourName, materialText } from "./view.js";
-/** The positional profile of the game in progress (D-19, T-12), or of any position of a game over (D-68): separate facts, never a score. */
+/** 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({
     name: "position",
     description: "Shows the positional facts of the position, from the strong level up and at every level once the game is over: material, pawns (isolated, doubled, backward, passed, islands), open files, rooks and queens on the seventh, bishops, "
@@ -17,6 +18,7 @@ export const position = defineCommand({
     input: z.object(studyInput),
     readOnly: true,
     idempotent: true,
+    sharedWith: [analystAgent],
     run: ({ game, move }, context) => {
         if (game !== undefined || move !== undefined) {
             const studied = gameToStudy(context, game);

package/dist/commands/profiles.d.ts

@@ -10,7 +10,10 @@ export declare const profiles: import("./registry.ts").Command<z.ZodObject<{}, z
     profiles: PlayerProfile[];
     active: string;
 }>;
-/** A new profile, put in use once the game going on has ended; the one Chesspal made at the first start, while new, becomes it, game and all (D-71). */
+/**
+ * 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).
+ */
 export declare const newProfile: import("./registry.ts").Command<z.ZodObject<{
     name: z.ZodString;
     level: z.ZodOptional<z.ZodEnum<{
@@ -37,7 +40,10 @@ export declare const newProfile: import("./registry.ts").Command<z.ZodObject<{
         cat: "cat";
         owl: "owl";
     }>>;
-}, z.core.$strip>, PlayerProfile>;
+    use: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, PlayerProfile & {
+    readonly inUse: boolean;
+}>;
 /** Another profile put in use, once the game going on has ended. */
 export declare const useProfile: import("./registry.ts").Command<z.ZodObject<{
     profile: z.ZodString;
@@ -49,6 +55,11 @@ 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<{
+    lichess: z.ZodOptional<z.ZodString>;
+    chesscom: z.ZodOptional<z.ZodString>;
+}, 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;
 /**
@@ -56,5 +67,3 @@ 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;
-/** Throws while a game goes on in the profile in use. */
-export declare function refuseWhilePlaying(context: Context): void;

package/dist/commands/profiles.js

@@ -20,39 +20,43 @@ export const profiles = defineCommand({
     cliOnly: true,
     readOnly: true,
     idempotent: true,
-    run: (_input, context) => ({ profiles: listProfiles(context.home()), active: activeProfile(context.home()).id }),
+    run: (input, context) => ({ profiles: listProfiles(context.home()), active: activeProfile(context.home()).id }),
     format: ({ profiles, active }) => profiles.map((profile) => `${profile.id === active ? "*" : " "} ${profile.id}: ${playerText(profile)}`).join("\n"),
 });
-/** A new profile, put in use once the game going on has ended; the one Chesspal made at the first start, while new, becomes it, game and all (D-71). */
+/**
+ * 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).
+ */
 export const newProfile = defineCommand({
     name: "new_profile",
-    description: "Makes a player's profile and puts it in use: 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.",
+    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.",
     input: z.object({
         name: z.string().trim().min(1).max(nameLimit).regex(/^[^\p{Cc}]+$/u, "one line of text").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"),
         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 }, context) => {
+    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.");
         }
-        if (activeProfile(context.home()).new !== true) {
-            refuseWhilePlaying(context);
-        }
-        return createProfile(context.home(), {
+        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);
+        return { ...profile, inUse };
     },
-    format: (profile) => `Profile ${profile.id} made, and in use: ${playerText(profile)}.`,
+    format: (profile) => `Profile ${profile.id} made${profile.inUse ? ", and in use" : ", not in use"}: ${playerText(profile)}.`,
 });
 /** Another profile put in use, once the game going on has ended. */
 export const useProfile = defineCommand({
@@ -94,6 +98,25 @@ 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.",
+    input: z.object({
+        lichess: accountName().optional().describe("the player's name on Lichess"),
+        chesscom: accountName().optional().describe("the player's name on chess.com"),
+    }),
+    cliOnly: true,
+    idempotent: true,
+    run: (names, 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 }) } });
+    },
+    format: (profile) => `${profile.id} is ${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) {
     updateProfile(context.home(), id, { avatar });
@@ -108,17 +131,28 @@ export function playerLine(context) {
     return profile.new === true ? undefined : `Player: ${playerText(profile)}.`;
 }
 /** Throws while a game goes on in the profile in use. */
-export function refuseWhilePlaying(context) {
-    const current = gameAt(gameFolder(context.home()), context.now());
-    if (current !== undefined && endOf(current.game) === undefined) {
+function refuseWhilePlaying(context) {
+    if (isPlaying(context)) {
         throw new GameGoingOn();
     }
 }
+function isPlaying(context) {
+    const current = gameAt(gameFolder(context.home()), context.now());
+    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(", ");
 }
+/** 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.");
+}
+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 ");
+}
 function imageFile(path) {
     try {
         return readFileSync(path);

package/dist/commands/registry.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import type { Context } from "./context.ts";
-/** A command is defined once: the command line and the MCP server are generated from it (D-5), and later the page's actions. */
+/** A command is defined once: the command line and the MCP server are generated from it (D-5); the page's routes call the same commands. */
 export interface Command<Schema extends z.ZodObject = z.ZodObject, Result = unknown> {
     name: string;
     /** Written for an AI: what the command does (the first sentence, shown in the list of commands), when to use it, an example. */
@@ -16,8 +16,13 @@ export interface Command<Schema extends z.ZodObject = z.ZodObject, Result = unkn
     alwaysLoad?: boolean;
     /** Its answer shows the chat the game as it is: the chat may move on it, and on no other (D-71). */
     showsGame?: boolean;
-    /** An agent calls it apart from the chat, as ponder (D-72): the doorbell's record of what the chat has read stays as it was. */
-    byAgent?: boolean;
+    /**
+     * The agents that call it apart from the chat, as ponder (D-72), by their names: the doorbell's record of what the chat has read stays as it was, and the
+     * server refuses it to the chat and to other agents (Priya).
+     */
+    byAgents?: readonly string[];
+    /** The agents that call it besides the chat, as the analyst analyse_game (D-89): their calls leave the doorbell's record of what the chat has read as it was. */
+    sharedWith?: readonly string[];
     /** The only host the MCP server offers it to, by the client's name, as ponder to Claude Code: elsewhere its description would cost tokens for nothing. */
     host?: string;
     /** Only the command line has it, as init: the MCP server leaves it out, and its description costs the AI no tokens. */

package/dist/commands/registry.js

@@ -1,3 +1,4 @@
+// What a command is, and the reading of its input schema that the command line and the MCP server share.
 import { z } from "zod";
 /** Checks a command's types where it is written; the command is used as it is. */
 export function defineCommand(command) {
@@ -14,17 +15,6 @@ export function sentence(most) {
 export function inputProblems(command, issues, given, written) {
     return issues.map((issue) => inputIssue(command, issue, given, written)).join(" ");
 }
-function inputIssue(command, issue, given, written) {
-    const path = issue.path.map(String).join(".");
-    if (issue.code === "unrecognized_keys") {
-        return path === "" ? `${command} has no parameter ${issue.keys.map(written).join(", ")}.` : `${written(path)} has no ${issue.keys.join(", ")}.`;
-    }
-    // A parameter left out, whatever zod calls it.
-    if (issue.path.length === 1 && given[path] === undefined) {
-        return `${command} needs ${written(path)}.`;
-    }
-    return path === "" ? `${issue.message}.` : `${written(path)}: ${issue.message}.`;
-}
 /**
  * What keeps a field of a command's input from being given on the command line: one named no-x, read as turning x off, or json, read as answering in JSON;
  * undefined for any other. A positional is never an option, so json is its name freely.
@@ -52,6 +42,17 @@ export function takesNumbers(field) {
     const definition = baseDefinition(field);
     return definition.type === "number" || (definition.type === "array" && definition.element !== undefined && baseType(definition.element) === "number");
 }
+function inputIssue(command, issue, given, written) {
+    const path = issue.path.map(String).join(".");
+    if (issue.code === "unrecognized_keys") {
+        return path === "" ? `${command} has no parameter ${issue.keys.map(written).join(", ")}.` : `${written(path)} has no ${issue.keys.join(", ")}.`;
+    }
+    // A parameter left out, whatever zod calls it.
+    if (issue.path.length === 1 && given[path] === undefined) {
+        return `${command} needs ${written(path)}.`;
+    }
+    return path === "" ? `${issue.message}.` : `${written(path)}: ${issue.message}.`;
+}
 function baseDefinition(field) {
     let definition = field.def;
     while (definition.innerType && ["optional", "default", "nullable"].includes(definition.type)) {

package/dist/commands/say.d.ts

@@ -6,7 +6,7 @@ import type { Context } from "./context.ts";
  * With no game the line goes in the talk before it (D-77). A line refused changes nothing: it throws, in words for whoever spoke.
  */
 export declare function say(folder: string, who: Sayer, text: string, at: Date, mood?: Mood): Talk;
-/** 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. */
+/** 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): string[];
 /** Every word of the player's the AI has not answered, given again: status gives them all, for a chat that lost them in a summary. */
 export declare function unansweredWords(context: Context): string[];

package/dist/commands/say.js

@@ -1,4 +1,4 @@
-// The talk on the board page (D-51, T-65): a line of the player's or the AI's, saved with the game, and the player's words the AI has not been given yet.
+// The talk on the board page (D-51): a line of the player's or the AI's, saved with the game, and the player's words the AI has not been given yet.
 import { endWithMood } from "../core/index.js";
 import { archiveEnded, endOf, loadGame, loadTableTalk, saveGame, saveTableTalk, talkLimits, talkLine, unheardWords } from "../games/index.js";
 import { gameFolder, helpsIn } from "../profiles/index.js";
@@ -26,22 +26,9 @@ export function say(folder, who, text, at, mood) {
     }
     return current;
 }
-/** The most a line of the AI's may hold in the games of `folder`: an analyst's note with the helps on (D-78); a longer one with them off is refused. */
-function aiMost(folder, who, text) {
-    if (who !== "ai") {
-        return talkLimits.ai;
-    }
-    if (helpsIn(folder)) {
-        return talkLimits.aiHelps;
-    }
-    if (text.trim().length > talkLimits.ai) {
-        throw new Error(`The player has the helps off: write at most ${talkLimits.ai} characters. Nothing changed.`);
-    }
-    return talkLimits.ai;
-}
-/** 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. */
+/** 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 function newWords(context) {
-    return give(context, waitingWords(context));
+    return context.agent === undefined ? give(context, waitingWords(context)) : [];
 }
 /** Every word of the player's the AI has not answered, given again: status gives them all, for a chat that lost them in a summary. */
 export function unansweredWords(context) {
@@ -69,6 +56,19 @@ export function give(context, words) {
     }
     return words.map(({ text }) => text);
 }
+/** The most a line of the AI's may hold in the games of `folder`: an analyst's note with the helps on (D-78); a longer one with them off is refused. */
+function aiMost(folder, who, text) {
+    if (who !== "ai") {
+        return talkLimits.ai;
+    }
+    if (helpsIn(folder)) {
+        return talkLimits.aiHelps;
+    }
+    if (text.trim().length > talkLimits.ai) {
+        throw new Error(`The player has the helps off: write at most ${talkLimits.ai} characters. Nothing changed.`);
+    }
+    return talkLimits.ai;
+}
 /** A line of the talk with no game, which starts it the first time; no mood, which only the end of a game takes. */
 function sayAtTable(folder, who, text, at, mood) {
     if (who === "agent") {

package/dist/commands/speech.d.ts

@@ -0,0 +1,8 @@
+/** The player's language by its English name when it is not English. */
+export interface Speech {
+    language: string;
+}
+/** The player's speech, from the page's settings or the system's language; undefined in English, which the AI speaks unless told. */
+export declare function speechOf(folder: string, systemLanguage: string | undefined): Speech | undefined;
+/** What the AI is told of the player's speech once a chat (Priya); the moves are SAN in every language (D-87). */
+export declare function speechLine({ language }: Speech): string;

package/dist/commands/speech.js

@@ -0,0 +1,20 @@
+// The player's language, which the AI is told once a chat when it is not English: the moves stay in SAN (D-87).
+import { languageIn } from "../profiles/index.js";
+/** The player's speech, from the page's settings or the system's language; undefined in English, which the AI speaks unless told. */
+export function speechOf(folder, systemLanguage) {
+    const language = languageName(languageIn(folder, systemLanguage));
+    return language === undefined ? undefined : { language };
+}
+/** What the AI is told of the player's speech once a chat (Priya); the moves are SAN in every language (D-87). */
+export function speechLine({ language }) {
+    return `The player speaks ${language}.`;
+}
+/** A language by its English name when it is not English (Italian), from the way the system or the page names it (it-IT, it). */
+function languageName(language) {
+    const code = language?.split(/[-_]/)[0]?.toLowerCase() ?? "";
+    if (!/^[a-z]{2,3}$/.test(code) || code === "en" || code === "und") {
+        return undefined;
+    }
+    const name = new Intl.DisplayNames(["en"], { type: "language" }).of(code);
+    return name === undefined || name === code ? undefined : name;
+}