homeassistant-ai
diff --git a/‎src/ha_mcp/read_only.py‎
Lines changed: 34 additions & 2 deletions b/‎src/ha_mcp/read_only.py‎
Lines changed: 34 additions & 2 deletions
diff --git a/‎tests/src/doomed_run.py‎
Lines changed: 40 additions & 0 deletions b/‎tests/src/doomed_run.py‎
Lines changed: 40 additions & 0 deletions
diff --git a/‎tests/src/e2e/basic/test_backend_dispatch_smoke.py‎
Lines changed: 2 additions & 2 deletions b/‎tests/src/e2e/basic/test_backend_dispatch_smoke.py‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎tests/src/e2e/conftest.py‎
Lines changed: 31 additions & 0 deletions b/‎tests/src/e2e/conftest.py‎
Lines changed: 31 additions & 0 deletions
diff --git a/‎tests/src/e2e/policy/test_readonly_mode.py‎
Lines changed: 151 additions & 0 deletions b/‎tests/src/e2e/policy/test_readonly_mode.py‎
Lines changed: 151 additions & 0 deletions
diff --git a/‎tests/src/unit/test_doomed_run.py‎
Lines changed: 69 additions & 0 deletions b/‎tests/src/unit/test_doomed_run.py‎
Lines changed: 69 additions & 0 deletions
@@ -131,12 +131,37 @@ def _custom_tool_write(args: dict[str, Any]) -> str | None:
     return "sandbox code execution"
 
 
+def _radio_write(args: dict[str, Any]) -> str | None:
+    action = args.get("action")
+    # Reads (allowed): per-node diagnostics, the integration/network summary,
+    # the active reachability probe, a single Zigbee cluster-attribute read, and
+    # the Thread dataset listing. Everything else is a write — commission/add,
+    # remove, reinterview, firmware, fabric/credential/channel/network changes,
+    # plus the two actions that LOOK read-ish but are not: zigbee network_backup
+    # (creates a backup artifact + key material, like ha_manage_backup's blocked
+    # snapshot create) and thread discover_routers (kicks off a long-running
+    # mDNS scan). A missing action fails closed.
+    if action in (
+        "diagnostics",
+        "network_status",
+        "ping",
+        "cluster_read",
+        "list_datasets",
+    ):
+        return None
+    return f"action={action!r}"
+
+
 # Mixed read/write tools whose read surface has no pure-read duplicate
 # (verified per tool: ha_get_addon cannot proxy-read addon-internal
 # APIs; energy prefs and assist pipelines are reachable only through
 # these tools; edit-backup listing exists nowhere else; the saved-tools
-# cache is only listable here). Everything NOT in this table and not
-# ``readOnlyHint=True`` is hidden and blocked outright.
+# cache is only listable here; ha_manage_radio's 'ping' probe, 'cluster_read'
+# and 'list_datasets' have no pure-read duplicate elsewhere, while its
+# 'diagnostics'/'network_status' reads mirror ha_get_device /
+# ha_get_system_health but stay reachable here mid-management). Everything
+# NOT in this table and not ``readOnlyHint=True`` is hidden and blocked
+# outright.
 #
 # ``MANDATORY_TOOLS`` (settings_ui/__init__.py) intentionally needs no special
 # case here: every mandatory tool is either ``readOnlyHint=True`` or
@@ -168,6 +193,13 @@ def _custom_tool_write(args: dict[str, Any]) -> str | None:
         _custom_tool_write,
         "listing saved tools (list_saved=True)",
     ),
+    "ha_manage_radio": ReadOnlyExemption(
+        _radio_write,
+        "node diagnostics ('diagnostics'), the integration/network summary "
+        "('network_status'), the active reachability probe ('ping'), a Zigbee "
+        "cluster-attribute read ('cluster_read'), and the Thread dataset "
+        "listing ('list_datasets')",
+    ),
 }
 
 
 
@@ -0,0 +1,40 @@
+"""Doomed-run detector for the e2e fail-fast hook.
+
+Extracted from ``tests/src/e2e/conftest.py`` so the streak logic is unit-testable
+without importing the heavy e2e conftest. See
+``tests/src/e2e/conftest.py::pytest_runtest_logreport`` for the wiring and
+``tests/src/unit/test_doomed_run.py`` for the tests.
+"""
+
+from __future__ import annotations
+
+DOOMED_RUN_ERROR_STREAK = 50
+
+
+class DoomedRunDetector:
+    """Counts CONSECUTIVE setup/teardown errors with zero call-phase pass/fail
+    between them.
+
+    ``record(when, outcome)`` returns ``True`` once the streak reaches
+    ``threshold`` — the signal that the run is producing nothing but errors and
+    should be aborted. A genuine call-phase ``passed``/``failed`` resets the
+    streak, so an isolated flaky-setup test never trips it. pytest-rerunfailures'
+    intermediate ``rerun`` outcome is ignored (neither resets nor increments), as
+    is ``skipped`` and a non-failing setup/teardown.
+    """
+
+    def __init__(self, threshold: int = DOOMED_RUN_ERROR_STREAK) -> None:
+        self.threshold = threshold
+        self.streak = 0
+
+    def record(self, when: str, outcome: str) -> bool:
+        # A real test body ran -> the run is alive; reset.
+        if when == "call" and outcome in ("passed", "failed"):
+            self.streak = 0
+            return False
+        # A setup/teardown error (an "error", not a "fail"). ``== "failed"``
+        # excludes the "rerun" outcome, which must not extend a doomed streak.
+        if when in ("setup", "teardown") and outcome == "failed":
+            self.streak += 1
+            return self.streak >= self.threshold
+        return False
@@ -80,8 +80,8 @@
     # Baselines are the observed skip counts as of 2026-05-22 (container=46,
     # haos=14, haos_inaddon=39 from the prose above), plus this PR's new
     # marker-gated skips, plus a 5-9 growth buffer.
-    "container": 65,  # was 62; +3 self-update-notice inaddon tests (@inaddon_only, skip here)
-    "haos": 32,  # was 29; +3 self-update-notice inaddon tests (@inaddon_only, skip here)
+    "container": 66,  # was 65; +1 inaddon read-only test (@inaddon_only, skips here)
+    "haos": 33,  # was 32; +1 inaddon read-only test (@inaddon_only, skips here)
     "haos_inaddon": 58,  # was 55; +3 self-update notice tests (TestSelfUpdateNoticeSurfacedInTools, @external_only)
 }
 
 
@@ -44,6 +44,7 @@
 sys.path.insert(0, str(Path(__file__).parent.parent.parent / "src"))
 sys.path.insert(0, str(Path(__file__).parent.parent))  # tests/src/ for haos_runtime
 
+from doomed_run import DoomedRunDetector
 from fastmcp import Client
 from haos_runtime import (
     HA_MCP_DEV_ADDON_SLUG,
@@ -168,6 +169,36 @@ def pytest_collection_modifyitems(config, items):
             item.add_marker(skip_external_only)
 
 
+# Fail fast on a doomed run, on EVERY e2e lane (this conftest is shared by the
+# testcontainer / external-HAOS / inaddon suites, so the hook guards all three).
+# A Supervisor add-on-update flake did exactly this on PR #1699: all 997 inaddon
+# tests ERRORed at setup (0 passed, 0 failed) while the run ground on 11m39s
+# producing nothing but errors. DoomedRunDetector aborts once it sees 50
+# consecutive setup/teardown errors with zero call-phase pass/fail between them;
+# a genuine pass/fail resets the streak, so real failures still run through in
+# full (this is NOT --maxfail). The detector logic is unit-tested in
+# tests/src/unit/test_doomed_run.py.
+#
+# Under xdist, pytest_runtest_logreport fires in EACH process — the controller
+# (which receives every worker's reports) AND each worker for its own tests — so
+# every process keeps its own module-global detector; the streak is per-process,
+# not global. That is fine: a doomed run errors on every process, so whichever
+# reaches 50 first calls pytest.exit and ends the session (validated under -n2:
+# a 150-test all-error run aborts at 50 in ~2s).
+_doomed_detector = DoomedRunDetector()
+
+
+def pytest_runtest_logreport(report):
+    if _doomed_detector.record(report.when, report.outcome):
+        pytest.exit(
+            f"Aborting: {_doomed_detector.streak} consecutive setup/teardown "
+            f"errors with no test passing or failing — the run is doomed by a "
+            f"systemic setup failure (e.g. add-on/container setup). Failing fast "
+            f"instead of grinding through the suite.",
+            returncode=1,
+        )
+
+
 def pytest_sessionfinish(session, exitstatus):
     """xdist worker hook: hand collected timings up to the master.
 
 
@@ -147,6 +147,7 @@ async def test_write_tools_hidden_exempt_and_read_tools_listed(readonly_mcp):
         "ha_manage_backup",
         "ha_manage_pipeline",
         "ha_manage_energy_prefs",
+        "ha_manage_radio",
     ):
         assert kept in names, f"{kept} should stay listed"
 
@@ -237,6 +238,32 @@ async def test_exempt_tool_write_action_blocked(readonly_mcp):
     assert "list" in body["error"]["message"], body
 
 
+@pytest.mark.asyncio
+async def test_radio_read_action_works(readonly_mcp):
+    """ha_manage_radio is exempt: a read action (network_status) stays
+    callable in read-only mode. Z-Wave JS is not configured on the test
+    container, so this also exercises the graceful integration-absent read
+    path (available=False but success=True)."""
+    client, _server = readonly_mcp
+    result = await client.call_tool(
+        "ha_manage_radio", {"radio": "zwave", "action": "network_status"}
+    )
+    body = parse_mcp_result(result)
+    assert body.get("success") is True, body
+
+
+@pytest.mark.asyncio
+async def test_radio_write_action_blocked(readonly_mcp):
+    """A ha_manage_radio write action (zwave 'add') is blocked with the
+    structured READ_ONLY_MODE error before the handler runs."""
+    client, _server = readonly_mcp
+    body = await _expect_read_only_blocked(
+        client, "ha_manage_radio", {"radio": "zwave", "action": "add"}
+    )
+    assert body["tool_name"] == "ha_manage_radio", body
+    assert body["blocked_operation"], body
+
+
 @pytest.mark.asyncio
 async def test_proxy_dispatched_write_blocked_with_tool_search(readonly_toolsearch_mcp):
     """ha_call_write_tool re-dispatches through the middleware chain, so
@@ -399,3 +426,127 @@ async def test_code_mode_tool_read_works_and_execution_blocked(readonly_codemode
         {"code": "1 + 1", "justification": "read-only mode test"},
     )
     assert body["tool_name"] == "ha_manage_custom_tool", body
+
+
+@pytest.mark.inaddon_only
+@pytest.mark.asyncio
+async def test_inaddon_read_only_mode_blocks_radio_writes(
+    ha_container_with_fresh_config, mcp_client
+):
+    """Read-only mode on the REAL inaddon add-on (every test above skips inaddon
+    via ``_build_readonly_server``, which can only inject ``READ_ONLY_MODE`` into
+    a fresh in-process server).
+
+    Enables read_only_mode through the add-on's OWN settings API — which merges it
+    into the Supervisor add-on options the production way (a bare options POST is
+    full-replacement and would drop required keys) — self-restarts ONLY the add-on
+    (~10s; Home Assistant is untouched) so it boots with ``READ_ONLY_MODE=true``,
+    asserts ha_manage_radio's read action still works while a write is blocked with
+    the structured READ_ONLY_MODE error, then RESTORES read-only to off.
+
+    xdist runs a worker's tests serially and each worker owns an isolated add-on
+    (``_haos_worker_setup``), so bracketing read-only around just this test and
+    restoring it in ``finally`` is safe at any position. (Ordering tricks do NOT
+    help — ``--dist loadscope`` groups tests by module, so a single "run last"
+    marker can't make this the last thing on its worker.) The two dev-add-on
+    restarts also drop the SHARED session ``mcp_client`` connection
+    (test_supervisor_inaddon.py documents that restarting the dev add-on kills
+    mcp_client for later tests), so the ``finally`` also warms that client back up
+    so whatever module loadscope hands this worker next gets a live session.
+    """
+    import asyncio
+    import time
+
+    import httpx
+    from fastmcp.client.transports import StreamableHttpTransport
+    from haos_runtime import HA_MCP_TEST_SECRET_PATH, wait_for_addon_mcp_ready
+
+    container_info = ha_container_with_fresh_config
+    addon_mcp_url = container_info.get("addon_mcp_url")
+    assert addon_mcp_url, "inaddon backend should expose addon_mcp_url"
+    # The settings UI is mounted at the secret-path root (see TestSettingsUiRestartReal).
+    base = addon_mcp_url.split("/mcp", 1)[0]
+    settings = f"{base}{HA_MCP_TEST_SECRET_PATH}/api/settings"
+    _transient = (AssertionError, TimeoutError, OSError, httpx.HTTPError, RuntimeError)
+
+    async def _set_read_only(enabled: bool) -> None:
+        """POST the flag (handler merges into Supervisor options) + self-restart
+        the add-on. Empty restart body -> target='self', which the handler
+        schedules in the background so this 200 flushes before the bounce."""
+        async with httpx.AsyncClient(timeout=30.0) as http:
+            resp = await http.post(
+                f"{settings}/features", json={"flags": {"read_only_mode": enabled}}
+            )
+            assert resp.status_code == 200, (
+                f"set read_only_mode={enabled}: {resp.status_code} {resp.text[:300]!r}"
+            )
+            resp = await http.post(f"{settings}/restart", json={})
+            assert resp.status_code == 200, (
+                f"restart add-on: {resp.status_code} {resp.text[:300]!r}"
+            )
+
+    async def _await_read_only(expected: bool) -> None:
+        """Poll, reconnecting each round, until the add-on's CATALOG reflects
+        read_only_mode == expected — i.e. the restart actually took effect. In
+        read-only mode the catalog filter hides write tools, so ``ha_call_service``
+        is absent iff read-only is on. Keying on a positive signal from a real
+        ``list_tools`` response (rather than the absence of an overview key, which
+        a degraded payload could also fake) ensures we only confirm against a
+        healthy, fully-booted add-on."""
+        deadline = time.monotonic() + 180.0
+        last: object = None
+        while time.monotonic() < deadline:
+            try:
+                url = wait_for_addon_mcp_ready(timeout=30.0)
+                async with Client(StreamableHttpTransport(url=url)) as mcp:
+                    names = {t.name for t in await mcp.list_tools()}
+                if ("ha_call_service" not in names) is expected:
+                    return
+                last = len(names)
+            except _transient as err:
+                last = err
+            await asyncio.sleep(3)
+        raise AssertionError(
+            f"read-only catalog did not become {expected} within 180s (last={last!r})"
+        )
+
+    try:
+        await _set_read_only(True)
+        await _await_read_only(True)
+        url = wait_for_addon_mcp_ready(timeout=30.0)
+        async with Client(StreamableHttpTransport(url=url)) as mcp:
+            result = await mcp.call_tool(
+                "ha_manage_radio", {"radio": "zwave", "action": "network_status"}
+            )
+            assert parse_mcp_result(result).get("success") is True, result
+            blocked = await _expect_read_only_blocked(
+                mcp, "ha_manage_radio", {"radio": "zwave", "action": "add"}
+            )
+            assert blocked.get("tool_name") == "ha_manage_radio", blocked
+    finally:
+        # Restore read-only OFF: this worker's remaining tests share the add-on
+        # and need writes, so a leaked read-only would cascade READ_ONLY_MODE into
+        # all of them. Retry the whole set+restart until it's confirmed off.
+        restore_deadline = time.monotonic() + 300.0
+        while True:
+            try:
+                await _set_read_only(False)
+                await _await_read_only(False)
+                break
+            except _transient:
+                if time.monotonic() >= restore_deadline:
+                    raise
+                await asyncio.sleep(3)
+        # The dev-add-on restarts above dropped the SHARED session mcp_client's
+        # connection. Warm it back up so the next test loadscope schedules on this
+        # worker gets a live session rather than a stale one (a read tool is enough
+        # to force re-establishment; retry while the add-on finishes coming up).
+        warm_deadline = time.monotonic() + 120.0
+        while True:
+            try:
+                await mcp_client.call_tool("ha_get_overview", {})
+                break
+            except _transient:
+                if time.monotonic() >= warm_deadline:
+                    raise
+                await asyncio.sleep(3)
@@ -0,0 +1,69 @@
+"""Unit tests for the e2e fail-fast ``DoomedRunDetector``.
+
+Covers the abort threshold, the reset-on-real-pass/fail semantics, and the
+rerun/skip exclusions — the branching the e2e hook relies on (which is otherwise
+only exercised incidentally on real e2e runs).
+"""
+
+from tests.src.doomed_run import DoomedRunDetector
+
+
+def test_call_pass_resets_streak():
+    d = DoomedRunDetector(threshold=5)
+    for _ in range(4):
+        assert d.record("setup", "failed") is False
+    assert d.streak == 4
+    assert d.record("call", "passed") is False
+    assert d.streak == 0
+
+
+def test_call_fail_resets_streak():
+    d = DoomedRunDetector(threshold=5)
+    for _ in range(4):
+        d.record("setup", "failed")
+    assert d.record("call", "failed") is False
+    assert d.streak == 0
+
+
+def test_rerun_outcome_neither_resets_nor_increments():
+    d = DoomedRunDetector(threshold=5)
+    d.record("setup", "failed")
+    d.record("setup", "failed")
+    assert d.streak == 2
+    assert d.record("setup", "rerun") is False  # pytest-rerunfailures
+    assert d.record("call", "rerun") is False
+    assert d.streak == 2
+
+
+def test_aborts_exactly_at_threshold():
+    d = DoomedRunDetector(threshold=50)
+    for _ in range(49):
+        assert d.record("setup", "failed") is False
+    assert d.record("setup", "failed") is True
+    assert d.streak == 50
+
+
+def test_interleaved_pass_prevents_abort():
+    d = DoomedRunDetector(threshold=5)
+    for _ in range(10):
+        for _ in range(4):
+            assert d.record("setup", "failed") is False
+        assert d.record("call", "passed") is False
+    assert d.streak == 0
+
+
+def test_teardown_error_counts_toward_streak():
+    d = DoomedRunDetector(threshold=2)
+    assert d.record("teardown", "failed") is False
+    assert d.record("teardown", "failed") is True
+
+
+def test_skip_and_passing_setup_do_not_increment():
+    d = DoomedRunDetector(threshold=2)
+    assert d.record("setup", "skipped") is False
+    assert d.record("setup", "passed") is False
+    assert d.streak == 0
+
+
+def test_default_threshold_is_50():
+    assert DoomedRunDetector().threshold == 50