chesspal 0.2.4 → 0.3.1

package/dist/server/bell.d.ts

@@ -29,16 +29,32 @@ export declare class Bell {
     ring(): void;
     /** A hook waits for the bell, so the chat's turn has ended; the hook before it, of a turn already ended, is let go. */
     listen(request: IncomingMessage, response: ServerResponse): void;
+    /** The chat left the table (D-104): its process ended, and nobody is in a turn or waits for the bell; a ring no hook heard is no longer news for anyone. */
+    chatLeft(): void;
     private tellIf;
 }
-/** Whose page answers at a port, for the hook to find its own: the chat's session, the player's folder, and whether a browser has the page open. */
-export declare function bellProbe(folder: string, open?: boolean): BellProbe;
+/**
+ * Whose page answers at a port, for the hook to find its own: the chat's session, the player's folder, whether a browser has the page open, Chesspal's
+ * version, and whether the table serves it (D-104), with the session and the folder of the chat attached to it, never its own process's.
+ */
+export declare function bellProbe(folder: string, open?: boolean, table?: TableChat): BellProbe;
+/** The chat attached to the table, as its probe says it: its session, null for none or for Codex, and its folder; neither while no chat is attached. */
+export interface TableChat {
+    session: string | null;
+    chat?: string;
+}
 /** What a page says of itself at `/api/bell?probe`. */
 export interface BellProbe {
     session: string | null;
     folder: string;
     open: boolean;
+    version?: string;
+    table?: true;
+    /** The folder of the chat attached to the table. */
+    chat?: string;
 }
+/** What the page at a port of this computer says of itself; undefined when none answers there. */
+export declare function pageAt(port: number): Promise<BellProbe | undefined>;
 /** The ports a folder's page tries first: one in each of a few ranges, by its path, since Windows may reserve a range. The hook looks for it there. */
 export declare function pagePorts(folder: string): number[];
 /** What Codex's Stop hook answers to wake the chat: its turn goes on with the doorbell's line. */
@@ -62,7 +78,12 @@ export type BellHeard = {
     rang: false;
     why: string;
 };
-/** Waits at the page of the hook's chat, as waitForBell does, and says what it heard. */
+/**
+ * Waits at the page of the hook's chat, as waitForBell does, and says what it heard. The chat may be attached to the table (D-104), beside another chat
+ * of its folder that serves its own page: the table is one more page to choose from, unless the ports to try are given (Priya).
+ */
 export declare function bellHeard(input: string, ports?: number[]): Promise<BellHeard>;
 /** Adds a line to the log of the hooks that heard no bell, keeping its last lines; a log that cannot be written never stops the hook. */
 export declare function noteSilence(folder: string, why: string, now?: Date): void;
+/** Whether two paths name the same folder: without regard to case on Windows. */
+export declare function samePath(one: string, other: string): boolean;

package/dist/server/bell.js

@@ -5,6 +5,8 @@ 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";
 /** 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.";
 /**
@@ -84,15 +86,32 @@ export class Bell {
             }
         });
     }
+    /** The chat left the table (D-104): its process ended, and nobody is in a turn or waits for the bell; a ring no hook heard is no longer news for anyone. */
+    chatLeft() {
+        this.busy = false;
+        this.woken = false;
+        this.pending = false;
+        this.listener?.end("dismissed");
+        this.listener = undefined;
+        this.changed();
+    }
     tellIf(changed) {
         if (changed) {
             this.changed();
         }
     }
 }
-/** Whose page answers at a port, for the hook to find its own: the chat's session, the player's folder, and whether a browser has the page open. */
-export function bellProbe(folder, open = false) {
-    return { session: process.env.CLAUDE_CODE_SESSION_ID ?? null, folder: resolve(folder), open };
+/**
+ * Whose page answers at a port, for the hook to find its own: the chat's session, the player's folder, whether a browser has the page open, Chesspal's
+ * version, and whether the table serves it (D-104), with the session and the folder of the chat attached to it, never its own process's.
+ */
+export function bellProbe(folder, open = false, table) {
+    const session = table === undefined ? process.env.CLAUDE_CODE_SESSION_ID ?? null : table.session;
+    return { session, folder: resolve(folder), open, version, ...(table === undefined ? {} : { table: true, ...(table.chat === undefined ? {} : { chat: table.chat }) }) };
+}
+/** What the page at a port of this computer says of itself; undefined when none answers there. */
+export async function pageAt(port) {
+    return probeOf(await body(port, "/api/bell?probe", probeWait));
 }
 /** The ports a folder's page tries first: one in each of a few ranges, by its path, since Windows may reserve a range. The hook looks for it there. */
 export function pagePorts(folder) {
@@ -133,13 +152,18 @@ export async function listen(codex = false) {
 export async function waitForBell(input, ports) {
     return (await bellHeard(input, ports)).rang;
 }
-/** Waits at the page of the hook's chat, as waitForBell does, and says what it heard. */
+/**
+ * Waits at the page of the hook's chat, as waitForBell does, and says what it heard. The chat may be attached to the table (D-104), beside another chat
+ * of its folder that serves its own page: the table is one more page to choose from, unless the ports to try are given (Priya).
+ */
 export async function bellHeard(input, ports) {
     const hook = hookInput(input);
     const folder = chatFolder(hook);
     const tried = ports ?? pagePorts(folder);
-    const probes = await Promise.all(tried.map(async (port) => ({ port, said: probeOf(await body(port, "/api/bell?probe", probeWait)) })));
-    const ours = probes.flatMap(({ port, said }) => (said !== undefined && samePath(said.folder, folder) ? [{ port, said }] : []));
+    const [probes, table] = await Promise.all([Promise.all(tried.map(async (port) => ({ port, said: await pageAt(port) }))), ports === undefined ? tableOf(folder, hook.session) : undefined]);
+    const pages = probes.flatMap(({ port, said }) => (said !== undefined && samePath(said.folder, folder) ? [{ port, said }] : []));
+    // A chat opened in the table's own folder finds the table among the pages of its folder already.
+    const ours = table === undefined || pages.some(({ port }) => port === table.port) ? pages : [...pages, table];
     const port = chatPage(ours, hook.session)?.port;
     if (port === undefined) {
         const others = probes.flatMap((one) => (one.said === undefined ? [] : [`${one.port} is ${one.said.folder}'s`]));
@@ -152,6 +176,50 @@ export async function bellHeard(input, ports) {
 }
 // How long a port may take to say whose page it is: one of this computer answers at once.
 const probeWait = 1000;
+/**
+ * The table, when the chat attached to it is the hook's: of its folder, or of its session; none when the data folder cannot be found, or no table has
+ * this chat. Finding the data folder costs some tens of milliseconds on Windows, off the AI's clock: the hook waits after the turn.
+ */
+async function tableOf(folder, session) {
+    let ports;
+    try {
+        ports = pagePorts(tableFolder(serverHome(folder) ?? dataFolder()));
+    }
+    catch {
+        return undefined;
+    }
+    const probes = await Promise.all(ports.map(async (port) => ({ port, said: await pageAt(port) })));
+    return probes.find((one) => one.said?.table === true && ((one.said.chat !== undefined && samePath(one.said.chat, folder)) || (session !== undefined && one.said.session === session)));
+}
+/**
+ * The data folder the chat's server is given in its folder's settings, as CHESSPAL_HOME in a playtest: the hook runs in the host's environment, not the
+ * server's (Federico). Claude Code's .mcp.json first, then Codex's config.
+ */
+function serverHome(folder) {
+    const chosen = [claudeHome(folder), codexHome(folder)].find((one) => one !== undefined && one.trim() !== "");
+    return chosen === undefined ? undefined : resolve(chosen.trim());
+}
+function claudeHome(folder) {
+    try {
+        const config = JSON.parse(readFileSync(join(folder, ".mcp.json"), "utf8"));
+        const home = config.mcpServers?.chesspal?.env?.CHESSPAL_HOME;
+        return typeof home === "string" ? home : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+// The setting as init keeps it in Codex's table: a basic string, whose escapes are JSON's for a path, or a literal one.
+function codexHome(folder) {
+    try {
+        const config = readFileSync(join(folder, ".codex", "config.toml"), "utf8");
+        const [, basic, literal] = /\bCHESSPAL_HOME\s*=\s*(?:("(?:[^"\\]|\\.)*")|'([^']*)')/.exec(config) ?? [];
+        return basic === undefined ? literal : JSON.parse(basic);
+    }
+    catch {
+        return undefined;
+    }
+}
 // The log of Codex's hooks that heard no bell, in the chat's folder: its last lines only.
 const silenceLog = "listen.log";
 const silenceLines = 100;
@@ -193,15 +261,21 @@ function chatPage(pages, session) {
 function probeOf(said) {
     try {
         const parsed = said === undefined ? undefined : JSON.parse(said);
-        return parsed === undefined || typeof parsed.folder !== "string"
-            ? undefined
-            : { session: typeof parsed.session === "string" ? parsed.session : null, folder: parsed.folder, open: parsed.open === true };
+        return parsed === undefined || typeof parsed.folder !== "string" ? undefined : {
+            session: typeof parsed.session === "string" ? parsed.session : null,
+            folder: parsed.folder,
+            open: parsed.open === true,
+            ...(typeof parsed.version === "string" ? { version: parsed.version } : {}),
+            ...(parsed.table === true ? { table: true } : {}),
+            ...(typeof parsed.chat === "string" ? { chat: parsed.chat } : {}),
+        };
     }
     catch {
         return undefined;
     }
 }
-function samePath(one, other) {
+/** Whether two paths name the same folder: without regard to case on Windows. */
+export function samePath(one, other) {
     return process.platform === "win32" ? resolve(one).toLowerCase() === resolve(other).toLowerCase() : resolve(one) === resolve(other);
 }
 /** The body a page of this computer answers with, once it ends; undefined when it does not answer, or not with 200. */

package/dist/server/caller.d.ts

@@ -6,11 +6,12 @@ export interface Client {
 }
 /** 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 declare function callerOf(meta: Record<string, unknown> | undefined, client: Client | undefined, folder: string, wait?: number): Promise<Caller | undefined>;
-/** Who in Claude Code or Codex made a tool call: the chat itself, or one of its agents by its type. */
+/** Who in Claude Code or Codex made a tool call: the chat itself, or one of its agents by its type, with the run it is, when the host tells it. */
 export type CallingAgent = {
     chat: true;
 } | {
     agent: string;
+    run?: string;
 };
 /**
  * Who in Claude Code or Codex made a tool call: the chat, when its line is in the chat's transcript, or the agent whose file has it, by the type Claude Code

package/dist/server/caller.js

@@ -39,8 +39,9 @@ export async function callingAgent(meta, folder, wait = 50) {
     if (found.file === transcript) {
         return { chat: true };
     }
+    // Each agent Claude Code starts writes a file of its own: its name tells two runs of the same agent apart.
     const type = objectOf(textOf(found.file.replace(/\.jsonl$/, ".meta.json")))?.agentType;
-    return typeof type === "string" ? { agent: type } : undefined;
+    return typeof type === "string" ? { agent: type, run: basename(found.file, ".jsonl") } : undefined;
 }
 /** Whether a call comes from one of Codex's agents, as its metadata say: its own process starts no board page (D-98). */
 export function fromCodexAgent(meta) {
@@ -110,7 +111,7 @@ async function codexCaller(turn, wait) {
         const start = headOf(codexSession(thread));
         const role = /"agent_role":"([^"]+)"/.exec(start)?.[1];
         if (role !== undefined) {
-            const caller = start.includes('"forked_from_id":"') ? { chat: true } : { agent: role };
+            const caller = start.includes('"forked_from_id":"') ? { chat: true } : { agent: role, run: thread };
             codexThreads.set(thread, caller);
             return caller;
         }

package/dist/server/mcp.d.ts

@@ -1,6 +1,9 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { type AnyCommand, type Context } from "../commands/index.ts";
-/** What the host reads as the server starts, before any tool: where to begin, and the rule of every move (D-27). Short, since hosts may cut it. */
+/**
+ * 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.
+ */
 export declare const serverInstructions: string;
 /** The MCP server for an AI host: every command of the registry as a tool, with its description and parameters (D-5). */
 export declare function createMcpServer(context?: Context, list?: AnyCommand[], beforeCall?: (meta: Record<string, unknown> | undefined) => Promise<void>): McpServer;
@@ -10,9 +13,10 @@ export declare function createMcpServer(context?: Context, list?: AnyCommand[],
  */
 export declare function startMcpServer(context?: Context, list?: AnyCommand[]): Promise<void>;
 /**
- * The board page started once, before the chat's first call, the status every chat opens with, which then gives its address: the process of a Codex
+ * The board page started once, before the chat's first call, the status every chat opens with, which then gives its address; started `again` when the
+ * table the chat was attached to is lost, at once, off the AI's clock, or at the next call when a table to go to has come (D-104). The process of a Codex
  * agent, which has one of its own, starts none, which would stand beside the chat's and could keep the doorbell from it (D-98, Priya).
  */
-export declare function lazyPage(start: () => Promise<void>): (meta: Record<string, unknown> | undefined) => Promise<void>;
+export declare function lazyPage(start: (again: (now?: boolean) => void) => Promise<void>): (meta: Record<string, unknown> | undefined) => Promise<void>;
 /** The opponent's name for the page, from the host's (D-97): another host than Claude's and Codex is unnamed. */
 export declare function opponentOf(host: string | undefined): string | undefined;

package/dist/server/mcp.js

@@ -1,19 +1,23 @@
-// The MCP server an AI host starts: every command as a tool (D-5), and the board page served for as long as the chat lasts (D-47).
+// The MCP server an AI host starts: every command as a tool (D-5), and the board page: the table's, which the chat attaches to, or one it serves itself
+// for as long as it lasts (D-47, D-104).
 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 } from "../games/index.js";
-import { agentTools, hasAgent } from "../host-files/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 { allowedCaller, callerOf, callingAgent, fromCodexAgent } from "./caller.js";
 import { chatHasRead, startPage } from "./page/page.js";
-/** What the host reads as the server starts, before any tool: where to begin, and the rule of every move (D-27). Short, since hosts may cut it. */
-export const serverInstructions = "Chesspal keeps the chess for you: the rules, the board, the clock, the games and the player's memory. Call `status` at the start of every "
-    + "chat. Every move goes through Chesspal's tools: never keep the board in your head or invent a position.";
+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.
+ */
+export const serverInstructions = startInstructions();
 /** The MCP server for an AI host: every command of the registry as a tool, with its description and parameters (D-5). */
 export function createMcpServer(context = defaultContext(), list = commands, beforeCall) {
     const server = new McpServer({ name: "chesspal", version }, { instructions: serverInstructions });
@@ -24,28 +28,8 @@ export function createMcpServer(context = defaultContext(), list = commands, bef
     context.host ??= () => server.server.getClientVersion()?.name;
     const forSomeHosts = [];
     for (const command of list.filter((each) => each.cliOnly !== true)) {
-        const tool = server.registerTool(command.name, toolConfig(command), async (input, extra) => {
-            await beforeCall?.(extra._meta);
-            const codexAgent = fromCodexAgent(extra._meta);
-            const calling = command.byAgents !== undefined || codexAgent ? await callingAgent(extra._meta, context.folder) : undefined;
-            // An agent's tool called by the chat, or by another agent, would give what only that agent may see (Priya).
-            if (command.byAgents !== undefined && !allowedCaller(calling, command.byAgents)) {
-                // It names no agent to start: the chat that asked would start one itself (Priya).
-                return { content: [{ type: "text", text: `${command.name} is not yours to call: the player reads what it gives on the board page. Nothing changed.` }], isError: true };
-            }
-            // Codex gives its agents every tool: one of Chesspal's keeps to its own, and never plays or talks for the opponent (D-98, Federico).
-            const own = calling !== undefined && "agent" in calling ? agentTools(calling.agent) : undefined;
-            if (codexAgent && own !== undefined && !own.includes(command.name)) {
-                return { content: [{ type: "text", text: `${command.name} is not yours to call: you work only with ${own.join(", ")}. Nothing changed.` }], isError: true };
-            }
-            // Each call knows who makes it, for the commands that write it down (D-81).
-            const caller = () => callerOf(extra._meta, server.server.getClientVersion(), context.folder);
-            const result = await track(runTool(command, input, context, caller, extra._meta));
-            if (command === aiMove && result.isError !== true) {
-                noteTheAi(context, caller);
-            }
-            return result;
-        });
+        // A call runs from its start, the page started before it too: the server that leaves waits for it.
+        const tool = server.registerTool(command.name, toolConfig(command), (input, extra) => track(callTool(command, input, context, server, extra._meta, beforeCall)));
         if (command.hosts !== undefined) {
             tool.disable();
             forSomeHosts.push({ hosts: command.hosts, tool });
@@ -73,21 +57,35 @@ export async function startMcpServer(context = defaultContext(), list = commands
     };
     process.stdin.on("end", leave);
     process.stdin.on("close", leave);
-    const pageFirst = lazyPage(async () => {
-        context.page = await pageOf(context, () => opponentOf(context.host?.()));
+    let page;
+    // The page served before, of its own, closes when the chat goes to a table.
+    const pageFirst = lazyPage(async (again) => {
+        await page?.close();
+        page = await pageOf(context, () => opponentOf(context.host?.()), again);
+        context.page = page?.url;
     });
     const server = createMcpServer(context, list, pageFirst);
     await server.connect(new StdioServerTransport());
 }
 /**
- * The board page started once, before the chat's first call, the status every chat opens with, which then gives its address: the process of a Codex
+ * The board page started once, before the chat's first call, the status every chat opens with, which then gives its address; started `again` when the
+ * table the chat was attached to is lost, at once, off the AI's clock, or at the next call when a table to go to has come (D-104). The process of a Codex
  * agent, which has one of its own, starts none, which would stand beside the chat's and could keep the doorbell from it (D-98, Priya).
  */
 export function lazyPage(start) {
     let page;
+    const begin = () => {
+        // What an earlier start asks is no reason to drop the page this one serves.
+        const started = start((now = false) => {
+            if (page === started) {
+                page = now ? begin() : undefined;
+            }
+        });
+        return started;
+    };
     return async (meta) => {
         if (!fromCodexAgent(meta)) {
-            page ??= start();
+            page ??= begin();
             await page;
         }
     };
@@ -96,19 +94,24 @@ export function lazyPage(start) {
 export function opponentOf(host) {
     return aiNameOf(host);
 }
-/** The board page of the player's folder, served by this process for as long as the chat lasts (D-47); without it the game goes on in the chat. */
-async function pageOf(context, opponent) {
+/**
+ * The board page of the player's folder: the table's, when one of this version takes the chat (D-104), else served by this process, which looks for a
+ * table after each tool; without it the game goes on in the chat. It starts `again`: at once when the table is lost, at the next call when one is found.
+ */
+async function pageOf(context, opponent, again) {
     try {
-        const { url, heard, chatCalls, open, askNewGame } = await startPage(context, opponent);
+        const table = await attachTable(context, () => again(true));
+        const page = table ?? await startPage(context, { opponent });
         // Words the AI is given change no file: the pages hear of them from the commands.
-        context.heard = heard;
-        context.calls = chatCalls;
-        context.pageOpen = open;
-        context.askNewGame = askNewGame;
-        if (!pagePorts(context.folder).includes(Number(new URL(url).port))) {
-            process.stderr.write(`The board page is at ${url}, off its usual ports: the doorbell cannot find it, so moves on the page do not wake the chat.\n`);
+        context.heard = page.heard;
+        context.calls = page.chatCalls;
+        context.toolEnded = table === undefined ? lookForTable(context, again) : page.toolEnded;
+        context.pageOpen = page.open;
+        context.askNewGame = page.askNewGame;
+        if (table === undefined && !pagePorts(context.folder).includes(Number(new URL(page.url).port))) {
+            process.stderr.write(`The board page is at ${page.url}, off its usual ports: the doorbell cannot find it, so moves on the page do not wake the chat.\n`);
         }
-        return url;
+        return page;
     }
     catch (error) {
         // The host keeps what the server writes on stderr in its logs.
@@ -116,6 +119,27 @@ async function pageOf(context, opponent) {
         return undefined;
     }
 }
+/**
+ * After each tool of a chat that serves its own page, a look for a table of its version with no chat at it, off the AI's clock: one started since, by
+ * `chesspal` or the icon, takes the chat at its next tool, and its page then closes (Priya).
+ */
+function lookForTable(context, again) {
+    let looking = false;
+    return () => {
+        if (looking) {
+            return;
+        }
+        looking = true;
+        setImmediate(() => {
+            void tableToJoin(context).then((found) => {
+                looking = false;
+                if (found) {
+                    again();
+                }
+            });
+        });
+    };
+}
 /**
  * Who played the AI's move, its host and model, read once the move has gone back to the chat, and kept in memory (D-82, D-97): the AI's card on the
  * page shows it, and the game's PGN once it ends; a change shows from the next move. A host that ties no model to the call leaves the last one known.
@@ -125,19 +149,41 @@ function noteTheAi(context, caller) {
     setImmediate(() => {
         // Nothing that fails here may stop the server: the move is played and answered.
         caller().then((found) => {
+            const folder = gameFolder(context.home());
             const host = context.host?.();
-            if (host !== undefined && host.trim() !== "") {
-                noteAiHost(gameFolder(context.home()), host);
-            }
-            if (found === undefined || found.hostOnly === true) {
-                return;
-            }
-            if (noteAiModel(gameFolder(context.home()), { model: found.annotator, ...(found.effort === undefined ? {} : { effort: found.effort }) })) {
+            const hostChanged = host !== undefined && host.trim() !== "" && noteAiHost(folder, host);
+            const modelChanged = found !== undefined && found.hostOnly !== true
+                && noteAiModel(folder, { model: found.annotator, ...(found.effort === undefined ? {} : { effort: found.effort }) });
+            // The pages, and the table the chat is attached to, hear of it now: the move's copy went before (Federico).
+            if (hostChanged || modelChanged) {
                 context.heard?.();
             }
         }).catch(() => undefined);
     });
 }
+/** A tool called: the page started first, at the chat's first call; refused to an agent it is not for (D-89, D-98); and who played as the AI noted after a move. */
+async function callTool(command, input, context, server, meta, beforeCall) {
+    await beforeCall?.(meta);
+    const codexAgent = fromCodexAgent(meta);
+    const calling = command.byAgents !== undefined || codexAgent ? await callingAgent(meta, context.folder) : undefined;
+    // An agent's tool called by the chat, or by another agent, would give what only that agent may see (Priya).
+    if (command.byAgents !== undefined && !allowedCaller(calling, command.byAgents)) {
+        // It names no agent to start: the chat that asked would start one itself (Priya).
+        return { content: [{ type: "text", text: `${command.name} is not yours to call: the player reads what it gives on the board page. Nothing changed.` }], isError: true };
+    }
+    // Codex gives its agents every tool: one of Chesspal's keeps to its own, and never plays or talks for the opponent (D-98, Federico).
+    const own = calling !== undefined && "agent" in calling ? agentTools(calling.agent) : undefined;
+    if (codexAgent && own !== undefined && !own.includes(command.name)) {
+        return { content: [{ type: "text", text: `${command.name} is not yours to call: you work only with ${own.join(", ")}. Nothing changed.` }], isError: true };
+    }
+    // Each call knows who makes it, for the commands that write it down (D-81).
+    const caller = () => callerOf(meta, server.server.getClientVersion(), context.folder);
+    const result = await runTool(command, input, context, caller, meta);
+    if (command === aiMove && result.isError !== true) {
+        noteTheAi(context, caller);
+    }
+    return result;
+}
 // The tool calls still running, which the server waits for before it leaves.
 const running = new Set();
 function track(call) {
@@ -160,10 +206,12 @@ async function runTool(command, input, context, caller, meta) {
     let refused = false;
     try {
         if (chat) {
-            context.calls?.();
+            await context.calls?.();
         }
-        const who = agent !== undefined ? { agent } : calling !== undefined ? { chat: true } : {};
-        const result = await command.run(checkedInput(command, input), { ...context, caller, ...who });
+        const run = calling !== undefined && "run" in calling ? calling.run : undefined;
+        const who = agent !== undefined ? { agent, ...(run === undefined ? {} : { agentRun: run }) } : calling !== undefined ? { chat: true } : {};
+        // A game another process changed under the call is read again, and the call made once more.
+        const result = await rerunIfChanged(() => command.run(checkedInput(command, input), { ...context, caller, ...who }));
         return { content: [{ type: "text", text: command.format(result, context) }] };
     }
     catch (error) {

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

@@ -12,6 +12,8 @@ export interface AnalysisItem {
     readonly opening?: string;
     readonly moves: number;
     readonly reviewed: boolean;
+    /** A review begun and not finished, its notes or the analyst that took it, which the page lets the player write again or delete (Stefano). */
+    readonly begun?: true;
     /** Who reviewed it (D-81). */
     readonly annotator?: AiModel;
     /** Where a game loaded from elsewhere was played, as its Site tag says: the player's name there makes it theirs (D-93). */

package/dist/server/page/analyses.js

@@ -1,6 +1,6 @@
 import { bookOpening, deleteGame, deleteReview } from "../../commands/index.js";
-import { aiModelIn, annotatorOf, isReviewed } from "../../core/index.js";
-import { archivedGame, archivedGames, gameStemOf, keptGame, keptGames } from "../../games/index.js";
+import { aiModelIn, annotatorOf, isReviewed, leadOf, reviewOf } from "../../core/index.js";
+import { archivedGame, archivedGames, gameInAnalysis, gameStemOf, keptGame, keptGames } from "../../games/index.js";
 import { gameFolder } from "../../profiles/index.js";
 import { bodyOf, isJson, jsonOf, runRoute, sendJson, textOf } from "./http.js";
 /** The games to analyse in the profile in use, the latest first, all of them for the page's search: those kept to study and those played, reviewed or not. */
@@ -9,7 +9,8 @@ export function analysesOf(home) {
     // By the time in their names, which orders kept and played games together.
     const stamp = (name) => gameStemOf(name) ?? "";
     const names = [...keptGames(folder), ...archivedGames(folder)].sort((one, other) => stamp(other).localeCompare(stamp(one)));
-    return names.flatMap((name) => itemOf(name, () => name.startsWith("study/") ? keptGame(folder, name) : archivedGame(folder, name)));
+    const taken = gameInAnalysis(folder)?.analyst?.game;
+    return names.flatMap((name) => itemOf(name, () => name.startsWith("study/") ? keptGame(folder, name) : archivedGame(folder, name), taken === name));
 }
 /** Answers the page's deletions, of a game or of its review alone, done as the command line does them: true when the request was one. */
 export function answerAnalyses(request, response, url, served) {
@@ -33,7 +34,7 @@ export function answerAnalyses(request, response, url, served) {
     return true;
 }
 const deletions = { "/api/delete-game": deleteGame, "/api/delete-review": deleteReview };
-function itemOf(name, read) {
+function itemOf(name, read, taken) {
     let record;
     try {
         record = read();
@@ -42,6 +43,10 @@ function itemOf(name, read) {
         // A game that cannot be read stays out of the list.
         return [];
     }
+    // A game closed before any move has nothing to analyse; a position brought to study without moves stays, to open again or delete.
+    if (record.moves.length === 0 && name.startsWith("games/")) {
+        return [];
+    }
     const { tags } = record;
     const date = tags.Date === undefined || tags.Date.includes("?") ? undefined : tags.Date;
     const opening = bookOpening(record)?.name;
@@ -49,6 +54,8 @@ function itemOf(name, read) {
     const site = tags.Site === undefined || /^[?\-\s]*$/.test(tags.Site) ? undefined : tags.Site;
     const signed = annotatorOf(record);
     const annotator = signed === undefined ? undefined : { model: signed.annotator, ...(signed.effort === undefined ? {} : { effort: signed.effort }) };
+    const reviewed = isReviewed(record);
+    const begun = !reviewed && (taken || reviewBegun(record));
     return [{
             name,
             white: tags.White ?? "?",
@@ -58,8 +65,16 @@ function itemOf(name, read) {
             result: tags.Result ?? "*",
             ...(opening === undefined ? {} : { opening }),
             moves: Math.ceil(record.moves.length / 2),
-            reviewed: isReviewed(record),
+            reviewed,
+            ...(begun ? { begun: true } : {}),
             ...(annotator === undefined ? {} : { annotator }),
             ...(site === undefined ? {} : { site }),
         }];
 }
+/** Whether a game holds part of a review on its moves: a note, a badge but the book's, which Chesspal puts there, or who is ahead. */
+function reviewBegun(record) {
+    return record.moves.some(({ comment }) => {
+        const review = reviewOf(comment);
+        return review?.note !== undefined || (review?.badge !== undefined && review.badge !== "book") || leadOf(comment) !== undefined;
+    });
+}

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

@@ -0,0 +1,4 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { Served } from "./page.ts";
+/** Answers the chat's requests to the table, under /api/chat; false for any other, and for every request to a page a chat serves itself. */
+export declare function answerChat(request: IncomingMessage, response: ServerResponse, url: URL, served: Served): boolean;