pokertools-arena 0.17.0 → 0.17.1

package/README.md

@@ -17,7 +17,7 @@
 | **Package** | `npx pokertools-arena` |
 | **Runtime** | Node.js ≥ 24 for tooling; any modern browser for the app |
 
-> **Current release: 0.17.0.** Seats on OpenRouter models that advertise reasoning efforts can now pick a per-seat reasoning effort, so a slow reasoner such as DeepSeek can be lowered from its `high` default to `low` instead of exhausting the action clock and being auto-folded.
+> **Current release: 0.17.1.** A mid-hand all-in no longer aborts the tournament: the decision-context player count now tracks non-eliminated seats instead of stacks, and any context failure falls back to a deterministic safe action so the game continues.
 
 ---
 

package/dist/app.js

@@ -114662,6 +114662,13 @@ function playerCards(player) {
 function playerStack(player) {
   return asNumber(player?.stack ?? player?.chips ?? 0);
 }
+function playersStillInTournament(players, eliminatedPlayerIds = []) {
+  const eliminated = new Set(eliminatedPlayerIds ?? []);
+  return (players ?? []).filter((player) => player?.id && !eliminated.has(player.id));
+}
+function playersWithChips(players) {
+  return (players ?? []).filter((player) => player && playerStack(player) > 0);
+}
 function currentBet(state, seat) {
   return asNumber(mapGet(state?.currentBets, seat, state?.players?.[seat]?.bet ?? 0));
 }
@@ -114909,7 +114916,7 @@ function assertDecisionState(state) {
     }
   }
   const expectedRemaining = 1 + state.opponents.length;
-  if (Number(state.tournament?.playersRemaining) !== expectedRemaining) throw new Error(`playersRemaining mismatch: expected ${expectedRemaining}, got ${state.tournament?.playersRemaining}`);
+  if (Number(state.tournament?.playersRemaining) !== expectedRemaining) throw new Error(`playersRemaining mismatch: expected ${expectedRemaining} (hero plus ${state.opponents.length} non-eliminated opponents), got ${state.tournament?.playersRemaining}`);
   return state;
 }
 function extractTextContent(message) {
@@ -116640,7 +116647,7 @@ var TournamentDirector = class {
     for (const player of this.config.players) {
       this.engine.sit(player.seat, player.id, player.name, this.config.startingStack);
       this.timeBanks[player.id] = this.config.timeBankSeconds * 1e3;
-      this.stats[player.id] = { decisions: 0, invalid: 0, modelErrors: 0, providerErrors: 0, rateLimits: 0, timeouts: 0, autoFallbacks: 0, protocolFallbacks: 0, retries: 0, totalLatencyMs: 0, lastAction: null, lastActionType: null, lastActionAmount: null, lastReason: "" };
+      this.stats[player.id] = { decisions: 0, invalid: 0, modelErrors: 0, providerErrors: 0, rateLimits: 0, timeouts: 0, autoFallbacks: 0, contextErrors: 0, protocolFallbacks: 0, retries: 0, totalLatencyMs: 0, lastAction: null, lastActionType: null, lastActionAmount: null, lastReason: "" };
     }
     this.logEvent("TOURNAMENT_START", { config: this.publicConfig() });
     this.broadcast();
@@ -116684,8 +116691,15 @@ var TournamentDirector = class {
     while (this.status === "PAUSED") await new Promise((resolve) => this.pauseResolvers.push(resolve));
     if (this.status === "STOPPED") throw new Error("Tournament stopped");
   }
+  // Decision-context/table count: seated players that are not eliminated. Must
+  // equal `1 + non-eliminated opponents` in serializeForAgent, so it must NOT be
+  // derived from stacks — an all-in player has stack 0 mid-hand and is still in.
   playersRemaining() {
-    return (this.engine?.state?.players ?? []).map((p, seat) => ({ p, seat })).filter(({ p }) => p && playerStack(p) > 0);
+    return playersStillInTournament(this.engine?.state?.players, this.eliminations.map((e) => e.playerId));
+  }
+  // Tournament-end / place accounting: seats that can still contest chips.
+  playersWithChips() {
+    return playersWithChips(this.engine?.state?.players);
   }
   tournamentMeta() {
     const startingPlayers = this.config?.players.length ?? 0;
@@ -116752,9 +116766,9 @@ var TournamentDirector = class {
   async run() {
     while (["RUNNING", "PAUSED"].includes(this.status)) {
       await this.waitIfPaused();
-      const remaining = this.playersRemaining();
+      const remaining = this.playersWithChips();
       if (remaining.length <= 1) {
-        this.finish(remaining[0]?.p ?? null);
+        this.finish(remaining[0] ?? null);
         return;
       }
       if (this.handNumber > 0 && this.handNumber % this.config.handsPerLevel === 0) {
@@ -116765,10 +116779,18 @@ var TournamentDirector = class {
           this.logEvent("BLINDS_UP_FAILED", { error: summarizeError(err) });
         }
       }
-      await this.startHand();
-      await this.playHand();
-      this.completeHand();
-      this.broadcast();
+      try {
+        await this.startHand();
+        await this.playHand();
+        this.completeHand();
+        this.broadcast();
+        this.handErrorStreak = 0;
+      } catch (err) {
+        if (this.status === "STOPPED" || err?.name === "AbortError") throw err;
+        await this.recoverHand(err);
+        this.handErrorStreak = (this.handErrorStreak || 0) + 1;
+        if (this.handErrorStreak >= 3) throw err;
+      }
       if (this.budgetReached) {
         this.logEvent("DECISION_BUDGET_REACHED", { decisions: this.decisionCount, budget: this.decisionBudget });
         this.stop();
@@ -116778,6 +116800,52 @@ var TournamentDirector = class {
       await sleep(Math.max(WINNER_REVIEW_MS, this.config.betweenHandsMs));
     }
   }
+  // Last-resort safety net for a hand. A model failure or a decision-context
+  // failure is already handled inside the hand loop; anything else that escapes
+  // (a future regression) would otherwise abort the whole tournament mid-game.
+  // Here the hand is finished with deterministic safe actions so the tournament
+  // continues. Recovery is bounded by the hand-action guard and by the caller's
+  // streak counter, so a genuinely broken engine still surfaces as an error
+  // instead of looping forever.
+  async recoverHand(triggerError) {
+    this.currentDecision = null;
+    if (this.handComplete()) {
+      this.broadcast();
+      return;
+    }
+    this.logEvent("HAND_RECOVERY", { handNumber: this.handNumber, street: this.engine?.state?.street ?? null, error: summarizeError(triggerError) });
+    this.broadcast();
+    let guard = 0;
+    while (!this.handComplete()) {
+      if (++guard > 500) throw new Error("Hand recovery guard exceeded 500 actions");
+      await this.waitIfPaused();
+      const state = this.engine.state, seat = state.actionTo;
+      if (seat == null) {
+        if (Array.isArray(state.winners) && state.winners.length) break;
+        await sleep(10);
+        continue;
+      }
+      const player = state.players?.[seat];
+      if (!player) break;
+      if (state.street === "SHOWDOWN") {
+        const show = { type: ACTION.SHOW, playerId: player.id, cardIndices: [0, 1] };
+        if (this.engine.validate(show)?.valid) {
+          this.engine.act(show);
+          continue;
+        }
+        const muck = { type: ACTION.MUCK, playerId: player.id };
+        if (this.engine.validate(muck)?.valid) {
+          this.engine.act(muck);
+          continue;
+        }
+      }
+      if (!this.forceSafeAction(seat, { error: triggerError, errorCategory: "recovery" })) break;
+      this.broadcast();
+    }
+    if (!this.handComplete()) throw triggerError;
+    this.completeHand();
+    this.broadcast();
+  }
   pruneBustedSeats() {
     const failures = [];
     for (const p of this.engine?.state?.players ?? []) {
@@ -116858,22 +116926,31 @@ var TournamentDirector = class {
   }
   async takeDecision(agent, seat, legalActions) {
     const decisionId = id(`d-h${this.handNumber}-s${seat + 1}`), baseMs = this.config.actionSeconds * 1e3, bankBefore = this.timeBanks[agent.id] ?? 0, totalMs = baseMs + bankBefore;
+    const stats = this.stats[agent.id];
+    const connection = this.config.connections.find((c) => c.id === agent.connectionId);
+    const architecture = this.config.decisionArchitecture === DECISION_ARCHITECTURES.FLAT ? "flat" : "hierarchical";
     const recentHands = buildPublicTournamentMemory(this.events, this.handNumber);
     const publicPlayerStats = buildPublicPlayerStats(this.events, this.config.players, this.handNumber);
     const actionHistory = buildCurrentHandPublicActions(this.events, this.handNumber);
-    const baseState2 = serializeForAgent(this.engine, seat, this.tournamentMeta(), legalActions, recentHands, publicPlayerStats, actionHistory);
-    const stateForAgent = assertDecisionState(applyBenchmarkMode(baseState2, this.config.benchmarkMode)), startedAt = Date.now();
-    const connection = this.config.connections.find((c) => c.id === agent.connectionId);
-    const architecture = this.config.decisionArchitecture === DECISION_ARCHITECTURES.FLAT ? "flat" : "hierarchical";
     const sizesForFamily = (family) => legalAggressiveSizes(this.engine, seat, family);
-    let hierarchy = null;
-    if (architecture === "hierarchical") {
-      hierarchy = buildHierarchicalDecision(stateForAgent, { legalActions: stateForAgent.legalActions });
-      if (hierarchy.aggressiveFamily) {
-        const engineSizes = sizesForFamily(hierarchy.aggressiveFamily);
-        hierarchy.stage2 = { ...hierarchy.stage2, sizes: engineSizes, criteria: sizeCriteria(engineSizes) };
+    let stateForAgent = null, hierarchy = null;
+    try {
+      stateForAgent = assertDecisionState(applyBenchmarkMode(
+        serializeForAgent(this.engine, seat, this.tournamentMeta(), legalActions, recentHands, publicPlayerStats, actionHistory),
+        this.config.benchmarkMode
+      ));
+      if (architecture === "hierarchical") {
+        hierarchy = buildHierarchicalDecision(stateForAgent, { legalActions: stateForAgent.legalActions });
+        if (hierarchy.aggressiveFamily) {
+          const engineSizes = sizesForFamily(hierarchy.aggressiveFamily);
+          hierarchy.stage2 = { ...hierarchy.stage2, sizes: engineSizes, criteria: sizeCriteria(engineSizes) };
+        }
       }
+    } catch (contextError) {
+      if (!this.forceSafeAction(seat, { error: contextError, errorCategory: "context", decisionId })) throw contextError;
+      return;
     }
+    const startedAt = Date.now();
     this.currentDecision = {
       id: decisionId,
       playerId: agent.id,
@@ -116900,7 +116977,6 @@ var TournamentDirector = class {
     };
     this.logEvent("DECISION_START", this.currentDecision);
     this.broadcast();
-    const stats = this.stats[agent.id];
     let result = null, error = null, errorCategory = null, elapsed = 0;
     const pausedTotal = () => (this.currentDecision?.pausedMs || 0) + (this.currentDecision?.pausedAt ? Math.max(0, Date.now() - this.currentDecision.pausedAt) : 0);
     const recordIncident = (incident) => {
@@ -117074,6 +117150,72 @@ var TournamentDirector = class {
     }
     this.currentDecision = null;
   }
+  // Deterministic safe action for one seat, used whenever a decision cannot be
+  // produced (context failure or emergency hand recovery). It always picks a
+  // legal engine action, records a normal DECISION event so public action
+  // history, replay and stats stay complete, and marks the row `forced`. It
+  // never consults a model and never sees masked-out information.
+  // Returns the chosen action, or null when the seat has no legal action.
+  forceSafeAction(seat, { error = null, errorCategory = "context", decisionId = null } = {}) {
+    const state = this.engine.state;
+    const player = state.players?.[seat];
+    if (!player) return null;
+    const legalActions = legalActionCandidates(this.engine, seat);
+    const chosen = fallbackAction(legalActions);
+    if (!chosen) return null;
+    this.engine.act(chosen.engineAction);
+    const agent = (this.config?.players ?? []).find((p) => p.id === player.id) ?? null;
+    const connection = agent ? this.config.connections.find((c) => c.id === agent.connectionId) ?? null : null;
+    const stats = this.stats?.[player.id];
+    if (stats) {
+      stats.decisions++;
+      stats.autoFallbacks++;
+      stats.contextErrors = (stats.contextErrors || 0) + 1;
+      stats.lastAction = chosen.description;
+      stats.lastActionType = chosen.type;
+      stats.lastActionAmount = chosen.amount ?? null;
+      stats.lastReason = `Automatic ${chosen.description} after ${errorCategory} error.`;
+    }
+    this.decisionCount++;
+    if (this.decisionBudget > 0 && this.decisionCount >= this.decisionBudget) this.budgetReached = true;
+    this.currentDecision = null;
+    const protocol = agent ? effectiveProtocol(agent, connection) : "none";
+    this.logEvent("DECISION", {
+      decisionId: decisionId ?? id(`d-h${this.handNumber}-s${seat + 1}`),
+      handNumber: this.handNumber,
+      street: state.street,
+      position: positionForSeat(state, seat),
+      potBefore: totalPot(state),
+      playerId: player.id,
+      playerName: player.name,
+      connection: connection?.name ?? agent?.connectionId ?? null,
+      protocol,
+      requestedProtocol: protocol,
+      protocolFallback: null,
+      configuredModel: agent?.model ?? null,
+      resolvedModel: agent?.model ?? null,
+      provider: agent?.provider || "auto",
+      reasoningEffort: agent?.reasoningEffort || null,
+      action: { id: chosen.id, type: chosen.type, amount: chosen.amount, description: chosen.description },
+      forced: true,
+      legalActions: legalActions.map((a) => ({ id: a.id, type: a.type, amount: a.amount ?? null, description: a.description })),
+      latencyMs: 0,
+      primaryDecisionLatencyMs: 0,
+      timeBankUsedMs: 0,
+      timeBankRemainingMs: this.timeBanks?.[player.id] ?? 0,
+      publicReason: stats?.lastReason ?? "",
+      usage: null,
+      decisionMeta: { method: "safe-fallback", decisionArchitecture: "safe-fallback-v1", reason: errorCategory, error: error ? summarizeError(error) : null },
+      reasoning: null,
+      benchmarkMode: this.config?.benchmarkMode ?? DEFAULT_BENCHMARK_MODE,
+      decisionArchitecture: this.config?.decisionArchitecture ?? DEFAULT_DECISION_ARCHITECTURE,
+      representation: this.config?.representation ?? DEFAULT_REPRESENTATION_MODE,
+      replay: null,
+      errorCategory,
+      error: error ? summarizeError(error) : null
+    });
+    return chosen;
+  }
   enqueueSpectatorExplanation({ decisionId, agent, connection, stateForAgent, chosen }) {
     if (!connection || !["openai", "openrouter"].includes(connection.kind) || isJevModel(agent.model)) return this.explanationChain;
     this.explanationChain = this.explanationChain.then(async () => {
@@ -117114,7 +117256,7 @@ var TournamentDirector = class {
       const already = this.eliminations.some((e) => e.playerId === player.id);
       return p && playerStack(p) <= 0 && !already ? { player, seat, startStack: asNumber(this.handStartStacks?.[player.id]) } : null;
     }).filter(Boolean).sort((a, b) => b.startStack - a.startStack || a.seat - b.seat);
-    const survivors = this.playersRemaining().length;
+    const survivors = this.playersWithChips().length;
     newlyEliminated.forEach((row, index) => {
       const elimination = { playerId: row.player.id, playerName: row.player.name, place: Math.max(2, survivors + 1 + index), handNumber: this.handNumber, at: Date.now() };
       this.eliminations.push(elimination);
@@ -118201,7 +118343,7 @@ function renderStats(s) {
     const pc = (value) => `${Math.round(Number(value || 0) * 100)}%`;
     return `<div class="stat-card"><div class="stat-top"><div><div class="stat-name">${escapeHtml(visiblePlayerName(p.name, p.model))}</div><div class="stat-model mono">${escapeHtml(p.model)} \xB7 ${escapeHtml(effectiveProtocol(p, s.config.connections.find((c) => c.id === p.connectionId)))}</div></div><strong>${fmt(tableP?.stack || 0)}</strong></div>
       <div class="poker-profile"><div title="Voluntarily put chips in pot"><b>${pc(poker.vpipPct)}</b><span>VPIP</span></div><div title="Preflop raise"><b>${pc(poker.pfrPct)}</b><span>PFR</span></div><div title="Aggression frequency"><b>${pc(poker.aggressionPct)}</b><span>AFq</span></div><div title="Fold when folding was legal"><b>${pc(poker.foldPct)}</b><span>FOLD</span></div><div><b>${poker.sampleHands || 0}</b><span>HANDS</span></div></div>
-      <div class="stat-values"><div class="metric"><b>${st.decisions || 0}</b><span>moves</span></div><div class="metric"><b>${avg}ms</b><span>avg</span></div><div class="metric"><b>${st.autoFallbacks || 0}</b><span>auto</span></div></div><div class="stat-reliability"><span><b>${st.modelErrors || 0}</b> model</span><span><b>${st.providerErrors || 0}</b> provider</span><span><b>${st.rateLimits || 0}</b> rate</span><span><b>${st.timeouts || 0}</b> timeout</span><span><b>${st.protocolFallbacks || 0}</b> protocol</span><span><b>${st.retries || 0}</b> retry</span></div></div>`;
+      <div class="stat-values"><div class="metric"><b>${st.decisions || 0}</b><span>moves</span></div><div class="metric"><b>${avg}ms</b><span>avg</span></div><div class="metric"><b>${st.autoFallbacks || 0}</b><span>auto</span></div></div><div class="stat-reliability"><span><b>${st.modelErrors || 0}</b> model</span><span><b>${st.providerErrors || 0}</b> provider</span><span><b>${st.rateLimits || 0}</b> rate</span><span><b>${st.timeouts || 0}</b> timeout</span><span><b>${st.contextErrors || 0}</b> context</span><span><b>${st.protocolFallbacks || 0}</b> protocol</span><span><b>${st.retries || 0}</b> retry</span></div></div>`;
   }).join("");
 }
 function tableRenderSignature(s) {

package/dist/pokertools-arena.html

@@ -115826,6 +115826,13 @@ function playerCards(player) {
 function playerStack(player) {
   return asNumber(player?.stack ?? player?.chips ?? 0);
 }
+function playersStillInTournament(players, eliminatedPlayerIds = []) {
+  const eliminated = new Set(eliminatedPlayerIds ?? []);
+  return (players ?? []).filter((player) => player?.id && !eliminated.has(player.id));
+}
+function playersWithChips(players) {
+  return (players ?? []).filter((player) => player && playerStack(player) > 0);
+}
 function currentBet(state, seat) {
   return asNumber(mapGet(state?.currentBets, seat, state?.players?.[seat]?.bet ?? 0));
 }
@@ -116073,7 +116080,7 @@ function assertDecisionState(state) {
     }
   }
   const expectedRemaining = 1 + state.opponents.length;
-  if (Number(state.tournament?.playersRemaining) !== expectedRemaining) throw new Error(`playersRemaining mismatch: expected ${expectedRemaining}, got ${state.tournament?.playersRemaining}`);
+  if (Number(state.tournament?.playersRemaining) !== expectedRemaining) throw new Error(`playersRemaining mismatch: expected ${expectedRemaining} (hero plus ${state.opponents.length} non-eliminated opponents), got ${state.tournament?.playersRemaining}`);
   return state;
 }
 function extractTextContent(message) {
@@ -117804,7 +117811,7 @@ var TournamentDirector = class {
     for (const player of this.config.players) {
       this.engine.sit(player.seat, player.id, player.name, this.config.startingStack);
       this.timeBanks[player.id] = this.config.timeBankSeconds * 1e3;
-      this.stats[player.id] = { decisions: 0, invalid: 0, modelErrors: 0, providerErrors: 0, rateLimits: 0, timeouts: 0, autoFallbacks: 0, protocolFallbacks: 0, retries: 0, totalLatencyMs: 0, lastAction: null, lastActionType: null, lastActionAmount: null, lastReason: "" };
+      this.stats[player.id] = { decisions: 0, invalid: 0, modelErrors: 0, providerErrors: 0, rateLimits: 0, timeouts: 0, autoFallbacks: 0, contextErrors: 0, protocolFallbacks: 0, retries: 0, totalLatencyMs: 0, lastAction: null, lastActionType: null, lastActionAmount: null, lastReason: "" };
     }
     this.logEvent("TOURNAMENT_START", { config: this.publicConfig() });
     this.broadcast();
@@ -117848,8 +117855,15 @@ var TournamentDirector = class {
     while (this.status === "PAUSED") await new Promise((resolve) => this.pauseResolvers.push(resolve));
     if (this.status === "STOPPED") throw new Error("Tournament stopped");
   }
+  // Decision-context/table count: seated players that are not eliminated. Must
+  // equal `1 + non-eliminated opponents` in serializeForAgent, so it must NOT be
+  // derived from stacks — an all-in player has stack 0 mid-hand and is still in.
   playersRemaining() {
-    return (this.engine?.state?.players ?? []).map((p, seat) => ({ p, seat })).filter(({ p }) => p && playerStack(p) > 0);
+    return playersStillInTournament(this.engine?.state?.players, this.eliminations.map((e) => e.playerId));
+  }
+  // Tournament-end / place accounting: seats that can still contest chips.
+  playersWithChips() {
+    return playersWithChips(this.engine?.state?.players);
   }
   tournamentMeta() {
     const startingPlayers = this.config?.players.length ?? 0;
@@ -117916,9 +117930,9 @@ var TournamentDirector = class {
   async run() {
     while (["RUNNING", "PAUSED"].includes(this.status)) {
       await this.waitIfPaused();
-      const remaining = this.playersRemaining();
+      const remaining = this.playersWithChips();
       if (remaining.length <= 1) {
-        this.finish(remaining[0]?.p ?? null);
+        this.finish(remaining[0] ?? null);
         return;
       }
       if (this.handNumber > 0 && this.handNumber % this.config.handsPerLevel === 0) {
@@ -117929,10 +117943,18 @@ var TournamentDirector = class {
           this.logEvent("BLINDS_UP_FAILED", { error: summarizeError(err) });
         }
       }
-      await this.startHand();
-      await this.playHand();
-      this.completeHand();
-      this.broadcast();
+      try {
+        await this.startHand();
+        await this.playHand();
+        this.completeHand();
+        this.broadcast();
+        this.handErrorStreak = 0;
+      } catch (err) {
+        if (this.status === "STOPPED" || err?.name === "AbortError") throw err;
+        await this.recoverHand(err);
+        this.handErrorStreak = (this.handErrorStreak || 0) + 1;
+        if (this.handErrorStreak >= 3) throw err;
+      }
       if (this.budgetReached) {
         this.logEvent("DECISION_BUDGET_REACHED", { decisions: this.decisionCount, budget: this.decisionBudget });
         this.stop();
@@ -117942,6 +117964,52 @@ var TournamentDirector = class {
       await sleep(Math.max(WINNER_REVIEW_MS, this.config.betweenHandsMs));
     }
   }
+  // Last-resort safety net for a hand. A model failure or a decision-context
+  // failure is already handled inside the hand loop; anything else that escapes
+  // (a future regression) would otherwise abort the whole tournament mid-game.
+  // Here the hand is finished with deterministic safe actions so the tournament
+  // continues. Recovery is bounded by the hand-action guard and by the caller's
+  // streak counter, so a genuinely broken engine still surfaces as an error
+  // instead of looping forever.
+  async recoverHand(triggerError) {
+    this.currentDecision = null;
+    if (this.handComplete()) {
+      this.broadcast();
+      return;
+    }
+    this.logEvent("HAND_RECOVERY", { handNumber: this.handNumber, street: this.engine?.state?.street ?? null, error: summarizeError(triggerError) });
+    this.broadcast();
+    let guard = 0;
+    while (!this.handComplete()) {
+      if (++guard > 500) throw new Error("Hand recovery guard exceeded 500 actions");
+      await this.waitIfPaused();
+      const state = this.engine.state, seat = state.actionTo;
+      if (seat == null) {
+        if (Array.isArray(state.winners) && state.winners.length) break;
+        await sleep(10);
+        continue;
+      }
+      const player = state.players?.[seat];
+      if (!player) break;
+      if (state.street === "SHOWDOWN") {
+        const show = { type: ACTION.SHOW, playerId: player.id, cardIndices: [0, 1] };
+        if (this.engine.validate(show)?.valid) {
+          this.engine.act(show);
+          continue;
+        }
+        const muck = { type: ACTION.MUCK, playerId: player.id };
+        if (this.engine.validate(muck)?.valid) {
+          this.engine.act(muck);
+          continue;
+        }
+      }
+      if (!this.forceSafeAction(seat, { error: triggerError, errorCategory: "recovery" })) break;
+      this.broadcast();
+    }
+    if (!this.handComplete()) throw triggerError;
+    this.completeHand();
+    this.broadcast();
+  }
   pruneBustedSeats() {
     const failures = [];
     for (const p of this.engine?.state?.players ?? []) {
@@ -118022,22 +118090,31 @@ var TournamentDirector = class {
   }
   async takeDecision(agent, seat, legalActions) {
     const decisionId = id(`d-h${this.handNumber}-s${seat + 1}`), baseMs = this.config.actionSeconds * 1e3, bankBefore = this.timeBanks[agent.id] ?? 0, totalMs = baseMs + bankBefore;
+    const stats = this.stats[agent.id];
+    const connection = this.config.connections.find((c) => c.id === agent.connectionId);
+    const architecture = this.config.decisionArchitecture === DECISION_ARCHITECTURES.FLAT ? "flat" : "hierarchical";
     const recentHands = buildPublicTournamentMemory(this.events, this.handNumber);
     const publicPlayerStats = buildPublicPlayerStats(this.events, this.config.players, this.handNumber);
     const actionHistory = buildCurrentHandPublicActions(this.events, this.handNumber);
-    const baseState2 = serializeForAgent(this.engine, seat, this.tournamentMeta(), legalActions, recentHands, publicPlayerStats, actionHistory);
-    const stateForAgent = assertDecisionState(applyBenchmarkMode(baseState2, this.config.benchmarkMode)), startedAt = Date.now();
-    const connection = this.config.connections.find((c) => c.id === agent.connectionId);
-    const architecture = this.config.decisionArchitecture === DECISION_ARCHITECTURES.FLAT ? "flat" : "hierarchical";
     const sizesForFamily = (family) => legalAggressiveSizes(this.engine, seat, family);
-    let hierarchy = null;
-    if (architecture === "hierarchical") {
-      hierarchy = buildHierarchicalDecision(stateForAgent, { legalActions: stateForAgent.legalActions });
-      if (hierarchy.aggressiveFamily) {
-        const engineSizes = sizesForFamily(hierarchy.aggressiveFamily);
-        hierarchy.stage2 = { ...hierarchy.stage2, sizes: engineSizes, criteria: sizeCriteria(engineSizes) };
+    let stateForAgent = null, hierarchy = null;
+    try {
+      stateForAgent = assertDecisionState(applyBenchmarkMode(
+        serializeForAgent(this.engine, seat, this.tournamentMeta(), legalActions, recentHands, publicPlayerStats, actionHistory),
+        this.config.benchmarkMode
+      ));
+      if (architecture === "hierarchical") {
+        hierarchy = buildHierarchicalDecision(stateForAgent, { legalActions: stateForAgent.legalActions });
+        if (hierarchy.aggressiveFamily) {
+          const engineSizes = sizesForFamily(hierarchy.aggressiveFamily);
+          hierarchy.stage2 = { ...hierarchy.stage2, sizes: engineSizes, criteria: sizeCriteria(engineSizes) };
+        }
       }
+    } catch (contextError) {
+      if (!this.forceSafeAction(seat, { error: contextError, errorCategory: "context", decisionId })) throw contextError;
+      return;
     }
+    const startedAt = Date.now();
     this.currentDecision = {
       id: decisionId,
       playerId: agent.id,
@@ -118064,7 +118141,6 @@ var TournamentDirector = class {
     };
     this.logEvent("DECISION_START", this.currentDecision);
     this.broadcast();
-    const stats = this.stats[agent.id];
     let result = null, error = null, errorCategory = null, elapsed = 0;
     const pausedTotal = () => (this.currentDecision?.pausedMs || 0) + (this.currentDecision?.pausedAt ? Math.max(0, Date.now() - this.currentDecision.pausedAt) : 0);
     const recordIncident = (incident) => {
@@ -118238,6 +118314,72 @@ var TournamentDirector = class {
     }
     this.currentDecision = null;
   }
+  // Deterministic safe action for one seat, used whenever a decision cannot be
+  // produced (context failure or emergency hand recovery). It always picks a
+  // legal engine action, records a normal DECISION event so public action
+  // history, replay and stats stay complete, and marks the row `forced`. It
+  // never consults a model and never sees masked-out information.
+  // Returns the chosen action, or null when the seat has no legal action.
+  forceSafeAction(seat, { error = null, errorCategory = "context", decisionId = null } = {}) {
+    const state = this.engine.state;
+    const player = state.players?.[seat];
+    if (!player) return null;
+    const legalActions = legalActionCandidates(this.engine, seat);
+    const chosen = fallbackAction(legalActions);
+    if (!chosen) return null;
+    this.engine.act(chosen.engineAction);
+    const agent = (this.config?.players ?? []).find((p) => p.id === player.id) ?? null;
+    const connection = agent ? this.config.connections.find((c) => c.id === agent.connectionId) ?? null : null;
+    const stats = this.stats?.[player.id];
+    if (stats) {
+      stats.decisions++;
+      stats.autoFallbacks++;
+      stats.contextErrors = (stats.contextErrors || 0) + 1;
+      stats.lastAction = chosen.description;
+      stats.lastActionType = chosen.type;
+      stats.lastActionAmount = chosen.amount ?? null;
+      stats.lastReason = `Automatic ${chosen.description} after ${errorCategory} error.`;
+    }
+    this.decisionCount++;
+    if (this.decisionBudget > 0 && this.decisionCount >= this.decisionBudget) this.budgetReached = true;
+    this.currentDecision = null;
+    const protocol = agent ? effectiveProtocol(agent, connection) : "none";
+    this.logEvent("DECISION", {
+      decisionId: decisionId ?? id(`d-h${this.handNumber}-s${seat + 1}`),
+      handNumber: this.handNumber,
+      street: state.street,
+      position: positionForSeat(state, seat),
+      potBefore: totalPot(state),
+      playerId: player.id,
+      playerName: player.name,
+      connection: connection?.name ?? agent?.connectionId ?? null,
+      protocol,
+      requestedProtocol: protocol,
+      protocolFallback: null,
+      configuredModel: agent?.model ?? null,
+      resolvedModel: agent?.model ?? null,
+      provider: agent?.provider || "auto",
+      reasoningEffort: agent?.reasoningEffort || null,
+      action: { id: chosen.id, type: chosen.type, amount: chosen.amount, description: chosen.description },
+      forced: true,
+      legalActions: legalActions.map((a) => ({ id: a.id, type: a.type, amount: a.amount ?? null, description: a.description })),
+      latencyMs: 0,
+      primaryDecisionLatencyMs: 0,
+      timeBankUsedMs: 0,
+      timeBankRemainingMs: this.timeBanks?.[player.id] ?? 0,
+      publicReason: stats?.lastReason ?? "",
+      usage: null,
+      decisionMeta: { method: "safe-fallback", decisionArchitecture: "safe-fallback-v1", reason: errorCategory, error: error ? summarizeError(error) : null },
+      reasoning: null,
+      benchmarkMode: this.config?.benchmarkMode ?? DEFAULT_BENCHMARK_MODE,
+      decisionArchitecture: this.config?.decisionArchitecture ?? DEFAULT_DECISION_ARCHITECTURE,
+      representation: this.config?.representation ?? DEFAULT_REPRESENTATION_MODE,
+      replay: null,
+      errorCategory,
+      error: error ? summarizeError(error) : null
+    });
+    return chosen;
+  }
   enqueueSpectatorExplanation({ decisionId, agent, connection, stateForAgent, chosen }) {
     if (!connection || !["openai", "openrouter"].includes(connection.kind) || isJevModel(agent.model)) return this.explanationChain;
     this.explanationChain = this.explanationChain.then(async () => {
@@ -118278,7 +118420,7 @@ var TournamentDirector = class {
       const already = this.eliminations.some((e) => e.playerId === player.id);
       return p && playerStack(p) <= 0 && !already ? { player, seat, startStack: asNumber(this.handStartStacks?.[player.id]) } : null;
     }).filter(Boolean).sort((a, b) => b.startStack - a.startStack || a.seat - b.seat);
-    const survivors = this.playersRemaining().length;
+    const survivors = this.playersWithChips().length;
     newlyEliminated.forEach((row, index) => {
       const elimination = { playerId: row.player.id, playerName: row.player.name, place: Math.max(2, survivors + 1 + index), handNumber: this.handNumber, at: Date.now() };
       this.eliminations.push(elimination);
@@ -119365,7 +119507,7 @@ function renderStats(s) {
     const pc = (value) => `${Math.round(Number(value || 0) * 100)}%`;
     return `<div class="stat-card"><div class="stat-top"><div><div class="stat-name">${escapeHtml(visiblePlayerName(p.name, p.model))}</div><div class="stat-model mono">${escapeHtml(p.model)} \xB7 ${escapeHtml(effectiveProtocol(p, s.config.connections.find((c) => c.id === p.connectionId)))}</div></div><strong>${fmt(tableP?.stack || 0)}</strong></div>
       <div class="poker-profile"><div title="Voluntarily put chips in pot"><b>${pc(poker.vpipPct)}</b><span>VPIP</span></div><div title="Preflop raise"><b>${pc(poker.pfrPct)}</b><span>PFR</span></div><div title="Aggression frequency"><b>${pc(poker.aggressionPct)}</b><span>AFq</span></div><div title="Fold when folding was legal"><b>${pc(poker.foldPct)}</b><span>FOLD</span></div><div><b>${poker.sampleHands || 0}</b><span>HANDS</span></div></div>
-      <div class="stat-values"><div class="metric"><b>${st.decisions || 0}</b><span>moves</span></div><div class="metric"><b>${avg}ms</b><span>avg</span></div><div class="metric"><b>${st.autoFallbacks || 0}</b><span>auto</span></div></div><div class="stat-reliability"><span><b>${st.modelErrors || 0}</b> model</span><span><b>${st.providerErrors || 0}</b> provider</span><span><b>${st.rateLimits || 0}</b> rate</span><span><b>${st.timeouts || 0}</b> timeout</span><span><b>${st.protocolFallbacks || 0}</b> protocol</span><span><b>${st.retries || 0}</b> retry</span></div></div>`;
+      <div class="stat-values"><div class="metric"><b>${st.decisions || 0}</b><span>moves</span></div><div class="metric"><b>${avg}ms</b><span>avg</span></div><div class="metric"><b>${st.autoFallbacks || 0}</b><span>auto</span></div></div><div class="stat-reliability"><span><b>${st.modelErrors || 0}</b> model</span><span><b>${st.providerErrors || 0}</b> provider</span><span><b>${st.rateLimits || 0}</b> rate</span><span><b>${st.timeouts || 0}</b> timeout</span><span><b>${st.contextErrors || 0}</b> context</span><span><b>${st.protocolFallbacks || 0}</b> protocol</span><span><b>${st.retries || 0}</b> retry</span></div></div>`;
   }).join("");
 }
 function tableRenderSignature(s) {

package/docs/diagnostics/SUMMARY.md

@@ -1,4 +1,4 @@
-# pokertools-arena 0.17.0 — benchmark methodology & results
+# pokertools-arena 0.17.1 — benchmark methodology & results
 
 Generated: 2026-09-19T18:19:58.352Z
 Methodology: paired fixed-state corpus; deterministic interleaving with recorded experiment seed.

package/docs/diagnostics/summary.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.17.0",
+  "version": "0.17.1",
   "generatedAt": "2026-09-19T18:19:58.352Z",
   "experiments": [
     "paired"

package/docs/releases/RELEASE_NOTES.md

@@ -1,5 +1,30 @@
 # Release notes
 
+## 0.17.1 — mid-hand all-in no longer aborts the tournament
+
+- Fixed a regression where a single all-in mid-hand ended the whole tournament
+  with `TOURNAMENT_ERROR: playersRemaining mismatch: expected 3, got 2`. The
+  decision context counted "players remaining" by chips, so a player who shoved
+  all-in (stack 0, `ALL_IN`, but not eliminated) dropped out of the count while
+  the masked opponent list still included them. The two counts now use distinct,
+  named helpers: `playersStillInTournament` (non-eliminated, used by the decision
+  context and table HUD) and `playersWithChips` (used only for tournament-end
+  detection and hand-end survivor/place accounting).
+- Decision-context failures can no longer cut a game short. If a context cannot
+  be built for any reason, the seat takes a deterministic legal safe action
+  (check/fold/call), a normal `DECISION` event is recorded with
+  `errorCategory: "context"`, and the hand continues. The failed context is never
+  sent anywhere, so masking still fails closed.
+- Added `Arena.recoverHand()` as a last-resort safety net: an unexpected error
+  that escapes the hand loop finishes that hand with safe actions instead of
+  aborting the tournament. It is bounded, so a genuinely broken engine still
+  surfaces as a tournament error rather than looping forever.
+- Added `tests/unit/tournament-safety-tests.mjs`: 2–6 handed simulations that
+  replay every decision context through all-ins, eliminations, heads-up and four
+  stack/policy combinations, plus chip-conservation and forced-recovery
+  assertions. Runs as part of `npm test`.
+- Reliability telemetry now reports a `context` error count per seat.
+
 ## 0.17.0 — per-seat reasoning effort
 
 - The seat editor now exposes **Reasoning effort** for OpenRouter models whose

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pokertools-arena",
-  "version": "0.17.0",
+  "version": "0.17.1",
   "description": "Browser-first AI poker benchmark powered by @pokertools/engine with generic OpenAI-compatible endpoints, optional OpenRouter/Jev Decisions routing, deterministic hierarchical decisions, paired fixed-state methodology, and reproducible reporting.",
   "type": "module",
   "bin": {
@@ -24,7 +24,7 @@
     "og": "rsvg-convert -w 1200 -h 630 -o src/assets/og-image.png src/assets/og-image.svg",
     "check": "node --check src/app.js && node --check src/benchmark/scenarios.js && node --check build.mjs && node --check bin/pokertools-arena.mjs && node tests/release-check.mjs",
     "test": "npm run build && npm run check && npm run test:unit && npm run test:integration",
-    "test:unit": "node tests/unit/decision-scenarios.mjs && node tests/unit/decision-diagnostics.mjs && node tests/unit/hierarchical-decision-tests.mjs && node tests/unit/methodology-tests.mjs && node tests/unit/size-bucket-tests.mjs && node tests/unit/model-capabilities-tests.mjs && node tests/unit/streaming-reasoning-tests.mjs && node tests/unit/paired-architecture-tests.mjs && node tests/unit/archive-content.mjs && node tests/unit/report-consistency.mjs",
+    "test:unit": "node tests/unit/decision-scenarios.mjs && node tests/unit/decision-diagnostics.mjs && node tests/unit/hierarchical-decision-tests.mjs && node tests/unit/tournament-safety-tests.mjs && node tests/unit/methodology-tests.mjs && node tests/unit/size-bucket-tests.mjs && node tests/unit/model-capabilities-tests.mjs && node tests/unit/streaming-reasoning-tests.mjs && node tests/unit/paired-architecture-tests.mjs && node tests/unit/archive-content.mjs && node tests/unit/report-consistency.mjs",
     "test:integration": "node tests/integration/pokertools-integration.mjs && node tests/integration/env-bootstrap.mjs && node tests/integration/launcher-port-retry.mjs",
     "test:diagnostics": "node tests/real/real-decision-diagnostics.mjs",
     "test:diagnostics:dry": "node tests/real/real-decision-diagnostics.mjs --dry-run",

package/src/app.js

@@ -10,7 +10,7 @@ import {
   retryDelayMs, sleepWithSignal, fetchJsonWithRetry, isUnsupportedToolChoiceError, mapGet, jsonSafe,
   normalizeBaseUrl, completionsUrl, openRouterDecisionsUrl, isOpenRouterConnection, isJevModel,
   effectiveProtocol, modelsUrl, parseHeaders, makeHeaders, combineAbort,
-  playerCards, playerStack, currentBet, totalPot, potChipBreakdown, positionForSeat, tableMarkerSeats,
+  playerCards, playerStack, playersStillInTournament, playersWithChips, currentBet, totalPot, potChipBreakdown, positionForSeat, tableMarkerSeats,
   describeAction, tryCandidate, legalActionCandidates, fallbackAction,
   serializeForAgent, assertDecisionState, extractTextContent, stripCodeFence,
   decideOpenAICompatible, decideJevDecisions, decideJevNative, decide, decideHierarchical, protocolCapabilityCache,
@@ -669,7 +669,7 @@ class TournamentDirector {
     for (const player of this.config.players) {
       this.engine.sit(player.seat, player.id, player.name, this.config.startingStack);
       this.timeBanks[player.id] = this.config.timeBankSeconds * 1000;
-      this.stats[player.id] = { decisions: 0, invalid: 0, modelErrors: 0, providerErrors: 0, rateLimits: 0, timeouts: 0, autoFallbacks: 0, protocolFallbacks: 0, retries: 0, totalLatencyMs: 0, lastAction: null, lastActionType: null, lastActionAmount: null, lastReason: '' };
+      this.stats[player.id] = { decisions: 0, invalid: 0, modelErrors: 0, providerErrors: 0, rateLimits: 0, timeouts: 0, autoFallbacks: 0, contextErrors: 0, protocolFallbacks: 0, retries: 0, totalLatencyMs: 0, lastAction: null, lastActionType: null, lastActionAmount: null, lastReason: '' };
     }
     this.logEvent('TOURNAMENT_START', { config: this.publicConfig() }); this.broadcast();
     this.runPromise = this.run().catch(err => {
@@ -697,7 +697,12 @@ class TournamentDirector {
   }
   stop() { if (['RUNNING', 'PAUSED'].includes(this.status)) { this.status = 'STOPPED'; this.abortController?.abort(); for (const resolve of this.pauseResolvers.splice(0)) resolve(); this.persistLightweight(); this.broadcast(); } }
   async waitIfPaused() { while (this.status === 'PAUSED') await new Promise(resolve => this.pauseResolvers.push(resolve)); if (this.status === 'STOPPED') throw new Error('Tournament stopped'); }
-  playersRemaining() { return (this.engine?.state?.players ?? []).map((p, seat) => ({ p, seat })).filter(({ p }) => p && playerStack(p) > 0); }
+  // Decision-context/table count: seated players that are not eliminated. Must
+  // equal `1 + non-eliminated opponents` in serializeForAgent, so it must NOT be
+  // derived from stacks — an all-in player has stack 0 mid-hand and is still in.
+  playersRemaining() { return playersStillInTournament(this.engine?.state?.players, this.eliminations.map(e => e.playerId)); }
+  // Tournament-end / place accounting: seats that can still contest chips.
+  playersWithChips() { return playersWithChips(this.engine?.state?.players); }
   tournamentMeta() {
     const startingPlayers = this.config?.players.length ?? 0;
     const eliminatedPlayerIds = this.eliminations.map(e => e.playerId);
@@ -741,17 +746,56 @@ class TournamentDirector {
   async run() {
     while (['RUNNING', 'PAUSED'].includes(this.status)) {
       await this.waitIfPaused();
-      const remaining = this.playersRemaining();
-      if (remaining.length <= 1) { this.finish(remaining[0]?.p ?? null); return; }
+      const remaining = this.playersWithChips();
+      if (remaining.length <= 1) { this.finish(remaining[0] ?? null); return; }
       if (this.handNumber > 0 && this.handNumber % this.config.handsPerLevel === 0) {
         try { this.engine.nextBlindLevel(); this.logEvent('BLINDS_UP', { level: this.engine.state.blindLevel, smallBlind: this.engine.state.smallBlind, bigBlind: this.engine.state.bigBlind, ante: this.engine.state.ante }); }
         catch (err) { this.logEvent('BLINDS_UP_FAILED', { error: summarizeError(err) }); }
       }
-      await this.startHand(); await this.playHand(); this.completeHand(); this.broadcast();
+      try {
+        await this.startHand(); await this.playHand(); this.completeHand(); this.broadcast();
+        this.handErrorStreak = 0;
+      } catch (err) {
+        if (this.status === 'STOPPED' || err?.name === 'AbortError') throw err;
+        await this.recoverHand(err);
+        this.handErrorStreak = (this.handErrorStreak || 0) + 1;
+        if (this.handErrorStreak >= 3) throw err;
+      }
       if (this.budgetReached) { this.logEvent('DECISION_BUDGET_REACHED', { decisions: this.decisionCount, budget: this.decisionBudget }); this.stop(); return; }
       await this.waitIfPaused(); await sleep(Math.max(WINNER_REVIEW_MS, this.config.betweenHandsMs));
     }
   }
+  // Last-resort safety net for a hand. A model failure or a decision-context
+  // failure is already handled inside the hand loop; anything else that escapes
+  // (a future regression) would otherwise abort the whole tournament mid-game.
+  // Here the hand is finished with deterministic safe actions so the tournament
+  // continues. Recovery is bounded by the hand-action guard and by the caller's
+  // streak counter, so a genuinely broken engine still surfaces as an error
+  // instead of looping forever.
+  async recoverHand(triggerError) {
+    this.currentDecision = null;
+    if (this.handComplete()) { this.broadcast(); return; }
+    this.logEvent('HAND_RECOVERY', { handNumber: this.handNumber, street: this.engine?.state?.street ?? null, error: summarizeError(triggerError) });
+    this.broadcast();
+    let guard = 0;
+    while (!this.handComplete()) {
+      if (++guard > 500) throw new Error('Hand recovery guard exceeded 500 actions');
+      await this.waitIfPaused();
+      const state = this.engine.state, seat = state.actionTo;
+      if (seat == null) { if (Array.isArray(state.winners) && state.winners.length) break; await sleep(10); continue; }
+      const player = state.players?.[seat]; if (!player) break;
+      if (state.street === 'SHOWDOWN') {
+        const show = { type: ACTION.SHOW, playerId: player.id, cardIndices: [0, 1] };
+        if (this.engine.validate(show)?.valid) { this.engine.act(show); continue; }
+        const muck = { type: ACTION.MUCK, playerId: player.id };
+        if (this.engine.validate(muck)?.valid) { this.engine.act(muck); continue; }
+      }
+      if (!this.forceSafeAction(seat, { error: triggerError, errorCategory: 'recovery' })) break;
+      this.broadcast();
+    }
+    if (!this.handComplete()) throw triggerError;
+    this.completeHand(); this.broadcast();
+  }
   pruneBustedSeats() {
     const failures = [];
     for (const p of (this.engine?.state?.players ?? [])) {
@@ -802,22 +846,36 @@ class TournamentDirector {
   }
   async takeDecision(agent, seat, legalActions) {
     const decisionId = id(`d-h${this.handNumber}-s${seat + 1}`), baseMs = this.config.actionSeconds * 1000, bankBefore = this.timeBanks[agent.id] ?? 0, totalMs = baseMs + bankBefore;
+    const stats = this.stats[agent.id];
+    const connection = this.config.connections.find(c => c.id === agent.connectionId);
+    const architecture = this.config.decisionArchitecture === DECISION_ARCHITECTURES.FLAT ? 'flat' : 'hierarchical';
     const recentHands = buildPublicTournamentMemory(this.events, this.handNumber);
     const publicPlayerStats = buildPublicPlayerStats(this.events, this.config.players, this.handNumber);
     const actionHistory = buildCurrentHandPublicActions(this.events, this.handNumber);
-    const baseState = serializeForAgent(this.engine, seat, this.tournamentMeta(), legalActions, recentHands, publicPlayerStats, actionHistory);
-    const stateForAgent = assertDecisionState(applyBenchmarkMode(baseState, this.config.benchmarkMode)), startedAt = Date.now();
-    const connection = this.config.connections.find(c => c.id === agent.connectionId);
-    const architecture = this.config.decisionArchitecture === DECISION_ARCHITECTURES.FLAT ? 'flat' : 'hierarchical';
     const sizesForFamily = family => legalAggressiveSizes(this.engine, seat, family);
-    let hierarchy = null;
-    if (architecture === 'hierarchical') {
-      hierarchy = buildHierarchicalDecision(stateForAgent, { legalActions: stateForAgent.legalActions });
-      if (hierarchy.aggressiveFamily) {
-        const engineSizes = sizesForFamily(hierarchy.aggressiveFamily);
-        hierarchy.stage2 = { ...hierarchy.stage2, sizes: engineSizes, criteria: sizeCriteria(engineSizes) };
+    // Building the masked decision context is the only step that can fail on an
+    // unforeseen table state (for example a tournament-count invariant). It must
+    // never abort the tournament mid-hand: the failure is recorded and the hero
+    // takes a deterministic safe action, exactly like a model failure. The failed
+    // context is never sent anywhere, so masking still fails closed.
+    let stateForAgent = null, hierarchy = null;
+    try {
+      stateForAgent = assertDecisionState(applyBenchmarkMode(
+        serializeForAgent(this.engine, seat, this.tournamentMeta(), legalActions, recentHands, publicPlayerStats, actionHistory),
+        this.config.benchmarkMode,
+      ));
+      if (architecture === 'hierarchical') {
+        hierarchy = buildHierarchicalDecision(stateForAgent, { legalActions: stateForAgent.legalActions });
+        if (hierarchy.aggressiveFamily) {
+          const engineSizes = sizesForFamily(hierarchy.aggressiveFamily);
+          hierarchy.stage2 = { ...hierarchy.stage2, sizes: engineSizes, criteria: sizeCriteria(engineSizes) };
+        }
       }
+    } catch (contextError) {
+      if (!this.forceSafeAction(seat, { error: contextError, errorCategory: 'context', decisionId })) throw contextError;
+      return;
     }
+    const startedAt = Date.now();
     this.currentDecision = {
       id: decisionId, playerId: agent.id, playerName: agent.name, seat, model: agent.model, connection: connection?.name ?? agent.connectionId, provider: agent.provider || 'auto',
       reasoningEffort: agent.reasoningEffort || null,
@@ -827,7 +885,7 @@ class TournamentDirector {
       legalActions: legalActions.map(({ id: actionId, type, amount, description }) => ({ id: actionId, type, amount, description })),
     };
     this.logEvent('DECISION_START', this.currentDecision); this.broadcast();
-    const stats = this.stats[agent.id]; let result = null, error = null, errorCategory = null, elapsed = 0;
+    let result = null, error = null, errorCategory = null, elapsed = 0;
     const pausedTotal = () => (this.currentDecision?.pausedMs || 0) + (this.currentDecision?.pausedAt ? Math.max(0, Date.now() - this.currentDecision.pausedAt) : 0);
     const recordIncident = (incident) => {
       if (incident?.category === 'rate_limit') stats.rateLimits++;
@@ -955,6 +1013,52 @@ class TournamentDirector {
     }
     this.currentDecision = null;
   }
+  // Deterministic safe action for one seat, used whenever a decision cannot be
+  // produced (context failure or emergency hand recovery). It always picks a
+  // legal engine action, records a normal DECISION event so public action
+  // history, replay and stats stay complete, and marks the row `forced`. It
+  // never consults a model and never sees masked-out information.
+  // Returns the chosen action, or null when the seat has no legal action.
+  forceSafeAction(seat, { error = null, errorCategory = 'context', decisionId = null } = {}) {
+    const state = this.engine.state;
+    const player = state.players?.[seat];
+    if (!player) return null;
+    const legalActions = legalActionCandidates(this.engine, seat);
+    const chosen = fallbackAction(legalActions);
+    if (!chosen) return null;
+    this.engine.act(chosen.engineAction);
+    const agent = (this.config?.players ?? []).find(p => p.id === player.id) ?? null;
+    const connection = agent ? this.config.connections.find(c => c.id === agent.connectionId) ?? null : null;
+    const stats = this.stats?.[player.id];
+    if (stats) {
+      stats.decisions++; stats.autoFallbacks++; stats.contextErrors = (stats.contextErrors || 0) + 1;
+      stats.lastAction = chosen.description; stats.lastActionType = chosen.type; stats.lastActionAmount = chosen.amount ?? null;
+      stats.lastReason = `Automatic ${chosen.description} after ${errorCategory} error.`;
+    }
+    this.decisionCount++;
+    if (this.decisionBudget > 0 && this.decisionCount >= this.decisionBudget) this.budgetReached = true;
+    this.currentDecision = null;
+    const protocol = agent ? effectiveProtocol(agent, connection) : 'none';
+    this.logEvent('DECISION', {
+      decisionId: decisionId ?? id(`d-h${this.handNumber}-s${seat + 1}`),
+      handNumber: this.handNumber, street: state.street, position: positionForSeat(state, seat), potBefore: totalPot(state),
+      playerId: player.id, playerName: player.name, connection: connection?.name ?? agent?.connectionId ?? null,
+      protocol, requestedProtocol: protocol, protocolFallback: null,
+      configuredModel: agent?.model ?? null, resolvedModel: agent?.model ?? null, provider: agent?.provider || 'auto', reasoningEffort: agent?.reasoningEffort || null,
+      action: { id: chosen.id, type: chosen.type, amount: chosen.amount, description: chosen.description }, forced: true,
+      legalActions: legalActions.map(a => ({ id: a.id, type: a.type, amount: a.amount ?? null, description: a.description })),
+      latencyMs: 0, primaryDecisionLatencyMs: 0, timeBankUsedMs: 0, timeBankRemainingMs: this.timeBanks?.[player.id] ?? 0,
+      publicReason: stats?.lastReason ?? '', usage: null,
+      decisionMeta: { method: 'safe-fallback', decisionArchitecture: 'safe-fallback-v1', reason: errorCategory, error: error ? summarizeError(error) : null },
+      reasoning: null,
+      benchmarkMode: this.config?.benchmarkMode ?? DEFAULT_BENCHMARK_MODE,
+      decisionArchitecture: this.config?.decisionArchitecture ?? DEFAULT_DECISION_ARCHITECTURE,
+      representation: this.config?.representation ?? DEFAULT_REPRESENTATION_MODE,
+      replay: null,
+      errorCategory, error: error ? summarizeError(error) : null,
+    });
+    return chosen;
+  }
   enqueueSpectatorExplanation({ decisionId, agent, connection, stateForAgent, chosen }) {
     if (!connection || !['openai', 'openrouter'].includes(connection.kind) || isJevModel(agent.model)) return this.explanationChain;
     this.explanationChain = this.explanationChain.then(async () => {
@@ -992,7 +1096,7 @@ class TournamentDirector {
       const already = this.eliminations.some(e => e.playerId === player.id);
       return p && playerStack(p) <= 0 && !already ? { player, seat, startStack: asNumber(this.handStartStacks?.[player.id]) } : null;
     }).filter(Boolean).sort((a, b) => b.startStack - a.startStack || a.seat - b.seat);
-    const survivors = this.playersRemaining().length;
+    const survivors = this.playersWithChips().length;
     newlyEliminated.forEach((row, index) => {
       const elimination = { playerId: row.player.id, playerName: row.player.name, place: Math.max(2, survivors + 1 + index), handNumber: this.handNumber, at: Date.now() };
       this.eliminations.push(elimination); this.logEvent('ELIMINATION', elimination);
@@ -2066,7 +2170,7 @@ function renderStats(s) {
     const pc = value => `${Math.round(Number(value || 0) * 100)}%`;
     return `<div class="stat-card"><div class="stat-top"><div><div class="stat-name">${escapeHtml(visiblePlayerName(p.name, p.model))}</div><div class="stat-model mono">${escapeHtml(p.model)} · ${escapeHtml(effectiveProtocol(p, s.config.connections.find(c => c.id === p.connectionId)))}</div></div><strong>${fmt(tableP?.stack || 0)}</strong></div>
       <div class="poker-profile"><div title="Voluntarily put chips in pot"><b>${pc(poker.vpipPct)}</b><span>VPIP</span></div><div title="Preflop raise"><b>${pc(poker.pfrPct)}</b><span>PFR</span></div><div title="Aggression frequency"><b>${pc(poker.aggressionPct)}</b><span>AFq</span></div><div title="Fold when folding was legal"><b>${pc(poker.foldPct)}</b><span>FOLD</span></div><div><b>${poker.sampleHands || 0}</b><span>HANDS</span></div></div>
-      <div class="stat-values"><div class="metric"><b>${st.decisions || 0}</b><span>moves</span></div><div class="metric"><b>${avg}ms</b><span>avg</span></div><div class="metric"><b>${st.autoFallbacks || 0}</b><span>auto</span></div></div><div class="stat-reliability"><span><b>${st.modelErrors || 0}</b> model</span><span><b>${st.providerErrors || 0}</b> provider</span><span><b>${st.rateLimits || 0}</b> rate</span><span><b>${st.timeouts || 0}</b> timeout</span><span><b>${st.protocolFallbacks || 0}</b> protocol</span><span><b>${st.retries || 0}</b> retry</span></div></div>`;
+      <div class="stat-values"><div class="metric"><b>${st.decisions || 0}</b><span>moves</span></div><div class="metric"><b>${avg}ms</b><span>avg</span></div><div class="metric"><b>${st.autoFallbacks || 0}</b><span>auto</span></div></div><div class="stat-reliability"><span><b>${st.modelErrors || 0}</b> model</span><span><b>${st.providerErrors || 0}</b> provider</span><span><b>${st.rateLimits || 0}</b> rate</span><span><b>${st.timeouts || 0}</b> timeout</span><span><b>${st.contextErrors || 0}</b> context</span><span><b>${st.protocolFallbacks || 0}</b> protocol</span><span><b>${st.retries || 0}</b> retry</span></div></div>`;
   }).join('');
 }
 function tableRenderSignature(s) {

package/src/lib/decision-core.js

@@ -446,6 +446,26 @@ export function playerCards(player) {
   return Array.isArray(raw) ? raw.filter(Boolean).map(String) : [];
 }
 export function playerStack(player) { return asNumber(player?.stack ?? player?.chips ?? 0); }
+// Two counts of "players still around" exist and must never be conflated:
+//
+//  - playersStillInTournament: seated players that have not been eliminated.
+//    This is the tournament field exposed to models and the table HUD. It has to
+//    equal `1 + non-eliminated opponents` in serializeForAgent. Chip-based counts
+//    are wrong here: a player who shoves all-in has stack 0 for the rest of the
+//    hand but is not eliminated until the hand settles.
+//  - playersWithChips: seats that can still contest chips. Used for
+//    tournament-end detection and hand-end survivor/place accounting, where an
+//    all-in player may have already committed every chip.
+//
+// Mixing them lets one mid-hand all-in make the decision-context invariant throw
+// and abort the whole tournament, so keep the callers aligned with the names.
+export function playersStillInTournament(players, eliminatedPlayerIds = []) {
+  const eliminated = new Set(eliminatedPlayerIds ?? []);
+  return (players ?? []).filter(player => player?.id && !eliminated.has(player.id));
+}
+export function playersWithChips(players) {
+  return (players ?? []).filter(player => player && playerStack(player) > 0);
+}
 export function currentBet(state, seat) { return asNumber(mapGet(state?.currentBets, seat, state?.players?.[seat]?.bet ?? 0)); }
 export function totalPot(state) {
   const pots = Array.isArray(state?.pots) ? state.pots : [];
@@ -697,8 +717,12 @@ export function assertDecisionState(state) {
       aggressiveByAmount.set(Number(action.amount), action.type);
     }
   }
+  // The tournament field must describe non-eliminated players only. It has to
+  // match the masked opponent list exactly (`playersStillInTournament`), so it
+  // must never be derived from stacks: an all-in player has stack 0 mid-hand but
+  // is not eliminated until the hand settles.
   const expectedRemaining = 1 + state.opponents.length;
-  if (Number(state.tournament?.playersRemaining) !== expectedRemaining) throw new Error(`playersRemaining mismatch: expected ${expectedRemaining}, got ${state.tournament?.playersRemaining}`);
+  if (Number(state.tournament?.playersRemaining) !== expectedRemaining) throw new Error(`playersRemaining mismatch: expected ${expectedRemaining} (hero plus ${state.opponents.length} non-eliminated opponents), got ${state.tournament?.playersRemaining}`);
   return state;
 }