pokertools-arena 0.16.2 → 0.17.1

package/dist/pokertools-arena.html

@@ -548,7 +548,7 @@ label input, label select { margin-top: 5px; font-weight: 450; }
 .split-footer { justify-content: space-between; }
 .seat-footer-actions, .replay-share-actions { display: flex; gap: 7px; }
 .seat-editor-grid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 12px; }
-.seat-model-field { grid-column: 1 / -1; }
+.seat-model-field, .seat-effort-field { grid-column: 1 / -1; }
 .model-input-wrap { margin-top: 6px; display: grid; grid-template-columns: minmax(0, 1fr) 38px; gap: 8px; }
 .model-input-wrap input { margin: 0; }
 .field-icon-button, .dialog-body .remove-connection { width: 38px; height: 38px; min-height: 38px; border-radius: 8px; }
@@ -1041,6 +1041,11 @@ label input, label select { margin-top: 5px; font-weight: 450; }
             <span class="checkbox-field"><input id="seatCaptureReasoning" type="checkbox" /> Capture raw model reasoning</span>
             <span class="field-help seat-reasoning-help hidden">This model is not a reasoning model by default. Capturing its reasoning can be far slower (Gemma measured ~2s → 27–48s per decision) and is outside the standard benchmark track. Raise the action clock before using it.</span>
           </label>
+          <label class="seat-effort-field">
+            <span class="field-label-row">Reasoning effort <button class="info-button inline-info" type="button" aria-label="About reasoning effort" data-tip="How much hidden thinking the model may spend. Higher effort is smarter but slower; a slow reasoner can exhaust the action clock and be forced to fold. Options come from the OpenRouter model catalogue, and an unset value keeps the arena's fixed reasoning cap.">i</button></span>
+            <select id="seatReasoningEffort"></select>
+            <span id="seatReasoningEffortHelp" class="field-help"></span>
+          </label>
         </div>
       </div>
       <div id="seatError" class="setup-error hidden"></div>
@@ -115591,8 +115596,15 @@ async function fetchStreamingJson(url, options, { maxRetries = 1, onDelta = null
     throw new ArenaRequestError(message, { status: response.status, category: requestErrorCategory(response.status), payload, incidents });
   }
 }
+function requestErrorDetail(err) {
+  const parts = [summarizeError(err)];
+  const nested = err?.payload?.error?.metadata?.raw ?? err?.payload?.metadata?.raw;
+  if (typeof nested === "string") parts.push(nested);
+  else if (nested) parts.push(String(JSON.stringify(nested)));
+  return parts.join(" ");
+}
 function isUnsupportedToolChoiceError(err) {
-  const message = summarizeError(err);
+  const message = requestErrorDetail(err);
   return [400, 404, 422].includes(Number(err?.status)) && /tool[_ -]?choice|tool call|tools?.*(?:unsupported|support)|no endpoints?.*support/i.test(message);
 }
 function mapGet(mapish, key, fallback = 0) {
@@ -115618,13 +115630,23 @@ function jsonSafe(value) {
 }
 var protocolCapabilityCache = /* @__PURE__ */ new Map();
 var modelSupportedParameters = /* @__PURE__ */ new Map();
+var modelReasoningCapabilities = /* @__PURE__ */ new Map();
 var DEFAULT_TEMPERATURE = 0.3;
 function registerModelCapabilities(models = []) {
   for (const entry of models ?? []) {
     const id2 = typeof entry === "string" ? entry : entry?.id;
+    if (!id2) continue;
     const parameters = typeof entry === "object" && entry ? entry.supported_parameters : null;
-    if (!id2 || !Array.isArray(parameters)) continue;
-    modelSupportedParameters.set(String(id2), new Set(parameters.map(String)));
+    if (Array.isArray(parameters)) modelSupportedParameters.set(String(id2), new Set(parameters.map(String)));
+    const reasoning = typeof entry === "object" && entry ? entry.reasoning : null;
+    if (!reasoning || typeof reasoning !== "object") continue;
+    const efforts = Array.isArray(reasoning.supported_efforts) ? reasoning.supported_efforts.map((value) => String(value).trim().toLowerCase()).filter(Boolean) : [];
+    const declaredDefault = String(reasoning.default_effort || "").trim().toLowerCase();
+    modelReasoningCapabilities.set(String(id2), {
+      mandatory: reasoning.mandatory === true,
+      supportedEfforts: efforts,
+      defaultEffort: efforts.includes(declaredDefault) ? declaredDefault : null
+    });
   }
 }
 function modelSupportsParameter(model, parameter) {
@@ -115632,6 +115654,34 @@ function modelSupportsParameter(model, parameter) {
   if (!supported) return null;
   return supported.has(String(parameter));
 }
+function reasoningCapabilities(model) {
+  return modelReasoningCapabilities.get(String(model || "")) ?? null;
+}
+function reasoningEffortsFor(model) {
+  return reasoningCapabilities(model)?.supportedEfforts ?? [];
+}
+function defaultReasoningEffort(model) {
+  return reasoningCapabilities(model)?.defaultEffort ?? null;
+}
+function requiresReasoning(model) {
+  return reasoningCapabilities(model)?.mandatory === true;
+}
+function resolveReasoningEffort(model, requested) {
+  const value = String(requested || "").trim().toLowerCase();
+  if (!value) return null;
+  const capabilities = reasoningCapabilities(model);
+  if (!capabilities) return value;
+  return capabilities.supportedEfforts.includes(value) ? value : null;
+}
+function reasoningOverrideFor(agent) {
+  const effort = resolveReasoningEffort(agent?.model, agent?.reasoningEffort);
+  return effort ? { effort } : { max_tokens: 256, exclude: false };
+}
+function truncationReasoningOverride(model) {
+  const capabilities = reasoningCapabilities(model);
+  if (!capabilities) return { effort: "low" };
+  return capabilities.supportedEfforts.includes("low") ? { effort: "low" } : { max_tokens: 4096, exclude: false };
+}
 function resolveTemperature(model, requested) {
   if (modelSupportsParameter(model, "temperature") === false) return void 0;
   return Number.isFinite(Number(requested)) ? Number(requested) : DEFAULT_TEMPERATURE;
@@ -115670,7 +115720,7 @@ function isReasoningModel(model) {
   return /(?:^|[\/._:-])(qwen3|qwq|deepseek-[rv]\d|magistral|glm-(?:\d+[a-z]*|latest|flash-latest)|gpt-oss|nemotron|reason(?:ing)?|thinking|o1|o3|o4)(?:$|[\/._:-])/.test(id2);
 }
 function wantsReasoning(agent) {
-  return isReasoningModel(agent?.model) || agent?.captureReasoning === true;
+  return isReasoningModel(agent?.model) || agent?.captureReasoning === true || reasoningCapabilities(agent?.model)?.mandatory === true || Boolean(resolveReasoningEffort(agent?.model, agent?.reasoningEffort));
 }
 function effectiveProtocol(agent, connection) {
   if (isOpenRouterConnection(connection) && isJevModel(agent?.model)) return "jev_decisions";
@@ -115776,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));
 }
@@ -116023,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) {
@@ -116446,7 +116503,7 @@ Respond with one of: ${criteriaKeys.map((k) => `${k} = ${criteria[k]}`).join(";
   }
   if (isOpenRouter) {
     body.provider = agent.provider ? { only: [agent.provider], allow_fallbacks: false, require_parameters: true } : { allow_fallbacks: true, require_parameters: true };
-    if (wantsReasoning(agent)) body.reasoning = reasoning ?? { max_tokens: 256, exclude: false };
+    if (wantsReasoning(agent)) body.reasoning = reasoning ?? reasoningOverrideFor(agent);
   }
   if (stream) {
     body.stream = true;
@@ -116509,7 +116566,7 @@ async function decideOpenAICompatible({ agent, connection, state, legalActions,
         result = await execute(actualProtocol);
       } else if (err?.truncated) {
         truncationRetry = true;
-        result = await execute(actualProtocol, { maxTokens: 4096, reasoning: { effort: "low" } });
+        result = await execute(actualProtocol, { maxTokens: 4096, reasoning: truncationReasoningOverride(agent.model) });
       } else throw err;
     }
     const normalized = normalizeDecisionObject(result.obj, legalActions, decisionId);
@@ -116685,7 +116742,7 @@ async function requestChatStage({ agent, connection, schema, toolName, systemPro
     }
     if (isOpenRouter) {
       body.provider = agent.provider ? { only: [agent.provider], allow_fallbacks: false, require_parameters: true } : { allow_fallbacks: true, require_parameters: true };
-      if (wantsReasoning(agent)) body.reasoning = override.reasoning ?? { max_tokens: 256, exclude: false };
+      if (wantsReasoning(agent)) body.reasoning = override.reasoning ?? reasoningOverrideFor(agent);
     }
     if (onDelta) {
       body.stream = true;
@@ -116729,7 +116786,7 @@ async function requestChatStage({ agent, connection, schema, toolName, systemPro
       return { ...result, protocolFallback: "tool\u2192json_schema" };
     }
     if (err?.truncated) {
-      const result = await execute(actual, { maxTokens: 4096, reasoning: { effort: "low" } });
+      const result = await execute(actual, { maxTokens: 4096, reasoning: truncationReasoningOverride(agent.model) });
       return { ...result, protocolFallback: "truncated\u2192retry" };
     }
     throw err;
@@ -117002,6 +117059,8 @@ var els = {
   seatProtocol: $("#seatProtocol"),
   seatProvider: $("#seatProvider"),
   seatCaptureReasoning: $("#seatCaptureReasoning"),
+  seatReasoningEffort: $("#seatReasoningEffort"),
+  seatReasoningEffortHelp: $("#seatReasoningEffortHelp"),
   seatError: $("#seatError"),
   removeSeatBtn: $("#removeSeatBtn"),
   cancelSeatBtn: $("#cancelSeatBtn"),
@@ -117052,6 +117111,7 @@ var WINNER_REVIEW_MS = 2e3;
 var seatAssignments = Array(MAX_LOBBY_SEATS).fill(null);
 var editingSeatIndex = null;
 var seatNameAuto = false;
+var seatReasoningEffortDraft = "";
 var lobbyVisible = true;
 var pendingAutostart = false;
 var arenaMaxDecisions = 0;
@@ -117357,7 +117417,8 @@ function injectedEnvironmentConfig() {
       model: String(player.model || ""),
       protocol: String(player.protocol || "tool"),
       provider: String(player.provider || ""),
-      captureReasoning: Boolean(player.captureReasoning)
+      captureReasoning: Boolean(player.captureReasoning),
+      reasoningEffort: String(player.reasoningEffort || "").trim().toLowerCase()
     }))
   };
 }
@@ -117674,7 +117735,7 @@ function normalizeConfig(input = {}) {
       if (!connIds.has(raw.connectionId)) throw new Error(`Connection missing for ${name}`);
       const model = String(raw.model || "").trim();
       if (!model) throw new Error(`Model missing for ${name}`);
-      return { id: `player-${lobbySeat + 1}`, seat: index, lobbySeat, name, connectionId: raw.connectionId, model, protocol: raw.protocol || "tool", provider: String(raw.provider || "").trim(), captureReasoning: raw.captureReasoning === true, temperature: clamp(Number(raw.temperature) || 0.3, 0, 2) };
+      return { id: `player-${lobbySeat + 1}`, seat: index, lobbySeat, name, connectionId: raw.connectionId, model, protocol: raw.protocol || "tool", provider: String(raw.provider || "").trim(), captureReasoning: raw.captureReasoning === true, reasoningEffort: String(raw.reasoningEffort || "").trim().toLowerCase(), temperature: clamp(Number(raw.temperature) || 0.3, 0, 2) };
     })
   };
 }
@@ -117750,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();
@@ -117794,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;
@@ -117862,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) {
@@ -117875,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();
@@ -117888,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 ?? []) {
@@ -117968,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,
@@ -117992,6 +118123,7 @@ var TournamentDirector = class {
       model: agent.model,
       connection: connection?.name ?? agent.connectionId,
       provider: agent.provider || "auto",
+      reasoningEffort: agent.reasoningEffort || null,
       protocol: effectiveProtocol(agent, connection),
       handNumber: this.handNumber,
       street: this.engine.state.street,
@@ -118009,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) => {
@@ -118140,6 +118271,7 @@ var TournamentDirector = class {
       configuredModel: agent.model,
       resolvedModel: result?.model ?? agent.model,
       provider: agent.provider || "auto",
+      reasoningEffort: agent.reasoningEffort || null,
       action: { id: chosen.id, type: chosen.type, amount: chosen.amount, description: chosen.description },
       forced,
       legalActions: legalActions.map((a) => ({ id: a.id, type: a.type, amount: a.amount ?? null, description: a.description })),
@@ -118182,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 () => {
@@ -118222,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);
@@ -118380,6 +118578,7 @@ function renderModelOptions(models, currentValue = "") {
   if (currentValue && !byId.has(currentValue)) byId.set(currentValue, { id: currentValue, name: currentValue });
   const rows = [...byId.values()].sort((a, b) => a.id.localeCompare(b.id));
   els.seatModelOptions.innerHTML = rows.map((model) => `<option value="${escapeHtml(model.id)}" label="${escapeHtml(model.name || model.id)}"></option>`).join("");
+  updateSeatReasoningEffortOptions();
 }
 async function refreshSeatModelCatalog({ force = false } = {}) {
   const connection = fullConnectionById(els.seatConnection?.value);
@@ -118433,9 +118632,41 @@ function defaultSeatDraft(seatIndex) {
     model: conn?.kind === "typesafe" ? "jev-latest" : "",
     protocol: conn?.kind === "typesafe" ? "jev_native" : "tool",
     provider: "",
-    captureReasoning: false
+    captureReasoning: false,
+    reasoningEffort: ""
   };
 }
+function updateSeatReasoningEffortOptions(selected) {
+  const select = els.seatReasoningEffort;
+  if (!select) return;
+  const openRouter = isOpenRouterConnection(connectionById(els.seatConnection.value));
+  const model = els.seatModel.value.trim();
+  const efforts = openRouter ? reasoningEffortsFor(model) : [];
+  const modelDefault = efforts.length ? defaultReasoningEffort(model) : null;
+  const current = String(selected ?? seatReasoningEffortDraft ?? "").trim().toLowerCase();
+  select.innerHTML = [
+    '<option value="">Arena default (capped)</option>',
+    ...efforts.map((effort) => `<option value="${escapeHtml(effort)}">${escapeHtml(effort)}${effort === modelDefault ? " \xB7 model default" : ""}</option>`)
+  ].join("");
+  if (efforts.includes(current)) {
+    select.value = current;
+    seatReasoningEffortDraft = current;
+  } else {
+    select.value = "";
+    if (!current) seatReasoningEffortDraft = "";
+  }
+  select.disabled = !efforts.length;
+  const help = els.seatReasoningEffortHelp;
+  if (!help) return;
+  help.dataset.tone = "";
+  if (!openRouter) help.textContent = "Reasoning effort is available for OpenRouter models that advertise it.";
+  else if (!efforts.length) help.textContent = "This model does not advertise reasoning efforts; the capped default is used.";
+  else if (!select.value && requiresReasoning(model)) {
+    help.textContent = `This model always reasons and ignores the capped default, so it can exceed the action clock and auto-fold. Pick an effort \u2014 ${efforts.includes("minimal") ? "minimal" : efforts[0]} is usually fastest.`;
+    help.dataset.tone = "bad";
+  } else if (modelDefault) help.textContent = `Model default is ${modelDefault}. Lower it when a slow reasoner runs out of action clock and auto-folds.`;
+  else help.textContent = "Lower it when a slow reasoner runs out of action clock and auto-folds.";
+}
 function applySeatProtocolRules() {
   const conn = connectionById(els.seatConnection.value);
   const kind = conn?.kind || "openrouter";
@@ -118444,6 +118675,7 @@ function applySeatProtocolRules() {
   const jevSeat = kind === "typesafe" || jevViaOpenRouter;
   document.querySelector(".seat-provider-field")?.classList.toggle("hidden", !openRouter || jevViaOpenRouter);
   document.querySelector(".seat-reasoning-field")?.classList.toggle("hidden", jevSeat);
+  document.querySelector(".seat-effort-field")?.classList.toggle("hidden", jevSeat);
   if (els.seatCaptureReasoning) {
     els.seatCaptureReasoning.disabled = jevSeat;
     const alreadyReasoning = isReasoningModel(els.seatModel.value.trim());
@@ -118464,6 +118696,7 @@ function applySeatProtocolRules() {
     els.seatProvider.disabled = !openRouter;
     if (els.seatModel.value === "jev-latest") els.seatModel.value = "";
   }
+  updateSeatReasoningEffortOptions();
 }
 function updateSeatSummary() {
   const count = seatAssignments.filter(Boolean).length;
@@ -118490,13 +118723,16 @@ function openSeatEditor(seatIndex) {
   els.seatProtocol.value = draft.protocol || "tool";
   els.seatProvider.value = draft.provider || "";
   if (els.seatCaptureReasoning) els.seatCaptureReasoning.checked = Boolean(draft.captureReasoning);
+  seatReasoningEffortDraft = String(draft.reasoningEffort || "").trim().toLowerCase();
   applySeatProtocolRules();
+  updateSeatReasoningEffortOptions(seatReasoningEffortDraft);
   syncSeatNameFromModel();
   void refreshSeatModelCatalog();
   els.seatError.classList.add("hidden");
   els.seatLockNotice.classList.toggle("hidden", !locked);
   for (const control of [els.seatName, els.seatConnection, els.seatModel, els.seatProtocol, els.seatProvider]) control.disabled = locked || control === els.seatProvider && (!isOpenRouterConnection(connectionById(els.seatConnection.value)) || isJevModel(els.seatModel.value));
   if (els.seatCaptureReasoning) els.seatCaptureReasoning.disabled = locked || els.seatCaptureReasoning.disabled;
+  if (els.seatReasoningEffort) els.seatReasoningEffort.disabled = locked || els.seatReasoningEffort.disabled;
   els.saveSeatBtn.disabled = locked;
   els.removeSeatBtn.disabled = locked || !seatAssignments[seatIndex];
   if (!els.seatDialog.open) els.seatDialog.showModal();
@@ -118514,7 +118750,8 @@ function readSeatDraft() {
     model: els.seatModel.value.trim(),
     protocol: els.seatProtocol.value,
     provider: els.seatProvider.disabled ? "" : els.seatProvider.value.trim(),
-    captureReasoning: Boolean(els.seatCaptureReasoning && !els.seatCaptureReasoning.disabled && els.seatCaptureReasoning.checked)
+    captureReasoning: Boolean(els.seatCaptureReasoning && !els.seatCaptureReasoning.disabled && els.seatCaptureReasoning.checked),
+    reasoningEffort: els.seatReasoningEffort && !els.seatReasoningEffort.disabled ? els.seatReasoningEffort.value.trim().toLowerCase() : ""
   };
 }
 function readSeatPlayers() {
@@ -118543,7 +118780,8 @@ function restoreSeatAssignments(rows = []) {
       model: player.model || "",
       protocol: player.protocol || "tool",
       provider: player.provider || "",
-      captureReasoning: player.captureReasoning === true
+      captureReasoning: player.captureReasoning === true,
+      reasoningEffort: String(player.reasoningEffort || "").trim().toLowerCase()
     };
   });
   updateSeatSummary();
@@ -119269,13 +119507,13 @@ 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) {
   const running = ["RUNNING", "PAUSED"].includes(s?.status);
   if (lobbyVisible && !running) {
-    return JSON.stringify(["lobby", seatAssignments.map((p) => p ? [p.name, p.model, p.protocol, p.connectionId, p.provider, Boolean(p.captureReasoning)] : null)]);
+    return JSON.stringify(["lobby", seatAssignments.map((p) => p ? [p.name, p.model, p.protocol, p.connectionId, p.provider, Boolean(p.captureReasoning), p.reasoningEffort || ""] : null)]);
   }
   const t = s?.table;
   if (!t) return JSON.stringify(["empty", s?.status || "IDLE"]);
@@ -120659,6 +120897,9 @@ els.seatName.addEventListener("input", () => {
 });
 els.seatProtocol.addEventListener("change", applySeatProtocolRules);
 els.seatCaptureReasoning?.addEventListener("change", applySeatProtocolRules);
+els.seatReasoningEffort?.addEventListener("change", () => {
+  seatReasoningEffortDraft = els.seatReasoningEffort.value;
+});
 els.refreshModelsBtn?.addEventListener("click", () => void refreshSeatModelCatalog({ force: true }));
 els.removeSeatBtn.addEventListener("click", () => {
   if (editingSeatIndex == null || director && ["RUNNING", "PAUSED"].includes(director.status)) return;

package/dist/styles.css

@@ -492,7 +492,7 @@ label input, label select { margin-top: 5px; font-weight: 450; }
 .split-footer { justify-content: space-between; }
 .seat-footer-actions, .replay-share-actions { display: flex; gap: 7px; }
 .seat-editor-grid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 12px; }
-.seat-model-field { grid-column: 1 / -1; }
+.seat-model-field, .seat-effort-field { grid-column: 1 / -1; }
 .model-input-wrap { margin-top: 6px; display: grid; grid-template-columns: minmax(0, 1fr) 38px; gap: 8px; }
 .model-input-wrap input { margin: 0; }
 .field-icon-button, .dialog-body .remove-connection { width: 38px; height: 38px; min-height: 38px; border-radius: 8px; }

package/docs/diagnostics/SUMMARY.md

@@ -1,4 +1,4 @@
-# pokertools-arena 0.16.2 — 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.16.2",
+  "version": "0.17.1",
   "generatedAt": "2026-09-19T18:19:58.352Z",
   "experiments": [
     "paired"