chesspal 0.4.1 → 0.5.0

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

@@ -182,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",
@@ -621,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

@@ -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/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,6 +19,8 @@ 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. */
 export interface HeldChat {

package/dist/server/page/table.js

@@ -287,7 +287,7 @@ function hostOffered(served, host) {
 function hostsOffered(served) {
     return `Name a host the table offers and this computer has: ${served.table?.chats?.hosts().filter((one) => one.installed).map((one) => one.name).join(", ") || "none"}.`;
 }
-// The host of the chat at the table, among those offered: it says its name as its MCP client does, «claude-code» or «codex-mcp-client».
+// The host of the chat at the table, among those offered: it says its name as its MCP client does, «claude-code», «codex-mcp-client» or «antigravity-client».
 function hostAtTable(served) {
     const said = served.chat.host()?.toLowerCase() ?? "";
     return served.attached === undefined ? undefined : served.table?.chats?.hosts().find((one) => said.includes(one.name))?.name;

package/dist/server/table/hosts/chats.d.ts

@@ -1,10 +1,12 @@
 import type { Context } from "../../../commands/index.ts";
 import type { TableChats } from "../../page/index.ts";
+import { type RunProgram } from "./models.ts";
 /**
  * The chats of a real table: the hosts installed, looked for again once a while has passed, since the player may install one with the page open; a
- * terminal opened with `chesspal play`, run by `chesspal`, the same Node and script as the table's.
+ * terminal opened with `chesspal play`, run by `chesspal`, the same Node and script as the table's. Antigravity's models are read with `run` as soon
+ * as it is found, and again when it is looked for after a reading that failed.
  */
-export declare function terminalChats(context: Context, chesspal?: readonly string[], env?: NodeJS.ProcessEnv): TableChats;
+export declare function terminalChats(context: Context, chesspal?: readonly string[], env?: NodeJS.ProcessEnv, run?: RunProgram): TableChats;
 /**
  * What the terminal runs: `chesspal play <host>`, with the table's data folder when it has one of its own, as a playtest's: Terminal.app and Windows
  * Terminal start the chat without the table's environment.

package/dist/server/table/hosts/chats.js

@@ -1,22 +1,35 @@
 import { samePath, tableFolder } from "../../../home/index.js";
-import { programPath } from "./find.js";
+import { hostProgramPath } from "./find.js";
 import { hostChoices, hostNames, isHostName } from "./hosts.js";
+import { antigravityModels } from "./models.js";
 import { askAgain, seatHeld } from "./seat.js";
 import { openTerminal } from "./terminal.js";
 /**
  * The chats of a real table: the hosts installed, looked for again once a while has passed, since the player may install one with the page open; a
- * terminal opened with `chesspal play`, run by `chesspal`, the same Node and script as the table's.
+ * terminal opened with `chesspal play`, run by `chesspal`, the same Node and script as the table's. Antigravity's models are read with `run` as soon
+ * as it is found, and again when it is looked for after a reading that failed.
  */
-export function terminalChats(context, chesspal = [process.execPath, ...process.execArgv, process.argv[1] ?? ""], env = process.env) {
+export function terminalChats(context, chesspal = [process.execPath, ...process.execArgv, process.argv[1] ?? ""], env = process.env, run) {
     let found;
+    const models = antigravityModels(tableFolder(context.home()), run);
+    const programs = () => {
+        const now = context.now().getTime();
+        if (found === undefined || now - found.at >= lookAgain) {
+            found = { programs: Object.fromEntries(hostNames.map((name) => [name, hostProgramPath(name, context.platform, env)])), at: now };
+            const agy = found.programs.antigravity;
+            if (agy !== undefined) {
+                models.read(agy);
+            }
+        }
+        return found.programs;
+    };
+    programs();
     return {
         hosts: () => {
-            const now = context.now().getTime();
-            if (found === undefined || now - found.at >= lookAgain) {
-                found = { hosts: hostNames.map((name) => chatHost(name, context.platform, env)), at: now };
-            }
-            return found.hosts;
+            const found = programs();
+            return hostNames.map((name) => chatHost(name, found[name] !== undefined, name === "antigravity" ? models.choices() : hostChoices[name]));
         },
+        watch: (changed) => models.watch(changed),
         open: async (host) => isHostName(host) && await openTerminal(tableFolder(context.home()), playCommand(chesspal, host, env), context.platform, env),
         // Only a chat in the table's folder can be the one chesspal play holds.
         held: (folder) => {
@@ -36,6 +49,6 @@ export function playCommand(chesspal, host, env) {
 }
 // Looking on the PATH takes a few milliseconds, and the page asks at every change of the game.
 const lookAgain = 10_000;
-function chatHost(name, platform, env) {
-    return { name, installed: programPath(name, platform, env) !== undefined, ...hostChoices[name], command: `chesspal play ${name}` };
+function chatHost(name, installed, choices) {
+    return { name, installed, ...choices, command: `chesspal play ${name}` };
 }

package/dist/server/table/hosts/find.d.ts

@@ -1,2 +1,8 @@
+import { type HostName } from "./hosts.ts";
+/**
+ * The host's program: on the PATH of `env`, else where its installer puts it, as Antigravity's, which a terminal opened before it was installed does not
+ * find; none when it is not installed.
+ */
+export declare function hostProgramPath(host: HostName, platform: string, env: NodeJS.ProcessEnv, exists?: (path: string) => boolean): string | undefined;
 /** The program's path on the PATH of `env`, the first found; none when it is not installed there. */
 export declare function programPath(name: string, platform: string, env: NodeJS.ProcessEnv, exists?: (path: string) => boolean): string | undefined;

package/dist/server/table/hosts/find.js

@@ -1,6 +1,24 @@
-// A program found on the PATH, as a shell would find it: on Windows with the extensions of PATHEXT, which npm's shims (.cmd) and installers (.exe) use.
+// A program found on the PATH, as a shell would find it: on Windows with the extensions of PATHEXT, which npm's shims (.cmd) and installers (.exe) use;
+// a host's, also where its installer puts it.
 import { existsSync, lstatSync } from "node:fs";
 import { posix, win32 } from "node:path";
+import { hostPrograms } from "./hosts.js";
+/**
+ * The host's program: on the PATH of `env`, else where its installer puts it, as Antigravity's, which a terminal opened before it was installed does not
+ * find; none when it is not installed.
+ */
+export function hostProgramPath(host, platform, env, exists = present) {
+    const found = programPath(hostPrograms[host], platform, env, exists);
+    if (found !== undefined || host !== "antigravity") {
+        return found;
+    }
+    const base = platform === "win32" ? env.LOCALAPPDATA : env.HOME;
+    if (base === undefined || base.trim() === "") {
+        return undefined;
+    }
+    const installed = platform === "win32" ? win32.join(base, "agy", "bin", "agy.exe") : posix.join(base, ".local", "bin", "agy");
+    return exists(installed) ? installed : undefined;
+}
 /** The program's path on the PATH of `env`, the first found; none when it is not installed there. */
 export function programPath(name, platform, env, exists = present) {
     const windows = platform === "win32";

package/dist/server/table/hosts/hooks.d.ts

@@ -1,6 +1,9 @@
 /** Codex's hooks as Chesspal last wrote them, which Codex asks the player to trust: the first time, or changed over ones trusted before. */
 export type HooksNews = "new" | "changed";
-/** Sets the table's folder up as init does, noting when Chesspal wrote Codex's hooks: Codex then asks the player to trust them. */
-export declare function setUpTable(folder: string, platform: string): void;
+/**
+ * Sets the table's folder up as init does, Antigravity's settings in the user's home too when given, noting when Chesspal wrote Codex's hooks: Codex
+ * then asks the player to trust them.
+ */
+export declare function setUpTable(folder: string, platform: string, userHome?: string): void;
 /** What Chesspal wrote of Codex's hooks since the player last heard it; the note is taken. One that cannot be read is no note. */
 export declare function takeHooksNews(folder: string): HooksNews | undefined;

package/dist/server/table/hosts/hooks.js

@@ -4,11 +4,14 @@ import { existsSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { writeAtomically } from "../../../games/index.js";
 import { codexHooksPath, setUpHosts } from "../../../host-files/index.js";
-/** Sets the table's folder up as init does, noting when Chesspal wrote Codex's hooks: Codex then asks the player to trust them. */
-export function setUpTable(folder, platform) {
+/**
+ * Sets the table's folder up as init does, Antigravity's settings in the user's home too when given, noting when Chesspal wrote Codex's hooks: Codex
+ * then asks the player to trust them.
+ */
+export function setUpTable(folder, platform, userHome) {
     const hooks = codexHooksPath(folder);
     const hadHooks = existsSync(hooks);
-    if (setUpHosts(folder, platform).includes(hooks)) {
+    if (setUpHosts(folder, platform, userHome).includes(hooks)) {
         // Hooks never trusted stay new, whatever Chesspal wrote over them before Codex asked.
         const news = hadHooks && readNote(folder) !== "new" ? "changed" : "new";
         writeAtomically(join(folder, hooksNoteFile), `${JSON.stringify({ hooks: news })}\n`);

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

@@ -1,28 +1,35 @@
-/** The hosts the page offers, by their command's name. */
-export declare const hostNames: readonly ["claude", "codex"];
+/** The hosts the page offers, by the name `chesspal play` takes. */
+export declare const hostNames: readonly ["claude", "codex", "antigravity"];
 export type HostName = typeof hostNames[number];
+/** Each host's program, as its installer names it. */
+export declare const hostPrograms: Readonly<Record<HostName, string>>;
 /**
  * The models and efforts the player may choose for a host, as its command line names them: aliases, which follow the host's newest models; and the
- * `model` and `effort` a chat starts with until the player chooses, the middle ones.
+ * `model` and `effort` a chat starts with until the player chooses, the middle ones. `modelEfforts`, where the models differ, the efforts of each,
+ * none for a model without; else every model has `efforts`.
  */
 export interface HostChoices {
     readonly models: readonly string[];
     readonly efforts: readonly string[];
     readonly model: string;
     readonly effort: string;
+    readonly modelEfforts?: Readonly<Record<string, readonly string[]>>;
 }
-/** What the player chose for a host on the page: none of either, or one the host does not offer, is the host's middle one. */
+/** What the player chose for a host on the page: none of either, or one the host does not offer, is the host's middle one; no effort for a model without. */
 export interface HostChoice {
     readonly model?: string | undefined;
     readonly effort?: string | undefined;
 }
 /**
  * Each host's choices, as tried in each (Priya): a value outside them would fail only at the chat's first turn. Claude Code's are its aliases; Codex's, the
- * models a ChatGPT account lists, which change with its releases.
+ * models a ChatGPT account lists, which change with its releases; Antigravity's, the Gemini Flash its free plan gives, its effort apart (D-115), until
+ * the table has read the models of the player's account.
  */
 export declare const hostChoices: Readonly<Record<HostName, HostChoices>>;
 /** Whether a word names a host the page offers. */
 export declare function isHostName(name: unknown): name is HostName;
+/** The efforts a host offers for one of its models: none for a model that has no effort to choose. */
+export declare function effortsOf(choices: HostChoices, model: string): readonly string[];
 /**
  * The message a chat opened by the table starts with, in the player's language: the AI answers it by calling status, as every chat does. A chat opened
  * `toAnalyse` the game the page shows is asked for that: told to play, it opened the New game window over the analysis it had just started.
@@ -30,13 +37,15 @@ export declare function isHostName(name: unknown): name is HostName;
 export declare function startMessage(language: string | undefined, toAnalyse?: boolean): string;
 /**
  * The start message and the choices the host knows: first for Claude Code, whose options may take the word after; last for Codex, where "resume" is no
- * subcommand, kept from its update screen, which an Enter would accept.
+ * subcommand, kept from its update screen, which an Enter would accept; for Antigravity after -i, which keeps the chat open, with Chesspal's tools
+ * allowed and the table's `folder` trusted for this chat alone, never saved in its settings: a folder trusted only at its first chat's dialog leaves that
+ * chat without its hooks. A model with no effort to choose is given none. `choices` are those the host offers, as read for Antigravity.
  */
-export declare function hostArgs(host: HostName, message: string, choice?: HostChoice): string[];
-/** The settings' keys that keep a host's choice in the profile: claudeModel, claudeEffort, codexModel, codexEffort. */
+export declare function hostArgs(host: HostName, message: string, choice?: HostChoice, folder?: string, choices?: HostChoices): string[];
+/** The settings' keys that keep a host's choice in the profile: claudeModel, claudeEffort, codexModel, codexEffort, antigravityModel, antigravityEffort. */
 export declare function choiceKeys(host: HostName): {
     model: string;
     effort: string;
 };
-/** A host's choice as the profile's settings keep it: the values the host offers alone, the rest is its middle one. */
-export declare function choiceIn(settings: Readonly<Record<string, unknown>> | undefined, host: HostName): HostChoice;
+/** A host's choice as the profile's settings keep it: the values the host offers alone, among `choices`, the rest is its middle one. */
+export declare function choiceIn(settings: Readonly<Record<string, unknown>> | undefined, host: HostName, choices?: HostChoices): HostChoice;