chesspal 0.3.1 → 0.3.3

package/dist/server/{bell.js → bell/bell.js}

@@ -4,9 +4,10 @@ import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import { get } from "node:http";
 import { join, resolve } from "node:path";
-import { writeAtomically } from "../games/index.js";
-import { dataFolder, tableFolder } from "../home/index.js";
-import { version } from "../version.js";
+import { writeAtomically } from "../../games/index.js";
+import { dataFolder, tableFolder } from "../../home/index.js";
+import { analystAgent } from "../../host-files/index.js";
+import { version } from "../../version.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.";
 /**
@@ -171,7 +172,8 @@ export async function bellHeard(input, ports) {
         const pages = ours.length > 1 ? `${ours.length} pages of it, none of this chat's session, ${open} open in a browser` : "no page of it";
         return { folder, rang: false, why: `${pages} at ports ${tried.join(", ")}${others.length > 0 ? `; ${others.join(", ")}` : ""}` };
     }
-    const said = await body(port, "/api/bell");
+    // The page lets the analyst go as the hook starts waiting, when none runs any more.
+    const said = await body(port, hook.analystGone === true ? "/api/bell?analyst=gone" : "/api/bell");
     return said === "ring" ? { folder, rang: true } : { folder, rang: false, why: said === undefined ? `the page at port ${port} did not answer` : `the page at port ${port} said "${said}"` };
 }
 // How long a port may take to say whose page it is: one of this computer answers at once.
@@ -244,12 +246,23 @@ function hookInput(input) {
         return {
             ...(typeof parsed.session_id === "string" ? { session: parsed.session_id } : {}),
             ...(typeof parsed.cwd === "string" ? { cwd: parsed.cwd } : {}),
+            ...(analystGone(parsed.background_tasks) ? { analystGone: true } : {}),
         };
     }
     catch {
         return {};
     }
 }
+/**
+ * Whether Claude Code's Stop hook says no analyst runs in the background: after it ends, is stopped or fails, the chat takes a turn, and its Stop hook
+ * lists the tasks still running (D-109, Priya's test). A host that lists none says nothing.
+ */
+function analystGone(tasks) {
+    return Array.isArray(tasks) && !tasks.some((task) => {
+        const { agent_type: agent, status } = (task ?? {});
+        return agent === analystAgent && status === "running";
+    });
+}
 /**
  * The chat's page among those of its folder: the one of its session; else the only one, or the only one a browser has open, where the player plays. Codex
  * gives the page no session, and a chat closed may leave its page behind for a while.

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

@@ -0,0 +1 @@
+export { Bell, bellProbe, listen, pageAt, pagePorts, samePath, type TableChat } from "./bell.ts";

package/dist/server/bell/index.js

@@ -0,0 +1,2 @@
+// The doorbell that wakes a chat when the player acts on the page (D-47), and the ports where a folder's page answers.
+export { Bell, bellProbe, listen, pageAt, pagePorts, samePath } from "./bell.js";

package/dist/server/{caller.d.ts → mcp/caller.d.ts}

@@ -1,4 +1,4 @@
-import type { Caller } from "../commands/index.ts";
+import type { Caller } from "../../commands/index.ts";
 /** The host as it names itself to the server. */
 export interface Client {
     name: string;

package/dist/server/{caller.js → mcp/caller.js}

@@ -3,7 +3,7 @@
 import { closeSync, openSync, readdirSync, readFileSync, readSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, join } from "node:path";
-import { lastChatStart } from "../games/index.js";
+import { lastChatStart } from "../../games/index.js";
 /** Who made the call with these metadata: the model and effort the host ties to it, else the host's name; undefined without a host. */
 export async function callerOf(meta, client, folder, wait = 50) {
     const turn = objectOf(meta?.["x-codex-turn-metadata"]);

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

@@ -0,0 +1 @@
+export { startMcpServer } from "./mcp.ts";

package/dist/server/mcp/index.js

@@ -0,0 +1,2 @@
+// The MCP server an AI host starts, every command as a tool (D-5); it loads the MCP SDK, so only `chesspal mcp` imports it.
+export { startMcpServer } from "./mcp.js";

package/dist/server/{mcp.d.ts → mcp/mcp.d.ts}

@@ -1,5 +1,5 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { type AnyCommand, type Context } from "../commands/index.ts";
+import { type AnyCommand, type Context } from "../../commands/index.ts";
 /**
  * What the host reads as the server starts, before any tool: the lines that start a chat, `instructions` then `status`, and the rule of every move (D-27,
  * D-102). Short, since hosts cut them or copy them into every tool.

package/dist/server/{mcp.js → mcp/mcp.js}

@@ -3,16 +3,16 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { aiMove, commands, defaultContext, inputProblems, isBoolean, PositionChanged } from "../commands/index.js";
-import { aiNameOf } from "../core/index.js";
-import { endOf, loadGame, noteAiHost, noteAiModel, rerunIfChanged } from "../games/index.js";
-import { agentTools, hasAgent, startInstructions } from "../host-files/index.js";
-import { gameFolder } from "../profiles/index.js";
-import { version } from "../version.js";
-import { pagePorts } from "./bell.js";
+import { aiMove, commands, defaultContext, inputProblems, isBoolean, PositionChanged } from "../../commands/index.js";
+import { aiNameOf } from "../../core/index.js";
+import { endOf, loadGame, noteAiHost, noteAiModel, rerunIfChanged } from "../../games/index.js";
+import { agentTools, hasAgent, startInstructions } from "../../host-files/index.js";
+import { gameFolder } from "../../profiles/index.js";
+import { version } from "../../version.js";
+import { pagePorts } from "../bell/index.js";
+import { chatHasRead, startPage } from "../page/index.js";
+import { attachTable, tableToJoin } from "../table/index.js";
 import { allowedCaller, callerOf, callingAgent, fromCodexAgent } from "./caller.js";
-import { chatHasRead, startPage } from "./page/page.js";
-import { attachTable, tableToJoin } from "./table/index.js";
 /**
  * What the host reads as the server starts, before any tool: the lines that start a chat, `instructions` then `status`, and the rule of every move (D-27,
  * D-102). Short, since hosts cut them or copy them into every tool.

package/dist/server/page/attach.js

@@ -1,7 +1,7 @@
 // The table's end of the chat attached to it (D-104): the chat attaches and stays while its process lives, says when it calls a tool, sends a copy of what
 // it saw, and asks for the New game window. One chat at a time, of this version alone; a page a chat serves itself has none of these routes.
 import { randomUUID } from "node:crypto";
-import { forgetTheAi, noteAiHost, noteAiModel } from "../../games/index.js";
+import { forgetAnalyst, forgetTheAi, noteAiHost, noteAiModel } from "../../games/index.js";
 import { gameFolder } from "../../profiles/index.js";
 import { version } from "../../version.js";
 import { chatAttach, chatCopy } from "./chat.js";
@@ -67,10 +67,15 @@ function attach(body, response, served) {
     });
     tellWatchers(served.watchers);
 }
-/** The next chat may play in another host, with another model: the AI's card shows its own from its first move (Federico). */
+/**
+ * The next chat may play in another host, with another model: the AI's card shows its own from its first move (Federico). The analyst ended with its chat
+ * (D-109): the game it held is free for the next one.
+ */
 function forgetChat(served) {
     try {
-        forgetTheAi(gameFolder(served.context.home()));
+        const folder = gameFolder(served.context.home());
+        forgetTheAi(folder);
+        forgetAnalyst(folder);
     }
     catch {
         // A data folder that cannot be read keeps no notes to forget.

package/dist/server/page/game.js

@@ -1,11 +1,13 @@
-import { analyseGame, answerDraw, bookPlies, ChatNotClear, DrawRefused, endGame, gameAt, gameToStudy, namedGame, newGame, offerDraw, playMove, samePosition, say, shownPosition, startNewGame, } from "../../commands/index.js";
+import { analyseGame, analystOf, answerDraw, bookPlies, ChatNotClear, DrawRefused, endGame, gameAt, gameToStudy, namedGame, newGame, offerDraw, playMove, samePosition, say, shownPosition, startNewGame, } from "../../commands/index.js";
 import { clockStarted, isReviewed, writePgn } from "../../core/index.js";
 import { aiModelOf, archiveName, coachShown, coachWords, drawOfferOf, endOf, gameInAnalysis, heardLines, loadGame, loadTableTalk, playerPgn, ponderingOn, rerunIfChanged, saveGame, startAnalysis, talkLimits, thoughtKey, wakesTheChat, WordsRefused, } from "../../games/index.js";
 import { gameFolder, helpsIn } from "../../profiles/index.js";
+import { version } from "../../version.js";
 import { asTheChatSees } from "./chat.js";
 import { bodyOf, bytesOf, isJson, json, jsonOf, runRoute, send, textOf } from "./http.js";
 import { profilesShown } from "./profiles.js";
 import { chatToRelaunch, 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) {
     const route = routes[`${request.method ?? ""} ${url.pathname}`];
@@ -295,6 +297,8 @@ function sendGame(response, served) {
     const analysis = current === undefined || endOf(current.game) !== undefined ? analysisShown(served) : undefined;
     const aiModel = aiModelOf(folder);
     const body = {
+        // The page loaded from another version loads again, its files and all (Federico).
+        version,
         game,
         ...(game === null && talk.length > 0 ? { talk } : {}),
         ...(analysis === undefined ? {} : { analysis }),
@@ -303,6 +307,7 @@ function sendGame(response, served) {
         listening: served.bell.listening,
         ...thinkingShown(served, current),
         ...(served.outdated ? { outdated: true } : {}),
+        ...updateShown(served),
         ...tableShown(served),
         ...profilesShown(served.context.home()),
     };
@@ -336,7 +341,10 @@ function coachOn(folder, current) {
     const shown = coachShown(coachWords(folder, current), current);
     return shown.judgments.length === 0 && shown.hint === undefined && shown.leads === undefined ? undefined : shown;
 }
-/** The game in analysis, once no game goes on (D-69): its name and its PGN with the AI's review; none without one, or when it cannot be read. */
+/**
+ * The game in analysis, once no game goes on (D-69): its name and its PGN with the AI's review, and whether an AI is going over it now; none without one,
+ * or when it cannot be read.
+ */
 function analysisShown(served) {
     const analysis = gameInAnalysis(gameFolder(served.context.home()));
     if (analysis === undefined) {
@@ -344,8 +352,16 @@ function analysisShown(served) {
     }
     try {
         const { name, record } = namedGame(served.context, analysis.game);
+        // Without a review, an AI is at it only while the chat is in a turn, or hears the player while its analyst holds the game (D-89): one the chat has
+        // started again since is gone (Priya). On the table the chat's start is in the chat's own folder.
+        const { bell } = served;
+        const chat = { ...served.context, folder: served.attached?.chat.folder ?? served.folder };
+        const reviewed = isReviewed(record);
+        const reviewing = !reviewed && (bell.inTurn || (bell.listening && analystOf(chat, analysis.game) !== undefined));
+        // Without a review and with nobody at it, the analysis is incomplete: the page offers to bring it back to the AI (D-109).
+        const state = reviewed ? {} : reviewing ? { reviewing: true } : { incomplete: true };
         // How far the book goes, which the page cannot tell without the book's moves: its card names the opening on those moves.
-        return { name, pgn: writePgn(record), book: bookPlies(record) };
+        return { name, pgn: writePgn(record), book: bookPlies(record), ...state };
     }
     catch {
         // A game gone from the archive is no longer shown.

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

@@ -8,7 +8,7 @@ export declare const json = "application/json; charset=utf-8";
  */
 export interface Refused {
     readonly error: string;
-    readonly refusal?: "no-game" | "ai-to-move" | "illegal" | "clear-chat" | `words-${WordsRefused["reason"]}` | `draw-${DrawRefused["reason"]}` | "profile-game" | "game-going" | "pgn-unreadable";
+    readonly refusal?: "no-game" | "ai-to-move" | "illegal" | "clear-chat" | `words-${WordsRefused["reason"]}` | `draw-${DrawRefused["reason"]}` | "profile-game" | "game-going" | "pgn-unreadable" | "update-game" | "update-chat";
     readonly most?: number;
 }
 /** Answers a request, with nothing cached, sniffed or referred, and the page's policy unless the headers give another. */

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

@@ -0,0 +1,3 @@
+export { jsonOf } from "./http.ts";
+export { chatHasRead, type Page, startPage } from "./page.ts";
+export type { ChatHost, TableChats } from "./table.ts";

package/dist/server/page/index.js

@@ -0,0 +1,3 @@
+// The board page's server (D-8, D-47): its files, its routes, the events the pages listen to and the chat attached to the table. Below the table and the MCP server.
+export { jsonOf } from "./http.js";
+export { chatHasRead, startPage } from "./page.js";

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

@@ -1,6 +1,6 @@
 import { type ServerResponse } from "node:http";
 import { type Context } from "../../commands/index.ts";
-import { Bell } from "../bell.ts";
+import { Bell } from "../bell/index.ts";
 import { type Attached, type ChatSeen } from "./chat.ts";
 import { type Opening, type TableChats } from "./table.ts";
 /**
@@ -29,13 +29,19 @@ export interface PageOptions {
     readonly table?: TableEnd;
 }
 /**
- * What the page tells the table that serves it: a request came, so the table is in use, or another Chesspal version asked it to quit; and how the table
- * opens a chat, which the page offers while none is at the table.
+ * What the page tells the table that serves it: a request came, so the table is in use, or another Chesspal version asked it to quit; how the table
+ * opens a chat, which the page offers while none is at the table, and how it updates Chesspal.
  */
 export interface TableEnd {
     used(): void;
     quit(): void;
     readonly chats?: TableChats | undefined;
+    readonly update?: TableUpdate | undefined;
+}
+/** How the table updates Chesspal (D-108): npm installs a version, whether it did, and the table closes to start again from it. */
+export interface TableUpdate {
+    install(version: string): Promise<boolean>;
+    restart(): void;
 }
 /**
  * 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
@@ -73,6 +79,9 @@ export interface Served {
     restartWanted?: {
         readonly host: string;
     } | undefined;
+    /** The newer Chesspal npm has (D-108); the table installing it, installed and waiting to be at rest, or starting again from it. */
+    newer?: string;
+    updating?: "installing" | "installed" | "restarting" | 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

@@ -5,10 +5,10 @@ import { createServer } from "node:http";
 import { join } from "node:path";
 import { positionIn, samePosition } from "../../commands/index.js";
 import { aiNameOf } from "../../core/index.js";
-import { gameStamp, tableTalkStamp } from "../../games/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, bellProbe, pagePorts } from "../bell.js";
+import { Bell, bellProbe, pagePorts } from "../bell/index.js";
 import { analysesOf, answerAnalyses } from "./analyses.js";
 import { answerChat } from "./attach.js";
 import { attachedSeen, chatSeenOf, pageContext } from "./chat.js";
@@ -17,7 +17,8 @@ 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, restartWhenAtRest } from "./table.js";
+import { answerTable, restartWhenAtRest, updateWhenAtRest } from "./table.js";
+import { watchForUpdates } from "./update.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,9 +34,10 @@ export async function startPage(context, options = {}) {
         context: pageContext(context),
         chat,
         opponent: options.opponent ?? (() => aiNameOf(chat.host())),
-        // A start again asked while the chat was at work comes once it has ended its answer (D-107).
+        // A start again asked while the chat was at work comes once it has ended its answer (D-107), as an update installed meanwhile (D-108).
         bell: new Bell(() => hasNews(context, chat), () => {
             restartWhenAtRest(served);
+            updateWhenAtRest(served);
             tellWatchers(watchers);
         }),
         watchers,
@@ -49,7 +51,12 @@ export async function startPage(context, options = {}) {
         if (await listened(server, port)) {
             server.unref();
             served.port = portOf(server);
-            const stopWatching = watchGame(served);
+            const stopWatchingGame = watchGame(served);
+            const stopAskingNpm = watchForUpdates(served);
+            const stopWatching = () => {
+                stopWatchingGame();
+                stopAskingNpm();
+            };
             return {
                 url: `http://127.0.0.1:${served.port}/`,
                 heard: () => tellWatchers(watchers),
@@ -134,6 +141,9 @@ function answer(request, response, served) {
             send(response, 200, json, JSON.stringify(bellProbe(served.folder, served.watchers.size > 0, tableChat(served))));
         }
         else {
+            if (url.searchParams.get("analyst") === "gone") {
+                forgetGoneAnalyst(served);
+            }
             served.bell.listen(request, response);
         }
     }
@@ -141,6 +151,15 @@ function answer(request, response, served) {
         sendFile(response, path);
     }
 }
+/** The chat's hook says no analyst runs any more (D-109): the game it held is free, and its review, unless finished, incomplete. */
+function forgetGoneAnalyst(served) {
+    try {
+        forgetAnalyst(gameFolder(served.context.home()));
+    }
+    catch {
+        // A data folder that cannot be written keeps the analyst until half an hour has gone by.
+    }
+}
 /** The chat at the table, as its probe says it: none on a page a chat serves itself. */
 function tableChat(served) {
     if (served.table === undefined) {
@@ -188,6 +207,8 @@ function watchGame(served) {
                 waiting = undefined;
                 watchAll();
                 tellWatchers(served.watchers);
+                // A game that has ended lets an update installed meanwhile start the table again (D-108).
+                updateWhenAtRest(served);
             }, 30);
         }
     };

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

@@ -16,7 +16,8 @@ export interface TableChats {
     hosts(): readonly ChatHost[];
     open(host: string): Promise<boolean>;
     held(folder: string): HeldChat | undefined;
-    relaunch(folder: string, host?: string): boolean;
+    /** 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;
 }
 /** The chat `chesspal play` holds: the model and effort its host started with, none for the host's own. */
 export interface HeldChat {
@@ -56,3 +57,8 @@ export declare function chatToRelaunch(served: Served): boolean;
 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;
+/**
+ * Once npm has installed the newer Chesspal (D-108), and no game goes on and the chat is at rest, as a game or a chat may have started while npm worked:
+ * the chat `chesspal play` holds starts again from it, clean, and once it has left the table, the table closes to start again from it too.
+ */
+export declare function updateWhenAtRest(served: Served): void;

package/dist/server/page/table.js

@@ -1,5 +1,6 @@
-import { samePosition } from "../../commands/index.js";
-import { gameInAnalysis } from "../../games/index.js";
+import { setTimeout as delay } from "node:timers/promises";
+import { gameAt, samePosition } from "../../commands/index.js";
+import { endOf, 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";
@@ -44,8 +45,13 @@ export function answerTable(request, response, url, served) {
     else if (path === "/api/table/waiting") {
         runRoute(response, () => endWaiting(request, response, served));
     }
+    else if (path === "/api/table/update") {
+        runRoute(response, () => updateChesspal(request, response, served));
+    }
     else {
-        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.` });
+        sendJson(response, 404, {
+            error: `${path} is no route of the table's: it answers POST /api/table/chat, /api/table/restart, /api/table/waiting, /api/table/update and /api/table/quit.`,
+        });
     }
     return true;
 }
@@ -160,6 +166,76 @@ async function endWaiting(request, response, served) {
         sendJson(response, 200, now ? { restarting } : { waiting: false });
     }
 }
+/**
+ * Once npm has installed the newer Chesspal (D-108), and no game goes on and the chat is at rest, as a game or a chat may have started while npm worked:
+ * the chat `chesspal play` holds starts again from it, clean, and once it has left the table, the table closes to start again from it too.
+ */
+export function updateWhenAtRest(served) {
+    if (served.updating !== "installed" || gameGoingOn(served) || !tableAtRest(served)) {
+        return;
+    }
+    served.updating = "restarting";
+    tellWatchers(served.watchers);
+    const relaunched = served.table?.chats?.relaunch(served.folder, undefined, true) === true;
+    void restartOnceLeft(served, relaunched);
+}
+/**
+ * Installs the newer Chesspal npm has (D-108), asked by the table's own page alone, never while a game goes on, the chat is at work or one is opening;
+ * the table then starts again from it as soon as it is at rest. Whether npm installed it; when it did not, the page gives the command to type.
+ */
+async function updateChesspal(request, response, served) {
+    await bodyOf(request);
+    const { newer, table } = served;
+    if (!fromTablePage(request, served)) {
+        sendJson(response, 403, { error: "Only the table's own page updates Chesspal." });
+    }
+    else if (newer === undefined || table?.update === undefined) {
+        sendJson(response, 409, { error: "No newer Chesspal to install: this one is the latest npm has." });
+    }
+    else if (served.updating !== undefined) {
+        sendJson(response, 409, { error: "Chesspal is being updated already: wait for the table to start again." });
+    }
+    else if (gameGoingOn(served)) {
+        sendJson(response, 409, { error: "A game is going on: finish it, then update Chesspal.", refusal: "update-game" });
+    }
+    else if (!tableAtRest(served)) {
+        sendJson(response, 409, { error: "The chat is at work, or opening: update Chesspal once it is at rest.", refusal: "update-chat" });
+    }
+    else {
+        served.updating = "installing";
+        tellWatchers(served.watchers);
+        let installed = false;
+        try {
+            installed = await table.update.install(newer);
+        }
+        finally {
+            served.updating = installed ? "installed" : undefined;
+        }
+        // Starting again ends every connection: once this answer has gone, or the page that asked has.
+        response.once("close", () => updateWhenAtRest(served));
+        tellWatchers(served.watchers);
+        sendJson(response, 200, { installed });
+    }
+}
+// The chat started again leaves the table as `chesspal play` ends its host: a table closed before would leave its server to serve its own page on the
+// table's ports, where the new table would then find them taken (Priya). One that does not leave in time is left to it.
+async function restartOnceLeft(served, relaunched) {
+    for (let tries = 0; relaunched && served.attached !== undefined && tries < leaveTries; tries++) {
+        await delay(100);
+    }
+    served.table?.update?.restart();
+}
+// `chesspal play` sees the request within half a second and ends its host in a few more.
+const leaveTries = 100;
+// A game with moves still to come, a new one too: never an update meanwhile (D-108).
+function gameGoingOn(served) {
+    const current = gameAt(gameFolder(served.context.home()), served.context.now());
+    return current !== undefined && endOf(current.game) === undefined;
+}
+// No chat is at work at the table, and none is opening.
+function tableAtRest(served) {
+    return (served.attached === undefined || chatAtRest(served)) && opening(served) === undefined;
+}
 // 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}`;

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

@@ -0,0 +1,18 @@
+import type { Served } from "./page.ts";
+/**
+ * What the page shows of a newer Chesspal: its version, and on the table whether it is being installed, or installed and waiting for the game to end and
+ * the chat to be at rest.
+ */
+export interface UpdateShown {
+    readonly version: string;
+    readonly installing?: true;
+    readonly installed?: true;
+}
+/** Asks npm for Chesspal's latest version now and once a day after, the pages told when it is newer than this one; how to stop. None in the tests. */
+export declare function watchForUpdates(served: Served, every?: number): () => void;
+/** The newer Chesspal the page shows, when npm has one. */
+export declare function updateShown(served: Served): {
+    update?: UpdateShown;
+};
+/** Chesspal's latest version on npm, none when npm cannot be reached in time or answers something else. */
+export declare function latestVersion(fetch: typeof globalThis.fetch): Promise<string | undefined>;

package/dist/server/page/update.js

@@ -0,0 +1,40 @@
+// A newer Chesspal on npm (D-108): the page's server asks as it starts and once a day after; the table's page offers to install it, a chat's own page says
+// the command to type.
+import { answerTime, askSite } from "../../sites/index.js";
+import { isOlder, version } from "../../version.js";
+import { tellWatchers } from "./events.js";
+/** Asks npm for Chesspal's latest version now and once a day after, the pages told when it is newer than this one; how to stop. None in the tests. */
+export function watchForUpdates(served, every = aDay) {
+    const fetch = served.context.fetch;
+    if (fetch === undefined) {
+        return () => undefined;
+    }
+    const ask = async () => {
+        const latest = await latestVersion(fetch);
+        if (latest !== undefined && isOlder(version, latest) && latest !== served.newer) {
+            served.newer = latest;
+            tellWatchers(served.watchers);
+        }
+    };
+    void ask();
+    const timer = setInterval(() => void ask(), every);
+    timer.unref();
+    return () => clearInterval(timer);
+}
+/** The newer Chesspal the page shows, when npm has one. */
+export function updateShown(served) {
+    const { newer, updating } = served;
+    if (newer === undefined) {
+        return {};
+    }
+    return { update: { version: newer, ...(updating === "installed" ? { installed: true } : updating === undefined ? {} : { installing: true }) } };
+}
+/** Chesspal's latest version on npm, none when npm cannot be reached in time or answers something else. */
+export async function latestVersion(fetch) {
+    const answer = await askSite(latestUrl, fetch, AbortSignal.timeout(answerTime));
+    const said = answer?.body?.version;
+    // Only a plain release: the version goes into npm's command line.
+    return answer?.status === 200 && typeof said === "string" && /^\d+\.\d+\.\d+$/.test(said) ? said : undefined;
+}
+const latestUrl = "https://registry.npmjs.org/chesspal/latest";
+const aDay = 24 * 60 * 60 * 1000;

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

@@ -1,6 +1,6 @@
 /** 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 declare function openInBrowser(url: string, platform: string): Promise<boolean>;
-/** The address of the window the table opens, marked so that the page sizes it the first time (page/layout/window.ts). */
+/** The address of the window the table opens, marked so that the page sizes it as it opens (page/layout/window.ts). */
 export declare function openedAddress(url: string): string;
 /** Chrome or Edge, where each system installs them: the first there is; none when neither is. */
 export declare function appBrowser(platform: string, env: NodeJS.ProcessEnv, exists?: (path: string) => boolean): string | undefined;

package/dist/server/table/browser.js

@@ -10,7 +10,7 @@ export async function openInBrowser(url, platform) {
     // 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);
 }
-/** The address of the window the table opens, marked so that the page sizes it the first time (page/layout/window.ts). */
+/** 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) {
     const address = new URL(url);
     address.searchParams.set("opened", "");

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

@@ -1,5 +1,5 @@
 import type { Context } from "../../../commands/index.ts";
-import type { TableChats } from "../../page/table.ts";
+import type { TableChats } from "../../page/index.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.

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

@@ -1,5 +1,5 @@
 import { tableFolder } from "../../../home/index.js";
-import { samePath } from "../../bell.js";
+import { samePath } from "../../bell/index.js";
 import { programPath } from "./find.js";
 import { hostChoices, hostNames, isHostName } from "./hosts.js";
 import { askAgain, seatHeld } from "./seat.js";
@@ -24,7 +24,7 @@ export function terminalChats(context, chesspal = [process.execPath, ...process.
             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 }),
+        relaunch: (folder, host, updated) => samePath(folder, tableFolder(context.home())) && askAgain(folder, context.now(), { ...(host === undefined ? {} : { host }), ...(updated === true ? { updated } : {}) }),
     };
 }
 // Looking on the PATH takes a few milliseconds, and the page asks at every change of the game.

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

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

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

@@ -1,4 +1,4 @@
 // 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 { isHostName } from "./hosts.js";
-export { hostLaunch, playHost } from "./play.js";
+export { endTree, hostLaunch, playHost } from "./play.js";

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

@@ -1,3 +1,4 @@
+import { type ChildProcess } from "node:child_process";
 import type { Context } from "../../../commands/index.ts";
 import { type HostChoice, type HostName } from "./hosts.ts";
 /**
@@ -14,7 +15,8 @@ export interface HostLaunch {
 }
 /**
  * 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.
+ * 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.
  */
 export declare function playHost(context: Context, host: HostName): Promise<number>;
 /**
@@ -27,3 +29,8 @@ export declare function runHost(launch: HostLaunch, again: () => boolean, platfo
 }>;
 /** How the host starts for the profile in use: found on the PATH, with its choice; it throws, saying how to install it, when it is not there. */
 export declare function hostLaunch(context: Context, host: HostName, env?: NodeJS.ProcessEnv, exists?: (path: string) => boolean): HostLaunch;
+/**
+ * Ends a process and what it started, a host's MCP server among them: on Windows its whole tree, which taskkill ends, never the console (Priya); else the
+ * process, which ends its own. A taskkill that failed leaves it to a kill.
+ */
+export declare function endTree(chat: ChildProcess, platform: string): void;