chesspal 0.2.0 → 0.2.1

package/dist/core/index.d.ts

@@ -17,4 +17,4 @@ export { pgnDate, readPgn, writePgn } from "./pgn.ts";
 export type { BishopFacts, CentreSquare, KingFacts, Outpost, PawnFacts, PawnSquare, Phase, Profile, SideProfile } from "./profile.ts";
 export { movesOnly } from "./record.ts";
 export type { Annotation, GameRecord, RecordedMove } from "./record.ts";
-export { type AiModel, aiModelIn, annotatorOf, arrowOf, type Badge, badges, closingOf, type DrawColour, drawingsIn, drawingsText, type DrawnArrow, type DrawnSquare, gameReviewOf, isReviewed, type MoveReview, reviewed, reviewOf, squareOf, unreviewed, withAiModel, withAnnotator, withGameReview, } from "./review.ts";
+export { aiHostIn, type AiModel, aiModelIn, aiNameOf, annotatorOf, arrowOf, type Badge, badges, closingOf, type DrawColour, drawingsIn, drawingsText, type DrawnArrow, type DrawnSquare, gameReviewOf, isReviewed, type MoveReview, reviewed, reviewOf, squareOf, unreviewed, withAiHost, withAiModel, withAnnotator, withGameReview, } from "./review.ts";

package/dist/core/index.js

@@ -9,4 +9,4 @@ export { endWithMood, moodAt, moodOf, moods, moodTag, withoutMoods } from "./moo
 export { bookMoves, indexBook, indexOpenings, inOpenings, openingOf, outOfBookMove } from "./openings.js";
 export { pgnDate, readPgn, writePgn } from "./pgn.js";
 export { movesOnly } from "./record.js";
-export { aiModelIn, annotatorOf, arrowOf, badges, closingOf, drawingsIn, drawingsText, gameReviewOf, isReviewed, reviewed, reviewOf, squareOf, unreviewed, withAiModel, withAnnotator, withGameReview, } from "./review.js";
+export { aiHostIn, aiModelIn, aiNameOf, annotatorOf, arrowOf, badges, closingOf, drawingsIn, drawingsText, gameReviewOf, isReviewed, reviewed, reviewOf, squareOf, unreviewed, withAiHost, withAiModel, withAnnotator, withGameReview, } from "./review.js";

package/dist/core/review.d.ts

@@ -72,6 +72,15 @@ export declare function annotatorOf(record: GameRecord): {
 } | undefined;
 /** The model the AI played the game with, as its tags say (D-82), and the effort when known; undefined without one. */
 export declare function aiModelIn(record: GameRecord): AiModel | undefined;
+/** The record with the host the AI played it in (D-97); with none known, as it is. */
+export declare function withAiHost(record: GameRecord, host: string | undefined): GameRecord;
+/** The host the AI played the game in, as its tags say (D-97); undefined without one. */
+export declare function aiHostIn(record: GameRecord): string | undefined;
+/**
+ * The AI's name from its host: Claude Code and the desktop app are Claude, Codex is Codex; without a host it names, from the model, a Claude model is
+ * Claude (D-97). Undefined otherwise.
+ */
+export declare function aiNameOf(host: string | undefined, model?: string): string | undefined;
 /** The record with the AI's word on the whole game, or its last word on the ending, in place of the one it had: each only when given. */
 export declare function withGameReview(record: GameRecord, { summary, closing }: {
     summary?: string;

package/dist/core/review.js

@@ -91,6 +91,29 @@ export function annotatorOf(record) {
 export function aiModelIn(record) {
     return signerOf(record.tags, ["AIModel", "AIEffort"]);
 }
+/** The record with the host the AI played it in (D-97); with none known, as it is. */
+export function withAiHost(record, host) {
+    const named = host?.trim();
+    return named === undefined || named === "" ? record : { ...record, tags: { ...record.tags, AIHost: named } };
+}
+/** The host the AI played the game in, as its tags say (D-97); undefined without one. */
+export function aiHostIn(record) {
+    const host = record.tags.AIHost?.trim();
+    return host === undefined || host === "" ? undefined : host;
+}
+/**
+ * The AI's name from its host: Claude Code and the desktop app are Claude, Codex is Codex; without a host it names, from the model, a Claude model is
+ * Claude (D-97). Undefined otherwise.
+ */
+export function aiNameOf(host, model) {
+    if (/claude/i.test(host ?? "")) {
+        return "Claude";
+    }
+    if (/codex/i.test(host ?? "")) {
+        return "Codex";
+    }
+    return /^claude/i.test(model?.trim() ?? "") ? "Claude" : undefined;
+}
 /** The record with the AI's word on the whole game, or its last word on the ending, in place of the one it had: each only when given. */
 export function withGameReview(record, { summary, closing }) {
     const summed = summary === undefined ? gameReviewOf(record) : noteText(summary);

package/dist/games/ai-model.d.ts

@@ -3,3 +3,7 @@ import type { AiModel } from "../core/index.ts";
 export declare function noteAiModel(folder: string, noted: AiModel): boolean;
 /** The AI's model last noted for the games of a folder in this process; none on the command line, or before the AI's first move. */
 export declare function aiModelOf(folder: string): AiModel | undefined;
+/** Notes the host the AI plays in for the games of a folder, after its move (D-97), as the model. */
+export declare function noteAiHost(folder: string, host: string): void;
+/** The host the AI played its last move in, for the games of a folder in this process; none on the command line, or before the AI's first move. */
+export declare function aiHostOf(folder: string): string | undefined;

package/dist/games/ai-model.js

@@ -11,5 +11,14 @@ export function noteAiModel(folder, noted) {
 export function aiModelOf(folder) {
     return models.get(folder);
 }
+/** Notes the host the AI plays in for the games of a folder, after its move (D-97), as the model. */
+export function noteAiHost(folder, host) {
+    hosts.set(folder, host);
+}
+/** The host the AI played its last move in, for the games of a folder in this process; none on the command line, or before the AI's first move. */
+export function aiHostOf(folder) {
+    return hosts.get(folder);
+}
 // By the game's folder, the profile's, where the games are archived.
 const models = new Map();
+const hosts = new Map();

package/dist/games/archive.d.ts

@@ -10,7 +10,7 @@ export declare function isOverOnTable(folder: string, name: string): boolean;
  */
 export declare function startOfNewGame(folder: string, now: Date, before?: CurrentGame): Date;
 /**
- * Writes the game to the archive, with the plans, how it ended and the AI's model last noted (D-82), and gives its name; the same game again rewrites the
+ * Writes the game to the archive, with the plans, how it ended and the AI's model and host last noted (D-82, D-97), and gives its name; the same game again rewrites the
  * same file.
  */
 export declare function archiveGame(folder: string, current: CurrentGame): string;

package/dist/games/archive.js

@@ -1,8 +1,8 @@
 // The finished games, as PGN in games/ (D-9, D-41), with the AI's plans for the analyst (D-21); and the games played elsewhere, kept to study in study/ (D-68).
 import { existsSync, readdirSync, readFileSync, rmSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { movesOnly, pgnDate, readPgn, withAiModel, writePgn } from "../core/index.js";
-import { aiModelOf } from "./ai-model.js";
+import { movesOnly, pgnDate, readPgn, withAiHost, withAiModel, writePgn } from "../core/index.js";
+import { aiHostOf, aiModelOf } from "./ai-model.js";
 import { coachWords, withCoach } from "./coach.js";
 import { endOf, loadGame } from "./current-game.js";
 import { makeFolder, writeAtomically } from "./files.js";
@@ -34,7 +34,7 @@ export function startOfNewGame(folder, now, before) {
     return start;
 }
 /**
- * Writes the game to the archive, with the plans, how it ended and the AI's model last noted (D-82), and gives its name; the same game again rewrites the
+ * Writes the game to the archive, with the plans, how it ended and the AI's model and host last noted (D-82, D-97), and gives its name; the same game again rewrites the
  * same file.
  */
 export function archiveGame(folder, current) {
@@ -42,7 +42,7 @@ export function archiveGame(folder, current) {
     const path = join(folder, name);
     try {
         makeFolder(dirname(path));
-        writeAtomically(path, writePgn(withAiModel(endedRecord(folder, current), aiModelOf(folder))));
+        writeAtomically(path, writePgn(withAiHost(withAiModel(endedRecord(folder, current), aiModelOf(folder)), aiHostOf(folder))));
     }
     catch (error) {
         throw new Error(`Chesspal could not archive the game: ${error.message}`, { cause: error });

package/dist/games/index.d.ts

@@ -1,4 +1,4 @@
-export { aiModelOf, noteAiModel } from "./ai-model.ts";
+export { aiHostOf, aiModelOf, noteAiHost, noteAiModel } from "./ai-model.ts";
 export { type Analysis, endAnalysis, gameInAnalysis, startAnalysis } from "./analysis.ts";
 export { archiveCoached, archivedGame, archivedGames, archivedName, archivedWhen, archiveEnded, archiveGame, archiveName, deleteGame, gameStemOf, isGameName, isOverOnTable, keepToStudy, keptGame, keptGames, listedName, movesPgn, playerPgn, rewriteGame, startOfNewGame, } from "./archive.ts";
 export { type ChatStart, cleanSince, lastChatStart, saveChatStart } from "./chat-start.ts";

package/dist/games/index.js

@@ -1,5 +1,5 @@
 // The player's games on disk: the current one in game.json, the finished ones in games/ (D-27, D-41), the games kept to study in study/ (D-68). Below the commands, above the core.
-export { aiModelOf, noteAiModel } from "./ai-model.js";
+export { aiHostOf, aiModelOf, noteAiHost, noteAiModel } from "./ai-model.js";
 export { endAnalysis, gameInAnalysis, startAnalysis } from "./analysis.js";
 export { archiveCoached, archivedGame, archivedGames, archivedName, archivedWhen, archiveEnded, archiveGame, archiveName, deleteGame, gameStemOf, isGameName, isOverOnTable, keepToStudy, keptGame, keptGames, listedName, movesPgn, playerPgn, rewriteGame, startOfNewGame, } from "./archive.js";
 export { cleanSince, lastChatStart, saveChatStart } from "./chat-start.js";

package/dist/page/app/app.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "preact/jsx-runtime";
 import { useEffect, useMemo, useRef, useState } from "preact/hooks";
-import { aiModelIn, annotatorOf, closingOf, Game, gameReviewOf, materialOf, moodAt, movesOnly, openingOf, readPgn, suggestedLevel, timeControlText, writePgn, } from "../../core/index.js";
+import { aiHostIn, aiModelIn, aiNameOf, annotatorOf, closingOf, Game, gameReviewOf, materialOf, moodAt, movesOnly, openingOf, readPgn, suggestedLevel, timeControlText, writePgn, } from "../../core/index.js";
 import { PlayerPicture } from "../avatars/avatars.js";
 import { Thinker, Thought } from "../avatars/thought.js";
 import { Torretta } from "../avatars/torretta.js";
@@ -101,6 +101,10 @@ export function App({ start }) {
     const idle = phase === "idle";
     const tableSet = useMemo(() => new Game(), []);
     const live = idle ? tableSet : replayed;
+    // In analysis the AI is who played that game, as its PGN says, and the review's words are of who wrote them: never the chat open now (D-97).
+    const annotator = studied === undefined ? undefined : annotatorOf(live.record);
+    const playedAs = studied === undefined ? name : aiNameOf(aiHostIn(live.record), aiModelIn(live.record)?.model) ?? text.ai;
+    const analyst = annotator === undefined ? name : aiNameOf(annotator.annotator, annotator.annotator) ?? text.ai;
     const material = useMemo(() => materialOf(live.position.fen), [live]);
     const pieces = useMemo(() => piecesOf(live.position.fen), [live]);
     // While the game goes on, the book's first moves carry its badge, when the player wants it, as the AI's review gives it after (D-69).
@@ -139,7 +143,7 @@ export function App({ start }) {
     // With the helps on, the player sees all of Chesspal's facts, whatever the AI's level (D-79), in a game and in the analysis of one (Stefano).
     const analysing = studied !== undefined;
     // Seen from the player's side (D-91): theirs in a game, in analysis the side the game names theirs, none when it names neither.
-    const you = analysing ? playerIn(studiedSides(live.record.tags, served?.profile.name ?? "", name, text.sides, served?.profile.accounts)) : game?.ai === undefined ? undefined : game.ai === "white" ? "black" : "white";
+    const you = analysing ? playerIn(studiedSides(live.record.tags, served?.profile.name ?? "", playedAs, text.sides, served?.profile.accounts)) : game?.ai === undefined ? undefined : game.ai === "white" ? "black" : "white";
     const helps = useMemo(() => (going || analysing) && settings.helps ? helpsOf(shown, you) : undefined, [shown, going, analysing, settings.helps, you]);
     // Who the AI saw ahead, the coach's with the helps on in a game and the analyst's in analysis, for the bar and the chart (D-90).
     const drawnOnBoard = live.outcome.over && live.outcome.result === "1/2-1/2";
@@ -236,7 +240,7 @@ export function App({ start }) {
     const profile = served.profile;
     const picture = _jsx(PlayerPicture, { profile: profile });
     // In analysis the cards name the players of the game, the player's side at the bottom when they played it (D-69).
-    const sides = studied === undefined ? undefined : studiedSides(live.record.tags, profile.name, name, text.sides, profile.accounts);
+    const sides = studied === undefined ? undefined : studiedSides(live.record.tags, profile.name, playedAs, text.sides, profile.accounts);
     const player = sides?.bottom ?? (game === null || game.ai === "black" ? "white" : "black");
     const ai = player === "white" ? "black" : "white";
     // The Torretta's face on the move shown: the mood the AI gave, while it lasts (D-70); in analysis, of the side the AI played.
@@ -251,7 +255,6 @@ export function App({ start }) {
     const drawn = hintOpen && hint !== undefined && viewing === undefined && (hint.arrows !== undefined || hint.squares !== undefined) ? hint : review;
     const summary = studied === undefined ? undefined : gameReviewOf(live.record);
     const closing = studied === undefined ? undefined : closingOf(live.record);
-    const annotator = studied === undefined ? undefined : annotatorOf(live.record);
     // In analysis the AI's card says who played that game, as its PGN keeps it (D-82), not who plays now.
     const playedBy = studied === undefined ? undefined : aiModelIn(live.record);
     const talk = game?.talk ?? served.talk ?? [];
@@ -358,7 +361,7 @@ export function App({ start }) {
     return (_jsx(ChosenSet.Provider, { value: settings.set, children: _jsxs(PointSquare.Provider, { value: pointSquare, children: [panel, _jsx(PictureDialog, { open: dialog === "picture", profile: profile, onClose: () => setDialog(undefined), text: text }), _jsx(ProfilesDialog, { open: dialog === "profiles", profiles: served.profiles, active: profile, locked: going ? text.profile.whilePlaying : undefined, dataFolder: served.dataFolder, onClose: () => setDialog(undefined), text: text }), _jsx(NewGameDialog, { open: dialog === "new-game", choice: choice, going: going, onStart: startNewGame, onClose: () => setDialog(undefined), text: text }), _jsx(StudyDialog, { open: dialog === "study", onStudy: studyGame, onClose: () => setDialog(undefined), you: profile.name, accounts: profile.accounts, ai: name, text: text }), offline ? _jsx("p", { class: "offline", role: "alert", children: text.offline(name) }) : null, served.outdated === true ? _jsx("p", { class: "outdated", role: "status", children: text.outdated(name) }) : null, _jsxs("main", { class: `app${flipped ? " flipped" : ""}${folds.talk === "open" ? "" : ` talk-${folds.talk}`}${folds.game === "folded" ? " folded" : ""}`, inert: offline, children: [header, sides === undefined
                             ? (_jsx(TalkFaces, { name: name, aiPicture: thinker(40), you: profile.name, picture: picture, ...(idle ? {} : { ai, player }), aiMoves: going && !playerToMove, playerMoves: playerToMove, unread: unread || asleep, text: text }))
                             : (_jsx(TalkFaces, { name: sides[ai].name, aiPicture: pictureOf(sides[ai], profile, 40, mood), you: sides[player].name, picture: pictureOf(sides[player], profile, 40, mood), ai: ai, player: player, aiMoves: false, playerMoves: false, unread: asleep, text: text })), _jsx(FoldTab, { column: "talk", folded: folds.talk === "folded", label: thinking === undefined || folds.talk !== "folded" ? text.talk : `${text.talk}: ${text.thinking[thinking]}`, unread: (unread || asleep) && folds.talk === "folded", ...(thinking === undefined || folds.talk !== "folded" ? {} : { mark: _jsx(Thought, { thinking: thinking, words: text.thinking }) }), onFold: fold }), _jsx(FoldTab, { column: "game", folded: folds.game === "folded", label: text.game, onFold: fold }), _jsx("span", { class: "visually-hidden", "aria-live": "polite", children: unread ? text.wrote(name) : "" }), _jsx("div", { class: sides === undefined ? "talk" : "talk studied", id: "talk", children: sides !== undefined
-                                ? (_jsxs(_Fragment, { children: [_jsxs("section", { class: "ai-block", "aria-label": sides[top].name, children: [studiedCard(top, "ai"), asleepNote, _jsx(AiNote, { ...(reviewed === undefined ? {} : { ply: reviewed }), ...(shownOpening === undefined ? {} : { opening: shownOpening }), ...(at === total && closing !== undefined ? { closing } : {}), ...(at === 0 && summary !== undefined ? { summary } : {}), ...(summary === undefined ? { reviewing: true } : {}), name: name, by: annotator, mood: mood, ...(settings.voice ? { voice: text.language } : {}), text: text })] }), _jsx("section", { class: "you-block", "aria-label": sides[bottom].name, children: studiedCard(bottom, "you") })] }))
+                                ? (_jsxs(_Fragment, { children: [_jsxs("section", { class: "ai-block", "aria-label": sides[top].name, children: [studiedCard(top, "ai"), asleepNote, _jsx(AiNote, { ...(reviewed === undefined ? {} : { ply: reviewed }), ...(shownOpening === undefined ? {} : { opening: shownOpening }), ...(at === total && closing !== undefined ? { closing } : {}), ...(at === 0 && summary !== undefined ? { summary } : {}), ...(summary === undefined ? { reviewing: true } : {}), name: analyst, by: annotator, mood: mood, ...(settings.voice ? { voice: text.language } : {}), text: text })] }), _jsx("section", { class: "you-block", "aria-label": sides[bottom].name, children: studiedCard(bottom, "you") })] }))
                                 : (_jsxs(_Fragment, { children: [_jsxs("section", { class: "ai-block", "aria-label": name, children: [_jsx(PlayerCard, { place: "ai", picture: thinker(48), name: name, signed: signed, side: idle ? undefined : ai, ...(idle ? {} : { level: text.start.levels[level] }), taken: material.taken[ai], ahead: ahead(ai), clock: clockOf(ai), text: text }), asleepNote, _jsx(AiWords, { words: aiWords(plies, ai, talk), newestFirst: !flipped, ...(settings.voice ? { voice: text.language } : {}) })] }), _jsxs("section", { class: "you-block", "aria-label": profile.name, children: [_jsx(Compose, { lines: said, newestFirst: flipped, 
                                                     // Between games, and before the first, the player writes freely, a line at a time, as the AI does (D-74, D-77).
                                                     spent: going ? playerSpent(plies, ai, talk) : 0, draft: draft, onDraft: (words) => {
@@ -370,7 +373,7 @@ export function App({ start }) {
                             // A press on the board while the player looks back brings the game as it is: the next one plays.
                             onPointerDownCapture: viewing === undefined || studied !== undefined ? undefined : (event) => event.button === 0 && goTo(total), children: [_jsx(Board, { fen: shown.position.fen, bottom: flipped ? ai : player, lastMove: shown.lastMove, pointed: pointed, ...(helps === undefined ? {} : { helps }), ...(mapping && helps !== undefined ? { control: helps.strategy.control } : {}), bare: bare && helps !== undefined, ...(review?.badge === undefined ? {} : { badge: { badge: review.badge, name: text.badges[review.badge] } }), ...(drawn === undefined ? {} : { drawn }), nextMove: next, jumped: jumped, check: shown.position.check, end: ended && viewing === undefined && pending === undefined ? { how, winner, player, fresh: justEnded } : undefined, player: playerToMove && pending === undefined && viewing === undefined ? player : undefined, selected: selected, targets: selected === undefined || viewing !== undefined ? [] : live.legalMoves(selected), dots: settings.dots, names: settings.squareNames, notice: viewing === undefined ? refusal : undefined, promotion: promoting === undefined || viewing !== undefined || !playerToMove ? undefined : { ...promoting, side: player }, onPromote: (piece) => piece === undefined ? setPromoting(undefined) : play(promoting.from, promoting.to, piece), onSelect: select, onMove: play, onRefuse: refuse, text: text }), folds.talk !== "open" && (asleep || clockWaits)
                                     ? (_jsxs("div", { class: "over-board", children: [asleep ? _jsx("p", { class: "asleep", role: "status", children: text.asleep(name) }) : null, startClocks] }))
-                                    : null] }), studied === undefined ? null : (_jsx("div", { class: "board-steps", children: _jsx(Steps, { shown: at, total: total, onStep: step, text: text }) })), helps === undefined ? null : (_jsxs("div", { class: "board-map", children: [_jsx(BareButton, { bare: bare, onBare: setBare, text: text }), _jsx(MapButton, { mapping: mapping, onMap: setMapping, text: text }), hint === undefined || viewing !== undefined ? null : _jsx(HintLine, { hint: hint, open: hintOpen, onOpen: openTheHint, text: text })] })), _jsx(GameColumn, { plies: idle ? [] : plies, result: ended ? result : undefined, how: how, lit: justEnded, started: idle ? undefined : played?.started, move: live.position.moveNumber, toMove: live.position.turn, opening: opening, helps: helps === undefined ? undefined : (_jsx(HelpsCard, { helps: helps, judged: judgments, hint: viewing === undefined ? hint : undefined, hintOpen: hintOpen, onHint: openTheHint, onPoint: setPointed, onMap: setMapping, mapping: mapping, onBare: setBare, bare: bare, text: text })), ...(standings === undefined ? {} : { standings }), ...(studied === undefined ? {} : { analysis: summary === undefined ? { by: name } : { by: name, summary } }), shownPlies: at, onShow: goTo, onStep: step, ...(studied === undefined ? {} : { onDownload: () => download(studied.pgn, pgnName(live.record.tags, "analysis")) }), ...(total === 0 ? {} : { onSaveMoves: () => download(writePgn(movesOnly(live.record)), pgnName(live.record.tags)) }), ...(between && game !== null ? { onAnalyse: () => void studyGame({ last: true }) } : {}), text: text })] })] }) }));
+                                    : null] }), studied === undefined ? null : (_jsx("div", { class: "board-steps", children: _jsx(Steps, { shown: at, total: total, onStep: step, text: text }) })), helps === undefined ? null : (_jsxs("div", { class: "board-map", children: [_jsx(BareButton, { bare: bare, onBare: setBare, text: text }), _jsx(MapButton, { mapping: mapping, onMap: setMapping, text: text }), hint === undefined || viewing !== undefined ? null : _jsx(HintLine, { hint: hint, open: hintOpen, onOpen: openTheHint, text: text })] })), _jsx(GameColumn, { plies: idle ? [] : plies, result: ended ? result : undefined, how: how, lit: justEnded, started: idle ? undefined : played?.started, move: live.position.moveNumber, toMove: live.position.turn, opening: opening, helps: helps === undefined ? undefined : (_jsx(HelpsCard, { helps: helps, judged: judgments, hint: viewing === undefined ? hint : undefined, hintOpen: hintOpen, onHint: openTheHint, onPoint: setPointed, onMap: setMapping, mapping: mapping, onBare: setBare, bare: bare, text: text })), ...(standings === undefined ? {} : { standings }), ...(studied === undefined ? {} : { analysis: summary === undefined ? { by: analyst } : { by: analyst, summary } }), shownPlies: at, onShow: goTo, onStep: step, ...(studied === undefined ? {} : { onDownload: () => download(studied.pgn, pgnName(live.record.tags, "analysis")) }), ...(total === 0 ? {} : { onSaveMoves: () => download(writePgn(movesOnly(live.record)), pgnName(live.record.tags)) }), ...(between && game !== null ? { onAnalyse: () => void studyGame({ last: true }) } : {}), text: text })] })] }) }));
 }
 /** The picture of a player of the game in analysis: the player's own, the AI's Torretta with its mood, or the plain face of someone else. */
 function pictureOf({ who }, profile, size, mood) {

package/dist/page/game/column.js

@@ -45,7 +45,11 @@ function GameCard({ plies, result, how, lit, started, move, toMove, bar, text })
  * and the move the game left the book at.
  */
 function OpeningCard({ opening, text }) {
-    const [folded, toggleFold] = useCardFold("opening");
+    const [foldedHere, toggleFold] = useCardFold("opening");
     const book = opening.inBook ? text.inBook : `${text.outOfBook} ${outOfBookMove(opening)}`;
-    return (_jsxs("section", { class: `card opening${folded ? " folded" : ""}`, "aria-label": text.opening, children: [_jsx("h3", { class: "family", children: _jsxs(FoldButton, { folded: folded, onFold: toggleFold, text: text, children: [_jsx("span", { class: `book${opening.inBook ? "" : " out"}`, title: book, role: "img", "aria-label": book, children: _jsxs("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: [_jsx("path", { d: "M12 6.5C10 5 7 4.5 4 5V18C7 17.5 10 18 12 19.5C14 18 17 17.5 20 18V5C17 4.5 14 5 12 6.5ZM12 6.5V19.5" }), opening.inBook ? null : _jsx("path", { d: "M3.5 3.5L20.5 20.5" })] }) }), _jsx("b", { children: opening.family })] }) }), folded || opening.variation === undefined ? null : _jsx("p", { class: "variation", children: opening.variation }), folded || opening.inBook ? null : _jsxs("p", { class: "out", children: [text.outOfBook, " ", outOfBookMove(opening)] })] }));
+    // The family alone has nothing under it to fold: no button, no chevron (Stefano).
+    const foldable = opening.variation !== undefined || !opening.inBook;
+    const folded = foldable && foldedHere;
+    const title = (_jsxs(_Fragment, { children: [_jsx("span", { class: `book${opening.inBook ? "" : " out"}`, title: book, role: "img", "aria-label": book, children: _jsxs("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: [_jsx("path", { d: "M12 6.5C10 5 7 4.5 4 5V18C7 17.5 10 18 12 19.5C14 18 17 17.5 20 18V5C17 4.5 14 5 12 6.5ZM12 6.5V19.5" }), opening.inBook ? null : _jsx("path", { d: "M3.5 3.5L20.5 20.5" })] }) }), _jsx("b", { children: opening.family })] }));
+    return (_jsxs("section", { class: `card opening${folded ? " folded" : ""}`, "aria-label": text.opening, children: [_jsx("h3", { class: "family", children: foldable ? _jsx(FoldButton, { folded: folded, onFold: toggleFold, text: text, children: title }) : title }), folded || opening.variation === undefined ? null : _jsx("p", { class: "variation", children: opening.variation }), folded || opening.inBook ? null : _jsxs("p", { class: "out", children: [text.outOfBook, " ", outOfBookMove(opening)] })] }));
 }

package/dist/server/mcp.d.ts

@@ -9,5 +9,5 @@ export declare function createMcpServer(context?: Context, list?: AnyCommand[]):
  * host goes and its input closes, once the calls still running have answered: a move half made would be lost.
  */
 export declare function startMcpServer(context?: Context, list?: AnyCommand[]): Promise<void>;
-/** The opponent's name for the page, from the host's: Claude Code and the desktop app are Claude, Codex is Codex; another host is unnamed. */
+/** The opponent's name for the page, from the host's (D-97): another host than Claude's and Codex is unnamed. */
 export declare function opponentOf(host: string | undefined): string | undefined;

package/dist/server/mcp.js

@@ -3,7 +3,8 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import { aiMove, commands, defaultContext, inputProblems, isBoolean, PositionChanged } from "../commands/index.js";
-import { endOf, loadGame, noteAiModel } from "../games/index.js";
+import { aiNameOf } from "../core/index.js";
+import { endOf, loadGame, noteAiHost, noteAiModel } from "../games/index.js";
 import { hasAgent } from "../host-files/index.js";
 import { gameFolder } from "../profiles/index.js";
 import { version } from "../version.js";
@@ -19,6 +20,8 @@ export function createMcpServer(context = defaultContext(), list = commands) {
     // The server keeps what it told the chat, the instructions a tool gives once, and the position it showed: none yet (D-71).
     context.told ??= new Set();
     context.positionSeen ??= null;
+    // The host the chat runs in, as it introduced itself: it names the AI on the page and in the game's PGN (D-97).
+    context.host ??= () => server.server.getClientVersion()?.name;
     const forOneHost = [];
     for (const command of list.filter((each) => each.cliOnly !== true)) {
         const tool = server.registerTool(command.name, toolConfig(command), async (input, extra) => {
@@ -63,13 +66,12 @@ export async function startMcpServer(context = defaultContext(), list = commands
     process.stdin.on("end", leave);
     process.stdin.on("close", leave);
     const server = createMcpServer(context, list);
-    context.host = () => server.server.getClientVersion()?.name;
     context.page = await pageOf(context, () => opponentOf(context.host?.()));
     await server.connect(new StdioServerTransport());
 }
-/** The opponent's name for the page, from the host's: Claude Code and the desktop app are Claude, Codex is Codex; another host is unnamed. */
+/** The opponent's name for the page, from the host's (D-97): another host than Claude's and Codex is unnamed. */
 export function opponentOf(host) {
-    return /claude/i.test(host ?? "") ? "Claude" : /codex/i.test(host ?? "") ? "Codex" : undefined;
+    return aiNameOf(host);
 }
 /** The board page of the player's folder, served by this process for as long as the chat lasts (D-47); without it the game goes on in the chat. */
 async function pageOf(context, opponent) {
@@ -93,14 +95,18 @@ async function pageOf(context, opponent) {
     }
 }
 /**
- * Who played the AI's move, read once the move has gone back to the chat, and kept in memory (D-82): the AI's card on the page shows it, and the game's
- * PGN once it ends; a change shows from the next move. A host that ties no model to the call leaves the last one known.
+ * Who played the AI's move, its host and model, read once the move has gone back to the chat, and kept in memory (D-82, D-97): the AI's card on the
+ * page shows it, and the game's PGN once it ends; a change shows from the next move. A host that ties no model to the call leaves the last one known.
  */
 function noteTheAi(context, caller) {
     // Claude Code writes the call's line a few milliseconds late: read after the answer, it costs the AI's clock nothing (D-13).
     setImmediate(() => {
         // Nothing that fails here may stop the server: the move is played and answered.
         caller().then((found) => {
+            const host = context.host?.();
+            if (host !== undefined && host.trim() !== "") {
+                noteAiHost(gameFolder(context.home()), host);
+            }
             if (found === undefined || found.hostOnly === true) {
                 return;
             }

package/package.json

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