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

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

@@ -5,6 +5,40 @@ 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.9.0] - 2026-05-14
+
+Comprehensive bug-hunt, logic, and performance audit pass. Three parallel Explore agents covered the classic engine (`game.py` / `scoring.py` / `ai.py` / `gameflow.py` / `deck.py`), the BelAtro engine (`round_driver.py` / `modifier_patch.py` / `event_bus.py` / `belatro/core/scoring.py` / `boss.py` / `run_state.py` / `shop.py` / `belatro/main.py`), and the items catalogue + UI hot paths (`registry.py` + every joker / planet / tarot / voucher + `render.py` / `hud.py` / shop UI). Every load-bearing claim was spot-checked against the current code. **One real bug** (LOW), **one feature gap** filled, and a defensive cosmetic cleanup. Performance verdict: no measured hotspot — prior 3.6 / 3.7.1 / 3.8.0 audits already addressed the obvious paths. All 21 boss modifiers, 36 jokers, 8 planets, 12 tarots, 12 vouchers verified wired end-to-end. **+6 regression tests** (655 → 661). Plan file at `/home/mrrobot/.claude/plans/bug-hunt-code-performance-wise-puzzle.md`.
+
+### Fixed
+
+- **`src/belote/belatro/ui/announce.py:98` (LOW) — `BelAtroAnnounce.yes_no()` no longer hangs on `Key.EOF`.** Pre-3.9.0 the prompt loop exited on `Key.ENTER`, `Key.ESC`, `Key.QUIT`, or character `y`/`n`/`o`, but had no `Key.EOF` return path. Two call sites in `belatro/main.py` (the post-Ante-8 endless prompt at line 137 and the player-side surcoinche prompt at line 267) would hang the process on Ctrl-D / piped-empty stdin / closed terminal. Established inconsistency: sibling `banner()` (line 75) and `score_popup()` (line 126) in the same file already handled EOF. Regression test in `tests/test_input_eof.py::test_announce_yes_no_returns_false_on_eof`.
+
+### Added
+
+- **`src/belote/ansi.py` — `NO_COLOR` env-var support** per the [no-color.org](https://no-color.org/) spec. When `NO_COLOR` is set to any non-empty value, `fg()` / `bg()` return the empty string. SGR formatting (`BOLD`, `DIM`, `REVERSE`, `UNDERLINE`, `STRIKETHROUGH`, `RESET`) and cursor/clear sequences are unchanged — they aren't color. Read once at import (mirrors `a11y._ENABLED`); `_refresh_no_color_from_env()` exported for tests. 4 new tests in `tests/test_no_color.py`.
+- **`scripts/benchmark.py::benchmark_belatro_round` (new)** — end-to-end `drive_round` rounds/sec probe under a deterministic seed (mean + p95 + rounds/sec). Regression sentinel for round-driver throughput. New `--smoke` flag runs every benchmark at iterations=2 for a fast CI-friendly check; pinned by `tests/test_benchmark_smoke.py`.
+
+### Changed
+
+- **`src/belote/scoring.py::resolve_declarations` (cosmetic)** — the 4-seat announce-order tuple (clockwise from taker) is now built once in the enclosing function and shared by `_resolve_tie_carre` and `_resolve_tie_seq` via closure. Pre-3.9.0 each helper rebuilt the same tuple inline. Behavior-preserving; the regression guard is the existing `tests/test_declaration_tiebreak.py` suite.
+- **`scripts/benchmark.py` cleanup** — auto-fixed 17 long-standing ruff issues (W293/W291/I001/F401) in the file as part of the enhancement-pass scope.
+
+### Audit verdict — verified clean, no fix needed
+
+- **Classic engine** (game.py / scoring.py / ai.py / gameflow.py / deck.py): all 19 game mechanics wired end-to-end (bidding pass/normal/TA/SA/coinche/surcoinche, trump-play follow/trump/overtrump/partner-master exception, declarations + tie-break, belote/rebelote, contract-aware Capot 220/348/252, Dix-de-der, litige, taker-failed redistribution). AI memoization (`processed_tricks_count` / `last_voids_key` / `last_partner_hand_key`) resets correctly on both new-round and undo paths.
+- **BelAtro engine**: all 21 boss modifiers patch → state → read end-to-end; no `boss.id == "…"` string branching anywhere; event bus correctly round-scoped; `ScoreAccumulator.update_state` already coalesces into one `replace()` per event; voucher idempotency guard live; endless mode (×2.2) scaling correct.
+- **Items + UI**: all 36 jokers' `on_event` signatures match bus dispatch; team-not-seat convention applied correctly (jokers checking "did our team win" use `team_of(event.winner) == 0`, partner jokers deliberately key on `Seat.NORTH`). Theme cache invalidates on theme change; `_card_face` and `visible_len` both `lru_cache(4096)` with proper invalidation; HUD opt-in rebuild via `force_hud=False` since 3.8.0. Shop layout: card frame 16 cells, gap 2→1→0 degradation works.
+
+### Performance verdict
+
+No measured hotspot. `dataclasses.replace()` on the frozen `GameState` runs ~256 calls/round at sub-µs each — well under the 1 ms/round budget. Joker triggers linear-scan over ≤ 5 jokers (max slots). The "enhancement plan" here is the regression sentinel (`benchmark_belatro_round`), not a speculative rewrite.
+
+### Internal
+
+- **Tests**: 655 → 661 (+6). yes_no EOF ×1, NO_COLOR ×4, benchmark smoke ×1.
+- **Strict gates**: pytest 661/661 green, mypy `--strict` 0 errors (77 files), ruff 0 violations.
+- **Version markers bumped**: `pyproject.toml`, `src/belote/__init__.py`.
+
 ## [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.

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

@@ -84,14 +84,17 @@ PYTHONPATH=src mypy --strict src/
 # Linting (0 violations expected)
 ruff check src/ tests/
 
-# Full test suite (655 tests expected)
+# Full test suite (661 tests expected)
 PYTHONPATH=src pytest
 ```
 
-Current baseline (3.8.1):
-Current baseline (3.8.2):
+Current baseline (3.9.0):
+
+- **661 tests** passing (3.8.2 had 655; +6 in 3.9.0: yes_no EOF, NO_COLOR ×4, benchmark smoke).
+- 3.9.0 ships a clean three-agent audit pass (classic engine / BelAtro engine / items+UI). Confirmed bugs: one (LOW) — `BelAtroAnnounce.yes_no()` hung on `Key.EOF`, fixed in `src/belote/belatro/ui/announce.py:98`. New feature: `NO_COLOR` env-var support in `src/belote/ansi.py`. Cosmetic: deduped seat-order computation in `scoring.py` tie-break helpers. Tooling: `scripts/benchmark.py` gains an end-to-end `drive_round` rounds/sec probe and a `--smoke` flag pinned by `tests/test_benchmark_smoke.py`. Performance verdict: no measured hotspot — prior L1/L2/L3/D-pass audits already addressed the obvious paths. All 21 boss modifiers, 36 jokers, 8 planets, 12 tarots, 12 vouchers wired end-to-end. Plan file at `/home/mrrobot/.claude/plans/bug-hunt-code-performance-wise-puzzle.md`.
+
+Past baselines:
 
-- **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.
@@ -162,6 +165,10 @@ once at startup; toggling mid-run has no effect.
   `~/.local/share/belote/ghosts/<label>-<seed>.json`. The file is written
   once when the run ends. Useful for sharing or replaying interesting
   runs. Backed by `src/belote/belatro/ghost_run.py`.
+- `NO_COLOR=<any-non-empty>` — suppress truecolor SGR escapes from
+  `fg()` / `bg()` per the [no-color.org](https://no-color.org/) spec.
+  Bold/dim/underline/reverse/strikethrough and cursor sequences remain
+  (they aren't color). Added in 3.9.0. Backed by `src/belote/ansi.py`.
 
 ## Releasing a New Version
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: belote-cli
-Version: 3.8.2
+Version: 3.9.0
 Summary: A 4-player terminal card game
 Project-URL: Homepage, https://github.com/ElysiumDisc/belote
 Project-URL: Repository, https://github.com/ElysiumDisc/belote
@@ -215,7 +215,7 @@ belote --difficulty hard --target 500 --seed 123 --speed fast
 - **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.
 - **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`).
+- **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", contract-aware **Capot** (252 normal / 220 Sans Atout / 348 Tout Atout), 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`).
 - **Rules & History Viewer:** A scrollable, bilingual (English/French) in-game reference for the game's heritage and mechanics.
 
 ## AI
@@ -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 (655 tests)
+├── tests/             # Comprehensive test suite (661 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 **655 tests** passing with 100% coverage on game-logic modules (3.8.2).
+Currently **661 tests** passing with 100% coverage on game-logic modules (3.9.0).
 
 ## Technical Integrity
 
 The codebase is strictly validated with the following tools:
 - **mypy**: 0 errors (strict type safety)
 - **ruff**: 0 violations (linting & formatting)
-- **pytest**: 655/655 passed
+- **pytest**: 661/661 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.2 → belote_cli-3.9.0}/README.md

@@ -172,7 +172,7 @@ belote --difficulty hard --target 500 --seed 123 --speed fast
 - **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.
 - **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`).
+- **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", contract-aware **Capot** (252 normal / 220 Sans Atout / 348 Tout Atout), 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`).
 - **Rules & History Viewer:** A scrollable, bilingual (English/French) in-game reference for the game's heritage and mechanics.
 
 ## AI
@@ -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 (655 tests)
+├── tests/             # Comprehensive test suite (661 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 **655 tests** passing with 100% coverage on game-logic modules (3.8.2).
+Currently **661 tests** passing with 100% coverage on game-logic modules (3.9.0).
 
 ## Technical Integrity
 
 The codebase is strictly validated with the following tools:
 - **mypy**: 0 errors (strict type safety)
 - **ruff**: 0 violations (linting & formatting)
-- **pytest**: 655/655 passed
+- **pytest**: 661/661 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.2 → belote_cli-3.9.0}/pyproject.toml

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

{belote_cli-3.8.2 → belote_cli-3.9.0}/scripts/benchmark.py

@@ -68,17 +68,16 @@ def benchmark_ai(difficulty: Difficulty, iterations: int = 50) -> float:
 
 def benchmark_belatro_bus(num_jokers: int = 5, iterations: int = 1000) -> float:
     from belote.belatro.core.scoring import ScoreAccumulator
-    from belote.belatro.engine.event_bus import EventBus, TrickWonEvent
+    from belote.belatro.engine.event_bus import TrickWonEvent
     from belote.belatro.items.jokers.contract import LeDiplomate
     from belote.deck import Card, Rank
-    from belote.game import GameState
 
     print(f"Benchmarking BelAtro State Update ({num_jokers} Jokers) over {iterations} iterations...")
 
     jokers = [LeDiplomate() for _ in range(num_jokers)]
     acc = ScoreAccumulator()
     acc.attach_jokers(jokers)
-    
+
     state = new_game()
     event = TrickWonEvent(
         winner=Seat.SOUTH,
@@ -102,28 +101,28 @@ def benchmark_belatro_bus(num_jokers: int = 5, iterations: int = 1000) -> float:
 
 
 def benchmark_scoring(iterations: int = 1000) -> float:
-    from belote.scoring import score_round
     from belote.deck import Card, Rank
-    from belote.game import TrickCard, Phase, replace
-    
+    from belote.game import Phase, TrickCard, replace
+    from belote.scoring import score_round
+
     print(f"Benchmarking score_round() over {iterations} iterations...")
-    
+
     state = new_game()
     state = replace(
-        state, 
-        phase=Phase.SCORING, 
-        trump=Suit.SPADES, 
+        state,
+        phase=Phase.SCORING,
+        trump=Suit.SPADES,
         taker=Seat.SOUTH,
         completed_tricks=tuple([(TrickCard(Seat.SOUTH, Card(Suit.SPADES, Rank.ACE)),) * 4] * 8),
         last_trick_winner=Seat.SOUTH
     )
-    
+
     times = []
     for _ in range(iterations):
         start = time.perf_counter()
         _ = score_round(state)
         times.append(time.perf_counter() - start)
-        
+
     avg = statistics.mean(times) * 1000
     print(f"  Scoring Time: {avg:.3f}ms")
     return avg
@@ -132,23 +131,23 @@ def benchmark_scoring(iterations: int = 1000) -> float:
 def benchmark_deal(iterations: int = 1000) -> float:
     from belote.game import start_round
     print(f"Benchmarking start_round() (deal) over {iterations} iterations...")
-    
+
     state = new_game()
     rng = random.Random(42)
-    
+
     times = []
     for _ in range(iterations):
         start = time.perf_counter()
         _ = start_round(state, rng)
         times.append(time.perf_counter() - start)
-        
+
     avg = statistics.mean(times) * 1000
     print(f"  Deal Time: {avg:.3f}ms")
     return avg
 
 
 def benchmark_legal_cards(iterations: int = 1000) -> float:
-    from belote.game import legal_cards, clear_legal_cards_cache, replace
+    from belote.game import clear_legal_cards_cache, legal_cards, replace
     print(f"Benchmarking legal_cards() (cache cleared per call) over {iterations} iterations...")
 
     state = new_game()
@@ -173,7 +172,7 @@ def benchmark_legal_cards_cached(iterations: int = 1000) -> float:
     `benchmark_legal_cards` above invalidates every iteration and so reflects
     worst-case-only time.
     """
-    from belote.game import legal_cards, clear_legal_cards_cache, replace
+    from belote.game import clear_legal_cards_cache, legal_cards, replace
     print(f"Benchmarking legal_cards() (warm cache) over {iterations} iterations...")
 
     state = new_game()
@@ -198,8 +197,8 @@ def benchmark_trick_scoring(iterations: int = 1000) -> float:
     (HUD running total) and again from `scoring.py::_calculate_base_points`
     (final round score). One of the hottest functions in a played round.
     """
-    from belote.game import TrickCard, replace
     from belote.deck import Card, Rank
+    from belote.game import TrickCard, replace
     from belote.scoring import trick_card_points
 
     print(f"Benchmarking trick_card_points() over {iterations} iterations...")
@@ -249,6 +248,55 @@ def benchmark_ai_legality_filter(iterations: int = 500) -> float:
     return avg
 
 
+def benchmark_belatro_round(rounds: int = 30, seed: int = 42) -> float:
+    """End-to-end BelAtro round throughput under a deterministic seed.
+
+    Drives a full round (bid → 8 tricks → score) headlessly via the same
+    round_driver path the game uses, with AI on every seat. The seed is
+    threaded into drive_round so the per-round work is reproducible — a
+    regression sentinel, not a wall-clock target.
+    """
+    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.deck import Card
+    from belote.game import GameState, legal_cards
+
+    class _HeadlessUI(RoundUICallbacks):
+        def prompt_bid(self, state: GameState) -> Suit | None:
+            return None  # pass; AI seats may take
+
+        def prompt_card(self, state: GameState) -> tuple[Card, GameState]:
+            return legal_cards(state, Seat.SOUTH)[0], state
+
+        def on_card_played(self, state: GameState, seat: Seat, card: Card) -> None:
+            pass
+
+        def on_trick_end(self, state: GameState, winner: Seat, points: int) -> None:
+            pass
+
+        def on_round_end(self, breakdown: object) -> None:
+            pass
+
+    print(f"Benchmarking drive_round() E2E over {rounds} rounds (seed={seed})...")
+
+    times = []
+    for i in range(rounds):
+        bus = EventBus()
+        partner = PartnerState()
+        acc = ScoreAccumulator()
+        start = time.perf_counter()
+        drive_round(bus=bus, partner=partner, ui_callbacks=_HeadlessUI(), acc=acc, seed=seed + i)
+        times.append(time.perf_counter() - start)
+
+    mean = statistics.mean(times) * 1000
+    p95 = sorted(times)[int(len(times) * 0.95) - 1] * 1000 if len(times) > 1 else mean
+    rps = 1.0 / statistics.mean(times) if times else 0.0
+    print(f"  E2E Round Time: mean {mean:.2f}ms, p95 {p95:.2f}ms ({rps:.1f} rounds/sec)")
+    return mean
+
+
 def run_benchmarks() -> None:
     print("=== Belote-CLI Performance Benchmark ===")
     benchmark_render()
@@ -265,9 +313,29 @@ def run_benchmarks() -> None:
     benchmark_legal_cards_cached()
     benchmark_trick_scoring()
     benchmark_ai_legality_filter()
+    print()
+    benchmark_belatro_round()
     print("========================================")
 
 
+def run_smoke() -> None:
+    """Tiny smoke pass: every benchmark runs once at minimum iteration count.
+    Used by the test suite to keep the script from rotting.
+    """
+    benchmark_render(iterations=2)
+    benchmark_ai(Difficulty.EASY, iterations=2)
+    benchmark_belatro_bus(iterations=2)
+    benchmark_scoring(iterations=2)
+    benchmark_deal(iterations=2)
+    benchmark_legal_cards(iterations=2)
+    benchmark_legal_cards_cached(iterations=2)
+    benchmark_trick_scoring(iterations=2)
+    benchmark_ai_legality_filter(iterations=2)
+    benchmark_belatro_round(rounds=2)
+
 
 if __name__ == "__main__":
-    run_benchmarks()
+    if "--smoke" in sys.argv:
+        run_smoke()
+    else:
+        run_benchmarks()

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

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

{belote_cli-3.8.2 → belote_cli-3.9.0}/src/belote/ansi.py

@@ -1,10 +1,26 @@
 from __future__ import annotations
 
+import os
 import re
 from functools import lru_cache
 
 from .themes import Theme, theme_manager
 
+# Respect https://no-color.org/. Read once at import; tests use
+# _refresh_no_color_from_env() after monkeypatch.setenv. Only color escapes
+# are suppressed; SGR formatting (BOLD/DIM/etc.) and cursor sequences remain,
+# per the spec.
+_NO_COLOR: bool = bool(os.environ.get("NO_COLOR", ""))
+
+
+def _refresh_no_color_from_env() -> None:
+    global _NO_COLOR
+    _NO_COLOR = bool(os.environ.get("NO_COLOR", ""))
+
+
+def no_color_active() -> bool:
+    return _NO_COLOR
+
 # ── Theme cache ────────────────────────────────────────────────────────────
 # Each color flavor (felt_bg, red_fg, etc.) is hit dozens of times per render.
 # Pre-3.0.0 each call walked into theme_manager.get_current() (a dict lookup);
@@ -58,15 +74,27 @@ def ansi_ljust(s: str, width: int) -> str:
 
 
 @lru_cache(maxsize=512)
-def fg(r: int, g: int, b: int) -> str:
+def _fg_seq(r: int, g: int, b: int) -> str:
     return f"\x1b[38;2;{r};{g};{b}m"
 
 
 @lru_cache(maxsize=512)
-def bg(r: int, g: int, b: int) -> str:
+def _bg_seq(r: int, g: int, b: int) -> str:
     return f"\x1b[48;2;{r};{g};{b}m"
 
 
+def fg(r: int, g: int, b: int) -> str:
+    if _NO_COLOR:
+        return ""
+    return _fg_seq(r, g, b)
+
+
+def bg(r: int, g: int, b: int) -> str:
+    if _NO_COLOR:
+        return ""
+    return _bg_seq(r, g, b)
+
+
 BOLD = "\x1b[1m"
 DIM = "\x1b[2m"
 REVERSE = "\x1b[7m"

{belote_cli-3.8.2 → belote_cli-3.9.0}/src/belote/belatro/ui/announce.py

@@ -78,7 +78,7 @@ class BelAtroAnnounce:
 
     @staticmethod
     def yes_no(prompt: str, reader: KeyReader) -> bool:
-        """Centered Y/N prompt. Returns True on Y/Enter, False on N/Esc/Q.
+        """Centered Y/N prompt. Returns True on Y/Enter, False on N/Esc/Q/EOF.
 
         Repaints in-place — no scroll on alt-screen-strict terminals. Used by
         the post-Ante-8 endless-mode offer.
@@ -95,7 +95,7 @@ class BelAtroAnnounce:
             event = reader.read()
             if event.key in (Key.ENTER,):
                 return True
-            if event.key in (Key.ESC, Key.QUIT):
+            if event.key in (Key.ESC, Key.QUIT, Key.EOF):
                 return False
             if event.key == Key.CHAR and event.char:
                 ch = event.char.lower()

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

@@ -288,15 +288,21 @@ def resolve_declarations(
     ns_best_carre = _best_carre(ns_carres)
     ew_best_carre = _best_carre(ew_carres)
 
+    # Announce-order walk: clockwise from taker. Used by both tie-break
+    # resolvers below — compute once.
+    seat_order: tuple[Seat, ...] = ()
+    if taker is not None:
+        s1 = taker.next_seat()
+        s2 = s1.next_seat()
+        s3 = s2.next_seat()
+        seat_order = (taker, s1, s2, s3)
+
     def _resolve_tie_carre() -> int | None:
         if taker is None:
             return None  # legacy cancel behaviour
-        # Walk seats in announce order starting at the taker; the first seat
-        # holding a matching-rank carré wins the tie.
         assert ns_best_carre is not None and ew_best_carre is not None
         tied_rank = ns_best_carre.rank
-        order = [taker, taker.next_seat(), taker.next_seat().next_seat(), taker.next_seat().next_seat().next_seat()]
-        for s in order:
+        for s in seat_order:
             for c, cs in zip(ns_carres, ns_carre_seats, strict=True):
                 if cs == s and c.rank == tied_rank:
                     return 0
@@ -310,8 +316,7 @@ def resolve_declarations(
             return None
         assert ns_best_seq is not None and ew_best_seq is not None
         tied_strength = _sequence_strength(ns_best_seq)
-        order = [taker, taker.next_seat(), taker.next_seat().next_seat(), taker.next_seat().next_seat().next_seat()]
-        for s in order:
+        for s in seat_order:
             for seq, ss in zip(ns_seqs, ns_seq_seats, strict=True):
                 if ss == s and _sequence_strength(seq) == tied_strength:
                     return 0

belote_cli-3.9.0/tests/test_benchmark_smoke.py

@@ -0,0 +1,29 @@
+"""Keep scripts/benchmark.py from rotting.
+
+Runs the smoke pass (iterations=2 each) and asserts the script exits cleanly.
+Not a perf gate — just a "does it import + execute end-to-end" guard. Useful
+because the script is referenced from the audit-plan as the canonical
+regression sentinel for round-driver throughput.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+
+def test_benchmark_smoke_runs() -> None:
+    script = Path(__file__).parent.parent / "scripts" / "benchmark.py"
+    result = subprocess.run(
+        [sys.executable, str(script), "--smoke"],
+        capture_output=True,
+        text=True,
+        timeout=120,
+        check=False,
+    )
+    assert result.returncode == 0, (
+        f"benchmark.py --smoke exited {result.returncode}\n"
+        f"stdout:\n{result.stdout}\n"
+        f"stderr:\n{result.stderr}"
+    )

{belote_cli-3.8.2 → belote_cli-3.9.0}/tests/test_input_eof.py

@@ -99,3 +99,17 @@ def test_eof_in_consumables_overlay_returns_false() -> None:
     overlay = ConsumablesOverlay(run, reader)
     assert overlay.open() is False
     assert reader.read.call_count == 1
+
+
+def test_announce_yes_no_returns_false_on_eof() -> None:
+    """BelAtroAnnounce.yes_no must exit on EOF — pre-3.9.0 it spun forever
+    when stdin was closed during the post-Ante-8 or surcoinche prompt.
+
+    Sibling methods banner() and score_popup() in the same file already
+    handle EOF; this test pins the inconsistency closed."""
+    from belote.belatro.ui.announce import BelAtroAnnounce
+
+    reader = MagicMock()
+    reader.read.return_value = KeyEvent(Key.EOF)
+    assert BelAtroAnnounce.yes_no("Continue?", reader) is False
+    assert reader.read.call_count == 1

belote_cli-3.9.0/tests/test_no_color.py

@@ -0,0 +1,62 @@
+"""3.9.0: NO_COLOR env-var support (https://no-color.org/).
+
+When `NO_COLOR` is set to any non-empty value, `fg()` and `bg()` return the
+empty string. SGR formatting (BOLD/DIM/REVERSE/UNDERLINE/STRIKETHROUGH) and
+cursor/clear sequences are not affected — only color, per the spec.
+
+Mirror the `BELOTE_A11Y` test pattern: monkeypatch the env, call
+`_refresh_no_color_from_env()` to re-read the cached flag, restore in teardown
+via the fixture so module state doesn't leak.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+
+import pytest
+
+from belote import ansi
+
+
+@pytest.fixture(autouse=True)
+def _restore_no_color() -> Iterator[None]:
+    """Snapshot _NO_COLOR before each test, restore after — keeps module
+    state from leaking across tests in this file or to the broader suite."""
+    saved = ansi._NO_COLOR
+    yield
+    ansi._NO_COLOR = saved
+
+
+def test_fg_returns_empty_when_no_color_set(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("NO_COLOR", "1")
+    ansi._refresh_no_color_from_env()
+    assert ansi.fg(255, 0, 0) == ""
+    assert ansi.bg(0, 255, 0) == ""
+    assert ansi.no_color_active() is True
+
+
+def test_fg_emits_sgr_when_no_color_unset(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("NO_COLOR", raising=False)
+    ansi._refresh_no_color_from_env()
+    assert ansi.fg(255, 0, 0) == "\x1b[38;2;255;0;0m"
+    assert ansi.bg(0, 255, 0) == "\x1b[48;2;0;255;0m"
+    assert ansi.no_color_active() is False
+
+
+def test_no_color_empty_string_means_unset(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Per the no-color.org spec: NO_COLOR="" is treated as unset."""
+    monkeypatch.setenv("NO_COLOR", "")
+    ansi._refresh_no_color_from_env()
+    assert ansi.no_color_active() is False
+    assert ansi.fg(10, 20, 30) == "\x1b[38;2;10;20;30m"
+
+
+def test_sgr_constants_unaffected_by_no_color() -> None:
+    """BOLD/DIM/REVERSE/UNDERLINE/STRIKETHROUGH are SGR formatting, not color —
+    must remain emittable under NO_COLOR per the spec."""
+    assert ansi.BOLD == "\x1b[1m"
+    assert ansi.DIM == "\x1b[2m"
+    assert ansi.REVERSE == "\x1b[7m"
+    assert ansi.UNDERLINE == "\x1b[4m"
+    assert ansi.STRIKETHROUGH == "\x1b[9m"
+    assert ansi.RESET == "\x1b[0m"