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

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

@@ -5,6 +5,71 @@ 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.
+
+### Removed
+
+- **`src/belote/ui/announce.py::play_sound`** — terminal-bell helper (writes `\a` bytes for `trick` / `belote` / `declaration` / `chute` / `capot` events). Was called from five sites in `gameflow.py` (post-trick, capot, first-trick declarations, Belote announcement, chute on failed contract); all five call sites are deleted along with the function. BelAtro's `engine/round_driver.py` never imported it, so no BelAtro behaviour changes.
+- **`src/belote/ui/announce.py::is_muted` / `toggle_mute`** — wrappers around `AUDIO.is_muted()` / `AUDIO.toggle_mute()`. Re-exports dropped from `src/belote/ui/__init__.py::__all__`.
+- **`src/belote/context.py::AudioManager` + the `AUDIO` singleton** — process-wide mute state holder. `TerminalContext` and the `TERMINAL` singleton are kept (they back the terminal-size cache used elsewhere).
+- **`src/belote/input.py::Key.MUTE` + the `m` / `b"m"` key bindings** — `M` no longer triggers a special key event in either `_UnixKeyReader` or `_WindowsKeyReader`; it now falls through to `Key.CHAR` like any other letter (Belote has no other meaning for `M`).
+- **Three `case Key.MUTE: toggle_mute()` branches in `src/belote/ui/prompts.py`** (card prompt, bid prompt, rules viewer) — deleted along with the `from .announce import is_muted, toggle_mute` import.
+- **Two `case Key.MUTE: toggle_mute()` branches in `src/belote/ui/menu.py`** (AI config submenu, main menu) — deleted along with the `from .announce import toggle_mute` import.
+- **`[M] Toggle Sound Effects` line from the in-game help screen** (`src/belote/ui/prompts.py::show_help`) — plus the live `(Currently: ON/OFF)` status line that reflected `is_muted()`.
+- **`tests/test_gameflow.py`** — the obsolete `unittest.mock.patch("belote.gameflow.play_sound")` mock inside `test_run_play_8_tricks`'s `ExitStack` is gone; the test still passes (the underlying `display` / `patch_trick_card` / `announce` / `prompt_card` mocks remain).
+
+### Internal
+
+- **Tests**: still 549 passing.
+- **Strict gates**: pytest 549/549, mypy 0 errors (75 files — `context.py` lost one class but kept the module), ruff 0 violations.
+- **Unused-import sweep**: `green_fg` dropped from `src/belote/ui/prompts.py` imports (only the deleted `sound_status` line used it).
+
+### Why drop the bell instead of guarding it on musl
+
+`play_sound` only writes BEL (`\a`) bytes to stdout; writing those bytes is just `write(2)` and doesn't itself trigger SIGSYS on any sane libc. Whatever the precise mechanism on Alpine 23 (terminal-driver quirk, blocked downstream ioctl, or musl-specific signal-frame interaction with the existing `signal.signal(SIGINT/SIGTERM)` registration in `main.py:132-133`), the simplest and most robust answer is to stop writing the bell at all. Modern terminal emulators on every tested distro either ignored or visually-flashed the bell — no user-meaningful audio was being produced. The mute toggle exists only to suppress those flashes; with the bell gone, the toggle is dead weight.
+
 ## [3.3.3] - 2026-05-10
 
 Audit-of-audit release — a fresh three-agent codebase pass (classic engine / BelAtro mode / tests + UI) produced ~50 candidate findings. Verification cut that to **3 real fixes** plus **3 net-new invariant test suites** for properties the prior 3.3.x cycles silently relied on. ~14 rejected claims are catalogued at the bottom of this entry so they aren't re-investigated next cycle. 549 tests passing (up from 537), ruff and mypy strict still clean. Plan file at `/home/mrrobot/.claude/plans/bug-hunt-code-performance-tingly-barto.md`.

{belote_cli-3.3.3 → 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.3):
+Current baseline (3.4.0):
 - **mypy**: 0 errors (strict mode, 76 files)
 - **ruff**: 0 violations
-- **pytest**: 549 tests, 0 failures
-- 3.3.3 covered: boss-RNG seeding, Tout Atout hand sort, Le Jugement Common-only filter, plus three new invariant suites (scoring conservation, replay round-trip, HUD synergy negative test).
+- **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.3 → belote_cli-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: belote-cli
-Version: 3.3.3
+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,22 @@ 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.
+- **Test coverage** — Still 549 tests. Strict gates clean: pytest 549/549, mypy 0 errors, ruff 0 violations.
+
 ## What's new in 3.3.3
 
 - **Determinism** — Boss assignment in BelAtro mode now draws from the run's seeded RNG instead of the module-level `random`. This was the last unseeded RNG site in the round flow (shop and tarots were converted in 3.2.0, AI in 3.3.1, replay analysis in 3.3.2). Same seed now reproduces the same boss on the boss blind.
@@ -243,7 +259,6 @@ belote --difficulty hard --target 500 --seed 123 --speed fast
 
 **General:**
 - `?`: Show keyboard shortcut help
-- `M`: Toggle sound effects on/off
 - `I` or `V`: Toggle BelAtro score overlay (per-trick breakdown popup)
 - `Q`: Quit to main menu or exit
 - `H`: View Game History (round-by-round, with contract / taker / tricks / declarations)
@@ -284,7 +299,6 @@ belote --difficulty hard --target 500 --seed 123 --speed fast
 - **Statistics:** unified global tracking of games played, win rates, best rounds, and BelAtro expansion milestones.
 - **Responsive Layout (3 tiers):** Three preset layouts — **compact** (80×32, fits 1366×768), **standard** (96×38), **spacious** (120×48+). The game picks the largest preset that fits your terminal on every render, so resizing mid-game adapts automatically; cards, side columns, and HUD verbosity all scale with the preset. Vertical centering pads tall terminals so the game never clings to the top.
 - **Alternate Screen Buffer:** Both classic Belote and BelAtro run in a dedicated terminal buffer for a clean, non-overlapping interface — your shell scrollback stays untouched after you quit.
-- **Sound Effects:** Enhanced auditory feedback for trick wins, Belote, and Capot, with a built-in mute toggle.
 - **Declarations:** Automatic detection and announcement of sequences (Tierce, Quarte, etc.) and Carrés after the first trick.
 - **Live HUD:** Real-time round scoring displays points won during the current round, with a smooth "rolling" numerical animation for total scores.
 - **High Fidelity:** Implementation of French Belote rules according to the [official rules of the Fédération Française de Belote](https://www.ffbelote.org/regles-officielle-belote/), including a two-round bidding system, "Dix de Der", "Capot" (252 pts), and "Litige" (tie-break). All six contracts are bidable in round 2: the four card suits, **Tout Atout** (every suit acts as trump within its own led-suit group; press `a`), and **Sans Atout** (no trump, lead-suit highest wins; press `s`).
@@ -316,7 +330,7 @@ belote/
 │   ├── scoring.py     # Declarations, round scoring, capot
 │   ├── ai.py          # Three-tier AI (easy/medium/hard)
 │   ├── config.py      # Global configuration and timings
-│   ├── context.py     # Global managers (Audio, Terminal)
+│   ├── context.py     # Global managers (Terminal)
 │   ├── themes.py      # Color theme management
 │   ├── ui/            # Modular UI package
 │   ├── ansi.py        # ANSI escape helpers (colors, cursor)

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

@@ -2,6 +2,22 @@
 
 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.
+- **Test coverage** — Still 549 tests. Strict gates clean: pytest 549/549, mypy 0 errors, ruff 0 violations.
+
 ## What's new in 3.3.3
 
 - **Determinism** — Boss assignment in BelAtro mode now draws from the run's seeded RNG instead of the module-level `random`. This was the last unseeded RNG site in the round flow (shop and tarots were converted in 3.2.0, AI in 3.3.1, replay analysis in 3.3.2). Same seed now reproduces the same boss on the boss blind.
@@ -200,7 +216,6 @@ belote --difficulty hard --target 500 --seed 123 --speed fast
 
 **General:**
 - `?`: Show keyboard shortcut help
-- `M`: Toggle sound effects on/off
 - `I` or `V`: Toggle BelAtro score overlay (per-trick breakdown popup)
 - `Q`: Quit to main menu or exit
 - `H`: View Game History (round-by-round, with contract / taker / tricks / declarations)
@@ -241,7 +256,6 @@ belote --difficulty hard --target 500 --seed 123 --speed fast
 - **Statistics:** unified global tracking of games played, win rates, best rounds, and BelAtro expansion milestones.
 - **Responsive Layout (3 tiers):** Three preset layouts — **compact** (80×32, fits 1366×768), **standard** (96×38), **spacious** (120×48+). The game picks the largest preset that fits your terminal on every render, so resizing mid-game adapts automatically; cards, side columns, and HUD verbosity all scale with the preset. Vertical centering pads tall terminals so the game never clings to the top.
 - **Alternate Screen Buffer:** Both classic Belote and BelAtro run in a dedicated terminal buffer for a clean, non-overlapping interface — your shell scrollback stays untouched after you quit.
-- **Sound Effects:** Enhanced auditory feedback for trick wins, Belote, and Capot, with a built-in mute toggle.
 - **Declarations:** Automatic detection and announcement of sequences (Tierce, Quarte, etc.) and Carrés after the first trick.
 - **Live HUD:** Real-time round scoring displays points won during the current round, with a smooth "rolling" numerical animation for total scores.
 - **High Fidelity:** Implementation of French Belote rules according to the [official rules of the Fédération Française de Belote](https://www.ffbelote.org/regles-officielle-belote/), including a two-round bidding system, "Dix de Der", "Capot" (252 pts), and "Litige" (tie-break). All six contracts are bidable in round 2: the four card suits, **Tout Atout** (every suit acts as trump within its own led-suit group; press `a`), and **Sans Atout** (no trump, lead-suit highest wins; press `s`).
@@ -273,7 +287,7 @@ belote/
 │   ├── scoring.py     # Declarations, round scoring, capot
 │   ├── ai.py          # Three-tier AI (easy/medium/hard)
 │   ├── config.py      # Global configuration and timings
-│   ├── context.py     # Global managers (Audio, Terminal)
+│   ├── context.py     # Global managers (Terminal)
 │   ├── themes.py      # Color theme management
 │   ├── ui/            # Modular UI package
 │   ├── ansi.py        # ANSI escape helpers (colors, cursor)

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

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

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

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

{belote_cli-3.3.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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
+        )