chesspal 0.3.6 → 0.4.0

package/dist/page/text.js

@@ -30,6 +30,7 @@ const english = {
     sounds: "Sounds",
     voice: "Read the AI's words aloud",
     noVoice: "This browser has no voice for this language: add one in your system's settings",
+    skipReading: "Stop reading this aloud",
     saidMove: (move) => moveInWords(englishMoveWords, move),
     newGame: "New game",
     offerDraw: "Offer a draw",
@@ -176,21 +177,25 @@ const english = {
         choose: "Choose the chat to play with: it opens in a window of its own, to keep open.",
         reviewTitle: "Who reviews the game?",
         reviewChoose: "Choose the chat that reviews the game: 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.",
+        restartHint: "The chat starts again, clean, in the same window, once it has ended its answer, with the chat, model and effort chosen here. 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.`,
+        chat: "Chat",
         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.",
+        atTable: "At the table",
+        act: { open: (host) => `Start ${host}`, review: (host) => `Review with ${host}`, restart: (host) => `Restart ${host}`, switch: (host) => `Switch to ${host}` },
+        opening: "Opening the chat… In the terminal, if it asks whether you trust the folder, say yes (in Claude Code, go down to Yes with the arrow keys) and press Enter; with Codex, on the hooks, choose Trust all and continue.",
         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",
+        newGameWaiting: (name) => `The new game starts once ${name} has ended its answer…`,
         restartNow: "Start again now: it cuts the answer it is giving",
         cancel: "Do not start again",
+        newGameNow: "Start the new game now: it cuts the answer it is giving",
+        newGameCancel: "Do not start the new game",
         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:",
@@ -205,6 +210,7 @@ const english = {
         "ai-to-move": () => "Wait for the AI's move.",
         illegal: () => "That move is not legal here.",
         "clear-chat": (most, name) => english.clearChat(name),
+        "new-game-profile": () => "The new game did not start: you changed profile while it waited. Start it again from this one.",
         "words-empty": () => "Write something first.",
         "words-spent": () => "You have used up your words for this move: write again after the AI's move.",
         "words-long": (most) => `Write at most ${most} characters.`,
@@ -215,6 +221,8 @@ const english = {
         "profile-game": () => english.profile.whilePlaying,
         "game-going": () => "A game is going on: finish it before you bring another to analyse.",
         "pgn-unreadable": () => "Chesspal cannot read this PGN: check you copied the whole game, its tags and its moves.",
+        "game-missing": () => "This game is no longer there: pick another.",
+        "game-not-archived": () => "The game just over is not saved yet: try again in a moment.",
         "update-game": () => english.update.whilePlaying,
         "update-chat": (most, name) => `${name} is answering: update once it has done.`,
     },
@@ -460,6 +468,7 @@ const italian = {
     sounds: "Suoni",
     voice: "Leggi ad alta voce le parole dell'AI",
     noVoice: "Questo browser non ha una voce per questa lingua: aggiungila nelle impostazioni del sistema",
+    skipReading: "Smetti di leggere questo a voce",
     saidMove: (move) => moveInWords(italianMoveWords, move),
     newGame: "Nuova partita",
     offerDraw: "Proponi patta",
@@ -606,21 +615,25 @@ const italian = {
         choose: "Scegli la chat con cui giocare: parte in una finestra a parte, da tenere aperta.",
         reviewTitle: "Chi analizza la partita?",
         reviewChoose: "Scegli la chat che analizza la partita: 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'è.",
+        restartHint: "La chat riparte pulita nella stessa finestra, appena ha finito di rispondere, con la chat, il modello e il ragionamento scelti qui. 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.`,
+        chat: "Chat",
         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.",
+        atTable: "Al tavolo",
+        act: { open: (host) => `Avvia ${host}`, review: (host) => `Analizza con ${host}`, restart: (host) => `Riavvia ${host}`, switch: (host) => `Passa a ${host}` },
+        opening: "Apro la chat… Nel terminale, se ti chiede se ti fidi della cartella, rispondi sì (in Claude Code scendi su Yes con le frecce) e premi Invio; con Codex, sugli «hook», scegli Trust all and continue.",
         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",
+        newGameWaiting: (name) => `La nuova partita comincia appena ${name} ha finito di rispondere…`,
         restartNow: "Riparti adesso: interrompe la risposta in corso",
         cancel: "Non ripartire",
+        newGameNow: "Comincia adesso la nuova partita: interrompe la risposta in corso",
+        newGameCancel: "Non cominciare la nuova partita",
         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:",
@@ -635,6 +648,7 @@ const italian = {
         "ai-to-move": () => "Aspetta la mossa dell'AI.",
         illegal: () => "Questa mossa qui non è legale.",
         "clear-chat": (most, name) => italian.clearChat(name),
+        "new-game-profile": () => "La nuova partita non è cominciata: hai cambiato profilo mentre aspettava. Ricominciala da questo.",
         "words-empty": () => "Scrivi prima qualcosa.",
         "words-spent": () => "Hai finito le parole per questa mossa: scrivi di nuovo dopo quella dell'AI.",
         "words-long": (most) => `Scrivi al massimo ${most} caratteri.`,
@@ -645,6 +659,8 @@ const italian = {
         "profile-game": () => italian.profile.whilePlaying,
         "game-going": () => "C'è una partita in corso: finiscila prima di portarne un'altra da analizzare.",
         "pgn-unreadable": () => "Chesspal non riesce a leggere questo PGN: controlla di aver copiato la partita intera, intestazioni e mosse.",
+        "game-missing": () => "Questa partita non c'è più: scegline un'altra.",
+        "game-not-archived": () => "La partita appena finita non è ancora salvata: riprova fra un momento.",
         "update-game": () => italian.update.whilePlaying,
         "update-chat": (most, name) => `${name} sta rispondendo: aggiorna quando ha finito.`,
     },

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

@@ -1,4 +1,4 @@
-import { type IncomingMessage, type ServerResponse } from "node:http";
+import type { IncomingMessage, ServerResponse } from "node:http";
 /** What the chat hears from the doorbell: one line for whatever the player did, never what, only where to read it. */
 export declare const bellLine = "The player acted on the board page: call status to see it.";
 /**
@@ -10,6 +10,7 @@ export declare class Bell {
     private pending;
     private busy;
     private woken;
+    private hooked;
     private readonly news;
     private readonly changed;
     /**
@@ -25,38 +26,34 @@ export declare class Bell {
     get listening(): boolean;
     /** The chat calls a tool, so it is in a turn: true when nobody was listening before. */
     chatCalls(): boolean;
-    /** The player acted on the page: the hook waiting hears it now, or the next one as soon as it comes. */
-    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 player's message, or one the host sent for the doorbell or an agent, starts the chat's turn, as the prompt hook says: the hook of the turn
+     * before is let go without a ring, and what the player does on the page meanwhile waits for the turn's end, as during a tool. A chat nobody heard
+     * stays unheard until its first tool, which starts the AI's clock, held till then: the message moves no clock.
+     */
+    chatPrompted(): void;
+    /**
+     * The player acted on the page: the hook waiting hears it now, or the next one as soon as it comes. In a host that runs no hook nothing tells the end of
+     * a turn: an act the chat waits for finds it out of its turn, and nobody hears the player, unless the chat `mayBeAtWork` on the AI's move meanwhile.
+     */
+    ring(mayBeAtWork?: boolean): 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. A ring no hook heard is dropped when
+     * the chat is `told` all of it otherwise: by the player's message that came with the move the prompt hook played.
+     */
+    listen(request: IncomingMessage, response: ServerResponse, told?: boolean): 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, 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.
+ * Notes in the data folder the port a chat's page took off its folder's usual ports, one file per page, for the hook to find it there; then forgets, off
+ * the caller's clock, the notes of its folder whose page is gone: nobody listens at the port, or another folder's page does. A page that answers late
+ * is busy, not gone, and keeps its note. It throws when the note cannot be written.
  */
-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[];
+export declare function notePagePort(home: string, folder: string, port: number, wait?: number): Promise<void>;
+/** Forgets the note of a page that closes, unless another folder's page took its port since; a note that cannot go is left for the next page to clear. */
+export declare function forgetPagePort(home: string, folder: string, port: number): void;
 /** What Codex's Stop hook answers to wake the chat: its turn goes on with the doorbell's line. */
 export declare const codexBellAnswer: string;
 /**

package/dist/server/bell/bell.js

@@ -1,13 +1,11 @@
 // The doorbell for the page (D-47): `chesspal listen`, the Stop hook init writes for Claude Code and Codex, waits at the page of its chat and, when
 // the player moves or writes there, tells the chat to call status. It never carries the move, the words or the position: status reads them fresh.
-import { 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, samePath, tableFolder } from "../../home/index.js";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { positionShownNote, writeAtomically } from "../../games/index.js";
+import { samePath } from "../../home/index.js";
 import { analystAgent } from "../../host-files/index.js";
-import { version } from "../../version.js";
+import { askPage, chatFolder, findChatPage, notedFolder, notedPagePorts, pageNote, probeOf, probeWait } from "../ports/index.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.";
 /**
@@ -17,10 +15,13 @@ export const bellLine = "The player acted on the board page: call status to see
 export class Bell {
     listener;
     pending = false;
-    // The chat is in a turn: it called a tool, or a hook woke it, and its turn has not ended yet. A chat never started, or just cleared, is not.
+    // The chat is in a turn: the player's message started it, it called a tool, or a hook woke it, and its turn has not ended yet. A chat never started,
+    // or just cleared, is not.
     busy = false;
     // The doorbell woke the chat in this turn: the player acted on the page, and the chat goes to see it.
     woken = false;
+    // A hook has waited for the bell since the chat came: its host runs Chesspal's hooks, and only they tell where a turn ends.
+    hooked = false;
     news;
     changed;
     /**
@@ -50,10 +51,31 @@ export class Bell {
         this.tellIf(asleep);
         return asleep;
     }
-    /** The player acted on the page: the hook waiting hears it now, or the next one as soon as it comes. */
-    ring() {
+    /**
+     * The player's message, or one the host sent for the doorbell or an agent, starts the chat's turn, as the prompt hook says: the hook of the turn
+     * before is let go without a ring, and what the player does on the page meanwhile waits for the turn's end, as during a tool. A chat nobody heard
+     * stays unheard until its first tool, which starts the AI's clock, held till then: the message moves no clock.
+     */
+    chatPrompted() {
+        if (this.listener === undefined) {
+            return;
+        }
+        this.listener.end("dismissed");
+        this.listener = undefined;
+        this.busy = true;
+        this.changed();
+    }
+    /**
+     * The player acted on the page: the hook waiting hears it now, or the next one as soon as it comes. In a host that runs no hook nothing tells the end of
+     * a turn: an act the chat waits for finds it out of its turn, and nobody hears the player, unless the chat `mayBeAtWork` on the AI's move meanwhile.
+     */
+    ring(mayBeAtWork = false) {
         if (this.listener === undefined) {
             this.pending = true;
+            if (!this.hooked && !mayBeAtWork && this.busy) {
+                this.busy = false;
+                this.changed();
+            }
             return;
         }
         this.listener.end("ring");
@@ -62,10 +84,14 @@ export class Bell {
         this.woken = true;
         this.changed();
     }
-    /** 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, response) {
+    /**
+     * 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. A ring no hook heard is dropped when
+     * the chat is `told` all of it otherwise: by the player's message that came with the move the prompt hook played.
+     */
+    listen(request, response, told = false) {
         response.writeHead(200, { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" });
-        const missed = this.pending;
+        this.hooked = true;
+        const missed = this.pending && !told;
         this.pending = false;
         if (missed && this.news()) {
             response.end("ring");
@@ -89,6 +115,7 @@ 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.hooked = false;
         this.busy = false;
         this.woken = false;
         this.pending = false;
@@ -103,21 +130,27 @@ export class Bell {
     }
 }
 /**
- * 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.
+ * Notes in the data folder the port a chat's page took off its folder's usual ports, one file per page, for the hook to find it there; then forgets, off
+ * the caller's clock, the notes of its folder whose page is gone: nobody listens at the port, or another folder's page does. A page that answers late
+ * is busy, not gone, and keeps its note. It throws when the note cannot be written.
  */
-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 }) }) };
+export function notePagePort(home, folder, port, wait = probeWait) {
+    const note = pageNote(home, port);
+    mkdirSync(dirname(note), { recursive: true });
+    writeAtomically(note, JSON.stringify({ folder: resolve(folder) }));
+    return forgetGonePages(home, folder, port, wait);
 }
-/** 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) {
-    const offset = createHash("sha256").update(resolve(folder).toLowerCase()).digest()[0] % 10;
-    return [5870, 6870, 7870].map((base) => base + offset);
+/** Forgets the note of a page that closes, unless another folder's page took its port since; a note that cannot go is left for the next page to clear. */
+export function forgetPagePort(home, folder, port) {
+    const noted = notedFolder(home, port);
+    if (noted !== undefined && samePath(noted, folder)) {
+        try {
+            rmSync(pageNote(home, port), { force: true });
+        }
+        catch {
+            // The next page of the folder clears it.
+        }
+    }
 }
 /** What Codex's Stop hook answers to wake the chat: its turn goes on with the doorbell's line. */
 export const codexBellAnswer = JSON.stringify({ decision: "block", reason: bellLine });
@@ -159,68 +192,32 @@ export async function waitForBell(input, ports) {
  */
 export async function bellHeard(input, ports) {
     const hook = hookInput(input);
-    const folder = chatFolder(hook);
-    const tried = ports ?? pagePorts(folder);
-    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;
+    const found = await findChatPage(hook, ports);
+    const { folder, port } = found;
     if (port === undefined) {
-        const others = probes.flatMap((one) => (one.said === undefined ? [] : [`${one.port} is ${one.said.folder}'s`]));
-        const open = ours.filter(({ said }) => said.open).length;
-        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(", ")}` : ""}` };
+        return { folder, rang: false, why: found.why };
     }
-    // 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");
+    // The page lets the analyst go as the hook starts waiting, when none runs any more; and it rings for nothing older than the move the prompt hook played
+    // for this chat, which hears it from the player's message itself.
+    const shown = hook.session === undefined ? undefined : positionShownNote(folder);
+    const told = shown !== undefined && shown.session === hook.session ? shown.stamp : undefined;
+    const query = new URLSearchParams({ ...(hook.analystGone === true ? { analyst: "gone" } : {}), ...(told === undefined ? {} : { shown: told }) });
+    const said = (await askPage(port, `/api/bell${query.size === 0 ? "" : `?${query}`}`)).text;
     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.
-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.
+ * Forgets the notes of a folder's pages that are gone, but the one at `kept`: a page closed without forgetting its own, when nobody listens at its port or
+ * another folder's page took it. A page that does not answer in time, or not as a page, may only be busy, and its note stays.
  */
-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;
-    }
+async function forgetGonePages(home, folder, kept, wait) {
+    const others = notedPagePorts(home, folder).filter((port) => port !== kept);
+    await Promise.all(others.map(async (port) => {
+        const { refused, text } = await askPage(port, "/api/bell?probe", wait);
+        const said = probeOf(text);
+        if (refused || (said !== undefined && !samePath(said.folder, folder))) {
+            forgetPagePort(home, folder, port);
+        }
+    }));
 }
 // The log of Codex's hooks that heard no bell, in the chat's folder: its last lines only.
 const silenceLog = "listen.log";
@@ -236,10 +233,6 @@ export function noteSilence(folder, why, now = new Date()) {
         // The log only explains; the hook ends the same.
     }
 }
-/** The chat's folder, where its server started: Claude Code names it, and the hook's cwd follows the cd's of the chat. */
-function chatFolder(hook) {
-    return resolve(process.env.CLAUDE_PROJECT_DIR ?? hook.cwd ?? process.cwd());
-}
 function hookInput(input) {
     try {
         const parsed = JSON.parse(input);
@@ -263,60 +256,3 @@ function analystGone(tasks) {
         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.
- */
-function chatPage(pages, session) {
-    const open = pages.filter(({ said }) => said.open);
-    return pages.find(({ said }) => session !== undefined && said.session === session) ?? (pages.length === 1 ? pages[0] : open.length === 1 ? open[0] : undefined);
-}
-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,
-            ...(typeof parsed.version === "string" ? { version: parsed.version } : {}),
-            ...(parsed.table === true ? { table: true } : {}),
-            ...(typeof parsed.chat === "string" ? { chat: parsed.chat } : {}),
-        };
-    }
-    catch {
-        return undefined;
-    }
-}
-/** The body a page of this computer answers with, once it ends; undefined when it does not answer, or not with 200. */
-function body(port, path, wait) {
-    return new Promise((done) => {
-        // A connection of its own: Node's shared one ends a request idle for five seconds, and the doorbell waits for hours.
-        const request = get({ host: "127.0.0.1", port, path, agent: false }, (response) => {
-            let text = "";
-            response.setEncoding("utf8");
-            response.on("data", (chunk) => {
-                text += chunk;
-            });
-            response.on("end", () => done(response.statusCode === 200 ? text : undefined));
-            response.on("error", () => done(undefined));
-        });
-        if (wait !== undefined) {
-            giveUpAfterTurns(request, wait);
-        }
-        request.on("error", () => done(undefined));
-    });
-}
-/**
- * Ends a request still unanswered after `wait`, counted in ten turns of this process's clock: after a stall (a busy computer, one waking up), a timer
- * fires before the answer waiting is read, and a page of this process, or one that answered meanwhile, would be taken for one that does not answer.
- */
-function giveUpAfterTurns(request, wait) {
-    let turns = 0;
-    const timer = setInterval(() => {
-        turns++;
-        if (turns === 10) {
-            request.destroy();
-        }
-    }, wait / 10);
-    request.on("close", () => clearInterval(timer));
-}

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

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

package/dist/server/bell/index.js

@@ -1,2 +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 } from "./bell.js";
+// The doorbell that wakes a chat when the player acts on the page (D-47), and the notes of the ports a folder's page took off its usual ones.
+export { Bell, forgetPagePort, listen, notePagePort } from "./bell.js";

package/dist/server/mcp/mcp.js

@@ -3,13 +3,12 @@
 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 { aiMove, commands, defaultContext, homeForOneCall, inputProblems, isBoolean, PositionChanged, positionIn, samePosition } from "../../commands/index.js";
 import { aiNameOf } from "../../core/index.js";
-import { endOf, loadGame, noteAiHost, noteAiModel, rerunIfChanged } from "../../games/index.js";
+import { endOf, forgetPositionShown, hostProcess, lastChatStart, loadGame, noteAiHost, noteAiModel, positionShownNote, 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";
@@ -108,8 +107,8 @@ async function pageOf(context, opponent, again) {
         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`);
+        if (!page.findable) {
+            process.stderr.write(`The board page is at ${page.url}, off its usual ports, and its port could not be noted in the data folder: the doorbell cannot find it, so moves on the page do not wake the chat.\n`);
         }
         return page;
     }
@@ -203,15 +202,17 @@ async function runTool(command, input, context, caller, meta) {
     const calling = await sharingCaller(command, meta, context);
     const agent = calling !== undefined && "agent" in calling ? calling.agent : undefined;
     const chat = command.byAgents === undefined && agent === undefined;
+    const home = homeForOneCall(context);
     let refused = false;
     try {
         if (chat) {
+            takePositionShown(context, home);
             await context.calls?.();
         }
         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 }));
+        const result = await rerunIfChanged(() => command.run(checkedInput(command, input), { ...context, home, caller, ...who }));
         return { content: [{ type: "text", text: command.format(result, context) }] };
     }
     catch (error) {
@@ -222,10 +223,51 @@ async function runTool(command, input, context, caller, meta) {
         // What the tool read or wrote, the chat has seen: the doorbell rings it only for what changes after, and it may move on the game a tool showed it,
         // unless that tool was refused for a position it had not seen. An agent's call is not the chat's.
         if (chat) {
-            chatHasRead(context, command.showsGame === true && !refused);
+            chatHasRead(context, command.showsGame === true && !refused, home);
         }
     }
 }
+/**
+ * The position the prompt hook showed the chat with the move the player wrote alone (D-71), taken before the chat's tool runs as if a tool had shown it,
+ * while the game is still there: the AI moves on it without a status, and the player's words the hook gave count as given, which the page hears. A note
+ * on another position goes; one of another chat's stays for it.
+ */
+function takePositionShown(context, home) {
+    const shown = positionShownNote(context.folder);
+    if (shown === undefined) {
+        return;
+    }
+    let current;
+    try {
+        current = samePosition(shown, positionIn(gameFolder(home())));
+    }
+    catch {
+        // A game that cannot be read is the tool's to report.
+        return;
+    }
+    if (current && !chatsNote(shown, context.folder)) {
+        return;
+    }
+    forgetPositionShown(context.folder);
+    if (!current) {
+        return;
+    }
+    shown.given.forEach((key) => context.given.add(key));
+    // The position is new to the chat, a move later than any it saw: the page hears of it, and of the words read with it.
+    chatHasRead(context, true, home);
+}
+/**
+ * Whether a note of the hooks is this server's chat's: by the Claude Code process, which names itself alike to the server and its hooks, when both have its
+ * name. Else by the session: the server's is the one Claude Code started it with, and the hooks get a new one after /clear, which the chat's start notes;
+ * a chat started or resumed since in the folder is taken for another Claude Code.
+ */
+function chatsNote({ process: noted, session }, folder, own = hostProcess(), ownSession = process.env.CLAUDE_CODE_SESSION_ID) {
+    if (noted !== undefined && own !== undefined) {
+        return noted === own;
+    }
+    const start = lastChatStart(folder);
+    return session === ownSession || (start?.session === session && start.source !== "startup" && start.source !== "resume");
+}
 /**
  * Who calls a tool the chat shares with an agent, as the analyst (D-89): the chat, or the agent by its type; looked up only in a folder where one may run
  * and while no game goes on, so that no call of the chat's waits for it while it plays. None when it cannot be told, or for an agent the tool is not shared with.