chesspal 0.4.1 → 0.6.0

package/dist/page/game/variation.js

@@ -0,0 +1,65 @@
+import { stepped } from "./browse.js";
+/** Whether the board shows a move of the line, not the game. */
+export function onLine(line) {
+    return line !== undefined && line.cursor > 0;
+}
+/**
+ * The line after the player moves `san` where the board stands, and how many of the game's moves the board shows by then: on the game, its own next move
+ * steps forward and the line's first move goes back into the line; any other starts a new line. On the line, its own next move steps forward and any other
+ * cuts the line there and goes on with it.
+ */
+export function afterMove(line, game, shown, san) {
+    if (line !== undefined && line.cursor > 0) {
+        const moves = line.moves[line.cursor] === san ? line.moves : [...line.moves.slice(0, line.cursor), san];
+        return { line: { at: line.at, moves, cursor: line.cursor + 1 }, shown: line.at };
+    }
+    if (game[shown] === san) {
+        return { line: line === undefined ? undefined : { ...line, cursor: 0 }, shown: shown + 1 };
+    }
+    if (line?.at === shown && line.moves[0] === san) {
+        return { line: { ...line, cursor: 1 }, shown };
+    }
+    return { line: { at: shown, moves: [san], cursor: 1 }, shown };
+}
+/** The line after a step back or forward through it: back from its first move the board is on the game again, where the line leaves it. */
+export function stepLine(line, step) {
+    return { ...line, cursor: stepped(step, line.cursor, line.moves.length) };
+}
+/** The line with the board back on the game, the line kept faded. */
+export function leaveLine(line) {
+    return line === undefined ? undefined : { ...line, cursor: 0 };
+}
+/** The record of the position the board shows: the game's moves up to the line, then the line's up to its cursor. */
+export function lineRecord(record, line) {
+    const moves = [...record.moves.slice(0, line.at).map(({ san }) => san), ...line.moves.slice(0, line.cursor)];
+    return { tags: record.tags, moves: moves.map((san) => ({ san })) };
+}
+/** The line's moves numbered from the position it leaves the game at, given by its move number and the side to move. */
+export function linePlies(line, start) {
+    let { moveNumber: number, turn: side } = start;
+    return line.moves.map((san) => {
+        const ply = { san, number, side };
+        number += side === "black" ? 1 : 0;
+        side = side === "white" ? "black" : "white";
+        return ply;
+    });
+}
+/** The moves written as a PGN writes them, 12...Kf8 13.Nxe5 Bxe2: the number before White's moves, and before the first when it is Black's. */
+export function lineText(plies) {
+    return plies.map((ply, index) => `${moveNumberOf(ply, index === 0)}${ply.san}`).join(" ");
+}
+/** The number written before a move of a line, 13. or 12..., none before Black's but the first. */
+export function moveNumberOf(ply, first) {
+    return ply.side === "white" ? `${ply.number}.` : first ? `${ply.number}...` : "";
+}
+/** Whether the board goes from one place to another by more than one move, which shows the position at once instead of sliding a move. */
+export function isJump(from, to) {
+    if (from.cursor === 0 && to.cursor === 0) {
+        return Math.abs(from.at - to.at) > 1;
+    }
+    if (from.cursor > 0 && to.cursor > 0) {
+        return from.at !== to.at || Math.abs(from.cursor - to.cursor) > 1;
+    }
+    const [game, line] = from.cursor === 0 ? [from, to] : [to, from];
+    return !(game.at === line.at && line.cursor === 1);
+}

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,7 +37,7 @@ 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. In analysis the name stands over the box where you write to it.
+- **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
@@ -53,6 +53,7 @@ No chess engine plays for the AI: every move and every judgment is its own. Ches
 ![The bar that steps through the moves, and the judgments on the moves](analysis)
 
 - When the game is over, press **Analyse the game**: the AI goes over it and puts its judgments and notes on the moves. Read them by stepping through the moves with the arrows at the foot of the column, or by clicking a move.
+- In analysis, **move the pieces**, White's and Black's, from any move: a variation starts, with a coloured edge round the board. Click a move of the game to go back to it; the ✕, or Esc, closes the variation.
 - **Analyses**, in the header, opens your analyses, and loads a game played elsewhere: paste its PGN, or choose a .pgn file.
 - With your names on Lichess and Chess.com in your profile, **Load a game** lists your latest games there: click one to analyse it.
 - Ask the AI about the game in the box under its name.

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,7 +37,7 @@ 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'è. Nell'analisi il nome sta sopra la casella dove le scrivi.
+- **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
@@ -53,6 +53,7 @@ Nessun motore di scacchi gioca al posto dell'AI: ogni mossa e ogni giudizio sono
 ![La barra per scorrere le mosse e i giudizi sulle mosse](analysis)
 
 - A partita finita premi **Analizza la partita**: l'AI la ripassa e mette sulle mosse i suoi giudizi e le sue note. Le leggi scorrendo le mosse con le frecce in fondo alla colonna, o cliccando una mossa.
+- Nell'analisi **muovi i pezzi**, bianchi e neri, da qualunque mossa: nasce una variante, con un bordo colorato attorno alla scacchiera. Clicca una mossa della partita per tornarci; la ✕, o Esc, chiude la variante.
 - **Analisi**, nell'intestazione, apre le tue analisi e carica una partita giocata altrove: incolla il suo PGN, o scegli un file .pgn.
 - Con i tuoi nomi su Lichess e Chess.com nel profilo, **Carica una partita** elenca le tue ultime partite là: clicca su una per analizzarla.
 - Chiedi all'AI della partita nella casella sotto il suo nome.

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/text.js

@@ -84,6 +84,7 @@ const english = {
     game: "The game",
     moves: "Moves",
     steps: { first: "Start", back: "Previous move", forward: "Next move", last: "Back to the game" },
+    variation: { line: "Variation", close: "Close the variation (Esc)", back: (move) => move === undefined ? "Back to the start of the game" : `Back to the game, at ${move}` },
     noGame: "No game yet: press + to start one, or ask for one in the chat.",
     foldCard: "Fold the card",
     openCard: "Open the card",
@@ -182,7 +183,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",
@@ -523,6 +524,7 @@ const italian = {
     game: "La partita",
     moves: "Mosse",
     steps: { first: "Inizio", back: "Mossa precedente", forward: "Mossa successiva", last: "Torna alla partita" },
+    variation: { line: "Variante", close: "Chiudi la variante (Esc)", back: (move) => move === undefined ? "Torna all'inizio della partita" : `Torna alla partita, a ${move}` },
     noGame: "Nessuna partita: premi + per iniziarne una, o chiedila nella chat.",
     foldCard: "Chiudi la scheda",
     openCard: "Apri la scheda",
@@ -621,7 +623,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

@@ -65,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.

package/dist/server/bell/bell.js

@@ -1,4 +1,4 @@
-// The doorbell for the page (D-47): `chesspal listen`, the Stop hook init writes for Claude Code and Codex, waits at the page of its chat and, when
+// The doorbell for the page (D-47): `chesspal listen`, the Stop hook init writes for Claude Code, Codex and Antigravity, waits at the page of its chat and, when
 // the player moves or writes there, tells the chat to call status. It never carries the move, the words or the position: status reads them fresh.
 import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
@@ -6,6 +6,7 @@ import { positionShownNote, writeAtomically } from "../../games/index.js";
 import { samePath } from "../../home/index.js";
 import { analystAgent } from "../../host-files/index.js";
 import { askPage, chatFolder, findChatPage, notedFolder, notedPagePorts, pageNote, probeOf, probeWait } from "../ports/index.js";
+import { watchNewTurn } from "./antigravity.js";
 /** What the chat hears from the doorbell: one line for whatever the player did, never what, only where to read it. */
 export const bellLine = "The player acted on the board page: call status to see it.";
 /**
@@ -185,31 +186,51 @@ export function forgetPagePort(home, folder, port) {
 }
 /** What Codex's Stop hook answers to wake the chat: its turn goes on with the doorbell's line. */
 export const codexBellAnswer = JSON.stringify({ decision: "block", reason: bellLine });
+/** 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 const antigravityBellAnswer = JSON.stringify({ decision: "continue", reason: bellLine });
 /**
  * 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 async function listen(codex = false) {
+export async function listen(host = "claude") {
     let input = "";
     for await (const chunk of process.stdin) {
         input += String(chunk);
     }
-    const heard = await bellHeard(input).catch((error) => ({ folder: chatFolder(hookInput(input)), rang: false, why: `failed: ${error.message}` }));
+    const conversation = host === "antigravity" ? hookInput(input).session : undefined;
+    const turn = conversation === undefined ? undefined : watchNewTurn(conversation);
+    const waited = bellHeard(input).catch((error) => ({ folder: chatFolder(hookInput(input)), rang: false, why: `failed: ${error.message}` }));
+    const newTurn = turn?.started.then(() => ({ folder: chatFolder(hookInput(input)), rang: false, why: "the player started a new turn" }));
+    const heard = await (newTurn === undefined ? waited : Promise.race([waited, newTurn]));
+    turn?.stop();
     // Codex's turn ends with a hook that heard no bell, and the player's next move on the page wakes nobody: the log keeps why.
-    if (codex && !heard.rang) {
+    if (host === "codex" && !heard.rang) {
         noteSilence(heard.folder, heard.why);
     }
     // It ends as soon as it knows: the chat hears the hook only once it ends.
-    if (!heard.rang) {
+    const answer = hookAnswer(host, heard.rang);
+    if (answer === undefined) {
         process.exit(0);
     }
-    else if (codex) {
-        process.stdout.write(`${codexBellAnswer}\n`, () => process.exit(0));
+    else if (host === "claude") {
+        process.stderr.write(`${answer}\n`, () => process.exit(2));
     }
     else {
-        process.stderr.write(`${bellLine}\n`, () => process.exit(2));
+        process.stdout.write(`${answer}\n`, () => process.exit(0));
     }
 }
+/** 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 function hookAnswer(host, rang) {
+    if (host === "antigravity") {
+        return rang ? antigravityBellAnswer : "{}";
+    }
+    if (!rang) {
+        return undefined;
+    }
+    return host === "codex" ? codexBellAnswer : bellLine;
+}
 /**
  * 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.
@@ -264,11 +285,13 @@ export function noteSilence(folder, why, now = new Date()) {
         // The log only explains; the hook ends the same.
     }
 }
+/** What the hook reads of its host's input: the chat's session, Antigravity's conversation, its folder, and whether its analyst has gone. */
 function hookInput(input) {
     try {
         const parsed = JSON.parse(input);
+        const session = typeof parsed.session_id === "string" ? parsed.session_id : parsed.conversationId;
         return {
-            ...(typeof parsed.session_id === "string" ? { session: parsed.session_id } : {}),
+            ...(typeof session === "string" ? { session } : {}),
             ...(typeof parsed.cwd === "string" ? { cwd: parsed.cwd } : {}),
             ...(analystGone(parsed.background_tasks) ? { analystGone: true } : {}),
         };

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

@@ -1,2 +1,2 @@
-export { Bell, forgetPagePort, listen, notePagePort } from "./bell.ts";
+export { Bell, forgetPagePort, listen, type ListeningHost, notePagePort } from "./bell.ts";
 export { chatInterrupted } from "./interrupted.ts";

package/dist/server/bell/index.js

@@ -1,3 +1,4 @@
-// The doorbell that wakes a chat when the player acts on the page (D-47), and the notes of the ports a folder's page took off its usual ones.
+// The doorbell that wakes a chat when the player acts on the page (D-47), Antigravity's included (D-115), and the notes of the ports a folder's page took
+// off its usual ones.
 export { Bell, forgetPagePort, listen, notePagePort } from "./bell.js";
 export { chatInterrupted } from "./interrupted.js";

package/dist/server/mcp/caller.js

@@ -1,5 +1,6 @@
 // Who makes a tool call (D-81): only what the host ties to that call, never what the AI says of itself nor a setting the chat may have changed.
-// Codex sends the model and the effort with each call; Claude Code writes them into the chat's transcript, on the line of the call.
+// Codex sends the model and the effort with each call; Claude Code writes them into the chat's transcript, on the line of the call; Antigravity sends the
+// conversation, whose transcript names the model with its effort on each of the AI's steps (D-115).
 import { closeSync, openSync, readdirSync, readFileSync, readSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, join } from "node:path";
@@ -18,6 +19,13 @@ export async function callerOf(meta, client, folder, wait = 50) {
             return found;
         }
     }
+    const conversation = meta?.["antigravity.google/artifacts_dir"];
+    if (typeof conversation === "string" && conversation !== "") {
+        const found = await antigravityModel(join(conversation, ".system_generated", "logs", "transcript_full.jsonl"), wait);
+        if (found !== undefined) {
+            return found;
+        }
+    }
     return client === undefined ? undefined : { annotator: client.title ?? client.name, hostOnly: true };
 }
 /**
@@ -91,6 +99,23 @@ function callerIn(text, call) {
     }
     return undefined;
 }
+/**
+ * The model of the AI's last step in an Antigravity conversation, as its transcript names it, the effort after it (gemini-3.8-flash-medium); the step of
+ * the call is written after it, but the chat's steps before it had the same model. None when no step names one in time.
+ */
+async function antigravityModel(transcript, wait) {
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        const model = tailOf(transcript).split("\n").reverse().map((line) => objectOf(line)).find((entry) => entry?.type === "PLANNER_RESPONSE" && typeof entry.model === "string")?.model;
+        if (typeof model === "string") {
+            const [, name, effort] = /^(.+)-(low|medium|high|xhigh|max)$/.exec(model) ?? [];
+            return name === undefined ? { annotator: model } : withEffort(name, effort);
+        }
+        if (attempt < attempts - 1) {
+            await new Promise((done) => setTimeout(done, wait));
+        }
+    }
+    return undefined;
+}
 /**
  * Who in Codex made a call: the chat, or an agent by the role its session notes first, before its first call (Priya). An agent started with the chat's
  * own turns sees the opponent's plan, so it counts as the chat (D-88).

package/dist/server/page/game.js

@@ -7,7 +7,7 @@ import { asTheChatSees } from "./chat.js";
 import { tellWatchers } from "./events.js";
 import { bodyOf, bytesOf, isJson, json, jsonOf, runRoute, send, textOf } from "./http.js";
 import { profilesShown } from "./profiles.js";
-import { analystAtWork, chatPlayedAtLength, chatToRelaunch, chatToWaitFor, refuseWaited, relaunchChat, tableShown } from "./table.js";
+import { analystAtWork, chatForAnalysis, chatPlayedAtLength, chatToRelaunch, chatToWaitFor, refuseWaited, relaunchChat, tableShown } from "./table.js";
 import { updateShown } from "./update.js";
 /** Answers the page's requests about the game: true when the request was one. */
 export function answerGame(request, response, url, served) {
@@ -132,7 +132,8 @@ async function messageFromPage(request, response, served) {
 /**
  * A new game from the page, with the sides, the level and the clock the player chose: the sides and the level they leave out are as in the game
  * before, and no clock means a game without one. One going on goes to the archive unfinished, and the doorbell tells the chat, unless the table starts
- * it again. A chat the table holds that must be clear for it, and is at work, has the game wait with the choices kept until it has ended its answer (D-107).
+ * it again. A chat the table holds that must be clear for it, or that it started for the analysis, and is at work, has the game wait with the choices kept
+ * until it has ended its answer (D-107).
  */
 async function newGameFromPage(request, response, served) {
     const asked = 'Send the new game as JSON: {"ai_colour": "black", "level": "club", "clock": "10+5"}, each one optional; no clock for a game without one.';
@@ -152,7 +153,7 @@ async function newGameFromPage(request, response, served) {
         }
         // The game starts from the page, open: its clocks wait for the player's Start there. A chat the table starts again is clean: no /clear is asked.
         relaunching = chatToRelaunch(served);
-        if (!relaunching && chatToWaitFor(served) && chatPlayedAtLength(served, before)) {
+        if (!relaunching && chatToWaitFor(served) && (chatPlayedAtLength(served, before) || chatForAnalysis(served))) {
             waitForChat(served, input.data);
             send(response, 200, json, JSON.stringify({ waiting: true }));
             return;

package/dist/server/page/page.js

@@ -60,6 +60,7 @@ export async function startPage(context, options = {}) {
             const noted = offPorts ? notePort(served) : undefined;
             const stopWatchingGame = watchGame(served);
             const stopAskingNpm = watchForUpdates(served);
+            table?.chats?.watch?.(() => tellWatchers(watchers));
             // A chat's process ends without closing its page: the note goes with it.
             const forgetPort = () => {
                 if (noted !== undefined) {

package/dist/server/page/table.d.ts

@@ -19,12 +19,18 @@ export interface TableChats {
     held(folder: string): HeldChat | undefined;
     /** Asks for the chat again: with another host, or `updated`, from the Chesspal just installed (D-108). */
     relaunch(folder: string, host?: string, updated?: boolean): boolean;
+    /** Tells `changed` when the hosts' choices change: Antigravity's models, read from the player's account. */
+    watch?(changed: () => void): void;
 }
-/** The chat `chesspal play` holds: the model and effort its host started with, none for the host's own, and the seat, the play's process. */
+/**
+ * The chat `chesspal play` holds: the model and effort its host started with, none for the host's own, the seat, the play's process, and `analysis` when
+ * it started it for the game in analysis on the page.
+ */
 export interface HeldChat {
     readonly model?: string | undefined;
     readonly effort?: string | undefined;
     readonly seat?: number;
+    readonly analysis?: true;
 }
 /** A chat opening at the table: one the page asked for, the one started again for a new game, or with another model or host (D-107). */
 export type Opening = "chat" | "again" | "restart";
@@ -67,7 +73,8 @@ export declare function tableShown(served: Served): {
 export declare function answerTable(request: IncomingMessage, response: ServerResponse, url: URL, served: Served): boolean;
 /**
  * Whether a new game starts the chat at the table again, clean (D-57): `chesspal play` holds it, it waits for the bell, no analyst of it is at work, and it
- * has seen a game move since it was first shown one; one that only greeted the player stays, as one opened from the chat's window before a new game.
+ * has seen a game move since it was first shown one; one that only greeted the player stays, as one opened from the chat's window before a new game. One
+ * `chesspal play` started for the analysis starts again all the same, at rest or still opening, or its first turn would analyse a game no longer there.
  */
 export declare function chatToRelaunch(served: Served): boolean;
 /**
@@ -80,6 +87,11 @@ export declare function relaunchChat(served: Served, how?: "again" | "restart",
  * it, it is at work, and no analyst of it is; with an analyst at work the player is asked for /clear, as with a chat opened by hand.
  */
 export declare function chatToWaitFor(served: Served): boolean;
+/**
+ * Whether the chat `chesspal play` holds was started for the analysis on the page: the one at the table, or, with none at it yet, the one still opening.
+ * A chat opened by hand never is.
+ */
+export declare function chatForAnalysis(served: Served): boolean;
 /**
  * Whether the chat at the table has played the game `current` at length (D-57), counted from the first position it was shown of it. A chat the table
  * started again for a game began after it, and new_game takes it for one cleared since: it holds the whole game all the same.