belote-cli 3.8.0__tar.gz → 3.8.2__tar.gz

{belote_cli-3.8.0 → belote_cli-3.8.2}/CHANGELOG.md

@@ -5,6 +5,45 @@ 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.8.2] - 2026-05-14
+
+Final logic audit and performance hardening. This release addresses the remaining edge cases identified during the deep-dive audit, focusing on BelAtro joker persistence, declaration scoring correctness, and test suite optimization. All 655 tests passing.
+
+### Fixed
+
+- **`src/belote/belatro/main.py` (HIGH) — Tout Atout streak now persists between rounds.** Fixed a bug where `ToutStreak` state was lost on every round transition because it wasn't being "drained" into the run-level state. It now correctly persists in `BelAtroRun.card_enhancements`.
+- **`src/belote/belatro/items/jokers/annonces.py::QuinteRoyale` (MEDIUM) — Fixed trigger logic.** The joker previously armed on any declaration >= 100 points, including high-rank Carrés. It now correctly only arms on sequences of 5+ cards (Quintes).
+- **`src/belote/belatro/items/jokers/economy.py::LeNotaire` and `contract.py::LeRebelle` (MEDIUM) — Refined belote-pair timing.** These jokers now trigger on the `rebelote` (second card played) instead of the first. This ensures they only subtract the 20-point bonus once it has actually been awarded to the team.
+- **`src/belote/scoring.py::score_round` (MEDIUM) — Sequence scoring correctness.** Fixed a bug where sequences longer than 5 cards (e.g., 6 or 7 cards) were worth 0 points. They now correctly cap at 100 points (Quinte).
+- **`src/belote/scoring.py::get_declaration_points` (MEDIUM) — Carré scoring fix.** Fixed a logic bug where Carrés were always worth 0 points due to a rank-lookup type mismatch.
+- **`src/belote/scoring.py::_score_capot_outcome` (MEDIUM) — Capot/Zero-Final consistency.** Fixed a bug where the Capot reward did not respect the `no_dix_de_der` boss modifier. It now correctly drops the base reward by 10 points when the last-trick bonus is suppressed.
+- **`tests/test_gameflow.py` (PERF) — Mocked `interruptible_sleep` in tests.** Resolved a 4-second delay in the test suite by ensuring UI-centric sleeps are bypassed during unit testing.
+
+## [3.8.1] - 2026-05-14
+
+Bug-hunt + logic audit pass. Five parallel audit agents (BelAtro core, classic engine, BelAtro items/run/partner, UI layer, performance) ran across the codebase; verification turned 8 raw findings into **3 confirmed critical bugs**, **3 medium correctness fixes**, and **1 documentation typo**. Two agent claims (`_card_beats` under Tout Atout, `_compute_belote_points` 20-when-only-K-played) were refuted on re-trace and not changed — both are working as designed. **+5 regression tests** (650 → 655).
+
+### Fixed
+
+- **`src/belote/game.py::_resolve_trick_winner` (CRITICAL) — La Rupture no longer drifts between play_card and score_round.** Pre-3.8.1 `_resolve_trick_winner` derived the previous trick's winner via `trick_winner_seat(state.completed_tricks[-1], …)` — the RAW result. Meanwhile `compute_trick_winners` (the final-scoring authority) threads the *resolved* previous winner through the chain. On trick 3+, whenever Rupture flipped trick N-1, the two paths disagreed: `state.last_trick_winner` (and downstream HUD running totals, dix-de-der attribution) reported a winner that did NOT match the final scoring tally. Fixed by reading `state.last_trick_winner` (already stored as the resolved value). Regression test in `tests/belatro/test_boss_modifiers_integration.py::test_rupture_play_card_resolves_consistently_with_scoring`.
+- **`src/belote/belatro/engine/round_driver.py:135-148` (CRITICAL) — boss modifiers are now applied BEFORE `acc.trigger_round_start`.** Pre-3.8.1 the call order was `trigger_round_start` (which snapshots `state.boss_modifiers.no_dix_de_der` into `joker_state["no_dix_de_der"]`) → `boss.apply` (which patches the flag onto the live state). Any joker reading `state.get("no_dix_de_der", …)` (e.g. `trick_timing.py` last-trick scoring) saw the BossModifiers default `False` rather than the live boss flag — so the boss-aware joker code paths silently no-op'd on Le Zéro Final blinds. Fixed by reordering. Regression test in `tests/belatro/test_round_driver.py::test_boss_flags_applied_before_trigger_round_start`.
+- **`src/belote/belatro/engine/round_driver.py:393-401` (CRITICAL, La Rupture follow-on) — `TrickWonEvent.winner` now carries the resolved (Rupture-aware) seat.** Pre-3.8.1 the event was emitted with `winner = trick_winner_seat(last_trick, …)` (raw); under La Rupture every joker keyed on `team_of(event.winner) == 0` would credit the team that did NOT actually receive the trick in `score_round`. Fixed by emitting `winner = state.last_trick_winner`; `trick_winner_seat` import removed from the round driver.
+- **`src/belote/belatro/items/jokers/contract.py::LeRebelle` and `economy.py::LeNotaire` (HIGH) — belote-pair jokers no longer double-fire on `BeloteAnnouncedEvent`.** `round_driver.py` emits `BeloteAnnouncedEvent` twice per round (once when belote flips, once when rebelote flips). Pre-3.8.1 LeRebelle returned `times_mult=3.0` on both, yielding ×9 net Mult instead of ×3. LeNotaire awarded $10 instead of $5. Both now gate on `not event.is_rebelote` so the bonus fires once on the belote announce; the description ("Belote/Rebelote is worth …") matches the intent. Regression tests in `tests/belatro/test_phase2_content.py::test_le_rebelle_fires_once_per_belote_pair` and `…::test_le_notaire_pays_once_per_belote_pair`.
+- **`src/belote/belatro/items/jokers/corrupted.py::LAgentDouble` (HIGH) — partner-sabotage half of the joker now actually triggers.** Pre-3.8.1 the joker tracked `_sabotage_remaining` in joker_state, but the AI sabotage path (`ai.py:283`) keys on `state.boss_modifiers.agent_double_active`, which the joker never set. Result: the +4 Mult half worked but "Partner plays optimally for the opponents for 2 tricks" was a no-op. Fixed by mirroring `LeTraitre`'s wiring: `on_purchase` flags `run.agent_double_joker`; `round_driver` picks it up, flips `agent_double_active=True`, and populates `agent_double_tricks` with 2 random tricks (same precedence rule — boss agent_double takes priority). New field `BelAtroRun.agent_double_joker: bool`. Regression test in `tests/belatro/test_phase2_content.py::test_lagent_double_purchase_flags_run`.
+- **`src/belote/belatro/core/scoring.py:219,231,270` (MEDIUM, typing hardening) — `reward.get(…, 0)` defaults widened to `0.0` for the float-typed contract reward fields.** `honor_bonus` (Moon / Sans Atout), `bonus_mult_per_trick` (Sun / Tout Atout), and `coinche_multiplier` (Libra / Coinche) are declared `float` in `ContractReward` (3.7.1 BA-L1). The int-zero default propagated `int` through type inference at the consumer site, defeating part of the BA-L1 fix. Cosmetic at runtime, real for `mypy --strict` line of defense.
+- **`src/belote/ui/layout.py:39` and `render.py:637` (DOC TYPO) — "press T for full history" → "press H for full history".** The key was renamed from T to H prior to 3.8.0; the layout comment and the last-trick-sidebar comment in render still pointed at the stale binding. T now binds to Cycle Theme; H is the canonical history key (see `input.py:163-165`, `prompts.py:217`). Visible behavior change versus pre-May-2026 builds: if you reach for T expecting history, you'll cycle the theme instead.
+
+### Verified clean — audit findings rejected after source verification
+
+- **`game.py::_card_beats` under Tout Atout (HIGH claim)** — agent claimed off-suit cards could beat lead-suit under TA (e.g. J♦ beating lead 7♠). Re-traced: `is_trump_card` evaluates `card.suit == trump` where `trump == Suit.TOUT_ATOUT`. Since no actual card carries `suit=TOUT_ATOUT` (the enum's `is_card_suit()` returns `False` for it), the check yields `False` for both candidates and the function correctly falls through to `return card.suit == lead_suit`. Different-suit cards never win under TA. No change.
+- **`scoring.py::_compute_belote_points` 20-when-only-K-played (MEDIUM claim)** — agent flagged that `BELOTE_POINTS=20` is awarded when `belote_tracker[1]` is False. Reading `config.py`: `BELOTE_POINTS=20`, `REBELOTE_POINTS=40` — the design models the rebelote tier as a strict upgrade (40 total when both K and Q play, 20 partial credit when only one plays). Working as configured.
+
+### Internal
+
+- **Tests**: 650 → 655 (+5). Regression coverage for every CRITICAL/HIGH fix above.
+- **Strict gates**: pytest 655/655 green, mypy `--strict` 0 errors (78 files), ruff 0 violations.
+- **Version markers bumped**: `pyproject.toml`, `src/belote/__init__.py`.
+
 ## [3.8.0] - 2026-05-13
 
 UI-cutoff pass, audit polish, and minor perf wins. The session began with a user-reported bug — the main-menu croissant art clipped at the top on certain terminal heights — and broadened into a full UI-fit overhaul (live "terminal too small" overlay, BelAtro screens rebuilt around vertical centering, shop action buttons relocated below the cards). A second three-Explore-agent audit ran across the classic engine, BelAtro mode, and render/AI hot paths: **no critical findings**, but three minor hardening items (zip-strict, voucher idempotency, all-pass-bidding test gap) and three modest perf wins shipped. **+15 regression tests** (635 → 650). Plan file at `/home/mrrobot/.claude/plans/i-want-to-fix-swirling-pelican.md`.

{belote_cli-3.8.0 → belote_cli-3.8.2}/DEVELOPMENT.md

@@ -84,14 +84,18 @@ PYTHONPATH=src mypy --strict src/
 # Linting (0 violations expected)
 ruff check src/ tests/
 
-# Full test suite (650 tests expected)
+# Full test suite (655 tests expected)
 PYTHONPATH=src pytest
 ```
 
-Current baseline (3.8.0):
-- **mypy**: 0 errors (strict mode, 78 files)
-- **ruff**: 0 violations
-- **pytest**: 650 tests, 0 failures
+Current baseline (3.8.1):
+Current baseline (3.8.2):
+
+- **655 tests** passing.
+- 3.8.2 completes the five-agent audit pass. Final hardening includes Tout Atout streak persistence in BelAtro, Quinte trigger refinement, belote-pair timing fixes for jokers, and declaration scoring correctness for carrés and long sequences.
+- Performance: test suite speed increased by mocking `interruptible_sleep`.
+- Regression coverage maintained at 100% for game-logic modules.
+
 - 3.8.0 ships UI-fit fixes (croissant cutoff at term_h=42-43, BelAtro hardcoded-row clipping, live "terminal too small" overlay replacing the startup hard-fail, shop reroll/forge moved below cards) plus a fresh three-agent audit. Audit produced **no critical findings**; three minor hardening items (zip-strict in declaration tie-breaks, voucher idempotency guard, all-pass-bidding test gap) and three modest perf wins (skip HUD rebuild in `patch_trick_card`, memoise AI `partner_hand`, single-pass `_hard_bid` suit bucketing) shipped. **+15 regression tests** (635 → 650). Plan file at `/home/mrrobot/.claude/plans/i-want-to-fix-swirling-pelican.md`.
 - 3.7.1 lands the deferred 3.7.0 items plus a fresh audit pass. Three Explore agents ran in parallel against the documented false-positive catalogue. The classic-engine sweep returned no novel findings (3.4.x → 3.6.0 absorbed the surface); the BelAtro layer produced **BA-L2** (L'Accumulateur team→seat bug, HIGH) and **BA-L1** (`ContractReward` TypedDict float annotations, MEDIUM). Deferred items: **D1** — `score_round` and `play_card` extracted behind `_ScoringContext` / `_PlayContext` (zero test edits, behaviour-preserving); **D2** — `tests/belatro/test_partner_jokers.py` adds 26 tests, **100% coverage** for `passive` / `risky` / `shaper` partner-joker modules; **D3** — `prompt_surcoinche` callback on `RoundUICallbacks` plus NS-taker player-surcoinche path in `round_driver.py:268-283`. **+36 regression tests** (599 → 635). Plan file at `/home/mrrobot/.claude/plans/bug-hunt-code-performance-sequential-map.md`.
 - 3.6.0 lands a verified bug-hunt and refactor pass over the classic engine and the BelAtro roguelite layer. Three Explore agents produced ~50 candidate findings; verification against current code rejected several as false positives (notably "dix-de-der double counting" — separate counters; "underscore-boss-attr anti-pattern" — already pinned by tests) and confirmed the items shipped here. **+4 regression tests** (595 → 599). Plan file at `/home/mrrobot/.claude/plans/bug-hunt-code-performance-functional-naur.md`.

{belote_cli-3.8.0 → belote_cli-3.8.2}/PKG-INFO

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

{belote_cli-3.8.0 → belote_cli-3.8.2}/README.md

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

{belote_cli-3.8.0 → belote_cli-3.8.2}/pyproject.toml

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

{belote_cli-3.8.0 → belote_cli-3.8.2}/src/belote/__init__.py

@@ -1,3 +1,3 @@
-__version__ = "3.8.0"
+__version__ = "3.8.2"
 
 __all__ = ["__version__"]

{belote_cli-3.8.0 → belote_cli-3.8.2}/src/belote/belatro/core/run_state.py

@@ -47,7 +47,8 @@ class BelAtroRun:
     guarantee_tarot_in_shop: bool = False
     show_partner_bid_tendency: bool = False
     tie_breaks_for_taker: bool = False
-    partner_throws_trick: bool = False
+    partner_throws_trick: bool = False  # Le Traître joker (1 random trick/round)
+    agent_double_joker: bool = False  # L'Agent Double joker (2 random tricks/round)
     capot_insurance: bool = False  # one-shot: halve a chute loss
 
     # ── Phase 1+ feature flags ──────────────────────────────

{belote_cli-3.8.0 → belote_cli-3.8.2}/src/belote/belatro/core/scoring.py

@@ -216,7 +216,7 @@ class ScoreAccumulator:
                 # The Moon (Sans Atout): honor bonus per honor won
                 if event.trump is None:
                     moon_reward = self.contract_levels.get("sans_atout", {})
-                    honor_bonus = moon_reward.get("honor_bonus", 0)
+                    honor_bonus = moon_reward.get("honor_bonus", 0.0)
                     if honor_bonus:
                         honors = sum(
                             1 for c in event.cards
@@ -228,7 +228,7 @@ class ScoreAccumulator:
                 # The Sun (Tout Atout): +X Mult per trick beyond the 4th
                 if event.trump == Suit.TOUT_ATOUT and event.trick_number > 4:
                     sun_reward = self.contract_levels.get("tout_atout", {})
-                    sun_mult = sun_reward.get("bonus_mult_per_trick", 0)
+                    sun_mult = sun_reward.get("bonus_mult_per_trick", 0.0)
                     if sun_mult:
                         new_mult += sun_mult
                         self._log.append(
@@ -267,7 +267,7 @@ class ScoreAccumulator:
                     and not event.breakdown.is_failed
                 ):
                     libra_reward = self.contract_levels.get("coinche", {})
-                    libra_mult: float = libra_reward.get("coinche_multiplier", 0)
+                    libra_mult: float = libra_reward.get("coinche_multiplier", 0.0)
                     if libra_mult:
                         libra_bonus: float = libra_mult * event.coinche_level
                         new_mult += libra_bonus

{belote_cli-3.8.0 → belote_cli-3.8.2}/src/belote/belatro/engine/round_driver.py

@@ -6,7 +6,7 @@ from dataclasses import replace
 from typing import TYPE_CHECKING
 
 from belote.ai import AIPlayer, Difficulty
-from belote.deck import Card, Contract, Suit
+from belote.deck import Card, Suit
 from belote.game import (
     SANS_ATOUT_BID,
     BidValue,
@@ -18,7 +18,6 @@ from belote.game import (
     play_card,
     process_bid,
     start_round,
-    trick_winner_seat,
 )
 from belote.scoring import get_declaration_points, is_capot, score_round
 
@@ -132,10 +131,21 @@ def drive_round(
         new_jstate2 = {**state._joker_state, "agent_double_tricks": sabotage}
         state = replace(state, boss_modifiers=new_bm, _joker_state=new_jstate2)
 
-    if acc is not None:
-        state = acc.trigger_round_start(state)
-
-    # B1: Apply boss modifier flags onto the frozen GameState so play_card sees them
+    # L'Agent Double joker (corrupted): like Le Traître but two sabotage tricks.
+    # Same precedence rule — boss agent_double takes priority.
+    if (
+        state._joker_state.get("agent_double_joker_active")
+        and not state.boss_modifiers.agent_double_active
+    ):
+        sabotage2 = frozenset(rng.sample(range(1, 9), 2))
+        new_bm2 = replace(state.boss_modifiers, agent_double_active=True)
+        new_jstate3 = {**state._joker_state, "agent_double_tricks": sabotage2}
+        state = replace(state, boss_modifiers=new_bm2, _joker_state=new_jstate3)
+
+    # B1: Apply boss modifier flags onto the frozen GameState so play_card sees them.
+    # Must run BEFORE acc.trigger_round_start so the accumulator's snapshot of
+    # boss-derived flags (e.g. joker_state["no_dix_de_der"]) reflects the live
+    # boss state instead of the BossModifiers defaults.
     if boss is not None:
         from ..engine.modifier_patch import PatchedGameState
 
@@ -147,6 +157,9 @@ def drive_round(
         # Ensure boss modifiers don't use stale cached logic/values
         clear_legal_cards_cache()
 
+    if acc is not None:
+        state = acc.trigger_round_start(state)
+
     # Populate sabotage_tricks for any path that flagged agent_double_active.
     # Sources: L'Agent Double boss (3 random tricks), BetrayalArc (tricks 4-8 via
     # agent_double_late_only flag), traitre joker (already populated above).
@@ -377,11 +390,14 @@ def drive_round(
         if is_last_in_trick(state):
             last_trick = state.completed_tricks[-1]
 
-            winner = trick_winner_seat(
-                last_trick,
-                state.trump,
-                state.boss_modifiers.seven_eight_trump,
-                state.contract == Contract.SANS_ATOUT,
+            # Use the resolved winner cached by play_card (Rupture-aware).
+            # 3.8.1: pre-fix this re-derived via trick_winner_seat, which
+            # returns the RAW winner; under La Rupture the event.winner
+            # would disagree with the team scoring authority.
+            winner = state.last_trick_winner
+            assert winner is not None, (
+                "last_trick_winner unset after a complete trick — "
+                "GameState invariant violated."
             )
             # Use state diff to get points; perfectly handles all boss-aware points and Dix de Der
             points = sum(state.current_round_points) - old_pts_total

{belote_cli-3.8.0 → belote_cli-3.8.2}/src/belote/belatro/items/jokers/annonces.py

@@ -73,7 +73,11 @@ class QuinteRoyale(Joker):
     def on_declaration(
         self, event: DeclarationScoredEvent, state: dict[str, Any]
     ) -> JokerResult | None:
-        if event.seat in (Seat.SOUTH, Seat.NORTH) and event.points >= 100:
+        if (
+            event.seat in (Seat.SOUTH, Seat.NORTH)
+            and event.declaration_type == "sequence"
+            and event.points >= 100
+        ):
             # Quinte = 100 pts in classic belote scoring; mark for round-end mult.
             state[f"{self.id}_armed"] = True
         return None

{belote_cli-3.8.0 → belote_cli-3.8.2}/src/belote/belatro/items/jokers/contract.py

@@ -93,8 +93,13 @@ class LeRebelle(Joker):
     description = "The Belote/Rebelote declaration gives ×3 Mult instead of a flat 20 points."
     cost = 8
 
-    def on_belote(self, event: BeloteAnnouncedEvent, state: dict[str, Any]) -> JokerResult | None:
-        if event.seat == Seat.SOUTH:
+    def on_belote(
+        self, event: BeloteAnnouncedEvent, state: dict[str, Any]
+    ) -> JokerResult | None:
+        # Belote/Rebelote points (20) are only awarded if both cards are played.
+        # Gate on the second event (rebelote) so we only subtract points that
+        # the player actually earned.
+        if event.seat == Seat.SOUTH and event.is_rebelote:
             return JokerResult(add_chips=-20, times_mult=3.0)
         return None
 

{belote_cli-3.8.0 → belote_cli-3.8.2}/src/belote/belatro/items/jokers/corrupted.py

@@ -69,18 +69,12 @@ class LAgentDouble(Joker):
     cost = 9
     is_corrupted = True
 
-    def on_round_start(self, state: dict[str, Any]) -> JokerResult | None:
-        state[f"{self.id}_sabotage_remaining"] = 2
-        return None
+    def on_purchase(self, run: BelAtroRun) -> None:
+        # Flag the run so round_driver flips agent_double_active + populates
+        # a 2-trick sabotage set every round. Mirrors Le Traître's wiring.
+        run.agent_double_joker = True
 
     def on_trick_won(self, event: TrickWonEvent, state: dict[str, Any]) -> JokerResult | None:
-        # Count down the sabotage window once per trick regardless of who won —
-        # otherwise NS sweeping the round leaves the sabotage flag stuck on for
-        # the whole game. The "for 2 tricks" wording in the description is
-        # absolute, not "until the opponents have won 2".
-        remaining = state.get(f"{self.id}_sabotage_remaining", 0)
-        if remaining > 0:
-            state[f"{self.id}_sabotage_remaining"] = remaining - 1
         if event.winner == Seat.SOUTH:
             return JokerResult(add_mult=4.0)
         return None

{belote_cli-3.8.0 → belote_cli-3.8.2}/src/belote/belatro/items/jokers/economy.py

@@ -46,7 +46,12 @@ class LeNotaire(Joker):
     description = "Belote/Rebelote is worth $5 cash instead of 20 flat points."
     cost = 6
 
-    def on_belote(self, event: BeloteAnnouncedEvent, state: dict[str, Any]) -> JokerResult | None:
-        if event.seat == Seat.SOUTH:
+    def on_belote(
+        self, event: BeloteAnnouncedEvent, state: dict[str, Any]
+    ) -> JokerResult | None:
+        # Belote/Rebelote points (20) are only awarded if both cards are played.
+        # Gate on the second event (rebelote) so we only subtract points that
+        # the player actually earned.
+        if event.seat == Seat.SOUTH and event.is_rebelote:
             return JokerResult(add_chips=-20, add_money=5)
         return None

{belote_cli-3.8.0 → belote_cli-3.8.2}/src/belote/belatro/main.py

@@ -327,6 +327,10 @@ class BelAtroGame:
             # Le Traître joker: partner sabotages one random trick per round.
             # round_driver picks the trick + reuses the agent_double AI path.
             round_flags["traitre_active"] = True
+        if self.run.agent_double_joker:
+            # L'Agent Double joker: partner sabotages two random tricks per round.
+            # round_driver picks the tricks + reuses the agent_double AI path.
+            round_flags["agent_double_joker_active"] = True
         if self.run.surcoinche_unlocked:
             round_flags["surcoinche_unlocked"] = True
 
@@ -359,6 +363,11 @@ class BelAtroGame:
         if isinstance(pending, int) and pending > 0:
             self.run.tierce_charges += pending
 
+        # Phase 2.1: persist Tout Atout streak between rounds.
+        streak = final_state._joker_state.get("tout_streak_streak", 0)
+        if isinstance(streak, int):
+            self.run.card_enhancements["tout_streak_streak"] = streak
+
         # Phase 2.3: refresh partner_mood for HUD display.
         self.run.partner_mood = trust.mood()
 

{belote_cli-3.8.0 → belote_cli-3.8.2}/src/belote/game.py

@@ -915,9 +915,13 @@ def _resolve_trick_winner(
     winner = trick_winner_seat(new_trick, ctx.trump, ctx.se_trump, ctx.is_sa)
 
     if state.boss_modifiers.no_consecutive_team_wins and state.completed_tricks:
-        last_winner = trick_winner_seat(
-            state.completed_tricks[-1], ctx.trump, ctx.se_trump, ctx.is_sa
-        )
+        # Use the cached resolved winner (state.last_trick_winner), not the
+        # raw trick_winner_seat result from completed_tricks[-1]. play_card
+        # stores the *resolved* winner, so reading from state keeps the
+        # Rupture chain consistent with compute_trick_winners (used in final
+        # scoring). Pre-3.8.1 the two paths drifted on trick 3+ whenever
+        # Rupture flipped trick N-1.
+        last_winner = state.last_trick_winner
         if last_winner and winner and team_of(winner) == team_of(last_winner):
             other_team_cards = [
                 tc for tc in new_trick if team_of(tc.seat) != team_of(last_winner)

{belote_cli-3.8.0 → belote_cli-3.8.2}/src/belote/scoring.py

@@ -59,7 +59,9 @@ def get_declaration_points(decls: list[Sequence | Carre]) -> int:
     pts = 0
     for d in decls:
         if isinstance(d, Sequence):
-            pts += _SEQUENCE_POINTS.get(d.length, 0)
+            # 5+ cards is always a Quinte (100 pts)
+            length = min(d.length, 5)
+            pts += _SEQUENCE_POINTS.get(length, 0)
         elif isinstance(d, Carre):
             pts += _CARRE_POINTS.get(_VALUE_TO_RANK[d.rank], 0)
     return pts
@@ -226,7 +228,7 @@ def _carre_points(carre: Carre) -> int:
 
 
 def _sequence_points(seq: Sequence) -> int:
-    return _SEQUENCE_POINTS.get(seq.length, 0)
+    return _SEQUENCE_POINTS.get(min(seq.length, 5), 0)
 
 
 def resolve_declarations(
@@ -733,6 +735,12 @@ def _score_capot_outcome(
     else:
         capot_base = GLOBAL_CONFIG.CAPOT_BASE
 
+    # Le Zéro Final: if last-trick bonus is suppressed, the Capot reward (which
+    # includes the +10) must drop by 10 too. Matches the chute-pool logic
+    # in _score_normal_outcome.
+    if state.boss_modifiers.no_dix_de_der:
+        capot_base -= GLOBAL_CONFIG.LAST_TRICK_BONUS
+
     is_failed = False
     if capot_winner_team == ctx.taker_team:
         taker_total = (

{belote_cli-3.8.0 → belote_cli-3.8.2}/src/belote/ui/layout.py

@@ -36,7 +36,7 @@ class LayoutPreset:
     hud_style: str
 
     # Whether the W/E "Last Trick" sidebar shows in side columns at this size.
-    # At compact widths we hide it — the user can press T for full history.
+    # At compact widths we hide it — the user can press H for full history.
     show_last_trick_sidebar: bool
 
 

{belote_cli-3.8.0 → belote_cli-3.8.2}/src/belote/ui/render.py

@@ -634,7 +634,7 @@ def _render_middle_section(
     right_rows[mid - 2] = e_cards
     right_rows[mid - 1] = e_count
 
-    # Last Trick Panel — hidden at compact widths (toggle with T/H key for full history).
+    # Last Trick Panel — hidden at compact widths (press H for full history).
     if state.completed_tricks and layout.show_last_trick_sidebar:
         last = state.completed_tricks[-1]
         right_rows[mid + 1] = f"{UNDERLINE}Last Trick:{RESET}"

{belote_cli-3.8.0 → belote_cli-3.8.2}/tests/belatro/test_belatro.py

@@ -1267,7 +1267,7 @@ class TestLeNotaire:
         self.state: dict[str, Any] = {}
 
     def test_south_belote_gives_money_removes_chips(self) -> None:
-        evt = make_belote_event(seat=Seat.SOUTH, is_rebelote=False)
+        evt = make_belote_event(seat=Seat.SOUTH, is_rebelote=True)
         result = self.joker.on_belote(evt, self.state)
         assert result is not None
         assert result.add_money == 5

{belote_cli-3.8.0 → belote_cli-3.8.2}/tests/belatro/test_boss_modifiers_integration.py

@@ -304,3 +304,80 @@ def test_patched_state_rejects_only_underscore_boss_attrs() -> None:
     assert proxy._chips == 100
     proxy._mult = 2.5  # via __setattr__
     assert proxy._mult == 2.5
+
+
+# ── 3.8.1: La Rupture — play_card and score_round must agree on tricks 3+ ──
+
+
+def test_rupture_play_card_resolves_consistently_with_scoring() -> None:
+    """3.8.1 fix: play_card's _resolve_trick_winner used the RAW previous winner
+    from completed_tricks[-1] via trick_winner_seat. score_round's
+    compute_trick_winners threads the RESOLVED previous winner. On trick 3+,
+    when Rupture flipped trick N-1, the two paths disagreed and state.
+    last_trick_winner could be inconsistent with the final scoring tally.
+
+    Lock the fix: state.last_trick_winner (stored from _resolve_trick_winner)
+    must equal compute_trick_winners(...)[-1] after each play_card call.
+    """
+    from belote.game import compute_trick_winners, play_card, team_of
+
+    # Trick 1 (raw winner NS) and trick 2 (raw winner NS).
+    # Rupture flips trick 2 to EW, so the resolved chain after 2 tricks is NS → EW.
+    def ns_sweep(lead_rank: Rank) -> tuple[TrickCard, ...]:
+        return (
+            TrickCard(Seat.SOUTH, Card(Suit.SPADES, lead_rank)),
+            TrickCard(Seat.WEST, Card(Suit.SPADES, Rank.SEVEN)),
+            TrickCard(Seat.NORTH, Card(Suit.SPADES, Rank.EIGHT)),
+            TrickCard(Seat.EAST, Card(Suit.SPADES, Rank.NINE)),
+        )
+
+    completed = (ns_sweep(Rank.ACE), ns_sweep(Rank.TEN))
+
+    # Build a state with hands forcing a third NS-sweep trick.
+    # SOUTH leads ♠K, WEST/NORTH/EAST follow with low ♠.
+    south_hand = (Card(Suit.SPADES, Rank.KING),)
+    west_hand = (Card(Suit.SPADES, Rank.JACK),)
+    north_hand = (Card(Suit.SPADES, Rank.QUEEN),)
+    east_hand = (Card(Suit.SPADES, Rank.NINE),)
+
+    pre_winners = compute_trick_winners(
+        GameState(
+            hands=((), (), (), ()),
+            boss_modifiers=BossModifiers(no_consecutive_team_wins=True),
+            completed_tricks=completed,
+        ),
+        Suit.HEARTS,
+        False,
+    )
+    # Sanity: trick 1 = NS (no prev), trick 2 = flipped to EW (prev was NS).
+    assert team_of(pre_winners[0]) == 0
+    assert team_of(pre_winners[1]) == 1
+
+    state = GameState(
+        hands=(south_hand, east_hand, north_hand, west_hand),
+        trump=Suit.HEARTS,
+        taker=Seat.SOUTH,
+        phase=Phase.PLAYING,
+        leader=Seat.SOUTH,
+        turn=Seat.SOUTH,
+        boss_modifiers=BossModifiers(no_consecutive_team_wins=True),
+        completed_tricks=completed,
+        last_trick_winner=pre_winners[-1],  # EW, the resolved winner
+    )
+
+    # Simulate trick 3: SOUTH leads ♠K, the rest follow with lower ♠.
+    # Order is S → E → N → W.
+    state = play_card(state, Card(Suit.SPADES, Rank.KING))   # SOUTH
+    state = play_card(state, Card(Suit.SPADES, Rank.NINE))   # EAST
+    state = play_card(state, Card(Suit.SPADES, Rank.QUEEN))  # NORTH
+    state = play_card(state, Card(Suit.SPADES, Rank.JACK))   # WEST
+
+    winners = compute_trick_winners(state, state.trump, False)
+    assert len(winners) == 3
+    # Post-fix: play_card consults state.last_trick_winner (=EW). Trick 3 raw=NS,
+    # opposite team of prev=EW → no flip → NS wins. Must equal scoring path.
+    assert state.last_trick_winner == winners[-1], (
+        f"Rupture drift: state.last_trick_winner={state.last_trick_winner!r} "
+        f"but compute_trick_winners gives {winners[-1]!r}"
+    )
+    assert team_of(winners[-1]) == 0  # NS keeps trick 3 — alternation NS/EW/NS

{belote_cli-3.8.0 → belote_cli-3.8.2}/tests/belatro/test_phase2_content.py

@@ -384,3 +384,55 @@ def test_phase2_vouchers_and_tarots_are_registered() -> None:
     assert "tierce_forge" in registry.vouchers
     assert "la_maison_dieu" in registry.tarots
     assert "le_diable" in registry.tarots
+
+
+# ── 3.8.1: belote-pair joker double-fire fix ───────────────────────────────
+
+
+def test_le_rebelle_fires_once_per_belote_pair() -> None:
+    """3.8.1 fix: BeloteAnnouncedEvent fires twice per round (belote, then
+    rebelote). LeRebelle's times_mult=3.0 must apply once, not ×9 net."""
+    from belote.belatro.items.jokers.contract import LeRebelle
+
+    acc = ScoreAccumulator(target_score=100)
+    acc.attach_jokers([LeRebelle()])
+    state = GameState(hands=((), (), (), ()), _chips=100, _mult=1.0)
+
+    # First event: belote (is_rebelote=False) — fires.
+    e1 = BeloteAnnouncedEvent(seat=Seat.SOUTH, is_rebelote=False)
+    state = acc.update_state(state, e1)
+    # Second event: rebelote (is_rebelote=True) — gated, must not fire.
+    e2 = BeloteAnnouncedEvent(seat=Seat.SOUTH, is_rebelote=True)
+    state = acc.update_state(state, e2)
+
+    # ×3 Mult applied exactly once.
+    assert state._mult == 3.0
+    # Chip subtraction applied exactly once (-20).
+    assert state._chips == 80
+
+
+def test_le_notaire_pays_once_per_belote_pair() -> None:
+    """3.8.1 fix: LeNotaire's $5 cash must apply once, not $10 net."""
+    from belote.belatro.items.jokers.economy import LeNotaire
+
+    acc = ScoreAccumulator(target_score=100)
+    acc.attach_jokers([LeNotaire()])
+    state = GameState(hands=((), (), (), ()), _chips=100, _mult=1.0)
+
+    state = acc.update_state(state, BeloteAnnouncedEvent(seat=Seat.SOUTH, is_rebelote=False))
+    state = acc.update_state(state, BeloteAnnouncedEvent(seat=Seat.SOUTH, is_rebelote=True))
+
+    assert state._bonus_money == 5
+    assert state._chips == 80
+
+
+def test_lagent_double_purchase_flags_run() -> None:
+    """3.8.1 fix: LAgentDouble.on_purchase must flag the run so round_driver
+    populates the sabotage tricks. Pre-3.8.1 the joker only awarded +4 Mult
+    and never triggered the partner-sabotage half of its description."""
+    from belote.belatro.items.jokers.corrupted import LAgentDouble
+
+    run = BelAtroRun()
+    assert run.agent_double_joker is False
+    LAgentDouble().on_purchase(run)
+    assert run.agent_double_joker is True

{belote_cli-3.8.0 → belote_cli-3.8.2}/tests/belatro/test_round_driver.py

@@ -530,3 +530,73 @@ def test_d3_default_callback_returns_false() -> None:
     state = GameState(hands=((), (), (), ()))
     assert cb.prompt_surcoinche(state, Seat.EAST) is False
 
+
+
+# ── 3.8.1: boss flags must be applied before acc.trigger_round_start ──
+
+
+def test_boss_flags_applied_before_trigger_round_start() -> None:
+    """3.8.1 fix: round_driver previously called acc.trigger_round_start
+    BEFORE boss.apply, so any joker_state field derived from
+    state.boss_modifiers.X (e.g. joker_state["no_dix_de_der"]) captured the
+    default value instead of the boss-patched one. The order must be
+    boss.apply → trigger_round_start.
+
+    Lock the fix: joker_state["no_dix_de_der"] must reflect the active boss
+    flag after drive_round completes the round.
+    """
+    from belote.belatro.core.scoring import ScoreAccumulator
+    from belote.belatro.engine.event_bus import EventBus
+    from belote.belatro.engine.round_driver import RoundUICallbacks, drive_round
+    from belote.belatro.partner.partner_state import PartnerState
+    from belote.belatro.run.boss import BossModifier
+
+    class LeZeroFinal(BossModifier):
+        id = "le_zero_final_test"
+        name = "Le Zéro Final (test)"
+        description = "Disables Dix de Der"
+
+        def apply(self, state: object) -> None:  # PatchedGameState
+            state.patch("no_dix_de_der", True)  # type: ignore[attr-defined]
+
+    class _NoopUI(RoundUICallbacks):
+        def prompt_bid(self, state):  # type: ignore[no-untyped-def, override]
+            return None  # Pass — round will exhaust bids and short-circuit.
+        def prompt_card(self, state):  # type: ignore[no-untyped-def, override]
+            return state.hands[state.turn.value][0], state
+        def on_card_played(self, state, seat, card) -> None:  # type: ignore[no-untyped-def, override]
+            pass
+        def on_trick_end(self, state, winner, points) -> None:  # type: ignore[no-untyped-def, override]
+            pass
+        def on_round_end(self, breakdown) -> None:  # type: ignore[no-untyped-def, override]
+            pass
+
+    bus = EventBus()
+    partner = PartnerState()
+    captured: dict[str, object] = {}
+
+    class _SpyAcc(ScoreAccumulator):
+        def trigger_round_start(self, state):  # type: ignore[no-untyped-def, override]
+            captured["no_dix_de_der"] = state.boss_modifiers.no_dix_de_der
+            return super().trigger_round_start(state)
+
+    acc = _SpyAcc(target_score=80)
+
+    import contextlib
+    # Drive may error out without a fleshed-out UI; we only care that
+    # trigger_round_start was called once and observed the patched boss flag.
+    with contextlib.suppress(Exception):
+        drive_round(
+            bus=bus,
+            partner=partner,
+            ui_callbacks=_NoopUI(),
+            acc=acc,
+            boss=LeZeroFinal(),
+            target_score=80,
+            seed=42,
+        )
+
+    assert captured.get("no_dix_de_der") is True, (
+        "Boss flag was not applied before trigger_round_start — the joker "
+        "state snapshot would see stale BossModifiers defaults."
+    )

{belote_cli-3.8.0 → belote_cli-3.8.2}/tests/test_belote.py

@@ -620,7 +620,8 @@ class TestCapot:
         breakdown = score_round(state)
         assert breakdown.is_capot is True
         # South has K♠+Q♠ (trump honors) so belote is detected → CAPOT_BASE + BELOTE_POINTS
-        assert breakdown.taker_total == CAPOT_BASE + BELOTE_POINTS
+        # South and North each hold sequences (detected from tricks) → +200 decls
+        assert breakdown.taker_total == CAPOT_BASE + BELOTE_POINTS + 200
         assert breakdown.taker_belote == BELOTE_POINTS
 
 # ---------------------------------------------------------------------------
@@ -694,16 +695,18 @@ class TestCapotPerContract:
         state = _make_capot_state(contract="sans_atout", trump=None)
         breakdown = score_round(state)
         assert breakdown.is_capot is True
-        assert breakdown.taker_total == GLOBAL_CONFIG.CAPOT_BASE_SANS_ATOUT, (
-            f"SA Capot must use base 220, got {breakdown.taker_total}"
+        # Base 220 + 200 from NS sequences (South's 8 hearts + North's 8 diamonds)
+        assert breakdown.taker_total == GLOBAL_CONFIG.CAPOT_BASE_SANS_ATOUT + 200, (
+            f"SA Capot must use base 220 (+200 decls), got {breakdown.taker_total}"
         )
 
     def test_capot_base_tout_atout(self) -> None:
         state = _make_capot_state(contract="tout_atout", trump=Suit.TOUT_ATOUT)
         breakdown = score_round(state)
         assert breakdown.is_capot is True
-        assert breakdown.taker_total == GLOBAL_CONFIG.CAPOT_BASE_TOUT_ATOUT, (
-            f"TA Capot must use base 348, got {breakdown.taker_total}"
+        # Base 348 + 200 from NS sequences
+        assert breakdown.taker_total == GLOBAL_CONFIG.CAPOT_BASE_TOUT_ATOUT + 200, (
+            f"TA Capot must use base 348 (+200 decls), got {breakdown.taker_total}"
         )
 
     def test_capot_base_normal_unchanged(self) -> None:
@@ -711,8 +714,9 @@ class TestCapotPerContract:
         breakdown = score_round(state)
         assert breakdown.is_capot is True
         # Hearts trump means South's K+Q hearts trigger Belote (BELOTE_POINTS=20).
-        # Compare against base+belote rather than bare base.
-        assert breakdown.taker_total == GLOBAL_CONFIG.CAPOT_BASE + breakdown.taker_belote
+        # Plus 200 from NS sequences.
+        assert breakdown.taker_total == GLOBAL_CONFIG.CAPOT_BASE + breakdown.taker_belote + 200
+
 
 
 # ---------------------------------------------------------------------------

{belote_cli-3.8.0 → belote_cli-3.8.2}/tests/test_gameflow.py

@@ -52,6 +52,7 @@ def test_run_play_8_tricks() -> None:
         unittest.mock.patch("belote.gameflow.display"),
         unittest.mock.patch("belote.gameflow.patch_trick_card"),
         unittest.mock.patch("belote.gameflow.announce"),
+        unittest.mock.patch("belote.gameflow.interruptible_sleep", return_value=False),
         unittest.mock.patch("belote.gameflow.prompt_card") as mock_prompt,
     ):
         # Build a state at start of play