chesspal 0.4.1 → 0.6.0

package/dist/server/page/table.js

@@ -62,22 +62,25 @@ export function answerTable(request, response, url, served) {
 }
 /**
  * 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 function chatToRelaunch(served) {
     const { positionSeen, positionFirstSeen } = served.chat;
     const played = positionSeen?.started !== undefined && (positionFirstSeen === undefined || !samePosition(positionSeen, positionFirstSeen));
-    return played && heldChat(served) !== undefined && chatAtRest(served);
+    return chatForAnalysis(served) ? served.attached === undefined || chatAtRest(served) : played && heldChat(served) !== undefined && chatAtRest(served);
 }
 /**
  * Asks `chesspal play` to start the chat at the table again: once the new game has started, or with another model or host in its place (D-107). Whether
  * it was asked; the pages then show it opening.
  */
 export function relaunchChat(served, how = "again", host) {
-    const folder = served.attached?.chat.folder;
+    // One started for the analysis is asked again while it is still opening, in the table's folder.
+    const opening = served.attached === undefined && how === "again" && chatForAnalysis(served);
+    const folder = opening ? served.context.folder : served.attached?.chat.folder;
     // Another host may first ask whether it trusts the table's folder: the pages say so, as for a chat opened.
     const switching = how === "restart" && host !== undefined && host !== hostAtTable(served);
-    if (folder === undefined || heldChat(served) === undefined || served.table?.chats?.relaunch(folder, host) !== true) {
+    if (folder === undefined || (!opening && heldChat(served) === undefined) || served.table?.chats?.relaunch(folder, host) !== true) {
         return false;
     }
     noteOpening(served, switching ? "chat" : how);
@@ -90,6 +93,15 @@ export function relaunchChat(served, how = "again", host) {
 export function chatToWaitFor(served) {
     return heldChat(served) !== undefined && !chatAtRest(served) && !analystAtWork(served);
 }
+/**
+ * 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 function chatForAnalysis(served) {
+    const { attached, context, table } = served;
+    const held = table?.chats?.held(attached?.chat.folder ?? context.folder);
+    return held?.analysis === true && (attached === undefined || held.seat === attached.chat.seat);
+}
 /**
  * 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.
@@ -287,7 +299,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,27 +1,40 @@
 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) => {
             const seat = samePath(folder, tableFolder(context.home())) ? seatHeld(folder, context.now()) : undefined;
-            return seat === undefined ? undefined : { model: seat.model, effort: seat.effort, seat: seat.pid };
+            return seat === undefined ? undefined : { model: seat.model, effort: seat.effort, seat: seat.pid, ...(seat.analysis === true ? { analysis: true } : {}) };
         },
         relaunch: (folder, host, updated) => samePath(folder, tableFolder(context.home())) && askAgain(folder, context.now(), { ...(host === undefined ? {} : { host }), ...(updated === true ? { updated } : {}) }),
     };
@@ -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;

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

@@ -1,20 +1,28 @@
-// The AI hosts the table opens a chat in (D-104): Claude Code and Codex, each with the start message, and the model and effort the player chose on the page
+// The AI hosts the table opens a chat in (D-104, D-115): Claude Code, Codex and Antigravity, each with the start message, and the model and effort the player chose on the page
 // for the profile in use, or each host's middle ones until they choose: the chat never starts with whatever the host was left at.
 import { speaksItalian } from "../../../commands/index.js";
-/** The hosts the page offers, by their command's name. */
-export const hostNames = ["claude", "codex"];
+/** The hosts the page offers, by the name `chesspal play` takes. */
+export const hostNames = ["claude", "codex", "antigravity"];
+/** Each host's program, as its installer names it. */
+export const hostPrograms = { claude: "claude", codex: "codex", antigravity: "agy" };
 /**
  * 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 const hostChoices = {
     claude: { models: ["fable", "opus", "sonnet", "haiku"], efforts: ["low", "medium", "high", "xhigh", "max"], model: "sonnet", effort: "medium" },
     codex: { models: ["gpt-6.1-sol", "gpt-6-astra", "gpt-6.1-terra", "gpt-6-luna"], efforts: ["low", "medium", "high", "xhigh", "max"], model: "gpt-6.1-terra", effort: "medium" },
+    antigravity: { models: ["gemini-3.8-flash"], efforts: ["low", "medium", "high"], model: "gemini-3.8-flash", effort: "medium" },
 };
 /** Whether a word names a host the page offers. */
 export function isHostName(name) {
     return hostNames.includes(name);
 }
+/** The efforts a host offers for one of its models: none for a model that has no effort to choose. */
+export function effortsOf(choices, model) {
+    return choices.modelEfforts?.[model] ?? choices.efforts;
+}
 /**
  * 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.
@@ -27,29 +35,39 @@ export function startMessage(language, toAnalyse = false) {
 }
 /**
  * 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 function hostArgs(host, message, choice = {}) {
-    const { model, effort } = offered(host, choice);
+export function hostArgs(host, message, choice = {}, folder, choices = hostChoices[host]) {
+    const { model, effort } = offered(choices, choice);
     if (host === "claude") {
         return [message, ...(model === undefined ? [] : ["--model", model]), ...(effort === undefined ? [] : ["--effort", effort])];
     }
+    if (host === "antigravity") {
+        const settings = { ...antigravityAllowed, ...(folder === undefined ? {} : { trustedWorkspaces: [folder] }) };
+        return ["-i", message, ...(model === undefined ? [] : ["--model", model]), ...(effort === undefined ? [] : ["--effort", effort]), "--settings", JSON.stringify(settings)];
+    }
     return ["-c", "check_for_update_on_startup=false", ...(model === undefined ? [] : ["-m", model]), ...(effort === undefined ? [] : ["-c", `model_reasoning_effort=${effort}`]), message];
 }
-/** The settings' keys that keep a host's choice in the profile: claudeModel, claudeEffort, codexModel, codexEffort. */
+/** The settings' keys that keep a host's choice in the profile: claudeModel, claudeEffort, codexModel, codexEffort, antigravityModel, antigravityEffort. */
 export function choiceKeys(host) {
     return { model: `${host}Model`, effort: `${host}Effort` };
 }
-/** A host's choice as the profile's settings keep it: the values the host offers alone, the rest is its middle one. */
-export function choiceIn(settings, host) {
+/** 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 function choiceIn(settings, host, choices = hostChoices[host]) {
     const keys = choiceKeys(host);
     const text = (value) => (typeof value === "string" ? value : undefined);
-    return offered(host, { model: text(settings?.[keys.model]), effort: text(settings?.[keys.effort]) });
+    return offered(choices, { model: text(settings?.[keys.model]), effort: text(settings?.[keys.effort]) });
 }
-// The choice kept to the values the host offers: its middle model and effort where none is chosen, or one it does not offer.
-function offered(host, choice) {
-    const choices = hostChoices[host];
+// Antigravity's settings for one chat: Chesspal's tools allowed, which it would otherwise ask for at each first use.
+const antigravityAllowed = { permissions: { allow: ["mcp(chesspal/*)"] } };
+// The choice kept to the values the host offers: its middle model where none is chosen, or one it does not offer; the model's middle effort likewise,
+// none for a model without.
+function offered(choices, choice) {
     const model = choice.model !== undefined && choices.models.includes(choice.model) ? choice.model : choices.model;
-    const effort = choice.effort !== undefined && choices.efforts.includes(choice.effort) ? choice.effort : choices.effort;
-    return { model, effort };
+    const efforts = effortsOf(choices, model);
+    const middle = efforts.includes(choices.effort) ? choices.effort : efforts[Math.floor((efforts.length - 1) / 2)];
+    const effort = choice.effort !== undefined && efforts.includes(choice.effort) ? choice.effort : middle;
+    return effort === undefined ? { model } : { model, effort };
 }

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

@@ -0,0 +1,19 @@
+import { type HostChoices, type HostName } from "./hosts.ts";
+/** Runs a program with its arguments: what it wrote on stdout; it fails when the program fails, or has not ended within `timeout` milliseconds. */
+export type RunProgram = (program: string, args: readonly string[], timeout: number) => Promise<string>;
+/** Antigravity's models as the table reads them: the choices offered now, a reading started, and who is told when they come. */
+export interface AntigravityModels {
+    choices(): HostChoices;
+    /** Reads the models with the program, once: again only after a reading that failed. */
+    read(program: string): void;
+    watch(changed: () => void): void;
+}
+/** Antigravity's models read with `run` for the table in `folder`, which keeps the list read for `chesspal play`. */
+export declare function antigravityModels(folder: string, run?: RunProgram): AntigravityModels;
+/**
+ * The choices in what `agy models` lists, an id and a name on each line: an id ending in an effort is that model with that effort, one without a model with
+ * no effort to choose. A Gemini Flash is the middle model where there is one, else the first; none when no line names a model.
+ */
+export declare function antigravityChoices(listed: string): HostChoices | undefined;
+/** The choices a host offers at the table in `folder`: Antigravity's as the table last read them, the others' always the same. */
+export declare function tableChoices(folder: string, host: HostName): HostChoices;

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

@@ -0,0 +1,95 @@
+// Antigravity's models, as `agy models` lists them for the account signed in: Gemini Flash on a free plan, more with a subscription. The table reads them
+// once, without waiting for them, and keeps the list in its folder for `chesspal play`; until it comes, or when it cannot be read, Gemini Flash alone.
+import { execFile } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { writeAtomically } from "../../../games/index.js";
+import { hostChoices } from "./hosts.js";
+/** Antigravity's models read with `run` for the table in `folder`, which keeps the list read for `chesspal play`. */
+export function antigravityModels(folder, run = runProgram) {
+    let read;
+    let reading = false;
+    const watchers = [];
+    return {
+        choices: () => read ?? hostChoices.antigravity,
+        read: (program) => {
+            if (read !== undefined || reading) {
+                return;
+            }
+            reading = true;
+            run(program, ["models"], readTime).then((listed) => {
+                reading = false;
+                read = antigravityChoices(listed);
+                if (read !== undefined) {
+                    keepList(folder, listed);
+                    watchers.forEach((changed) => changed());
+                }
+            }, () => {
+                reading = false;
+            });
+        },
+        watch: (changed) => {
+            watchers.push(changed);
+        },
+    };
+}
+/**
+ * The choices in what `agy models` lists, an id and a name on each line: an id ending in an effort is that model with that effort, one without a model with
+ * no effort to choose. A Gemini Flash is the middle model where there is one, else the first; none when no line names a model.
+ */
+export function antigravityChoices(listed) {
+    const modelEfforts = {};
+    for (const line of listed.split(/\r?\n/)) {
+        const id = line.split("\t")[0].trim();
+        if (!modelId.test(id)) {
+            continue;
+        }
+        const [, model = id, effort] = effortEnd.exec(id) ?? [];
+        const efforts = (modelEfforts[model] ??= []);
+        if (effort !== undefined && !efforts.includes(effort)) {
+            efforts.push(effort);
+            efforts.sort((one, other) => effortScale.indexOf(one) - effortScale.indexOf(other));
+        }
+    }
+    const models = Object.keys(modelEfforts);
+    if (models.length === 0) {
+        return undefined;
+    }
+    const efforts = effortScale.filter((effort) => models.some((model) => modelEfforts[model].includes(effort)));
+    const model = models.find((one) => /^gemini-.*flash/.test(one)) ?? models[0];
+    return { models, efforts, model, effort: "medium", modelEfforts };
+}
+/** The choices a host offers at the table in `folder`: Antigravity's as the table last read them, the others' always the same. */
+export function tableChoices(folder, host) {
+    if (host !== "antigravity") {
+        return hostChoices[host];
+    }
+    try {
+        return antigravityChoices(readFileSync(join(folder, listFile), "utf8")) ?? hostChoices.antigravity;
+    }
+    catch {
+        return hostChoices.antigravity;
+    }
+}
+// `agy models` asks Google's servers for the account's models: about a second, at times more.
+const readTime = 15_000;
+const listFile = "antigravity-models.txt";
+// The efforts Antigravity's ids end in, from the least.
+const effortScale = ["low", "medium", "high", "xhigh", "max"];
+const effortEnd = new RegExp(`^(.+)-(${effortScale.join("|")})$`);
+// An id as Antigravity writes them, which a header or a message never is.
+const modelId = /^[a-z0-9][a-z0-9._-]*$/;
+function runProgram(program, args, timeout) {
+    return new Promise((done, failed) => {
+        execFile(program, args, { timeout, windowsHide: true, encoding: "utf8" }, (error, stdout) => (error === null ? done(stdout) : failed(error)));
+    });
+}
+// A list that cannot be written leaves `chesspal play` with Gemini Flash: the chat starts all the same.
+function keepList(folder, listed) {
+    try {
+        writeAtomically(join(folder, listFile), listed);
+    }
+    catch {
+        // Nothing to do: see above.
+    }
+}

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

@@ -4,7 +4,7 @@ import { type HooksNews } from "./hooks.ts";
 import { type HostChoice, type HostName } from "./hosts.ts";
 /**
  * What `chesspal play` starts: the host's program, its arguments, folder and environment, whether it needs cmd, as a .cmd shim does on Windows, and the
- * model and effort it is given, which the seat notes for the page (D-107).
+ * model and effort it is given, which the seat notes for the page (D-107), as it notes a chat started for the game in analysis.
  */
 export interface HostLaunch {
     readonly program: string;
@@ -13,6 +13,8 @@ export interface HostLaunch {
     readonly env: NodeJS.ProcessEnv;
     readonly shell: boolean;
     readonly choice: HostChoice;
+    /** Started for the game in analysis on the page, with no game going on: a new game from the page starts it again. */
+    readonly analysis: boolean;
     /** Chesspal wrote Codex's hooks, the first time or again: Codex runs them only once the player trusts them. */
     readonly hooks?: HooksNews;
 }
@@ -31,7 +33,10 @@ export declare function runHost(launch: HostLaunch, again: () => boolean, platfo
     code: number;
     again: boolean;
 }>;
-/** How the host starts for the profile in use: found on the PATH, with its choice; it throws, saying how to install it, when it is not there. */
+/**
+ * How the host starts for the profile in use: found on the PATH, or where its installer puts it, with its choice among those the table offers; it throws,
+ * saying how to install it, when it is not there.
+ */
 export declare function hostLaunch(context: Context, host: HostName, env?: NodeJS.ProcessEnv, exists?: (path: string) => boolean): HostLaunch;
 /**
  * Ends a process and what it started, a host's MCP server among them: on Windows its whole tree, which taskkill ends, never the console (Priya); else the

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

@@ -7,9 +7,10 @@ import { speaksItalian } from "../../../commands/index.js";
 import { endOf, gameInAnalysis, loadGame } from "../../../games/index.js";
 import { tableFolder } from "../../../home/index.js";
 import { activeProfile, gameFolder, languageIn, profileSettings } from "../../../profiles/index.js";
-import { programPath } from "./find.js";
+import { hostProgramPath } from "./find.js";
 import { setUpTable, takeHooksNews } from "./hooks.js";
 import { choiceIn, hostArgs, isHostName, startMessage } from "./hosts.js";
+import { tableChoices } from "./models.js";
 import { askedAgain, leaveSeat, refreshSeat, seatTimes, takeSeat } from "./seat.js";
 import { cmdQuoted } from "./terminal.js";
 /**
@@ -127,30 +128,35 @@ export function runHost(launch, again, platform = process.platform, every = 500)
         });
     });
 }
-/** How the host starts for the profile in use: found on the PATH, with its choice; it throws, saying how to install it, when it is not there. */
+/**
+ * How the host starts for the profile in use: found on the PATH, or where its installer puts it, with its choice among those the table offers; it throws,
+ * saying how to install it, when it is not there.
+ */
 export function hostLaunch(context, host, env = process.env, exists) {
     const home = context.home();
     const folder = tableFolder(home);
-    const found = programPath(host, context.platform, env, exists);
+    const found = hostProgramPath(host, context.platform, env, exists);
     if (found === undefined) {
         throw new Error(`${hostTitle[host]} is not installed on this computer, or not on its PATH: install it (${installHint[host]}), then try again.`);
     }
-    setUpTable(folder, context.platform);
+    setUpTable(folder, context.platform, context.userHome?.());
     // Codex's hooks written, by this play or by the table before it: the note is for Codex's chat, and waits for it.
     const news = host === "codex" ? takeHooksNews(folder) : undefined;
     const hooks = news === undefined ? {} : { hooks: news };
-    const choice = choiceIn(profileSettings(home, activeProfile(home).id), host);
+    const choices = tableChoices(folder, host);
+    const choice = choiceIn(profileSettings(home, activeProfile(home).id), host, choices);
     const games = gameFolder(home);
-    const args = hostArgs(host, startMessage(languageIn(games, context.language), analysisAsked(games)), choice);
+    const analysis = analysisAsked(games);
+    const args = hostArgs(host, startMessage(languageIn(games, context.language), analysis), choice, folder, choices);
     // An effort the player set for every chat would win over the one chosen on the page: spawn leaves out a variable that is undefined.
     const effort = host === "claude" && choice.effort !== undefined ? { CLAUDE_CODE_EFFORT_LEVEL: undefined } : {};
     // The seat this play holds, by which its chat's server tells the table it is the chat held, and not another opened in the same folder.
     const childEnv = { ...env, ...Object.fromEntries(sessionMarks.map((name) => [name, undefined])), ...effort, CHESSPAL_SEAT: String(process.pid) };
     const script = npmScript(host, found, context.platform, exists ?? existsSync);
     if (script !== undefined) {
-        return { program: process.execPath, args: [script, ...args], folder, env: childEnv, shell: false, choice, ...hooks };
+        return { program: process.execPath, args: [script, ...args], folder, env: childEnv, shell: false, choice, analysis, ...hooks };
     }
-    return { program: found, args, folder, env: childEnv, shell: context.platform === "win32" && /\.(cmd|bat)$/i.test(found), choice, ...hooks };
+    return { program: found, args, folder, env: childEnv, shell: context.platform === "win32" && /\.(cmd|bat)$/i.test(found), choice, analysis, ...hooks };
 }
 /** Whether the board page shows a game in analysis, none going on: the chat opened there is for that game, brought to review or to talk over, not for a new one. */
 function analysisAsked(folder) {
@@ -163,7 +169,7 @@ function analysisAsked(folder) {
         return false;
     }
 }
-const hostTitle = { claude: "Claude Code", codex: "Codex" };
+const hostTitle = { claude: "Claude Code", codex: "Codex", antigravity: "Antigravity" };
 // What the player is told before Codex asks about the hooks Chesspal wrote: the first time, and when they changed.
 const hooksWords = {
     new: {
@@ -180,10 +186,10 @@ const closedAtStartWords = {
     english: ["Claude Code closed as soon as it opened.", 'If it asks whether you trust this folder, go down to "Yes, I trust this folder" with the arrow keys, then press Enter.'],
     italian: ["Claude Code si è chiuso appena aperto.", "Se ti chiede se ti fidi della cartella, scendi con le frecce su «Yes, I trust this folder», poi premi Invio."],
 };
-// Runs the host as runHost does, the seat noting the model and effort it is given; one not installed, or that could not start, fails saying so.
+// Runs the host as runHost does, the seat noting the model and effort it is given, and whether for the analysis; one not installed, or that could not start, fails saying so.
 async function started(context, host, again) {
     const launch = hostLaunch(context, host);
-    takeSeat(launch.folder, { pid: process.pid, host, ...launch.choice });
+    takeSeat(launch.folder, { pid: process.pid, host, ...launch.choice, ...(launch.analysis ? { analysis: true } : {}) });
     // Codex asks the player to trust the hooks Chesspal wrote: said here, above its question, as init says it.
     if (launch.hooks !== undefined) {
         const words = hooksWords[launch.hooks];
@@ -256,7 +262,11 @@ function savedTerminal(platform) {
 }
 // What marks a chat's own session, which a table started from inside a chat would hand down, and the host take for its own (Priya).
 const sessionMarks = ["CLAUDECODE", "CLAUDE_CODE_SESSION_ID", "CLAUDE_CODE_CHILD_SESSION", "CLAUDE_CODE_SESSION_ATTENDED", "CLAUDE_PID", "CLAUDE_EFFORT", "AI_AGENT", "TRACEPARENT"];
-const installHint = { claude: "https://claude.com/claude-code", codex: "npm install -g @openai/codex" };
+const installHint = {
+    claude: "https://claude.com/claude-code",
+    codex: "npm install -g @openai/codex",
+    antigravity: "https://antigravity.google/docs/getting-started",
+};
 /**
  * The script behind npm's Windows shim of Codex, which Node runs as the shim would, without cmd and its quoting of the start message (Priya); none for
  * another program, or when it is not beside the shim.

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

@@ -1,9 +1,13 @@
-/** The play process in the seat: its process id, its host, and the model and effort it started that host with, none for the host's own. */
+/**
+ * The play process in the seat: its process id, its host, and the model and effort it started that host with, none for the host's own; `analysis` when
+ * it started it for the game in analysis on the page, which a new game then starts again.
+ */
 export interface Seat {
     readonly pid: number;
     readonly host: string;
     readonly model?: string | undefined;
     readonly effort?: string | undefined;
+    readonly analysis?: true;
 }
 /**
  * Takes the seat for this play process, over a request left for one before it; it throws while another one holds it. A seat is held while its play

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

@@ -70,7 +70,7 @@ function seatIn(folder) {
         return undefined;
     }
     const text = (value) => (typeof value === "string" ? value : undefined);
-    return { pid: seat.pid, host: seat.host, model: text(seat.model), effort: text(seat.effort) };
+    return { pid: seat.pid, host: seat.host, model: text(seat.model), effort: text(seat.effort), ...(seat.analysis === true ? { analysis: true } : {}) };
 }
 function jsonIn(path) {
     try {

package/dist/server/table/table.js

@@ -14,7 +14,7 @@ export const tableTimes = { idle: 5 * 60_000, every: 15_000 };
  */
 export async function startTable(context, times = tableTimes, chats, updater) {
     const folder = tableFolder(context.home());
-    setUpTable(folder, context.platform);
+    setUpTable(folder, context.platform, context.userHome?.());
     let quit = () => undefined;
     const quitting = new Promise((done) => {
         quit = done;