chesspal 0.4.0 → 0.5.0

package/dist/page/app/app.js

@@ -43,7 +43,7 @@ import { AiNote, AiWords, Compose, PointSquare, TalkFaces } from "../talk/talk.j
 import { textFor } from "../text.js";
 import { anchorName, useAnchor } from "./anchor.js";
 import { useBrowseKeys, useFoldKeys, useLegendKey, useMapKey, useWheelSteps } from "./keys.js";
-import { phaseOf, verdictOf } from "./phase.js";
+import { helpsShown, phaseOf, verdictOf } from "./phase.js";
 import { ask, post, refusedText, sendMessage, sendMove, useServed } from "./served.js";
 import { tabTitle, useTabTitle } from "./title.js";
 /**
@@ -87,8 +87,9 @@ export function App({ start }) {
         setChatToReview(false);
         setDialog(first ? "chat" : "new-game");
     };
+    // In analysis the chat is who answers on the game: its window asks who reviews it.
     const askChat = () => {
-        setChatToReview(false);
+        setChatToReview(served?.analysis !== undefined);
         setDialog("chat");
     };
     const closeChat = () => {
@@ -130,7 +131,7 @@ export function App({ start }) {
             apply(settingsFrom(served.settings));
         }
     }, [profileId]);
-    // The AI as the host names it (Claude, Codex), also where the page sends the player to write; the last known while the page is offline.
+    // The AI as the host names it (Claude, Codex, Gemini), also where the page sends the player to write; the last known while the page is offline.
     const name = served?.opponent ?? text.ai;
     // Under it, the model and effort the AI played its last move with (D-82).
     const signed = served?.aiModel === undefined ? undefined : signature(served.aiModel.model, served.aiModel.effort);
@@ -207,14 +208,15 @@ export function App({ start }) {
     const shown = useMemo(() => past ?? (pending === undefined ? live : withMove(live, pending)), [live, pending, past]);
     // A square lit from the AI's words goes off with the position: a touch keeps it lit until then, a mouse until it leaves the word.
     useEffect(() => setPointed(noSquares), [shown]);
-    // 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).
+    // The player sees all of Chesspal's facts, whatever the AI's level (D-79): in a game with the helps on, always in analysis (D-114).
     const analysing = studied !== undefined;
+    const helped = helpsShown(phase, settings.helps);
     // 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 ?? "", 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 helps = useMemo(() => helped ? helpsOf(shown, you) : undefined, [shown, helped, you]);
+    // Who the AI saw ahead, the coach's 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";
-    const standings = useMemo(() => (going && settings.helps) || analysing ? standingsOf(plies, drawnOnBoard) : undefined, [plies, drawnOnBoard, going, analysing, settings.helps]);
+    const standings = useMemo(() => helped ? standingsOf(plies, drawnOnBoard) : undefined, [plies, drawnOnBoard, helped]);
     useMapKey(helps !== undefined, setMapping);
     // A new move or a new game ends what the player was doing on the one before: the move sent, the look back, the choice of a promotion. The same game
     // sent again, for the talk, the coach's words or the settings, leaves them where they are (Zoe); so does a review written on the game in analysis.
@@ -297,7 +299,7 @@ export function App({ start }) {
     const header = (_jsx(Header, { text: text, kind: kind, verdict: verdict, ...(!ended && (offer === "ai" || declined) ? { who: name } : {}), actions: actions, onNewGame: served === undefined ? undefined : askNewGame, 
         // Between games the new one stands out in the player's card (D-77): in the header only when the talk, and the card with it, is folded away.
         standOut: studied !== undefined || (between && folds.talk !== "open"), onStudy: served === undefined || going ? undefined : () => setDialog("study"), flipped: flipped, onFlip: () => setFlipped(!flipped), sound: sound, onSound: () => change({ ...settings, sound: !sound }), onTheme: switchTheme, onSettings: () => setSetting(true), onGuide: () => setDialog("guide"), ...(served === undefined ? {} : { profile: served.profile, onProfile: () => setDialog("profiles") }), ...(served?.update === undefined || served.table === undefined || offline ? {} : { update: { version: served.update.version, installing: served.update.installing === true }, onUpdate: () => setDialog("update") }) }));
-    const panel = _jsx(SettingsPanel, { open: setting, settings: settings, onChange: change, onClose: () => setSetting(false), text: text });
+    const panel = _jsx(SettingsPanel, { open: setting, settings: settings, analysing: analysing, onChange: change, onClose: () => setSetting(false), text: text });
     // The guide opens before the page has its data too.
     const guide = _jsx(GuideDialog, { open: dialog === "guide", onClose: () => setDialog(undefined), text: text });
     if (problem !== undefined) {
@@ -367,6 +369,8 @@ export function App({ start }) {
     // Where to wake the chat, under the AI's card (over the board when the talk is folded); the button that starts the clocks, under the player's (Zoe).
     // On the table, what its chat is doing stands there, and in a game with no chat at it a line that opens the chat's window (D-107).
     const table = offline ? undefined : served.table;
+    // In analysis the chat that answers stands over the box: its name opens its window, as on the AI's card in a game.
+    const chatName = table === undefined ? undefined : _jsx(AiNameButton, { name: name, table: table, onOpen: askChat, text: text });
     const atTable = table === undefined ? null : tableNote({ table, name, inGame: going, onOpen: askChat, text });
     const asleepNote = atTable !== null
         ? atTable
@@ -473,7 +477,7 @@ export function App({ start }) {
                                 ? (_jsxs(_Fragment, { children: [_jsxs("section", { class: "ai-block", "aria-label": sides[ai].name, children: [studiedCard(ai, "ai"), asleepNote, _jsx(AiNote, { ...(reviewed === undefined ? {} : { ply: reviewed }), ...(shownOpening === undefined ? {} : { opening: shownOpening }), ...(at === total && closing !== undefined ? { closing } : {}), ...(at === 0 && summary !== undefined ? { summary } : {}), ...(reviewing ? { reviewing: true } : {}), ...(count === undefined ? {} : { count }), ...(completeIt === undefined ? {} : { onComplete: completeIt }), name: analyst, by: annotator, mood: mood, ...(voiced ? { voice: text } : {}), text: text })] }), _jsxs("section", { class: "you-block", "aria-label": sides[player].name, children: [_jsx("div", { class: "chat", children: _jsx(Compose, { lines: analysisTalk(talk, studied.name), newestFirst: false, spent: 0, draft: draft, onDraft: (words) => {
                                                             setDraft(words);
                                                             setUnsent(undefined);
-                                                        }, onSend: () => sendWords({ game: studied.name, at }), canMove: false, name: name, problem: unsent, about: { ...(at === 0 ? {} : { ply: plies[at - 1] }), onShow: goTo }, text: text }) }), studiedCard(player, "you")] })] }))
+                                                        }, onSend: () => sendWords({ game: studied.name, at }), canMove: false, name: name, problem: unsent, about: { ...(at === 0 ? {} : { ply: plies[at - 1] }), onShow: goTo }, ...(chatName === undefined ? {} : { to: chatName }), text: text }) }), studiedCard(player, "you")] })] }))
                                 : (_jsxs(_Fragment, { children: [_jsxs("section", { class: "ai-block", "aria-label": name, children: [_jsx(PlayerCard, { place: "ai", picture: thinker(48), name: table === undefined ? name : _jsx(AiNameButton, { name: name, table: table, onOpen: askChat, text: text }), 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, ...(voiced ? { voice: text } : {}) })] }), _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) => {

package/dist/page/app/phase.js

@@ -14,6 +14,10 @@ export function phaseOf(analysing, game, over, sawEnd) {
     }
     return sawEnd ? "over" : "idle";
 }
+/** Whether the board shows the helps: always in analysis, where the player uses every tool there is (D-114); in a game, with the helps `switched` on. */
+export function helpsShown(phase, switched) {
+    return phase === "analysis" || (phase === "going" && switched);
+}
 /** What the header says of the game, with the kind that gives it a colour and an icon: in analysis, none going on, how it ended, or the draw offered. */
 export function verdictOf(phase, how, winner, offer, declined, text) {
     if (phase === "analysis") {

package/dist/page/dialogs/settings.js

@@ -3,8 +3,8 @@ import { useEffect, useRef, useState } from "preact/hooks";
 import { Piece } from "../pieces/pieces.js";
 import { looks, pieceSets } from "../profile/settings.js";
 import { hasVoice, onVoices } from "../talk/voice.js";
-/** The panel of the settings, open while `open` is true: every change goes to `onChange` at once. */
-export function SettingsPanel({ open, settings, onChange, onClose, text }) {
+/** The panel of the settings, open while `open` is true: every change goes to `onChange` at once; `analysing` while a game is in analysis. */
+export function SettingsPanel({ open, settings, analysing, onChange, onClose, text }) {
     const dialog = useRef(null);
     const voiced = useVoiced(text.language);
     useEffect(() => {
@@ -17,7 +17,7 @@ export function SettingsPanel({ open, settings, onChange, onClose, text }) {
         }
     }, [open]);
     const set = (key, value) => onChange({ ...settings, [key]: value });
-    return (_jsxs("dialog", { ref: dialog, class: "dialog", "aria-label": text.settings, onClose: onClose, onClick: (event) => event.target === dialog.current && onClose(), children: [_jsxs("header", { children: [_jsx("h2", { children: text.settings }), _jsx("button", { class: "icon-button", type: "button", title: text.close, "aria-label": text.close, onClick: onClose, children: _jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M6 6L18 18M18 6L6 18" }) }) })] }), _jsxs("div", { class: "setting-columns", children: [_jsxs(Section, { title: text.look, icon: lookIcon, children: [_jsxs("div", { class: "setting-group", children: [_jsx("p", { class: "setting-label", children: text.themeChoice }), _jsx(Segments, { label: text.themeChoice, children: ["system", "light", "dark"].map((theme) => _jsx(Choice, { on: settings.theme === theme, onPick: () => set("theme", theme), children: text.themes[theme] }, theme)) })] }), _jsxs("div", { class: "setting-group", children: [_jsxs("p", { class: "setting-label", children: [text.boardSkin, " ", _jsx("b", { children: nameOf(settings.board, text) })] }), _jsx(Swatches, { look: "board", label: text.boardSkin, settings: settings, onPick: (id) => set("board", id), text: text })] }), _jsxs("div", { class: "setting-group", children: [_jsx("p", { class: "setting-label", children: text.pieceSet }), _jsx("div", { class: "piece-sets", role: "radiogroup", "aria-label": text.pieceSet, children: pieceSets.map((pieceSet) => (_jsxs(Choice, { on: settings.set === pieceSet, onPick: () => set("set", pieceSet), children: [_jsxs("span", { class: "sample", children: [_jsx(Piece, { letter: "N", set: pieceSet }), _jsx(Piece, { letter: "n", set: pieceSet })] }), nameOf(pieceSet, text)] }, pieceSet))) })] }), _jsxs("div", { class: "setting-group setting-pair", children: [_jsxs("div", { children: [_jsx("p", { class: "setting-label", children: text.pieceColours }), _jsx(Swatches, { look: "pieces", label: text.pieceColours, settings: settings, onPick: (id) => set("pieces", id), text: text })] }), _jsxs("div", { children: [_jsx("p", { class: "setting-label", children: text.marksColour }), _jsx(Swatches, { look: "marks", label: text.marksColour, settings: settings, onPick: (id) => set("marks", id), text: text })] })] })] }), _jsxs("div", { class: "setting-column", children: [_jsxs(Section, { title: text.play, icon: playIcon, children: [_jsx(Switch, { on: settings.dots, onSwitch: (on) => set("dots", on), children: text.dots }), _jsx(Switch, { on: settings.squareNames, onSwitch: (on) => set("squareNames", on), children: text.squareNames }), _jsx(Switch, { on: settings.explain, onSwitch: (on) => set("explain", on), children: text.explain }), _jsx(Switch, { on: settings.book, onSwitch: (on) => set("book", on), children: text.bookBadges }), _jsx(Switch, { on: settings.helps, onSwitch: (on) => set("helps", on), children: text.helps }), _jsx(Switch, { on: settings.sound, onSwitch: (on) => set("sound", on), children: text.sounds }), _jsx(Switch, { on: settings.voice, onSwitch: (on) => set("voice", on), ...(voiced ? {} : { unavailable: text.noVoice }), children: text.voice })] }), _jsx(Section, { title: text.languageChoice, icon: languageIcon, children: _jsx(Segments, { label: text.languageChoice, children: ["auto", "it", "en"].map((language) => _jsx(Choice, { on: settings.language === language, onPick: () => set("language", language), children: text.languages[language] }, language)) }) })] })] })] }));
+    return (_jsxs("dialog", { ref: dialog, class: "dialog", "aria-label": text.settings, onClose: onClose, onClick: (event) => event.target === dialog.current && onClose(), children: [_jsxs("header", { children: [_jsx("h2", { children: text.settings }), _jsx("button", { class: "icon-button", type: "button", title: text.close, "aria-label": text.close, onClick: onClose, children: _jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M6 6L18 18M18 6L6 18" }) }) })] }), _jsxs("div", { class: "setting-columns", children: [_jsxs(Section, { title: text.look, icon: lookIcon, children: [_jsxs("div", { class: "setting-group", children: [_jsx("p", { class: "setting-label", children: text.themeChoice }), _jsx(Segments, { label: text.themeChoice, children: ["system", "light", "dark"].map((theme) => _jsx(Choice, { on: settings.theme === theme, onPick: () => set("theme", theme), children: text.themes[theme] }, theme)) })] }), _jsxs("div", { class: "setting-group", children: [_jsxs("p", { class: "setting-label", children: [text.boardSkin, " ", _jsx("b", { children: nameOf(settings.board, text) })] }), _jsx(Swatches, { look: "board", label: text.boardSkin, settings: settings, onPick: (id) => set("board", id), text: text })] }), _jsxs("div", { class: "setting-group", children: [_jsx("p", { class: "setting-label", children: text.pieceSet }), _jsx("div", { class: "piece-sets", role: "radiogroup", "aria-label": text.pieceSet, children: pieceSets.map((pieceSet) => (_jsxs(Choice, { on: settings.set === pieceSet, onPick: () => set("set", pieceSet), children: [_jsxs("span", { class: "sample", children: [_jsx(Piece, { letter: "N", set: pieceSet }), _jsx(Piece, { letter: "n", set: pieceSet })] }), nameOf(pieceSet, text)] }, pieceSet))) })] }), _jsxs("div", { class: "setting-group setting-pair", children: [_jsxs("div", { children: [_jsx("p", { class: "setting-label", children: text.pieceColours }), _jsx(Swatches, { look: "pieces", label: text.pieceColours, settings: settings, onPick: (id) => set("pieces", id), text: text })] }), _jsxs("div", { children: [_jsx("p", { class: "setting-label", children: text.marksColour }), _jsx(Swatches, { look: "marks", label: text.marksColour, settings: settings, onPick: (id) => set("marks", id), text: text })] })] })] }), _jsxs("div", { class: "setting-column", children: [_jsxs(Section, { title: text.play, icon: playIcon, children: [_jsx(Switch, { on: settings.dots, onSwitch: (on) => set("dots", on), children: text.dots }), _jsx(Switch, { on: settings.squareNames, onSwitch: (on) => set("squareNames", on), children: text.squareNames }), _jsx(Switch, { on: settings.explain, onSwitch: (on) => set("explain", on), children: text.explain }), _jsx(Switch, { on: settings.book, onSwitch: (on) => set("book", on), children: text.bookBadges }), _jsx(Switch, { on: settings.helps, onSwitch: (on) => set("helps", on), ...(analysing ? { locked: { on: true, why: text.helpsInAnalysis } } : {}), children: text.helps }), _jsx(Switch, { on: settings.sound, onSwitch: (on) => set("sound", on), children: text.sounds }), _jsx(Switch, { on: settings.voice, onSwitch: (on) => set("voice", on), ...(voiced ? {} : { locked: { on: false, why: text.noVoice } }), children: text.voice })] }), _jsx(Section, { title: text.languageChoice, icon: languageIcon, children: _jsx(Segments, { label: text.languageChoice, children: ["auto", "it", "en"].map((language) => _jsx(Choice, { on: settings.language === language, onPick: () => set("language", language), children: text.languages[language] }, language)) }) })] })] })] }));
 }
 // The sections' line icons: a palette, a pawn, a globe.
 const lookIcon = (_jsxs(_Fragment, { children: [_jsx("path", { d: "M12 3a9 9 0 1 0 0 18c1.2 0 1.8-.8 1.8-1.7 0-1.2-1-1.6-1-2.6 0-1 .8-1.7 1.8-1.7H17a4 4 0 0 0 4-4C21 6.5 17 3 12 3Z" }), _jsx("circle", { cx: "7.5", cy: "11", r: "1.2" }), _jsx("circle", { cx: "10", cy: "7", r: "1.2" }), _jsx("circle", { cx: "14.5", cy: "7", r: "1.2" })] }));
@@ -36,10 +36,9 @@ function Segments({ label, children }) {
 function Choice({ on, onPick, children }) {
     return (_jsx("button", { type: "button", role: "radio", "aria-checked": on, onClick: onPick, children: children }));
 }
-/** A switch; one that cannot be used here is off and disabled, and its tooltip says why. */
-function Switch({ on, onSwitch, unavailable, children }) {
-    const usable = unavailable === undefined;
-    return (_jsxs("label", { class: "switch", title: unavailable, children: [_jsx("span", { children: children }), _jsx("input", { type: "checkbox", role: "switch", checked: on && usable, disabled: !usable, title: unavailable, onChange: (event) => onSwitch(event.currentTarget.checked) })] }));
+/** A switch; one `locked` here holds its value, disabled, and its tooltip says why. */
+function Switch({ on, onSwitch, locked, children }) {
+    return (_jsxs("label", { class: "switch", title: locked?.why, children: [_jsx("span", { children: children }), _jsx("input", { type: "checkbox", role: "switch", checked: locked?.on ?? on, disabled: locked !== undefined, title: locked?.why, onChange: (event) => onSwitch(event.currentTarget.checked) })] }));
 }
 /** Whether the browser has a voice for the language, looked at again whenever its voices change. */
 function useVoiced(language) {

package/dist/page/guide/en.md

@@ -18,7 +18,7 @@ No chess engine plays for the AI: every move and every judgment is its own. Ches
 
 ### Getting started
 
-1. Click the **AI's name**, at the top left, and choose its chat among those on your computer: **Claude Code** or **Codex**. It opens in a window of its own: keep it open while you play. The first time it asks some questions. Whether you trust the folder: **Yes** (in Claude Code No is chosen already: go down to Yes with the arrow keys, then Enter). With Codex, about the hooks, Chesspal's two helpers: **Trust all and continue**. On Windows Codex also asks whether to set up its sandbox, the protected space it works in: choose the first option, and yes when Windows asks for permission.
+1. Click the **AI's name**, at the top left, and choose its chat among those on your computer: **Claude Code**, **Codex** or **Antigravity**. It opens in a window of its own: keep it open while you play. The first time it asks some questions. Whether you trust the folder: **Yes** (in Claude Code No is chosen already: go down to Yes with the arrow keys, then Enter). With Codex, about the hooks, Chesspal's two helpers: **Trust all and continue**. On Windows Codex also asks whether to set up its sandbox, the protected space it works in: choose the first option, and yes when Windows asks for permission.
 2. Press **New game**, choose your colour, the clock and the AI's level, and press **Start**.
 3. Move: the AI answers on the board, and with a few words under its name.
 
@@ -37,14 +37,14 @@ No chess engine plays for the AI: every move and every judgment is its own. Ches
 
 - You talk with the AI in the **box under its name**, a few words with each move: it reads them with your move. You can also write to it in its window. With Codex, if you write there while it waits for your move, press **Esc** after Enter: else it reads your message only after your move.
 - A **move written** in the chat counts too: `e4`, `Nf3`, with the English letters of the pieces (K Q R B N), or in words.
-- **The AI's name** opens the choice of its chat: Claude Code or Codex, the model (which AI: some are faster, others stronger) and how much it reasons. The more it reasons, the slower it plays. If you change them, the chat starts afresh in the same window: the AI forgets what you talked about, and the game stays as it is.
+- **The AI's name** opens the choice of its chat: Claude Code, Codex or Antigravity, the model (which AI: some are faster, others stronger) and how much it reasons. The more it reasons, the slower it plays. If you change them, the chat starts afresh in the same window: the AI forgets what you talked about, and the game stays as it is. In analysis the name stands over the box where you write to it.
 - At each **new game**, the chat the page opened starts afresh by itself, once the AI has stopped thinking: a long chat makes the AI slower.
 
 ## Helps and marks
 
 ![Coloured arrows and badges on the board, beside the helps' card](helps)
 
-- With **"The AI teaches as you play"**, in the settings, the **Helps** card shows the pieces in danger, the pins and the pawns, and the AI, as your coach, gives you an idea.
+- With **"The AI teaches as you play"**, in the settings, the **Helps** card shows the pieces in danger, the pins and the pawns, and the AI, as your coach, gives you an idea. In analysis the card and its marks are always there.
 - The AI draws **coloured arrows** on the board: the **?** beside the moves explains every mark.
 - In the review, a **badge** on a move gives the AI's judgment: a great move, an inaccuracy, a blunder.
 

package/dist/page/guide/it.md

@@ -18,7 +18,7 @@ Nessun motore di scacchi gioca al posto dell'AI: ogni mossa e ogni giudizio sono
 
 ### Per cominciare
 
-1. Clicca il **nome dell'AI**, in alto a sinistra, e scegli la chat fra quelle che hai sul computer: **Claude Code** o **Codex**. Si apre in una finestra sua: tienila aperta mentre giochi. La prima volta fa qualche domanda. Se ti fidi della cartella: **Sì** (in Claude Code è già scelto No: scendi su Yes con le frecce, poi Invio). Con Codex, sugli hook, i due aiutanti di Chesspal: **Trust all and continue**. Su Windows Codex chiede anche se preparare la sua sandbox, lo spazio protetto dove lavora: scegli la prima opzione, e sì quando Windows chiede il permesso.
+1. Clicca il **nome dell'AI**, in alto a sinistra, e scegli la chat fra quelle che hai sul computer: **Claude Code**, **Codex** o **Antigravity**. Si apre in una finestra sua: tienila aperta mentre giochi. La prima volta fa qualche domanda. Se ti fidi della cartella: **Sì** (in Claude Code è già scelto No: scendi su Yes con le frecce, poi Invio). Con Codex, sugli hook, i due aiutanti di Chesspal: **Trust all and continue**. Su Windows Codex chiede anche se preparare la sua sandbox, lo spazio protetto dove lavora: scegli la prima opzione, e sì quando Windows chiede il permesso.
 2. Premi **Nuova partita**, scegli il colore, l'orologio e il livello dell'AI, e premi **Inizia**.
 3. Muovi: l'AI risponde sulla scacchiera, e con qualche parola sotto il suo nome.
 
@@ -37,14 +37,14 @@ Nessun motore di scacchi gioca al posto dell'AI: ogni mossa e ogni giudizio sono
 
 - Parli con l'AI nella **casella sotto il suo nome**, qualche parola a ogni mossa: le legge con la tua mossa. Puoi scriverle anche nella sua finestra. Con Codex, se gli scrivi lì mentre aspetta la tua mossa, dopo Invio premi **Esc**: se no legge il messaggio solo dopo la tua mossa.
 - Anche una **mossa scritta** nella chat vale: `e4`, `Nf3`, con le lettere inglesi dei pezzi (K Q R B N), o a parole.
-- **Il nome dell'AI** apre la scelta della chat: Claude Code o Codex, il modello (quale AI: alcune sono più veloci, altre più forti) e quanto ragiona. Più ragiona, più gioca lenta. Se cambi, la chat riparte da capo nella stessa finestra: l'AI dimentica la chiacchierata di prima, la partita resta com'è.
+- **Il nome dell'AI** apre la scelta della chat: Claude Code, Codex o Antigravity, il modello (quale AI: alcune sono più veloci, altre più forti) e quanto ragiona. Più ragiona, più gioca lenta. Se cambi, la chat riparte da capo nella stessa finestra: l'AI dimentica la chiacchierata di prima, la partita resta com'è. Nell'analisi il nome sta sopra la casella dove le scrivi.
 - A ogni **nuova partita** la chat aperta dalla pagina riparte da capo da sola, se l'AI ha finito di pensare: una chat lunga rende l'AI più lenta.
 
 ## Gli aiuti e i segni
 
 ![Frecce colorate e bollini sulla scacchiera, accanto alla scheda degli aiuti](helps)
 
-- Con **«L'AI ti insegna mentre giochi»**, nelle impostazioni, la scheda **Aiuti** mostra i pezzi in pericolo, le inchiodature e i pedoni, e l'AI, da allenatore, ti dà un'idea.
+- Con **«L'AI ti insegna mentre giochi»**, nelle impostazioni, la scheda **Aiuti** mostra i pezzi in pericolo, le inchiodature e i pedoni, e l'AI, da allenatore, ti dà un'idea. Nell'analisi la scheda e i suoi segni ci sono sempre.
 - L'AI disegna **frecce colorate** sulla scacchiera: il **?** accanto alle mosse spiega ogni segno.
 - Nel ripasso, un **bollino** su una mossa dice il giudizio dell'AI: un'ottima mossa, un'imprecisione, un errore grave.
 

package/dist/page/profile/settings.js

@@ -36,6 +36,8 @@ export function settingsFrom(value, defaults = { theme: "system", sound: true })
         claudeEffort: word(stored.claudeEffort),
         codexModel: word(stored.codexModel),
         codexEffort: word(stored.codexEffort),
+        antigravityModel: word(stored.antigravityModel),
+        antigravityEffort: word(stored.antigravityEffort),
     };
 }
 /** Remembers the settings in this browser. */

package/dist/page/table/action.js

@@ -2,6 +2,7 @@
 export const choiceKeys = {
     claude: { model: "claudeModel", effort: "claudeEffort" },
     codex: { model: "codexModel", effort: "codexEffort" },
+    antigravity: { model: "antigravityModel", effort: "antigravityEffort" },
 };
 /** The hosts the window offers: those installed whose choices the settings keep. */
 export function offeredHosts(table) {
@@ -13,14 +14,21 @@ export function firstHost(table, settings) {
     const atTable = offered.find((host) => table.chat && host.name === table.host);
     return (atTable ?? offered.find((host) => host.name === settings.chatHost) ?? offered[0])?.name;
 }
-/** A host's model or effort as the settings keep it: the host's middle one for none, and for a choice it no longer offers. */
+/** The efforts a host offers for one of its models: none for a model that has no effort to choose. */
+export function effortsOf(host, model) {
+    return host.modelEfforts?.[model] ?? host.efforts;
+}
+/**
+ * A host's model or effort as the settings keep it: the host's middle one for none, and for a choice it no longer offers; the effort among the chosen
+ * model's, none for a model without.
+ */
 export function chosen(host, kind, settings) {
-    const key = choiceKeys[host.name][kind];
-    return offeredOr(host, kind, settings[key]);
+    const keys = choiceKeys[host.name];
+    return offered(host, settings[keys.model], settings[keys.effort])[kind];
 }
 /** What the chat held started with: the host's middle one where the table does not say, or says one it no longer offers. */
 export function startedWith(table, host, kind) {
-    return offeredOr(host, kind, table.started?.[kind]);
+    return offered(host, table.started?.model, table.started?.effort)[kind];
 }
 /** What the button does with the host selected, none without one: with no chat, open one, to review the game in `review`; else start the chat again, in another host when it is not the one at the table. */
 export function chatAction(table, host, review) {
@@ -36,7 +44,11 @@ export function chatAction(table, host, review) {
 export function canAct(table) {
     return table.opening === undefined && table.waiting === undefined && (!table.chat || table.held);
 }
-function offeredOr(host, kind, value) {
-    const offered = kind === "model" ? host.models : host.efforts;
-    return value !== undefined && offered.includes(value) ? value : host[kind];
+// The choice kept to what the host offers, as the table keeps it when it starts the chat.
+function offered(host, model, effort) {
+    const kept = model !== undefined && host.models.includes(model) ? model : host.model;
+    const efforts = effortsOf(host, kept);
+    const middle = efforts.includes(host.effort) ? host.effort : efforts[Math.floor((efforts.length - 1) / 2)];
+    const keptEffort = effort !== undefined && efforts.includes(effort) ? effort : middle;
+    return keptEffort === undefined ? { model: kept } : { model: kept, effort: keptEffort };
 }

package/dist/page/table/window.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "preact/jsx-ru
 import { useEffect, useState } from "preact/hooks";
 import { Dialog } from "../dialogs/dialog.js";
 import { checkIcon } from "../dialogs/profiles.js";
-import { canAct, chatAction, choiceKeys, chosen, firstHost, offeredHosts, startedWith } from "./action.js";
+import { canAct, chatAction, choiceKeys, chosen, effortsOf, firstHost, offeredHosts, startedWith } from "./action.js";
 /** The chat's window: closed once a chat opens or starts again, the page then saying where it stands; `review` when it opened to have a game analysed. */
 export function ChatDialog({ open, review = false, table, settings, onChange, name, onClose, text }) {
     return (_jsx(Dialog, { open: open, title: review ? text.table.reviewTitle : text.table.title, onClose: onClose, text: text, children: _jsx(ChatForm, { review: review, table: table, settings: settings, onChange: onChange, name: name, onClose: onClose, text: text }) }));
@@ -41,7 +41,7 @@ export function chatState(table, name, text) {
     }
     return table.opening === "chat" ? words.opening : table.opening === "again" ? words.again(name) : table.opening === "restart" ? words.restart : undefined;
 }
-const hostTitles = { claude: "Claude Code", codex: "Codex" };
+const hostTitles = { claude: "Claude Code", codex: "Codex", antigravity: "Antigravity" };
 /** The ↻ of a chat that starts again. */
 const restartIcon = (_jsx("svg", { class: "icon in-use", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M19.5 12a7.5 7.5 0 1 1-2.2-5.3M19.5 4.5v4h-4" }) }));
 /** The window's form, made again at each opening with the host at the table selected, else the last the button used, else the first. */
@@ -94,17 +94,19 @@ function submitOnEnter(event) {
 /** A host's model or effort as a row of choices, its middle one chosen until the player chooses; the one the chat at the table `started` with bears a dot. */
 function Choices({ host, kind, settings, started, onChange, text }) {
     const key = choiceKeys[host.name][kind];
-    const offered = kind === "model" ? host.models : host.efforts;
+    // The efforts of the model chosen: none, and no row, for a model without.
+    const offered = kind === "model" ? host.models : effortsOf(host, chosen(host, "model", settings) ?? host.model);
     const value = chosen(host, kind, settings);
     if (offered.length === 0) {
         return null;
     }
     return (_jsxs("fieldset", { children: [_jsx("legend", { children: text.table[kind] }), _jsx("div", { class: "chat-choices", children: offered.map((one) => {
                     const words = one + (one === started ? ` · ${text.table.atTable}` : "");
-                    return (_jsxs("label", { class: one === started ? "level started" : "level", title: words, children: [_jsx("input", { type: "radio", name: `chat-${kind}`, checked: value === one, onChange: () => onChange({ ...settings, [key]: one }), "aria-label": words }), _jsx("span", { children: shortName(one) })] }, one));
+                    return (_jsxs("label", { class: one === started ? "level started" : "level", title: words, children: [_jsx("input", { type: "radio", name: `chat-${kind}`, checked: value === one, onChange: () => onChange({ ...settings, [key]: one }), "aria-label": words }), _jsx("span", { children: host.name === "codex" ? shortName(one) : one })] }, one));
                 }) })] }));
 }
-// Codex's models without the "gpt-" they all start with, so the choice stays narrow; the title keeps the whole name.
+// Codex's models without the "gpt-" they all start with, so the choice stays narrow; the title keeps the whole name. Another host's keep it: Antigravity's
+// GPT-OSS would read as "oss".
 function shortName(value) {
     return value.replace(/^gpt-/, "");
 }

package/dist/page/talk/talk.css

@@ -266,6 +266,14 @@
     color: var(--accent);
 }
 
+/* In analysis the chat that answers, over the box as its addressee: its name opens the chat's window, as on the AI's card in a game */
+.sent + .ai-name {
+    align-self: flex-start;
+    margin: 0 0 6px 12px;
+    color: var(--soft);
+    font-size: 0.875rem;
+}
+
 /* The bubbles: the AI's under its card, the tail under the Torretta's centre (14 px of padding, 48 px picture), and the player's above their box */
 .says,
 .sent {
@@ -328,6 +336,11 @@
     cursor: pointer;
 }
 
+/* In the game's review the mark ends the title's line */
+.review .head > .skip-reading {
+    margin-left: auto;
+}
+
 .skip-reading .icon {
     display: block;
     width: 16px;

package/dist/page/talk/talk.js

@@ -72,7 +72,7 @@ export function Legend({ review, words }) {
  * move takes them with it. 200 characters from one move of the AI's to the next: once they are written, the box goes until its move (D-54). In analysis the
  * AI's answers are in the same thread, each by a small Torretta, and each line of the player's names the move it was written on (D-101).
  */
-export function Compose({ lines, newestFirst, spent, draft, onDraft, onSend, canMove, name, problem, about, text }) {
+export function Compose({ lines, newestFirst, spent, draft, onDraft, onSend, canMove, name, problem, about, to, text }) {
     const list = useRef(null);
     useOnlyWhole(list, lines.map((line) => line.text));
     const left = talkLimits.line - spent;
@@ -87,7 +87,7 @@ export function Compose({ lines, newestFirst, spent, draft, onDraft, onSend, can
     };
     return (_jsxs(_Fragment, { children: [_jsx("ol", { ref: list, class: "sent", "aria-live": "polite", children: inOrder(lines.map((line, index) => (_jsxs("li", { class: line.who === "ai" ? "from-ai" : undefined, style: about === undefined ? aged(lines.length - 1 - index) : reread(index, lastAnswer), children: [line.who === "ai"
                             ? (_jsxs(_Fragment, { children: [_jsx(Torretta, { size: 24 }), _jsx("p", { class: "say", children: _jsx(Marked, { text: line.text }) })] }))
-                            : (_jsxs("p", { class: "said", children: [about === undefined || line.shown?.move === undefined ? null : _jsx(ShownMove, { move: line.shown.move, onShow: () => about.onShow(line.shown.at), text: text }), line.text] })), index === lastWritten ? _jsx(Status, { heard: line.heard, name: name, text: text }) : null] }, index))), newestFirst) }), left <= 0 ? null : (_jsxs("form", { class: about === undefined ? "compose" : "compose asking", onSubmit: (event) => {
+                            : (_jsxs("p", { class: "said", children: [about === undefined || line.shown?.move === undefined ? null : _jsx(ShownMove, { move: line.shown.move, onShow: () => about.onShow(line.shown.at), text: text }), line.text] })), index === lastWritten ? _jsx(Status, { heard: line.heard, name: name, text: text }) : null] }, index))), newestFirst) }), to, left <= 0 ? null : (_jsxs("form", { class: about === undefined ? "compose" : "compose asking", onSubmit: (event) => {
                     event.preventDefault();
                     submit();
                 }, children: [_jsx("p", { class: "limit", role: "status", children: problem ?? "" }), _jsx("textarea", { rows: 2, maxLength: left, placeholder: prompt, "aria-label": prompt, value: draft, onInput: (event) => onDraft(event.currentTarget.value), onKeyDown: (event) => {
@@ -135,7 +135,7 @@ function squareIn(word) {
 /** The AI's word on the whole game (D-69), in the Torretta's bubble at the start of the game: a paragraph, and its points as a list. */
 function GameReview({ by, summary, skipping, text }) {
     const [lead = "", ...points] = summary.split(/\s*•\s+/);
-    return (_jsxs("section", { class: "say review", "aria-label": text.reviewBy(by), children: [skipping, _jsxs("p", { class: "head", children: [_jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M12 4V20M8 20H16M5 7H19M5 7L2.5 13A2.5 2 0 0 0 7.5 13ZM19 7L16.5 13A2.5 2 0 0 0 21.5 13Z" }) }), text.reviewBy(by)] }), lead === "" ? null : (_jsx("p", { children: _jsx(Marked, { text: lead }) })), points.length === 0 ? null : (_jsx("ul", { children: points.map((point, index) => (_jsx("li", { children: _jsx(Marked, { text: point }) }, index))) }))] }));
+    return (_jsxs("section", { class: "say review", "aria-label": text.reviewBy(by), children: [_jsxs("p", { class: "head", children: [_jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M12 4V20M8 20H16M5 7H19M5 7L2.5 13A2.5 2 0 0 0 7.5 13ZM19 7L16.5 13A2.5 2 0 0 0 21.5 13Z" }) }), text.reviewBy(by), skipping] }), lead === "" ? null : (_jsx("p", { children: _jsx(Marked, { text: lead }) })), points.length === 0 ? null : (_jsx("ul", { children: points.map((point, index) => (_jsx("li", { children: _jsx(Marked, { text: point }) }, index))) }))] }));
 }
 function RailPlayer({ place, picture, name, side, moves, unread = false }) {
     return (_jsxs("div", { class: `rail-player ${place}${moves ? " moving" : ""}`, children: [_jsx("span", { class: `face${unread ? " unread" : ""}`, children: picture }), _jsxs("span", { class: "rail-name", children: [name, " ", side === undefined ? null : _jsxs("span", { class: "note", children: ["\u00B7 ", side] })] })] }));

package/dist/page/text.js

@@ -30,6 +30,7 @@ const english = {
     sounds: "Sounds",
     voice: "Read the AI's words aloud",
     noVoice: "This browser has no voice for this language: add one in your system's settings",
+    helpsInAnalysis: "In analysis the helps are always on: the switch counts in a game",
     skipReading: "Stop reading this aloud",
     saidMove: (move) => moveInWords(englishMoveWords, move),
     newGame: "New game",
@@ -181,7 +182,7 @@ const english = {
         byHand: (name) => `You opened this chat yourself: change ${name}'s model with /model in its window, or close it and open one from here, with the choices below.`,
         noChat: "No chat at the table: choose one",
         change: "Change the chat or its model",
-        install: (name) => `To play with ${name}, install Claude Code or Codex, then open this page again.`,
+        install: (name) => `To play with ${name}, install Claude Code, Codex or Antigravity, then open this page again.`,
         chat: "Chat",
         model: "Model",
         effort: "Effort",
@@ -468,6 +469,7 @@ const italian = {
     sounds: "Suoni",
     voice: "Leggi ad alta voce le parole dell'AI",
     noVoice: "Questo browser non ha una voce per questa lingua: aggiungila nelle impostazioni del sistema",
+    helpsInAnalysis: "Nell'analisi gli aiuti sono sempre accesi: l'interruttore vale in partita",
     skipReading: "Smetti di leggere questo a voce",
     saidMove: (move) => moveInWords(italianMoveWords, move),
     newGame: "Nuova partita",
@@ -619,7 +621,7 @@ const italian = {
         byHand: (name) => `Questa chat l'hai aperta tu: cambia il modello di ${name} con /model nella sua finestra, oppure chiudila e aprine una da qui, con le scelte qui sotto.`,
         noChat: "Nessuna chat al tavolo: scegline una",
         change: "Cambia la chat o il modello",
-        install: (name) => `Per giocare con ${name}, installa Claude Code o Codex, poi apri di nuovo questa pagina.`,
+        install: (name) => `Per giocare con ${name}, installa Claude Code, Codex o Antigravity, poi apri di nuovo questa pagina.`,
         chat: "Chat",
         model: "Modello",
         effort: "Ragionamento",

package/dist/server/bell/antigravity.d.ts

@@ -0,0 +1,10 @@
+/** Antigravity's own folder, where its command line keeps its history and its log. */
+export declare function antigravityFolder(userHome?: string): string;
+/**
+ * Watches, from now on, whether the player starts a new turn in the conversation: writes in the chat, or stops it with Esc. `started` resolves then, never
+ * otherwise; `stop` ends the watch.
+ */
+export declare function watchNewTurn(conversation: string, folder?: string, every?: number): {
+    started: Promise<void>;
+    stop: () => void;
+};

package/dist/server/bell/antigravity.js

@@ -0,0 +1,75 @@
+// Antigravity's Stop hook holds the chat until it ends: a message the player writes meanwhile waits behind it, and Esc leaves it running. Antigravity's own
+// files tell either: the history of what the player typed, with the conversation it went to, and its log, which notes the conversation stopped.
+import { closeSync, openSync, readSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/** Antigravity's own folder, where its command line keeps its history and its log. */
+export function antigravityFolder(userHome = homedir()) {
+    return join(userHome, ".gemini", "antigravity-cli");
+}
+/**
+ * Watches, from now on, whether the player starts a new turn in the conversation: writes in the chat, or stops it with Esc. `started` resolves then, never
+ * otherwise; `stop` ends the watch.
+ */
+export function watchNewTurn(conversation, folder = antigravityFolder(), every = 500) {
+    const history = join(folder, "history.jsonl");
+    const log = join(folder, "cli.log");
+    const read = { [history]: sizeOf(history), [log]: sizeOf(log) };
+    let timer;
+    const started = new Promise((done) => {
+        timer = setInterval(() => {
+            if (wrote(newText(history, read), conversation) || stopped(newText(log, read), conversation)) {
+                clearInterval(timer);
+                done();
+            }
+        }, every);
+        timer.unref();
+    });
+    return { started, stop: () => clearInterval(timer) };
+}
+/** Whether these lines of Antigravity's history hold something the player typed in the conversation: a message, or a command such as /clear. */
+function wrote(lines, conversation) {
+    return lines.split("\n").some((line) => {
+        try {
+            return JSON.parse(line).conversationId === conversation;
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/** Whether these lines of Antigravity's log say the conversation was stopped, as Esc does. */
+function stopped(lines, conversation) {
+    return lines.includes(`Cancelling conversation ${conversation}`);
+}
+/** What a file gained since it was last read, as `read` keeps its size; a file that shrank, written anew, is read from its start. */
+function newText(file, read) {
+    const size = sizeOf(file);
+    const from = size < (read[file] ?? 0) ? 0 : read[file] ?? 0;
+    read[file] = size;
+    if (size <= from) {
+        return "";
+    }
+    try {
+        const descriptor = openSync(file, "r");
+        try {
+            const buffer = Buffer.alloc(size - from);
+            const length = readSync(descriptor, buffer, 0, buffer.length, from);
+            return buffer.subarray(0, length).toString("utf8");
+        }
+        finally {
+            closeSync(descriptor);
+        }
+    }
+    catch {
+        return "";
+    }
+}
+function sizeOf(file) {
+    try {
+        return statSync(file).size;
+    }
+    catch {
+        return 0;
+    }
+}

package/dist/server/bell/bell.d.ts

@@ -11,14 +11,17 @@ export declare class Bell {
     private busy;
     private woken;
     private hooked;
+    private stopWatch;
     private readonly news;
     private readonly changed;
+    private readonly stopped;
     /**
      * `news` says whether a ring no hook heard is still worth waking the chat for; `changed` is told when what the page shows of the chat may change: it
-     * starts or stops listening, the doorbell wakes it, its turn ends.
+     * starts or stops listening, the doorbell wakes it, its turn ends; `stopped` whether the host says the chat was stopped in its turn (Esc), which no
+     * hook tells.
      */
-    constructor(news?: () => boolean, changed?: () => void);
-    /** Whether the chat is in a turn, as far as the doorbell knows: a chat stopped with Esc stays in it until its next tool. */
+    constructor(news?: () => boolean, changed?: () => void, stopped?: () => boolean);
+    /** Whether the chat is in a turn, as far as the doorbell knows: a chat stopped with Esc stays in it until its next tool, or until a ring finds it stopped. */
     get inTurn(): boolean;
     /** Whether the doorbell woke the chat in the turn it is in. */
     get woke(): boolean;
@@ -35,6 +38,7 @@ export declare class Bell {
     /**
      * The player acted on the page: the hook waiting hears it now, or the next one as soon as it comes. In a host that runs no hook nothing tells the end of
      * a turn: an act the chat waits for finds it out of its turn, and nobody hears the player, unless the chat `mayBeAtWork` on the AI's move meanwhile.
+     * A chat stopped in its turn ends no turn either: while the ring waits, the doorbell looks every `stopCheck` whether the host says so.
      */
     ring(mayBeAtWork?: boolean): void;
     /**
@@ -45,7 +49,12 @@ export declare class Bell {
     /** The chat left the table (D-104): its process ended, and nobody is in a turn or waits for the bell; a ring no hook heard is no longer news for anyone. */
     chatLeft(): void;
     private tellIf;
+    /** A ring waits for a chat in its turn: a chat stopped there, which nobody hears, is out of it now, and the page says where to wake it. */
+    private watchForStop;
+    private waitsInTurn;
 }
+/** How often the doorbell looks whether a chat a ring waits for was stopped in its turn. */
+export declare const stopCheck = 2000;
 /**
  * Notes in the data folder the port a chat's page took off its folder's usual ports, one file per page, for the hook to find it there; then forgets, off
  * the caller's clock, the notes of its folder whose page is gone: nobody listens at the port, or another folder's page does. A page that answers late
@@ -56,11 +65,19 @@ export declare function notePagePort(home: string, folder: string, port: number,
 export declare function forgetPagePort(home: string, folder: string, port: number): void;
 /** What Codex's Stop hook answers to wake the chat: its turn goes on with the doorbell's line. */
 export declare const codexBellAnswer: string;
+/** What Antigravity's Stop hook answers to wake the chat: its turn goes on, the doorbell's line given as a system message (D-115). */
+export declare const antigravityBellAnswer: string;
+/** The host whose Stop hook runs `chesspal listen`, as its flag names it: Claude Code with none. */
+export type ListeningHost = "claude" | "codex" | "antigravity";
 /**
  * Reads the hook's input, waits for the bell, and ends the process as the host reads it: for Claude Code's asyncRewake, 2 with the line on stderr; for
- * Codex's Stop hook, 0 with its answer on stdout, since Windows PowerShell, which runs Codex's hooks, turns an exit code 2 into 1. Else 0, saying nothing.
+ * Codex's and Antigravity's Stop hooks, 0 with their answer on stdout, since Windows PowerShell, which runs Codex's hooks, turns an exit code 2 into 1.
+ * Else 0, saying nothing, or for Antigravity an empty answer, which lets its chat stop. Antigravity's hook holds the chat: it lets it go as soon as the
+ * player writes in the chat or stops it, without the bell.
  */
-export declare function listen(codex?: boolean): Promise<void>;
+export declare function listen(host?: ListeningHost): Promise<void>;
+/** What the hook says as it ends, by its host: the doorbell's line or answer when it rang; else nothing, but for Antigravity, which reads an answer. */
+export declare function hookAnswer(host: ListeningHost, rang: boolean): string | undefined;
 /**
  * Waits at the page of the hook's chat until the player moves there: true then; false when there is no page to wait at, or another hook takes its place.
  * The chat's own page is the one with its session; after /clear, which gives the hook a new one, the only page of its folder.