chesspal 0.3.5 → 0.4.0

package/dist/server/table/browser.js

@@ -1,40 +1,118 @@
-// The table's page opened in the player's browser (D-104): in a window of its own, as an application, when Chrome or Edge is installed, which open one with
-// --app; else in a tab of the system's default browser.
-import { spawn } from "node:child_process";
+// The table's page opened in the player's browser (D-104): in a window of its own, as an application, in the default browser when it opens one with --app,
+// else in Chrome or Edge when either is installed; else in a tab of the system's default browser.
+import { execFile, spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { posix, win32 } from "node:path";
 import { openFolder } from "../../home/index.js";
-/** Opens an address in a window of its own, else in a tab of the default browser, without waiting for it: whether a browser started. */
-export async function openInBrowser(url, platform) {
-    const browser = appBrowser(platform, process.env);
+/**
+ * Opens an address in a window of its own, marked with the table's opening, else in a tab of the default browser, without waiting for it: how it opened.
+ * A tab is not marked: a page cannot close a tab it did not open.
+ */
+export async function openInBrowser(url, platform, opening) {
+    const browser = await appBrowser(platform, process.env);
+    if (browser !== undefined && await started(browser, [`--app=${openedAddress(url, opening)}`])) {
+        return "window";
+    }
     // Explorer, open and xdg-open take an address as they take a folder, and hand it to the default browser.
-    return (browser !== undefined && await started(browser, [`--app=${openedAddress(url)}`])) || openFolder(url, platform);
+    return await openFolder(url, platform) ? "tab" : "none";
 }
-/** The address of the window the table opens, marked so that the page sizes it as it opens (page/layout/window.ts). */
-export function openedAddress(url) {
+/**
+ * The address of the window the table opens, marked so that the page sizes it as it opens, with its opening, so that it closes once a newer window has
+ * opened (page/layout/window.ts).
+ */
+export function openedAddress(url, opening) {
     const address = new URL(url);
-    address.searchParams.set("opened", "");
+    address.searchParams.set("opened", opening === undefined ? "" : String(opening));
     return address.href;
 }
-/** Chrome or Edge, where each system installs them: the first there is; none when neither is. */
-export function appBrowser(platform, env, exists = existsSync) {
-    return browserPaths(platform, env).find(exists);
+/**
+ * The browser that opens the table's window: the default one when it is a Chromium that takes --app and is where it installs itself, so that the window
+ * opens in the browser the player uses; else Chrome or Edge, the first there is; none when neither is.
+ */
+export async function appBrowser(platform, env, system = realSystem) {
+    const chosen = await defaultBrowser(platform, system);
+    const tried = platform === "linux" ? [chrome, chromium, edge] : [chrome, edge];
+    const browsers = chosen === undefined ? tried : [chosen, ...tried];
+    return browsers.flatMap((browser) => browserPaths(browser, platform, env)).find(system.exists);
+}
+const chrome = {
+    windows: ["Google", "Chrome", "Application", "chrome.exe"],
+    progId: "ChromeHTML",
+    mac: "Google Chrome",
+    linux: ["google-chrome", "google-chrome-stable"],
+    desktop: ["google-chrome"],
+};
+const edge = {
+    windows: ["Microsoft", "Edge", "Application", "msedge.exe"],
+    progId: "MSEdgeHTM",
+    mac: "Microsoft Edge",
+    linux: ["microsoft-edge", "microsoft-edge-stable"],
+    desktop: ["microsoft-edge"],
+};
+const brave = {
+    windows: ["BraveSoftware", "Brave-Browser", "Application", "brave.exe"],
+    progId: "BraveHTML",
+    mac: "Brave Browser",
+    linux: ["brave-browser", "brave-browser-stable", "brave"],
+    desktop: ["brave-browser", "brave_brave"],
+};
+const chromium = {
+    windows: ["Chromium", "Application", "chrome.exe"],
+    progId: "ChromiumHTM",
+    mac: "Chromium",
+    linux: ["chromium", "chromium-browser"],
+    desktop: ["chromium", "chromium-browser", "chromium_chromium"],
+};
+const chromiums = [chrome, edge, brave, chromium];
+// Windows keeps the default browser for http in UserChoiceLatest when it has one, which it then reads in place of UserChoice; macOS is not asked.
+async function defaultBrowser(platform, system) {
+    if (platform === "win32") {
+        const choices = await system.output("reg", ["query", String.raw `HKCU\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http`, "/s"]);
+        const progId = progIdIn(choices, String.raw `\UserChoiceLatest\ProgId`) ?? progIdIn(choices, String.raw `\UserChoice`);
+        return chromiums.find((browser) => progId === browser.progId || progId?.startsWith(`${browser.progId}.`) === true);
+    }
+    if (platform === "linux") {
+        const desktop = (await system.output("xdg-settings", ["get", "default-web-browser"])).trim().replace(/\.desktop$/, "");
+        return chromiums.find((browser) => browser.desktop.includes(desktop));
+    }
+    return undefined;
+}
+// The ProgId under the key of reg's answer that ends so.
+function progIdIn(choices, key) {
+    let inKey = false;
+    for (const line of choices.split(/\r?\n/)) {
+        if (line.startsWith("HKEY_")) {
+            inKey = line.trimEnd().endsWith(key);
+        }
+        else if (inKey) {
+            const value = /^\s+ProgId\s+REG_SZ\s+(\S+)/.exec(line);
+            if (value !== null) {
+                return value[1];
+            }
+        }
+    }
+    return undefined;
 }
-// Chrome before Edge: Chrome is the one tried, and Edge may be missing even on Windows.
-function browserPaths(platform, env) {
+// Where each system installs a browser: Program Files and the user's AppData, the Applications of macOS, the PATH of Linux.
+function browserPaths(browser, platform, env) {
     if (platform === "win32") {
         const roots = [env.ProgramFiles, env["ProgramFiles(x86)"], env.LOCALAPPDATA].filter((root) => root !== undefined && root !== "");
-        const programs = [["Google", "Chrome", "Application", "chrome.exe"], ["Microsoft", "Edge", "Application", "msedge.exe"]];
-        return programs.flatMap((program) => roots.map((root) => win32.join(root, ...program)));
+        return roots.map((root) => win32.join(root, ...browser.windows));
     }
     if (platform === "darwin") {
         const roots = ["/Applications", ...(env.HOME === undefined ? [] : [posix.join(env.HOME, "Applications")])];
-        return ["Google Chrome", "Microsoft Edge"].flatMap((name) => roots.map((root) => posix.join(root, `${name}.app`, "Contents", "MacOS", name)));
+        return roots.map((root) => posix.join(root, `${browser.mac}.app`, "Contents", "MacOS", browser.mac));
     }
     const folders = (env.PATH ?? "").split(":").filter((folder) => folder !== "");
-    const names = ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser", "microsoft-edge", "microsoft-edge-stable"];
-    return names.flatMap((name) => folders.map((folder) => posix.join(folder, name)));
+    return browser.linux.flatMap((name) => folders.map((folder) => posix.join(folder, name)));
 }
+const realSystem = {
+    exists: existsSync,
+    output: (command, args) => new Promise((done) => {
+        // A second at most: the window would rather open in Chrome or Edge than wait on a registry or a desktop that does not answer.
+        execFile(command, args, { windowsHide: true, timeout: 1000 }, (error, output) => done(error === null ? output : ""));
+    }),
+};
 // A browser started apart from this process, which it outlives: whether it started.
 function started(browser, args) {
     return new Promise((done) => {

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

@@ -5,3 +5,8 @@ import type { TableChats } from "../../page/index.ts";
  * terminal opened with `chesspal play`, run by `chesspal`, the same Node and script as the table's.
  */
 export declare function terminalChats(context: Context, chesspal?: readonly string[], env?: NodeJS.ProcessEnv): 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.
+ */
+export declare function playCommand(chesspal: readonly string[], host: string, env: NodeJS.ProcessEnv): string[];

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

@@ -1,5 +1,4 @@
-import { tableFolder } from "../../../home/index.js";
-import { samePath } from "../../bell/index.js";
+import { samePath, tableFolder } from "../../../home/index.js";
 import { programPath } from "./find.js";
 import { hostChoices, hostNames, isHostName } from "./hosts.js";
 import { askAgain, seatHeld } from "./seat.js";
@@ -18,15 +17,23 @@ export function terminalChats(context, chesspal = [process.execPath, ...process.
             }
             return found.hosts;
         },
-        open: async (host) => isHostName(host) && await openTerminal(tableFolder(context.home()), [...chesspal, "play", host], context.platform, env),
+        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 };
+            return seat === undefined ? undefined : { model: seat.model, effort: seat.effort, seat: seat.pid };
         },
         relaunch: (folder, host, updated) => samePath(folder, tableFolder(context.home())) && askAgain(folder, context.now(), { ...(host === undefined ? {} : { host }), ...(updated === true ? { updated } : {}) }),
     };
 }
+/**
+ * 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.
+ */
+export function playCommand(chesspal, host, env) {
+    const home = env.CHESSPAL_HOME?.trim();
+    return [...chesspal, "play", host, ...(home ? ["--home", home] : [])];
+}
 // 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) {

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

@@ -0,0 +1,6 @@
+/** 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;
+/** 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

@@ -0,0 +1,38 @@
+// The table's folder set up as init does, for the table and for `chesspal play` alike: when Chesspal writes Codex's hooks, the first time or again over
+// older ones, a note says so, which the next `chesspal play codex` takes, for the player to hear it whichever of the two wrote them.
+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) {
+    const hooks = codexHooksPath(folder);
+    const hadHooks = existsSync(hooks);
+    if (setUpHosts(folder, platform).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`);
+    }
+}
+/** 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 function takeHooksNews(folder) {
+    const news = readNote(folder);
+    try {
+        rmSync(join(folder, hooksNoteFile), { force: true });
+    }
+    catch {
+        // A note that cannot go now (the table rewrites it) is said again at the next play, which is harmless.
+    }
+    return news;
+}
+const hooksNoteFile = "codex-hooks-note.json";
+// The note's news, none when there is no note or it cannot be read.
+function readNote(folder) {
+    try {
+        const hooks = JSON.parse(readFileSync(join(folder, hooksNoteFile), "utf8"))?.hooks;
+        return hooks === "new" || hooks === "changed" ? hooks : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

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

@@ -1,12 +1,17 @@
 /** The hosts the page offers, by their command's name. */
 export declare const hostNames: readonly ["claude", "codex"];
 export type HostName = typeof hostNames[number];
-/** 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. */
+/**
+ * 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.
+ */
 export interface HostChoices {
     readonly models: readonly string[];
     readonly efforts: readonly string[];
+    readonly model: string;
+    readonly effort: string;
 }
-/** What the player chose for a host on the page: none of either keeps the host's own. */
+/** 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. */
 export interface HostChoice {
     readonly model?: string | undefined;
     readonly effort?: string | undefined;
@@ -18,8 +23,11 @@ export interface HostChoice {
 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 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. */
-export declare function startMessage(language: string | undefined): 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.
+ */
+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.
@@ -30,5 +38,5 @@ 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 the host's own. */
+/** 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;

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

@@ -1,5 +1,5 @@
 // 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
-// for the profile in use; "as the host" passes nothing, and the host's own settings stand.
+// 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"];
@@ -8,15 +8,21 @@ export const hostNames = ["claude", "codex"];
  * models a ChatGPT account lists, which change with its releases.
  */
 export const hostChoices = {
-    claude: { models: ["fable", "opus", "sonnet", "haiku"], efforts: ["low", "medium", "high", "xhigh", "max"] },
-    codex: { models: ["gpt-6.1-sol", "gpt-6-astra", "gpt-6.1-terra", "gpt-6-luna"], efforts: ["low", "medium", "high", "xhigh", "max"] },
+    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" },
 };
 /** Whether a word names a host the page offers. */
 export function isHostName(name) {
     return hostNames.includes(name);
 }
-/** 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. */
-export function startMessage(language) {
+/**
+ * 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.
+ */
+export function startMessage(language, toAnalyse = false) {
+    if (toAnalyse) {
+        return speaksItalian(language) ? "Analizziamo la partita!" : "Let's analyse the game!";
+    }
     return speaksItalian(language) ? "Giochiamo!" : "Let's play!";
 }
 /**
@@ -34,16 +40,16 @@ export function hostArgs(host, message, choice = {}) {
 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 the host's own. */
+/** 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) {
     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]) });
 }
-// The choice kept to the values the host offers.
+// 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 { models, efforts } = hostChoices[host];
-    const model = choice.model !== undefined && models.includes(choice.model) ? choice.model : undefined;
-    const effort = choice.effort !== undefined && efforts.includes(choice.effort) ? choice.effort : undefined;
+    const choices = hostChoices[host];
+    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 };
 }

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

@@ -1,3 +1,4 @@
 export { terminalChats } from "./chats.ts";
+export { setUpTable } from "./hooks.ts";
 export { isHostName } from "./hosts.ts";
 export { endTree, hostLaunch, playHost } from "./play.ts";

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

@@ -1,4 +1,5 @@
 // The AI hosts a table opens a chat in (D-104): their choices, the terminal they open in, and `chesspal play`, which starts one there.
 export { terminalChats } from "./chats.js";
+export { setUpTable } from "./hooks.js";
 export { isHostName } from "./hosts.js";
 export { endTree, hostLaunch, playHost } from "./play.js";

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

@@ -1,5 +1,6 @@
 import { type ChildProcess } from "node:child_process";
-import type { Context } from "../../../commands/index.ts";
+import { type Context } from "../../../commands/index.ts";
+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
@@ -12,11 +13,14 @@ export interface HostLaunch {
     readonly env: NodeJS.ProcessEnv;
     readonly shell: boolean;
     readonly choice: HostChoice;
+    /** Chesspal wrote Codex's hooks, the first time or again: Codex runs them only once the player trusts them. */
+    readonly hooks?: HooksNews;
 }
 /**
  * Runs the host in the table's folder, in this terminal, until it ends: its exit code; started again, clean, when the table asks for a new game (D-57),
- * or for another model or host, which then takes its place (D-107); after an update, by the Chesspal installed (D-108). Ctrl+C is the host's: this
- * process ignores it, or the terminal would close with the chat.
+ * or for another model or host, which then takes its place (D-107); after an update, by the Chesspal installed (D-108). Claude Code closed at its
+ * start with an error, as when the player keeps No at its question on the folder, is told how to answer and started once more. Ctrl+C is the host's:
+ * this process ignores it, or the terminal would close with the chat.
  */
 export declare function playHost(context: Context, host: HostName): Promise<number>;
 /**

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

@@ -3,17 +3,20 @@
 import { spawn, spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { win32 } from "node:path";
+import { speaksItalian } from "../../../commands/index.js";
+import { endOf, gameInAnalysis, loadGame } from "../../../games/index.js";
 import { tableFolder } from "../../../home/index.js";
-import { setUpHosts } from "../../../host-files/index.js";
 import { activeProfile, gameFolder, languageIn, profileSettings } from "../../../profiles/index.js";
 import { programPath } from "./find.js";
+import { setUpTable, takeHooksNews } from "./hooks.js";
 import { choiceIn, hostArgs, isHostName, startMessage } from "./hosts.js";
 import { askedAgain, leaveSeat, refreshSeat, seatTimes, takeSeat } from "./seat.js";
 import { cmdQuoted } from "./terminal.js";
 /**
  * Runs the host in the table's folder, in this terminal, until it ends: its exit code; started again, clean, when the table asks for a new game (D-57),
- * or for another model or host, which then takes its place (D-107); after an update, by the Chesspal installed (D-108). Ctrl+C is the host's: this
- * process ignores it, or the terminal would close with the chat.
+ * or for another model or host, which then takes its place (D-107); after an update, by the Chesspal installed (D-108). Claude Code closed at its
+ * start with an error, as when the player keeps No at its question on the folder, is told how to answer and started once more. Ctrl+C is the host's:
+ * this process ignores it, or the terminal would close with the chat.
  */
 export async function playHost(context, host) {
     const folder = tableFolder(context.home());
@@ -32,6 +35,8 @@ export async function playHost(context, host) {
     let refreshed = Date.now();
     // Chesspal was updated under this process (D-108): the new one plays on.
     let updated = false;
+    // Claude Code was started once more after it closed at its start.
+    let startedOnceMore = false;
     const asked = () => {
         if (Date.now() - refreshed >= seatTimes.refresh) {
             refreshed = Date.now();
@@ -46,6 +51,7 @@ export async function playHost(context, host) {
         for (;;) {
             // A request left from a second click while the host before was ending is not for this one.
             askedAgain(folder, process.pid);
+            const startedAt = context.now();
             const ran = await started(context, playing, asked).catch((error) => {
                 if (before === undefined) {
                     throw error;
@@ -60,7 +66,16 @@ export async function playHost(context, host) {
             }
             before = undefined;
             if (!ran.again) {
-                return ran.code;
+                if (playing !== "claude" || ran.code === 0 || context.now().getTime() - startedAt.getTime() >= closedAtStart) {
+                    return ran.code;
+                }
+                const words = speaksItalian(context.language) ? closedAtStartWords.italian : closedAtStartWords.english;
+                process.stdout.write(`\n${words.join("\n")}\n`);
+                if (startedOnceMore) {
+                    return ran.code;
+                }
+                startedOnceMore = true;
+                continue;
             }
             if (updated) {
                 terminal.restore();
@@ -120,23 +135,60 @@ export function hostLaunch(context, host, env = process.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.`);
     }
-    setUpHosts(folder, context.platform);
+    setUpTable(folder, context.platform);
+    // 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 args = hostArgs(host, startMessage(languageIn(gameFolder(home), context.language)), choice);
+    const games = gameFolder(home);
+    const args = hostArgs(host, startMessage(languageIn(games, context.language), analysisAsked(games)), choice);
     // 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 } : {};
-    const childEnv = { ...env, ...Object.fromEntries(sessionMarks.map((name) => [name, undefined])), ...effort };
+    // 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 };
+        return { program: process.execPath, args: [script, ...args], folder, env: childEnv, shell: false, choice, ...hooks };
+    }
+    return { program: found, args, folder, env: childEnv, shell: context.platform === "win32" && /\.(cmd|bat)$/i.test(found), choice, ...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) {
+    try {
+        const current = loadGame(folder);
+        return (current === undefined || endOf(current.game) !== undefined) && gameInAnalysis(folder) !== undefined;
+    }
+    catch {
+        // A game that cannot be read is status's to report.
+        return false;
     }
-    return { program: found, args, folder, env: childEnv, shell: context.platform === "win32" && /\.(cmd|bat)$/i.test(found), choice };
 }
 const hostTitle = { claude: "Claude Code", codex: "Codex" };
+// What the player is told before Codex asks about the hooks Chesspal wrote: the first time, and when they changed.
+const hooksWords = {
+    new: {
+        english: "Codex will ask about Chesspal's two hooks, small helpers that let it see your moves on the board: choose Trust all and continue.",
+        italian: "Codex ti chiederà dei due «hook» di Chesspal, piccoli aiuti che gli fanno vedere le tue mosse sulla scacchiera: scegli Trust all and continue.",
+    },
+    changed: {
+        english: "Chesspal's hooks for Codex have changed: when Codex asks about them, choose Trust all again.",
+        italian: "Gli «hook» di Chesspal per Codex sono cambiati: quando Codex te lo chiede, scegli di nuovo Trust all.",
+    },
+};
+// What the player is told when Claude Code closed at its start: its question on the folder starts on No.
+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.
 async function started(context, host, again) {
     const launch = hostLaunch(context, host);
     takeSeat(launch.folder, { pid: process.pid, host, ...launch.choice });
+    // 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];
+        process.stdout.write(`${speaksItalian(context.language) ? words.italian : words.english}\n`);
+    }
     return runHost(launch, again, context.platform).catch((error) => {
         throw new Error(`${hostTitle[host]} did not start: ${error.message}`);
     });
@@ -167,6 +219,8 @@ function playUpdated(host) {
 const killAfter = 3_000;
 // A play process that ends sooner never got to its host.
 const quickExit = 10_000;
+// Claude Code ends 1.5 s after No at its question on the folder, a chat the player ends ends with no error (Priya): a minute is the time to read it.
+const closedAtStart = 60_000;
 // A host ended in the middle leaves the modes it set: colours, scroll region, synchronized output, bracketed paste, focus and mouse reports, kitty's
 // keyboard flags, its own screen, a hidden cursor (Priya). All off, and the screen cleared, as a new chat.
 const cleanScreen = "\x1b[0m\x1b[r\x1b[?2026l\x1b[?2004l\x1b[?1004l\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[<99u\x1b[?1049l\x1b[?25h\x1b[2J\x1b[3J\x1b[H";

package/dist/server/table/icon/index.d.ts

@@ -25,6 +25,8 @@ export declare function iconAsked(home: string, machine?: string): boolean;
 export declare function noteIconAsked(home: string, machine?: string): void;
 /** Notes the icon made on this machine, its command and files, which asks no more there. */
 export declare function noteIconMade(home: string, command: IconCommand, files: readonly string[], machine?: string): void;
+/** Takes Chesspal's icon off the desktop and the menu of this machine, the files noted when it was made: those it removed. */
+export declare function removeIcons(home: string, machine?: string): string[];
 /**
  * Whether the icon made on this machine runs another Node or script than `command`, which a Node manager or an update may have taken away, and is still
  * there: then it is made again. One the player removed stays removed.

package/dist/server/table/icon/index.js

@@ -1,8 +1,8 @@
 // Chesspal's icon on the desktop and in the system's menu (D-104): it opens the table as `chesspal` alone does, with no console, on Windows, macOS and Linux.
 // The command line asks once a machine whether to put it there.
-import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, readFileSync, rmSync } from "node:fs";
 import { hostname } from "node:os";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { writeAtomically } from "../../../games/index.js";
 import { tableFolder } from "../../../home/index.js";
@@ -46,6 +46,18 @@ export function noteIconMade(home, command, files, machine = hostname()) {
     const asked = notes.asked.includes(machine) ? notes.asked : [...notes.asked, machine];
     writeIconNotes(home, { asked, made: { ...notes.made, [machine]: { command: commandLine(command), files: [...files] } } });
 }
+/** Takes Chesspal's icon off the desktop and the menu of this machine, the files noted when it was made: those it removed. */
+export function removeIcons(home, machine = hostname()) {
+    const notes = iconNotes(home);
+    // Only Chesspal's own files, by their names, and links too, whose target the player may have thrown away already.
+    const removed = (notes.made[machine]?.files ?? []).filter((file) => iconName.test(basename(file)) && lstatSync(file, { throwIfNoEntry: false }) !== undefined);
+    // On macOS the icon is an application, a folder.
+    for (const file of removed) {
+        rmSync(file, { recursive: true, force: true });
+    }
+    writeIconNotes(home, { ...notes, made: Object.fromEntries(Object.entries(notes.made).filter(([name]) => name !== machine)) });
+    return removed;
+}
 /**
  * Whether the icon made on this machine runs another Node or script than `command`, which a Node manager or an update may have taken away, and is still
  * there: then it is made again. One the player removed stays removed.
@@ -68,6 +80,8 @@ function writeIconNotes(home, notes) {
     mkdirSync(tableFolder(home), { recursive: true });
     writeAtomically(notesFile(home), `${JSON.stringify(notes, null, 2)}\n`);
 }
+// The names of the files an icon is made of, on Windows, Linux and macOS: removing touches no other, whatever the notes say.
+const iconName = /^chesspal\.(lnk|desktop|app)$/i;
 // The notes kept; none when the file is missing or cannot be read, which only asks again.
 function iconNotes(home) {
     const file = notesFile(home);

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

@@ -1,6 +1,6 @@
-export { appBrowser, openedAddress } from "./browser.ts";
+export { appBrowser, type BrowserSystem, type Opened, openedAddress } from "./browser.ts";
 export { hostLaunch, isHostName, playHost, terminalChats } from "./hosts/index.ts";
-export { iconAsked, type IconCommand, iconCommand, type IconPlaces, iconToRemake, makeIcons, noteIconAsked, noteIconMade } from "./icon/index.ts";
+export { iconAsked, type IconCommand, iconCommand, type IconPlaces, iconToRemake, makeIcons, noteIconAsked, noteIconMade, removeIcons } from "./icon/index.ts";
 export { noteFailure, openTable, processLauncher, type TableLauncher } from "./launch.ts";
 export { attachTable, tableToJoin } from "./link.ts";
 export { startTable, type Table, type TableTimes, tableTimes } from "./table.ts";

package/dist/server/table/index.js

@@ -1,7 +1,7 @@
 // The table (D-104): the board page in a process of its own, started by `chesspal` alone, with no chat. Above server/page, which serves the page in either process.
 export { appBrowser, openedAddress } from "./browser.js";
 export { hostLaunch, isHostName, playHost, terminalChats } from "./hosts/index.js";
-export { iconAsked, iconCommand, iconToRemake, makeIcons, noteIconAsked, noteIconMade } from "./icon/index.js";
+export { iconAsked, iconCommand, iconToRemake, makeIcons, noteIconAsked, noteIconMade, removeIcons } from "./icon/index.js";
 export { noteFailure, openTable, processLauncher } from "./launch.js";
 export { attachTable, tableToJoin } from "./link.js";
 export { startTable, tableTimes } from "./table.js";

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

@@ -1,16 +1,17 @@
 import { type Context } from "../../commands/index.ts";
+import { type Opened } from "./browser.ts";
 /** What opening the table does outside this process: start the table apart, open the browser, wait. The tests give their own. */
 export interface TableLauncher {
     /** Starts `chesspal table` apart from this process, which it outlives, in the data folder. */
     start(home: string): void;
-    /** Opens the page in the browser: whether it could. */
-    open(url: string): Promise<boolean>;
+    /** Opens the page in the browser, its window marked with its opening when the table gave one: how it opened. */
+    open(url: string, opening?: number): Promise<Opened>;
     wait(milliseconds: number): Promise<void>;
 }
 /**
  * Opens the table's page in the browser, the table started first when none answers, or when the one that does is of another version, which is asked to
- * quit; a table of this version another `chesspal` started meanwhile is as good. What to tell the player, in their language; a table that does not start
- * within ten seconds throws.
+ * quit; a table of this version another `chesspal` started meanwhile is as good. The window opened last stays, the table's older ones close, and none opens
+ * while another is opening (D-104). What to tell the player, in their language; a table that does not start within ten seconds throws.
  */
 export declare function openTable(context: Context, launcher?: TableLauncher): Promise<string>;
 /**