belote-cli 4.7.1__tar.gz → 4.7.2__tar.gz

{belote_cli-4.7.1 → belote_cli-4.7.2}/CHANGELOG.md

@@ -5,6 +5,114 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [4.7.2] - 2026-05-20
+
+Patch release: external-model audit verification pass. A prior audit (pasted
+from another LLM) flagged ~30 issues across bugs / perf / quality. Verifying
+each claim against the live code rejected the false positives (including one
+HIGH-severity claim — "160 event dispatches per round" — that the model
+invented out of whole cloth) and shipped only the genuinely confirmed
+findings. Two real correctness gaps the prior audit missed were caught via
+fresh-additions review. All baselines green: `ruff` 0 violations,
+`mypy --strict` 0 errors, `pytest` 1003/1003.
+
+### Fixed
+
+- **(Bug) Malédiction (`invert_scoring`) 4-4 trick tie.** Pre-fix the boss
+  flag zeroed the team that won MORE tricks, but a 4-4 split fell through
+  both branches and neither side was zeroed — both teams kept their full
+  scores under the curse. Rule chosen: the taker is zeroed (the cursed
+  side failed to break the tie). `scoring.py::_apply_invert_scoring` adds
+  an `else` branch; pinned by
+  `test_boss_invert_scoring_4_4_tie_zeros_taker` in
+  `tests/belatro/test_boss_modifiers_integration.py`.
+
+### Changed
+
+- **`bm: object` → `bm: BossModifiers`** on `_trick_zeroed_by_ban_clubs`,
+  `_card_points_with_zero_ranks`, `card_points_with_modifiers`, and
+  `_trick_points_with_modifiers` (`scoring.py`). All four helpers were
+  typed as `object` with `getattr(bm, "ban_clubs", False)` defensive
+  lookups; the actual callsites always pass `BossModifiers`. Now type-
+  safe attribute access — `mypy --strict` enforces every new field is
+  spelled correctly.
+- **`UICallbacks` extracted from `BelAtroGame._play_blind`** to a module-
+  top class in `belatro/main.py`. The nested class spanned 189 lines and
+  captured 8 closure variables (`run`, `profile`, `save_manager`, `hud`,
+  `acc`, `trust_bar`, `show_north`, plus a dead-write `last_display_state`
+  cell). Now an explicit constructor; `last_display_state` removed
+  (write-only, never read).
+- **Litige pool carry across all-pass redeals is now documented.** Added
+  a `reset_round_fields` docstring entry calling out that `litige_points`
+  is deliberately NOT in the reset list — the pool survives across
+  rounds (including all-pass redeals) until a non-litige scoring round
+  consumes it. Pinned by
+  `test_litige_pool_survives_all_pass_redeal` +
+  `test_litige_pool_survives_two_consecutive_all_pass_redeals` in
+  `tests/test_bidding_all_pass.py`.
+
+### Performance
+
+- **`detect_sequences` is now `@lru_cache(128)`.** Microbench placed it
+  at ~25% of `score_round` cost when `initial_hands` is populated, and
+  `get_declarations` runs the same 4 hand tuples through the helper
+  twice per round (once at bid-acceptance time in `game.py`, once during
+  `score_round` itself). Cache hits eliminate the second pass.
+  `score_round` macrobench: 300 µs → 227 µs (~24% on the full path).
+  Cards are frozen dataclasses (hashable); all callers treat the
+  returned list as read-only.
+
+### Tests strengthened
+
+- **`test_last_trick_bonus_applied`** (`tests/test_belote.py`) → split
+  into `test_capot_subsumes_last_trick_bonus` (asserts the actual
+  `CAPOT_BASE` total) and new `test_last_trick_bonus_applied_in_normal_round`
+  (deterministic 4-NS/4-EW non-capot fixture proving the +10 dix-de-der
+  actually lands on the taker side). Previously only asserted `is_capot
+  is True` — the +10 mechanic the test name promised was untested.
+- **`test_non_capot_points_sum_162`** (`tests/test_belote.py`) →
+  conditional `if not breakdown.is_capot:` replaced with explicit
+  `assert not breakdown.is_capot` plus the unconditional conservation
+  check. The old form passed vacuously if `make_deck()` ordering ever
+  produced a capot.
+
+### Internal
+
+- **Contract→word a11y mapping deduplicated** to a `_contract_word(state)`
+  helper in `gameflow.py`. Two near-identical 8-line blocks collapsed
+  into one helper call each (bid→play transition; round-result speak).
+
+### Documentation
+
+- README test count claims and CHANGELOG / DEVELOPMENT references
+  updated 999 → 1003.
+
+### Verified-false audit claims (re-investigate at your peril)
+
+For the record so the next audit cycle doesn't relitigate items the
+external model flagged but the code disagreed with:
+
+- `partner()` if-chain vs modular arithmetic — style only, not a bug.
+- `start_round` "doesn't reset belote_holders" — self-refuted (line 308
+  passes `belote_holders={}`).
+- Score-animation labels "confusing" — `gameflow.py:458` already labels
+  by `breakdown.taker_team`.
+- `_empty_breakdown` taker_team default — only returned on contract-
+  inactive states; harmless.
+- `BelAtroRun.consume()` "removes before use" — wrapped in
+  `contextlib.suppress(ValueError)`, semantically correct.
+- `_bonus_money` "race" — Le Fantôme writes to `acc._ledger.money`
+  directly since 4.6.2; main.py only consumes seal_round-routed amounts.
+- "160 event dispatches per round" — false. Jokers subscribe to
+  `TrickWonEvent` / `BeloteAnnouncedEvent` / `DeclarationScoredEvent`
+  only; per-card emit doesn't iterate jokers. Real count is ~85-100
+  dispatches per round and they're already O(jokers × events).
+- LeRebelle / RebeloteEcho / TierceCharger ungated under boss flags —
+  verified gated. `game.py:907` short-circuits `BeloteAnnouncedEvent`
+  under `no_belote`; `round_driver.py:467-473` documents
+  TierceCharger's intentional un-gating; LeMathématicien / QuinteRoyale
+  read `event.points` which Le Mime forces to 0.
+
 ## [4.7.1] - 2026-05-19
 
 Patch release: post-4.7.0 audit pass that found two latent correctness

{belote_cli-4.7.1 → belote_cli-4.7.2}/DEVELOPMENT.md

@@ -84,7 +84,7 @@ PYTHONPATH=src mypy --strict src/
 # Linting (0 violations expected)
 ruff check src/ tests/
 
-# Full test suite (999 tests expected)
+# Full test suite (1003 tests expected)
 PYTHONPATH=src pytest
 ```
 

{belote_cli-4.7.1 → belote_cli-4.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: belote-cli
-Version: 4.7.1
+Version: 4.7.2
 Summary: A 4-player terminal card game
 Project-URL: Homepage, https://github.com/ElysiumDisc/belote
 Project-URL: Repository, https://github.com/ElysiumDisc/belote
@@ -263,7 +263,7 @@ belote/
 │   ├── input.py       # Platform-dispatched key reader and interruptible sleep
 │   ├── stats.py       # Global and session statistics tracking
 │   └── rules.py       # Game rules content
-├── tests/             # Comprehensive test suite (999 tests)
+├── tests/             # Comprehensive test suite (1003 tests)
 ├── scripts/           # Performance benchmarks
 ├── pyproject.toml      # Build system and dev dependencies (ruff/mypy)
 ├── LICENSE             # MIT License
@@ -278,14 +278,14 @@ belote/
 PYTHONPATH=src pytest
 ```
 
-Currently **999 tests** passing with 100% coverage on game-logic modules (4.7.1).
+Currently **1003 tests** passing with 100% coverage on game-logic modules (4.7.2).
 
 ## Technical Integrity
 
 The codebase is strictly validated with the following tools:
 - **mypy**: 0 errors (strict type safety)
 - **ruff**: 0 violations (linting & formatting)
-- **pytest**: 999/999 passed
+- **pytest**: 1003/1003 passed
 - **Functional Architecture**: Purely immutable state transitions using `dataclasses.replace`
 - **Performance**: High-efficiency rendering and sub-millisecond AI decision times (see `scripts/benchmark.py`)
 

{belote_cli-4.7.1 → belote_cli-4.7.2}/README.md

@@ -220,7 +220,7 @@ belote/
 │   ├── input.py       # Platform-dispatched key reader and interruptible sleep
 │   ├── stats.py       # Global and session statistics tracking
 │   └── rules.py       # Game rules content
-├── tests/             # Comprehensive test suite (999 tests)
+├── tests/             # Comprehensive test suite (1003 tests)
 ├── scripts/           # Performance benchmarks
 ├── pyproject.toml      # Build system and dev dependencies (ruff/mypy)
 ├── LICENSE             # MIT License
@@ -235,14 +235,14 @@ belote/
 PYTHONPATH=src pytest
 ```
 
-Currently **999 tests** passing with 100% coverage on game-logic modules (4.7.1).
+Currently **1003 tests** passing with 100% coverage on game-logic modules (4.7.2).
 
 ## Technical Integrity
 
 The codebase is strictly validated with the following tools:
 - **mypy**: 0 errors (strict type safety)
 - **ruff**: 0 violations (linting & formatting)
-- **pytest**: 999/999 passed
+- **pytest**: 1003/1003 passed
 - **Functional Architecture**: Purely immutable state transitions using `dataclasses.replace`
 - **Performance**: High-efficiency rendering and sub-millisecond AI decision times (see `scripts/benchmark.py`)
 

{belote_cli-4.7.1 → belote_cli-4.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "belote-cli"
-version = "4.7.1"
+version = "4.7.2"
 description = "A 4-player terminal card game"
 readme = "README.md"
 requires-python = ">=3.10"

{belote_cli-4.7.1 → belote_cli-4.7.2}/src/belote/__init__.py

@@ -1,3 +1,3 @@
-__version__ = "4.7.1"
+__version__ = "4.7.2"
 
 __all__ = ["__version__"]

{belote_cli-4.7.1 → belote_cli-4.7.2}/src/belote/belatro/main.py

@@ -7,8 +7,14 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
+    from belote.deck import Card
+    from belote.game import GameState, Seat
+
     from ..input import KeyReader
     from .ghost_run import GhostRecorder
+    from .progression.save import Profile
+    from .ui.hud import BelAtroHUD
+    from .ui.trust_bar import TrustBar
 
 from .core.run_state import BelAtroRun
 from .core.scoring import ScoreAccumulator
@@ -22,6 +28,225 @@ from .ui.menu import BelAtroMainMenu
 from .ui.shop import ShopScreen
 
 
+class UICallbacks(RoundUICallbacks):
+    """BelAtro round-UI callbacks. Wraps the classic ``prompt_bid`` /
+    ``prompt_card`` flow with overlay handling, BelAtro HUD + trust-bar
+    repaint, L'Architecte buy-contract, Dix de Der Heist prompt, and
+    surcoinche prompt.
+
+    Extracted from ``BelAtroGame._play_blind`` for readability — the
+    eight dependencies were previously captured via closure cells. The
+    interfaces (RoundUICallbacks methods) are unchanged.
+    """
+
+    def __init__(
+        self,
+        reader: KeyReader,
+        run: BelAtroRun,
+        profile: Profile,
+        save_manager: SaveManager,
+        acc: ScoreAccumulator,
+        hud: BelAtroHUD,
+        trust_bar: TrustBar,
+        show_north: bool,
+    ) -> None:
+        self.reader = reader
+        self.run = run
+        self.profile = profile
+        self.save_manager = save_manager
+        self.acc = acc
+        self.hud = hud
+        self.trust_bar = trust_bar
+        self.show_north = show_north
+
+    def _show_overlay(self, state: GameState) -> None:
+        # 4.6.3: I/V now toggles BelAtro top HUD visibility (joker pip
+        # strip, ante line, chips×mult, trust bar, synergy tooltip).
+        # When hidden, the classic HUD's `Trump:` / `Taker:` fields on
+        # row 1 are no longer painted over. `invalidate_diff()` is
+        # required so `display()` re-paints row 1 from scratch instead
+        # of diffing against the cached frame that still believed the
+        # joker strip occupied cols 2–25.
+        from ..ui.render import display, invalidate_diff
+        from .ui.announce import toggle_top_hud
+
+        toggle_top_hud()
+        invalidate_diff()
+        display(state, show_north_hand=self.show_north)
+        self.hud.render(self.acc, state)
+        self.trust_bar.render()
+
+    def prompt_bid(self, state: GameState) -> object:
+        from ..ui.prompts import prompt_bid
+        from .ui.announce import BelAtroAnnounce
+
+        # L'Architecte (4.5.0): offer to buy the contract for $10
+        # before showing the normal bid UI. Re-checked each call (the
+        # loop may come around to SOUTH again after a pass) — money has
+        # to be high enough at the moment of purchase.
+        if (
+            self.run.card_enhancements.get("buy_contract")
+            and self.run.economy.money >= 10
+            and BelAtroAnnounce.yes_no(
+                "L'Architecte: buy the contract for $10?", self.reader
+            )
+        ):
+            chosen = BelAtroAnnounce.buy_contract_picker(self.reader)
+            if chosen is not None:
+                self.run.economy.money -= 10
+                BelAtroAnnounce.banner(
+                    "Contract bought — $10 spent",
+                    self.reader,
+                    hold=0.8,
+                )
+                return chosen
+
+        while True:
+            res = prompt_bid(state, self.reader)
+            if res == "OVERLAY":
+                self._show_overlay(state)
+                continue
+            if res == "QUIT":
+                raise KeyboardInterrupt
+            if isinstance(res, str):
+                return None
+            return res
+
+    def prompt_card(self, state: GameState) -> tuple[Card, GameState]:
+        from ..ui.prompts import prompt_card
+
+        # 4.7.0 follow-up: hook the BelAtro HUD + trust bar into the
+        # classic prompt_card loop so the persistent slot-machine tally
+        # readout (gated on `_top_hud_visible`) repaints after every
+        # `display()` call. Without this hook, between-tricks the player
+        # sees the felt mat but no readout — the HUD is only refreshed
+        # by `on_card_played` (post-play) and `_show_overlay` (I-toggle).
+        def _hud_after_display(s: GameState) -> None:
+            self.hud.render(self.acc, s)
+            self.trust_bar.render()
+
+        while True:
+            card, new_state = prompt_card(
+                state,
+                self.reader,
+                show_north_hand=self.show_north,
+                after_display=_hud_after_display,
+            )
+            if card == "OVERLAY":
+                self._show_overlay(state)
+                continue
+            if card == "INVENTORY":
+                # 4.7.0: V key — open the InventoryOverlay (read-only
+                # view of jokers/vouchers/consumables/permanent
+                # bonuses/contract levels). Wraps with invalidate_diff()
+                # then re-renders so the player returns to a clean
+                # card-selection prompt.
+                self._show_inventory(state)
+                continue
+            if card is None:
+                raise KeyboardInterrupt
+            if card == "UNDO":
+                continue
+            if isinstance(card, str):
+                continue
+            return card, new_state
+
+    def _show_inventory(self, state: GameState) -> None:
+        """Open the V-key inventory overlay and repaint on exit."""
+        from belote.ui.render import display, invalidate_diff
+
+        from .ui.inventory import InventoryOverlay
+
+        InventoryOverlay(self.run, self.reader).open()
+        invalidate_diff()
+        display(state, show_north_hand=self.show_north)
+        self.hud.render(self.acc, state)
+        self.trust_bar.render()
+
+    def on_card_played(self, state: GameState, seat: Seat, card: Card) -> None:
+        from dataclasses import replace as dc_replace
+
+        from ..ui.render import display
+
+        if not state.current_trick and state.completed_tricks:
+            display_state = dc_replace(state, current_trick=state.completed_tricks[-1])
+        else:
+            display_state = state
+        display(display_state, show_north_hand=self.show_north)
+        self.hud.render(self.acc, display_state)
+        self.trust_bar.render()
+
+    def on_trick_end(self, state: GameState, winner: Seat, points: int) -> None:
+        # 4.7.0: animated odometer-style tally replaces the static
+        # multi-line popup. The popup helper is kept defined for one
+        # release in case a future BelAtro overlay needs the per-trick
+        # log breakdown.
+        from .ui.announce import BelAtroAnnounce
+
+        BelAtroAnnounce.slot_machine_tally(
+            self.acc, state, self.reader, points=points
+        )
+
+    def on_round_end(self, breakdown: object) -> None:
+        pass
+
+    def prompt_surcoinche(self, state: GameState, coincheur: Seat) -> bool:
+        """3.7.1 D3: ask the NS taker whether to surcoinche after EW coinches."""
+        from .ui.announce import BelAtroAnnounce
+
+        prompt = f"{coincheur.name} coinched! Surcoinche back?"
+        return BelAtroAnnounce.yes_no(prompt, self.reader)
+
+    def prompt_heist(self, state: GameState) -> bool:
+        """4.7.0: Dix de Der Heist declaration prompt.
+
+        Two gates collapse the prompt when the heist has no value:
+          - ``state.taker == Seat.SOUTH``: only the player declares; AI
+            seats never get the prompt. The engine already gates on this
+            too — belt-and-suspenders here so a future direct caller
+            can't slip past.
+          - ``self.acc.interest_rate > 0``: with rate=0 the multiplier
+            is 1× (no reward), so declaring is pure downside. Default
+            Economy.interest_rate is 0 — La Voûte voucher or one of the
+            rate-bumping tarots must be purchased to enable.
+
+        Discoverability hint (4.7.0): when the player takes a contract
+        without La Voûte, show a one-time explainer banner.
+        ``self.profile.seen_heist_hint`` is flipped True and persisted,
+        so the hint never shows again for this profile.
+        """
+        from belote.game import Seat as _Seat
+
+        from .ui.announce import BelAtroAnnounce
+
+        if state.taker != _Seat.SOUTH:
+            return False
+        if self.acc.interest_rate <= 0:
+            if not self.profile.seen_heist_hint:
+                BelAtroAnnounce.banner(
+                    "Tip: buy the La Voûte voucher in the shop to unlock "
+                    "the Dix de Der Heist (×2+ Mult on trick 8).",
+                    self.reader,
+                    hold=2.5,
+                )
+                self.profile.seen_heist_hint = True
+                self.save_manager.save_profile(self.profile)
+            return False
+        multiplier = 1 + self.acc.interest_rate
+        declared = BelAtroAnnounce.yes_no(
+            f"DIX DE DER HEIST — Win trick 8 for ×{multiplier} Mult, "
+            "or lose trick 8 and forfeit tricks 1-7 chips. Declare?",
+            self.reader,
+        )
+        if declared:
+            BelAtroAnnounce.banner(
+                "DIX DE DER HEIST DECLARED — all in on trick 8",
+                self.reader,
+                hold=1.5,
+            )
+        return declared
+
+
 class BelAtroGame:
     def __init__(self) -> None:
         import os
@@ -202,204 +427,6 @@ class BelAtroGame:
         from .ui.announce import reset_tally_state
         reset_tally_state()
         show_north = self.run.show_north_hand or self.run.partner.trust.shares_void_info
-        run = self.run  # captured for UICallbacks closure (see prompt_bid)
-        # 4.7.0: captured for the one-time La Voûte hint in prompt_heist.
-        profile = self.profile
-        save_manager = self.save_manager
-
-        last_display_state: list[GameState | None] = [None]  # mutable cell for closure
-
-        from belote.deck import Card
-        from belote.game import GameState, Seat
-
-        class UICallbacks(RoundUICallbacks):
-            def __init__(self, reader: KeyReader):
-                self.reader = reader
-
-            def _show_overlay(self, state: GameState) -> None:
-                # 4.6.3: I/V now toggles BelAtro top HUD visibility (joker pip
-                # strip, ante line, chips×mult, trust bar, synergy tooltip).
-                # When hidden, the classic HUD's `Trump:` / `Taker:` fields on
-                # row 1 are no longer painted over. `invalidate_diff()` is
-                # required so `display()` re-paints row 1 from scratch instead
-                # of diffing against the cached frame that still believed the
-                # joker strip occupied cols 2–25.
-                from ..ui.render import display, invalidate_diff
-                from .ui.announce import toggle_top_hud
-
-                toggle_top_hud()
-                invalidate_diff()
-                display(state, show_north_hand=show_north)
-                hud.render(acc, state)
-                trust_bar.render()
-
-            def prompt_bid(self, state: GameState) -> object:
-                from ..ui.prompts import prompt_bid
-
-                # L'Architecte (4.5.0): offer to buy the contract for $10
-                # before showing the normal bid UI. We re-check eligibility
-                # each time prompt_bid is called (the loop may come around to
-                # SOUTH again after a pass) — money has to be high enough at
-                # the moment of purchase. `run` is the BelAtroRun captured in
-                # the enclosing closure.
-                if (
-                    run.card_enhancements.get("buy_contract")
-                    and run.economy.money >= 10
-                    and BelAtroAnnounce.yes_no(
-                        "L'Architecte: buy the contract for $10?", self.reader
-                    )
-                ):
-                    chosen = BelAtroAnnounce.buy_contract_picker(self.reader)
-                    if chosen is not None:
-                        run.economy.money -= 10
-                        BelAtroAnnounce.banner(
-                            "Contract bought — $10 spent",
-                            self.reader,
-                            hold=0.8,
-                        )
-                        return chosen
-
-                while True:
-                    res = prompt_bid(state, self.reader)
-                    if res == "OVERLAY":
-                        self._show_overlay(state)
-                        continue
-                    if res == "QUIT":
-                        raise KeyboardInterrupt
-                    if isinstance(res, str):
-                        return None
-                    return res
-
-            def prompt_card(self, state: GameState) -> tuple[Card, GameState]:
-                from ..ui.prompts import prompt_card
-
-                # 4.7.0 follow-up: hook the BelAtro HUD + trust bar into the
-                # classic prompt_card loop so the persistent slot-machine
-                # tally readout (gated on `_top_hud_visible`) repaints after
-                # every `display()` call. Without this hook, between-tricks
-                # the player sees the felt mat but no readout — the HUD is
-                # only refreshed by `on_card_played` (post-play) and
-                # `_show_overlay` (I-toggle).
-                def _hud_after_display(s: GameState) -> None:
-                    hud.render(acc, s)
-                    trust_bar.render()
-
-                while True:
-                    card, new_state = prompt_card(
-                        state,
-                        self.reader,
-                        show_north_hand=show_north,
-                        after_display=_hud_after_display,
-                    )
-                    if card == "OVERLAY":
-                        self._show_overlay(state)
-                        continue
-                    if card == "INVENTORY":
-                        # 4.7.0: V key — open the InventoryOverlay (read-only
-                        # view of jokers/vouchers/consumables/permanent
-                        # bonuses/contract levels). Wraps with
-                        # invalidate_diff() then re-renders so the player
-                        # returns to a clean card-selection prompt.
-                        self._show_inventory(state)
-                        continue
-                    if card is None:
-                        raise KeyboardInterrupt
-                    if card == "UNDO":
-                        continue
-                    if isinstance(card, str):
-                        continue
-                    return card, new_state
-
-            def _show_inventory(self, state: GameState) -> None:
-                """Open the V-key inventory overlay and repaint on exit."""
-                from belote.ui.render import display, invalidate_diff
-
-                from .ui.inventory import InventoryOverlay
-
-                InventoryOverlay(run, self.reader).open()
-                invalidate_diff()
-                display(state, show_north_hand=show_north)
-                hud.render(acc, state)
-                trust_bar.render()
-
-            def on_card_played(self, state: GameState, seat: Seat, card: Card) -> None:
-                from dataclasses import replace as dc_replace
-
-                from ..ui.render import display
-
-                if not state.current_trick and state.completed_tricks:
-                    display_state = dc_replace(state, current_trick=state.completed_tricks[-1])
-                else:
-                    display_state = state
-                last_display_state[0] = display_state
-                display(display_state, show_north_hand=show_north)
-                hud.render(acc, display_state)
-                trust_bar.render()
-
-            def on_trick_end(self, state: GameState, winner: Seat, points: int) -> None:
-                # 4.7.0: animated odometer-style tally replaces the static
-                # multi-line popup. The popup helper is kept defined for one
-                # release in case a future BelAtro overlay needs the per-trick
-                # log breakdown.
-                BelAtroAnnounce.slot_machine_tally(
-                    acc, state, self.reader, points=points
-                )
-
-            def on_round_end(self, breakdown: object) -> None:
-                pass
-
-            def prompt_surcoinche(self, state: GameState, coincheur: Seat) -> bool:
-                """3.7.1 D3: ask the NS taker whether to surcoinche after EW coinches."""
-                prompt = f"{coincheur.name} coinched! Surcoinche back?"
-                return BelAtroAnnounce.yes_no(prompt, self.reader)
-
-            def prompt_heist(self, state: GameState) -> bool:
-                """4.7.0: Dix de Der Heist declaration prompt.
-
-                Two gates collapse the prompt when the heist has no value:
-                  - `state.taker == Seat.SOUTH`: only the player declares; AI
-                    seats never get the prompt. The engine already gates on
-                    this too — belt-and-suspenders here so a future direct
-                    caller can't slip past.
-                  - `acc.interest_rate > 0`: with rate=0 the multiplier is
-                    1× (no reward), so declaring is pure downside. Default
-                    Economy.interest_rate is 0 — La Voûte voucher or one of
-                    the rate-bumping tarots must be purchased to enable.
-
-                Discoverability hint (4.7.0): when the player takes a
-                contract without La Voûte, show a one-time explainer
-                banner. `profile.seen_heist_hint` is flipped True and
-                persisted, so the hint never shows again for this profile.
-                Without this, fresh players would never see the heist —
-                the prompt is silently gated off and there's no signal
-                pointing at the unlock path.
-                """
-                if state.taker != Seat.SOUTH:
-                    return False
-                if acc.interest_rate <= 0:
-                    if not profile.seen_heist_hint:
-                        BelAtroAnnounce.banner(
-                            "Tip: buy the La Voûte voucher in the shop to unlock "
-                            "the Dix de Der Heist (×2+ Mult on trick 8).",
-                            self.reader,
-                            hold=2.5,
-                        )
-                        profile.seen_heist_hint = True
-                        save_manager.save_profile(profile)
-                    return False
-                multiplier = 1 + acc.interest_rate
-                declared = BelAtroAnnounce.yes_no(
-                    f"DIX DE DER HEIST — Win trick 8 for ×{multiplier} Mult, "
-                    "or lose trick 8 and forfeit tricks 1-7 chips. Declare?",
-                    self.reader,
-                )
-                if declared:
-                    BelAtroAnnounce.banner(
-                        "DIX DE DER HEIST DECLARED — all in on trick 8",
-                        self.reader,
-                        hold=1.5,
-                    )
-                return declared
 
         # Check if boss
         boss = None
@@ -494,7 +521,16 @@ class BelAtroGame:
             partner=self.run.partner,
             boss=boss,
             target_score=self.run.target_score,
-            ui_callbacks=UICallbacks(self.reader),
+            ui_callbacks=UICallbacks(
+                self.reader,
+                self.run,
+                self.profile,
+                self.save_manager,
+                acc,
+                hud,
+                trust_bar,
+                show_north,
+            ),
             acc=acc,
             card_enhancements=round_flags,
             recorder=self._ghost_recorder,

{belote_cli-4.7.1 → belote_cli-4.7.2}/src/belote/game.py

@@ -259,7 +259,13 @@ class GameState:
 
 
 def reset_round_fields(state: GameState, **kwargs: object) -> GameState:
-    """Return a new state with round-specific fields reset to defaults."""
+    """Return a new state with round-specific fields reset to defaults.
+
+    `litige_points` is deliberately NOT reset here. The litige pool survives
+    across rounds — including all-pass redeals — until a non-litige scoring
+    round consumes it (see `scoring.py::apply_round_score`). Tests in
+    `tests/test_bidding_all_pass.py` pin this contract.
+    """
     reset_values: dict[str, object] = {
         "trump": None,
         "taker": None,