Bilan : ne se redessine que si ce qu'il montre change ; le test attend son mini-plateau

Les analyses de l'ordinateur et les chances de gagner, rangées en
arrière-plan pour l'écran d'analyse, redessinaient tout le bilan, et son
mini-plateau disparaissait le temps d'être redessiné.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Makefile

@@ -127,8 +127,9 @@ SITE_ICONS := icone.svg icone-192.png icone-512.png icone-maskable-192.png icone
 #   docs/identite/logo/ (une seule source, ADR 0010) ;
 # - l'application compilée (build/web/src/) sous app/ ;
 # - le moteur sous wasm/ ;
-# - les copies du glossaire, des scénarios et du tutoriel sous docs/, lues par
-#   l'aide et le tutoriel de l'application (ADR 0008 : jamais commitées
+# - les copies du glossaire, des scénarios, du tutoriel et des phrases du
+#   maître sous docs/, lues par l'aide, le tutoriel et le conseil du maître
+#   (ADR 0008 : jamais commitées
 #   ailleurs) ;
 # - version.json (commit publié) ;
 # - sw.js, complété par la liste de tous ces fichiers (scripts/service-worker.sh).
@@ -141,7 +142,7 @@ site: engine-wasm web ## Assemble le site publié dans build/site/
 	cp -r $(BUILD_DIR)/web/src $(BUILD_DIR)/site/app
 	cp $(BUILD_DIR)/wasm/engine.mjs $(BUILD_DIR)/wasm/engine.wasm $(BUILD_DIR)/wasm/engine.data \
 		$(BUILD_DIR)/wasm/positions.json $(BUILD_DIR)/site/wasm/
-	cp -r docs/glossaire docs/scenarios docs/tutoriel $(BUILD_DIR)/site/docs/
+	cp -r docs/glossaire docs/scenarios docs/tutoriel docs/maitre $(BUILD_DIR)/site/docs/
 	printf '{"commit": "%s", "dirty": %s}\n' "$$(git rev-parse HEAD)" \
 		"$$(git diff --quiet HEAD && echo false || echo true)" > $(BUILD_DIR)/site/version.json
 	scripts/service-worker.sh $(BUILD_DIR)/site

app/src/domain/analysis/analyse.ts

@@ -0,0 +1,190 @@
+// L'analyse des décisions du joueur par le moteur, pour le conseil du
+// maître (étape 1d, ADR 0011) et le bilan de fin de partie (1e).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Tout vient du moteur : l'analyse du coup joué (rang, meilleur coup, équité
+// perdue, appréciation), le classement des coups, l'analyse de la décision
+// de videau, et les plateaux décodés, où se lisent les pions frappés et les
+// points faits. L'application lance ces analyses sur un second moteur, en
+// arrière-plan : elles ne retardent jamais la partie.
+
+import { ADVICE_VERSION, type Advice, type AdvisedMove, type MoveFacts } from "../game/advice.js";
+import type { BoardSide, CubeAction, Engine, EvaluatedMove, Ply } from "../game/engine.js";
+import { currentLine, type GameEvent, type GameJournal } from "../game/events.js";
+import { engineCube, STANDARD_PLY } from "../game/game.js";
+import { otherSide, type Side } from "../game/side.js";
+import { replay } from "../game/state.js";
+
+/** Niveau de l'analyse : 2 plis, comme l'analyse de partie de gnubg par
+ * défaut, et le niveau « standard » (ADR 0009). */
+export const ANALYSIS_PLY: Ply = STANDARD_PLY;
+
+/** Nombre de coups gardés du classement du moteur, pour « Voir les
+ * chiffres du moteur ». */
+export const RANKING_SIZE = 5;
+
+/**
+ * Les décisions du joueur à analyser parmi des événements : ses coups (pas
+ * un tour passé faute de coup possible), ses jets (il aurait pu doubler
+ * avant), ses doubles et ses réponses aux doubles de l'ordinateur.
+ */
+export function playerDecisions(events: readonly GameEvent[]): GameEvent[] {
+    return decisionsOf(events, "player");
+}
+
+/** Les décisions de side parmi des événements, comme playerDecisions. */
+export function decisionsOf(events: readonly GameEvent[], side: Side): GameEvent[] {
+    return events.filter((event) => {
+        switch (event.type) {
+            case "MovePlayed":
+                return event.side === side && event.halfMoves.length > 0;
+            case "DiceRolled":
+            case "CubeOffered":
+            case "CubeTaken":
+            case "CubeDropped":
+                return event.side === side;
+            default:
+                return false;
+        }
+    });
+}
+
+/** Ce qu'on demande à l'analyse d'une décision. */
+export interface DecisionOptions {
+    /** Niveau de l'analyse ; ANALYSIS_PLY par défaut. */
+    readonly ply?: Ply;
+    /** Le camp qui décide ; le joueur par défaut. Le conseil est alors vu
+     * de ce camp (sa position, ses coups). */
+    readonly side?: Side;
+    /** Garder le classement des coups (une seconde analyse) ; oui par
+     * défaut. L'analyse des coups de l'ordinateur s'en passe. */
+    readonly ranking?: boolean;
+}
+
+/**
+ * Le conseil du moteur sur la décision eventId du joueur (ou du camp
+ * options.side) ; null s'il n'y a rien à analyser (pas une décision de ce
+ * camp, aucun coup possible, videau inaccessible ou position de départ pour
+ * gnubg).
+ */
+export async function analyseDecision(
+    engine: Engine,
+    journal: GameJournal,
+    eventId: string,
+    options: DecisionOptions = {},
+): Promise<Advice | null> {
+    const ply = options.ply ?? ANALYSIS_PLY;
+    const side = options.side ?? "player";
+    const line = currentLine({ ...journal, head: eventId });
+    const event = line.at(-1);
+    if (event === undefined || decisionsOf([event], side).length === 0) {
+        return null;
+    }
+    const earlier = line.slice(0, -1);
+    const before = replay(earlier);
+    if (event.type === "MovePlayed") {
+        if (before.roll === null) {
+            return null;
+        }
+        const cube = engineCube(before, side);
+        // Le coup joué est enregistré vu de l'adversaire : le moteur donne
+        // la même position vue de celui qui l'a joué.
+        const after = await engine.board(event.position, engineCube(before, otherSide(side)));
+        const analysis = await engine.analyseMove(
+            before.position,
+            cube,
+            before.roll,
+            after.swappedPosition,
+            ply,
+        );
+        if (analysis === null) {
+            return null;
+        }
+        const ranking =
+            options.ranking === false
+                ? []
+                : await engine.rankMoves(before.position, cube, before.roll, ply);
+        const start = await engine.board(before.position, cube);
+        const facts = async (move: EvaluatedMove) =>
+            factsOf(start.onRoll, start.opponent, await engine.board(move.position, cube));
+        return {
+            version: ADVICE_VERSION,
+            kind: "move",
+            eventId,
+            ply,
+            position: before.position,
+            roll: before.roll,
+            opening: !earlier.some((e) => e.type === "MovePlayed"),
+            moveCount: analysis.moveCount,
+            rank: analysis.rank,
+            played: advised(analysis.played),
+            best: advised(analysis.best),
+            playedFacts: await facts(analysis.played),
+            bestFacts: await facts(analysis.best),
+            ranking: ranking.slice(0, RANKING_SIZE).map(advised),
+            equityLoss: analysis.equityLoss,
+            skill: analysis.skill,
+        };
+    }
+    let action: CubeAction;
+    let decider: Side = side;
+    if (event.type === "DiceRolled") {
+        if (before.phase !== "rolling") {
+            return null;
+        }
+        action = "noDouble";
+    } else if (event.type === "CubeOffered") {
+        action = "double";
+    } else {
+        action = event.type === "CubeTaken" ? "take" : "pass";
+        decider = otherSide(side);
+    }
+    const analysis = await engine.analyseCube(
+        before.position,
+        engineCube(before, decider),
+        action,
+        ply,
+    );
+    if (!analysis.analysed || analysis.equities === null) {
+        return null;
+    }
+    return {
+        version: ADVICE_VERSION,
+        kind: "cube",
+        eventId,
+        ply,
+        action,
+        position: before.position,
+        equities: analysis.equities,
+        equityLoss: analysis.equityLoss,
+        skill: analysis.skill,
+    };
+}
+
+function advised(move: EvaluatedMove): AdvisedMove {
+    return {
+        notation: move.notation,
+        halfMoves: move.halfMoves.map((h) => ({ from: h.from, to: h.to })),
+        equity: move.equity,
+        ply: move.ply,
+    };
+}
+
+/** Ce que le coup a changé sur le plateau, lu sur les plateaux du moteur
+ * (vus du joueur) : pions adverses envoyés sur la barre, cases où le
+ * joueur a désormais deux pions ou plus. */
+function factsOf(
+    mine: BoardSide,
+    theirs: BoardSide,
+    after: { readonly onRoll: BoardSide; readonly opponent: BoardSide },
+): MoveFacts {
+    const madePoints: number[] = [];
+    for (let i = 0; i < 24; i++) {
+        if ((mine.points[i] ?? 0) < 2 && (after.onRoll.points[i] ?? 0) >= 2) {
+            madePoints.push(i + 1);
+        }
+    }
+    return { hits: Math.max(0, after.opponent.bar - theirs.bar), madePoints };
+}

app/src/domain/analysis/game-analysis.ts

@@ -0,0 +1,579 @@
+// L'analyse d'une partie (étape 1e) : ce qui manque à analyser, le calcul
+// de chaque analyse par le moteur, et les chiffres du bilan à la manière de
+// GNU Backgammon (taux d'erreur, chance, résultat corrigé de la chance).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Tout ce qui juge le jeu vient du moteur : l'analyse de chaque décision
+// (équité perdue, appréciation), la chance de chaque jet, l'évaluation des
+// positions. Ce module ne fait que les ranger et les additionner, comme le
+// fait gnubg dans ses statistiques de partie. Sources, dans gnubg 1.08.003
+// (commit 14b67984, ADR 0005), fichiers analysis.c et formatgs.c :
+// - updateStatcontext (analysis.c, l. 304-596) : les erreurs de chaque
+//   décision et leur nombre ;
+// - getMWCFromError (analysis.c, l. 1432-1472) : le taux d'erreur ;
+// - GetRating et arThrsRating (analysis.c, l. 83-101) : le classement ;
+// - formatgs.c, l. 348-374 et getLuckRating (analysis.c, l. 1757) : la
+//   chance par coup et son appréciation ;
+// - arLuckAdj (analysis.c, l. 304-330 et 405-414) : le résultat corrigé de
+//   la chance.
+// Les tâches d'analyse sont indépendantes : l'application les lance une à
+// une sur le second moteur, en arrière-plan, et peut s'arrêter entre deux.
+
+import {
+    type Advice,
+    type CubeAdvice,
+    type MoveAdvice,
+    type Verdict,
+    verdictOf,
+} from "../game/advice.js";
+import type { Engine, LuckRating } from "../game/engine.js";
+import { LUCK_THRESHOLDS } from "../game/engine.js";
+import {
+    currentLine,
+    type GameEnded,
+    type GameEvent,
+    type GameJournal,
+    type MovePlayed,
+    withAdvice,
+    withReview,
+} from "../game/events.js";
+import { engineCube } from "../game/game.js";
+import { COMPUTER_LEVELS, type ComputerLevel } from "../game/level.js";
+import { emptyReview, type GameReview } from "../game/review.js";
+import type { Roll } from "../game/roll.js";
+import type { Side } from "../game/side.js";
+import { applyEvent, replay } from "../game/state.js";
+import { ANALYSIS_PLY, analyseDecision, decisionsOf } from "./analyse.js";
+
+// ------------------------------------------------------------ Les tours
+
+/**
+ * Un tour de la partie : ce qu'un camp a fait quand il avait la main
+ * (doubler ou non, lancer, jouer), avec la réponse de l'adversaire à son
+ * double. Les tours sont numérotés à partir de 1 ; c'est le « coup » de
+ * l'écran d'analyse (#/parties/<id>/analyse/<n>).
+ */
+export interface Turn {
+    readonly number: number;
+    /** Le camp qui avait la main. */
+    readonly side: Side;
+    /** Le jet joué (null : le tour s'est fini sur un double passé). */
+    readonly roll: Roll | null;
+    /** Le coup joué (null : double passé). */
+    readonly move: MovePlayed | null;
+    /** Les événements du tour, dans l'ordre (sans la fin de partie). */
+    readonly events: readonly GameEvent[];
+    /** La fin de partie, si elle suit ce tour. */
+    readonly end: GameEnded | null;
+}
+
+/** Les tours d'une ligne de jeu (événements du début à la fin). */
+export function turnsOf(line: readonly GameEvent[]): Turn[] {
+    const turns: Turn[] = [];
+    let bucket: GameEvent[] = [];
+    let state = replay([]);
+    for (const event of line) {
+        const before = state;
+        state = applyEvent(state, event);
+        if (event.type === "GameStarted") {
+            continue;
+        }
+        if (event.type === "GameEnded") {
+            const last = turns.at(-1);
+            if (bucket.length === 0 && last !== undefined) {
+                turns[turns.length - 1] = { ...last, end: event };
+            } else if (bucket.length > 0) {
+                const offer = bucket.find((e) => e.type === "CubeOffered");
+                const side = offer?.type === "CubeOffered" ? offer.side : (before.turn ?? "player");
+                turns.push(makeTurn(turns.length + 1, side, bucket, null, event));
+            }
+            bucket = [];
+            continue;
+        }
+        bucket.push(event);
+        if (event.type === "MovePlayed") {
+            turns.push(makeTurn(turns.length + 1, event.side, bucket, event, null));
+            bucket = [];
+        }
+    }
+    return turns;
+}
+
+function makeTurn(
+    number: number,
+    side: Side,
+    events: readonly GameEvent[],
+    move: MovePlayed | null,
+    end: GameEnded | null,
+): Turn {
+    const rolled = move === null ? undefined : events.findLast((e) => e.type === "DiceRolled");
+    return {
+        number,
+        side,
+        roll: rolled?.type === "DiceRolled" ? rolled.roll : null,
+        move,
+        events,
+        end,
+    };
+}
+
+/** Les tours de la ligne courante d'un journal. */
+export function gameTurns(journal: GameJournal): Turn[] {
+    return turnsOf(currentLine(journal));
+}
+
+// --------------------------------------------- Ce qui reste à analyser
+
+/** Une analyse à demander au moteur. */
+export type AnalysisTask =
+    /** Une décision (coup ou videau) d'un camp. */
+    | { readonly kind: "decision"; readonly side: Side; readonly eventId: string }
+    /** La chance d'un jet. */
+    | { readonly kind: "luck"; readonly eventId: string }
+    /** Les chances de gagner du joueur après un coup. */
+    | { readonly kind: "chance"; readonly eventId: string };
+
+/** L'analyse de partie du journal, au niveau d'analyse ; vide s'il n'y en
+ * a pas encore (ou à un autre niveau). */
+export function reviewOf(journal: GameJournal): GameReview {
+    const review = journal.review;
+    return review !== undefined && review.ply === ANALYSIS_PLY ? review : emptyReview(ANALYSIS_PLY);
+}
+
+/**
+ * Ce qui reste à analyser sur la ligne courante, dans l'ordre où le bilan
+ * en a besoin : les décisions du joueur (celles d'avant l'étape 1d, ou
+ * dont l'analyse est arrivée trop tard), la chance de chaque jet, puis,
+ * pour l'écran d'analyse, les décisions de l'ordinateur et les chances de
+ * gagner après chaque coup.
+ */
+export function missingAnalyses(journal: GameJournal): AnalysisTask[] {
+    const line = currentLine(journal);
+    const review = reviewOf(journal);
+    const skipped = new Set(review.unanalysed);
+    const advice = journal.advice ?? {};
+    const tasks: AnalysisTask[] = [];
+    for (const event of decisionsOf(line, "player")) {
+        if (advice[event.id] === undefined && !skipped.has(event.id)) {
+            tasks.push({ kind: "decision", side: "player", eventId: event.id });
+        }
+    }
+    for (const event of luckyRolls(line)) {
+        if (review.luck[event.id] === undefined) {
+            tasks.push({ kind: "luck", eventId: event.id });
+        }
+    }
+    for (const event of decisionsOf(line, "computer")) {
+        if (review.computer[event.id] === undefined && !skipped.has(event.id)) {
+            tasks.push({ kind: "decision", side: "computer", eventId: event.id });
+        }
+    }
+    for (const event of line) {
+        if (event.type === "MovePlayed" && review.winChances[event.id] === undefined) {
+            tasks.push({ kind: "chance", eventId: event.id });
+        }
+    }
+    return tasks;
+}
+
+/** Ce qu'il faut au bilan : toutes les décisions du joueur et la chance
+ * de tous les jets. */
+export function readyForSummary(journal: GameJournal): boolean {
+    return missingAnalyses(journal).every(
+        (task) => task.kind === "chance" || (task.kind === "decision" && task.side === "computer"),
+    );
+}
+
+/** Les jets qui ont une chance : tous ceux d'un camp, et le jet
+ * d'ouverture qui désigne le premier joueur (pas une égalité, qui se
+ * relance). */
+function luckyRolls(line: readonly GameEvent[]): GameEvent[] {
+    const rolls: GameEvent[] = [];
+    let state = replay([]);
+    for (const event of line) {
+        const before = state;
+        state = applyEvent(state, event);
+        if (event.type !== "DiceRolled") {
+            continue;
+        }
+        if (event.side !== null || (before.phase === "opening" && state.phase === "moving")) {
+            rolls.push(event);
+        }
+    }
+    return rolls;
+}
+
+/**
+ * Fait une analyse avec le moteur et la range dans le journal, qui est
+ * renvoyé (le journal reçu ne change pas). Une décision que le moteur
+ * n'analyse pas est notée comme telle, pour ne plus la demander.
+ */
+export async function runAnalysis(
+    engine: Engine,
+    journal: GameJournal,
+    task: AnalysisTask,
+): Promise<GameJournal> {
+    const review = reviewOf(journal);
+    switch (task.kind) {
+        case "decision": {
+            const advice = await analyseDecision(engine, journal, task.eventId, {
+                side: task.side,
+                ranking: task.side === "player",
+            });
+            if (advice === null) {
+                return withReview(journal, {
+                    ...review,
+                    unanalysed: [...review.unanalysed, task.eventId],
+                });
+            }
+            return task.side === "player"
+                ? withAdvice(journal, advice)
+                : withReview(journal, {
+                      ...review,
+                      computer: { ...review.computer, [task.eventId]: advice },
+                  });
+        }
+        case "luck": {
+            const line = currentLine({ ...journal, head: task.eventId });
+            const event = line.at(-1);
+            if (event?.type !== "DiceRolled") {
+                throw new Error(`pas un jet : ${task.eventId}`);
+            }
+            const before = replay(line.slice(0, -1));
+            // Le camp qui joue le jet ; au jet d'ouverture, celui qu'il
+            // désigne. La position de départ est la même pour les deux.
+            const roller = event.side ?? replay(line).turn ?? "player";
+            const luck = await engine.luck(before.position, engineCube(before, roller), event.roll);
+            return withReview(journal, { ...review, luck: { ...review.luck, [event.id]: luck } });
+        }
+        case "chance": {
+            const chance = await chanceAfter(engine, journal, task.eventId);
+            return withReview(journal, {
+                ...review,
+                winChances: { ...review.winChances, [task.eventId]: chance },
+            });
+        }
+    }
+}
+
+/** Les chances de gagner du joueur après le coup moveId : le résultat si
+ * la partie finit là, sinon l'évaluation du moteur, vue de celui qui a
+ * alors la main. */
+async function chanceAfter(engine: Engine, journal: GameJournal, moveId: string): Promise<number> {
+    const line = currentLine(journal);
+    const index = line.findIndex((e) => e.id === moveId);
+    const upTo = index >= 0 ? line.slice(0, index + 1) : currentLine({ ...journal, head: moveId });
+    const next = index >= 0 ? line[index + 1] : undefined;
+    if (next?.type === "GameEnded") {
+        return next.winner === "player" ? 1 : 0;
+    }
+    const after = replay(upTo);
+    const onRoll = after.turn ?? "player";
+    const evaluation = await engine.evaluate(
+        after.position,
+        engineCube(after, onRoll),
+        ANALYSIS_PLY,
+    );
+    return onRoll === "player" ? evaluation.win : 1 - evaluation.win;
+}
+
+// ------------------------------------------------ Les chiffres du bilan
+
+/**
+ * Classement de gnubg selon le taux d'erreur par décision (GetRating et
+ * arThrsRating, analysis.c l. 83-101) : en dessous de 0,005, « Super
+ * Grandmaster » ; puis 0,008 « Grandmaster », 0,013 « Master », 0,020
+ * « Advanced », 0,032 « Intermediate », au-delà « Beginner ». Les six
+ * classements portent les noms des six niveaux de l'ordinateur, dans le
+ * même ordre (correspondance dans docs/glossaire/taux-d-erreur.md).
+ */
+export const RATING_THRESHOLDS: readonly number[] = [0.032, 0.02, 0.013, 0.008, 0.005];
+
+/**
+ * Le taux d'erreur d'un camp, à la manière de gnubg (getMWCFromError,
+ * analysis.c) : l'équité perdue sur toutes ses décisions, divisée par le
+ * nombre de coups non forcés et de décisions de videau « serrées ».
+ *
+ * Glossaire : docs/glossaire/taux-d-erreur.md
+ */
+export interface ErrorRate {
+    /** Équité perdue au total, pour un videau de 1 (positive ou nulle). */
+    readonly total: number;
+    /** Nombre de décisions comptées. */
+    readonly decisions: number;
+    /** Équité perdue par décision (0 sans décision). */
+    readonly perDecision: number;
+    /** Le niveau correspondant, du nom des niveaux de l'ordinateur. */
+    readonly level: ComputerLevel;
+}
+
+/** La chance d'un camp sur la partie, à la manière de gnubg (formatgs.c,
+ * « Luck total », « Luck rate », « Luck rating »). */
+export interface LuckSummary {
+    /** Somme de la chance de ses jets, pour un videau de 1. */
+    readonly total: number;
+    /** Nombre de ses tours avec un jet (anTotalMoves de gnubg). */
+    readonly rolls: number;
+    /** Chance par tour (0 sans tour). */
+    readonly perRoll: number;
+    /** getLuckRating : la chance par tour, multipliée par 10, comparée aux
+     * seuils d'un jet (LUCK_THRESHOLDS). */
+    readonly rating: LuckRating;
+    /** La chance comptée en points : chaque jet multiplié par la valeur
+     * du videau à ce moment (arLuck[…][1] de gnubg en partie libre). */
+    readonly points: number;
+}
+
+/** Ce que le bilan dit d'un camp. */
+export interface SideSummary {
+    readonly errorRate: ErrorRate;
+    readonly luck: LuckSummary;
+}
+
+/** Une décision du joueur et son conseil, dans son tour. */
+export interface ReviewedDecision {
+    readonly turn: number;
+    readonly advice: Advice;
+}
+
+/** Le bilan d'une partie (ligne courante). */
+export interface GameSummary {
+    readonly player: SideSummary;
+    readonly computer: SideSummary;
+    /** Les décisions du joueur comptées, par appréciation : ses coups, ses
+     * doubles et ses réponses aux doubles, et ses jets sans doubler
+     * seulement quand doubler était mieux. */
+    readonly counts: Readonly<Record<Verdict, number>>;
+    /** La plus grosse erreur du joueur (null : aucune imprécision ni
+     * erreur). */
+    readonly toReview: ReviewedDecision | null;
+    /** Le résultat de la partie en points pour le joueur (0 si elle n'est
+     * pas finie), et ce résultat corrigé de la chance des deux camps
+     * (arLuckAdj de gnubg) : ce qu'il serait sans les dés. */
+    readonly result: number;
+    readonly luckAdjustedResult: number;
+}
+
+/** Le niveau de gnubg pour un taux d'erreur par décision. */
+export function levelOfErrorRate(perDecision: number): ComputerLevel {
+    let index = 0;
+    while (index < RATING_THRESHOLDS.length && perDecision < (RATING_THRESHOLDS[index] ?? 0)) {
+        index++;
+    }
+    return COMPUTER_LEVELS[index] ?? "beginner";
+}
+
+/** getLuckRating de gnubg : Luck(chance par tour × 10). */
+export function luckRatingOf(perRoll: number): LuckRating {
+    const r = perRoll * 10;
+    if (r > LUCK_THRESHOLDS.veryLucky) {
+        return "veryLucky";
+    }
+    if (r > LUCK_THRESHOLDS.lucky) {
+        return "lucky";
+    }
+    if (r < -LUCK_THRESHOLDS.veryLucky) {
+        return "veryUnlucky";
+    }
+    if (r < -LUCK_THRESHOLDS.lucky) {
+        return "unlucky";
+    }
+    return "none";
+}
+
+/**
+ * Une décision de videau « serrée » pour gnubg (isCloseCubedecision,
+ * eval.c l. 5107) : doubler coûte moins de 0,16 par rapport à l'optimum.
+ * Un jet sans doubler n'est compté dans le taux d'erreur que dans ce cas ;
+ * un double, une prise ou un refus le sont toujours.
+ */
+function closeCube(advice: CubeAdvice): boolean {
+    const e = advice.equities;
+    return e.optimal - Math.min(e.doubleTake, 1) < 0.16;
+}
+
+/** L'erreur d'une décision (équité perdue, positive) et si elle compte
+ * dans le nombre de décisions (updateStatcontext). */
+function errorOf(advice: Advice): { error: number; counted: boolean } {
+    const error = -Math.min(0, advice.equityLoss);
+    if (advice.kind === "move") {
+        // Un coup forcé ne compte pas (anUnforcedMoves).
+        return { error: advice.moveCount > 1 ? error : 0, counted: advice.moveCount > 1 };
+    }
+    return { error, counted: advice.action !== "noDouble" || closeCube(advice) };
+}
+
+function errorRateOf(advices: readonly Advice[]): ErrorRate {
+    let total = 0;
+    let decisions = 0;
+    for (const advice of advices) {
+        const { error, counted } = errorOf(advice);
+        total += error;
+        decisions += counted ? 1 : 0;
+    }
+    const perDecision = decisions > 0 ? total / decisions : 0;
+    return { total, decisions, perDecision, level: levelOfErrorRate(perDecision) };
+}
+
+/** Le bilan de la ligne courante, avec les analyses déjà faites (les
+ * manquantes ne comptent pas : voir readyForSummary). */
+export function summarizeAnalysis(journal: GameJournal): GameSummary {
+    const line = currentLine(journal);
+    const review = reviewOf(journal);
+    const advice = journal.advice ?? {};
+    const turns = turnsOf(line);
+    const turnOf = new Map<string, number>();
+    for (const turn of turns) {
+        for (const event of turn.events) {
+            turnOf.set(event.id, turn.number);
+        }
+    }
+
+    const decided = (side: Side): Advice[] =>
+        decisionsOf(line, side)
+            .map((e) => (side === "player" ? advice[e.id] : review.computer[e.id]))
+            .filter((a): a is Advice => a !== undefined);
+    const mine = decided("player");
+
+    // La chance de chaque camp, et la valeur du videau à chaque jet.
+    const luck: Record<Side, { total: number; points: number; rolls: number }> = {
+        player: { total: 0, points: 0, rolls: 0 },
+        computer: { total: 0, points: 0, rolls: 0 },
+    };
+    let state = replay([]);
+    for (const event of line) {
+        const before = state;
+        state = applyEvent(state, event);
+        if (event.type === "MovePlayed") {
+            luck[event.side].rolls++;
+        }
+        const value = event.type === "DiceRolled" ? review.luck[event.id] : undefined;
+        if (value !== undefined && event.type === "DiceRolled") {
+            const roller = event.side ?? state.turn ?? "player";
+            luck[roller].total += value.value;
+            luck[roller].points += value.value * before.cube.value;
+        }
+    }
+    const luckSummary = (side: Side): LuckSummary => {
+        const { total, points, rolls } = luck[side];
+        const perRoll = rolls > 0 ? total / rolls : 0;
+        return { total, rolls, perRoll, rating: luckRatingOf(perRoll), points };
+    };
+
+    const counts: Record<Verdict, number> = { good: 0, doubtful: 0, bad: 0, veryBad: 0 };
+    let toReview: ReviewedDecision | null = null;
+    for (const a of mine) {
+        const verdict = verdictOf(a.skill);
+        // Un jet sans doubler n'est une décision visible que s'il était
+        // une faute.
+        if (!(a.kind === "cube" && a.action === "noDouble" && verdict === "good")) {
+            counts[verdict]++;
+        }
+        if (
+            verdict !== "good" &&
+            (toReview === null || a.equityLoss < toReview.advice.equityLoss)
+        ) {
+            toReview = { turn: turnOf.get(a.eventId) ?? 0, advice: a };
+        }
+    }
+
+    const ended = line.findLast((e) => e.type === "GameEnded");
+    const result =
+        ended?.type === "GameEnded" ? (ended.winner === "player" ? 1 : -1) * ended.points : 0;
+    const player = luckSummary("player");
+    const computer = luckSummary("computer");
+    return {
+        player: { errorRate: errorRateOf(mine), luck: player },
+        computer: { errorRate: errorRateOf(decided("computer")), luck: computer },
+        counts,
+        toReview,
+        result,
+        luckAdjustedResult: result - player.points + computer.points,
+    };
+}
+
+// ------------------------------------------------ Coup par coup
+
+/** Un point de la courbe des chances de gagner : un tour. */
+export interface ChancePoint {
+    readonly turn: number;
+    readonly side: Side;
+    /** Chances de gagner du joueur après le tour, de 0 à 1 (null : pas
+     * encore analysé). */
+    readonly chance: number | null;
+    /** L'appréciation de la décision du joueur la plus coûteuse du tour
+     * (null : aucune décision du joueur analysée). */
+    readonly verdict: Verdict | null;
+}
+
+/**
+ * La courbe des chances de gagner du joueur, tour après tour : la position
+ * après chaque coup évaluée par le moteur, et le résultat après le dernier.
+ *
+ * Glossaire : docs/glossaire/courbe-des-chances.md
+ */
+export type WinChanceCurve = readonly ChancePoint[];
+
+/** La décision du joueur à revoir dans un tour : la plus coûteuse, le coup
+ * à égalité (null : aucune décision du joueur analysée dans ce tour). */
+export function mainAdvice(journal: GameJournal, turn: Turn): Advice | null {
+    const advice = journal.advice ?? {};
+    let main: Advice | null = null;
+    for (const event of decisionsOf(turn.events, "player")) {
+        const a = advice[event.id];
+        if (a === undefined) {
+            continue;
+        }
+        if (
+            main === null ||
+            a.equityLoss < main.equityLoss ||
+            (a.equityLoss === main.equityLoss && a.kind === "move")
+        ) {
+            main = a;
+        }
+    }
+    return main;
+}
+
+/** Le conseil sur le coup de l'ordinateur d'un tour (null sinon). */
+export function computerMoveAdvice(journal: GameJournal, turn: Turn): MoveAdvice | null {
+    if (turn.side !== "computer" || turn.move === null) {
+        return null;
+    }
+    const advice = reviewOf(journal).computer[turn.move.id];
+    return advice?.kind === "move" ? advice : null;
+}
+
+export function chanceCurve(journal: GameJournal): WinChanceCurve {
+    const review = reviewOf(journal);
+    return gameTurns(journal).map((turn) => {
+        const main = mainAdvice(journal, turn);
+        let chance: number | null = null;
+        if (turn.move !== null) {
+            chance = review.winChances[turn.move.id] ?? null;
+        }
+        if (turn.end !== null && (turn.move === null || chance === null)) {
+            chance = turn.end.winner === "player" ? 1 : 0;
+        }
+        return {
+            turn: turn.number,
+            side: turn.side,
+            chance,
+            verdict: main === null ? null : verdictOf(main.skill),
+        };
+    });
+}
+
+/**
+ * « Rejouer d'ici » sur un tour : l'événement où revenir pour rejouer la
+ * décision à revoir du joueur (juste avant elle : même jet pour un coup,
+ * même moment pour un videau). null pour un tour sans décision du joueur.
+ */
+export function replayPoint(journal: GameJournal, turn: Turn): string | null {
+    const main = mainAdvice(journal, turn);
+    const decisions = decisionsOf(turn.events, "player");
+    const event = main === null ? decisions.at(-1) : decisions.find((e) => e.id === main.eventId);
+    return event?.parent ?? null;
+}

app/src/domain/analysis/phrases.ts

@@ -0,0 +1,312 @@
+// Les mots et les phrases du maître : lecture de leur source
+// (docs/maitre/phrases.md, ADR 0008 : une seule source) et remplissage des
+// gabarits avec un conseil du moteur. Fonctions pures, testées sous Node
+// sur de vraies analyses (app/tests/advice.test.ts).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import {
+    type Advice,
+    type CubeAdvice,
+    type MoveAdvice,
+    type MoveFacts,
+    masterCubeAction,
+    type Verdict,
+    verdictOf,
+} from "../game/advice.js";
+import type { CubeAction, LuckRating } from "../game/engine.js";
+import type { GameSummary } from "./game-analysis.js";
+
+/** Les gabarits, par clé de section (« coup.meilleur »…). */
+export type MasterPhrases = ReadonlyMap<string, readonly string[]>;
+
+/** Longueur maximale de la ligne du maître (mot et phrase), en caractères
+ * (charte, « Les phrases du maître ») : elle doit rester en dessous. */
+export const LINE_LIMIT = 140;
+
+/** Ce que le maître dit d'une décision. */
+export interface MasterWords {
+    readonly verdict: Verdict;
+    /** Le mot d'appréciation, sans point : « Bon coup », « Erreur »… */
+    readonly word: string;
+    /** La phrase du maître. */
+    readonly phrase: string;
+    /** Le titre de la feuille d'explication. */
+    readonly title: string;
+    /** Le contexte de la décision : « votre 3-1 d'ouverture »… */
+    readonly context: string;
+}
+
+/** Lit la source des phrases : les sections « ## clé » à partir de la
+ * première « ## mot.… », un gabarit par ligne « - … ». */
+export function parsePhrases(text: string): MasterPhrases {
+    const phrases = new Map<string, string[]>();
+    let key: string | null = null;
+    let started = false;
+    for (const raw of text.split("\n")) {
+        const line = raw.trim();
+        const heading = /^## (\S+)$/.exec(line);
+        if (heading !== null) {
+            const name = heading[1] as string;
+            started ||= name.startsWith("mot.");
+            key = started ? name : null;
+            if (key !== null) {
+                phrases.set(key, []);
+            }
+        } else if (key !== null && line.startsWith("- ")) {
+            phrases.get(key)?.push(line.slice(2).trim());
+        }
+    }
+    return phrases;
+}
+
+/** Les clés que la source doit contenir (vérifié par les tests). */
+export const PHRASE_KEYS: readonly string[] = [
+    "mot.coup.bon",
+    "mot.videau.bon",
+    "mot.douteux",
+    "mot.mauvais",
+    "mot.tres-mauvais",
+    "coup.meilleur",
+    "coup.seul",
+    "coup.proche",
+    "coup.douteux",
+    "coup.mauvais",
+    "coup.tres-mauvais",
+    "coup.loin",
+    "fait.frappe",
+    "fait.frappe-plusieurs",
+    "fait.point",
+    "fait.frappe-et-point",
+    "fait.maitre-frappe",
+    "fait.maitre-point",
+    "fait.joueur-frappe",
+    ...["bon", "proche", "autre"].flatMap((group) =>
+        ["double", "pas-de-double", "prendre", "passer"].map((a) => `videau.${group}.${a}`),
+    ),
+    "titre.coup.meme",
+    "titre.coup.autre",
+    "titre.videau.meme",
+    ...["double", "pas-de-double", "prendre", "passer"].map((a) => `titre.videau.${a}`),
+    "contexte.coup",
+    "contexte.coup.ouverture",
+    "contexte.videau.double",
+    "contexte.videau.pas-de-double",
+    "contexte.videau.reponse",
+    "bilan.jeu.gagne",
+    "bilan.jeu.perdu",
+    "bilan.des",
+    "bilan.des.tres-pour",
+    "bilan.des.pour",
+    "bilan.des.neutres",
+    "bilan.des.contre",
+    "bilan.des.tres-contre",
+    "bilan.aucun-coup",
+];
+
+const DICE_KEYS: Readonly<Record<LuckRating, string>> = {
+    veryLucky: "bilan.des.tres-pour",
+    lucky: "bilan.des.pour",
+    none: "bilan.des.neutres",
+    unlucky: "bilan.des.contre",
+    veryUnlucky: "bilan.des.tres-contre",
+};
+
+/** La chance de vos dés sur la partie, en mots : « un peu contre vous »… */
+export function diceWords(phrases: MasterPhrases, rating: LuckRating): string {
+    return pick(phrases, DICE_KEYS[rating], "0");
+}
+
+/**
+ * La lecture du bilan d'une partie finie : ce qui a fait la différence,
+ * selon le résultat corrigé de la chance (gnubg) ; et vos dés, en mots.
+ * Partie gagnée : votre jeu, si le résultat corrigé de la chance reste
+ * positif, sinon les dés ; partie perdue : le jeu de l'ordinateur, si le
+ * résultat corrigé reste négatif, sinon les dés.
+ */
+export function summaryReading(phrases: MasterPhrases, summary: GameSummary): string {
+    const dice = diceWords(phrases, summary.player.luck.rating);
+    const won = summary.result > 0;
+    const playDecided = won ? summary.luckAdjustedResult > 0 : summary.luckAdjustedResult < 0;
+    if (!playDecided) {
+        return pick(phrases, "bilan.des", "0");
+    }
+    return fillIn(pick(phrases, won ? "bilan.jeu.gagne" : "bilan.jeu.perdu", "0"), { dice });
+}
+
+/** « Aucun coup à revoir… » : la carte du coup à revoir sans erreur. */
+export function nothingToReview(phrases: MasterPhrases): string {
+    return pick(phrases, "bilan.aucun-coup", "0");
+}
+
+/** Ce que le maître dit d'un conseil du moteur. */
+export function masterWords(phrases: MasterPhrases, advice: Advice): MasterWords {
+    return advice.kind === "move" ? moveWords(phrases, advice) : cubeWords(phrases, advice);
+}
+
+/** La ligne du maître telle qu'elle s'affiche : « Erreur. J'aurais… ». */
+export function masterLine(words: MasterWords): string {
+    return `${words.word}. ${words.phrase}`;
+}
+
+const ACTION_KEYS: Readonly<Record<CubeAction, string>> = {
+    double: "double",
+    noDouble: "pas-de-double",
+    take: "prendre",
+    pass: "passer",
+};
+
+function wordKey(verdict: Verdict, kind: Advice["kind"]): string {
+    switch (verdict) {
+        case "good":
+            return kind === "move" ? "mot.coup.bon" : "mot.videau.bon";
+        case "doubtful":
+            return "mot.douteux";
+        case "bad":
+            return "mot.mauvais";
+        case "veryBad":
+            return "mot.tres-mauvais";
+    }
+}
+
+function moveWords(phrases: MasterPhrases, advice: MoveAdvice): MasterWords {
+    const verdict = verdictOf(advice.skill);
+    const word = pick(phrases, wordKey(verdict, "move"), advice.eventId);
+    const values = {
+        best: advice.best.notation,
+        played: advice.played.notation,
+        rank: String(advice.rank),
+        roll: `${advice.roll[0]}-${advice.roll[1]}`,
+    };
+    const fill = (key: string, extra: Readonly<Record<string, string>> = {}) =>
+        fillIn(pick(phrases, key, advice.eventId), { ...values, ...extra });
+    let base: string;
+    let fact: string | null;
+    if (advice.moveCount <= 1) {
+        base = fill("coup.seul");
+        fact = null;
+    } else if (advice.rank === 1) {
+        base = fill("coup.meilleur");
+        fact = selfFact(phrases, advice.eventId, advice.played.notation, advice.playedFacts);
+    } else {
+        // Le rang n'est cité que pour un bon coup non meilleur ou une
+        // imprécision, au 2e ou 3e choix : il mesure mal la gravité d'une
+        // erreur, et le classement est dans les chiffres du moteur.
+        const near = advice.rank <= 3;
+        const key = {
+            good: near ? "coup.proche" : "coup.loin",
+            doubtful: near ? "coup.douteux" : "coup.loin",
+            bad: "coup.mauvais",
+            veryBad: "coup.tres-mauvais",
+        }[verdict];
+        base = fill(key);
+        fact = differenceFact(phrases, advice);
+    }
+    const withFact = fact === null ? base : `${base} ${fact}`;
+    const phrase = `${word}. ${withFact}`.length < LINE_LIMIT ? withFact : base;
+    return {
+        verdict,
+        word,
+        phrase,
+        title: fill(advice.rank === 1 ? "titre.coup.meme" : "titre.coup.autre"),
+        context: fill(advice.opening ? "contexte.coup.ouverture" : "contexte.coup"),
+    };
+}
+
+/** Ce que fait le coup lui-même : pions frappés, points faits. */
+function selfFact(
+    phrases: MasterPhrases,
+    id: string,
+    move: string,
+    facts: MoveFacts,
+): string | null {
+    const values = { move, points: pointsText(facts.madePoints), hits: String(facts.hits) };
+    const made = facts.madePoints.length > 0;
+    if (facts.hits === 1 && made) {
+        return fillIn(pick(phrases, "fait.frappe-et-point", id), values);
+    }
+    if (facts.hits > 1) {
+        return fillIn(pick(phrases, "fait.frappe-plusieurs", id), values);
+    }
+    if (facts.hits === 1) {
+        return fillIn(pick(phrases, "fait.frappe", id), values);
+    }
+    return made ? fillIn(pick(phrases, "fait.point", id), values) : null;
+}
+
+/** Un fait qui distingue le coup du maître du coup joué, s'il y en a un. */
+function differenceFact(phrases: MasterPhrases, advice: MoveAdvice): string | null {
+    const best = advice.bestFacts;
+    const played = advice.playedFacts;
+    if (best.hits > 0 && played.hits === 0) {
+        return pick(phrases, "fait.maitre-frappe", advice.eventId);
+    }
+    const onlyBest = best.madePoints.filter((p) => !played.madePoints.includes(p));
+    if (onlyBest.length > 0) {
+        return fillIn(pick(phrases, "fait.maitre-point", advice.eventId), {
+            points: pointsText(onlyBest),
+        });
+    }
+    if (played.hits > 0 && best.hits === 0) {
+        return pick(phrases, "fait.joueur-frappe", advice.eventId);
+    }
+    return null;
+}
+
+function cubeWords(phrases: MasterPhrases, advice: CubeAdvice): MasterWords {
+    const verdict = verdictOf(advice.skill);
+    const master = masterCubeAction(advice);
+    const same = master === advice.action;
+    const group = verdict !== "good" ? "autre" : same ? "bon" : "proche";
+    const shown = group === "bon" ? advice.action : master;
+    const context =
+        advice.action === "take" || advice.action === "pass"
+            ? "contexte.videau.reponse"
+            : `contexte.videau.${ACTION_KEYS[advice.action]}`;
+    return {
+        verdict,
+        word: pick(phrases, wordKey(verdict, "cube"), advice.eventId),
+        phrase: pick(phrases, `videau.${group}.${ACTION_KEYS[shown]}`, advice.eventId),
+        title: pick(
+            phrases,
+            same ? "titre.videau.meme" : `titre.videau.${ACTION_KEYS[master]}`,
+            advice.eventId,
+        ),
+        context: pick(phrases, context, advice.eventId),
+    };
+}
+
+/** « votre point 5 », « vos points 5 et 7 », « vos points 4, 5 et 7 ». */
+function pointsText(points: readonly number[]): string {
+    const sorted = [...points].sort((a, b) => a - b).map(String);
+    if (sorted.length <= 1) {
+        return `votre point ${sorted[0] ?? ""}`;
+    }
+    return `vos points ${sorted.slice(0, -1).join(", ")} et ${sorted.at(-1)}`;
+}
+
+/** Un gabarit de la section key ; plusieurs tournent selon l'identifiant
+ * de l'événement. Erreur si la section manque. */
+function pick(phrases: MasterPhrases, key: string, id: string): string {
+    const choices = phrases.get(key) ?? [];
+    if (choices.length === 0) {
+        throw new Error(`phrases du maître : section « ${key} » absente`);
+    }
+    const n = Number.parseInt(id, 10);
+    // Les identifiants des coups du joueur vont souvent de quatre en quatre :
+    // un brassage (hachage de Knuth, bits de poids fort) les fait tourner.
+    const index = (Math.imul(Number.isNaN(n) ? 0 : n, 2654435761) >>> 16) % choices.length;
+    return choices[index] as string;
+}
+
+/** Remplace les {repères} ; erreur sur un repère inconnu. */
+function fillIn(template: string, values: Readonly<Record<string, string>>): string {
+    return template.replace(/\{([a-z]+)\}/g, (_, name: string) => {
+        const value = values[name];
+        if (value === undefined) {
+            throw new Error(`phrases du maître : repère {${name}} inconnu`);
+        }
+        return value;
+    });
+}

app/src/domain/game/advice.ts

@@ -0,0 +1,124 @@
+// Le conseil du maître sur une décision du joueur : ce que le moteur en dit,
+// rattaché à l'événement de la décision dans le journal (étape 1d).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Ce fichier ne contient que des données : tout ce qu'elles disent vient du
+// moteur (analyse du coup, classement des coups, analyse de la décision de
+// videau, plateaux décodés). Le calcul est dans domain/analysis/ ; le
+// stockage, dans le journal (events.ts, champ advice). Le format est
+// durable (ADR 0007) : chaque conseil porte sa version (ADVICE_VERSION).
+
+import type { CubeAction, CubeEquities, Ply, Skill } from "./engine.js";
+import type { HalfMove, PositionId } from "./position.js";
+import type { Roll } from "./roll.js";
+
+/** Version du format d'un conseil enregistré. Un conseil d'une autre
+ * version est ignoré à la reprise (il peut être recalculé). */
+export const ADVICE_VERSION = 1;
+
+/**
+ * Le conseil du maître sur une décision du joueur : un coup ou une décision
+ * de videau, avec l'appréciation du moteur.
+ *
+ * Glossaire : docs/glossaire/conseil-du-maitre.md
+ */
+export type Advice = MoveAdvice | CubeAdvice;
+
+/** Un coup, tel que le conseil le retient. */
+export interface AdvisedMove {
+    /** Notation de gnubg, par exemple « 8/5 6/5 ». */
+    readonly notation: string;
+    readonly halfMoves: readonly HalfMove[];
+    /** Équité (avec videau) du point de vue du joueur, et le niveau auquel
+     * le moteur l'a évaluée. */
+    readonly equity: number;
+    readonly ply: Ply;
+}
+
+/** Ce que l'on lit sur les plateaux décodés par le moteur, avant et après
+ * un coup : de quoi écrire une phrase sans rien inventer. */
+export interface MoveFacts {
+    /** Pions adverses envoyés sur la barre. */
+    readonly hits: number;
+    /** Cases (numérotation du joueur) où il n'avait pas deux pions avant
+     * le coup et en a deux ou plus après : les points qu'il fait. */
+    readonly madePoints: readonly number[];
+}
+
+export interface MoveAdvice {
+    readonly version: number;
+    readonly kind: "move";
+    /** L'événement MovePlayed du coup. */
+    readonly eventId: string;
+    /** Niveau de l'analyse, en plis. */
+    readonly ply: Ply;
+    /** La position avant le coup, vue du joueur, et son jet. */
+    readonly position: PositionId;
+    readonly roll: Roll;
+    /** Le premier coup de la partie (après le jet d'ouverture). */
+    readonly opening: boolean;
+    /** Nombre de coups légaux et rang du coup joué (à partir de 1). */
+    readonly moveCount: number;
+    readonly rank: number;
+    readonly played: AdvisedMove;
+    readonly best: AdvisedMove;
+    readonly playedFacts: MoveFacts;
+    readonly bestFacts: MoveFacts;
+    /** Les meilleurs coups du classement du moteur, du meilleur au moins
+     * bon (cinq au plus). */
+    readonly ranking: readonly AdvisedMove[];
+    /** Équité du coup joué moins celle du meilleur : 0 ou négative. */
+    readonly equityLoss: number;
+    readonly skill: Skill;
+}
+
+export interface CubeAdvice {
+    readonly version: number;
+    readonly kind: "cube";
+    /** L'événement de la décision : DiceRolled (le joueur lance sans
+     * doubler), CubeOffered (il double), CubeTaken ou CubeDropped (il
+     * répond au double de l'ordinateur). */
+    readonly eventId: string;
+    readonly ply: Ply;
+    /** La décision du joueur. */
+    readonly action: CubeAction;
+    /** La position, vue de celui qui double ou non (l'ordinateur quand le
+     * joueur prend ou passe). */
+    readonly position: PositionId;
+    /** Équités de celui qui double ou non, pour un videau de 1. */
+    readonly equities: CubeEquities;
+    /** Équité perdue par le joueur : 0 ou négative. */
+    readonly equityLoss: number;
+    readonly skill: Skill;
+}
+
+/** L'appréciation dite au joueur : celle du moteur, « rien à signaler »
+ * devenant « bon ». */
+export type Verdict = "good" | "doubtful" | "bad" | "veryBad";
+
+export function verdictOf(skill: Skill): Verdict {
+    return skill === "none" ? "good" : skill;
+}
+
+/** L'autre choix d'une décision de videau. */
+export function otherCubeAction(action: CubeAction): CubeAction {
+    switch (action) {
+        case "double":
+            return "noDouble";
+        case "noDouble":
+            return "double";
+        case "take":
+            return "pass";
+        case "pass":
+            return "take";
+    }
+}
+
+/** La décision que le maître aurait prise : celle du joueur s'il n'a perdu
+ * aucune équité, l'autre sinon (une décision de videau n'a que deux
+ * choix). */
+export function masterCubeAction(advice: CubeAdvice): CubeAction {
+    return advice.equityLoss < 0 ? otherCubeAction(advice.action) : advice.action;
+}

app/src/domain/game/engine.ts

@@ -80,6 +80,17 @@ export interface Engine {
         ply: Ply,
     ): Promise<MoveAnalysis | null>;
 
+    /** Les coups légaux d'un jet classés du meilleur au moins bon, au
+     * niveau ply, comme la commande « hint » de gnubg (les coups écartés
+     * par ses filtres gardent l'évaluation d'un niveau inférieur, voir leur
+     * ply). */
+    rankMoves(
+        position: PositionId,
+        cube: EngineCube,
+        roll: Roll,
+        ply: Ply,
+    ): Promise<EvaluatedMove[]>;
+
     /** L'analyse d'une décision de videau, position vue du joueur au trait
      * (celui qui double ou non ; take et pass sont la réponse de son
      * adversaire). */
@@ -93,6 +104,11 @@ export interface Engine {
     /** La chance d'un jet pour le joueur au trait. */
     luck(position: PositionId, cube: EngineCube, roll: Roll): Promise<Luck>;
 
+    /** L'évaluation d'une position, joueur au trait avant de lancer les
+     * dés, au niveau ply : ses chances de gain (sans videau) et son équité
+     * avec videau. */
+    evaluate(position: PositionId, cube: EngineCube, ply: Ply): Promise<Evaluation>;
+
     /** Le Match ID, joueur 0 au trait, avec ce videau et ce match vus de lui
      * (partie libre sans match), sans dés. */
     encodeMatch(cube: EngineCube): Promise<MatchId>;
@@ -178,6 +194,16 @@ export interface Luck {
     readonly rating: LuckRating;
 }
 
+/** Une position évaluée par le moteur, du point de vue du joueur au
+ * trait. */
+export interface Evaluation {
+    /** Chances de gagner la partie, de 0 à 1, sans tenir compte du videau
+     * (première probabilité de gnubg). */
+    readonly win: number;
+    /** Équité avec videau, normalisée pour un videau de 1. */
+    readonly equity: number;
+}
+
 /** Un coup avec son équité (avec videau), du point de vue de celui qui le joue. */
 export interface EvaluatedMove extends Move {
     readonly equity: number;

app/src/domain/game/events.ts

@@ -12,10 +12,12 @@
 // Chaque événement contient tout ce qu'il faut pour rejouer la partie sans
 // le moteur : l'état se recalcule par une simple boucle (state.ts).
 
+import { ADVICE_VERSION, type Advice } from "./advice.js";
 import type { Cube } from "./cube.js";
 import type { Level, ResultKind } from "./engine.js";
 import type { Match, MatchAfterGame } from "./match.js";
 import type { HalfMove, PositionId } from "./position.js";
+import { type GameReview, REVIEW_VERSION } from "./review.js";
 import type { Roll } from "./roll.js";
 import type { Side } from "./side.js";
 
@@ -38,7 +40,8 @@ const VERSION_1_LEVEL: Level = "2ply";
  * une partie de la version 1 étant une partie libre. Un événement d'une
  * version inconnue est laissé tel quel (Game.resume le refuse).
  */
-export function migrateJournal(journal: GameJournal): GameJournal {
+export function migrateJournal(saved: GameJournal): GameJournal {
+    const journal = keepKnownReview(keepKnownAdvice(saved));
     if (journal.events.every((event) => event.version === EVENT_VERSION)) {
         return journal;
     }
@@ -55,7 +58,84 @@ export function migrateJournal(journal: GameJournal): GameJournal {
         }
         return Object.freeze({ ...event, version: EVENT_VERSION });
     });
-    return { events, head: journal.head };
+    return { ...journal, events };
+}
+
+/**
+ * Les conseils du maître d'un journal enregistré : seuls restent ceux de la
+ * version courante (ADVICE_VERSION), rattachés à un événement du journal.
+ * Les autres sont oubliés : ce ne sont que des analyses du moteur, qui
+ * peuvent être refaites. Un journal sans conseils (enregistré avant l'étape
+ * 1d) reste tel quel.
+ */
+function keepKnownAdvice(journal: GameJournal): GameJournal {
+    const advice = journal.advice;
+    if (advice === undefined) {
+        return journal;
+    }
+    const ids = new Set(journal.events.map((event) => event.id));
+    const kept = Object.entries(advice).filter(
+        ([id, a]) =>
+            typeof a === "object" &&
+            a !== null &&
+            a.version === ADVICE_VERSION &&
+            a.eventId === id &&
+            ids.has(id),
+    );
+    if (kept.length === Object.keys(advice).length) {
+        return journal;
+    }
+    return { ...journal, advice: Object.fromEntries(kept) };
+}
+
+/**
+ * L'analyse de partie d'un journal enregistré (étape 1e) : oubliée si elle
+ * est d'une autre version (REVIEW_VERSION) ou mal formée ; sinon, seules
+ * restent ses entrées rattachées à un événement du journal. Ce n'est
+ * qu'une analyse du moteur, qui peut être refaite. Un journal sans analyse
+ * (enregistré avant l'étape 1e) reste tel quel.
+ */
+function keepKnownReview(journal: GameJournal): GameJournal {
+    const review = journal.review;
+    if (review === undefined) {
+        return journal;
+    }
+    const tables = [review.luck, review.winChances, review.computer];
+    const wellFormed =
+        typeof review === "object" &&
+        review !== null &&
+        review.version === REVIEW_VERSION &&
+        typeof review.ply === "number" &&
+        tables.every((table) => typeof table === "object" && table !== null) &&
+        Array.isArray(review.unanalysed);
+    if (!wellFormed) {
+        const { review: _, ...rest } = journal;
+        return rest;
+    }
+    const ids = new Set(journal.events.map((event) => event.id));
+    const known = <T>(table: Readonly<Record<string, T>>) =>
+        Object.fromEntries(Object.entries(table).filter(([id]) => ids.has(id)));
+    const computer = Object.fromEntries(
+        Object.entries(review.computer).filter(
+            ([id, a]) =>
+                ids.has(id) &&
+                typeof a === "object" &&
+                a !== null &&
+                a.version === ADVICE_VERSION &&
+                a.eventId === id,
+        ),
+    );
+    const kept: GameReview = {
+        ...review,
+        luck: known(review.luck),
+        winChances: known(review.winChances),
+        computer,
+        unanalysed: review.unanalysed.filter((id) => ids.has(id)),
+    };
+    // Le nombre d'entrées de chaque table : rien d'oublié, rien ne change.
+    const sizes = (r: GameReview) =>
+        [r.luck, r.winChances, r.computer, r.unanalysed].map((t) => Object.keys(t).length).join();
+    return sizes(kept) === sizes(review) ? journal : { ...journal, review: kept };
 }
 
 interface EventBase {
@@ -150,10 +230,17 @@ export type NewGameEvent = WithoutBase<GameEvent>;
 type WithoutBase<E> = E extends unknown ? Omit<E, keyof EventBase> : never;
 
 /** Tous les événements d'une partie, branches comprises, et l'événement
- * courant (head) : la partie en est là. */
+ * courant (head) : la partie en est là. advice (étape 1d, facultatif) : le
+ * conseil du maître sur les décisions du joueur, par identifiant de
+ * l'événement de la décision. Ce n'est pas un événement : il arrive après
+ * coup, quand l'analyse du moteur est prête, et ne change pas la partie.
+ * review (étape 1e, facultatif) : le reste de l'analyse de la partie (chance
+ * des jets, chances de gagner, décisions de l'ordinateur), pour le bilan. */
 export interface GameJournal {
     readonly events: readonly GameEvent[];
     readonly head: string | null;
+    readonly advice?: Readonly<Record<string, Advice>>;
+    readonly review?: GameReview;
 }
 
 export const EMPTY_JOURNAL: GameJournal = { events: [], head: null };
@@ -166,7 +253,35 @@ export function appendEvent(journal: GameJournal, event: NewGameEvent): GameJour
         parent: journal.head,
         version: EVENT_VERSION,
     }) as GameEvent;
-    return { events: [...journal.events, added], head: added.id };
+    return { ...journal, events: [...journal.events, added], head: added.id };
+}
+
+/** Rattache un conseil du maître à son événement (il remplace un conseil
+ * déjà rattaché). Erreur si l'événement n'est pas dans le journal. */
+export function withAdvice(journal: GameJournal, advice: Advice): GameJournal {
+    if (!journal.events.some((event) => event.id === advice.eventId)) {
+        throw new Error(`événement introuvable : ${advice.eventId}`);
+    }
+    return { ...journal, advice: { ...journal.advice, [advice.eventId]: advice } };
+}
+
+/** Remplace l'analyse de partie du journal (elle ne change pas la
+ * partie). */
+export function withReview(journal: GameJournal, review: GameReview): GameJournal {
+    return { ...journal, review };
+}
+
+/** Le journal avec les analyses d'une copie de lui-même, faite en
+ * arrière-plan : ses conseils s'ajoutent, son analyse de partie remplace
+ * celle du journal. Les événements ne changent pas. */
+export function withAnalysesOf(journal: GameJournal, analysed: GameJournal): GameJournal {
+    const ids = new Set(journal.events.map((event) => event.id));
+    const advice = Object.entries(analysed.advice ?? {}).filter(([id]) => ids.has(id));
+    return {
+        ...journal,
+        advice: { ...Object.fromEntries(advice), ...journal.advice },
+        ...(analysed.review === undefined ? {} : { review: analysed.review }),
+    };
 }
 
 /** Les événements du début jusqu'à l'événement courant, dans l'ordre. */
@@ -190,5 +305,5 @@ export function goBackTo(journal: GameJournal, id: string): GameJournal {
     if (!journal.events.some((event) => event.id === id)) {
         throw new Error(`événement introuvable : ${id}`);
     }
-    return { events: journal.events, head: id };
+    return { ...journal, head: id };
 }

app/src/domain/game/game.ts

@@ -9,6 +9,7 @@
 // l'ordinateur, videau (Crawford compris), fin de partie, points et score du
 // match.
 
+import type { Advice } from "./advice.js";
 import { type Branch, branches, switchToBranch } from "./branches.js";
 import { CENTERED_CUBE, type Cube } from "./cube.js";
 import type { BoardSide, Engine, EngineCube, Level, Ply, ResultKind } from "./engine.js";
@@ -22,6 +23,8 @@ import {
     goBackTo,
     migrateJournal,
     type NewGameEvent,
+    withAdvice,
+    withAnalysesOf,
 } from "./events.js";
 import { firstGameOf, type Match, nextGameOf } from "./match.js";
 import { BAR, type HalfMove, OFF, type PositionId, START_POSITION } from "./position.js";
@@ -227,36 +230,65 @@ export class Game {
      * (checkHalfMoves, puis board) : aucune règle n'est rejouée ici.
      */
     async lastMoveSteps(): Promise<MoveSteps | null> {
-        const events = this.events;
-        const index = events.findLastIndex((e) => e.type === "MovePlayed");
-        const played = events[index];
-        if (played?.type !== "MovePlayed") {
-            return null;
-        }
-        // L'état juste avant le coup : la position vue de celui qui joue, et
-        // son jet.
-        const before = replay(events.slice(0, index));
-        const roll = rollToPlay(before);
+        const played = this.events.findLast((e) => e.type === "MovePlayed");
+        return played?.type === "MovePlayed"
+            ? this.stepsBefore(played.id, played.side, played.halfMoves)
+            : null;
+    }
+
+    /**
+     * Un coup de side joué demi-coup par demi-coup à partir de la position
+     * d'avant l'événement eventId (le coup réellement joué, ou un autre coup
+     * du même jet : celui du maître). Les plateaux viennent du moteur ;
+     * erreur s'il refuse un demi-coup. Sans demi-coup, boards ne contient
+     * que la position d'avant l'événement.
+     */
+    async stepsBefore(
+        eventId: string,
+        side: Side,
+        halfMoves: readonly HalfMove[],
+    ): Promise<MoveSteps> {
+        const line = currentLine({ ...this.#journal, head: eventId });
+        // L'état juste avant l'événement : la position vue de celui qui a la
+        // main, et son jet.
+        const before = replay(line.slice(0, -1));
         const positions = [before.position];
-        for (let i = 1; i <= played.halfMoves.length; i++) {
+        for (let i = 1; i <= halfMoves.length; i++) {
             const check = await this.#engine.checkHalfMoves(
                 before.position,
-                roll,
-                played.halfMoves.slice(0, i),
+                rollToPlay(before),
+                halfMoves.slice(0, i),
             );
             if (check.position === null) {
-                throw new Error("coup enregistré refusé par le moteur");
+                throw new Error("coup refusé par le moteur");
             }
             positions.push(check.position);
         }
-        const boards = await Promise.all(
-            positions.map((p) => this.#sideBoards(p, played.side, before)),
-        );
-        const opponent = otherSide(played.side);
-        const hits = played.halfMoves.map(
+        const onRoll = before.turn ?? side;
+        const boards = await Promise.all(positions.map((p) => this.#sideBoards(p, onRoll, before)));
+        const opponent = otherSide(side);
+        const hits = halfMoves.map(
             (_, i) => (boards[i + 1]?.[opponent].bar ?? 0) > (boards[i]?.[opponent].bar ?? 0),
         );
-        return { side: played.side, halfMoves: played.halfMoves, boards, hits };
+        return { side, halfMoves, boards, hits };
+    }
+
+    /** Les conseils du maître déjà rattachés aux décisions du joueur, par
+     * identifiant d'événement. */
+    get advice(): Readonly<Record<string, Advice>> {
+        return this.#journal.advice ?? {};
+    }
+
+    /** Rattache le conseil du maître à sa décision dans le journal (il sera
+     * enregistré avec la partie). Erreur si l'événement n'existe pas. */
+    recordAdvice(advice: Advice): void {
+        this.#journal = withAdvice(this.#journal, advice);
+    }
+
+    /** Range dans le journal les analyses faites en arrière-plan sur une
+     * copie de celui-ci (étape 1e : conseils, analyse de partie). */
+    recordAnalyses(analysed: GameJournal): void {
+        this.#journal = withAnalysesOf(this.#journal, analysed);
     }
 
     /**

app/src/domain/game/review.ts

@@ -0,0 +1,55 @@
+// L'analyse de la partie par le moteur, rangée dans le journal à côté du
+// conseil du maître (étape 1e) : la chance de chaque jet, les chances de
+// gagner après chaque coup, et les décisions de l'ordinateur.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Ce fichier ne contient que des données : tout ce qu'elles disent vient du
+// moteur. Le calcul est dans domain/analysis/game-analysis.ts. Comme le
+// conseil (advice.ts), ce n'est pas un événement : l'analyse arrive après
+// coup et ne change pas la partie. Le format est durable (ADR 0007) : il
+// porte sa version (REVIEW_VERSION), et une analyse d'une autre version
+// est oubliée à la reprise (elle peut être refaite).
+
+import type { Advice } from "./advice.js";
+import type { Luck, Ply } from "./engine.js";
+
+/** Version du format de l'analyse de partie enregistrée. */
+export const REVIEW_VERSION = 1;
+
+/**
+ * L'analyse de la partie, en plus des conseils du maître : de quoi
+ * calculer le bilan (taux d'erreur, chance) et tracer la courbe des chances
+ * de gagner. Chaque table est indexée par l'identifiant d'un événement du
+ * journal ; une table incomplète est complétée en arrière-plan.
+ */
+export interface GameReview {
+    readonly version: number;
+    /** Niveau des analyses et des évaluations, en plis. */
+    readonly ply: Ply;
+    /** Pour chaque jet (DiceRolled, ouverture comprise), sa chance pour le
+     * camp qui le joue, selon le moteur. */
+    readonly luck: Readonly<Record<string, Luck>>;
+    /** Pour chaque coup (MovePlayed), les chances de gagner du joueur dans
+     * la position d'après, de 0 à 1, selon le moteur. */
+    readonly winChances: Readonly<Record<string, number>>;
+    /** Les décisions de l'ordinateur, analysées comme celles du joueur (le
+     * conseil d'un coup de l'ordinateur est vu de lui). */
+    readonly computer: Readonly<Record<string, Advice>>;
+    /** Les décisions (des deux camps) que le moteur n'analyse pas : videau
+     * inaccessible, position de départ. Elles ne sont plus demandées. */
+    readonly unanalysed: readonly string[];
+}
+
+/** Une analyse vide, au niveau ply. */
+export function emptyReview(ply: Ply): GameReview {
+    return {
+        version: REVIEW_VERSION,
+        ply,
+        luck: {},
+        winChances: {},
+        computer: {},
+        unanalysed: [],
+    };
+}

app/src/engine/wasm-engine.ts

@@ -19,6 +19,7 @@ import type {
     EngineCube,
     EngineMatch,
     EvaluatedMove,
+    Evaluation,
     HalfMovesCheck,
     Level,
     Luck,
@@ -195,6 +196,14 @@ export function createWasmEngine(run: RunCommand): Engine {
             };
         },
 
+        async rankMoves(position: PositionId, cube: EngineCube, roll: Roll, ply: Ply) {
+            const args = ["--ply", String(ply), "moves", position, await matchId(cube)];
+            const answer = (await run([...args, diceText(roll)])) as {
+                moves: CliEvaluatedMove[];
+            };
+            return answer.moves.map(toEvaluatedMove);
+        },
+
         async analyseCube(
             position: PositionId,
             cube: EngineCube,
@@ -252,6 +261,15 @@ export function createWasmEngine(run: RunCommand): Engine {
             return { value: answer.luck, rating };
         },
 
+        async evaluate(position: PositionId, cube: EngineCube, ply: Ply): Promise<Evaluation> {
+            const args = ["--ply", String(ply), "eval", position, await matchId(cube)];
+            const answer = (await run(args)) as {
+                probabilities: { win: number };
+                cubeful_equity: number;
+            };
+            return { win: answer.probabilities.win, equity: answer.cubeful_equity };
+        },
+
         encodeMatch: matchId,
 
         async decodeMatch(id: MatchId): Promise<MatchDescription> {

app/src/main.ts

@@ -5,8 +5,11 @@
 // Copyright (C) 2026 les auteurs d'Ustagammon.
 // Licence : GPLv3 ou ultérieure (voir LICENSE).
 
+import { analyseDecision } from "./domain/analysis/analyse.js";
+import { runAnalysis } from "./domain/analysis/game-analysis.js";
 import { Game } from "./domain/game/game.js";
 import { linkOf, readPosition } from "./domain/game/position-link.js";
+import { levelOf } from "./domain/game/saved-game.js";
 import { exportSgf } from "./domain/game/sgf.js";
 import {
     illustratedMove,
@@ -15,7 +18,7 @@ import {
     tutorialBoard,
 } from "./domain/learning/tutorial.js";
 import { createWasmEngine } from "./engine/wasm-engine.js";
-import { startEngineWorker } from "./engine/worker-run.js";
+import { type EngineWorker, startEngineWorker } from "./engine/worker-run.js";
 import { createGameSession } from "./storage/game-session.js";
 import { memoryStorage, openGameLibrary } from "./storage/open-library.js";
 import { createSettingsStore } from "./storage/settings-store.js";
@@ -27,6 +30,30 @@ import { startUpdates } from "./ui/updates.js";
 const worker = startEngineWorker(new URL("../engine-worker.mjs", import.meta.url));
 const engine = createWasmEngine(worker.run);
 
+// Le conseil du maître (étape 1d) : les analyses à 2 plis tournent sur un
+// second moteur, dans son propre Web Worker. Le premier ne traite qu'une
+// commande à la fois : une analyse y retarderait le coup de l'ordinateur.
+// Le second démarre à la première analyse demandée, une fois le premier
+// chargé et le service worker installé (au plus 20 s d'attente) : si deux
+// téléchargements des données du moteur se croisent, Chromium fait échouer
+// l'installation hors ligne (voir startUpdates plus bas). Ensuite, les
+// données viennent du cache.
+let analysisWorker: Promise<EngineWorker> | null = null;
+function startAnalysisWorker(): Promise<EngineWorker> {
+    analysisWorker ??= worker.ready
+        .then(() => {
+            const installed =
+                "serviceWorker" in navigator ? navigator.serviceWorker.ready : Promise.resolve();
+            return Promise.race([installed, new Promise((resolve) => setTimeout(resolve, 20_000))]);
+        })
+        .then(() => {
+            const started = startEngineWorker(new URL("../engine-worker.mjs", import.meta.url));
+            return started.ready.then(() => started);
+        });
+    return analysisWorker;
+}
+const analysisEngine = createWasmEngine(async (args) => (await startAnalysisWorker()).run(args));
+
 // Chaque accès au stockage du navigateur peut lever une exception (stockage
 // interdit) : on fait alors sans.
 const localStorage = attempt(() => window.localStorage);
@@ -78,6 +105,22 @@ startApp({
         journal: async (id) => (await storage().library.load(id))?.journal ?? null,
         shownId: () => storage().session.shownId,
         open: (id, branchHead) => storage().session.open(id, branchHead),
+        view: async (id) => {
+            const saved = await storage().library.load(id);
+            if (saved === null) {
+                return null;
+            }
+            try {
+                return Game.resume(engine, saved.journal);
+            } catch {
+                return null;
+            }
+        },
+        saveAnalyses: (id, journal) => {
+            storage()
+                .library.saveAnalyses(id, journal, { level: levelOf(journal) })
+                .catch(() => {});
+        },
         remove: (id) => storage().library.remove(id),
         exportSgf: async (id) => {
             const game = await storage().library.load(id);
@@ -117,6 +160,10 @@ startApp({
     // network error »), et l'application n'est pas disponible hors ligne.
     // Cela évite aussi de télécharger deux fois ces données à la première
     // visite.
+    analyse: (journal, eventId) => analyseDecision(analysisEngine, journal, eventId),
+    // Le bilan et l'analyse de partie (étape 1e) : les analyses qui
+    // manquent, une à une, sur le même moteur à part.
+    analyseGame: (journal, task) => runAnalysis(analysisEngine, journal, task),
     startUpdates: (onAvailable) =>
         startUpdates(new URL("../sw.js", import.meta.url), worker.ready, onAvailable),
 });

app/src/storage/game-library.ts

@@ -33,6 +33,10 @@ export interface GameLibrary {
     /** Enregistre la partie id (nouvelle ou non), qui devient la partie en
      * cours. Renvoie son résumé. */
     save(id: string, journal: GameJournal, details: SavedGameDetails): Promise<SavedGameSummary>;
+    /** Enregistre le journal d'une partie analysée en arrière-plan (étape
+     * 1e) : ni la partie en cours ni la date de la dernière action ne
+     * changent. Rien si la partie n'existe plus. */
+    saveAnalyses(id: string, journal: GameJournal, details: SavedGameDetails): Promise<void>;
     /** Supprime une partie (rien si elle n'existe pas). */
     remove(id: string): Promise<void>;
     /** La partie en cours : la dernière enregistrée ou choisie (setCurrent),
@@ -118,6 +122,15 @@ export function createGameLibrary(
                 await backend.setCurrentId(id);
                 return summary;
             }),
+        saveAnalyses: (id, journal, details) =>
+            enqueue(async () => {
+                const known = await backend.summary(id);
+                if (known === undefined) {
+                    return;
+                }
+                const times = { startedAt: known.startedAt, updatedAt: known.updatedAt };
+                await backend.write(summarizeGame(id, journal, details, times), journal);
+            }),
         remove: (id) => enqueue(() => backend.remove(id)),
         current: () =>
             enqueue(async () => {

app/src/ui/advice-texts.ts

@@ -0,0 +1,55 @@
+// Les textes de l'interface du conseil du maître (ligne, feuille
+// d'explication, menu). Les mots et les phrases du maître eux-mêmes sont
+// dans docs/maitre/phrases.md (une seule source, ADR 0008).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import type { CubeAction } from "../domain/game/engine.js";
+
+export const ADVICE_TEXTS = {
+    /** Interrupteur du menu, comme sur l'écran « Nouvelle partie ». */
+    menuSwitch: "Conseil du maître",
+    lineLabel: (line: string) => `Conseil du maître : ${line} Toucher pour l'explication.`,
+    /** Paysage : la pastille du mot, au lecteur d'écran. */
+    chipLabel: (line: string) => `Conseil du maître : ${line} Toucher pour l'explication.`,
+    sheetLabel: "Explication du maître",
+    yourMove: "Votre coup",
+    masterMove: "Le coup du maître",
+    choiceLabel: "Coup montré sur le plateau",
+    legendMine: (move: string) =>
+        `Votre coup, ${move}, joué pion par pion sur la position d'avant.`,
+    legendBest: (move: string) =>
+        `Le coup du maître, ${move}, joué pion par pion sur la position d'avant votre coup.`,
+    legendSame: (move: string) => `${move}, joué pion par pion sur la position d'avant.`,
+    legendCube: "La position au moment de la décision.",
+    replay: "Rejouer le coup",
+    numbers: "Voir les chiffres du moteur",
+    you: "(vous)",
+    moveNote: (ply: number) =>
+        `Écart d'équité à ${ply} plis, par rapport au meilleur coup. Un écart de 0,03 ou moins reste un bon coup.`,
+    cubeNote: (ply: number) =>
+        `Équités de celui qui double, pour un videau de 1, à ${ply} plis. Écart de votre décision : `,
+    cubeRows: {
+        noDouble: "Pas de double",
+        doubleTake: "Double, prend",
+        doublePass: "Double, passe",
+    },
+    glossary: (term: string) => `En savoir plus : « ${term} »`,
+    close: "Fermer",
+    missing: "Le maître n'a pas d'explication pour ce coup.",
+} as const;
+
+/** La fiche du glossaire d'une décision de videau, et son titre. */
+export const CUBE_GLOSSARY: Readonly<Record<CubeAction, { file: string; term: string }>> = {
+    double: { file: "doubler", term: "Doubler" },
+    noDouble: { file: "doubler", term: "Doubler" },
+    take: { file: "prendre", term: "Prendre" },
+    pass: { file: "passer", term: "Passer" },
+};
+
+/** Un nombre à la française, signé, à trois décimales : « −0,123 ». */
+export function formatEquity(value: number): string {
+    const text = Math.abs(value).toFixed(3).replace(".", ",");
+    return value < -0.0005 ? `−${text}` : value > 0.0005 ? `+${text}` : text;
+}

app/src/ui/advice-tracker.ts

@@ -0,0 +1,152 @@
+// Le conseil du maître pendant la partie : quelles décisions du joueur
+// analyser, quand montrer la ligne, quand l'effacer (charte, 1d « La ligne
+// du maître »). Sans DOM : testé sous Node (app/tests/advice-tracker.test.ts).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Les analyses partent dès que la décision est jouée, sans être attendues :
+// l'application les confie à un second moteur (main.ts), et le tour de
+// l'ordinateur continue sur le premier. Chaque résultat est rattaché à sa
+// décision dans le journal, pour le bilan (1e). La ligne apparaît quand
+// l'analyse attendue est prête, si le joueur n'a rien fait entre-temps ;
+// sinon elle n'apparaît pas, et le coup reste commenté dans le journal.
+
+import { playerDecisions } from "../domain/analysis/analyse.js";
+import type { Advice } from "../domain/game/advice.js";
+import type { GameEvent, GameJournal } from "../domain/game/events.js";
+import type { Game } from "../domain/game/game.js";
+
+/** Analyse une décision du joueur (null : rien à en dire). */
+export type Analyse = (journal: GameJournal, eventId: string) => Promise<Advice | null>;
+
+export interface AdviceTracker {
+    /** Le conseil à montrer maintenant (null : rien). */
+    readonly shown: Advice | null;
+    /** Après une action du joueur sur game : before est la ligne de la
+     * partie avant l'action. Les décisions ajoutées sont analysées. */
+    track(game: Game, before: readonly GameEvent[]): void;
+    /** L'action suivante du joueur : la ligne s'efface, et une analyse
+     * encore attendue ne s'affichera pas. */
+    clear(): void;
+}
+
+export interface AdviceTrackerOptions {
+    readonly analyse: Analyse;
+    /** Un conseil a été rattaché au journal de game (à enregistrer). */
+    readonly recorded: (game: Game) => void;
+    /** Le conseil à montrer a changé. */
+    readonly changed: () => void;
+}
+
+export function createAdviceTracker(options: AdviceTrackerOptions): AdviceTracker {
+    let shown: Advice | null = null;
+    // Chaque attente de ligne a son jeton : clear() l'annule.
+    let waiting: object | null = null;
+    let tracked: Game | null = null;
+    let pending = new Map<string, Promise<Advice | null>>();
+
+    /** Le conseil d'une décision : déjà rattaché, en cours, ou à demander. */
+    function adviceOf(game: Game, id: string): Promise<Advice | null> {
+        const known = game.advice[id];
+        if (known !== undefined) {
+            return Promise.resolve(known);
+        }
+        let running = pending.get(id);
+        if (running === undefined) {
+            running = options
+                .analyse(game.journal, id)
+                .catch(() => null)
+                .then((advice) => {
+                    if (advice !== null && game.journal.events.some((e) => e.id === id)) {
+                        game.recordAdvice(advice);
+                        options.recorded(game);
+                    }
+                    return advice;
+                });
+            pending.set(id, running);
+        }
+        return running;
+    }
+
+    return {
+        get shown() {
+            return shown;
+        },
+        track(game, before) {
+            if (game !== tracked) {
+                tracked = game;
+                pending = new Map();
+            }
+            const known = new Set(before.map((e) => e.id));
+            const line = game.events;
+            const added = line.filter((e) => !known.has(e.id));
+            for (const decision of playerDecisions(added)) {
+                void adviceOf(game, decision.id);
+            }
+            const candidates = toShow(line, added);
+            if (candidates.length === 0) {
+                return;
+            }
+            const token = {};
+            waiting = token;
+            void Promise.all(candidates.map((id) => adviceOf(game, id))).then((results) => {
+                if (waiting !== token || tracked !== game) {
+                    return; // trop tard : le joueur a déjà agi
+                }
+                waiting = null;
+                shown = choose(results);
+                if (shown !== null) {
+                    options.changed();
+                }
+            });
+        },
+        clear() {
+            waiting = null;
+            if (shown !== null) {
+                shown = null;
+                options.changed();
+            }
+        },
+    };
+}
+
+/**
+ * Les décisions dont la ligne peut parler après une action : le coup du
+ * joueur et, juste avant lui, son jet sans doubler (il aurait pu doubler) ;
+ * ou son double, ou sa réponse au double de l'ordinateur. Un jet seul ne
+ * montre rien : le joueur réfléchit alors à son coup.
+ */
+function toShow(line: readonly GameEvent[], added: readonly GameEvent[]): string[] {
+    const cube = added.find(
+        (e) =>
+            (e.type === "CubeOffered" || e.type === "CubeTaken" || e.type === "CubeDropped") &&
+            e.side === "player",
+    );
+    if (cube !== undefined) {
+        return [cube.id];
+    }
+    const move = added.find((e) => e.type === "MovePlayed" && e.side === "player");
+    if (move?.type !== "MovePlayed") {
+        return [];
+    }
+    const index = line.findIndex((e) => e.id === move.id);
+    const roll = line
+        .slice(0, index)
+        .findLast((e) => e.type === "DiceRolled" && e.side === "player");
+    const ids = move.halfMoves.length > 0 ? [move.id] : [];
+    return roll === undefined ? ids : [roll.id, ...ids];
+}
+
+/** Ce que la ligne montre : un double manqué avant le jet s'il était une
+ * faute, sinon le conseil sur le coup ou sur la décision de videau. */
+function choose(results: readonly (Advice | null)[]): Advice | null {
+    const advices = results.filter((a): a is Advice => a !== null);
+    const missedDouble = advices.find(
+        (a) => a.kind === "cube" && a.action === "noDouble" && a.skill !== "none",
+    );
+    if (missedDouble !== undefined) {
+        return missedDouble;
+    }
+    return advices.find((a) => !(a.kind === "cube" && a.action === "noDouble")) ?? null;
+}

app/src/ui/advice-view.ts

@@ -0,0 +1,343 @@
+// La feuille d'explication du maître (#/explication/<événement>), qui monte
+// du bas au-dessus du plateau voilé (charte, 1d « La feuille
+// d'explication ») : le mot et le contexte, le coup du maître en titre, sa
+// phrase, « Votre coup » et « Le coup du maître » joués pion par pion sur la
+// position d'avant, puis les chiffres du moteur, repliés.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import { type MasterPhrases, masterWords } from "../domain/analysis/phrases.js";
+import {
+    type Advice,
+    type CubeAdvice,
+    type MoveAdvice,
+    masterCubeAction,
+    type Verdict,
+} from "../domain/game/advice.js";
+import type { Game } from "../domain/game/game.js";
+import { ADVICE_TEXTS, CUBE_GLOSSARY, formatEquity } from "./advice-texts.js";
+import { type IconName, icon } from "./icons.js";
+import { boardSvg, createMovePlayer, drawSteps, type MovePlayer } from "./move-board.js";
+import { routeHash } from "./router.js";
+
+/** Préfixe des identifiants du plateau de la feuille. */
+const PREFIX = "explain-";
+
+/** Le pictogramme d'une appréciation (interaction.md, pictogrammes). */
+export const VERDICT_ICONS: Readonly<Record<Verdict, IconName>> = {
+    good: "verdictGood",
+    doubtful: "verdictDoubtful",
+    bad: "verdictBad",
+    veryBad: "verdictBad",
+};
+
+export interface AdviceViewOptions {
+    /** Le voile de la feuille (index.html) ; la feuille est construite ici. */
+    readonly veil: HTMLElement;
+    readonly game: () => Game | null;
+    readonly phrases: () => Promise<MasterPhrases>;
+    readonly reducedMotion: MediaQueryList;
+    /** Fermer : quitter l'adresse de la feuille. */
+    readonly close: () => void;
+}
+
+export interface AdviceView {
+    /** Ouvre la feuille sur le conseil de l'événement eventId. */
+    show(eventId: string): Promise<void>;
+    hide(): void;
+}
+
+type Shown = "mine" | "best";
+
+function element<K extends keyof HTMLElementTagNameMap>(
+    parent: HTMLElement,
+    tag: K,
+    options: { id?: string; className?: string; text?: string } = {},
+): HTMLElementTagNameMap[K] {
+    const child = document.createElement(tag);
+    if (options.id !== undefined) {
+        child.id = options.id;
+    }
+    if (options.className !== undefined) {
+        child.className = options.className;
+    }
+    if (options.text !== undefined) {
+        child.textContent = options.text;
+    }
+    parent.append(child);
+    return child;
+}
+
+export function createAdviceView(options: AdviceViewOptions): AdviceView {
+    const { veil } = options;
+    const sheet = element(veil, "div", { id: "explain-sheet", className: "sheet explain-sheet" });
+    sheet.setAttribute("role", "dialog");
+    sheet.setAttribute("aria-modal", "true");
+    sheet.setAttribute("aria-labelledby", "explain-title");
+    veil.addEventListener("click", (event) => {
+        if (event.target === veil) {
+            options.close();
+        }
+    });
+    // Chaque ouverture a son numéro : une ouverture plus récente, ou la
+    // fermeture, arrête l'animation en cours.
+    let opened = 0;
+    // Le plateau de la feuille joue un coup à la fois.
+    let player: MovePlayer | null = null;
+
+    async function show(eventId: string): Promise<void> {
+        const id = ++opened;
+        const game = options.game();
+        const advice = game?.advice[eventId] ?? null;
+        sheet.replaceChildren();
+        veil.hidden = false;
+        const head = element(sheet, "div", { className: "sheet-head" });
+        element(head, "span", { className: "grip" }).setAttribute("aria-hidden", "true");
+        const verdictLine = element(head, "p", {
+            id: "explain-verdict",
+            className: "explain-verdict",
+        });
+        const close = element(head, "button", { id: "explain-close", className: "icon-button" });
+        close.type = "button";
+        close.append(icon("close"));
+        close.setAttribute("aria-label", ADVICE_TEXTS.close);
+        close.onclick = () => options.close();
+        const title = element(sheet, "h2", { id: "explain-title", className: "explain-title" });
+        if (game === null || advice === null) {
+            title.textContent = ADVICE_TEXTS.sheetLabel;
+            element(sheet, "p", { className: "explain-phrase", text: ADVICE_TEXTS.missing });
+            closeButton();
+            close.focus();
+            return;
+        }
+        const words = masterWords(await options.phrases(), advice);
+        if (id !== opened) {
+            return;
+        }
+        verdictLine.dataset.verdict = words.verdict;
+        verdictLine.append(icon(VERDICT_ICONS[words.verdict]));
+        element(verdictLine, "span", { text: `${words.word} · ${words.context}` });
+        title.textContent = words.title;
+        // Le titre dit déjà le coup du maître : la phrase ne le répète pas
+        // (et disparaît si elle ne disait que lui).
+        const rest = words.phrase.startsWith(`${words.title}.`)
+            ? words.phrase.slice(words.title.length + 1).trim()
+            : words.phrase;
+        if (rest !== "") {
+            element(sheet, "p", { id: "explain-phrase", className: "explain-phrase", text: rest });
+        }
+
+        const body = element(sheet, "div", { className: "explain-body" });
+        const boardBox = element(body, "div", { className: "explain-board-box" });
+        if (advice.kind === "move") {
+            await showMoves(id, game, advice, body, boardBox);
+        } else {
+            await showCube(id, game, advice, boardBox);
+        }
+        if (id !== opened) {
+            return;
+        }
+        numbers(advice);
+        if (advice.kind === "cube") {
+            const entry = CUBE_GLOSSARY[masterCubeAction(advice)];
+            const link = element(sheet, "a", {
+                id: "explain-glossary",
+                className: "link-button explain-glossary",
+                text: ADVICE_TEXTS.glossary(entry.term),
+            });
+            link.href = routeHash({ screen: "glossary", term: entry.file });
+        }
+        closeButton();
+        close.focus();
+    }
+
+    function closeButton(): void {
+        const actions = element(sheet, "div", { className: "explain-actions" });
+        const done = element(actions, "button", {
+            id: "explain-done",
+            className: "secondary",
+            text: ADVICE_TEXTS.close,
+        });
+        done.type = "button";
+        done.onclick = () => options.close();
+    }
+
+    /** Le plateau de la feuille, dans son cadre, et ce qui y joue les
+     * coups. */
+    function sheetBoard(box: HTMLElement): SVGSVGElement {
+        const svg = boardSvg(box, "explain-board", "explain-board");
+        player = createMovePlayer(svg, PREFIX, options.reducedMotion);
+        return svg;
+    }
+
+    async function showMoves(
+        id: number,
+        game: Game,
+        advice: MoveAdvice,
+        body: HTMLElement,
+        boardBox: HTMLElement,
+    ): Promise<void> {
+        const same = advice.rank === 1;
+        const [mine, best] = await Promise.all([
+            game.stepsBefore(advice.eventId, "player", advice.played.halfMoves),
+            same ? null : game.stepsBefore(advice.eventId, "player", advice.best.halfMoves),
+        ]);
+        if (id !== opened) {
+            return;
+        }
+        const legend = element(body, "p", { id: "explain-legend", className: "explain-legend" });
+        const svg = sheetBoard(boardBox);
+        if (best === null) {
+            svg.dataset.move = "mine";
+            svg.setAttribute("aria-label", ADVICE_TEXTS.legendSame(advice.played.notation));
+            legend.textContent = ADVICE_TEXTS.legendSame(advice.played.notation);
+            void player?.play(mine);
+            return;
+        }
+        const choice = element(body, "div", { id: "explain-choice", className: "segmented" });
+        choice.setAttribute("role", "radiogroup");
+        choice.setAttribute("aria-label", ADVICE_TEXTS.choiceLabel);
+        body.prepend(choice);
+        const buttons: Record<Shown, HTMLButtonElement> = {
+            mine: element(choice, "button", {
+                id: "explain-mine",
+                className: "segment",
+                text: ADVICE_TEXTS.yourMove,
+            }),
+            best: element(choice, "button", {
+                id: "explain-best",
+                className: "segment",
+                text: ADVICE_TEXTS.masterMove,
+            }),
+        };
+        const select = (shown: Shown) => {
+            for (const key of ["mine", "best"] as const) {
+                buttons[key].setAttribute("aria-checked", String(key === shown));
+            }
+            const notation = shown === "mine" ? advice.played.notation : advice.best.notation;
+            const text =
+                shown === "mine"
+                    ? ADVICE_TEXTS.legendMine(notation)
+                    : ADVICE_TEXTS.legendBest(notation);
+            legend.textContent = text;
+            svg.setAttribute("aria-label", text);
+            svg.dataset.move = shown;
+            void player?.play(shown === "mine" ? mine : best);
+        };
+        for (const key of ["mine", "best"] as const) {
+            const button = buttons[key];
+            button.type = "button";
+            button.setAttribute("role", "radio");
+            button.onclick = () => select(key);
+        }
+        // Flèches gauche et droite entre les deux segments.
+        choice.addEventListener("keydown", (event) => {
+            if (event.key === "ArrowLeft" || event.key === "ArrowRight") {
+                event.preventDefault();
+                const next = buttons.mine.getAttribute("aria-checked") === "true" ? "best" : "mine";
+                select(next);
+                buttons[next].focus();
+            }
+        });
+        // Par défaut, le coup du maître (maquette).
+        select("best");
+    }
+
+    async function showCube(
+        id: number,
+        game: Game,
+        advice: CubeAdvice,
+        boardBox: HTMLElement,
+    ): Promise<void> {
+        const steps = await game.stepsBefore(advice.eventId, "player", []);
+        if (id !== opened) {
+            return;
+        }
+        const svg = boardSvg(boardBox, "explain-board", "explain-board");
+        svg.setAttribute("aria-label", ADVICE_TEXTS.legendCube);
+        drawSteps(svg, steps, 0, false, PREFIX);
+        element(boardBox, "p", { className: "explain-legend", text: ADVICE_TEXTS.legendCube });
+    }
+
+    /** « Voir les chiffres du moteur », replié par défaut. */
+    function numbers(advice: Advice): void {
+        const details = element(sheet, "details", {
+            id: "explain-numbers",
+            className: "explain-numbers",
+        });
+        element(details, "summary", { text: ADVICE_TEXTS.numbers });
+        const table = element(details, "div", { className: "explain-table" });
+        const row = (cells: string[], strong: boolean) => {
+            for (const text of cells) {
+                element(table, "span", { className: strong ? "strong" : "", text });
+            }
+        };
+        if (advice.kind === "move") {
+            // Les écarts du classement se lisent par rapport à son premier
+            // coup ; votre coup, s'il n'y figure pas, avec l'écart de
+            // l'analyse du coup joué.
+            const first = advice.ranking[0]?.equity ?? advice.best.equity;
+            const listed = advice.ranking.map((move, i) => ({
+                move,
+                rank: i + 1,
+                loss: move.equity - first,
+            }));
+            if (!advice.ranking.some((m) => m.notation === advice.played.notation)) {
+                listed.push({ move: advice.played, rank: advice.rank, loss: advice.equityLoss });
+            }
+            for (const { move, rank, loss } of listed) {
+                const mine = move.notation === advice.played.notation;
+                row(
+                    [
+                        String(rank),
+                        mine ? `${move.notation} ${ADVICE_TEXTS.you}` : move.notation,
+                        formatEquity(loss),
+                    ],
+                    mine,
+                );
+            }
+            element(details, "p", {
+                className: "explain-note",
+                text: ADVICE_TEXTS.moveNote(advice.ply),
+            });
+        } else {
+            // Les lignes de votre décision, en gras : doubler mène à l'une des
+            // deux lignes « Double », selon la réponse de l'ordinateur.
+            const mine = {
+                noDouble: ["noDouble"],
+                double: ["doubleTake", "doublePass"],
+                take: ["doubleTake"],
+                pass: ["doublePass"],
+            }[advice.action];
+            for (const key of ["noDouble", "doubleTake", "doublePass"] as const) {
+                const bold = mine.includes(key);
+                const name = ADVICE_TEXTS.cubeRows[key];
+                row(
+                    [
+                        "",
+                        bold && mine.length === 1 ? `${name} ${ADVICE_TEXTS.you}` : name,
+                        formatEquity(advice.equities[key]),
+                    ],
+                    bold,
+                );
+            }
+            element(details, "p", {
+                className: "explain-note",
+                text: `${ADVICE_TEXTS.cubeNote(advice.ply)}${formatEquity(advice.equityLoss)}.`,
+            });
+        }
+    }
+
+    return {
+        show,
+        hide() {
+            opened++;
+            player?.stop();
+            if (!veil.hidden) {
+                veil.hidden = true;
+                sheet.replaceChildren();
+            }
+        },
+    };
+}

app/src/ui/analysis-view.ts

@@ -0,0 +1,682 @@
+// L'écran d'analyse d'une partie (#/parties/<id>/analyse/<coup>, étape
+// 1e ; charte, ecrans-etape-1.md, « Analyse ») : une page qui défile, avec
+// la courbe de vos chances de gagner coup après coup, parcourue du doigt ;
+// le visualiseur du coup choisi (votre coup contre le coup du maître,
+// « Rejouer d'ici ») ; la liste des coups à revoir, filtrable ; et les
+// chiffres du moteur, repliés.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// La courbe est dessinée à la main en SVG (aucune bibliothèque). Chaque
+// coup y a une bande verticale sur toute la hauteur, cible du doigt : on
+// touche ou on glisse, et le coup sous le doigt est choisi. Le coup choisi
+// est dans l'adresse ; en changer remplace l'adresse (le retour du
+// téléphone quitte l'écran, il ne repasse pas par chaque coup).
+
+import {
+    chanceCurve,
+    computerMoveAdvice,
+    type GameSummary,
+    gameTurns,
+    mainAdvice,
+    replayPoint,
+    summarizeAnalysis,
+    type Turn,
+    type WinChanceCurve,
+} from "../domain/analysis/game-analysis.js";
+import { type MasterPhrases, masterWords } from "../domain/analysis/phrases.js";
+import { type Advice, type Verdict, verdictOf } from "../domain/game/advice.js";
+import type { GameJournal } from "../domain/game/events.js";
+import type { Game, MoveSteps } from "../domain/game/game.js";
+import { formatHalfMoves } from "../domain/game/position.js";
+import { VERDICT_ICONS } from "./advice-view.js";
+import { icon } from "./icons.js";
+import { MATCH_TEXTS } from "./match-texts.js";
+import { boardSvg, createMovePlayer, drawSteps, type MovePlayer } from "./move-board.js";
+import { percent, REVIEW_TEXTS, signed } from "./review-texts.js";
+import { routeHash } from "./router.js";
+
+/** Ce que montre l'écran. */
+export interface AnalysisData {
+    readonly id: string;
+    readonly journal: GameJournal;
+    /** La partie, pour rejouer les coups sur le plateau. */
+    readonly game: Game;
+    /** Le coup choisi (null : le coup à revoir, ou le premier). */
+    readonly turn: number | null;
+    readonly phrases: MasterPhrases | null;
+}
+
+export interface AnalysisViewOptions {
+    /** La page (index.html) ; son contenu est construit ici. */
+    readonly section: HTMLElement;
+    readonly reducedMotion: MediaQueryList;
+    /** Choisir un autre coup : remplacer l'adresse. */
+    readonly select: (turn: number) => void;
+    /** « Rejouer d'ici » : revenir à cet événement de la partie. */
+    readonly replay: (id: string, eventId: string) => void;
+    /** Le lien « Retour » (quitter l'écran sans empiler d'adresse). */
+    readonly back: (link: HTMLAnchorElement) => void;
+}
+
+export interface AnalysisView {
+    show(data: AnalysisData | null): void;
+    hide(): void;
+    /** ← et → : le coup d'avant ou d'après. */
+    step(delta: number): void;
+}
+
+type Filter = "all" | "errors" | "doubtful";
+type Shown = "mine" | "best";
+
+const SVG_NS = "http://www.w3.org/2000/svg";
+/** Hauteur de la courbe, et marges du tracé (repère en pixels). */
+const CURVE_HEIGHT = 168;
+const PAD = { left: 40, right: 10, top: 10, bottom: 10 };
+
+function element<K extends keyof HTMLElementTagNameMap>(
+    parent: HTMLElement,
+    tag: K,
+    options: { id?: string; className?: string; text?: string } = {},
+): HTMLElementTagNameMap[K] {
+    const child = document.createElement(tag);
+    if (options.id !== undefined) {
+        child.id = options.id;
+    }
+    if (options.className !== undefined) {
+        child.className = options.className;
+    }
+    if (options.text !== undefined) {
+        child.textContent = options.text;
+    }
+    parent.append(child);
+    return child;
+}
+
+function svgElement<K extends keyof SVGElementTagNameMap>(
+    parent: Element,
+    tag: K,
+    attributes: Record<string, string | number>,
+): SVGElementTagNameMap[K] {
+    const child = document.createElementNS(SVG_NS, tag);
+    for (const [name, value] of Object.entries(attributes)) {
+        child.setAttribute(name, String(value));
+    }
+    parent.append(child);
+    return child;
+}
+
+/** Les verdicts que montre chaque filtre. */
+const FILTERS: Readonly<Record<Filter, readonly Verdict[]>> = {
+    all: ["good", "doubtful", "bad", "veryBad"],
+    errors: ["bad", "veryBad"],
+    doubtful: ["doubtful"],
+};
+
+export function createAnalysisView(options: AnalysisViewOptions): AnalysisView {
+    const { section } = options;
+    let data: AnalysisData | null = null;
+    let turns: Turn[] = [];
+    let curve: WinChanceCurve = [];
+    let selected = 1;
+    let filter: Filter = "all";
+    // Ce qui est dessiné dans le visualiseur, pour ne pas rejouer le coup à
+    // chaque analyse rangée.
+    let drawnTurn = "";
+    let player: MovePlayer | null = null;
+    // Chaque changement de coup a son numéro : un plateau qui arrive trop
+    // tard n'est pas dessiné.
+    let request = 0;
+
+    // La page : en-tête, courbe, visualiseur, liste, chiffres.
+    const head = element(section, "div", { className: "analysis-head" });
+    const back = element(head, "a", {
+        id: "analysis-back",
+        className: "button secondary",
+        text: REVIEW_TEXTS.back,
+    });
+    back.href = "#/";
+    options.back(back);
+    element(head, "h2", {
+        id: "analysis-title",
+        className: "analysis-title",
+        text: REVIEW_TEXTS.analysisTitle,
+    });
+    const message = element(section, "p", {
+        id: "analysis-message",
+        className: "analysis-message",
+    });
+    message.setAttribute("role", "status");
+
+    const curveCard = element(section, "section", { className: "analysis-card curve-card" });
+    element(curveCard, "h3", { className: "overline", text: REVIEW_TEXTS.curveTitle });
+    const curveSvg = document.createElementNS(SVG_NS, "svg");
+    curveSvg.id = "analysis-curve";
+    curveSvg.setAttribute("class", "analysis-curve");
+    curveSvg.setAttribute("role", "slider");
+    curveSvg.setAttribute("tabindex", "0");
+    curveCard.append(curveSvg);
+
+    const viewer = element(section, "section", {
+        id: "analysis-viewer",
+        className: "analysis-card viewer",
+    });
+    const nav = element(viewer, "div", { className: "viewer-nav" });
+    const prev = element(nav, "a", { id: "analysis-prev", className: "icon-button viewer-step" });
+    prev.append(icon("chevron"));
+    prev.setAttribute("aria-label", REVIEW_TEXTS.previous);
+    const turnTitle = element(nav, "p", { id: "analysis-turn", className: "viewer-turn" });
+    turnTitle.setAttribute("aria-live", "polite");
+    const next = element(nav, "a", { id: "analysis-next", className: "icon-button viewer-step" });
+    next.append(icon("chevron"));
+    next.setAttribute("aria-label", REVIEW_TEXTS.next);
+    for (const [link, delta] of [
+        [prev, -1],
+        [next, 1],
+    ] as const) {
+        link.addEventListener("click", (event) => {
+            event.preventDefault();
+            step(delta);
+        });
+    }
+    const viewerBody = element(viewer, "div", { className: "viewer-body" });
+    const boardBox = element(viewerBody, "div", { className: "viewer-board-box" });
+    const board = boardSvg(boardBox, "analysis-board", "analysis-board");
+    player = createMovePlayer(board, "analysis-", options.reducedMotion);
+    const viewerText = element(viewerBody, "div", { className: "viewer-text" });
+    const phrase = element(viewerText, "p", { id: "analysis-phrase", className: "viewer-phrase" });
+    const choice = element(viewerText, "div", { id: "analysis-choice", className: "segmented" });
+    choice.setAttribute("role", "radiogroup");
+    choice.setAttribute("aria-label", REVIEW_TEXTS.choiceLabel);
+    const segments: Record<Shown, HTMLButtonElement> = {
+        mine: element(choice, "button", { id: "analysis-mine", className: "segment" }),
+        best: element(choice, "button", {
+            id: "analysis-best",
+            className: "segment",
+            text: REVIEW_TEXTS.masterMove,
+        }),
+    };
+    for (const key of ["mine", "best"] as const) {
+        segments[key].type = "button";
+        segments[key].setAttribute("role", "radio");
+    }
+    const legend = element(viewerText, "p", { id: "analysis-legend", className: "viewer-legend" });
+    const chanceLine = element(viewerText, "p", {
+        id: "analysis-chance",
+        className: "viewer-chance",
+    });
+    const viewerActions = element(viewerText, "div", { className: "viewer-actions" });
+    const replayButton = element(viewerActions, "button", {
+        id: "analysis-replay",
+        text: REVIEW_TEXTS.replayFromHere,
+    });
+    replayButton.type = "button";
+    // L'emplacement de « Demander à une IA » (étape 1f).
+    const slot = element(viewerActions, "div", { className: "ask-ai-slot" });
+    slot.dataset.slot = "ask-ai";
+    const replayHint = element(viewerText, "p", {
+        className: "viewer-legend",
+        text: REVIEW_TEXTS.replayHint,
+    });
+
+    const listCard = element(section, "section", { className: "analysis-card list-card" });
+    element(listCard, "h3", { className: "overline", text: REVIEW_TEXTS.listTitle });
+    const filters = element(listCard, "div", { id: "analysis-filters", className: "filters" });
+    filters.setAttribute("role", "group");
+    filters.setAttribute("aria-label", REVIEW_TEXTS.filterLabel);
+    const filterButtons: Record<Filter, HTMLButtonElement> = {
+        all: element(filters, "button", { className: "filter" }),
+        errors: element(filters, "button", { className: "filter" }),
+        doubtful: element(filters, "button", { className: "filter" }),
+    };
+    for (const key of ["all", "errors", "doubtful"] as const) {
+        const button = filterButtons[key];
+        button.type = "button";
+        button.dataset.filter = key;
+        button.onclick = () => {
+            filter = key;
+            renderList();
+        };
+    }
+    const list = element(listCard, "ul", { id: "analysis-list", className: "analysis-list" });
+
+    const numbers = element(section, "details", {
+        id: "analysis-numbers",
+        className: "analysis-card explain-numbers",
+    });
+    element(numbers, "summary", { text: REVIEW_TEXTS.numbers });
+    const table = element(numbers, "div", { className: "explain-table analysis-table" });
+    element(numbers, "p", { className: "explain-note", text: REVIEW_TEXTS.numbersNote });
+
+    // ------------------------------------------------------------ Courbe
+
+    /** Le coup sous l'abscisse x (pixels du tracé). */
+    function turnAt(x: number): number {
+        const width = curveSvg.getBoundingClientRect().width;
+        const inner = Math.max(1, width - PAD.left - PAD.right);
+        const index = Math.floor(((x - PAD.left) / inner) * turns.length);
+        return Math.min(turns.length, Math.max(1, index + 1));
+    }
+
+    let dragging = false;
+    curveSvg.addEventListener("pointerdown", (event) => {
+        dragging = true;
+        curveSvg.setPointerCapture?.(event.pointerId);
+        choose(turnAt(event.clientX - curveSvg.getBoundingClientRect().left));
+    });
+    curveSvg.addEventListener("pointermove", (event) => {
+        if (dragging) {
+            choose(turnAt(event.clientX - curveSvg.getBoundingClientRect().left));
+        }
+    });
+    for (const end of ["pointerup", "pointercancel"] as const) {
+        curveSvg.addEventListener(end, () => {
+            dragging = false;
+        });
+    }
+    curveSvg.addEventListener("keydown", (event) => {
+        if (event.key === "ArrowLeft" || event.key === "ArrowRight") {
+            event.preventDefault();
+            event.stopPropagation();
+            step(event.key === "ArrowLeft" ? -1 : 1);
+        }
+    });
+
+    function renderCurve(): void {
+        const width = Math.round(curveSvg.getBoundingClientRect().width || 360);
+        const height = CURVE_HEIGHT;
+        curveSvg.setAttribute("viewBox", `0 0 ${width} ${height}`);
+        curveSvg.replaceChildren();
+        const inner = width - PAD.left - PAD.right;
+        const band = turns.length > 0 ? inner / turns.length : inner;
+        const x = (turn: number) => PAD.left + (turn - 0.5) * band;
+        const y = (chance: number) => PAD.top + (1 - chance) * (height - PAD.top - PAD.bottom);
+        // Axe : 100 %, 50 % (pointillé), 0 %.
+        for (const level of [1, 0.5, 0]) {
+            svgElement(curveSvg, "line", {
+                x1: PAD.left,
+                x2: width - PAD.right,
+                y1: y(level),
+                y2: y(level),
+                class: level === 0.5 ? "curve-half" : "curve-axis",
+            });
+            const label = svgElement(curveSvg, "text", {
+                x: PAD.left - 6,
+                y: y(level) + 4,
+                class: "curve-label",
+                "text-anchor": "end",
+            });
+            label.textContent = percent(level);
+        }
+        const known = curve.filter((p) => p.chance !== null) as {
+            turn: number;
+            chance: number;
+            verdict: Verdict | null;
+            side: string;
+        }[];
+        if (known.length > 0) {
+            const line = known.map((p) => `${x(p.turn)},${y(p.chance)}`).join(" ");
+            const first = known[0] as { turn: number };
+            const last = known.at(-1) as { turn: number };
+            svgElement(curveSvg, "polygon", {
+                points: `${x(first.turn)},${y(0)} ${line} ${x(last.turn)},${y(0)}`,
+                class: "curve-area",
+            });
+            svgElement(curveSvg, "polyline", { points: line, class: "curve-line" });
+        }
+        // Le coup choisi : un trait vertical brique.
+        svgElement(curveSvg, "line", {
+            x1: x(selected),
+            x2: x(selected),
+            y1: PAD.top,
+            y2: height - PAD.bottom,
+            class: "curve-cursor",
+        });
+        for (const point of known) {
+            const commented = point.verdict !== null;
+            svgElement(curveSvg, "circle", {
+                cx: x(point.turn),
+                cy: y(point.chance),
+                r: commented ? 4 : 2,
+                class: commented ? `curve-dot verdict-${point.verdict}` : "curve-dot other",
+            });
+        }
+        const chosen = curve[selected - 1];
+        if (chosen?.chance != null) {
+            svgElement(curveSvg, "circle", {
+                cx: x(selected),
+                cy: y(chosen.chance),
+                r: 7,
+                class: "curve-ring",
+            });
+        }
+        // Les bandes, sur toute la hauteur : cibles du doigt.
+        for (const turn of turns) {
+            const rect = svgElement(curveSvg, "rect", {
+                x: PAD.left + (turn.number - 1) * band,
+                y: 0,
+                width: band,
+                height,
+                class: turn.number === selected ? "curve-band selected" : "curve-band",
+            });
+            rect.dataset.turn = String(turn.number);
+        }
+        const chance = chosen?.chance;
+        curveSvg.setAttribute("aria-valuemin", "1");
+        curveSvg.setAttribute("aria-valuemax", String(turns.length));
+        curveSvg.setAttribute("aria-valuenow", String(selected));
+        const spoken =
+            chance === null || chance === undefined ? REVIEW_TEXTS.curveUnknown : percent(chance);
+        curveSvg.setAttribute("aria-valuetext", spoken);
+        curveSvg.setAttribute(
+            "aria-label",
+            REVIEW_TEXTS.curveLabel(selected, turns.length, spoken),
+        );
+    }
+
+    // -------------------------------------------------------- Visualiseur
+
+    function renderViewer(): void {
+        const current = data;
+        const turn = turns[selected - 1];
+        if (current === null || turn === undefined) {
+            return;
+        }
+        prev.href = routeHash({
+            screen: "analysis",
+            game: current.id,
+            turn: Math.max(1, selected - 1),
+        });
+        next.href = routeHash({
+            screen: "analysis",
+            game: current.id,
+            turn: Math.min(turns.length, selected + 1),
+        });
+        prev.setAttribute("aria-disabled", String(selected <= 1));
+        next.setAttribute("aria-disabled", String(selected >= turns.length));
+        const roll = turn.roll === null ? "" : ` · ${REVIEW_TEXTS.roll(turn.roll)}`;
+        turnTitle.textContent = `${REVIEW_TEXTS.turnOf(selected, turns.length)}${roll}`;
+        const chance = curve[selected - 1]?.chance;
+        chanceLine.textContent =
+            chance === null || chance === undefined
+                ? ""
+                : REVIEW_TEXTS.chanceAfter(percent(chance));
+
+        const main = mainAdvice(current.journal, turn);
+        const theirs = computerMoveAdvice(current.journal, turn);
+        const key = [
+            current.id,
+            selected,
+            main?.eventId ?? "",
+            theirs?.eventId ?? "",
+            current.phrases !== null,
+        ].join("|");
+        replayButton.hidden = replayPoint(current.journal, turn) === null;
+        replayHint.hidden = replayButton.hidden;
+        replayButton.onclick = () => {
+            const point = replayPoint(current.journal, turn);
+            if (point !== null) {
+                options.replay(current.id, point);
+            }
+        };
+        if (key === drawnTurn) {
+            return;
+        }
+        drawnTurn = key;
+        player?.stop();
+        phrase.replaceChildren();
+        delete phrase.dataset.verdict;
+        legend.textContent = "";
+        const id = ++request;
+
+        // Ce qu'en dit le maître : la décision du joueur à revoir, ou ce
+        // qu'a fait l'ordinateur.
+        if (main !== null && current.phrases !== null) {
+            const words = masterWords(current.phrases, main);
+            phrase.dataset.verdict = words.verdict;
+            const word = document.createElement("strong");
+            word.append(icon(VERDICT_ICONS[words.verdict]), `${words.word}.`);
+            const said = document.createElement("em");
+            said.textContent = words.phrase;
+            phrase.append(word, " ", said);
+        } else if (turn.side === "computer") {
+            phrase.textContent =
+                turn.move === null
+                    ? REVIEW_TEXTS.computerCube
+                    : turn.move.halfMoves.length === 0
+                      ? REVIEW_TEXTS.computerCannotMove
+                      : REVIEW_TEXTS.computerPlayed(
+                            theirs?.played.notation ?? formatHalfMoves(turn.move.halfMoves),
+                        );
+        } else if (turn.move !== null && turn.move.halfMoves.length === 0) {
+            phrase.textContent = REVIEW_TEXTS.playerCannotMove;
+        }
+
+        // Le plateau : le coup joué et, s'il diffère, le meilleur coup.
+        void (async () => {
+            const side = turn.side;
+            let mine: MoveSteps | null = null;
+            let best: MoveSteps | null = null;
+            // Les coups s'écrivent dans la notation du moteur, comme dans le
+            // bilan et la feuille du maître (« 6/off », pas « 6/5 5/off ») ;
+            // à défaut d'analyse, à partir des demi-coups.
+            let names = { mine: "", best: "" };
+            const moveAdvice: Advice | null = side === "player" ? main : theirs;
+            try {
+                if (moveAdvice?.kind === "move") {
+                    mine = await current.game.stepsBefore(
+                        moveAdvice.eventId,
+                        side,
+                        moveAdvice.played.halfMoves,
+                    );
+                    names = {
+                        mine: moveAdvice.played.notation,
+                        best: moveAdvice.best.notation,
+                    };
+                    if (moveAdvice.rank > 1) {
+                        best = await current.game.stepsBefore(
+                            moveAdvice.eventId,
+                            side,
+                            moveAdvice.best.halfMoves,
+                        );
+                    }
+                } else if (moveAdvice?.kind === "cube") {
+                    mine = await current.game.stepsBefore(moveAdvice.eventId, "player", []);
+                } else if (turn.move !== null) {
+                    mine = await current.game.stepsBefore(turn.move.id, side, turn.move.halfMoves);
+                    names = { mine: formatHalfMoves(turn.move.halfMoves), best: "" };
+                } else {
+                    const first = turn.events[0];
+                    mine =
+                        first === undefined
+                            ? null
+                            : await current.game.stepsBefore(first.id, side, []);
+                }
+            } catch {
+                mine = null;
+            }
+            if (id !== request || mine === null) {
+                return;
+            }
+            showMoves(mine, best, side, names);
+        })();
+    }
+
+    function showMoves(
+        mine: MoveSteps,
+        best: MoveSteps | null,
+        side: "player" | "computer",
+        names: { readonly mine: string; readonly best: string },
+    ): void {
+        const who = side === "player" ? REVIEW_TEXTS.yourMoveSegment : REVIEW_TEXTS.theirMove;
+        segments.mine.textContent = who;
+        choice.hidden = best === null;
+        const select = (shown: Shown) => {
+            const steps = shown === "best" && best !== null ? best : mine;
+            for (const key of ["mine", "best"] as const) {
+                segments[key].setAttribute("aria-checked", String(key === shown));
+            }
+            board.dataset.move = shown;
+            if (steps.halfMoves.length === 0) {
+                legend.textContent = REVIEW_TEXTS.legendPosition;
+                board.setAttribute("aria-label", REVIEW_TEXTS.legendPosition);
+                drawSteps(board, steps, 0, false, "analysis-");
+                return;
+            }
+            const text = REVIEW_TEXTS.legendMove(
+                shown === "best" ? REVIEW_TEXTS.masterMove : who,
+                shown === "best" ? names.best : names.mine,
+            );
+            legend.textContent = text;
+            board.setAttribute("aria-label", text);
+            void player?.play(steps);
+        };
+        segments.mine.onclick = () => select("mine");
+        segments.best.onclick = () => select("best");
+        choice.onkeydown = (event) => {
+            if (event.key === "ArrowLeft" || event.key === "ArrowRight") {
+                event.preventDefault();
+                event.stopPropagation();
+                const nextShown =
+                    segments.mine.getAttribute("aria-checked") === "true" ? "best" : "mine";
+                select(nextShown);
+                segments[nextShown].focus();
+            }
+        };
+        select("mine");
+    }
+
+    // -------------------------------------------------------------- Liste
+
+    function renderList(): void {
+        const current = data;
+        if (current === null) {
+            return;
+        }
+        const rows = turns
+            .map((turn) => ({ turn, advice: mainAdvice(current.journal, turn) }))
+            .filter((row): row is { turn: Turn; advice: Advice } => row.advice !== null);
+        const count = (f: Filter) =>
+            rows.filter((r) => FILTERS[f].includes(verdictOf(r.advice.skill))).length;
+        for (const key of ["all", "errors", "doubtful"] as const) {
+            filterButtons[key].textContent = `${REVIEW_TEXTS.filters[key]} · ${count(key)}`;
+            filterButtons[key].setAttribute("aria-pressed", String(key === filter));
+        }
+        list.replaceChildren();
+        const shown = rows.filter((r) => FILTERS[filter].includes(verdictOf(r.advice.skill)));
+        if (shown.length === 0) {
+            element(list, "li", { className: "analysis-empty", text: REVIEW_TEXTS.emptyFilter });
+            return;
+        }
+        for (const { turn, advice } of shown) {
+            const item = element(list, "li");
+            const link = element(item, "a", { className: "analysis-row" });
+            link.href = routeHash({ screen: "analysis", game: current.id, turn: turn.number });
+            link.dataset.turn = String(turn.number);
+            if (turn.number === selected) {
+                link.setAttribute("aria-current", "true");
+            }
+            const verdict = verdictOf(advice.skill);
+            const word = current.phrases === null ? "" : masterWords(current.phrases, advice).word;
+            const roll = turn.roll === null ? "" : REVIEW_TEXTS.roll(turn.roll);
+            const move =
+                advice.kind === "move"
+                    ? advice.played.notation
+                    : REVIEW_TEXTS.cubeActions[advice.action];
+            link.setAttribute("aria-label", REVIEW_TEXTS.rowLabel(turn.number, roll, move, word));
+            element(link, "span", { className: "row-number", text: String(turn.number) });
+            element(link, "span", { className: "row-roll", text: roll });
+            element(link, "span", { className: "row-move", text: move });
+            const mark = element(link, "span", { className: "row-word" });
+            mark.dataset.verdict = verdict;
+            mark.append(icon(VERDICT_ICONS[verdict]), word);
+            link.addEventListener("click", (event) => {
+                if (event.button !== 0 || event.ctrlKey || event.metaKey || event.shiftKey) {
+                    return;
+                }
+                event.preventDefault();
+                choose(turn.number);
+            });
+        }
+    }
+
+    // ------------------------------------------------- Chiffres du moteur
+
+    function renderNumbers(summary: GameSummary): void {
+        table.replaceChildren();
+        const cell = (text: string, className = "") => element(table, "span", { className, text });
+        cell("");
+        cell(REVIEW_TEXTS.numbersHead.you, "strong");
+        cell(REVIEW_TEXTS.numbersHead.computer, "strong");
+        const rows: [string, (s: GameSummary["player"]) => string][] = [
+            [REVIEW_TEXTS.numbersRows.errorRate, (s) => signed(-s.errorRate.perDecision)],
+            [REVIEW_TEXTS.numbersRows.decisions, (s) => String(s.errorRate.decisions)],
+            [REVIEW_TEXTS.numbersRows.level, (s) => MATCH_TEXTS.levels[s.errorRate.level].name],
+            [REVIEW_TEXTS.numbersRows.luck, (s) => signed(s.luck.perRoll)],
+        ];
+        for (const [name, value] of rows) {
+            cell(name);
+            cell(value(summary.player));
+            cell(value(summary.computer));
+        }
+    }
+
+    // ---------------------------------------------------------- Ensemble
+
+    function choose(turn: number): void {
+        if (turn === selected || turn < 1 || turn > turns.length) {
+            return;
+        }
+        selected = turn;
+        renderCurve();
+        renderViewer();
+        renderList();
+        options.select(turn);
+    }
+
+    function step(delta: number): void {
+        choose(selected + delta);
+    }
+
+    window.addEventListener("resize", () => {
+        if (!section.hidden && data !== null) {
+            renderCurve();
+        }
+    });
+
+    return {
+        show(next) {
+            data = next;
+            if (next === null) {
+                message.textContent = REVIEW_TEXTS.missingGame;
+                curveCard.hidden = true;
+                viewer.hidden = true;
+                listCard.hidden = true;
+                numbers.hidden = true;
+                return;
+            }
+            turns = gameTurns(next.journal);
+            curve = chanceCurve(next.journal);
+            const summary = summarizeAnalysis(next.journal);
+            const fallback = summary.toReview?.turn ?? 1;
+            selected = Math.min(Math.max(1, next.turn ?? fallback), Math.max(1, turns.length));
+            message.textContent = turns.length === 0 ? REVIEW_TEXTS.emptyFilter : "";
+            curveCard.hidden = turns.length === 0;
+            viewer.hidden = turns.length === 0;
+            listCard.hidden = turns.length === 0;
+            numbers.hidden = turns.length === 0;
+            renderCurve();
+            renderViewer();
+            renderList();
+            renderNumbers(summary);
+        },
+        hide() {
+            data = null;
+            drawnTurn = "";
+            player?.stop();
+            request++;
+        },
+        step,
+    };
+}

app/src/ui/app.ts

@@ -21,6 +21,14 @@
 // dessine l'écran que désigne l'adresse, au démarrage et à chaque
 // changement. Les actions de jeu restent des boutons.
 
+import { missingAnalyses, readyForSummary } from "../domain/analysis/game-analysis.js";
+import {
+    type MasterPhrases,
+    masterLine,
+    masterWords,
+    parsePhrases,
+} from "../domain/analysis/phrases.js";
+import type { Advice } from "../domain/game/advice.js";
 import type { Cube } from "../domain/game/cube.js";
 import type { GameJournal } from "../domain/game/events.js";
 import type { Game, MoveSteps, NewGame, SideBoards } from "../domain/game/game.js";
@@ -29,6 +37,10 @@ import { type PositionLink, type SharedPosition, setupOf } from "../domain/game/
 import type { SavedGameSummary } from "../domain/game/saved-game.js";
 import { otherSide, type Side } from "../domain/game/side.js";
 import type { GameState } from "../domain/game/state.js";
+import { ADVICE_TEXTS } from "./advice-texts.js";
+import { type Analyse, createAdviceTracker } from "./advice-tracker.js";
+import { createAdviceView, VERDICT_ICONS } from "./advice-view.js";
+import { createAnalysisView } from "./analysis-view.js";
 import {
     boardModel,
     moveTargets,
@@ -40,6 +52,7 @@ import {
     placeOf,
 } from "./board-model.js";
 import {
+    type BoardAdvice,
     type BoardDecor,
     checkerSpot,
     type DiceAction,
@@ -63,6 +76,7 @@ import { installPlatform, startInstaller } from "./install.js";
 import { MATCH_TEXTS } from "./match-texts.js";
 import { replacingLink, startNavigation } from "./navigation.js";
 import { createNewGameView } from "./new-game-view.js";
+import { createReviewRunner, type RunAnalysis } from "./review-runner.js";
 import { isHelpScreen, type Route, routeHash } from "./router.js";
 import {
     chosenGame,
@@ -72,6 +86,7 @@ import {
     parseSettings,
     type Settings,
 } from "./settings.js";
+import { createSummaryView } from "./summary-view.js";
 import { type PromptText, TEXTS } from "./texts.js";
 import { seenAfter } from "./tutorial-nav.js";
 import { createTutorialView, type TutorialAccess } from "./tutorial-view.js";
@@ -119,8 +134,17 @@ export interface AppOptions {
     /** Les mises à jour de l'application (service worker) : onAvailable est
      * appelé quand une nouvelle version attend. */
     readonly startUpdates: (onAvailable: () => void) => Updates;
+    /** Le conseil du maître : l'analyse d'une décision du joueur, sur un
+     * moteur à part (elle ne retarde jamais la partie). */
+    readonly analyse: Analyse;
+    /** L'analyse d'une partie pour son bilan (étape 1e), une analyse à la
+     * fois, sur le même moteur à part. */
+    readonly analyseGame: RunAnalysis;
 }
 
+/** La source des phrases du maître, copiée dans le site (make site). */
+const PHRASES_SOURCE = "docs/maitre/phrases.md";
+
 /** Ce que « Mes parties » demande au stockage. */
 export interface SavedGamesAccess {
     /** Les parties, la dernière jouée d'abord. */
@@ -131,6 +155,12 @@ export interface SavedGamesAccess {
     /** Une partie reprise, au bout de la branche branchHead si elle est
      * donnée ; elle devient la partie à l'écran. */
     readonly open: (id: string, branchHead?: string) => Promise<Game>;
+    /** Une partie enregistrée, reprise pour la regarder (bilan, analyse)
+     * sans qu'elle devienne la partie à l'écran ; null si elle n'existe
+     * pas ou est illisible. */
+    readonly view: (id: string) => Promise<Game | null>;
+    /** Enregistre les analyses d'une partie qui n'est pas à l'écran. */
+    readonly saveAnalyses: (id: string, journal: GameJournal) => void;
     readonly remove: (id: string) => Promise<void>;
     readonly exportSgf: (id: string) => Promise<{ fileName: string; text: string }>;
 }
@@ -194,6 +224,11 @@ export function startApp(options: AppOptions): void {
         board: byId("board") as unknown as SVGSVGElement,
         boardBox: child<HTMLElement>(document.documentElement, ".board-box"),
         info: byId("info"),
+        adviceLine: byId<HTMLAnchorElement>("advice-line"),
+        explainVeil: byId("explain-veil"),
+        summaryVeil: byId("summary-veil"),
+        analysis: byId("analysis"),
+        menuAdvice: byId<HTMLButtonElement>("menu-advice"),
         prompt: byId("prompt"),
         strips: { computer: stripOf("strip-computer"), player: stripOf("strip-player") },
         bubble: byId("pip-bubble"),
@@ -341,6 +376,8 @@ export function startApp(options: AppOptions): void {
     label(ui.menuHelp, TEXTS.helpAndGlossary, "help");
     ui.menuTheme.prepend(icon("theme"));
     child(ui.menuTheme, ".item-label").textContent = TEXTS.theme;
+    ui.menuAdvice.prepend(icon("verdictGood"));
+    child(ui.menuAdvice, ".item-label").textContent = ADVICE_TEXTS.menuSwitch;
     ui.menuVibrations.prepend(icon("vibrate"));
     child(ui.menuVibrations, ".item-label").textContent = TEXTS.vibrations;
     ui.menuScreenOn.prepend(icon("screenOn"));
@@ -434,6 +471,36 @@ export function startApp(options: AppOptions): void {
     // Les parties jouées et gagnées, lues dans « Mes parties » pour
     // l'accueil.
     let homeProgress: { played: number; won: number } | null = null;
+    // Le conseil du maître : ses phrases (lues une fois), les analyses en
+    // cours et la ligne à montrer.
+    let phrases: MasterPhrases | null = null;
+    const phrasesLoading: Promise<MasterPhrases> = fetch(PHRASES_SOURCE)
+        .then((response) => {
+            if (!response.ok) {
+                throw new Error(`phrases du maître : ${response.status}`);
+            }
+            return response.text();
+        })
+        .then((text) => {
+            phrases = parsePhrases(text);
+            render();
+            return phrases;
+        });
+    phrasesLoading.catch(() => undefined);
+    const adviceTracker = createAdviceTracker({
+        analyse: options.analyse,
+        // Le conseil rattaché au journal est enregistré avec la partie, si
+        // elle est toujours à l'écran.
+        recorded: (g) => {
+            if (g === game) {
+                save();
+            }
+        },
+        changed: () => render(),
+    });
+    // La ligne du maître dessinée (identifiant de sa décision) : elle n'est
+    // reconstruite, en fondu, que si elle change.
+    let adviceDrawn: string | null = null;
 
     const landscapeQuery = window.matchMedia("(orientation: landscape) and (max-height: 40rem)");
     const portraitQuery = window.matchMedia("(orientation: portrait)");
@@ -543,6 +610,7 @@ export function startApp(options: AppOptions): void {
                             : bandText(text.short, state.match?.crawford === true)
                         : null,
                 controls: landscape ? controls() : null,
+                advice: landscape && !panelShown ? boardAdvice(shownAdvice()) : null,
             });
         }
         renderStrips(model.pipCount, state.phase === "over" ? null : state.turn);
@@ -550,6 +618,8 @@ export function startApp(options: AppOptions): void {
 
         // Ligne d'information : un jet sans coup possible reste annoncé
         // jusqu'à l'action suivante, même après un rechargement de la page.
+        const advice = shownAdvice();
+        renderAdviceLine(notice === null && !stuck ? advice : null);
         if (notice !== null) {
             ui.info.textContent = notice;
         } else if (stuck && state.roll !== null) {
@@ -610,6 +680,70 @@ export function startApp(options: AppOptions): void {
         document.body.classList.toggle("busy", busy);
         announceEnd(game);
         void keepScreenOn(isPlaying(game) || state.phase === "doubled");
+        reviewFinishedGame();
+    }
+
+    /** Le conseil du maître à montrer : le réglage le permet, ses phrases
+     * sont lues, et l'analyse attendue est prête. */
+    function shownAdvice(): {
+        advice: Advice;
+        line: string;
+        words: ReturnType<typeof masterWords>;
+    } | null {
+        const advice = adviceTracker.shown;
+        if (!settings.masterAdvice || phrases === null || advice === null) {
+            return null;
+        }
+        const words = masterWords(phrases, advice);
+        return { advice, line: masterLine(words), words };
+    }
+
+    /** Portrait : la ligne du maître à la place du dernier coup (charte 1d) :
+     * pictogramme, mot en couleur, phrase en italique, chevron ; un lien vers
+     * la feuille d'explication. */
+    function renderAdviceLine(shown: ReturnType<typeof shownAdvice>): void {
+        ui.info.hidden = shown !== null;
+        ui.adviceLine.hidden = shown === null;
+        const id = shown?.advice.eventId ?? null;
+        if (shown === null || id === adviceDrawn) {
+            adviceDrawn = id;
+            return;
+        }
+        adviceDrawn = id;
+        const link = ui.adviceLine;
+        link.replaceChildren();
+        link.href = routeHash({ screen: "explanation", event: shown.advice.eventId });
+        link.dataset.verdict = shown.words.verdict;
+        link.setAttribute("aria-label", ADVICE_TEXTS.lineLabel(shown.line));
+        link.append(icon(VERDICT_ICONS[shown.words.verdict]));
+        const text = document.createElement("span");
+        text.className = "advice-text";
+        const word = document.createElement("strong");
+        word.className = "advice-word";
+        word.textContent = `${shown.words.word}.`;
+        const phrase = document.createElement("em");
+        phrase.className = "advice-phrase";
+        phrase.textContent = shown.words.phrase;
+        text.append(word, " ", phrase);
+        link.append(text, icon("chevron"));
+        // Le fondu d'apparition repart à chaque nouvelle ligne.
+        link.classList.remove("appear");
+        void link.offsetWidth;
+        link.classList.add("appear");
+    }
+
+    /** Paysage : la pastille du conseil dans la bande centrale. */
+    function boardAdvice(shown: ReturnType<typeof shownAdvice>): BoardAdvice | null {
+        if (shown === null) {
+            return null;
+        }
+        return {
+            href: routeHash({ screen: "explanation", event: shown.advice.eventId }),
+            verdict: shown.words.verdict,
+            icon: VERDICT_ICONS[shown.words.verdict],
+            word: shown.words.word,
+            label: ADVICE_TEXTS.chipLabel(shown.line),
+        };
     }
 
     /** Avant que le moteur réponde : le dernier plateau affiché (ou la
@@ -723,7 +857,13 @@ export function startApp(options: AppOptions): void {
     /** Le panneau centré : fin de partie, ou double de l'ordinateur en
      * paysage (en portrait, la barre d'actions s'en charge). */
     function renderPanel(g: Game, landscape: boolean, doubled: boolean): void {
-        const over = g.state.phase === "over" && !panelDismissed;
+        // Le panneau appartient à l'écran de jeu : ni sur une page, ni sous
+        // le bilan.
+        const over =
+            g.state.phase === "over" &&
+            !panelDismissed &&
+            !ui.game.hidden &&
+            navigation.route.screen !== "summary";
         const ask = landscape && doubled;
         ui.panelVeil.hidden = !(over || ask);
         const overline = byId("panel-overline");
@@ -758,6 +898,7 @@ export function startApp(options: AppOptions): void {
         );
         child(ui.menuTheme, ".item-value").textContent = TEXTS.themes[settings.theme];
         ui.menuVibrations.setAttribute("aria-checked", String(settings.vibrations));
+        ui.menuAdvice.setAttribute("aria-checked", String(settings.masterAdvice));
         ui.menuScreenOn.setAttribute("aria-checked", String(settings.keepScreenOn));
     }
 
@@ -973,11 +1114,19 @@ export function startApp(options: AppOptions): void {
         bubbleSide = null;
         notice = null;
         ui.bubble.hidden = true;
+        // L'action suivante du joueur efface la ligne du maître.
+        adviceTracker.clear();
         render();
         const before = game;
+        const lineBefore = game.events;
         const wasOver = game.state.phase === "over";
         try {
             await action(game);
+            // Ses décisions partent à l'analyse, sans être attendues : le
+            // tour de l'ordinateur suit tout de suite.
+            if (game === before) {
+                adviceTracker.track(game, lineBefore);
+            }
             save();
             await computerTurns();
             // Une partie vient de se terminer (pas une partie finie
@@ -996,6 +1145,9 @@ export function startApp(options: AppOptions): void {
     /** Commence une partie : celle des choix de l'écran « Nouvelle partie »
      * si rien d'autre n'est demandé. */
     function startNewGame(chosen: NewGame = chosenGame(settings)): void {
+        // L'analyse d'une partie passée laisse le moteur à part au conseil
+        // du maître.
+        reviewRunner.stop();
         game = options.newGame(chosen);
         panelDismissed = false;
         announcedEnd = null;
@@ -1082,7 +1234,11 @@ export function startApp(options: AppOptions): void {
     // L'adresse de la page dit quel écran montrer (applyRoute, plus bas).
     const navigation = startNavigation((route) => applyRoute(route));
     const isSheet = (route: Route) =>
-        route.screen === "menu" || route.screen === "games" || route.screen === "install";
+        route.screen === "menu" ||
+        route.screen === "games" ||
+        route.screen === "install" ||
+        route.screen === "explanation" ||
+        route.screen === "summary";
 
     // « Mes parties » : reprendre une partie (ou une branche) en change à
     // l'écran, sans recharger la page.
@@ -1106,6 +1262,183 @@ export function startApp(options: AppOptions): void {
 
     const helpView = createHelpView(ui.helpContent, ui.helpTabs);
 
+    // La feuille d'explication du maître (#/explication/<événement>).
+    const adviceView = createAdviceView({
+        veil: ui.explainVeil,
+        game: () => game,
+        phrases: () => phrasesLoading,
+        reducedMotion,
+        close: () => leaveSheet(),
+    });
+
+    // ------------------------------------------- Bilan et analyse (1e)
+
+    // Les analyses qui manquent à une partie, en arrière-plan, sur le
+    // moteur à part ; la partie regardée (bilan, analyse) et son journal.
+    const reviewRunner = createReviewRunner(options.analyseGame);
+    let reviewed: { id: string; journal: GameJournal; game: Game } | null = null;
+
+    const summaryView = createSummaryView({
+        veil: ui.summaryVeil,
+        close: () => leaveSheet(),
+        again: () => afterGame(),
+    });
+
+    const analysisView = createAnalysisView({
+        section: ui.analysis,
+        reducedMotion,
+        select: (turn) => {
+            const route = navigation.route;
+            if (route.screen === "analysis") {
+                navigation.replace(routeHash({ ...route, turn }));
+            }
+        },
+        replay: (id, eventId) => void replayFrom(id, eventId),
+        back: (link) => leavingLink(link, (route) => route.screen === "analysis"),
+    });
+
+    /** La partie à l'écran, si c'est la partie id. */
+    function liveGame(id: string): Game | null {
+        return game !== null && options.games.shownId() === id ? game : null;
+    }
+
+    /** Ouvre le bilan ou l'analyse de la partie id, et lance ce qui manque
+     * à son analyse. */
+    async function openReview(id: string): Promise<void> {
+        const live = liveGame(id);
+        if (live !== null) {
+            reviewed = { id, journal: live.journal, game: live };
+        } else if (reviewed?.id !== id) {
+            const [journal, viewed] = await Promise.all([
+                options.games.journal(id),
+                options.games.view(id),
+            ]);
+            reviewed = journal === null || viewed === null ? null : { id, journal, game: viewed };
+            if (reviewed === null) {
+                showReview(id, true);
+                return;
+            }
+        }
+        if (reviewed !== null) {
+            review(reviewed.id, reviewed.journal);
+        }
+        showReview(id, false);
+    }
+
+    /** Lance l'analyse de ce qui manque à la partie id (rien si tout est
+     * là, ou si elle est déjà en cours). */
+    function review(id: string, journal: GameJournal): void {
+        if (missingAnalyses(journal).length === 0) {
+            return;
+        }
+        reviewRunner.start(id, journal, (analysed) => {
+            const live = liveGame(id);
+            if (live !== null) {
+                live.recordAnalyses(analysed);
+                save();
+            } else {
+                options.games.saveAnalyses(id, analysed);
+            }
+            if (reviewed?.id === id) {
+                reviewed = { ...reviewed, journal: live?.journal ?? analysed };
+            }
+            showReview(id, false);
+            render();
+        });
+    }
+
+    /** L'analyse en cours d'une partie qui n'est ni regardée ni à l'écran
+     * s'arrête : le moteur à part revient au conseil du maître. */
+    function stopForeignReview(): void {
+        const running = reviewRunner.running;
+        if (running !== null && liveGame(running) === null) {
+            reviewRunner.stop();
+        }
+    }
+
+    /** Redessine le bilan ou l'analyse de la partie id, s'ils sont à
+     * l'écran. */
+    function showReview(id: string, missing: boolean): void {
+        const route = navigation.route;
+        if ((route.screen !== "summary" && route.screen !== "analysis") || route.game !== id) {
+            return;
+        }
+        const live = liveGame(id);
+        const shown =
+            missing || reviewed?.id !== id
+                ? null
+                : { ...reviewed, journal: live?.journal ?? reviewed.journal };
+        if (route.screen === "summary") {
+            summaryView.show(
+                shown === null
+                    ? null
+                    : {
+                          id,
+                          journal: shown.journal,
+                          game: shown.game,
+                          end: shown.game.state.phase === "over" ? endParts(shown.game) : null,
+                          afterLabel: live === null ? null : afterGameLabel(live),
+                          phrases,
+                      },
+            );
+        } else {
+            analysisView.show(
+                shown === null
+                    ? null
+                    : {
+                          id,
+                          journal: shown.journal,
+                          game: shown.game,
+                          turn: route.turn,
+                          phrases,
+                      },
+            );
+        }
+    }
+
+    /**
+     * La partie à l'écran vient de finir : son analyse part en
+     * arrière-plan, et le bilan remplace le panneau de fin de partie dès
+     * qu'il est prêt (charte 1e), si le panneau est toujours là.
+     */
+    function reviewFinishedGame(): void {
+        const id = options.games.shownId();
+        if (game === null || id === null || busy || game.state.phase !== "over") {
+            return;
+        }
+        // L'analyse d'une autre partie, regardée, passe d'abord.
+        const running = reviewRunner.running;
+        if (running === null || running === id) {
+            review(id, game.journal);
+        }
+        if (
+            navigation.route.screen === "game" &&
+            !panelDismissed &&
+            phrases !== null &&
+            readyForSummary(game.journal)
+        ) {
+            queueMicrotask(() => {
+                if (navigation.route.screen === "game" && !panelDismissed) {
+                    navigation.go(routeHash({ screen: "summary", game: id }));
+                }
+            });
+        }
+    }
+
+    /** « Rejouer d'ici » : la partie id reprend à l'événement eventId ; le
+     * prochain coup ouvre une branche, la partie d'origine reste. */
+    async function replayFrom(id: string, eventId: string): Promise<void> {
+        if (busy) {
+            return;
+        }
+        reviewRunner.stop();
+        const other = await options.games.open(id);
+        other.goBackTo(eventId);
+        hideBanner();
+        navigation.replace("#/");
+        await act(() => showGame(other));
+    }
+
     /** Joue un demi-coup du joueur ; le coup attend ensuite sa suite ou sa
      * validation. Le pion qui se pose vibre (deux fois s'il frappe). */
     function playHalfMove(halfMove: HalfMove): void {
@@ -1233,6 +1566,8 @@ export function startApp(options: AppOptions): void {
                 navigation.leave((r) => r.screen === "position");
             } else if (route.screen === "newGame") {
                 navigation.leave((r) => r.screen === "newGame");
+            } else if (route.screen === "analysis") {
+                navigation.leave((r) => r.screen === "analysis");
             } else if (route.screen === "tutorial" || route.screen === "tutorialEnd") {
                 navigation.leave((r) => r.screen === "tutorial" || r.screen === "tutorialEnd");
             }
@@ -1275,6 +1610,12 @@ export function startApp(options: AppOptions): void {
         ui.menuVeil.hidden = true;
         ui.installVeil.hidden = true;
         gamesView?.hide();
+        adviceView.hide();
+        if (summaryView.isOpen) {
+            // Le bilan fermé laisse voir la partie finie, sans le panneau.
+            panelDismissed = true;
+            summaryView.hide();
+        }
         if (menuWasOpen) {
             (menuReturnFocus ?? ui.menuButton).focus();
         }
@@ -1345,6 +1686,7 @@ export function startApp(options: AppOptions): void {
     ui.menuFullscreen.onclick = actions.fullscreen;
     ui.menuTheme.onclick = () => saveSettings({ theme: nextTheme(settings.theme) });
     ui.menuVibrations.onclick = () => saveSettings({ vibrations: !settings.vibrations });
+    ui.menuAdvice.onclick = () => saveSettings({ masterAdvice: !settings.masterAdvice });
     ui.menuScreenOn.onclick = () => saveSettings({ keepScreenOn: !settings.keepScreenOn });
     ui.fullscreenButton.onclick = actions.fullscreen;
     // « Retour » : à l'écran d'avant l'aide (la partie, si l'aide a été
@@ -1383,7 +1725,8 @@ export function startApp(options: AppOptions): void {
         const home = below.screen === "home";
         const tutorial = below.screen === "tutorial" || below.screen === "tutorialEnd";
         const choosing = below.screen === "newGame";
-        const page = help || position || home || tutorial || choosing;
+        const analysing = below.screen === "analysis";
+        const page = help || position || home || tutorial || choosing || analysing;
         const wasPage = ui.game.hidden;
         const wasScreen = ui.root.dataset.screen;
         ui.game.hidden = page;
@@ -1391,6 +1734,7 @@ export function startApp(options: AppOptions): void {
         ui.position.hidden = !position;
         ui.home.hidden = !home;
         ui.tutorial.hidden = !tutorial;
+        ui.analysis.hidden = !analysing;
         const opening = choosing && ui.newGameSection.hidden;
         ui.newGameSection.hidden = !choosing;
         ui.root.classList.toggle("page-open", page);
@@ -1441,6 +1785,37 @@ export function startApp(options: AppOptions): void {
                 (menuReturnFocus ?? ui.menuButton).focus();
             }
         }
+        // La feuille d'explication du maître, sur une décision de la partie
+        // à l'écran.
+        if (route.screen === "explanation") {
+            closeTransient();
+            ui.menuVeil.hidden = true;
+            void adviceView.show(route.event);
+        } else {
+            adviceView.hide();
+        }
+        // Le bilan et l'analyse d'une partie : son journal, lu dans le
+        // stockage (ouvert avec le moteur), puis analysé en arrière-plan.
+        if (route.screen !== "summary" && summaryView.isOpen) {
+            // Quitter le bilan (pour l'analyse, ou par le retour du
+            // téléphone) laisse la partie finie sans le panneau.
+            panelDismissed = true;
+            summaryView.hide();
+        }
+        if (!analysing) {
+            analysisView.hide();
+        }
+        if (route.screen === "summary" || route.screen === "analysis") {
+            closeTransient();
+            ui.menuVeil.hidden = true;
+            const id = route.game;
+            void options.engineReady.then(
+                () => openReview(id),
+                () => undefined,
+            );
+        } else {
+            stopForeignReview();
+        }
         if (route.screen === "games") {
             const expanded = route.game;
             // La liste vient du stockage, ouvert avec le moteur.
@@ -1909,6 +2284,15 @@ export function startApp(options: AppOptions): void {
         }
         const onButton =
             event.target instanceof HTMLButtonElement || event.target instanceof HTMLAnchorElement;
+        // L'écran d'analyse : les flèches passent d'un coup à l'autre.
+        if (
+            navigation.route.screen === "analysis" &&
+            (event.key === "ArrowLeft" || event.key === "ArrowRight")
+        ) {
+            event.preventDefault();
+            analysisView.step(event.key === "ArrowLeft" ? -1 : 1);
+            return;
+        }
         let name: ActionName | null = null;
         switch (event.key) {
             case " ":
@@ -1953,6 +2337,10 @@ export function startApp(options: AppOptions): void {
         if (ui.game.hidden && name !== null && !["close", "help", "menu"].includes(name)) {
             name = null;
         }
+        // La feuille d'explication ouverte : le jeu attend qu'on la ferme.
+        if (!ui.explainVeil.hidden && name !== null && name !== "close") {
+            name = null;
+        }
         if (name !== null) {
             event.preventDefault();
             actions[name]();
@@ -1983,6 +2371,15 @@ export function startApp(options: AppOptions): void {
                     announcedEnd = game.journal.head;
                 }
             }
+            // Ouverte par son adresse avant que la partie soit là : la
+            // feuille d'explication la retrouve maintenant.
+            const route = navigation.route;
+            if (route.screen === "explanation") {
+                void adviceView.show(route.event);
+            }
+            if (route.screen === "summary" || route.screen === "analysis") {
+                void openReview(route.game);
+            }
             // Comme après une action du joueur : l'ordinateur joue si c'est
             // à lui (partie nouvelle ou reprise pendant son tour). Une partie
             // reprise juste après son coup le montre, sans l'animer.
@@ -2130,6 +2527,7 @@ function endParts(game: Game): { title: string; detail: string } {
     }
     const { winner, kind, points } = result;
     const dropped = game.events.some((e) => e.type === "CubeDropped");
+    const how = dropped ? TEXTS.droppedDouble(winner) : "";
     const { match, matchAfter } = game.state;
     if (match !== null && matchAfter !== null) {
         const { player, computer } = matchAfter.score;
@@ -2144,13 +2542,13 @@ function endParts(game: Game): { title: string; detail: string } {
         return {
             title: matchAfter.over
                 ? MATCH_TEXTS.matchWonTitle(winner)
-                : TEXTS.endTitle(winner, kind, dropped),
-            detail: matchAfter.crawford ? `${detail} ${MATCH_TEXTS.crawfordNext}` : detail,
+                : TEXTS.endTitle(winner, kind),
+            detail: `${how}${matchAfter.crawford ? `${detail} ${MATCH_TEXTS.crawfordNext}` : detail}`,
         };
     }
     return {
-        title: TEXTS.endTitle(winner, kind, dropped),
-        detail: TEXTS.endDetail(winner, points, game.state.cube.value),
+        title: TEXTS.endTitle(winner, kind),
+        detail: `${how}${TEXTS.endDetail(winner, points, game.state.cube.value)}`,
     };
 }
 

app/src/ui/board-view.ts

@@ -83,6 +83,21 @@ export interface BoardDecor {
     readonly band: string | null;
     /** Paysage : la colonne de commandes (null : pas de colonne). */
     readonly controls: BoardControls | null;
+    /** Paysage : le conseil du maître, une pastille avant la consigne dans
+     * la bande centrale (absent ou null : rien). */
+    readonly advice?: BoardAdvice | null;
+}
+
+/** Le conseil du maître en paysage : son mot, sur une pastille qui mène à
+ * la feuille d'explication. */
+export interface BoardAdvice {
+    readonly href: string;
+    /** Appréciation : la couleur et le pictogramme. */
+    readonly verdict: "good" | "doubtful" | "bad" | "veryBad";
+    readonly icon: IconName;
+    readonly word: string;
+    /** Ce que lit le lecteur d'écran : le mot, la phrase, l'invitation. */
+    readonly label: string;
 }
 
 /** Ce qui ne s'ajoute pas aux pions pendant l'animation d'un coup. */
@@ -188,8 +203,10 @@ export function renderBoard(
     }
     svg.append(pieces);
     drawLandings(svg, g, board, decor.targets);
+    const advice = decor.band !== null ? (decor.advice ?? null) : null;
+    const chip = advice === null ? 0 : adviceChipWidth(g, advice) + 8;
     if (decor.band !== null) {
-        drawBand(svg, g, decor.band);
+        drawBand(svg, g, decor.band, chip);
     }
     drawDice(svg, g, decor.dice);
     const cube = decor.cube === null ? null : drawCube(svg, g, decor.cube);
@@ -215,6 +232,9 @@ export function renderBoard(
     if (decor.controls !== null) {
         drawControls(svg, g, hits, decor.controls);
     }
+    if (advice !== null) {
+        drawAdviceChip(svg, g, hits, advice);
+    }
     // Les zones à toucher passent devant tout le reste.
     svg.append(hits);
 }
@@ -496,12 +516,13 @@ function addRing(
 }
 
 /** Paysage : la consigne courte, dans la moitié gauche de la bande
- * centrale, sur une pastille accent-soft. */
-function drawBand(svg: SVGSVGElement, g: Geometry, text: string): void {
+ * centrale, sur une pastille accent-soft ; elle laisse la place before à
+ * gauche (la pastille du conseil du maître). */
+function drawBand(svg: SVGSVGElement, g: Geometry, text: string, before = 0): void {
     const middle = g.height / 2;
-    const width = 6 * g.pointWidth - 24;
+    const width = 6 * g.pointWidth - 24 - before;
     const height = Math.max(44, g.bandFont + 20);
-    const x = g.x0 + 12;
+    const x = g.x0 + 12 + before;
     // Une consigne longue (« Partie Crawford · … ») tient dans la pastille :
     // la police se resserre, sans descendre sous 13 px (charte). Largeur
     // moyenne d'un caractère d'Alegreya Sans en gras : un peu moins de
@@ -529,6 +550,63 @@ function drawBand(svg: SVGSVGElement, g: Geometry, text: string): void {
     );
 }
 
+/** Largeur de la pastille du conseil : pictogramme, mot (estimé à 0,55 em
+ * par lettre, police Alegreya Sans) et marges. */
+function adviceChipWidth(g: Geometry, advice: BoardAdvice): number {
+    return 16 + g.bandFont + 6 + advice.word.length * g.bandFont * 0.55 + 16;
+}
+
+/**
+ * Paysage : le conseil du maître, une pastille au début de la bande
+ * centrale (pictogramme et mot en couleur d'appréciation), lien vers la
+ * feuille d'explication (charte 1d, adaptée au paysage : la phrase est dans
+ * la feuille). Posée parmi les zones à toucher, devant celle des dés.
+ */
+function drawAdviceChip(svg: SVGSVGElement, g: Geometry, hits: Element, advice: BoardAdvice): void {
+    const middle = g.height / 2;
+    const height = Math.max(44, g.bandFont + 20);
+    const width = adviceChipWidth(g, advice);
+    const x = g.x0 + 12;
+    const group = add(svg, "g", { class: `advice-chip verdict-${advice.verdict}` });
+    add(group, "rect", {
+        class: "advice-chip-pill",
+        x,
+        y: middle - height / 2,
+        width,
+        height,
+        rx: height / 2,
+    });
+    const size = g.bandFont;
+    const icon = add(group, "g", {
+        transform: `translate(${x + 16},${middle - size / 2}) scale(${size / 24})`,
+    });
+    add(icon, "path", { class: "advice-chip-icon", d: ICON_PATHS[advice.icon] });
+    add(
+        group,
+        "text",
+        {
+            class: "advice-chip-text",
+            x: x + 16 + size + 6,
+            y: middle + g.bandFont * 0.35,
+            "font-size": g.bandFont,
+        },
+        advice.word,
+    );
+    const link = add(hits, "a", {
+        href: advice.href,
+        id: "advice-chip",
+        role: "link",
+        "aria-label": advice.label,
+    });
+    add(link, "rect", {
+        class: "hit action",
+        x,
+        y: middle - Math.max(height, g.target) / 2,
+        width,
+        height: Math.max(height, g.target),
+    });
+}
+
 /**
  * Paysage : le score du match, dans une case sous le menu, dans l'ordre des
  * camps à l'écran : l'ordinateur en haut, « sur N », vous en bas

app/src/ui/games-texts.ts

@@ -28,6 +28,7 @@ export const GAMES_TEXTS = {
     close: "Fermer",
     resume: "Reprendre",
     showBranches: "Branches",
+    summary: "Bilan",
     resumeBranch: "Reprendre cette branche",
     exportSgf: "Exporter (SGF)",
     remove: "Supprimer",

app/src/ui/games-view.ts

@@ -123,6 +123,7 @@ export function createGamesView(options: GamesViewOptions): GamesView {
                 "resume",
             ),
             branchesLink(game.id),
+            ...(game.status === "over" ? [summaryLink(game.id)] : []),
             button(
                 GAMES_TEXTS.exportSgf,
                 run(async () => download(await options.exportSgf(game.id))),
@@ -171,6 +172,15 @@ export function createGamesView(options: GamesViewOptions): GamesView {
         return link;
     }
 
+    /** « Bilan » : le lien vers le bilan d'une partie finie (étape 1e). */
+    function summaryLink(id: string): HTMLAnchorElement {
+        const link = element("a", "button secondary");
+        link.textContent = GAMES_TEXTS.summary;
+        link.dataset.action = "summary";
+        link.href = routeHash({ screen: "summary", game: id });
+        return link;
+    }
+
     async function renderBranches(id: string, target: HTMLElement): Promise<void> {
         const journal = await options.journal(id);
         const all = journal === null ? [] : branches(journal);

app/src/ui/help.ts

@@ -30,6 +30,8 @@ import { TEXTS } from "./texts.js";
 export const FEATURES = [
     "docs/scenarios/jouer-une-partie.feature",
     "docs/scenarios/jouer-un-match.feature",
+    "docs/scenarios/comprendre-mes-coups.feature",
+    "docs/scenarios/revoir-ma-partie.feature",
     "docs/scenarios/apprendre-les-regles.feature",
     "docs/scenarios/mes-parties.feature",
     "docs/scenarios/partager-une-position.feature",

app/src/ui/move-board.ts

@@ -0,0 +1,109 @@
+// Un petit plateau qui rejoue un coup pion par pion, sur la position
+// d'avant le coup, puis laisse ses traces : la feuille d'explication du
+// maître (1d), le coup à revoir du bilan et le visualiseur de l'analyse
+// (1e).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import type { MoveSteps } from "../domain/game/game.js";
+import { boardModel, moveTrace, placeOf } from "./board-model.js";
+import { checkerSpot, NO_MARKS, renderBoard, slideChecker } from "./board-view.js";
+import { boardGeometry, PORTRAIT_ASPECT } from "./geometry.js";
+
+const SLIDE_MS = 160;
+const PAUSE_MS = 120;
+
+/** Un plateau SVG vide, dans son cadre. */
+export function boardSvg(box: HTMLElement, id: string, className: string): SVGSVGElement {
+    const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+    svg.id = id;
+    svg.setAttribute("class", `board ${className}`);
+    svg.setAttribute("role", "img");
+    box.append(svg);
+    return svg;
+}
+
+/**
+ * Dessine le plateau d'un coup après index demi-coups (0 : avant le
+ * coup), avec ses traces si traced. Les flèches des traces renvoient à leur
+ * pointe par identifiant : prefix les distingue de celles du plateau de jeu.
+ */
+export function drawSteps(
+    svg: SVGSVGElement,
+    steps: MoveSteps,
+    index: number,
+    traced: boolean,
+    prefix: string,
+): void {
+    const boards = steps.boards[index];
+    if (boards === undefined) {
+        return;
+    }
+    const width = svg.getBoundingClientRect().width || 358;
+    renderBoard(svg, boardGeometry("portrait", PORTRAIT_ASPECT, width / 640), boardModel(boards), {
+        ...NO_MARKS,
+        dice: [],
+        cube: null,
+        band: null,
+        controls: null,
+        trace: traced ? moveTrace(steps.side, steps.halfMoves, steps.hits) : null,
+    });
+    for (const marker of svg.querySelectorAll("marker[id]")) {
+        marker.id = `${prefix}${marker.id}`;
+    }
+    for (const path of svg.querySelectorAll("[marker-end]")) {
+        const ref = path.getAttribute("marker-end") ?? "";
+        path.setAttribute("marker-end", ref.replace("url(#", `url(#${prefix}`));
+    }
+}
+
+/** Un plateau qui joue des coups ; un coup demandé arrête le précédent. */
+export interface MovePlayer {
+    /** Joue le coup pion par pion (sans mouvement si le système le
+     * demande), puis laisse ses traces. */
+    play(steps: MoveSteps): Promise<void>;
+    /** Arrête le coup en cours. */
+    stop(): void;
+}
+
+export function createMovePlayer(
+    svg: SVGSVGElement,
+    prefix: string,
+    reducedMotion: MediaQueryList,
+): MovePlayer {
+    let playing = 0;
+    return {
+        async play(steps) {
+            const id = ++playing;
+            drawSteps(svg, steps, 0, false, prefix);
+            if (!reducedMotion.matches) {
+                for (const [i, halfMove] of steps.halfMoves.entries()) {
+                    if (id !== playing) {
+                        return;
+                    }
+                    if (i > 0) {
+                        await new Promise((resolve) => setTimeout(resolve, PAUSE_MS));
+                    }
+                    const from = placeOf(steps.side, halfMove.from);
+                    const to = placeOf(steps.side, halfMove.to);
+                    drawSteps(svg, steps, i, false, prefix);
+                    const start = checkerSpot(svg, from);
+                    const bar = steps.side === "player" ? "bar-computer" : "bar-player";
+                    const victim = steps.hits[i] === true ? checkerSpot(svg, to) : null;
+                    drawSteps(svg, steps, i + 1, false, prefix);
+                    await Promise.all([
+                        start && slideChecker(svg, to, start, SLIDE_MS),
+                        victim && slideChecker(svg, bar, victim, SLIDE_MS),
+                    ]);
+                }
+            }
+            if (id === playing) {
+                drawSteps(svg, steps, steps.halfMoves.length, true, prefix);
+            }
+        },
+        stop() {
+            playing++;
+        },
+    };
+}

app/src/ui/review-runner.ts

@@ -0,0 +1,87 @@
+// L'analyse d'une partie en arrière-plan (étape 1e) : les analyses qui
+// manquent au bilan et à l'écran d'analyse sont demandées une à une au
+// second moteur, rangées au fur et à mesure, et l'ensemble s'arrête dès
+// qu'on n'en a plus besoin (une autre partie, une nouvelle partie). Sans
+// DOM : testé sous Node (app/tests/review-runner.test.ts).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Une analyse déjà partie vers le moteur ne s'interrompt pas : l'arrêt
+// prend effet entre deux analyses, et le résultat d'une analyse arrêtée
+// n'est pas rangé.
+
+import { type AnalysisTask, missingAnalyses } from "../domain/analysis/game-analysis.js";
+import type { GameJournal } from "../domain/game/events.js";
+
+/** Fait une analyse et renvoie le journal qui la contient. */
+export type RunAnalysis = (journal: GameJournal, task: AnalysisTask) => Promise<GameJournal>;
+
+export interface ReviewRunner {
+    /** La partie en cours d'analyse (null : aucune). */
+    readonly running: string | null;
+    /**
+     * Analyse ce qui manque au journal de la partie id ; record reçoit le
+     * journal après chaque analyse rangée, done une fois tout analysé.
+     * Une analyse en cours d'une autre partie est arrêtée ; la même partie
+     * continue sans repartir.
+     */
+    start(
+        id: string,
+        journal: GameJournal,
+        record: (journal: GameJournal) => void,
+        done?: () => void,
+    ): void;
+    /** Arrête l'analyse en cours. */
+    stop(): void;
+}
+
+export function createReviewRunner(run: RunAnalysis): ReviewRunner {
+    // Chaque analyse lancée a son jeton : stop() ou une autre partie
+    // l'annulent.
+    let token: object | null = null;
+    let running: string | null = null;
+
+    return {
+        get running() {
+            return running;
+        },
+        start(id, journal, record, done) {
+            if (running === id && token !== null) {
+                return;
+            }
+            const mine = {};
+            token = mine;
+            running = id;
+            void (async () => {
+                let current = journal;
+                try {
+                    for (;;) {
+                        const task = missingAnalyses(current)[0];
+                        if (task === undefined) {
+                            break;
+                        }
+                        const next = await run(current, task);
+                        if (token !== mine) {
+                            return;
+                        }
+                        current = next;
+                        record(current);
+                    }
+                } catch {
+                    // Le moteur a échoué : l'analyse s'arrête là, ce qui est
+                    // rangé reste, et la prochaine demande reprendra.
+                }
+                if (token === mine) {
+                    token = null;
+                    running = null;
+                    done?.();
+                }
+            })();
+        },
+        stop() {
+            token = null;
+            running = null;
+        },
+    };
+}

app/src/ui/review-texts.ts

@@ -0,0 +1,99 @@
+// Les textes de l'interface du bilan et de l'écran d'analyse (étape 1e).
+// Les phrases du maître elles-mêmes (lecture du bilan, dés en mots) sont
+// dans docs/maitre/phrases.md (une seule source, ADR 0008).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import type { CubeAction } from "../domain/game/engine.js";
+import type { Roll } from "../domain/game/roll.js";
+
+const plural = (n: number, one: string, many: string) => (n > 1 ? many : one);
+
+/** « 41 % ». */
+export function percent(chance: number): string {
+    return `${Math.round(chance * 100)} %`;
+}
+
+/** Un nombre à la française, signé, à trois décimales : « +0,021 ». */
+export function signed(value: number): string {
+    const text = Math.abs(value).toFixed(3).replace(".", ",");
+    return value < -0.0005 ? `−${text}` : value > 0.0005 ? `+${text}` : text;
+}
+
+export const REVIEW_TEXTS = {
+    // Bilan
+    summaryLabel: "Bilan de la partie",
+    analysing: "Le maître analyse la partie…",
+    progress: (done: number, total: number) => `Analyse : ${done} sur ${total}`,
+    notOver: "Cette partie n'est pas finie : son bilan viendra à la fin.",
+    missingGame: "Cette partie n'est plus sur ce téléphone.",
+    counts: {
+        good: (n: number) => plural(n, "Bon coup", "Bons coups"),
+        doubtful: (n: number) => plural(n, "Imprécision", "Imprécisions"),
+        bad: (n: number) => plural(n, "Erreur", "Erreurs"),
+    },
+    countsLabel: "Vos décisions, par appréciation",
+    yourPlay: "Votre jeu",
+    theDice: "Les dés",
+    playGauge: (level: string) => `Votre jeu : niveau ${level}`,
+    diceGauge: (words: string) => `Les dés : ${words}`,
+    howToRead: "Comment lire ces mesures",
+    toReview: "Le coup à revoir",
+    yourMove: (notation: string) => `Votre coup : ${notation}`,
+    yourDecision: (action: string) => `Votre décision : ${action}`,
+    reviewMove: "Revoir ce coup",
+    seeAnalysis: "Voir l'analyse",
+    newGame: "Nouvelle partie",
+    close: "Fermer",
+    cubeActions: {
+        double: "doubler",
+        noDouble: "lancer sans doubler",
+        take: "prendre",
+        pass: "passer",
+    } satisfies Record<CubeAction, string>,
+    toReviewBoard: "La position au moment de la décision à revoir.",
+
+    // Analyse
+    analysisTitle: "Analyse de la partie",
+    back: "Retour",
+    curveTitle: "Vos chances de gagner",
+    curveLabel: (turn: number, total: number, chance: string) =>
+        `Courbe de vos chances de gagner : coup ${turn} sur ${total}, ${chance}. Flèches gauche et droite pour changer de coup.`,
+    curveUnknown: "pas encore calculé",
+    turnOf: (turn: number, total: number) => `Coup ${turn} sur ${total}`,
+    roll: (roll: Roll) => `${roll[0]}-${roll[1]}`,
+    previous: "Coup précédent",
+    next: "Coup suivant",
+    who: { player: "Vous", computer: "L'ordinateur" },
+    computerPlayed: (notation: string) => `L'ordinateur a joué ${notation}.`,
+    computerCannotMove: "L'ordinateur ne pouvait pas jouer.",
+    playerCannotMove: "Vous ne pouviez pas jouer.",
+    computerCube: "L'ordinateur a doublé.",
+    chanceAfter: (chance: string) => `Vos chances de gagner après ce coup : ${chance}`,
+    theirMove: "Son coup",
+    masterMove: "Le coup du maître",
+    yourMoveSegment: "Votre coup",
+    choiceLabel: "Coup montré sur le plateau",
+    legendMove: (who: string, notation: string) =>
+        `${who} : ${notation}, joué pion par pion sur la position d'avant le coup.`,
+    legendPosition: "La position avant la décision.",
+    replayFromHere: "Rejouer d'ici",
+    replayHint: "Une nouvelle branche : la partie d'origine reste intacte.",
+    listTitle: "Les coups à revoir",
+    filters: { all: "Tout", errors: "Erreurs", doubtful: "Imprécisions" },
+    filterLabel: "Filtrer les coups",
+    emptyFilter: "Aucun coup de ce genre dans la partie.",
+    rowLabel: (turn: number, roll: string, move: string, word: string) =>
+        `Coup ${turn}, ${roll}, ${move} : ${word}`,
+    numbers: "Voir les chiffres du moteur",
+    numbersRows: {
+        errorRate: "Erreur par décision",
+        decisions: "Décisions comptées",
+        luck: "Chance par tour",
+        level: "Niveau",
+    },
+    numbersHead: { you: "Vous", computer: "L'ordinateur" },
+    numbersNote:
+        "Calculés comme GNU Backgammon : équité perdue par décision non forcée, chance des dés par tour, à 2 plis.",
+} as const;

app/src/ui/router.ts

@@ -27,10 +27,19 @@ export type Route =
     | { readonly screen: "install" }
     /** #/parties, et une partie : #/parties/<identifiant>. */
     | { readonly screen: "games"; readonly game: string | null }
+    /** #/parties/<identifiant>/bilan : le bilan de fin de partie (1e). */
+    | { readonly screen: "summary"; readonly game: string }
+    /** #/parties/<identifiant>/analyse/<coup> : l'écran d'analyse, placé
+     * sur un coup (un tour de la partie, à partir de 1) ; sans coup :
+     * #/parties/<identifiant>/analyse. */
+    | { readonly screen: "analysis"; readonly game: string; readonly turn: number | null }
     /** #/menu. */
     | { readonly screen: "menu" }
     /** #/nouvelle-partie : le choix de la partie (type, niveau, conseil). */
     | { readonly screen: "newGame" }
+    /** #/explication/<événement> : la feuille d'explication du maître sur
+     * une décision de la partie en cours (étape 1d). */
+    | { readonly screen: "explanation"; readonly event: string }
     /** #/position/<Position ID>/<Match ID> (Match ID facultatif). */
     | { readonly screen: "position"; readonly position: string; readonly match: string | null }
     /** Une adresse que l'application ne connaît pas. */
@@ -68,6 +77,9 @@ export function parseRoute(hash: string): Route {
     if (head === "tutoriel") {
         return tutorialRoute(rest) ?? unknown;
     }
+    if (head === "parties" && rest.length > 1) {
+        return gameReviewRoute(rest) ?? unknown;
+    }
     if (rest.length > 1) {
         return unknown;
     }
@@ -90,6 +102,8 @@ export function parseRoute(hash: string): Route {
             return name === null ? { screen: "menu" } : unknown;
         case "nouvelle-partie":
             return name === null ? { screen: "newGame" } : unknown;
+        case "explication":
+            return name === null ? unknown : { screen: "explanation", event: name };
         case "parties":
             return { screen: "games", game: name };
         case "installer":
@@ -99,6 +113,24 @@ export function parseRoute(hash: string): Route {
     }
 }
 
+/** #/parties/<id>/bilan, #/parties/<id>/analyse, #/parties/<id>/analyse/<n>. */
+function gameReviewRoute(rest: readonly string[]): Route | null {
+    const [game = "", part, turn, ...more] = rest;
+    if (!NAME.test(game) || more.length > 0) {
+        return null;
+    }
+    if (part === "bilan") {
+        return turn === undefined ? { screen: "summary", game } : null;
+    }
+    if (part !== "analyse") {
+        return null;
+    }
+    if (turn === undefined) {
+        return { screen: "analysis", game, turn: null };
+    }
+    return /^[1-9][0-9]{0,3}$/.test(turn) ? { screen: "analysis", game, turn: Number(turn) } : null;
+}
+
 /** #/tutoriel, #/tutoriel/<n>, #/tutoriel/<n>/a-vous, #/tutoriel/fin. */
 function tutorialRoute(rest: readonly string[]): Route | null {
     const [name, part, ...more] = rest;
@@ -168,10 +200,18 @@ export function routeHash(route: Route): string {
             return "#/installer";
         case "games":
             return route.game === null ? "#/parties" : `#/parties/${route.game}`;
+        case "summary":
+            return `#/parties/${route.game}/bilan`;
+        case "analysis":
+            return route.turn === null
+                ? `#/parties/${route.game}/analyse`
+                : `#/parties/${route.game}/analyse/${route.turn}`;
         case "menu":
             return "#/menu";
         case "newGame":
             return "#/nouvelle-partie";
+        case "explanation":
+            return `#/explication/${route.event}`;
         case "position": {
             const position = `#/position/${encodeURIComponent(route.position)}`;
             return route.match === null

app/src/ui/summary-view.ts

@@ -0,0 +1,362 @@
+// Le bilan de fin de partie (#/parties/<id>/bilan, étape 1e ; charte,
+// ecrans-etape-1.md, « Bilan ») : un panneau centré sur un voile, à la
+// place du panneau de fin de partie. Le résultat et sa lecture, les
+// décisions par appréciation, deux jauges (votre jeu, les dés), le coup à
+// revoir, puis « Voir l'analyse » et l'action qui suit la partie.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Tout ce qu'il affiche vient de l'analyse du moteur (game-analysis.ts) et
+// des phrases du maître (docs/maitre/phrases.md) ; tant que l'analyse
+// n'est pas prête, il dit où elle en est.
+
+import {
+    type GameSummary,
+    readyForSummary,
+    summarizeAnalysis,
+} from "../domain/analysis/game-analysis.js";
+import {
+    diceWords,
+    type MasterPhrases,
+    masterWords,
+    nothingToReview,
+    summaryReading,
+} from "../domain/analysis/phrases.js";
+import { masterCubeAction } from "../domain/game/advice.js";
+import type { GameJournal } from "../domain/game/events.js";
+import type { Game } from "../domain/game/game.js";
+import { COMPUTER_LEVELS } from "../domain/game/level.js";
+import { VERDICT_ICONS } from "./advice-view.js";
+import { icon } from "./icons.js";
+import { MATCH_TEXTS } from "./match-texts.js";
+import { boardSvg, drawSteps } from "./move-board.js";
+import { REVIEW_TEXTS } from "./review-texts.js";
+import { routeHash } from "./router.js";
+import { TEXTS } from "./texts.js";
+
+/** Ce que montre le bilan. */
+export interface SummaryData {
+    readonly id: string;
+    readonly journal: GameJournal;
+    /** La partie, pour dessiner la position du coup à revoir. */
+    readonly game: Game;
+    /** Le titre et le détail du résultat (null : partie pas finie). */
+    readonly end: { readonly title: string; readonly detail: string } | null;
+    /** L'action qui suit la partie, si c'est la partie à l'écran :
+     * « Rejouer » ou « Partie suivante ». Sinon, « Nouvelle partie » mène à
+     * l'écran des choix. */
+    readonly afterLabel: string | null;
+    readonly phrases: MasterPhrases | null;
+}
+
+export interface SummaryViewOptions {
+    /** Le voile du bilan (index.html) ; le panneau est construit ici. */
+    readonly veil: HTMLElement;
+    /** La croix : revenir au plateau. */
+    readonly close: () => void;
+    /** « Rejouer » ou « Partie suivante ». */
+    readonly again: () => void;
+}
+
+export interface SummaryView {
+    /** Ouvre (ou met à jour) le bilan. */
+    show(data: SummaryData | null): void;
+    hide(): void;
+    readonly isOpen: boolean;
+}
+
+function element<K extends keyof HTMLElementTagNameMap>(
+    parent: HTMLElement,
+    tag: K,
+    options: { id?: string; className?: string; text?: string } = {},
+): HTMLElementTagNameMap[K] {
+    const child = document.createElement(tag);
+    if (options.id !== undefined) {
+        child.id = options.id;
+    }
+    if (options.className !== undefined) {
+        child.className = options.className;
+    }
+    if (options.text !== undefined) {
+        child.textContent = options.text;
+    }
+    parent.append(child);
+    return child;
+}
+
+const DICE_SIDE = {
+    veryLucky: "for-2",
+    lucky: "for-1",
+    none: "even",
+    unlucky: "against-1",
+    veryUnlucky: "against-2",
+} as const;
+
+export function createSummaryView(options: SummaryViewOptions): SummaryView {
+    const { veil } = options;
+    const panel = element(veil, "div", { id: "summary", className: "panel summary-panel" });
+    panel.setAttribute("role", "dialog");
+    panel.setAttribute("aria-modal", "true");
+    panel.setAttribute("aria-labelledby", "summary-title");
+    veil.addEventListener("click", (event) => {
+        if (event.target === veil) {
+            options.close();
+        }
+    });
+    // Ce qui est dessiné, pour ne redessiner qu'en cas de changement (le
+    // bilan est mis à jour à chaque analyse rangée).
+    let drawn = "";
+
+    function render(data: SummaryData | null): void {
+        const ready = data !== null && data.phrases !== null && readyForSummary(data.journal);
+        const summary = ready ? summarizeAnalysis(data.journal) : null;
+        // Seulement ce que le bilan montre : les analyses qui arrivent
+        // ensuite en arrière-plan pour l'écran d'analyse (coups de
+        // l'ordinateur, chances de gagner) ne le redessinent pas, sinon le
+        // panneau et son mini-plateau sauteraient sous les yeux du joueur.
+        const shown =
+            summary === null || data === null || data.phrases === null
+                ? null
+                : {
+                      counts: summary.counts,
+                      level: summary.player.errorRate.level,
+                      dice: summary.player.luck.rating,
+                      reading: summaryReading(data.phrases, summary),
+                      toReview: summary.toReview?.advice.eventId ?? null,
+                      turn: summary.toReview?.turn ?? null,
+                  };
+        const key =
+            data === null
+                ? "missing"
+                : [
+                      data.id,
+                      data.end?.title ?? "",
+                      data.end?.detail ?? "",
+                      data.afterLabel ?? "",
+                      ready,
+                      JSON.stringify(shown),
+                  ].join("|");
+        if (key === drawn) {
+            return;
+        }
+        drawn = key;
+        panel.replaceChildren();
+        delete panel.dataset.ready;
+        const head = element(panel, "div", { className: "summary-head" });
+        element(head, "p", { className: "overline", text: TEXTS.endOverline });
+        const close = element(head, "button", { id: "summary-close", className: "icon-button" });
+        close.type = "button";
+        close.append(icon("close"));
+        close.setAttribute("aria-label", REVIEW_TEXTS.close);
+        close.onclick = () => options.close();
+        const title = element(panel, "h2", { id: "summary-title", className: "summary-title" });
+        if (data === null) {
+            title.textContent = REVIEW_TEXTS.summaryLabel;
+            element(panel, "p", { className: "summary-reading", text: REVIEW_TEXTS.missingGame });
+            return;
+        }
+        if (data.end === null) {
+            title.textContent = REVIEW_TEXTS.summaryLabel;
+            element(panel, "p", { className: "summary-reading", text: REVIEW_TEXTS.notOver });
+            actions(data);
+            return;
+        }
+        title.textContent = data.end.title;
+        const reading = element(panel, "p", {
+            id: "summary-reading",
+            className: "summary-reading",
+        });
+        reading.textContent =
+            summary !== null && data.phrases !== null
+                ? `${data.end.detail} ${summaryReading(data.phrases, summary)}`
+                : data.end.detail;
+        if (summary === null || data.phrases === null) {
+            const status = element(panel, "p", {
+                id: "summary-status",
+                className: "summary-status",
+                text: REVIEW_TEXTS.analysing,
+            });
+            status.setAttribute("role", "status");
+            actions(data);
+            return;
+        }
+        panel.dataset.ready = "true";
+        counts(summary);
+        gauges(summary, data.phrases);
+        toReview(data, summary, data.phrases);
+        actions(data);
+    }
+
+    function counts(summary: GameSummary): void {
+        const box = element(panel, "div", { id: "summary-counts", className: "summary-counts" });
+        box.setAttribute("role", "list");
+        box.setAttribute("aria-label", REVIEW_TEXTS.countsLabel);
+        const cells = [
+            { verdict: "good", n: summary.counts.good, word: REVIEW_TEXTS.counts.good },
+            {
+                verdict: "doubtful",
+                n: summary.counts.doubtful,
+                word: REVIEW_TEXTS.counts.doubtful,
+            },
+            {
+                verdict: "bad",
+                n: summary.counts.bad + summary.counts.veryBad,
+                word: REVIEW_TEXTS.counts.bad,
+            },
+        ] as const;
+        for (const cell of cells) {
+            const item = element(box, "div", { className: "summary-count" });
+            item.setAttribute("role", "listitem");
+            item.dataset.verdict = cell.verdict;
+            element(item, "span", { className: "summary-number", text: String(cell.n) });
+            const word = element(item, "span", { className: "summary-word" });
+            word.append(icon(VERDICT_ICONS[cell.verdict]), cell.word(cell.n));
+        }
+    }
+
+    function gauges(summary: GameSummary, phrases: MasterPhrases): void {
+        const box = element(panel, "div", { className: "summary-gauges" });
+        const level = summary.player.errorRate.level;
+        const levelName = MATCH_TEXTS.levels[level].name;
+        const play = element(box, "div", { id: "gauge-play", className: "gauge" });
+        play.setAttribute("aria-label", REVIEW_TEXTS.playGauge(levelName));
+        play.setAttribute("role", "img");
+        element(play, "span", { className: "gauge-name", text: REVIEW_TEXTS.yourPlay });
+        const track = element(play, "span", { className: "gauge-track" });
+        element(track, "span", {
+            className: `gauge-fill level-${COMPUTER_LEVELS.indexOf(level) + 1}`,
+        });
+        element(play, "span", { className: "gauge-value", text: levelName });
+
+        const words = diceWords(phrases, summary.player.luck.rating);
+        const dice = element(box, "div", { id: "gauge-dice", className: "gauge" });
+        dice.setAttribute("aria-label", REVIEW_TEXTS.diceGauge(words));
+        dice.setAttribute("role", "img");
+        element(dice, "span", { className: "gauge-name", text: REVIEW_TEXTS.theDice });
+        const centred = element(dice, "span", { className: "gauge-track centred" });
+        element(centred, "span", {
+            className: `gauge-fill dice ${DICE_SIDE[summary.player.luck.rating]}`,
+        });
+        element(dice, "span", { className: "gauge-value", text: words });
+        const link = element(box, "a", {
+            id: "summary-glossary",
+            className: "link-button summary-glossary",
+            text: REVIEW_TEXTS.howToRead,
+        });
+        link.href = routeHash({ screen: "glossary", term: "taux-d-erreur" });
+    }
+
+    function toReview(data: SummaryData, summary: GameSummary, phrases: MasterPhrases): void {
+        const card = element(panel, "section", {
+            id: "summary-review",
+            className: "summary-review",
+        });
+        card.setAttribute("aria-labelledby", "summary-review-title");
+        element(card, "h3", {
+            id: "summary-review-title",
+            className: "overline",
+            text: REVIEW_TEXTS.toReview,
+        });
+        const reviewed = summary.toReview;
+        if (reviewed === null) {
+            element(card, "p", { className: "summary-none", text: nothingToReview(phrases) });
+            return;
+        }
+        const advice = reviewed.advice;
+        const words = masterWords(phrases, advice);
+        const body = element(card, "div", { className: "summary-review-body" });
+        const box = element(body, "div", { className: "summary-board-box" });
+        const svg = boardSvg(box, "summary-board", "summary-board");
+        svg.setAttribute("aria-label", REVIEW_TEXTS.toReviewBoard);
+        const halfMoves = advice.kind === "move" ? advice.played.halfMoves : [];
+        void data.game
+            .stepsBefore(advice.eventId, "player", halfMoves)
+            .then((steps) => drawSteps(svg, steps, steps.halfMoves.length, true, "summary-"))
+            .catch(() => undefined);
+        const text = element(body, "div", { className: "summary-review-text" });
+        const verdict = element(text, "p", { className: "summary-verdict" });
+        verdict.dataset.verdict = words.verdict;
+        verdict.append(icon(VERDICT_ICONS[words.verdict]), `${words.word} · ${words.context}`);
+        element(text, "p", {
+            className: "summary-played",
+            text:
+                advice.kind === "move"
+                    ? REVIEW_TEXTS.yourMove(advice.played.notation)
+                    : REVIEW_TEXTS.yourDecision(REVIEW_TEXTS.cubeActions[advice.action]),
+        });
+        element(text, "p", {
+            className: "summary-master",
+            text:
+                advice.kind === "move" || masterCubeAction(advice) !== advice.action
+                    ? words.title
+                    : words.phrase,
+        });
+        const links = element(card, "div", { className: "summary-review-actions" });
+        const revisit = element(links, "a", {
+            id: "summary-revisit",
+            className: "button secondary",
+            text: REVIEW_TEXTS.reviewMove,
+        });
+        revisit.href = routeHash({ screen: "analysis", game: data.id, turn: reviewed.turn });
+        // L'emplacement de « Demander à une IA » (étape 1f).
+        const slot = element(links, "div", { className: "ask-ai-slot" });
+        slot.dataset.slot = "ask-ai";
+    }
+
+    function actions(data: SummaryData): void {
+        // Les actions et le lien des réglages, ensemble : en paysage, en bas
+        // de la colonne de droite.
+        const end = element(panel, "div", { className: "summary-end" });
+        const bar = element(end, "div", { className: "panel-actions summary-actions" });
+        const analysis = element(bar, "a", {
+            id: "summary-analysis",
+            className: "button secondary",
+            text: REVIEW_TEXTS.seeAnalysis,
+        });
+        analysis.href = routeHash({ screen: "analysis", game: data.id, turn: null });
+        if (data.afterLabel !== null) {
+            const again = element(bar, "button", {
+                id: "summary-primary",
+                text: data.afterLabel,
+            });
+            again.type = "button";
+            again.onclick = () => options.again();
+            const settings = element(end, "a", {
+                id: "summary-settings",
+                className: "panel-link",
+                text: MATCH_TEXTS.changeSettings,
+            });
+            settings.href = routeHash({ screen: "newGame" });
+        } else {
+            const start = element(bar, "a", {
+                id: "summary-primary",
+                className: "button",
+                text: REVIEW_TEXTS.newGame,
+            });
+            start.href = routeHash({ screen: "newGame" });
+        }
+    }
+
+    return {
+        show(data) {
+            const opening = veil.hidden;
+            veil.hidden = false;
+            render(data);
+            if (opening) {
+                panel.querySelector<HTMLElement>("#summary-close")?.focus();
+            }
+        },
+        hide() {
+            if (!veil.hidden) {
+                veil.hidden = true;
+                panel.replaceChildren();
+                delete panel.dataset.ready;
+                drawn = "";
+            }
+        },
+        get isOpen() {
+            return !veil.hidden;
+        },
+    };
+}

app/src/ui/texts.ts

@@ -136,15 +136,18 @@ export const TEXTS = {
     // Fin de partie
     gameOver: "Partie finie",
     endOverline: "Fin de partie",
-    /** Titre du panneau de fin : qui gagne, et comment. */
-    endTitle: (winner: "player" | "computer", kind: ResultKind, dropped: boolean) => {
-        if (dropped) {
-            return winner === "player" ? "L'ordinateur passe" : "Vous passez";
-        }
-        return winner === "player"
+    /** Titre du panneau de fin et du bilan : toujours l'issue, qui gagne
+     * et comment (un double passé se dit dans le détail). */
+    endTitle: (winner: "player" | "computer", kind: ResultKind) =>
+        winner === "player"
             ? `Vous gagnez ${RESULT_KIND[kind]}`
-            : `L'ordinateur gagne ${RESULT_KIND[kind]}`;
-    },
+            : `L'ordinateur gagne ${RESULT_KIND[kind]}`,
+    /** Avant le détail des points, quand la partie finit sur un double
+     * passé : « Vous avez passé son double : 1 point pour lui. ». */
+    droppedDouble: (winner: "player" | "computer") =>
+        winner === "player"
+            ? "L'ordinateur a passé votre double : "
+            : "Vous avez passé son double : ",
     /** « 8 points pour lui, videau à 4. » */
     endDetail: (winner: "player" | "computer", n: number, cube: number) =>
         `${points(n)} pour ${winner === "player" ? "vous" : "lui"}${

app/tests/advice-tracker.test.ts

@@ -0,0 +1,141 @@
+// Le conseil du maître pendant la partie (app/src/ui/advice-tracker.ts) :
+// les analyses ne retardent pas le tour de l'ordinateur, la ligne
+// n'apparaît qu'après la décision et pas si le joueur a déjà agi, et
+// chaque conseil est rattaché au journal.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { analyseDecision } from "../src/domain/analysis/analyse.js";
+import type { Advice } from "../src/domain/game/advice.js";
+import type { GameJournal } from "../src/domain/game/events.js";
+import { Game } from "../src/domain/game/game.js";
+import { parseHalfMoves, START_POSITION } from "../src/domain/game/position.js";
+import { fixedDice } from "../src/domain/game/roll.js";
+import { createAdviceTracker } from "../src/ui/advice-tracker.js";
+import { DOUBLE_TAKE_POSITION } from "./support/advice.js";
+import { loadNodeEngine } from "./support/node-engine.js";
+
+/** Une analyse qu'on libère à la main. */
+function heldAnalyses() {
+    const held: { id: string; release: () => Promise<void> }[] = [];
+    const analyse = (journal: GameJournal, eventId: string) =>
+        new Promise<Advice | null>((resolve) => {
+            held.push({
+                id: eventId,
+                release: async () => {
+                    resolve(await analyseDecision(engine, journal, eventId));
+                    await new Promise((r) => setTimeout(r, 0));
+                },
+            });
+        });
+    return { held, analyse };
+}
+
+let engine: Awaited<ReturnType<typeof loadNodeEngine>>;
+
+async function opening(dice: number[]): Promise<Game> {
+    engine = await loadNodeEngine();
+    return Game.start(engine, {
+        setup: { position: START_POSITION, firstTurn: "player" },
+        dice: fixedDice(dice),
+    });
+}
+
+async function play(game: Game, move: string): Promise<void> {
+    for (const halfMove of parseHalfMoves(move)) {
+        assert.ok(await game.playHalfMove(halfMove));
+    }
+    await game.confirmMove();
+}
+
+test("le tour de l'ordinateur n'attend pas l'analyse ; la ligne vient ensuite", async () => {
+    const game = await opening([3, 1, 6, 5, 4, 2]);
+    const { held, analyse } = heldAnalyses();
+    let saved = 0;
+    let changes = 0;
+    const tracker = createAdviceTracker({
+        analyse,
+        recorded: () => saved++,
+        changed: () => changes++,
+    });
+    let before = game.events;
+    await game.roll();
+    tracker.track(game, before);
+    // Un jet seul ne montre rien : le joueur réfléchit.
+    assert.equal(held.length, 1, "le jet est analysé (aurait-il fallu doubler ?)");
+    before = game.events;
+    await play(game, "24/23 13/10");
+    tracker.track(game, before);
+    // Les analyses sont en attente : l'ordinateur joue quand même.
+    await game.playComputerTurn();
+    assert.equal(game.state.turn, "player");
+    assert.equal(tracker.shown, null);
+    for (const h of held) {
+        await h.release();
+    }
+    const shown = tracker.shown as Advice | null;
+    assert.equal(shown?.kind, "move");
+    assert.equal(shown?.skill, "veryBad");
+    assert.equal(changes, 1);
+    // Le coup est rattaché au journal (le jet aussi s'il y avait à dire).
+    assert.ok(saved >= 1);
+    assert.ok(game.advice[shown?.eventId ?? ""] !== undefined);
+    // L'action suivante du joueur efface la ligne.
+    tracker.clear();
+    assert.equal(tracker.shown, null);
+});
+
+test("si le joueur a déjà agi, la ligne n'apparaît pas, mais le conseil reste au journal", async () => {
+    const game = await opening([3, 1, 6, 5]);
+    const { held, analyse } = heldAnalyses();
+    const tracker = createAdviceTracker({ analyse, recorded: () => {}, changed: () => {} });
+    await game.roll();
+    const before = game.events;
+    await play(game, "8/5 6/5");
+    tracker.track(game, before);
+    tracker.clear(); // le joueur a relancé avant l'analyse
+    for (const h of held) {
+        await h.release();
+    }
+    assert.equal(tracker.shown, null);
+    const move = game.events.findLast((e) => e.type === "MovePlayed");
+    assert.equal(game.advice[move?.id ?? ""]?.skill, "none");
+});
+
+test("un double manqué avant le jet passe avant le coup dans la ligne", async () => {
+    engine = await loadNodeEngine();
+    const game = Game.start(engine, {
+        setup: { position: DOUBLE_TAKE_POSITION, firstTurn: "player" },
+        dice: fixedDice([6, 5]),
+    });
+    const tracker = createAdviceTracker({
+        analyse: (journal, id) => analyseDecision(engine, journal, id),
+        recorded: () => {},
+        changed: () => {},
+    });
+    let before = game.events;
+    await game.roll();
+    tracker.track(game, before);
+    const best = await engine.bestMove(
+        game.state.position,
+        { value: 1, owner: "centered" },
+        [6, 5],
+        0,
+    );
+    assert.ok(best !== null);
+    before = game.events;
+    for (const halfMove of best.halfMoves) {
+        assert.ok(await game.playHalfMove(halfMove));
+    }
+    await game.confirmMove();
+    tracker.track(game, before);
+    for (let i = 0; i < 50 && tracker.shown === null; i++) {
+        await new Promise((r) => setTimeout(r, 20));
+    }
+    const shown = tracker.shown as Advice | null;
+    assert.equal(shown?.kind, "cube");
+    assert.equal(shown?.kind === "cube" ? shown.action : null, "noDouble");
+});

app/tests/advice.test.ts

@@ -0,0 +1,273 @@
+// Le conseil du maître (étape 1d) : analyses du moteur sur des décisions
+// connues, phrases rendues sur ces analyses, conseil rattaché au journal et
+// gardé à l'enregistrement.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import {
+    LINE_LIMIT,
+    masterLine,
+    masterWords,
+    PHRASE_KEYS,
+} from "../src/domain/analysis/phrases.js";
+import { ADVICE_VERSION, type Advice, type MoveAdvice } from "../src/domain/game/advice.js";
+import { Game } from "../src/domain/game/game.js";
+import { createGameLibrary } from "../src/storage/game-library.js";
+import { createKeyValueBackend } from "../src/storage/key-value-backend.js";
+import { memoryStorage } from "../src/storage/open-library.js";
+import {
+    adviceOn,
+    loadPhrases,
+    playerAnswers,
+    playerDoubles,
+    playerRollsWithoutDoubling,
+    playOpening,
+} from "./support/advice.js";
+import { loadNodeEngine } from "./support/node-engine.js";
+
+const phrases = loadPhrases();
+
+test("la source des phrases a toutes ses sections, sans point d'exclamation", () => {
+    for (const key of PHRASE_KEYS) {
+        assert.ok((phrases.get(key)?.length ?? 0) > 0, `section ${key} absente ou vide`);
+    }
+    for (const [key, templates] of phrases) {
+        assert.ok(PHRASE_KEYS.includes(key), `section ${key} inconnue`);
+        for (const template of templates) {
+            assert.ok(!template.includes("!"), `« ! » dans ${key} : ${template}`);
+        }
+    }
+});
+
+// Des décisions réelles, analysées par le moteur à 2 plis. Les coups
+// d'ouverture et leurs écarts viennent du classement de gnubg.
+const cases: { name: string; play: () => Promise<Advice>; word: string }[] = [
+    {
+        name: "3-1 joué 8/5 6/5 : le meilleur coup",
+        play: async () =>
+            adviceOn(
+                await loadNodeEngine(),
+                await playOpening(await loadNodeEngine(), [3, 1], "8/5 6/5"),
+            ),
+        word: "Bon coup",
+    },
+    {
+        name: "2-1 joué 13/11 6/5 : tout près du meilleur",
+        play: async () =>
+            adviceOn(
+                await loadNodeEngine(),
+                await playOpening(await loadNodeEngine(), [2, 1], "13/11 6/5"),
+            ),
+        word: "Bon coup",
+    },
+    {
+        name: "2-1 joué 13/10 : imprécision",
+        play: async () =>
+            adviceOn(
+                await loadNodeEngine(),
+                await playOpening(await loadNodeEngine(), [2, 1], "13/11 11/10"),
+            ),
+        word: "Imprécision",
+    },
+    {
+        name: "2-1 joué 24/22 6/5 : erreur",
+        play: async () =>
+            adviceOn(
+                await loadNodeEngine(),
+                await playOpening(await loadNodeEngine(), [2, 1], "24/22 6/5"),
+            ),
+        word: "Erreur",
+    },
+    {
+        name: "3-1 joué 24/23 13/10 : grosse erreur",
+        play: async () =>
+            adviceOn(
+                await loadNodeEngine(),
+                await playOpening(await loadNodeEngine(), [3, 1], "24/23 13/10"),
+            ),
+        word: "Grosse erreur",
+    },
+    {
+        name: "double dans une position de double et prise",
+        play: async () =>
+            adviceOn(await loadNodeEngine(), await playerDoubles(await loadNodeEngine())),
+        word: "Bonne décision",
+    },
+    {
+        name: "lancer sans doubler dans une position de double",
+        play: async () =>
+            adviceOn(
+                await loadNodeEngine(),
+                await playerRollsWithoutDoubling(await loadNodeEngine()),
+            ),
+        word: "Erreur",
+    },
+    {
+        name: "prendre un double juste",
+        play: async () =>
+            adviceOn(await loadNodeEngine(), await playerAnswers(await loadNodeEngine(), true)),
+        word: "Bonne décision",
+    },
+    {
+        name: "passer un double qu'il fallait prendre",
+        play: async () =>
+            adviceOn(await loadNodeEngine(), await playerAnswers(await loadNodeEngine(), false)),
+        word: "Erreur",
+    },
+];
+
+const analysed: Advice[] = [];
+
+for (const c of cases) {
+    test(`conseil : ${c.name}`, async () => {
+        const advice = await c.play();
+        analysed.push(advice);
+        const words = masterWords(phrases, advice);
+        assert.equal(words.word, c.word, JSON.stringify(advice));
+        // Chaque gabarit tourne avec l'identifiant de l'événement : la ligne
+        // est rendue pour plusieurs identifiants.
+        for (let id = 1; id <= 40; id++) {
+            const line = masterLine(masterWords(phrases, { ...advice, eventId: String(id) }));
+            assert.ok(line.length < LINE_LIMIT, `trop long (${line.length}) : ${line}`);
+            assert.ok(!line.includes("!"), line);
+            assert.ok(!/[{}]/.test(line), `repère non rempli : ${line}`);
+        }
+    });
+}
+
+test("le coup du maître est nommé, et le fait qui distingue les coups vient du plateau", async () => {
+    const engine = await loadNodeEngine();
+    const best = (await adviceOn(
+        engine,
+        await playOpening(engine, [3, 1], "8/5 6/5"),
+    )) as MoveAdvice;
+    assert.equal(best.kind, "move");
+    assert.equal(best.version, ADVICE_VERSION);
+    assert.equal(best.rank, 1);
+    assert.equal(best.opening, true);
+    assert.deepEqual(best.playedFacts, { hits: 0, madePoints: [5] });
+    assert.equal(best.ranking[0]?.notation, "8/5 6/5");
+    const words = masterWords(phrases, best);
+    assert.equal(words.title, "C'est aussi le coup que j'aurais joué");
+    assert.equal(words.context, "votre 3-1 d'ouverture");
+
+    const worst = (await adviceOn(
+        engine,
+        await playOpening(engine, [3, 1], "24/23 13/10"),
+    )) as MoveAdvice;
+    assert.equal(worst.skill, "veryBad");
+    assert.equal(worst.best.notation, "8/5 6/5");
+    assert.deepEqual(worst.bestFacts.madePoints, [5]);
+    const said = masterWords(phrases, worst);
+    assert.equal(said.title, "J'aurais joué 8/5 6/5");
+    assert.equal(said.phrase, "J'aurais joué 8/5 6/5. Mon coup fait votre point 5.");
+});
+
+test("le rang n'est cité que pour un bon coup non meilleur ou une imprécision, au 2e ou 3e choix", async () => {
+    const engine = await loadNodeEngine();
+    const worst = (await adviceOn(
+        engine,
+        await playOpening(engine, [3, 1], "24/23 13/10"),
+    )) as MoveAdvice;
+    for (const skill of ["none", "doubtful", "bad", "veryBad"] as const) {
+        for (const rank of [2, 3, 4, 7, 15]) {
+            const { phrase } = masterWords(phrases, { ...worst, skill, rank });
+            const cited = (skill === "none" || skill === "doubtful") && rank <= 3;
+            if (cited) {
+                assert.ok(phrase.includes(`le ${rank}e choix`), `${skill} ${rank} : ${phrase}`);
+            } else {
+                assert.ok(!phrase.includes("choix"), `${skill} ${rank} : ${phrase}`);
+                assert.equal(phrase, "J'aurais joué 8/5 6/5. Mon coup fait votre point 5.");
+            }
+        }
+    }
+});
+
+test("décisions de videau : la décision du maître et le contexte", async () => {
+    const engine = await loadNodeEngine();
+    const missed = await adviceOn(engine, await playerRollsWithoutDoubling(engine));
+    const words = masterWords(phrases, missed);
+    assert.equal(words.phrase, "Ici, j'aurais doublé.");
+    assert.equal(words.title, "J'aurais doublé");
+    assert.equal(words.context, "avant votre jet");
+    const passed = masterWords(phrases, await adviceOn(engine, await playerAnswers(engine, false)));
+    assert.equal(passed.phrase, "Ici, j'aurais pris.");
+    assert.equal(passed.context, "le double de l'ordinateur");
+});
+
+test("tous les gabarits, remplis avec les plus longues notations, restent sous la limite", () => {
+    const long = "bar/22* 13/9*(2) 6/off";
+    const move = (equity: number) => ({ notation: long, halfMoves: [], equity, ply: 2 });
+    for (const skill of ["none", "doubtful", "bad", "veryBad"] as const) {
+        for (const rank of [1, 2, 23]) {
+            for (const facts of [
+                { hits: 0, madePoints: [] },
+                { hits: 1, madePoints: [4, 5, 7] },
+                { hits: 3, madePoints: [] },
+            ]) {
+                const advice: MoveAdvice = {
+                    version: ADVICE_VERSION,
+                    kind: "move",
+                    eventId: "7",
+                    ply: 2,
+                    position: "4HPwATDgc/ABMA",
+                    roll: [6, 6],
+                    opening: false,
+                    moveCount: 87,
+                    rank,
+                    played: move(-0.2),
+                    best: move(0),
+                    playedFacts: rank === 1 ? facts : { hits: 0, madePoints: [] },
+                    bestFacts: facts,
+                    ranking: [],
+                    equityLoss: rank === 1 ? 0 : -0.2,
+                    skill: rank === 1 ? "none" : skill,
+                };
+                for (let id = 0; id < 20; id++) {
+                    const line = masterLine(
+                        masterWords(phrases, { ...advice, eventId: String(id) }),
+                    );
+                    assert.ok(line.length < LINE_LIMIT, `trop long (${line.length}) : ${line}`);
+                }
+            }
+        }
+    }
+});
+
+test("le conseil est rattaché au journal et gardé à l'enregistrement", async () => {
+    const engine = await loadNodeEngine();
+    const played = await playOpening(engine, [3, 1], "8/5 6/5");
+    const advice = await adviceOn(engine, played);
+    played.game.recordAdvice(advice);
+    // Le tour de l'ordinateur, puis l'enregistrement : le conseil reste.
+    await played.game.playComputerTurn();
+    assert.deepEqual(played.game.advice[played.eventId], advice);
+    const library = createGameLibrary(createKeyValueBackend(memoryStorage()));
+    await library.save("g", played.game.journal, { level: "2ply" });
+    const loaded = await library.load("g");
+    assert.ok(loaded !== null);
+    const resumed = Game.resume(engine, loaded.journal);
+    assert.deepEqual(resumed.advice[played.eventId], advice);
+    // Revenir en arrière garde le conseil, rattaché à son événement.
+    resumed.goBackTo(played.eventId);
+    assert.deepEqual(resumed.advice[played.eventId], advice);
+});
+
+test("migration : un journal sans conseil, ou avec un conseil d'une autre version", async () => {
+    const engine = await loadNodeEngine();
+    const played = await playOpening(engine, [3, 1], "8/5 6/5");
+    const { advice: _, ...withoutAdvice } = played.game.journal;
+    assert.deepEqual(Game.resume(engine, withoutAdvice).advice, {});
+    const advice = await adviceOn(engine, played);
+    const future = { ...advice, version: ADVICE_VERSION + 1 };
+    const orphan = { ...advice, eventId: "999" };
+    const resumed = Game.resume(engine, {
+        ...played.game.journal,
+        advice: { [played.eventId]: future, "999": orphan },
+    });
+    assert.deepEqual(resumed.advice, {});
+    assert.throws(() => resumed.recordAdvice(orphan), /introuvable/);
+});

app/tests/game-analysis.test.ts

@@ -0,0 +1,318 @@
+// L'analyse de partie (étape 1e) : les tours, le format durable de
+// l'analyse et sa migration, les chiffres du bilan à la manière de gnubg,
+// et une partie complète analysée par le vrai moteur.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import {
+    chanceCurve,
+    gameTurns,
+    levelOfErrorRate,
+    luckRatingOf,
+    mainAdvice,
+    missingAnalyses,
+    readyForSummary,
+    replayPoint,
+    runAnalysis,
+    summarizeAnalysis,
+} from "../src/domain/analysis/game-analysis.js";
+import { ADVICE_VERSION, type Advice, type CubeAdvice } from "../src/domain/game/advice.js";
+import type { Engine } from "../src/domain/game/engine.js";
+import {
+    appendEvent,
+    EMPTY_JOURNAL,
+    type GameJournal,
+    migrateJournal,
+    type NewGameEvent,
+    withAnalysesOf,
+} from "../src/domain/game/events.js";
+import { Game } from "../src/domain/game/game.js";
+import { START_POSITION } from "../src/domain/game/position.js";
+import { emptyReview, REVIEW_VERSION } from "../src/domain/game/review.js";
+import { loadNodeEngine } from "./support/node-engine.js";
+import { playToTheEnd, seededDice } from "./support/play.js";
+
+/** Un journal fait d'événements donnés, à la suite. */
+function journalOf(events: readonly NewGameEvent[]): GameJournal {
+    return events.reduce(appendEvent, EMPTY_JOURNAL);
+}
+
+const START: NewGameEvent = {
+    type: "GameStarted",
+    position: START_POSITION,
+    cube: { value: 1, owner: null },
+    firstTurn: null,
+};
+const P = START_POSITION;
+
+/** Une petite partie : ouverture (égalité puis 3-1 pour le joueur), un
+ * coup de chaque camp, puis le joueur double et l'ordinateur passe. */
+const SHORT: NewGameEvent[] = [
+    START,
+    { type: "DiceRolled", side: null, roll: [2, 2] },
+    { type: "DiceRolled", side: null, roll: [3, 1] },
+    { type: "MovePlayed", side: "player", halfMoves: [{ from: 8, to: 5 }], position: P },
+    { type: "DiceRolled", side: "computer", roll: [6, 5] },
+    { type: "MovePlayed", side: "computer", halfMoves: [{ from: 24, to: 13 }], position: P },
+    { type: "CubeOffered", side: "player" },
+    { type: "CubeDropped", side: "computer" },
+    { type: "GameEnded", winner: "player", kind: "single", points: 1 },
+];
+
+test("les tours d'une partie : ouverture, coups, double passé", () => {
+    const journal = journalOf(SHORT);
+    const turns = gameTurns(journal);
+    assert.deepEqual(
+        turns.map((t) => [t.number, t.side, t.roll, t.move?.id ?? null, t.end?.id ?? null]),
+        [
+            [1, "player", [3, 1], "4", null],
+            [2, "computer", [6, 5], "6", null],
+            [3, "player", null, null, "9"],
+        ],
+    );
+    // L'égalité d'ouverture appartient au premier tour.
+    assert.deepEqual(
+        turns[0]?.events.map((e) => e.id),
+        ["2", "3", "4"],
+    );
+    // Le jet d'ouverture qui désigne le joueur a une chance, l'égalité non.
+    const luck = missingAnalyses(journal).filter((t) => t.kind === "luck");
+    assert.deepEqual(
+        luck.map((t) => t.eventId),
+        ["3", "5"],
+    );
+});
+
+/** Un conseil fictif sur un coup du joueur. */
+function moveAdvice(eventId: string, equityLoss: number, moveCount = 10): Advice {
+    const move = { notation: "8/5", halfMoves: [], equity: 0, ply: 2 };
+    return {
+        version: ADVICE_VERSION,
+        kind: "move",
+        eventId,
+        ply: 2,
+        position: P,
+        roll: [3, 1],
+        opening: true,
+        moveCount,
+        rank: equityLoss === 0 ? 1 : 2,
+        played: move,
+        best: move,
+        playedFacts: { hits: 0, madePoints: [] },
+        bestFacts: { hits: 0, madePoints: [] },
+        ranking: [],
+        equityLoss,
+        skill:
+            equityLoss < -0.12
+                ? "veryBad"
+                : equityLoss < -0.06
+                  ? "bad"
+                  : equityLoss < -0.03
+                    ? "doubtful"
+                    : "none",
+    };
+}
+
+function cubeAdvice(eventId: string, action: CubeAdvice["action"], equityLoss: number): Advice {
+    return {
+        version: ADVICE_VERSION,
+        kind: "cube",
+        eventId,
+        ply: 2,
+        action,
+        position: P,
+        equities: { noDouble: 0.5, doubleTake: 0.6, doublePass: 1, optimal: 0.6 },
+        equityLoss,
+        skill: equityLoss < -0.06 ? "bad" : "none",
+    };
+}
+
+test("le taux d'erreur, le niveau et la chance à la manière de gnubg", () => {
+    // arThrsRating de gnubg : 0,032, 0,020, 0,013, 0,008, 0,005 ; les six
+    // classements de gnubg prennent, dans l'ordre, les noms des six niveaux
+    // de l'ordinateur (Advanced de gnubg : Intermédiaire).
+    assert.equal(levelOfErrorRate(0.05), "beginner");
+    assert.equal(levelOfErrorRate(0.032), "beginner");
+    assert.equal(levelOfErrorRate(0.031), "amateur");
+    assert.equal(levelOfErrorRate(0.015), "intermediate");
+    assert.equal(levelOfErrorRate(0.01), "advanced");
+    assert.equal(levelOfErrorRate(0.006), "expert");
+    assert.equal(levelOfErrorRate(0.001), "champion");
+    // getLuckRating : chance par tour × 10, seuils 0,3 et 0,6.
+    assert.equal(luckRatingOf(0.07), "veryLucky");
+    assert.equal(luckRatingOf(0.04), "lucky");
+    assert.equal(luckRatingOf(0.02), "none");
+    assert.equal(luckRatingOf(-0.04), "unlucky");
+    assert.equal(luckRatingOf(-0.07), "veryUnlucky");
+
+    const base = journalOf(SHORT);
+    const journal: GameJournal = {
+        ...base,
+        advice: {
+            "4": moveAdvice("4", -0.08),
+            "7": cubeAdvice("7", "double", 0),
+        },
+        review: {
+            ...emptyReview(2),
+            luck: {
+                "3": { value: 0.2, rating: "none" },
+                "5": { value: -0.1, rating: "none" },
+            },
+            computer: { "6": moveAdvice("6", 0) },
+        },
+    };
+    assert.ok(readyForSummary(journal));
+    const summary = summarizeAnalysis(journal);
+    // Un coup non forcé (0,08) et un double (compté toujours) : 0,04 par
+    // décision.
+    assert.equal(summary.player.errorRate.decisions, 2);
+    assert.ok(Math.abs(summary.player.errorRate.perDecision - 0.04) < 1e-9);
+    assert.equal(summary.player.errorRate.level, "beginner");
+    assert.deepEqual(summary.counts, { good: 1, doubtful: 0, bad: 1, veryBad: 0 });
+    assert.equal(summary.toReview?.advice.eventId, "4");
+    assert.equal(summary.toReview?.turn, 1);
+    // Une seule fois la main pour chacun : chance par tour égale au total.
+    assert.equal(summary.player.luck.rolls, 1);
+    assert.equal(summary.player.luck.rating, "veryLucky");
+    assert.equal(summary.computer.luck.rating, "veryUnlucky");
+    // Gagné 1 point, avec 0,2 de chance contre −0,1 pour l'ordinateur :
+    // 1 − 0,2 − 0,1.
+    assert.equal(summary.result, 1);
+    assert.ok(Math.abs(summary.luckAdjustedResult - 0.7) < 1e-9);
+    // Rejouer le premier tour : juste avant le coup, avec le même jet.
+    const first = gameTurns(journal)[0];
+    assert.ok(first !== undefined);
+    assert.equal(mainAdvice(journal, first)?.eventId, "4");
+    assert.equal(replayPoint(journal, first), "3");
+    // La courbe : le dernier tour finit la partie, gagnée.
+    assert.deepEqual(
+        chanceCurve(journal).map((p) => [p.turn, p.chance, p.verdict]),
+        [
+            [1, null, "bad"],
+            [2, null, null],
+            [3, 1, "good"],
+        ],
+    );
+});
+
+test("un jet sans doubler ne compte que si la décision est serrée (isCloseCubedecision)", () => {
+    const base = journalOf([
+        { ...START, firstTurn: "player" },
+        { type: "DiceRolled", side: "player", roll: [3, 1] },
+    ]);
+    const noDouble = (equities: CubeAdvice["equities"]): GameJournal => ({
+        ...base,
+        advice: { "2": { ...(cubeAdvice("2", "noDouble", 0) as CubeAdvice), equities } },
+    });
+    // Doubler coûterait 0,2 par rapport à l'optimum : pas serré.
+    const far = noDouble({ noDouble: 0.5, doubleTake: 0.3, doublePass: 1, optimal: 0.5 });
+    assert.equal(summarizeAnalysis(far).player.errorRate.decisions, 0);
+    // Doubler est l'optimum : serré, compté.
+    const close = noDouble({ noDouble: 0.5, doubleTake: 0.6, doublePass: 1, optimal: 0.6 });
+    assert.equal(summarizeAnalysis(close).player.errorRate.decisions, 1);
+    // Un bon jet sans doubler n'est pas une décision visible du bilan.
+    assert.deepEqual(summarizeAnalysis(close).counts, {
+        good: 0,
+        doubtful: 0,
+        bad: 0,
+        veryBad: 0,
+    });
+});
+
+test("l'analyse de partie enregistrée : migration du format durable", () => {
+    const journal = journalOf(SHORT);
+    const review = {
+        ...emptyReview(2),
+        luck: { "3": { value: 0.1, rating: "none" as const } },
+        winChances: { "4": 0.55, "99": 0.5 },
+        unanalysed: ["5", "98"],
+    };
+    // Un journal d'avant l'étape 1e se reprend tel quel.
+    assert.equal(migrateJournal(journal), journal);
+    // Les entrées rattachées à un événement absent sont oubliées.
+    const migrated = migrateJournal({ ...journal, review });
+    assert.deepEqual(migrated.review?.winChances, { "4": 0.55 });
+    assert.deepEqual(migrated.review?.unanalysed, ["5"]);
+    assert.deepEqual(migrated.review?.luck, review.luck);
+    // Une analyse complète et connue ne change pas.
+    const clean = { ...journal, review: migrated.review };
+    assert.equal(migrateJournal(clean), clean);
+    // Une autre version, ou une analyse mal formée, est oubliée.
+    const other = migrateJournal({
+        ...journal,
+        review: { ...review, version: REVIEW_VERSION + 1 },
+    });
+    assert.equal(other.review, undefined);
+    const broken = { ...journal, review: { version: REVIEW_VERSION } } as unknown as GameJournal;
+    assert.equal(migrateJournal(broken).review, undefined);
+    // Les analyses d'une copie s'ajoutent au journal sans toucher aux
+    // conseils déjà là.
+    const live: GameJournal = { ...journal, advice: { "4": moveAdvice("4", 0) } };
+    const copy: GameJournal = {
+        ...journal,
+        advice: { "4": moveAdvice("4", -0.5), "7": cubeAdvice("7", "double", 0) },
+        review,
+    };
+    const merged = withAnalysesOf(live, copy);
+    assert.equal(merged.advice?.["4"]?.equityLoss, 0);
+    assert.ok(merged.advice?.["7"] !== undefined);
+    assert.equal(merged.review, review);
+});
+
+/** Toutes les analyses qui manquent, une à une. */
+async function analyseAll(engine: Engine, journal: GameJournal): Promise<GameJournal> {
+    let current = journal;
+    for (let i = 0; i < 500; i++) {
+        const next = missingAnalyses(current)[0];
+        if (next === undefined) {
+            return current;
+        }
+        current = await runAnalysis(engine, current, next);
+    }
+    throw new Error("l'analyse ne finit pas");
+}
+
+test("une partie complète analysée par le moteur, comme une partie d'avant 1d", async () => {
+    const engine = await loadNodeEngine();
+    // Une course courte (tests/reference/positions.json, race-1).
+    const game = Game.start(engine, {
+        setup: { position: "trsXAADs7mwAAA", firstTurn: "player" },
+        level: "2ply",
+        dice: seededDice(7),
+    });
+    await playToTheEnd(game, engine, 1);
+    // Aucun conseil n'a été rangé pendant la partie (comme avant l'étape
+    // 1d) : tout est à analyser.
+    assert.equal(game.journal.advice, undefined);
+    assert.ok(!readyForSummary(game.journal));
+    const analysed = await analyseAll(engine, game.journal);
+    assert.ok(readyForSummary(analysed));
+    assert.deepEqual(missingAnalyses(analysed), []);
+
+    const summary = summarizeAnalysis(analysed);
+    const advices = Object.values(analysed.advice ?? {});
+    assert.ok(advices.length > 0);
+    // Le coup à revoir est la plus grosse perte d'équité du joueur, s'il en
+    // a une.
+    const worst = advices
+        .filter((a) => a.skill !== "none")
+        .reduce<Advice | null>((w, a) => (w === null || a.equityLoss < w.equityLoss ? a : w), null);
+    assert.equal(summary.toReview?.advice.eventId, worst?.eventId);
+    // La chance de chaque tour d'un camp est comptée.
+    const moves = game.events.filter((e) => e.type === "MovePlayed");
+    assert.equal(summary.player.luck.rolls + summary.computer.luck.rolls, moves.length);
+    // Les chances de gagner sont des probabilités, et la courbe finit sur
+    // le résultat.
+    const curve = chanceCurve(analysed);
+    assert.ok(curve.every((p) => p.chance !== null && p.chance >= 0 && p.chance <= 1));
+    const won = game.state.result?.winner === "player";
+    assert.equal(curve.at(-1)?.chance, won ? 1 : 0);
+    // Les coups de l'ordinateur sont analysés aussi.
+    assert.ok(Object.keys(analysed.review?.computer ?? {}).length > 0);
+    // Le journal analysé se reprend : l'analyse fait partie du format.
+    const resumed = Game.resume(engine, JSON.parse(JSON.stringify(analysed)));
+    assert.deepEqual(resumed.journal.review, analysed.review);
+});

app/tests/game.test.ts

@@ -73,6 +73,7 @@ function fakeEngine(overrides: Partial<Engine> = {}): Engine {
             };
         },
         analyseMove: async () => null,
+        rankMoves: async () => [],
         analyseCube: async () => ({
             analysed: false,
             equities: null,
@@ -80,6 +81,7 @@ function fakeEngine(overrides: Partial<Engine> = {}): Engine {
             skill: "none",
         }),
         luck: async () => ({ value: 0, rating: "none" }),
+        evaluate: async () => ({ win: 0.5, equity: 0 }),
         encodeMatch: async () => "MATCH",
         decodeMatch: async () => ({
             matchLength: 0,

app/tests/review-runner.test.ts

@@ -0,0 +1,151 @@
+// L'analyse d'une partie en arrière-plan (app/src/ui/review-runner.ts) :
+// une analyse à la fois, rangée au fur et à mesure, arrêtée à la demande
+// ou par une autre partie ; et les phrases du bilan.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import {
+    type AnalysisTask,
+    type GameSummary,
+    missingAnalyses,
+} from "../src/domain/analysis/game-analysis.js";
+import { diceWords, nothingToReview, summaryReading } from "../src/domain/analysis/phrases.js";
+import {
+    appendEvent,
+    EMPTY_JOURNAL,
+    type GameJournal,
+    type NewGameEvent,
+} from "../src/domain/game/events.js";
+import { START_POSITION } from "../src/domain/game/position.js";
+import { emptyReview, type GameReview } from "../src/domain/game/review.js";
+import { createReviewRunner } from "../src/ui/review-runner.js";
+import { loadPhrases } from "./support/advice.js";
+
+const P = START_POSITION;
+/** Un tour de l'ordinateur, sans décision du joueur. */
+const EVENTS: NewGameEvent[] = [
+    { type: "GameStarted", position: P, cube: { value: 1, owner: null }, firstTurn: "computer" },
+    { type: "DiceRolled", side: "computer", roll: [6, 5] },
+    { type: "MovePlayed", side: "computer", halfMoves: [], position: P },
+];
+const JOURNAL: GameJournal = EVENTS.reduce(appendEvent, EMPTY_JOURNAL);
+
+/** Une fausse analyse : elle range la tâche sans moteur, quand on la
+ * libère. */
+function fakeRun() {
+    const waiting: (() => void)[] = [];
+    const run = async (journal: GameJournal, task: AnalysisTask): Promise<GameJournal> => {
+        await new Promise<void>((resolve) => waiting.push(resolve));
+        const review: GameReview = journal.review ?? emptyReview(2);
+        if (task.kind === "luck") {
+            return {
+                ...journal,
+                review: { ...review, luck: { [task.eventId]: { value: 0, rating: "none" } } },
+            };
+        }
+        if (task.kind === "chance") {
+            return {
+                ...journal,
+                review: { ...review, winChances: { ...review.winChances, [task.eventId]: 0.5 } },
+            };
+        }
+        return { ...journal, review: { ...review, unanalysed: [task.eventId] } };
+    };
+    const release = async () => {
+        while (waiting.length === 0) {
+            await new Promise((resolve) => setTimeout(resolve, 1));
+        }
+        waiting.shift()?.();
+        await new Promise((resolve) => setTimeout(resolve, 1));
+    };
+    return { run, release };
+}
+
+test("l'analyse en arrière-plan range chaque analyse, puis s'arrête une fois tout fait", async () => {
+    const { run, release } = fakeRun();
+    const runner = createReviewRunner(run);
+    const recorded: GameJournal[] = [];
+    let done = false;
+    // La chance du jet, le jet sans doubler de l'ordinateur, ses chances
+    // après le coup.
+    const total = missingAnalyses(JOURNAL).length;
+    assert.equal(total, 3);
+    runner.start(
+        "a",
+        JOURNAL,
+        (j) => recorded.push(j),
+        () => {
+            done = true;
+        },
+    );
+    assert.equal(runner.running, "a");
+    // La même partie redemandée ne repart pas.
+    runner.start("a", JOURNAL, () => assert.fail("deuxième analyse"));
+    for (let i = 0; i < total; i++) {
+        await release();
+    }
+    assert.equal(recorded.length, total);
+    assert.deepEqual(missingAnalyses(recorded.at(-1) as GameJournal), []);
+    assert.ok(done);
+    assert.equal(runner.running, null);
+});
+
+test("l'analyse s'arrête à la demande, ou pour une autre partie, sans ranger la dernière", async () => {
+    const { run, release } = fakeRun();
+    const runner = createReviewRunner(run);
+    const recorded: string[] = [];
+    runner.start("a", JOURNAL, () => recorded.push("a"));
+    runner.stop();
+    assert.equal(runner.running, null);
+    await release();
+    assert.equal(recorded.length, 0);
+    runner.start("b", JOURNAL, () => recorded.push("b"));
+    runner.start("c", JOURNAL, () => recorded.push("c"));
+    assert.equal(runner.running, "c");
+    await release();
+    await release();
+    assert.deepEqual(recorded, ["c"]);
+});
+
+/** Un bilan réduit à ce que lisent les phrases. */
+function summaryWith(result: number, luckAdjustedResult: number): GameSummary {
+    const side = {
+        errorRate: { total: 0, decisions: 0, perDecision: 0, level: "champion" as const },
+        luck: { total: 0, rolls: 1, perRoll: -0.04, rating: "unlucky" as const, points: 0 },
+    };
+    return {
+        player: side,
+        computer: side,
+        counts: { good: 0, doubtful: 0, bad: 0, veryBad: 0 },
+        toReview: null,
+        result,
+        luckAdjustedResult,
+    };
+}
+
+test("les phrases du bilan : ce qui a fait la différence, et les dés en mots", () => {
+    const phrases = loadPhrases();
+    assert.equal(diceWords(phrases, "unlucky"), "un peu contre vous");
+    assert.equal(
+        summaryReading(phrases, summaryWith(1, 1.2)),
+        "D'après mon analyse, votre jeu a fait la différence, avec des dés un peu contre vous.",
+    );
+    assert.equal(
+        summaryReading(phrases, summaryWith(-2, -1.5)),
+        "D'après mon analyse, le jeu de l'ordinateur a fait la différence, avec des dés un peu contre vous.",
+    );
+    // Gagnée grâce aux dés, ou perdue à cause d'eux : les dés.
+    for (const [result, adjusted] of [
+        [1, -0.3],
+        [-1, 0.2],
+    ] as const) {
+        assert.equal(
+            summaryReading(phrases, summaryWith(result, adjusted)),
+            "D'après mon analyse, les dés ont fait la différence, plus que le jeu.",
+        );
+    }
+    assert.ok(nothingToReview(phrases).startsWith("Aucun coup à revoir"));
+});

app/tests/router.test.ts

@@ -35,8 +35,12 @@ const TABLE: [string, Route][] = [
     ["#/installer", { screen: "install" }],
     ["#/parties", { screen: "games", game: null }],
     ["#/parties/mh2k3x-a1b2c3", { screen: "games", game: "mh2k3x-a1b2c3" }],
+    ["#/parties/mh2k3x-a1b2c3/bilan", { screen: "summary", game: "mh2k3x-a1b2c3" }],
+    ["#/parties/mh2k3x-a1b2c3/analyse", { screen: "analysis", game: "mh2k3x-a1b2c3", turn: null }],
+    ["#/parties/mh2k3x-a1b2c3/analyse/7", { screen: "analysis", game: "mh2k3x-a1b2c3", turn: 7 }],
     ["#/menu", { screen: "menu" }],
     ["#/nouvelle-partie", { screen: "newGame" }],
+    ["#/explication/12", { screen: "explanation", event: "12" }],
     [
         "#/position/4HPwATDgc%2FABMA/cAkAAAAAAAAA",
         { screen: "position", position: START, match: MATCH },
@@ -74,6 +78,12 @@ test("une adresse inconnue est reconnue comme telle", () => {
         "#/a-propos/x",
         "#/position",
         "#/position/%E0%A4%A",
+        "#/parties/ab/autre",
+        "#/parties/ab/bilan/2",
+        "#/parties/ab/analyse/0",
+        "#/parties/ab/analyse/x",
+        "#/parties/ab/analyse/3/plus",
+        "#/parties/AB/bilan",
     ]) {
         assert.equal(parseRoute(hash).screen, "unknown", hash);
     }

app/tests/steps/comprendre-mes-coups.steps.ts

@@ -0,0 +1,145 @@
+// Étapes du scénario docs/scenarios/comprendre-mes-coups.feature (ADR 0008) :
+// les décisions passent par le domaine et le vrai moteur, le conseil par
+// l'analyse du domaine, ses mots par la source des phrases du maître, et
+// la ligne par le suivi du conseil de l'interface (advice-tracker.ts) avec
+// le réglage de l'application.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import assert from "node:assert/strict";
+import { Before, BeforeAll, Given, setDefaultTimeout, Then, When } from "@cucumber/cucumber";
+import { analyseDecision } from "../../src/domain/analysis/analyse.js";
+import { masterWords } from "../../src/domain/analysis/phrases.js";
+import type { Advice } from "../../src/domain/game/advice.js";
+import type { Engine } from "../../src/domain/game/engine.js";
+import { Game } from "../../src/domain/game/game.js";
+import { parseHalfMoves, START_POSITION } from "../../src/domain/game/position.js";
+import { fixedDice } from "../../src/domain/game/roll.js";
+import { createAdviceTracker } from "../../src/ui/advice-tracker.js";
+import { parseSettings, type Settings } from "../../src/ui/settings.js";
+import { DOUBLE_TAKE_POSITION, loadPhrases } from "../support/advice.js";
+import { loadNodeEngine } from "../support/node-engine.js";
+
+setDefaultTimeout(30_000);
+
+const phrases = loadPhrases();
+let engine: Engine;
+let game: Game;
+let settings: Settings;
+let tracker: ReturnType<typeof createAdviceTracker>;
+let ready: Promise<void>;
+let markReady: () => void;
+
+BeforeAll(async () => {
+    engine = await loadNodeEngine();
+});
+
+Before(() => {
+    settings = parseSettings(null);
+    ready = new Promise((resolve) => {
+        markReady = resolve;
+    });
+    tracker = createAdviceTracker({
+        analyse: (journal, eventId) => analyseDecision(engine, journal, eventId),
+        recorded: () => {},
+        changed: () => markReady(),
+    });
+});
+
+/** Joue une décision du joueur comme l'écran de jeu : la ligne d'avant
+ * s'efface, la décision part à l'analyse. */
+async function decide(action: (g: Game) => Promise<void> | void): Promise<void> {
+    tracker.clear();
+    const before = game.events;
+    await action(game);
+    tracker.track(game, before);
+}
+
+/** Ce que montre la ligne du maître (null : rien), comme l'écran : le
+ * conseil prêt, si le réglage le permet. */
+async function line(): Promise<{ word: string; phrase: string; advice: Advice } | null> {
+    await Promise.race([ready, new Promise((resolve) => setTimeout(resolve, 10_000))]);
+    const advice = tracker.shown;
+    if (!settings.masterAdvice || advice === null) {
+        return null;
+    }
+    const words = masterWords(phrases, advice);
+    return { word: words.word, phrase: words.phrase, advice };
+}
+
+Given("vous avez {int}-{int} à jouer à la position de départ", async (a: number, b: number) => {
+    game = Game.start(engine, {
+        setup: { position: START_POSITION, firstTurn: "player" },
+        dice: fixedDice([a, b, 6, 5]),
+    });
+    await decide((g) => g.roll());
+});
+
+Given("vous avez coupé le conseil du maître", () => {
+    settings = { ...settings, masterAdvice: false };
+});
+
+When("vous validez le coup {}", async (move: string) => {
+    await decide(async (g) => {
+        for (const halfMove of parseHalfMoves(move)) {
+            assert.ok(await g.playHalfMove(halfMove), `demi-coup refusé : ${move}`);
+        }
+        await g.confirmMove();
+    });
+    // L'ordinateur joue aussitôt, sans attendre l'analyse.
+    await game.playComputerTurn();
+});
+
+Then("le maître dit « {}. »", async (word: string) => {
+    const shown = await line();
+    assert.equal(shown?.word, word);
+});
+
+Then("sa phrase dit que {} fait votre point {int}", async (move: string, point: number) => {
+    const shown = await line();
+    assert.ok(shown?.phrase.includes(`${move} fait votre point ${point}.`), shown?.phrase);
+});
+
+Then("sa phrase commence par « {} »", async (start: string) => {
+    const shown = await line();
+    assert.ok(shown?.phrase.startsWith(start), shown?.phrase);
+});
+
+Then("sa phrase dit « {} »", async (phrase: string) => {
+    const shown = await line();
+    assert.equal(shown?.phrase, phrase);
+});
+
+Then("l'explication peut montrer votre coup et le coup du maître sur le plateau", async () => {
+    const shown = await line();
+    assert.ok(shown !== null && shown.advice.kind === "move");
+    const advice = shown.advice;
+    const mine = await game.stepsBefore(advice.eventId, "player", advice.played.halfMoves);
+    const best = await game.stepsBefore(advice.eventId, "player", advice.best.halfMoves);
+    // Les deux coups partent de la même position, celle d'avant le coup.
+    assert.deepEqual(mine.boards[0], best.boards[0]);
+    assert.equal(best.halfMoves.length, 2);
+    assert.notDeepEqual(mine.boards.at(-1), best.boards.at(-1));
+});
+
+Then("le maître ne dit rien", async () => {
+    assert.equal(await line(), null);
+    // Le coup est tout de même analysé, pour le bilan de fin de partie.
+    const move = game.events.find((e) => e.type === "MovePlayed" && e.side === "player");
+    assert.ok(game.advice[move?.id ?? ""] !== undefined);
+});
+
+Given("l'ordinateur vous propose de doubler dans une position où il faut prendre", async () => {
+    game = Game.start(engine, {
+        setup: { position: DOUBLE_TAKE_POSITION, firstTurn: "computer" },
+        level: "2ply",
+        dice: fixedDice([]),
+    });
+    await game.playComputerTurn();
+    assert.equal(game.state.phase, "doubled");
+});
+
+When("vous passez son double", async () => {
+    await decide((g) => g.drop());
+});

app/tests/steps/revoir-ma-partie.steps.ts

@@ -0,0 +1,232 @@
+// Étapes du scénario docs/scenarios/revoir-ma-partie.feature (ADR 0008) :
+// la partie se joue par le domaine sur le vrai moteur, avec des dés
+// imposés ; son analyse passe par l'analyse en arrière-plan de l'interface
+// (review-runner.ts, sans DOM), le bilan par le domaine
+// (game-analysis.ts) et les phrases du maître, et l'ancienne partie par le
+// stockage des parties sur un localStorage simulé.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import assert from "node:assert/strict";
+import { BeforeAll, Given, setDefaultTimeout, Then, When } from "@cucumber/cucumber";
+import {
+    chanceCurve,
+    gameTurns,
+    missingAnalyses,
+    readyForSummary,
+    replayPoint,
+    runAnalysis,
+    summarizeAnalysis,
+} from "../../src/domain/analysis/game-analysis.js";
+import { diceWords, summaryReading } from "../../src/domain/analysis/phrases.js";
+import type { Engine } from "../../src/domain/game/engine.js";
+import type { GameJournal } from "../../src/domain/game/events.js";
+import { Game } from "../../src/domain/game/game.js";
+import { parseHalfMoves } from "../../src/domain/game/position.js";
+import { fixedDice } from "../../src/domain/game/roll.js";
+import { memoryStorage, openGameLibrary } from "../../src/storage/open-library.js";
+import { createReviewRunner } from "../../src/ui/review-runner.js";
+import { loadPhrases } from "../support/advice.js";
+import { loadNodeEngine } from "../support/node-engine.js";
+
+setDefaultTimeout(60_000);
+
+/** Le joueur au trait : un pion sur son point 6, un sur son point 1 ;
+ * l'ordinateur : un sur son point 1, un sur son point 2 (Position ID de
+ * gnubg, chacun vu de lui-même). */
+const BEAROFF = "BQAACAIAAAAAAA";
+
+const phrases = loadPhrases();
+let engine: Engine;
+let game: Game;
+let dice: number[];
+/** Le journal analysé de la partie. */
+let analysed: GameJournal;
+/** La partie d'origine, avant « Rejouer d'ici ». */
+let original: { head: string; events: number };
+/** Les analyses rangées par l'analyse en arrière-plan. */
+let recorded: number;
+
+BeforeAll(async () => {
+    engine = await loadNodeEngine();
+});
+
+/** Analyse ce qui manque au journal, comme l'application en
+ * arrière-plan. */
+async function analyse(journal: GameJournal): Promise<GameJournal> {
+    const runner = createReviewRunner((j, task) => runAnalysis(engine, j, task));
+    recorded = 0;
+    let latest = journal;
+    await new Promise<void>((resolve) => {
+        runner.start(
+            "partie",
+            journal,
+            (j) => {
+                latest = j;
+                recorded++;
+            },
+            resolve,
+        );
+    });
+    return latest;
+}
+
+async function playMove(move: string): Promise<void> {
+    for (const halfMove of parseHalfMoves(move)) {
+        assert.ok(await game.playHalfMove(halfMove), `demi-coup refusé : ${move}`);
+    }
+    await game.confirmMove();
+}
+
+Given(
+    "il vous reste deux pions, sur vos points 6 et 1, et à l'ordinateur deux pions sur ses points 1 et 2",
+    () => {
+        dice = [];
+        // Les dés sont tirés au moment voulu : ceux qu'impose le scénario.
+        game = Game.start(engine, {
+            setup: { position: BEAROFF, firstTurn: "player" },
+            level: "2ply",
+            dice: () => {
+                const die = dice.shift();
+                if (die === undefined) {
+                    throw new Error("plus de dés imposés");
+                }
+                return die;
+            },
+        });
+    },
+);
+
+Given("vous avez {int}-{int} à jouer", async (a: number, b: number) => {
+    dice.push(a, b);
+    await game.roll();
+    assert.deepEqual(game.state.roll, [a, b]);
+});
+
+When(/^vous choisissez (?:cette fois )?le coup (.+)$/, async (move: string) => {
+    await playMove(move);
+});
+
+/** L'ordinateur, sûr de sortir ses deux pions au jet suivant, double ; le
+ * joueur passe. */
+async function computerDoublesAndPlayerPasses(): Promise<void> {
+    await game.playComputerTurn();
+    assert.equal(game.state.phase, "doubled", "l'ordinateur ne double pas");
+    await game.drop();
+    assert.equal(game.state.phase, "over");
+}
+
+When("l'ordinateur, sûr de gagner, double et que vous passez", async () => {
+    await computerDoublesAndPlayerPasses();
+    analysed = await analyse(game.journal);
+});
+
+Then("la partie est finie, gagnée par l'ordinateur", () => {
+    assert.equal(game.state.result?.winner, "computer");
+});
+
+Then("le bilan compte une grosse erreur", () => {
+    assert.ok(readyForSummary(analysed));
+    assert.equal(summarizeAnalysis(analysed).counts.veryBad, 1);
+});
+
+Then("sa phrase dit ce qui a fait la différence, et comment étaient vos dés", () => {
+    const summary = summarizeAnalysis(analysed);
+    const reading = summaryReading(phrases, summary);
+    assert.ok(reading.startsWith("D'après mon analyse, "), reading);
+    assert.ok(!reading.includes("!"), reading);
+    // Perdue : le jeu de l'ordinateur a fait la différence, si le résultat
+    // corrigé de la chance reste négatif ; sinon les dés.
+    if (summary.luckAdjustedResult < 0) {
+        assert.ok(reading.includes(diceWords(phrases, summary.player.luck.rating)), reading);
+    } else {
+        assert.ok(reading.includes("les dés ont fait la différence"), reading);
+    }
+});
+
+Then("le coup à revoir est votre coup {}, le premier de la partie", (move: string) => {
+    const toReview = summarizeAnalysis(analysed).toReview;
+    assert.equal(toReview?.turn, 1);
+    assert.equal(toReview?.advice.kind, "move");
+    assert.equal(toReview?.advice.kind === "move" && toReview.advice.played.notation, move);
+});
+
+Then("le maître y aurait joué {}", (move: string) => {
+    const advice = summarizeAnalysis(analysed).toReview?.advice;
+    assert.equal(advice?.kind === "move" && advice.best.notation, move);
+    assert.equal(advice?.skill, "veryBad");
+});
+
+Then("la courbe de vos chances de gagner finit à {int} %", (percent: number) => {
+    const curve = chanceCurve(analysed);
+    assert.equal(curve.length, gameTurns(analysed).length);
+    assert.equal(curve.at(-1)?.chance, percent / 100);
+    assert.ok(curve.every((p) => p.chance !== null && p.chance >= 0 && p.chance <= 1));
+});
+
+When("vous rejouez d'ici le coup à revoir", () => {
+    game.recordAnalyses(analysed);
+    original = { head: game.journal.head ?? "", events: game.events.length };
+    const toReview = summarizeAnalysis(game.journal).toReview;
+    const turn = gameTurns(game.journal)[(toReview?.turn ?? 0) - 1];
+    assert.ok(turn !== undefined);
+    const point = replayPoint(game.journal, turn);
+    assert.ok(point !== null);
+    game.goBackTo(point);
+});
+
+Then("vous avez de nouveau {int}-{int} à jouer", (a: number, b: number) => {
+    assert.equal(game.state.phase, "moving");
+    assert.equal(game.state.turn, "player");
+    assert.deepEqual(game.state.roll, [a, b]);
+});
+
+Then("la partie est finie, gagnée par vous", () => {
+    assert.equal(game.state.result?.winner, "player");
+});
+
+Then("la partie a deux branches, dont la partie d'origine, intacte", () => {
+    const branches = game.branches;
+    assert.equal(branches.length, 2);
+    const origin = branches.find((b) => b.forkedFrom === null);
+    assert.equal(origin?.head, original.head);
+    assert.ok(origin?.over);
+    // L'analyse de la partie d'origine reste attachée à ses événements.
+    assert.ok(game.journal.review !== undefined);
+});
+
+Given("une partie finie enregistrée sans aucune analyse", async () => {
+    dice = [6, 1];
+    game = Game.start(engine, {
+        setup: { position: BEAROFF, firstTurn: "player" },
+        level: "2ply",
+        dice: fixedDice(dice),
+    });
+    await game.roll();
+    await playMove("6/5 5/off");
+    await computerDoublesAndPlayerPasses();
+    const { library } = await openGameLibrary({ localStorage: memoryStorage() });
+    await library.save("ancienne", game.journal, { level: "2ply" });
+    const saved = await library.load("ancienne");
+    assert.ok(saved !== null);
+    analysed = saved.journal;
+    assert.equal(analysed.advice, undefined);
+    assert.equal(analysed.review, undefined);
+});
+
+When("vous ouvrez son bilan", () => {
+    assert.ok(!readyForSummary(analysed));
+});
+
+Then("le maître l'analyse d'abord en arrière-plan", async () => {
+    const before = missingAnalyses(analysed).length;
+    analysed = await analyse(analysed);
+    assert.equal(recorded, before);
+    assert.ok(readyForSummary(analysed));
+});
+
+Then("le bilan nomme ensuite le coup à revoir", () => {
+    const advice = summarizeAnalysis(analysed).toReview?.advice;
+    assert.equal(advice?.kind === "move" && advice.played.notation, "6/off");
+});

app/tests/support/advice.ts

@@ -0,0 +1,108 @@
+// Des décisions du joueur dans des positions connues, jouées par le domaine
+// sur le vrai moteur, puis analysées : de quoi tester le conseil du maître
+// (tests unitaires et scénarios).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import { readFileSync } from "node:fs";
+import { analyseDecision } from "../../src/domain/analysis/analyse.js";
+import { type MasterPhrases, parsePhrases } from "../../src/domain/analysis/phrases.js";
+import type { Advice } from "../../src/domain/game/advice.js";
+import type { Engine } from "../../src/domain/game/engine.js";
+import { Game } from "../../src/domain/game/game.js";
+import { parseHalfMoves, START_POSITION } from "../../src/domain/game/position.js";
+import { fixedDice } from "../../src/domain/game/roll.js";
+
+const root = new URL("../../../../", import.meta.url);
+
+/** Les phrases du maître, lues dans leur source. */
+export function loadPhrases(): MasterPhrases {
+    return parsePhrases(readFileSync(new URL("docs/maitre/phrases.md", root), "utf8"));
+}
+
+/** Une position de double et prise (videau au centre), vue de celui qui a
+ * la main : doubler y est juste, et prendre aussi (tests du moteur, 1a). */
+export const DOUBLE_TAKE_POSITION = "6O5uAAC4uzsAAA";
+
+/** Le joueur, au trait à la position de départ, lance dice et joue move ;
+ * la partie et l'événement du coup. */
+export async function playOpening(
+    engine: Engine,
+    dice: readonly [number, number],
+    move: string,
+): Promise<{ game: Game; eventId: string }> {
+    const game = Game.start(engine, {
+        setup: { position: START_POSITION, firstTurn: "player" },
+        // Le jet du joueur, puis celui de l'ordinateur s'il joue ensuite.
+        dice: fixedDice([...dice, 6, 5]),
+    });
+    await game.roll();
+    for (const halfMove of parseHalfMoves(move)) {
+        if (!(await game.playHalfMove(halfMove))) {
+            throw new Error(`demi-coup refusé : ${move}`);
+        }
+    }
+    await game.confirmMove();
+    const played = game.events.findLast((e) => e.type === "MovePlayed");
+    return { game, eventId: played?.id ?? "" };
+}
+
+/** Le joueur, au trait dans la position de double et prise, double ;
+ * l'ordinateur répond. */
+export async function playerDoubles(engine: Engine): Promise<{ game: Game; eventId: string }> {
+    const game = Game.start(engine, {
+        setup: { position: DOUBLE_TAKE_POSITION, firstTurn: "player" },
+        dice: fixedDice([]),
+    });
+    await game.double();
+    const offered = game.events.find((e) => e.type === "CubeOffered");
+    return { game, eventId: offered?.id ?? "" };
+}
+
+/** Le joueur, au trait dans la position de double et prise, lance sans
+ * doubler. */
+export async function playerRollsWithoutDoubling(
+    engine: Engine,
+): Promise<{ game: Game; eventId: string }> {
+    const game = Game.start(engine, {
+        setup: { position: DOUBLE_TAKE_POSITION, firstTurn: "player" },
+        dice: fixedDice([6, 5]),
+    });
+    await game.roll();
+    const rolled = game.events.findLast((e) => e.type === "DiceRolled");
+    return { game, eventId: rolled?.id ?? "" };
+}
+
+/** L'ordinateur, au trait dans la position de double et prise, double ; le
+ * joueur prend (take) ou passe. */
+export async function playerAnswers(
+    engine: Engine,
+    take: boolean,
+): Promise<{ game: Game; eventId: string }> {
+    const game = Game.start(engine, {
+        setup: { position: DOUBLE_TAKE_POSITION, firstTurn: "computer" },
+        level: "2ply",
+        dice: fixedDice([]),
+    });
+    await game.playComputerTurn();
+    if (take) {
+        game.take();
+    } else {
+        await game.drop();
+    }
+    const answer = game.events.find((e) => e.type === (take ? "CubeTaken" : "CubeDropped"));
+    return { game, eventId: answer?.id ?? "" };
+}
+
+/** Le conseil du moteur sur une décision ; erreur s'il n'y en a pas. */
+export async function adviceOn(
+    engine: Engine,
+    played: { game: Game; eventId: string },
+): Promise<Advice> {
+    const advice = await analyseDecision(engine, played.game.journal, played.eventId);
+    if (advice === null) {
+        throw new Error(`aucun conseil pour l'événement ${played.eventId}`);
+    }
+    return advice;
+}

app/tests/ui.test.ts

@@ -242,11 +242,15 @@ test("l'aide lit chaque fiche de l'index du glossaire", () => {
 });
 
 test("les textes de fin de partie emploient les mots du glossaire", () => {
-    assert.equal(TEXTS.endTitle("computer", "gammon", false), "L'ordinateur gagne un gammon");
+    assert.equal(TEXTS.endTitle("computer", "gammon"), "L'ordinateur gagne un gammon");
     assert.equal(TEXTS.endDetail("computer", 8, 4), "8 points pour lui, videau à 4.");
-    assert.equal(TEXTS.endTitle("player", "single", false), "Vous gagnez la partie simple");
+    assert.equal(TEXTS.endTitle("player", "single"), "Vous gagnez la partie simple");
     assert.equal(TEXTS.endDetail("player", 1, 1), "1 point pour vous.");
-    assert.equal(TEXTS.endTitle("player", "single", true), "L'ordinateur passe");
+    // Un double passé : le titre donne l'issue, le détail dit comment.
+    assert.equal(
+        `${TEXTS.droppedDouble("computer")}${TEXTS.endDetail("computer", 1, 1)}`,
+        "Vous avez passé son double : 1 point pour lui.",
+    );
     assert.equal(
         TEXTS.computerMoved([6, 4], "24/18 13/9"),
         "L'ordinateur a joué 6-4 : 24/18 13/9.",

docs/adr/0007-architecture-et-conventions-de-code.md

@@ -128,3 +128,59 @@ ne change pas (version 1) : le résumé d'une partie gagne un champ facultatif
 `match`, recalculé à chaque enregistrement, et les réglages
 (`ustagammon.settings`) quatre champs (`gameKind`, `matchLength`, `level`,
 `masterAdvice`) qui ont une valeur par défaut quand ils manquent.
+
+### 2026-11-10 — Le conseil du maître rattaché au journal
+
+Avec le conseil du maître (étape 1d), le journal d'une partie
+(`GameJournal`, `app/src/domain/game/events.ts`) gagne un champ facultatif
+`advice` : pour chaque décision du joueur analysée (coup, jet sans doubler,
+double, prise ou refus d'un double), l'analyse du moteur à 2 plis, rangée
+sous l'identifiant de l'événement de la décision
+(`app/src/domain/game/advice.ts`). Ce n'est pas un événement : l'analyse
+arrive après coup, d'un second moteur, et ne change pas la partie ; les
+événements gardent leur version (2). Le bilan de fin de partie (1e) la
+relira sans recalcul.
+
+- Chaque conseil porte sa version (`ADVICE_VERSION`, 1). À la reprise
+  (`migrateJournal`), un conseil d'une autre version, ou rattaché à un
+  événement absent, est oublié : ce n'est qu'une analyse, qui peut être
+  refaite. Un journal enregistré avant l'étape 1d n'a pas de champ `advice`
+  et se reprend tel quel. Testé dans `app/tests/advice.test.ts`.
+- Ajouter un événement, revenir en arrière ou changer de branche garde les
+  conseils ; un conseil reste attaché à son événement, même hors de la
+  branche courante.
+- Le schéma IndexedDB ne change pas : le journal est enregistré tel quel.
+
+### 2026-11-10 — L'analyse de partie rattachée au journal
+
+Avec le bilan de fin de partie et l'écran d'analyse (étape 1e), le journal
+d'une partie (`GameJournal`) gagne un second champ facultatif, `review`
+(`GameReview`, `app/src/domain/game/review.ts`) : le reste de l'analyse
+de la partie par le moteur, à côté des conseils du maître (`advice`) :
+
+- `luck` : la chance de chaque jet (`DiceRolled`, jet d'ouverture compris)
+  pour le camp qui le joue ;
+- `winChances` : les chances de gagner du joueur après chaque coup
+  (`MovePlayed`), de 0 à 1 ;
+- `computer` : les décisions de l'ordinateur, analysées comme celles du
+  joueur (même format que les conseils) ;
+- `unanalysed` : les décisions que le moteur n'analyse pas (videau
+  inaccessible, position de départ), pour ne plus les redemander ;
+- `version` (`REVIEW_VERSION`, 1) et `ply`, le niveau des analyses (2).
+
+Comme les conseils, ce n'est pas un événement : les événements gardent leur
+version (2). Les analyses qui manquent (dont tous les conseils d'une partie
+jouée avant l'étape 1d) sont calculées en arrière-plan sur le second moteur,
+une à une, rangées au fur et à mesure, et l'ensemble s'arrête quand on n'en
+a plus besoin (`app/src/ui/review-runner.ts`).
+
+- À la reprise (`migrateJournal`), une analyse d'une autre version ou mal
+  formée est oubliée ; ses entrées rattachées à un événement absent aussi.
+  Un journal enregistré avant l'étape 1e n'a pas de champ `review` et se
+  reprend tel quel. Testé dans `app/tests/game-analysis.test.ts`.
+- Une analyse faite en arrière-plan sur une copie du journal s'y range
+  sans toucher aux conseils déjà là (`withAnalysesOf`).
+- Le schéma IndexedDB ne change pas : le journal est enregistré tel quel.
+  La bibliothèque gagne `saveAnalyses`, qui enregistre le journal analysé
+  d'une partie sans en faire la partie en cours ni changer la date de sa
+  dernière action (l'ordre de « Mes parties »).

docs/adr/0013-position-dans-l-adresse.md

@@ -112,3 +112,50 @@ Le menu, l'accueil et « Nouvelle partie » en fin de partie y mènent. « Comme
 remplace cette adresse par celle de la partie (`#/`) : le retour du téléphone
 ne rouvre pas l'écran. Le lien d'une position d'une partie de match porte le
 Match ID du match (longueur, score, partie Crawford), écrit par le moteur.
+
+### 2026-11-10 — Adresse de la feuille d'explication du maître
+
+Ajoutée avec le conseil du maître (étape 1d), dans le même schéma :
+
+| Écran | Adresse |
+| --- | --- |
+| Feuille d'explication du maître sur une décision de la partie en cours | `#/explication/<événement>` |
+
+`<événement>` est l'identifiant, dans le journal de la partie en cours, de
+l'événement de la décision commentée (le coup, le double, la prise…). La
+ligne du maître est un lien vers cette adresse ; la feuille monte au-dessus
+de la partie, comme le menu, et « Fermer » (ou le retour du téléphone)
+revient à la partie. Rechargée, l'adresse rouvre la même explication : le
+conseil est enregistré dans le journal (ADR 0007, amendement du
+2026-11-10). Un événement sans conseil donne un message, jamais une page
+cassée. L'adresse n'a de sens que sur l'appareil qui a joué la partie : ce
+n'est pas un lien à partager (le lien de la position, lui, se partage).
+
+### 2026-11-10 — Adresses du bilan et de l'analyse d'une partie
+
+Ajoutées avec le bilan de fin de partie et l'écran d'analyse (étape 1e),
+dans le même schéma, sous l'adresse de la partie dans « Mes parties » :
+
+| Écran | Adresse |
+| --- | --- |
+| Bilan de fin de partie | `#/parties/<id>/bilan` |
+| Analyse d'une partie, placée sur un coup | `#/parties/<id>/analyse/<coup>` |
+| Analyse d'une partie, sur le coup à revoir | `#/parties/<id>/analyse` |
+
+`<id>` est l'identifiant de la partie enregistrée ; `<coup>` le numéro d'un
+tour de la partie (ce qu'un camp a fait quand il avait la main : doubler ou
+non, lancer, jouer), à partir de 1, sur sa ligne courante.
+
+- Le bilan remplace le panneau de fin de partie dès que l'analyse est
+  prête : l'application va à l'adresse du bilan, par-dessus celle de la
+  partie (`#/`). Il monte au-dessus de la partie, comme une
+  feuille ; le fermer (croix, retour du téléphone) laisse voir la partie
+  finie, sans le panneau. « Mes parties » donne le bilan de chaque partie
+  finie.
+- L'analyse est une page. Choisir un autre coup (courbe, flèches, liste)
+  remplace l'adresse : le retour du téléphone quitte l'écran au lieu de
+  repasser par chaque coup. « Rejouer d'ici » ramène à la partie (`#/`),
+  reprise juste avant la décision du coup.
+- Comme la feuille d'explication, ces adresses n'ont de sens que sur
+  l'appareil qui a joué la partie. Une partie absente donne un message,
+  jamais une page cassée.

docs/etape-1.md

@@ -20,8 +20,8 @@ Repris du cadrage (modules, écrans clés, IA générative en V1) et des ADR 001
 | 1a. Moteur pour l'analyse (fait) | Niveaux de jeu (plis et bruit de GNU Backgammon : débutant à expert), classement des coups d'un jet avec équités, analyse d'un coup joué et d'une décision de videau, chance d'un jet ; exposés par `engine.h`, `engine-cli` et le Worker, avec positions de référence comparées à gnubg de bureau | — |
 | 1b. Parties enregistrées (fait) | Stockage IndexedDB derrière l'interface de stockage existante : plusieurs parties, reprise automatique, branches (« Rejouer d'ici » crée une branche, l'originale reste intacte et rechargeable), export SGF avec variantes | — |
 | 1c. Match et réglages (fait) | Partie libre ou match en N points, règle Crawford, règle Jacoby, choix du niveau de l'ordinateur, conseil du maître activable ou non ; écran de nouvelle partie | 1a, 1b |
-| 1d. Conseil du maître | Après chaque coup du joueur, jamais avant (ADR 0011) : appréciation du moteur (bon coup, imprécision, erreur, grosse erreur) avec mot, icône et couleur, phrase du maître fondée sur les chiffres du moteur, coup recommandé montré sur demande ; aussi pour les décisions de videau ; calcul en arrière-plan sans retarder le jeu | 1a |
-| 1e. Fin de partie et analyse | Bilan (ADR 0011) : résultat, coups par appréciation, taux d'erreur comparé à la chance, « le coup à revoir » ; écran d'analyse : graphe d'équité (toucher un point ouvre la position), liste des erreurs filtrable, visualiseur pas à pas coup joué contre meilleur coup, « Rejouer d'ici » | 1a, 1b, 1d |
+| 1d. Conseil du maître (fait) | Après chaque coup du joueur, jamais avant (ADR 0011) : appréciation du moteur (bon coup, imprécision, erreur, grosse erreur) avec mot, icône et couleur, phrase du maître fondée sur les chiffres du moteur, coup recommandé montré sur demande ; aussi pour les décisions de videau ; calcul en arrière-plan sans retarder le jeu | 1a |
+| 1e. Fin de partie et analyse (fait) | Bilan (ADR 0011) : résultat, coups par appréciation, taux d'erreur comparé à la chance, « le coup à revoir » ; écran d'analyse : graphe d'équité (toucher un point ouvre la position), liste des erreurs filtrable, visualiseur pas à pas coup joué contre meilleur coup, « Rejouer d'ici » | 1a, 1b, 1d |
 | 1f. Prompts à copier | Gabarits versionnés et testés (`docs/prompts/` ou équivalent, source unique), bouton « Demander à une IA » sur le plateau, le conseil du maître, l'analyse et la fin de partie ; le moteur décide, l'IA explique | 1d, 1e |
 | 1g. Accueil, tutoriel et leçons | Accueil (reprendre, nouvelle partie, prochaine leçon, progression résumée), tutoriel des règles interactif et illustré (0e.5), cinq premières leçons numérotées (ADR 0011) avec positions et « à vous de jouer », progression locale ; contenus CC BY-SA 4.0 en brouillon, à relire par un joueur fort | 0e.5, 1a |
 | 1h. Progression | Historique des parties et courbe du taux d'erreur | 1b, 1e |

docs/glossaire/README.md

@@ -43,7 +43,9 @@ exportée. `make test` vérifie le lien dans les deux sens : chaque fiche avec
 | [Camp](camp.md) | Home board |
 | [Chance](chance.md) | Luck |
 | [Compte de points](compte-de-points.md) | Pip count |
+| [Conseil du maître](conseil-du-maitre.md) | Advice |
 | [Coup](coup.md) | Move |
+| [Courbe des chances de gagner](courbe-des-chances.md) | Win chance curve |
 | [Demi-coup](demi-coup.md) | Half-move |
 | [Course](course.md) | Race |
 | [Doubler](doubler.md) | Double |
@@ -69,4 +71,5 @@ exportée. `make test` vérifie le lien dans les deux sens : chaque fiche avec
 | [Règle de Jacoby](regle-de-jacoby.md) | Jacoby rule |
 | [SGF](sgf.md) | SGF |
 | [Sortie](sortie.md) | Bear-off |
+| [Taux d'erreur](taux-d-erreur.md) | Error rate |
 | [Videau](videau.md) | Cube |

docs/glossaire/conseil-du-maitre.md

@@ -0,0 +1,18 @@
+---
+term: Conseil du maître
+english: Advice
+code: Advice
+---
+# Conseil du maître
+
+**En bref** : après chacun de vos coups et chacune de vos décisions de videau, une ligne qui donne l'appréciation du moteur et ce que le maître aurait joué.
+
+Le maître ne parle jamais avant votre coup : il commente ce que vous venez de
+jouer, avec un mot (bon coup, imprécision, erreur, grosse erreur) choisi
+d'après l'[équité](equite.md) perdue par rapport au meilleur choix (voir
+[Appréciation](appreciation.md)). Toucher la ligne ouvre l'explication : votre
+coup et celui du maître, joués sur le plateau, et les chiffres du
+[moteur](moteur.md) si vous les demandez. Le conseil se coupe dans le menu ou
+sur l'écran « Nouvelle partie ».
+
+Voir aussi : [Appréciation](appreciation.md), [Coup](coup.md), [Videau](videau.md)

docs/glossaire/courbe-des-chances.md

@@ -0,0 +1,24 @@
+---
+term: Courbe des chances de gagner
+english: Win chance curve
+code: WinChanceCurve
+---
+# Courbe des chances de gagner
+
+**En bref** : vos chances de gagner la partie après chaque coup, selon le moteur, tracées coup après coup en pourcentage.
+
+Après chaque coup, des deux camps, le moteur évalue la position et donne
+vos chances de gagner la partie, sans tenir compte du videau. La courbe
+monte quand la partie tourne en votre faveur, descend sinon ; la ligne en
+pointillé marque 50 %. Le dernier point est le résultat : 100 % si vous avez
+gagné, 0 % sinon.
+
+Les points en couleur sont vos coups commentés par le maître, avec la
+couleur de leur [appréciation](appreciation.md) ; les petits points sont les
+coups de l'ordinateur. Une chute juste après l'un de vos coups montre ce
+qu'une erreur a coûté ; une chute après un jet montre la part des dés.
+
+C'est le « graphe d'équité » de GNU Backgammon, en pourcentage plutôt qu'en
+équité, plus parlant pour un débutant.
+
+Voir aussi : [Équité](equite.md), [Taux d'erreur](taux-d-erreur.md), [Chance](chance.md)

docs/glossaire/taux-d-erreur.md

@@ -0,0 +1,36 @@
+---
+term: Taux d'erreur
+english: Error rate
+code: ErrorRate
+---
+# Taux d'erreur
+
+**En bref** : l'équité que vous avez perdue en moyenne à chaque décision de la partie, d'après le moteur ; plus il est bas, mieux vous avez joué.
+
+Le moteur compare chacun de vos coups et chacune de vos décisions de videau
+au meilleur choix, et note l'équité perdue (0 pour le meilleur coup). Le
+taux d'erreur additionne ces pertes et les divise par le nombre de
+décisions qui comptent : les coups où vous aviez le choix (un coup forcé ne
+compte pas), vos doubles, vos prises et vos refus, et vos jets sans doubler
+quand doubler se discutait. C'est le calcul de GNU Backgammon (« Error rate
+per decision »).
+
+Le bilan traduit ce taux en niveau, avec les seuils de GNU Backgammon et
+les noms des niveaux de l'ordinateur, dans le même ordre :
+
+| Équité perdue par décision | Classement de GNU Backgammon | Niveau dans Ustagammon |
+| --- | --- | --- |
+| moins de 0,005 | Super Grandmaster | Champion |
+| 0,005 à 0,008 | Grandmaster | Expert |
+| 0,008 à 0,013 | Master | Avancé |
+| 0,013 à 0,020 | Advanced | Intermédiaire |
+| 0,020 à 0,032 | Intermediate | Amateur |
+| 0,032 et plus | Beginner | Débutant |
+
+Le bilan montre à côté la [chance](chance.md) de vos dés sur la partie : par
+tour, la chance de vos jets ; « un peu » pour vous ou contre vous au-delà de
+0,03 par tour, « nettement » au-delà de 0,06, comme GNU Backgammon. La
+phrase du bilan compare enfin le résultat à ce qu'il aurait été sans la
+chance des deux camps : si l'écart vient surtout des dés, elle le dit.
+
+Voir aussi : [Appréciation](appreciation.md), [Chance](chance.md), [Équité](equite.md), [Courbe des chances de gagner](courbe-des-chances.md)

docs/identite/charte/ecrans-etape-1.md

@@ -78,7 +78,11 @@ Maquette « Portrait révisé : conseil du maître après le coup ». Une ligne
   trop tard (le joueur a déjà relancé), la ligne n'apparaît pas, et le coup
   reste commenté dans le bilan ;
 - conseil désactivé : la ligne reste réservée et vide (la mise en page ne
-  bouge pas).
+  bouge pas) ;
+- tant qu'elle est affichée, elle prend la place de « L'ordinateur a joué… »
+  (les traces laiton et ↻ restent) ;
+- **en paysage** : une pastille (pictogramme et mot d'appréciation) en tête
+  de la bande centrale, à gauche de la consigne ; la toucher ouvre la feuille.
 
 ### Les mots
 
@@ -89,7 +93,7 @@ Maquette « Portrait révisé : conseil du maître après le coup ». Une ligne
 | 0,06 à 0,12 (bad) | Erreur | `verdict-bad` | croix |
 | plus de 0,12 (very bad) | Grosse erreur | `verdict-bad` | croix |
 
-Pour le videau : « Bon choix » et « Bonne décision » remplacent « Bon coup ».
+Pour le videau : « Bonne décision » remplace « Bon coup ».
 « Grosse erreur » est la recommandation de design ; `docs/etape-1.md` écrit
 « gaffe », et le choix final revient à Pierre (ton).
 
@@ -130,13 +134,17 @@ permet de le déterminer, sinon rien.
   de superlatif. Les bons coups ont plusieurs formules qui tournent
   (« C'est le coup du maître. », « Exactement ce que j'aurais joué. »,
   « Bien vu. »), pour ne pas lasser.
+- **Le rang de votre coup** n'est cité que pour un bon coup qui n'est pas le
+  meilleur et pour une imprécision, et seulement s'il vaut 2 ou 3. Jamais pour
+  une erreur ni une grosse erreur : le rang mesure mal la gravité (« 2e
+  choix » peut cacher un écart de 0,2). Le classement complet reste dans
+  « Voir les chiffres du moteur ».
 - **Exemples** (gabarits à remplir avec les données du moteur) :
   - Bon coup : « Bien vu. 8/5 6/5 fait votre point 5. »
   - Imprécision : « J'aurais joué {meilleur}. Votre coup était le
     {rang}e choix, tout près. »
-  - Erreur : « J'aurais joué {meilleur}. Votre {joué} était le {rang}e
-    choix. »
-  - Videau, prise juste : « Bonne décision : prendre était le bon choix. »
+  - Erreur : « J'aurais joué {meilleur}. Mon coup fait votre point 5. »
+  - Videau, prise juste : « Prendre était le bon choix. »
   - Videau, double manqué : « Ici, j'aurais doublé. »
 
 ## 1e. Bilan et analyse

docs/maitre/phrases.md

@@ -0,0 +1,283 @@
+# Les phrases du maître
+
+Les mots et les phrases du conseil du maître (étape 1d) et du bilan de fin
+de partie (étape 1e), en une seule source (ADR 0008) : `make site` copie ce
+dossier dans le site publié
+(`docs/maitre/`), l'application le lit à l'exécution
+(`app/src/domain/analysis/phrases.ts`), et `make test` rend chaque gabarit
+sur de vraies analyses du moteur (`app/tests/advice.test.ts`).
+
+Texte sous licence **CC BY-SA 4.0**. Version 1, rédigée par Claude Code
+d'après la charte (`docs/identite/charte/ecrans-etape-1.md`, « Les phrases du
+maître »), **à relire** par la session « identité » puis par Pierre.
+
+## Règles
+
+- Le maître parle à la première personne et vouvoie : « J'aurais joué… »,
+  jamais « Vous auriez dû… ».
+- Il ne cite que des faits donnés par le moteur : le coup recommandé, le rang
+  du coup joué, le nombre de coups possibles, les pions frappés et les points
+  faits (lus sur les plateaux décodés par le moteur), la décision de videau
+  qu'il préfère. Aucune explication stratégique.
+- La ligne (le mot et la phrase) fait moins de 140 caractères ; pas de point
+  d'exclamation, pas d'émoji, pas de superlatif.
+- Quand une section a plusieurs gabarits, ils tournent d'un coup à l'autre
+  (l'identifiant de l'événement choisit), pour ne pas lasser.
+
+## Format
+
+Une section `## clé` par emploi, suivie d'un gabarit par ligne (`- …`). Les
+mots entre accolades sont remplis avec les données du moteur :
+
+| Repère | Ce qu'il devient |
+| --- | --- |
+| `{best}` | le coup du maître, en notation de gnubg (« 8/5 6/5 ») |
+| `{played}` | votre coup, même notation |
+| `{move}` | le coup dont parle le fait (le vôtre ou celui du maître) |
+| `{rank}` | le rang de votre coup dans le classement du moteur (2 ou 3 seulement) |
+| `{points}` | « votre point 5 » ou « vos points 5 et 7 » |
+| `{roll}` | le jet, « 3-1 » |
+| `{hits}` | le nombre de pions frappés, en chiffres |
+| `{dice}` | la chance de vos dés sur la partie, en mots (bilan, étape 1e) |
+
+Un fait (sections `fait.…`) s'ajoute à la phrase seulement si la ligne reste
+sous 140 caractères.
+
+Tout ce qui précède la première section `## mot.…` n'est pas lu.
+
+## mot.coup.bon
+
+- Bon coup
+
+## mot.videau.bon
+
+- Bonne décision
+
+## mot.douteux
+
+- Imprécision
+
+## mot.mauvais
+
+- Erreur
+
+## mot.tres-mauvais
+
+- Grosse erreur
+
+## coup.meilleur
+
+- C'est le coup du maître.
+- Exactement ce que j'aurais joué.
+- Bien vu.
+- C'est aussi mon choix.
+
+## coup.seul
+
+- C'était le seul coup possible.
+
+## coup.proche
+
+« Bon coup » sans être le meilleur, votre coup étant le 2e ou le 3e choix du
+moteur. Le rang n'est cité qu'ici et dans coup.douteux : il mesure mal la
+gravité d'une erreur (un 2e choix peut être loin du premier), et le
+classement complet est dans « Voir les chiffres du moteur ».
+
+- Tout près : j'aurais joué {best}, votre coup était le {rank}e choix.
+
+## coup.douteux
+
+Imprécision, votre coup étant le 2e ou le 3e choix.
+
+- J'aurais joué {best}. Votre coup était le {rank}e choix, tout près.
+
+## coup.loin
+
+« Bon coup » non meilleur ou imprécision, votre coup étant au-delà du 3e
+choix : le rang n'est pas cité.
+
+- J'aurais joué {best}.
+
+## coup.mauvais
+
+Erreur : le rang n'est jamais cité.
+
+- J'aurais joué {best}.
+
+## coup.tres-mauvais
+
+Grosse erreur : le rang n'est jamais cité.
+
+- J'aurais joué {best}.
+
+## fait.frappe
+
+- {move} frappe un pion.
+
+## fait.frappe-plusieurs
+
+- {move} frappe {hits} pions.
+
+## fait.point
+
+- {move} fait {points}.
+
+## fait.frappe-et-point
+
+- {move} frappe un pion et fait {points}.
+
+## fait.maitre-frappe
+
+- Mon coup frappe un pion.
+
+## fait.maitre-point
+
+- Mon coup fait {points}.
+
+## fait.joueur-frappe
+
+- Votre coup frappe un pion, le mien non.
+
+## videau.bon.double
+
+- Doubler était le bon choix.
+
+## videau.bon.pas-de-double
+
+- Ne pas doubler était le bon choix.
+
+## videau.bon.prendre
+
+- Prendre était le bon choix.
+
+## videau.bon.passer
+
+- Passer était le bon choix.
+
+## videau.proche.double
+
+- Les deux choix étaient très proches. J'aurais doublé.
+
+## videau.proche.pas-de-double
+
+- Les deux choix étaient très proches. Je n'aurais pas doublé.
+
+## videau.proche.prendre
+
+- Les deux choix étaient très proches. J'aurais pris.
+
+## videau.proche.passer
+
+- Les deux choix étaient très proches. J'aurais passé.
+
+## videau.autre.double
+
+- Ici, j'aurais doublé.
+
+## videau.autre.pas-de-double
+
+- Ici, je n'aurais pas doublé.
+
+## videau.autre.prendre
+
+- Ici, j'aurais pris.
+
+## videau.autre.passer
+
+- Ici, j'aurais passé.
+
+## titre.coup.meme
+
+- C'est aussi le coup que j'aurais joué
+
+## titre.coup.autre
+
+- J'aurais joué {best}
+
+## titre.videau.meme
+
+- C'est aussi ce que j'aurais fait
+
+## titre.videau.double
+
+- J'aurais doublé
+
+## titre.videau.pas-de-double
+
+- Je n'aurais pas doublé
+
+## titre.videau.prendre
+
+- J'aurais pris
+
+## titre.videau.passer
+
+- J'aurais passé
+
+## contexte.coup
+
+- votre {roll}
+
+## contexte.coup.ouverture
+
+- votre {roll} d'ouverture
+
+## contexte.videau.double
+
+- votre double
+
+## contexte.videau.pas-de-double
+
+- avant votre jet
+
+## contexte.videau.reponse
+
+- le double de l'ordinateur
+
+## bilan.jeu.gagne
+
+Bilan de fin de partie (étape 1e), partie gagnée, quand le résultat corrigé
+de la chance (celui qu'on aurait eu sans les dés, à la manière de gnubg)
+reste en votre faveur. {dice} : la chance de vos dés sur la partie (sections
+bilan.des.…).
+
+- D'après mon analyse, votre jeu a fait la différence, avec des dés {dice}.
+
+## bilan.jeu.perdu
+
+Partie perdue, le résultat corrigé de la chance restant en faveur de
+l'ordinateur.
+
+- D'après mon analyse, le jeu de l'ordinateur a fait la différence, avec des dés {dice}.
+
+## bilan.des
+
+Partie gagnée ou perdue, le résultat corrigé de la chance allant dans
+l'autre sens que le résultat : les dés des deux camps ont pesé plus que les
+erreurs.
+
+- D'après mon analyse, les dés ont fait la différence, plus que le jeu.
+
+## bilan.des.tres-pour
+
+- nettement pour vous
+
+## bilan.des.pour
+
+- un peu pour vous
+
+## bilan.des.neutres
+
+- équilibrés
+
+## bilan.des.contre
+
+- un peu contre vous
+
+## bilan.des.tres-contre
+
+- nettement contre vous
+
+## bilan.aucun-coup
+
+- Aucun coup à revoir : vous avez joué comme je l'aurais fait.

docs/plans/2026-11-03-bilan-et-analyse.md

@@ -1,46 +0,0 @@
-# Fin de partie et analyse (1e)
-
-- **Date** : 2026-11-03
-- **Étape** : 1e (`docs/etape-1.md`)
-- **Statut** : prévu (après 1d)
-- **Exécutant** : sous-agent general-purpose, dans un worktree
-
-## Objectif
-
-Que le joueur comprenne sa partie : le bilan de fin de partie (ADR 0011), puis un écran d'analyse avec graphe d'équité, liste des erreurs, visualiseur et « Rejouer d'ici ».
-
-## Consignes
-
-Respecter les ADR 0007, 0008, 0011 et 0013. Chaque écran a son adresse : `#/parties/<id>/bilan` et `#/parties/<id>/analyse/<coup>`, à ajouter au tableau de l'ADR 0013 par un amendement. Pour la charte, suivre les maquettes « Fin de partie » du canevas. Aucune nouvelle dépendance : le graphe est dessiné en SVG à la main.
-
-1. **Analyse de la partie.** Elle réutilise les analyses rangées par 1d (coups et videau) et complète celles qui manquent en arrière-plan, de façon progressive et annulable. Elle donne :
-   - le taux d'erreur à la manière de gnubg ;
-   - la chance aux dés (`luck`) pour chaque camp ;
-   - le décompte des coups par appréciation.
-2. **Bilan**, dans le panneau de fin de partie existant :
-   - le résultat ;
-   - les coups par appréciation ;
-   - le taux d'erreur comparé à la chance, en phrases simples ;
-   - « le coup à revoir » : la plus grosse erreur, avec sa position, le coup joué et le meilleur coup ;
-   - un emplacement pour le bouton « Demander à une IA » (1f) ;
-   - « Voir l'analyse ».
-3. **Écran d'analyse** :
-   - un graphe d'équité où toucher un point ouvre la position ;
-   - la liste des erreurs, filtrable par appréciation ;
-   - un visualiseur pas à pas qui montre sur le plateau le coup joué contre le meilleur coup, avec des pions animés ;
-   - « Rejouer d'ici », qui crée une branche (domaine de 1b) sans toucher l'original.
-4. **Tests** :
-   - scénarios Gherkin : bilan, coup à revoir, rejouer d'ici, chacun avec des dés imposés ;
-   - fiches du glossaire : taux d'erreur, graphe d'équité si absentes ;
-   - `make lint`, `make test`, `make test-browser`, avec des captures pour la recette design.
-
-## Critères de réussite
-
-- Après une partie, le bilan nomme le coup à revoir, conforme à l'analyse du moteur.
-- L'analyse s'ouvre par son adresse.
-- « Rejouer d'ici » crée une branche.
-- Les trois commandes passent.
-
-## Résultat
-
-À remplir à la clôture.

docs/plans/2026-11-03-conseil-du-maitre.md

@@ -1,64 +0,0 @@
-# Conseil du maître (1d)
-
-- **Date** : 2026-11-03
-- **Étape** : 1d (`docs/etape-1.md`)
-- **Statut** : prévu (après 1c)
-- **Exécutant** : sous-agent general-purpose, dans un worktree
-
-## Objectif
-
-Le coach bienveillant, « mis en avant mais discret » (Pierre, 2026-11-03) :
-après chaque coup et chaque décision de videau du joueur, jamais avant
-(ADR 0011), une appréciation et une phrase du maître fondées sur les chiffres
-du moteur.
-
-## Références
-
-- ADR 0011 ; maquette « conseil du maître après le coup » du canevas
-  https://claude.ai/artifact/CQw6vbDpi6XQqVWQa4sANe ; règles de la charte
-  (`docs/identite/charte/`, dont interaction.md) ; la ligne réservée de 44 px
-  de la révision UX.
-- Moteur : `analyseMove`, `analyseCube`, `luck`, seuils `SKILL_THRESHOLDS`
-  (gnubg : 0,03 / 0,06 / 0,12).
-
-## Consignes
-
-1. **Analyse en arrière-plan** : après la validation d'un coup (ou une
-   décision de videau), l'analyse à 2 plis part dans le Worker sans retarder le
-   tour de l'ordinateur ; son résultat est rattaché au coup dans le journal
-   (événement d'analyse rétrocompatible, ou cache séparé justifié) pour servir
-   au bilan (1e) sans recalcul.
-2. **Ligne du maître** : icône d'appréciation, mot en couleur (« Bon coup. »,
-   « Imprécision. », « Erreur. », « Grosse erreur. » (choix de Pierre du 2026-11-09, plutôt que « gaffe ») : correspondance avec les seuils
-   de gnubg documentée), phrase courte en italique, chevron. Toucher ouvre la
-   feuille d'explication : coup joué et meilleur coup montrés sur le plateau
-   (pions animés, ADR 0011 « comparaison visuelle »), écart d'équité seulement
-   sur demande, lien vers la fiche du glossaire du concept en jeu si le moteur
-   permet de le déterminer, sinon rien.
-3. **Phrases du maître** : gabarits versionnés en français dans une source
-   unique sous `docs/` (CC BY-SA 4.0). Référence de ton, approuvée par Pierre
-   le 2026-11-09 : la section « Les phrases du maître » de
-   `docs/identite/charte/ecrans-etape-1.md` (1re personne et vouvoiement,
-   faits du moteur uniquement, moins de 140 caractères, ton sobre sans
-   exclamation, formules qui tournent pour les bons coups, exemples). Un test
-   vérifie la longueur et l'absence de « ! » sur chaque gabarit rendu. Les
-   phrases livrées passent par la session « identité » puis par Pierre pour
-   la relecture finale.
-4. **Discret** : rien n'apparaît pendant que le joueur réfléchit ; la ligne
-   s'efface à l'action suivante ; désactivable (réglage de 1c et menu).
-5. **Videau** : même traitement pour doubler, ne pas doubler, prendre, passer.
-6. Scénarios Gherkin (bon coup, erreur avec meilleur coup montré, conseil
-   désactivé, décision de videau commentée) avec positions et dés imposés ;
-   tests unitaires des gabarits (chaque gabarit rendu sur des analyses réelles
-   du moteur). `make lint`, `make test`, `make test-browser`, captures pour la
-   recette design.
-
-## Critères de réussite
-
-Après une erreur volontaire dans une position connue, la ligne du maître dit
-« Erreur. », nomme le coup recommandé par le moteur et le montre sur demande ;
-le tour de l'ordinateur n'est pas retardé ; les trois commandes passent.
-
-## Résultat
-
-À remplir à la clôture.

docs/scenarios/README.md

@@ -57,6 +57,8 @@ Règles d'écriture :
 | --- | --- | --- |
 | [jouer-une-partie.feature](jouer-une-partie.feature) | Jouer une partie contre l'ordinateur | Étape 0d |
 | [jouer-un-match.feature](jouer-un-match.feature) | Choisir sa partie (libre ou match, niveau) et jouer un match | Étape 1c |
+| [comprendre-mes-coups.feature](comprendre-mes-coups.feature) | Comprendre ses coups avec le conseil du maître | Étape 1d |
+| [revoir-ma-partie.feature](revoir-ma-partie.feature) | Revoir sa partie : bilan, coup à revoir, analyse, rejouer d'ici | Étape 1e |
 | [mes-parties.feature](mes-parties.feature) | Retrouver mes parties, leurs branches, les exporter en SGF | Étape 1b |
 | [partager-une-position.feature](partager-une-position.feature) | Ouvrir et partager le lien d'une position | Étape 0e.4 |
 | [regler-l-application.feature](regler-l-application.feature) | Régler l'application (menu), la mettre à jour | Étape 0e |

docs/scenarios/comprendre-mes-coups.feature

@@ -0,0 +1,52 @@
+# language: fr
+Fonctionnalité: Comprendre mes coups avec le conseil du maître
+
+  Après chacun de vos coups, et après chacune de vos décisions de videau,
+  le maître dit en une ligne ce qu'il en pense : « Bon coup. »,
+  « Imprécision. », « Erreur. » ou « Grosse erreur. », puis une phrase,
+  par exemple le coup qu'il aurait joué. Il ne parle jamais avant que vous
+  ayez joué, et la ligne s'efface dès que vous lancez les dés ou touchez un
+  pion. Touchez-la pour ouvrir l'explication. Le maître, c'est GNU
+  Backgammon : il ne dit que ce que le programme a calculé.
+
+  Scénario: Que dit le maître après un bon coup ?
+    « Bon coup. », avec une phrase qui change d'une fois à l'autre et, s'il
+    y en a, ce que votre coup fait sur le plateau : un pion frappé, un point
+    fait. Avec 3-1 à l'ouverture, 8/5 6/5 est le meilleur coup.
+
+    Étant donné que vous avez 3-1 à jouer à la position de départ
+    Quand vous validez le coup 8/5 6/5
+    Alors le maître dit « Bon coup. »
+    Et sa phrase dit que 8/5 6/5 fait votre point 5
+
+  Scénario: Comment voir le coup que le maître aurait joué ?
+    Après une imprécision ou une erreur, la ligne nomme le coup du maître.
+    Touchez-la : l'explication montre, sur le plateau, votre coup et le coup
+    du maître joués pion par pion depuis la même position. Les chiffres,
+    repliés en bas, donnent l'écart entre les coups si vous les voulez.
+
+    Étant donné que vous avez 3-1 à jouer à la position de départ
+    Quand vous validez le coup 24/23 13/10
+    Alors le maître dit « Grosse erreur. »
+    Et sa phrase commence par « J'aurais joué 8/5 6/5. »
+    Et l'explication peut montrer votre coup et le coup du maître sur le plateau
+
+  Scénario: Comment faire taire le maître ?
+    Coupez « Conseil du maître » dans le menu, ou sur l'écran « Nouvelle
+    partie ». La ligne reste alors vide, et rien d'autre ne bouge. Vos coups
+    restent analysés pour le bilan de fin de partie.
+
+    Étant donné que vous avez coupé le conseil du maître
+    Et que vous avez 3-1 à jouer à la position de départ
+    Quand vous validez le coup 24/23 13/10
+    Alors le maître ne dit rien
+
+  Scénario: Le maître commente-t-il le videau ?
+    Oui : après votre double, votre réponse à un double de l'ordinateur, ou
+    quand vous avez lancé les dés alors qu'il aurait doublé, le maître dit
+    si vous avez bien fait.
+
+    Étant donné que l'ordinateur vous propose de doubler dans une position où il faut prendre
+    Quand vous passez son double
+    Alors le maître dit « Erreur. »
+    Et sa phrase dit « Ici, j'aurais pris. »

docs/scenarios/revoir-ma-partie.feature

@@ -0,0 +1,62 @@
+# language: fr
+Fonctionnalité: Revoir ma partie avec le bilan et l'analyse
+
+  À la fin de chaque partie, le maître fait le bilan : le résultat, vos
+  décisions par appréciation (bons coups, imprécisions, erreurs), votre jeu
+  traduit en niveau, la chance de vos dés, et le coup à revoir, celui qui
+  vous a coûté le plus. « Voir l'analyse » montre la courbe de vos chances de
+  gagner, coup après coup : parcourez-la du doigt pour revoir chaque coup sur
+  le plateau, le vôtre et celui du maître. Tout vient de GNU Backgammon,
+  comme le conseil du maître ; ce qui manque est calculé en arrière-plan,
+  même pour une partie jouée avant que le conseil existe.
+
+  Scénario: Que dit le bilan d'une partie ?
+    Le bilan compte vos décisions par appréciation, traduit votre jeu en
+    niveau, et dit en une phrase ce qui a fait la différence : votre jeu,
+    celui de l'ordinateur, ou les dés. Ici, après 6/5 5/off, l'ordinateur
+    est sûr de sortir ses deux derniers pions : il double, et vous passez.
+
+    Étant donné qu'il vous reste deux pions, sur vos points 6 et 1, et à l'ordinateur deux pions sur ses points 1 et 2
+    Et que vous avez 6-1 à jouer
+    Quand vous choisissez le coup 6/5 5/off
+    Et que l'ordinateur, sûr de gagner, double et que vous passez
+    Alors la partie est finie, gagnée par l'ordinateur
+    Et le bilan compte une grosse erreur
+    Et sa phrase dit ce qui a fait la différence, et comment étaient vos dés
+
+  Scénario: Quel est le coup à revoir ?
+    C'est votre décision qui a perdu le plus d'équité, d'après le maître. Le
+    bilan la montre sur le plateau, avec le coup que le maître aurait joué ;
+    « Revoir ce coup » ouvre l'analyse sur ce coup.
+
+    Étant donné qu'il vous reste deux pions, sur vos points 6 et 1, et à l'ordinateur deux pions sur ses points 1 et 2
+    Et que vous avez 6-1 à jouer
+    Quand vous choisissez le coup 6/5 5/off
+    Et que l'ordinateur, sûr de gagner, double et que vous passez
+    Alors le coup à revoir est votre coup 6/off, le premier de la partie
+    Et le maître y aurait joué 6/off 1/off
+    Et la courbe de vos chances de gagner finit à 0 %
+
+  Scénario: Comment rejouer un coup autrement ?
+    Dans l'analyse, « Rejouer d'ici » vous remet juste avant le coup, avec le
+    même jet. Jouez autre chose : une nouvelle branche commence là, et la
+    partie d'origine reste intacte dans « Mes parties ».
+
+    Étant donné qu'il vous reste deux pions, sur vos points 6 et 1, et à l'ordinateur deux pions sur ses points 1 et 2
+    Et que vous avez 6-1 à jouer
+    Quand vous choisissez le coup 6/5 5/off
+    Et que l'ordinateur, sûr de gagner, double et que vous passez
+    Et que vous rejouez d'ici le coup à revoir
+    Alors vous avez de nouveau 6-1 à jouer
+    Quand vous choisissez cette fois le coup 1/off 6/off
+    Alors la partie est finie, gagnée par vous
+    Et la partie a deux branches, dont la partie d'origine, intacte
+
+  Scénario: Puis-je voir le bilan d'une partie plus ancienne ?
+    Oui : une partie enregistrée sans analyse, par exemple jouée avant le
+    conseil du maître, est analysée quand vous ouvrez son bilan.
+
+    Étant donné une partie finie enregistrée sans aucune analyse
+    Quand vous ouvrez son bilan
+    Alors le maître l'analyse d'abord en arrière-plan
+    Et le bilan nomme ensuite le coup à revoir

scripts/deploy.sh

@@ -11,6 +11,7 @@ set -euo pipefail
 
 CAPROVER_MACHINE="${CAPROVER_MACHINE:-sans-pub}"
 CAPROVER_APP="${CAPROVER_APP:-ustagammon}"
+SITE_URL="${SITE_URL:-https://ustagammon.sans.pub}"
 
 die() {
 	echo "Erreur : $1" >&2
@@ -33,9 +34,14 @@ git fetch -q origin main
 [ "$(git rev-parse main)" = "$(git rev-parse origin/main)" ] \
 	|| die "main diffère d'origin/main : git pull (ou fusionner la MR) d'abord"
 
-# Le jeton CapRover expire ; caprover ls ne le vérifie pas.
-caprover api -n "$CAPROVER_MACHINE" -t /user/system/info -m GET -d '{}' -o false >/dev/null 2>&1 \
-	|| die "session CapRover expirée : lancer caprover login dans un terminal"
+# Le jeton CapRover expire ; caprover ls ne le vérifie pas. Sans terminal
+# (stdin fermé), la CLI ne peut pas demander le mot de passe : elle doit
+# échouer, et sa sortie ne doit pas contenir de demande de mot de passe (le
+# 2026-11-09, elle a demandé le mot de passe puis rendu 0 sans rien publier).
+if ! session=$(caprover api -n "$CAPROVER_MACHINE" -t /user/system/info -m GET -d '{}' -o false </dev/null 2>&1) \
+	|| grep -qi "password\|not valid anymore" <<<"$session"; then
+	die "session CapRover expirée : lancer caprover login dans un terminal"
+fi
 
 echo "Vérification avant publication : make lint et make test"
 make lint
@@ -43,4 +49,17 @@ make test
 
 make package
 echo "Publication de main ($(git rev-parse --short main)) sur l'app $CAPROVER_APP"
-caprover deploy -n "$CAPROVER_MACHINE" -a "$CAPROVER_APP" -t build/ustagammon.tar
+caprover deploy -n "$CAPROVER_MACHINE" -a "$CAPROVER_APP" -t build/ustagammon.tar </dev/null
+
+# La CLI peut rendre 0 sans avoir publié : on vérifie le résultat réel, le
+# commit servi par le site (version.json), pendant deux minutes au plus.
+commit=$(git rev-parse main)
+for _ in $(seq 24); do
+	served=$(curl -fsS "$SITE_URL/version.json?verif=$RANDOM" 2>/dev/null || true)
+	if grep -q "\"$commit\"" <<<"$served"; then
+		echo "Publié : $SITE_URL sert $(git rev-parse --short main)."
+		exit 0
+	fi
+	sleep 5
+done
+die "le site ne sert pas le commit $(git rev-parse --short main) après 2 minutes : la publication a échoué (version servie : ${served:-aucune})"

tests/browser.sh

@@ -8,8 +8,13 @@
 # partie » et un match en 3 points joué jusqu'au bout (tests/browser/match.mjs),
 # captures dans build/browser-shots/match/.
 #
-# BROWSERS=chromium et SCRIPTS=accueil (ou play, ou match) restreignent le
-# test.
+# Le conseil du maître (tests/browser/maitre.mjs), captures dans
+# build/browser-shots/maitre/. Le bilan de fin de partie et l'écran
+# d'analyse (tests/browser/bilan.mjs), captures dans
+# build/browser-shots/bilan/.
+#
+# BROWSERS=chromium et SCRIPTS=accueil (ou play, match, maitre, bilan)
+# restreignent le test.
 #
 # Outils : l'image de Playwright (navigateurs) et le paquet playwright,
 # installé une fois par npm dans build/browser-tools/ (réseau nécessaire la
@@ -22,7 +27,7 @@ cd "$(dirname "$0")/.."
 image="${PLAYWRIGHT_IMAGE:?lancer via make test-browser}"
 browsers="${BROWSERS:-chromium firefox}"
 # Les scripts à lancer (tests/browser/<nom>.mjs), tous par défaut.
-scripts="${SCRIPTS:-play accueil match}"
+scripts="${SCRIPTS:-play accueil match maitre bilan}"
 
 unset MAKEFLAGS MFLAGS MAKELEVEL
 make -s package >/dev/null
@@ -59,7 +64,8 @@ update_port="$(docker port "$update_container" 80/tcp | head -n1 | sed 's/.*://'
 
 rm -rf build/browser-shots
 mkdir -p build/browser-shots
-cp tests/browser/play.mjs tests/browser/accueil.mjs tests/browser/match.mjs tests/browser/recette.mjs "$tools/"
+cp tests/browser/play.mjs tests/browser/accueil.mjs tests/browser/match.mjs tests/browser/recette.mjs \
+	tests/browser/maitre.mjs tests/browser/bilan.mjs "$tools/"
 status=0
 for browser in $browsers; do
 	# Réseau de l'hôte : le site est sur 127.0.0.1. Le service worker
@@ -85,5 +91,19 @@ for browser in $browsers; do
 			-v "$PWD/$tools:/tools" -v "$PWD/build/browser-shots:/shots" -w /tools "$image" \
 			node match.mjs "http://localhost:$port/" "$browser" /shots || status=1
 	fi
+	if [[ " $scripts " == *" maitre "* ]]; then
+		# Conseil du maître : ligne, feuille d'explication, videau, réglage ;
+		# captures de la recette dans build/browser-shots/maitre/.
+		docker run --rm --init --ipc=host --network host --user "$(id -u):$(id -g)" -e HOME=/tmp \
+			-v "$PWD/$tools:/tools" -v "$PWD/build/browser-shots:/shots" -w /tools "$image" \
+			node maitre.mjs "http://localhost:$port/" "$browser" /shots || status=1
+	fi
+	if [[ " $scripts " == *" bilan "* ]]; then
+		# Bilan de fin de partie et écran d'analyse ; captures de la recette
+		# dans build/browser-shots/bilan/.
+		docker run --rm --init --ipc=host --network host --user "$(id -u):$(id -g)" -e HOME=/tmp \
+			-v "$PWD/$tools:/tools" -v "$PWD/build/browser-shots:/shots" -w /tools "$image" \
+			node bilan.mjs "http://localhost:$port/" "$browser" /shots || status=1
+	fi
 done
 exit "$status"

tests/browser/bilan.mjs

@@ -0,0 +1,482 @@
+// bilan.mjs -- le bilan de fin de partie et l'écran d'analyse (étape 1e)
+// joués par l'interface, dans un vrai navigateur sans écran (Playwright),
+// sur le site servi par l'image de production (charte,
+// ecrans-etape-1.md, « 1e. Bilan et analyse »).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Usage : node bilan.mjs <adresse du site> <chromium|firefox> <dossier des captures>
+// Lancé par tests/browser.sh. Une fin de course courte, partie depuis un
+// lien de position avec des dés imposés : le joueur a 6-1 et deux pions,
+// sur 6 et 1 ; 6/off 1/off gagne, 6/5/off perd (l'ordinateur sortira ses
+// deux derniers pions au coup suivant : il double, et le joueur passe). Le
+// joueur joue 6/5/off. Vérifie que le
+// bilan remplace le panneau de fin de partie et nomme ce coup comme le coup
+// à revoir, que l'analyse s'ouvre par son adresse (courbe, point touché,
+// liste filtrée, visualiseur), que « Rejouer d'ici » crée une branche, la
+// règle de la recette (rien d'interactif sous une barre d'action), et
+// l'absence d'erreur et de violation de la politique de sécurité. Captures
+// (Chromium) dans <dossier des captures>/bilan/, en 412×915, 915×412 et
+// 844×320.
+
+import { mkdirSync } from "node:fs";
+import { chromium, firefox } from "playwright";
+import { hiddenUnderActionBar, tallButtons } from "./recette.mjs";
+
+const [base, browserName, shots] = process.argv.slice(2);
+const browserType = { chromium, firefox }[browserName];
+if (!base || !browserType || !shots) {
+    console.error("usage : node bilan.mjs <adresse> <chromium|firefox> <dossier des captures>");
+    process.exit(2);
+}
+const full = browserName === "chromium";
+const dir = `${shots}/bilan`;
+mkdirSync(dir, { recursive: true });
+const PORTRAIT = { width: 412, height: 915 };
+const LANDSCAPE = { width: 915, height: 412 };
+const SMALL_LANDSCAPE = { width: 844, height: 320 };
+const SIZES = [PORTRAIT, LANDSCAPE, SMALL_LANDSCAPE];
+// Le joueur au trait : un pion sur 6, un sur 1 ; l'ordinateur : un sur 1,
+// un sur 2 (positions de gnubg, chacun vu de lui-même).
+const BEAROFF = "BQAACAIAAAAAAA";
+
+const problems = [];
+const log = (text) => console.log(`[${browserName}] ${text}`);
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+let captures = 0;
+
+function check(condition, message) {
+    if (!condition) {
+        throw new Error(message);
+    }
+}
+
+const browser = await browserType.launch();
+const context = await browser.newContext({
+    viewport: PORTRAIT,
+    deviceScaleFactor: 1,
+    locale: "fr-FR",
+    // Sans animation : les captures montrent les coups posés, avec leurs
+    // traces.
+    reducedMotion: "reduce",
+});
+await context.addInitScript(() => {
+    // Les dés imposés d'abord (un dé par valeur), puis une graine fixe.
+    window.__dice = [];
+    let state = 5;
+    Math.random = () => {
+        const die = window.__dice.shift();
+        if (die !== undefined) {
+            return (die - 0.5) / 6;
+        }
+        state = (state * 1103515245 + 12345) % 2147483648;
+        return state / 2147483648;
+    };
+    window.__csp = [];
+    document.addEventListener("securitypolicyviolation", (e) =>
+        window.__csp.push(`${e.effectiveDirective} ${e.blockedURI}`),
+    );
+});
+const page = await context.newPage();
+page.on("pageerror", (error) => problems.push(`erreur de la page : ${error.message}`));
+page.on("console", (message) => {
+    if (message.type() === "error") {
+        problems.push(`console : ${message.text()}`);
+    }
+});
+
+/** Attend une condition dans la page (sans page.waitForFunction, qui passe
+ * par eval, interdit par la politique de sécurité du site). */
+async function until(what, fn, arg, ms = 120_000) {
+    for (let waited = 0; waited < ms; waited += 100) {
+        if (await page.evaluate(fn, arg)) {
+            return;
+        }
+        await sleep(100);
+    }
+    await page.screenshot({ path: `${dir}/${browserName}-bloque.png` }).catch(() => {});
+    throw new Error(`attente trop longue : ${what}`);
+}
+
+const idle = () => until("écran libre", () => !document.body.classList.contains("busy"));
+
+/** Une capture de la recette dans les trois tailles (Chromium seulement),
+ * après la règle commune : rien d'interactif sous une barre d'action. */
+async function capture(name) {
+    if (!full) {
+        return;
+    }
+    await until("bandeau parti", () => document.getElementById("banner").hidden, null, 15_000);
+    for (const size of SIZES) {
+        await page.setViewportSize(size);
+        await sleep(300);
+        const hidden = await hiddenUnderActionBar(page);
+        check(
+            hidden.length === 0,
+            `${name} ${size.width}x${size.height} : caché sous la barre d'action : ${hidden.join(", ")}`,
+        );
+        const tall = await tallButtons(page);
+        check(tall.length === 0, `${name} ${size.width}x${size.height} : boutons étirés : ${tall.join(", ")}`);
+        await page.screenshot({ path: `${dir}/${name}-${size.width}x${size.height}.png` });
+        captures++;
+    }
+    await page.setViewportSize(PORTRAIT);
+    await sleep(300);
+}
+
+/** Une nouvelle partie à partir d'une position, joueur au trait. */
+async function startFrom(position) {
+    await page.goto(`${base}#/position/${encodeURIComponent(position)}`);
+    await until("position lue", () => {
+        const play = document.getElementById("position-play");
+        return !play.hidden && !play.disabled;
+    });
+    await page.click("#position-play");
+    await until(
+        "partie commencée",
+        () =>
+            location.hash === "#/" &&
+            !document.body.classList.contains("busy") &&
+            !document.getElementById("roll").hidden,
+    );
+}
+
+/** Une case du plateau de jeu : « off » pour la sortie du joueur. */
+const place = (point) => (point === 0 ? "off-player" : `p${point}`);
+
+/** Joue un coup déjà lancé, demi-coup par demi-coup, puis le valide. */
+async function playMove(halfMoves) {
+    for (const [from, to] of halfMoves) {
+        await page.click(`#board .hit[data-place="${place(from)}"]`);
+        await idle();
+        const land = page.locator(`#board .hit.can-land[data-place="${place(to)}"]`);
+        if ((await land.count()) > 0) {
+            await land.click();
+            await idle();
+        }
+    }
+    check(!(await page.locator("#confirm").isHidden()), `coup incomplet : ${JSON.stringify(halfMoves)}`);
+    await page.click("#confirm");
+}
+
+/** Lance les dés imposés et joue un coup. */
+async function play(dice, halfMoves) {
+    await page.evaluate((d) => {
+        window.__dice.push(...d);
+    }, dice);
+    await page.click("#roll");
+    await idle();
+    await playMove(halfMoves);
+}
+
+// --------------------------------------------- Une partie, puis son bilan
+
+await startFrom(BEAROFF);
+await play([6, 1], [[6, 5], [5, 0]]);
+// L'ordinateur, sûr de gagner, double. La ligne du maître commente le
+// coup : sa feuille d'explication écrit le coup joué dans la notation du
+// moteur, comme le bilan et l'analyse plus bas.
+await until("double de l'ordinateur", () => !document.getElementById("drop").hidden);
+await until("ligne du maître", () => !document.getElementById("advice-line").hidden);
+await page.click("#advice-line");
+await until("feuille du maître", () => document.getElementById("explain-mine") !== null);
+await page.click("#explain-mine");
+const sheetLegend = await page.textContent("#explain-legend");
+check(sheetLegend.includes(" 6/off,"), `feuille du maître : ${sheetLegend}`);
+await page.click("#explain-done");
+await until("feuille fermée", () => document.getElementById("explain-veil").hidden);
+// Le joueur passe.
+await page.click("#drop");
+// Le panneau de fin de partie, puis le bilan à sa place, à son adresse.
+await until(
+    "bilan prêt",
+    () =>
+        /^#\/parties\/[a-z0-9-]+\/bilan$/.test(location.hash) &&
+        document.getElementById("summary")?.dataset.ready === "true",
+);
+await until("mini-plateau du coup à revoir", () =>
+    document.querySelector("#summary-board .board-frame") !== null,
+);
+const summary = await page.evaluate(() => ({
+    hash: location.hash,
+    panelHidden: document.getElementById("panel-veil").hidden,
+    title: document.getElementById("summary-title").textContent,
+    reading: document.getElementById("summary-reading").textContent,
+    counts: [...document.querySelectorAll(".summary-count .summary-number")].map(
+        (n) => n.textContent,
+    ),
+    verdict: document.querySelector(".summary-verdict")?.textContent ?? "",
+    played: document.querySelector(".summary-played")?.textContent ?? "",
+    master: document.querySelector(".summary-master")?.textContent ?? "",
+    board: document.querySelector("#summary-board .board-frame") !== null,
+    play: document.querySelector("#gauge-play .gauge-value")?.textContent ?? "",
+    dice: document.querySelector("#gauge-dice .gauge-value")?.textContent ?? "",
+    slot: document.querySelector("#summary-review .ask-ai-slot") !== null,
+}));
+const id = summary.hash.split("/")[2];
+check(summary.panelHidden, "le panneau de fin de partie reste sous le bilan");
+check(summary.title === "L'ordinateur gagne la partie simple", `titre : ${summary.title}`);
+check(
+    summary.reading.startsWith("Vous avez passé son double : 1 point pour lui. "),
+    `lecture : ${summary.reading}`,
+);
+check(summary.reading.includes("D'après mon analyse"), `lecture : ${summary.reading}`);
+check(!summary.reading.includes("!"), `lecture : ${summary.reading}`);
+// Le refus du double, juste ; le coup 6/5/off, grosse erreur ; le jet
+// sans doubler, compté seulement s'il était une faute.
+check(
+    summary.counts[0] === "1" && summary.counts[2] !== "0",
+    `décisions : ${summary.counts.join()}`,
+);
+check(summary.verdict.startsWith("Grosse erreur"), `coup à revoir : ${summary.verdict}`);
+check(summary.played === "Votre coup : 6/off", `coup joué : ${summary.played}`);
+check(summary.master === "J'aurais joué 6/off 1/off", `coup du maître : ${summary.master}`);
+check(summary.board, "pas de mini-plateau dans le coup à revoir");
+check(summary.play !== "" && summary.dice !== "", "jauges vides");
+check(summary.slot, "pas d'emplacement pour « Demander à une IA »");
+await capture("1-bilan");
+log(`bilan : « ${summary.reading} » ; coup à revoir « ${summary.played} » contre « ${summary.master} »`);
+
+// Le bilan se recharge par son adresse.
+await page.reload();
+await until(
+    "bilan rouvert",
+    () => document.getElementById("summary")?.dataset.ready === "true",
+);
+
+// ------------------------------------------------------- Écran d'analyse
+
+await page.click("#summary-revisit");
+await until(
+    "analyse ouverte sur le coup à revoir",
+    (game) =>
+        location.hash === `#/parties/${game}/analyse/1` &&
+        !document.getElementById("analysis").hidden &&
+        document.querySelector("#analysis-board .board-frame") !== null &&
+        document.querySelectorAll("#analysis-curve .curve-band").length === 2 &&
+        document.querySelector("#analysis-curve .curve-line") !== null,
+    id,
+);
+const viewer = await page.evaluate(() => ({
+    turn: document.getElementById("analysis-turn").textContent,
+    phrase: document.getElementById("analysis-phrase").textContent,
+    mine: document.getElementById("analysis-mine").getAttribute("aria-checked"),
+    choice: !document.getElementById("analysis-choice").hidden,
+    replay: !document.getElementById("analysis-replay").hidden,
+    slot: document.querySelector("#analysis-viewer .ask-ai-slot") !== null,
+}));
+check(viewer.turn === "Coup 1 sur 2 · 6-1", `visualiseur : ${viewer.turn}`);
+check(viewer.phrase.startsWith("Grosse erreur."), `phrase : ${viewer.phrase}`);
+check(viewer.choice && viewer.mine === "true", "votre coup n'est pas montré d'abord");
+check(viewer.replay && viewer.slot, "« Rejouer d'ici » ou l'emplacement de l'IA manquent");
+await capture("2-analyse-courbe");
+
+// Toucher un point de la courbe : la bande du coup 2 (le double de
+// l'ordinateur, que le joueur a passé).
+const band = await page.locator('#analysis-curve .curve-band[data-turn="2"]').boundingBox();
+await page.mouse.click(band.x + band.width / 2, band.y + band.height / 3);
+await until(
+    "coup 2 choisi",
+    (game) =>
+        location.hash === `#/parties/${game}/analyse/2` &&
+        document.getElementById("analysis-turn").textContent.startsWith("Coup 2 sur 2"),
+    id,
+);
+const touched = await page.evaluate(() => ({
+    phrase: document.getElementById("analysis-phrase").textContent,
+    ring: document.querySelector("#analysis-curve .curve-ring") !== null,
+    replay: document.getElementById("analysis-replay").hidden,
+}));
+check(touched.phrase.startsWith("Bonne décision."), `coup 2 : ${touched.phrase}`);
+check(touched.ring, "le point choisi n'est pas cerclé");
+check(!touched.replay, "pas de « Rejouer d'ici » sur une décision du joueur");
+await capture("3-point-touche");
+// Au clavier, ← revient au coup 1.
+await page.focus("#analysis-curve");
+await page.keyboard.press("ArrowLeft");
+await until("coup 1 au clavier", (game) => location.hash === `#/parties/${game}/analyse/1`, id);
+
+// La liste, filtrée : une erreur, aucune imprécision.
+await page.click('#analysis-filters .filter[data-filter="errors"]');
+const errors = await page.evaluate(() => ({
+    rows: [...document.querySelectorAll("#analysis-list .analysis-row")].map((r) =>
+        r.getAttribute("aria-label"),
+    ),
+    filters: [...document.querySelectorAll("#analysis-filters .filter")].map((f) => f.textContent),
+}));
+check(errors.rows.length === 1 && errors.rows[0].includes("Grosse erreur"), `liste : ${errors.rows}`);
+check(errors.filters.join() === "Tout · 2,Erreurs · 1,Imprécisions · 0", `filtres : ${errors.filters}`);
+await page.locator("#analysis-list").scrollIntoViewIfNeeded();
+await capture("4-liste-filtree");
+await page.click('#analysis-filters .filter[data-filter="doubtful"]');
+check(
+    (await page.locator("#analysis-list .analysis-row").count()) === 0,
+    "une imprécision dans la liste",
+);
+await page.click('#analysis-filters .filter[data-filter="errors"]');
+await page.click("#analysis-list .analysis-row");
+
+// Le visualiseur : le coup du maître sur la position d'avant le coup.
+await page.locator("#analysis-viewer").scrollIntoViewIfNeeded();
+await page.click("#analysis-best");
+const best = await page.evaluate(() => ({
+    legend: document.getElementById("analysis-legend").textContent,
+    move: document.getElementById("analysis-board").dataset.move,
+}));
+check(best.move === "best" && best.legend.includes("6/off 1/off"), `maître : ${best.legend}`);
+// Une seule notation, celle du moteur : le même coup s'écrit pareil dans
+// la feuille du maître, le bilan, la liste et le visualiseur.
+await page.click("#analysis-mine");
+const notations = await page.evaluate(() => ({
+    legend: document.getElementById("analysis-legend").textContent,
+    row: document.querySelector('#analysis-list .analysis-row[data-turn="1"] .row-move')
+        ?.textContent,
+}));
+check(
+    notations.legend.includes(" 6/off,") && notations.row === "6/off",
+    `notation : visualiseur « ${notations.legend} », liste « ${notations.row} »`,
+);
+await page.click("#analysis-best");
+await capture("5-visualiseur");
+log("analyse : courbe, point touché, clavier, liste filtrée, visualiseur");
+
+// L'analyse s'ouvre aussi par son adresse, dans un nouvel onglet.
+const other = await context.newPage();
+await other.goto(`${base}#/parties/${id}/analyse/2`);
+for (let waited = 0; ; waited += 100) {
+    const ready = await other.evaluate(
+        () =>
+            !document.getElementById("analysis").hidden &&
+            document.getElementById("analysis-turn")?.textContent.startsWith("Coup 2 sur 2"),
+    );
+    if (ready) {
+        break;
+    }
+    check(waited < 60_000, "l'analyse ne s'ouvre pas par son adresse");
+    await sleep(100);
+}
+await other.close();
+
+// ------------------------------------------------------- Rejouer d'ici
+
+await page.click("#analysis-replay");
+await until(
+    "partie reprise avant le coup",
+    () =>
+        location.hash === "#/" &&
+        !document.body.classList.contains("busy") &&
+        document.querySelector("#board .hit.can-move") !== null,
+);
+await capture("6-rejouer-d-ici");
+// Le pion du point 1 d'abord : chacun n'a alors qu'une arrivée, la sortie.
+await playMove([
+    [1, 0],
+    [6, 0],
+]);
+await until(
+    "partie gagnée, son bilan",
+    () =>
+        /\/bilan$/.test(location.hash) &&
+        document.getElementById("summary")?.dataset.ready === "true",
+);
+const won = await page.evaluate(() => ({
+    title: document.getElementById("summary-title").textContent,
+    none: document.querySelector(".summary-none")?.textContent ?? "",
+}));
+check(won.title === "Vous gagnez la partie simple", `branche : ${won.title}`);
+check(won.none.startsWith("Aucun coup à revoir"), `branche : ${won.none}`);
+// Deux branches dans « Mes parties », l'originale intacte.
+await page.goto(`${base}#/parties/${id}`);
+await until(
+    "branches dépliées",
+    () => document.querySelectorAll(".games-branch").length > 0,
+);
+const branches = await page.evaluate(() =>
+    [...document.querySelectorAll(".games-branch span")].map((s) => s.textContent),
+);
+check(branches.length === 2, `branches : ${branches.join(" | ")}`);
+check(branches[0].startsWith("Partie d'origine : 1 coup, finie"), `origine : ${branches[0]}`);
+log(`rejouer d'ici : ${branches.join(" | ")}`);
+
+// ------------------------------------------- Une partie plus longue
+
+// Pour juger la courbe en usage réel (Chromium seulement) : une longue
+// course (tests/reference/positions.json, race-2) jouée jusqu'au bout,
+// le joueur prenant à chaque fois le premier pion jouable et sa première
+// arrivée, puis son analyse complète.
+if (full) {
+    await startFrom("cLezAQBwN2cGAA");
+    for (let actions = 0; ; actions++) {
+        check(actions < 2000, "la longue partie ne finit pas");
+        const what = await page.evaluate(() => {
+            if (document.body.classList.contains("busy")) {
+                return null;
+            }
+            if (!document.getElementById("summary-veil").hidden) {
+                return "over";
+            }
+            if (!document.getElementById("panel-veil").hidden) {
+                return "panel";
+            }
+            const usable = (id) => {
+                const b = document.getElementById(id);
+                return !b.hidden && !b.disabled;
+            };
+            for (const id of ["take", "skip", "confirm", "roll"]) {
+                if (usable(id)) {
+                    return id;
+                }
+            }
+            if (document.querySelector("#board .hit.can-land")) {
+                return "land";
+            }
+            return document.querySelector("#board .hit.can-move") ? "move" : null;
+        });
+        if (what === "over") {
+            break;
+        }
+        if (what === null || what === "panel") {
+            await sleep(100);
+            continue;
+        }
+        const target = {
+            take: "#take",
+            skip: "#skip",
+            confirm: "#confirm",
+            roll: "#roll",
+            land: "#board .hit.can-land",
+            move: "#board .hit.can-move",
+        }[what];
+        await page.locator(target).first().click();
+        await idle();
+    }
+    await until("bilan de la longue partie", () =>
+        document.getElementById("summary")?.dataset.ready === "true");
+    await page.click("#summary-analysis");
+    await until("analyse complète de la longue partie", () => {
+        const bands = document.querySelectorAll("#analysis-curve .curve-band").length;
+        return (
+            !document.getElementById("analysis").hidden &&
+            bands >= 20 &&
+            document.querySelectorAll("#analysis-curve .curve-dot").length === bands
+        );
+    }, null, 600_000);
+    const turns = await page.locator("#analysis-curve .curve-band").count();
+    await page.evaluate(() => window.scrollTo(0, 0));
+    await capture("7-analyse-partie-longue");
+    log(`longue partie : ${turns} coups, courbe complète`);
+}
+
+const csp = await page.evaluate(() => window.__csp);
+for (const violation of csp) {
+    problems.push(`politique de sécurité : ${violation}`);
+}
+await browser.close();
+if (problems.length > 0) {
+    for (const problem of problems) {
+        console.error(`[${browserName}] ${problem}`);
+    }
+    process.exit(1);
+}
+log(`bilan et analyse : tout est conforme (${captures} captures)`);

tests/browser/maitre.mjs

@@ -0,0 +1,297 @@
+// maitre.mjs -- le conseil du maître (étape 1d) joué par l'interface, dans
+// un vrai navigateur sans écran (Playwright), sur le site servi par l'image
+// de production (étape 1d, docs/etape-1.md ; charte, ecrans-etape-1.md).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Usage : node maitre.mjs <adresse du site> <chromium|firefox> <dossier des captures>
+// Lancé par tests/browser.sh. Chaque cas part d'une position connue
+// (#/position/..., « Jouer à partir d'ici ») avec des dés imposés : les dés
+// de l'application viennent de Math.random, remplacé ici par une file de
+// valeurs choisies (window.__dice), puis par un générateur à graine.
+// Vérifie la ligne du maître (bon coup, imprécision, erreur, grosse
+// erreur), la feuille d'explication et son adresse, une décision de videau
+// commentée, le conseil coupé dans le menu, l'absence d'erreur et de
+// violation de la politique de sécurité. Captures de la recette design
+// (Chromium) dans <dossier des captures>/maitre/, en 412×915 et 915×412.
+
+import { mkdirSync } from "node:fs";
+import { chromium, firefox } from "playwright";
+
+const [base, browserName, shots] = process.argv.slice(2);
+const browserType = { chromium, firefox }[browserName];
+if (!base || !browserType || !shots) {
+    console.error("usage : node maitre.mjs <adresse> <chromium|firefox> <dossier des captures>");
+    process.exit(2);
+}
+const full = browserName === "chromium";
+const dir = `${shots}/maitre`;
+mkdirSync(dir, { recursive: true });
+const PORTRAIT = { width: 412, height: 915 };
+const LANDSCAPE = { width: 915, height: 412 };
+const START = "4HPwATDgc/ABMA";
+// Une position de double et prise (videau au centre) : doubler y est juste.
+const DOUBLE_TAKE = "6O5uAAC4uzsAAA";
+
+const problems = [];
+const log = (text) => console.log(`[${browserName}] ${text}`);
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+let captures = 0;
+
+function check(condition, message) {
+    if (!condition) {
+        throw new Error(message);
+    }
+}
+
+const browser = await browserType.launch();
+const context = await browser.newContext({
+    viewport: PORTRAIT,
+    deviceScaleFactor: 1,
+    locale: "fr-FR",
+    // Sans animation : les captures montrent les coups posés, avec leurs
+    // traces.
+    reducedMotion: "reduce",
+});
+await context.addInitScript(() => {
+    // Les dés imposés d'abord (un dé par valeur), puis une graine fixe.
+    window.__dice = [];
+    let state = 11;
+    Math.random = () => {
+        const die = window.__dice.shift();
+        if (die !== undefined) {
+            return (die - 0.5) / 6;
+        }
+        state = (state * 1103515245 + 12345) % 2147483648;
+        return state / 2147483648;
+    };
+    window.__csp = [];
+    document.addEventListener("securitypolicyviolation", (e) =>
+        window.__csp.push(`${e.effectiveDirective} ${e.blockedURI}`),
+    );
+});
+const page = await context.newPage();
+page.on("pageerror", (error) => problems.push(`erreur de la page : ${error.message}`));
+page.on("console", (message) => {
+    if (message.type() === "error") {
+        problems.push(`console : ${message.text()}`);
+    }
+});
+
+/** Attend une condition dans la page (sans page.waitForFunction, qui passe
+ * par eval, interdit par la politique de sécurité du site). */
+async function until(what, fn, arg, ms = 90_000) {
+    for (let waited = 0; waited < ms; waited += 100) {
+        if (await page.evaluate(fn, arg)) {
+            return;
+        }
+        await sleep(100);
+    }
+    await page.screenshot({ path: `${dir}/${browserName}-bloque.png` }).catch(() => {});
+    throw new Error(`attente trop longue : ${what}`);
+}
+
+const idle = () => until("écran libre", () => !document.body.classList.contains("busy"));
+
+/** Une capture de la recette, dans les deux tailles (Chromium seulement). */
+async function capture(name) {
+    if (!full) {
+        return;
+    }
+    // Le bandeau « Reprendre l'ancienne » (10 s) ne gêne pas la lecture.
+    await until("bandeau parti", () => document.getElementById("banner").hidden, null, 15_000);
+    for (const size of [PORTRAIT, LANDSCAPE]) {
+        await page.setViewportSize(size);
+        await sleep(300);
+        await page.screenshot({ path: `${dir}/${name}-${size.width}x${size.height}.png` });
+        captures++;
+    }
+    await page.setViewportSize(PORTRAIT);
+    await sleep(300);
+}
+
+/** Une nouvelle partie à partir d'une position, joueur au trait. */
+async function startFrom(position) {
+    await page.goto(`${base}#/position/${encodeURIComponent(position)}`);
+    await until("position lue", () => {
+        const play = document.getElementById("position-play");
+        return !play.hidden && !play.disabled;
+    });
+    await page.click("#position-play");
+    await until("partie commencée", () =>
+        location.hash === "#/" && !document.body.classList.contains("busy") &&
+        !document.getElementById("roll").hidden);
+}
+
+/** Lance les dés imposés et joue un coup, demi-coup par demi-coup : le pion
+ * de départ, puis sa case d'arrivée si le pion ne s'y est pas déjà posé. */
+async function play(dice, halfMoves) {
+    await page.evaluate((d) => {
+        window.__dice.push(...d);
+    }, dice);
+    await page.click("#roll");
+    await idle();
+    for (const [from, to] of halfMoves) {
+        await page.click(`#board .hit[data-place="p${from}"]`);
+        await idle();
+        const land = page.locator(`#board .hit.can-land[data-place="p${to}"]`);
+        if ((await land.count()) > 0) {
+            await land.click();
+            await idle();
+        }
+    }
+    check(!(await page.locator("#confirm").isHidden()), `coup incomplet : ${JSON.stringify(halfMoves)}`);
+    await page.click("#confirm");
+}
+
+/** La ligne du maître telle qu'elle s'affiche. */
+async function adviceLine() {
+    return page.evaluate(() => {
+        const line = document.getElementById("advice-line");
+        return {
+            shown: !line.hidden,
+            word: line.querySelector(".advice-word")?.textContent ?? "",
+            phrase: line.querySelector(".advice-phrase")?.textContent ?? "",
+            href: line.getAttribute("href"),
+            infoShown: !document.getElementById("info").hidden,
+            height: line.getBoundingClientRect().height,
+            chip: document.getElementById("advice-chip") !== null,
+        };
+    });
+}
+
+async function waitAdvice() {
+    await until("ligne du maître", () =>
+        !document.getElementById("advice-line").hidden &&
+        !document.body.classList.contains("busy"));
+    return adviceLine();
+}
+
+// ------------------------------------------------- Bon coup, et ses voisins
+
+const cases = [
+    { name: "1-bon-coup", dice: [3, 1], moves: [[8, 5], [6, 5]], word: "Bon coup." },
+    { name: "2-imprecision", dice: [2, 1], moves: [[13, 11], [11, 10]], word: "Imprécision." },
+    { name: "3-erreur", dice: [2, 1], moves: [[24, 22], [6, 5]], word: "Erreur." },
+    { name: "4-grosse-erreur", dice: [3, 1], moves: [[24, 23], [13, 10]], word: "Grosse erreur." },
+];
+for (const c of cases) {
+    await startFrom(START);
+    // Rien pendant que le joueur réfléchit.
+    check(!(await adviceLine()).shown, `${c.name} : ligne avant le coup`);
+    await play(c.dice, c.moves);
+    const line = await waitAdvice();
+    check(line.word === c.word, `${c.name} : mot « ${line.word} », attendu « ${c.word} »`);
+    check(line.phrase.length > 0 && !line.phrase.includes("!"), `${c.name} : phrase « ${line.phrase} »`);
+    check(!line.infoShown, `${c.name} : la ligne du dernier coup reste visible`);
+    check(line.height <= 44, `${c.name} : ligne de ${line.height} px`);
+    check(/^#\/explication\/\d+$/.test(line.href), `${c.name} : lien ${line.href}`);
+    if (c.word !== "Bon coup.") {
+        check(line.phrase.startsWith("J'aurais joué") || line.phrase.startsWith("Tout près"),
+            `${c.name} : le coup du maître n'est pas nommé : « ${line.phrase} »`);
+    }
+    await capture(c.name);
+    if (full) {
+        // En paysage, la pastille du mot mène à la même feuille.
+        await page.setViewportSize(LANDSCAPE);
+        await sleep(200);
+        check((await adviceLine()).chip, `${c.name} : pas de pastille en paysage`);
+        await page.setViewportSize(PORTRAIT);
+        await sleep(200);
+    }
+    log(`${c.name} : « ${line.word} ${line.phrase} »`);
+}
+
+// La ligne s'efface à l'action suivante du joueur.
+await page.click("#roll");
+await idle();
+check(!(await adviceLine()).shown, "la ligne reste après le lancer suivant");
+
+// ------------------------------------------------- Feuille d'explication
+
+await startFrom(START);
+await play([3, 1], [[24, 23], [13, 10]]);
+await waitAdvice();
+await page.click("#advice-line");
+await until("feuille ouverte", () =>
+    /^#\/explication\/\d+$/.test(location.hash) &&
+    !document.getElementById("explain-veil").hidden &&
+    document.getElementById("explain-board") !== null &&
+    document.querySelector("#explain-board .board-frame") !== null);
+const sheet = await page.evaluate(() => ({
+    verdict: document.getElementById("explain-verdict").textContent,
+    title: document.getElementById("explain-title").textContent,
+    mine: document.getElementById("explain-mine")?.getAttribute("aria-checked"),
+    best: document.getElementById("explain-best")?.getAttribute("aria-checked"),
+    numbersOpen: document.getElementById("explain-numbers").open,
+}));
+check(sheet.verdict === "Grosse erreur · votre 3-1 d'ouverture", `feuille : ${JSON.stringify(sheet)}`);
+check(sheet.title === "J'aurais joué 8/5 6/5", `titre : ${sheet.title}`);
+check(sheet.best === "true" && sheet.mine === "false", "le coup du maître n'est pas montré d'abord");
+check(!sheet.numbersOpen, "les chiffres du moteur ne sont pas repliés");
+await capture("5-feuille-explication");
+await page.click("#explain-mine");
+await sleep(300);
+await page.click("#explain-numbers summary");
+const rows = await page.evaluate(() => document.querySelector(".explain-table .strong")?.textContent);
+check(rows !== undefined, "votre coup n'est pas en gras dans les chiffres");
+await capture("5b-feuille-votre-coup-chiffres");
+// L'adresse se recharge : la feuille revient, le conseil vient du journal.
+await page.reload();
+await until("feuille rouverte après rechargement", () =>
+    !document.getElementById("explain-veil").hidden &&
+    document.getElementById("explain-title")?.textContent === "J'aurais joué 8/5 6/5");
+await page.click("#explain-done");
+await until("feuille fermée", () =>
+    location.hash === "#/" && document.getElementById("explain-veil").hidden);
+log("feuille d'explication : mot, coup du maître, votre coup, chiffres repliés, adresse rechargée");
+
+// ------------------------------------------------- Décision de videau
+
+await startFrom(DOUBLE_TAKE);
+check(!(await page.locator("#double").isHidden()), "doubler n'est pas proposé");
+await page.click("#double");
+await page.click("#double-confirm");
+const cube = await waitAdvice();
+check(cube.word === "Bonne décision." && cube.phrase === "Doubler était le bon choix.",
+    `videau : « ${cube.word} ${cube.phrase} »`);
+await capture("6-decision-de-videau");
+log(`décision de videau : « ${cube.word} ${cube.phrase} »`);
+
+// ------------------------------------------------- Conseil coupé
+
+await page.click("#menu-button");
+await page.waitForSelector("#menu", { state: "visible" });
+check((await page.getAttribute("#menu-advice", "aria-checked")) === "true", "conseil coupé par défaut");
+await page.click("#menu-advice");
+check((await page.getAttribute("#menu-advice", "aria-checked")) === "false", "interrupteur sans effet");
+await page.click("#menu-close");
+await startFrom(START);
+await play([3, 1], [[24, 23], [13, 10]]);
+await idle();
+// Laisse le temps à l'analyse : la ligne ne doit pas venir.
+await sleep(3000);
+const off = await adviceLine();
+check(!off.shown && off.infoShown, `conseil coupé : ${JSON.stringify(off)}`);
+await capture("7-conseil-desactive");
+// On le rallume : le conseil déjà prêt réapparaît.
+await page.click("#menu-button");
+await page.waitForSelector("#menu", { state: "visible" });
+await page.click("#menu-advice");
+await page.click("#menu-close");
+check((await waitAdvice()).word === "Grosse erreur.", "conseil rallumé : la ligne ne revient pas");
+log("conseil coupé dans le menu : la ligne reste vide ; rallumé, elle revient");
+
+const csp = await page.evaluate(() => window.__csp);
+for (const violation of csp) {
+    problems.push(`politique de sécurité : ${violation}`);
+}
+await browser.close();
+if (problems.length > 0) {
+    for (const problem of problems) {
+        console.error(`[${browserName}] ${problem}`);
+    }
+    process.exit(1);
+}
+log(`conseil du maître : tout est conforme (${captures} captures)`);

tests/browser/match.mjs

@@ -117,6 +117,10 @@ async function todo() {
             if (!panel.hidden) {
                 return panel.dataset.kind;
             }
+            // Le bilan remplace le panneau de fin de partie (étape 1e).
+            if (!document.getElementById("summary-veil").hidden) {
+                return "over";
+            }
             const usable = (id) => {
                 const b = document.getElementById(id);
                 return !b.hidden && !b.disabled;
@@ -282,12 +286,17 @@ for (;;) {
         check(now.cube === 0 && !now.double, `partie Crawford : videau visible ${JSON.stringify(now)}`);
     }
     if (what === "over") {
-        const title = await page.textContent("#panel-text");
-        const detail = await page.textContent("#panel-detail");
-        const primary = await page.textContent("#panel-primary");
+        // Le bilan, une fois l'analyse prête, à la place du panneau.
+        await until("bilan prêt", () =>
+            !document.getElementById("summary-veil").hidden &&
+            document.getElementById("summary")?.dataset.ready === "true", null, 120_000);
+        const title = await page.textContent("#summary-title");
+        const reading = await page.textContent("#summary-reading");
+        const detail = reading.split(" D'après mon analyse")[0];
+        const primary = await page.textContent("#summary-primary");
         log(`partie ${games}${crawford ? " (Crawford)" : ""} : ${title} ; ${detail}`);
         const settingsLink = await page.evaluate(() => {
-            const a = document.getElementById("panel-settings");
+            const a = document.getElementById("summary-settings");
             return a.hidden ? null : { text: a.textContent, href: a.getAttribute("href") };
         });
         check(settingsLink?.text === "Changer les réglages" && settingsLink.href === "#/nouvelle-partie",
@@ -309,10 +318,15 @@ for (;;) {
             // Après le match, « Changer les réglages » mène à l'écran des
             // choix ; le fermer ramène au résultat, où « Rejouer » relance
             // tout de suite un match de même longueur.
-            await page.click("#panel-settings");
+            await page.click("#summary-settings");
             await until("écran « Nouvelle partie » après le match", () =>
                 location.hash === "#/nouvelle-partie" && document.getElementById("panel-veil").hidden);
             await page.click("#new-game-close");
+            // Retour au bilan ; le fermer laisse le résultat sur le plateau.
+            await until("retour au bilan du match", () =>
+                /\/bilan$/.test(location.hash) &&
+                document.getElementById("summary")?.dataset.ready === "true");
+            await page.click("#summary-close");
             await until("retour au résultat du match", () => location.hash === "#/" &&
                 !document.getElementById("again").hidden);
             check((await page.textContent("#again")) === "Rejouer",
@@ -334,7 +348,7 @@ for (;;) {
         }
         check(primary === "Partie suivante" && /Match en 3 points : vous \d+, l'ordinateur \d+/.test(detail),
             `fin de partie dans un match : ${primary} ; ${detail}`);
-        await page.click("#panel-primary");
+        await page.click("#summary-primary");
         games++;
         await until("partie suivante", () => !document.body.classList.contains("busy"));
         const next = await shownMatch();

tests/browser/play.mjs

@@ -184,13 +184,21 @@ async function savedGameCount() {
     );
 }
 
+/** Les événements d'un journal et son événement courant : la partie,
+ * sans les analyses du moteur qui s'y rangent en arrière-plan (conseils,
+ * analyse de partie, étapes 1d et 1e). */
+function played(journal) {
+    return journal === null ? null : { events: journal.events, head: journal.head };
+}
+
 /** Le journal enregistré, une fois les enregistrements en cours terminés
- * (l'application enregistre sans attendre) : deux lectures identiques. */
+ * (l'application enregistre sans attendre) : deux lectures identiques de
+ * la partie. */
 async function savedJournal() {
-    let last = await readJournal();
+    let last = played(await readJournal());
     for (let i = 0; i < 50; i++) {
         await new Promise((resolve) => setTimeout(resolve, 100));
-        const next = await readJournal();
+        const next = played(await readJournal());
         if (JSON.stringify(next) === JSON.stringify(last)) {
             return next;
         }
@@ -222,6 +230,10 @@ async function waitForPlayer() {
             if (!panel.hidden) {
                 return panel.dataset.kind;
             }
+            // Le bilan remplace le panneau de fin de partie (étape 1e).
+            if (!document.getElementById("summary-veil").hidden) {
+                return "over";
+            }
             const usable = (id) => {
                 const b = document.getElementById(id);
                 return !b.hidden && !b.disabled;
@@ -1523,13 +1535,25 @@ for (let actions = 0; ; actions++) {
 
 // --------------------------------------------------------- Fin de partie
 
+// Le panneau de fin de partie, puis le bilan à sa place une fois
+// l'analyse prête (étape 1e, testé en détail par bilan.mjs).
+await page.waitForSelector('#summary[data-ready="true"]', { timeout: 120_000 });
+// Le bilan posé : son mini-plateau dessiné (ou « Aucun coup à revoir »).
+await page.waitForSelector("#summary-board .board-frame, #summary .summary-none", { state: "attached" });
 const journal = await savedJournal();
-const result = `${await page.textContent("#panel-text")}, ${await page.textContent("#panel-detail")}`;
-check((await page.textContent("#panel-overline")) === "Fin de partie" &&
-    /^(Vous gagnez|L'ordinateur gagne|Vous passez|L'ordinateur passe)/.test(
-        await page.textContent("#panel-text")) &&
-    /^\d+ points? pour (vous|lui)(, videau à \d+)?\.$/.test(await page.textContent("#panel-detail")),
-    `panneau de fin de partie : ${result}`);
+/** Le titre du bilan et la phrase du résultat. */
+async function summaryResult() {
+    const title = await page.textContent("#summary-title");
+    const reading = await page.textContent("#summary-reading");
+    const detail = /^(Vous avez passé son double : |L'ordinateur a passé votre double : )?\d+ points? pour (vous|lui)(, videau à \d+)?\./.exec(reading)?.[0] ?? reading;
+    return `${title}, ${detail}`;
+}
+const result = await summaryResult();
+check((await page.textContent("#summary .overline")) === "Fin de partie" &&
+    /^(Vous gagnez|L'ordinateur gagne)/.test(await page.textContent("#summary-title")) &&
+    /^(Vous avez passé son double : |L'ordinateur a passé votre double : )?\d+ points? pour (vous|lui)(, videau à \d+)?\. /.test(
+        await page.textContent("#summary-reading")),
+    `bilan de fin de partie : ${result}`);
 check((await page.textContent("#prompt")) === "", "fin de partie : la consigne répète le panneau");
 log(
     `partie finie : ${result} (${countMoves(journal, "player")} coups du joueur, ` +
@@ -1538,11 +1562,11 @@ log(
 const won = journal.events.at(-1).winner === "player";
 check((await vibrations()).at(-1) === (won ? "30,50,30,50,60" : "60"),
     `fin de partie : vibration ${(await vibrations()).at(-1)}`);
-check((await page.textContent("#panel-secondary")) === "Revoir la partie" &&
-    (await page.textContent("#panel-primary")) === "Rejouer" &&
-    (await page.textContent("#panel-settings")) === "Changer les réglages" &&
-    (await page.getAttribute("#panel-settings", "href")) === "#/nouvelle-partie",
-    "fin de partie : panneau sans « Revoir la partie », « Rejouer » et « Changer les réglages »");
+check((await page.textContent("#summary-analysis")) === "Voir l'analyse" &&
+    (await page.textContent("#summary-primary")) === "Rejouer" &&
+    (await page.textContent("#summary-settings")) === "Changer les réglages" &&
+    (await page.getAttribute("#summary-settings", "href")) === "#/nouvelle-partie",
+    "fin de partie : bilan sans « Voir l'analyse », « Rejouer » et « Changer les réglages »");
 await review("6-fin-de-partie");
 await page.setViewportSize({ width: 844, height: 320 });
 await sleep(150);
@@ -1573,12 +1597,13 @@ log(skips > 0 ? `aucun coup possible ${skips} fois (${skipsByDice} en touchant l
 log(`vibrations demandées : ${(await vibrations()).length}`);
 await shot("4-fin-de-partie");
 
-// « Revoir la partie » ferme le panneau ; « Rejouer » reste dans la barre
-// d'actions.
-await page.click("#panel-secondary");
+// Fermer le bilan laisse voir la partie finie, sans panneau ; « Rejouer »
+// reste dans la barre d'actions.
+await page.click("#summary-close");
+await page.waitForSelector("#summary-veil", { state: "hidden" });
 check(!(await page.isVisible("#panel")) && (await page.textContent("#again")) === "Rejouer" &&
     (await page.isVisible("#again")),
-    "« Revoir la partie » : panneau toujours là, ou pas de « Rejouer »");
+    "bilan fermé : panneau toujours là, ou pas de « Rejouer »");
 
 step("mes parties");
 // Mes parties (IndexedDB), depuis le menu : une deuxième partie commencée,
@@ -1628,14 +1653,16 @@ step("mes parties");
         }));
         throw new Error(`reprise bloquée : ${JSON.stringify(state)}`);
     });
-    await page.waitForSelector("#panel");
+    // La partie finie reprise : son bilan, déjà analysé, à la place du
+    // panneau.
+    await page.waitForSelector('#summary[data-ready="true"]', { timeout: 60_000 });
     const resumed = await savedJournal();
     check(JSON.stringify(resumed) === JSON.stringify(finished), "la première partie n'a pas été reprise");
-    const shown = `${await page.textContent("#panel-text")}, ${await page.textContent("#panel-detail")}`;
+    const shown = await summaryResult();
     check(shown === result, `écran différent après la reprise : ${shown}`);
     check((await page.evaluate(() => performance.getEntriesByType("navigation").length)) === loads,
         "la page a été rechargée");
-    await page.click("#panel-secondary");
+    await page.click("#summary-close");
     log(
         `mes parties : ${listed} parties listées (${branchCount} branche(s) pour la première), ` +
             `SGF exporté (${sgf.length} octets), première partie reprise sans rechargement`,

tests/browser/recette.mjs

@@ -5,6 +5,32 @@
 // Copyright (C) 2026 les auteurs d'Ustagammon.
 // Licence : GPLv3 ou ultérieure (voir LICENSE).
 
+/**
+ * Les boutons visibles (et les liens qui en ont l'allure) plus hauts que
+ * 56 px : un bouton fait 48 px, il ne s'étire pas. Renvoie la liste des
+ * boutons trop hauts, décrits (vide si tout va bien).
+ */
+export async function tallButtons(target) {
+    return target.evaluate(() => {
+        const found = [];
+        for (const el of document.querySelectorAll("button, a.button")) {
+            if (el.closest("[hidden]")) {
+                continue;
+            }
+            const style = getComputedStyle(el);
+            const r = el.getBoundingClientRect();
+            if (style.display === "none" || style.visibility === "hidden" || r.width === 0) {
+                continue;
+            }
+            if (r.height > 56) {
+                const name = el.id ? `#${el.id}` : `« ${el.textContent.trim().slice(0, 30)} »`;
+                found.push(`${name} (${Math.round(r.height)} px)`);
+            }
+        }
+        return found;
+    });
+}
+
 /**
  * Les éléments interactifs visibles cachés, même en partie, sous une barre
  * d'action collée en bas de l'écran (position: sticky, ancrée par bottom) :

web/app.css

@@ -2671,3 +2671,738 @@ html.landscape .position-view.with-board .position-actions {
 html.landscape .position-view.with-board .position-actions > * {
   padding-inline: 16px;
 }
+
+/* ------------------------------------------- Conseil du maître (1d) */
+
+/* La ligne du maître : à la place du dernier coup, dans la ligne réservée
+ * de 44 px (elle ne pousse rien). Pictogramme et mot en couleur
+ * d'appréciation, phrase en italique tronquée, chevron. */
+.advice-line {
+  display: flex;
+  flex: 1;
+  gap: var(--space-2);
+  align-items: center;
+  min-width: 0;
+  height: 44px;
+  font-size: 15px;
+  line-height: 20px;
+  color: var(--text);
+  text-decoration: none;
+  border-radius: 12px;
+  -webkit-tap-highlight-color: transparent;
+}
+
+.advice-line.appear {
+  animation: fade-in var(--duration-fast) var(--easing-standard);
+}
+
+.advice-line .icon {
+  width: 20px;
+  height: 20px;
+}
+
+.advice-line .icon-chevron {
+  width: 16px;
+  height: 16px;
+  color: var(--muted);
+}
+
+.advice-text {
+  flex: 1;
+  min-width: 0;
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+
+.advice-word {
+  font-weight: 700;
+}
+
+[data-verdict="good"] .icon:not(.icon-chevron),
+[data-verdict="good"] .advice-word { color: var(--verdict-good); }
+[data-verdict="doubtful"] .icon:not(.icon-chevron),
+[data-verdict="doubtful"] .advice-word { color: var(--verdict-doubtful); }
+[data-verdict="bad"] .icon:not(.icon-chevron),
+[data-verdict="bad"] .advice-word,
+[data-verdict="veryBad"] .icon:not(.icon-chevron),
+[data-verdict="veryBad"] .advice-word { color: var(--verdict-bad); }
+
+/* Paysage : la pastille du mot, au début de la bande centrale. */
+.advice-chip-pill {
+  fill: var(--surface);
+  stroke: currentColor;
+  stroke-width: 2;
+}
+
+.advice-chip-icon {
+  fill: none;
+  stroke: currentColor;
+  stroke-width: 2px;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+  vector-effect: non-scaling-stroke;
+}
+
+.advice-chip-text {
+  fill: currentColor;
+  font-weight: 700;
+}
+
+.advice-chip.verdict-good { color: var(--verdict-good); }
+.advice-chip.verdict-doubtful { color: var(--verdict-doubtful); }
+.advice-chip.verdict-bad,
+.advice-chip.verdict-veryBad { color: var(--verdict-bad); }
+
+/* La feuille d'explication : elle monte du bas, au-dessus du plateau
+ * voilé. */
+.explain-sheet {
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-3);
+}
+
+.explain-verdict {
+  display: inline-flex;
+  gap: 6px;
+  align-items: center;
+  margin: 0;
+  font-size: 15px;
+  line-height: 20px;
+  font-weight: 700;
+}
+
+.explain-verdict .icon {
+  width: 18px;
+  height: 18px;
+}
+
+.explain-verdict[data-verdict="good"] { color: var(--verdict-good); }
+.explain-verdict[data-verdict="doubtful"] { color: var(--verdict-doubtful); }
+.explain-verdict[data-verdict="bad"],
+.explain-verdict[data-verdict="veryBad"] { color: var(--verdict-bad); }
+
+.explain-title {
+  margin: 0;
+  font-size: 24px;
+  line-height: 30px;
+}
+
+.explain-phrase {
+  margin: 0;
+  font-style: italic;
+}
+
+.explain-body {
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-2);
+}
+
+.explain-body .segment {
+  min-height: 44px;
+  font-size: 15px;
+}
+
+/* Le coup montré : le vôtre en couleur du texte, celui du maître en
+ * couleur du bon coup (charte 1d). */
+.explain-board[data-move="mine"] { --last-move: var(--text); }
+.explain-board[data-move="best"] { --last-move: var(--verdict-good); }
+
+.explain-legend {
+  margin: 0;
+  font-size: 13px;
+  line-height: 18px;
+  color: var(--muted);
+}
+
+.explain-numbers {
+  border-top: 1px solid var(--border);
+}
+
+.explain-numbers summary {
+  display: flex;
+  align-items: center;
+  min-height: 44px;
+  font-size: 15px;
+  font-weight: 500;
+  cursor: pointer;
+}
+
+.explain-table {
+  display: grid;
+  grid-template-columns: auto 1fr auto;
+  gap: 4px 12px;
+  font-size: 15px;
+  line-height: 20px;
+  font-variant-numeric: tabular-nums;
+}
+
+.explain-table .strong {
+  font-weight: 700;
+}
+
+.explain-note {
+  margin: var(--space-2) 0 0;
+  font-size: 13px;
+  line-height: 18px;
+  color: var(--muted);
+}
+
+.explain-glossary {
+  min-height: 44px;
+}
+
+.explain-actions {
+  display: flex;
+  justify-content: flex-end;
+}
+
+.explain-actions button {
+  min-width: 140px;
+}
+
+/* En paysage : la feuille prend la hauteur de l'écran ; le plateau à
+ * gauche, le texte à droite. */
+/* Le plateau tient dans la hauteur, sous le sélecteur et sa légende. */
+html.landscape .explain-board {
+  width: auto;
+  max-width: 100%;
+  height: calc(100vh - 140px);
+  height: calc(100dvh - 140px);
+  aspect-ratio: 640 / 520;
+}
+
+html.landscape .explain-sheet {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) minmax(0, 1fr);
+  grid-auto-flow: dense;
+  column-gap: var(--space-4);
+  align-content: start;
+  width: min(100%, 60rem);
+  height: 100%;
+  border-radius: 0;
+}
+
+html.landscape .explain-sheet > * {
+  grid-column: 2;
+}
+
+html.landscape .explain-sheet > .explain-body {
+  grid-column: 1;
+  grid-row: 1 / span 8;
+}
+
+/* ------------------------------------------ Bilan de fin de partie (1e) */
+
+/* Maquette « Bilan de fin de partie » (charte, ecrans-etape-1.md) : un
+ * panneau centré, à la place du panneau de fin de partie ; il défile si
+ * l'écran est trop bas. */
+.summary-panel {
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-3);
+  width: min(26rem, 100%);
+  max-height: 100%;
+  overflow-y: auto;
+}
+
+.summary-panel p {
+  margin: 0;
+  font-size: 17px;
+  line-height: 25px;
+  font-weight: 400;
+}
+
+.summary-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  min-height: 44px;
+  margin: calc(-1 * var(--space-2)) 0;
+}
+
+.summary-title {
+  margin: 0;
+  font-size: 28px;
+  line-height: 34px;
+}
+
+.summary-panel .summary-status {
+  font-size: 15px;
+  line-height: 20px;
+  color: var(--muted);
+}
+
+/* Trois cases : bons coups, imprécisions, erreurs. */
+.summary-counts {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: var(--space-2);
+}
+
+.summary-count {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  padding: var(--space-2) var(--space-1);
+  background: var(--surface-sunken);
+  border-radius: var(--radius-sm);
+}
+
+.summary-number {
+  font-size: 28px;
+  line-height: 34px;
+  font-weight: 800;
+  font-variant-numeric: tabular-nums lining-nums;
+}
+
+.summary-word {
+  display: inline-flex;
+  gap: 4px;
+  align-items: center;
+  font-size: 13px;
+  line-height: 18px;
+  font-weight: 700;
+  text-align: center;
+}
+
+.summary-word .icon {
+  width: 16px;
+  height: 16px;
+}
+
+[data-verdict="good"] > .summary-word,
+.summary-verdict[data-verdict="good"],
+.row-word[data-verdict="good"],
+.viewer-phrase[data-verdict="good"] strong { color: var(--verdict-good); }
+[data-verdict="doubtful"] > .summary-word,
+.summary-verdict[data-verdict="doubtful"],
+.row-word[data-verdict="doubtful"],
+.viewer-phrase[data-verdict="doubtful"] strong { color: var(--verdict-doubtful); }
+[data-verdict="bad"] > .summary-word,
+.summary-verdict[data-verdict="bad"],
+.summary-verdict[data-verdict="veryBad"],
+.row-word[data-verdict="bad"],
+.row-word[data-verdict="veryBad"],
+.viewer-phrase[data-verdict="bad"] strong,
+.viewer-phrase[data-verdict="veryBad"] strong { color: var(--verdict-bad); }
+
+/* Deux jauges sur une ligne chacune : votre jeu (niveau), les dés. */
+.summary-gauges {
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-1);
+}
+
+.gauge {
+  display: grid;
+  grid-template-columns: 5.5rem minmax(3rem, 1fr) auto;
+  gap: var(--space-2);
+  align-items: center;
+  min-height: 28px;
+  font-size: 15px;
+  line-height: 20px;
+}
+
+.gauge-name {
+  font-weight: 700;
+}
+
+.gauge-value {
+  color: var(--muted);
+  text-align: right;
+}
+
+.gauge-track {
+  position: relative;
+  height: 8px;
+  overflow: hidden;
+  background: var(--surface-sunken);
+  border-radius: 4px;
+}
+
+.gauge-fill {
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: 0;
+  background: var(--verdict-good);
+  border-radius: 4px;
+}
+
+.gauge-fill.level-1 { width: 16.7%; }
+.gauge-fill.level-2 { width: 33.3%; }
+.gauge-fill.level-3 { width: 50%; }
+.gauge-fill.level-4 { width: 66.7%; }
+.gauge-fill.level-5 { width: 83.3%; }
+.gauge-fill.level-6 { width: 100%; }
+
+/* La chance : jauge centrée, à droite si elle vous a aidé. */
+.gauge-track.centred::after {
+  content: "";
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: calc(50% - 1px);
+  width: 2px;
+  background: var(--muted);
+}
+
+.gauge-fill.dice { background: var(--border-strong); border-radius: 0; }
+.gauge-fill.dice.for-1 { left: 50%; width: 25%; }
+.gauge-fill.dice.for-2 { left: 50%; width: 50%; }
+.gauge-fill.dice.against-1 { left: 25%; width: 25%; }
+.gauge-fill.dice.against-2 { left: 0; width: 50%; }
+.gauge-fill.dice.even { left: calc(50% - 6px); width: 12px; }
+
+.summary-glossary {
+  display: inline-flex;
+  align-items: center;
+  align-self: flex-start;
+  font-size: 15px;
+}
+
+/* Le coup à revoir : mini-plateau, mot, votre coup, celui du maître. */
+.summary-review {
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-2);
+  padding-top: var(--space-3);
+  border-top: 1px solid var(--border);
+}
+
+.summary-review-body {
+  display: grid;
+  grid-template-columns: minmax(0, 9rem) minmax(0, 1fr);
+  gap: var(--space-3);
+  align-items: start;
+}
+
+.summary-panel .summary-verdict {
+  display: inline-flex;
+  gap: 6px;
+  align-items: center;
+  font-size: 15px;
+  line-height: 20px;
+  font-weight: 700;
+}
+
+.summary-verdict .icon {
+  width: 18px;
+  height: 18px;
+}
+
+.summary-panel .summary-played,
+.summary-panel .summary-master {
+  font-size: 15px;
+  line-height: 20px;
+}
+
+.summary-panel .summary-master {
+  font-style: italic;
+}
+
+.summary-review-actions,
+.viewer-actions {
+  display: flex;
+  gap: var(--space-2);
+  align-items: center;
+}
+
+/* L'emplacement de « Demander à une IA » (étape 1f) : réservé, vide. */
+.ask-ai-slot {
+  flex: 1 1 0;
+  min-height: 44px;
+}
+
+/* Deux boutons de 48 px, côte à côte, jamais étirés en hauteur. */
+.summary-actions {
+  align-items: center;
+}
+
+.summary-actions > * {
+  flex: 1 1 0;
+  height: var(--button-height);
+  padding: 0 12px;
+}
+
+/* En paysage : deux colonnes, le résultat et les mesures à gauche, le
+ * coup à revoir et les actions à droite. */
+html.landscape .summary-panel {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) minmax(0, 1fr);
+  grid-auto-flow: row dense;
+  column-gap: var(--space-6);
+  align-content: start;
+  width: min(52rem, 100%);
+}
+
+html.landscape .summary-panel > * {
+  grid-column: 1;
+}
+
+html.landscape .summary-panel > .summary-review,
+html.landscape .summary-panel > .summary-end {
+  grid-column: 2;
+}
+
+html.landscape .summary-panel > .summary-review {
+  grid-row: 1 / span 4;
+  padding-top: 0;
+  border-top: 0;
+}
+
+/* Les actions en bas de la colonne de droite, « Changer les réglages »
+ * dessous, comme en portrait. */
+html.landscape .summary-panel > .summary-end {
+  grid-row: 5 / span 2;
+  align-self: end;
+}
+
+/* ------------------------------------------- Analyse d'une partie (1e) */
+
+/* Maquette interactive « Analyse » : une page qui défile. */
+.analysis {
+  max-width: var(--page-width);
+  margin: 0 auto;
+  padding-bottom: var(--space-6);
+}
+
+.analysis-head {
+  display: flex;
+  gap: var(--space-3);
+  align-items: center;
+  margin: var(--space-3) 0;
+}
+
+.analysis-title {
+  margin: 0;
+  font-size: 24px;
+  line-height: 30px;
+}
+
+.analysis-message:empty {
+  display: none;
+}
+
+.analysis-card {
+  margin: 0 0 var(--space-4);
+  padding: var(--space-3);
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-md);
+}
+
+.analysis-card > .overline {
+  margin-bottom: var(--space-2);
+}
+
+/* La courbe de vos chances de gagner : on la parcourt du doigt. */
+.analysis-curve {
+  display: block;
+  width: 100%;
+  height: 168px;
+  touch-action: pan-y;
+  user-select: none;
+  -webkit-user-select: none;
+  -webkit-tap-highlight-color: transparent;
+  font-family: var(--font-sans);
+}
+
+.analysis-curve:focus-visible {
+  outline: 2px solid var(--focus);
+  outline-offset: 2px;
+}
+
+.curve-axis { stroke: var(--border); stroke-width: 1; }
+.curve-half { stroke: var(--border-strong); stroke-width: 1; stroke-dasharray: 4 4; }
+.curve-label { fill: var(--muted); font-size: 12px; }
+.curve-area { fill: var(--accent-soft); }
+.curve-line { fill: none; stroke: var(--text); stroke-width: 2; stroke-linejoin: round; }
+.curve-dot.other { fill: var(--text); }
+.curve-dot.verdict-good { fill: var(--verdict-good); }
+.curve-dot.verdict-doubtful { fill: var(--verdict-doubtful); }
+.curve-dot.verdict-bad,
+.curve-dot.verdict-veryBad { fill: var(--verdict-bad); }
+.curve-cursor { stroke: var(--accent); stroke-width: 2; }
+.curve-ring { fill: none; stroke: var(--accent); stroke-width: 2; }
+.curve-band { fill: transparent; cursor: pointer; }
+.curve-band.selected { fill: var(--accent); fill-opacity: 0.08; }
+
+/* Le visualiseur : « ‹ Coup 7 sur 24 · 6-1 › », le plateau d'avant le
+ * coup, la phrase du maître, votre coup contre celui du maître. */
+.viewer-nav {
+  display: flex;
+  gap: var(--space-2);
+  align-items: center;
+  justify-content: space-between;
+}
+
+#analysis-prev .icon {
+  transform: rotate(180deg);
+}
+
+.viewer-step[aria-disabled="true"] {
+  opacity: 0.35;
+  pointer-events: none;
+}
+
+.viewer-turn {
+  margin: 0;
+  font-weight: 700;
+  text-align: center;
+  font-variant-numeric: tabular-nums lining-nums;
+}
+
+.viewer-body,
+.viewer-text {
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-2);
+}
+
+.viewer-phrase {
+  margin: 0;
+}
+
+.viewer-phrase strong {
+  display: inline-flex;
+  gap: 4px;
+  align-items: center;
+}
+
+.viewer-phrase strong .icon {
+  width: 18px;
+  height: 18px;
+}
+
+.viewer-legend {
+  margin: 0;
+  font-size: 13px;
+  line-height: 18px;
+  color: var(--muted);
+}
+
+.viewer-chance {
+  margin: 0;
+  font-size: 15px;
+  line-height: 20px;
+}
+
+.viewer-chance:empty {
+  display: none;
+}
+
+.viewer-text .segment {
+  min-height: 44px;
+  font-size: 15px;
+}
+
+.analysis-board[data-move="mine"] { --last-move: var(--text); }
+.analysis-board[data-move="best"] { --last-move: var(--verdict-good); }
+
+/* Les coups à revoir : filtres en pastilles, une ligne par coup. */
+.filters {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--space-2);
+  margin-bottom: var(--space-2);
+}
+
+.filters .filter {
+  min-height: 44px;
+  padding: 0 14px;
+  font-size: 15px;
+  font-weight: 500;
+  color: var(--text);
+  background: var(--surface-sunken);
+  border: 1px solid var(--border);
+}
+
+/* Le filtre choisi en accent-soft, comme l'onglet choisi de l'aide. */
+.filters .filter[aria-pressed="true"] {
+  font-weight: 700;
+  color: var(--text);
+  background: var(--accent-soft);
+  border-color: var(--accent);
+}
+
+.analysis-list {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.analysis-row {
+  display: grid;
+  grid-template-columns: 2rem 2.5rem minmax(0, 1fr) auto;
+  gap: var(--space-2);
+  align-items: center;
+  min-height: 44px;
+  padding: 0 var(--space-1);
+  color: var(--text);
+  text-decoration: none;
+  border-bottom: 1px solid var(--border);
+}
+
+.analysis-row[aria-current="true"] {
+  background: var(--accent-soft);
+}
+
+.row-number,
+.row-roll {
+  color: var(--muted);
+  font-variant-numeric: tabular-nums lining-nums;
+}
+
+.row-move {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.row-word {
+  display: inline-flex;
+  gap: 4px;
+  align-items: center;
+  font-size: 15px;
+  font-weight: 700;
+}
+
+.row-word .icon {
+  width: 16px;
+  height: 16px;
+}
+
+.analysis-empty {
+  padding: var(--space-2) 0;
+  color: var(--muted);
+}
+
+.analysis-table {
+  grid-template-columns: minmax(0, 1fr) auto auto;
+}
+
+/* En paysage : le plateau du visualiseur à gauche, tenu dans la hauteur
+ * de l'écran ; le texte à droite. */
+html.landscape .viewer-body {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr);
+  gap: var(--space-4);
+  align-items: start;
+}
+
+html.landscape .analysis-board {
+  width: auto;
+  max-width: 100%;
+  height: calc(100vh - 120px);
+  height: calc(100dvh - 120px);
+  aspect-ratio: 640 / 520;
+}
+
+/* Le mini-plateau du coup à revoir : trop petit pour les numéros des
+ * flèches, qui se chevaucheraient. */
+.summary-board .point-number {
+  display: none;
+}

web/index.html

@@ -63,8 +63,12 @@
     <span class="match-score" hidden></span>
     <button type="button" class="count"></button>
   </div>
+  <!-- Ligne du maître ou du dernier coup : après une décision du joueur,
+       le conseil du maître (un lien vers sa feuille d'explication) prend la
+       place du texte du dernier coup. -->
   <div class="infoline">
     <p id="info" class="info" aria-live="polite"></p>
+    <a id="advice-line" class="advice-line" href="#/" hidden></a>
     <button id="replay" type="button" class="icon-button replay" hidden></button>
     <button id="copy-link" type="button" class="icon-button copy-link" hidden></button>
   </div>
@@ -97,6 +101,10 @@
      app/src/ui/new-game-view.ts. -->
 <section id="new-game" class="new-game page" hidden></section>
 
+<!-- L'analyse d'une partie (#/parties/<id>/analyse/<coup>), construite par
+     app/src/ui/analysis-view.ts. -->
+<section id="analysis" class="analysis page" hidden></section>
+
 <!-- L'aide : un onglet par adresse (#/aide, #/glossaire, #/a-propos). -->
 <section id="help" class="help page" hidden>
   <!-- La barre haute de l'aide reste en vue quand la page défile. -->
@@ -143,12 +151,21 @@
     <a id="menu-help" href="#/aide" class="item"></a>
     <button id="menu-install" type="button" class="item"></button>
     <button id="menu-theme" type="button" class="item"><span class="item-label"></span><span class="item-value"></span></button>
+    <button id="menu-advice" type="button" class="item" role="switch"><span class="item-label"></span><span class="switch" aria-hidden="true"></span></button>
     <button id="menu-vibrations" type="button" class="item" role="switch"><span class="item-label"></span><span class="switch" aria-hidden="true"></span></button>
     <button id="menu-screen-on" type="button" class="item" role="switch"><span class="item-label"></span><span class="switch" aria-hidden="true"></span></button>
     <button id="menu-update" type="button" class="item"></button>
   </div>
 </div>
 
+<!-- L'explication du maître (#/explication/<événement>) : une feuille,
+     construite par app/src/ui/advice-view.ts. -->
+<div id="explain-veil" class="veil sheet-veil" hidden></div>
+
+<!-- Le bilan de fin de partie (#/parties/<id>/bilan) : un panneau centré,
+     construit par app/src/ui/summary-view.ts. -->
+<div id="summary-veil" class="veil summary-veil" hidden></div>
+
 <!-- La marche à suivre pour installer (#/installer) : une feuille. -->
 <div id="install-veil" class="veil sheet-veil" hidden>
   <div id="install-sheet" class="sheet" role="dialog" aria-modal="true" aria-labelledby="install-title">