fix(tests,health): isolate HOME in E2E gates + detect empty version segment (#1490)

Two Critical issues surfaced in CI (e2e-plugin-hooks/3.11) that the
local pre-push check missed because the developer/runner HOME leaked
into pytest subprocess invocations:

1. **TestHudInstallE2ERegressionGate all 4 scenarios FAILED on CI**
   with `assert "CB v" in out` because
   ``hud_version.get_fresh_version``'s tier-1 lookup reads
   ``~/.claude/plugins/installed_plugins.json`` and CI has none. The
   render therefore produced ``CB | Ready 🟢 | ...`` — a silent
   half-broken state where every module imports successfully but the
   version segment is empty. Locally the same test passed only
   because the developer's real ``~/.claude/plugins/installed_plugins.json``
   (v5.6.1) leaked into the subprocess.

   Fix: the test now writes a stub
   ``installed_plugins.json`` into the tmpdir fake home and invokes
   the subprocess with ``env={"HOME": str(home), ...}`` so all three
   version-resolution tiers (tier 1 installed_plugins.json, tier 2
   plugin.json, tier 3 hud_state) see the isolated environment.
   Assertion is strengthened to ``CB v<expected_version>`` with
   ``expected_version`` read from ``plugin.json`` so future
   bump-version.sh runs auto-gate. A ``.version`` stamp assertion
   is also added per scenario.

   The simulation shell script (commit 8) was already hardened this
   way; this commit brings the pytest E2E suite to parity so CI and
   local runs agree.

2. **check_hud_installation smoke test did not detect empty version**
   — it only compared against the literal fallback face, so the
   ``CB | Ready ...`` half-broken state returned PASS even though
   the user would see a status line with a missing version segment.

   Fix: ``check_hud_installation`` now detects ``"CB "`` without
   ``"CB v"`` in the rendered output and returns FAIL with a clear
   message ("HUD rendered empty version segment — hud_version
   fallback chain broken"). The subprocess call also pins
   ``HOME=self._home_dir`` so the diagnostic honours the
   HealthChecker's configured home directory rather than leaking the
   CI runner's real home. A new regression test
   ``test_fail_when_version_segment_is_empty`` stubs a script that
   prints the half-broken line and asserts the check FAILs.

3. **test_pass_with_real_plugin_install** (health_check green-path
   gate) now writes the same fake ``installed_plugins.json`` so the
   subprocess check_hud_installation invokes can resolve the plugin
   version inside the isolated environment.

Local verification:
  $ python3 -m pytest tests/test_session_start_hud.py tests/test_health_check.py -v
  ... 56 passed in 0.90s
  $ bash packages/claude-code-plugin/scripts/verify-install-simulation.sh
  [verify-install-simulation] PASS: full status line rendered (v5.6.2)

Refs #1490

Author: JeremyDev87

packages/claude-code-plugin/hooks/lib/health_check.py

@@ -306,21 +306,47 @@ def check_hud_installation(self) -> Dict[str, str]:
                 f"HUD lib missing modules: {', '.join(missing)}",
             )
 
-        # Subprocess render smoke — catches runtime import failures.
+        # Subprocess render smoke — catches runtime import failures
+        # AND partially-rendered status lines (e.g. empty version
+        # segment when hud_version's 3-tier fallback all fail).
+        # HOME is pinned to self._home_dir so the subprocess's
+        # tier-1 version lookup (~/.claude/plugins/installed_plugins.json)
+        # resolves against the same environment the diagnostic was
+        # configured with, rather than leaking the CI runner's real
+        # home.
+        isolated_env = {
+            "HOME": self._home_dir,
+            "PATH": os.environ.get("PATH", ""),
+            "LANG": os.environ.get("LANG", ""),
+            "LC_ALL": os.environ.get("LC_ALL", ""),
+        }
         try:
             r = subprocess.run(
                 ["python3", script],
                 input='{"session_id":"healthcheck","model":{"display_name":"Test"}}',
                 capture_output=True,
                 text=True,
                 timeout=5,
+                env=isolated_env,
             )
-            if r.stdout.strip() == "◕‿◕ CodingBuddy":
+            rendered = r.stdout.strip()
+            if rendered == "◕‿◕ CodingBuddy":
                 return _result(
                     "hud_installation",
                     "FAIL",
                     "HUD smoke test produced fallback face — lib import failing at runtime",
                 )
+            # Version segment must not be empty. ``CB `` without the
+            # trailing ``v`` indicates all three version-resolution
+            # tiers (installed_plugins.json, plugin.json, hud_state)
+            # returned the empty string — a silent half-broken state
+            # that would otherwise ship unnoticed.
+            if "CB " in rendered and "CB v" not in rendered:
+                return _result(
+                    "hud_installation",
+                    "FAIL",
+                    "HUD rendered empty version segment — hud_version fallback chain broken",
+                )
         except subprocess.TimeoutExpired:
             return _result(
                 "hud_installation",

packages/claude-code-plugin/tests/test_health_check.py

@@ -415,13 +415,41 @@ def test_fail_when_smoke_test_returns_fallback(self, env):
         assert result["status"] == "FAIL"
         assert "fallback" in result["message"].lower()
 
+    def test_fail_when_version_segment_is_empty(self, env):
+        """v5.6.2 regression gate: empty version segment must FAIL.
+
+        Stubs a script that renders a partial status line without a
+        ``CB v<version>`` prefix — mimics the v5.6.0/v5.6.1 runtime
+        where hud_version's 3-tier fallback all returned empty
+        strings and the rendered line read ``CB | Ready 🟢 | ...``.
+        The smoke test must detect this silent half-broken state.
+        """
+        from pathlib import Path
+        h = Path(env) / ".claude" / "hud"
+        h.mkdir(parents=True, exist_ok=True)
+        (h / "codingbuddy-hud.py").write_text(
+            "#!/usr/bin/env python3\n"
+            "print('\u25d5\u203f\u25d5 CB | Ready \U0001f7e2 | Opus 4.6')\n"
+        )
+        os.chmod(str(h / "codingbuddy-hud.py"), 0o755)
+        lib = h / "lib"
+        lib.mkdir(exist_ok=True)
+        for name in HUD_REQUIRED_LIB_MODULES:
+            (lib / name).write_text(f"# {name} stub")
+
+        checker = _make_checker(env)
+        result = checker.check_hud_installation()
+        assert result["status"] == "FAIL"
+        assert "empty version segment" in result["message"].lower()
+
     def test_pass_with_real_plugin_install(self, env, monkeypatch):
         """End-to-end: install real HUD via _install_statusline, then check.
 
         This is the green-path regression gate — if check_hud_installation
         ever stops returning PASS for a freshly-installed real plugin,
         we know either the installer or the diagnostic regressed.
         """
+        import json as _json
         from pathlib import Path
         import importlib.util as importutil
 
@@ -437,6 +465,32 @@ def test_pass_with_real_plugin_install(self, env, monkeypatch):
         session_start = importutil.module_from_spec(spec)
         spec.loader.exec_module(session_start)
 
+        # Mimic Claude Code's plugin manifest so check_hud_installation's
+        # subprocess (HOME=self._home_dir=env) can resolve the plugin
+        # version via tier-1 lookup. Without this, CI environments
+        # produce an empty version segment and the new version-segment
+        # validation correctly FAILs the check.
+        plugin_root = repo_hooks.parent
+        plugin_json = plugin_root / ".claude-plugin" / "plugin.json"
+        expected_version = _json.loads(plugin_json.read_text())["version"]
+        plugins_dir = env / ".claude" / "plugins"
+        plugins_dir.mkdir(parents=True, exist_ok=True)
+        (plugins_dir / "installed_plugins.json").write_text(
+            _json.dumps(
+                {
+                    "plugins": {
+                        "codingbuddy@jeremydev87": [
+                            {
+                                "scope": "user",
+                                "installPath": str(plugin_root),
+                                "version": expected_version,
+                            }
+                        ]
+                    }
+                }
+            )
+        )
+
         # Force the installer to use the real source
         monkeypatch.setattr(
             session_start, "_find_hud_source", lambda: real_hud_source
@@ -450,3 +504,4 @@ def test_pass_with_real_plugin_install(self, env, monkeypatch):
             f"expected PASS, got {result}"
         )
         assert "rendering full status line" in result["message"]
+        assert expected_version in result["message"]

packages/claude-code-plugin/tests/test_session_start_hud.py

@@ -362,6 +362,35 @@ def test_install_then_render_full_status_line(
         settings_file.parent.mkdir(parents=True)
         settings_file.write_text("{}")
 
+        # Mimic Claude Code's plugin manifest so the installed HUD's
+        # tier-1 version lookup (hud_version.get_fresh_version →
+        # ~/.claude/plugins/installed_plugins.json) resolves to the
+        # in-tree plugin version. Without this, CI environments (which
+        # have no prior install) leave the version segment empty and
+        # the `"CB v" in out` assertion below fails. This mirrors the
+        # behavior Claude Code performs after /plugin update on real
+        # user machines.
+        plugin_root = real_plugin_hud_source.parents[1]
+        plugin_json_path = plugin_root / ".claude-plugin" / "plugin.json"
+        expected_version = json.loads(plugin_json_path.read_text())["version"]
+        plugins_dir = home / ".claude" / "plugins"
+        plugins_dir.mkdir(parents=True, exist_ok=True)
+        (plugins_dir / "installed_plugins.json").write_text(
+            json.dumps(
+                {
+                    "plugins": {
+                        "codingbuddy@jeremydev87": [
+                            {
+                                "scope": "user",
+                                "installPath": str(plugin_root),
+                                "version": expected_version,
+                            }
+                        ]
+                    }
+                }
+            )
+        )
+
         hud_dir = home / ".claude" / "hud"
 
         if scenario == "partial":
@@ -405,7 +434,10 @@ def test_install_then_render_full_status_line(
         if scenario == "stale":
             assert not (installed_lib / "hud_obsolete_v5_5.py").exists()
 
-        # 🔴 The render gate
+        # 🔴 The render gate — run the installed script as a real
+        # subprocess with an isolated HOME so tier-1 version lookup
+        # reads the fake installed_plugins.json we wrote above instead
+        # of leaking the developer/CI runner's real home directory.
         stdin_payload = json.dumps(
             {
                 "session_id": "regression-gate",
@@ -416,12 +448,19 @@ def test_install_then_render_full_status_line(
                 },
             }
         )
+        isolated_env = {
+            "HOME": str(home),
+            "PATH": os.environ.get("PATH", ""),
+            "LANG": os.environ.get("LANG", ""),
+            "LC_ALL": os.environ.get("LC_ALL", ""),
+        }
         result = subprocess.run(
             ["python3", str(installed_script)],
             input=stdin_payload,
             capture_output=True,
             text=True,
             timeout=10,
+            env=isolated_env,
         )
         assert result.returncode == 0, (
             f"scenario={scenario} crashed: stderr={result.stderr!r}"
@@ -436,6 +475,16 @@ def test_install_then_render_full_status_line(
             f"{sorted(p.name for p in installed_lib.iterdir())}"
         )
 
-        assert "CB v" in out, f"version segment missing: {out!r}"
+        # Exact version assertion — auto-tracks bump-version.sh so
+        # every release gates on a fully-populated version segment.
+        assert f"CB v{expected_version}" in out, (
+            f"version segment missing/wrong: {out!r} "
+            f"(expected 'CB v{expected_version}')"
+        )
         assert "Opus 4.6" in out, f"model segment missing: {out!r}"
         assert "$0.42" in out, f"cost segment missing: {out!r}"
+
+        # Stamp file assertion
+        stamp = hud_dir / ".version"
+        assert stamp.exists(), f"scenario={scenario}: .version stamp missing"
+        assert stamp.read_text(encoding="utf-8").strip() == expected_version