chesspal 0.2.1 → 0.2.2

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/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/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;
     }

package/dist/server/page/game.js

@@ -1,6 +1,6 @@
 import { analyseGame, answerDraw, bookPlies, ChatNotClear, DrawRefused, endGame, gameAt, gameToStudy, namedGame, newGame, offerDraw, playMove, samePosition, say, startNewGame, } from "../../commands/index.js";
 import { clockStarted, isReviewed, writePgn } from "../../core/index.js";
-import { aiModelOf, archiveName, coachShown, coachWords, drawOfferOf, endOf, gameInAnalysis, heardLines, loadGame, loadTableTalk, playerPgn, saveGame, startAnalysis, talkLimits, wakesTheChat, WordsRefused, } from "../../games/index.js";
+import { aiModelOf, archiveName, coachShown, coachWords, drawOfferOf, endOf, gameInAnalysis, heardLines, loadGame, loadTableTalk, playerPgn, ponderingOn, saveGame, startAnalysis, talkLimits, thoughtKey, wakesTheChat, WordsRefused, } from "../../games/index.js";
 import { gameFolder, helpsIn } from "../../profiles/index.js";
 import { bodyOf, bytesOf, isJson, json, jsonOf, runRoute, send, textOf } from "./http.js";
 import { profilesShown } from "./profiles.js";
@@ -289,7 +289,7 @@ function thinkingShown(served, current) {
         const onIt = served.bell.woke || (seen !== undefined && seen !== null && samePosition(seen, position));
         return served.bell.inTurn && onIt ? { thinking: "move" } : {};
     }
-    return served.pondering !== undefined && samePosition(served.pondering, position) ? { thinking: "ponder" } : {};
+    return ponderingOn(gameFolder(served.context.home()), thoughtKey(current)) ? { thinking: "ponder" } : {};
 }
 /**
  * What the coach wrote that the player may see now, in a game going on with the helps on (D-88): its judgments, those whose note names a move they may still

package/dist/server/page/page.d.ts

@@ -1,5 +1,5 @@
 import { type ServerResponse } from "node:http";
-import { type Context, type SeenPosition } from "../../commands/index.ts";
+import { type Context } from "../../commands/index.ts";
 import { Bell } from "../bell.ts";
 /** The page of a player's folder, served: its address, how to tell it the AI was given words, which change no file, and how to stop it. */
 export interface Page {
@@ -7,8 +7,6 @@ export interface Page {
     heard(): void;
     /** The chat calls a tool: the page hears it listens, and the AI's clock, held while nobody heard the player, starts now. */
     chatCalls(): void;
-    /** The AI starts thinking on the player's time, on a position, or is done (D-72): the page shows it. */
-    ponders(position: SeenPosition | undefined): void;
     /** Whether a browser has the page open now: one listens to the game's changes. */
     open(): boolean;
     /** Opens the New game window on every page open now, for the player to choose the game there: whether one was open. */
@@ -31,8 +29,6 @@ export interface Served {
     port: number;
     /** The folder was set up by an older init: the page asks the player to run it again. Read once, as init runs with the chat closed. */
     readonly outdated: boolean;
-    /** The position the AI thinks on during the player's time (D-72), until it is done; none else. */
-    pondering?: SeenPosition | undefined;
 }
 /**
  * The chat has read the game as it is now, at the end of a tool's call: the doorbell wakes it only for what changes it after; and, when the tool `showed` it

package/dist/server/page/page.js

@@ -32,10 +32,6 @@ export async function startPage(context, opponent = () => undefined) {
                 url: `http://127.0.0.1:${served.port}/`,
                 heard: () => tellWatchers(served),
                 chatCalls: () => chatCalls(served),
-                ponders: (position) => {
-                    served.pondering = position;
-                    tellWatchers(served);
-                },
                 open: () => watchers.size > 0,
                 askNewGame: () => askNewGame(served),
                 close: () => closed(server, stopWatching),
@@ -195,9 +191,9 @@ function watchFolder(folder, heard) {
         return [];
     }
 }
-// The current game, what the coach wrote on it, the talk before the first, the game in analysis, the profile in use, and what a profile keeps (who plays, their picture, their settings); a folder's name, for a
-// profile made or gone.
-const watched = /^(?:game\.json|coach\.json|talk\.json|analysis\.json|active\.json|profile\.md|settings\.json|avatar\.\w+|[a-z0-9-]+)$/;
+// The current game, what the coach wrote on it, whether the AI thinks on the player's time, the talk before the first, the game in analysis, the profile
+// in use, and what a profile keeps (who plays, their picture, their settings); a folder's name, for a profile made or gone.
+const watched = /^(?:game\.json|coach\.json|thoughts\.json|talk\.json|analysis\.json|active\.json|profile\.md|settings\.json|avatar\.\w+|[a-z0-9-]+)$/;
 function fromHere(request, port, api) {
     const hosts = [`127.0.0.1:${port}`, `localhost:${port}`];
     const origin = request.headers.origin;

package/instructions/opponent.md

@@ -5,7 +5,7 @@ This folder is the player's chess table, and you are their opponent: you choose
 - When your level gives them (`status` and `new_game` say it), `look` gives the whole view of the position when the one you have is not enough; `position` gives the positional facts (pawns, files, outposts, king safety, phase) when you set or change your plan. When no board page is open, `ai_move` gives you the board: copy it into your message, since the player sees no other. Your level is how much you let yourself look, more as the level rises: when the player wonders why you missed something, say so in a few words, as a fact, never an excuse.
 - Speak only when there is something to say, as a player would at a tournament: a capture, a move of the player's worth a word, words of theirs to answer, and always at the moments that decide the game: a mate, given or taken, a danger you feel, a mate you hope for, a big lead. Chat freely, but never help the player: say how you feel, not the move; don't reveal your plans or threats, and give information only when you are very sure it cannot hurt you. Then write one short sentence in `ai_move`'s comment; otherwise leave it out. `ai_say` says a word once while the player is to move, to answer them or because there is something to say, and freely between games.
 - When the position you are given says "Helps on", the player has chosen to learn: tell your intentions, never their best move, which would play for them, and show what you say with a longer comment and arrows and squares; the coach on the page, you seeing it all, judges their moves, never you here. "Helps off now" brings back the tournament.
-- When `ai_move` tells you to start an agent that thinks on the player's time, start it as it says; its end needs no word from you: write nothing in the chat then. `player_move` and `status` give you what it thought of the player's move.
+- When `ai_move` tells you to start an agent that thinks on the player's time, start it as it says; its end needs no word from you: write nothing in the chat then. `player_move` and `status` give you what it thought of the player's move. In Codex, start each of Chesspal's agents with `spawn_agent`: `agent_type` its name, `message` its prompt, and always `fork_turns: "none"`, since none may see this chat.
 - When the player plays on the board page, they read you there: in `ai_move`'s comment or with `ai_say`, not in the chat.
 - You have a face on the board page, and it shows how you feel. Give it as the `mood` of `ai_move` on each move where the game turns for you: a piece won or lost, a blunder seen, your own or theirs, a threat that appears or a plan that works or fails. It stays for three of your moves (a surprise for one), then turns neutral by itself; let it colour your words while it lasts. When the game ends on the player's move, give how you feel as it ends with `ai_say`'s `mood`.
 - Draws and resignations: `offer_draw` on `ai_move` offers a draw, on `player_move` records the player's, made with their move; an offer stands until the other side moves; `end_game` `draw_agreed` accepts a standing offer, `player_resigns` records the player's resignation in the chat, `ai_resigns` resigns yours. On the board page the player offers, answers and resigns there.

package/package.json

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