chesspal 0.3.0 → 0.3.1

package/dist/page/text.js

@@ -5,12 +5,31 @@ export function textFor(languages) {
 }
 const englishNames = { K: "king", Q: "queen", R: "rook", B: "bishop", N: "knight", P: "pawn" };
 const italianNames = { K: "re", Q: "donna", R: "torre", B: "alfiere", N: "cavallo", P: "pedone" };
+const englishMoveWords = {
+    names: englishNames,
+    castles: { short: "castles short", long: "castles long" },
+    from: "from",
+    to: "to",
+    takes: "takes",
+    promotes: "promotes to",
+    check: { check: "check", mate: "checkmate" },
+};
+const italianMoveWords = {
+    names: italianNames,
+    castles: { short: "arrocco corto", long: "arrocco lungo" },
+    from: "da",
+    to: "in",
+    takes: "prende",
+    promotes: "promuove a",
+    check: { check: "scacco", mate: "scacco matto" },
+};
 const english = {
     language: "en",
     flip: "Flip",
     theme: "Light or dark theme",
     sounds: "Sounds",
     voice: "Read the AI's words aloud",
+    saidMove: (move) => moveInWords(englishMoveWords, move),
     newGame: "New game",
     offerDraw: "Offer a draw",
     offerDrawWhen: "Offer a draw: on your turn, once each side has moved",
@@ -134,15 +153,25 @@ const english = {
     asleep: (name) => `${name} is not listening: write a message, such as "hi", in the window where you opened ${name}, not here. Its clock waits until it answers.`,
     asleepInAnalysis: (name) => `${name} is not listening: write to it in the window where you opened it, not here.`,
     table: {
-        label: "Open a chat",
-        noChat: (name) => `To play with ${name}, open its chat: it starts in a window of its own, to keep open.`,
+        title: "Who are you playing?",
+        choose: "Choose the chat to play with: it opens in a window of its own, to keep open.",
+        restartHint: "Choose the model and effort, then press Claude Code or Codex: the chat starts again, clean, in the same window, once it has ended its answer. The game stays as it is.",
+        byHand: (name) => `You opened this chat yourself: change ${name}'s model with /model in its window, or close it and open one from here, with the choices below.`,
+        noChat: "No chat at the table: choose one",
+        change: "Change the chat or its model",
         install: (name) => `To play with ${name}, install Claude Code or Codex, then open this page again.`,
         model: "Model",
         effort: "Effort",
         asHost: (host) => `as set in ${host}`,
         opening: "Opening the chat… In the terminal, if it asks whether you trust the folder, choose Yes with the arrow keys and press Enter.",
         again: (name) => `${name} starts again with a clean chat for the new game…`,
+        restart: "The chat starts again, clean…",
+        waiting: (name) => `${name} starts again once it has ended its answer…`,
+        restartChanged: "Starts again, clean, with the new choices",
+        restartNow: "Start again now: it cuts the answer it is giving",
+        cancel: "Do not start again",
         failed: "The terminal did not open: type the command below in a terminal.",
+        notRestarted: "The chat did not start again: close its window, then open another from here.",
         typeIt: "Or type in a terminal:",
     },
     commandHere: (name) => `/clear and the other commands go in the window where you opened ${name}, not here.`,
@@ -383,6 +412,7 @@ const italian = {
     theme: "Tema chiaro o scuro",
     sounds: "Suoni",
     voice: "Leggi ad alta voce le parole dell'AI",
+    saidMove: (move) => moveInWords(italianMoveWords, move),
     newGame: "Nuova partita",
     offerDraw: "Proponi patta",
     offerDrawWhen: "Proponi patta: nel tuo turno, dopo una mossa a testa",
@@ -506,15 +536,25 @@ const italian = {
     asleep: (name) => `${name} non ti sta ascoltando: scrivi un messaggio, per esempio "ciao", nella finestra dove hai aperto ${name}, non qui. Il suo orologio aspetta che risponda.`,
     asleepInAnalysis: (name) => `${name} non ti sta ascoltando: scrivigli nella finestra dove l'hai aperto, non qui.`,
     table: {
-        label: "Apri una chat",
-        noChat: (name) => `Per giocare con ${name}, apri la sua chat: parte in una finestra a parte, da tenere aperta.`,
+        title: "Contro chi giochi?",
+        choose: "Scegli la chat con cui giocare: parte in una finestra a parte, da tenere aperta.",
+        restartHint: "Scegli modello e ragionamento, poi premi Claude Code o Codex: la chat riparte pulita nella stessa finestra, appena ha finito di rispondere. La partita resta com'è.",
+        byHand: (name) => `Questa chat l'hai aperta tu: cambia il modello di ${name} con /model nella sua finestra, oppure chiudila e aprine una da qui, con le scelte qui sotto.`,
+        noChat: "Nessuna chat al tavolo: scegline una",
+        change: "Cambia la chat o il modello",
         install: (name) => `Per giocare con ${name}, installa Claude Code o Codex, poi apri di nuovo questa pagina.`,
         model: "Modello",
         effort: "Ragionamento",
         asHost: (host) => `come è impostato in ${host}`,
         opening: "Apro la chat… Nel terminale, se ti chiede se ti fidi della cartella, scegli Yes con le frecce e premi Invio.",
         again: (name) => `${name} riparte con una chat pulita per la nuova partita…`,
+        restart: "La chat riparte pulita…",
+        waiting: (name) => `${name} riparte appena ha finito di rispondere…`,
+        restartChanged: "Riparte pulita con le nuove scelte",
+        restartNow: "Riparti adesso: interrompe la risposta in corso",
+        cancel: "Non ripartire",
         failed: "Il terminale non si è aperto: scrivi il comando qui sotto in un terminale.",
+        notRestarted: "La chat non è ripartita: chiudi la sua finestra, poi aprine un'altra da qui.",
         typeIt: "Oppure scrivi in un terminale:",
     },
     commandHere: (name) => `/clear e gli altri comandi vanno scritti nella finestra dove hai aperto ${name}, non qui.`,
@@ -811,6 +851,14 @@ function italianCulprit(by) {
 function italianWith(preposition, letter) {
     return italianThe[letter].replace(/^il /, `${preposition}l `).replace(/^la /, `${preposition}lla `).replace(/^l'/, `${preposition}ll'`);
 }
+/** A move in words: "knight from b takes d7, check", "cavallo in f3", "arrocco corto". */
+function moveInWords(words, move) {
+    const promotion = "castles" in move || move.promotion === undefined ? undefined : `${words.promotes} ${words.names[move.promotion]}`;
+    const played = "castles" in move
+        ? words.castles[move.castles]
+        : [words.names[move.piece], ...(move.from === undefined ? [] : [words.from, move.from]), move.takes ? words.takes : words.to, move.square].join(" ");
+    return [played, promotion, move.check === undefined ? undefined : words.check[move.check]].filter((part) => part !== undefined).join(", ");
+}
 /** The words with their first letter capital, to open a sentence. */
 function capital(words) {
     return words.charAt(0).toUpperCase() + words.slice(1);

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

@@ -8,6 +8,7 @@ export interface ChatSeen {
     readonly given: ReadonlySet<string>;
     readonly seen: string | undefined;
     readonly positionSeen: SeenPosition | null | undefined;
+    readonly positionFirstSeen: SeenPosition | undefined;
     host(): string | undefined;
 }
 /** The chat as the page reads it, in the chat's own process: read from its context at each request, so always as the chat left it. */
@@ -39,6 +40,10 @@ export declare const chatCopy: z.ZodObject<{
         started: z.ZodOptional<z.ZodString>;
         plies: z.ZodInt;
     }, z.core.$strip>>>;
+    positionFirstSeen: z.ZodOptional<z.ZodObject<{
+        started: z.ZodOptional<z.ZodString>;
+        plies: z.ZodInt;
+    }, z.core.$strip>>;
     given: z.ZodArray<z.ZodString>;
     host: z.ZodOptional<z.ZodString>;
     aiModel: z.ZodOptional<z.ZodObject<{

package/dist/server/page/chat.js

@@ -13,6 +13,9 @@ export function chatSeenOf(chat) {
         get positionSeen() {
             return chat.positionSeen;
         },
+        get positionFirstSeen() {
+            return chat.positionFirstSeen;
+        },
         host: () => chat.host?.(),
     };
 }
@@ -47,6 +50,7 @@ export const chatAttach = z.object({
     host: z.string().optional(),
     outdated: z.boolean(),
 });
+const seenPosition = z.object({ started: z.string().optional(), plies: z.int().min(0) });
 /**
  * What the chat attached to the table tells it after each tool, and when the page has news no file holds (`news`): what it saw, the words it was given,
  * its host, and the AI's model and host, which the table notes for a game that ends on the page (D-82, D-97).
@@ -54,7 +58,8 @@ export const chatAttach = z.object({
 export const chatCopy = z.object({
     token: z.string(),
     seen: z.string().optional(),
-    positionSeen: z.object({ started: z.string().optional(), plies: z.int().min(0) }).nullable().optional(),
+    positionSeen: seenPosition.nullable().optional(),
+    positionFirstSeen: seenPosition.optional(),
     given: z.array(z.string()),
     host: z.string().optional(),
     aiModel: z.object({ model: z.string(), effort: z.string().optional() }).optional(),
@@ -74,6 +79,9 @@ export function attachedSeen(attached) {
         get positionSeen() {
             return attached()?.copy?.positionSeen;
         },
+        get positionFirstSeen() {
+            return attached()?.copy?.positionFirstSeen;
+        },
         host: () => attached()?.copy?.host ?? attached()?.chat.host,
     };
 }

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

@@ -69,6 +69,10 @@ export interface Served {
         readonly at: number;
         readonly how: Opening;
     } | undefined;
+    /** The host the page asked the chat to start again with while it was at work (D-107). */
+    restartWanted?: {
+        readonly host: string;
+    } | undefined;
 }
 /**
  * The chat has read the game as it is now, at the end of a tool's call: the doorbell wakes it only for what changes it after; and, when the tool `showed` it

package/dist/server/page/page.js

@@ -17,7 +17,7 @@ import { sendFile, sendHtml } from "./files.js";
 import { answerGame, chatCalls } from "./game.js";
 import { json, send } from "./http.js";
 import { answerProfiles, readRatingsOf } from "./profiles.js";
-import { answerTable } from "./table.js";
+import { answerTable, restartWhenAtRest } from "./table.js";
 /**
  * Serves the page of the context's folder on 127.0.0.1, on a port of its own when free, else on any free one, where the doorbell cannot find it; the
  * table's on its own ports alone, which keep two tables apart. The page reads the chat from the context in the chat's process, and on the table from
@@ -33,7 +33,11 @@ export async function startPage(context, options = {}) {
         context: pageContext(context),
         chat,
         opponent: options.opponent ?? (() => aiNameOf(chat.host())),
-        bell: new Bell(() => hasNews(context, chat), () => tellWatchers(watchers)),
+        // A start again asked while the chat was at work comes once it has ended its answer (D-107).
+        bell: new Bell(() => hasNews(context, chat), () => {
+            restartWhenAtRest(served);
+            tellWatchers(watchers);
+        }),
         watchers,
         port: 0,
         outdated: outdatedHostFiles(folder, context.platform).length > 0,
@@ -77,6 +81,7 @@ export function chatHasRead(context, showed) {
         catch {
             context.positionSeen = null;
         }
+        context.positionFirstSeen ??= context.positionSeen ?? undefined;
         // The chat on another position may now be thinking on its move: the page hears it, which no file tells when no bell woke the chat.
         if (!sameSeen(before, context.positionSeen)) {
             context.heard?.();

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

@@ -9,31 +9,50 @@ export interface ChatHost {
     readonly command: string;
 }
 /**
- * How the table opens a chat: the hosts it offers, and a terminal with one of them, whether one opened; whether `chesspal play` holds the chat of a folder,
- * and how it is asked to start it again.
+ * How the table opens a chat: the hosts it offers, and a terminal with one of them, whether one opened; the chat `chesspal play` holds in a folder, with
+ * the model and effort it started with, and how it is asked to start it again.
  */
 export interface TableChats {
     hosts(): readonly ChatHost[];
     open(host: string): Promise<boolean>;
-    holds(folder: string): boolean;
-    relaunch(folder: string): boolean;
+    held(folder: string): HeldChat | undefined;
+    relaunch(folder: string, host?: string): boolean;
 }
-/** A chat opening at the table: one the page asked for, or the one started again for a new game. */
-export type Opening = "chat" | "again";
-/** What the table's page shows of its chat: whether one is at the table, the hosts it can open one in, and one opening. */
+/** The chat `chesspal play` holds: the model and effort its host started with, none for the host's own. */
+export interface HeldChat {
+    readonly model?: string | undefined;
+    readonly effort?: string | undefined;
+}
+/** A chat opening at the table: one the page asked for, the one started again for a new game, or with another model or host (D-107). */
+export type Opening = "chat" | "again" | "restart";
+/** What the table's page shows of its chat (D-104, D-107). */
+export interface TableShown {
+    /** Whether a chat is at the table, and its host among those offered, when it says one. */
+    readonly chat: boolean;
+    readonly host?: string;
+    /** Whether `chesspal play` holds the chat, which the page can then start again; one opened by hand it cannot. With the model and effort it started with. */
+    readonly held: boolean;
+    readonly started?: HeldChat;
+    readonly hosts: readonly ChatHost[];
+    readonly opening?: Opening;
+    /** A start again asked while the chat was at work, waiting for it to end its answer, or to be started at once or let go from the page. */
+    readonly waiting?: true;
+}
+/** What the table's page shows of its chat: whether one is at the table, with which host, the hosts it can open one in, and one opening. */
 export declare function tableShown(served: Served): {
-    table?: {
-        chat: boolean;
-        hosts: readonly ChatHost[];
-        opening?: Opening;
-    };
+    table?: TableShown;
 };
 /** Answers the table's own routes, under /api/table/; false for any other, and for every request to a page a chat serves itself. */
 export declare function answerTable(request: IncomingMessage, response: ServerResponse, url: URL, served: Served): boolean;
 /**
  * Whether a new game starts the chat at the table again, clean (D-57): `chesspal play` holds it, it waits for the bell, no analyst of it is at work, and it
- * has seen a game; one that only greeted the player stays.
+ * 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.
  */
 export declare function chatToRelaunch(served: Served): boolean;
-/** Asks `chesspal play` to start the chat at the table again, once the new game has started: whether it was asked; the pages then show it opening. */
-export declare function relaunchChat(served: Served): boolean;
+/**
+ * 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 declare function relaunchChat(served: Served, how?: "again" | "restart", host?: string): boolean;
+/** Starts the chat again as the page asked while it was at work, now that it has ended its answer; a chat gone meanwhile takes the request with it. */
+export declare function restartWhenAtRest(served: Served): void;

package/dist/server/page/table.js

@@ -1,15 +1,28 @@
+import { samePosition } from "../../commands/index.js";
 import { gameInAnalysis } from "../../games/index.js";
 import { gameFolder } from "../../profiles/index.js";
 import { tellWatchers } from "./events.js";
 import { bodyOf, isJson, jsonOf, runRoute, sendJson } from "./http.js";
-/** What the table's page shows of its chat: whether one is at the table, the hosts it can open one in, and one opening. */
+/** What the table's page shows of its chat: whether one is at the table, with which host, the hosts it can open one in, and one opening. */
 export function tableShown(served) {
-    const { table } = served;
+    const { table, attached } = served;
     if (table === undefined) {
         return {};
     }
+    const host = hostAtTable(served);
+    const held = heldChat(served);
     const now = opening(served);
-    return { table: { chat: served.attached !== undefined, hosts: table.chats?.hosts() ?? [], ...(now === undefined ? {} : { opening: now }) } };
+    return {
+        table: {
+            chat: attached !== undefined,
+            ...(host === undefined ? {} : { host }),
+            held: held !== undefined,
+            ...(held === undefined ? {} : { started: held }),
+            hosts: table.chats?.hosts() ?? [],
+            ...(now === undefined ? {} : { opening: now }),
+            ...(served.restartWanted === undefined ? {} : { waiting: true }),
+        },
+    };
 }
 /** Answers the table's own routes, under /api/table/; false for any other, and for every request to a page a chat serves itself. */
 export function answerTable(request, response, url, served) {
@@ -25,30 +38,54 @@ export function answerTable(request, response, url, served) {
     else if (path === "/api/table/chat") {
         runRoute(response, () => openChat(request, response, served));
     }
+    else if (path === "/api/table/restart") {
+        runRoute(response, () => restartChat(request, response, served));
+    }
+    else if (path === "/api/table/waiting") {
+        runRoute(response, () => endWaiting(request, response, served));
+    }
     else {
-        sendJson(response, 404, { error: `${path} is no route of the table's: it answers POST /api/table/chat and /api/table/quit.` });
+        sendJson(response, 404, { error: `${path} is no route of the table's: it answers POST /api/table/chat, /api/table/restart, /api/table/waiting and /api/table/quit.` });
     }
     return true;
 }
 /**
  * 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; one that only greeted the player stays.
+ * 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.
  */
 export function chatToRelaunch(served) {
-    const { attached, bell } = served;
-    const stopped = bell.listening && !bell.inTurn;
-    const analysing = gameInAnalysis(gameFolder(served.context.home()))?.analyst !== undefined;
-    return attached !== undefined && stopped && !analysing && served.chat.positionSeen?.started !== undefined && served.table?.chats?.holds(attached.chat.folder) === true;
+    const { positionSeen, positionFirstSeen } = served.chat;
+    const played = positionSeen?.started !== undefined && (positionFirstSeen === undefined || !samePosition(positionSeen, positionFirstSeen));
+    return played && heldChat(served) !== undefined && chatAtRest(served);
 }
-/** Asks `chesspal play` to start the chat at the table again, once the new game has started: whether it was asked; the pages then show it opening. */
-export function relaunchChat(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;
-    if (folder === undefined || served.table?.chats?.relaunch(folder) !== true) {
+    // 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 || served.table?.chats?.relaunch(folder, host) !== true) {
         return false;
     }
-    noteOpening(served, "again");
+    noteOpening(served, switching ? "chat" : how);
     return true;
 }
+/** Starts the chat again as the page asked while it was at work, now that it has ended its answer; a chat gone meanwhile takes the request with it. */
+export function restartWhenAtRest(served) {
+    const wanted = served.restartWanted;
+    if (wanted === undefined) {
+        return;
+    }
+    if (heldChat(served) === undefined) {
+        served.restartWanted = undefined;
+    }
+    else if (chatAtRest(served)) {
+        served.restartWanted = undefined;
+        relaunchChat(served, "restart", wanted.host);
+    }
+}
 // A terminal takes a few seconds to open and its chat to attach: a second click meanwhile would open a second chat, which serves a page of its own.
 const openingFor = 30_000;
 /**
@@ -56,13 +93,12 @@ const openingFor = 30_000;
  * opening. Whether it opened; else the page shows the command to type.
  */
 async function openChat(request, response, served) {
-    const host = jsonOf(await bodyOf(request))?.host;
-    const offered = served.table?.chats?.hosts().find((one) => one.name === host && one.installed);
-    if (request.headers.origin !== `http://127.0.0.1:${served.port}` && request.headers.origin !== `http://localhost:${served.port}`) {
+    const offered = hostOffered(served, jsonOf(await bodyOf(request))?.host);
+    if (!fromTablePage(request, served)) {
         sendJson(response, 403, { error: "Only the table's own page opens a chat." });
     }
     else if (offered === undefined || served.table?.chats === undefined) {
-        sendJson(response, 400, { error: `Name a host the table offers and this computer has: ${served.table?.chats?.hosts().filter((one) => one.installed).map((one) => one.name).join(", ") || "none"}.` });
+        sendJson(response, 400, { error: hostsOffered(served) });
     }
     else if (served.attached !== undefined || opening(served) !== undefined) {
         sendJson(response, 409, { error: "A chat is at the table, or opening: play there." });
@@ -77,6 +113,78 @@ async function openChat(request, response, served) {
         tellWatchers(served.watchers);
     }
 }
+/**
+ * Starts the chat `chesspal play` holds again, clean, with the host the page names and the model and effort it keeps for it (D-107): at once when it is at
+ * rest, else once it has ended its answer. Asked by the table's own page alone; a chat opened by hand changes its model with /model.
+ */
+async function restartChat(request, response, served) {
+    const offered = hostOffered(served, jsonOf(await bodyOf(request))?.host);
+    if (!fromTablePage(request, served)) {
+        sendJson(response, 403, { error: "Only the table's own page starts the chat again." });
+    }
+    else if (offered === undefined) {
+        sendJson(response, 400, { error: hostsOffered(served) });
+    }
+    else if (heldChat(served) === undefined) {
+        sendJson(response, 409, { error: "No chat the table opened is at it: open one from the page, or change the model with /model in a chat opened by hand." });
+    }
+    else if (chatAtRest(served)) {
+        sendJson(response, 200, { restarting: relaunchChat(served, "restart", offered.name) });
+    }
+    else {
+        served.restartWanted = { host: offered.name };
+        tellWatchers(served.watchers);
+        sendJson(response, 200, { waiting: true });
+    }
+}
+/**
+ * Ends a start again the page asked while the chat was at work (D-107): `now` starts it at once, cutting the answer it gives, as after an Esc, when it would
+ * never end; else the request is let go. Asked by the table's own page alone.
+ */
+async function endWaiting(request, response, served) {
+    const now = jsonOf(await bodyOf(request))?.now;
+    const wanted = served.restartWanted;
+    if (!fromTablePage(request, served)) {
+        sendJson(response, 403, { error: "Only the table's own page ends a start again that waits." });
+    }
+    else if (typeof now !== "boolean") {
+        sendJson(response, 400, { error: "Say now: true to start the chat again at once, cutting its answer, or now: false to let the request go." });
+    }
+    else if (wanted === undefined) {
+        sendJson(response, 409, { error: "No start again waits: ask for one from the chat's window." });
+    }
+    else {
+        served.restartWanted = undefined;
+        const restarting = now && heldChat(served) !== undefined && relaunchChat(served, "restart", wanted.host);
+        tellWatchers(served.watchers);
+        sendJson(response, 200, now ? { restarting } : { waiting: false });
+    }
+}
+// The browser marks a request of the table's own page with its origin.
+function fromTablePage(request, served) {
+    return request.headers.origin === `http://127.0.0.1:${served.port}` || request.headers.origin === `http://localhost:${served.port}`;
+}
+function hostOffered(served, host) {
+    return served.table?.chats?.hosts().find((one) => one.name === host && one.installed);
+}
+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».
+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;
+}
+// The chat at the table when `chesspal play` holds it, which the table can start again: the model and effort it started with.
+function heldChat(served) {
+    const { attached } = served;
+    return attached === undefined ? undefined : served.table?.chats?.held(attached.chat.folder);
+}
+// The chat waits for the doorbell, out of a turn, and no analyst of it is at work: starting it again loses nothing.
+function chatAtRest(served) {
+    const { bell } = served;
+    return bell.listening && !bell.inTurn && gameInAnalysis(gameFolder(served.context.home()))?.analyst === undefined;
+}
 // The pages show a chat opening from now until it attaches; one that has not by then lets them open another. The opening noted.
 function noteOpening(served, how) {
     const opened = { at: served.context.now().getTime(), how };
@@ -98,5 +206,5 @@ function opening(served) {
     if (chatOpened !== undefined && context.now().getTime() - chatOpened.at < openingFor) {
         return chatOpened.how;
     }
-    return served.table?.chats?.holds(context.folder) === true ? "chat" : undefined;
+    return served.table?.chats?.held(context.folder) === undefined ? undefined : "chat";
 }

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

@@ -2,7 +2,7 @@ import { tableFolder } from "../../../home/index.js";
 import { samePath } from "../../bell.js";
 import { programPath } from "./find.js";
 import { hostChoices, hostNames, isHostName } from "./hosts.js";
-import { askAgain, seatTaken } from "./seat.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
@@ -20,8 +20,11 @@ export function terminalChats(context, chesspal = [process.execPath, ...process.
         },
         open: async (host) => isHostName(host) && await openTerminal(tableFolder(context.home()), [...chesspal, "play", host], context.platform, env),
         // Only a chat in the table's folder can be the one chesspal play holds.
-        holds: (folder) => samePath(folder, tableFolder(context.home())) && seatTaken(folder, context.now()),
-        relaunch: (folder) => samePath(folder, tableFolder(context.home())) && askAgain(folder, context.now()),
+        held: (folder) => {
+            const seat = samePath(folder, tableFolder(context.home())) ? seatHeld(folder, context.now()) : undefined;
+            return seat === undefined ? undefined : { model: seat.model, effort: seat.effort };
+        },
+        relaunch: (folder, host) => samePath(folder, tableFolder(context.home())) && askAgain(folder, context.now(), host === undefined ? {} : { host }),
     };
 }
 // Looking on the PATH takes a few milliseconds, and the page asks at every change of the game.

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

@@ -1,16 +1,20 @@
 import type { Context } from "../../../commands/index.ts";
-import { type HostName } from "./hosts.ts";
-/** What `chesspal play` starts: the host's program, its arguments, folder and environment, and whether it needs cmd, as a .cmd shim does on Windows. */
+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).
+ */
 export interface HostLaunch {
     readonly program: string;
     readonly args: readonly string[];
     readonly folder: string;
     readonly env: NodeJS.ProcessEnv;
     readonly shell: boolean;
+    readonly choice: HostChoice;
 }
 /**
- * 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).
- * Ctrl+C is the host's: this process ignores it, or the terminal would close with the chat.
+ * 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). 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

@@ -7,12 +7,12 @@ 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 { choiceIn, hostArgs, startMessage } from "./hosts.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).
- * Ctrl+C is the host's: this process ignores it, or the terminal would close with the chat.
+ * 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). 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());
@@ -24,24 +24,44 @@ export async function playHost(context, host) {
         process.exit(129);
     });
     const terminal = savedTerminal(context.platform);
+    let playing = host;
+    let next = host;
+    // The host before one asked in its place, until that one has started: it goes on when the other does not start.
+    let before;
     let refreshed = Date.now();
     const asked = () => {
         if (Date.now() - refreshed >= seatTimes.refresh) {
             refreshed = Date.now();
             refreshSeat(folder, process.pid);
         }
-        return askedAgain(folder, process.pid);
+        const again = askedAgain(folder, process.pid);
+        next = again?.host !== undefined && isHostName(again.host) ? again.host : playing;
+        return again !== undefined;
     };
     try {
         for (;;) {
             // A request left from a second click while the host before was ending is not for this one.
             askedAgain(folder, process.pid);
-            const ran = await runHost(hostLaunch(context, host), asked, context.platform).catch((error) => {
-                throw new Error(`${hostTitle[host]} did not start: ${error.message}`);
+            const ran = await started(context, playing, asked).catch((error) => {
+                if (before === undefined) {
+                    throw error;
+                }
+                process.stderr.write(`${error.message} ${hostTitle[before]} goes on.\n`);
+                return undefined;
             });
+            if (ran === undefined) {
+                playing = before ?? playing;
+                before = undefined;
+                continue;
+            }
+            before = undefined;
             if (!ran.again) {
                 return ran.code;
             }
+            if (next !== playing) {
+                before = playing;
+                playing = next;
+            }
             terminal.restore();
             process.stdout.write(cleanScreen);
         }
@@ -98,11 +118,19 @@ export function hostLaunch(context, host, env = process.env, exists) {
     const childEnv = { ...env, ...Object.fromEntries(sessionMarks.map((name) => [name, undefined])), ...effort };
     const script = npmScript(host, found, context.platform, exists ?? existsSync);
     if (script !== undefined) {
-        return { program: process.execPath, args: [script, ...args], folder, env: childEnv, shell: false };
+        return { program: process.execPath, args: [script, ...args], folder, env: childEnv, shell: false, choice };
     }
-    return { program: found, args, folder, env: childEnv, shell: context.platform === "win32" && /\.(cmd|bat)$/i.test(found) };
+    return { program: found, args, folder, env: childEnv, shell: context.platform === "win32" && /\.(cmd|bat)$/i.test(found), choice };
 }
 const hostTitle = { claude: "Claude Code", codex: "Codex" };
+// 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 });
+    return runHost(launch, again, context.platform).catch((error) => {
+        throw new Error(`${hostTitle[host]} did not start: ${error.message}`);
+    });
+}
 // A host that has not ended this long after it was asked is killed.
 const killAfter = 3_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