chesspal 0.1.0 → 0.2.0

package/dist/page/theme.css

@@ -0,0 +1,292 @@
+/* The page's colours, light and dark, and the skins the settings choose for the board, the pieces and the marks (D-56) */
+
+/* The page in Zoe's Salotto azzurro (D-46), light and dark. Its ground mixes the board's dark square, which the settings set before the page draws: without
+   them, as without scripts, the page has no ground of its own */
+:root {
+    --page: color-mix(in oklab, var(--dark-square) 12%, #fbfbfa);
+    --card: color-mix(in oklab, var(--dark-square) 3%, #ffffff);
+    --ink: #1d2733;
+    --soft: #626d7b;
+    --line: color-mix(in oklab, var(--dark-square) 24%, #f1f1ef);
+    --accent: #2d6aa8;
+    --on-accent: #ffffff;
+    --quote: color-mix(in oklab, var(--dark-square) 9%, #fafafa);
+    --say: color-mix(in oklab, var(--dark-square) 38%, #fafafa);
+    --say-ink: #1d2733;
+    --warn-back: #fff4d6;
+    /* The squares, their highlights, the marks and the pieces take their colours from the skins the settings choose, further on */
+    --mated: rgba(214, 40, 40, 0.8);
+    --low-time: #c62828;
+    --hint: rgba(0, 0, 0, 0.14);
+    --explain-ink: #1d2733;
+    --lift-shadow: rgba(16, 28, 44, 0.32);
+    --ghost: 0.35;
+    /* The four colours of PGN's %cal and %csl, for what the AI draws (D-69) */
+    --drawn-green: #15a34a;
+    --drawn-red: #dc2626;
+    --drawn-yellow: #eab308;
+    --drawn-blue: #2563eb;
+    /* Ink that stays dark in both themes: on the light squares and on White's chips */
+    --fixed-ink: #1d2733;
+    /* The helps (D-78, Zoe's sketch B): one ink for all they draw, never one of the AI's colours, a fill or a ring. The board says where, the card says what */
+    --help-ink: #11161d;
+    --help-on: #fff;
+    --help-line: rgba(17, 22, 29, 0.78);
+    --help-halo: rgba(255, 255, 255, 0.85);
+    --torretta-body: #6d9fd1;
+    --torretta-shade: #4b7cb0;
+    --torretta-screen: #16263a;
+    --torretta-face: #f2f7fc;
+    --torretta-light: #f4c84c;
+    --torretta-alarm: #ef6a4c;
+    --torretta-ponder: #8f9a8a;
+    /* The badges of the moves (D-69): white signs, dark on the yellow one; each disc at least 3:1 with its sign */
+    --badge-ink: #fff;
+    /* How a game went for the player, in the Analysis window's list: the colours of the move badges (D-69) */
+    --result-win: var(--badge-best);
+    --result-loss: var(--badge-blunder);
+    --result-draw: var(--badge-note);
+    --badge-note: #7b8794;
+    --badge-brilliant: #0f9a9e;
+    --badge-great: #2f74c8;
+    --badge-best: #3c9a3a;
+    --badge-excellent: #6b9c2c;
+    --badge-good: #7d9a62;
+    --badge-book: #94704c;
+    --badge-inaccuracy: #e6b422;
+    --badge-inaccuracy-ink: #3b2c00;
+    --badge-mistake: #d4650f;
+    --badge-miss: #c2407d;
+    --badge-blunder: #d22c2c;
+    --shadow: 0 1px 2px rgba(29, 39, 51, 0.06), 0 6px 18px rgba(29, 39, 51, 0.06);
+    /* On a light page the board keeps a thin edge in its dark squares colour, and a deeper shadow, so its light squares do not melt into the page */
+    --board-shadow: 0 0 0 1px color-mix(in oklab, var(--dark-square) 55%, transparent), 0 2px 4px rgba(29, 39, 51, 0.1), 0 10px 28px rgba(29, 39, 51, 0.12);
+    --gap: 20px;
+    --left: 300px;
+    --right: 300px;
+    /* The board's least size beside the talk: room for the AI's words, the box and both cards; a lower window scrolls */
+    --least: 440px;
+    --tab: 16px;
+    --rail: 56px;
+    --coin: 40px;
+    /* How far from the board's top and bottom edges the faces sit, in the cards and folded, and the tabs */
+    --ear: 36px;
+    --tuck: 10px;
+    --bar: 36px;
+    /* The cards' corners, as the board's; the room between the cards, and between them and the board */
+    --radius: 6px;
+    --between: 10px;
+    --bubble: 14px;
+    color-scheme: light;
+}
+
+:root[data-theme="dark"] {
+    --page: color-mix(in oklab, var(--dark-square) 13%, #0b0d10);
+    --card: color-mix(in oklab, var(--dark-square) 16%, #14171b);
+    --ink: #e6ebf1;
+    --soft: #8d98a7;
+    --line: color-mix(in oklab, var(--dark-square) 24%, #1b1f24);
+    --accent: #7cb0e4;
+    --on-accent: #0f1a28;
+    --low-time: #ff6b6b;
+    --quote: color-mix(in oklab, var(--dark-square) 20%, #1a1d22);
+    --say: color-mix(in oklab, var(--dark-square) 34%, #15181c);
+    --say-ink: #e6ebf1;
+    --warn-back: #2a2616;
+    --hint: rgba(0, 0, 0, 0.17);
+    --lift-shadow: rgba(0, 0, 0, 0.5);
+    --torretta-screen: #0f1a28;
+    --badge-great: #3577c9;
+    --badge-book: #9c7650;
+    --badge-miss: #c9478a;
+    --badge-blunder: #d93434;
+    --shadow: 0 1px 2px rgba(0, 0, 0, 0.3), 0 8px 22px rgba(0, 0, 0, 0.25);
+    --board-shadow: var(--shadow);
+    color-scheme: dark;
+}
+
+/* Zoe's palettes: on the page's root and on each swatch of the settings. Board skins, each with its own highlights */
+:root[data-board="azzurro"],
+[data-board="azzurro"] {
+    --light-square: #eaf1f8;
+    --dark-square: #86abd0;
+    --last-move: rgba(255, 206, 70, 0.65);
+    --selected: rgba(255, 190, 50, 0.85);
+    --hover-edge: #f4c84c;
+}
+
+:root[data-theme="dark"][data-board="azzurro"],
+:root[data-theme="dark"] [data-board="azzurro"] {
+    --light-square: #a9bccd;
+    --dark-square: #61809e;
+}
+
+:root[data-board="verde"],
+[data-board="verde"] {
+    --light-square: #eeeed2;
+    --dark-square: #769656;
+    --last-move: rgba(255, 255, 51, 0.5);
+    --selected: rgba(255, 236, 40, 0.75);
+    --hover-edge: #f6f669;
+}
+
+:root[data-theme="dark"][data-board="verde"],
+:root[data-theme="dark"] [data-board="verde"] {
+    --light-square: #c3c7a8;
+    --dark-square: #5f7c45;
+}
+
+:root[data-board="noce"],
+[data-board="noce"] {
+    --light-square: #e9d8bd;
+    --dark-square: #a6866a;
+    --last-move: rgba(200, 212, 40, 0.55);
+    --selected: rgba(185, 205, 20, 0.75);
+    --hover-edge: #cdd26a;
+}
+
+:root[data-theme="dark"][data-board="noce"],
+:root[data-theme="dark"] [data-board="noce"] {
+    --light-square: #c4b096;
+    --dark-square: #80654d;
+}
+
+:root[data-board="ardesia"],
+[data-board="ardesia"] {
+    --light-square: #dfe3e8;
+    --dark-square: #8b97a4;
+    --last-move: rgba(255, 206, 70, 0.6);
+    --selected: rgba(255, 190, 50, 0.8);
+    --hover-edge: #f4c84c;
+}
+
+:root[data-theme="dark"][data-board="ardesia"],
+:root[data-theme="dark"] [data-board="ardesia"] {
+    --light-square: #a7b0ba;
+    --dark-square: #65707c;
+}
+
+:root[data-board="grigio"],
+[data-board="grigio"] {
+    --light-square: #ededed;
+    --dark-square: #9a9a9a;
+    --last-move: rgba(255, 206, 70, 0.6);
+    --selected: rgba(255, 190, 50, 0.8);
+    --hover-edge: #f4c84c;
+}
+
+:root[data-theme="dark"][data-board="grigio"],
+:root[data-theme="dark"] [data-board="grigio"] {
+    --light-square: #b9b9b9;
+    --dark-square: #707070;
+}
+
+:root[data-board="lavanda"],
+[data-board="lavanda"] {
+    --light-square: #ece6f2;
+    --dark-square: #9a86b8;
+    --last-move: rgba(255, 214, 90, 0.6);
+    --selected: rgba(255, 200, 60, 0.8);
+    --hover-edge: #f4c84c;
+}
+
+:root[data-theme="dark"][data-board="lavanda"],
+:root[data-theme="dark"] [data-board="lavanda"] {
+    --light-square: #b8adc6;
+    --dark-square: #6f5e8c;
+}
+
+:root[data-board="ciliegio"],
+[data-board="ciliegio"] {
+    --light-square: #ecd3b6;
+    --dark-square: #9a5a3e;
+    --last-move: rgba(230, 220, 70, 0.55);
+    --selected: rgba(220, 210, 40, 0.75);
+    --hover-edge: #e6dc46;
+}
+
+:root[data-theme="dark"][data-board="ciliegio"],
+:root[data-theme="dark"] [data-board="ciliegio"] {
+    --light-square: #c6ab8f;
+    --dark-square: #73412c;
+}
+
+:root[data-board="menta"],
+[data-board="menta"] {
+    --light-square: #e9f3ec;
+    --dark-square: #7cb396;
+    --last-move: rgba(255, 218, 80, 0.6);
+    --selected: rgba(255, 204, 50, 0.8);
+    --hover-edge: #f4c84c;
+}
+
+:root[data-theme="dark"][data-board="menta"],
+:root[data-theme="dark"] [data-board="menta"] {
+    --light-square: #b3c6b9;
+    --dark-square: #58876d;
+}
+
+:root[data-board="carta"],
+[data-board="carta"] {
+    --light-square: #f3f1ea;
+    --dark-square: #b8b2a2;
+    --last-move: rgba(110, 165, 225, 0.5);
+    --selected: rgba(80, 145, 215, 0.7);
+    --hover-edge: #4a8ad0;
+}
+
+:root[data-theme="dark"][data-board="carta"],
+:root[data-theme="dark"] [data-board="carta"] {
+    --light-square: #c9c5b9;
+    --dark-square: #8a8577;
+}
+
+/* Piece colours for Nitida and Torretta */
+:root[data-pieces="classico"],
+[data-pieces="classico"] {
+    --white-piece: #fff;
+    --black-piece: #000;
+}
+
+:root[data-pieces="avorio"],
+[data-pieces="avorio"] {
+    --white-piece: #f4ead3;
+    --black-piece: #2a1c12;
+}
+
+:root[data-pieces="notte"],
+[data-pieces="notte"] {
+    --white-piece: #fff;
+    --black-piece: #1a3050;
+}
+
+:root[data-pieces="bordeaux"],
+[data-pieces="bordeaux"] {
+    --white-piece: #fff;
+    --black-piece: #5e161c;
+}
+
+/* Marks with the right button */
+:root[data-marks="arancione"],
+[data-marks="arancione"] {
+    --mark: #f07c1e;
+    --mark-square: rgba(240, 124, 30, 0.65);
+}
+
+:root[data-marks="rosso"],
+[data-marks="rosso"] {
+    --mark: #d6342c;
+    --mark-square: rgba(214, 52, 44, 0.6);
+}
+
+:root[data-marks="blu"],
+[data-marks="blu"] {
+    --mark: #2335a8;
+    --mark-square: rgba(35, 53, 168, 0.62);
+}
+
+:root[data-marks="verde"],
+[data-marks="verde"] {
+    --mark: #0f6b30;
+    --mark-square: rgba(15, 107, 48, 0.7);
+}

package/dist/profiles/index.d.ts

@@ -1,3 +1,3 @@
 export { type ImageType, imageTypeOf, imageTypes, ownImage, ownImageStamp, removeOwnImage, saveOwnImage, sentImageLimit } from "./avatar.ts";
-export { activateProfile, activeProfile, createProfile, type DrawnAvatar, drawnAvatars, ensureProfile, gameFolder, gameFolders, type Level, levels, listProfiles, nameLimit, type PlayerProfile, type ProfileFields, profileFolder, type Rating, ratingLimits, type RatingSite, ratingSites, updateProfile, } from "./profiles.ts";
+export { type Accounts, activateProfile, activeProfile, createProfile, type DrawnAvatar, drawnAvatars, ensureProfile, gameFolder, gameFolders, type Level, levels, listProfiles, nameLimit, type PlayerProfile, type ProfileFields, profileFolder, type Rating, ratingLimits, type RatingSite, ratingSites, updateProfile, } from "./profiles.ts";
 export { helpsIn, languageIn, type PageSettings, profileSettings, saveProfileSettings, settingsOf } from "./settings.ts";

package/dist/profiles/profiles.d.ts

@@ -26,12 +26,23 @@ export interface ProfileFields {
     readonly rating?: Rating;
     readonly avatar?: DrawnAvatar;
 }
+/** The player's names on the sites they play on. */
+export interface Accounts {
+    readonly lichess?: string;
+    readonly chesscom?: string;
+}
 /** A profile: its folder's name, and what profile.md says; a folder without one is named by the folder. */
 export interface PlayerProfile extends ProfileFields {
     readonly id: string;
     /** Made by Chesspal at the first start, until the player completes it: the board page's wizard does (D-71). */
     readonly new?: true;
+    /** The player's names on Lichess and chess.com, written in profile.md by hand or from the page, by which the games they load are theirs (D-93). */
+    readonly accounts?: Accounts;
 }
+/** What may change in a profile: what the player tells of themselves, and their names on the sites, each one written whole. */
+export type ProfileChanges = Partial<ProfileFields> & {
+    readonly accounts?: Accounts;
+};
 /** The profiles in the data folder, by their folders' names. */
 export declare function listProfiles(root: string): PlayerProfile[];
 /**
@@ -46,13 +57,13 @@ export declare function gameFolder(root: string): string;
 /** A profile's folder. */
 export declare function profileFolder(root: string, id: string): string;
 /**
- * Makes a profile, its folder named from the player's name, and puts it in use; the one Chesspal made, while new, becomes it instead, with its games, and
- * its folder takes the player's name too (D-71).
+ * Makes a profile, its folder named from the player's name, and puts it in use unless told not to; the one Chesspal made, while new, becomes it instead,
+ * with its games, and its folder takes the player's name too (D-71).
  */
-export declare function createProfile(root: string, fields: ProfileFields): PlayerProfile;
+export declare function createProfile(root: string, fields: ProfileFields, use?: boolean): PlayerProfile;
 /** Every profile's folder, where games may be. */
 export declare function gameFolders(root: string): string[];
 /** Puts a profile in use. */
 export declare function activateProfile(root: string, id: string): PlayerProfile;
 /** Changes what a profile says of the player, keeping the rest of profile.md as it was written: its other fields and the text below them. */
-export declare function updateProfile(root: string, id: string, changes: Partial<ProfileFields>): PlayerProfile;
+export declare function updateProfile(root: string, id: string, changes: ProfileChanges): PlayerProfile;

package/dist/profiles/profiles.js

@@ -41,10 +41,10 @@ export function profileFolder(root, id) {
     return join(root, folderName, id);
 }
 /**
- * Makes a profile, its folder named from the player's name, and puts it in use; the one Chesspal made, while new, becomes it instead, with its games, and
- * its folder takes the player's name too (D-71).
+ * Makes a profile, its folder named from the player's name, and puts it in use unless told not to; the one Chesspal made, while new, becomes it instead,
+ * with its games, and its folder takes the player's name too (D-71).
  */
-export function createProfile(root, fields) {
+export function createProfile(root, fields, use = true) {
     const id = activeId(root);
     if (id !== undefined && readProfile(root, id).new === true) {
         const { level, rating, avatar } = fields;
@@ -57,7 +57,7 @@ export function createProfile(root, fields) {
     while (!claimed(root, made)) {
         made = freeId(root, slugOf(fields.name));
     }
-    return fillProfile(root, made, fields, false);
+    return fillProfile(root, made, fields, false, use);
 }
 /** Every profile's folder, where games may be. */
 export function gameFolders(root) {
@@ -117,11 +117,13 @@ function claimed(root, id) {
         throw new Error(`${folder} could not be made (${error.message}): check that it is a folder, and can be written.`, { cause: error });
     }
 }
-/** Writes a profile in the folder this call claimed and puts it in use; on a failure the folder goes, which holds nothing of another's. */
-function fillProfile(root, id, fields, made) {
+/** Writes a profile in the folder this call claimed and puts it in use when asked; on a failure the folder goes, which holds nothing of another's. */
+function fillProfile(root, id, fields, made, use = true) {
     try {
         writeProfile(root, id, made ? { ...fields, new: true } : fields);
-        writeActive(root, id);
+        if (use) {
+            writeActive(root, id);
+        }
     }
     catch (error) {
         rmSync(profileFolder(root, id), { recursive: true, force: true });
@@ -183,8 +185,19 @@ function readProfile(root, id) {
         ...(rated ? { rating: { value, site } } : {}),
         ...(avatar === undefined ? {} : { avatar }),
         ...(fields.new === "true" ? { new: true } : {}),
+        ...accountsIn(fields),
     };
 }
+/** The player's names on the sites, from profile.md's lichess and chesscom lines; none without either. */
+function accountsIn(fields) {
+    const named = (site) => fields[site]?.trim().slice(0, nameLimit).trim() || undefined;
+    const lichess = named("lichess");
+    const chesscom = named("chesscom");
+    if (lichess === undefined && chesscom === undefined) {
+        return {};
+    }
+    return { accounts: { ...(lichess === undefined ? {} : { lichess }), ...(chesscom === undefined ? {} : { chesscom }) } };
+}
 // Writes the fields that change, and keeps the others as the file has them, even those this version does not read.
 function writeProfile(root, id, changes) {
     const { fields, body } = readFrontMatter(profileText(root, id));
@@ -202,6 +215,10 @@ function writeProfile(root, id, changes) {
     if ("avatar" in changes) {
         written.avatar = changes.avatar;
     }
+    if ("accounts" in changes) {
+        written.lichess = changes.accounts?.lichess;
+        written.chesscom = changes.accounts?.chesscom;
+    }
     if ("new" in changes) {
         written.new = changes.new === true ? "true" : undefined;
     }

package/dist/server/bell.d.ts

@@ -9,10 +9,18 @@ export declare class Bell {
     private listener;
     private pending;
     private busy;
+    private woken;
     private readonly news;
     private readonly changed;
-    /** `news` says whether a ring no hook heard is still worth waking the chat for; `changed` is told when the chat starts or stops listening. */
+    /**
+     * `news` says whether a ring no hook heard is still worth waking the chat for; `changed` is told when what the page shows of the chat may change: it
+     * starts or stops listening, the doorbell wakes it, its turn ends.
+     */
     constructor(news?: () => boolean, changed?: () => void);
+    /** Whether the chat is in a turn, as far as the doorbell knows: a chat stopped with Esc stays in it until its next tool. */
+    get inTurn(): boolean;
+    /** Whether the doorbell woke the chat in the turn it is in. */
+    get woke(): boolean;
     /** Whether the chat hears the player: in a turn, or waiting for the bell with a hook. */
     get listening(): boolean;
     /** The chat calls a tool, so it is in a turn: true when nobody was listening before. */
@@ -33,7 +41,7 @@ export interface BellProbe {
 }
 /** The ports a folder's page tries first: one in each of a few ranges, by its path, since Windows may reserve a range. The hook looks for it there. */
 export declare function pagePorts(folder: string): number[];
-/** What Codex's Stop hook answers to wake the chat (T-62): its turn goes on with the doorbell's line. */
+/** What Codex's Stop hook answers to wake the chat: its turn goes on with the doorbell's line. */
 export declare const codexBellAnswer: string;
 /**
  * Reads the hook's input, waits for the bell, and ends the process as the host reads it: for Claude Code's asyncRewake, 2 with the line on stderr; for

package/dist/server/bell.js

@@ -1,5 +1,5 @@
-// The doorbell for the page (D-47): `chesspal listen`, the Stop hook init writes for Claude Code and Codex (T-62), waits at the page of its chat and, when
-// the player moves or writes there (T-65), tells the chat to call status. It never carries the move, the words or the position: status reads them fresh.
+// The doorbell for the page (D-47): `chesspal listen`, the Stop hook init writes for Claude Code and Codex, waits at the page of its chat and, when
+// the player moves or writes there, tells the chat to call status. It never carries the move, the words or the position: status reads them fresh.
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import { get } from "node:http";
@@ -16,13 +16,26 @@ export class Bell {
     pending = false;
     // The chat is in a turn: it called a tool, or a hook woke it, and its turn has not ended yet. A chat never started, or just cleared, is not.
     busy = false;
+    // The doorbell woke the chat in this turn: the player acted on the page, and the chat goes to see it.
+    woken = false;
     news;
     changed;
-    /** `news` says whether a ring no hook heard is still worth waking the chat for; `changed` is told when the chat starts or stops listening. */
+    /**
+     * `news` says whether a ring no hook heard is still worth waking the chat for; `changed` is told when what the page shows of the chat may change: it
+     * starts or stops listening, the doorbell wakes it, its turn ends.
+     */
     constructor(news = () => true, changed = () => undefined) {
         this.news = news;
         this.changed = changed;
     }
+    /** Whether the chat is in a turn, as far as the doorbell knows: a chat stopped with Esc stays in it until its next tool. */
+    get inTurn() {
+        return this.busy;
+    }
+    /** Whether the doorbell woke the chat in the turn it is in. */
+    get woke() {
+        return this.woken;
+    }
     /** Whether the chat hears the player: in a turn, or waiting for the bell with a hook. */
     get listening() {
         return this.busy || this.listener !== undefined;
@@ -43,23 +56,26 @@ export class Bell {
         this.listener.end("ring");
         this.listener = undefined;
         this.busy = true;
+        this.woken = true;
+        this.changed();
     }
     /** A hook waits for the bell, so the chat's turn has ended; the hook before it, of a turn already ended, is let go. */
     listen(request, response) {
         response.writeHead(200, { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" });
-        const asleep = !this.listening;
         const missed = this.pending;
         this.pending = false;
         if (missed && this.news()) {
             response.end("ring");
             this.busy = true;
-            this.tellIf(asleep);
+            this.woken = true;
+            this.changed();
             return;
         }
         this.busy = false;
+        this.woken = false;
         this.listener?.end("dismissed");
         this.listener = response;
-        this.tellIf(asleep);
+        this.changed();
         request.on("close", () => {
             if (this.listener === response) {
                 // The hook went without the bell (the chat stopped, cleared or closed): nobody hears the player until the chat calls a tool again.
@@ -83,7 +99,7 @@ export function pagePorts(folder) {
     const offset = createHash("sha256").update(resolve(folder).toLowerCase()).digest()[0] % 10;
     return [5870, 6870, 7870].map((base) => base + offset);
 }
-/** What Codex's Stop hook answers to wake the chat (T-62): its turn goes on with the doorbell's line. */
+/** What Codex's Stop hook answers to wake the chat: its turn goes on with the doorbell's line. */
 export const codexBellAnswer = JSON.stringify({ decision: "block", reason: bellLine });
 /**
  * Reads the hook's input, waits for the bell, and ends the process as the host reads it: for Claude Code's asyncRewake, 2 with the line on stderr; for
@@ -95,7 +111,7 @@ export async function listen(codex = false) {
         input += String(chunk);
     }
     const heard = await bellHeard(input).catch((error) => ({ folder: chatFolder(hookInput(input)), rang: false, why: `failed: ${error.message}` }));
-    // Codex's turn ends with a hook that heard no bell, and the player's next move on the page wakes nobody: the log keeps why (T-62).
+    // Codex's turn ends with a hook that heard no bell, and the player's next move on the page wakes nobody: the log keeps why.
     if (codex && !heard.rang) {
         noteSilence(heard.folder, heard.why);
     }
@@ -139,10 +155,6 @@ const probeWait = 1000;
 // The log of Codex's hooks that heard no bell, in the chat's folder: its last lines only.
 const silenceLog = "listen.log";
 const silenceLines = 100;
-/** The chat's folder, where its server started: Claude Code names it, and the hook's cwd follows the cd's of the chat. */
-function chatFolder(hook) {
-    return resolve(process.env.CLAUDE_PROJECT_DIR ?? hook.cwd ?? process.cwd());
-}
 /** Adds a line to the log of the hooks that heard no bell, keeping its last lines; a log that cannot be written never stops the hook. */
 export function noteSilence(folder, why, now = new Date()) {
     const path = join(folder, silenceLog);
@@ -154,6 +166,10 @@ export function noteSilence(folder, why, now = new Date()) {
         // The log only explains; the hook ends the same.
     }
 }
+/** The chat's folder, where its server started: Claude Code names it, and the hook's cwd follows the cd's of the chat. */
+function chatFolder(hook) {
+    return resolve(process.env.CLAUDE_PROJECT_DIR ?? hook.cwd ?? process.cwd());
+}
 function hookInput(input) {
     try {
         const parsed = JSON.parse(input);

package/dist/server/caller.d.ts

@@ -1,4 +1,4 @@
-import type { Caller } from "../commands/context.ts";
+import type { Caller } from "../commands/index.ts";
 /** The host as it names itself to the server. */
 export interface Client {
     name: string;
@@ -6,5 +6,16 @@ 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>;
-/** The model and effort on the transcript's line of a tool call, in the chat's file or its subagents'; Claude Code writes it a few milliseconds late. */
-export declare function lineOfCall(transcript: string, call: 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. */
+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.
+ */
+export declare function callingAgent(meta: Record<string, unknown> | undefined, folder: string, wait?: number): Promise<CallingAgent | undefined>;
+/** 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,6 @@
-// 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 (T-113).
+// 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, readSync, statSync } from "node:fs";
+import { closeSync, openSync, readdirSync, readFileSync, readSync, statSync } from "node:fs";
 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. */
@@ -19,13 +19,45 @@ 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.
+ */
+export async function callingAgent(meta, folder, wait = 50) {
+    const call = meta?.["claudecode/toolUseId"];
+    const transcript = lastChatStart(folder)?.transcript;
+    const found = typeof call === "string" && transcript !== undefined ? await foundCall(transcript, call, wait) : undefined;
+    if (found === undefined) {
+        return undefined;
+    }
+    if (found.file === transcript) {
+        return { chat: true };
+    }
+    const type = objectOf(textOf(found.file.replace(/\.jsonl$/, ".meta.json")))?.agentType;
+    return typeof type === "string" ? { agent: type } : undefined;
+}
+/** 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));
+}
 /** The model and effort on the transcript's line of a tool call, in the chat's file or its subagents'; Claude Code writes it a few milliseconds late. */
-export async function lineOfCall(transcript, call, wait = 50) {
+async function lineOfCall(transcript, call, wait = 50) {
+    return (await foundCall(transcript, call, wait))?.caller;
+}
+// Three seconds at most: the line comes 30 or 40 milliseconds after a short call, but over 300 after annotate_game's long one. Nobody waits for it on the
+// AI's clock: annotate_game runs with no game going on, and the AI's move is read after its answer.
+const attempts = 60;
+// The line of a call just made is near the end of its file.
+const tailBytes = 512 * 1024;
+// A subagent's file is one written in the last minute.
+const recentFiles = 60_000;
+/** Who made a tool call, and the file its line is in, the chat's own or a subagent's; none when no line has it. */
+async function foundCall(transcript, call, wait) {
     for (let attempt = 0; attempt < attempts; attempt++) {
         for (const file of [transcript, ...subagentFiles(transcript)]) {
             const found = callerIn(tailOf(file), call);
             if (found !== undefined) {
-                return found;
+                return { caller: found, file };
             }
         }
         if (attempt < attempts - 1) {
@@ -34,13 +66,6 @@ export async function lineOfCall(transcript, call, wait = 50) {
     }
     return undefined;
 }
-// Three seconds at most: the line comes 30 or 40 milliseconds after a short call, but over 300 after annotate_game's long one. Nobody waits for it on the
-// AI's clock: annotate_game runs with no game going on, and the AI's move is read after its answer.
-const attempts = 60;
-// The line of a call just made is near the end of its file.
-const tailBytes = 512 * 1024;
-// A subagent's file is one written in the last minute.
-const recentFiles = 60_000;
 function callerIn(text, call) {
     const marker = `"id":"${call}"`;
     for (const line of text.split("\n").reverse()) {
@@ -86,6 +111,14 @@ function tailOf(file) {
         return "";
     }
 }
+function textOf(file) {
+    try {
+        return readFileSync(file, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
 function objectOf(value) {
     if (typeof value === "string") {
         try {

package/dist/server/mcp.d.ts

@@ -1,6 +1,5 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { type Context } from "../commands/context.ts";
-import { type AnyCommand } from "../commands/registry.ts";
+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). */