belote-cli 2.5.3__tar.gz → 2.7.1__tar.gz

{belote_cli-2.5.3 → belote_cli-2.7.1}/.claude/settings.local.json

@@ -9,7 +9,8 @@
       "Bash(python3 -m pytest tests/ -q --tb=short)",
       "Bash(python3 -m pytest tests/ -q --tb=no)",
       "Bash(python3 -m pytest tests/ -x -q)",
-      "Bash(PYTHONPATH=src python3 *)"
+      "Bash(PYTHONPATH=src python3 *)",
+      "Bash(.venv/bin/python -m mypy src/)"
     ]
   }
 }

belote_cli-2.7.1/.python-version

@@ -0,0 +1 @@
+3.13.5

{belote_cli-2.5.3 → belote_cli-2.7.1}/CHANGELOG.md

@@ -5,6 +5,201 @@ 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).
 
+## [2.7.1] - 2026-05-04
+
+Audit follow-up: cleared the last `getattr(state, "_X", False)` boss-flag reads, removed the now-redundant property aliases on `GameState`, and closed three coverage gaps the v2.7 audit flagged.
+
+### Changed
+
+- **`src/belote/scoring.py`** — replaced 12 `getattr(state, "_kings_zero" / "_seven_eight_trump" / "_separate_scoring" / …, False)` reads with direct `state.boss_modifiers.X` access. mypy can now type-check these branches; renaming a flag will surface as an error instead of silently returning `False`. `_calculate_base_points`, `_apply_scoring_modifiers`, and the 10-de-der branch in `score_round` are all migrated.
+- **`src/belote/game.py`** — deleted the 17 underscore property aliases on `GameState` (`_no_belote` … `_separate_scoring`) that previously delegated to `boss_modifiers.*`. `PatchedGameState` keeps its `__getattr__` fallback so `state.patch("_kings_zero", True)` style boss applications and the existing tests at `tests/belatro/test_belatro.py:1496+` continue to work unchanged.
+
+### Added
+
+- **`tests/belatro/test_phase0_coverage.py::test_boss_dynamic_trump_changes_trump_every_two_tricks`** — plays a full 8-trick round under L'Anarchie and asserts trump rotates after tricks 2/4/6 and stays put after trick 8 (`game.py:752`'s `tricks_count < 8` guard). Pairs with the existing seed-determinism test.
+- **`tests/belatro/test_progression.py`** — five endless-mode tests: 2.2× per-offset target scaling (`ante.py:26`), `advance_blind` ante-8 → endless transition, `run_won` flip when not in endless, and `current_blind` dispatch to `endless_ante()` vs the static `ANTE_TABLE`.
+- **`tests/test_undo.py`** (new file, 3 tests) — pins the gameflow history-stack contract: snapshot/pop equality, `stack_base` round-boundary semantics, and round-to-round isolation. Exercises the rollback logic at `src/belote/gameflow.py:264-299` without booting the interactive input layer.
+
+### Audit claims explicitly rejected
+
+The v2.7 audit also recommended five changes that turned out to be wrong or already done; documenting here so future reviewers don't reopen them:
+
+- `@cached_property` on the 17 boss-flag properties — **infeasible**: `GameState` is `@dataclass(frozen=True, slots=True)`; `cached_property` requires `__dict__`, which `slots=True` removes. Verified locally (`TypeError: No '__dict__' attribute…`).
+- "Stale legal-cards cache when `dynamic_trump` swaps trump mid-round" — **not a bug**: `_calculate_legal_cards_impl` (`game.py:457`) takes `trump` as a key parameter, so trump changes naturally produce a different cache entry.
+- "Phantom card fallback in `ai.py:128`" — **already fixed** (the fallback is `legal = hand`).
+- "Cache key uses `Seat` object directly at `game.py:461`" — **wrong**: parameter is `seat_val: int` and `legal_cards()` passes `seat.value`.
+- `belatro/main.py:248` "f-string consistency" — **bogus**: that line is a literal string with no interpolation.
+
+### Test count
+
+381 → **390** (+9: 1 dynamic-trump, 5 endless, 3 undo).
+
+## [2.7.0] - 2026-05-04
+
+A responsive-layout overhaul: the game now adapts to any terminal between **80×32** (compact) and arbitrarily large (spacious), picking the largest preset that fits and re-detecting on every render so resize-during-play just works.
+
+### Added
+
+- **Layout system** (`src/belote/ui/layout.py` — new): `LayoutPreset` dataclass and three presets (`COMPACT` 80×32 / `STANDARD` 96×38 / `SPACIOUS` 120×48). `choose_layout(cols, rows)` picks the largest fitting preset. Each preset drives card dimensions, side-column widths, HUD verbosity, and whether the W/E "Last Trick" sidebar is shown.
+- **Adaptive card art** in `render.py`: `_card_face_internal` now keys its cache on `(card_w, card_h)`. Standard / spacious render the full Art Nouveau face art; compact (5-row cards) drops to a clean rank-corners-and-suit design that fits the tighter inner area.
+- **Per-tier HUD formatter**: spacious widths get the verbose form (full labels + help hints + theme name on the right). Compact and standard widths get an abbreviated single-line bar (`BELOTE  T:♥  NS:200(+50)  EW:80(+30)  5/8  Tk:S`) — fits cleanly in 80 cols. The previous unconditional ~132-char HUD was already overflowing at 96 cols pre-2.7.
+- **BelAtro HUD compact mode** (`belatro/ui/hud.py`): drops the joker-name list for `J:N/M [J]` placeholder, abbreviates Ante/Blind/Target labels, adds a partner-mood glyph (`✗ · ○ ● ★`).
+- **Vertical centering**: when the terminal is taller than the rendered content, `render()` pads top + bottom equally so the game centres vertically instead of clinging to the top.
+- **Tests** (`tests/test_layout.py`, 20 tests): preset-selection boundaries, fits-minimum gate, card-cache layout separation, HUD verbosity per tier, vertical centering math, trick-mat dimension consistency, KeyReader factory regression.
+
+### Changed
+
+- **Minimum terminal size**: 90×32 → **80×32**. A 1366×768 monitor at default font (~150×40) now uses the compact preset comfortably; the previous 90-col floor cut off the bottom rows on many practical setups.
+- **Layout-aware redraw**: `render()` clears the screen on layout flavour change (`compact` → `standard`, etc.) so a mid-game resize doesn't leak stale artifacts from the previous layout.
+- **`patch_trick_card` and trick-mat row offsets** are now computed from the active layout (`_trick_row_offsets(layout)` returns the seat→row map), instead of being baked-in at standard-preset dimensions.
+- **Alt-screen mode is entered before the menu loop**, not when "Start Game" is picked. Without this, every menu redraw frame wrote to the regular terminal scrollback; on exit the user saw a wall of cup-template frames in their shell history. Game-start and BelAtro-mode entry points now stay in alt-screen and just clear when transitioning.
+
+### Fixed
+
+- **`KeyReader()` constructor regression** introduced in 2.6.0's `input.py` refactor. The `__new__`-based factory returned a `_UnixKeyReader` instance via `cls.__new__(cls)`, which Python treats as "not a `KeyReader` subclass" and therefore skips `__init__`. Result: `_stdin_fd` was never set and `__enter__` crashed with `AttributeError`. Factory now calls the concrete reader as a normal constructor (`_UnixKeyReader()`), so its `__init__` always runs.
+- **"Infinite main menu" cosmetic bug**: the menu's animation loop was redrawing 3× per second outside of alt-screen mode, so each `clear_screen() + redraw` cycle pushed the previous frame into the terminal scrollback. By the time the user quit the menu, their shell history was filled with overlapping cup templates. Fixed by entering alt-screen mode at the start of the `KeyReader` context, not at game-start.
+
+### Migration notes
+
+- Code that imported `CARD_W`, `CARD_H`, `CARD_GAP`, or `SIDE_COL_W` directly from `belote.ui.render` still works — those constants are now derived from the `STANDARD` preset for back-compat. New code should call `belote.ui.layout.choose_layout(cols, rows)` and read dimensions from the returned `LayoutPreset`.
+- The legacy `partner_jokers_double` flag still forces +1 apply for back-compat with tests setting it directly. New partner-joker scaling reads `ScoreAccumulator.partner_tier` (set from `TrustTrack.tier`).
+
+## [2.6.0] - 2026-05-04
+
+A large BelAtro expansion landed in one release: a Phase 0 audit pass plus six feature areas (see `plans/let-do-all-of-radiant-pizza.md`).
+
+### Fixed
+
+**Critical bugs (audit Phase 0.1)**
+
+- `game.py:750` — `random.choice(possible)` for L'Anarchie's `dynamic_trump` boss used the global RNG, ignoring `--seed`. `GameState` now carries a private `_rng: random.Random` field that `start_round` populates from the seeded RNG, and the dynamic-trump branch reads from it. L'Anarchie rounds are now seed-deterministic.
+- `gameflow.py:125–126` — `if not isinstance(card, Card): return "UNDO"` silently coerced every non-Card return value (including `"OVERLAY"` from the info-toggle key) into UNDO, restarting the round when the user pressed `I`. `run_play` now handles `"OVERLAY"` explicitly (re-prompts; classic mode has no overlay UI). Same bug existed in `run_bidding` — pressing `I` during bidding hit `if isinstance(res, str): return None` and quit the game; now also handled explicitly.
+- `scoring.py:616` — chute scoring hardcoded `162` instead of using `GLOBAL_CONFIG.TOTAL_POINTS + GLOBAL_CONFIG.LAST_TRICK_BONUS`. Replaced; tweaks to either config constant now propagate.
+- `scoring.py:319, 326, 628` — `getattr(state, "_seven_eight_trump", False)` silently returned False if the property got renamed. All three sites now read `state.boss_modifiers.seven_eight_trump` directly (matches the boss-flag pattern).
+- `ai.py:110–112` — `current_trick in sabotage_tricks` operated on an `object`-typed value pulled from `_joker_state` (mypy errored), and `trick_rank(c, state.trump)` could be called with `trump=None`. Now reads `state.boss_modifiers.agent_double_active` (consistent with the rest), narrows `sabotage_tricks` to `frozenset[int]`, and guards on `trump is not None`.
+- `input.py:106–109` — UTF-8 multi-byte handler used `n` for the count of *continuation* bytes, then read `n + 1` bytes. Behaviour was correct but naming was misleading; renamed to `continuation_bytes` / `total_bytes`.
+
+**Test suite hygiene (audit Phase 0.2)**
+
+- `tests/test_official_rules.py::test_chute_declaration_transfer` — first scenario's `breakdown` was overwritten before any assertion, making it dead code. Split into two real tests (one for capot+declaration-transfer, one for defender-belote on taker success).
+- `tests/belatro/test_boss_modifiers_integration.py::test_boss_invert_scoring` — body was just `pass`. Now actually tests La Malédiction zeroing the taker's total when NS wins more tricks.
+- Same file — `(TrickCard(...),) * 4` patterns built four-identical-cards tricks (invalid). Helper `_trick_won_by_south` builds proper four-seat tricks instead.
+- `tests/test_belote.py::test_must_trump_when_void_partner_not_winning` actually tested the partner-winning *exception*. Renamed to `test_void_can_discard_when_partner_winning`.
+- `tests/test_belote.py::test_card_points_sum_152` was a duplicate of `test_total_points_consistency`. Dropped.
+- `tests/test_new_coverage.py::test_sort_south_hand_persists_across_plays` never called `play_card`. Renamed to `test_sort_south_hand_orders_trump_first_and_is_idempotent`.
+- `tests/test_properties.py::test_legal_moves_never_empty` silently `break`-ed on empty hands instead of failing. Now asserts the invariant explicitly.
+
+**Lint/types (audit Phase 0.3)**
+
+- `ruff check`: 72 → 0 errors.
+- `mypy --strict`: 15 → 0 errors. Notably refactored `input.py::KeyReader` from a stub-class with runtime `KeyReader = _UnixKeyReader` reassignment to a polymorphic `__new__`-dispatching base, eliminating attribute-error and type-assignment errors and exposing `_restored` / `restore()` cleanly to callers.
+
+### Added
+
+**Phase 0.4 — Coverage backstop** (`tests/belatro/test_phase0_coverage.py`, 13 tests)
+
+Happy-path tests for jokers, partner personalities, and boss modifiers that subsequent Phase 1+ refactors touch: `LeFanatique`, `LeDiplomate`, `LEconome`, `LeFlambeur`, `LeSacrifie`, `LeFantome`, `LeStratege`, `seven_eight_trump`, `dynamic_trump` seed determinism, `no_dix_de_der`, `agent_double_active`, plus a regression guard on `RoundEndEvent` payload.
+
+**Phase 1 — Plumbing foundations** (`tests/belatro/test_phase1_plumbing.py`, 10 tests)
+
+- `Suit.TOUT_ATOUT` is now a real enum value alongside the four card suits, with an `is_card_suit` property and a `CARD_SUITS` tuple. Every `for suit in Suit:` iteration in `game.py`, `ai.py`, and `belatro/partner/personality.py` is gated on `is_card_suit` so cards/decks are never built with TOUT_ATOUT. Under TOUT_ATOUT every card is treated as trump (`card_points` and `trick_rank` updated). `_SUIT_TO_CONTRACT` includes the new suit. `LeFanatique`'s unlock path is re-enabled in `unlocks.py` (was deferred in 2.5.6).
+- Player-facing **coinche / surcoinche**. After bidding, if the taker is on the EW team, `RoundUICallbacks.prompt_coinche` is called; the AI rolls a seeded 30% surcoinche on top. `BidMadeEvent` and `RoundEndEvent` now carry `coinche_level: int` and `contract: str`; jokers and the economy can react to it.
+- `BeloteAnnouncedEvent` is now actually *emitted* in `round_driver` whenever `state.belote_tracker` flips, with `is_rebelote` set correctly. The event class existed since 2.5.x but was never fired.
+- `Rarity` enum on item base (`COMMON / UNCOMMON / RARE / LEGENDARY`); `Joker` gains `fusable: bool = True` for Phase 3 fusion gating. All existing items default to `Rarity.COMMON`.
+- New `BelAtroRun` fields: `tierce_charges`, `legendary_unlocked`, `endless`, `endless_ante_offset`, `ante_theme`, `capot_insurance`, `partner_mood`.
+
+**Phase 2 — Content** (`tests/belatro/test_phase2_content.py`, 20 tests)
+
+- *Contract jokers* (`items/jokers/coinche.py`): `CoincheStack` (+4 Mult/coinche level on win), `ToutStreak` (consecutive Tout-Atout wins ramp Mult by ×0.5/streak; resets on Tout failure).
+- *Annonce jokers* (`items/jokers/annonces.py`): `TierceCharger` (+5 chips and +1 charge per sequence announced), `RebeloteEcho` (×3 Mult on Rebelote play), `QuinteRoyale` (Legendary — quinte arms a ×4 round multiplier).
+- *Vouchers* (`items/vouchers.py`): `CapotInsurance` (one-shot — chute next round survived without run-over), `TierceForge` (placeholder for shop-side charge spending).
+- *Tarots* (`items/tarots.py`): `LaMaisonDieu` (sets `disable_next_boss` flag), `LeDiable` (sets `partner_overcut_round` flag).
+- *Decks* (`run/decks.py`): `marseille` (annonces ×2, no Belote/Rebelote), `coinche` (+50 starting chips, pre-coinched rounds).
+- *Trust as a real second axis* (`partner/trust.py`): `TrustTrack.tier` (0–4 buckets), `TrustTrack.mood()` returning HUD strings. `ScoreAccumulator.partner_tier` replaces the binary `partner_jokers_double` for partner-joker effect scaling — extra applies follow `(0,0,1,1,2)[tier]`. Legacy `partner_jokers_double` still forces +1 apply for back-compat.
+- *Betrayal Arc boss* (`run/boss.py::BetrayalArc`): forces `lock_trust_zero` and `agent_double_active` for the round, registered in `ALL_BOSS_MODIFIERS`.
+- `_play_blind` (`belatro/main.py`) wires Capot Insurance consumption (one-shot halve on chute) and drains pending Tierce charges into `run.tierce_charges`. `run.partner_mood` is refreshed each blind from `trust.mood()`.
+
+**Phase 3 — Meta** (`tests/belatro/test_phase3_meta.py`, 15 tests)
+
+- *Ante themes* (`run/ante_themes.py`): `AnteTheme` base + `CafeAnte` (+25 chips at ante start, +1 trust on blind-1 win, target 5% softer on boss blind) and `TournoiAnte` (always offers coinche, +money per blind win). `roll_theme(rng_value)` picks one with 30% probability.
+- *Endless mode (La Belote Infinie)*: `BelAtroRun.advance_blind` no longer terminates at ante 8 / blind 2 when `run.endless` is True — instead increments `endless_ante_offset` and restarts the blind cycle. `BelAtroRun.enter_endless()` toggles the flag and clears `run_won`. `calculate_target` accepts `endless_offset` for ×2.2-per-loop super-exponential scaling. `BelAtroRun.current_blind` returns dynamically-built `endless_ante` instances when offset > 0.
+- *Joker fusion* (`items/base.py::fuse_jokers`): two jokers → one with rarity bumped one tier (clamped at RARE — never auto-promotes to LEGENDARY), `fusable=False` on the result so fused jokers can't be re-fused, names concatenated. Rejects legendary inputs and `fusable=False` inputs with `FusionError`.
+
+### Changed
+
+- `GameState` gains a private `_rng: random.Random` field (`compare=False, repr=False`) so seeded randomness is reachable mid-play. Existing call sites that don't pass an RNG continue to work — the field defaults to a fresh `random.Random()`.
+- `BidMadeEvent` and `RoundEndEvent` payload extensions (`coinche_level`, `contract`, `trump`).
+- `make_deck()` builds from `CARD_SUITS` instead of `list(Suit)`; `deck.py` exposes `CARD_SUITS` for clean iteration in BelAtro code.
+- Test count: 303 → 361 (+58 across Phase 0.4, Phase 1, Phase 2, and Phase 3 suites).
+
+## [2.5.6] - 2026-05-03
+
+### Fixed
+
+**Critical crashes (BelAtro module)**
+- `belatro/items/tarots.py`: `random` was never imported — `NameError` on any use of `LeJugement`, `LaPretresse`, or `LeFou`.
+- `belatro/core/run_state.py`: `BelAtroRun` had no `consumables` list — `AttributeError` whenever tarots or the shop tried to add a Planet or Tarot to the player's inventory.
+- `belatro/run/shop.py`: `run.consumables` crash removed; the double-append fallback in the overflow branch also removed.
+- `belatro/items/registry.py`: `get_available_jokers(None)` and `get_available_vouchers(None)` crashed with `AttributeError` — both now accept `Profile | None` and treat `None` as "show all non-unlockable items".
+- `belatro/engine/round_driver.py`: `Suit` was referenced in type annotations but never imported — `NameError` on module load.
+- `belatro/progression/save.py`: `stats=data.get("stats", {})` returned an empty dict on profiles missing any stat key, causing `KeyError` when `unlocks.py` accessed `stats["total_capots"]`. Load now merges against the full default dict.
+- `belatro/engine/event_bus.py`: `EventBus.unsubscribe` called `list.remove` unconditionally — `ValueError` if the handler was never subscribed. Now uses `contextlib.suppress(ValueError)`.
+
+**Logic bugs (jokers / progression)**
+- `LaSentinelle` (`hand_comp.py`): detection loop read `state.get("trump")` which is never written to the joker state dict, so it was always `None` and the joker never fired. Fixed to use `event.trump`.
+- `LeFanatique` (`contract.py`): checked `state.get("contract") != "tout"` but `"contract"` was never injected into joker state, so the joker never activated. `ScoreAccumulator` now injects `event.contract` into joker state on every `BidMadeEvent`. Key corrected to `"tout_atout"` to match actual contract identifiers.
+- `sans_atout_wins` stat (`unlocks.py`): incremented on every Sans Atout round regardless of outcome. Now only counts rounds where the NS team declared Sans Atout and succeeded.
+- `LePuriste` (`contract.py`): `getattr(event.breakdown, "is_failed", True)` — wrong default (`True` = assume failed) silently blocked the joker from ever triggering. Default changed to `False`.
+- `LaSentinelleP` (`shaper.py`): fired `trump_led = True` whenever North won any trick containing trump, including when North was *following* suit. `TrickWonEvent` now carries `leader_seat: Seat` (default `Seat.SOUTH` for backwards compatibility); the joker correctly sets the flag only when `leader_seat == Seat.NORTH` and the lead card was trump.
+- `LeBanquier` (`economy.py`): `state.get("target_score", 80)` hardcoded to 80 because the key was never injected. `ScoreAccumulator.trigger_round_start` now writes `target_score` into the joker state dict.
+- `LeDernierMot` (`trick_timing.py`): hard-coded `add_chips=-10` to cancel the Dix de Der bonus regardless of whether the `no_dix_de_der` boss modifier was active. Now reads `state.get("no_dix_de_der", False)` (injected at round start) and only subtracts when the bonus was actually applied.
+
+**Boss modifier enforcement gaps**
+- `LAvocat` (`l_avocat`): `auto_coinche` flag was set on `BossModifiers` but never read. `_play_blind` now doubles `acc.target_score` before the round; if the player wins, the base payout is tripled (2× added on top of `economy.process_round_end`).
+- `LeDivorce` (`le_divorce`): `lock_trust_zero` flag was set but `TrustTrack` was never frozen. Trust is now temporarily set to 0 before `drive_round` (suppressing partner joker doubling and AI difficulty bonuses), restored to its original value after, and all post-round trust updates (`blind_beaten`, `big_margin_win`, `blind_failed`, `chute`, `capot_together`) are skipped.
+- `LAgentDoubleBoss` (`l_agent_double_boss`): `_agent_double_active` caused North to sabotage for all 8 tricks despite the description stating "a random 3 tricks". `round_driver.drive_round` now picks 3 random trick numbers via the round RNG and stores them in `_joker_state["agent_double_tricks"]`; `ai.py` gates the sabotage behavior on the current trick number.
+- `LeBrouillard` (`le_brouillard`): `hide_hud` flag was set but `BelAtroHUD.render` always drew the chips×mult score line. The score row is now skipped when `state.boss_modifiers.hide_hud` is True.
+- `LeFantomePartenaire` (`le_fantome_partenaire`): `hide_partner_hand` flag was set but `show_north` in `_play_blind` was computed only from `run.show_north_hand` and `trust.shares_void_info`. `show_north` is now forced to `False` when this boss is active, overriding both.
+
+**Joker accuracy**
+- `LePuriste` (`contract.py`): `on_round_end` returned a hard-coded `add_money=10` regardless of the actual round payout. It now sets `joker_state["puriste_triggered"] = True` instead; `_play_blind` reads the flag after `economy.process_round_end` and adds an equal extra amount, correctly doubling the base payout.
+
+### Added
+
+**Incomplete features now implemented**
+- `BelAtroRun` new fields: `permanent_chips`, `permanent_mult`, `guarantee_tarot_in_shop`, `show_partner_bid_tendency`, `tie_breaks_for_taker`, `partner_throws_trick`.
+- `Economy.bonus_per_round`: flat per-round cash bonus, incremented by vouchers.
+- `Joker.on_purchase(run)`: lifecycle hook called once at buy time for permanent run-level effects. `Shop._apply_item` now calls it after adding a joker.
+- `Planet.use(run)`: applies `level_up_reward()` into `run.contract_levels`, stacking numerically on repeated use.
+- **Tarot cards**: `LaRoue` (`+1.0 permanent Mult`) and `LaForce` (`+20 permanent chips`) fully implemented.
+- **Vouchers**: `LaTelescope` (`+$1/round via bonus_per_round`), `LeGrimoire` (sets `guarantee_tarot_in_shop`), `LEncyclopedie` (sets `show_partner_bid_tendency`), `LesCartesDorees` (`+1 interest rate, +5 interest cap`), and `LaBalance` (sets `tie_breaks_for_taker`) all implemented.
+- **Corrupted joker negative effects**: `LeTraitre.on_purchase` sets `run.partner_throws_trick = True`; `LeDemon.on_purchase` reduces partner trust by 3; `LAgentDouble` tracks a per-round sabotage window in joker state.
+- **Planet contract bonuses consumed**: `ScoreAccumulator` now applies `contract_levels` rewards during play — per-trick chip bonuses (Saturn), per-trick Mult bonuses (Venus), Jack/9 capture bonuses (Jupiter), honor bonuses in Sans Atout (The Moon), capot chip bonus (Pluto), and round-win money bonus (Mercury).
+- **Permanent Tarot bonuses applied**: `ScoreAccumulator.trigger_round_start` applies `permanent_chips` and `permanent_mult` from the run to the initial `GameState` before the round begins.
+- `ScoreAccumulator` wired in `BelAtroGame._play_blind`: `target_score`, `contract_levels`, `permanent_chips`, and `permanent_mult` are now set from the active run before each blind.
+
+### Changed
+- `TrickWonEvent` gains `leader_seat: Seat = Seat.SOUTH` field. `round_driver.drive_round` populates it from `last_trick[0].seat`. All existing event construction and tests remain compatible via the keyword-argument default.
+- `round_driver.py` import cleanup: removed unused `Rank`, `card_points`, `clear_announced`, and `BeloteAnnouncedEvent`; added the missing `Suit`.
+- `Shop.generate_inventory` respects the `guarantee_tarot_in_shop` flag set by `LeGrimoire`.
+- `LeFou` (tarot) no longer adds a copy of itself to consumables; also respects the consumable slot limit.
+
+## [2.5.5] - 2026-05-03
+
+### Fixed
+- **BelAtro Run Loop**: Fixed multiple critical crashes, including a `TypeError` in `drive_round` due to signature mismatch and an `IndexError` when tricks were accessed prematurely.
+- **Event Bus Integrity**: Fixed `TrickWonEvent` instantiation error by providing missing `trick_number` and `trump` context.
+- **Run State Consistency**: Added missing `consumable_slots` to `BelAtroRun` to prevent crashes when applying certain Vouchers (e.g., Le Couteau).
+- **Cache Clear Bug**: Fixed an `AttributeError` when clearing the legal cards cache by ensuring the implementation function is properly decorated with `@lru_cache`.
+- **Input & HUD**: Fixed the `[I]` key mapping for the score overlay HUD and synchronized the Windows `KeyReader` to support all game-specific keys.
+
+## [2.5.4] - 2026-05-03
+
+### Fixed
+- **Missing read_timeout**: Fixed an `AttributeError` in the main menu by implementing the `read_timeout` method in the `KeyReader` class.
+- **IndentationError in trick_timing.py**: Fixed a critical syntax error in the BelAtro items module.
+- **LePremierSang Logic**: Fixed `LePremierSang` joker to correctly apply +2 Mult (additive) and track its active state.
+
 ## [2.5.3] - 2026-05-03
 
 ### Fixed

{belote_cli-2.5.3 → belote_cli-2.7.1}/DEVELOPMENT.md

@@ -37,6 +37,7 @@ Or via python:
 ```bash
 python -m belote.main
 python -m belote.belatro.main
+PYTHONPATH=src python3 -m belote.main
 ```
 
 ## Testing
@@ -82,7 +83,7 @@ PYTHONPATH=src mypy .
 
 # Linting (0 violations expected)
 ruff check .
-# Full test suite (305 tests expected)
+# Full test suite (390 tests expected)
 PYTHONPATH=src pytest
 
 # ...
@@ -90,7 +91,7 @@ PYTHONPATH=src pytest
 Current baseline:
 - **mypy**: 0 errors (strict mode)
 - **ruff**: 0 violations
-- **pytest**: 305 tests, 0 failures
+- **pytest**: 390 tests, 0 failures
 
 
 ## Benchmarking

{belote_cli-2.5.3 → belote_cli-2.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: belote-cli
-Version: 2.5.3
+Version: 2.7.1
 Summary: A 4-player terminal card game
 Project-URL: Homepage, https://github.com/ElysiumDisc/belote
 Project-URL: Repository, https://github.com/ElysiumDisc/belote
@@ -78,6 +78,10 @@ belatro
 | **Le Carnet** | See partner's full hand every round. +1 Mult each time South wins a trick |
 | La Voûte | Earn $1 interest per $5 held, up to $5/round |
 | La Double Donne | +1 Joker slot |
+| **La Télescope** | +$1 flat bonus after every round |
+| **Le Grimoire** | Shop always stocks at least one Tarot card |
+| **Les Cartes Dorées** | +1 interest rate and +5 interest cap permanently |
+| **La Balance** | Your team wins automatically on a card-point tie |
 | La Surcoinche | Unlocks the Surcoinche contract *(unlockable)* |
 
 ## Showcase
@@ -134,7 +138,7 @@ belatro
 
 - Python >= 3.10
 - No third-party dependencies (stdlib only)
-- Terminal with >= 90 columns x 32 rows
+- Terminal with >= **80 columns × 32 rows** (compact preset). Recommended: 96×38 (standard) or 120×48 (spacious) for the full Art Nouveau card art and verbose HUD. The game auto-selects the best fit and adapts on resize.
 - UTF-8 support (for card symbols: ♠♥♦♣)
 
 ## Quick Start
@@ -187,7 +191,7 @@ belote --difficulty hard --target 500 --seed 123 --speed fast
 
 ## Features
 
-- **BelAtro Roguelite Mode:** A massive expansion featuring 50+ Jokers, 15+ Tarot cards, and permanent upgrades.
+- **BelAtro Roguelite Mode:** A massive expansion featuring 50+ Jokers, 10 Tarot cards, and permanent upgrades.
 - **Collection (Almanac):** Persistent tracker to browse every Joker, Planet, and Voucher you've discovered across your runs.
 - **Full Boss Blind Suite:** All 17 unique bosses implemented, including complex mechanics like *L'Anarchie* (dynamic trump) and *La Rupture* (no consecutive wins).
 - **Multiplier Scoring:** Use items to stack Multipliers and reach scores in the millions.
@@ -200,8 +204,8 @@ belote --difficulty hard --target 500 --seed 123 --speed fast
 - **Main Menu:** Simple single-player entry point with configurable AI difficulty, Target Score, and Speed.
 - **Undo/Redo:** Press `Z` to undo your last move during bidding or play.
 - **Statistics:** unified global tracking of games played, win rates, best rounds, and BelAtro expansion milestones.
-- **Dynamic Adaptive UI:** Menu art and text automatically center based on terminal width.
-- **Alternate Screen Buffer:** BelAtro uses a dedicated terminal buffer for a clean, non-overlapping interface.
+- **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.
@@ -241,7 +245,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 (250+ tests)
+├── tests/             # Comprehensive test suite (390 tests)
 ├── scripts/           # Performance benchmarks
 ├── pyproject.toml      # Build system and dev dependencies (ruff/mypy)
 ├── LICENSE             # MIT License
@@ -257,14 +261,14 @@ belote/
 PYTHONPATH=src pytest
 ```
 
-Currently **305 tests** passing with 100% coverage on core logic.
+Currently **390 tests** passing with 100% coverage on core logic.
 
 ## Technical Integrity
 
 The codebase is strictly validated with the following tools:
 - **mypy**: 0 errors (strict type safety)
 - **ruff**: 0 violations (linting & formatting)
-- **pytest**: 305/305 passed
+- **pytest**: 390/390 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-2.5.3 → belote_cli-2.7.1}/README.md

@@ -35,6 +35,10 @@ belatro
 | **Le Carnet** | See partner's full hand every round. +1 Mult each time South wins a trick |
 | La Voûte | Earn $1 interest per $5 held, up to $5/round |
 | La Double Donne | +1 Joker slot |
+| **La Télescope** | +$1 flat bonus after every round |
+| **Le Grimoire** | Shop always stocks at least one Tarot card |
+| **Les Cartes Dorées** | +1 interest rate and +5 interest cap permanently |
+| **La Balance** | Your team wins automatically on a card-point tie |
 | La Surcoinche | Unlocks the Surcoinche contract *(unlockable)* |
 
 ## Showcase
@@ -91,7 +95,7 @@ belatro
 
 - Python >= 3.10
 - No third-party dependencies (stdlib only)
-- Terminal with >= 90 columns x 32 rows
+- Terminal with >= **80 columns × 32 rows** (compact preset). Recommended: 96×38 (standard) or 120×48 (spacious) for the full Art Nouveau card art and verbose HUD. The game auto-selects the best fit and adapts on resize.
 - UTF-8 support (for card symbols: ♠♥♦♣)
 
 ## Quick Start
@@ -144,7 +148,7 @@ belote --difficulty hard --target 500 --seed 123 --speed fast
 
 ## Features
 
-- **BelAtro Roguelite Mode:** A massive expansion featuring 50+ Jokers, 15+ Tarot cards, and permanent upgrades.
+- **BelAtro Roguelite Mode:** A massive expansion featuring 50+ Jokers, 10 Tarot cards, and permanent upgrades.
 - **Collection (Almanac):** Persistent tracker to browse every Joker, Planet, and Voucher you've discovered across your runs.
 - **Full Boss Blind Suite:** All 17 unique bosses implemented, including complex mechanics like *L'Anarchie* (dynamic trump) and *La Rupture* (no consecutive wins).
 - **Multiplier Scoring:** Use items to stack Multipliers and reach scores in the millions.
@@ -157,8 +161,8 @@ belote --difficulty hard --target 500 --seed 123 --speed fast
 - **Main Menu:** Simple single-player entry point with configurable AI difficulty, Target Score, and Speed.
 - **Undo/Redo:** Press `Z` to undo your last move during bidding or play.
 - **Statistics:** unified global tracking of games played, win rates, best rounds, and BelAtro expansion milestones.
-- **Dynamic Adaptive UI:** Menu art and text automatically center based on terminal width.
-- **Alternate Screen Buffer:** BelAtro uses a dedicated terminal buffer for a clean, non-overlapping interface.
+- **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.
@@ -198,7 +202,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 (250+ tests)
+├── tests/             # Comprehensive test suite (390 tests)
 ├── scripts/           # Performance benchmarks
 ├── pyproject.toml      # Build system and dev dependencies (ruff/mypy)
 ├── LICENSE             # MIT License
@@ -214,14 +218,14 @@ belote/
 PYTHONPATH=src pytest
 ```
 
-Currently **305 tests** passing with 100% coverage on core logic.
+Currently **390 tests** passing with 100% coverage on core logic.
 
 ## Technical Integrity
 
 The codebase is strictly validated with the following tools:
 - **mypy**: 0 errors (strict type safety)
 - **ruff**: 0 violations (linting & formatting)
-- **pytest**: 305/305 passed
+- **pytest**: 390/390 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-2.5.3 → belote_cli-2.7.1}/pyproject.toml

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

{belote_cli-2.5.3 → belote_cli-2.7.1}/src/belote/__init__.py

@@ -1,3 +1,3 @@
-__version__ = "2.4.1"
+__version__ = "2.7.1"
 
 __all__ = ["__version__"]

{belote_cli-2.5.3 → belote_cli-2.7.1}/src/belote/ai.py

@@ -103,12 +103,15 @@ class AIPlayer:
         hand = state.hand_of(self.seat)
         legal = legal_cards(state, self.seat)
 
-        # Boss: L'Agent Double (Partner sabotages)
-        if getattr(state, "_agent_double_active", False) and self.seat == partner(Seat.SOUTH):
-            # For simplicity, if active, partner picks the 'worst' card (lowest score)
-            # Designing it as 'optimal for opponents' usually means discarding honors or ducking.
+        # Boss: L'Agent Double (Partner sabotages on 3 random tricks)
+        if state.boss_modifiers.agent_double_active and self.seat == partner(Seat.SOUTH):
+            current_trick = len(state.completed_tricks) + 1
+            raw_tricks = state._joker_state.get("agent_double_tricks", frozenset())
+            sabotage_tricks: frozenset[int] = (
+                raw_tricks if isinstance(raw_tricks, frozenset) else frozenset()
+            )
             trump = state.trump
-            if trump:
+            if current_trick in sabotage_tricks and trump is not None:
                 return min(legal, key=lambda c: trick_rank(c, trump))
 
         if not hand:
@@ -136,7 +139,7 @@ class AIPlayer:
         """Bid if hand has >= 2 trump honors (J, 9, A) in any suit."""
         honors = {Rank.JACK, Rank.NINE, Rank.ACE}
         for suit in Suit:
-            if suit == exclude:
+            if suit == exclude or not suit.is_card_suit:
                 continue
             count = sum(1 for c in hand if c.suit == suit and c.rank in honors)
             if count >= 2:
@@ -173,7 +176,7 @@ class AIPlayer:
         if state.bidding_round == 2 and state.bidder_index == 3:
             aggression = 1.0
 
-        avail = [s for s in Suit if s != exclude]
+        avail = [s for s in Suit if s != exclude and s.is_card_suit]
         best_suit = max(avail, key=lambda s: suit_scores[s])
         if suit_scores[best_suit] + personality + aggression >= 4:
             return best_suit
@@ -263,7 +266,11 @@ class AIPlayer:
         # 2. Lead from longest non-trump suit (to establish it)
         non_trumps = [c for c in legal if c.suit != trump]
         if non_trumps:
-            suit_counts = {s: sum(1 for c in non_trumps if c.suit == s) for s in Suit if s != trump}
+            suit_counts = {
+                s: sum(1 for c in non_trumps if c.suit == s)
+                for s in Suit
+                if s != trump and s.is_card_suit
+            }
             best_suit = max(suit_counts, key=lambda s: suit_counts[s])
             if suit_counts[best_suit] > 1:
                 suit_cards = [c for c in non_trumps if c.suit == best_suit]
@@ -290,10 +297,11 @@ class AIPlayer:
         self, hand: tuple[Card, ...], state: GameState, exclude: Suit | None = None
     ) -> Suit | None:
         """Monte-Carlo-lite bidding evaluation with personality."""
-        suit_scores: dict[Suit, float] = dict.fromkeys(Suit, 0.0)
+        card_suits = [s for s in Suit if s.is_card_suit]
+        suit_scores: dict[Suit, float] = dict.fromkeys(card_suits, 0.0)
         personality = self._rng.uniform(-0.8, 0.8)
 
-        for suit in Suit:
+        for suit in card_suits:
             trump_cards = [c for c in hand if c.suit == suit]
             honor_count = sum(1 for c in trump_cards if c.rank in (Rank.JACK, Rank.NINE, Rank.ACE))
             point_total = sum(card_points_fn(c, suit) for c in trump_cards)
@@ -306,7 +314,7 @@ class AIPlayer:
             if state.bidding_round == 2 and state.bidder_index >= 2:
                 suit_scores[suit] += 1.5
 
-            for other in Suit:
+            for other in card_suits:
                 if other != suit:
                     other_count = sum(1 for c in hand if c.suit == other)
                     if other_count == 0:
@@ -314,7 +322,7 @@ class AIPlayer:
                     elif other_count == 1:
                         suit_scores[suit] += 1
 
-        avail = [s for s in Suit if s != exclude]
+        avail = [s for s in card_suits if s != exclude]
         best_suit = max(avail, key=lambda s: suit_scores[s])
         if suit_scores[best_suit] + personality >= 6:
             return best_suit

{belote_cli-2.5.3 → belote_cli-2.7.1}/src/belote/belatro/core/economy.py

@@ -10,6 +10,7 @@ class Economy:
     money: int = 0
     interest_rate: int = 0  # default 0, becomes 1 with La Voute voucher
     max_interest: int = 0  # default 0, becomes 5 with La Voute voucher
+    bonus_per_round: int = 0  # flat bonus paid each round end (La Télescope)
 
     def add_money(self, amount: int) -> None:
         self.money += amount
@@ -27,9 +28,9 @@ class Economy:
         return min(interest, self.max_interest)
 
     def process_round_end(self, points_over_target: int) -> int:
-        """Calculate payout: $1 per 10pts over target + interest."""
+        """Calculate payout: $1 per 10pts over target + interest + flat bonus."""
         base_payout = max(0, points_over_target // 10)
         interest = self.calculate_interest()
-        total = base_payout + interest
+        total = base_payout + interest + self.bonus_per_round
         self.add_money(total)
         return total

{belote_cli-2.5.3 → belote_cli-2.7.1}/src/belote/belatro/core/run_state.py

@@ -12,6 +12,7 @@ from ..partner.partner_state import PartnerState
 from .economy import Economy
 
 MAX_JOKER_SLOTS = 5
+DEFAULT_CONSUMABLE_SLOTS = 2
 
 
 @dataclass
@@ -28,7 +29,28 @@ class BelAtroRun:
     # ── Collectibles ───────────────────────────────────────
     jokers: list[Joker] = field(default_factory=list)
     vouchers: list[Voucher] = field(default_factory=list)
+    consumables: list[Any] = field(default_factory=list)  # Tarot/Planet instances
     joker_slots: int = MAX_JOKER_SLOTS
+    consumable_slots: int = DEFAULT_CONSUMABLE_SLOTS
+
+    # ── Permanent run bonuses (from Tarot cards) ───────────
+    permanent_chips: int = 0
+    permanent_mult: float = 1.0
+
+    # ── Voucher flags ───────────────────────────────────────
+    guarantee_tarot_in_shop: bool = False
+    show_partner_bid_tendency: bool = False
+    tie_breaks_for_taker: bool = False
+    partner_throws_trick: bool = False
+    capot_insurance: bool = False  # one-shot: halve a chute loss
+
+    # ── Phase 1+ feature flags ──────────────────────────────
+    tierce_charges: int = 0
+    legendary_unlocked: set[str] = field(default_factory=set)
+    endless: bool = False
+    endless_ante_offset: int = 0
+    ante_theme: str | None = None
+    partner_mood: str = "neutral"
 
     # ── Economy ────────────────────────────────────────────
     economy: Economy = field(default_factory=Economy)
@@ -72,11 +94,23 @@ class BelAtroRun:
                         planet_instance = planet_cls()
                         self.contract_levels[planet_instance.contract_id] = planet_instance.level_up_reward()
 
+            # Phase 2.4 deck mods
+            if deck.deck_modifications.get("start_chips_bonus"):
+                self.permanent_chips += int(deck.deck_modifications["start_chips_bonus"])
+            if deck.deck_modifications.get("start_coinched"):
+                self.card_enhancements["start_coinched"] = True
+            if deck.deck_modifications.get("announce_x2"):
+                self.card_enhancements["announce_x2"] = True
+            if deck.deck_modifications.get("no_belote_rebelote"):
+                self.card_enhancements["no_belote_rebelote"] = True
+
     # ── Current blind target ───────────────────────────────
     @property
     def current_blind(self) -> Ante:
-        from ..run.ante import ANTE_TABLE
+        from ..run.ante import ANTE_TABLE, endless_ante
 
+        if self.endless and self.endless_ante_offset > 0:
+            return endless_ante(self.ante_number, self.blind_index, self.endless_ante_offset)
         return ANTE_TABLE[self.ante_number - 1][self.blind_index]
 
     @property
@@ -86,8 +120,22 @@ class BelAtroRun:
     def advance_blind(self) -> None:
         if self.blind_index < 2:
             self.blind_index += 1
-        elif self.ante_number < 8:
+            return
+        # End of an ante.
+        if self.ante_number < 8:
             self.ante_number += 1
             self.blind_index = 0
-        else:
-            self.run_won = True
+            return
+        # End of ante 8.
+        if self.endless:
+            # Stay at ante 8, increment endless offset, restart blind cycle.
+            self.endless_ante_offset += 1
+            self.blind_index = 0
+            return
+        # Standard run completion.
+        self.run_won = True
+
+    def enter_endless(self) -> None:
+        """Toggle endless mode after beating ante 8."""
+        self.endless = True
+        self.run_won = False  # endless overrides run-won state