refactor: reconcile registry in all modes, expand CI test report

Remove the executable-mode early-exit from reconcile_shell_integration so
the context-menu keys are written regardless of how the app was launched.
Drop the now-unused REGISTRY_RECONCILE_SKIPPED log event.

Refactor BinaryTestReport into per-stage Check objects so each artifact
(exe, log, config, Start Menu shortcut, individual registry values) is
individually probed and reported rather than checked as a positional tuple.
Add read_registry_value helpers and REGISTRY_VALUE_PROBES to the CI
actions module, and add start_menu_shortcut to Paths in config.

Update the registry test to assert that reconcile writes in executable mode.

Author: vagabondHustler

.github/workflows/scripts/actions.py

@@ -204,6 +204,30 @@ def registry_key_exists() -> bool:
         return False
 
 
+def read_registry_value(sub_key: str, value_name: str) -> str | None:
+    import winreg  # Windows-only; imported lazily so this module loads on the Linux CI runner.
+
+    try:
+        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, sub_key, 0, winreg.KEY_READ) as key:
+            value, _ = winreg.QueryValueEx(key, value_name)
+            return str(value)
+    except FileNotFoundError:
+        return None
+
+
+# (label, sub_key, value_name) for the context-menu entries the app populates on first launch.
+REGISTRY_VALUE_PROBES = (
+    ("Subsearch", r"Software\Classes\*\shell\Subsearch", ""),
+    ("Icon", r"Software\Classes\*\shell\Subsearch", "Icon"),
+    ("AppliesTo", r"Software\Classes\*\shell\Subsearch", "AppliesTo"),
+    ("command", r"Software\Classes\*\shell\Subsearch\command", ""),
+)
+
+
+def read_registry_values() -> list[tuple[str, str | None]]:
+    return [(label, read_registry_value(sub_key, value_name)) for label, sub_key, value_name in REGISTRY_VALUE_PROBES]
+
+
 class BinaryTester:
     def msi_artifact_path(self) -> Path:
         candidates = sorted(Paths.artifacts.glob("*.msi"))
@@ -368,46 +392,96 @@ def test_executable(self, test_length: int = 30) -> None:
         self.end_process(EXE_NAME)
 
 
-class BinaryTestReport:
-    _PROBES = ("Exe", "Log", "Config", "Registry key")
+class Check:
+    def __init__(self, label: str, expected: bool, actual: bool, detail: str) -> None:
+        self.label = label
+        self.expected = expected
+        self.actual = actual
+        self.detail = detail
 
-    # Per stage, the expected presence of (exe, log, config, registry key).
-    _EXPECTED_STATE = {
-        "install": (True, False, False, True),
-        "executable": (True, True, True, True),
-        "uninstall": (False, True, True, False),
+    @property
+    def passed(self) -> bool:
+        return self.actual == self.expected
+
+
+class BinaryTestReport:
+    _TITLES = {
+        "install": "MSI install",
+        "executable": "Subsearch ran",
+        "uninstall": "MSI uninstall",
     }
 
     def __init__(self, step_summary: StepSummary) -> None:
         self._step_summary = step_summary
 
-    def _current_state(self) -> tuple[bool, bool, bool, bool]:
-        return (
-            Paths.installed_executable.is_file(),
-            Paths.log_file.is_file(),
-            Paths.config_file.is_file(),
-            registry_key_exists(),
-        )
+    def _path_check(self, label: str, path: Path, expected: bool) -> Check:
+        present = path.is_file()
+        detail = path.as_posix() if present else f"missing ({path.as_posix()})"
+        return Check(label, expected, present, detail)
+
+    def _registry_value_checks(self, expected_populated: bool) -> list[Check]:
+        checks = []
+        for label, value in read_registry_values():
+            populated = value not in (None, "")
+            if value is None:
+                detail = "key absent"
+            elif value == "":
+                detail = "empty placeholder"
+            else:
+                detail = f"`{value}`"
+            checks.append(Check(f"Registry {label}", expected_populated, populated, detail))
+        return checks
+
+    def _checks_for_install(self) -> list[Check]:
+        return [
+            self._path_check("Executable", Paths.installed_executable, expected=True),
+            self._path_check("Start Menu shortcut", Paths.start_menu_shortcut, expected=True),
+            *self._registry_value_checks(expected_populated=False),
+        ]
+
+    def _checks_for_executable(self) -> list[Check]:
+        return [
+            self._path_check("Executable", Paths.installed_executable, expected=True),
+            self._path_check("Log", Paths.log_file, expected=True),
+            self._path_check("Config", Paths.config_file, expected=True),
+            *self._registry_value_checks(expected_populated=True),
+        ]
+
+    def _checks_for_uninstall(self) -> list[Check]:
+        return [
+            self._path_check("Executable removed", Paths.installed_executable, expected=False),
+            self._path_check("Start Menu shortcut removed", Paths.start_menu_shortcut, expected=False),
+            Check("Registry key removed", expected=False, actual=registry_key_exists(), detail="HKCU context-menu key"),
+        ]
+
+    def _checks_for_stage(self, name: str) -> list[Check]:
+        return {
+            "install": self._checks_for_install,
+            "executable": self._checks_for_executable,
+            "uninstall": self._checks_for_uninstall,
+        }[name]()
+
+    def add_stage_card(self, name: str) -> None:
+        checks = self._checks_for_stage(name)
+        passed = all(check.passed for check in checks)
+        self._step_summary.card(f"{self._TITLES[name]}: {self._step_summary.result(passed)}", passed=passed)
+        self._step_summary.add_summary("Reason:")
+        for check in checks:
+            mark = self._step_summary.result(check.passed)
+            self._step_summary.add_summary(f"- {check.label}: {mark} - {check.detail}")
+        self._log_stage(name, checks, passed)
+        self._assert_stage_passed(name, passed)
 
     def _assert_stage_passed(self, name: str, passed: bool) -> None:
         if not passed:
             list_files_in_directory(Paths.installed_executable.parent)
             list_files_in_directory(Paths.log_file.parent)
             raise RuntimeError(f"{name} test failed")
 
-    def add_stage_card(self, name: str) -> None:
-        actual = self._current_state()
-        expected = self._EXPECTED_STATE[name]
-        passed = actual == expected
-        self._step_summary.card(f"{name.capitalize()} test", passed=passed)
-        for probe, probe_found, probe_expected in zip(self._PROBES, actual, expected):
-            self._step_summary.add_summary(f"- {probe}: {self._step_summary.result(probe_found == probe_expected)}")
-        self._log_stage(name, actual, passed)
-        self._assert_stage_passed(name, passed)
-
-    def _log_stage(self, name: str, actual: tuple[bool, bool, bool, bool], passed: bool) -> None:
-        log(", ".join(f"{probe}: {present}" for probe, present in zip(self._PROBES, actual)))
-        log(f"{name.capitalize()} test {'passed' if passed else 'failed'}", level="PASS" if passed else "FAIL")
+    def _log_stage(self, name: str, checks: list[Check], passed: bool) -> None:
+        for check in checks:
+            log(f"{check.label}: {'OK' if check.passed else 'BAD'} ({check.detail})")
+        log(f"{self._TITLES[name]} {'passed' if passed else 'failed'}", level="PASS" if passed else "FAIL")
         print(STYLE_SEPARATOR)
 
 

.github/workflows/scripts/config.py

@@ -23,6 +23,9 @@ class Paths:
     installed_executable: Path = install_directory / EXE_NAME
     log_file: Path = user_data_directory / "log.log"
     config_file: Path = user_data_directory / "config.json"
+    start_menu_shortcut: Path = (
+        home_directory / "AppData" / "Roaming" / "Microsoft" / "Windows" / "Start Menu" / "Programs" / f"{APP_NAME}.lnk"
+    )
 
     working_directory: Path = Path.cwd()
     pyproject: Path = working_directory / "pyproject.toml"

src/subsearch/io/windows_registry.py

@@ -145,9 +145,6 @@ def _write_registry_value(sub_key: str, value_name: str, value: str) -> None:
 
 
 def reconcile_shell_integration() -> None:
-    if DEVICE_INFO.mode == "executable":
-        log.event(LogEvent.REGISTRY_RECONCILE_SKIPPED, level="debug")
-        return
     context_menu_enabled = config_session.read_config_value(ConfigKey.SHELL_INTEGRATION_CONTEXT_MENU)
     if not context_menu_enabled:
         if _context_menu_key_exists():

src/subsearch/runtime/logging/events.py

@@ -48,7 +48,6 @@ class LogEvent(StrEnum):
     REGISTRY_KEY_DELETING = "registry.key_deleting"
     REGISTRY_CONTEXT_MENU_REMOVING = "registry.context_menu_removing"
     REGISTRY_KEY_MISSING = "registry.key_missing"
-    REGISTRY_RECONCILE_SKIPPED = "registry.reconcile_skipped"
     REGISTRY_MATCHES_ABSENT = "registry.matches_absent"
     REGISTRY_MATCHES_CURRENT = "registry.matches_current"
     REGISTRY_VALUE_UPDATED = "registry.value_updated"
@@ -209,7 +208,6 @@ class LogEvent(StrEnum):
     LogEvent.REGISTRY_KEY_DELETING: "Deleting registry key: {key}",
     LogEvent.REGISTRY_CONTEXT_MENU_REMOVING: "Removing Subsearch context menu from registry",
     LogEvent.REGISTRY_KEY_MISSING: "Registry key missing, could not write {sub_key}\\{value_name}",
-    LogEvent.REGISTRY_RECONCILE_SKIPPED: "Skipping registry reconcile: MSI installer owns the context menu keys",
     LogEvent.REGISTRY_MATCHES_ABSENT: "Registry matches config: context menu absent",
     LogEvent.REGISTRY_MATCHES_CURRENT: "Registry matches config: context menu up to date",
     LogEvent.REGISTRY_VALUE_UPDATED: "Registry updated: {name}",

tests/test_windows_registry.py

@@ -24,16 +24,25 @@ def test_changed_value_names_reports_everything_when_keys_absent():
     assert windows_registry.changed_value_names(desired, current) == ["subsearch", "icon"]
 
 
-def test_reconcile_skips_in_executable_mode(monkeypatch):
+def test_reconcile_writes_in_executable_mode(monkeypatch):
     monkeypatch.setattr(
         windows_registry, "DEVICE_INFO", dataclasses.replace(windows_registry.DEVICE_INFO, mode="executable")
     )
+    monkeypatch.setattr(windows_registry.config_session, "read_config_value", lambda key: True)
+    monkeypatch.setattr(windows_registry, "desired_registry_values", lambda: {"command": "run"})
+    monkeypatch.setattr(windows_registry, "current_registry_values", lambda: {"command": None})
+    monkeypatch.setattr(windows_registry, "_create_context_menu_keys", lambda: None)
+    written = []
     monkeypatch.setattr(
-        windows_registry, "current_registry_values", lambda: (_ for _ in ()).throw(AssertionError("touched registry"))
+        windows_registry,
+        "_write_registry_value",
+        lambda sub_key, value_name, value: written.append((sub_key, value_name, value)),
     )
 
     windows_registry.reconcile_shell_integration()
 
+    assert written == [(*windows_registry.VALUE_LOCATIONS["command"], "run")]
+
 
 def test_reconcile_disabled_and_absent_does_not_touch_registry(monkeypatch):
     monkeypatch.setattr(