@leafarcade/cli 0.8.0 → 0.9.1

package/dist/cli.mjs

@@ -3754,6 +3754,21 @@ function asianLastMove(history) {
   const from = a.findIndex((cell, i) => cell.startsWith(mine) && !b[i].startsWith(mine));
   return { from: from < 0 ? null : from, to };
 }
+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) {
@@ -3792,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],
@@ -4271,13 +4541,22 @@ function createGin(entropy2) {
 }
 function playGin(s, type, at, entropy2) {
   if (type === "next" && s.phase === "round")
-    return deal2(
-      s.result.startsWith("Stock") ? s.dealer : 1 - s.dealer,
-      s.scores,
-      s.wins,
-      s.round + 1,
-      entropy2
-    );
+    return {
+      ...deal2(
+        s.result.startsWith("Stock") ? s.dealer : 1 - s.dealer,
+        s.scores,
+        s.wins,
+        s.round + 1,
+        entropy2
+      ),
+      previous: [
+        s.result,
+        ...s.hands.map((h, i) => {
+          const layout = ginLayout(h);
+          return `Player ${i + 1}: melds ${layout.melds.map((m) => m.map(cardLabel).join(" ")).join(" \xB7 ") || "none"}; deadwood ${layout.deadwood.map(cardLabel).join(" ") || "none"} (${layout.value}).`;
+        })
+      ].join(" ")
+    };
   if (["finished", "round"].includes(s.phase))
     throw Error("This round is finished.");
   const t = structuredClone(s), seat = s.turn;
@@ -4396,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. Remaining kitty cards 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",
@@ -4516,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. 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",
@@ -4628,7 +4907,7 @@ var multiplayerGames = [
     symbol: "\u25CC",
     players: "2 players",
     description: "Sow seeds. Capture twos and threes.",
-    rules: "Each of twelve pits starts with four seeds. Sow counterclockwise, skipping the starting pit on a full lap. Ending on an opposing pit with two or three seeds captures it and preceding opposing pits with two or three. Captures that empty the entire opposing row are cancelled. Feed an empty opponent if possible. More than 24 captured seeds wins. No legal feeding move or three repetitions ends play; remaining seeds go to their owners."
+    rules: "Each of twelve pits starts with four seeds. Sow counterclockwise, skipping the starting pit on a full lap. Ending on an opposing pit with two or three seeds captures it and preceding opposing pits with two or three. Captures that would empty the entire opposing row (a grand slam) are cancelled. Feed an empty opponent if possible. More than 24 captured seeds wins. No legal feeding move or three repetitions ends play; remaining seeds go to their owners."
   },
   {
     id: "mills",
@@ -4991,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.",
@@ -5100,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.",
@@ -5226,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;
@@ -5726,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) {
@@ -5752,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;
@@ -5801,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;
 }
@@ -5896,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);
@@ -5914,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) {
@@ -7703,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;
@@ -8299,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(
@@ -8316,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
@@ -8323,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);
@@ -8708,7 +8758,7 @@ var adapter5 = defineMatchAdapter({
     return {
       finished: state.winner !== null || state.draw,
       winner: state.winner,
-      label: state.draw ? "Draw" : state.winner !== null ? `Player ${state.winner + 1} wins \xB7 the opponent has no legal move.` : ""
+      label: state.draw ? drawReason(state.history) : state.winner !== null ? `Player ${state.winner + 1} wins \xB7 the opponent has no legal move.` : ""
     };
   },
   apply(state, _seat, action, _entropy, _now) {
@@ -8726,7 +8776,7 @@ var adapter6 = defineMatchAdapter({
   actions: ["move", "sequence"],
   create: () => createInternational(),
   turn: (s) => s.turn,
-  outcome: (s) => ({ finished: s.winner !== null || s.draw, winner: s.winner, label: s.draw ? "Draw" : s.winner !== null ? `Player ${s.winner + 1} wins \xB7 the opponent has no legal move.` : "" }),
+  outcome: (s) => ({ finished: s.winner !== null || s.draw, winner: s.winner, label: s.draw ? drawReason(s.history) : s.winner !== null ? `Player ${s.winner + 1} wins \xB7 the opponent has no legal move.` : "" }),
   apply(s, _seat, a) {
     if (a.type === "move" && typeof a.from === "number" && typeof a.to === "number") return moveInternational(s, a.from, a.to);
     if (a.type === "sequence" && Array.isArray(a.cards) && a.cards.length >= 2 && a.cards.length <= 21) {
@@ -9061,6 +9111,7 @@ function playThousand(s, a, entropy2) {
   if (a.type === "next" && s.phase === "round") {
     t.round++;
     t.dealer = (s.dealer + 1) % s.hands.length;
+    t.previous = s.result;
     return deal6(t, entropy2);
   }
   if (a.type === "redeal" && s.phase === "auction" && s.hands[seat].filter((c) => cardRank(c) === 9).length === 4)
@@ -9107,9 +9158,9 @@ function playThousand(s, a, entropy2) {
     return t;
   }
   if (a.type === "bomb" && ["kitty", "exchange", "declare"].includes(s.phase)) {
-    if (t.bombs[seat]++ > 0)
-      t.players.filter((i) => i !== seat && t.scores[i] < 800).forEach((i) => t.scores[i] += t.hands.length === 4 ? 40 : 60);
-    t.result = "Declarer cancels the hand with a bomb.";
+    const penalty2 = t.bombs[seat]++ > 0 ? t.hands.length === 4 ? 40 : 60 : 0;
+    t.players.filter((i) => i !== seat && t.scores[i] < 800).forEach((i) => t.scores[i] += penalty2);
+    t.result = `Player ${seat + 1} cancels the hand with a bomb${penalty2 ? `; the other players score ${penalty2}` : " (the first bomb is free)"}.`;
     finish4(t);
     return t;
   }
@@ -9154,10 +9205,12 @@ function playThousand(s, a, entropy2) {
         (n, c) => n + pointValue(cardRank(c)),
         0
       );
+      const before = t.scores;
       t.scores = t.scores.map(
         (n, i) => i === t.bidder ? n + (t.points[i] >= t.contract ? t.contract : -t.contract) : t.players.includes(i) && n < 800 ? n + Math.round(t.points[i] / 10) * 10 : n
       );
-      t.result = `Hand points ${t.points.join(" / ")} \xB7 Contract ${t.contract}.`;
+      const made = t.points[t.bidder] >= t.contract, change = (i) => `${t.scores[i] - before[i] >= 0 ? "+" : ""}${t.scores[i] - before[i]}`;
+      t.result = `Player ${t.bidder + 1} ${made ? "makes" : "fails"} ${t.contract} with ${t.points[t.bidder]} (${change(t.bidder)}). ${t.players.filter((i) => i !== t.bidder).map((i) => `Player ${i + 1} ${t.points[i]} points (${before[i] >= 800 ? "not scored: 800 rule" : change(i)})`).join(", ")}.`;
       finish4(t);
     }
     return t;
@@ -10413,6 +10466,7 @@ function playMakao(s, a, entropy2) {
   const t = structuredClone(s), seat = s.turn;
   if (a.type === "catch" && s.unannounced !== null && s.unannounced !== seat) {
     draw(t, s.unannounced, 5, entropy2);
+    t.last = { seat: s.unannounced, type: "caught", count: 5 };
     t.unannounced = null;
     t.result = "Missed Makao: draw five.";
     return t;
@@ -10421,12 +10475,13 @@ function playMakao(s, a, entropy2) {
     t.unannounced = null;
     if (s.wait) {
       t.blocked[seat] = s.wait - 1;
+      t.last = { seat, type: "wait", count: s.wait };
       t.wait = 0;
       advance3(t);
       return t;
     }
     if (s.penalty) {
-      draw(t, seat, s.penalty, entropy2);
+      t.last = { seat, type: "penalty", count: draw(t, seat, s.penalty, entropy2).length };
       t.penalty = 0;
       t.suit = null;
       advance3(t);
@@ -10434,11 +10489,13 @@ function playMakao(s, a, entropy2) {
     }
     const received = draw(t, seat, 1, entropy2);
     t.drawn = received[0] ?? null;
+    t.last = { seat, type: "draw", count: received.length };
     t.phase = "drawn";
     if (t.drawn === null) advance3(t);
     return t;
   }
   if (a.type === "pass" && s.phase === "drawn") {
+    t.last = { seat, type: "keep", count: 1 };
     t.unannounced = null;
     t.suit = null;
     advance3(t);
@@ -10453,6 +10510,7 @@ function playMakao(s, a, entropy2) {
     throw Error("Request an ordinary rank, or choose no demand.");
   t.unannounced = null;
   t.hands[seat] = t.hands[seat].filter((c) => !cards.includes(c));
+  t.last = { seat, type: "play", cards: [...cards], ...t.hands[seat].length === 1 && a.promotion === "makao" ? { announced: true } : {} };
   t.pile.push(...cards);
   t.suit = null;
   if (rank2 === 14) t.suit = a.amount;
@@ -11187,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
@@ -11262,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;
@@ -11406,7 +11465,7 @@ function panLegal(s, cards) {
 }
 function playPan(s, type, cards, entropy2) {
   if (type === "next" && s.phase === "round")
-    return deal12(s.hands.length, entropy2, s.letters, s.round + 1);
+    return { ...deal12(s.hands.length, entropy2, s.letters, s.round + 1), previous: s.result };
   if (s.phase !== "play") throw Error("This round is finished.");
   const t = structuredClone(s), seat = s.turn;
   if (type === "play" && panLegal(s, cards)) {
@@ -11560,7 +11619,7 @@ function award2(t, winner2, failure = false) {
 }
 function playSixtySix(s, type, at, marriage = false, claimMarriage = false, entropy2) {
   if (type === "next" && s.phase === "round")
-    return deal13(1 - s.dealer, s.scores, s.round + 1, entropy2);
+    return { ...deal13(1 - s.dealer, s.scores, s.round + 1, entropy2), previous: s.result };
   if (s.phase !== "play") throw Error("This round is finished.");
   const t = structuredClone(s), seat = s.turn;
   if (type === "close" && !s.trick.length && s.closed === null && s.upcard !== null) {
@@ -11605,6 +11664,7 @@ function playSixtySix(s, type, at, marriage = false, claimMarriage = false, entr
     t.tricks[winner2]++;
     t.turn = winner2;
     t.lastTrick = t.trick;
+    t.played = [...s.played ?? [], ...t.trick.map((c) => c.card)];
     t.trick = [];
     if (t.closed === null && t.upcard !== null)
       for (const i of [winner2, 1 - winner2]) {
@@ -11746,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,
@@ -11756,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);
@@ -11775,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));
@@ -11794,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,
@@ -11802,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;
@@ -12117,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"]) {
@@ -12144,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"]);
@@ -12198,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 [];
@@ -12407,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})`);
@@ -12425,11 +12522,19 @@ 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.`] : []) : 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})`);
+  })() : null;
   const asianMove = match?.kind === "shogi" || match?.kind === "xiangqi" ? asianLastMove(match.state.history) : null;
   const asianLast = asianMove && (match?.kind === "shogi" || match?.kind === "xiangqi") ? { ...asianMove, by: match.state.history.at(-1).mover } : null;
   const millLast = match?.kind === "mills" ? millLastTurn(match.state) : null;
-  const cribbageCard = match?.kind === "cribbage" && match.state.phase === "peg" ? match.state.sequence.at(-1) : void 0;
-  const cribbageLast = match?.kind === "cribbage" && cribbageCard !== void 0 ? { by_seat: match.state.played.findIndex((cards) => cards.includes(cribbageCard)), played: `${cribbageLabel(cribbageCard)} (id ${cribbageCard})`, count: match.state.total } : null;
+  const peg = match?.kind === "cribbage" && match.state.phase === "peg" ? match.state.lastPeg : void 0;
+  const cribbageLast = peg ? { by_seat: peg.seat, ...peg.go ? { type: "go" } : { played: `${cribbageLabel(peg.card)} (id ${peg.card})` }, count: peg.count, ...peg.count === 31 || match?.kind === "cribbage" && match.state.total === 0 && peg.count > 0 ? { count_reset: true } : {} } : null;
   return {
     protocol_version: 1,
     room: room.code,
@@ -12444,16 +12549,18 @@ 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 : 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 } : {},
     visible_state: match?.state ?? null,
     cards_labeled: match ? cardsLabeled(room.game, match.state) : null,
     ...ginHint ? { gin_deadwood: ginHint } : {},
+    ...sixtyUnseen ? { sixty_six_unseen: sixtyUnseen } : {},
+    ...ruleNotes.length ? { rule_notes: ruleNotes } : {},
     // Timed rounds (drawing, categories): agents cannot measure time, so give the remaining seconds.
     ...typeof match?.state?.deadline === "number" && room.serverNow ? { deadline_seconds_left: Math.max(0, Math.ceil((match.state.deadline - room.serverNow) / 1e3)) } : {},
     action_types: action_catalog_default[room.game],
@@ -12481,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 };
@@ -12529,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) {
@@ -12782,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;
@@ -12795,7 +12924,7 @@ function nextStep(position, event, brief = false, server) {
   const play = (move2) => `leafarcade game play ${room} --revision ${revision} --action ${move2}`;
   if (wire?.length && !position.turn?.yours) return `You may act now (phase action outside the normal turn): ${play("'<one legal_wire_actions entry>'")}${flag}. Otherwise wait: ${wait}`;
   if (position.turn?.yours) {
-    if (wire?.length === 1 && wire[0].type === "next" && Object.keys(wire[0]).length === 1) return `The hand is over; start the next one (the deal moves on): ${play(`'{"type":"next"}'`)} --wait${flag}`;
+    if (wire?.length === 1 && wire[0].type === "next" && Object.keys(wire[0]).length === 1) return `The hand is over and you deal the next one: ${play(`'{"type":"next"}'`)} --wait${flag}`;
     const partial = !wire && position.legal_wire_actions?.length ? "Some legal actions are listed in legal_wire_actions, but the list is not exhaustive (see game rules for melds, offers, amounts or card groups). " : "";
     const move2 = wire ? "'<one legal_wire_actions entry>'" : position.legal_actions_complete ? "'<one legal_actions entry>'" : "'<wire action JSON from game rules>'";
     const check = lineGames.includes(position.game) ? "Check your immediate win and your opponent's immediate threats (every line, including diagonals), then: " : "";
@@ -12803,12 +12932,19 @@ function nextStep(position, event, brief = false, server) {
       state?.penalty ? `A ${state.penalty}-card penalty is active: answer with a matching attack card, or draw takes all ${state.penalty}. ` : "",
       state?.wait ? `A ${state.wait}-turn wait is active: answer with a 4, or draw serves the wait (no cards drawn). ` : "",
       state?.blocked?.[position.you.seat] ? `You are blocked for ${state.blocked[position.you.seat]} more turn(s). ` : "",
-      state?.demand !== null && state?.demand !== void 0 ? `Jack demand in force: ${state.demand === 13 ? "king" : `rank ${state.demand}`}. ` : "",
-      state?.suit !== null && state?.suit !== void 0 ? `Ace suit in force: ${["clubs", "diamonds", "hearts", "spades"][state.suit]}. ` : ""
+      state?.demand !== null && state?.demand !== void 0 ? `Jack demand in force: ${state.demand === 13 ? "king" : `rank ${state.demand}`}, or answer with a jack${state.demandTurns ? ` (${state.demandTurns} turn(s) left)` : ""}. ` : "",
+      state?.suit !== null && state?.suit !== void 0 ? `Ace suit in force: ${["clubs", "diamonds", "hearts", "spades"][state.suit]}. ` : "",
+      state?.phase === "drawn" && state.drawn !== null && state.drawn !== void 0 ? `You drew ${cardLabel(state.drawn)} (id ${state.drawn}): play it if it is listed, otherwise pass to keep it. ` : "",
+      wire?.some((action) => action.type === "play" && Array.isArray(action.cards) && action.cards.length === (state?.hands?.[position.you.seat]?.length ?? 0) - 1) ? 'A play that leaves you one card must use its entry with "promotion":"makao", or the opponent can make you draw five. ' : ""
     ].join(""))(position.visible_state) : "";
+    const chain = position.visible_state?.chain;
+    const jumper = (position.legal_actions?.[0] ?? wire?.[0])?.from;
+    const capture = chain !== null && chain !== void 0 && jumper !== void 0 ? `Your capture continues: jump again with the piece on ${String(jumper)} (one jump per call). ` : "";
     const mill = position.game === "mills" && wire?.length && wire.every((action) => action.type === "capture") ? "You completed a mill: remove one opposing piece (only pieces outside mills, unless all are in mills). " : "";
-    return `Your move. ${mill}${makao}${partial}${check}${play(move2)} --wait${flag}`;
+    return `Your move. ${capture}${mill}${makao}${partial}${check}${play(move2)} --wait${flag}`;
   }
+  const dealing = ["round", "show"].includes(String(position.visible_state?.phase));
+  if (dealing && position.turn) return `The hand is over; seat ${position.turn.seat} (${position.players[position.turn.seat]?.name ?? "empty"}) deals the next one. Do not send next yourself. Wait: ${wait}`;
   if (event === "waiting") return `No change yet. If the other players are still playing, wait again: ${wait}. After several silent waits, stop and tell the human how to resume.`;
   const outOfTurn = position.legal_actions_complete || position.legal_wire_actions_complete ? "" : " Some phases allow out-of-turn actions; check game rules for this phase first.";
   const mover = position.turn ? ` (seat ${position.turn.seat}, ${position.players[position.turn.seat]?.name ?? "empty"}, to act)` : "";
@@ -12899,7 +13035,7 @@ async function installSkill(agent = "codex", update = false) {
 // packages/cli/package.json
 var package_default = {
   name: "@leafarcade/cli",
-  version: "0.8.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",
@@ -13007,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",
@@ -13195,6 +13331,15 @@ function stateChanges(game, before, after, limit = 30) {
     const here = path.join(".");
     const primitive = (v) => v === null || typeof v !== "object";
     if (Array.isArray(a) && Array.isArray(b)) {
+      if (a.length && b.length && [...a, ...b].every((v) => typeof v === "string")) {
+        for (let k = 0; k < a.length; k++) {
+          const kept = a.slice(k);
+          if (kept.every((v, i) => v === b[i]) && b.length > kept.length) {
+            out2.push(`${here}: + ${b.slice(kept.length).map((v) => show(v)).join(", ")}`);
+            return;
+          }
+        }
+      }
       if (a.length === b.length && a.length > 4 && a.every(primitive) && b.every(primitive)) {
         a.forEach((v, i) => {
           if (v !== b[i] && out2.length <= limit) out2.push(`${here}[${i}]: ${show(v)} \u2192 ${show(b[i])}`);
@@ -13666,6 +13811,28 @@ var scores = (position) => {
   const value = position.visible_state?.scores;
   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;
@@ -13688,14 +13855,18 @@ 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 } : {},
     // Only the classic convenience games are fully described by their labeled board.
-    ...position.legal_actions_complete && position.board_labeled || !position.visible_state ? {} : { visible_state: position.visible_state },
+    // The legal moves are listed once at the top level, not again inside the state.
+    ...position.legal_actions_complete && position.board_labeled || !position.visible_state ? {} : { visible_state: withoutLegal(position.visible_state) },
     ...position.cards_labeled ? { cards_labeled: position.cards_labeled } : {},
     ..."gin_deadwood" in position ? { gin_deadwood: position.gin_deadwood } : {},
+    ..."sixty_six_unseen" in position ? { sixty_six_unseen: position.sixty_six_unseen } : {},
+    ..."rule_notes" in position ? { rule_notes: position.rule_notes } : {},
     ...position.access_requests?.length ? { access_requests: position.access_requests } : {}
   };
 }
@@ -13794,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);
@@ -13869,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);