chesspal 0.2.1 → 0.2.3

package/dist/commands/agents.d.ts

@@ -1,7 +1,7 @@
 import { type CurrentGame } from "../games/index.ts";
 import type { Context } from "./context.ts";
 import type { GameSummary } from "./game-summary.ts";
-/** Whether an analyst agent goes over a game over when the player wants: in Claude Code, with its agent in the player's folder (D-89). */
+/** Whether an analyst agent goes over a game over when the player wants: in Claude Code or Codex, with its agent in the player's folder (D-89, D-98). */
 export declare function analystRuns(context: Context): boolean;
 /**
  * The game over, with the analyst agent that goes over it when the player wants, where it runs (D-89); over, the game from status and ai_say, which come after
@@ -12,8 +12,10 @@ export declare function withAnalyst(summary: GameSummary, context: Context, over
 export declare function analystLine(game?: string): string;
 /** How the chat goes over a game the analyst agent has reviewed, or is reviewing: from that review, never with another agent (Stefano). */
 export declare function reviewedLine(game?: string): string;
-/** Whether a coach judges the player's moves when the helps are on: in Claude Code, with its agent in the player's folder (D-80, D-88). */
+/** Whether a coach judges the player's moves when the helps are on: in Claude Code or Codex, with its agent in the player's folder (D-80, D-88, D-98). */
 export declare function coachRuns(context: Context): boolean;
+/** Whether one of Chesspal's agents runs beside this chat: in a host that starts agents, with its file in the player's folder. */
+export declare function agentRuns(context: Context, agent: string): boolean;
 /**
  * Whether to start the coach after the player's own move has ended the game on the board, with the helps on: it judges that move too (D-88). Told again
  * until it starts, since a chat woken by the page may lose the line on its way to its words (Priya).

package/dist/commands/agents.js

@@ -1,11 +1,11 @@
-// The agents that work beside the chat in Claude Code: the analyst that goes over a game over (D-89) and the coach that judges the player's moves (D-88).
+// The agents that work beside the chat in Claude Code and Codex (D-98): the analyst that goes over a game over (D-89) and the coach that judges the player's moves (D-88).
 import { isReviewed } from "../core/index.js";
 import { archivedGame, archivedName, coachStarted, gameInAnalysis } from "../games/index.js";
-import { analystAgent, coachAgent, hasAgent } from "../host-files/index.js";
+import { agentHosts, analystAgent, coachAgent, hasAgent } from "../host-files/index.js";
 import { gameFolder, helpsIn } from "../profiles/index.js";
-/** Whether an analyst agent goes over a game over when the player wants: in Claude Code, with its agent in the player's folder (D-89). */
+/** Whether an analyst agent goes over a game over when the player wants: in Claude Code or Codex, with its agent in the player's folder (D-89, D-98). */
 export function analystRuns(context) {
-    return context.host?.() === "claude-code" && hasAgent(context.folder, analystAgent);
+    return agentRuns(context, analystAgent);
 }
 /**
  * The game over, with the analyst agent that goes over it when the player wants, where it runs (D-89); over, the game from status and ai_say, which come after
@@ -28,9 +28,14 @@ export function reviewedLine(game) {
     return "The analyst agent has gone over this game, or is at it: never start it again. When the player wants it gone over, go over it with them from what "
         + `it told you, or, in a chat without it, from its review on the board page, which analyse_game ${game === undefined ? "" : `{"game": "${game}"} `}gives.`;
 }
-/** Whether a coach judges the player's moves when the helps are on: in Claude Code, with its agent in the player's folder (D-80, D-88). */
+/** Whether a coach judges the player's moves when the helps are on: in Claude Code or Codex, with its agent in the player's folder (D-80, D-88, D-98). */
 export function coachRuns(context) {
-    return context.host?.() === "claude-code" && hasAgent(context.folder, coachAgent);
+    return agentRuns(context, coachAgent);
+}
+/** Whether one of Chesspal's agents runs beside this chat: in a host that starts agents, with its file in the player's folder. */
+export function agentRuns(context, agent) {
+    const host = context.host?.();
+    return host !== undefined && agentHosts.includes(host) && hasAgent(context.folder, agent, host);
 }
 /**
  * Whether to start the coach after the player's own move has ended the game on the board, with the helps on: it judges that move too (D-88). Told again

package/dist/commands/ai-move.js

@@ -1,9 +1,9 @@
 import { z } from "zod";
 import { boardText, drawingsText, moods, moodTag } from "../core/index.js";
 import { commentWithPlan, talkLimits } from "../games/index.js";
-import { coachAgent, hasAgent, ponderAgentFor } from "../host-files/index.js";
+import { coachAgent, ponderAgentFor } from "../host-files/index.js";
 import { gameFolder, helpsIn } from "../profiles/index.js";
-import { agentsLine, coachRuns, withAnalyst } from "./agents.js";
+import { agentRuns, agentsLine, coachRuns, withAnalyst } from "./agents.js";
 import { closingLines, moveLines, shownMove } from "./answer-lines.js";
 import { arrowsInput, drawingsOf, squaresInput } from "./drawings.js";
 import {} from "./game-summary.js";
@@ -71,15 +71,12 @@ function refuseWithoutHelps(folder, { comment, arrows, squares }) {
     }
 }
 /**
- * The agents to start after the move, in Claude Code, in a folder init set up with them: the one that thinks for the AI while the game goes on (D-72), then
+ * The agents to start after the move, in Claude Code or Codex, in a folder init set up with them: the one that thinks for the AI while the game goes on (D-72), then
  * the coach with the helps on, which judges the player's move even when the AI's ends the game (D-88).
  */
 function agentsAfter(context, folder, played) {
-    if (context.host?.() !== "claude-code") {
-        return [];
-    }
     const ponder = ponderAgentFor(played.game.level);
-    const thinks = played.game.end === undefined && hasAgent(context.folder, ponder);
+    const thinks = played.game.end === undefined && agentRuns(context, ponder);
     const coaches = helpsIn(folder) && coachRuns(context);
     return [...(thinks ? [ponder] : []), ...(coaches ? [coachAgent] : [])];
 }

package/dist/commands/coach.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { badges, Game, leadText, levelOf, materialOf, withSanLetters } from "../core/index.js";
 import { archiveCoached, coachWaitingSince, coachWords, endOf, keepHint, keepJudgment, keepLead, loadGame, startCoach } from "../games/index.js";
-import { coachAgent } from "../host-files/index.js";
+import { agentHosts, coachAgent } from "../host-files/index.js";
 import { activeProfile, gameFolder, helpsIn } from "../profiles/index.js";
 import { clockLine, clockSummaryOf } from "./clock.js";
 import { arrowsInput, drawingsOf, noteInput, squaresInput } from "./drawings.js";
@@ -40,7 +40,7 @@ export const coach = defineCommand({
         done: z.boolean().optional().describe("true once you have kept your words, who is ahead always while the game goes on: it waits for the player's move"),
     }),
     byAgents: [coachAgent],
-    host: "claude-code",
+    hosts: agentHosts,
     run: async ({ game, position, ahead, badge, note, hint, arrows, squares, done = false }, context) => {
         const folder = gameFolder(context.home());
         const current = loadGame(folder);

package/dist/commands/context.d.ts

@@ -30,8 +30,6 @@ export interface Context {
     heard?: () => void;
     /** Told when the chat calls a tool, before it runs: the board page hears the chat listens, and the AI's clock, held while nobody did, starts. */
     calls?: () => void;
-    /** Told when the AI starts thinking on the player's time (D-72), with the position, and when it is done: the board page shows it. */
-    ponders?: (position: SeenPosition | undefined) => void;
     /** The game the chat saw when its last tool ended, its folder and its stamp: the doorbell wakes it only for a game changed since. */
     seen?: string | undefined;
     /**

package/dist/commands/ponder.d.ts

@@ -29,7 +29,7 @@ interface Start {
 }
 /**
  * The AI's thinking on the player's time (D-72), for the agent that does it: the position, the view after a reply, its answer kept for its move, and its
- * words on the board page. Its calls are not the chat's: the doorbell still wakes the chat for the player's move. Offered to Claude Code alone, which runs the agent.
+ * words on the board page. Its calls are not the chat's: the doorbell still wakes the chat for the player's move. Offered to the hosts that run the agent (D-98).
  */
 export declare const ponder: import("./registry.ts").Command<z.ZodObject<{
     position: z.ZodOptional<z.ZodInt>;
@@ -46,6 +46,7 @@ export declare const ponder: import("./registry.ts").Command<z.ZodObject<{
 export declare function waitForPlayer(context: {
     now: () => Date;
     pause?: (milliseconds: number) => Promise<void>;
+    host?: () => string | undefined;
 }, since: Date, gone: () => boolean): Promise<"moved" | "waited" | "waiting">;
 /** The words of the AI's move for the player: its comment without the plan, the mood, the clock and the draw offer it carries. */
 export declare function wordsOf(comment: string | undefined): string | undefined;

package/dist/commands/ponder.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { Game, levelOf, moodAt, sees, timeLeft } from "../core/index.js";
-import { currentPlan, endOf, keepThought, loadGame, talkLimits, thoughtKey, waitingSince } from "../games/index.js";
-import { ponderAgents } from "../host-files/index.js";
+import { currentPlan, endOf, keepThought, loadGame, notePondering, talkLimits, thoughtKey, waitingSince } from "../games/index.js";
+import { agentHosts, isCodex, ponderAgents } from "../host-files/index.js";
 import { gameFolder } from "../profiles/index.js";
 import { positionLines } from "./answer-lines.js";
 import { summaryOf } from "./game-summary.js";
@@ -11,7 +11,7 @@ import { say as sayWords } from "./say.js";
 import { boardView, colourName, compactView } from "./view.js";
 /**
  * The AI's thinking on the player's time (D-72), for the agent that does it: the position, the view after a reply, its answer kept for its move, and its
- * words on the board page. Its calls are not the chat's: the doorbell still wakes the chat for the player's move. Offered to Claude Code alone, which runs the agent.
+ * words on the board page. Its calls are not the chat's: the doorbell still wakes the chat for the player's move. Offered to the hosts that run the agent (D-98).
  */
 export const ponder = defineCommand({
     name: "ponder",
@@ -28,7 +28,7 @@ export const ponder = defineCommand({
         done: z.boolean().optional().describe("true when you have no more replies to think on: it waits for the player's move"),
     }),
     byAgents: ponderAgents,
-    host: "claude-code",
+    hosts: agentHosts,
     run: async ({ position, reply, move, why, say, done = false }, context) => {
         const folder = gameFolder(context.home());
         const current = toPonder(folder, context.now(), position);
@@ -39,7 +39,7 @@ export const ponder = defineCommand({
             if (reply !== undefined || move !== undefined || why !== undefined || say !== undefined || done) {
                 throw new Error("Give the position's number with it: call ponder {} first, which gives it. Nothing changed.");
             }
-            context.ponders?.({ started: current.started, plies: current.game.record.moves.length });
+            notePondering(folder, thoughtKey(current), true);
             return { start: startOf(current) };
         }
         if ((say !== undefined || done) && (reply !== undefined || move !== undefined || why !== undefined || (say !== undefined && done))) {
@@ -50,7 +50,7 @@ export const ponder = defineCommand({
             return { said: position };
         }
         if (done) {
-            context.ponders?.(undefined);
+            notePondering(folder, thoughtKey(current), false);
             return await waitForMove(folder, context, current);
         }
         if (reply === undefined) {
@@ -106,14 +106,15 @@ export const ponder = defineCommand({
 export async function waitForPlayer(context, since, gone) {
     const pause = context.pause ?? ((milliseconds) => new Promise((done) => setTimeout(done, milliseconds)));
     const start = context.now().getTime();
-    const end = Math.min(start + playerWait.most, since.getTime() + playerWait.inAll);
+    const most = isCodex(context.host?.()) ? playerWait.mostInCodex : playerWait.most;
+    const end = Math.min(start + most, since.getTime() + playerWait.inAll);
     while (context.now().getTime() < end) {
         await pause(playerWait.every);
         if (gone()) {
             return "moved";
         }
     }
-    return end < start + playerWait.most ? "waited" : "waiting";
+    return end < start + most ? "waited" : "waiting";
 }
 /** The words of the AI's move for the player: its comment without the plan, the mood, the clock and the draw offer it carries. */
 export function wordsOf(comment) {
@@ -122,9 +123,10 @@ export function wordsOf(comment) {
 }
 /**
  * How long one call waits for the player's move at most, under the minute a host may give a tool (Priya), how often it looks, and how long the agent
- * waits in all before it stops: a player who leaves the game open must not keep it asking (Priya).
+ * waits in all before it stops: a player who leaves the game open must not keep it asking (Priya). Codex hands its agent's code back to the model after 30
+ * seconds: a call shorter than that is one turn of the model, not several (Priya).
  */
-const playerWait = { most: 50_000, every: 500, inAll: 10 * 60_000 };
+const playerWait = { most: 50_000, mostInCodex: 25_000, every: 500, inAll: 10 * 60_000 };
 /** The game whose position the AI thinks on, read and never written: none once the player has moved, the game is over or their flag has fallen, or the position given is another. */
 function toPonder(folder, now, position) {
     const current = loadGame(folder);

package/dist/commands/registry.d.ts

@@ -23,8 +23,8 @@ export interface Command<Schema extends z.ZodObject = z.ZodObject, Result = unkn
     byAgents?: readonly string[];
     /** The agents that call it besides the chat, as the analyst analyse_game (D-89): their calls leave the doorbell's record of what the chat has read as it was. */
     sharedWith?: readonly string[];
-    /** The only host the MCP server offers it to, by the client's name, as ponder to Claude Code: elsewhere its description would cost tokens for nothing. */
-    host?: string;
+    /** The only hosts the MCP server offers it to, by the client's name, as ponder to those that run agents: elsewhere its description would cost tokens for nothing. */
+    hosts?: readonly string[];
     /** Only the command line has it, as init: the MCP server leaves it out, and its description costs the AI no tokens. */
     cliOnly?: boolean;
     /** Fields the command line takes as positional arguments, in order. */

package/dist/core/facts.d.ts

@@ -23,6 +23,18 @@ export interface Pin {
     readonly by: Square;
     readonly to: Square;
 }
+/**
+ * A king, queen or rook attacked by a bishop, rook or queen with a piece of its side worth less behind it on the line, when the front piece must move (it
+ * is the king, the attacker is worth less, or it is undefended) and the attacker is worth less than the piece behind or that piece is undefended without
+ * counting the front piece (Anatolij).
+ */
+export interface Skewer {
+    /** The piece in front, attacked. */
+    readonly square: Square;
+    readonly by: Square;
+    /** The piece behind it. */
+    readonly to: Square;
+}
 /** The facts of a position: data for the AI and the page, never a judgment (D-19). */
 export interface Facts {
     /** Every piece, White's first, each side's from the king down: K Q R B N P. */
@@ -38,6 +50,7 @@ export interface Facts {
     /** Pieces neither attacked nor defended, kings left out: the first targets of a tactic. */
     readonly loose: readonly Square[];
     readonly pins: readonly Pin[];
+    readonly skewers: readonly Skewer[];
     /** The checks of the side to move, in SAN. */
     readonly checks: readonly string[];
     /** The checks the other side would have if it were to move; left out when the side to move is in check, since it could not be. */

package/dist/core/facts.js

@@ -1,4 +1,4 @@
-// What a position shows, computed without judging it (D-19, D-26): who attacks and defends each piece, what is at risk, the pins, the checks, the moves of each piece.
+// What a position shows, computed without judging it (D-19, D-26): who attacks and defends each piece, what is at risk, the pins and skewers, the checks, the moves of each piece.
 import { Chess } from "chess.js";
 /** The facts of a chess.js board, whose legal moves are given: computed once for each position, by its key, and frozen. */
 export function factsOf(chess, legal) {
@@ -51,6 +51,7 @@ function computed(chess, legal) {
     const defended = atRisk.filter((piece) => piece.defenders.length > 0);
     const byCheaper = defended.filter((piece) => Math.min(...piece.attackers.map(valueAt)) < valueAt(piece.square));
     const relativePins = placed.filter((piece) => piece.type === "q" || piece.type === "r").flatMap((target) => pinsTo(chess, target).filter((pin) => valueAt(pin.by) < values[target.type] || factsAt.get(target.square)?.defenders.length === 0));
+    const skewers = placed.filter((piece) => piece.type === "k" || piece.type === "q" || piece.type === "r").flatMap((front) => skewersOf(chess, front, factsAt));
     const king = pieces.find((piece) => piece.piece === "K" && piece.side === sideOf(turn));
     const facts = {
         pieces,
@@ -60,6 +61,7 @@ function computed(chess, legal) {
         outnumbered: defended.filter((piece) => !byCheaper.includes(piece) && piece.attackers.length > piece.defenders.length).map((piece) => piece.square),
         loose: officers.filter((piece) => piece.attackers.length === 0 && piece.defenders.length === 0).map((piece) => piece.square),
         pins: [...kingPins, ...relativePins].sort((left, right) => compare(left.square, right.square)),
+        skewers: skewers.sort((left, right) => compare(left.square, right.square)),
         checks: legal.filter((move) => /[+#]$/.test(move.san)).map((move) => move.san),
     };
     return chess.inCheck() ? facts : { ...facts, otherChecks: otherChecks(chess) };
@@ -128,6 +130,30 @@ function pinsTo(chess, target) {
     }
     return pins;
 }
+/**
+ * The skewers of a king, queen or rook: a rook, bishop or queen that attacks it as the facts count, and a piece of its side worth less right behind it.
+ * The piece behind is counted without the front one among its defenders: the front piece leaves the line when it moves (Anatolij).
+ */
+function skewersOf(chess, front, factsAt) {
+    const skewers = [];
+    const facts = factsAt.get(front.square);
+    for (const [fileStep, rankStep, slider] of lines) {
+        const by = rayFrom(front.square, fileStep, rankStep).find((square) => chess.get(square) !== undefined);
+        const to = rayFrom(front.square, -fileStep, -rankStep).find((square) => chess.get(square) !== undefined);
+        const attacker = by === undefined ? undefined : chess.get(by);
+        const behind = to === undefined ? undefined : chess.get(to);
+        if (attacker === undefined || behind === undefined || attacker.color === front.color || behind.color !== front.color
+            || (attacker.type !== slider && attacker.type !== "q") || values[behind.type] >= values[front.type] || !facts.attackers.includes(by)) {
+            continue;
+        }
+        const mustMove = front.type === "k" || values[attacker.type] < values[front.type] || facts.defenders.length === 0;
+        const behindDefended = factsAt.get(to).defenders.some((square) => square !== front.square);
+        if (mustMove && (values[attacker.type] < values[behind.type] || !behindDefended)) {
+            skewers.push({ square: front.square, by: by, to: to });
+        }
+    }
+    return skewers;
+}
 /** The pawn that can be taken en passant, and the square a pawn takes it on; none without an en passant square. */
 function enPassantVictim(chess) {
     const to = chess.fen().split(" ")[3];

package/dist/core/index.d.ts

@@ -1,7 +1,7 @@
 export { boardText, figurinesOf } from "./board-text.ts";
 export { canMate, clockAfterMove, clockOfComment, clockStarted, clockTag, clockText, startClock, timeControlOf, timeControlOfTag, timeControlTag, timeControlText, timeLeft } from "./clock.ts";
 export type { Clock, TimeControl } from "./clock.ts";
-export type { Facts, PieceFacts, PieceLetter, Pin } from "./facts.ts";
+export type { Facts, PieceFacts, PieceLetter, Pin, Skewer } from "./facts.ts";
 export { Game, withSanLetters } from "./game.ts";
 export type { Ending, Move, Outcome, Played, Position, Promotion, Refusal, Side, Square } from "./game.ts";
 export type { Illegal, IllegalReason } from "./illegal.ts";

package/dist/games/index.d.ts

@@ -8,4 +8,4 @@ export { makeFolder, renameOver, writeAtomically } from "./files.ts";
 export { commentWithPlan, currentPlan, planOf, withoutPlans } from "./plans.ts";
 export { endTableTalk, loadTableTalk, saveTableTalk, type TableTalk } from "./table-talk.ts";
 export { type Heard, heardLines, type Sayer, type Talk, talkLimits, talkLine, unheardWords, wakesTheChat, type Words, WordsRefused } from "./talk.ts";
-export { keepThought, type Thought, thoughtForLastMove, thoughtKey, waitingSince } from "./thoughts.ts";
+export { keepThought, notePondering, ponderingOn, type Thought, thoughtForLastMove, thoughtKey, waitingSince } from "./thoughts.ts";

package/dist/games/index.js

@@ -9,4 +9,4 @@ export { makeFolder, renameOver, writeAtomically } from "./files.js";
 export { commentWithPlan, currentPlan, planOf, withoutPlans } from "./plans.js";
 export { endTableTalk, loadTableTalk, saveTableTalk } from "./table-talk.js";
 export { heardLines, talkLimits, talkLine, unheardWords, wakesTheChat, WordsRefused } from "./talk.js";
-export { keepThought, thoughtForLastMove, thoughtKey, waitingSince } from "./thoughts.js";
+export { keepThought, notePondering, ponderingOn, thoughtForLastMove, thoughtKey, waitingSince } from "./thoughts.js";

package/dist/games/thoughts.d.ts

@@ -13,3 +13,10 @@ export declare function keepThought(folder: string, key: string, thought: Though
 export declare function thoughtForLastMove(folder: string, current: CurrentGame): Thought | undefined;
 /** Since when the AI has waited for the player's move in a position: the first time it asked, `now` then, kept with its thoughts. */
 export declare function waitingSince(folder: string, key: string, now: Date): Date;
+/**
+ * Notes whether the AI thinks on the player's time in a position now, from its first look until it waits for their move, for the page's sign: in the file,
+ * since in Codex the agent that thinks has a process of its own (D-98).
+ */
+export declare function notePondering(folder: string, key: string, pondering: boolean): void;
+/** Whether the AI thinks on the player's time in a position now, as noted. */
+export declare function ponderingOn(folder: string, key: string): boolean;

package/dist/games/thoughts.js

@@ -33,6 +33,21 @@ export function waitingSince(folder, key, now) {
     write(folder, { ...kept, since: now.toISOString() });
     return now;
 }
+/**
+ * Notes whether the AI thinks on the player's time in a position now, from its first look until it waits for their move, for the page's sign: in the file,
+ * since in Codex the agent that thinks has a process of its own (D-98).
+ */
+export function notePondering(folder, key, pondering) {
+    const { pondering: before, ...kept } = keptAt(folder, key);
+    if ((before === true) !== pondering) {
+        write(folder, pondering ? { ...kept, pondering: true } : kept);
+    }
+}
+/** Whether the AI thinks on the player's time in a position now, as noted. */
+export function ponderingOn(folder, key) {
+    const kept = read(folder);
+    return kept?.key === key && kept.pondering === true;
+}
 /** The most thoughts kept for a position: a few likely replies, not every legal one. */
 const mostThoughts = 8;
 const fileName = "thoughts.json";
@@ -40,6 +55,7 @@ const thoughtsFile = z.object({
     key: z.string(),
     thoughts: z.array(z.object({ reply: z.string(), move: z.string(), why: z.string() })),
     since: z.iso.datetime().optional(),
+    pondering: z.boolean().optional(),
 });
 /** What is kept for a position: nothing yet when the file is for another, or missing. */
 function keptAt(folder, key) {

package/dist/host-files/agents.d.ts

@@ -1,4 +1,8 @@
 import type { AiLevel } from "../core/index.ts";
+/** The hosts whose chat starts Chesspal's agents, by the names they give the server (D-98). */
+export declare const agentHosts: readonly string[];
+/** Whether the host is Codex, which runs each agent in a process of its own and gives it every tool (D-98). */
+export declare function isCodex(host: string | undefined): boolean;
 /** The agents that think for the AI, by their names. */
 export declare const ponderAgents: readonly string[];
 /** The coach's agent (D-88). */
@@ -9,9 +13,11 @@ export declare const analystAgent = "chesspal-analyst";
 export declare function ponderAgentFor(level: AiLevel): string;
 /** Whether the AI's thoughts on the player's time come from a quicker model than its own at a level. */
 export declare function onQuickModel(level: AiLevel): boolean;
-/** Whether the player's folder has the agent, as init writes it: a folder set up before it has none, and the AI then plays as before. */
-export declare function hasAgent(folder: string, agent: string): boolean;
-/** The agents' files, as Claude Code reads them from .claude/agents: Chesspal's whole, rewritten by init. */
+/** Whether the player's folder has the agent for the host, as init writes it: a folder set up before it has none, and the AI then plays as before. */
+export declare function hasAgent(folder: string, agent: string, host: string | undefined): boolean;
+/** The tools of one of Chesspal's agents, by its name; undefined for another agent. Codex gives its agents every tool, so the server keeps them to theirs (D-98). */
+export declare function agentTools(agent: string): readonly string[] | undefined;
+/** The agents' files, as Claude Code reads them from .claude/agents and Codex from .codex/agents: Chesspal's whole, rewritten by init, for both hosts. */
 export declare function agentFiles(folder: string): {
     path: string;
     text: string;

package/dist/host-files/agents.js

@@ -1,9 +1,16 @@
-// The agents that work in the background in Claude Code: those that think for the opponent on the player's time (D-72), one on the host's quick model for the
-// lower levels, one on the AI's own for the higher; the coach, with the helps on (D-88), and the analyst of a game over (D-89), on the AI's own model.
+// The agents that work in the background in Claude Code and Codex (D-98): those that think for the opponent on the player's time (D-72), one on the host's
+// quick model for the lower levels, one on the AI's own for the higher; the coach, with the helps on (D-88), and the analyst of a game over (D-89), on the AI's own.
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 const quickAgent = "chesspal-ponder-quick";
 const ownAgent = "chesspal-ponder";
+const codexHost = "codex-mcp-client";
+/** The hosts whose chat starts Chesspal's agents, by the names they give the server (D-98). */
+export const agentHosts = ["claude-code", codexHost];
+/** Whether the host is Codex, which runs each agent in a process of its own and gives it every tool (D-98). */
+export function isCodex(host) {
+    return host === codexHost;
+}
 /** The agents that think for the AI, by their names. */
 export const ponderAgents = [quickAgent, ownAgent];
 /** The coach's agent (D-88). */
@@ -18,36 +25,74 @@ export function ponderAgentFor(level) {
 export function onQuickModel(level) {
     return level === "beginner" || level === "club";
 }
-/** Whether the player's folder has the agent, as init writes it: a folder set up before it has none, and the AI then plays as before. */
-export function hasAgent(folder, agent) {
-    return existsSync(agentPath(folder, agent));
+/** Whether the player's folder has the agent for the host, as init writes it: a folder set up before it has none, and the AI then plays as before. */
+export function hasAgent(folder, agent, host) {
+    return existsSync(isCodex(host) ? codexAgentPath(folder, agent) : claudeAgentPath(folder, agent));
+}
+/** The tools of one of Chesspal's agents, by its name; undefined for another agent. Codex gives its agents every tool, so the server keeps them to theirs (D-98). */
+export function agentTools(agent) {
+    return toolsOf[agent];
 }
-/** The agents' files, as Claude Code reads them from .claude/agents: Chesspal's whole, rewritten by init. */
+/** The agents' files, as Claude Code reads them from .claude/agents and Codex from .codex/agents: Chesspal's whole, rewritten by init, for both hosts. */
 export function agentFiles(folder) {
+    const agents = agentSpecs();
+    return [...agents.map((agent) => claudeAgentFile(folder, agent)), ...agents.map((agent) => codexAgentFile(folder, agent))];
+}
+/** Instructions for the AI, by their file's name in the package's instructions folder. */
+export function instructions(name) {
+    return readFileSync(new URL(`../../instructions/${name}.md`, import.meta.url), "utf8").trim();
+}
+const toolsOf = {
+    [quickAgent]: ["ponder"],
+    [ownAgent]: ["ponder"],
+    [coachAgent]: ["coach"],
+    [analystAgent]: ["analyse_game", "annotate_game", "look", "position"],
+};
+// Codex's quick model for the lower levels: written in its agent, since Codex ignores a model the chat names when it starts one that has it (Priya).
+const codexQuickModel = "gpt-6-luna";
+function agentSpecs() {
     const ponder = instructions("ponder");
     const thinking = "Chesspal's opponent thinking on the player's time. Started by the AI in the background after its move, as ai_move says.";
     return [
-        { agent: quickAgent, model: "haiku", description: thinking, tools: ["ponder"], text: ponder },
-        { agent: ownAgent, model: "inherit", description: thinking, tools: ["ponder"], text: ponder },
+        { agent: quickAgent, claudeModel: "haiku", codexModel: codexQuickModel, description: thinking, text: ponder },
+        { agent: ownAgent, claudeModel: "inherit", description: thinking, text: ponder },
         // Its description tells the chat it starts the agent only as ai_move says, never to ask it about the game (Priya).
-        { agent: coachAgent, model: "inherit", description: "Chesspal's coach. Started only as Chesspal's answers say, in the background, never to answer the player.", tools: ["coach"], text: instructions("coach") },
+        {
+            agent: coachAgent,
+            claudeModel: "inherit",
+            description: "Chesspal's coach. Started only as Chesspal's answers say, in the background, never to answer the player.",
+            text: instructions("coach"),
+        },
         {
             agent: analystAgent,
-            model: "inherit",
+            claudeModel: "inherit",
             description: "Chesspal's analyst. Started only as Chesspal's answers say, in the background, to review a game over on the board page; never to answer the player.",
-            tools: ["analyse_game", "annotate_game", "look", "position"],
             text: `${instructions("analyst-agent")}\n${instructions("analysis")}`,
         },
-    ].map(({ agent, model, description, tools, text }) => ({
-        path: agentPath(folder, agent),
-        // The tools it works with: Claude Code gives an agent its MCP tools loaded, with no search first (Priya).
-        text: ["---", `name: ${agent}`, `description: ${description}`, `tools: ${tools.map((tool) => `mcp__chesspal__${tool}`).join(", ")}`, `model: ${model}`, "---", "", text, ""].join("\n"),
-    }));
+    ];
 }
-/** Instructions for the AI, by their file's name in the package's instructions folder. */
-export function instructions(name) {
-    return readFileSync(new URL(`../../instructions/${name}.md`, import.meta.url), "utf8").trim();
+function claudeAgentFile(folder, { agent, claudeModel, description, text }) {
+    // The tools it works with: Claude Code gives an agent its MCP tools loaded, with no search first (Priya).
+    const tooled = `tools: ${(toolsOf[agent] ?? []).map((tool) => `mcp__chesspal__${tool}`).join(", ")}`;
+    return { path: claudeAgentPath(folder, agent), text: ["---", `name: ${agent}`, `description: ${description}`, tooled, `model: ${claudeModel}`, "---", "", text, ""].join("\n") };
+}
+/**
+ * Codex's agent: its instructions in a literal string; no effort, which the chat could no longer change, and no model but the quick one's, so that the
+ * others play on the AI's own (Priya). Codex gives an agent all the chat's MCP servers: its instructions name its own tools.
+ */
+function codexAgentFile(folder, { agent, codexModel, description, text }) {
+    if (text.includes("'''")) {
+        throw new Error(`The instructions of ${agent} hold ''', which would end Codex's literal string early: write them another way.`);
+    }
+    const model = codexModel === undefined ? [] : [`model = ${JSON.stringify(codexModel)}`];
+    // Its tools by the names Codex gives them, which spare the agent a search for them first (Priya).
+    const tools = (toolsOf[agent] ?? []).map((tool) => `tools.mcp__chesspal__${tool}`).join(", ");
+    const lines = [`name = ${JSON.stringify(agent)}`, `description = ${JSON.stringify(description)}`, ...model, "developer_instructions = '''", text, "", `Your tools: ${tools}.`, "'''", ""];
+    return { path: codexAgentPath(folder, agent), text: lines.join("\n") };
 }
-function agentPath(folder, agent) {
+function claudeAgentPath(folder, agent) {
     return join(folder, ".claude", "agents", `${agent}.md`);
 }
+function codexAgentPath(folder, agent) {
+    return join(folder, ".codex", "agents", `${agent}.toml`);
+}

package/dist/host-files/host-files.js

@@ -41,15 +41,15 @@ const endMark = "<!-- chesspal: end -->";
 const markedBlock = /<!-- chesspal: (?!end)[^\n]*\n[\s\S]*?<!-- chesspal: end -->/;
 /** What init writes for each host, missing or changed: what the player wrote there stays. */
 function hostChanges(folder, platform) {
-    const changes = [mcpFile(folder, platform), agentsFile(folder), claudeFile(folder), claudeSettingsFile(folder), ...ponderAgentChanges(folder), codexConfigFile(folder, platform), codexHooksFile(folder)];
+    const changes = [mcpFile(folder, platform), agentsFile(folder), claudeFile(folder), claudeSettingsFile(folder), ...agentChanges(folder), codexConfigFile(folder, platform), codexHooksFile(folder)];
     return changes.filter((change) => change !== undefined);
 }
 /** How a host starts the server: on Windows through cmd, which finds npm's shim. */
 function chesspalServer(platform) {
     return platform === "win32" ? { command: "cmd", args: ["/c", "chesspal", "mcp"] } : { command: "chesspal", args: ["mcp"] };
 }
-/** Claude Code's agents that work on the player's time, thinking for the opponent and coaching, Chesspal's whole: written when they are missing or changed. */
-function ponderAgentChanges(folder) {
+/** The agents of Claude Code and Codex, Chesspal's whole, whichever host the player has (Stefano): written when they are missing or changed. */
+function agentChanges(folder) {
     return agentFiles(folder).filter(({ path, text }) => textOf(path) !== text);
 }
 /** .mcp.json with the chesspal server, beside the servers already there, keeping the environment the player gave it, as CHESSPAL_HOME in a playtest. */

package/dist/host-files/index.d.ts

@@ -1,2 +1,2 @@
-export { analystAgent, coachAgent, hasAgent, instructions, onQuickModel, ponderAgentFor, ponderAgents } from "./agents.ts";
+export { agentHosts, agentTools, analystAgent, coachAgent, hasAgent, instructions, isCodex, onQuickModel, ponderAgentFor, ponderAgents } from "./agents.ts";
 export { codexHooksPath, opponentInstructions, outdatedHostFiles, setUpHosts } from "./host-files.ts";

package/dist/host-files/index.js

@@ -1,3 +1,3 @@
 // The files through which an AI host finds Chesspal in the player's folder: the server, the opponent's instructions, the hosts' settings.
-export { analystAgent, coachAgent, hasAgent, instructions, onQuickModel, ponderAgentFor, ponderAgents } from "./agents.js";
+export { agentHosts, agentTools, analystAgent, coachAgent, hasAgent, instructions, isCodex, onQuickModel, ponderAgentFor, ponderAgents } from "./agents.js";
 export { codexHooksPath, opponentInstructions, outdatedHostFiles, setUpHosts } from "./host-files.js";

package/dist/page/board/board.js

@@ -3,10 +3,10 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "preact/jsx-ru
 // with two clicks or by dragging a piece, which lifts off the board, in Zoe's design.
 import { useMemo, useRef } from "preact/hooks";
 import { BadgeIcon } from "../game/badges.js";
-import { riskOn } from "../helps/view.js";
+import { pinOn, riskOn, skewerOn } from "../helps/view.js";
 import { Piece } from "../pieces/pieces.js";
 import { bubblePlace, keptSquares } from "./explain.js";
-import { Arrows, Badge, Bubble, ControlCount, controlOf, kingSigns, Lifted, noSigns, Notch, Pins, PromotionChoice } from "./marks.js";
+import { Arrows, Badge, Bubble, ControlCount, controlOf, kingSigns, Lifted, noSigns, Notch, PinsAndSkewers, PromotionChoice, Pushpin, Skewer } from "./marks.js";
 import { backOf, motionOf, noMotion, playedOn, rearranged } from "./motion.js";
 import { useBoardPointer } from "./pointer.js";
 import { files, kingToMove, piecesOf } from "./squares.js";
@@ -104,12 +104,17 @@ export function Board({ fen, bottom, lastMove, pointed, helps, control, bare, ba
                             "--dy": ranks.indexOf(Number(from[1])) - row,
                         };
                         const risk = signsOfHelps === undefined ? undefined : riskOn(signsOfHelps, square);
+                        // A pinned piece's pushpin and a skewered one's skewer go with their lines, so not over the control map.
+                        const pin = signsOfHelps === undefined || control !== undefined ? undefined : pinOn(signsOfHelps, square);
+                        const skewer = signsOfHelps === undefined || control !== undefined ? undefined : skewerOn(signsOfHelps, square);
                         return (_jsxs("div", { class: classes, role: "button", "aria-label": label, "aria-pressed": own(square) ? selected === square : undefined, tabIndex: square === focused ? 0 : -1, "data-square": square, onKeyDown: (event) => key(event, square), onFocus: () => setCursor(square), 
                             // A click with no pointer behind it, as a screen reader's in browse mode, presses the square as Enter does.
                             onClick: (event) => event.detail === 0 && pressKey(square), style: away, children: [column === 0 ? _jsx("span", { class: "coordinate rank", children: rank }) : null, row === 7 ? _jsx("span", { class: "coordinate file", children: file }) : null, _jsx("span", { class: "square-name", "aria-hidden": "true", children: square }), motion.taken?.square === square
                                     ? (_jsx("span", { class: "taken-piece", children: _jsx(Piece, { letter: motion.taken.letter }) }, `taken ${fen}`))
-                                    : null, motion.gone?.filter((gone) => gone.square === square).map((gone) => (_jsx("span", { class: "gone-piece", children: _jsx(Piece, { letter: gone.letter }) }, `gone ${fen}`))), control === undefined ? null : _jsx("span", { class: `control-ground ${controlOf(control[square])}`, "aria-hidden": "true" }), piece === undefined ? null : _jsx(Piece, { letter: piece }, moving ? fen : "still"), sign === undefined ? null : _jsx(Badge, { kind: sign.badge }), risk === undefined ? null : _jsx(Notch, { tone: risk }), control === undefined ? null : _jsx(ControlCount, { counts: control[square] }), badge === undefined || lastMove?.to !== square ? null : _jsx(BadgeIcon, { badge: badge.badge, title: badge.name })] }, square));
-                    })), signsOfHelps === undefined || signsOfHelps.pins.length === 0 || control !== undefined ? null : _jsx(Pins, { pins: signsOfHelps.pins, at: centreOf })] }), _jsx(Arrows, { arrows: aiArrows, at: centreOf, occupied: (square) => pieces.has(square) }), _jsx(Arrows, { arrows: ownArrows, at: centreOf }), notice?.explanation?.arrow === undefined ? null : _jsx(Arrows, { arrows: [notice.explanation.arrow], at: centreOf, explain: { occupied: pieces.has(notice.explanation.arrow.to) } }), drag === undefined || !pieces.has(drag.from) ? null : _jsx(Lifted, { drag: drag, letter: pieces.get(drag.from) }), promotion === undefined
+                                    : null, motion.gone?.filter((gone) => gone.square === square).map((gone) => (_jsx("span", { class: "gone-piece", children: _jsx(Piece, { letter: gone.letter }) }, `gone ${fen}`))), control === undefined ? null : _jsx("span", { class: `control-ground ${controlOf(control[square])}`, "aria-hidden": "true" }), piece === undefined ? null : _jsx(Piece, { letter: piece }, moving ? fen : "still"), sign === undefined ? null : _jsx(Badge, { kind: sign.badge }), risk === undefined ? null : _jsx(Notch, { tone: risk }), pin === undefined ? null : _jsx(Pushpin, { tone: pin }), skewer === undefined ? null : _jsx(Skewer, { tone: skewer }), control === undefined ? null : _jsx(ControlCount, { counts: control[square] }), badge === undefined || lastMove?.to !== square ? null : _jsx(BadgeIcon, { badge: badge.badge, title: badge.name })] }, square));
+                    })), signsOfHelps === undefined || signsOfHelps.pins.length + signsOfHelps.skewers.length === 0 || control !== undefined
+                        ? null
+                        : _jsx(PinsAndSkewers, { pins: signsOfHelps.pins, skewers: signsOfHelps.skewers, at: centreOf })] }), _jsx(Arrows, { arrows: aiArrows, at: centreOf, occupied: (square) => pieces.has(square) }), _jsx(Arrows, { arrows: ownArrows, at: centreOf }), notice?.explanation?.arrow === undefined ? null : _jsx(Arrows, { arrows: [notice.explanation.arrow], at: centreOf, explain: { occupied: pieces.has(notice.explanation.arrow.to) } }), drag === undefined || !pieces.has(drag.from) ? null : _jsx(Lifted, { drag: drag, letter: pieces.get(drag.from) }), promotion === undefined
                 ? null
                 : _jsx(PromotionChoice, { side: promotion.side, column: columns.indexOf(promotion.to[0]), down: ranks[0] === Number(promotion.to[1]), onPick: promote, text: text }), notice === undefined ? null : (_jsx(Bubble, { notice: notice, place: notice.square === undefined ? undefined : seen(notice.square), where: notice.square === undefined
                     ? "above"