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

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

@@ -5,6 +5,93 @@ 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.3] - 2026-05-21
+
+Patch release: targeted bug-hunt + performance + code-logic audit. Three
+parallel exploration passes (classic engine, BelAtro layer, UI/render)
+surfaced ~30 candidate findings; verifying each against the live code
+rejected the false positives (deck.py "deluge scores 0", LePasseur "missing
+re_emit guard", show_rules "missing invalidate on scroll", show_history
+"missing term_h in cache key", legal_cards "missing trick_rank hoist") and
+shipped only the verified-true delta. All baselines green: `ruff` 0
+violations, `mypy --strict` 0 errors, `pytest` 1007/1007.
+
+### Fixed
+
+- **(Bug) `announce()` did not invalidate the render-diff baseline.** The
+  function paints a transient banner with absolute cursor positioning,
+  bypassing `display()`. Without a post-paint `invalidate_diff()` the next
+  `display()` diffed against `_last_emitted_lines` (which has no record of
+  the banner) and could leave the banner visible as a ghost on the bottom
+  row. Same architectural rule as `show_help` / `show_history` /
+  `show_rules` / `show_card_detail` / `show_round_summary` /
+  `animate_score_update`. `announce()` was the last unfixed site of the
+  4.0.0 / 4.6.4 finally-pattern sweep. Pinned by
+  `test_announce_invalidates_diff_baseline` in `tests/test_render_diff.py`.
+- **(Bug) L'Infiltré × La Déluge interaction.** The `ghost_lead` deck rule
+  paid `+2 Mult / +$1` when NS won a trick by playing trump on a "non-trump
+  lead". The is-trump-lead check at `belatro/core/scoring.py:414-417`
+  considered only `lead_suit == event.trump` and the TOUT_ATOUT case —
+  it did not honour `seven_eight_trump` (La Déluge), so a 7-led or 8-led
+  trick was incorrectly treated as a non-trump lead and the bonus could
+  fire even though the lead was effectively trump. Pinned by
+  `test_ghost_lead_silent_when_lead_is_seven_under_deluge` in
+  `tests/belatro/test_decks_4_5.py`.
+- **(Defensive) `LeDemon.on_purchase` is now idempotent.** Re-running the
+  hook on an already-owned joker (a future save/load round-trip or replay-
+  resume tool) would have compounded the trust subtraction. New
+  `_applied_purchase_ids: set[str]` field on `BelAtroRun` (mirrors
+  `_applied_voucher_ids` from 3.9.3) short-circuits the second call. Pinned
+  by `test_le_demon_on_purchase_is_idempotent` in
+  `tests/belatro/test_joker_contracts.py`.
+
+### Changed
+
+- **AI comment about La Déluge corrected** (`src/belote/ai.py:293-296`).
+  The pre-4.7.3 comment claimed "promotes 7s/8s of trump above the Jack" —
+  but `deck.py::trick_rank` puts the 7 at rank 8 and the 8 at rank 9
+  (the two LOWEST trumps, scoring 0). The boss description in
+  `boss.py:95` ("become trump") matches the code, not the comment. The
+  comment now states the actual behaviour so future maintainers don't
+  chase a phantom bug.
+- **`render_joker_pip_strip` / `render_synergy_tooltip` split into
+  builders + writers** (`belatro/ui/hud.py`). Pre-4.7.3 each helper did
+  its own `sys.stdout.write + flush` outside `BelAtroHUD._render`'s
+  batched parts list, costing 2–3 syscalls per HUD refresh instead of
+  one. New `build_joker_pip_strip` / `build_synergy_tooltip` return
+  strings; the legacy `render_*` wrappers (used by direct callers and
+  tests) still exist for backward compatibility. `BelAtroHUD.render`
+  and `_render_compact` now embed both builders into a single batched
+  write. Pinned by `test_belatro_hud_render_writes_once` in
+  `tests/belatro/test_hud_toggle.py`.
+
+### Performance
+
+- **`_get_card_face` reads `_cached_theme_name` instead of
+  `theme_manager.current_name`** (`belote/ui/render.py:314`). The module
+  already caches the theme name (line 84) and refreshes it via the theme
+  callback (line 95); `_get_card_face` is called ~52 times per game
+  frame, so eliminating the per-call property lookup shaves a few
+  microseconds off the render budget. The cache is kept in sync via the
+  existing theme-change callback. `clear_card_cache` ensures the card
+  face cache is reset on every theme change, so reading the cached name
+  is safe.
+
+### Internal
+
+- New `BelAtroRun._applied_purchase_ids: set[str]` field for joker
+  on_purchase idempotency (analogous to `_applied_voucher_ids`). Empty
+  by default; populated lazily by corrupted jokers with non-idempotent
+  on_purchase actions.
+- `build_joker_pip_strip(...) -> str` / `build_synergy_tooltip(...) -> str`
+  public builder API in `belatro/ui/hud.py`; `render_joker_pip_strip` /
+  `render_synergy_tooltip` retained as thin wrappers around the builders.
+
+### Test count baseline
+
+- 1007 (4.7.2 had 1003; +4 in 4.7.3 across `test_render_diff.py`,
+  `test_decks_4_5.py`, `test_joker_contracts.py`, `test_hud_toggle.py`).
+
 ## [4.7.2] - 2026-05-20
 
 Patch release: external-model audit verification pass. A prior audit (pasted

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: belote-cli
-Version: 4.7.2
+Version: 4.7.3
 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 (1003 tests)
+├── tests/             # Comprehensive test suite (1007 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 **1003 tests** passing with 100% coverage on game-logic modules (4.7.2).
+Currently **1007 tests** passing with 100% coverage on game-logic modules (4.7.3).
 
 ## Technical Integrity
 
 The codebase is strictly validated with the following tools:
 - **mypy**: 0 errors (strict type safety)
 - **ruff**: 0 violations (linting & formatting)
-- **pytest**: 1003/1003 passed
+- **pytest**: 1007/1007 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.2 → belote_cli-4.7.3}/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 (1003 tests)
+├── tests/             # Comprehensive test suite (1007 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 **1003 tests** passing with 100% coverage on game-logic modules (4.7.2).
+Currently **1007 tests** passing with 100% coverage on game-logic modules (4.7.3).
 
 ## Technical Integrity
 
 The codebase is strictly validated with the following tools:
 - **mypy**: 0 errors (strict type safety)
 - **ruff**: 0 violations (linting & formatting)
-- **pytest**: 1003/1003 passed
+- **pytest**: 1007/1007 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.2 → belote_cli-4.7.3}/pyproject.toml

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

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

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

{belote_cli-4.7.2 → belote_cli-4.7.3}/src/belote/ai.py

@@ -290,9 +290,11 @@ class AIPlayer:
         """Decide which card to play."""
         hand = state.hand_of(self.seat)
         legal = legal_cards(state, self.seat)
-        # La Déluge boss promotes 7s/8s of trump above the Jack — every ranking
-        # / point read in this method must respect that flag or the AI will
-        # pick the wrong cards.
+        # La Déluge boss makes 7s and 8s of any suit rank as trump (the two
+        # LOWEST trumps — 7 at rank 8, 8 at rank 9, both scoring 0 points;
+        # see deck.py::trick_rank and ::card_points). Every ranking / point
+        # read in this method must thread `_se` through or the AI under-
+        # values trump cards that should beat them.
         self._se = state.boss_modifiers.seven_eight_trump
 
         # Boss: L'Agent Double (Partner sabotages on 3 random tricks)

{belote_cli-4.7.2 → belote_cli-4.7.3}/src/belote/belatro/core/run_state.py

@@ -104,6 +104,16 @@ class BelAtroRun:
     # future save/load round-trip — gets the same protection automatically.
     _applied_voucher_ids: set[str] = field(default_factory=set)
 
+    # ── Idempotency guard for Joker.on_purchase() ──────────
+    # Corrupted jokers with non-idempotent on_purchase actions (LeDemon's
+    # trust subtraction) record their id here on first apply. Re-application
+    # paths (a future save/load round-trip, replay tooling) consult this set
+    # and short-circuit so a once-paid cost never compounds. Joker on_purchase
+    # actions that are already idempotent (boolean flags like
+    # LeTraitre.partner_throws_trick, LAgentDouble.agent_double_joker) don't
+    # need to consult this set, but adding their id is harmless. 4.7.3.
+    _applied_purchase_ids: set[str] = field(default_factory=set)
+
     # ── Recent-boss tracker (3.9.3 Phase 5) ────────────────
     # Used by the BelAtro main loop to suppress immediate boss repeats in
     # endless mode. The deque holds at most 2 recent boss ids; the selector

{belote_cli-4.7.2 → belote_cli-4.7.3}/src/belote/belatro/core/scoring.py

@@ -407,13 +407,23 @@ class ScoreAccumulator:
                 # of lead (legal_cards forbids trumping while holding lead).
                 # +2 Mult, +$1.
                 if joker_state.get("ghost_lead") and event.trump is not None:
-                    lead_suit = event.cards[0].suit if event.cards else None
+                    lead_card = event.cards[0] if event.cards else None
+                    lead_suit = lead_card.suit if lead_card else None
                     # Under TOUT_ATOUT every card is trump, so no play can be
                     # "void of the led suit" — is_trump_lead resolves to True
                     # and the bonus is correctly gated off.
+                    # Under La Déluge (seven_eight_trump), a 7 or 8 of any
+                    # suit also functions as trump — a 7-led trick is a
+                    # trump-led trick even when lead_suit != event.trump.
+                    se_lead = (
+                        state.boss_modifiers.seven_eight_trump
+                        and lead_card is not None
+                        and lead_card.rank in (Rank.SEVEN, Rank.EIGHT)
+                    )
                     is_trump_lead = (
                         lead_suit == event.trump
                         or event.trump == Suit.TOUT_ATOUT
+                        or se_lead
                     )
                     if lead_suit is not None and not is_trump_lead:
                         seat = event.leader_seat

{belote_cli-4.7.2 → belote_cli-4.7.3}/src/belote/belatro/items/jokers/corrupted.py

@@ -40,7 +40,13 @@ class LeDemon(Joker):
     is_corrupted = True
 
     def on_purchase(self, run: BelAtroRun) -> None:
-        # Degrade trust by 3, making partner play worse
+        # Degrade trust by 3, making partner play worse. 4.7.3: idempotency
+        # guard — without it, a save/load round-trip or replay-resume tool
+        # that re-runs on_purchase on already-owned jokers would compound
+        # the cost. Voucher.apply() solved the same problem in 3.9.3.
+        if self.id in run._applied_purchase_ids:
+            return
+        run._applied_purchase_ids.add(self.id)
         run.partner.trust.value = max(0, run.partner.trust.value - 3)
 
     def on_trick_won(self, event: TrickWonEvent, state: dict[str, Any]) -> JokerResult | None:

{belote_cli-4.7.2 → belote_cli-4.7.3}/src/belote/belatro/ui/hud.py

@@ -160,15 +160,20 @@ class BelAtroHUD:
         # 3.4.0: joker pip strip on row 1 (above the existing HUD lines), shown
         # in every layout including compact. Cheap — empty inventory still
         # paints the dotted-slot capacity so the player learns the slot count.
+        #
+        # 4.7.3: the strip + tooltip are BUILT into strings here and embedded
+        # in the same write as the rest of the HUD. Pre-4.7.3 each helper
+        # did its own write+flush, so the HUD render syscalled 2–3 times
+        # instead of once. Compact path mirrors this (see `_render_compact`).
+        pip_strip = ""
+        synergy_tip = ""
         if not state.boss_modifiers.hide_hud:
-            render_joker_pip_strip(run, term_w, row=1)
-            # Synergy tooltip below the score line; only fires when at least
-            # one pair is active. Compact layouts get one line; verbose two.
+            pip_strip = build_joker_pip_strip(run, term_w, row=1)
             tooltip_row = 4 if layout.hud_style == "compact" else 5
-            render_synergy_tooltip(list(run.jokers), term_w, row=tooltip_row)
+            synergy_tip = build_synergy_tooltip(list(run.jokers), term_w, row=tooltip_row)
 
         if layout.hud_style == "compact":
-            self._render_compact(acc, state, term_w)
+            self._render_compact(acc, state, term_w, pip_strip, synergy_tip)
             return
 
         # Standard / verbose path (current behaviour, with a small mood glyph
@@ -176,7 +181,12 @@ class BelAtroHUD:
         # write+flush so the BelAtro HUD lays down all rows in one syscall.
         target_str = str(run.target_score)
         mood = _MOOD_GLYPH.get(run.partner_mood, "○")
-        parts: list[str] = [
+        # 4.7.3: prepend the row-1 pip strip + the row-{4|5} synergy tooltip
+        # so the whole HUD ships in one write+flush below.
+        parts: list[str] = []
+        if pip_strip:
+            parts.append(pip_strip)
+        parts.append(
             move(2, 2)
             + white_fg()
             + "Ante: "
@@ -204,7 +214,7 @@ class BelAtroHUD:
             + f"Partner: {mood}"
             + RESET
             + "\n"
-        ]
+        )
 
         # Row 3: Score (hidden by Le Brouillard boss). Also suppressed under
         # La Compétition (`separate_scoring`) because the live running total
@@ -252,13 +262,27 @@ class BelAtroHUD:
         # today but defensive) wouldn't paint either.
         _emit_tally_readout(parts, state, term_w, term_h)
 
+        # 4.7.3: tooltip ships in the same batched write as everything else.
+        if synergy_tip:
+            parts.append(synergy_tip)
+
         sys.stdout.write("".join(parts))
         sys.stdout.flush()
 
-    def _render_compact(self, acc: ScoreAccumulator, state: GameState, term_w: int) -> None:
+    def _render_compact(
+        self,
+        acc: ScoreAccumulator,
+        state: GameState,
+        term_w: int,
+        pip_strip: str = "",
+        synergy_tip: str = "",
+    ) -> None:
         """Compact HUD: single-line summary, joker count instead of names.
 
         Press J for the full joker list (handled by the gameplay loop, not here).
+
+        4.7.3: `pip_strip` / `synergy_tip` are pre-built by the caller so the
+        compact HUD also ships in a single write+flush.
         """
         run = self.run
         mood = _MOOD_GLYPH.get(run.partner_mood, "○")
@@ -277,11 +301,16 @@ class BelAtroHUD:
 
         # Compose both halves on row 2. 3.9.3: batched into a single
         # write/flush so the compact HUD lays down all rows atomically.
+        # 4.7.3: prepend the pip strip so the row-1/row-2 strip + summary
+        # ship in the same write.
         right_col = max(2, term_w - visible_len(joker_label) - 1)
-        parts: list[str] = [
+        parts: list[str] = []
+        if pip_strip:
+            parts.append(pip_strip)
+        parts.extend([
             move(2, 2) + left + "\n",
             move(2, right_col) + joker_label + "\n",
-        ]
+        ])
 
         # Row 3: chips × mult on the right (hidden by Le Brouillard, also
         # suppressed under La Compétition since the running total diverges
@@ -308,6 +337,10 @@ class BelAtroHUD:
         _, term_h = _gt()
         _emit_tally_readout(parts, state, term_w, term_h)
 
+        # 4.7.3: synergy tooltip ships in the same batched write.
+        if synergy_tip:
+            parts.append(synergy_tip)
+
         sys.stdout.write("".join(parts))
         sys.stdout.flush()
 
@@ -339,21 +372,22 @@ def _edition_color(ed_value: str) -> str:
     return str(white_fg())
 
 
-def render_joker_pip_strip(run: BelAtroRun, term_w: int, row: int = 1) -> None:
-    """Render a compact one-row strip of joker slots at `row` (default top).
+def build_joker_pip_strip(run: BelAtroRun, term_w: int, row: int = 1) -> str:
+    """Build the joker pip strip as a string (caller decides when to write).
 
     Layout: `J: [Co][To*][..][..][..]` — 4 chars per slot, leading "J: " label,
     `*` marker on slots involved in an active synergy pair. Empty slots are
     rendered with `··` so the player sees their capacity at a glance.
 
-    No-ops when `term_w < 24` (not enough room for a 5-slot strip).
+    Returns "" when the strip should be suppressed (HUD toggled off, or
+    `term_w < 24` — not enough room for a 5-slot strip).
     """
     from .announce import is_top_hud_visible
 
     if not is_top_hud_visible():
-        return
+        return ""
     if term_w < 24:
-        return
+        return ""
     slots = max(1, run.joker_slots)
     jokers = list(run.jokers)
     # Detect which joker ids are in an active synergy so we can mark their pips
@@ -379,28 +413,40 @@ def render_joker_pip_strip(run: BelAtroRun, term_w: int, row: int = 1) -> None:
             )
         else:
             parts.append(f"{DIM}[··]{RESET}")
-    strip = "".join(parts)
     # Center is overkill; anchor at col 2 so it doesn't fight the score line
-    # on the right of row 2. 3.9.3: single write+flush.
-    sys.stdout.write(move(row, 2) + strip + "\n")
+    # on the right of row 2.
+    strip: str = move(row, 2) + "".join(parts) + "\n"
+    return strip
+
+
+def render_joker_pip_strip(run: BelAtroRun, term_w: int, row: int = 1) -> None:
+    """Standalone writer for callers/tests that paint the pip strip directly.
+
+    BelAtroHUD's main render path embeds `build_joker_pip_strip` output in
+    its single batched write (4.7.3) — call this only when there's no
+    surrounding `parts` list to compose into.
+    """
+    strip = build_joker_pip_strip(run, term_w, row=row)
+    if not strip:
+        return
+    sys.stdout.write(strip)
     sys.stdout.flush()
 
 
-def render_synergy_tooltip(jokers: Sequence[object], term_w: int, row: int = 5) -> None:
-    """Render one-line synergy descriptions at `row` if any pair is active.
+def build_synergy_tooltip(jokers: Sequence[object], term_w: int, row: int = 5) -> str:
+    """Build synergy tooltip lines as a single string (caller decides when to write).
 
-    No-ops when there are no active synergies. Truncates each line to the
-    available width so we never wrap.
+    Returns "" when there are no active synergies, the HUD is hidden, or the
+    tooltip should otherwise be suppressed.
     """
     from .announce import is_top_hud_visible
 
     if not is_top_hud_visible():
-        return
+        return ""
     pairs = detect_synergies_full(list(jokers))
     if not pairs:
-        return
+        return ""
     # Show up to two synergies; further ones are summarised as "+N more".
-    # 3.9.3: batched single write/flush.
     max_w = max(20, term_w - 4)
     out: list[str] = []
     for i, (_a, _b, desc) in enumerate(pairs[:2]):
@@ -413,5 +459,17 @@ def render_synergy_tooltip(jokers: Sequence[object], term_w: int, row: int = 5)
     if len(pairs) > 2:
         extra = f"{DIM}+{len(pairs) - 2} more synergies{RESET}"
         out.append(move(row + 2, 2) + extra + "\n")
-    sys.stdout.write("".join(out))
+    return "".join(out)
+
+
+def render_synergy_tooltip(jokers: Sequence[object], term_w: int, row: int = 5) -> None:
+    """Standalone writer for callers/tests that paint the tooltip directly.
+
+    BelAtroHUD's main render path embeds `build_synergy_tooltip` output in
+    its single batched write (4.7.3); use this only for direct callers.
+    """
+    out = build_synergy_tooltip(jokers, term_w, row=row)
+    if not out:
+        return
+    sys.stdout.write(out)
     sys.stdout.flush()

{belote_cli-4.7.2 → belote_cli-4.7.3}/src/belote/ui/announce.py

@@ -48,11 +48,18 @@ def announce(
     )
     sys.stdout.write(move(max(1, term_h - 1), 1) + clear_line() + banner)
     sys.stdout.flush()
-    if reader and duration > 0:
-        return interruptible_sleep(duration, reader)
-    if duration > 0:
-        time.sleep(duration)
-    return None
+    # The banner is painted with absolute positioning, bypassing display()'s
+    # diff cache. The next display() would diff against the pre-banner cached
+    # frame and could skip repainting the banner row, leaving the message as a
+    # ghost. Mirrors the finally pattern in animate_score_update (4.6.4).
+    try:
+        if reader and duration > 0:
+            return interruptible_sleep(duration, reader)
+        if duration > 0:
+            time.sleep(duration)
+        return None
+    finally:
+        invalidate_diff()
 
 
 def show_round_summary(

{belote_cli-4.7.2 → belote_cli-4.7.3}/src/belote/ui/render.py

@@ -306,12 +306,18 @@ def _get_card_face(
     legal: bool = True,
     layout: LayoutPreset = STANDARD,
 ) -> list[str]:
-    """Helper to call cached _card_face with current global state."""
+    """Helper to call cached _card_face with current global state.
+
+    Uses the module-local `_cached_theme_name` (kept in sync by the theme
+    callback) instead of the live `theme_manager.current_name` property to
+    skip a property lookup + attribute dereference per card render
+    (~52 calls per game frame).
+    """
     return _card_face_internal(
         card,
         selected,
         legal,
-        theme_manager.current_name,
+        _cached_theme_name,
         TERMINAL.has_utf8,
         layout.card_w,
         layout.card_h,

{belote_cli-4.7.2 → belote_cli-4.7.3}/tests/belatro/test_decks_4_5.py

@@ -168,6 +168,40 @@ def test_ghost_lead_silent_when_winner_didnt_trump_void() -> None:
     assert out._bonus_money == 0
 
 
+def test_ghost_lead_silent_when_lead_is_seven_under_deluge() -> None:
+    """4.7.3 regression: under La Déluge (seven_eight_trump), a 7 or 8
+    of any suit functions as trump. A 7-led trick is therefore a
+    trump-led trick — L'Infiltré must NOT pay even though
+    `lead_suit != event.trump`. Pre-4.7.3 the is_trump_lead check
+    didn't honour the boss flag and the bonus fired spuriously.
+    """
+    from belote.game import BossModifiers
+
+    state = GameState(
+        hands=((), (), (), ()),
+        _joker_state={"ghost_lead": True},
+        boss_modifiers=BossModifiers(seven_eight_trump=True),
+    )
+    acc = ScoreAccumulator()
+    event = TrickWonEvent(
+        winner=Seat.NORTH,
+        cards=(
+            Card(Suit.HEARTS, Rank.SEVEN),    # SOUTH — leads a 7 = trump under Déluge
+            Card(Suit.HEARTS, Rank.TEN),      # EAST
+            Card(Suit.SPADES, Rank.JACK),     # NORTH — plays trump
+            Card(Suit.HEARTS, Rank.KING),     # WEST
+        ),
+        trick_number=3,
+        is_last=False,
+        card_points=30,
+        trump=Suit.SPADES,
+        leader_seat=Seat.SOUTH,
+    )
+    out = acc.update_state(state, event)
+    assert out._mult == 1.0, "ghost_lead must not fire when lead is a Déluge-trump 7/8"
+    assert out._bonus_money == 0
+
+
 # ── L'Architecte annonce-cash-x2 ────────────────────────────────────────────
 
 

{belote_cli-4.7.2 → belote_cli-4.7.3}/tests/belatro/test_hud_toggle.py

@@ -84,3 +84,52 @@ def test_trust_bar_paints_when_visible() -> None:
     bar = TrustBar(TrustTrack(value=5))
     out = _capture(bar.render)
     assert "Trust:" in out
+
+
+def test_belatro_hud_render_writes_once(monkeypatch: pytest.MonkeyPatch) -> None:
+    """4.7.3: BelAtroHUD.render must batch the pip strip, summary rows,
+    score line, joker list, tally readout, and synergy tooltip into a
+    SINGLE sys.stdout.write call. Pre-4.7.3 the pip strip and synergy
+    tooltip each did their own write+flush, costing 2–3 syscalls per HUD
+    refresh.
+
+    Same single-write convention as ShopScreen._render (pinned in
+    test_render_diff.py::test_shop_render_writes_once_per_frame).
+    """
+    from belote.belatro.core.scoring import ScoreAccumulator
+    from belote.belatro.items.registry import register_all_items
+    from belote.belatro.ui.hud import BelAtroHUD
+    from belote.game import new_game
+
+    register_all_items()
+    run = BelAtroRun(seed=1)
+    h = BelAtroHUD(run)
+    acc = ScoreAccumulator()
+    state = new_game()
+    acc.trigger_round_start(state)
+
+    class _CountingBuf(io.StringIO):
+        write_count = 0
+
+        def write(self, s: str) -> int:  # type: ignore[override]
+            self.write_count += 1
+            return super().write(s)
+
+    buf = _CountingBuf()
+    saved = sys.stdout
+    sys.stdout = buf
+    try:
+        # `get_term_size` is imported locally inside BelAtroHUD.render from
+        # `belote.ui.render`; patch the source module so both that import and
+        # the `_render_compact` fallback see the deterministic size.
+        render_mod = sys.modules["belote.ui.render"]
+        monkeypatch.setattr(render_mod, "get_term_size", lambda: (120, 40))
+        h.render(acc, state)
+    finally:
+        sys.stdout = saved
+
+    assert buf.write_count == 1, (
+        f"BelAtroHUD.render must batch into one write; got {buf.write_count}. "
+        f"Pre-4.7.3 this was 2–3 due to the pip-strip / tooltip helpers "
+        f"writing independently."
+    )

{belote_cli-4.7.2 → belote_cli-4.7.3}/tests/belatro/test_joker_contracts.py

@@ -392,6 +392,29 @@ def test_lagent_double_seat_keyed_to_south() -> None:
     assert LAgentDouble().on_trick_won(_trick(winner=Seat.NORTH), {}) is None
 
 
+def test_le_demon_on_purchase_is_idempotent() -> None:
+    """4.7.3: LeDemon.on_purchase degrades trust by 3; re-applying it (e.g.,
+    via a save/load round-trip or replay-resume tool) must NOT compound the
+    cost. The guard lives on `run._applied_purchase_ids`, mirroring
+    `_applied_voucher_ids` from 3.9.3.
+    """
+    from belote.belatro.core.run_state import BelAtroRun
+
+    run = BelAtroRun(seed=1)
+    starting_trust = run.partner.trust.value
+    j = LeDemon()
+    j.on_purchase(run)
+    after_first = run.partner.trust.value
+    assert after_first == max(0, starting_trust - 3)
+    # Second call must be a no-op.
+    j.on_purchase(run)
+    assert run.partner.trust.value == after_first
+    # A fresh LeDemon instance with the same id should also short-circuit on
+    # the same run (save/load → distinct Python object, same logical joker).
+    LeDemon().on_purchase(run)
+    assert run.partner.trust.value == after_first
+
+
 # ── trick_timing.py ────────────────────────────────────────────────────────