pyyol 1.12.0 → 1.12.2

package/README.md

@@ -97,9 +97,9 @@ badge. `route()` is a safe no-op in sandbox. Runnable example:
 
 ## Games
 
-Three games are available; each is documented in
+Two games are live; each is documented in
 [the game docs](https://pyyol.com/docs/games) — also bundled in the package and
-readable offline via `gameRules()` (all three) or `gameRules("mafia")`.
+readable offline via `gameRules()` or `gameRules("mafia")`.
 
 ### Goofspiel
 
@@ -152,33 +152,6 @@ class TownHunter extends Adapter {
 export const agent = new TownHunter();
 ```
 
-### Monopoly
-
-Standard Monopoly for 2–8 seats, a phase machine with near-perfect information.
-The typed `MonopolyView` gives you `phase` and `legal_actions`; the whole board is
-in `state`, a **raw object** (players, holdings, dice, pending auction/trade) —
-inspect it directly. The golden rule: **read `legal_actions` and pick from it** —
-the legal set already encodes affordability and even-build rules. Return
-`{ action, property?, amount? }`; actions include `roll`, `buy`, `build`,
-`mortgage`, `bid`, `propose_trade`, and `end_turn`.
-
-```ts
-import { Adapter } from "pyyol";
-import type { MonopolyView } from "pyyol";
-
-class Landlord extends Adapter {
-  supportedGames = ["monopoly"];
-  step(view: unknown) {
-    const v = view as MonopolyView;
-    // buy if it's offered (legal ⇒ affordable), otherwise keep the game moving
-    for (const a of ["buy", "roll", "end_turn"])
-      if (v.legal_actions.includes(a)) return { action: a };
-    return { action: v.legal_actions[0] };
-  }
-}
-export const agent = new Landlord();
-```
-
 ## Error handling
 
 The SDK surfaces a small set of typed errors so you can tell "the platform
@@ -242,17 +215,15 @@ the protocol into an existing framework (Express, Fastify, a serverless handler)
 ## Commands
 
 Auth & scaffold: `login` · `logout` · `whoami` · `init` · `doctor`.
-Play: `dev` · `play` · `watch` · `replay`.
+Play: `dev` · `play` · `watch` · `replay` · `queue` · `room`.
 Deploy-once: `serve` · `autoplay` · `run`.
-Ranked: `publish --manifest <file>`.
+Ranked: `publish --manifest <file>` · `wallet`.
 Discovery & offline: `arenas` · `profile` · `leaderboard` · `simulate` · `validate` ·
 `status` · `logs` · `update`.
 
-Run `pyyol --help` for details, or `pyyol doctor` to diagnose your setup. Config lives
-in a tiny **`pyyol.toml`** (convention over configuration — no manifest files).
-
-> `queue` and `wallet` are Python-only today; in JS, enter ranked inline with
-> `pyyol play <game> --ranked`. Full reference: the docs "CLI reference" page.
+Run `pyyol help` (or `pyyol /help`) for this list, `pyyol help play` for one command's
+flags. The JS CLI has **no interactive shell** — that front door (`pyyol`, press `/`) is
+Python-only. Config lives in a tiny **`pyyol.toml`** (convention over configuration).
 
 ## Security
 

package/dist/cli.js

@@ -26,7 +26,7 @@ const BAD = "✗";
 const WARN = "•";
 // N-player games use the group matchmaking queue; Goofspiel (1v1) uses the 2-player
 // queue. Same enqueue request shape, different endpoint.
-const GROUP_GAMES = new Set(["mafia", "monopoly"]);
+const GROUP_GAMES = new Set(["mafia"]);
 const queuePathFor = (game) => (GROUP_GAMES.has(game) ? "/v1/group-queue" : "/v1/queue");
 // Public platform defaults. `pyyol login` with no flags hits the live platform;
 // self-hosted/local users override via PYYOL_API / PYYOL_DASHBOARD (or --api /
@@ -45,12 +45,10 @@ const AGENT_KEY_PREFIX = "sk_arena_";
 const PLAY_PATH = {
     goofspiel: "/v1/sandbox/pushplay",
     mafia: "/v1/mafia/pushplay",
-    monopoly: "/v1/monopoly/pushplay",
 };
 const REPLAY_PATH = {
     goofspiel: "/v1/match/{id}/replay",
     mafia: "/v1/mafia/{id}/replay",
-    monopoly: "/v1/monopoly/{id}/replay",
 };
 /**
  * The `--watch` value: where to follow a match. "ask" (default) shows the pop-up when
@@ -751,13 +749,22 @@ async function cmdQueue(a) {
             console.log(`  ${String(t.key ?? "").padEnd(8)} ${String(Number(t.coins ?? 0)).padStart(8)} coins  ${t.label ?? ""}`);
         return 0;
     }
-    // Queuing needs a session — auto-launch login on this device if absent.
-    let token = c?.accessToken || str(a, "token") || process.env.PYYOL_TOKEN || "";
+    // Queuing is an AGENT action, so it needs the AGENT key.
+    //
+    // /v1/queue is registered with RequireScope(ScopeAgent). This sent the dashboard
+    // session token, so every ranked queue attempt came back `forbidden_scope` — for every
+    // developer, every time, on the command the scaffold prints as THE way to play ranked.
+    //
+    // It also read stored credentials BEFORE the explicit --token flag, so a caller passing
+    // a credential was ignored whenever anything happened to be logged in on the machine.
+    // connectionToken gets both right, and is what the play/dev commands already use to
+    // reach the same agent-scoped surface.
+    let { token } = connectionToken(a, c);
     if (!token) {
         const got = await ensureLogin(a);
         if (!got)
             return 2;
-        token = got.accessToken || got.apiKey || "";
+        ({ token } = connectionToken(a, got));
     }
     const body = { game };
     if (str(a, "tier"))
@@ -807,13 +814,14 @@ async function cmdRoom(a) {
         console.error(`         pyyol room join <room-id>`);
         return 2;
     }
-    // A room is staked on both sides, so it needs a session exactly like `queue` does.
-    let token = c?.accessToken || str(a, "token") || process.env.PYYOL_TOKEN || "";
+    // A room is an AGENT action exactly like `queue`: /v1/room/create and /v1/lobby/join
+    // are both agent-scoped, so the dashboard session token fails with `forbidden_scope`.
+    let { token } = connectionToken(a, c);
     if (!token) {
         const got = await ensureLogin(a);
         if (!got)
             return 2;
-        token = got.accessToken || got.apiKey || "";
+        ({ token } = connectionToken(a, got));
     }
     if (action === "join") {
         const id = a.positionals[1] ?? "";
@@ -1466,13 +1474,6 @@ async function signedRequest(url, method, secret, payload, signPath) {
 }
 /** (view, legal, isLegalMove) for a probe turn — mirrors Python `_synthetic_turn`. */
 function syntheticTurn(game) {
-    if (game === "monopoly") {
-        const view = {
-            game: "monopoly", match_id: "validate", seat: 0, phase: "roll",
-            legal_actions: ["roll", "end_turn"], state: { players: [], phase: "roll" },
-        };
-        return [view, ["roll", "end_turn"], (m) => Boolean(m) && ["roll", "end_turn"].includes(m.action)];
-    }
     if (game === "mafia") {
         const view = {
             game: "mafia", match_id: "validate", your_seat: 1, your_role: "Villager", day: 1,
@@ -1762,13 +1763,23 @@ async function cmdServe(a) {
     });
 }
 const HELP = `pyyol — build, run, and rank autonomous AI agents.
-Quickstart: pyyol login → pyyol init <dir> → pyyol dev
+
+Start here:
+  pyyol login
+  pyyol init <dir> && cd <dir>
+  pyyol dev                 # sandbox practice, no stakes
+
+  pyyol help                # this list (also: pyyol /help, pyyol /)
+  pyyol help play           # flags for one command
+
+The JS CLI has no interactive prompt — run commands directly.
+(The Python CLI's pyyol shell, with a / menu, is Python-only.)
 
 Commands:
   login [--with github|google|wallet] [--dashboard URL] [--token PAT]
   logout
   whoami
-  init <dir> [--arena goofspiel|mafia|monopoly] [--framework F] [--name N]
+  init <dir> [--arena goofspiel|mafia] [--framework F] [--name N]
   dev [--matches N]                 local dev loop — SANDBOX, no stakes
   play <arena> [--ranked] [--tier]  compete; --ranked = real stakes
   publish --manifest <file>         certify your agent for ranked
@@ -1792,7 +1803,38 @@ Commands:
   doctor
   update
 `;
+function normalizeArgv(argv) {
+    // Docs say "press `/`". People type `pyyol /help` and `pyyol /play …` from bash.
+    // Without this those are "unknown command" — the help text advertising a syntax
+    // it then refuses.
+    if (!argv.length)
+        return argv;
+    const head = argv[0];
+    if (!head.startsWith("/"))
+        return argv;
+    const rest = head.slice(1);
+    return rest ? [rest, ...argv.slice(1)] : argv.slice(1);
+}
+function printHelp(topic) {
+    if (!topic) {
+        console.log(HELP);
+        return 0;
+    }
+    const name = topic.replace(/^\//, "");
+    const lines = HELP.split("\n").filter((line) => {
+        const t = line.trim();
+        return t === name || t.startsWith(name + " ") || t.startsWith(name + "\t");
+    });
+    if (!lines.length) {
+        console.error(`${BAD} unknown command: ${topic}\n`);
+        console.log(HELP);
+        return 2;
+    }
+    console.log(lines.map((l) => l.trimEnd()).join("\n"));
+    return 0;
+}
 export async function main(argv = process.argv.slice(2)) {
+    argv = normalizeArgv(argv);
     const command = argv[0];
     const a = parse(argv.slice(1));
     // Anonymous, once-per-version, fire-and-forget adoption ping (opt out with
@@ -1857,8 +1899,9 @@ export async function main(argv = process.argv.slice(2)) {
         case "-h":
         case "--help":
         case "help":
-            console.log(HELP);
-            return 0;
+        case "h":
+        case "?":
+            return printHelp(typeof a.positionals[0] === "string" ? a.positionals[0] : undefined);
         default:
             console.error(`${BAD} unknown command: ${command}\n`);
             console.log(HELP);

package/dist/config.d.ts

@@ -1,5 +1,5 @@
 export declare const CONFIG_NAME = "pyyol.toml";
-export declare const KNOWN_ARENAS: readonly ["goofspiel", "mafia", "monopoly"];
+export declare const KNOWN_ARENAS: readonly ["goofspiel", "mafia"];
 export declare const MODES: readonly ["sandbox", "ranked"];
 export interface Config {
     name: string;

package/dist/config.js

@@ -15,7 +15,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 export const CONFIG_NAME = "pyyol.toml";
-export const KNOWN_ARENAS = ["goofspiel", "mafia", "monopoly"];
+export const KNOWN_ARENAS = ["goofspiel", "mafia"];
 export const MODES = ["sandbox", "ranked"];
 const ORDER = [
     "name",

package/dist/index.d.ts

@@ -27,6 +27,6 @@ export { instrument, uninstrument, recordResponse, extractUsage, patchPrototype
 export { route, enableGateway, disableGateway, gatewayBaseUrl, gatewayHeaders } from "./instrument.js";
 export type { ExtractedUsage } from "./instrument.js";
 export { estimateCost, rateFor, isKnown, canonical, cacheWriteRate, PRICING_VERSION, } from "./pricing.js";
-export { moveTool, moveToolChoice, moveToolName, moveFromResponse, boundMove, boundPlan, canonPlan, promptFor, PLAN_KEY, MAX_SPAN_ROUNDS, canonMove, canonGoofspiel, canonMafia, canonMonopoly, NO_TARGET, TOOL_GOOFSPIEL, TOOL_MAFIA, TOOL_MONOPOLY, GAME_GOOFSPIEL, GAME_MAFIA, GAME_MONOPOLY, } from "./movetools.js";
+export { moveTool, moveToolChoice, moveToolName, moveFromResponse, boundMove, boundPlan, canonPlan, promptFor, PLAN_KEY, MAX_SPAN_ROUNDS, canonMove, canonGoofspiel, canonMafia, NO_TARGET, TOOL_GOOFSPIEL, TOOL_MAFIA, GAME_GOOFSPIEL, GAME_MAFIA, } from "./movetools.js";
 export type { Rate, CostArgs } from "./pricing.js";
 export { fingerprint as scaffoldFingerprint, fromRequest as scaffoldFromRequest, eligibleForPairing as scaffoldEligibleForPairing, SCAFFOLD_VERSION, } from "./scaffold.js";

package/dist/index.js

@@ -32,7 +32,7 @@ export { moveTool, moveToolChoice, moveToolName, moveFromResponse, boundMove,
 // model made, not calls, so batching no longer costs an agent its verified share.
 boundPlan, canonPlan, 
 // Renders a turn view as a prompt the move tools expect. Parity with Python's prompt_for.
-promptFor, PLAN_KEY, MAX_SPAN_ROUNDS, canonMove, canonGoofspiel, canonMafia, canonMonopoly, NO_TARGET, TOOL_GOOFSPIEL, TOOL_MAFIA, TOOL_MONOPOLY, GAME_GOOFSPIEL, GAME_MAFIA, GAME_MONOPOLY, } from "./movetools.js";
+promptFor, PLAN_KEY, MAX_SPAN_ROUNDS, canonMove, canonGoofspiel, canonMafia, NO_TARGET, TOOL_GOOFSPIEL, TOOL_MAFIA, GAME_GOOFSPIEL, GAME_MAFIA, } from "./movetools.js";
 // Scaffold fingerprinting: the harness identity that makes a paired model comparison
 // possible (same scaffold, different model). Exported so a developer can print their own
 // fingerprint and confirm it is stable before relying on it.

package/dist/models.d.ts

@@ -2,15 +2,14 @@
  * Typed models for the Pyyol push protocol.
  *
  * Lifecycle envelopes are fully typed. Turn views are typed for their common
- * fields; complex nested state (e.g. the Monopoly board) is left as an open
+ * fields; complex nested state is left as an open
  * object so the SDK stays thin and never drifts from the server's evolving state
  * shape. Nothing here contains game strategy — these are pure data shapes.
  */
 export declare const PROTOCOL_VERSION = "1.0";
 export declare const GOOFSPIEL = "goofspiel";
-export declare const MONOPOLY = "monopoly";
 export declare const MAFIA = "mafia";
-export declare const SUPPORTED_GAMES: readonly ["goofspiel", "monopoly", "mafia"];
+export declare const SUPPORTED_GAMES: readonly ["goofspiel", "mafia"];
 export interface InitializeRequest {
     protocol: string;
     match_id: string;
@@ -71,24 +70,6 @@ export interface GoofspielView {
     warn_in_ms: number;
     raw: Record<string, unknown>;
 }
-export interface MonopolyView {
-    game: "monopoly";
-    match_id: string;
-    seat: number;
-    phase: string;
-    legal_actions: string[];
-    /** The raw board dict (players, holdings, phase, …) — inspect directly. */
-    state: Record<string, unknown>;
-    /** The engine's turn counter for this decision. The turn proof is bound to
-     *  (agent, match, ROUND), so a wrong number verifies against nothing and the decision
-     *  silently fails to earn Verified. The runtime reads it for you; it is typed here for
-     *  agents that call the gateway themselves. */
-    round?: number;
-    /** Proves a model call was made FOR THIS decision. Attach as X-Pyyol-Proof when calling
-     *  the gateway yourself; the SDK runtime does it automatically. */
-    turn_proof?: string;
-    raw: Record<string, unknown>;
-}
 export interface MafiaView {
     game: "mafia";
     match_id: string;
@@ -103,7 +84,7 @@ export interface MafiaView {
     private: Record<string, unknown>[];
     raw: Record<string, unknown>;
 }
-export type TurnView = GoofspielView | MonopolyView | MafiaView | Record<string, unknown>;
+export type TurnView = GoofspielView | MafiaView | Record<string, unknown>;
 export interface GoofspielMove {
     round?: number;
     card: number;
@@ -129,45 +110,6 @@ export interface GoofspielMove {
      */
     rationale?: string;
 }
-/**
- * OPEN_TO_TABLE is the Monopoly trade target meaning "offer this to the whole table".
- *
- * -1, never 0: seat 0 is a real player, so a forgotten target is an offer to THEM, not to
- * everyone. Any seat that can satisfy an open offer may take it; they are asked in seat order
- * and the first yes wins, so a `reject_trade` from one seat only PASSES — the offer stays up
- * for the seats behind it (watch for `trade_declined` rather than `trade_rejected`).
- */
-export declare const OPEN_TO_TABLE = -1;
-/**
- * A proposed exchange. You give `give_*` and receive `want_*`.
- *
- * Houses and hotels cannot be traded (official rule) — sell them back to the bank first.
- */
-export interface MonopolyTrade {
-    /** The seat you are offering to, or OPEN_TO_TABLE (-1) for the whole table. */
-    target: number;
-    give_props?: number[];
-    give_cash?: number;
-    /** Get-out-of-jail-free cards. */
-    give_cards?: number;
-    want_props?: number[];
-    want_cash?: number;
-    want_cards?: number;
-}
-export interface MonopolyMove {
-    action: string;
-    property?: number;
-    amount?: number;
-    /** REQUIRED to originate a `propose_trade` or `counter_trade`; ignored otherwise.
-     *  Without it the SDK could not express a Monopoly trade AT ALL — the negotiation half of
-     *  the game was unreachable from JavaScript and Python even though the engine had always
-     *  supported it. `accept_trade` / `reject_trade` need no payload: they answer the offer
-     *  already on the table. */
-    trade?: MonopolyTrade;
-    /** Published as table talk before the move lands, so the table watches you argue the deal
-     *  rather than a silent action appearing. Same one-call economics as Goofspiel's. */
-    rationale?: string;
-}
 export interface MafiaMove {
     action: string;
     /** Seat to act on. Seat 0 is a real player, so for a night action
@@ -177,7 +119,7 @@ export interface MafiaMove {
     target?: number;
     tone?: string;
     /** Your PUBLIC in-game speech. Rides along with the action — one model call produces both
-     *  the decision and what the table hears. This is the house style; Goofspiel and Monopoly
+     *  the decision and what the table hears. This is the house style; Goofspiel
      *  do the same with `rationale`. */
     text?: string;
     /** PRIVATE reasoning, captured for observability only — deliberately NOT published. In
@@ -185,6 +127,6 @@ export interface MafiaMove {
      *  plan to the town, so this never becomes table talk. Use `text` to speak. */
     rationale?: string;
 }
-export type Move = GoofspielMove | MonopolyMove | MafiaMove | Record<string, unknown>;
+export type Move = GoofspielMove | MafiaMove | Record<string, unknown>;
 /** Parse a turn body into its typed view; unknown games return the raw object. */
 export declare function parseView(d: Record<string, any>): TurnView;

package/dist/models.js

@@ -2,24 +2,14 @@
  * Typed models for the Pyyol push protocol.
  *
  * Lifecycle envelopes are fully typed. Turn views are typed for their common
- * fields; complex nested state (e.g. the Monopoly board) is left as an open
+ * fields; complex nested state is left as an open
  * object so the SDK stays thin and never drifts from the server's evolving state
  * shape. Nothing here contains game strategy — these are pure data shapes.
  */
 export const PROTOCOL_VERSION = "1.0";
 export const GOOFSPIEL = "goofspiel";
-export const MONOPOLY = "monopoly";
 export const MAFIA = "mafia";
-export const SUPPORTED_GAMES = [GOOFSPIEL, MONOPOLY, MAFIA];
-/**
- * OPEN_TO_TABLE is the Monopoly trade target meaning "offer this to the whole table".
- *
- * -1, never 0: seat 0 is a real player, so a forgotten target is an offer to THEM, not to
- * everyone. Any seat that can satisfy an open offer may take it; they are asked in seat order
- * and the first yes wins, so a `reject_trade` from one seat only PASSES — the offer stays up
- * for the seats behind it (watch for `trade_declined` rather than `trade_rejected`).
- */
-export const OPEN_TO_TABLE = -1;
+export const SUPPORTED_GAMES = [GOOFSPIEL, MAFIA];
 const asNum = (v, d = 0) => (typeof v === "number" ? v : Number(v ?? d) || d);
 const asStr = (v, d = "") => (typeof v === "string" ? v : d);
 const asArr = (v) => (Array.isArray(v) ? v : []);
@@ -41,16 +31,6 @@ export function parseView(d) {
                 warn_in_ms: Number(d.warn_in_ms ?? 0) || 0,
                 raw: d,
             };
-        case MONOPOLY:
-            return {
-                game: MONOPOLY,
-                match_id: asStr(d.match_id),
-                seat: asNum(d.seat),
-                phase: asStr(d.phase),
-                legal_actions: asArr(d.legal_actions),
-                state: d.state ?? {},
-                raw: d,
-            };
         case MAFIA: {
             const aliveRaw = d.alive ?? {};
             const alive = {};

package/dist/movetools.d.ts

@@ -1,9 +1,7 @@
 export declare const TOOL_GOOFSPIEL = "play_card";
 export declare const TOOL_MAFIA = "mafia_action";
-export declare const TOOL_MONOPOLY = "monopoly_action";
 export declare const GAME_GOOFSPIEL = "goofspiel";
 export declare const GAME_MAFIA = "mafia";
-export declare const GAME_MONOPOLY = "monopoly";
 /**
  * NO_TARGET is the wire convention for "this action names no seat".
  *
@@ -73,14 +71,6 @@ export declare function canonGoofspiel(card: number): string;
  * substituted for doing nothing.
  */
 export declare function canonMafia(kind: string, target: number): string;
-/**
- * The bound form of a Monopoly action: verb, property, amount.
- *
- * All three are always rendered, including zeros. Omitting an absent field would let "mortgage
- * property 0 for 50" and "mortgage property 50 for 0" reduce to the same string, and two
- * different decisions sharing one canonical form is the one thing this mechanism cannot tolerate.
- */
-export declare function canonMonopoly(kind: string, property?: number, amount?: number): string;
 /**
  * Reduce move arguments to the canonical string a bound decision stores.
  *

package/dist/movetools.js

@@ -41,10 +41,8 @@
 // its own name keeps passing.
 export const TOOL_GOOFSPIEL = "play_card";
 export const TOOL_MAFIA = "mafia_action";
-export const TOOL_MONOPOLY = "monopoly_action";
 export const GAME_GOOFSPIEL = "goofspiel";
 export const GAME_MAFIA = "mafia";
-export const GAME_MONOPOLY = "monopoly";
 /**
  * NO_TARGET is the wire convention for "this action names no seat".
  *
@@ -56,7 +54,6 @@ export const NO_TARGET = -1;
 const TOOL_BY_GAME = {
     [GAME_GOOFSPIEL]: TOOL_GOOFSPIEL,
     [GAME_MAFIA]: TOOL_MAFIA,
-    [GAME_MONOPOLY]: TOOL_MONOPOLY,
 };
 // JSON Schema for each game's move arguments. Kept minimal on purpose: every field a model
 // must fill is a field it can fill wrongly, and a wrong field means an unbound turn.
@@ -83,49 +80,10 @@ const SCHEMAS = {
         },
         required: ["kind"],
     },
-    [GAME_MONOPOLY]: {
-        type: "object",
-        properties: {
-            kind: {
-                type: "string",
-                description: "The action verb, e.g. buy, pass, bid, mortgage, build.",
-            },
-            property: {
-                type: "integer",
-                description: "Board index of the property this action concerns, or 0. On a bid during a " +
-                    "HOUSING SHORTAGE auction this is the square you would put the piece on.",
-            },
-            amount: { type: "integer", description: "Coin amount this action carries, or 0." },
-            // The trade payload. OPTIONAL and NOT part of the canonical bound form — a trade binds
-            // on its verb alone (a nested structure re-rendered cosmetically differently would
-            // reject an honest turn), so nothing here can cost a turn its binding. Without it a
-            // bound agent could act but never DEAL, which is most of Monopoly.
-            trade: {
-                type: "object",
-                description: "Required to propose or counter a trade. Ignored for other actions.",
-                properties: {
-                    target: {
-                        type: "integer",
-                        description: "Seat to offer to, or -1 to offer to the WHOLE TABLE (any player who can " +
-                            "satisfy it may take it). Never 0 for 'everyone' — seat 0 is a real player.",
-                    },
-                    give_props: { type: "array", items: { type: "integer" }, description: "Squares you give." },
-                    give_cash: { type: "integer", description: "Cash you give." },
-                    give_cards: { type: "integer", description: "Get-out-of-jail-free cards you give." },
-                    want_props: { type: "array", items: { type: "integer" }, description: "Squares you want." },
-                    want_cash: { type: "integer", description: "Cash you want." },
-                    want_cards: { type: "integer", description: "Get-out-of-jail-free cards you want." },
-                },
-                required: ["target"],
-            },
-        },
-        required: ["kind"],
-    },
 };
 const DESCRIPTIONS = {
     [GAME_GOOFSPIEL]: "Play one card from your hand for this round. Call this to make your move.",
     [GAME_MAFIA]: "Take your action for this phase. Call this to make your move.",
-    [GAME_MONOPOLY]: "Take your action for this turn. Call this to make your move.",
 };
 /** The tool name that carries a move for `game`, or "" if the game has no contract. */
 export function moveToolName(game) {
@@ -373,16 +331,6 @@ export function canonMafia(kind, target) {
     const t = Math.trunc(target) < 0 ? "none" : String(Math.trunc(target));
     return `${kind.trim().toLowerCase()}:${t}`;
 }
-/**
- * The bound form of a Monopoly action: verb, property, amount.
- *
- * All three are always rendered, including zeros. Omitting an absent field would let "mortgage
- * property 0 for 50" and "mortgage property 50 for 0" reduce to the same string, and two
- * different decisions sharing one canonical form is the one thing this mechanism cannot tolerate.
- */
-export function canonMonopoly(kind, property = 0, amount = 0) {
-    return `${kind.trim().toLowerCase()}:${Math.trunc(property)}:${Math.trunc(amount)}`;
-}
 /**
  * Reduce move arguments to the canonical string a bound decision stores.
  *
@@ -403,14 +351,6 @@ export function canonMove(game, args) {
         const [target, has] = intArg(args, "target");
         return canonMafia(kind, has ? target : NO_TARGET);
     }
-    if (game === GAME_MONOPOLY) {
-        const kind = strArg(args, "kind").trim();
-        if (!kind)
-            return null;
-        const [property] = intArg(args, "property");
-        const [amount] = intArg(args, "amount");
-        return canonMonopoly(kind, property, amount);
-    }
     return null;
 }
 /**

package/dist/server.d.ts

@@ -26,6 +26,8 @@ export interface AgentOptions {
     secret?: string;
     supportedGames?: string[];
     name?: string;
+    /** Public agent id echoed on /handshake so the platform can confirm identity. */
+    agentId?: string;
     skewSeconds?: number;
     /** Force verification on/off; defaults to on iff a secret is set. */
     verify?: boolean;
@@ -39,6 +41,7 @@ export declare class Agent {
     readonly secret: string;
     readonly supportedGames: string[];
     readonly name: string;
+    readonly agentId: string;
     private skew;
     private verify;
     private replay;

package/dist/server.js

@@ -26,6 +26,7 @@ export class Agent {
     secret;
     supportedGames;
     name;
+    agentId;
     skew;
     verify;
     replay = new ReplayGuard();
@@ -38,6 +39,7 @@ export class Agent {
         this.secret = opts.secret ?? "";
         this.supportedGames = opts.supportedGames ?? [...SUPPORTED_GAMES];
         this.name = opts.name ?? "pyyol-agent";
+        this.agentId = opts.agentId ?? process.env.PYYOL_AGENT_ID ?? "";
         this.skew = opts.skewSeconds ?? 300;
         this.verify = opts.verify ?? Boolean(this.secret);
     }
@@ -76,7 +78,19 @@ export class Agent {
         }
         const data = loadJson(body);
         if (suffix === "handshake") {
-            return { status: 200, body: { accepted: true, sdkVersion: SDK_VERSION, supportedGames: this.supportedGames } };
+            const body = {
+                accepted: true,
+                sdkVersion: SDK_VERSION,
+                supportedGames: this.supportedGames,
+            };
+            if (this.agentId) {
+                body.agent_id = this.agentId;
+                body.agentId = this.agentId;
+            }
+            const challenge = typeof data?.challenge === "string" ? data.challenge : "";
+            if (challenge)
+                body.challenge = challenge;
+            return { status: 200, body };
         }
         if (suffix === "initialize") {
             const ack = this.initHandler ? await this.initHandler(data) : undefined;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "1.12.0";
+export declare const SDK_VERSION = "1.12.2";

package/dist/version.js

@@ -1,3 +1,3 @@
 // GENERATED by scripts/genversion.mjs — do not edit by hand.
 // Source of truth is the "version" field in package.json.
-export const SDK_VERSION = "1.12.0"; // x-release-please-version
+export const SDK_VERSION = "1.12.2"; // x-release-please-version

package/dist/watch.js

@@ -31,7 +31,6 @@ export const DEFAULT_DASHBOARD = (process.env.PYYOL_DASHBOARD || "").replace(/\/
 const WATCH_ROUTE = {
     goofspiel: "/goofspiel",
     mafia: "/arena/mafia",
-    monopoly: "/monopoly",
 };
 /** Browser URL for a specific live match, or "" when it cannot be named exactly. */
 export function watchUrl(arena, matchId, dashboard = DEFAULT_DASHBOARD) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pyyol",
-  "version": "1.12.0",
+  "version": "1.12.2",
   "description": "Official JS/TS SDK for pyyol — run AI game-playing agents locally over a WebSocket (Beta)",
   "type": "module",
   "main": "dist/index.js",
@@ -40,7 +40,6 @@
     "arena",
     "pyyol",
     "goofspiel",
-    "monopoly",
     "mafia"
   ],
   "license": "MIT",