chesspal 0.3.2 → 0.3.3

package/dist/commands/answers/agents.d.ts

@@ -38,7 +38,7 @@ export declare function agentsLine(agents: readonly string[]): string;
 export declare function goneOver(context: Context, game: string): boolean;
 /**
  * The run of the analyst agent at work on a game: the one that took it last, unless its chat has started again since, not only summarized, and took the
- * agent with it.
+ * agent with it, or it has written nothing for half an hour, as one long dead (D-109): a quiet minute proves nothing, since an analyst may think long.
  */
 export declare function analystOf(context: Context, game: string): string | undefined;
 /** What stops an analyst agent on a game another analyst has taken: the chat hears of the review from that one (Priya). */

package/dist/commands/answers/agents.js

@@ -90,14 +90,18 @@ export function goneOver(context, game) {
 }
 /**
  * The run of the analyst agent at work on a game: the one that took it last, unless its chat has started again since, not only summarized, and took the
- * agent with it.
+ * agent with it, or it has written nothing for half an hour, as one long dead (D-109): a quiet minute proves nothing, since an analyst may think long.
  */
 export function analystOf(context, game) {
-    const taken = gameInAnalysis(gameFolder(context.home()))?.analyst;
+    const analysis = gameInAnalysis(gameFolder(context.home()));
+    const taken = analysis?.analyst;
     const start = lastChatStart(context.folder);
-    const gone = taken !== undefined && start !== undefined && start.source !== "compact" && Date.parse(start.at) > Date.parse(taken.since);
-    return taken?.game === game && !gone ? taken.run : undefined;
+    const restarted = taken !== undefined && start !== undefined && start.source !== "compact" && Date.parse(start.at) > Date.parse(taken.since);
+    const quiet = analysis !== undefined && context.now().getTime() - Date.parse(analysis.at) > analystQuiet;
+    return taken?.game === game && !restarted && !quiet ? taken.run : undefined;
 }
+/** How long an analyst may write nothing before it counts as gone. */
+const analystQuiet = 30 * 60 * 1000;
 /** What stops an analyst agent on a game another analyst has taken: the chat hears of the review from that one (Priya). */
 export const anotherAnalyst = "Stop now: another analyst is reviewing this game. End with one line for the AI that started you: its review is on its way to the "
     + "board page, and its end comes to you by itself; meanwhile talk the game over with the player whenever they ask. Should it never come, the player has "

package/dist/page/app/app.js

@@ -43,7 +43,7 @@ import { textFor } from "../text.js";
 import { anchorName, useAnchor } from "./anchor.js";
 import { useBrowseKeys, useFoldKeys, useLegendKey, useMapKey, useWheelSteps } from "./keys.js";
 import { phaseOf, verdictOf } from "./phase.js";
-import { post, sendMessage, sendMove, useServed } from "./served.js";
+import { ask, post, sendMessage, sendMove, useServed } from "./served.js";
 import { tabTitle, useTabTitle } from "./title.js";
 /**
  * The page: the board of the game in the player's folder, where the player moves on their turn, the talk with the AI beside it, and the game's column; in the
@@ -71,12 +71,23 @@ export function App({ start }) {
     const { data: served, problem, offline, reload } = useServed(() => setDialog("new-game"));
     // Nuova partita with no chat at the table asks for one first (D-107): the chat's window, then the new game's, however the first closes.
     const [chatFirst, setChatFirst] = useState(false);
-    const askNewGame = () => {
+    // At the table with no chat, and none opening: what asks for the AI opens the chat's window first, to choose its host and model (D-107, D-109).
+    const chatMissing = () => {
         const table = offline ? undefined : served?.table;
-        const first = table !== undefined && !table.chat && table.opening === undefined;
+        return table !== undefined && !table.chat && table.opening === undefined;
+    };
+    // The chat's window opened for an analysis asks who reviews the game, not whom the player plays (Rosa, Zoe).
+    const [chatToReview, setChatToReview] = useState(false);
+    const askNewGame = () => {
+        const first = chatMissing();
         setChatFirst(first);
+        setChatToReview(false);
         setDialog(first ? "chat" : "new-game");
     };
+    const askChat = () => {
+        setChatToReview(false);
+        setDialog("chat");
+    };
     const closeChat = () => {
         setDialog(chatFirst ? "new-game" : undefined);
         setChatFirst(false);
@@ -302,6 +313,8 @@ export function App({ start }) {
     const summary = studied === undefined ? undefined : gameReviewOf(live.record);
     // An AI is going over the game only when the server says so: with no chat at it, nobody is (Stefano).
     const reviewing = summary === undefined && studied?.reviewing === true && !offline;
+    // With nobody at it, a review not finished says so, and the player brings the game back to the AI (D-109).
+    const completeIt = summary === undefined && studied?.incomplete === true && !offline ? () => void studyGame({ game: studied.name }) : undefined;
     const closing = studied === undefined ? undefined : closingOf(live.record);
     // In analysis the AI's card says who played that game, as its PGN keeps it (D-82), not who plays now.
     const playedBy = studied === undefined ? undefined : aiModelIn(live.record);
@@ -320,7 +333,7 @@ export function App({ start }) {
     // Where to wake the chat, under the AI's card (over the board when the talk is folded); the button that starts the clocks, under the player's (Zoe).
     // On the table, what its chat is doing stands there, and in a game with no chat at it a line that opens the chat's window (D-107).
     const table = offline ? undefined : served.table;
-    const atTable = table === undefined ? null : tableNote({ table, name, inGame: going, onOpen: () => setDialog("chat"), text });
+    const atTable = table === undefined ? null : tableNote({ table, name, inGame: going, onOpen: askChat, text });
     const asleepNote = atTable !== null
         ? atTable
         : asleep && table?.chat !== false
@@ -402,15 +415,19 @@ export function App({ start }) {
     };
     // In analysis the AI's note goes with the other side's card and the talk with the player's, turned round with the board as in a game (D-101, Zoe).
     const studiedCard = (side, place) => sides === undefined ? null : (_jsx(PlayerCard, { place: place, picture: pictureOf(sides[side], profile, 48, mood), name: sides[side].name, signed: sides[side].who === "ai" && playedBy !== undefined ? signature(playedBy.model, playedBy.effort) : undefined, side: side, taken: material.taken[side], ahead: ahead(side), badges: _jsx(BadgeCounts, { plies: plies, side: side, names: text.badges }), text: text }));
-    // A game brought to analyse: the page shows it once the server has it in analysis; a refusal stays in the dialog.
+    // A game brought to analyse: the page shows it once the server has it in analysis; a refusal stays in the dialog. One the AI has to go over, with no
+    // chat at the table, opens the chat's window: the analyst works with the chat's model (D-109).
     const studyGame = async (studied) => {
-        const refused = await post("/api/study", studied, text, name);
-        if (refused === undefined) {
-            setDialog(undefined);
+        const sent = await ask("/api/study", studied, text, name);
+        if ("refused" in sent) {
+            return sent.refused.text;
         }
-        return refused?.text;
+        const toReview = sent.answer.reviewed === false && chatMissing();
+        setChatToReview(toReview);
+        setDialog(toReview ? "chat" : undefined);
+        return undefined;
     };
-    return (_jsx(ChosenSet.Provider, { value: settings.set, children: _jsxs(PointSquare.Provider, { value: pointSquare, children: [panel, _jsx(ProfileDialog, { open: dialog === "profile", profile: profile, onClose: () => setDialog(undefined), text: text }), _jsx(ProfilesDialog, { open: dialog === "profiles", profiles: served.profiles, active: profile, locked: going ? text.profile.whilePlaying : undefined, dataFolder: served.dataFolder, onEdit: () => setDialog("profile"), onClose: () => setDialog(undefined), text: text }), table === undefined ? null : _jsx(ChatDialog, { open: dialog === "chat", table: table, settings: settings, onChange: change, name: name, onClose: closeChat, text: text }), _jsx(NewGameDialog, { open: dialog === "new-game", choice: choice, going: going, onStart: startNewGame, onClose: () => setDialog(undefined), text: text }), guide, _jsx(StudyDialog, { open: dialog === "study", onStudy: studyGame, onClose: () => setDialog(undefined), you: profile.name, accounts: profile.accounts, ai: name, text: text }), served.update === undefined || served.table === undefined
+    return (_jsx(ChosenSet.Provider, { value: settings.set, children: _jsxs(PointSquare.Provider, { value: pointSquare, children: [panel, _jsx(ProfileDialog, { open: dialog === "profile", profile: profile, onClose: () => setDialog(undefined), text: text }), _jsx(ProfilesDialog, { open: dialog === "profiles", profiles: served.profiles, active: profile, locked: going ? text.profile.whilePlaying : undefined, dataFolder: served.dataFolder, onEdit: () => setDialog("profile"), onClose: () => setDialog(undefined), text: text }), table === undefined ? null : _jsx(ChatDialog, { open: dialog === "chat", review: chatToReview, table: table, settings: settings, onChange: change, name: name, onClose: closeChat, text: text }), _jsx(NewGameDialog, { open: dialog === "new-game", choice: choice, going: going, onStart: startNewGame, onClose: () => setDialog(undefined), text: text }), guide, _jsx(StudyDialog, { open: dialog === "study", onStudy: studyGame, onClose: () => setDialog(undefined), you: profile.name, accounts: profile.accounts, ai: name, text: text }), served.update === undefined || served.table === undefined
                     ? null
                     : (_jsx(UpdateDialog, { open: dialog === "update", version: served.update.version, current: served.version, installing: served.update.installing === true, installed: served.update.installed === true, going: going, chat: served.table.chat ? (served.table.held ? "held" : "byHand") : undefined, name: name, onClose: () => setDialog(undefined), text: text })), offline ? _jsx("p", { class: "offline", role: "alert", children: text.offline(name) }) : null, served.outdated === true
                     ? _jsx("p", { class: "outdated", role: "status", children: text.outdated(name) })
@@ -419,11 +436,11 @@ export function App({ start }) {
                         : null, _jsxs("main", { class: `app${flipped ? " flipped" : ""}${folds.talk === "open" ? "" : ` talk-${folds.talk}`}${folds.game === "folded" ? " folded" : ""}`, inert: offline, children: [header, sides === undefined
                             ? (_jsx(TalkFaces, { name: name, aiPicture: thinker(40), you: profile.name, picture: picture, ...(idle ? {} : { ai, player }), aiMoves: going && !playerToMove, playerMoves: playerToMove, unread: unread || asleep, text: text }))
                             : (_jsx(TalkFaces, { name: sides[ai].name, aiPicture: pictureOf(sides[ai], profile, 40, mood), you: sides[player].name, picture: pictureOf(sides[player], profile, 40, mood), ai: ai, player: player, aiMoves: false, playerMoves: false, unread: asleep, text: text })), _jsx(FoldTab, { column: "talk", folded: folds.talk === "folded", label: thinking === undefined || folds.talk !== "folded" ? text.talk : `${text.talk}: ${text.thinking[thinking]}`, unread: (unread || asleep) && folds.talk === "folded", ...(thinking === undefined || folds.talk !== "folded" ? {} : { mark: _jsx(Thought, { thinking: thinking, words: text.thinking }) }), onFold: fold }), _jsx(FoldTab, { column: "game", folded: folds.game === "folded", label: text.game, onFold: fold }), _jsx("span", { class: "visually-hidden", "aria-live": "polite", children: unread ? text.wrote(name) : "" }), _jsx("div", { class: sides === undefined ? "talk" : "talk studied", id: "talk", children: sides !== undefined && studied !== undefined
-                                ? (_jsxs(_Fragment, { children: [_jsxs("section", { class: "ai-block", "aria-label": sides[ai].name, children: [studiedCard(ai, "ai"), asleepNote, _jsx(AiNote, { ...(reviewed === undefined ? {} : { ply: reviewed }), ...(shownOpening === undefined ? {} : { opening: shownOpening }), ...(at === total && closing !== undefined ? { closing } : {}), ...(at === 0 && summary !== undefined ? { summary } : {}), ...(reviewing ? { reviewing: true } : {}), name: analyst, by: annotator, mood: mood, ...(settings.voice ? { voice: text } : {}), text: text })] }), _jsxs("section", { class: "you-block", "aria-label": sides[player].name, children: [_jsx("div", { class: "chat", children: _jsx(Compose, { lines: analysisTalk(talk, studied.name), newestFirst: false, spent: 0, draft: draft, onDraft: (words) => {
+                                ? (_jsxs(_Fragment, { children: [_jsxs("section", { class: "ai-block", "aria-label": sides[ai].name, children: [studiedCard(ai, "ai"), asleepNote, _jsx(AiNote, { ...(reviewed === undefined ? {} : { ply: reviewed }), ...(shownOpening === undefined ? {} : { opening: shownOpening }), ...(at === total && closing !== undefined ? { closing } : {}), ...(at === 0 && summary !== undefined ? { summary } : {}), ...(reviewing ? { reviewing: true } : {}), ...(completeIt === undefined ? {} : { onComplete: completeIt }), name: analyst, by: annotator, mood: mood, ...(settings.voice ? { voice: text } : {}), text: text })] }), _jsxs("section", { class: "you-block", "aria-label": sides[player].name, children: [_jsx("div", { class: "chat", children: _jsx(Compose, { lines: analysisTalk(talk, studied.name), newestFirst: false, spent: 0, draft: draft, onDraft: (words) => {
                                                             setDraft(words);
                                                             setUnsent(undefined);
                                                         }, onSend: () => sendWords({ game: studied.name, at }), canMove: false, name: name, problem: unsent, about: { ...(at === 0 ? {} : { ply: plies[at - 1] }), onShow: goTo }, text: text }) }), studiedCard(player, "you")] })] }))
-                                : (_jsxs(_Fragment, { children: [_jsxs("section", { class: "ai-block", "aria-label": name, children: [_jsx(PlayerCard, { place: "ai", picture: thinker(48), name: table === undefined ? name : _jsx(AiNameButton, { name: name, table: table, onOpen: () => setDialog("chat"), text: text }), signed: signed, side: idle ? undefined : ai, ...(idle ? {} : { level: text.start.levels[level] }), taken: material.taken[ai], ahead: ahead(ai), clock: clockOf(ai), text: text }), asleepNote, _jsx(AiWords, { words: aiWords(plies, ai, talk), newestFirst: !flipped, ...(settings.voice ? { voice: text } : {}) })] }), _jsxs("section", { class: "you-block", "aria-label": profile.name, children: [_jsx(Compose, { lines: said, newestFirst: flipped, 
+                                : (_jsxs(_Fragment, { children: [_jsxs("section", { class: "ai-block", "aria-label": name, children: [_jsx(PlayerCard, { place: "ai", picture: thinker(48), name: table === undefined ? name : _jsx(AiNameButton, { name: name, table: table, onOpen: askChat, text: text }), signed: signed, side: idle ? undefined : ai, ...(idle ? {} : { level: text.start.levels[level] }), taken: material.taken[ai], ahead: ahead(ai), clock: clockOf(ai), text: text }), asleepNote, _jsx(AiWords, { words: aiWords(plies, ai, talk), newestFirst: !flipped, ...(settings.voice ? { voice: text } : {}) })] }), _jsxs("section", { class: "you-block", "aria-label": profile.name, children: [_jsx(Compose, { lines: said, newestFirst: flipped, 
                                                     // Between games, and before the first, the player writes freely, a line at a time, as the AI does (D-74, D-77).
                                                     spent: going ? playerSpent(plies, ai, talk) : 0, draft: draft, onDraft: (words) => {
                                                         setDraft(words);
@@ -434,7 +451,14 @@ export function App({ start }) {
                             // A press on the board while the player looks back brings the game as it is: the next one plays.
                             onPointerDownCapture: viewing === undefined || studied !== undefined ? undefined : (event) => event.button === 0 && goTo(total), children: [_jsx(Board, { fen: shown.position.fen, bottom: flipped ? ai : player, lastMove: shown.lastMove, pointed: pointed, ...(helps === undefined ? {} : { helps }), ...(mapping && helps !== undefined ? { control: helps.strategy.control } : {}), bare: bare && helps !== undefined, ...(review?.badge === undefined ? {} : { badge: { badge: review.badge, name: text.badges[review.badge] } }), ...(drawn === undefined ? {} : { drawn }), nextMove: next, jumped: jumped, check: shown.position.check, end: boardEnd, player: playerToMove && pending === undefined && viewing === undefined ? player : undefined, selected: selected, targets: selected === undefined || viewing !== undefined ? [] : live.legalMoves(selected), dots: settings.dots, names: settings.squareNames, notice: viewing === undefined ? refusal : undefined, promotion: promoting === undefined || viewing !== undefined || !playerToMove ? undefined : { ...promoting, side: player }, onPromote: (piece) => piece === undefined ? setPromoting(undefined) : play(promoting.from, promoting.to, piece), onSelect: select, onMove: play, onRefuse: refuse, text: text }), folds.talk !== "open" && (asleepNote !== null || clockWaits)
                                     ? (_jsxs("div", { class: "over-board", children: [asleepNote, startClocks] }))
-                                    : null] }), studied === undefined ? null : (_jsx("div", { class: "board-steps", children: _jsx(Steps, { shown: at, total: total, onStep: step, text: text }) })), helps === undefined ? null : (_jsxs("div", { class: "board-map", children: [legendAt(true), _jsx(BareButton, { bare: bare, onBare: setBare, text: text }), _jsx(MapButton, { mapping: mapping, onMap: setMapping, text: text }), hint === undefined || viewing !== undefined ? null : _jsx(HintLine, { hint: hint, open: hintOpen, onOpen: openTheHint, text: text })] })), _jsx(GameColumn, { plies: idle ? [] : plies, result: ended ? result : undefined, how: how, lit: justEnded, started: idle ? undefined : played?.started, move: live.position.moveNumber, toMove: live.position.turn, opening: opening, helps: helps === undefined ? undefined : (_jsx(HelpsCard, { helps: helps, judged: judgments, hint: viewing === undefined ? hint : undefined, hintOpen: hintOpen, onHint: openTheHint, onPoint: setPointed, onMap: setMapping, mapping: mapping, onBare: setBare, bare: bare, legend: legend, text: text })), ...(helps === undefined && legendRows.length > 0 ? { legend } : {}), ...(standings === undefined ? {} : { standings }), ...(studied === undefined ? {} : { analysis: { by: analyst, ...(summary === undefined ? {} : { summary }), ...(reviewing ? { reviewing: true } : {}) } }), shownPlies: at, onShow: goTo, onStep: step, ...(studied === undefined ? {} : { onDownload: () => download(studied.pgn, pgnName(live.record.tags, "analysis")) }), ...(total === 0 ? {} : { onSaveMoves: () => download(writePgn(movesOnly(live.record)), pgnName(live.record.tags)) }), ...(between && game !== null && replayed.record.moves.length > 0 ? { onAnalyse: () => void studyGame({ last: true }) } : {}), text: text }), _jsx(PageFoot, { version: served.version, text: text })] })] }) }));
+                                    : null] }), studied === undefined ? null : (_jsx("div", { class: "board-steps", children: _jsx(Steps, { shown: at, total: total, onStep: step, text: text }) })), helps === undefined ? null : (_jsxs("div", { class: "board-map", children: [legendAt(true), _jsx(BareButton, { bare: bare, onBare: setBare, text: text }), _jsx(MapButton, { mapping: mapping, onMap: setMapping, text: text }), hint === undefined || viewing !== undefined ? null : _jsx(HintLine, { hint: hint, open: hintOpen, onOpen: openTheHint, text: text })] })), _jsx(GameColumn, { plies: idle ? [] : plies, result: ended ? result : undefined, how: how, lit: justEnded, started: idle ? undefined : played?.started, move: live.position.moveNumber, toMove: live.position.turn, opening: opening, helps: helps === undefined ? undefined : (_jsx(HelpsCard, { helps: helps, judged: judgments, hint: viewing === undefined ? hint : undefined, hintOpen: hintOpen, onHint: openTheHint, onPoint: setPointed, onMap: setMapping, mapping: mapping, onBare: setBare, bare: bare, legend: legend, text: text })), ...(helps === undefined && legendRows.length > 0 ? { legend } : {}), ...(standings === undefined ? {} : { standings }), ...(studied === undefined ? {} : {
+                                analysis: {
+                                    by: analyst,
+                                    ...(summary === undefined ? {} : { summary }),
+                                    ...(reviewing ? { reviewing: true } : {}),
+                                    ...(completeIt === undefined ? {} : { onComplete: completeIt }),
+                                },
+                            }), shownPlies: at, onShow: goTo, onStep: step, ...(studied === undefined ? {} : { onDownload: () => download(studied.pgn, pgnName(live.record.tags, "analysis")) }), ...(total === 0 ? {} : { onSaveMoves: () => download(writePgn(movesOnly(live.record)), pgnName(live.record.tags)) }), ...(between && game !== null && replayed.record.moves.length > 0 ? { onAnalyse: () => void studyGame({ last: true }) } : {}), text: text }), _jsx(PageFoot, { version: served.version, text: text })] })] }) }));
 }
 /** The picture of a player of the game in analysis: the player's own, the AI's Torretta with its mood, or the plain face of someone else. */
 function pictureOf({ who }, profile, size, mood) {

package/dist/page/app/served.js

@@ -56,17 +56,22 @@ export function useServed(onNewGame) {
  * it sends the player, or undefined.
  */
 export async function post(path, body, text, name) {
+    const sent = await ask(path, body, text, name);
+    return "refused" in sent ? sent.refused : undefined;
+}
+/** Sends a request to the server as `post` does: its answer, or the reason it was refused. */
+export async function ask(path, body, text, name) {
     try {
         const response = await fetch(path, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
         if (response.ok) {
-            return undefined;
+            return { answer: await response.json().catch(() => ({})) };
         }
         const refused = (await response.json());
         const known = refused.refusal === undefined ? undefined : text.refused[refused.refusal];
-        return { text: known?.(refused.most ?? 0, name) ?? refused.error ?? response.statusText, words: refused.refusal?.startsWith("words-") === true };
+        return { refused: { text: known?.(refused.most ?? 0, name) ?? refused.error ?? response.statusText, words: refused.refusal?.startsWith("words-") === true } };
     }
     catch (error) {
-        return { text: String(error), words: false };
+        return { refused: { text: String(error), words: false } };
     }
 }
 /** Sends the player's move to the server, which plays it as the chat would, with the words written for the AI: the reason it was refused, or undefined. */

package/dist/page/game/column.js

@@ -14,7 +14,7 @@ export function GameColumn({ plies, result, how, lit, started, move, toMove, ope
     const bar = standings === undefined ? undefined : _jsx(LeadBar, { standing: standingAt(standings, shownPlies), shown: shownPlies, text: text });
     return (_jsx("aside", { class: "side", id: "game", "aria-label": text.game, children: started === undefined && analysis === undefined
             ? (_jsxs(_Fragment, { children: [_jsx("p", { class: "card empty", children: text.noGame }), onAnalyse === undefined ? null : _jsx(AnalyseButton, { label: text.study.analyseLast, onAnalyse: onAnalyse })] }))
-            : (_jsxs(_Fragment, { children: [_jsxs("div", { class: "side-cards", children: [_jsx(GameCard, { plies: plies, result: result, how: how, lit: lit, started: started, move: move, toMove: toMove, bar: bar, text: text }), analysis === undefined || standings === undefined ? null : _jsx(LeadChart, { plies: plies, standings: standings, shown: shownPlies, onShow: onShow, text: text }), opening === undefined ? null : _jsx(OpeningCard, { opening: opening, text: text }), helps, analysis?.reviewing !== true ? null : (_jsxs("p", { class: "card review waiting", role: "status", children: [_jsx("span", { class: "spinner", "aria-hidden": "true" }), text.reviewing(analysis.by)] }))] }), _jsxs("div", { class: "side-foot", children: [result !== undefined && plies.length === 0 ? null : _jsx(MoveList, { plies: plies, result: result, shown: shownPlies, onShow: onShow, tools: legend, text: text }), onDownload === undefined && onSaveMoves === undefined ? null : (_jsxs("div", { class: "card analysis-actions", children: [onDownload === undefined ? null : _jsx(SaveButton, { label: text.study.download, hint: text.study.downloadHint, onSave: onDownload }), onSaveMoves === undefined ? null : _jsx(SaveButton, { label: text.saveMoves, hint: text.saveMovesHint, onSave: onSaveMoves })] })), onAnalyse === undefined ? null : _jsx(AnalyseButton, { label: text.study.analyseIt, onAnalyse: onAnalyse }), _jsx(Steps, { shown: shownPlies, total: plies.length, onStep: onStep, text: text })] })] })) }));
+            : (_jsxs(_Fragment, { children: [_jsxs("div", { class: "side-cards", children: [_jsx(GameCard, { plies: plies, result: result, how: how, lit: lit, started: started, move: move, toMove: toMove, bar: bar, text: text }), analysis?.reviewing !== true ? null : (_jsxs("p", { class: "card review waiting", role: "status", children: [_jsx("span", { class: "spinner", "aria-hidden": "true" }), text.reviewing(analysis.by)] })), analysis?.onComplete === undefined ? null : (_jsxs("div", { class: "card review incomplete", children: [_jsx("p", { role: "status", children: text.incomplete }), _jsx("button", { type: "button", title: text.completeHint, "aria-label": text.completeHint, onClick: analysis.onComplete, children: text.complete })] })), analysis === undefined || standings === undefined ? null : _jsx(LeadChart, { plies: plies, standings: standings, shown: shownPlies, onShow: onShow, text: text }), opening === undefined ? null : _jsx(OpeningCard, { opening: opening, text: text }), helps] }), _jsxs("div", { class: "side-foot", children: [result !== undefined && plies.length === 0 ? null : _jsx(MoveList, { plies: plies, result: result, shown: shownPlies, onShow: onShow, tools: legend, text: text }), onDownload === undefined && onSaveMoves === undefined ? null : (_jsxs("div", { class: "card analysis-actions", children: [onDownload === undefined ? null : _jsx(SaveButton, { label: text.study.download, hint: text.study.downloadHint, onSave: onDownload }), onSaveMoves === undefined ? null : _jsx(SaveButton, { label: text.saveMoves, hint: text.saveMovesHint, onSave: onSaveMoves })] })), onAnalyse === undefined ? null : _jsx(AnalyseButton, { label: text.study.analyseIt, onAnalyse: onAnalyse }), _jsx(Steps, { shown: shownPlies, total: plies.length, onStep: onStep, text: text })] })] })) }));
 }
 /** A button that saves the game as a file in the player's downloads, its tooltip saying what the file holds. */
 function SaveButton({ label, hint, onSave }) {

package/dist/page/game/game.css

@@ -320,6 +320,27 @@
     color: var(--soft);
 }
 
+/* A review nobody is finishing: the note, and beside it the button that brings the game back to the AI (D-109); neutral, as no error (Zoe) */
+.review.incomplete,
+.say.incomplete {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 8px;
+    margin: 0;
+    color: var(--soft);
+}
+
+.review.incomplete button,
+.say.incomplete button {
+    flex: none;
+}
+
+/* On the bubble's tint the button keeps the card's ground, to read as one */
+.say.incomplete button {
+    background: var(--card);
+}
+
 .review ul {
     margin: 0;
     padding-left: 18px;
@@ -497,7 +518,8 @@
     padding: 8px;
 }
 
-.analysis-actions button {
+.analysis-actions button,
+.incomplete button {
     flex: 1;
     display: inline-flex;
     align-items: center;
@@ -513,7 +535,8 @@
     cursor: pointer;
 }
 
-.analysis-actions button:hover {
+.analysis-actions button:hover,
+.incomplete button:hover {
     border-color: var(--accent);
 }
 

package/dist/page/helps/helps.css

@@ -238,12 +238,19 @@
     padding: 3px 6px;
 }
 
-/* The coach's words at the top of the card (D-88): its judgment of the player's last move, then its hint, folded until they open it */
+/* The coach's words at the top of the card (D-88), tinted rows as the tactics': each judgment in its badge's colour, the hint in the accent behind a bulb */
 .helps-card .coach {
     display: flex;
     flex-direction: column;
-    gap: 6px;
-    font-size: 14px;
+    gap: 3px;
+    font-size: 13px;
+}
+
+.helps-card .coach .judged,
+.helps-card .coach .coach-hint {
+    --row: var(--accent);
+    border-radius: 6px;
+    background: color-mix(in srgb, var(--row) 10%, transparent);
 }
 
 .coach-hint summary {
@@ -257,6 +264,48 @@
     display: none;
 }
 
+/* A row's head: its icon, its words in ink, the sign of a line that opens on the right */
+.helps-card .coach .head,
+.helps-card .coach summary {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    padding: 3px 8px 3px 6px;
+    border-radius: 6px;
+    color: var(--ink);
+}
+
+.helps-card .coach summary {
+    cursor: pointer;
+    list-style: none;
+}
+
+.helps-card .coach summary:hover,
+.helps-card .coach details[open] > summary {
+    background: color-mix(in srgb, var(--row) 16%, transparent);
+}
+
+.helps-card .coach .row-icon {
+    display: grid;
+    place-items: center;
+    flex: none;
+    width: 16px;
+    height: 16px;
+    color: var(--row);
+}
+
+.board-map .coach-hint .row-icon {
+    display: none;
+}
+
+/* A finger needs a taller line (Zoe) */
+@media (pointer: coarse) {
+    .helps-card .coach .head,
+    .helps-card .coach summary {
+        padding-block: 7px;
+    }
+}
+
 /* The same sign on both, so that on a phone, with no pointer, they read as lines that open (Zoe) */
 .helps-card .coach summary::after,
 .board-map .coach-hint summary::after {
@@ -265,12 +314,31 @@
     color: var(--soft);
 }
 
+.helps-card .coach summary::after {
+    margin-left: auto;
+}
+
 .helps-card .coach details[open] > summary::after,
 .board-map .coach-hint[open] > summary::after {
     content: "▾";
 }
 
-.coach-hint .note {
+/* The words opened, under the head's text */
+.helps-card .coach .note {
+    display: block;
+    margin: 0;
+    padding: 2px 8px 6px 28px;
+    color: var(--say-ink);
+    font-size: 13px;
+    line-height: 1.4;
+}
+
+.helps-card .coach .legend {
+    margin: 0;
+    padding: 0 8px 6px 28px;
+}
+
+.board-map .coach-hint .note {
     display: block;
     margin-top: 4px;
     color: var(--say-ink);
@@ -472,7 +540,8 @@
     color: var(--row);
 }
 
-.help-rows .row-icon svg {
+.help-rows .row-icon svg,
+.coach-hint .row-icon svg {
     width: 14px;
     height: 14px;
     fill: none;

package/dist/page/helps/helps.js

@@ -41,12 +41,12 @@ export function BareButton({ bare, onBare, text }) {
     return (_jsx(HoldButton, { on: bare, onHold: onBare, title: text.helpsCard.bareHint, label: text.helpsCard.bare, kind: "bare-button", children: _jsxs("svg", { viewBox: "0 0 16 16", "aria-hidden": "true", children: [_jsx("path", { d: "M1.5 8S4 3.5 8 3.5 14.5 8 14.5 8 12 12.5 8 12.5 1.5 8 1.5 8Z" }), _jsx("circle", { cx: "8", cy: "8", r: "2" }), _jsx("path", { d: "M2.5 2.5l11 11" })] }) }));
 }
 /**
- * The coach's hint, a line that opens on its words and the legend of what it draws (D-88): in the helps' card, and on a phone under the board, beside the
- * map, where its drawings are in sight (Zoe).
+ * The coach's hint, a line that opens on its words and the legend of what it draws (D-88): in the helps' card a tinted row behind a bulb, as the tactics',
+ * and on a phone under the board, beside the map, where its drawings are in sight (Zoe).
  */
 export function HintLine({ hint, open, onOpen, text }) {
     const words = text.helpsCard;
-    return (_jsxs("details", { class: "coach-hint", open: open, onToggle: (event) => onOpen(event.currentTarget.open), children: [_jsx("summary", { children: open ? words.hideHint : words.showHint }), _jsx("span", { class: "note", children: _jsx(Marked, { text: hint.text }) }), hint.arrows === undefined && hint.squares === undefined ? null : _jsx(Legend, { review: hint, words: words.drawn })] }));
+    return (_jsxs("details", { class: "coach-hint", open: open, onToggle: (event) => onOpen(event.currentTarget.open), children: [_jsxs("summary", { children: [_jsxs(RowIcon, { children: [_jsx("path", { d: "M5.5 10.5C4.3 9.7 3.5 8.4 3.5 7a4.5 4.5 0 0 1 9 0c0 1.4-.8 2.7-2 3.5V12h-5Z" }), _jsx("path", { d: "M6.5 14.2h3" })] }), open ? words.hideHint : words.showHint] }), _jsx("span", { class: "note", children: _jsx(Marked, { text: hint.text }) }), hint.arrows === undefined && hint.squares === undefined ? null : _jsx(Legend, { review: hint, words: words.drawn })] }));
 }
 /** An icon the mouse holds, while what it shows lasts; a finger, or the keyboard, turns it on and off (D-78). */
 function HoldButton({ on, onHold, title, label, kind, children }) {
@@ -54,11 +54,11 @@ function HoldButton({ on, onHold, title, label, kind, children }) {
     const mouse = (event) => event instanceof PointerEvent && event.pointerType === "mouse";
     return (_jsx("button", { type: "button", class: kind === undefined ? "hold-button" : `hold-button ${kind}`, "aria-pressed": on, "aria-label": label, title: title, onPointerDown: (event) => mouse(event) && onHold(true), onPointerUp: (event) => mouse(event) && onHold(false), onPointerLeave: (event) => mouse(event) && onHold(false), onClick: (event) => !mouse(event) && onHold(!on), children: children }));
 }
-/** The coach's judgment of the player's move: its badge and the move in a line, which opens on its note (D-78, D-88). */
+/** The coach's judgment of the player's move: its badge and the move in a row tinted in the badge's colour, which opens on its note (D-78, D-88). */
 function Judged({ ply, text }) {
     const { badge, note } = ply.review ?? {};
     const head = (_jsxs(_Fragment, { children: [badge === undefined ? _jsx(NoteIcon, {}) : _jsx(BadgeIcon, { badge: badge }), _jsxs("b", { children: [_jsxs("span", { class: "move-number", children: [ply.number, ply.side === "white" ? "." : "..."] }), _jsx(Figurines, { san: ply.san, side: ply.side })] }), " ", badge === undefined ? null : text.badges[badge]] }));
-    return (_jsx("div", { class: `move-note judged ${badge ?? ""}`, children: note === undefined ? _jsx("span", { class: "head", children: head }) : (_jsxs("details", { children: [_jsx("summary", { class: "head", children: head }), _jsx("span", { class: "note", children: _jsx(Marked, { text: note }) })] })) }));
+    return (_jsx("div", { class: `move-note judged ${badge ?? ""}`, style: badge === undefined ? undefined : { "--row": `var(--badge-${badge})` }, children: note === undefined ? _jsx("span", { class: "head", children: head }) : (_jsxs("details", { children: [_jsx("summary", { class: "head", children: head }), _jsx("span", { class: "note", children: _jsx(Marked, { text: note }) })] })) }));
 }
 /**
  * The tactics in lines (D-91): one a kind of fact and a side, its count, red when it threatens the player and green when it is their chance; a click opens

package/dist/page/table/window.js

@@ -2,8 +2,8 @@ import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
 import { useEffect, useState } from "preact/hooks";
 import { Dialog } from "../dialogs/dialog.js";
 import { checkIcon } from "../dialogs/profiles.js";
-/** The chat's window: closed once a chat opens or starts again, the page then saying where it stands. */
-export function ChatDialog({ open, table, settings, onChange, name, onClose, text }) {
+/** The chat's window: closed once a chat opens or starts again, the page then saying where it stands; `review` when it opened to have a game analysed. */
+export function ChatDialog({ open, review = false, table, settings, onChange, name, onClose, text }) {
     const [sending, setSending] = useState(false);
     const [failed, setFailed] = useState(false);
     useEffect(() => setFailed(false), [open]);
@@ -25,20 +25,21 @@ export function ChatDialog({ open, table, settings, onChange, name, onClose, tex
         }
     };
     // While a chat opens or waits to start again, the rows wait too, and the note says why.
+    const chooseNote = review ? words.reviewChoose : words.choose;
     const note = installed.length === 0
         ? words.install(name)
         : busy
-            ? chatState(table, name, text) ?? words.choose
+            ? chatState(table, name, text) ?? chooseNote
             : byHand
                 ? words.byHand(name)
                 : table.chat
                     ? words.restartHint
-                    : words.choose;
+                    : chooseNote;
     const offersChoices = installed.some((host) => host.models.length > 0 || host.efforts.length > 0);
     // The chat at the table started with other choices than the ones kept now: its row starts it again with these, else it only closes the window.
     const started = table.held ? table.started : undefined;
     const changed = (host) => started !== undefined && (chosen(host, "model", settings) !== (started.model ?? "") || chosen(host, "effort", settings) !== (started.effort ?? ""));
-    return (_jsxs(Dialog, { open: open, title: words.title, onClose: onClose, text: text, children: [_jsx("p", { class: "note", children: note }), _jsxs("div", { class: "chat-hosts", role: "group", "aria-label": words.title, children: [offersChoices
+    return (_jsxs(Dialog, { open: open, title: review ? words.reviewTitle : words.title, onClose: onClose, text: text, children: [_jsx("p", { class: "note", children: note }), _jsxs("div", { class: "chat-hosts", role: "group", "aria-label": review ? words.reviewTitle : words.title, children: [offersChoices
                         ? (_jsxs("div", { class: "chat-head", "aria-hidden": "true", children: [_jsx("span", {}), _jsx("span", { children: words.model }), _jsx("span", { children: words.effort })] }))
                         : null, installed.map((host) => {
                         const atTable = table.chat && table.host === host.name;

package/dist/page/talk/talk.js

@@ -19,7 +19,7 @@ export function AiWords({ words, newestFirst, voice }) {
  * The AI's word on the move shown of a game in analysis (D-69), in a bubble under the Torretta beside the AI's name, pointing up at it: the move, its badge by name,
  * and its note when it wrote one; read out as the player steps through the game. The Torretta and the name stay when the move has no word.
  */
-export function AiNote({ ply, opening, closing, summary, reviewing, name, by, mood, voice, text }) {
+export function AiNote({ ply, opening, closing, summary, reviewing, onComplete, name, by, mood, voice, text }) {
     // On a move of the book without the AI's note, the AI reports what the book says: the opening in the title, the variation under it.
     const book = ply?.review?.note === undefined ? opening : undefined;
     const shown = ply?.review ?? (book === undefined ? undefined : { badge: "book" });
@@ -35,7 +35,7 @@ export function AiNote({ ply, opening, closing, summary, reviewing, name, by, mo
     // The Torretta stays in sight through the whole analysis, over its bubbles, which show only where it wrote something.
     return (_jsxs("div", { class: "ai-note", "aria-live": "polite", children: [_jsxs("p", { class: "who", children: [_jsx(Torretta, { size: 36, mood: mood }), _jsxs("span", { class: "signed", children: [name, by === undefined ? null : _jsx("small", { children: signature(by.annotator, by.effort) })] })] }), ply === undefined || shown === undefined ? null : (_jsxs("p", { class: `say move-note ${shown.badge ?? ""}`, children: [_jsxs("span", { class: "head", children: [shown.badge === undefined ? _jsx(NoteIcon, {}) : _jsx(BadgeIcon, { badge: shown.badge }), _jsxs("b", { children: [_jsxs("span", { class: "visually-hidden", children: [ply.number, ply.side === "white" ? "." : "...", ply.san] }), _jsxs("span", { "aria-hidden": "true", children: [_jsxs("span", { class: "move-number", children: [ply.number, ply.side === "white" ? "." : "..."] }), _jsx(Figurines, { san: ply.san, side: ply.side })] })] }), " ", title] }), note === undefined ? null : (_jsx("span", { class: "note", children: _jsx(Marked, { text: note }) })), shown.arrows === undefined && shown.squares === undefined ? null : _jsx(Legend, { review: shown, words: text.drawn })] })), summary === undefined ? null : _jsx(GameReview, { by: name, summary: summary, text: text }), closing === undefined ? null : (_jsx("p", { class: "say closing", children: _jsx(Marked, { text: closing }) })), reviewing === true
                 ? (_jsxs("p", { class: "say reviewing", children: [_jsx("span", { class: "spinner", "aria-hidden": "true" }), text.reviewing(name)] }))
-                : null] }));
+                : null, onComplete === undefined ? null : (_jsxs("p", { class: "say incomplete", children: [_jsx("span", { role: "status", children: text.incomplete }), _jsx("button", { type: "button", title: text.completeHint, "aria-label": text.completeHint, onClick: onComplete, children: text.complete })] }))] }));
 }
 /** The squares and moves in the AI's words, such as e3, Cxe4, 7.Nd4 or O-O: in bold, as the player looks for them on the board. */
 export function Marked({ text }) {

package/dist/page/text.js

@@ -87,7 +87,7 @@ const english = {
     saveMoves: "PGN",
     saveMovesHint: "The moves alone, to open on Lichess or chess.com",
     noGameNow: "No game in progress",
-    analysing: "Analysis in progress",
+    analysing: "Analysis",
     badges: {
         brilliant: "Brilliant",
         great: "Great move",
@@ -115,6 +115,9 @@ const english = {
         mated: (side) => `${side === "white" ? "White" : "Black"} is mated`,
     },
     reviewing: (name) => `${name} is going over the game…`,
+    incomplete: "Analysis not complete",
+    complete: "Complete it",
+    completeHint: "Complete the analysis",
     you: "You",
     ai: "AI",
     sides: { white: "White", black: "Black" },
@@ -170,6 +173,8 @@ const english = {
     table: {
         title: "Who are you playing?",
         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.",
         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",
@@ -494,7 +499,7 @@ const italian = {
     saveMoves: "PGN",
     saveMovesHint: "Solo le mosse, da aprire su Lichess o chess.com",
     noGameNow: "Nessuna partita in corso",
-    analysing: "Analisi in corso",
+    analysing: "Analisi",
     badges: {
         brilliant: "Geniale",
         great: "Ottima mossa",
@@ -522,6 +527,9 @@ const italian = {
         mated: (side) => `Matto al ${side === "white" ? "Bianco" : "Nero"}`,
     },
     reviewing: (name) => `${name} sta analizzando la partita…`,
+    incomplete: "Analisi non completa",
+    complete: "Completa",
+    completeHint: "Completa l'analisi",
     you: "Tu",
     ai: "AI",
     sides: { white: "Bianco", black: "Nero" },
@@ -577,6 +585,8 @@ const italian = {
     table: {
         title: "Contro chi giochi?",
         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'è.",
         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",

package/dist/server/bell/bell.js

@@ -6,6 +6,7 @@ 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 { 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/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

@@ -356,9 +356,12 @@ function analysisShown(served) {
         // 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 reviewing = !isReviewed(record) && (bell.inTurn || (bell.listening && analystOf(chat, analysis.game) !== undefined));
+        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), ...(reviewing ? { reviewing: true } : {}) };
+        return { name, pgn: writePgn(record), book: bookPlies(record), ...state };
     }
     catch {
         // A game gone from the archive is no longer shown.

package/dist/server/page/page.js

@@ -5,7 +5,7 @@ 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/index.js";
@@ -141,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);
         }
     }
@@ -148,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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chesspal",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "Play chess against an AI with a character, and learn with an AI coach: Chesspal keeps the rules, the board, the games and the memory; the AI plays, reasons and talks.",
   "type": "module",
   "bin": {