belote-cli 3.3.4__tar.gz → 3.4.0__tar.gz

{belote_cli-3.3.4 → belote_cli-3.4.0}/CHANGELOG.md

@@ -5,6 +5,46 @@ 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).
 
+## [3.4.0] - 2026-05-10
+
+Audit + endless-mode reliability + HUD polish release. A fresh three-agent codebase pass (classic engine / BelAtro layer / UI + I/O) produced ~80 candidate findings. Direct verification against the source rejected ~95% as false positives or by-design patterns. The five surviving issues plus two **new** bugs uncovered during follow-up verification of endless mode and classic game flow are fixed here. Two HUD features land alongside (joker pip strip with edition glow, synergy tooltip, polished trust bar). 551 tests passing (up from 549), ruff and mypy strict still clean. Plan file at `/home/mrrobot/.claude/plans/bug-hunt-code-performance-fizzy-summit.md`.
+
+### Fixed
+
+- **`src/belote/belatro/engine/round_driver.py` (A1, HIGH)** — `BidMadeEvent` was emitted twice for the winning bid on every coinche path (player coinche → AI surcoinche, AI partner coinche, boss `auto_coinche` for EW *and* NS takers, and the `start_coinched` deck mod). Both emits ran `on_bid` joker handlers — once with `coinche_level=0`, then again with the resolved level — so any `on_bid` joker that accumulates per event was silently invoked twice for the same bid (Le Passeur and the contract-injection path were both vulnerable, future on_bid jokers more so). The fix adds a `re_emit: bool = False` field to `BidMadeEvent`; the post-coinche refreshes pass `re_emit=True`, and `ScoreAccumulator.update_state` skips `_fire_jokers("on_bid", ...)` for re-emits while still updating `joker_state["contract"]` so the HUD and contract-aware logic stay in sync. Regression test in `tests/belatro/test_round_driver.py::test_bid_made_event_does_not_double_fire_on_bid_under_auto_coinche` (registers a counting `on_bid` joker under L'Avocat and asserts no fire carries `coinche_level > 0`).
+- **`src/belote/belatro/core/run_state.py::enter_endless` (E1, HIGH)** — Pre-3.4.0, accepting the "Continue into Endless Mode? (Ante 9+ scales ×2.2)" prompt left the run at `(ante=8, blind_index=2, endless_ante_offset=0, endless=True)`. The next `_play_blind` therefore *replayed* the Ante 8 Boss Blind at the SAME base target before the ×2.2 scaling kicked in on the second cycle — the prompt's promise of "Ante 9+ scales" was violated for one full round. The fix bumps `endless_ante_offset` to `max(offset, 1)` and resets `blind_index = 0` inside `enter_endless`, so the first endless round is Ante 8 Small Blind × 2.2 as advertised. Regression test in `tests/belatro/test_phase3_meta.py::test_enter_endless_advances_into_first_scaled_cycle`.
+- **`src/belote/main.py` classic game-over branch (E2, HIGH)** — `apply_round_score` (scoring.py:952-953) intentionally keeps `phase=Phase.DEAL` when both teams reach `target` AND the round ended in a tie — Belote's tie-breaker rule. The classic main loop then re-checked `ns >= target or ew >= target` and unconditionally forced `phase=Phase.GAME_OVER`, overriding the scoring layer's intent: tie-breakers never played, the game just ended on the first round any team crossed target even if the score was exactly even. Fixed by replacing the redundant re-check with `if state.phase == Phase.GAME_OVER:` — the scoring layer is the single source of truth, and the unused `dataclasses.replace` import is removed.
+- **`src/belote/input.py::_UnixKeyReader.restore` (A2, MED)** — `termios.tcsetattr` ran without exception handling. On a dropped SSH session, broken pipe, or a permission glitch it raised and left the host shell in raw/no-echo mode (the parent terminal would no longer echo keystrokes after the game crashed out). The call is now wrapped in `contextlib.suppress(termios.error, OSError)` and `_restored` is set regardless, so a follow-up restore call from `__exit__` after a prior raise is a no-op.
+- **`src/belote/belatro/ui/shop.py` selection clamp (A3, MED)** — After reroll the index clamp was `min(self.selected, len(self.shop.inventory))`, which allows `selected == len(inventory)` — out-of-bounds for the very next render's `inventory[self.selected]`. The buy-path guard at the same site already used the correct `max(0, len(...) - 1)` form. Fixed to match.
+- **`src/belote/ui/prompts.py::prompt_card` dead code (A5, LOW)** — The trailing `return None, state` after the `while True:` loop was unreachable (every match arm either continues or returns inside the loop). Replaced with an explicit `raise AssertionError("…")` so a future change that lets the loop fall through fails loud rather than silently returning a sentinel.
+
+### Added — UI/HUD polish
+
+- **`src/belote/belatro/ui/hud.py::render_joker_pip_strip` (B.3)** — Row-1 strip of 5 joker slots, each rendered as a 4-cell pip `[Xx ]` (or `[Xx*]` when the joker is in an active synergy pair). Empty slots paint as dotted `[··]` so the player sees their capacity at a glance. Edition support: `F` Foil → bright cyan, `H` Holo → magenta, `P` Polychrome → pink-violet, `N` Negative → reverse-video. The shortcode is `Joker.shortcode` — a new class property that returns the joker's manual `_shortcode_override` if set, else the first two letters of `name` upper-cased. New jokers inherit a sensible default with no extra plumbing. Hidden under Le Brouillard's `hide_hud` like the rest of the BelAtro HUD.
+- **`src/belote/belatro/ui/hud.py::render_synergy_tooltip` (B.4)** — When at least one synergy pair is active, prints a green-pip line below the score line describing the synergy (e.g. *"♦ Coinched Tout-Atout wins ramp the streak multiplier"*). Up to two synergies render on consecutive rows; further matches collapse to a `+N more synergies` line. `_SYNERGY_PAIRS` widened from `tuple[id_a, id_b]` to `tuple[id_a, id_b, description]`; existing `detect_synergies()` callers stay compatible via a 2-tuple shim, and the new `detect_synergies_full()` returns the description too. `validate_synergy_ids()` was updated to walk the new 3-tuple format.
+- **`src/belote/belatro/ui/trust_bar.py` polish (B.5)** — Four-tier colour ramp (cramoisi ≤2 / orange 3–4 / gold 5–7 / emeraude 8–10) replacing the previous three-tier red/gold/green. Leading tier glyph rendered from `_TIER_GLYPHS` (`✗ ♡ ♥ ♦ ★`) — Loyal/Mécène (tier ≥3) glyphs are bolded so the top tiers stand out. All four-tier transitions reuse `TrustTrack.tier`'s existing bucketing — no trust-math change.
+- **`src/belote/belatro/items/base.py::Joker.shortcode`** — New class property used by the pip strip. Subclasses can set `_shortcode_override = "Cs"` for a custom 2-char tag; otherwise the property derives one from `name`/`id`. No subclass changes required for the existing roster — defaults are good enough.
+
+### Verified clean — agent claims that did NOT survive source verification
+
+These were flagged by the audit agents but verification against the current code showed they are either correct behaviour, by-design patterns, or already-handled invariants. Catalogued so they aren't re-investigated next cycle.
+
+- **`game.py:562` "Tout Atout legal_cards downgrade" claim** — The `risers or tuple(my_suit_cards)` fallback is correct Belote: if you cannot rise within the lead suit, you may play any card *of that suit*. `my_suit_cards` is your hand filtered by lead suit, not played cards. **Not a bug.**
+- **`game.py:947-955` "L'Anarchie unseeded `_rng`"** — The default `_rng = field(default_factory=random.Random)` IS unseeded, BUT `start_round()` at `game.py:302` always sets `_rng=rng` from the driver's seeded RNG before any round logic runs. By the time L'Anarchie consumes it at line 955 the seeded instance is in place. **Clean.**
+- **`ai.py:73-92` "AI memory `last_voids_key` reset coverage"** — Both reset branches (new-round at line 73-78 and regression-detected at line 88-92) reset `last_voids_key` alongside the other three fields. **Clean per documented invariant.**
+- **`run/shop.py:166-168` "Negative-edition double-fits a full inventory"** — The `joker_slots += 1; jokers.append()` sequence is the documented Negative design (see `_can_accept` docstring at line 145-147). Net effect: slot pool grows with the joker. **Not a bug.**
+- **`round_driver.py:95-99` "Le Traître sabotage flag duplication"** — The guard `not state.boss_modifiers.agent_double_active` at line 95 and the population check `not state._joker_state.get("agent_double_tricks")` at line 120 prevent the double-population the agent feared. **Clean.**
+- **`run_state.py:66` "`contract_levels` not reset per run"** — `BelAtroRun.contract_levels` is `field(default_factory=dict)`; each new run instance starts fresh. Within a run it intentionally accumulates so planet rewards persist. **By design.**
+- **`registry.py:128-135` "`register_all_items` idempotency hole"** — The double-guard `_registered and registry.jokers` is *deliberate* per the docstring at line 130-133, to support test-suite registry resets. **Working as intended.**
+
+### Internal
+
+- **Tests**: 549 → 551 (+2 — A1 regression + E1 regression). Ruff and mypy strict still clean across all 76 source files.
+- **Strict gates**: pytest 551/551, mypy 0 errors (76 files), ruff 0 violations.
+- **`BidMadeEvent`** gained a `re_emit: bool = False` field. Existing call sites unchanged; only the three post-coinche refresh sites in `round_driver.py` opt into `re_emit=True`. Backward-compatible.
+- **`_SYNERGY_PAIRS`** widened to 3-tuples. `detect_synergies()` keeps the historic `list[tuple[str, str]]` return; `detect_synergies_full()` exposes the description.
+- **Deferred to a future release**: the larger render-pipeline features from the plan — score gutter (B.2) and trick-lane compass animation (B.1) — were scoped out because they touch `ui/render.py`'s line-assembly and vertical-centering logic, where a regression risks the classic and BelAtro display flows. They remain on the roadmap but want a dedicated session.
+
 ## [3.3.4] - 2026-05-10
 
 Portability release — removes all terminal-bell / sound code, which was triggering SIGSYS ("Bad system call") on Alpine 23 (musl libc) the moment the first trick completed in classic Belote mode. BelAtro mode was unaffected on the same Alpine box (it never imported `play_sound`), and Kubuntu / Lubuntu 24.10 / 25.10 (glibc) were unaffected in either mode. Rather than guard the BEL writes behind a libc-detection flag, the entire sound subsystem is removed: classic Belote and BelAtro now share the same "no bells" baseline. 549 tests still passing, ruff and mypy strict still clean.

{belote_cli-3.3.4 → belote_cli-3.4.0}/DEVELOPMENT.md

@@ -84,15 +84,15 @@ PYTHONPATH=src mypy --strict src/
 # Linting (0 violations expected)
 ruff check src/ tests/
 
-# Full test suite (549 tests expected)
+# Full test suite (551 tests expected)
 PYTHONPATH=src pytest
 ```
 
-Current baseline (3.3.4):
-- **mypy**: 0 errors (strict mode, 75 files)
+Current baseline (3.4.0):
+- **mypy**: 0 errors (strict mode, 76 files)
 - **ruff**: 0 violations
-- **pytest**: 549 tests, 0 failures
-- 3.3.4 covered: removed all terminal-bell / sound code (`play_sound`, `AudioManager`, `[M]` mute key) to fix a SIGSYS crash on Alpine 23 / musl after the first classic-mode trick. BelAtro and glibc distros were unaffected; classic Belote and BelAtro now share the same "no bells" baseline.
+- **pytest**: 551 tests, 0 failures
+- 3.4.0 covered: A1 `BidMadeEvent` double-fire on coinche paths (HIGH), E1 endless mode replaying Ante 8 Boss instead of advancing to the first scaled cycle (HIGH), E2 classic-mode tie-breaker overridden by main loop (HIGH), A2 termios raw-mode leak on SSH drop (MED), A3 shop selection index off-by-one after reroll (MED), A5 prompts.py dead return (LOW). Plus HUD additions: joker pip strip with edition glow (B.3), synergy tooltip (B.4), four-tier trust bar with tier glyph (B.5). Score gutter (B.2) and trick-lane compass (B.1) intentionally deferred — they touch `ui/render.py`'s vertical-centering logic and want a dedicated session.
 
 Run all gates before committing:
 

{belote_cli-3.3.4 → belote_cli-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: belote-cli
-Version: 3.3.4
+Version: 3.4.0
 Summary: A 4-player terminal card game
 Project-URL: Homepage, https://github.com/ElysiumDisc/belote
 Project-URL: Repository, https://github.com/ElysiumDisc/belote
@@ -45,6 +45,17 @@ Description-Content-Type: text/markdown
 
 Complete implementation of the French card game Belote for the terminal, with a full-screen green felt table and full card graphics at compass positions (N/W/E/S).
 
+## What's new in 3.4.0
+
+- **BelAtro joker correctness** — `BidMadeEvent` no longer double-fires `on_bid` joker handlers on coinche paths. Pre-3.4.0 the player-coinche, AI-partner-coinche, `auto_coinche` boss, and `start_coinched` deck-mod paths all re-emitted the same bid event a second time with the resolved `coinche_level`, so on_bid jokers (Le Passeur today, anything new tomorrow) were silently invoked twice for the same bid. Fixed via a `re_emit: bool` field on the event; refreshes update `joker_state["contract"]` but skip joker firing.
+- **Endless mode honours its prompt** — Accepting "Continue into Endless Mode? (Ante 9+ scales ×2.2)" used to leave the player at Ante 8 Boss Blind for one more *un-scaled* round before the ×2.2 kicked in. `enter_endless()` now advances into the first scaled cycle (offset=1, blind_index=0) immediately, so the very next round is the scaled Small Blind as advertised.
+- **Classic mode tie-breaker actually plays** — When both teams ended a round tied at exactly the target score, the classic loop unconditionally forced GAME_OVER, overriding `apply_round_score`'s deliberate `phase=DEAL` for tie-breaker rounds. The redundant re-check is gone; the scoring layer is the single source of truth for game-over phase.
+- **Terminal raw-mode no longer leaks on SSH drop** — `_UnixKeyReader.restore()` now wraps `termios.tcsetattr` in `contextlib.suppress(termios.error, OSError)` and marks the reader restored regardless. A dropped SSH session previously left the parent shell in no-echo mode.
+- **Shop reroll OOB fix** — Shop selection index after reroll is now correctly clamped to `len(inventory) - 1` instead of `len(inventory)`, preventing an out-of-range access on the next render.
+- **HUD: joker pip strip + synergy tooltip + polished trust bar** — Top-row 5-slot strip shows your jokers as compact pips with edition tint (Foil cyan / Holo magenta / Polychrome pink-violet / Negative reverse-video); slots in an active synergy pair gain a `*` marker, and a one-line tooltip below the score line describes the synergy. The trust bar gains a four-tier colour ramp (cramoisi/orange/gold/emeraude) and a leading tier glyph (`✗ ♡ ♥ ♦ ★`) — Loyal/Mécène glyphs are bolded so the top tiers pop.
+- **Audit reconciliation** — A fresh three-agent audit pass surfaced ~80 candidate findings; verification rejected ~95% as false positives or by-design patterns. The seven survivors are the fixes above; the rejected claims are catalogued in `CHANGELOG.md` so they aren't re-investigated.
+- **Test coverage** — 551 tests (up from 549). Strict gates still clean: pytest 551/551, mypy 0 errors (76 files), ruff 0 violations.
+
 ## What's new in 3.3.4
 
 - **Portability fix** — Removed all terminal-bell / sound code, which was triggering SIGSYS ("Bad system call") on Alpine 23 (musl libc) the moment the first trick completed in classic Belote mode. BelAtro mode and every glibc-based distro (Kubuntu / Lubuntu 24.10 / 25.10) were unaffected, but rather than guard the BEL writes behind a libc check, the entire sound subsystem is gone — `play_sound`, `AudioManager` / `AUDIO`, `is_muted` / `toggle_mute`, the `[M]` mute key, and the help-screen mute line. Classic Belote and BelAtro now share the same "no bells" baseline.

{belote_cli-3.3.4 → belote_cli-3.4.0}/README.md

@@ -2,6 +2,17 @@
 
 Complete implementation of the French card game Belote for the terminal, with a full-screen green felt table and full card graphics at compass positions (N/W/E/S).
 
+## What's new in 3.4.0
+
+- **BelAtro joker correctness** — `BidMadeEvent` no longer double-fires `on_bid` joker handlers on coinche paths. Pre-3.4.0 the player-coinche, AI-partner-coinche, `auto_coinche` boss, and `start_coinched` deck-mod paths all re-emitted the same bid event a second time with the resolved `coinche_level`, so on_bid jokers (Le Passeur today, anything new tomorrow) were silently invoked twice for the same bid. Fixed via a `re_emit: bool` field on the event; refreshes update `joker_state["contract"]` but skip joker firing.
+- **Endless mode honours its prompt** — Accepting "Continue into Endless Mode? (Ante 9+ scales ×2.2)" used to leave the player at Ante 8 Boss Blind for one more *un-scaled* round before the ×2.2 kicked in. `enter_endless()` now advances into the first scaled cycle (offset=1, blind_index=0) immediately, so the very next round is the scaled Small Blind as advertised.
+- **Classic mode tie-breaker actually plays** — When both teams ended a round tied at exactly the target score, the classic loop unconditionally forced GAME_OVER, overriding `apply_round_score`'s deliberate `phase=DEAL` for tie-breaker rounds. The redundant re-check is gone; the scoring layer is the single source of truth for game-over phase.
+- **Terminal raw-mode no longer leaks on SSH drop** — `_UnixKeyReader.restore()` now wraps `termios.tcsetattr` in `contextlib.suppress(termios.error, OSError)` and marks the reader restored regardless. A dropped SSH session previously left the parent shell in no-echo mode.
+- **Shop reroll OOB fix** — Shop selection index after reroll is now correctly clamped to `len(inventory) - 1` instead of `len(inventory)`, preventing an out-of-range access on the next render.
+- **HUD: joker pip strip + synergy tooltip + polished trust bar** — Top-row 5-slot strip shows your jokers as compact pips with edition tint (Foil cyan / Holo magenta / Polychrome pink-violet / Negative reverse-video); slots in an active synergy pair gain a `*` marker, and a one-line tooltip below the score line describes the synergy. The trust bar gains a four-tier colour ramp (cramoisi/orange/gold/emeraude) and a leading tier glyph (`✗ ♡ ♥ ♦ ★`) — Loyal/Mécène glyphs are bolded so the top tiers pop.
+- **Audit reconciliation** — A fresh three-agent audit pass surfaced ~80 candidate findings; verification rejected ~95% as false positives or by-design patterns. The seven survivors are the fixes above; the rejected claims are catalogued in `CHANGELOG.md` so they aren't re-investigated.
+- **Test coverage** — 551 tests (up from 549). Strict gates still clean: pytest 551/551, mypy 0 errors (76 files), ruff 0 violations.
+
 ## What's new in 3.3.4
 
 - **Portability fix** — Removed all terminal-bell / sound code, which was triggering SIGSYS ("Bad system call") on Alpine 23 (musl libc) the moment the first trick completed in classic Belote mode. BelAtro mode and every glibc-based distro (Kubuntu / Lubuntu 24.10 / 25.10) were unaffected, but rather than guard the BEL writes behind a libc check, the entire sound subsystem is gone — `play_sound`, `AudioManager` / `AUDIO`, `is_muted` / `toggle_mute`, the `[M]` mute key, and the help-screen mute line. Classic Belote and BelAtro now share the same "no bells" baseline.

{belote_cli-3.3.4 → belote_cli-3.4.0}/pyproject.toml

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

{belote_cli-3.3.4 → belote_cli-3.4.0}/src/belote/__init__.py

@@ -1,3 +1,3 @@
-__version__ = "3.3.4"
+__version__ = "3.4.0"
 
 __all__ = ["__version__"]

{belote_cli-3.3.4 → belote_cli-3.4.0}/src/belote/belatro/core/run_state.py

@@ -215,7 +215,18 @@ class BelAtroRun:
         self.run_over = True
 
     def enter_endless(self) -> None:
-        """Toggle endless mode after beating ante 8."""
+        """Toggle endless mode after beating ante 8.
+
+        Pre-3.4.0 the loop continued at (ante=8, blind=2, offset=0), which made
+        the *first* endless round replay the Ante 8 Boss Blind at the same
+        target before the ×2.2 scaling kicked in on the next cycle. We now
+        advance into a fresh endless cycle here so the prompt's "Ante 9+ scales
+        ×2.2" is honoured immediately.
+        """
         self.endless = True
         self.run_won = False  # endless overrides run-won state
         self.run_over = False  # ...and re-opens the run so the main loop continues
+        # Skip the redundant Ante 8 Boss replay: bump offset and restart the
+        # blind cycle. max(...) preserves any externally-set offset (tests).
+        self.endless_ante_offset = max(self.endless_ante_offset, 1)
+        self.blind_index = 0

{belote_cli-3.3.4 → belote_cli-3.4.0}/src/belote/belatro/core/scoring.py

@@ -230,7 +230,10 @@ class ScoreAccumulator:
         elif isinstance(event, BidMadeEvent):
             # Inject contract type into joker state so jokers can read it
             joker_state["contract"] = event.contract
-            _fire_jokers("on_bid", event)
+            # Re-emits (post-coinche refresh) update derived state but must not
+            # re-fire on_bid jokers — those already fired for the original bid.
+            if not event.re_emit:
+                _fire_jokers("on_bid", event)
 
         # Update GameState with new values
         return replace(

{belote_cli-3.3.4 → belote_cli-3.4.0}/src/belote/belatro/engine/event_bus.py

@@ -51,6 +51,12 @@ class BidMadeEvent:
     trump: Suit | None  # None = pass
     contract: str  # "normal" | "tout_atout" | "sans_atout" | "coinche" | "surcoinche"
     coinche_level: int = 0  # 0=none, 1=coinche, 2=surcoinche
+    # When True, this event is a post-coinche refresh of an already-emitted bid.
+    # Consumers should update derived state (HUD, joker_state["contract"]) but
+    # MUST NOT re-fire `on_bid` jokers — those already fired for the original
+    # bid during the bidding loop. Without this flag, jokers like Le Passeur
+    # would double-count or future on_bid-based scoring would silently overpay.
+    re_emit: bool = False
 
 
 # ── Bus ────────────────────────────────────────────────────────────────────

{belote_cli-3.3.4 → belote_cli-3.4.0}/src/belote/belatro/engine/round_driver.py

@@ -238,7 +238,9 @@ def drive_round(
         # L'Avocat boss forces at least coinche=1 (existing auto_coinche flag).
         if state.boss_modifiers.auto_coinche:
             coinche_level = max(coinche_level, 1)
-        # Re-emit the final BidMadeEvent so jokers/HUD see the coinche level.
+        # Refresh joker_state with the resolved coinche level via a re-emit.
+        # `re_emit=True` updates derived state (HUD, joker_state["contract"])
+        # without re-firing on_bid jokers — those already fired in the loop.
         if coinche_level > 0:
             state = _emit(
                 BidMadeEvent(
@@ -246,15 +248,14 @@ def drive_round(
                     trump=state.trump,
                     contract=state.contract or "normal",
                     coinche_level=coinche_level,
+                    re_emit=True,
                 ),
                 state,
             )
     elif state.boss_modifiers.auto_coinche and state.phase == Phase.PLAYING:
         # Boss forces coinche even if taker is on NS team.
         coinche_level = 1
-        # Re-emit BidMadeEvent so jokers/HUD subscribed to on_bid see the
-        # coinche level. The EW-taker branch above does this; this NS branch
-        # used to skip it, silently dropping the event for on_bid subscribers.
+        # Re-emit refresh — see comment above; on_bid is suppressed via re_emit.
         if state.taker is not None:
             state = _emit(
                 BidMadeEvent(
@@ -262,6 +263,7 @@ def drive_round(
                     trump=state.trump,
                     contract=state.contract or "normal",
                     coinche_level=coinche_level,
+                    re_emit=True,
                 ),
                 state,
             )
@@ -280,6 +282,7 @@ def drive_round(
                 trump=state.trump,
                 contract=state.contract or "normal",
                 coinche_level=coinche_level,
+                re_emit=True,
             ),
             state,
         )

{belote_cli-3.3.4 → belote_cli-3.4.0}/src/belote/belatro/items/base.py

@@ -61,6 +61,19 @@ class Joker(ABC):
     # NONE for backward compatibility with existing tests that instantiate
     # jokers directly.
     edition: Edition = Edition.NONE
+    # 3.4.0: short 2-char label used by the joker pip strip in the HUD. Sub-
+    # classes may override; the default takes the first two ASCII letters of
+    # `name` for instances that don't set their own. Resolved lazily so the
+    # default doesn't snapshot during class definition before name is set.
+    _shortcode_override: str = ""
+
+    @property
+    def shortcode(self) -> str:
+        if self._shortcode_override:
+            return self._shortcode_override[:2]
+        # Strip non-letters (avoid leading "L'" or "Le " producing empty codes)
+        letters = "".join(c for c in (self.name or self.id or "??") if c.isalpha())
+        return (letters[:2] or "??").upper()
 
     def on_trick_won(self, event: TrickWonEvent, state: dict[str, Any]) -> JokerResult | None:
         return None

{belote_cli-3.3.4 → belote_cli-3.4.0}/src/belote/belatro/ui/hud.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
+from collections.abc import Sequence
 from typing import TYPE_CHECKING
 
-from belote.ansi import BOLD, DIM, RESET, gold_fg, move, red_fg, visible_len, white_fg
+from belote.ansi import BOLD, DIM, RESET, gold_fg, green_fg, move, red_fg, visible_len, white_fg
 from belote.ui.layout import choose_layout
 
 if TYPE_CHECKING:
@@ -28,11 +29,21 @@ _MOOD_GLYPH = {
 # extend this tuple; pairs are order-insensitive (both directions matched).
 # Every id here MUST resolve in the joker registry — see
 # `validate_synergy_ids()` below; a startup self-check raises on typos.
-_SYNERGY_PAIRS: tuple[tuple[str, str], ...] = (
+# 3.4.0: now a 3-tuple with a human-readable description rendered in the
+# synergy tooltip when both jokers are active.
+_SYNERGY_PAIRS: tuple[tuple[str, str, str], ...] = (
     # Coinche stacking with the Tout-Atout streak ramp
-    ("coinche_stack", "tout_streak"),
+    (
+        "coinche_stack",
+        "tout_streak",
+        "Coinched Tout-Atout wins ramp the streak multiplier",
+    ),
     # La Sentinelle's trump-Jack lock plus a contract-level Mult booster
-    ("la_sentinelle", "le_fanatique"),
+    (
+        "la_sentinelle",
+        "le_fanatique",
+        "Sentinelle locks Jack; Fanatique amplifies contract-suit Mult",
+    ),
 )
 
 
@@ -47,16 +58,21 @@ def validate_synergy_ids() -> list[str]:
     from ..items.registry import registry
 
     seen: set[str] = set()
-    for a, b in _SYNERGY_PAIRS:
-        seen.add(a)
-        seen.add(b)
+    for entry in _SYNERGY_PAIRS:
+        seen.add(entry[0])
+        seen.add(entry[1])
     return sorted(s for s in seen if s not in registry.jokers)
 
 
-def detect_synergies(jokers: list[object]) -> list[tuple[str, str]]:
+def detect_synergies(jokers: Sequence[object]) -> list[tuple[str, str]]:
+    """Return the (id_a, id_b) pairs that are both present in `jokers`.
+
+    Backward-compatible with pre-3.4.0 2-tuple callers — the description
+    field is dropped here. Use `detect_synergies_full()` to keep it.
+    """
     ids = {getattr(j, "id", "") for j in jokers}
-    found = []
-    for a, b in _SYNERGY_PAIRS:
+    found: list[tuple[str, str]] = []
+    for a, b, _desc in _SYNERGY_PAIRS:
         if a in ids and b in ids:
             found.append((a, b))
     # Generic catch-all: if the player has 3+ jokers but no specific pair
@@ -66,6 +82,16 @@ def detect_synergies(jokers: list[object]) -> list[tuple[str, str]]:
     return found
 
 
+def detect_synergies_full(jokers: Sequence[object]) -> list[tuple[str, str, str]]:
+    """Like `detect_synergies` but returns the description too.
+
+    The generic 3+-joker stack synergy is NOT included — it has no specific
+    description and is purely a HUD nudge for variety.
+    """
+    ids = {getattr(j, "id", "") for j in jokers}
+    return [(a, b, desc) for (a, b, desc) in _SYNERGY_PAIRS if a in ids and b in ids]
+
+
 class BelAtroHUD:
     """Renders the roguelite HUD elements during gameplay."""
 
@@ -80,6 +106,16 @@ class BelAtroHUD:
         layout = choose_layout(term_w, term_h)
         run = self.run
 
+        # 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.
+        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.
+            tooltip_row = 4 if layout.hud_style == "compact" else 5
+            render_synergy_tooltip(list(run.jokers), term_w, row=tooltip_row)
+
         if layout.hud_style == "compact":
             self._render_compact(acc, state, term_w)
             return
@@ -165,3 +201,95 @@ class BelAtroHUD:
             score_str = f"{state._chips}×{state._mult:.1f}={acc.get_total(state)}"
             score_col = max(2, term_w - len(score_str) - 2)
             print(move(3, score_col) + red_fg() + BOLD + score_str + RESET)
+
+
+# ── 3.4.0: joker pip strip + synergy tooltip ────────────────────────────────
+
+# Edition glyph & colour for the pip strip. Polychrome cycles colours but we
+# keep a stable accent so the strip doesn't flicker — the visual interest
+# comes from the colour difference between editions, not animation.
+_EDITION_GLYPH: dict[str, str] = {
+    "none": " ",
+    "foil": "F",
+    "holo": "H",
+    "poly": "P",
+    "neg": "N",
+}
+
+
+def _edition_color(ed_value: str) -> str:
+    """ANSI prefix for an edition. Falls back to white for NONE."""
+    if ed_value == "foil":
+        return "\x1b[38;5;51m"   # bright cyan
+    if ed_value == "holo":
+        return "\x1b[38;5;201m"  # magenta
+    if ed_value == "poly":
+        return "\x1b[38;5;213m"  # pink-violet (stand-in for rainbow)
+    if ed_value == "neg":
+        return "\x1b[7m"         # reverse video
+    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).
+
+    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).
+    """
+    if term_w < 24:
+        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
+    synergetic_ids: set[str] = set()
+    for a, b, _desc in detect_synergies_full(jokers):
+        synergetic_ids.add(a)
+        synergetic_ids.add(b)
+
+    parts: list[str] = [f"{white_fg()}J:{RESET} "]
+    for i in range(slots):
+        if i < len(jokers):
+            j = jokers[i]
+            ed_value = getattr(getattr(j, "edition", None), "value", "none")
+            ed_color = _edition_color(ed_value)
+            shortcode = (getattr(j, "shortcode", "??") or "??")[:2]
+            marker = "*" if getattr(j, "id", "") in synergetic_ids else " "
+            # Pip cell: `[Xx*]` with edition-coloured content (4 cells wide
+            # excluding the gold brackets).
+            parts.append(
+                f"{gold_fg()}[{RESET}"
+                f"{ed_color}{shortcode}{marker}{RESET}"
+                f"{gold_fg()}]{RESET}"
+            )
+        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.
+    print(move(row, 2) + strip)
+
+
+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.
+
+    No-ops when there are no active synergies. Truncates each line to the
+    available width so we never wrap.
+    """
+    pairs = detect_synergies_full(list(jokers))
+    if not pairs:
+        return
+    # Show up to two synergies; further ones are summarised as "+N more".
+    max_w = max(20, term_w - 4)
+    for i, (_a, _b, desc) in enumerate(pairs[:2]):
+        line = f"{green_fg()}♦{RESET} {white_fg()}{desc}{RESET}"
+        if visible_len(line) > max_w:
+            # crude trim — fall back to plain ASCII to make ansi-stripping
+            # unnecessary (we never split mid-escape).
+            line = desc[: max_w - 2] + ".."
+        print(move(row + i, 2) + line)
+    if len(pairs) > 2:
+        extra = f"{DIM}+{len(pairs) - 2} more synergies{RESET}"
+        print(move(row + 2, 2) + extra)

{belote_cli-3.3.4 → belote_cli-3.4.0}/src/belote/belatro/ui/shop.py

@@ -68,7 +68,10 @@ class ShopScreen:
                         self.selected = max(0, len(self.shop.inventory) - 1)
                 elif self.selected == num_items:
                     self.shop.reroll()
-                    self.selected = min(self.selected, len(self.shop.inventory))
+                    # Clamp to a *valid* index: len(inventory)-1, not len.
+                    # The previous form let `selected == len(inventory)` slip
+                    # through, OOB on the next render's inventory[self.selected].
+                    self.selected = min(self.selected, max(0, len(self.shop.inventory) - 1))
                 elif self.selected == forge_idx:
                     self._handle_forge()
             elif key in (Key.ESC, Key.QUIT):

belote_cli-3.4.0/src/belote/belatro/ui/trust_bar.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from belote.ansi import BOLD, RESET, gold_fg, green_fg, move, red_fg, white_fg
+
+if TYPE_CHECKING:
+    from ..partner.trust import TrustTrack
+
+
+# 3.4.0: per-tier glyph + name. Index = TrustTrack.tier (0–4).
+_TIER_GLYPHS: tuple[str, ...] = ("✗", "♡", "♥", "♦", "★")
+_TIER_NAMES: tuple[str, ...] = ("Méfiant", "Sulking", "Neutre", "Loyal", "Mécène")
+
+
+def _orange_fg() -> str:
+    # Standalone helper — ansi.py doesn't expose an orange yet. Bright yellow
+    # SGR (38;5;208) renders close to "orange" on 256-colour terminals; falls
+    # back to gold on 16-colour. Cheap inline avoids a wider ansi.py change.
+    return "\x1b[38;5;208m"
+
+
+def _bar_color(value: int) -> str:
+    """Four-tier colour ramp: 0–2 cramoisi, 3–4 orange, 5–7 gold, 8–10 emeraude."""
+    if value <= 2:
+        return str(red_fg())
+    if value <= 4:
+        return _orange_fg()
+    if value <= 7:
+        return str(gold_fg())
+    return str(green_fg())
+
+
+class TrustBar:
+    """Visualizes the 0-10 Trust Track with a tier glyph and 4-colour gradient."""
+
+    def __init__(self, trust: TrustTrack) -> None:
+        self.trust = trust
+
+    def render(self) -> None:
+        """Render trust meter at (row 4, col 2)."""
+        val = self.trust.value
+        tier = self.trust.tier
+        filled = "█" * val
+        empty = "░" * (10 - val)
+        color = _bar_color(val)
+        bar = color + filled + white_fg() + empty + RESET
+        # Tier glyph leads the bar; bolded for the top two tiers so Loyal/
+        # Mécène stand out at a glance.
+        glyph = _TIER_GLYPHS[tier]
+        glyph_render = (BOLD + color + glyph + RESET) if tier >= 3 else (color + glyph + RESET)
+
+        if self.trust.ai_degraded:
+            status = red_fg() + " ⚠ Degraded" + RESET
+        elif self.trust.auto_capot_available:
+            status = gold_fg() + " ★ Auto-Capot" + RESET
+        elif self.trust.shares_void_info:
+            status = green_fg() + " ✦ Void Info" + RESET
+        else:
+            status = ""
+
+        print(
+            move(4, 2)
+            + white_fg() + "Trust: " + RESET
+            + glyph_render + " ["
+            + bar
+            + white_fg() + "] " + RESET
+            + status
+        )

{belote_cli-3.3.4 → belote_cli-3.4.0}/src/belote/input.py

@@ -56,7 +56,14 @@ class _UnixKeyReader:
 
     def restore(self) -> None:
         if self._old_termios and not self._restored:
-            termios.tcsetattr(self._stdin_fd, termios.TCSADRAIN, self._old_termios)
+            # A dropped SSH session / broken pipe can make tcsetattr raise.
+            # We swallow the error and mark restored anyway so a re-entrant
+            # restore() (e.g. from __exit__ after a prior failed restore) is
+            # a no-op rather than another raise.
+            import contextlib
+
+            with contextlib.suppress(termios.error, OSError):
+                termios.tcsetattr(self._stdin_fd, termios.TCSADRAIN, self._old_termios)
             self._restored = True
 
     def read(self) -> KeyEvent:

{belote_cli-3.3.4 → belote_cli-3.4.0}/src/belote/main.py

@@ -12,7 +12,6 @@ import random
 import shutil
 import signal
 import sys
-from dataclasses import replace
 
 from . import __version__
 from .ansi import (
@@ -216,11 +215,13 @@ def main() -> None:
                         break
                     state = res_round
 
-                    # Check for game over (after round end and score application)
-                    ns, ew = state.team_scores
-                    if ns >= target or ew >= target:
-                        state = replace(state, phase=Phase.GAME_OVER)
-
+                    # `apply_round_score` (scoring.py) already set the correct
+                    # phase: GAME_OVER when a team is ahead at/over target,
+                    # DEAL on a tie at target so a tie-breaker round plays.
+                    # Pre-3.4.0 this branch re-checked targets and forced
+                    # GAME_OVER unconditionally, breaking the tie-breaker.
+                    if state.phase == Phase.GAME_OVER:
+                        ns, ew = state.team_scores
                         unique_diffs = set(diffs_map.values())
                         difficulty_str = (
                             next(iter(unique_diffs)) if len(unique_diffs) == 1 else "mixed"

{belote_cli-3.3.4 → belote_cli-3.4.0}/src/belote/ui/prompts.py

@@ -109,7 +109,8 @@ def prompt_card(
                         idx = int(char) - 1
                         if 0 <= idx < len(hand) and hand[idx] in legal:
                             return hand[idx], state
-    return None, state
+    # Unreachable: the while(True) above only exits via return.
+    raise AssertionError("prompt_card loop fell through without returning")
 
 
 def prompt_bid(state: GameState, reader: KeyReader) -> Suit | str | None:

{belote_cli-3.3.4 → belote_cli-3.4.0}/tests/belatro/test_hud_synergy.py

@@ -42,8 +42,9 @@ def test_detect_synergies_finds_sentinelle_fanatique_pair() -> None:
 
 def test_detect_synergies_generic_stack_badge_for_three_unrelated() -> None:
     """Three jokers with no known pair still raise a generic 'stack' tag."""
-    # Pick three IDs that aren't part of any pair.
-    pair_ids = {a for pair in _SYNERGY_PAIRS for a in pair}
+    # Pick three IDs that aren't part of any pair. Each pair entry is
+    # (id_a, id_b, description) since 3.4.0 — pull the first two.
+    pair_ids = {x for pair in _SYNERGY_PAIRS for x in pair[:2]}
     unrelated = [j for j_id, j in registry.jokers.items() if j_id not in pair_ids][:3]
     if len(unrelated) < 3:
         return  # not enough non-paired jokers — registry too small
@@ -53,7 +54,7 @@ def test_detect_synergies_generic_stack_badge_for_three_unrelated() -> None:
 
 def test_detect_synergies_empty_for_unrelated_pair() -> None:
     """One unpaired + one unpaired = no badge, not even a generic one."""
-    pair_ids = {a for pair in _SYNERGY_PAIRS for a in pair}
+    pair_ids = {x for pair in _SYNERGY_PAIRS for x in pair[:2]}
     unrelated = [j for j_id, j in registry.jokers.items() if j_id not in pair_ids][:2]
     if len(unrelated) < 2:
         return
@@ -66,7 +67,8 @@ def test_detect_synergies_does_not_fire_for_solo_half() -> None:
     is owned. Trip-wire for any future change to detect_synergies that
     accidentally matches single jokers against pair entries.
     """
-    for left_id, right_id in _SYNERGY_PAIRS:
+    for entry in _SYNERGY_PAIRS:
+        left_id, right_id = entry[0], entry[1]
         # Confirm the right half is registered (the validate test above
         # already pins this, but be defensive).
         if right_id not in registry.jokers or left_id not in registry.jokers:

{belote_cli-3.3.4 → belote_cli-3.4.0}/tests/belatro/test_phase3_meta.py

@@ -107,6 +107,24 @@ def test_enter_endless_clears_run_won_and_flips_flag() -> None:
     assert run.run_won is False
 
 
+def test_enter_endless_advances_into_first_scaled_cycle() -> None:
+    """3.4.0 fix: pre-fix, entering endless from (ante=8, blind=2, offset=0)
+    left state at (ante=8, blind=2, offset=0, endless=True), so the next round
+    REPLAYED Ante 8 Boss Blind at base target before ×2.2 kicked in. The fix
+    bumps offset to 1 and resets blind_index so the very first endless round is
+    Ante 8 Small Blind × 2.2 — honouring the prompt's "Ante 9+ scales" promise.
+    """
+    run = BelAtroRun(ante_number=8, blind_index=2, run_won=True)
+    run.enter_endless()
+    assert run.endless is True
+    assert run.run_over is False
+    assert run.blind_index == 0  # restart of blind cycle
+    assert run.endless_ante_offset == 1  # first scaled cycle
+    # The very next blind is the scaled Small Blind, not a Boss replay.
+    assert run.current_blind.target == endless_ante(8, 0, 1).target
+    assert run.current_blind.name == "Small Blind"
+
+
 # ── Joker fusion ────────────────────────────────────────────────────────────
 
 

{belote_cli-3.3.4 → belote_cli-3.4.0}/tests/belatro/test_round_driver.py

@@ -227,3 +227,65 @@ def test_traitre_joker_sabotage_preserved_when_no_boss() -> None:
     tricks = state._joker_state.get("agent_double_tricks")
     assert isinstance(tricks, frozenset)
     assert len(tricks) == 1  # traitre's "single random trick" pattern
+
+
+# ── A1 regression (3.4.0): BidMadeEvent must not double-fire on_bid jokers ──
+
+
+def test_bid_made_event_does_not_double_fire_on_bid_under_auto_coinche() -> None:
+    """Regression for the coinche-path double-fire bug.
+
+    Before the fix, the auto_coinche boss path emitted BidMadeEvent twice for
+    the winning bid: once during the bidding loop (coinche_level=0), then
+    again post-coinche-resolution (coinche_level=1). Both emits fired
+    `on_bid` jokers, so any joker that read coinche-related state on the bid
+    event would be silently invoked twice (or with stale info on the first
+    fire). The fix flags re-emits with `re_emit=True` so the accumulator
+    skips on_bid firing while still updating joker_state["contract"].
+    """
+    from belote.belatro.run.boss import LAvocat
+
+    # A joker that records every on_bid fire — we'll assert no fire happens
+    # with coinche_level > 0, since re-emits should not invoke on_bid.
+    class _BidSniffer(Joker):
+        id = "bid_sniffer"
+        name = "BidSniffer"
+        description = "test"
+
+        def __init__(self) -> None:
+            self.fires: list[int] = []  # captured coinche_level per fire
+
+        def on_bid(self, event, state):  # type: ignore[no-untyped-def]
+            self.fires.append(event.coinche_level)
+
+    sniffer = _BidSniffer()
+    acc = ScoreAccumulator()
+    acc.attach_jokers([sniffer])
+    bus = EventBus()
+    partner = PartnerState()
+
+    # UI that passes on bids and plays the first legal card on every turn.
+    class _LegalPlayUI(MockUICallbacks):
+        def prompt_card(self, state: GameState):  # type: ignore[no-untyped-def]
+            from belote.game import legal_cards
+
+            legal = legal_cards(state, Seat.SOUTH)
+            return legal[0], state
+
+    drive_round(
+        bus=bus,
+        partner=partner,
+        boss=LAvocat(),
+        ui_callbacks=_LegalPlayUI(),
+        acc=acc,
+        seed=7,
+    )
+
+    # The fix must ensure no on_bid invocation carries coinche_level > 0 —
+    # those only come from re-emits, which are now suppressed. Failures here
+    # mean a re-emit slipped through without re_emit=True (regression).
+    coinched_fires = [lvl for lvl in sniffer.fires if lvl > 0]
+    assert coinched_fires == [], (
+        f"on_bid fired with coinche_level>0 ({coinched_fires}) — re-emits "
+        "should not invoke on_bid jokers."
+    )

belote_cli-3.3.4/src/belote/belatro/ui/trust_bar.py

@@ -1,44 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from belote.ansi import RESET, gold_fg, green_fg, move, red_fg, white_fg
-
-if TYPE_CHECKING:
-    from ..partner.trust import TrustTrack
-
-
-class TrustBar:
-    """Visualizes the 0-10 Trust Track."""
-
-    def __init__(self, trust: TrustTrack) -> None:
-        self.trust = trust
-
-    def render(self) -> None:
-        """Render trust meter."""
-        val = self.trust.value
-        filled = "█" * val
-        empty = "░" * (10 - val)
-        # Three-tier color: ≤3 red (danger), 4–6 gold (neutral), ≥7 green
-        # (healthy). The default trust=5 used to render red under the old
-        # `> 5` threshold, which falsely signalled distrust at game start.
-        if val <= 3:
-            color = red_fg()
-        elif val >= 7:
-            color = green_fg()
-        else:
-            color = gold_fg()
-        bar = color + filled + white_fg() + empty + RESET
-
-        if self.trust.ai_degraded:
-            status = red_fg() + " ⚠ Degraded" + RESET
-        elif self.trust.auto_capot_available:
-            status = gold_fg() + " ★ Auto-Capot" + RESET
-        elif self.trust.shares_void_info:
-            status = green_fg() + " ✦ Void Info" + RESET
-        else:
-            status = ""
-
-        print(
-            move(4, 2) + white_fg() + "Trust: [" + RESET + bar + white_fg() + "] " + RESET + status
-        )