Merge pull request 'Let the dealer take back an action from the bar' (#26 ) from feature/casino-holdem-action-undo into feature/casino-holdem-pace

Reviewed-on: #26
Let the dealer take back an action from the bar
2026-08-31 23:34:46 -06:00 · 2026-08-31 22:37:03 -06:00 · 2026-08-31 22:21:39 -06:00 · 2026-08-31 22:10:19 -06:00
6 changed files with 433 additions and 16 deletions
@@ -1075,12 +1075,37 @@ body.hasActionBar #holdemSidebar {

 .actionStatus {
    display: flex;
+    flex-wrap: wrap;
    align-items: baseline;
-    gap: 0.6rem;
+    gap: 0.4rem 0.6rem;
    margin-bottom: 0.55rem;
    font-size: 0.78rem;
 }

+/* Always there while there's something to take back, rather than a toast per tap. */
+.actionUndo {
+    flex: none;
+    min-height: 30px;
+    max-width: 100%;
+    padding: 0.15rem 0.6rem;
+    border-radius: 999px;
+    border: 1px solid #414141;
+    background: #262626;
+    color: #bdbdbd;
+    font-family: inherit;
+    font-size: 0.72rem;
+    cursor: pointer;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.actionUndo:hover {
+    background: #333;
+    border-color: #4f4f4f;
+    color: #eee;
+}
+
 .actionStreet {
    color: #d8b46a;
    font-weight: 600;
@@ -1094,6 +1119,11 @@ body.hasActionBar #holdemSidebar {
    font-variant-numeric: tabular-nums;
 }

+.actionPlayers {
+    color: #9c9c9c;
+    font-variant-numeric: tabular-nums;
+}
+
 .actionWho {
    margin-left: auto;
    color: #9c9c9c;
@@ -1102,6 +1132,87 @@ body.hasActionBar #holdemSidebar {
    white-space: nowrap;
 }

+/* Stopwatch, not a shot clock: it colours up as a prompt to the dealer, and does
+   nothing else. */
+.actionTank {
+    flex: none;
+    min-width: 3.1rem;
+    text-align: right;
+    color: #7d7d7d;
+    font-variant-numeric: tabular-nums;
+    transition: color 0.3s ease;
+}
+
+.actionTank.tankNudge {
+    color: #d8b46a;
+}
+
+.actionTank.tankSlow {
+    color: #e07b7b;
+    font-weight: 600;
+}
+
+/* ---------- Side-pot breakdown ---------- */
+
+.potBreakdown {
+    display: flex;
+    flex-direction: column;
+    gap: 0.2rem;
+    margin-bottom: 0.55rem;
+    padding: 0.4rem 0.55rem;
+    background: rgba(216, 180, 106, 0.07);
+    border: 1px solid rgba(216, 180, 106, 0.25);
+    border-radius: 8px;
+}
+
+.potBreakdownHeading {
+    margin: 0 0 0.35rem;
+    color: #d8b46a;
+    font-size: 0.68rem;
+    letter-spacing: 0.08em;
+    text-transform: uppercase;
+}
+
+.potLayer {
+    display: flex;
+    align-items: baseline;
+    gap: 0.5rem;
+    font-size: 0.76rem;
+}
+
+.potLayerLabel {
+    color: #d8b46a;
+    font-weight: 600;
+    flex: none;
+}
+
+.potLayerAmount {
+    color: #f2f2f2;
+    font-variant-numeric: tabular-nums;
+    font-weight: 600;
+    flex: none;
+}
+
+.potLayerWho {
+    color: #9a9a9a;
+    flex: 1;
+    min-width: 0;
+    text-align: right;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.potBreakdownWizard {
+    margin-bottom: 1rem;
+}
+
+.potLayerReturn .potLayerLabel,
+.potLayerReturn .potLayerAmount {
+    color: #9a9a9a;
+    font-weight: 500;
+}
+
 .actionButtons {
    display: flex;
    gap: 0.5rem;
@@ -27,6 +27,8 @@ const ActionBar = {
        if (!this.isRunning()) {
            host.hidden = true;
            document.body.classList.remove("hasActionBar");
+            this.stopTankTimer();
+            this.tankSeatIndex = null;
            return;
        }
        host.hidden = false;
@@ -34,6 +36,9 @@ const ActionBar = {

        host.appendChild(this.renderStatus());

+        const breakdown = this.renderPotBreakdown();
+        if (breakdown) host.appendChild(breakdown);
+
        if (Betting.isHandOver(this.state)) {
            host.appendChild(this.renderHandOver());
        } else if (this.state.actingSeatIndex === null || this.state.actingSeatIndex === undefined) {
@@ -43,6 +48,8 @@ const ActionBar = {
        } else {
            host.appendChild(this.renderActions());
        }
+
+        this.syncTankTimer();
    },

    renderStatus() {
@@ -59,6 +66,14 @@ const ActionBar = {
        pot.textContent = `Pot ${Money.format(Betting.potSoFar(this.state))}`;
        row.appendChild(pot);

+        // How many are still in the hand — part of the standard per-street
+        // announcement, and the number a dealer is asked for most often.
+        const remaining = Betting.liveSeats(this.state).length;
+        const players = document.createElement("span");
+        players.className = "actionPlayers";
+        players.textContent = `${remaining} ${remaining === 1 ? "player" : "players"}`;
+        row.appendChild(players);
+
        const index = this.state.actingSeatIndex;
        if (index !== null && index !== undefined && !Betting.isHandOver(this.state)) {
            const player = this.state.seats[index];
@@ -66,11 +81,119 @@ const ActionBar = {
            who.className = "actionWho";
            who.textContent = `${HoldemState.displayName(player, index)} · ${Money.format(Betting.stackOf(this.state, player))} behind`;
            row.appendChild(who);
+
+            const tank = document.createElement("span");
+            tank.className = "actionTank";
+            tank.id = "actionTank";
+            tank.title = "How long this player has been thinking";
+            tank.textContent = "0:00";
+            row.appendChild(tank);
+        }
+
+        // A standing control rather than a toast per action: a dealer taps this bar
+        // constantly, and a toast after every fold would be noise they'd learn to
+        // ignore — which is exactly when they'd miss the one that mattered.
+        const undoLabel = this.hooks.lastActionLabel();
+        if (undoLabel) {
+            const undo = document.createElement("button");
+            undo.type = "button";
+            undo.className = "actionUndo";
+            undo.title = `Undo ${undoLabel}`;
+            undo.textContent = `↶ ${undoLabel}`;
+            undo.addEventListener("click", () => this.hooks.undoLast());
+            row.appendChild(undo);
        }

        return row;
    },

+    // ---- Think timer ----
+    //
+    // A player who hasn't noticed the action is on them costs more time than anything
+    // else a dealer does, so the bar shows how long the current player has been in the
+    // tank. It's a stopwatch, not a shot clock: nothing happens when it grows, it just
+    // tells the dealer when it's worth a nudge.
+    NUDGE_AFTER_S: 30,
+    SLOW_AFTER_S: 60,
+
+    tankSeatIndex: null,
+    tankStartedAt: null,
+    tankInterval: null,
+
+    // Restarts only when the action actually moves — a re-render for any other reason
+    // (a chip edit, a name change) must not put a thinking player back to zero.
+    syncTankTimer() {
+        const index = this.state.actingSeatIndex;
+        const running = index !== null && index !== undefined && !Betting.isHandOver(this.state);
+
+        if (!running) {
+            this.stopTankTimer();
+            this.tankSeatIndex = null;
+            return;
+        }
+
+        if (this.tankSeatIndex !== index) {
+            this.tankSeatIndex = index;
+            this.tankStartedAt = Date.now();
+        }
+
+        if (!this.tankInterval) {
+            this.tankInterval = setInterval(() => this.paintTank(), 1000);
+        }
+        this.paintTank();
+    },
+
+    stopTankTimer() {
+        if (this.tankInterval) {
+            clearInterval(this.tankInterval);
+            this.tankInterval = null;
+        }
+    },
+
+    // Updates only the timer's own text, so the seconds ticking over never rebuilds the
+    // buttons under the dealer's thumb.
+    paintTank() {
+        const el = document.getElementById("actionTank");
+        if (!el || this.tankStartedAt === null) return;
+
+        const seconds = Math.floor((Date.now() - this.tankStartedAt) / 1000);
+        const mins = Math.floor(seconds / 60);
+        el.textContent = `${mins}:${String(seconds % 60).padStart(2, "0")}`;
+        el.classList.toggle("tankNudge", seconds >= this.NUDGE_AFTER_S && seconds < this.SLOW_AFTER_S);
+        el.classList.toggle("tankSlow", seconds >= this.SLOW_AFTER_S);
+    },
+
+    // Shown only once someone is all-in and the money has actually split — a single
+    // undivided pot needs no announcement, and a line that's always there stops being
+    // read.
+    renderPotBreakdown() {
+        // Only worth showing once someone is actually all-in. Mid-street the amounts in
+        // front of players are unequal all the time — the blinds alone are unequal —
+        // and layering that would announce a side pot on every hand before anyone had
+        // even acted.
+        const someoneAllIn = this.state.seats.some(
+            player => player.inHand && Betting.handTotal(player) > 0 && Betting.stackOf(this.state, player) <= 0
+        );
+        if (!someoneAllIn) return null;
+
+        const contributions = this.state.seats.map((player, index) => ({
+            id: player.id,
+            index,
+            contribution: Betting.handTotal(player),
+            folded: player.folded,
+        }));
+
+        const nameById = new Map(
+            this.state.seats.map((player, index) => [player.id, HoldemState.displayName(player, index)])
+        );
+
+        return Render.buildPotBreakdown(
+            PotCalculator.layers(contributions),
+            PotCalculator.uncalledReturns(contributions),
+            id => nameById.get(id)
+        );
+    },
+
    button(label, className, onClick, sublabel) {
        const btn = document.createElement("button");
        btn.type = "button";
@@ -92,7 +215,11 @@ const ActionBar = {
        return btn;
    },

-    commit(mutate) {
+    // Every action taken from the bar goes through here, which is also where it gets
+    // recorded so it can be taken back. A misclick on Fold is the one mistake in this
+    // tool a dealer can't talk their way out of.
+    commit(label, mutate) {
+        this.hooks.beginAction(label);
        mutate();
        this.hooks.save(this.state);
        this.hooks.rerender();
@@ -103,20 +230,21 @@ const ActionBar = {
        const player = this.state.seats[index];
        const owed = Betting.toCall(this.state, player);
        const stack = Betting.stackOf(this.state, player);
+        const who = HoldemState.displayName(player, index);

        const row = document.createElement("div");
        row.className = "actionButtons";

-        row.appendChild(this.button("Fold", "actionFold", () => this.commit(() => Betting.fold(this.state, index))));
+        row.appendChild(this.button("Fold", "actionFold", () => this.commit(`${who}'s fold`, () => Betting.fold(this.state, index))));

        if (owed <= 0) {
-            row.appendChild(this.button("Check", "actionCheck", () => this.commit(() => Betting.check(this.state, index))));
+            row.appendChild(this.button("Check", "actionCheck", () => this.commit(`${who}'s check`, () => Betting.check(this.state, index))));
        } else if (owed >= stack) {
            // Calling would put them all-in, so say that rather than quoting a number
            // they can't cover.
-            row.appendChild(this.button("Call all-in", "actionCall", () => this.commit(() => Betting.allIn(this.state, index)), Money.format(stack)));
+            row.appendChild(this.button("Call all-in", "actionCall", () => this.commit(`${who}'s all-in`, () => Betting.allIn(this.state, index)), Money.format(stack)));
        } else {
-            row.appendChild(this.button("Call", "actionCall", () => this.commit(() => Betting.call(this.state, index)), Money.format(owed)));
+            row.appendChild(this.button("Call", "actionCall", () => this.commit(`${who}'s call`, () => Betting.call(this.state, index)), Money.format(owed)));
        }

        if (stack > owed) {
@@ -185,7 +313,8 @@ const ActionBar = {
        entry.appendChild(this.button("Raise to", "raiseConfirm", () => {
            const target = Math.max(0, Math.min(Number(this.raiseDraft) || 0, maxTo));
            this.raiseOpen = false;
-            this.commit(() => Betting.raiseTo(this.state, index, target));
+            const who = HoldemState.displayName(player, index);
+            this.commit(`${who}'s raise to ${Money.format(target)}`, () => Betting.raiseTo(this.state, index, target));
        }));

        wrap.appendChild(entry);
@@ -204,7 +333,7 @@ const ActionBar = {
                this.hooks.resolvePot();
                return;
            }
-            this.commit(() => Betting.closeStreet(this.state));
+            this.commit(`dealing the ${Betting.streetLabel(Betting.STREETS[Betting.STREETS.indexOf(this.state.street) + 1]).toLowerCase()}`, () => Betting.closeStreet(this.state));
        }));

        return row;
@@ -83,12 +83,39 @@ document.addEventListener("DOMContentLoaded", () => {
        });
    };

+    // A short history of actions taken from the bar, so a misclicked Fold can be taken
+    // back — and the one before it, since a dealer usually notices a beat late. Kept in
+    // memory only: this is for the mistake you just made, not last night's hand.
+    const MAX_UNDO_STEPS = 12;
+    const actionHistory = [];
+
    ActionBar.mount(state, {
        save: hooks.save,
        rerender: hooks.rerender,
        resolvePot: openPotWizard,
+
+        beginAction: label => {
+            actionHistory.push({ label, snapshot: JSON.parse(JSON.stringify(state)) });
+            if (actionHistory.length > MAX_UNDO_STEPS) actionHistory.shift();
+        },
+
+        lastActionLabel: () => (actionHistory.length ? actionHistory[actionHistory.length - 1].label : null),
+
+        undoLast: () => {
+            const step = actionHistory.pop();
+            if (!step) return;
+            Object.keys(state).forEach(key => delete state[key]);
+            Object.assign(state, step.snapshot);
+            hooks.save(state);
+            Render.renderAll();
+            Toast.show(`Took back ${step.label}.`, { duration: 2500 });
+        },
    });

+    // Anything that ends the hand makes the per-action history meaningless — the
+    // snapshots refer to a hand that no longer exists.
+    const clearActionHistory = () => { actionHistory.length = 0; };
+
    // Moving to the next hand used to ask "are you sure?" every single time —
    // the most-pressed button in a session, gated behind a system dialog. It now
    // just happens, and the toast offers the way back for the few seconds anyone
@@ -97,6 +124,9 @@ document.addEventListener("DOMContentLoaded", () => {
    const runUndoable = (message, mutate) => {
        const snapshot = JSON.parse(JSON.stringify(state));
        mutate();
+        // Starting or settling a hand invalidates the per-action history: those
+        // snapshots describe a hand that's over. The whole-step Undo below replaces it.
+        clearActionHistory();
        hooks.save(state);
        Render.renderAll();

@@ -177,6 +207,7 @@ document.addEventListener("DOMContentLoaded", () => {

        HoldemState.clear();
        Object.assign(state, HoldemState.createDefault());
+        clearActionHistory();
        Render.mount(state, hooks);
        Toast.show("Table reset.", { duration: 2500 });
    });
@@ -24,6 +24,79 @@ const PotCalculator = {
        return entries.filter(e => !e.folded && e.remaining > this.EPSILON);
    },

+    // Splits the money on the table into the main pot and any side pots, with who can
+    // win each. Read-only — this is what a dealer says out loud before the showdown
+    // ("main pot four-eighty, side pot ninety between seats 3 and 5"), which is the
+    // announcement that goes missing far more often than the arithmetic goes wrong.
+    //
+    // Every distinct all-in amount opens a new layer: each player pays into a layer up
+    // to their own contribution, and only players who reached that height can win it.
+    // Folded money stays in — it's dead money owed to whoever wins the layer it fell in.
+    layers(players) {
+        const live = players.filter(p => p.contribution > this.EPSILON);
+        if (live.length === 0) return [];
+
+        const heights = [...new Set(live.map(p => Math.round(p.contribution * 100)))].sort((a, b) => a - b);
+
+        const layers = [];
+        let floor = 0;
+        heights.forEach(height => {
+            const band = height - floor;
+            const payers = live.filter(p => Math.round(p.contribution * 100) >= height);
+            const amount = band * payers.length;
+            const eligible = payers.filter(p => !p.folded).map(p => p.id);
+
+            // A band nobody can win isn't a pot — it's an overbet that never got
+            // called, and it goes back to whoever put it in. Announcing it as a side
+            // pot would overstate what's actually being played for.
+            if (amount > 0 && eligible.length > 0) {
+                layers.push({ amount: amount / 100, eligible });
+            }
+            floor = height;
+        });
+
+        // Consecutive layers with the same set of eligible players are one pot to a
+        // dealer — nobody announces two side pots between the same two people.
+        const merged = [];
+        layers.forEach(layer => {
+            const previous = merged[merged.length - 1];
+            const sameEligibility =
+                previous &&
+                previous.eligible.length === layer.eligible.length &&
+                previous.eligible.every(id => layer.eligible.includes(id));
+
+            if (sameEligibility) {
+                previous.amount = Math.round((previous.amount + layer.amount) * 100) / 100;
+            } else {
+                merged.push({ ...layer });
+            }
+        });
+
+        return merged.map((layer, index) => ({
+            ...layer,
+            label: index === 0 ? "Main pot" : `Side pot ${index}`,
+        }));
+    },
+
+    // Chips nobody could call, which the dealer pushes back rather than into the pot.
+    // Anything above the biggest live contribution was never contested — most often an
+    // overbet by someone who then folded.
+    uncalledReturns(players) {
+        const contributing = players.filter(p => p.contribution > this.EPSILON);
+        const liveCents = contributing.filter(p => !p.folded).map(p => Math.round(p.contribution * 100));
+
+        // Nobody live at all means the fold flags are wrong, not that every chip on
+        // the table was uncalled. That's a correction for the dealer to make, so say
+        // nothing here and let the wizard ask them to fix it.
+        if (liveCents.length === 0) return [];
+
+        const cap = Math.max(...liveCents);
+
+        return contributing
+            .map(p => ({ id: p.id, amount: (Math.round(p.contribution * 100) - cap) / 100 }))
+            .filter(r => r.amount > this.EPSILON);
+    },
+
    // Awards the current pot layer to `winnerIds` (one id, or several for a split/tie).
    // The payout is capped at the smallest remaining contribution among the winners —
    // that's the classic side-pot rule: an all-in player can only win what everyone at
@@ -18,13 +18,16 @@ const PotWizard = {
        this.playerLabelById = new Map(
            players.map(p => [p.id, this.labelFor(p, state.seats.indexOf(p))])
        );
-        this.entries = PotCalculator.buildEntries(
-            players.map(p => ({
-                id: p.id,
-                contribution: HoldemState.computeContribution(p, state.chipLegend, state.basePotAmount),
-                folded: p.folded,
-            }))
-        );
+        const contributions = players.map(p => ({
+            id: p.id,
+            contribution: HoldemState.computeContribution(p, state.chipLegend, state.basePotAmount),
+            folded: p.folded,
+        }));
+        this.entries = PotCalculator.buildEntries(contributions);
+        // Kept so the wizard can show the whole breakdown up front, not just the layer
+        // it happens to be asking about.
+        this.layers = PotCalculator.layers(contributions);
+        this.returns = PotCalculator.uncalledReturns(contributions);
        this.log = [];
        this.totals = new Map();

@@ -58,6 +61,7 @@ const PotWizard = {

        const body = document.getElementById("potWizardBody");
        body.innerHTML = "";
+        if (this.log.length === 0) body.appendChild(this.renderBreakdown());
        body.appendChild(this.renderLog());

        const remaining = PotCalculator.totalPot(this.entries.filter(e => e.remaining > PotCalculator.EPSILON));
@@ -65,7 +69,17 @@ const PotWizard = {
        if (contenders.length === 0 && remaining > PotCalculator.EPSILON) {
            const warning = document.createElement("p");
            warning.className = "potWizardPrompt";
-            warning.textContent = `${Money.format(remaining)} is still unassigned, but every remaining player is marked Folded. Uncheck Fold on whoever should win it.`;
+
+            // Money left over because nobody could call it isn't a pot anyone won —
+            // it goes back to whoever put it in. Telling the dealer to un-fold someone
+            // to "win" it would be wrong.
+            const returned = (this.returns || []).reduce((sum, r) => sum + r.amount, 0);
+            if (Math.abs(returned - remaining) <= PotCalculator.EPSILON && returned > 0) {
+                const who = this.returns.map(r => this.playerLabelById.get(r.id)).join(", ");
+                warning.textContent = `${Money.format(remaining)} was never called — push it back to ${who} rather than paying it out.`;
+            } else {
+                warning.textContent = `${Money.format(remaining)} is still unassigned, but every remaining player is marked Folded. Uncheck Fold on whoever should win it.`;
+            }
            body.appendChild(warning);
            body.appendChild(this.renderSummary());
            return;
@@ -131,6 +145,20 @@ const PotWizard = {
        });
    },

+    // The announcement, spelled out before anyone is asked to pick a winner: what the
+    // main pot is worth, what each side pot is worth, and who can win each.
+    renderBreakdown() {
+        const node = Render.buildPotBreakdown(
+            this.layers || [],
+            this.returns || [],
+            id => this.playerLabelById.get(id),
+            "Announce before the showdown"
+        );
+        if (!node) return document.createDocumentFragment();
+        node.classList.add("potBreakdownWizard");
+        return node;
+    },
+
    renderLog() {
        const wrap = document.createElement("div");
        wrap.className = "potWizardLog";
@@ -520,6 +520,51 @@ const Render = {
        });
    },

+    // ---- Pot breakdown ----
+
+    // Shared by the action bar (live, mid-hand) and the pot wizard (before winners are
+    // picked), because both are showing the dealer the same announcement.
+    buildPotBreakdown(pots, returns, nameFor, heading) {
+        if (pots.length < 2 && returns.length === 0) return null;
+
+        const wrap = document.createElement("div");
+        wrap.className = "potBreakdown";
+
+        if (heading) {
+            const title = document.createElement("p");
+            title.className = "potBreakdownHeading";
+            title.textContent = heading;
+            wrap.appendChild(title);
+        }
+
+        const addRow = (label, amount, who, className) => {
+            const row = document.createElement("div");
+            row.className = `potLayer ${className || ""}`;
+
+            const labelEl = document.createElement("span");
+            labelEl.className = "potLayerLabel";
+            labelEl.textContent = label;
+
+            const amountEl = document.createElement("span");
+            amountEl.className = "potLayerAmount";
+            amountEl.textContent = Money.format(amount);
+
+            const whoEl = document.createElement("span");
+            whoEl.className = "potLayerWho";
+            whoEl.textContent = who;
+
+            row.appendChild(labelEl);
+            row.appendChild(amountEl);
+            row.appendChild(whoEl);
+            wrap.appendChild(row);
+        };
+
+        pots.forEach(pot => addRow(pot.label, pot.amount, pot.eligible.map(nameFor).join(", ")));
+        returns.forEach(ret => addRow("Uncalled", ret.amount, `back to ${nameFor(ret.id)}`, "potLayerReturn"));
+
+        return wrap;
+    },
+
    // ---- Session standings ----

    renderStandings() {
Author	SHA1	Message	Date
jheaps	271194cc9e	Merge pull request 'Let the dealer take back an action from the bar' (#26 ) from feature/casino-holdem-action-undo into feature/casino-holdem-pace Reviewed-on: #26	2026-08-31 23:34:46 -06:00
jheapsandClaude Sonnet 5	95c523738c	Let the dealer take back an action from the bar An audit of what's accumulated turned up an inconsistency worth fixing: double- tapping a seat to fold someone was undoable, but tapping Fold in the action bar — the button a dealer actually uses all hand — was not. Nor was Call, Raise, or dealing a street. The safest path through the tool was the shortcut, and the main one had no way back. Every action taken from the bar now goes through one place that records it first, and the bar carries a standing Undo naming what it will take back: "Ben's fold", "dealing the flop". Twelve steps deep, because a misclick usually gets noticed a beat late and one level of undo would only cover the luckiest case. It's a control rather than a toast per action. A dealer taps this bar constantly, and a toast after every fold is noise they'd learn to ignore — which is precisely when they'd miss the one that mattered. The history is discarded whenever a hand starts or settles, because those snapshots describe a hand that no longer exists. The whole-hand Undo on the toast already covers that boundary. Co-Authored-By: Claude Sonnet 5 <[email protected]> Claude-Session: https://claude.ai/code/session_015bnp7xKUPFFSpwkYNFaPgb	2026-08-31 22:37:03 -06:00
jheapsandClaude Sonnet 5	1fcc058dd8	Show how long the current player has been thinking, and how many are left Dealing guides put the biggest time sink not in shuffling or spreading cards but in players who haven't noticed the action is on them — and they list the per-street count of players remaining as part of what a dealer announces. The action bar now carries both. A stopwatch runs on whoever is to act, going amber at thirty seconds and red at a minute, so a dealer can see at a glance whether someone is genuinely deciding or has stopped paying attention. Nothing happens when it grows; it is a prompt for the dealer, not a clock on the player. Beside it is the count of players still in the hand. The timer restarts only when the action actually moves, so re-rendering for an unrelated reason doesn't put a thinking player back to zero, and it ticks by repainting its own text rather than rebuilding the buttons under the dealer's thumb. It stops when the hand ends or the bar hides. Also stops the side-pot breakdown from crying wolf: it now waits for someone to actually be all-in. Unequal amounts in front of players are normal mid-street — the blinds alone are unequal — and layering those announced a side pot on every hand before anyone had acted. Co-Authored-By: Claude Sonnet 5 <[email protected]> Claude-Session: https://claude.ai/code/session_015bnp7xKUPFFSpwkYNFaPgb	2026-08-31 22:21:39 -06:00
jheapsandClaude Sonnet 5	ee25e2a4fa	Show the side-pot breakdown before the showdown, not after Dealing guides are consistent that the most common side-pot error isn't miscounting the chips, it's failing to announce the breakdown clearly before the showdown. The tool had the arithmetic right but only revealed it after the hand, one layer at a time, as the wizard asked who won each. The breakdown is now visible while the hand is still running: as soon as an all-in splits the money, the action bar lists the main pot and each side pot with the amount and who can win it, and the wizard repeats it under "Announce before the showdown" before asking for a winner. A hand with a single undivided pot shows nothing, so the line means something when it appears. Chips nobody could call are called what they are. Money above the largest live contribution was never contested — usually an overbet by someone who then folded — so it's listed as "Uncalled, back to X" rather than padding a side pot nobody can win. The wizard's leftover warning says the same thing instead of telling the dealer to un-fold someone to win it, which was the wrong advice for chips that should simply be pushed back. Co-Authored-By: Claude Sonnet 5 <[email protected]> Claude-Session: https://claude.ai/code/session_015bnp7xKUPFFSpwkYNFaPgb	2026-08-31 22:10:19 -06:00