@leafarcade/cli 0.9.0 → 0.9.1

package/README.md

@@ -2,7 +2,7 @@
 
 Let your own agent play a private board-game room while you use the browser board. The CLI reads positions and submits moves; it does not call a model, collect model credentials or implement its own opponent.
 
-**Scope of 0.9.0:** all 53 multiplayer games in unclocked, unrated rooms that admit agents. Nine games expose complete convenience move lists and 41 more list legal wire actions in `legal_wire_actions` (marked incomplete only in free-form phases such as melds, trade offers, raise amounts, bluffs and four-card discards); Categories, Draw & Guess and Letter Tiles use their documented free-form actions. Card games add `cards_labeled`, index boards add `board_labeled` and `board_legend`, and every read adds `changed_since_last_read`. Local automatic play is available through the watcher below. OAuth login, seat-scoped pairing and resuming a stopped desktop chat are not implemented. Approval-only private tables require the host to approve a joining player before that seat is admitted. Invite-only tables admit players holding the invitation. Spectator and agent admission follow the host’s settings.
+**Scope of 0.9.1:** all 53 multiplayer games in unclocked, unrated rooms that admit agents. Nine games expose complete convenience move lists and 41 more list legal wire actions in `legal_wire_actions` (marked incomplete only in free-form phases such as melds, trade offers, raise amounts, bluffs and four-card discards); Categories, Draw & Guess and Letter Tiles use their documented free-form actions. Card games add `cards_labeled`, index boards add `board_labeled` and `board_legend`, and every read adds `changed_since_last_read`. Local automatic play is available through the watcher below. OAuth login, seat-scoped pairing and resuming a stopped desktop chat are not implemented. Approval-only private tables require the host to approve a joining player before that seat is admitted. Invite-only tables admit players holding the invitation. Spectator and agent admission follow the host’s settings.
 
 ## Start a game from your agent
 

package/dist/cli.mjs

@@ -3758,6 +3758,17 @@ function drawReason(history) {
   const last = history.at(-1);
   return history.filter((key2) => key2 === last).length >= 3 ? "Draw \xB7 the same position occurred three times." : "Draw \xB7 too many moves without progress (no capture or man move).";
 }
+function snapshotTurn(before, after, owner4, movers) {
+  if (!before || !after || before.length !== after.length) return null;
+  for (const seat of movers) {
+    const to = after.findIndex((p, i) => owner4(p) === seat && owner4(before[i]) !== seat);
+    if (to < 0) continue;
+    const from = before.findIndex((p, i) => owner4(p) === seat && owner4(after[i]) !== seat);
+    const captured = before.flatMap((p, i) => owner4(p) === 1 - seat && owner4(after[i]) !== 1 - seat ? [i] : []);
+    return { by_seat: seat, ...from >= 0 ? { from } : {}, to, ...captured.length ? { captured } : {} };
+  }
+  return null;
+}
 
 // lib/random.ts
 function randomStep(seed) {
@@ -3796,6 +3807,261 @@ function best(scores2) {
   return winners.length === 1 ? winners[0] : null;
 }
 
+// lib/multiplayer/dice.ts
+var diceCategories = [
+  "Ones",
+  "Twos",
+  "Threes",
+  "Fours",
+  "Fives",
+  "Sixes",
+  "Three of a kind",
+  "Four of a kind",
+  "Full house",
+  "Small straight",
+  "Large straight",
+  "Five of a kind",
+  "Chance"
+];
+function createDice(count) {
+  if (!index(count - 2, 3)) throw Error("Choose two to four players.");
+  return {
+    dice: [0, 0, 0, 0, 0],
+    held: Array(5).fill(false),
+    rolls: 0,
+    sheets: Array.from({ length: count }, () => Array(13).fill(null)),
+    bonuses: Array(count).fill(0),
+    turn: 0,
+    finished: false,
+    winner: null
+  };
+}
+function diceScore(dice, category, joker = false) {
+  const counts = Array.from(
+    { length: 6 },
+    (_, i) => dice.filter((v) => v === i + 1).length
+  ), sum = dice.reduce((a, b) => a + b, 0);
+  if (category < 6) return counts[category] * (category + 1);
+  switch (category) {
+    case 6:
+      return Math.max(...counts) >= 3 ? sum : 0;
+    case 7:
+      return Math.max(...counts) >= 4 ? sum : 0;
+    case 8:
+      return joker || counts.includes(3) && counts.includes(2) ? 25 : 0;
+    case 9:
+      return joker || [0, 1, 2].some((start) => counts.slice(start, start + 4).every(Boolean)) ? 30 : 0;
+    case 10:
+      return joker || [0, 1].some((start) => counts.slice(start, start + 5).every(Boolean)) ? 40 : 0;
+    case 11:
+      return counts.includes(5) ? 50 : 0;
+    case 12:
+      return sum;
+    default:
+      throw Error("Choose a score category.");
+  }
+}
+function diceTotal(s, seat) {
+  const sheet = s.sheets[seat], upper = sheet.slice(0, 6).reduce((sum, n) => sum + (n ?? 0), 0);
+  return sheet.reduce((sum, n) => sum + (n ?? 0), 0) + (upper >= 63 ? 35 : 0) + s.bonuses[seat];
+}
+function playDice(s, type, at, entropy2) {
+  if (s.finished) throw Error("This match is finished.");
+  if (type === "roll") {
+    if (s.rolls >= 3) throw Error("Record a score after three rolls.");
+    if (s.rolls && s.held.every(Boolean)) throw Error("Release a die before rolling again, or record a score.");
+    const random = draws(entropy2, 5);
+    return {
+      ...s,
+      rolls: s.rolls + 1,
+      dice: s.dice.map(
+        (v, i) => s.rolls && s.held[i] ? v : 1 + Math.floor(random[i] * 6)
+      )
+    };
+  }
+  if (at === void 0 || !index(at, type === "hold" ? 5 : 13) || !s.rolls)
+    throw Error("Roll first, then choose a die or score category.");
+  if (type === "hold") {
+    if (s.rolls >= 3) throw Error("No rolls are left: record a score.");
+    return { ...s, held: s.held.map((v, i) => i === at ? !v : v) };
+  }
+  if (type !== "score" || s.sheets[s.turn][at] !== null)
+    throw Error("Choose an unused score category.");
+  const sheets = s.sheets.map((row) => [...row]), bonuses = [...s.bonuses];
+  const five = s.dice.every((v) => v === s.dice[0]), upper = s.dice[0] - 1;
+  const joker = five && sheets[s.turn][11] !== null && sheets[s.turn][upper] !== null;
+  if (joker && sheets[s.turn].slice(6).some((n) => n === null) && at < 6)
+    throw Error(
+      "Use the five-of-a-kind joker in an unused lower category first."
+    );
+  sheets[s.turn][at] = diceScore(s.dice, at, joker);
+  if (joker && sheets[s.turn][11] === 50) bonuses[s.turn] += 100;
+  const next3 = {
+    ...s,
+    sheets,
+    bonuses,
+    turn: (s.turn + 1) % s.sheets.length,
+    rolls: 0,
+    held: Array(5).fill(false),
+    dice: [0, 0, 0, 0, 0]
+  };
+  next3.finished = sheets.every((row) => row.every((n) => n !== null));
+  if (next3.finished)
+    next3.winner = best(sheets.map((_, i) => diceTotal(next3, i)));
+  return next3;
+}
+
+// lib/multiplayer/ludo.ts
+function createLudo(count) {
+  if (!index(count - 2, 3)) throw Error("Choose two to four players.");
+  return {
+    pieces: Array.from({ length: count }, () => [-1, -1, -1, -1]),
+    turn: 0,
+    die: 0,
+    streak: 0,
+    attempts: 0,
+    winner: null,
+    last: "Roll a six to leave your yard."
+  };
+}
+var ludoTrack = (seat, progress, count = 4) => (seat * (count === 2 ? 20 : 10) + progress) % 40;
+function ludoMoves(s) {
+  if (!s.die || s.winner !== null) return [];
+  return s.pieces[s.turn].flatMap((p, i) => {
+    const to = p < 0 ? s.die === 6 ? 0 : -1 : p + s.die;
+    return to >= 0 && to <= 43 && !s.pieces[s.turn].some((other, j) => j !== i && other === to) ? [i] : [];
+  });
+}
+function advance(s) {
+  return {
+    ...s,
+    turn: (s.turn + 1) % s.pieces.length,
+    die: 0,
+    streak: 0,
+    attempts: 0
+  };
+}
+function playLudo(s, type, at, entropy2) {
+  if (s.winner !== null) throw Error("This match is finished.");
+  if (type === "roll") {
+    if (s.die) throw Error("Move a piece before rolling again.");
+    const die = 1 + Math.floor(draws(entropy2, 1)[0] * 6), streak = die === 6 ? s.streak + 1 : 0;
+    let next4 = {
+      ...s,
+      die,
+      streak,
+      attempts: s.attempts + 1,
+      last: `Player ${s.turn + 1} rolled ${die}.`
+    };
+    if (streak > 3)
+      return advance({
+        ...next4,
+        last: "Three extra moves is the limit. Turn passes."
+      });
+    if (!ludoMoves(next4).length) {
+      const allHome = s.pieces[s.turn].every((p) => p === -1);
+      next4 = allHome && next4.attempts < 3 || die === 6 ? { ...next4, die: 0, last: `Player ${s.turn + 1} rolled ${die}: no piece can move${die === 6 ? "; roll again" : allHome ? `; ${3 - next4.attempts} more tr${3 - next4.attempts === 1 ? "y" : "ies"} for a 6` : ""}.` } : advance({ ...next4, last: `Player ${s.turn + 1} rolled ${die}: no piece can move. Turn passes.` });
+    }
+    return next4;
+  }
+  if (type !== "move" || at === void 0 || !index(at, 4) || !ludoMoves(s).includes(at))
+    throw Error(
+      "Choose a highlighted piece. You need an exact roll to reach home."
+    );
+  const pieces = s.pieces.map((row) => [...row]), old = pieces[s.turn][at], to = old < 0 ? 0 : old + s.die;
+  pieces[s.turn][at] = to;
+  const captured = [];
+  if (to < 40) {
+    for (let seat = 0; seat < pieces.length; seat++)
+      if (seat !== s.turn) {
+        pieces[seat] = pieces[seat].map((p, piece2) => {
+          const hit = p >= 0 && p < 40 && ludoTrack(seat, p, pieces.length) === ludoTrack(s.turn, to, pieces.length);
+          if (hit) captured.push(`Player ${seat + 1}'s piece ${piece2 + 1}`);
+          return hit ? -1 : p;
+        });
+      }
+  }
+  const won = pieces[s.turn].every((p) => p >= 40);
+  const next3 = {
+    ...s,
+    pieces,
+    die: 0,
+    attempts: 0,
+    winner: won ? s.turn : null,
+    last: `Player ${s.turn + 1} moved piece ${at + 1} ${old < 0 ? "out of the yard to 0" : `from ${old} to ${to}`} with a ${s.die}${to >= 40 ? " (home lane)" : ""}${captured.length ? `, sending ${captured.join(" and ")} back to the yard` : ""}${!won && s.die === 6 && s.streak < 3 ? "; the 6 gives another roll" : ""}.`
+  };
+  return s.die === 6 && s.streak < 3 || won ? next3 : advance(next3);
+}
+
+// lib/multiplayer/football.ts
+var footballPoint = (at) => [at % 9, Math.floor(at / 9)];
+var footballEdge = (a, b) => a < b ? `${a}:${b}` : `${b}:${a}`;
+var valid = (at) => index(at, 117) && (Math.floor(at / 9) > 0 && Math.floor(at / 9) < 12 || at % 9 >= 3 && at % 9 <= 5);
+var boundary = (at) => {
+  const [x, y] = footballPoint(at);
+  return x === 0 || x === 8 || y === 0 || y === 12 || (y === 1 || y === 11) && x !== 4;
+};
+function createFootball() {
+  const edges = [];
+  for (let y = 1; y <= 11; y++)
+    for (const x of [0, 8])
+      if (y < 11) edges.push(footballEdge(y * 9 + x, (y + 1) * 9 + x));
+  for (const y of [1, 11])
+    for (let x = 0; x < 8; x++)
+      if (x < 3 || x >= 5) edges.push(footballEdge(y * 9 + x, y * 9 + x + 1));
+  for (const y of [0, 12]) {
+    edges.push(
+      footballEdge(y * 9 + 3, y * 9 + 4),
+      footballEdge(y * 9 + 4, y * 9 + 5)
+    );
+    for (const x of [3, 5])
+      edges.push(footballEdge(y * 9 + x, (y === 0 ? 1 : 11) * 9 + x));
+  }
+  return { ball: 58, edges, turn: 0, winner: null, last: null };
+}
+function footballMoves(s) {
+  if (s.winner !== null) return [];
+  const [x, y] = footballPoint(s.ball), moves = [];
+  for (let dy = -1; dy <= 1; dy++)
+    for (let dx = -1; dx <= 1; dx++) {
+      const nx = x + dx, ny = y + dy, at = ny * 9 + nx;
+      if ((ny === 0 || ny === 12) && (x < 3 || x > 5)) continue;
+      if ((dx || dy) && nx >= 0 && nx <= 8 && ny >= 0 && ny <= 12 && valid(at) && !s.edges.includes(footballEdge(s.ball, at)))
+        moves.push(at);
+    }
+  return moves;
+}
+function playFootball(s, at) {
+  if (!footballMoves(s).includes(at))
+    throw Error("Choose an adjacent point along an unused line.");
+  const bounced = boundary(at) || s.edges.some((edge) => edge.split(":").map(Number).includes(at));
+  const y = Math.floor(at / 9);
+  const next3 = {
+    ...s,
+    ball: at,
+    edges: [...s.edges, footballEdge(s.ball, at)],
+    turn: bounced ? s.turn : s.turn === 0 ? 1 : 0,
+    winner: y === 0 ? 0 : y === 12 ? 1 : null,
+    last: [s.ball, at]
+  };
+  if (next3.winner === null && !footballMoves(next3).length)
+    next3.winner = 1 - next3.turn;
+  return next3;
+}
+var compass = { "0,-1": "up", "1,-1": "up-right", "1,0": "right", "1,1": "down-right", "0,1": "down", "-1,1": "down-left", "-1,0": "left", "-1,-1": "up-left" };
+function footballLabeled(s) {
+  const [x, y] = footballPoint(s.ball);
+  return [
+    `ball: point ${s.ball} (row ${y}, column ${x}); points are row*9+column on a 9-column, 13-row grid, rows 0 and 12 are the goals`,
+    "seat 0 scores in the top goal (row 0: points 3, 4, 5); seat 1 in the bottom goal (row 12: points 111, 112, 113)",
+    ...footballMoves(s).map((at) => {
+      const [nx, ny] = footballPoint(at);
+      const bounce = boundary(at) || s.edges.some((edge) => edge.split(":").map(Number).includes(at));
+      return `move to ${at}: ${compass[`${nx - x},${ny - y}`]}${ny === 0 || ny === 12 ? ", goal" : bounce ? ", bounce: you move again" : ""}`;
+    })
+  ];
+}
+
 // lib/multiplayer/mills.ts
 var millLines = [
   [0, 1, 2],
@@ -4409,7 +4675,7 @@ var multiplayerGames = [
     symbol: "1000",
     players: "2\u20134 players",
     description: "Bid your hand. Marry a new trump.",
-    rules: "A 24-card deck, nine through ace; strength is nine, jack, queen, king, ten, ace. Three active players receive seven cards and a three-card kitty. With four seats the dealer sits out and scores revealed kitty aces (50 each) and marriages. Two players receive ten cards each and choose one of two two-card kitties. The first active player opens at 100; bid in tens, no higher than 120 plus held marriages. Winner takes a kitty, gives each other active player a card (or discards two with two seats), then declares at least the auction bid. Follow suit and beat the winner when possible; if void, trump when held. Leading a held queen-king pair with the marriage declaration earns clubs 60, diamonds 80, hearts 100 or spades 40 and changes trump. Card points: ace 11, ten 10, king 4, queen 3, jack 2. Cards left from the kitties, including the declarer\u2019s two discards in a two-player game, score for the last trick winner. Declarer makes or loses their contract; others round their points to tens. At 800, only declarer earns further points. First to 1000 wins, with declarer winning a simultaneous finish. The first bomb cancels freely; subsequent bombs award opponents 60 (40 with four seats). Four nines can request a redeal."
+    rules: "A 24-card deck, nine through ace; strength from lowest to highest is nine, jack, queen, king, ten, ace. Three active players receive seven cards and a three-card kitty. With four seats the dealer sits out and scores revealed kitty aces (50 each) and marriages. Two players receive ten cards each and choose one of two two-card kitties. The first active player opens at 100; bid in tens, no higher than 120 plus held marriages. Winner takes a kitty, gives each other active player a card (or discards two with two seats), then declares at least the auction bid. Follow suit and beat the winner when possible; if void, trump when held. Leading a held queen-king pair with the marriage declaration earns clubs 60, diamonds 80, hearts 100 or spades 40 and changes trump. Card points: ace 11, ten 10, king 4, queen 3, jack 2. Cards left from the kitties, including the declarer\u2019s two discards in a two-player game, score for the last trick winner. Declarer makes or loses their contract; others round their points to tens. At 800, only declarer earns further points. First to 1000 wins, with declarer winning a simultaneous finish. The first bomb cancels freely; subsequent bombs award opponents 60 (40 with four seats). Four nines can request a redeal."
   },
   {
     id: "binokel",
@@ -4529,7 +4795,7 @@ var multiplayerGames = [
     symbol: "\u2654",
     players: "2 players",
     description: "Claim sixty-six. Close the stock with care.",
-    rules: "Six cards each from a 24-card deck. Rank order: nine, jack, queen, king, ten, ace; values 0, 2, 3, 4, 10, 11. While stock is open, play freely; trick winner draws first, and the trump upcard is the last card drawn. Exchange trump nine after winning a trick. Before leading, you may close the stock; then follow suit, overtake if possible, otherwise trump. A queen\u2013king marriage declared while leading with open stock earns 20, or 40 in trump, once you have won a trick (including the one it leads). Claim 66 before leading, or immediately with a marriage. False claims or failed closure award the opponent 2/3 match points. Otherwise round wins earn 1\u20133 based on opponent points. An unclosed last trick adds ten. First to seven match points wins."
+    rules: "Six cards each from a 24-card deck. Rank order from lowest to highest: nine, jack, queen, king, ten, ace; values 0, 2, 3, 4, 10, 11. While stock is open, play freely; trick winner draws first, and the trump upcard is the last card drawn. Exchange trump nine after winning a trick. Before leading, you may close the stock; then follow suit, overtake if possible, otherwise trump. A queen\u2013king marriage declared while leading with open stock earns 20, or 40 in trump, once you have won a trick (including the one it leads). Claim 66 before leading, or immediately with a marriage. False claims or failed closure award the opponent 2/3 match points. Otherwise round wins earn 1\u20133 based on opponent points. An unclosed last trick adds ten. First to seven match points wins."
   },
   {
     id: "spades",
@@ -5004,107 +5270,6 @@ var action_catalog_default = {
   ]
 };
 
-// lib/multiplayer/dice.ts
-var diceCategories = [
-  "Ones",
-  "Twos",
-  "Threes",
-  "Fours",
-  "Fives",
-  "Sixes",
-  "Three of a kind",
-  "Four of a kind",
-  "Full house",
-  "Small straight",
-  "Large straight",
-  "Five of a kind",
-  "Chance"
-];
-function createDice(count) {
-  if (!index(count - 2, 3)) throw Error("Choose two to four players.");
-  return {
-    dice: [0, 0, 0, 0, 0],
-    held: Array(5).fill(false),
-    rolls: 0,
-    sheets: Array.from({ length: count }, () => Array(13).fill(null)),
-    bonuses: Array(count).fill(0),
-    turn: 0,
-    finished: false,
-    winner: null
-  };
-}
-function diceScore(dice, category, joker = false) {
-  const counts = Array.from(
-    { length: 6 },
-    (_, i) => dice.filter((v) => v === i + 1).length
-  ), sum = dice.reduce((a, b) => a + b, 0);
-  if (category < 6) return counts[category] * (category + 1);
-  switch (category) {
-    case 6:
-      return Math.max(...counts) >= 3 ? sum : 0;
-    case 7:
-      return Math.max(...counts) >= 4 ? sum : 0;
-    case 8:
-      return joker || counts.includes(3) && counts.includes(2) ? 25 : 0;
-    case 9:
-      return joker || [0, 1, 2].some((start) => counts.slice(start, start + 4).every(Boolean)) ? 30 : 0;
-    case 10:
-      return joker || [0, 1].some((start) => counts.slice(start, start + 5).every(Boolean)) ? 40 : 0;
-    case 11:
-      return counts.includes(5) ? 50 : 0;
-    case 12:
-      return sum;
-    default:
-      throw Error("Choose a score category.");
-  }
-}
-function diceTotal(s, seat) {
-  const sheet = s.sheets[seat], upper = sheet.slice(0, 6).reduce((sum, n) => sum + (n ?? 0), 0);
-  return sheet.reduce((sum, n) => sum + (n ?? 0), 0) + (upper >= 63 ? 35 : 0) + s.bonuses[seat];
-}
-function playDice(s, type, at, entropy2) {
-  if (s.finished) throw Error("This match is finished.");
-  if (type === "roll") {
-    if (s.rolls >= 3) throw Error("Record a score after three rolls.");
-    const random = draws(entropy2, 5);
-    return {
-      ...s,
-      rolls: s.rolls + 1,
-      dice: s.dice.map(
-        (v, i) => s.rolls && s.held[i] ? v : 1 + Math.floor(random[i] * 6)
-      )
-    };
-  }
-  if (at === void 0 || !index(at, type === "hold" ? 5 : 13) || !s.rolls)
-    throw Error("Roll first, then choose a die or score category.");
-  if (type === "hold")
-    return { ...s, held: s.held.map((v, i) => i === at ? !v : v) };
-  if (type !== "score" || s.sheets[s.turn][at] !== null)
-    throw Error("Choose an unused score category.");
-  const sheets = s.sheets.map((row) => [...row]), bonuses = [...s.bonuses];
-  const five = s.dice.every((v) => v === s.dice[0]), upper = s.dice[0] - 1;
-  const joker = five && sheets[s.turn][11] !== null && sheets[s.turn][upper] !== null;
-  if (joker && sheets[s.turn].slice(6).some((n) => n === null) && at < 6)
-    throw Error(
-      "Use the five-of-a-kind joker in an unused lower category first."
-    );
-  sheets[s.turn][at] = diceScore(s.dice, at, joker);
-  if (joker && sheets[s.turn][11] === 50) bonuses[s.turn] += 100;
-  const next3 = {
-    ...s,
-    sheets,
-    bonuses,
-    turn: (s.turn + 1) % s.sheets.length,
-    rolls: 0,
-    held: Array(5).fill(false),
-    dice: [0, 0, 0, 0, 0]
-  };
-  next3.finished = sheets.every((row) => row.every((n) => n !== null));
-  if (next3.finished)
-    next3.winner = best(sheets.map((_, i) => diceTotal(next3, i)));
-  return next3;
-}
-
 // lib/agents/action-help.ts
 var help = {
   amazons: "move: numeric from/to 0\u201399 and amount for the arrow square. Select an exact legal_wire_actions entry.",
@@ -5113,49 +5278,49 @@ var help = {
   euchre: "Use visible_state.legalActions. trump: amount 0 clubs, 1 diamonds, 2 hearts, 3 spades; promotion alone optionally sits your partner out. pass declines trump. discard/play: at is a held card ID, not a hand index. IDs are suit*6+rank, ranks 0\u20135 mean 9,10,J,Q,K,A. The left bower belongs to trump for following suit. next deals after a hand. Partners are opposite seats; first team to 10 wins.",
   cribbage: "Use visible_state.legalActions: discard has exactly two distinct card IDs from your own hand; play has at: card ID; go is legal only when no held card fits under 31; next starts the following deal after counting. Card IDs are suit*13+rank-1, A=1 through K=13; suit order clubs, diamonds, hearts, spades. Crib and opponents' unplayed cards remain hidden.",
   fanorona: "Use visible_state.legalActions: move has numeric from/to intersection indices 0\u201344 (row*9+column), amount 0 for approach/quiet or 1 for withdrawal. stop ends an optional capture continuation. Complete legal wire actions are enumerated; a chain must use the same stone and obey direction/visited constraints.",
-  categories: `begin: host starts a timed round; promotion:'untimed' disables the timer. submit/stop: text is a string holding a JSON array of six English answers in category order, for example text set to the string '["Apple","Ant",...]' (not a raw array); stop needs a complete sheet. expire reveals a timed-out round. vote: cards is rejected cell IDs (owner seat * 6 + category index), excluding your own row; an empty array accepts all other answers. next: host advances. Answers and ballots lock once submitted. Include at: the visible zero-based round and scoreKey: the visible roundKey on submit/stop/vote/expire to allow independent same-round actions arriving on the same revision.`,
+  categories: `begin: host starts a timed round; promotion:'untimed' disables the timer. submit/stop: text is a string holding a JSON array of six English answers in category order, for example text set to the string '["Apple","Ant",...]' (not a raw array); stop needs a complete sheet. expire reveals a timed-out round. vote: cards is rejected cell IDs (owner seat * 6 + category index), excluding your own row; an empty array accepts all other answers. next: host advances. Answers and ballots lock once submitted. The CLI fills at (the visible zero-based round) and scoreKey (the visible roundKey) on submit/stop/vote/expire when you leave them out, and accepts text as a plain array: {"type":"submit","text":["Spain","Seville","Seal","Soup","Singer","Spoon"]}.`,
   cheat: "play: cards is one to four card IDs from your hand, claiming the displayed rank. During challenge phase any other seat may challenge; only the next player may accept. Final-card claims must resolve before a win.",
   president: "play: cards is one to four equal-rank card IDs. Match pile size and beat its rank; 2 is high. Opening group includes 3 of clubs. pass sits out until the pile clears. Finished seats leave play; order gives final places.",
   rummy: "stock/upcard: draw first. meld: cards is a set or run of held card IDs. layoff: at is a public meld index, cards is held card IDs to add. discard: at is a held card ID. Aces low; keep one final discard; do not immediately discard the upcard you took.",
-  "connect-four": "place: at is a zero-based column (0\u20136). Convenience: --column 1\u20137.",
+  "connect-four": 'legal_actions list {"type":"drop","column":1\u20137}, one-based; pass one unchanged or use --column. The CLI converts it to the wire action place with zero-based at = column-1.',
   "tic-tac-toe": "place: at is a zero-based row-major square (0\u20138). legal_actions use one-based row/column instead; pass either form.",
   chess: "move: from/to are algebraic squares; promotion is q/r/b/n.",
   "atomic-chess": "move: from/to are algebraic squares; promotion is q/r/b/n. Explosions follow the game rules.",
   "three-check": "move: from/to are algebraic squares; promotion is q/r/b/n. Check counts are in visible_state.",
-  checkers: "move: from/to are zero-based row-major squares (0\u201363); continue a mandatory capture chain. Men move and capture forward only; kings move both ways. Convenience flags use algebraic squares.",
+  checkers: 'legal_actions use algebraic squares (from "c3" to "d4"); pass one unchanged or use --from/--to. The wire move uses zero-based row-major squares (0\u201363). Continue a mandatory capture chain. Men move and capture forward only; kings move both ways. Convenience flags use algebraic squares.',
   "brazilian-checkers": "move: from/to are zero-based squares (0\u201363); maximum captures apply.",
   "international-draughts": "move: from/to are zero-based squares (0\u201399). sequence: cards is a complete legal path of square indexes, including the origin.",
-  reversi: "place: at is a zero-based row-major square (0\u201363). Unavailable turns pass automatically.",
-  gomoku: "place: at is a zero-based row-major intersection (0\u2013224). Exactly five wins.",
-  hex: "place: at is a zero-based row-major hexagon. swap: no payload, only the second seat's first turn. Convenience: --row/--column or --swap.",
+  reversi: "legal_actions use one-based row/column (1\u20138); pass one unchanged or use --row/--column. The wire place uses zero-based row-major at (0\u201363). Unavailable turns pass automatically.",
+  gomoku: "legal_actions use one-based row/column (1\u201315); pass one unchanged or use --row/--column. The wire place uses zero-based row-major at (0\u2013224). Exactly five wins.",
+  hex: "legal_actions use one-based row/column; pass one unchanged or use --row/--column. The wire place uses a zero-based row-major hexagon. swap: no payload, only the second seat's first turn. Convenience: --row/--column or --swap.",
   "dots-boxes": 'Send a legal_actions entry ({"type":"edge","edge":N}, one-based) unchanged or use --edge N; the CLI converts it to the wire action place with zero-based at = N-1 (visible_state.edges[N-1]). board_labeled lists each box with its edge numbers. Horizontal edges precede vertical edges in row-major order. Edges and box owners are in visible_state. Convenience: --edge is one-based.',
-  oware: "sow: at is a zero-based pit index, 0\u20135 for seat 0 and 6\u201311 for seat 1. Convenience: --pit is one-based.",
+  oware: 'legal_actions list {"type":"sow","pit":N}, one-based: seat 0 owns pits 1\u20136, seat 1 pits 7\u201312; pass one unchanged or use --pit. The wire sow uses zero-based at = pit-1 (0\u20135 for seat 0, 6\u201311 for seat 1).',
   go: "place/dead: at is a zero-based row-major intersection (board_labeled shows row start indexes). pass/resume: no payload. accept: scoreKey names the scoring proposal you agree to; the CLI fills it from the position you read. Two passes start scoring: either seat marks dead groups, then both accept.",
   battleships: "auto/clear/ready: no payload. place: at is a zero-based starting square and amount selects orientation (0 horizontal, 1 vertical). fire: at is a zero-based target square. Inspect your fleet/setup phase; enemy ships remain hidden.",
   mills: "place/capture: at is a zero-based point index. move: from is the origin and at the destination. Completing a mill requires a subsequent capture action.",
   dice: `roll: no payload. hold: at is a die index (0\u20134) to toggle its hold after rolling. score: at is a category index: ${diceCategories.map((name, i) => `${i} ${name}`).join(", ")}. Inspect the roll phase and score sheet.`,
   ludo: "roll: no payload. move: at is the index (0\u20133) of your token. Token progress is relative to your own start: -1 yard, 0\u201339 track, 40\u201343 your home lane. Opponents' progress uses their own start, offset by 20 (two players) or 10 per seat (four) on the shared 40-square track. A 6 is needed to leave the yard; any 6 grants another roll, up to three in a row.",
   domino: "tile: at is your zero-based hand position (not a pip value) and amount selects the chain end: 0 left, 1 right. draw: draw until you can play, or pass when the stock is empty. next: start the following round. Scoring: open ends summing to a multiple of five score that sum; the player who empties their hand scores the opponent's pips rounded to the nearest five.",
-  football: "place: at is a zero-based destination point. The state records ball, used edges and continuing rebounds.",
+  football: "place: at is the destination point, row*9+column on a 9-column, 13-row grid (0\u2013116; rows 0 and 12 hold only the goal points 3\u20135 and 111\u2013113). board_labeled names each legal step with its direction and whether it bounces (another move). Seat 0 attacks the top goal, seat 1 the bottom.",
   backgammon: "roll: no payload. move: numeric from/to and amount (die value), one die per action. Points are 0\u201323. Positive point counts are seat 0, negative seat 1. Seat 0 moves up (enters from the bar to die-1, home 18\u201323); seat 1 moves down (enters to 24-die, home 0\u20135). from -1 means the bar; to 24 bears off for both seats. Compulsory dice usage is enforced.",
   shogi: "move: from is a zero-based square or a hand-piece type for a drop; to is a zero-based square; promotion:'yes' promotes. Inspect your hands and piece owners.",
   xiangqi: "move: numeric zero-based row-major from/to on the 9\xD710 board. promotion is unused.",
   poker: "fold/check/call/next: no payload. raise: amount is the desired bet total. Follow phase, pot, current bet, your cards and stack. next is a between-hand host action.",
-  durak: "play: at is your card ID from the visible hand; take/pass: no payload. Follow attack/defence roles and visible trump/table.",
+  durak: "play: at is your card ID from the visible hand (attack or add a card of a rank already on the table; defend by beating the open attack card). take: the defender picks up the table after the attackers finish adding. pass: an attacker stops adding cards; when every attacker has passed, beaten cards are discarded (or the defender takes them after take). Follow attack/defence roles and visible trump/table.",
   makao: "play: cards is 1\u20134 card IDs from your visible hand, all of the same rank. amount chooses an ace suit (0 clubs, 1 diamonds, 2 hearts, 3 spades) or a jack demand (rank 5\u201310 or 13 for king; 0 for no demand); visible_state.suit and demand use the same numbers; promotion:'makao' announces the last card. draw/pass/catch act according to phase. Inspect drawn-card and demand state.",
   pan: "play: cards is an array of card IDs from the visible hand; take/next: no payload. Follow the table rank and legal group rules.",
   "gin-rummy": "stock/upcard/pass/next: no payload. discard/knock: at is a card ID from the visible hand. Inspect draw/discard phase and deadwood rules.",
   "sixty-six": "play: at is a card ID from the visible hand; promotion:'marriage' or 'marriage-claim' declares. exchange/close/claim/next are phase-specific commands.",
   hearts: "select: at is a card ID from the visible hand for passing (selecting a chosen card again unselects it; visible_state.selected shows your choice), then pass. play: at is a card ID from the visible hand. moon: amount selects a scoring choice. Follow phase, lead suit and legal cards.",
-  spades: "bid: amount is the bid; blind/look for blind nil where offered. play: at is a card ID from the visible hand. Follow partner, phase and lead suit.",
+  spades: "bid: amount is the bid; blind/look for blind nil where offered. play: at is a card ID from the visible hand. Partners are opposite: seats 0 and 2 against seats 1 and 3 (the rules text calls them Players 1 & 3 and 2 & 4). Follow partner, phase and lead suit.",
   "oh-hell": "bid: amount is the bid. play: at is a card ID from the visible hand. next advances a completed hand; follow dealer restrictions and lead suit.",
-  "three-five-eight": "exchange: at is one card ID from your visible hand. discard: cards is exactly four distinct card IDs from your visible hand. play: at is one card ID from your visible hand. contract: amount 0\u20133 chooses a suit, 4 no trumps, 5 misere. next advances the hand.",
+  "three-five-eight": "exchange: at is one card ID from your visible hand. discard: cards is exactly four distinct card IDs from your visible hand; the listed sets are samples, any four of your cards are legal. play: at is one card ID from your visible hand. contract: amount 0 clubs, 1 diamonds, 2 hearts, 3 spades as trump, 4 no trumps, 5 no tricks (misere); each once per player. Cards rank 2 (low) to ace (high). next advances the hand.",
   bridge: "bid: amount 1\u201335 encodes level floor((amount-1)/5)+1 and strain (amount-1)%5; pass/double/redouble have no payload. play: at is the active card ID from the visible hand, including exposed dummy when you control it. Follow auction, strain and lead-suit rules.",
   "polish-hearts": "trump: amount is a suit index; pass: no payload, only when no layout card fits; play: at is a card ID from the visible hand. Follow the current penalty/trump/layout phase.",
   thousand: "bid/declare: amount is points. kitty: at selects a kitty. exchange: cards is card IDs from the visible hand. play: at is a card ID from the visible hand; to declare a marriage, lead its queen or king with promotion:'marriage'. pass/bomb/redeal/next depend on phase. Card IDs are suit*13+rank-2 (suits clubs, diamonds, hearts, spades; ranks 9 through ace). next: the dealer of the finished hand starts the next one (the deal moves on).",
-  binokel: "bid: amount is points; trump: amount is a suit; play: at is a card ID from the visible hand. pass/next have no payload. Meld values: aces around 10 (both sets 100), kings around 8 (80), queens around 6 (60), jacks around 4 (40), trump run 15 (150), royal marriage 4, ordinary marriage 2 per pair. A bid is the team's trick points plus melds; tricks hold 50 points per hand (scoring cards plus 2 for the last trick), so a contract rests mostly on melds. The declaring team needs 20 meld points.",
+  binokel: "bid: amount is points; trump: amount is a suit; play: at is a card ID from the visible hand. pass/next have no payload. Meld values (one set, two sets): aces around 10, 100; kings around 8, 80; queens around 6, 60; jacks around 4, 40; trump run 15, 150; royal marriage 4, ordinary marriage 2 per pair. A bid is the team's trick points plus melds; tricks hold 50 points per hand (scoring cards plus 2 for the last trick), so a contract rests mostly on melds. The declaring team needs 20 meld points.",
   skat: "bid: amount is an auction value; hold/pass/hand/pickup act in auction/pickup phases (after a hold the bidder must bid higher or pass). discard: cards is exactly two card IDs from your visible hand. contract: amount 0 clubs, 1 diamonds, 2 hearts, 3 spades as trump, 4 grand (jacks only), 5 null, with optional promotion normal/schneider/schwarz/ouvert. play: at is a card ID from the visible hand. Jacks rank clubs, spades, hearts, diamonds. Card IDs are suit*13+rank-2 (suits clubs, diamonds, hearts, spades). next: the dealer of the finished hand starts the next one (the deal moves on).",
-  baska: "announce: no payload in the honor phase. contract: amount is one of 1,3,4,5,6 and must exceed the current contract. double/pass act in auction; play: at is a card ID from the visible hand; next advances the hand.",
+  baska: "announce: no payload in the honor phase. contract: amount is one of 1 Wedding, 3 Grand, 4 Zolo, 5 Grand Du, 6 Zolo Du and must exceed the current contract (the other numbers name contracts not bid this way: 0 Ordinary, 2 Zolo Bieda, 7 Master, 8 Baska). double/pass act in auction; play: at is a card ID from the visible hand; next advances the hand.",
   canasta: "stock/next: no payload. pickup may require melds containing the top discard plus cards from your hand. meld: melds is an array of {rank,cards} groups of card IDs from the visible hand; rank is the natural rank 3\u201314 (J 11, Q 12, K 13, A 14), with twos and jokers as wild cards. cards_labeled names each card. discard: at is a card ID from the visible hand. Follow opening meld and canasta requirements. Warning: going out (melding or discarding your last card) before your side has the required canastas (two with 2 players, one each with 4) is accepted but loses the match.",
   "letter-tiles": "place: placements is an array of {at,rack,letter?}; at is a board index and rack a rack index, letter assigns a blank. exchange: cards is rack indexes. accept/challenge/pass/next depend on phase.",
   "draw-guess": "choose: at selects one of your offered prompts. draw: stroke is an array of 2\u2013256 {x,y} integer points, each coordinate 0\u20131000; optional amount is pen width 2/4/8/16 and promotion is a supported pen color. guess: text is your guess; guesses are permitted out of turn during drawing. clear/expire/next depend on phase. Hidden prompts stay hidden from guessers.",
@@ -5239,20 +5404,23 @@ function canastaCount(melds) {
   return melds.filter((m) => m.cards.length >= 7).length;
 }
 function finish2(t, out2, concealed = false) {
+  const parts = [];
   for (let i = 0; i < 2; i++) {
-    const meld2 = t.melds[i], red = t.red[i].length, bonus = meld2.reduce(
+    const meld2 = t.melds[i], red = t.red[i].length, canastas = meld2.reduce(
       (n, m) => n + (m.cards.length >= 7 ? m.cards.some(canastaWild) ? 300 : 500 : 0),
       0
-    ) + (red * 100 + (red === 4 ? 400 : 0)) * (meld2.length ? 1 : -1), cards = meld2.flatMap((m) => m.cards).reduce((n, c) => n + canastaValue(c), 0), held = t.hands.reduce(
+    ), threes = (red * 100 + (red === 4 ? 400 : 0)) * (meld2.length ? 1 : -1), bonus = canastas + threes, cards = meld2.flatMap((m) => m.cards).reduce((n, c) => n + canastaValue(c), 0), held = t.hands.reduce(
       (n, h, seat) => n + (team(t, seat) === i ? h.reduce((n2, c) => n2 + canastaValue(c), 0) : 0),
       0
     );
-    t.scores[i] += bonus + cards - held + (out2 !== null && team(t, out2) === i ? concealed ? 200 : 100 : 0);
+    const going = out2 !== null && team(t, out2) === i ? concealed ? 200 : 100 : 0;
+    t.scores[i] += bonus + cards - held + going;
+    parts.push(`Team ${i + 1}: melded cards ${cards}, canastas ${canastas}, red threes ${threes}${red && !meld2.length ? " (no meld, so negative)" : ""}, going out ${going}, cards left in hand -${held}`);
   }
   t.phase = t.scores.some((n) => n >= 5e3) ? "finished" : "round";
   t.winner = t.phase === "finished" ? best(t.scores) : null;
   t.turn = t.dealer;
-  t.result = `Hand complete. Scores ${t.scores.join(" / ")}.`;
+  t.result = `Hand complete${out2 === null ? " (stock exhausted)" : ""}. ${parts.join("; ")}. Scores ${t.scores.join(" / ")}.`;
 }
 function out(t, seat) {
   if (t.hands[seat].length) return;
@@ -5739,7 +5907,7 @@ function award(s) {
   }
   return s;
 }
-function advance(s) {
+function advance2(s) {
   const live = s.players.filter((p) => !p.folded && !p.out);
   if (live.length <= 1) return award(s);
   if (s.pending.length) {
@@ -5765,7 +5933,7 @@ function advance(s) {
   s.pending = s.players.flatMap((p, i) => canAct(p) ? [i] : []);
   if (s.pending.length <= 1) {
     s.pending = [];
-    return advance(s);
+    return advance2(s);
   }
   s.turn = nextSeat(s, s.button, canAct);
   return s;
@@ -5814,7 +5982,7 @@ function begin(s, seed) {
   s.turn = nextSeat(s, big, canAct);
   if (!s.pending.length || s.pending.length === 1 && s.players[s.pending[0]].street >= Math.max(...s.players.map((p) => p.street))) {
     s.pending = [];
-    return advance(s);
+    return advance2(s);
   }
   return s;
 }
@@ -5909,7 +6077,7 @@ function pokerAction(previous, seat, action, seed) {
   s.actedAt ??= s.players.map((player) => player.street);
   s.actedAt[seat] = s.bet;
   s.log = [...s.log, `Player ${seat + 1} ${label}`].slice(-80);
-  return advance(s);
+  return advance2(s);
 }
 function leavePoker(previous, seat) {
   const s = structuredClone(previous);
@@ -5927,7 +6095,7 @@ function leavePoker(previous, seat) {
     return s;
   }
   if (s.turn === seat || s.players.filter((p) => !p.folded && !p.out).length <= 1)
-    return advance(s);
+    return advance2(s);
   return s;
 }
 function pokerView(s, seat) {
@@ -7716,7 +7884,8 @@ function moveVariant(state, from, to, promotion = "q") {
   if (!parseUci(from + to)) throw Error("Choose a legal move.");
   const move2 = variantMoves(state).find((m) => m.from === from && m.to === to && (!m.promotion || m.promotion === promotion));
   if (!move2) throw Error("Choose a legal move.");
-  const pos = variantPosition(state), last = makeSanAndPlay(pos, move2.internal), setup = pos.toSetup();
+  const pos = variantPosition(state), san = makeSanAndPlay(pos, move2.internal), setup = pos.toSetup();
+  const last = san.endsWith("#") && !pos.isCheckmate() ? san.slice(0, -1) + (pos.isCheck() ? "+" : "") : san;
   const fen = makeFen(setup), history = [...state.history, repetitionKey(fen)];
   const outcome = pos.outcome();
   const repeated = history.filter((key2) => key2 === repetitionKey(fen)).length >= 3;
@@ -8312,13 +8481,14 @@ function playBackgammon(s, type, from, to, die, entropy2) {
       opening: false,
       rolled,
       dice: rolled[0] === rolled[1] ? Array(4).fill(rolled[0]) : rolled,
-      result: `Rolled ${rolled.join(" and ")}.`
+      result: `Player ${turn + 1} rolled ${rolled.join(" and ")}.`,
+      last: { by_seat: turn, rolled, moves: [] }
     };
     return backgammonMoves(next4).length ? next4 : {
       ...next4,
       dice: [],
       turn: turn === 0 ? 1 : 0,
-      result: "All moves are blocked. Turn passes."
+      result: `Player ${turn + 1} rolled ${rolled.join(" and ")}: all moves are blocked. Turn passes.`
     };
   }
   const move2 = backgammonMoves(s).find(
@@ -8329,6 +8499,7 @@ function playBackgammon(s, type, from, to, die, entropy2) {
       "Use the maximum number of dice; if only one can be used, use the higher die."
     );
   const next3 = step(s, move2);
+  next3.last = { by_seat: s.turn, rolled: s.last?.rolled ?? s.rolled, moves: [...s.last?.by_seat === s.turn ? s.last.moves : [], { ...move2, ...move2.to !== 24 && s.points[move2.to] === (s.turn === 0 ? -1 : 1) ? { hit: true } : {} }] };
   if (next3.off[s.turn] === 15) {
     const opponent = 1 - s.turn, backgammon = next3.bar[opponent] > 0 || next3.points.some(
       (n, i) => (s.turn === 0 ? i >= 18 : i < 6) && n * (s.turn === 0 ? -1 : 1) > 0
@@ -8336,147 +8507,13 @@ function playBackgammon(s, type, from, to, die, entropy2) {
     next3.winner = s.turn;
     next3.result = next3.off[opponent] ? "Single game." : backgammon ? "Backgammon \xB7 3 points." : "Gammon \xB7 2 points.";
   } else if (!backgammonMoves(next3).length) {
+    if (next3.dice.length) next3.result = `Player ${s.turn + 1} cannot use the remaining ${next3.dice.join(" and ")}. Turn passes.`;
     next3.dice = [];
     next3.turn = s.turn === 0 ? 1 : 0;
   }
   return next3;
 }
 
-// lib/multiplayer/football.ts
-var footballPoint = (at) => [at % 9, Math.floor(at / 9)];
-var footballEdge = (a, b) => a < b ? `${a}:${b}` : `${b}:${a}`;
-var valid = (at) => index(at, 117) && (Math.floor(at / 9) > 0 && Math.floor(at / 9) < 12 || at % 9 >= 3 && at % 9 <= 5);
-var boundary = (at) => {
-  const [x, y] = footballPoint(at);
-  return x === 0 || x === 8 || y === 0 || y === 12 || (y === 1 || y === 11) && x !== 4;
-};
-function createFootball() {
-  const edges = [];
-  for (let y = 1; y <= 11; y++)
-    for (const x of [0, 8])
-      if (y < 11) edges.push(footballEdge(y * 9 + x, (y + 1) * 9 + x));
-  for (const y of [1, 11])
-    for (let x = 0; x < 8; x++)
-      if (x < 3 || x >= 5) edges.push(footballEdge(y * 9 + x, y * 9 + x + 1));
-  for (const y of [0, 12]) {
-    edges.push(
-      footballEdge(y * 9 + 3, y * 9 + 4),
-      footballEdge(y * 9 + 4, y * 9 + 5)
-    );
-    for (const x of [3, 5])
-      edges.push(footballEdge(y * 9 + x, (y === 0 ? 1 : 11) * 9 + x));
-  }
-  return { ball: 58, edges, turn: 0, winner: null, last: null };
-}
-function footballMoves(s) {
-  if (s.winner !== null) return [];
-  const [x, y] = footballPoint(s.ball), moves = [];
-  for (let dy = -1; dy <= 1; dy++)
-    for (let dx = -1; dx <= 1; dx++) {
-      const nx = x + dx, ny = y + dy, at = ny * 9 + nx;
-      if ((ny === 0 || ny === 12) && (x < 3 || x > 5)) continue;
-      if ((dx || dy) && nx >= 0 && nx <= 8 && ny >= 0 && ny <= 12 && valid(at) && !s.edges.includes(footballEdge(s.ball, at)))
-        moves.push(at);
-    }
-  return moves;
-}
-function playFootball(s, at) {
-  if (!footballMoves(s).includes(at))
-    throw Error("Choose an adjacent point along an unused line.");
-  const bounced = boundary(at) || s.edges.some((edge) => edge.split(":").map(Number).includes(at));
-  const y = Math.floor(at / 9);
-  const next3 = {
-    ...s,
-    ball: at,
-    edges: [...s.edges, footballEdge(s.ball, at)],
-    turn: bounced ? s.turn : s.turn === 0 ? 1 : 0,
-    winner: y === 0 ? 0 : y === 12 ? 1 : null,
-    last: [s.ball, at]
-  };
-  if (next3.winner === null && !footballMoves(next3).length)
-    next3.winner = 1 - next3.turn;
-  return next3;
-}
-
-// lib/multiplayer/ludo.ts
-function createLudo(count) {
-  if (!index(count - 2, 3)) throw Error("Choose two to four players.");
-  return {
-    pieces: Array.from({ length: count }, () => [-1, -1, -1, -1]),
-    turn: 0,
-    die: 0,
-    streak: 0,
-    attempts: 0,
-    winner: null,
-    last: "Roll a six to leave your yard."
-  };
-}
-var ludoTrack = (seat, progress, count = 4) => (seat * (count === 2 ? 20 : 10) + progress) % 40;
-function ludoMoves(s) {
-  if (!s.die || s.winner !== null) return [];
-  return s.pieces[s.turn].flatMap((p, i) => {
-    const to = p < 0 ? s.die === 6 ? 0 : -1 : p + s.die;
-    return to >= 0 && to <= 43 && !s.pieces[s.turn].some((other, j) => j !== i && other === to) ? [i] : [];
-  });
-}
-function advance2(s) {
-  return {
-    ...s,
-    turn: (s.turn + 1) % s.pieces.length,
-    die: 0,
-    streak: 0,
-    attempts: 0
-  };
-}
-function playLudo(s, type, at, entropy2) {
-  if (s.winner !== null) throw Error("This match is finished.");
-  if (type === "roll") {
-    if (s.die) throw Error("Move a piece before rolling again.");
-    const die = 1 + Math.floor(draws(entropy2, 1)[0] * 6), streak = die === 6 ? s.streak + 1 : 0;
-    let next4 = {
-      ...s,
-      die,
-      streak,
-      attempts: s.attempts + 1,
-      last: `Player ${s.turn + 1} rolled ${die}.`
-    };
-    if (streak > 3)
-      return advance2({
-        ...next4,
-        last: "Three extra moves is the limit. Turn passes."
-      });
-    if (!ludoMoves(next4).length) {
-      const allHome = s.pieces[s.turn].every((p) => p === -1);
-      next4 = allHome && next4.attempts < 3 || die === 6 ? { ...next4, die: 0 } : advance2(next4);
-    }
-    return next4;
-  }
-  if (type !== "move" || at === void 0 || !index(at, 4) || !ludoMoves(s).includes(at))
-    throw Error(
-      "Choose a highlighted piece. You need an exact roll to reach home."
-    );
-  const pieces = s.pieces.map((row) => [...row]), old = pieces[s.turn][at], to = old < 0 ? 0 : old + s.die;
-  pieces[s.turn][at] = to;
-  if (to < 40) {
-    for (let seat = 0; seat < pieces.length; seat++)
-      if (seat !== s.turn) {
-        pieces[seat] = pieces[seat].map(
-          (p) => p >= 0 && p < 40 && ludoTrack(seat, p, pieces.length) === ludoTrack(s.turn, to, pieces.length) ? -1 : p
-        );
-      }
-  }
-  const won = pieces[s.turn].every((p) => p >= 40);
-  const next3 = {
-    ...s,
-    pieces,
-    die: 0,
-    attempts: 0,
-    winner: won ? s.turn : null,
-    last: `Player ${s.turn + 1} moved piece ${at + 1}.`
-  };
-  return s.die === 6 && s.streak < 3 || won ? next3 : advance2(next3);
-}
-
 // lib/multiplayer/go.ts
 function createGo(size = 9) {
   const board = Array(size * size).fill(0);
@@ -11208,7 +11245,7 @@ function playProperties(s, a, entropy2) {
   }
   if (s.phase === "tax") {
     if (a.type !== "tax" || ![0, 1].includes(a.amount ?? -1))
-      throw Error("Choose flat tax or ten percent of estate value.");
+      throw Error("Choose the tax: amount 0 pays the flat 200, amount 1 pays ten percent of your estate value.");
     const estate = p.cash + s.assets.reduce(
       (n, a2, i) => n + (a2.owner === seat ? propertyFields[i].price + a2.houses * propertyFields[i].build : 0),
       0
@@ -11283,7 +11320,8 @@ function playProperties(s, a, entropy2) {
     t.dice = [];
     return t;
   }
-  throw Error("Choose an action for the current estate phase.");
+  if (a.type === "release") throw Error(p.jail < 0 ? "You are not in jail." : "Leave jail at the start of your turn, in the roll phase: release with amount 0 pays 50, amount 1 uses a release card.");
+  throw Error(`That action is not available in the ${s.phase} phase; choose one from the legal list.`);
 }
 function propertyView(s) {
   const { decks, ...publicState } = s;
@@ -11768,9 +11806,9 @@ function dominoMoves(s) {
     ].filter((m) => m !== null);
   });
 }
-function endRound(s, winner2, bonus) {
-  const scores2 = [...s.scores];
-  if (winner2 !== null) scores2[winner2] += Math.round(bonus / 5) * 5;
+function endRound(s, winner2, bonus, out2 = false) {
+  const scores2 = [...s.scores], points = Math.round(bonus / 5) * 5;
+  if (winner2 !== null) scores2[winner2] += points;
   const finished = scores2.some((n) => n >= 100);
   return {
     ...s,
@@ -11778,7 +11816,7 @@ function endRound(s, winner2, bonus) {
     winner: finished ? best(scores2) : null,
     phase: finished ? "finished" : "round",
     turn: winner2 ?? s.turn,
-    result: winner2 === null ? "Blocked round: equal pip totals." : `Player ${winner2 + 1} wins the round.`
+    result: winner2 === null ? "Blocked round: equal pip totals, nobody scores." : out2 ? `Player ${winner2 + 1} goes out and scores ${points} for the opponent's ${bonus} pips (rounded to five).` : `Blocked round: Player ${winner2 + 1} holds fewer pips and scores ${points} for the ${bonus}-pip difference (rounded to five).`
   };
 }
 var pipSum = (hand2) => hand2.reduce((n, [a, b]) => n + a + b, 0);
@@ -11797,8 +11835,9 @@ function playDomino(s, type, at, end, entropy2) {
       throw Error("Play a matching tile before drawing.");
     while (stock.length && !dominoMoves({ ...s, hands }).length)
       hands[s.turn].push(stock.pop());
-    if (dominoMoves({ ...s, hands }).length) return { ...s, hands, stock };
-    const next4 = { ...s, hands, stock, turn: 1 - s.turn, passes: s.passes + 1 };
+    const drawn = hands[s.turn].length - s.hands[s.turn].length;
+    if (dominoMoves({ ...s, hands }).length) return { ...s, hands, stock, result: `Player ${s.turn + 1} drew ${drawn} tile${drawn === 1 ? "" : "s"}.` };
+    const next4 = { ...s, hands, stock, turn: 1 - s.turn, passes: s.passes + 1, result: `Player ${s.turn + 1} ${drawn ? `drew ${drawn} tile${drawn === 1 ? "" : "s"}, ` : ""}cannot play and passes.` };
     if (next4.passes < 2) return next4;
     const a2 = pipSum(hands[0]), b2 = pipSum(hands[1]);
     return endRound(next4, a2 === b2 ? null : a2 < b2 ? 0 : 1, Math.abs(a2 - b2));
@@ -11816,7 +11855,8 @@ function playDomino(s, type, at, end, entropy2) {
   }
   const left = chain[0], right = chain.at(-1);
   const total = chain.length === 1 ? left[0] + left[1] : (left[0] === left[1] ? left[0] * 2 : left[0]) + (right[0] === right[1] ? right[1] * 2 : right[1]);
-  if (total % 5 === 0) scores2[s.turn] += total;
+  const scored = total % 5 === 0 && total > 0;
+  if (scored) scores2[s.turn] += total;
   const next3 = {
     ...s,
     hands,
@@ -11824,10 +11864,11 @@ function playDomino(s, type, at, end, entropy2) {
     chain,
     scores: scores2,
     passes: 0,
-    turn: 1 - s.turn
+    turn: 1 - s.turn,
+    result: `Player ${s.turn + 1} played ${a}-${b}${scored ? ` and scores ${total}: the open ends total ${total}` : ""}.`
   };
   if (!hands[s.turn].length)
-    return endRound(next3, s.turn, pipSum(hands[1 - s.turn]));
+    return endRound(next3, s.turn, pipSum(hands[1 - s.turn]), true);
   if (scores2.some((n) => n >= 100))
     return { ...next3, phase: "finished", winner: best(scores2) };
   return next3;
@@ -12139,7 +12180,7 @@ function agentListComplete(game, state, legal) {
   if (game === "poker") return !legal.some((action) => action.type === "raise");
   return false;
 }
-var amounts = [.../* @__PURE__ */ new Set([...Array.from({ length: 301 }, (_, i) => i), ...Array.from({ length: 41 }, (_, i) => 300 + i * 10)])];
+var amounts = [.../* @__PURE__ */ new Set([...Array.from({ length: 301 }, (_, i) => i), ...Array.from({ length: 141 }, (_, i) => 300 + i * 5)])];
 var promotions = ["marriage", "marriage-claim", "makao", "normal", "schneider", "schwarz", "ouvert"];
 function hand(state, seat) {
   for (const key2 of ["hands", "hand"]) {
@@ -12166,6 +12207,15 @@ function cardGroups(cards) {
   else for (let i = 0; i + 4 <= cards.length; i += 4) add(cards.slice(i, i + 4));
   return [...groups.values()].map(([group]) => group);
 }
+function runGroups(cards) {
+  const runs = [];
+  for (const card2 of cards) for (let length = 3; ; length++) {
+    const run = Array.from({ length }, (_, i) => card2 + i);
+    if (card2 % 13 + length > 13 || !run.every((c) => cards.includes(c))) break;
+    runs.push(run);
+  }
+  return runs;
+}
 var atTypes = /* @__PURE__ */ new Set(["fire", "sow", "hold", "score", "capture", "knock", "dead", "mortgage", "redeem", "build", "sell", "choose", "kitty", "place", "tile", "move"]);
 var amountTypes = /* @__PURE__ */ new Set(["bid", "raise", "declare", "tax", "release", "moon", "trump", "contract", "kitty", "announce", "choose", "tile", "place", "move"]);
 var cardTypes = /* @__PURE__ */ new Set(["play", "discard", "exchange", "select", "meld", "layoff"]);
@@ -12220,6 +12270,10 @@ function specific(game, state, seat) {
     { type: "play", cards, promotion: "makao" },
     ...[0, 1, 2, 3, 5, 6, 7, 8, 9, 10, 13].flatMap((amount) => [{ type: "play", cards, amount }, { type: "play", cards, amount, promotion: "makao" }])
   ])];
+  if (game === "rummy") {
+    const runs = runGroups(hand(state, seat));
+    return [...generic(adapters.rummy, state, seat), ...runs.map((cards) => ({ type: "meld", cards })), ...runs.flatMap((cards) => Array.from({ length: 20 }, (_, at) => ({ type: "layoff", at, cards })))];
+  }
   if (game === "go") {
     const s = state;
     if (s.phase === "scoring" && s.accepted.includes(seat)) return [];
@@ -12429,12 +12483,33 @@ function agentPosition(room) {
   const active = room.phase === "playing" && !!match && !room.players[room.seat].left && !ended && !room.players.some((p) => p.paused);
   const grid = !complete && match ? indexedBoard(room.game, match.state) : null;
   const wire = !complete && match && enumeratedAgentGames.includes(room.game) ? active ? agentLegalActions(room.game, match.state, room.seat, room.capacity) ?? [] : [] : null;
-  const checkerLast = match?.kind === "checkers" || match?.kind === "brazilian-checkers" ? checkerLastMove(match.state.history) : null;
+  const checkerLast = match?.kind === "checkers" ? checkerLastMove(match.state.history) : null;
+  const snapshotLast = (() => {
+    if (!match) return null;
+    const draughts2 = (key2) => key2?.split(":")[0].split(",").map(Number);
+    const pieceOwner = (p) => p ? Math.abs(p) - 1 : -1, seatOwner = (p) => p;
+    if (match.kind === "checkers" || match.kind === "brazilian-checkers" || match.kind === "international-draughts") {
+      const [a, b] = match.state.history.slice(-2);
+      return snapshotTurn(draughts2(a), draughts2(b), pieceOwner, [1 - Number(b?.split(":")[1])]);
+    }
+    if (match.kind === "fanorona") {
+      const [a, b] = match.state.history.slice(-2).map((k) => k.split(":")[0].match(/-1|0|1/g)?.map(Number));
+      return snapshotTurn(a, b, seatOwner, [1 - match.state.turn, match.state.turn]);
+    }
+    if (match.kind === "go") {
+      if (match.state.passes > 0) return { by_seat: 1 - match.state.turn, type: "pass" };
+      const [a, b] = match.state.history.slice(-2).map((k) => [...k].map(Number));
+      return snapshotTurn(a, b, (p) => p - 1, [1 - match.state.turn]);
+    }
+    if ((match.kind === "amazons" || match.kind === "dots-boxes" || match.kind === "lines-of-action" || match.kind === "backgammon") && match.state.last) return match.state.last;
+    return null;
+  })();
   const dotsLabeled = match?.kind === "dots-boxes" ? match.state.boxes.map((owner4, box) => {
     const { size, edges } = match.state, sides2 = boxEdges(size, box), drawn = sides2.filter((e) => edges[e] >= 0).length;
     const named = ["top", "bottom", "left", "right"].map((side2, i) => `${side2} ${sides2[i] + 1}${edges[sides2[i]] >= 0 ? "*" : ""}`).join(", ");
     return `box row ${Math.floor(box / size) + 1} col ${box % size + 1} [${owner4 < 0 ? "." : "XO"[owner4]}]: ${named}${owner4 < 0 && drawn === 3 ? " (three sides: takeable)" : ""}`;
   }) : null;
+  const ludoLabeled = match?.kind === "ludo" ? match.state.pieces.map((row, seat) => `seat ${seat} (${room.players[seat]?.name ?? "empty"}): ${row.map((p, i) => `piece ${i + 1} ${p < 0 ? "yard" : p >= 40 ? `home lane ${p - 39}/4` : `progress ${p}, track square ${ludoTrack(seat, p, match.state.pieces.length)}`}`).join("; ")}`) : null;
   const ginHand = match?.kind === "gin-rummy" && match.state.phase !== "finished" ? match.state.hands[room.seat]?.filter((c) => c !== null) ?? [] : [];
   const ginHint = ginHand.length ? (() => {
     const layout = ginLayout(ginHand), names = (cards) => cards.map((c) => `${cardLabel(c)} (id ${c})`);
@@ -12447,7 +12522,10 @@ function agentPosition(room) {
       knock_limit: 10
     };
   })() : null;
-  const ruleNotes = match?.kind === "thousand" ? match.state.scores.flatMap((score, seat) => match.state.phase !== "finished" && score >= 800 ? [`Seat ${seat} (${room.players[seat]?.name ?? "empty"}) has ${score} points: from 800, defending points no longer score; only a made contract adds points.`] : []) : [];
+  const ruleNotes = match?.kind === "thousand" ? match.state.scores.flatMap((score, seat) => match.state.phase !== "finished" && score >= 800 ? [`Seat ${seat} (${room.players[seat]?.name ?? "empty"}) has ${score} points: from 800, defending points no longer score; only a made contract adds points.`] : []) : match?.kind === "dice" ? match.state.sheets.map((sheet, seat) => {
+    const upper = sheet.slice(0, 6).reduce((n, v) => n + (v ?? 0), 0);
+    return `Seat ${seat} (${room.players[seat]?.name ?? "empty"}): upper section ${upper}/63${upper >= 63 ? ", 35 bonus earned" : ""}; total ${diceTotal(match.state, seat)}.`;
+  }) : match?.kind === "polish-hearts" && match.state.phase !== "finished" ? [polishHandNote(match.state.round, match.state.hands.length)] : match?.kind === "three-check" ? [`Checks given: seat 0 ${match.state.checks[0]}, seat 1 ${match.state.checks[1]}; the third check wins.`] : [];
   const sixtyUnseen = match?.kind === "sixty-six" && match.state.phase === "play" ? (() => {
     const s = match.state, seen = /* @__PURE__ */ new Set([...(s.hands[room.seat] ?? []).filter((c) => c !== null), ...s.played ?? [], ...s.trick.map((c) => c.card), ...s.upcard === null ? [] : [s.upcard]]);
     return Array.from({ length: 24 }, (_, i) => Math.floor(i / 6) * 13 + 7 + i % 6).filter((c) => !seen.has(c)).map((c) => `${cardLabel(c)} (id ${c})`);
@@ -12471,10 +12549,10 @@ function agentPosition(room) {
     players: room.players.map((p, seat) => ({ seat, name: p.name, left: p.left, ...p.agent ? { agent: true } : {}, ...p.paused ? { paused: true } : {} })),
     board_size: complete ? { rows, columns } : grid ? { rows: grid.rows, columns: grid.columns } : { rows: 0, columns: 0 },
     board_top_to_bottom: board,
-    board_labeled: dotsLabeled ?? (match?.kind === "oware" ? [...labeledBoard(room.game, board) ?? [], `captured: seat 0 ${match.state.scores[0]}, seat 1 ${match.state.scores[1]}`] : null) ?? labeledBoard(room.game, board) ?? grid?.labeled ?? null,
+    board_labeled: dotsLabeled ?? ludoLabeled ?? (match?.kind === "football" ? footballLabeled(match.state) : null) ?? (match?.kind === "oware" ? [...labeledBoard(room.game, board) ?? [], `captured: seat 0 ${match.state.scores[0]}, seat 1 ${match.state.scores[1]}`] : null) ?? labeledBoard(room.game, board) ?? grid?.labeled ?? null,
     ...grid ? { board_legend: grid.legend } : dotsLabeled ? { board_legend: "One line per box: owner (X seat 0, O seat 1, . open), then its four edges as one-based edge numbers (--edge N); * marks a drawn edge. A box with three drawn edges can be taken now." } : {},
     // Chess and its variants record the last move in SAN.
-    last_move: (match?.kind === "chess" || match?.kind === "atomic-chess" || match?.kind === "three-check") && match.state.last ? { san: match.state.last } : checkerLast ? { from: square(checkerLast.from), to: square(checkerLast.to) } : cribbageLast ? cribbageLast : match?.kind === "makao" && match.state.last ? { by_seat: match.state.last.seat, type: match.state.last.type, ...match.state.last.cards ? { cards: match.state.last.cards.map((c) => `${cardLabel(c)} (id ${c})`) } : {}, ...match.state.last.count !== void 0 && match.state.last.type !== "play" ? { count: match.state.last.count } : {}, ...match.state.last.announced ? { announced_makao: true } : {} } : asianLast ? { by_seat: asianLast.by, ...asianLast.from === null ? { type: "drop" } : { from: asianLast.from }, to: asianLast.to } : match?.kind === "oware" && match.state.last !== null ? { last_seed_in_pit: match.state.last + 1 } : millLast ? { by_seat: millLast.seat, ...millLast.from === null ? { type: "place" } : { type: "move", from: millLast.from }, at: millLast.to, ...millLast.captured.length ? { captured: millLast.captured } : {} } : last === null ? null : room.game === "connect-four" ? { column: last % columns + 1, row_from_top: Math.floor(last / columns) + 1 } : { row: Math.floor(last / columns) + 1, column: last % columns + 1 },
+    last_move: (match?.kind === "chess" || match?.kind === "atomic-chess" || match?.kind === "three-check") && match.state.last ? { san: match.state.last } : checkerLast ? { by_seat: snapshotLast?.by_seat, from: square(checkerLast.from), to: square(checkerLast.to), ...snapshotLast && "captured" in snapshotLast && Array.isArray(snapshotLast.captured) ? { captured: snapshotLast.captured.map(square) } : {} } : snapshotLast ? snapshotLast : cribbageLast ? cribbageLast : match?.kind === "makao" && match.state.last ? { by_seat: match.state.last.seat, type: match.state.last.type, ...match.state.last.cards ? { cards: match.state.last.cards.map((c) => `${cardLabel(c)} (id ${c})`) } : {}, ...match.state.last.count !== void 0 && match.state.last.type !== "play" ? { count: match.state.last.count } : {}, ...match.state.last.announced ? { announced_makao: true } : {} } : asianLast ? { by_seat: asianLast.by, ...asianLast.from === null ? { type: "drop" } : { from: asianLast.from }, to: asianLast.to } : match?.kind === "oware" && match.state.last !== null ? { last_seed_in_pit: match.state.last + 1 } : millLast ? { by_seat: millLast.seat, ...millLast.from === null ? { type: "place" } : { type: "move", from: millLast.from }, at: millLast.to, ...millLast.captured.length ? { captured: millLast.captured } : {} } : last === null ? null : room.game === "connect-four" ? { column: last % columns + 1, row_from_top: Math.floor(last / columns) + 1 } : { row: Math.floor(last / columns) + 1, column: last % columns + 1 },
     ...room.game === "chess" ? { fen } : {},
     // The side to move is in check (chess family, xiangqi, shogi).
     ...match && room.phase === "playing" && (match.kind === "chess" ? chessPosition(match.state).inCheck() : "check" in match.state && match.state.check === true) ? { in_check: true } : {},
@@ -12510,13 +12588,29 @@ function labeledBoard(game, board) {
     ...board.map((row, r) => `${String(algebraic ? board.length - r : r + 1).padStart(rowWidth)} ${game === "hex" ? " ".repeat(Math.round(r * (cell + 1) / 2)) : ""}${[...row].map((p) => p.padStart(cell)).join(" ")}`)
   ];
 }
+function moveRejection(position, input) {
+  if (!position.turn?.yours) return "It is not your turn. ";
+  if (input.from === void 0) return "";
+  const wire = "legal_wire_actions" in position ? position.legal_wire_actions ?? [] : [];
+  const moves = [...position.legal_actions, ...wire].filter((a) => a.type === "move" && String(a.from) === input.from);
+  if (!moves.length) return `No legal move starts on ${input.from}. `;
+  const exact = moves.filter((a) => String(a.to) === input.to);
+  if (exact.length) return `${input.from} to ${input.to} is listed with promotion ${[...new Set(exact.map((a) => String(a.promotion ?? "none")))].join(" or ")}; pass --promotion exactly as listed. `;
+  return `${input.from} to ${input.to} is not legal now; from ${input.from} the legal destinations are ${[...new Set(moves.map((a) => String(a.to)))].join(", ")}. `;
+}
+function polishHandNote(round, count) {
+  const three = count === 3, total = 8 + count;
+  const hands = [`no tricks: ${three ? 15 : 20} off per trick taken`, "no hearts: 20 off per heart", "no queens: 60 off per queen", "no jacks or kings: 30 off each", `no king of hearts: ${three ? 140 : 150} off`, `no seventh or last trick: ${three ? 70 : 75} off each`, "robber: every penalty of hands 1\u20136 at once"];
+  const name = round < 7 ? hands[round] : round < 7 + count ? `trump contract chosen by the dealer: each trick taken scores +${three ? 20 : 25}` : "layout: build the four suit rows outward from the base rank (scoring as in the rules)";
+  return `Hand ${round + 1} of ${total}: ${name}.`;
+}
 function agentMove(position, input) {
   const action = position.legal_actions.find((a) => a.type === "swap" ? input.swap === true && Object.entries(input).every(([k, v]) => k === "swap" || v === void 0) : a.type === "edge" ? input.edge === a.edge && Object.entries(input).every(([k, v]) => k === "edge" || v === void 0) : a.type === "sow" ? input.pit === a.pit && Object.entries(input).every(([k, v]) => k === "pit" || v === void 0) : !input.swap && input.edge === void 0 && input.pit === void 0 && a.type === "move" ? input.column === void 0 && input.row === void 0 && a.from === input.from && a.to === input.to && a.promotion === input.promotion : a.type === "place" || a.type === "drop" ? !input.swap && input.edge === void 0 && input.pit === void 0 && input.from === void 0 && input.to === void 0 && input.promotion === void 0 && a.column === input.column && (a.type === "drop" ? input.row === void 0 : a.row === input.row) : false);
   if (!action && input.from !== void 0 && input.to !== void 0 && "legal_wire_actions" in position) {
     const wire = position.legal_wire_actions?.find((a) => a.type === "move" && String(a.from) === input.from && String(a.to) === input.to && (a.promotion === void 0 || a.promotion === input.promotion));
     if (wire) return wire;
   }
-  if (!action) throw Error("Choose an exact entry from legal_actions on your turn. Use --column for drops, --row/--column for placements, or --from/--to with explicit --promotion when listed.");
+  if (!action) throw Error(`${moveRejection(position, input)}Choose an exact entry from legal_actions on your turn. Use --column for drops, --row/--column for placements, or --from/--to with explicit --promotion when listed.`);
   if (action.type === "swap") return { type: "swap" };
   if (action.type === "edge") return { type: "place", at: action.edge - 1 };
   if (action.type === "sow") return { type: "sow", at: action.pit - 1 };
@@ -12558,6 +12652,10 @@ function agentWireMove(position, json) {
   if (!position.action_types.includes(action.type)) throw Error(`Choose a wire action type (${position.action_types.join(", ")}) from game rules, or pass an exact legal_actions entry.`);
   if (position.phase !== "playing" || position.you.left || position.paused) throw Error("This match is not active for your seat.");
   if (position.game === "go" && action.type === "accept" && action.scoreKey === void 0 && position.visible_state) action = { ...action, scoreKey: goProposalKey(position.visible_state) };
+  if (position.game === "categories" && ["submit", "stop", "vote", "expire"].includes(action.type) && position.visible_state) {
+    const state = position.visible_state;
+    action = { ...action, at: action.at ?? state.round, scoreKey: action.scoreKey ?? state.roundKey ?? void 0, ...Array.isArray(action.text) ? { text: JSON.stringify(action.text) } : {} };
+  }
   return action;
 }
 function sameFields(a, b) {
@@ -12811,7 +12909,9 @@ function nextStep(position, event, brief = false, server) {
   const room = `--room ${position.room}${server && server !== defaultServer ? ` --server ${server}` : ""}`, revision = position.revision, flag = brief ? " --brief" : "";
   const wait = `leafarcade game wait ${room} --after-revision ${revision} --timeout ${defaultWaitSeconds}${flag}`;
   if (position.you.left) return "You left this room. Create or join another room only if the human asks.";
-  if (position.phase === "finished") return `Match finished${position.outcome?.label ? ` (${position.outcome.label})` : ""}. Tell the human the result. Rematch only if they ask: leafarcade game rematch ${room} --revision ${revision}.`;
+  const won = position.outcome?.winner;
+  const result = won === void 0 || won === null ? position.phase === "finished" ? " Nobody won." : "" : won === position.you.seat ? " You won." : ` Seat ${won} (${position.players[won]?.name ?? "empty"}) won.`;
+  if (position.phase === "finished") return `Match finished${position.outcome?.label ? ` (${position.outcome.label})` : ""}.${result} Tell the human the result. Rematch only if they ask: leafarcade game rematch ${room} --revision ${revision}.`;
   if (position.paused) return `Paused. Stop and tell the human. Resume only when asked: leafarcade game resume ${room} --revision ${revision} (each player who paused must resume).`;
   if (position.phase === "waiting") {
     const host = position.you.seat === 0, seated = position.players.filter((p) => !p.left).length;
@@ -12935,7 +13035,7 @@ async function installSkill(agent = "codex", update = false) {
 // packages/cli/package.json
 var package_default = {
   name: "@leafarcade/cli",
-  version: "0.9.0",
+  version: "0.9.1",
   private: false,
   description: "Create private browser board games and play with your AI agent. Includes 53 games and an installable Codex/Claude skill.",
   type: "module",
@@ -13043,13 +13143,13 @@ var examples = {
   amazons: `--action '{"type":"move","from":30,"to":33,"amount":53}'`,
   "lines-of-action": `--action '{"type":"move","from":1,"to":17}'`,
   "last-greenhouse": `--action '{"type":"share"}'`,
-  euchre: "pass | trump --amount 0..3 [promotion alone] | discard/play --at CARD_ID | next. Use legal wire actions; card IDs use 24-card suit*6+rank encoding.",
+  euchre: `--action '{"type":"trump","amount":2}'`,
   cribbage: `--action '{"type":"discard","cards":[0,1]}'`,
   fanorona: `--action '{"type":"move","from":13,"to":22,"amount":0}'`,
-  categories: '{"type":"begin","promotion":"untimed"}',
-  cheat: '{"type":"play","cards":[0]}',
-  president: '{"type":"play","cards":[1]}',
-  rummy: '{"type":"stock"}',
+  categories: `--action '{"type":"begin","promotion":"untimed"}'`,
+  cheat: `--action '{"type":"play","cards":[0]}'`,
+  president: `--action '{"type":"play","cards":[1]}'`,
+  rummy: `--action '{"type":"stock"}'`,
   "connect-four": "--column 4",
   chess: "--from e2 --to e4",
   checkers: "--from b6 --to a5",
@@ -13712,6 +13812,27 @@ var scores = (position) => {
   return Array.isArray(value) && value.length && value.every((n) => typeof n === "number") ? value : null;
 };
 var withoutLegal = (state) => Object.fromEntries(Object.entries(state).filter(([key2]) => key2 !== "legalActions"));
+function groupedLegal(list) {
+  if (list.length <= 80 || !list.every((a) => a && typeof a === "object")) return null;
+  const groups = /* @__PURE__ */ new Map();
+  for (const action of list) {
+    const keys = Object.keys(action), last = keys.at(-1);
+    if (keys.length < 2 || last === "type") return null;
+    const head = Object.fromEntries(keys.slice(0, -1).map((k) => [k, action[k]])), id = JSON.stringify(head) + last;
+    const group = groups.get(id) ?? { ...head, [`${last}_choices`]: [] };
+    group[`${last}_choices`].push(action[last]);
+    groups.set(id, group);
+  }
+  return [...groups.values()].map((group) => {
+    const [name, choices] = Object.entries(group).find(([k]) => k.endsWith("_choices"));
+    const numbers = choices.every((n) => Number.isInteger(n)) ? choices.toSorted((a, b) => a - b) : null;
+    if (!numbers || numbers.length < 20 || numbers.some((n, i) => i && n !== numbers[i - 1] + 1)) return group;
+    const { [name]: _list, ...rest } = group;
+    void _list;
+    return { ...rest, [name.replace(/_choices$/, "_range")]: [numbers[0], numbers.at(-1)] };
+  });
+}
+var groupNote = "Grouped list: each entry gives the choices for its last field (*_choices, or *_range [min, max] inclusive). Send one action with a single value, e.g. column 4, not the list.";
 function briefPosition(position) {
   const turn = position.turn ? position.turn.yours ? "yours" : seatName(position, position.turn.seat) : null;
   const wire = "legal_wire_actions" in position ? position.legal_wire_actions ?? [] : null;
@@ -13734,7 +13855,8 @@ function briefPosition(position) {
     board_labeled: position.board_labeled,
     last_move: position.last_move,
     ..."changed_since_last_read" in position ? { changed_since_last_read: position.changed_since_last_read } : {},
-    ...wire ? { legal_wire_actions: wire, legal_wire_actions_complete: !!position.legal_wire_actions_complete } : { legal_actions: position.legal_actions, legal_actions_complete: position.legal_actions_complete },
+    ...wire ? { legal_wire_actions: groupedLegal(wire) ?? wire, legal_wire_actions_complete: !!position.legal_wire_actions_complete } : { legal_actions: groupedLegal(position.legal_actions) ?? position.legal_actions, legal_actions_complete: position.legal_actions_complete },
+    ...groupedLegal(wire ?? position.legal_actions) ? { legal_actions_grouped: groupNote } : {},
     // Card, tile and other games without a labeled board still need their seat-visible state.
     ..."deadline_seconds_left" in position ? { deadline_seconds_left: position.deadline_seconds_left } : {},
     ..."board_legend" in position ? { board_legend: position.board_legend } : {},
@@ -13843,8 +13965,10 @@ try {
       const goSize = integer(values["go-size"] ?? "9", "go-size", 9, 19);
       if (goSize !== 9 && goSize !== 13 && goSize !== 19) throw Error("go-size must be 9, 13 or 19.");
       result = await createRoom({ server, site: values.site ?? "https://leafarcade.com", game: values.game ?? "connect-four", name: values.name, capacity: values.capacity === void 0 ? void 0 : integer(values.capacity, "capacity", 2, 8), goSize, open: values.open, access: values.access, allowSpectators: !values["no-spectators"], brief: values.brief }, controller.signal);
-    } else if (command === "rules") result = agentRules(values.game);
-    else {
+    } else if (command === "rules") {
+      if (!values.game) throw Error("Pass --game GAME_ID (for example: leafarcade game rules --game thousand). leafarcade --help lists the game IDs.");
+      result = agentRules(values.game);
+    } else {
       const server = serviceUrl(values.server ?? defaultServer);
       if (command === "join" ? !positionals[1] : !values.room) throw Error(command === "join" ? 'Missing ROOMCODE. Usage: leafarcade join ROOMCODE --name "My agent"' : `Missing --room ROOMCODE. Usage: leafarcade game ${command} --room ROOMCODE. Saved rooms: leafarcade rooms.`);
       const room = roomCode(command === "join" ? positionals[1] : values.room);
@@ -13918,6 +14042,8 @@ try {
               const row = values.row === void 0 ? void 0 : integer(values.row, "row", 1, position.board_size.rows);
               if (revision !== position.revision) throw new ServiceError(`The room changed (now revision ${position.revision}). Read game status before playing.`, "STALE_REVISION");
               if (values.action && [values.column, values.row, values.from, values.to, values.promotion, values.edge, values.pit, values.swap].some((v) => v !== void 0)) throw Error("Use --action or convenience flags, not both.");
+              const grouped = values.action?.match(/"(\w+)_(?:choices|range)"/);
+              if (grouped) throw Error(`That entry is from a grouped list: replace the list with "${grouped[1]}" and one value from it.`);
               const action = values.action ? agentWireMove(position, values.action) : agentMove(position, { column, row, from: values.from, to: values.to, promotion: values.promotion, swap: values.swap, edge: values.edge === void 0 ? void 0 : integer(values.edge, "edge", 1, 1e3), pit: values.pit === void 0 ? void 0 : integer(values.pit, "pit", 1, 12) });
               const waitSeconds = integer(values.timeout ?? String(defaultWaitSeconds), "timeout", 1, 3600);
               await rpc(session, "play", { revision, action }, false, controller.signal);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leafarcade/cli",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "private": false,
   "description": "Create private browser board games and play with your AI agent. Includes 53 games and an installable Codex/Claude skill.",
   "type": "module",

package/skills/leafarcade/SKILL.md

@@ -24,7 +24,7 @@ leafarcade game create --game connect-four --name "My agent"     # add --open on
 
 Every JSON response has a `next` field with the exact command to run next. Follow it.
 
-Add `--brief` to `status`, `wait`, `start` and `play`. It returns only `status` (room, revision, phase, your piece, whose turn, outcome), `board_labeled`, `last_move`, the legal moves and `next`, which keeps the flag. Games without a labeled board (cards, tiles) also get `visible_state`. Drop `--brief` once if you need the full position: player list, raw state or rules.
+Add `--brief` to `status`, `wait`, `start` and `play`. It returns only `status` (room, revision, phase, your piece, whose turn, outcome), `board_labeled`, `last_move`, the legal moves and `next`, which keeps the flag. Games without a labeled board (cards, tiles) also get `visible_state`. Long move lists (more than 80, such as Gomoku or Amazons) are grouped in `--brief`: `{"type":"place","row":3,"column_choices":[1,2,5]}` means row 3 with any of those columns; send one value (`--row 3 --column 2`). Drop `--brief` once if you need the full position: player list, raw state or rules.
 
 `leafarcade help games` lists game IDs. `--capacity N` picks a supported table size; the default is the game's minimum. Each additional agent needs its own `LEAFARCADE_CONFIG_DIR` and seat.
 
@@ -35,7 +35,7 @@ When the human already has a room code, use `leafarcade join ROOMCODE --name "My
 ## The play loop
 
 - **Wait on the table yourself.** After your move, use `play --wait` or `game wait`. Never ask the human to tell you they moved.
-- Read `game rules --game GAME_ID` once. On your turn, `board_labeled` shows the board with the same row/column numbers as the move flags, and `last_move` shows the opponent's last move in board games (null in most card games; read `changed_since_last_read` there). Some games add hints: `rule_notes` (rules in force now, such as Thousand's 800 rule), `gin_deadwood` and `sixty_six_unseen` (cards you have not seen this deal).
+- Read `game rules --game GAME_ID` once. On your turn, `board_labeled` shows the board with the same row/column numbers as the move flags, and `last_move` shows the latest move in board games with `by_seat` and any `captured` squares (null in most card games; read `changed_since_last_read` there). In `legal_actions`, rows, columns, pits and edges count from 1, as the move flags do; the zero-based `at` in the help is the wire form the CLI converts to. Some games add hints: `rule_notes` (rules in force now, such as Thousand's 800 rule, three-check counts or the Dice upper bonus), `gin_deadwood` and `sixty_six_unseen` (cards you have not seen this deal).
 - Before each move in line games (Connect Four, tic-tac-toe, gomoku, hex), check two things across every row, column and **both diagonals**. First, can you win now? Second, does the opponent threaten to win next turn?
 - Most games list every legal move. With `legal_actions_complete` or `legal_wire_actions` (complete unless `legal_wire_actions_complete` is false), choose a listed entry and pass it unchanged: `--action '{"type":"bid","amount":120}'`. A partial list (melds, trade offers, raise amounts, bluffs) shows examples; build other moves from `game rules`. Wire indexes are zero-based; the convenience flags are one-based.
 - Card games add `cards_labeled` (for example `"hands.1": ["Q♠ (id 49)", …]`): read card names there, not from raw IDs. Index boards (Go, shogi, draughts, Amazons) label rows with the index of their first cell, so `at` = row label + column offset; `board_legend` explains the symbols.