refactor: address PR homeassistant-ai#1398 KP13 review (9 items)

- entity_not_verified detection via warnings-substring scan
  (homeassistant-ai#1297-popped flag was dead — VERDICT=VALIDATED could leak silently)
- sample-count invariant: len(samples) + not_verified == N_SAMPLES
- rename "p99" -> "worst" (at N=10 the percentile collapses to max;
  the threshold-check name now reflects what it measures)
- per-test try/finally cleanup: cleanup_tracker is a logging-only no-op,
  so 10 automations were leaking into the next worker run
- caplog.at_level context manager (set_level mutated worker-wide level
  and leaked DEBUG-on-rest_client into every later test)
- 6 comment subtractions per Boy-Scout

Boy-Scout fold per homeassistant-ai#1389 measurement (RETUNE NEEDED p50>=100ms):

- _POLL_CADENCE: (0.1, 1.0, 4.9) -> (0.025, 1.0, 4.975) — first-poll
  pulled to a 5x cushion above the measured ~4ms HA-Core
  entity-registration latency
- unit-test pins updated to the new cadence values
- test_proxy_http_request_headers_pass_through: add _wait_for_state
  helper + guard for state="started" (HAOS E2E fail: Node-RED was in
  "startup" when the strict status_code assertion ran)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Patch76

src/ha_mcp/client/rest_client.py

@@ -926,9 +926,12 @@ async def upsert_automation_config(
                 ) from e
             raise
 
-    # 3-attempt × 6s upper-bound budget; first poll 0.1s catches the
-    # typical sub-1s entity-publish window.
-    _POLL_CADENCE: tuple[float, ...] = (0.1, 1.0, 4.9)
+    # 3-attempt × 6s upper-bound budget; first poll 0.025s is a 5×
+    # cushion above the ~4ms HA-Core entity-registration latency
+    # measured by ``test_poll_cadence_measurement.py`` (#1389 — p50
+    # 104.1-104.8 ms on the prior 0.1s first-poll, all from the sleep
+    # itself with ~4 ms of real registration work).
+    _POLL_CADENCE: tuple[float, ...] = (0.025, 1.0, 4.975)
 
     async def _poll_for_automation_entity(self, unique_id: str) -> str | None:
         """Poll HA state to find the entity_id assigned to a newly created automation."""

tests/src/e2e/conftest.py

@@ -89,22 +89,18 @@
 _READINESS_TIMINGS: list[dict[str, Any]] = []
 _ALL_READINESS_TIMINGS: list[dict[str, Any]] = []
 
-# Same shape as ``_READINESS_TIMINGS``, parallel channel for the #1389
-# ``_POLL_CADENCE`` measurement. Lives at this conftest level (not deeper)
-# because pytest-xdist's master only loads conftests up to where tests
-# are collected; deeper subdir conftests don't get their hooks invoked
-# on the master, which is where ``pytest_terminal_summary`` writes to
-# the visible terminal output. See ``record_poll_cadence_measurement``
-# call site in ``workflows/automation/test_poll_cadence_measurement.py``.
+# Parallel channel for the #1389 ``_POLL_CADENCE`` measurement —
+# mirrors the xdist round-trip used by ``_READINESS_TIMINGS`` above.
 _POLL_CADENCE_MEASUREMENTS: list[dict[str, Any]] = []
 _ALL_POLL_CADENCE_MEASUREMENTS: list[dict[str, Any]] = []
 
 
 def record_poll_cadence_measurement(measurement: dict[str, Any]) -> None:
     """Record a single #1389 measurement run from a test method.
 
-    Expected keys: ``n``, ``attempts``, ``p50``, ``p90``, ``p99``, ``min``,
-    ``max``, ``not_verified``, ``verdict``, ``samples``.
+    See the call site in
+    ``workflows/automation/test_poll_cadence_measurement.py`` for the
+    measurement dict shape — that file owns the schema.
     """
     _POLL_CADENCE_MEASUREMENTS.append(measurement)
 
@@ -264,7 +260,8 @@ def pytest_terminal_summary(terminalreporter, exitstatus, config):
         for m in poll_measurements:
             terminalreporter.write_line(
                 f"[POLL_CADENCE_1389] N={m['n']}/{m.get('attempts', m['n'])} "
-                f"p50={m['p50']:.1f}ms p90={m['p90']:.1f}ms p99={m['p99']:.1f}ms "
+                f"p50={m['p50']:.1f}ms p90={m['p90']:.1f}ms "
+                f"worst={m['worst']:.1f}ms "
                 f"min={m['min']:.1f}ms max={m['max']:.1f}ms "
                 f"not_verified={m['not_verified']} VERDICT={m['verdict']}"
             )

tests/src/e2e/haos_only/test_manage_addon_modes.py

@@ -45,6 +45,8 @@
 
 from __future__ import annotations
 
+import asyncio
+import time
 from typing import Any
 
 import pytest
@@ -61,6 +63,9 @@
 MATTER_NAME = "Matter Server"
 APPDAEMON_NAME = "AppDaemon"
 
+_STATE_POLL_TIMEOUT = 30.0
+_STATE_POLL_INTERVAL = 0.5
+
 
 async def _resolve_slug(mcp_client: Any, display_name: str) -> str:
     """Map an addon display name to its Supervisor slug at runtime.
@@ -88,6 +93,37 @@ async def _resolve_slug(mcp_client: Any, display_name: str) -> str:
     )
 
 
+async def _wait_for_state(
+    mcp_client: Any,
+    slug: str,
+    expected: str,
+    *,
+    timeout: float = _STATE_POLL_TIMEOUT,
+) -> str:
+    """Poll ``ha_get_addon(slug=...)`` until ``state`` matches ``expected``.
+
+    Mirrors the helper in ``test_addon_lifecycle.py``. Same private-copy
+    rationale as ``_resolve_slug``: pytest treats sibling test files as
+    independent collection units, so cross-file imports of test-internal
+    helpers needlessly couple modules. If a third test file needs this,
+    move both into ``utilities/``.
+    """
+    deadline = time.monotonic() + timeout
+    last_state: str | None = None
+    while time.monotonic() < deadline:
+        detail_raw = await mcp_client.call_tool("ha_get_addon", {"slug": slug})
+        payload = parse_mcp_result(detail_raw)
+        addon = payload.get("addon") or {}
+        last_state = addon.get("state")
+        if last_state == expected:
+            return str(last_state)
+        await asyncio.sleep(_STATE_POLL_INTERVAL)
+    pytest.fail(
+        f"Addon {slug!r} state did not reach {expected!r} within "
+        f"{timeout}s (last observed: {last_state!r})"
+    )
+
+
 # ---------------------------------------------------------------------------
 # Config mode — options / boot / auto_update / watchdog round-trips
 # ---------------------------------------------------------------------------
@@ -234,6 +270,12 @@ async def test_proxy_http_request_headers_pass_through(mcp_client: Any) -> None:
     invalid", which proves the value crossed the wire.
     """
     slug = await _resolve_slug(mcp_client, NODERED_NAME)
+    # Supervisor returns success from ``addon_start`` before the addon's
+    # container reaches ``state="started"``; without this wait the proxy
+    # call lands while Node-RED is still in ``startup`` and the tool
+    # responds with a structured ``SERVICE_CALL_FAILED`` instead of an
+    # HTTP envelope. Same readiness race the lifecycle tests guard.
+    await _wait_for_state(mcp_client, slug, "started")
     without = await safe_call_tool(
         mcp_client,
         "ha_manage_addon",