chesspal 0.4.0 → 0.5.0

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.";
 /**
@@ -22,17 +23,22 @@ export class Bell {
     woken = false;
     // A hook has waited for the bell since the chat came: its host runs Chesspal's hooks, and only they tell where a turn ends.
     hooked = false;
+    // Looks again, while a ring waits for a chat in a turn, whether the chat was stopped meanwhile.
+    stopWatch;
     news;
     changed;
+    stopped;
     /**
      * `news` says whether a ring no hook heard is still worth waking the chat for; `changed` is told when what the page shows of the chat may change: it
-     * starts or stops listening, the doorbell wakes it, its turn ends.
+     * starts or stops listening, the doorbell wakes it, its turn ends; `stopped` whether the host says the chat was stopped in its turn (Esc), which no
+     * hook tells.
      */
-    constructor(news = () => true, changed = () => undefined) {
+    constructor(news = () => true, changed = () => undefined, stopped = () => false) {
         this.news = news;
         this.changed = changed;
+        this.stopped = stopped;
     }
-    /** Whether the chat is in a turn, as far as the doorbell knows: a chat stopped with Esc stays in it until its next tool. */
+    /** Whether the chat is in a turn, as far as the doorbell knows: a chat stopped with Esc stays in it until its next tool, or until a ring finds it stopped. */
     get inTurn() {
         return this.busy;
     }
@@ -68,6 +74,7 @@ export class Bell {
     /**
      * The player acted on the page: the hook waiting hears it now, or the next one as soon as it comes. In a host that runs no hook nothing tells the end of
      * a turn: an act the chat waits for finds it out of its turn, and nobody hears the player, unless the chat `mayBeAtWork` on the AI's move meanwhile.
+     * A chat stopped in its turn ends no turn either: while the ring waits, the doorbell looks every `stopCheck` whether the host says so.
      */
     ring(mayBeAtWork = false) {
         if (this.listener === undefined) {
@@ -76,6 +83,9 @@ export class Bell {
                 this.busy = false;
                 this.changed();
             }
+            else {
+                this.watchForStop();
+            }
             return;
         }
         this.listener.end("ring");
@@ -128,7 +138,29 @@ export class Bell {
             this.changed();
         }
     }
+    /** A ring waits for a chat in its turn: a chat stopped there, which nobody hears, is out of it now, and the page says where to wake it. */
+    watchForStop() {
+        if (this.stopWatch !== undefined || !this.waitsInTurn()) {
+            return;
+        }
+        if (this.stopped()) {
+            this.busy = false;
+            this.woken = false;
+            this.changed();
+            return;
+        }
+        this.stopWatch = setTimeout(() => {
+            this.stopWatch = undefined;
+            this.watchForStop();
+        }, stopCheck);
+        this.stopWatch.unref();
+    }
+    waitsInTurn() {
+        return this.pending && this.busy && this.listener === undefined;
+    }
 }
+/** How often the doorbell looks whether a chat a ring waits for was stopped in its turn. */
+export const stopCheck = 2_000;
 /**
  * Notes in the data folder the port a chat's page took off its folder's usual ports, one file per page, for the hook to find it there; then forgets, off
  * the caller's clock, the notes of its folder whose page is gone: nobody listens at the port, or another folder's page does. A page that answers late
@@ -154,30 +186,50 @@ 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.
@@ -233,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 +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,2 +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/bell/interrupted.d.ts

@@ -0,0 +1,2 @@
+/** Whether the chat last started in this folder was stopped in the middle of its turn, as Claude Code writes it in the chat's transcript; false when it cannot be told. */
+export declare function chatInterrupted(folder: string): boolean;

package/dist/server/bell/interrupted.js

@@ -0,0 +1,56 @@
+// A chat stopped with Esc: Claude Code runs no Stop hook then, so no hook waits for the bell, and the doorbell would think the chat still at work. Its
+// transcript says it: the last line of the conversation is the player's interruption.
+import { closeSync, openSync, readSync, statSync } from "node:fs";
+import { lastChatStart } from "../../games/index.js";
+/** Whether the chat last started in this folder was stopped in the middle of its turn, as Claude Code writes it in the chat's transcript; false when it cannot be told. */
+export function chatInterrupted(folder) {
+    const transcript = lastChatStart(folder)?.transcript;
+    return transcript !== undefined && endsInterrupted(tailOf(transcript));
+}
+/** Whether the last line of the conversation in these lines of a transcript is the player's interruption; the lines of agents and of the host's own notes are skipped. */
+function endsInterrupted(lines) {
+    for (const line of lines.split("\n").reverse()) {
+        const entry = objectOf(line);
+        if (entry === undefined || entry.isSidechain === true || (entry.type !== "user" && entry.type !== "assistant")) {
+            continue;
+        }
+        const content = entry.message?.content;
+        const parts = typeof content === "string" ? [{ type: "text", text: content }] : Array.isArray(content) ? content : [];
+        return entry.type === "user" && parts.some((part) => {
+            const { type, text } = (part ?? {});
+            return type === "text" && typeof text === "string" && text.startsWith(interruption);
+        });
+    }
+    return false;
+}
+// What Claude Code writes as the player's line when Esc stops the chat, with " for tool use]" or "]" after it.
+const interruption = "[Request interrupted by user";
+// The conversation's last line is near the end of the file.
+const tailBytes = 64 * 1024;
+function tailOf(file) {
+    try {
+        const descriptor = openSync(file, "r");
+        try {
+            const size = statSync(file).size;
+            const length = Math.min(size, tailBytes);
+            const buffer = Buffer.alloc(length);
+            readSync(descriptor, buffer, 0, length, size - length);
+            return buffer.toString("utf8");
+        }
+        finally {
+            closeSync(descriptor);
+        }
+    }
+    catch {
+        return "";
+    }
+}
+function objectOf(line) {
+    try {
+        const value = JSON.parse(line);
+        return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

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, chatToRelaunch, chatToWaitFor, refuseWaited, relaunchChat, tableShown } from "./table.js";
+import { analystAtWork, 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) {
@@ -152,6 +152,11 @@ 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)) {
+            waitForChat(served, input.data);
+            send(response, 200, json, JSON.stringify({ waiting: true }));
+            return;
+        }
         const sight = relaunching ? served.context : asTheChatSees(served.context, served.chat);
         chosen = input.data;
         rerunIfChanged(() => startNewGame(input.data, { ...sight, pageOpen: () => true }, "page"));

package/dist/server/page/page.js

@@ -8,7 +8,7 @@ import { aiNameOf } from "../../core/index.js";
 import { forgetAnalyst, gameStamp, tableTalkStamp } from "../../games/index.js";
 import { outdatedHostFiles } from "../../host-files/index.js";
 import { gameFolder } from "../../profiles/index.js";
-import { Bell, forgetPagePort, notePagePort } from "../bell/index.js";
+import { Bell, chatInterrupted, forgetPagePort, notePagePort } from "../bell/index.js";
 import { bellProbe, pagePorts } from "../ports/index.js";
 import { analysesOf, answerAnalyses, sendSiteGames } from "./analyses.js";
 import { answerChat } from "./attach.js";
@@ -41,7 +41,7 @@ export async function startPage(context, options = {}) {
             startWhenAtRest(served);
             updateWhenAtRest(served);
             tellWatchers(watchers);
-        }),
+        }, () => chatInterrupted(folder)),
         watchers,
         port: 0,
         outdated: outdatedHostFiles(folder, context.platform).length > 0,
@@ -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 {
@@ -80,6 +82,13 @@ 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 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.
+ */
+export declare function chatPlayedAtLength(served: Served, current: {
+    readonly started: string;
+} | undefined): boolean;
 /**
  * Does what the page asked while the chat was at work, now that it has ended its answer. A chat gone meanwhile takes a start again with it; a new game
  * starts without it, and loses nothing: the next chat at the table is a clean one.

package/dist/server/page/table.js

@@ -1,5 +1,5 @@
 import { setTimeout as delay } from "node:timers/promises";
-import { analystOf, gameAt, samePosition } from "../../commands/index.js";
+import { analystOf, gameAt, pliesBeforeClearing, samePosition } from "../../commands/index.js";
 import { endOf, gameInAnalysis } from "../../games/index.js";
 import { gameFolder } from "../../profiles/index.js";
 import { tellWatchers } from "./events.js";
@@ -90,6 +90,17 @@ export function relaunchChat(served, how = "again", host) {
 export function chatToWaitFor(served) {
     return heldChat(served) !== undefined && !chatAtRest(served) && !analystAtWork(served);
 }
+/**
+ * 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.
+ */
+export function chatPlayedAtLength(served, current) {
+    const { positionSeen: seen, positionFirstSeen: first } = served.chat;
+    if (current === undefined || seen?.started !== current.started) {
+        return false;
+    }
+    return seen.plies - (first?.started === seen.started ? first.plies : 0) >= pliesBeforeClearing;
+}
 /**
  * Does what the page asked while the chat was at work, now that it has ended its answer. A chat gone meanwhile takes a start again with it; a new game
  * starts without it, and loses nothing: the next chat at the table is a clean one.
@@ -276,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;