chesspal 0.2.1 → 0.2.3

package/dist/page/board/marks.js

@@ -1,12 +1,21 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "preact/jsx-runtime";
-// What the board draws over its squares and pieces: the kings' badges at the end, the arrows, the helps' corners and pins, the control map's counts, the
-// bubble of a refused move, the choice of a promotion and the piece lifted off the board.
 import { useEffect, useRef, useState } from "preact/hooks";
 import { Piece } from "../pieces/pieces.js";
 /** The corner folded on a piece at risk, red on the player's and green on the other side's, in ink when no side is theirs (D-91); before its line in the card. */
 export function Notch({ tone }) {
     return (_jsx("span", { class: tone === undefined ? "help-notch" : `help-notch ${tone}`, "aria-hidden": "true", children: _jsxs("svg", { viewBox: "0 0 10 10", children: [_jsx("path", { d: "M0.5 0.5V9.5H9.5Z" }), tone === undefined ? null : _jsx("path", { class: "edge", d: "M0.5 0.5V9.5H9.5Z" }), _jsx("circle", { cx: "2.9", cy: "7.1", r: "1.1" })] }) }));
 }
+/** The pushpin stuck in a pinned piece from the top left corner, its needle toward the piece, in the tone of its corner at risk (D-91); in ink in no side's. */
+export function Pushpin({ tone }) {
+    return _jsx(Stuck, { kind: "help-pin", shape: pushpin, tone: tone });
+}
+/**
+ * The skewer stuck in the skewered piece, the one in front, as the pushpin in a pinned one (D-91): a stick in ink with a big bead and a small one in the tone,
+ * as the piece in front and the cheaper one behind it, so that it reads apart from the pushpin, all in the tone (Stefano); in the card's line, in its colour.
+ */
+export function Skewer({ tone }) {
+    return (_jsx(Stuck, { kind: "help-skewer", shape: skewer, tone: tone, children: tone === undefined || tone === "neutral" ? null : skewerBeads.map(({ y, radius }) => _jsx("circle", { cx: "12", cy: y, r: radius }, y)) }));
+}
 /** A king's badge in the corner of its square. */
 export function Badge({ kind }) {
     return (_jsx("span", { class: `badge ${kind}`, "aria-hidden": "true", children: kind === "mate" ? "#" : kind === "half" ? "½" : (_jsx("svg", { viewBox: "0 0 24 24", children: kind === "crown" ? _jsx("path", { d: "M4 18L3 7L8.5 11L12 5L15.5 11L21 7L20 18Z" }) : _jsx("path", { d: "M6 21V4M6 4.5C10 2.5 13 6.5 18 4.5V13.5C13 15.5 10 11.5 6 13.5" }) })) }));
@@ -46,13 +55,20 @@ export function Arrows({ arrows, at, explain, occupied }) {
     const starts = [...new Set(shapes.map(({ from }) => from))];
     return (_jsx("svg", { class: explain !== undefined ? "arrows explain" : occupied !== undefined ? "arrows drawn" : "arrows", viewBox: "0 0 8 8", "aria-hidden": "true", children: starts.map((start) => _jsx(ArrowGroup, { shapes: shapes.filter(({ from }) => from === start), edged: occupied !== undefined }, start)) }));
 }
-/** Each pin as a dashed line from the pinning piece through the pinned one to what stands behind it (D-78), over a halo that reads on every board. */
-export function Pins({ pins, at }) {
-    return (_jsx("svg", { class: "helps-layer", viewBox: "0 0 8 8", "aria-hidden": "true", children: pins.map((pin) => {
+/**
+ * Each pin as a dashed line from the pinning piece through the pinned one to what stands behind it (D-78), and each skewer as a dash-dot one, beads on its stick, over
+ * a halo that reads on every board. A pin and a skewer on the same stretch of a line stand apart on its two sides, so that both read.
+ */
+export function PinsAndSkewers({ pins, skewers, at }) {
+    const lines = [...pins.map((line) => ({ kind: "pin", line, other: skewers })), ...skewers.map((line) => ({ kind: "skewer", line, other: pins }))];
+    return (_jsx("svg", { class: "helps-layer", viewBox: "0 0 8 8", "aria-hidden": "true", children: lines.map(({ kind, line, other }) => {
             // The line stops short of both ends, as an explaining arrow does: it hides neither piece, nor the corner of a pinner at risk.
-            const [x0, y0] = towards(at(pin.by.square), at(pin.to.square), pinTrim);
-            const [x1, y1] = towards(at(pin.to.square), at(pin.by.square), pinTrim);
-            return (_jsxs("g", { class: "pin", children: [_jsx("line", { class: "halo", x1: x0, y1: y0, x2: x1, y2: y1 }), _jsx("line", { x1: x0, y1: y0, x2: x1, y2: y1 })] }, `${pin.by.square}${pin.piece.square}`));
+            const [startX, startY] = towards(at(line.by.square), at(line.to.square), pinTrim);
+            const [endX, endY] = towards(at(line.to.square), at(line.by.square), pinTrim);
+            const shift = other.some((each) => sharedSquares(each, line) > 1) ? (kind === "pin" ? 1 : -1) * sharedLineShift : 0;
+            const [dx, dy] = across([startX, startY], [endX, endY], shift);
+            const ends = { x1: startX + dx, y1: startY + dy, x2: endX + dx, y2: endY + dy };
+            return (_jsxs("g", { class: kind, children: [_jsx("line", { class: "halo", ...ends }), _jsx("line", { ...ends })] }, `${kind} ${line.by.square}${line.piece.square}`));
         }) }));
 }
 /** A square's counts on the control map, as a domino in its middle: how many of White's pieces reach it, and of Black's; none when no piece does. */
@@ -135,6 +151,24 @@ function ArrowGroup({ shapes, edged }) {
                 ? shapes.map(({ key, shaft, head }) => (_jsxs("g", { children: [_jsx("path", { class: "edge", d: shaft }), _jsx("polygon", { class: "edge", points: head })] }, `edge${key}`)))
                 : null, shapes.map(({ key, colour, shaft, head }) => (_jsxs("g", { class: colour, children: [_jsx("path", { d: shaft }), _jsx("polygon", { points: head })] }, key)))] }));
 }
+/**
+ * A sign stuck in a piece from its square's top left corner, tilted toward the piece; edged in ink when coloured (Zoe). Its box holds the tilted sign and
+ * its halo only, so that it sits in the corner (Stefano).
+ */
+function Stuck({ kind, shape, tone, children }) {
+    return (_jsx("span", { class: tone === undefined ? kind : `${kind} ${tone}`, "aria-hidden": "true", children: _jsx("svg", { viewBox: "2 0.5 18.5 22.5", children: _jsxs("g", { transform: "rotate(-32 12 12)", children: [_jsx("path", { d: shape }), tone === undefined || tone === "neutral" ? null : _jsx("path", { class: "edge", d: shape }), children] }) }) }));
+}
+/** How many of their three squares a pin and a skewer share: two when they lie on the same stretch of a line. */
+function sharedSquares(one, other) {
+    const squares = [one.by.square, one.piece.square, one.to.square];
+    return [other.by.square, other.piece.square, other.to.square].filter((square) => squares.includes(square)).length;
+}
+/** A step of the given length across a line, always to the same side of it whichever way the line runs. */
+function across(start, end, distance) {
+    const length = Math.hypot(end[0] - start[0], end[1] - start[1]);
+    const way = end[0] < start[0] || (end[0] === start[0] && end[1] < start[1]) ? -1 : 1;
+    return [-(end[1] - start[1]) / length * distance * way, (end[0] - start[0]) / length * distance * way];
+}
 /** A point `distance` squares from `point` toward `target`. */
 function towards(point, target, distance) {
     const length = Math.hypot(target[0] - point[0], target[1] - point[1]);
@@ -150,10 +184,18 @@ function ExplainIcon({ kind, piece }) {
                     : _jsx("path", { d: "M4 8h15M15 4l4 4-4 4M20 16H5M9 12l-4 4 4 4" }) })) }));
 }
 const promotionPieces = ["q", "n", "r", "b"];
+// A pushpin standing up, as the bubble's pin: its cap, its body widening into the collar, and its needle. Tilted less than a diagonal, so it never lies along a pin's line.
+const pushpin = "M8.6 2.2H15.4Q16.6 2.2 16.6 3.4V4.6Q16.6 5.8 15.4 5.8H14.8V9.4L18.4 13.1V14.9H13V20L12 22.6L11 20V14.9H5.6V13.1L9.2 9.4V5.8H8.6Q7.4 5.8 7.4 4.6V3.4Q7.4 2.2 8.6 2.2Z";
+// A skewer standing up, in the pushpin's box: a round end, a big bead, a small one, a stretch of stick between them, and its point.
+const skewer = "M10.9 2.6A1.1 1.1 0 0 1 13.1 2.6V3.75A4.2 4.2 0 0 1 13.1 11.85V13A3.1 3.1 0 0 1 13.1 18.8V20.2L12 23.4L10.9 20.2V18.8A3.1 3.1 0 0 1 10.9 13V11.85A4.2 4.2 0 0 1 10.9 3.75Z";
+// The skewer's beads, on its stick: the big one and the small one, as its shape draws them.
+const skewerBeads = [{ y: 7.8, radius: 4.2 }, { y: 15.9, radius: 3.1 }];
 // How much an arrow that explains is cut, in squares: off the culprit at its start, and before an occupied square at its point.
 const explainTrim = { start: 0.36, end: 0.4 };
 // How much a pin's line is cut at each end, in squares.
 const pinTrim = 0.35;
+// How far a pin and a skewer on the same stretch of a line stand off it, each on its side, in squares: a little more than a line with its halo.
+const sharedLineShift = 0.08;
 // An arrow's head, in squares: how long, and how far each side of its line.
 const arrowHead = { length: 0.42, width: 0.3 };
 // The helps' point, smaller in step with their thinner shaft (Stefano).

package/dist/page/helps/helps.css

@@ -49,6 +49,74 @@
     stroke-width: 0.5;
 }
 
+/* A pinned piece: a pushpin stuck in it from the top left corner, in the notch's colours and on its halo; it takes the place of the rank's number there.
+   A skewered piece, the one in front: a skewer stuck in it the same way, beside the pushpin when the piece is pinned too */
+.help-pin,
+.help-skewer {
+    position: absolute;
+    left: 1px;
+    top: 1px;
+    z-index: 2;
+    display: block;
+    height: clamp(15px, 3.6cqw, 26px);
+    aspect-ratio: 18.5 / 22.5;
+    pointer-events: none;
+}
+
+.help-pin svg,
+.help-skewer svg {
+    display: block;
+    width: 100%;
+    height: 100%;
+    overflow: visible;
+}
+
+.help-pin path,
+.help-skewer path {
+    fill: var(--help-ink);
+    stroke: var(--help-halo);
+    stroke-width: 2.6;
+    stroke-linejoin: round;
+    paint-order: stroke;
+}
+
+.help-pin.threat path {
+    fill: var(--badge-blunder);
+}
+
+.help-pin.chance path {
+    fill: var(--badge-best);
+}
+
+/* The skewer's stick stays in ink and its beads take the tone, so that it reads apart from the pushpin (Stefano) */
+.help-skewer circle {
+    stroke: var(--help-ink);
+    stroke-width: 0.9;
+}
+
+.help-skewer.threat circle {
+    fill: var(--badge-blunder);
+}
+
+.help-skewer.chance circle {
+    fill: var(--badge-best);
+}
+
+.help-pin path.edge,
+.help-skewer path.edge {
+    fill: none;
+    stroke: var(--help-ink);
+    stroke-width: 1;
+}
+
+.square:has(> .help-pin) > .help-skewer {
+    left: clamp(9px, 3cqw, 22px);
+}
+
+.square:has(> .help-pin, > .help-skewer) > .coordinate.rank {
+    visibility: hidden;
+}
+
 /* A pin: a thin dashed ink line from the pinner to what stands behind, under the arrows; without a head, never an arrow */
 .helps-layer {
     position: absolute;
@@ -73,6 +141,11 @@
     stroke-linecap: round;
 }
 
+/* A skewer's line: a dash and a dot, beads on its stick, so that it reads apart from a pin's even dashes */
+.helps-layer .skewer line:not(.halo) {
+    stroke-dasharray: 0.22 0.11 0 0.11;
+}
+
 /* The map (Zoe, after the round): every square on one neutral ground, then light where only White reaches, dark where only Black does, half and half
    when both do; the two counts together in the middle, as a domino. The drawings and the pieces step back */
 .board.mapping ~ .arrows,
@@ -383,6 +456,18 @@
     fill: var(--card);
 }
 
+/* The skewer of the board, in the line's colour and without its halo */
+.help-rows .help-skewer {
+    left: 7px;
+    top: 4px;
+    height: 17px;
+}
+
+.help-rows .help-skewer path {
+    fill: var(--row);
+    stroke: none;
+}
+
 .help-rows .row-icon {
     position: absolute;
     left: 6px;

package/dist/page/helps/helps.js

@@ -3,7 +3,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "preact/jsx-ru
 // the coach's words (D-88).
 import { Fragment } from "preact";
 import { useState } from "preact/hooks";
-import { Notch } from "../board/marks.js";
+import { Notch, Skewer } from "../board/marks.js";
 import { BadgeIcon, NoteIcon } from "../game/badges.js";
 import { FoldButton, useCardFold } from "../game/card-fold.js";
 import { Figurines } from "../game/move-list.js";
@@ -70,7 +70,7 @@ function Judged({ ply, text }) {
 function Tactics({ helps, opened, onOpen, onPoint, text }) {
     const words = text.helpsCard;
     const point = pointing(onPoint);
-    const calm = !helps.lines.some((line) => line.kind === "risk" || line.kind === "pin");
+    const calm = !helps.lines.some((line) => line.kind === "risk" || line.kind === "pin" || line.kind === "skewer");
     return (_jsxs("ul", { class: "help-rows", children: [calm
                 ? (_jsxs("li", { class: "safe", children: [_jsxs(RowIcon, { children: [_jsx("circle", { cx: "8", cy: "8", r: "6.5" }), _jsx("path", { d: "M5.2 8.2l2 2 3.8-4" })] }), words.nothingAtRisk] }))
                 : null, helps.lines.map((line) => {
@@ -86,11 +86,14 @@ function pointing(onPoint) {
         onPointerLeave: (event) => event.pointerType === "mouse" && onPoint([]),
     });
 }
-/** A line's sign: the corner of a piece at risk, a pin's link, a check's plus, the loose pieces' i; its colour is the line's. */
+/** A line's sign: the corner of a piece at risk, a pin's link, the skewer of the board, a check's plus, the loose pieces' i; its colour is the line's. */
 function LineIcon({ kind }) {
     if (kind === "risk") {
         return _jsx(Notch, {});
     }
+    if (kind === "skewer") {
+        return _jsx(Skewer, {});
+    }
     if (kind === "loose") {
         return _jsx(InfoIcon, {});
     }
@@ -115,6 +118,8 @@ function LineDetails({ line, helps, point, text }) {
             return (_jsx("ul", { class: "line-details", children: line.items.map((risk) => (_jsxs("li", { ...point(riskSquares(risk)), children: [text.piece(risk.piece.piece, risk.piece.side), " ", _jsx(Squares, { squares: [risk.piece.square] }), " \u00B7 ", words.attackers, ": ", _jsx(Squares, { squares: risk.piece.attackers }), risk.why === "undefended" ? null : (_jsxs(_Fragment, { children: [" ", "\u00B7 ", words.defenders, ": ", _jsx(Squares, { squares: risk.piece.defenders })] })), " \u00B7 ", words[risk.why]] }, risk.piece.square))) }));
         case "pin":
             return (_jsx("ul", { class: "line-details", children: line.items.map((pin) => (_jsxs("li", { ...point(pinSquares(pin)), children: [text.piece(pin.piece.piece, pin.piece.side), " ", _jsx(Squares, { squares: [pin.piece.square] }), " ", words.pinnedTo(pin.to.piece), " ", _jsx(Squares, { squares: [pin.to.square] }), ", ", words.pinnedBy(pin.by.piece), " ", _jsx(Squares, { squares: [pin.by.square] })] }, pin.piece.square))) }));
+        case "skewer":
+            return (_jsx("ul", { class: "line-details", children: line.items.map((skewer) => (_jsxs("li", { ...point(pinSquares(skewer)), children: [text.piece(skewer.piece.piece, skewer.piece.side), " ", _jsx(Squares, { squares: [skewer.piece.square] }), " ", words.skeweredBefore(skewer.to.piece), " ", _jsx(Squares, { squares: [skewer.to.square] }), ", ", words.pinnedBy(skewer.by.piece), " ", _jsx(Squares, { squares: [skewer.by.square] })] }, skewer.piece.square))) }));
         case "check":
             return (_jsx("p", { class: "line-details", children: line.items.map((check) => (_jsx("span", { class: "help-move", children: _jsx(Figurines, { san: check, side: line.side }) }, check))) }));
         case "loose":

package/dist/page/helps/view.js

@@ -7,6 +7,7 @@ export function helpsOf(game, you) {
     const toMove = game.position.turn;
     const atRisk = [...risks(facts.undefended, "undefended"), ...risks(facts.attackedByCheaper, "cheaper"), ...risks(facts.outnumbered, "outnumbered")];
     const pins = facts.pins.map((pin) => ({ piece: on(pin.square), by: on(pin.by), to: on(pin.to) }));
+    const skewers = facts.skewers.map((skewer) => ({ piece: on(skewer.square), by: on(skewer.by), to: on(skewer.to) }));
     const checks = facts.checks;
     const otherChecks = facts.otherChecks ?? [];
     const loose = facts.loose.map(on);
@@ -15,10 +16,11 @@ export function helpsOf(game, you) {
         you,
         atRisk,
         pins,
+        skewers,
         checks,
         otherChecks,
         loose,
-        lines: tacticLines({ toMove, atRisk, pins, checks, otherChecks, loose }, you),
+        lines: tacticLines({ toMove, atRisk, pins, skewers, checks, otherChecks, loose }, you),
         strategy: game.profile,
         sides: you === "black" ? ["black", "white"] : ["white", "black"],
     };
@@ -28,12 +30,23 @@ export function riskOn(helps, square) {
     const risk = helps.atRisk.find((risk) => risk.piece.square === square);
     return risk === undefined ? undefined : toneOf(risk.piece.side, helps.you);
 }
-/** The squares a line of the tactics lights on the board: its pieces, and those that attack or pin them; none for the checks. */
+/** How the helps mark a square's pinned piece: in the tone of a piece at risk, red when it is the player's, green when it is the other side's (D-91). */
+export function pinOn(helps, square) {
+    const pin = helps.pins.find((pin) => pin.piece.square === square);
+    return pin === undefined ? undefined : toneOf(pin.piece.side, helps.you);
+}
+/** How the helps mark a square's skewered piece, the one in front: in the tone of a piece at risk, as a pinned one (D-91). */
+export function skewerOn(helps, square) {
+    const skewer = helps.skewers.find((skewer) => skewer.piece.square === square);
+    return skewer === undefined ? undefined : toneOf(skewer.piece.side, helps.you);
+}
+/** The squares a line of the tactics lights on the board: its pieces, and those that attack, pin or skewer them; none for the checks. */
 export function squaresOf(line) {
     switch (line.kind) {
         case "risk":
             return line.items.flatMap(riskSquares);
         case "pin":
+        case "skewer":
             return line.items.flatMap(pinSquares);
         case "check":
             return [];
@@ -45,7 +58,7 @@ export function squaresOf(line) {
 export function riskSquares(risk) {
     return [risk.piece.square, ...risk.piece.attackers];
 }
-/** A pinned piece, the one that pins it and the one behind it. */
+/** A pinned or skewered piece, the one that pins or skewers it and the one behind it. */
 export function pinSquares(pin) {
     return [pin.piece.square, pin.by.square, pin.to.square];
 }
@@ -88,12 +101,13 @@ const cells = {
     castled: castlingOf,
     kingAttacks: (side) => side.king?.attacksNear ?? 0,
 };
-// The tactics' lines that have something: with the player's side, their pieces at risk and pinned and the other side's checks, then the same the other way
-// round; without it, White's then Black's; the loose pieces last.
+// The tactics' lines that have something: with the player's side, their pieces at risk, pinned and skewered and the other side's checks, then the same the
+// other way round; without it, White's then Black's; the loose pieces last.
 function tacticLines(facts, you) {
     const sideLines = (side) => [
         { kind: "risk", side, tone: toneOf(side, you), items: facts.atRisk.filter((risk) => risk.piece.side === side) },
         { kind: "pin", side, tone: toneOf(side, you), items: facts.pins.filter((pin) => pin.piece.side === side) },
+        { kind: "skewer", side, tone: toneOf(side, you), items: facts.skewers.filter((skewer) => skewer.piece.side === side) },
     ];
     const checkLine = (side) => ({
         kind: "check",

package/dist/page/text.js

@@ -274,16 +274,18 @@ const english = {
         outnumbered: "more attackers than defenders",
         pinnedTo: (letter) => `pinned to the ${englishNames[letter]}`,
         pinnedBy: (letter) => `by the ${englishNames[letter]}`,
+        skeweredBefore: (letter) => `ahead of the ${englishNames[letter]}`,
         nothingAtRisk: "No piece at risk, no pins.",
         line: (kind, side, you, toMove) => {
             const name = side === "white" ? "White" : "Black";
+            const pieces = { risk: "pieces at risk", pin: "pinned pieces", skewer: "skewered pieces" };
             if (you === undefined) {
-                return kind === "risk" ? `${name}'s pieces at risk` : kind === "pin" ? `${name}'s pinned pieces` : `${name}'s checks${toMove ? "" : `, if it were ${name}'s move`}`;
+                return kind === "check" ? `${name}'s checks${toMove ? "" : `, if it were ${name}'s move`}` : `${name}'s ${pieces[kind]}`;
             }
             if (kind === "check") {
                 return side === you ? `Checks you ${toMove ? "can" : "could"} give` : `Checks the opponent ${toMove ? "can" : "could"} give you`;
             }
-            return `${side === you ? "Your" : "The opponent's"} ${kind === "risk" ? "pieces at risk" : "pinned pieces"}`;
+            return `${side === you ? "Your" : "The opponent's"} ${pieces[kind]}`;
         },
         loose: "Pieces neither attacked nor defended",
         yours: "yours",
@@ -594,16 +596,18 @@ const italian = {
         outnumbered: "più attaccanti che difensori",
         pinnedTo: (letter) => `davanti ${italianWith("a", letter)}`,
         pinnedBy: (letter) => italianWith("da", letter),
+        skeweredBefore: (letter) => `con dietro ${italianThe[letter]}`,
         nothingAtRisk: "Nessun pezzo in pericolo, nessuna inchiodatura.",
         line: (kind, side, you, toMove) => {
             const name = side === "white" ? "Bianco" : "Nero";
+            const what = { risk: "in pericolo", pin: "inchiodati", skewer: "infilati" };
             if (you === undefined) {
-                return kind === "risk" ? `Pezzi del ${name} in pericolo` : kind === "pin" ? `Pezzi del ${name} inchiodati` : `Scacchi del ${name}${toMove ? "" : ", se toccasse a lui"}`;
+                return kind === "check" ? `Scacchi del ${name}${toMove ? "" : ", se toccasse a lui"}` : `Pezzi del ${name} ${what[kind]}`;
             }
             if (kind === "check") {
                 return side === you ? `Scacchi che ${toMove ? "puoi" : "potresti"} dare` : `Scacchi che l'avversario ${toMove ? "può" : "potrebbe"} darti`;
             }
-            return `${side === you ? "I tuoi pezzi" : "I pezzi avversari"} ${kind === "risk" ? "in pericolo" : "inchiodati"}`;
+            return `${side === you ? "I tuoi pezzi" : "I pezzi avversari"} ${what[kind]}`;
         },
         loose: "Pezzi né attaccati né difesi",
         yours: "tuoi",

package/dist/server/caller.d.ts

@@ -6,16 +6,19 @@ export interface Client {
 }
 /** Who made the call with these metadata: the model and effort the host ties to it, else the host's name; undefined without a host. */
 export declare function callerOf(meta: Record<string, unknown> | undefined, client: Client | undefined, folder: string, wait?: number): Promise<Caller | undefined>;
-/** Who in Claude Code made a tool call: the chat itself, or one of its agents by its type. */
+/** Who in Claude Code or Codex made a tool call: the chat itself, or one of its agents by its type. */
 export type CallingAgent = {
     chat: true;
 } | {
     agent: string;
 };
 /**
- * Who in Claude Code made a tool call: the chat, when its line is in the chat's transcript, or the agent whose file has it, by the type Claude Code notes
- * beside that file (Priya). Undefined when it cannot be told: another host, no chat noted, no line, or no type.
+ * Who in Claude Code or Codex made a tool call: the chat, when its line is in the chat's transcript, or the agent whose file has it, by the type Claude Code
+ * notes beside that file (Priya); in Codex, as the call's metadata and the agent's own session say (D-98). Undefined when it cannot be told: another host,
+ * no chat noted, no line, or no type.
  */
 export declare function callingAgent(meta: Record<string, unknown> | undefined, folder: string, wait?: number): Promise<CallingAgent | undefined>;
+/** Whether a call comes from one of Codex's agents, as its metadata say: its own process starts no board page (D-98). */
+export declare function fromCodexAgent(meta: Record<string, unknown> | undefined): boolean;
 /** Whether an agent's tool may answer this caller: one of its agents, or a caller that cannot be told, since the tool's description is the first guard. */
 export declare function allowedCaller(caller: CallingAgent | undefined, agents: readonly string[]): boolean;

package/dist/server/caller.js

@@ -1,6 +1,7 @@
 // Who makes a tool call (D-81): only what the host ties to that call, never what the AI says of itself nor a setting the chat may have changed.
 // Codex sends the model and the effort with each call; Claude Code writes them into the chat's transcript, on the line of the call.
 import { closeSync, openSync, readdirSync, readFileSync, readSync, statSync } from "node:fs";
+import { homedir } from "node:os";
 import { basename, dirname, join } from "node:path";
 import { lastChatStart } from "../games/index.js";
 /** Who made the call with these metadata: the model and effort the host ties to it, else the host's name; undefined without a host. */
@@ -20,10 +21,15 @@ export async function callerOf(meta, client, folder, wait = 50) {
     return client === undefined ? undefined : { annotator: client.title ?? client.name, hostOnly: true };
 }
 /**
- * Who in Claude Code made a tool call: the chat, when its line is in the chat's transcript, or the agent whose file has it, by the type Claude Code notes
- * beside that file (Priya). Undefined when it cannot be told: another host, no chat noted, no line, or no type.
+ * Who in Claude Code or Codex made a tool call: the chat, when its line is in the chat's transcript, or the agent whose file has it, by the type Claude Code
+ * notes beside that file (Priya); in Codex, as the call's metadata and the agent's own session say (D-98). Undefined when it cannot be told: another host,
+ * no chat noted, no line, or no type.
  */
 export async function callingAgent(meta, folder, wait = 50) {
+    const turn = objectOf(meta?.["x-codex-turn-metadata"]);
+    if (turn !== undefined) {
+        return await codexCaller(turn, wait);
+    }
     const call = meta?.["claudecode/toolUseId"];
     const transcript = lastChatStart(folder)?.transcript;
     const found = typeof call === "string" && transcript !== undefined ? await foundCall(transcript, call, wait) : undefined;
@@ -36,6 +42,10 @@ export async function callingAgent(meta, folder, wait = 50) {
     const type = objectOf(textOf(found.file.replace(/\.jsonl$/, ".meta.json")))?.agentType;
     return typeof type === "string" ? { agent: type } : undefined;
 }
+/** Whether a call comes from one of Codex's agents, as its metadata say: its own process starts no board page (D-98). */
+export function fromCodexAgent(meta) {
+    return objectOf(meta?.["x-codex-turn-metadata"])?.thread_source === "subagent";
+}
 /** Whether an agent's tool may answer this caller: one of its agents, or a caller that cannot be told, since the tool's description is the first guard. */
 export function allowedCaller(caller, agents) {
     return caller === undefined || ("agent" in caller && agents.includes(caller.agent));
@@ -80,6 +90,81 @@ function callerIn(text, call) {
     }
     return undefined;
 }
+/**
+ * Who in Codex made a call: the chat, or an agent by the role its session notes first, before its first call (Priya). An agent started with the chat's
+ * own turns sees the opponent's plan, so it counts as the chat (D-88).
+ */
+async function codexCaller(turn, wait) {
+    if (turn.thread_source !== "subagent") {
+        return turn.thread_source === "user" ? { chat: true } : undefined;
+    }
+    const thread = turn.thread_id;
+    if (typeof thread !== "string" || !/^[0-9a-f-]{36}$/i.test(thread)) {
+        return undefined;
+    }
+    const known = codexThreads.get(thread);
+    if (known !== undefined) {
+        return known;
+    }
+    for (let attempt = 0; attempt < codexAttempts; attempt++) {
+        const start = headOf(codexSession(thread));
+        const role = /"agent_role":"([^"]+)"/.exec(start)?.[1];
+        if (role !== undefined) {
+            const caller = start.includes('"forked_from_id":"') ? { chat: true } : { agent: role };
+            codexThreads.set(thread, caller);
+            return caller;
+        }
+        await new Promise((done) => setTimeout(done, wait));
+    }
+    return undefined;
+}
+// Who each agent's thread is, read once: it never changes, and an agent calls a tool many times (Federico).
+const codexThreads = new Map();
+// The agent's session is written as it starts: a few tries are enough.
+const codexAttempts = 10;
+// Its first line holds Codex's long prompt, but the role comes in its first two kilobytes (Priya).
+const headBytes = 16 * 1024;
+/**
+ * The file of a Codex session by its thread: in the day's folder of its start, which its UUIDv7 holds, or the days beside it around midnight; none when
+ * it is not there.
+ */
+function codexSession(thread) {
+    const started = Number.parseInt(thread.replaceAll("-", "").slice(0, 12), 16);
+    const sessions = join(process.env.CODEX_HOME ?? join(homedir(), ".codex"), "sessions");
+    for (const day of [0, -1, 1]) {
+        const date = new Date(started + day * 86_400_000);
+        const folder = join(sessions, String(date.getFullYear()), String(date.getMonth() + 1).padStart(2, "0"), String(date.getDate()).padStart(2, "0"));
+        try {
+            const name = readdirSync(folder).find((each) => each.endsWith(`-${thread}.jsonl`));
+            if (name !== undefined) {
+                return join(folder, name);
+            }
+        }
+        catch {
+            // No session that day.
+        }
+    }
+    return "";
+}
+function headOf(file) {
+    if (file === "") {
+        return "";
+    }
+    try {
+        const descriptor = openSync(file, "r");
+        try {
+            const buffer = Buffer.alloc(headBytes);
+            const read = readSync(descriptor, buffer, 0, headBytes, 0);
+            return buffer.subarray(0, read).toString("utf8");
+        }
+        finally {
+            closeSync(descriptor);
+        }
+    }
+    catch {
+        return "";
+    }
+}
 function withEffort(model, effort) {
     return typeof effort === "string" && effort !== "" ? { annotator: model, effort } : { annotator: model };
 }

package/dist/server/mcp.d.ts

@@ -3,11 +3,16 @@ import { type AnyCommand, type Context } from "../commands/index.ts";
 /** What the host reads as the server starts, before any tool: where to begin, and the rule of every move (D-27). Short, since hosts may cut it. */
 export declare const serverInstructions: string;
 /** The MCP server for an AI host: every command of the registry as a tool, with its description and parameters (D-5). */
-export declare function createMcpServer(context?: Context, list?: AnyCommand[]): McpServer;
+export declare function createMcpServer(context?: Context, list?: AnyCommand[], beforeCall?: (meta: Record<string, unknown> | undefined) => Promise<void>): McpServer;
 /**
  * Serves the tools over standard input and output, as AI hosts expect: stdout carries the protocol alone, so nothing else may print there. It ends when the
  * host goes and its input closes, once the calls still running have answered: a move half made would be lost.
  */
 export declare function startMcpServer(context?: Context, list?: AnyCommand[]): Promise<void>;
+/**
+ * The board page started once, before the chat's first call, the status every chat opens with, which then gives its address: the process of a Codex
+ * agent, which has one of its own, starts none, which would stand beside the chat's and could keep the doorbell from it (D-98, Priya).
+ */
+export declare function lazyPage(start: () => Promise<void>): (meta: Record<string, unknown> | undefined) => Promise<void>;
 /** The opponent's name for the page, from the host's (D-97): another host than Claude's and Codex is unnamed. */
 export declare function opponentOf(host: string | undefined): string | undefined;

package/dist/server/mcp.js

@@ -5,31 +5,39 @@ import { z } from "zod";
 import { aiMove, commands, defaultContext, inputProblems, isBoolean, PositionChanged } from "../commands/index.js";
 import { aiNameOf } from "../core/index.js";
 import { endOf, loadGame, noteAiHost, noteAiModel } from "../games/index.js";
-import { hasAgent } from "../host-files/index.js";
+import { agentTools, hasAgent } from "../host-files/index.js";
 import { gameFolder } from "../profiles/index.js";
 import { version } from "../version.js";
 import { pagePorts } from "./bell.js";
-import { allowedCaller, callerOf, callingAgent } from "./caller.js";
+import { allowedCaller, callerOf, callingAgent, fromCodexAgent } from "./caller.js";
 import { chatHasRead, startPage } from "./page/page.js";
 /** What the host reads as the server starts, before any tool: where to begin, and the rule of every move (D-27). Short, since hosts may cut it. */
 export const serverInstructions = "Chesspal keeps the chess for you: the rules, the board, the clock, the games and the player's memory. Call `status` at the start of every "
     + "chat. Every move goes through Chesspal's tools: never keep the board in your head or invent a position.";
 /** The MCP server for an AI host: every command of the registry as a tool, with its description and parameters (D-5). */
-export function createMcpServer(context = defaultContext(), list = commands) {
+export function createMcpServer(context = defaultContext(), list = commands, beforeCall) {
     const server = new McpServer({ name: "chesspal", version }, { instructions: serverInstructions });
     // The server keeps what it told the chat, the instructions a tool gives once, and the position it showed: none yet (D-71).
     context.told ??= new Set();
     context.positionSeen ??= null;
     // The host the chat runs in, as it introduced itself: it names the AI on the page and in the game's PGN (D-97).
     context.host ??= () => server.server.getClientVersion()?.name;
-    const forOneHost = [];
+    const forSomeHosts = [];
     for (const command of list.filter((each) => each.cliOnly !== true)) {
         const tool = server.registerTool(command.name, toolConfig(command), async (input, extra) => {
+            await beforeCall?.(extra._meta);
+            const codexAgent = fromCodexAgent(extra._meta);
+            const calling = command.byAgents !== undefined || codexAgent ? await callingAgent(extra._meta, context.folder) : undefined;
             // An agent's tool called by the chat, or by another agent, would give what only that agent may see (Priya).
-            if (command.byAgents !== undefined && !allowedCaller(await callingAgent(extra._meta, context.folder), command.byAgents)) {
+            if (command.byAgents !== undefined && !allowedCaller(calling, command.byAgents)) {
                 // It names no agent to start: the chat that asked would start one itself (Priya).
                 return { content: [{ type: "text", text: `${command.name} is not yours to call: the player reads what it gives on the board page. Nothing changed.` }], isError: true };
             }
+            // Codex gives its agents every tool: one of Chesspal's keeps to its own, and never plays or talks for the opponent (D-98, Federico).
+            const own = calling !== undefined && "agent" in calling ? agentTools(calling.agent) : undefined;
+            if (codexAgent && own !== undefined && !own.includes(command.name)) {
+                return { content: [{ type: "text", text: `${command.name} is not yours to call: you work only with ${own.join(", ")}. Nothing changed.` }], isError: true };
+            }
             // Each call knows who makes it, for the commands that write it down (D-81).
             const caller = () => callerOf(extra._meta, server.server.getClientVersion(), context.folder);
             const result = await track(runTool(command, input, context, caller, extra._meta));
@@ -38,15 +46,15 @@ export function createMcpServer(context = defaultContext(), list = commands) {
             }
             return result;
         });
-        if (command.host !== undefined) {
+        if (command.hosts !== undefined) {
             tool.disable();
-            forOneHost.push({ host: command.host, tool });
+            forSomeHosts.push({ hosts: command.hosts, tool });
         }
     }
-    // A tool for one host is offered once the host has said its name, before it lists the tools.
+    // A tool for some hosts is offered once the host has said its name, before it lists the tools.
     server.server.oninitialized = () => {
         const host = server.server.getClientVersion()?.name;
-        for (const { tool } of forOneHost.filter((each) => each.host === host)) {
+        for (const { tool } of forSomeHosts.filter((each) => host !== undefined && each.hosts.includes(host))) {
             tool.enable();
         }
     };
@@ -65,10 +73,25 @@ export async function startMcpServer(context = defaultContext(), list = commands
     };
     process.stdin.on("end", leave);
     process.stdin.on("close", leave);
-    const server = createMcpServer(context, list);
-    context.page = await pageOf(context, () => opponentOf(context.host?.()));
+    const pageFirst = lazyPage(async () => {
+        context.page = await pageOf(context, () => opponentOf(context.host?.()));
+    });
+    const server = createMcpServer(context, list, pageFirst);
     await server.connect(new StdioServerTransport());
 }
+/**
+ * The board page started once, before the chat's first call, the status every chat opens with, which then gives its address: the process of a Codex
+ * agent, which has one of its own, starts none, which would stand beside the chat's and could keep the doorbell from it (D-98, Priya).
+ */
+export function lazyPage(start) {
+    let page;
+    return async (meta) => {
+        if (!fromCodexAgent(meta)) {
+            page ??= start();
+            await page;
+        }
+    };
+}
 /** The opponent's name for the page, from the host's (D-97): another host than Claude's and Codex is unnamed. */
 export function opponentOf(host) {
     return aiNameOf(host);
@@ -76,11 +99,10 @@ export function opponentOf(host) {
 /** The board page of the player's folder, served by this process for as long as the chat lasts (D-47); without it the game goes on in the chat. */
 async function pageOf(context, opponent) {
     try {
-        const { url, heard, chatCalls, ponders, open, askNewGame } = await startPage(context, opponent);
+        const { url, heard, chatCalls, open, askNewGame } = await startPage(context, opponent);
         // Words the AI is given change no file: the pages hear of them from the commands.
         context.heard = heard;
         context.calls = chatCalls;
-        context.ponders = ponders;
         context.pageOpen = open;
         context.askNewGame = askNewGame;
         if (!pagePorts(context.folder).includes(Number(new URL(url).port))) {
@@ -159,7 +181,7 @@ async function runTool(command, input, context, caller, meta) {
  * goes on, so that no call of the chat's waits for it while it plays; none for the chat, or when it cannot be told.
  */
 async function sharingAgent(command, meta, context) {
-    const agents = command.sharedWith?.filter((agent) => hasAgent(context.folder, agent)) ?? [];
+    const agents = command.sharedWith?.filter((agent) => hasAgent(context.folder, agent, context.host?.())) ?? [];
     if (agents.length === 0 || gameGoingOn(context)) {
         return undefined;
     }