belote-cli 4.9.4__tar.gz → 4.9.5__tar.gz

{belote_cli-4.9.4 → belote_cli-4.9.5}/CHANGELOG.md

@@ -5,6 +5,63 @@ 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.9.5] - 2026-05-28
+
+Bug-hunt, logic, and performance audit pass. Three parallel Explore agents
+swept the classic engine, BelAtro mechanics, and the UI/render layer; every
+finding below was traced to exact code and the high-severity ones reproduced at
+runtime before fixing. Test count 1066 → 1079.
+
+### Fixed
+
+- **Crash: `legal_cards` returned an empty set under La Déluge**
+  (`src/belote/game.py`). With the `seven_eight_trump` boss active, every 7/8
+  is a trump — but the trump-follow set was built from `c.suit == lead_suit`,
+  which dropped off-suit 7/8s. A player void of the trump *suit* but holding
+  only off-suit 7/8 (which ARE trumps) got zero legal cards on a trump lead,
+  tripping `AIPlayer.decide_card`'s empty-legal assertion. A single
+  `is_trump_card` predicate now drives both the trump-led and non-trump-led
+  follow/overtrump paths. Regression tests in `tests/test_deluge_legal_cards.py`.
+- **AI partner-signal double-count after a mid-round undo** (`src/belote/ai.py`).
+  The undo-regression branch reset the void cache and `processed_tricks_count`
+  but not the partner-signal tally; because `_update_voids` re-walks surviving
+  tricks from zero, their signals were counted twice. Both reset paths now share
+  a single `_reset_round_memory()` helper so they can't drift again.
+- **Belote + Rebelote scored 40 instead of the official 20** (`src/belote/config.py`).
+  Holding the King and Queen of trump is worth 20 points *total* in official
+  French Belote — and the in-game Rules screen already said 20. `REBELOTE_POINTS`
+  is now 20, matching both.
+- **Coinche round-end animation showed the pre-multiplier score**
+  (`src/belote/gameflow.py`). The score counter animated to the raw breakdown
+  total while the stored score applied `2 ** coinche_level`. Both now use the
+  shared `scoring.coinche_adjusted_credits()` helper, so the animation lands on
+  the real total.
+- **Joker money not reconciled on a failed-but-survived round**
+  (`src/belote/belatro/main.py`). Signed `JokerResult.add_money` (e.g.
+  LePrêteur's −$5 skim, baked into the round's ×Mult) was only applied on the
+  success path, handing a free multiplier when a chute was survived via Capot
+  Insurance. A shared `_reconcile_bonus_money()` helper now runs on both paths.
+- **La Symbiose fired ×1.2 Mult on zero-point declarations under Le Mime**
+  (`src/belote/belatro/items/partner_jokers/passive.py`). Now gated on
+  `event.points > 0`, mirroring Le Mathématicien.
+
+### Changed
+
+- **BelAtro HUD / TrustBar now invalidate the render diff** after their direct
+  stdout writes (`belatro/ui/hud.py`, `trust_bar.py`), matching the 4.0.0
+  overlay convention so a static-state `display()` can't leave a stale top bar.
+  The convention is now enforced for both files by
+  `tests/test_alt_screen_scroll.py`.
+- **Performance**: `_pip_at`'s LRU cache raised 4096 → 8192 so wide-terminal
+  felt mats (>5000 cells/frame) stop thrashing it (`ui/render.py`);
+  `visible_len` no longer spends cache slots on plain (no-ANSI) strings
+  (`ansi.py`); the BelAtro [H] history overlay caches its line list on
+  `(term_w, entry_count)` instead of rebuilding every keystroke
+  (`belatro/ui/history.py`).
+- **Docs**: corrected the trust tier-0 docstring (it claimed "effects halved";
+  the implementation applies the baseline once with no penalty) and the tier
+  bonus percentages to match the `(0, 0, 1, 1, 2)` extra-applies model.
+
 ## [4.9.4] - 2026-05-26
 
 Audit + maintenance pass. Three parallel Explore agents reviewed game-logic

{belote_cli-4.9.4 → belote_cli-4.9.5}/DEVELOPMENT.md

@@ -84,7 +84,7 @@ PYTHONPATH=src mypy --strict src/
 # Linting (0 violations expected)
 ruff check src/ tests/
 
-# Full test suite (1066 tests expected)
+# Full test suite (1079 tests expected)
 PYTHONPATH=src pytest
 ```
 
@@ -221,6 +221,8 @@ PYTHONPATH=src python scripts/benchmark.py
 If you suspect a per-frame allocation regression, the canonical hot paths to
 profile live (e.g. with `py-spy record --rate 100`) are `render()` in
 `src/belote/ui/render.py` and `_calculate_legal_cards_impl` in
-`src/belote/game.py`. The 4.9.4 audit pass found no quick wins beyond those
-already landed in the 4.6.x / 4.7.x perf cleanups — start from a profiler
-trace, not from guesswork, before adding new caches.
+`src/belote/game.py`. The 4.9.4 / 4.9.5 audit passes found only minor wins
+beyond those already landed in the 4.6.x / 4.7.x perf cleanups (4.9.5 bumped
+the `_pip_at` cache to 8192, trimmed `visible_len`'s cache to ANSI strings,
+and memoised the BelAtro history overlay) — start from a profiler trace, not
+from guesswork, before adding new caches.

{belote_cli-4.9.4 → belote_cli-4.9.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: belote-cli
-Version: 4.9.4
+Version: 4.9.5
 Summary: A 4-player terminal card game
 Project-URL: Homepage, https://github.com/ElysiumDisc/belote
 Project-URL: Repository, https://github.com/ElysiumDisc/belote
@@ -264,7 +264,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 (1069 tests)
+├── tests/             # Comprehensive test suite (1079 tests)
 ├── scripts/           # Performance benchmarks
 ├── pyproject.toml      # Build system and dev dependencies (ruff/mypy)
 ├── LICENSE             # MIT License
@@ -279,7 +279,7 @@ belote/
 PYTHONPATH=src pytest
 ```
 
-Currently **1069 tests** passing with 100% coverage on game-logic modules (4.9.4).
+Currently **1079 tests** passing with 100% coverage on game-logic modules (4.9.5).
 
 ## Technical Integrity
 

{belote_cli-4.9.4 → belote_cli-4.9.5}/README.md

@@ -221,7 +221,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 (1069 tests)
+├── tests/             # Comprehensive test suite (1079 tests)
 ├── scripts/           # Performance benchmarks
 ├── pyproject.toml      # Build system and dev dependencies (ruff/mypy)
 ├── LICENSE             # MIT License
@@ -236,7 +236,7 @@ belote/
 PYTHONPATH=src pytest
 ```
 
-Currently **1069 tests** passing with 100% coverage on game-logic modules (4.9.4).
+Currently **1079 tests** passing with 100% coverage on game-logic modules (4.9.5).
 
 ## Technical Integrity
 

{belote_cli-4.9.4 → belote_cli-4.9.5}/pyproject.toml

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

{belote_cli-4.9.4 → belote_cli-4.9.5}/src/belote/__init__.py

@@ -1,3 +1,3 @@
-__version__ = "4.9.4"
+__version__ = "4.9.5"
 
 __all__ = ["__version__"]

{belote_cli-4.9.4 → belote_cli-4.9.5}/src/belote/ai.py

@@ -74,6 +74,27 @@ class AIPlayer:
         # All ranking helpers in this class read it via self._se.
         self._se = False
 
+    def _reset_round_memory(self) -> None:
+        """Clear all per-round derived memory back to a clean slate.
+
+        Shared by the new-round and mid-round-undo paths in ``update_memory`` so
+        the two can't drift: a partial reset (e.g. clearing the void cache but
+        not the partner-signal tally) would let ``_update_voids`` re-walk the
+        surviving tricks and double-count their signals.
+        """
+        self.memory.played.clear()
+        for s in Seat:
+            self.memory.known_voids[s].clear()
+        self.memory.partner_hand.clear()
+        self.memory.processed_tricks_count = 0
+        self.memory.last_voids_key = None
+        self.memory.last_partner_hand_key = None
+        # 4.9.0 / G2: partner-signal tally and our emit-counter follow
+        # the same reset pattern as the void cache.
+        for suit in Suit:
+            self.memory.signals[suit] = 0
+        self.memory.signals_emitted = 0
+
     def update_memory(self, state: GameState) -> None:
         """Update memory with currently visible information."""
         completed_count = len(state.completed_tricks)
@@ -84,18 +105,7 @@ class AIPlayer:
             # this a (0, 0) / (0, 1) key from the first decision of *this* round
             # could coincidentally match a leftover from the previous round and
             # cause _update_voids to skip processing entirely.
-            self.memory.played.clear()
-            for s in Seat:
-                self.memory.known_voids[s].clear()
-            self.memory.partner_hand.clear()
-            self.memory.processed_tricks_count = 0
-            self.memory.last_voids_key = None
-            self.memory.last_partner_hand_key = None
-            # 4.9.0 / G2: partner-signal tally and our emit-counter follow
-            # the same triple-reset pattern as the void cache.
-            for suit in Suit:
-                self.memory.signals[suit] = 0
-            self.memory.signals_emitted = 0
+            self._reset_round_memory()
         elif (
             self.memory.last_voids_key is not None
             and (completed_count, current_count) < self.memory.last_voids_key
@@ -104,13 +114,12 @@ class AIPlayer:
             # we've processed. `known_voids` and `processed_tricks_count`
             # are monotonic and would carry stale inferences forward
             # (a void inferred from a now-rolled-back trick). Rebuild from
-            # the current state instead of trying to subtract.
-            self.memory.played.clear()
-            for s in Seat:
-                self.memory.known_voids[s].clear()
-            self.memory.processed_tricks_count = 0
-            self.memory.last_voids_key = None
-            self.memory.last_partner_hand_key = None
+            # the current state instead of trying to subtract. The signal
+            # tally is rebuilt by _update_voids' re-walk (processed count is
+            # reset to 0), so it MUST be cleared here too — otherwise the
+            # surviving tricks' signals are double-counted. Same full reset
+            # as a new round.
+            self._reset_round_memory()
 
         # Track all cards in completed tricks. N is small (max 32 cards), so
         # the O(N) re-walk is fine and keeps this in sync with the transient

{belote_cli-4.9.4 → belote_cli-4.9.5}/src/belote/ansi.py

@@ -101,12 +101,23 @@ _RESET_RE = re.compile(r"\x1b\[[0-9;?]*[A-Za-z]")
 RESET = "\x1b[0m"
 
 
-@lru_cache(maxsize=4096)
+@lru_cache(maxsize=2048)
+def _visible_len_ansi(s: str) -> int:
+    return len(_RESET_RE.sub("", s))
+
+
 def visible_len(s: str) -> int:
-    """Return length of string with ANSI escape codes stripped."""
+    """Return length of string with ANSI escape codes stripped.
+
+    4.9.5 (P3): only the regex-stripping path is cached. Plain (no-ESC) strings
+    return ``len(s)`` directly instead of occupying cache slots, so the bounded
+    cache is reserved for the ANSI strings that actually benefit from memoising
+    the regex sub (static glyphs, frames). Keeps the cache small and the
+    hit-rate high.
+    """
     if "\x1b" not in s:
         return len(s)
-    return len(_RESET_RE.sub("", s))
+    return _visible_len_ansi(s)
 
 
 def ansi_center(s: str, width: int) -> str:

{belote_cli-4.9.4 → belote_cli-4.9.5}/src/belote/belatro/items/partner_jokers/passive.py

@@ -29,7 +29,10 @@ class LaSymbiose(Joker):
     is_partner_joker = True
 
     def on_declaration(self, event: DeclarationScoredEvent, state: dict[str, Any]) -> JokerResult | None:
-        if event.seat == Seat.NORTH:
+        # Gate on points so Le Mime (declarations_zero) — which emits
+        # declarations worth 0 — doesn't grant the multiplier for a
+        # declaration that scored nothing. Mirrors LeMathematicien's guard.
+        if event.seat == Seat.NORTH and event.points > 0:
             return JokerResult(times_mult=1.2)
         return None
 

{belote_cli-4.9.4 → belote_cli-4.9.5}/src/belote/belatro/main.py

@@ -326,6 +326,22 @@ class BelAtroGame:
         for msg in self.unlock_tracker.drain_announcements():
             BelAtroAnnounce.banner(msg, self.reader, hold=1.5)
 
+    def _reconcile_bonus_money(self, bonus_money: int) -> None:
+        """Apply a round's signed joker money to the wallet.
+
+        ``final_state._bonus_money`` accumulates ``JokerResult.add_money`` over
+        the round (positive = credit, negative = debit such as LePreteur's -$5
+        skim). Positive amounts credit; negative amounts route through
+        ``spend_money`` (which no-ops if the wallet can't cover it) so the
+        Economy's non-negative guard on ``add_money`` is respected.
+        """
+        if self.run is None:
+            return
+        if bonus_money > 0:
+            self.run.economy.add_money(bonus_money)
+        elif bonus_money < 0:
+            self.run.economy.spend_money(-bonus_money)
+
     def _run_loop(self) -> None:
         """Main game loop: Blind -> Shop -> Next."""
         if self.run is None:
@@ -617,6 +633,12 @@ class BelAtroGame:
                     color="red",
                     hold=2.5,
                 )
+            else:
+                # The run continues past this chute. Reconcile signed joker
+                # money (e.g. LePreteur's -$5 skim, which was baked into the
+                # round's ×Mult) so the player isn't handed a free multiplier
+                # for the surviving round. spend_money no-ops if broke.
+                self._reconcile_bonus_money(final_state._bonus_money)
             if not lock_trust:
                 trust.blind_failed()
         else:
@@ -624,16 +646,7 @@ class BelAtroGame:
             payout = self.run.economy.process_round_end(total - self.run.target_score)
             if auto_coinche_active:
                 self.run.economy.add_money(payout * 2)  # L'Avocat: triple total payout
-            # JokerResult.add_money is signed: positive = credit, negative = debit.
-            # Pre-4.6.5 this branch was `> 0`, which silently dropped LePreteur's
-            # `-5` cost (and any other negative-add_money joker) while still
-            # applying the multiplier — free ×1.2 Mult on every $50+ round.
-            if final_state._bonus_money > 0:
-                self.run.economy.add_money(final_state._bonus_money)
-            elif final_state._bonus_money < 0:
-                # Route through spend_money so the Economy negative guard fires
-                # if accumulated debit somehow exceeds wallet (caller's bug).
-                self.run.economy.spend_money(-final_state._bonus_money)
+            self._reconcile_bonus_money(final_state._bonus_money)
             if final_state._joker_state.get("puriste_triggered"):
                 extra = max(0, (total - self.run.target_score) // 10)
                 self.run.economy.add_money(extra)  # Le Puriste: double base payout

{belote_cli-4.9.4 → belote_cli-4.9.5}/src/belote/belatro/partner/trust.py

@@ -73,15 +73,19 @@ class TrustTrack:
     def tier(self) -> int:
         """Five-tier bucketing for partner-joker effect scaling.
 
-        0 (degraded, value 0–2) — partner-joker effects halved
-        1 (base, value 3–4)     — baseline
-        2 (boost, value 5–6)    — +25%
-        3 (strong, value 7–8)   — +50%
-        4 (elite, value 9–10)   — +100%
+        Scaling is implemented as N *extra* applications of the joker's
+        JokerResult on top of the baseline one (see
+        ``ScoreAccumulator._fire_jokers``; ``tier_extras = (0, 0, 1, 1, 2)``):
+
+        0 (degraded, value 0–2) — baseline only (no bonus, no penalty)
+        1 (base,     value 3–4) — baseline only
+        2 (boost,    value 5–6) — +1 apply  (≈ ×2 effect)
+        3 (strong,   value 7–8) — +1 apply  (≈ ×2 effect)
+        4 (elite,    value 9–10) — +2 applies (≈ ×3 effect)
 
         Used by partner_jokers/* to scale their JokerResult payloads. The
         legacy `partner_jokers_double` flag (value≥7) still exists for backward
-        compatibility but tier_for is the new path.
+        compatibility but tier is the new path.
         """
         if self.value <= 2:
             return 0

{belote_cli-4.9.4 → belote_cli-4.9.5}/src/belote/belatro/ui/history.py

@@ -90,90 +90,109 @@ def _money_cell(delta: int) -> str:
     return f"{DIM}$0{RESET}"
 
 
+def _build_history_lines(entries: list[BelAtroHistoryEntry], term_w: int) -> list[str]:
+    """Build the full (pre-scroll) line list for the overlay.
+
+    Pure function of ``(entries, term_w)`` — the scroll position doesn't affect
+    it — so ``show_belatro_history`` memoises the result across keystrokes
+    instead of rebuilding ~3 lines per entry on every ↑/↓ (mirrors the classic
+    ``belote.ui.prompts._build_history_lines`` caching).
+    """
+    lines: list[str] = []
+    lines.append(f"{BOLD}{gold_fg()}BELATRO RUN HISTORY{RESET}")
+    lines.append("=" * 19)
+    lines.append("")
+
+    if not entries:
+        lines.append(f"{DIM}No blinds completed yet.{RESET}")
+    else:
+        # Wide layout: single-row record. ~84 visible chars at minimum.
+        wide = term_w >= 90
+        if wide:
+            w_no, w_ante, w_bl, w_tgt, w_boss, w_tkr, w_con, w_trk, w_score, w_st, w_money = (
+                3, 4, 5, 5, 14, 7, 4, 7, 7, 8, 6,
+            )
+            header_cells = [
+                _ljust_visible("#", w_no),
+                _ljust_visible("ANTE", w_ante),
+                _ljust_visible("BLIND", w_bl),
+                _ljust_visible("TGT", w_tgt),
+                _ljust_visible("BOSS", w_boss),
+                _ljust_visible("TAKER", w_tkr),
+                _ljust_visible("CON", w_con),
+                _ljust_visible("TRICKS", w_trk),
+                _ljust_visible("SCORE", w_score),
+                _ljust_visible("STATUS", w_st),
+                _ljust_visible("$Δ", w_money),
+            ]
+            header = " │ ".join(header_cells)
+            lines.append(f"{BOLD}{white_fg()}{header}{RESET}")
+            lines.append("─" * visible_len(header))
+
+            for i, e in enumerate(entries):
+                boss = e.boss_name or "─"
+                if visible_len(boss) > w_boss:
+                    boss = boss[: w_boss - 1] + "…"
+                row_cells = [
+                    _ljust_visible(f"{i + 1:02d}", w_no),
+                    _ljust_visible(str(e.ante), w_ante),
+                    _ljust_visible(e.blind_label, w_bl),
+                    _ljust_visible(str(e.target), w_tgt),
+                    _ljust_visible(boss, w_boss),
+                    _ljust_visible(e.taker_label, w_tkr),
+                    _ljust_visible(e.contract, w_con),
+                    _ljust_visible(f"{e.tricks_ns}/{e.tricks_ew}", w_trk),
+                    _ljust_visible(f"{BOLD}{e.score}{RESET}", w_score),
+                    _ljust_visible(_status_cell(e.status), w_st),
+                    _ljust_visible(_money_cell(e.money_delta), w_money),
+                ]
+                lines.append(" │ ".join(row_cells))
+        else:
+            # Compact three-line-per-row layout for narrow terminals.
+            lines.append(
+                f"{BOLD}{white_fg()}{'#':<3} {'A.B':<4} {'TGT':<5} "
+                f"{'SCORE':<7} STATUS{RESET}"
+            )
+            lines.append("─" * 40)
+            for i, e in enumerate(entries):
+                a_b = f"{e.ante}.{e.blind_label[0]}"
+                lines.append(
+                    f"{i + 1:02d}  {a_b:<4} {e.target:<5} "
+                    f"{BOLD}{e.score:<7}{RESET}{_status_cell(e.status)}"
+                )
+                boss = e.boss_name or "─"
+                lines.append(
+                    f"     boss: {boss}  taker: {e.taker_label}  con: {e.contract}  "
+                    f"tricks: {e.tricks_ns}/{e.tricks_ew}  {_money_cell(e.money_delta)}"
+                )
+                decl_n = _decl_str(e.decl_summary_ns, 14)
+                decl_e = _decl_str(e.decl_summary_ew, 14)
+                lines.append(f"     decl: {decl_n} / {decl_e}")
+                lines.append("")
+
+    lines.append("")
+    lines.append(f"{DIM}[↑↓] Scroll  [Any Key] Return{RESET}")
+    return lines
+
+
 def show_belatro_history(reader: KeyReader, entries: list[BelAtroHistoryEntry]) -> None:
     """Scrollable BelAtro round-by-round overlay; called via the [H] hook."""
     from belote.ui.fit_guard import require_minimum
 
     scroll = 0
+    cached_key: tuple[int, int] | None = None
+    lines: list[str] = []
 
     while True:
         require_minimum(reader)
         term_w, term_h = get_term_size()
 
-        lines: list[str] = []
-        lines.append(f"{BOLD}{gold_fg()}BELATRO RUN HISTORY{RESET}")
-        lines.append("=" * 19)
-        lines.append("")
-
-        if not entries:
-            lines.append(f"{DIM}No blinds completed yet.{RESET}")
-        else:
-            # Wide layout: single-row record. ~84 visible chars at minimum.
-            wide = term_w >= 90
-            if wide:
-                w_no, w_ante, w_bl, w_tgt, w_boss, w_tkr, w_con, w_trk, w_score, w_st, w_money = (
-                    3, 4, 5, 5, 14, 7, 4, 7, 7, 8, 6,
-                )
-                header_cells = [
-                    _ljust_visible("#", w_no),
-                    _ljust_visible("ANTE", w_ante),
-                    _ljust_visible("BLIND", w_bl),
-                    _ljust_visible("TGT", w_tgt),
-                    _ljust_visible("BOSS", w_boss),
-                    _ljust_visible("TAKER", w_tkr),
-                    _ljust_visible("CON", w_con),
-                    _ljust_visible("TRICKS", w_trk),
-                    _ljust_visible("SCORE", w_score),
-                    _ljust_visible("STATUS", w_st),
-                    _ljust_visible("$Δ", w_money),
-                ]
-                header = " │ ".join(header_cells)
-                lines.append(f"{BOLD}{white_fg()}{header}{RESET}")
-                lines.append("─" * visible_len(header))
-
-                for i, e in enumerate(entries):
-                    boss = e.boss_name or "─"
-                    if visible_len(boss) > w_boss:
-                        boss = boss[: w_boss - 1] + "…"
-                    row_cells = [
-                        _ljust_visible(f"{i + 1:02d}", w_no),
-                        _ljust_visible(str(e.ante), w_ante),
-                        _ljust_visible(e.blind_label, w_bl),
-                        _ljust_visible(str(e.target), w_tgt),
-                        _ljust_visible(boss, w_boss),
-                        _ljust_visible(e.taker_label, w_tkr),
-                        _ljust_visible(e.contract, w_con),
-                        _ljust_visible(f"{e.tricks_ns}/{e.tricks_ew}", w_trk),
-                        _ljust_visible(f"{BOLD}{e.score}{RESET}", w_score),
-                        _ljust_visible(_status_cell(e.status), w_st),
-                        _ljust_visible(_money_cell(e.money_delta), w_money),
-                    ]
-                    lines.append(" │ ".join(row_cells))
-            else:
-                # Compact three-line-per-row layout for narrow terminals.
-                lines.append(
-                    f"{BOLD}{white_fg()}{'#':<3} {'A.B':<4} {'TGT':<5} "
-                    f"{'SCORE':<7} STATUS{RESET}"
-                )
-                lines.append("─" * 40)
-                for i, e in enumerate(entries):
-                    a_b = f"{e.ante}.{e.blind_label[0]}"
-                    lines.append(
-                        f"{i + 1:02d}  {a_b:<4} {e.target:<5} "
-                        f"{BOLD}{e.score:<7}{RESET}{_status_cell(e.status)}"
-                    )
-                    boss = e.boss_name or "─"
-                    lines.append(
-                        f"     boss: {boss}  taker: {e.taker_label}  con: {e.contract}  "
-                        f"tricks: {e.tricks_ns}/{e.tricks_ew}  {_money_cell(e.money_delta)}"
-                    )
-                    decl_n = _decl_str(e.decl_summary_ns, 14)
-                    decl_e = _decl_str(e.decl_summary_ew, 14)
-                    lines.append(f"     decl: {decl_n} / {decl_e}")
-                    lines.append("")
-
-        lines.append("")
-        lines.append(f"{DIM}[↑↓] Scroll  [Any Key] Return{RESET}")
+        # The line list only depends on (term_w, entry count); rebuild it only
+        # when one of those changes, not on every scroll keystroke.
+        key = (term_w, len(entries))
+        if key != cached_key:
+            lines = _build_history_lines(entries, term_w)
+            cached_key = key
 
         view_h = max(1, term_h - 4)
         max_scroll = max(0, len(lines) - view_h)

{belote_cli-4.9.4 → belote_cli-4.9.5}/src/belote/belatro/ui/hud.py

@@ -287,6 +287,10 @@ class BelAtroHUD:
 
         sys.stdout.write("".join(parts))
         sys.stdout.flush()
+        # This write bypasses display(); invalidate the render-diff baseline so
+        # the next display() repaints rows the HUD overwrote (4.0.0 convention).
+        from belote.ui.render import invalidate_diff
+        invalidate_diff()
 
     def _render_compact(
         self,
@@ -362,6 +366,9 @@ class BelAtroHUD:
 
         sys.stdout.write("".join(parts))
         sys.stdout.flush()
+        # Bypasses display(); invalidate the render-diff baseline (4.0.0 conv).
+        from belote.ui.render import invalidate_diff
+        invalidate_diff()
 
 
 # ── 3.4.0: joker pip strip + synergy tooltip ────────────────────────────────
@@ -450,6 +457,8 @@ def render_joker_pip_strip(run: BelAtroRun, term_w: int, row: int = 1) -> None:
         return
     sys.stdout.write(strip)
     sys.stdout.flush()
+    from belote.ui.render import invalidate_diff
+    invalidate_diff()
 
 
 def build_synergy_tooltip(jokers: Sequence[object], term_w: int, row: int = 5) -> str:
@@ -492,3 +501,5 @@ def render_synergy_tooltip(jokers: Sequence[object], term_w: int, row: int = 5)
         return
     sys.stdout.write(out)
     sys.stdout.flush()
+    from belote.ui.render import invalidate_diff
+    invalidate_diff()

{belote_cli-4.9.4 → belote_cli-4.9.5}/src/belote/belatro/ui/trust_bar.py

@@ -74,6 +74,10 @@ class TrustBar:
             + white_fg() + "] " + RESET
             + status
         )
+        # Bypasses display(); invalidate the render-diff baseline so the next
+        # display() repaints row 4 (4.0.0 convention).
+        from belote.ui.render import invalidate_diff
+        invalidate_diff()
 
     # 4.8.0 / B4: tick-up / tick-down animation between two trust values.
     # ──────────────────────────────────────────────────────────────────

{belote_cli-4.9.4 → belote_cli-4.9.5}/src/belote/config.py

@@ -10,8 +10,13 @@ class Config:
     # Game rules
     TARGET_SCORE: int = 1000
     LAST_TRICK_BONUS: int = 10
+    # Official French Belote: holding the King AND Queen of trump (announced
+    # "Belote" on the first played, "Rebelote" on the second) is worth 20
+    # points TOTAL — not 20 each. BELOTE_POINTS is the provisional credit once
+    # the first card is announced; REBELOTE_POINTS is the final value once the
+    # pair is complete. Both are 20 so the completed pair scores the official 20.
     BELOTE_POINTS: int = 20
-    REBELOTE_POINTS: int = 40
+    REBELOTE_POINTS: int = 20
     CAPOT_BASE: int = 252
     # Capot bases for special contracts. Standard FFB practice scales the
     # Capot reward to the contract's total card points: Capot pays the deck

{belote_cli-4.9.4 → belote_cli-4.9.5}/src/belote/game.py

@@ -606,35 +606,41 @@ def _calculate_legal_cards_impl(
             res_cards = hand
         return tuple(_CARD_TO_ID[c] for c in res_cards)
 
+    # A card is trump if it's the trump suit, or — under La Déluge
+    # (seven_eight_trump) — any 7 or 8 regardless of suit. Following a trump
+    # lead means following with ANY trump, not just lead-suit cards: an off-suit
+    # 7/8 is a trump too. Using `c.suit == lead_suit` here would drop those and
+    # wrongly report the player as void (empty legal set → crash).
+    def is_trump_card(c: Card) -> bool:
+        return c.suit == trump or (
+            seven_eight_trump and c.rank in (Rank.SEVEN, Rank.EIGHT)
+        )
+
     is_trump_lead = (lead_suit == trump) or (
         seven_eight_trump and lead_card.rank in (Rank.SEVEN, Rank.EIGHT)
     )
 
     if is_trump_lead:
-        # Trump led: must follow if possible, must overtrump if possible
-        if my_suit_cards:
+        # Trump led: must follow with a trump if possible, must overtrump if possible
+        my_trumps = [c for c in hand if is_trump_card(c)]
+        if my_trumps:
             highest_in_trick = max(
                 (trick_rank(tc.card, trump, seven_eight_trump) for tc in played_cards), default=-1
             )
             must_overtrump = any(
-                trick_rank(c, trump, seven_eight_trump) > highest_in_trick for c in my_suit_cards
+                trick_rank(c, trump, seven_eight_trump) > highest_in_trick for c in my_trumps
             )
             if must_overtrump:
                 res_cards = tuple(
                     c
-                    for c in my_suit_cards
+                    for c in my_trumps
                     if trick_rank(c, trump, seven_eight_trump) > highest_in_trick
                 )
             else:
-                res_cards = tuple(my_suit_cards)
+                res_cards = tuple(my_trumps)
         else:
-            # Void in trump (led suit) - can only play non-trump
-            res_cards = tuple(
-                c
-                for c in hand
-                if c.suit != trump
-                and not (seven_eight_trump and c.rank in (Rank.SEVEN, Rank.EIGHT))
-            )
+            # No trumps at all - can play anything (every card is non-trump)
+            res_cards = hand
     else:
         # Non-trump led
         if my_suit_cards:
@@ -647,11 +653,7 @@ def _calculate_legal_cards_impl(
                 res_cards = hand
             else:
                 # Must trump if possible
-                my_trumps = [
-                    c
-                    for c in hand
-                    if c.suit == trump or (seven_eight_trump and c.rank in (Rank.SEVEN, Rank.EIGHT))
-                ]
+                my_trumps = [c for c in hand if is_trump_card(c)]
                 if my_trumps:
                     # Must trump; also must overtrump if possible
                     highest_trump_in_trick = max(