chesspal 0.2.3 → 0.2.4

package/dist/commands/agents.js

@@ -21,7 +21,8 @@ export function withAnalyst(summary, context, over) {
 /** How the chat has a game over gone over by the analyst agent, on the player's yes or for the game they brought (D-89). */
 export function analystLine(game) {
     return `start the chesspal-analyst agent in the background with the prompt "Analyse${game === undefined ? "" : ` ${game}`}. The player speaks <their language>.": it writes its review on the board `
-        + "page, which shows it at work; tell the player in a word, and when it ends go over the game with them from what it tells you.";
+        + "page, which shows it at work; tell the player in a word, talk the game over with them meanwhile whenever they ask, and when it ends go over it with them "
+        + "from what it tells you.";
 }
 /** How the chat goes over a game the analyst agent has reviewed, or is reviewing: from that review, never with another agent (Stefano). */
 export function reviewedLine(game) {

package/dist/commands/ai-say.d.ts

@@ -1,9 +1,10 @@
 import { z } from "zod";
 import { type GameSummary } from "./game-summary.ts";
+import { type Written } from "./say.ts";
 interface Said {
     /** The game, none when the AI spoke before the first (D-77). */
     game?: GameSummary;
-    words: string[];
+    words: Written[];
     /** The coach yet to start on the player's move that ended the game (D-88). */
     coach?: true;
 }

package/dist/commands/analyse-game.d.ts

@@ -14,6 +14,8 @@ interface MoveFacts {
     /** After it, the pieces at risk of either side when they changed from the line before ("none" once no piece is), and the mates the side to move has; none once the board ends the game. */
     atRisk?: string;
     mates?: readonly string[];
+    /** After it, what the moves of the side to move would do (D-100): forks, double attacks, discovered and double checks, promotions, stalemates and traps. */
+    tactics?: string;
     /** The first move the opening book does not know. */
     outOfBook?: true;
     drawOffer?: true;

package/dist/commands/analyse-game.js

@@ -8,14 +8,15 @@ import { bookOpening, bookReaches } from "./opening-book.js";
 import { defineCommand } from "./registry.js";
 import { speechLine, speechOf } from "./speech.js";
 import { gameToStudy, knownTag, moveNumbers, namedGame, noGameGoingOn } from "./study.js";
-import { balanceText, colourName, riskLine } from "./view.js";
+import { balanceText, colourName, riskLine, tacticsText } from "./view.js";
 // The analyst's instructions, read at the first analysis.
 let analystText;
 /** A game over move by move, for the analyst (D-68): the current one, one of the archive or kept to study, or one the player brings as a PGN, kept to study. */
 export const analyseGame = defineCommand({
     name: "analyse_game",
     description: "Gives a game that is over move by move, to comment it with the player: each move with what it took and the time it took, the material "
-        + "when it changes, the pieces at risk and the mates in one after it, where the game left the opening book, and your comments and plans. Facts "
+        + "when it changes, the pieces at risk, the mates in one and what the next moves would do after it (forks, double attacks, discovered checks, "
+        + "promotions, stalemates and stalemate traps), where the game left the opening book, and your comments and plans. Facts "
         + "only: the judgment is yours. Without game or pgn, the game just over, or else the last one played; game: a name as past_games or study_games "
         + "writes it; pgn: a game the player brings from elsewhere, kept to study in the profile. Never while a game goes on. The first time in a chat "
         + "it also says how to analyse. annotate_game then keeps your badges and notes for the board page. Example: analyse_game {}.",
@@ -145,7 +146,7 @@ function movesOf(record, ai) {
     let inBook = record.tags.FEN === undefined && bookReaches(game.position.fen);
     let before = game.facts;
     let balance = materialOf(game.position.fen).balance;
-    const start = { atRisk: riskLine(before), mates: matesOf(before) };
+    const start = { atRisk: riskLine(before), mates: matesOf(before), tactics: tacticsText(before, game.possibilities, true) };
     // What was at risk on the line before: a move tells it only when it changed.
     let risk = start.atRisk;
     const moves = record.moves.map(({ san, comment }, ply) => {
@@ -170,6 +171,7 @@ function movesOf(record, ai) {
             material: now === balance ? undefined : balanceText(now),
             atRisk: over || risks === risk ? undefined : (risks ?? "none"),
             mates: over ? undefined : matesOf(facts),
+            tactics: over ? undefined : tacticsText(facts, game.possibilities, true),
             outOfBook: outOfBook ? true : undefined,
             drawOffer: comment?.includes("(=)") === true ? true : undefined,
             said: side === ai ? saidIn(comment) : undefined,
@@ -206,7 +208,7 @@ function analysisHead(analysis) {
     const review = analysis.review === undefined ? [] : [`Your review: ${analysis.review}`];
     return [head, ...opening, ...review, `${name}.`, ...start];
 }
-/** 12...Nxe5: took P; spent 0:12, 4:32 left; material White +1; at risk: undefended Black Nf6; mate in one: Qh7#; out of book; you said "…"; your plan: …; ahead -1.5 */
+/** 12...Nxe5: took P; spent 0:12, 4:32 left; material White +1; at risk: undefended Black Nf6; mate in one: Qh7#; tactics: fork Nc7+ (Ke8 Ra8); out of book; you said "…"; your plan: …; ahead -1.5 */
 function moveLine(move) {
     const left = move.left === undefined ? undefined : `${clockText(move.left)} left`;
     const parts = [
@@ -215,6 +217,7 @@ function moveLine(move) {
         move.material === undefined ? undefined : `material ${move.material}`,
         move.atRisk === undefined ? undefined : `at risk: ${move.atRisk}`,
         move.mates === undefined ? undefined : `mate in one: ${move.mates.join(" ")}`,
+        move.tactics === undefined ? undefined : `tactics: ${move.tactics}`,
         move.outOfBook ? "out of book" : undefined,
         move.drawOffer ? "offers a draw" : undefined,
         move.said === undefined ? undefined : `you said "${move.said}"`,

package/dist/commands/annotate-game.d.ts

@@ -10,6 +10,8 @@ interface Annotated {
     /** How many moves took who is ahead after them, and those still without it, as analyse_game numbers them (D-90). */
     estimated: number;
     unestimated: string[];
+    /** The moves whose note the chat corrected with the player, told the analyst at each call: its notes leave them as they are (D-101). */
+    left: string[];
 }
 /** The AI's badges and notes on a game over, and its word on the whole game, written into the game's PGN (D-69). */
 export declare const annotateGame: import("./registry.ts").Command<z.ZodObject<{

package/dist/commands/annotate-game.js

@@ -5,6 +5,7 @@ import { annotatorOf, badges, Game, leadOf, reviewed, reviewOf, withAnnotator, w
 import { gameInAnalysis, rewriteGame, startAnalysis } from "../games/index.js";
 import { analystAgent } from "../host-files/index.js";
 import { gameFolder } from "../profiles/index.js";
+import { analystRuns } from "./agents.js";
 import { arrowsInput, drawingsOf, noteInput, squaresInput } from "./drawings.js";
 import { leadFrom, leadInput } from "./lead-input.js";
 import { defineCommand } from "./registry.js";
@@ -48,6 +49,14 @@ export const annotateGame = defineCommand({
         // would be lost (Federico).
         const caller = await context.caller?.();
         const studied = game === undefined ? gameAnalysed(context) : namedGame(context, game);
+        const folder = gameFolder(context.home());
+        const numbers = moveNumbers(studied.record);
+        // Where the analyst reviews the games, the chat's notes are corrections it made with the player: the analyst, at work then or later, leaves those notes
+        // and is told of them at each call, and the chat is not asked for the analyst's work (D-101, Priya). Only a call the host ties to the chat is its own.
+        const correction = context.chat === true && analystRuns(context) && estimates.length === 0 && summary === undefined && closing === undefined;
+        const analysis = gameInAnalysis(folder);
+        const corrected = context.chat !== true && analysis?.game === studied.name ? analysis.corrected ?? [] : [];
+        let skipped = 0;
         // Every move is checked before the game is written: all or nothing.
         const moves = [...studied.record.moves];
         for (const { move, badge, note, arrows = [], squares = [] } of notes) {
@@ -55,6 +64,10 @@ export const annotateGame = defineCommand({
                 throw new Error(`Give ${move} a badge, a note, or both: arrows and squares go with them. Nothing changed.`);
             }
             const index = indexIn(studied.record, move, "notes");
+            if (corrected.includes(numbers[index])) {
+                skipped += 1;
+                continue;
+            }
             // A note alone on a move of the book keeps its book badge: a fact Chesspal put there, not the AI's judgment.
             const kept = badge ?? (reviewOf(moves[index].comment)?.badge === "book" ? "book" : undefined);
             moves[index] = reviewed(moves[index], { ...(kept === undefined ? {} : { badge: kept }), ...(note === undefined ? {} : { note }), ...drawingsOf(arrows, squares) });
@@ -66,25 +79,25 @@ export const annotateGame = defineCommand({
         // Who reviewed it, as far as the host says it for certain (D-81): on the command line, or by a host that names no model over one that did, as it was.
         const kept = caller === undefined || (caller.hostOnly === true && annotatorOf(studied.record) !== undefined);
         const marked = { ...(kept ? studied.record : withAnnotator(studied.record, caller)), moves };
-        rewriteGame(gameFolder(context.home()), studied.name, summary === undefined && closing === undefined ? marked : withGameReview(marked, { ...(summary === undefined ? {} : { summary }), ...(closing === undefined ? {} : { closing }) }));
-        startAnalysis(gameFolder(context.home()), studied.name, context.now());
-        const numbers = moveNumbers(marked);
+        rewriteGame(folder, studied.name, summary === undefined && closing === undefined ? marked : withGameReview(marked, { ...(summary === undefined ? {} : { summary }), ...(closing === undefined ? {} : { closing }) }));
+        startAnalysis(folder, studied.name, context.now(), false, correction ? notes.map(({ move }) => numbers[indexIn(studied.record, move, "notes")]) : []);
         const bookUnnoted = moves.flatMap((move, index) => {
             const review = reviewOf(move.comment);
             return review?.badge === "book" && review.note === undefined ? [numbers[index]] : [];
         });
         return {
             game: studied.name,
-            marked: notes.length,
+            marked: notes.length - skipped,
             summary: summary !== undefined,
             closing: closing !== undefined,
-            bookUnnoted,
+            bookUnnoted: correction ? [] : bookUnnoted,
             estimated: estimates.length,
             // Asked every time, of an older review too: an analyst whose instructions predate the estimates learns of them here.
-            unestimated: unestimatedMoves(marked, numbers),
+            unestimated: correction ? [] : unestimatedMoves(marked, numbers),
+            left: [...corrected],
         };
     },
-    format: ({ game, marked, summary, closing, bookUnnoted, estimated, unestimated }) => {
+    format: ({ game, marked, summary, closing, bookUnnoted, estimated, unestimated, left }) => {
         const kept = [
             marked === 0 ? undefined : `${marked} ${marked === 1 ? "move" : "moves"} marked`,
             estimated === 0 ? undefined : `who is ahead after ${estimated} ${estimated === 1 ? "move" : "moves"}`,
@@ -100,7 +113,12 @@ export const annotateGame = defineCommand({
         const shown = unestimated.slice(0, unestimatedShown).join(" ");
         const more = unestimated.length > unestimatedShown ? ` and ${unestimated.length - unestimatedShown} more` : "";
         const ahead = unestimated.length === 0 ? [] : [`Who is ahead is still missing after ${shown}${more}: give it with ahead, for the page's bar and chart.`];
-        return [`Kept in ${game}: ${[kept.slice(0, -1).join(", "), kept.at(-1)].filter((part) => part !== "").join(" and ")}. The board page shows them.`, ...book, ...ahead].join("\n");
+        const one = left.length === 1;
+        const corrected = left.length === 0
+            ? []
+            : [`${left.join(" ")} ${one ? "keeps the note" : "keep the notes"} the AI wrote with the player: leave ${one ? "it" : "them"}, and don't contradict ${one ? "it" : "them"} in your summary${summary ? "; if this one does, give it again" : ""}.`];
+        const head = kept.length === 0 ? `Nothing new kept in ${game}.` : `Kept in ${game}: ${[kept.slice(0, -1).join(", "), kept.at(-1)].filter((part) => part !== "").join(" and ")}. The board page shows them.`;
+        return [head, ...corrected, ...book, ...ahead].join("\n");
     },
 });
 /** The moves without who is ahead after them, as analyse_game numbers them: all but the last when the board ended the game there, which says it. */

package/dist/commands/answer-lines.d.ts

@@ -1,5 +1,6 @@
 import { type Side } from "../core/index.ts";
 import { type GameSummary, type LastMove, type MovePlayed } from "./game-summary.ts";
+import type { Written } from "./say.ts";
 /** Where the game stands: the AI's position to decide on, with its last move unless the lines before named it; the player's turn; or how it ended. */
 export declare function positionLines(game: GameSummary, withLastMove?: boolean): string[];
 /** The head of a view: where the game stands, the last move unless the lines before named it, the opening, the material as the player sees it, and the FEN. */
@@ -14,14 +15,17 @@ export declare function shownMove(move: string): string;
 /** The lines after a move, which the line before named: its note, where the game stands, a warning. closingLines end them. */
 export declare function moveLines({ note, game, warning }: MovePlayed): string[];
 /** The last lines of a tool's answer: the player's words from the board page, then the next step, which stays the last line. */
-export declare function closingLines(game: GameSummary | undefined, words?: readonly string[], pageClosed?: boolean): string[];
-/** The player's words from the board page, one line each: lines they broke are joined, so no line of theirs reads as one of Chesspal's. */
-export declare function wordLines(words: readonly string[]): string[];
+export declare function closingLines(game: GameSummary | undefined, words?: readonly Written[], pageClosed?: boolean): string[];
+/**
+ * The player's words from the board page, one line each, in analysis with the move the page showed (D-101): lines they broke are joined, so no line of
+ * theirs reads as one of Chesspal's.
+ */
+export declare function wordLines(words: readonly Written[]): string[];
 /**
  * What the AI does next: the one line every host reads, even where the server's instructions are not shown. Words of the player's ask for an answer. With the
  * board page open in no browser, a new game starts there, never in the chat.
  */
-export declare function nextStep(game: GameSummary | undefined, words?: readonly string[], pageClosed?: boolean): string;
+export declare function nextStep(game: GameSummary | undefined, words?: readonly Written[], pageClosed?: boolean): string;
 /** How a new game starts: the player chooses it in the board page's window, which new_game without choices opens (D-85). */
 export declare const newGameStep = "call new_game without choices: it opens the board page's New game window, where the player chooses the colour, the clock and the level.";
 /** Who plays what, from the AI's side. */

package/dist/commands/answer-lines.js

@@ -13,7 +13,7 @@ export function positionLines(game, withLastMove = true) {
     }
     return [
         ...headLines(game, withLastMove),
-        ...(game.facts === undefined ? [] : (sees(game.level, "tactics") ? compactView : boardView)(game.facts, game.turn)),
+        ...(game.facts === undefined ? [] : viewLines(game.facts, game)),
         ...(game.book === undefined ? [] : [`Book moves, most named lines first: ${game.book.join(", ")}`]),
         ...(game.plan === undefined ? [] : [`Plan: ${game.plan}`]),
         ...(game.thought === undefined ? [] : [thoughtLine(game.thought, game.level)]),
@@ -21,6 +21,14 @@ export function positionLines(game, withLastMove = true) {
         ...(game.helps === "coached" ? [`${helpsLine} ${coachLine}`] : game.helps === "on" ? [helpsLine] : game.helps === "off now" ? [helpsOffLine] : []),
     ];
 }
+/** The view of the AI's position as its level sees it (D-60, D-100): the tactical facts from the club level, the other side's chances from the strong level. */
+function viewLines(facts, game) {
+    if (!sees(game.level, "tactics")) {
+        return boardView(facts, game.turn);
+    }
+    const possible = game.possibilities === undefined ? undefined : { possibilities: game.possibilities, threats: game.threats, strong: sees(game.level, "strategy") };
+    return compactView(facts, game.turn, possible);
+}
 /** The helps turned on: the AI may teach as the analyst does (D-62, D-78), never playing for the player. */
 const helpsLine = "Helps on: the player wants to learn. Tell your intentions, never their best move; draw arrows and squares to show what you say, and write up to "
     + `${talkLimits.aiHelps} characters.`;
@@ -63,9 +71,12 @@ export function moveLines({ note, game, warning }) {
 export function closingLines(game, words = [], pageClosed = false) {
     return [...wordLines(words), nextStep(game, words, pageClosed)];
 }
-/** The player's words from the board page, one line each: lines they broke are joined, so no line of theirs reads as one of Chesspal's. */
+/**
+ * The player's words from the board page, one line each, in analysis with the move the page showed (D-101): lines they broke are joined, so no line of
+ * theirs reads as one of Chesspal's.
+ */
 export function wordLines(words) {
-    return words.map((text) => `Player wrote on the board page: «${text.replace(/\s+/g, " ")}»`);
+    return words.map(({ text, at }) => `Player wrote on the board page${at === undefined ? "" : `, at ${at}`}: «${text.replace(/\s+/g, " ")}»`);
 }
 /**
  * What the AI does next: the one line every host reads, even where the server's instructions are not shown. Words of the player's ask for an answer. With the
@@ -73,6 +84,11 @@ export function wordLines(words) {
  */
 export function nextStep(game, words = [], pageClosed = false) {
     const step = pageClosed ? closedPageGameStep : newGameStep;
+    // Words written on a game in analysis: the chat answers them there, and corrects the review where they show it wrong (D-101).
+    if (words.some((word) => word.at !== undefined) && (game === undefined || game.end !== undefined)) {
+        return "Next: answer the player with ai_say, about the move they were looking at. When they show you something the review missed, first correct that move's "
+            + "note with annotate_game, that move only.";
+    }
     if (game === undefined) {
         return words.length === 0 ? `Next: when the player wants a game, ${step}` : `Next: answer the player with ai_say. When they want a game, ${step}`;
     }

package/dist/commands/coach.js

@@ -202,7 +202,7 @@ function judgedLines({ game }, ply, player) {
         `Their move to judge: ${lastMoves(played, 1)}. The position they played it in:`,
         `FEN: ${before.position.fen}`,
         `Material: ${materialText(materialOf(before.position.fen))}`,
-        ...compactView(before.facts, player),
+        ...compactView(before.facts, player, { possibilities: before.possibilities, threats: before.threats, strong: true }),
         ...(book.length === 0 ? [] : [`Book moves there, most named lines first: ${book.join(", ")}`]),
     ];
     if (ply === record.moves.length) {
@@ -229,7 +229,7 @@ function nowLines(current, folder, player) {
     return [
         "Now, for who is ahead and your hint:",
         `FEN: ${game.position.fen}`,
-        ...compactView(game.facts, player),
+        ...compactView(game.facts, player, { possibilities: game.possibilities, threats: game.threats, strong: true }),
         ...profileLines(game.profile),
         ...(lead === undefined ? [] : [`Who you saw ahead on their turn before: ${leadText(lead)}, ${aheadWords(lead)}`]),
         ...(hint === undefined || hint.position !== plies - 2 ? [] : [`Your hint on their turn before: «${hint.text}»`]),

package/dist/commands/context.d.ts

@@ -43,6 +43,8 @@ export interface Context {
     caller?: () => Promise<Caller | undefined>;
     /** The agent that makes this call of a tool it shares with the chat, as the analyst (D-89); none for the chat, or when it cannot be told. */
     agent?: string;
+    /** The chat makes this call of a tool it shares with an agent, as the host tells it: a caller that cannot be told is not the chat here (Federico). */
+    chat?: true;
 }
 /** Who made a tool call: the model, else the host's name, never what the AI says of itself; the effort only when the host gives it. */
 export interface Caller {

package/dist/commands/delete-review.js

@@ -2,7 +2,7 @@
 // delete, never the AI.
 import { z } from "zod";
 import { isReviewed, unreviewed } from "../core/index.js";
-import { forgetCoach, gameInAnalysis, isOverOnTable, rewriteGame, startAnalysis } from "../games/index.js";
+import { endAnalysis, forgetCoach, gameInAnalysis, isOverOnTable, rewriteGame, startAnalysis } from "../games/index.js";
 import { gameFolder } from "../profiles/index.js";
 import { defineCommand } from "./registry.js";
 import { namedGame } from "./study.js";
@@ -24,8 +24,9 @@ export const deleteReview = defineCommand({
         if (isOverOnTable(folder, name)) {
             forgetCoach(folder);
         }
-        // The page showing the game hears of it, and shows it without its review.
+        // The page showing the game hears of it, and shows it without its review; the chat's corrections go with it.
         if (gameInAnalysis(folder)?.game === name) {
+            endAnalysis(folder);
             startAnalysis(folder, name, context.now());
         }
         return { game: name, reviewed: isReviewed(record) };

package/dist/commands/game-summary.d.ts

@@ -1,6 +1,7 @@
-import { type AiLevel, type Facts, type GameRecord, type MoodNow, type Side, type Square } from "../core/index.ts";
+import { type AiLevel, type Chances, type Facts, type GameRecord, type MoodNow, type Possibilities, type Side, type Square } from "../core/index.ts";
 import { type CurrentGame, type Speaker, type Thought } from "../games/index.ts";
 import { type ClockSummary } from "./clock.ts";
+import type { Written } from "./say.ts";
 /** The current game, as the commands give it. */
 export interface GameSummary {
     ai: Side;
@@ -17,6 +18,10 @@ export interface GameSummary {
     opening?: string;
     /** When the AI is to move: the facts of the position (D-26); below the club level, only the check and the legal moves of each piece are shown. */
     facts?: Facts;
+    /** When the AI is to move, from the club level up: what the moves would do (D-100). */
+    possibilities?: Possibilities;
+    /** With the possibilities, out of check: what the player's moves would do if they were to move. */
+    threats?: Chances;
     /** When the AI is to move at the master level, in the book: the moves it knows from the position (D-15, D-60). */
     book?: readonly string[];
     /** When the AI is to move: the plan it wrote last. */
@@ -58,7 +63,7 @@ export interface MovePlayed {
     /** What went wrong after the move was saved, such as the archive not written. */
     warning?: string;
     /** What the player wrote on the board page that the AI has not been given yet. */
-    words?: string[];
+    words?: Written[];
 }
 /** The game as the commands tell it; a game over with the name it has in the archive, when it is there. */
 export declare function summaryOf(current: CurrentGame, now: Date, archive?: string): GameSummary;

package/dist/commands/game-summary.js

@@ -90,6 +90,13 @@ function judgedBefore(current) {
 function addAiFacts(summary, { game }) {
     const plan = currentPlan(game.record);
     summary.facts = game.facts;
+    if (sees(summary.level, "tactics")) {
+        summary.possibilities = game.possibilities;
+        const { threats } = game;
+        if (threats !== undefined) {
+            summary.threats = threats;
+        }
+    }
     if (sees(summary.level, "theory")) {
         const book = knownMoves(summary.fen);
         if (book.length > 0) {

package/dist/commands/index.d.ts

@@ -13,6 +13,6 @@ export { playMove, PositionChanged, positionIn, samePosition } from "./play-move
 export { chooseDrawnAvatar, GameGoingOn, newProfile, setAccounts, useProfile } from "./profiles.ts";
 export { type AnyCommand, baseType, type Command, commandLineFieldProblem, inputProblems, isBoolean, isList, takesNumbers } from "./registry.ts";
 export { say } from "./say.ts";
-export { gameToStudy, namedGame } from "./study.ts";
+export { gameToStudy, namedGame, shownPosition } from "./study.ts";
 /** Every command of Chesspal, in the order the command line lists them and the MCP server offers them. */
 export declare const commands: AnyCommand[];

package/dist/commands/index.js

@@ -34,7 +34,7 @@ export { playMove, PositionChanged, positionIn, samePosition } from "./play-move
 export { chooseDrawnAvatar, GameGoingOn, newProfile, setAccounts, useProfile } from "./profiles.js";
 export { baseType, commandLineFieldProblem, inputProblems, isBoolean, isList, takesNumbers } from "./registry.js";
 export { say } from "./say.js";
-export { gameToStudy, namedGame } from "./study.js";
+export { gameToStudy, namedGame, shownPosition } from "./study.js";
 /** Every command of Chesspal, in the order the command line lists them and the MCP server offers them. */
 export const commands = [
     init,

package/dist/commands/look.d.ts

@@ -1,16 +1,20 @@
 import { z } from "zod";
-import { type Facts, type Side } from "../core/index.ts";
+import { type Chances, type Facts, type Possibilities, type Side } from "../core/index.ts";
 import { type GameSummary } from "./game-summary.ts";
-/** The game with the facts of its position, whoever is to move. */
+import { type Written } from "./say.ts";
+/** The game with the facts, the possibilities and the threats of its position, whoever is to move. */
 type Viewed = GameSummary & {
     facts: Facts;
+    possibilities: Possibilities;
 };
-/** A position of a game studied (D-68): where it stands, and its facts. */
+/** A position of a game studied (D-68): where it stands, its facts, its possibilities and the threats. */
 interface StudyView {
     where: string;
     turn: Side;
     fen: string;
     facts: Facts;
+    possibilities: Possibilities;
+    threats: Chances | undefined;
 }
 /** The whole view (D-26), when the compact one after the player's move is not enough; or the board for the player, where the host does not show it (D-36). */
 export declare const look: import("./registry.ts").Command<z.ZodObject<{
@@ -23,9 +27,9 @@ export declare const look: import("./registry.ts").Command<z.ZodObject<{
     board: string;
 } | {
     game: Viewed;
-    words: string[];
+    words: Written[];
 } | {
     study: StudyView;
-    words: string[];
+    words: Written[];
 }>;
 export {};

package/dist/commands/look.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { boardText, materialOf } from "../core/index.js";
+import { boardText, materialOf, sees } from "../core/index.js";
 import { analystAgent } from "../host-files/index.js";
 import { gameFolder } from "../profiles/index.js";
 import { headLines, wordLines } from "./answer-lines.js";
@@ -8,7 +8,7 @@ import { summaryOf } from "./game-summary.js";
 import { refuseUnseen } from "./levels.js";
 import { defineCommand } from "./registry.js";
 import { newWords } from "./say.js";
-import { gameToStudy, positionAfter, positionLine, studyInput } from "./study.js";
+import { gameShown, positionAfter, positionLine, studyInput } from "./study.js";
 import { fullView, materialText } from "./view.js";
 /** The whole view (D-26), when the compact one after the player's move is not enough; or the board for the player, where the host does not show it (D-36). */
 export const look = defineCommand({
@@ -34,31 +34,41 @@ export const look = defineCommand({
         if (only !== "board") {
             refuseUnseen(current, "tactics", 'look without only: "board"');
         }
-        return only === "board" ? { board: boardText(current.game.position.fen) } : { game: { ...summaryOf(current, context.now()), facts: current.game.facts }, words: newWords(context) };
+        if (only === "board") {
+            return { board: boardText(current.game.position.fen) };
+        }
+        const { threats } = current.game;
+        const viewed = { ...summaryOf(current, context.now()), facts: current.game.facts, possibilities: current.game.possibilities };
+        return { game: threats === undefined ? viewed : { ...viewed, threats }, words: newWords(context) };
     },
     format: (look) => {
         if ("board" in look) {
             return look.board;
         }
-        return [...("game" in look ? [...headLines(look.game), ...fullView(look.game.facts, look.game.turn)] : studyLines(look.study)), ...wordLines(look.words)].join("\n");
+        return [...("game" in look ? gameLines(look.game) : studyLines(look.study)), ...wordLines(look.words)].join("\n");
     },
 });
 /** A position of a game over, as the view of the game going on gives it. */
 function studyLook(context, only, name, move) {
-    const studied = gameToStudy(context, name);
+    const studied = gameShown(context, name);
     const at = positionAfter(studied.record, move);
     const { position } = at.game;
     if (only === "board") {
         return { board: boardText(position.fen) };
     }
-    return { study: { where: positionLine(at, studied.name), turn: position.turn, fen: position.fen, facts: at.game.facts }, words: newWords(context) };
+    const view = { where: positionLine(at, studied.name), turn: position.turn, fen: position.fen, facts: at.game.facts, possibilities: at.game.possibilities, threats: at.game.threats };
+    return { study: view, words: newWords(context) };
+}
+/** The game going on: its head and the whole view, with the other side's chances from the strong level (D-100). */
+function gameLines(game) {
+    return [...headLines(game), ...fullView(game.facts, game.turn, { possibilities: game.possibilities, threats: game.threats, strong: sees(game.level, "strategy") })];
 }
-/** Where the position stands, the material, the FEN, and the whole view. */
-function studyLines({ where, turn, fen, facts }) {
+/** Where the position stands, the material, the FEN, and the whole view, with every possibility, as the analyst sees it. */
+function studyLines({ where, turn, fen, facts, possibilities, threats }) {
     return [
         where,
         `Material: ${materialText(materialOf(fen))}`,
         `FEN: ${fen}`,
-        ...fullView(facts, turn),
+        ...fullView(facts, turn, { possibilities, threats, strong: true }),
     ];
 }

package/dist/commands/ponder.js

@@ -156,7 +156,7 @@ function startOf(current) {
     const line = [
         `Position ${game.record.moves.length}: the player (${colourName(player)}) to move, move ${game.position.moveNumber}; you play ${colourName(ai)} ${levelText(level)}.`,
         `FEN: ${game.position.fen}`,
-        ...(sees(level, "tactics") ? compactView : boardView)(game.facts, player),
+        ...(sees(level, "tactics") ? compactView(game.facts, player, { possibilities: game.possibilities, threats: game.threats, strong: sees(level, "strategy") }) : boardView(game.facts, player)),
     ].join("\n");
     const said = talk.slice(-3).map((spoken) => `${spoken.who === "ai" ? "You" : "Player"}: «${spoken.text.replace(/\s+/g, " ")}»`);
     return {

package/dist/commands/position.js

@@ -5,7 +5,7 @@ import { gameFolder } from "../profiles/index.js";
 import { gameAt } from "./clock.js";
 import { refuseUnseen } from "./levels.js";
 import { defineCommand } from "./registry.js";
-import { gameToStudy, positionAfter, positionLine, studyInput } from "./study.js";
+import { gameShown, positionAfter, positionLine, studyInput } from "./study.js";
 import { colourName, materialText } from "./view.js";
 /** The positional profile of the game in progress (D-19), or of any position of a game over (D-68): separate facts, never a score. */
 export const position = defineCommand({
@@ -21,7 +21,7 @@ export const position = defineCommand({
     sharedWith: [analystAgent],
     run: ({ game, move }, context) => {
         if (game !== undefined || move !== undefined) {
-            const studied = gameToStudy(context, game);
+            const studied = gameShown(context, game);
             const at = positionAfter(studied.record, move);
             return { ...at.game.profile, where: positionLine(at, studied.name) };
         }

package/dist/commands/say.d.ts

@@ -1,16 +1,21 @@
 import { type Mood } from "../core/index.ts";
-import { type Sayer, type Talk, type Words } from "../games/index.ts";
+import { type Sayer, type Shown, type Talk, type Words } from "../games/index.ts";
 import type { Context } from "./context.ts";
 /**
  * Adds a line to the talk of the current game, going on or just over, and saves it; the AI's mood once the game is over, which the archive keeps too (D-70).
  * With no game the line goes in the talk before it (D-77). A line refused changes nothing: it throws, in words for whoever spoke.
  */
-export declare function say(folder: string, who: Sayer, text: string, at: Date, mood?: Mood): Talk;
+export declare function say(folder: string, who: Sayer, text: string, at: Date, mood?: Mood, shown?: Shown): Talk;
+/** Words of the player's as the AI is given them: their text, and in analysis the move the board page showed as they wrote, 52...♚f6 (D-101). */
+export interface Written {
+    readonly text: string;
+    readonly at?: string;
+}
 /** What the player wrote on the board page that the AI has not been given in this chat, given now: each game tool gives it once; never to an agent (D-89). */
-export declare function newWords(context: Context): string[];
+export declare function newWords(context: Context): Written[];
 /** Every word of the player's the AI has not answered, given again: status gives them all, for a chat that lost them in a summary. */
-export declare function unansweredWords(context: Context): string[];
+export declare function unansweredWords(context: Context): Written[];
 /** What the player wrote on the board page that the AI has not been given in this chat, still to give: the AI's move would count as its answer. */
 export declare function waitingWords(context: Context, given?: ReadonlySet<string>): Words[];
-/** Gives the words to the AI: from now on they count as given in this chat. Their text. */
-export declare function give(context: Context, words: readonly Words[]): string[];
+/** Gives the words to the AI: from now on they count as given in this chat. Their text, with the move shown in analysis. */
+export declare function give(context: Context, words: readonly Words[]): Written[];

package/dist/commands/say.js

@@ -1,22 +1,24 @@
 // The talk on the board page (D-51): a line of the player's or the AI's, saved with the game, and the player's words the AI has not been given yet.
 import { endWithMood } from "../core/index.js";
-import { archiveEnded, endOf, loadGame, loadTableTalk, saveGame, saveTableTalk, talkLimits, talkLine, unheardWords } from "../games/index.js";
+import { archiveEnded, endOf, gameInAnalysis, loadGame, loadTableTalk, saveGame, saveTableTalk, talkLimits, talkLine, unheardWords } from "../games/index.js";
 import { gameFolder, helpsIn } from "../profiles/index.js";
+import { shownMove } from "./answer-lines.js";
 import { gameAt } from "./clock.js";
 /**
  * Adds a line to the talk of the current game, going on or just over, and saves it; the AI's mood once the game is over, which the archive keeps too (D-70).
  * With no game the line goes in the talk before it (D-77). A line refused changes nothing: it throws, in words for whoever spoke.
  */
-export function say(folder, who, text, at, mood) {
+export function say(folder, who, text, at, mood, shown) {
     const current = gameAt(folder, at);
     if (current === undefined) {
-        return sayAtTable(folder, who, text, at, mood);
+        return sayAtTable(folder, who, text, at, mood, shown);
     }
-    if (mood !== undefined && endOf(current.game) === undefined) {
+    const going = endOf(current.game) === undefined;
+    if (mood !== undefined && going) {
         throw new Error("While the game goes on your mood comes with ai_move: say it without mood. Nothing changed.");
     }
-    // With the helps on the AI writes as long as the analyst (D-78).
-    current.talk.push(talkLine(current, who, text, at, undefined, aiMost(folder, who, text)));
+    // With the helps on the AI writes as long as the analyst (D-78), and once the game is over as long, to talk it over (D-101).
+    current.talk.push(talkLine(current, who, text, at, undefined, aiMost(folder, who, text, going), shown));
     if (mood !== undefined) {
         endWithMood(current.game, mood);
     }
@@ -45,7 +47,7 @@ export function waitingWords(context, given = context.given) {
         return [];
     }
 }
-/** Gives the words to the AI: from now on they count as given in this chat. Their text. */
+/** Gives the words to the AI: from now on they count as given in this chat. Their text, with the move shown in analysis. */
 export function give(context, words) {
     const before = context.given.size;
     for (const { key } of words) {
@@ -54,14 +56,19 @@ export function give(context, words) {
     if (context.given.size > before) {
         context.heard?.();
     }
-    return words.map(({ text }) => text);
+    const analysed = words.some((word) => word.shown !== undefined) ? gameInAnalysis(gameFolder(context.home()))?.game : undefined;
+    return words.map(({ text, shown }) => shown === undefined ? { text } : { text, at: placeOf(shown, analysed) });
 }
-/** The most a line of the AI's may hold in the games of `folder`: an analyst's note with the helps on (D-78); a longer one with them off is refused. */
-function aiMost(folder, who, text) {
+/** Where the page stood: the move shown, as the player saw it, or the start; with the game's name when the page shows another now. */
+function placeOf({ game, move }, analysed) {
+    return `${move === undefined ? "the start" : shownMove(move)}${game === analysed ? "" : ` of ${game}`}`;
+}
+/** The most a line of the AI's may hold in the games of `folder`: an analyst's note with the helps on (D-78), or with no game going on (D-101); a longer one is refused. */
+function aiMost(folder, who, text, going) {
     if (who !== "ai") {
         return talkLimits.ai;
     }
-    if (helpsIn(folder)) {
+    if (!going || helpsIn(folder)) {
         return talkLimits.aiHelps;
     }
     if (text.trim().length > talkLimits.ai) {
@@ -70,7 +77,7 @@ function aiMost(folder, who, text) {
     return talkLimits.ai;
 }
 /** A line of the talk with no game, which starts it the first time; no mood, which only the end of a game takes. */
-function sayAtTable(folder, who, text, at, mood) {
+function sayAtTable(folder, who, text, at, mood, shown) {
     if (who === "agent") {
         throw new Error("There is no game to think on. Nothing changed.");
     }
@@ -78,7 +85,8 @@ function sayAtTable(folder, who, text, at, mood) {
         throw new Error("There is no game: a mood goes with a game's end. Say it without mood. Nothing changed.");
     }
     const before = loadTableTalk(folder);
-    const table = { started: before.started === "" ? at.toISOString() : before.started, talk: [...before.talk, talkLine(before, who, text, at, undefined, aiMost(folder, who, text))] };
+    const line = talkLine(before, who, text, at, undefined, aiMost(folder, who, text, false), shown);
+    const table = { started: before.started === "" ? at.toISOString() : before.started, talk: [...before.talk, line] };
     saveTableTalk(folder, table);
     return table;
 }