firestarter 3.2.7b1__tar.gz → 3.2.7b2__tar.gz

{firestarter-3.2.7b1/firestarter.egg-info → firestarter-3.2.7b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: firestarter
-Version: 3.2.7b1
+Version: 3.2.7b2
 Summary: EPROM programmer software for the Relatively Universal ROM Programmer
 Author-email: Henrik Olsson <henols@gmail.com>
 Project-URL: Homepage, https://github.com/henols/firestarter_app

{firestarter-3.2.7b1 → firestarter-3.2.7b2}/firestarter/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '3.2.7b1'
-__version_tuple__ = version_tuple = (3, 2, 7, 'b1')
+__version__ = version = '3.2.7b2'
+__version_tuple__ = version_tuple = (3, 2, 7, 'b2')
 
-__commit_id__ = commit_id = 'g0159d48'
+__commit_id__ = commit_id = 'g30e9def'

{firestarter-3.2.7b1 → firestarter-3.2.7b2}/firestarter/cli_handlers.py

@@ -37,6 +37,7 @@ from firestarter.channel import (
     available_boards,
     dev_command_gate_message,
     is_dev_tools_enabled,
+    is_prerelease_build,
 )
 from firestarter.chip_resolver import (
     describe_ambiguity,
@@ -186,6 +187,27 @@ def _complete_eprom(
 _ALL_BOARDS: tuple[str, ...] = ("uno", "uno328pb", "leonardo", "py32f071")
 _BOARD_CHOICES: list[str] = available_boards(_ALL_BOARDS)
 _PY32_ENABLED: bool = "py32f071" in _BOARD_CHOICES
+# A stable build never offers pre-release firmware: `fw --pre` is refused and
+# `fw --list` shows stable releases only. fw_release_gate refuses the install.
+_PRE_CHANNEL_ENABLED: bool = is_prerelease_build()
+
+
+def _reject_gated_option(name: str, given: bool, enabled: bool) -> None:
+    """The one refusal for a CLI option that this build's channel does not offer.
+
+    It reads like Click's own unknown-option error, because on this build the
+    option does not exist.
+    """
+    if given and not enabled:
+        raise click.UsageError(f"no such option: {name}")
+
+
+def _reject_pre_only_option(name: str, given: bool) -> None:
+    """Refuse a pre-release-only CLI option on a stable build.
+
+    Reads `_PRE_CHANNEL_ENABLED` at CALL time, like `_reject_py32_only_option`.
+    """
+    _reject_gated_option(name, given, _PRE_CHANNEL_ENABLED)
 
 
 def _reject_py32_only_option(name: str, given: bool) -> None:
@@ -204,8 +226,7 @@ def _reject_py32_only_option(name: str, given: bool) -> None:
     default -- which is what makes it monkeypatchable while the Click surface
     stays frozen at import time.
     """
-    if given and not _PY32_ENABLED:
-        raise click.UsageError(f"no such option: {name}")
+    _reject_gated_option(name, given, _PY32_ENABLED)
 
 
 def map_typed_errors(f: Callable[..., Any]) -> Callable[..., Any]:
@@ -1764,6 +1785,7 @@ def _maybe_auto_route_to_pre_click(
 @click.option(
     "--pre",
     is_flag=True,
+    hidden=not _PRE_CHANNEL_ENABLED,
     help="Fetch latest pre-release firmware (mirrors pip install --pre).",
 )
 @click.option(
@@ -1772,7 +1794,11 @@ def _maybe_auto_route_to_pre_click(
     type=_FirmwareVersionType(),
     default=None,
     metavar="VERSION",
-    help="Pin exact firmware version (e.g. 3.1.0, 3.1.0b2, 3.1.0rc1).",
+    help=(
+        "Pin exact firmware version (e.g. 3.1.0, 3.1.0b2, 3.1.0rc1)."
+        if _PRE_CHANNEL_ENABLED
+        else "Pin exact firmware version (e.g. 3.1.0)."
+    ),
 )
 @click.option(
     "--stable",
@@ -1861,11 +1887,15 @@ def fw(
 ) -> None:
     """Firmware version.
 
-    ``--pre``, ``--firmware-version`` and ``--stable`` are mutually exclusive;
-    passing more than one is refused before anything is installed.
+    The release channel options are mutually exclusive; passing more than one
+    is refused before anything is installed.
     """
     app: AppContext = ctx.obj
 
+    # Before the mutex check, so a stable build never names --pre in an error
+    # other than this one.
+    _reject_pre_only_option("--pre", pre)
+
     # 3-way --pre / --firmware-version / --stable mutex enforced once,
     # post-parse, with a deterministic error message that doesn't depend on
     # the user's option ordering. Raises click.UsageError → exit-2, matching
@@ -1914,7 +1944,7 @@ def fw(
         channel_filter: Literal["all", "pre", "stable"]
         if pre:
             channel_filter = "pre"
-        elif stable:
+        elif stable or not _PRE_CHANNEL_ENABLED:
             channel_filter = "stable"
         else:
             channel_filter = "all"

{firestarter-3.2.7b1 → firestarter-3.2.7b2}/firestarter/eprom_operations.py

@@ -362,6 +362,20 @@ def _blank_expected_bytes(_offset: int, length: int) -> bytes:
     return b"\xff" * length
 
 
+def _default_read_path(eprom_name: str) -> str:
+    """The output file name `read` uses when the user gives none:
+    `<NAME>.bin`, or `<NAME>-<n>.bin` with the lowest free `n` when that
+    file exists, so a second read never overwrites the first.
+    """
+    base = eprom_name.upper()
+    path = f"{base}.bin"
+    n = 1
+    while os.path.exists(path):
+        path = f"{base}-{n}.bin"
+        n += 1
+    return path
+
+
 def _write_blank_guard_refusal_message(
     eprom_name: str, region_start: int, result: CompareResult
 ) -> str:
@@ -1298,7 +1312,7 @@ class EpromOperator:
             if not cmd_data:
                 return False
 
-            actual_output_file = output_file or f"{eprom_name.upper()}.bin"
+            actual_output_file = output_file or _default_read_path(eprom_name)
             logger.info(
                 f"Reading EPROM {eprom_name.upper()}, saving to {actual_output_file}"
             )

{firestarter-3.2.7b1 → firestarter-3.2.7b2}/firestarter/exceptions.py

@@ -181,6 +181,9 @@ class FirmwareReleaseRefusedError(FirmwareOperationError):
     waives it; `--force` does not, because `--force` means "reinstall the same
     version" and is also a wire flag (FLAG_FORCE).
 
+    Also raised when this CLI is a stable release and the firmware release is a
+    pre-release. Nothing waives that refusal.
+
     A FirmwareOperationError, so cli_handlers.map_typed_errors renders it
     verbatim through the existing FirmwareOperationError arm. No new arm.
     """

{firestarter-3.2.7b1 → firestarter-3.2.7b2}/firestarter/firmware.py

@@ -866,6 +866,9 @@ class FirmwareManager:
         # onto the pre channel, which is the channel most likely to be ahead of
         # it. That raises how often this refusal fires. Do not "fix" the auto
         # route to avoid the refusal -- the refusal is the point.
+        #
+        # The same call refuses a pre-release on a stable CLI. That covers a
+        # library caller that asks a stable CLI for channel="pre".
         if app_version is None:
             # Dereferenced at call time, not bound at import, so a test can
             # monkeypatch firestarter.__version__ without reloading this module.

{firestarter-3.2.7b1 → firestarter-3.2.7b2}/firestarter/fw_release_gate.py

@@ -16,6 +16,11 @@ The rule is the FEATURE version, (major, minor). The patch number is ignored,
 and so is the pre-release suffix: 3.1.0b2 and 3.1.0b5 are one feature version.
 A release is refused when its feature version is ABOVE this CLI's.
 
+A stable CLI also refuses every pre-release firmware. A stable CLI is a final
+PEP 440 release; a pre-release firmware is a b/rc/dev tag. This rule ignores the
+feature version, and nothing waives it: a stable user gets stable firmware only.
+A pre-release CLI (a b/rc tag, or a dev checkout) installs either.
+
 The reverse pairing -- a CLI newer than the firmware -- is NOT gated here.
 `_maybe_auto_route_to_pre` in cli_handlers.py steers channel selection away from
 it. The two checks cover opposite directions and neither replaces the other.
@@ -23,7 +28,7 @@ it. The two checks cover opposite directions and neither replaces the other.
 Polarity: fail closed. A false pass flashes a board this host cannot drive, and
 the board must then be recovered through the bootloader. A false refusal only
 makes the install unavailable, and `firestarter fw --list` still enumerates
-every release. A version that cannot be read on either side is refused exactly
+the releases. A version that cannot be read on either side is refused exactly
 like a version that is too new.
 
 One deliberate exception: a release version of None is NOT a refusal. With no
@@ -31,7 +36,8 @@ release there is nothing to flash, and `manage_firmware_update` already reports
 the failed fetch. Turning a GitHub outage into a version-mismatch refusal would
 be a lie. This is the one place the gate looks fail-open and is not.
 
-Escape: `--allow-newer-firmware`. Never an environment variable.
+Escape for the feature-version refusal: `--allow-newer-firmware`. Never an
+environment variable. The pre-release refusal has no escape.
 
 Unlike the pre-serial gates, the authoritative call runs AFTER the release
 metadata fetch, because the release tag is only known then. It still runs before
@@ -75,6 +81,15 @@ _UNREADABLE_FORMAT = (
     "--allow-newer-firmware. This pairing is not tested."
 )
 
+_PRERELEASE_ON_STABLE_FORMAT = (
+    "Firmware {release} is a pre-release. This CLI is {app}, a stable release. "
+    "A stable CLI installs stable firmware only. "
+    "Refusing to install firmware {release}.\n"
+    "Run 'firestarter fw --install' to install the latest stable firmware.\n"
+    "To use pre-release firmware, install a pre-release CLI. "
+    "Run 'pip install --upgrade --pre firestarter'."
+)
+
 _UNREADABLE_TEXT = "an unreadable version"
 
 
@@ -94,6 +109,20 @@ def feature_version(raw: str | None) -> tuple[int, int] | None:
     return (parsed.major, parsed.minor)
 
 
+def is_prerelease_version(raw: str | None) -> bool | None:
+    """True for a PEP 440 pre-release (b, rc or dev), False for a final release.
+
+    None when the version cannot be read. The caller decides what that means;
+    the feature-version check already refuses an unreadable version.
+    """
+    if not raw:
+        return None
+    try:
+        return Version(raw).is_prerelease
+    except InvalidVersion:
+        return None
+
+
 def is_refused(app_version: str | None, release_version: str | None) -> bool:
     """True when this CLI must not flash this release.
 
@@ -117,9 +146,22 @@ def require_installable_release(
 ) -> None:
     """Raise FirmwareReleaseRefusedError when this CLI must not flash this release.
 
-    Returns None on pass. `allow_newer` waives the refusal; it defaults to False
-    so a library caller that does not ask for the waiver does not get it.
+    Returns None on pass. `allow_newer` waives the feature-version refusal; it
+    defaults to False so a library caller that does not ask for the waiver does
+    not get it. Nothing waives the pre-release refusal on a stable CLI.
+
+    An unreadable version on either side is not judged by the pre-release rule.
+    The feature-version check refuses it.
     """
+    if (
+        is_prerelease_version(app_version) is False
+        and is_prerelease_version(release_version) is True
+    ):
+        raise FirmwareReleaseRefusedError(
+            _PRERELEASE_ON_STABLE_FORMAT.format(
+                app=app_version, release=release_version
+            )
+        )
     if allow_newer or not is_refused(app_version, release_version):
         return
     app = feature_version(app_version)

{firestarter-3.2.7b1 → firestarter-3.2.7b2/firestarter.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: firestarter
-Version: 3.2.7b1
+Version: 3.2.7b2
 Summary: EPROM programmer software for the Relatively Universal ROM Programmer
 Author-email: Henrik Olsson <henols@gmail.com>
 Project-URL: Homepage, https://github.com/henols/firestarter_app

{firestarter-3.2.7b1 → firestarter-3.2.7b2}/firestarter.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "3.2.7b1",
+  "tag": "3.2.7b2",
   "distance": 0,
-  "node": "g0159d48",
+  "node": "g30e9def",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-28"

{firestarter-3.2.7b1 → firestarter-3.2.7b2}/tests/__snapshots__/test_characterization.ambr

@@ -217,8 +217,8 @@
   
     Firmware version.
   
-    ``--pre``, ``--firmware-version`` and ``--stable`` are mutually exclusive;
-    passing more than one is refused before anything is installed.
+    The release channel options are mutually exclusive; passing more than one is
+    refused before anything is installed.
   
   Options:
     -i, --install                   Try to install the latest firmware.
@@ -257,15 +257,12 @@
   
     Firmware version.
   
-    ``--pre``, ``--firmware-version`` and ``--stable`` are mutually exclusive;
-    passing more than one is refused before anything is installed.
+    The release channel options are mutually exclusive; passing more than one is
+    refused before anything is installed.
   
   Options:
     -i, --install                   Try to install the latest firmware.
-    --pre                           Fetch latest pre-release firmware (mirrors
-                                    pip install --pre).
-    --firmware-version VERSION      Pin exact firmware version (e.g. 3.1.0,
-                                    3.1.0b2, 3.1.0rc1).
+    --firmware-version VERSION      Pin exact firmware version (e.g. 3.1.0).
     --stable                        Explicitly select stable channel. With
                                     --list, filters to stable releases only.
     --list                          List available firmware releases for the

{firestarter-3.2.7b1 → firestarter-3.2.7b2}/tests/test_characterization.py

@@ -239,29 +239,36 @@ def _run_fw_help_at_version(version: str) -> str:
     firestarter fw [OPTIONS]` header `run_firestarter()`'s real subprocess
     produces, rather than Click's own default derived from `sys.argv[0]`.
     """
+    stdout, stderr, rc = _run_firestarter_at_version(version, "fw", "--help")
+    assert rc == 0, stderr
+    return stdout
+
+
+def _run_firestarter_at_version(version: str, *args: str) -> tuple[str, str, int]:
+    """Run `firestarter <args>` in a subprocess simulating `version`.
+
+    The mechanism of `_run_fw_help_at_version`, for any arguments. Returns
+    (normalized_stdout, normalized_stderr, exit_code).
+    """
     program = (
-        "import sys, io, contextlib\n"
+        "import sys\n"
         "import firestarter\n"
         f"firestarter.__version__ = {version!r}\n"
         "from firestarter import cli_handlers\n"
-        "buf = io.StringIO()\n"
-        "with contextlib.redirect_stdout(buf):\n"
-        "    try:\n"
-        "        cli_handlers.cli.main(\n"
-        "            args=['fw', '--help'], prog_name='firestarter'\n"
-        "        )\n"
-        "    except SystemExit:\n"
-        "        pass\n"
-        "sys.stdout.write(buf.getvalue())\n"
+        f"cli_handlers.cli.main(args={list(args)!r}, prog_name='firestarter')\n"
     )
     result = subprocess.run(
         [sys.executable, "-c", program],
         capture_output=True,
         text=True,
         timeout=15,
+        env={**os.environ, "FIRESTARTER_CONFIG_DIR": _CLEAN_CONFIG_DIR},
+    )
+    return (
+        normalize_output(result.stdout),
+        normalize_output(result.stderr),
+        result.returncode,
     )
-    assert result.returncode == 0, result.stderr
-    return normalize_output(result.stdout)
 
 
 def test_help_fw(snapshot):
@@ -434,15 +441,25 @@ def test_error_write_missing_args(snapshot):
 
 
 def test_error_fw_pre_stable_mutex(snapshot):
-    """fw --pre --stable → mutually exclusive, exit 2."""
-    stdout, stderr, rc = run_firestarter("fw", "--pre", "--stable")
+    """fw --pre --stable → mutually exclusive, exit 2.
+
+    On a pre-release CLI: a stable CLI refuses --pre itself.
+    """
+    stdout, stderr, rc = _run_firestarter_at_version(
+        "3.0.0b1", "fw", "--pre", "--stable"
+    )
     assert rc == 2
     assert stderr == snapshot
 
 
 def test_error_fw_pre_firmware_version_mutex(snapshot):
-    """fw --pre --firmware-version → mutually exclusive, exit 2."""
-    stdout, stderr, rc = run_firestarter("fw", "--pre", "--firmware-version", "3.0.0")
+    """fw --pre --firmware-version → mutually exclusive, exit 2.
+
+    On a pre-release CLI: a stable CLI refuses --pre itself.
+    """
+    stdout, stderr, rc = _run_firestarter_at_version(
+        "3.0.0b1", "fw", "--pre", "--firmware-version", "3.0.0"
+    )
     assert rc == 2
     assert stderr == snapshot
 

{firestarter-3.2.7b1 → firestarter-3.2.7b2}/tests/test_cli_handlers.py

@@ -1296,6 +1296,13 @@ def test_fw_install_returns_false(runner: CliRunner) -> None:
     assert result.exit_code == 1
 
 
+@pytest.fixture
+def _pre_channel_enabled(monkeypatch: pytest.MonkeyPatch) -> None:
+    """A pre-release build: a stable build refuses --pre before the mutex check."""
+    monkeypatch.setattr(cli_handlers_mod, "_PRE_CHANNEL_ENABLED", True)
+
+
+@pytest.mark.usefixtures("_pre_channel_enabled")
 def test_fw_mutex_pre_and_firmware_version(runner: CliRunner) -> None:
     """TRAP #4 / D-13.4: --pre + --firmware-version exits 2 (mutually exclusive).
 
@@ -1312,6 +1319,7 @@ def test_fw_mutex_pre_and_firmware_version(runner: CliRunner) -> None:
     assert "mutually exclusive" in result.output.lower()
 
 
+@pytest.mark.usefixtures("_pre_channel_enabled")
 def test_fw_mutex_stable_and_pre(runner: CliRunner) -> None:
     """TRAP #4 / D-13.4: --stable + --pre exits 2 (mutually exclusive)."""
     fw_mgr = Mock(spec=FirmwareManager)

{firestarter-3.2.7b1 → firestarter-3.2.7b2}/tests/test_eprom_operations.py

@@ -24,7 +24,7 @@ from unittest.mock import patch
 
 from firestarter.compare import CompareAccumulator
 from firestarter.config import ConfigManager
-from firestarter.eprom_operations import EpromOperator
+from firestarter.eprom_operations import EpromOperator, _default_read_path
 from firestarter.messages import (
     MSG_DATA_CHUNK,
     MSG_END_DONE,
@@ -2729,3 +2729,16 @@ def test_seen_message_ids_records_decoded_ids_and_stays_bounded(
     assert unknown_id not in comm.seen_message_ids
     assert isinstance(comm.seen_message_ids, set)
     assert all(isinstance(i, int) for i in comm.seen_message_ids)
+
+
+def test_default_read_path_adds_lowest_free_suffix(tmp_path, monkeypatch):
+    """`read` with no file name never overwrites an earlier read: the
+    default `<NAME>.bin` gets `-1`, `-2`, ... when that name is taken."""
+    monkeypatch.chdir(tmp_path)
+    assert _default_read_path("w27c512") == "W27C512.bin"
+
+    (tmp_path / "W27C512.bin").write_bytes(b"")
+    assert _default_read_path("w27c512") == "W27C512-1.bin"
+
+    (tmp_path / "W27C512-1.bin").write_bytes(b"")
+    assert _default_read_path("w27c512") == "W27C512-2.bin"

{firestarter-3.2.7b1 → firestarter-3.2.7b2}/tests/test_fw_port_targeting_and_blind_install.py

@@ -229,6 +229,13 @@ def _manager_that_cannot_identify(monkeypatch):
 
 
 class TestBlindInstallRequiresExplicitBoard:
+    @pytest.fixture(autouse=True)
+    def _prerelease_cli(self, monkeypatch):
+        """A pre-release CLI: a stable CLI refuses the pre-release tags below."""
+        import firestarter as _pkg
+
+        monkeypatch.setattr(_pkg, "__version__", "3.0.0b19")
+
     @pytest.mark.parametrize(
         ("install_flag", "flags", "label"),
         [(True, 0, "--install"), (False, FLAG_FORCE, "--force")],

{firestarter-3.2.7b1 → firestarter-3.2.7b2}/tests/test_fw_release_gate.py

@@ -15,7 +15,7 @@ version explicitly or monkeypatches the package attribute, so a release bump
 cannot redden this file.
 """
 
-from unittest.mock import Mock
+from unittest.mock import MagicMock, Mock
 
 import pytest
 from click.testing import CliRunner
@@ -28,9 +28,11 @@ from firestarter.exceptions import (
 )
 from firestarter.firmware import FirmwareManager
 from firestarter.fw_release_gate import (
+    _PRERELEASE_ON_STABLE_FORMAT,
     _REFUSAL_FORMAT,
     _UNREADABLE_FORMAT,
     feature_version,
+    is_prerelease_version,
     is_refused,
     require_installable_release,
 )
@@ -261,3 +263,111 @@ def test_list_still_enumerates_a_too_new_release(
     )
     assert result.exit_code == 0
     assert "3.2.0" in result.output
+
+
+# ---------------------------------------------------------------------------
+# G. A stable CLI refuses every pre-release firmware
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    ("raw", "expected"),
+    [
+        ("3.2.6", False),
+        ("v3.2.6", False),
+        ("3.2.7b1", True),
+        ("3.2.0rc1", True),
+        ("3.2.7.dev3+gabc1234", True),
+        ("not-a-version", None),
+        ("", None),
+        (None, None),
+    ],
+)
+def test_is_prerelease_version(raw, expected) -> None:
+    assert is_prerelease_version(raw) is expected
+
+
+@pytest.mark.parametrize("release_version", ["3.2.7b1", "3.2.0rc1", "3.3.0.dev1"])
+@pytest.mark.parametrize("allow_newer", [False, True])
+def test_stable_cli_refuses_a_prerelease(release_version, allow_newer) -> None:
+    """No waiver: --allow-newer-firmware does not open this refusal."""
+    with pytest.raises(FirmwareReleaseRefusedError) as exc:
+        require_installable_release("3.2.6", release_version, allow_newer=allow_newer)
+    assert str(exc.value) == _PRERELEASE_ON_STABLE_FORMAT.format(
+        app="3.2.6", release=release_version
+    )
+
+
+def test_stable_cli_refuses_an_older_prerelease() -> None:
+    """The rule ignores the feature version: an older pre-release is refused too."""
+    with pytest.raises(FirmwareReleaseRefusedError):
+        require_installable_release("3.2.6", "3.1.0b2")
+
+
+@pytest.mark.parametrize(
+    ("app_version", "release_version"),
+    [
+        ("3.2.6", "3.2.6"),  # stable on stable
+        ("3.2.6", None),  # nothing to flash
+        ("3.2.7b1", "3.2.7b2"),  # pre-release CLI
+        ("3.2.7.dev3+gabc1234", "3.2.7b1"),  # dev checkout
+        ("3.2.7b1", "3.2.6"),  # pre-release CLI, stable firmware
+    ],
+)
+def test_prerelease_rule_passes(app_version, release_version) -> None:
+    require_installable_release(app_version, release_version)
+
+
+def test_stable_cli_unreadable_release_keeps_the_unreadable_refusal() -> None:
+    with pytest.raises(FirmwareReleaseRefusedError) as exc:
+        require_installable_release("3.2.6", "garbage")
+    assert "is a pre-release" not in str(exc.value)
+    assert "not readable" in str(exc.value)
+
+
+def test_pinned_prerelease_on_stable_cli_refuses_before_any_port_or_request(
+    runner, fw_manager, monkeypatch
+) -> None:
+    monkeypatch.setattr(_pkg, "__version__", "3.2.6")
+    result = runner.invoke(
+        cli,
+        ["fw", "--install", "--firmware-version", "3.2.7b1"],
+        obj=make_app_context(firmware_manager=fw_manager),
+    )
+    assert result.exit_code == 1
+    assert "is a pre-release" in result.output
+    fw_manager.check_current_firmware.assert_not_called()
+    fw_manager.manage_firmware_update.assert_not_called()
+
+
+def test_pre_channel_on_stable_library_call_refuses_before_download(
+    monkeypatch,
+) -> None:
+    """A library caller that asks a stable CLI for channel='pre' is refused."""
+    fm = FirmwareManager(config_manager=MagicMock())
+    monkeypatch.setattr(
+        fm,
+        "check_current_firmware",
+        lambda **_kw: ("/dev/ttyACM0", "3.2.6", "uno"),
+    )
+    monkeypatch.setattr(
+        fm,
+        "fetch_release_info",
+        lambda channel="stable", version=None, board="uno": (
+            "3.2.7b1",
+            "https://example.invalid/uno.hex",
+        ),
+    )
+    monkeypatch.setattr(
+        fm, "_download_firmware_file", lambda url: pytest.fail("must not download")
+    )
+    monkeypatch.setattr(
+        fm, "_install_firmware", lambda **kw: pytest.fail("must not flash")
+    )
+    with pytest.raises(FirmwareReleaseRefusedError):
+        fm.manage_firmware_update(
+            install_flag=True,
+            channel="pre",
+            app_version="3.2.6",
+            allow_newer_firmware=True,
+        )

{firestarter-3.2.7b1 → firestarter-3.2.7b2}/tests/test_fw_update_path_gate.py

@@ -203,6 +203,13 @@ class TestWaiverPlumbing:
 class TestUpdateDecisionReachedOnPreCap02Firmware:
     """The end-to-end regression: the update decision must be REACHED."""
 
+    @pytest.fixture(autouse=True)
+    def _prerelease_cli(self, monkeypatch):
+        """A pre-release CLI: a stable CLI refuses the pre-release tags below."""
+        import firestarter as _pkg
+
+        monkeypatch.setattr(_pkg, "__version__", "3.0.0b19")
+
     def test_manage_firmware_update_reaches_the_download_boundary(self, monkeypatch):
         """No identity in the ack, version from the legacy text ack, then install.