plugin-scanner 2.2.100__tar.gz → 2.2.102__tar.gz

{plugin_scanner-2.2.100 → plugin_scanner-2.2.102}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.2.100
+Version: 2.2.102
 Summary: Lint, verify, and gate plugin ecosystems for maintainers, CI, and publish workflows.
 Project-URL: Homepage, https://hol.org/guard
 Project-URL: Security, https://hol.org/guard/security

plugin_scanner-2.2.102/ci/test-suite-ratchet-baseline.json

@@ -0,0 +1,5 @@
+{
+  "maximum_collected_cases": 12662,
+  "maximum_test_source_lines": 289976,
+  "schema_version": 1
+}

{plugin_scanner-2.2.100 → plugin_scanner-2.2.102}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "plugin-scanner"
-version = "2.2.100"
+version = "2.2.102"
 description = "Lint, verify, and gate plugin ecosystems for maintainers, CI, and publish workflows."
 readme = "README.md"
 license = "Apache-2.0"

{plugin_scanner-2.2.100 → plugin_scanner-2.2.102}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.2.100"
+version = "2.2.102"
 description = "Open-source antivirus and runtime protection for AI agents, tools, MCP servers, plugins, skills, and package installs."
 readme = "README.md"
 license = "Apache-2.0"

plugin_scanner-2.2.100/release-metadata/plugin-scanner-v2.2.100.toolchain.cdx.json → plugin_scanner-2.2.102/release-metadata/plugin-scanner-v2.2.102.toolchain.cdx.json

@@ -27,7 +27,7 @@
     "component": {
       "name": "hol-guard-release-toolchain",
       "type": "application",
-      "version": "2.2.100"
+      "version": "2.2.102"
     }
   },
   "specVersion": "1.6",

{plugin_scanner-2.2.100 → plugin_scanner-2.2.102}/src/codex_plugin_scanner/guard/adapters/bounded_cli_hook_bridge.py

@@ -116,17 +116,21 @@ def _validated_frozen_cli_args(
     guard_home: Path,
     harness: str,
 ) -> tuple[str, ...] | None:
-    expected_prefix = (
-        "guard",
-        "hook",
-        "--guard-home",
-        str(guard_home),
-        "--harness",
-        harness,
-    )
-    if tuple(cli_args[: len(expected_prefix)]) != expected_prefix:
+    if len(cli_args) < 6 or tuple(cli_args[:3]) != ("guard", "hook", "--guard-home"):
+        return None
+    supplied_guard_home_value = Path(cli_args[3])
+    if not supplied_guard_home_value.is_absolute() or not guard_home.is_absolute():
         return None
-    tail = cli_args[len(expected_prefix) :]
+    try:
+        supplied_guard_home = supplied_guard_home_value.resolve(strict=False)
+        expected_guard_home = guard_home.resolve(strict=False)
+    except (OSError, RuntimeError):
+        return None
+    if supplied_guard_home != expected_guard_home:
+        return None
+    if tuple(cli_args[4:6]) != ("--harness", harness):
+        return None
+    tail = cli_args[6:]
     json_output = bool(tail and tail[-1] == "--json")
     if json_output:
         tail = tail[:-1]
@@ -140,7 +144,14 @@ def _validated_frozen_cli_args(
         if not Path(value).is_absolute():
             return None
         seen_flags.add(flag)
-    command = ("hook", *cli_args[2 : len(cli_args) - int(json_output)])
+    command: tuple[str, ...] = (
+        "hook",
+        "--guard-home",
+        str(expected_guard_home),
+        "--harness",
+        harness,
+        *tail,
+    )
     if json_output:
         command = (*command, "--json")
     return command
@@ -496,22 +507,8 @@ def run_bounded_cli_hook(config: Mapping[str, object], *, input_text: str) -> in
         return _emit_failure(harness=harness, input_text=input_text)
     package_root = Path(package_root_value)
     guard_home = Path(guard_home_value)
-    # Fast path: serve the hook from the already-running daemon (~50ms)
-    # instead of paying a fresh interpreter + full CLI import (~1s).
-    daemon_result = _try_daemon_hook(
-        guard_home=guard_home,
-        harness=harness,
-        input_text=input_text,
-        timeout_seconds=float(timeout_seconds),
-    )
-    if daemon_result is not None:
-        daemon_stdout, daemon_stderr, daemon_exit = daemon_result
-        if daemon_stdout:
-            _ = sys.stdout.write(daemon_stdout)
-        if daemon_stderr:
-            print(daemon_stderr, file=sys.stderr)
-        return daemon_exit
-    if frozen_launcher:
+    runtime_frozen = bool(getattr(sys, "frozen", False))
+    if runtime_frozen:
         direct_cli_args = _validated_frozen_cli_args(
             cli_args,
             guard_home=guard_home,
@@ -520,12 +517,29 @@ def run_bounded_cli_hook(config: Mapping[str, object], *, input_text: str) -> in
         if direct_cli_args is None:
             return _emit_failure(harness=harness, input_text=input_text)
         command = (sys.executable, *direct_cli_args)
+    elif frozen_launcher:
+        return _emit_failure(harness=harness, input_text=input_text)
     else:
         command = isolated_guard_cli_command(
             python_executable,
             package_root,
             cli_args,
         )
+    # Fast path: serve an already-validated hook through the running daemon (~50ms)
+    # instead of paying a fresh interpreter + full CLI import (~1s).
+    daemon_result = _try_daemon_hook(
+        guard_home=guard_home,
+        harness=harness,
+        input_text=input_text,
+        timeout_seconds=float(timeout_seconds),
+    )
+    if daemon_result is not None:
+        daemon_stdout, daemon_stderr, daemon_exit = daemon_result
+        if daemon_stdout:
+            _ = sys.stdout.write(daemon_stdout)
+        if daemon_stderr:
+            print(daemon_stderr, file=sys.stderr)
+        return daemon_exit
     result = run_isolated_hook_process(
         command,
         input_text=input_text,

{plugin_scanner-2.2.100 → plugin_scanner-2.2.102}/src/codex_plugin_scanner/guard/cli/update_commands.py

@@ -25,6 +25,7 @@ from urllib.parse import ParseResult, urlparse
 from packaging.specifiers import InvalidSpecifier, SpecifierSet
 from packaging.version import InvalidVersion, Version
 
+from ... import version as package_version
 from ..adapters.base import HarnessContext
 from ..adapters.codex import CodexHarnessAdapter, codex_native_hook_state
 from ..adapters.cursor_hooks import cursor_native_hook_state
@@ -1007,6 +1008,16 @@ def _expected_script_dir(installer_binary: str, installer: str) -> Path | None:
 
 
 def build_guard_install_surface_payload() -> dict[str, object]:
+    if _is_desktop_managed_runtime():
+        return {
+            "installer": "desktop",
+            "binary_diagnostics": {
+                "resolved_hol_guard": str(Path(sys.executable).resolve()),
+                "installer_binary": None,
+                "expected_script_dir": None,
+                "path_status": "bundled",
+            },
+        }
     installer = _installer_kind()
     return {
         "installer": installer,
@@ -1505,7 +1516,29 @@ def _current_version() -> str:
     try:
         return importlib.metadata.version("hol-guard")
     except importlib.metadata.PackageNotFoundError:
-        return "unknown"
+        return package_version.__version__ if _is_frozen_runtime() else "unknown"
+
+
+def _is_frozen_runtime() -> bool:
+    return getattr(sys, "frozen", False) is True
+
+
+def _is_desktop_managed_runtime() -> bool:
+    return _is_frozen_runtime() and os.environ.get("HOL_GUARD_DESKTOP") == "1"
+
+
+def _runtime_package_path() -> Path:
+    return Path(__file__).resolve()
+
+
+def _runtime_installer_kind() -> str | None:
+    for parent in _runtime_package_path().parents:
+        normalized_parent = parent.as_posix().lower()
+        if "/pipx/venvs/" in normalized_parent and (parent / "pipx_metadata.json").is_file():
+            return "pipx"
+        if "/uv/tools/" in normalized_parent and (parent / "pyvenv.cfg").is_file():
+            return "uv"
+    return None
 
 
 def _installer_kind() -> str:
@@ -1517,7 +1550,7 @@ def _installer_kind() -> str:
         return "pipx"
     if "/pipx/venvs/" in normalized_prefix:
         return "pipx"
-    return "pip"
+    return _runtime_installer_kind() or "pip"
 
 
 def _should_upgrade_from_pypi(
@@ -2615,7 +2648,15 @@ def build_guard_update_status_payload(*, guard_home: Path | None = None) -> dict
     blocked_reason: str | None = None
     trusted_failure_reason: str | None = None
     recovery_reinstall_available = False
-    installed_distribution: InstalledDistribution | None = None
+    installed_distribution = (
+        InstalledDistribution(
+            name="hol-guard",
+            version=_current_version(),
+            root=Path(sys.executable).resolve().parent,
+        )
+        if installer == "desktop"
+        else None
+    )
 
     if managed_state.status != "absent" and managed_policy is None:
         auto_updatable = False
@@ -2630,6 +2671,9 @@ def build_guard_update_status_payload(*, guard_home: Path | None = None) -> dict
     ):
         auto_updatable = False
         blocked_reason = "An organization-configured package source is required."
+    elif installer == "desktop":
+        auto_updatable = False
+        blocked_reason = "Updates are managed by HOL Guard Desktop."
     else:
         try:
             installed_distribution = _status_installed_distribution(
@@ -2658,11 +2702,11 @@ def build_guard_update_status_payload(*, guard_home: Path | None = None) -> dict
             network_policy=(managed_policy.network if managed_policy is not None else ManagedNetworkPolicy()),
             include_alpha=include_alpha,
         )
-        if installed_distribution is not None
+        if installed_distribution is not None and installer != "desktop"
         else {
             "source": source_kind,
-            "status": "unavailable",
-            "current_version": None,
+            "status": "managed" if installer == "desktop" else "unavailable",
+            "current_version": current_version if installer == "desktop" else None,
             "latest_version": None,
             "update_available": None,
         }

{plugin_scanner-2.2.100 → plugin_scanner-2.2.102}/src/codex_plugin_scanner/guard/daemon/manager.py

@@ -186,6 +186,10 @@ def _daemon_launcher_env(
             "PYTHONSAFEPATH": "1",
         }
     )
+    if getattr(sys, "frozen", False) is True:
+        env["PYINSTALLER_RESET_ENVIRONMENT"] = "1"
+        if os.environ.get("HOL_GUARD_DESKTOP") == "1":
+            env["HOL_GUARD_DESKTOP"] = "1"
     if os.name == "nt":
         env["USERPROFILE"] = str(trusted_home)
     if guard_home is not None and not _guard_home_is_ephemeral(guard_home):

{plugin_scanner-2.2.100 → plugin_scanner-2.2.102}/src/codex_plugin_scanner/version.py

@@ -1,3 +1,3 @@
 """Single source of truth for tool version."""
 
-__version__ = "2.2.100"
+__version__ = "2.2.102"

{plugin_scanner-2.2.100 → plugin_scanner-2.2.102}/tests/test_bounded_cli_hook_bridge.py

@@ -147,6 +147,7 @@ def test_frozen_fallback_runs_supported_cli_subcommand_without_python_flags(
     config = _config(tmp_path, harness="grok")
     config["python_executable"] = "/Applications/HOL Guard.app/Contents/MacOS/hol-guard"
     config["frozen_launcher"] = True
+    monkeypatch.setattr(bounded_cli_hook_bridge.sys, "frozen", True, raising=False)
     monkeypatch.setattr(bounded_cli_hook_bridge.sys, "executable", config["python_executable"])
     monkeypatch.setattr(bounded_cli_hook_bridge, "_try_daemon_hook", lambda **kwargs: None)
     monkeypatch.setattr(bounded_cli_hook_bridge, "run_isolated_hook_process", run)
@@ -172,6 +173,7 @@ def test_frozen_fallback_rejects_forged_executable_and_arguments(
     config["python_executable"] = "/bin/sh"
     config["cli_args"] = ["-c", "echo bypassed"]
     config["frozen_launcher"] = True
+    monkeypatch.setattr(bounded_cli_hook_bridge.sys, "frozen", True, raising=False)
     monkeypatch.setattr(bounded_cli_hook_bridge, "_try_daemon_hook", lambda **kwargs: None)
 
     def forbidden_runner(*args: object, **kwargs: object) -> BoundedHookProcessResult:
@@ -187,6 +189,89 @@ def test_frozen_fallback_rejects_forged_executable_and_arguments(
     assert _json_object(output.getvalue())["decision"] == "deny"
 
 
+def test_live_frozen_runtime_ignores_forged_config_mode_and_executable(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    observed: list[str] = []
+
+    def run(command: Sequence[str], **kwargs: object) -> BoundedHookProcessResult:
+        del kwargs
+        observed.extend(command)
+        return BoundedHookProcessResult(0, '{"decision":"allow"}\n', False, False)
+
+    config = _config(tmp_path, harness="grok")
+    config["python_executable"] = "/bin/sh"
+    config["frozen_launcher"] = False
+    monkeypatch.setattr(bounded_cli_hook_bridge.sys, "frozen", True, raising=False)
+    monkeypatch.setattr(bounded_cli_hook_bridge.sys, "executable", "/app/hol-guard")
+    monkeypatch.setattr(bounded_cli_hook_bridge, "_try_daemon_hook", lambda **kwargs: None)
+    monkeypatch.setattr(bounded_cli_hook_bridge, "run_isolated_hook_process", run)
+
+    assert bounded_cli_hook_bridge.run_bounded_cli_hook(config, input_text="{}") == 0
+    assert observed == [
+        "/app/hol-guard",
+        "hook",
+        "--guard-home",
+        str((tmp_path / "guard-home").resolve()),
+        "--harness",
+        "grok",
+    ]
+
+
+def test_non_frozen_runtime_rejects_forged_frozen_config(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    config = _config(tmp_path, harness="grok")
+    config["frozen_launcher"] = True
+    monkeypatch.delattr(bounded_cli_hook_bridge.sys, "frozen", raising=False)
+    monkeypatch.setattr(bounded_cli_hook_bridge, "_try_daemon_hook", lambda **kwargs: None)
+
+    def forbidden_runner(*args: object, **kwargs: object) -> BoundedHookProcessResult:
+        del args, kwargs
+        raise AssertionError("config must not force frozen dispatch")
+
+    monkeypatch.setattr(bounded_cli_hook_bridge, "run_isolated_hook_process", forbidden_runner)
+    output = io.StringIO()
+    with redirect_stdout(output):
+        returncode = bounded_cli_hook_bridge.run_bounded_cli_hook(config, input_text="{}")
+
+    assert returncode == 0
+    assert _json_object(output.getvalue())["decision"] == "deny"
+
+
+def test_frozen_fallback_accepts_equivalent_noncanonical_guard_home(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    observed: list[str] = []
+
+    def run(command: Sequence[str], **kwargs: object) -> BoundedHookProcessResult:
+        del kwargs
+        observed.extend(command)
+        return BoundedHookProcessResult(0, '{"decision":"allow"}\n', False, False)
+
+    config = _config(tmp_path, harness="grok")
+    cli_args = cast(list[str], config["cli_args"])
+    cli_args[3] = str(tmp_path / "unused" / ".." / "guard-home")
+    config["frozen_launcher"] = True
+    monkeypatch.setattr(bounded_cli_hook_bridge.sys, "frozen", True, raising=False)
+    monkeypatch.setattr(bounded_cli_hook_bridge.sys, "executable", "/app/hol-guard")
+    monkeypatch.setattr(bounded_cli_hook_bridge, "_try_daemon_hook", lambda **kwargs: None)
+    monkeypatch.setattr(bounded_cli_hook_bridge, "run_isolated_hook_process", run)
+
+    assert bounded_cli_hook_bridge.run_bounded_cli_hook(config, input_text="{}") == 0
+    assert observed == [
+        "/app/hol-guard",
+        "hook",
+        "--guard-home",
+        str((tmp_path / "guard-home").resolve()),
+        "--harness",
+        "grok",
+    ]
+
+
 @pytest.mark.parametrize("harness", ["hermes", "openclaw"])
 def test_frozen_fallback_accepts_normalized_json_hook_contract(
     monkeypatch: pytest.MonkeyPatch,
@@ -203,6 +288,7 @@ def test_frozen_fallback_accepts_normalized_json_hook_contract(
     config = _config(tmp_path, harness=harness)
     config["cli_args"] = [*cast(list[str], config["cli_args"]), "--json"]
     config["frozen_launcher"] = True
+    monkeypatch.setattr(bounded_cli_hook_bridge.sys, "frozen", True, raising=False)
     monkeypatch.setattr(bounded_cli_hook_bridge.sys, "executable", "/app/hol-guard")
     monkeypatch.setattr(bounded_cli_hook_bridge, "_try_daemon_hook", lambda **kwargs: None)
     monkeypatch.setattr(bounded_cli_hook_bridge, "run_isolated_hook_process", run)
@@ -292,3 +378,127 @@ def test_oversized_input_uses_configured_harness_native_deny(
 
     assert returncode == 0
     assert _json_object(output.getvalue())["permissionDecision"] == "deny"
+
+
+def test_invalid_frozen_args_deny_before_daemon_dispatch(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    config = _config(tmp_path, harness="grok")
+    config["cli_args"] = ["-c", "echo bypassed"]
+    config["frozen_launcher"] = True
+    monkeypatch.setattr(bounded_cli_hook_bridge.sys, "frozen", True, raising=False)
+
+    def forbidden_daemon(**kwargs: object) -> object:
+        del kwargs
+        raise AssertionError("invalid frozen arguments must not reach the daemon")
+
+    monkeypatch.setattr(bounded_cli_hook_bridge, "_try_daemon_hook", forbidden_daemon)
+    output = io.StringIO()
+    with redirect_stdout(output):
+        returncode = bounded_cli_hook_bridge.run_bounded_cli_hook(config, input_text="{}")
+
+    assert returncode == 0
+    assert _json_object(output.getvalue())["decision"] == "deny"
+
+
+def test_frozen_path_resolution_failure_denies_before_daemon_dispatch(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    config = _config(tmp_path, harness="grok")
+    config["frozen_launcher"] = True
+    monkeypatch.setattr(bounded_cli_hook_bridge.sys, "frozen", True, raising=False)
+
+    def fail_resolve(self: Path, *, strict: bool = False) -> Path:
+        del self, strict
+        raise RuntimeError("symlink loop")
+
+    def forbidden_daemon(**kwargs: object) -> object:
+        del kwargs
+        raise AssertionError("unresolved frozen paths must not reach the daemon")
+
+    monkeypatch.setattr(bounded_cli_hook_bridge.Path, "resolve", fail_resolve)
+    monkeypatch.setattr(bounded_cli_hook_bridge, "_try_daemon_hook", forbidden_daemon)
+    output = io.StringIO()
+    with redirect_stdout(output):
+        returncode = bounded_cli_hook_bridge.run_bounded_cli_hook(config, input_text="{}")
+
+    assert returncode == 0
+    assert _json_object(output.getvalue())["decision"] == "deny"
+
+
+def test_valid_frozen_args_retain_daemon_fast_path(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    config = _config(tmp_path, harness="grok")
+    config["frozen_launcher"] = True
+    monkeypatch.setattr(bounded_cli_hook_bridge.sys, "frozen", True, raising=False)
+    monkeypatch.setattr(bounded_cli_hook_bridge.sys, "executable", "/app/hol-guard")
+    monkeypatch.setattr(
+        bounded_cli_hook_bridge,
+        "_try_daemon_hook",
+        lambda **kwargs: ('{"decision":"allow"}\n', "", 0),
+    )
+
+    def forbidden_runner(*args: object, **kwargs: object) -> BoundedHookProcessResult:
+        del args, kwargs
+        raise AssertionError("valid daemon result must avoid fallback startup")
+
+    monkeypatch.setattr(bounded_cli_hook_bridge, "run_isolated_hook_process", forbidden_runner)
+    output = io.StringIO()
+    with redirect_stdout(output):
+        returncode = bounded_cli_hook_bridge.run_bounded_cli_hook(config, input_text="{}")
+
+    assert returncode == 0
+    assert _json_object(output.getvalue())["decision"] == "allow"
+
+
+def test_relative_frozen_guard_home_denies_before_daemon_dispatch(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    config = _config(tmp_path, harness="grok")
+    cli_args = cast(list[str], config["cli_args"])
+    cli_args[3] = "guard-home"
+    config["frozen_launcher"] = True
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setattr(bounded_cli_hook_bridge.sys, "frozen", True, raising=False)
+
+    def forbidden_daemon(**kwargs: object) -> object:
+        del kwargs
+        raise AssertionError("relative frozen Guard home must not reach the daemon")
+
+    monkeypatch.setattr(bounded_cli_hook_bridge, "_try_daemon_hook", forbidden_daemon)
+    output = io.StringIO()
+    with redirect_stdout(output):
+        returncode = bounded_cli_hook_bridge.run_bounded_cli_hook(config, input_text="{}")
+
+    assert returncode == 0
+    assert _json_object(output.getvalue())["decision"] == "deny"
+
+
+def test_relative_configured_guard_home_denies_before_daemon_dispatch(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    config = _config(tmp_path, harness="grok")
+    config["guard_home"] = "guard-home"
+    cli_args = cast(list[str], config["cli_args"])
+    cli_args[3] = "guard-home"
+    config["frozen_launcher"] = True
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setattr(bounded_cli_hook_bridge.sys, "frozen", True, raising=False)
+
+    def forbidden_daemon(**kwargs: object) -> object:
+        del kwargs
+        raise AssertionError("relative configured Guard home must not reach the daemon")
+
+    monkeypatch.setattr(bounded_cli_hook_bridge, "_try_daemon_hook", forbidden_daemon)
+    output = io.StringIO()
+    with redirect_stdout(output):
+        returncode = bounded_cli_hook_bridge.run_bounded_cli_hook(config, input_text="{}")
+
+    assert returncode == 0
+    assert _json_object(output.getvalue())["decision"] == "deny"

{plugin_scanner-2.2.100 → plugin_scanner-2.2.102}/tests/test_dashboard_update.py

@@ -18,6 +18,7 @@ import pytest
 
 from codex_plugin_scanner.guard.adapters.base import HarnessContext
 from codex_plugin_scanner.guard.approval_gate import update_settings as update_approval_gate_settings
+from codex_plugin_scanner.guard.cli import update_commands
 from codex_plugin_scanner.guard.cli.update_commands import build_guard_update_status_payload
 from codex_plugin_scanner.guard.config import load_guard_config
 from codex_plugin_scanner.guard.daemon import GuardDaemonServer
@@ -142,6 +143,138 @@ def test_build_guard_update_status_payload_shape(monkeypatch: pytest.MonkeyPatch
     assert payload["update_available"] is True
 
 
+def test_frozen_desktop_status_uses_embedded_version_without_package_probe(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(update_commands, "_is_frozen_runtime", lambda: True)
+    monkeypatch.setenv("HOL_GUARD_DESKTOP", "1")
+    monkeypatch.setattr(update_commands.package_version, "__version__", "3.0.0a160")
+    monkeypatch.setattr(
+        update_commands.importlib.metadata,
+        "version",
+        MagicMock(side_effect=update_commands.importlib.metadata.PackageNotFoundError),
+    )
+    status_probe = MagicMock(side_effect=AssertionError("Desktop must not probe package metadata"))
+    monkeypatch.setattr(update_commands, "_status_installed_distribution", status_probe)
+    version_check = MagicMock(side_effect=AssertionError("Desktop manages Core updates"))
+    monkeypatch.setattr(update_commands, "_version_check_payload", version_check)
+
+    payload = build_guard_update_status_payload()
+
+    assert payload["installer"] == "desktop"
+    assert payload["current_version"] == "3.0.0a160"
+    assert payload["latest_version"] is None
+    assert payload["auto_updatable"] is False
+    assert payload["update_available"] is False
+    assert payload["blocked_reason"] == "Updates are managed by HOL Guard Desktop."
+    assert "reason_code" not in payload
+    assert payload["version_check"] == {
+        "source": "pypi",
+        "status": "managed",
+        "current_version": "3.0.0a160",
+        "latest_version": None,
+        "update_available": None,
+    }
+    status_probe.assert_not_called()
+    version_check.assert_not_called()
+
+
+def test_frozen_runtime_without_desktop_marker_keeps_installer_detection(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(update_commands, "_is_frozen_runtime", lambda: True)
+    monkeypatch.delenv("HOL_GUARD_DESKTOP", raising=False)
+    monkeypatch.setattr(update_commands, "_installer_kind", lambda: "pip")
+
+    payload = update_commands.build_guard_install_surface_payload()
+
+    assert payload["installer"] == "pip"
+    assert cast(dict[str, object], payload["binary_diagnostics"])["path_status"] != "bundled"
+
+
+@pytest.mark.parametrize(
+    ("installer_root", "marker_name", "expected_installer"),
+    [
+        ("pipx/venvs/hol-guard", "pipx_metadata.json", "pipx"),
+        ("uv/tools/hol-guard", "pyvenv.cfg", "uv"),
+    ],
+)
+def test_installer_kind_uses_authenticated_runtime_path_when_prefix_isolated(
+    installer_root: str,
+    marker_name: str,
+    expected_installer: str,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    base_prefix = tmp_path / "python-runtime"
+    base_prefix.mkdir()
+    runtime_root = tmp_path / installer_root
+    runtime_path = runtime_root / "lib/python3/site-packages/guard/update_commands.py"
+    runtime_path.parent.mkdir(parents=True)
+    (runtime_root / marker_name).write_text("{}", encoding="utf-8")
+    monkeypatch.setattr(update_commands.sys, "prefix", str(base_prefix))
+    monkeypatch.setattr(update_commands, "_runtime_package_path", lambda: runtime_path)
+
+    assert update_commands._installer_kind() == expected_installer
+
+
+def test_installer_kind_rejects_unmarked_runtime_path(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    base_prefix = tmp_path / "python-runtime"
+    base_prefix.mkdir()
+    runtime_path = tmp_path / "pipx/venvs/hol-guard/lib/python3/site-packages/guard/update_commands.py"
+    runtime_path.parent.mkdir(parents=True)
+    monkeypatch.setattr(update_commands.sys, "prefix", str(base_prefix))
+    monkeypatch.setattr(update_commands, "_runtime_package_path", lambda: runtime_path)
+
+    assert update_commands._installer_kind() == "pip"
+
+
+def test_update_status_recovers_pipx_authority_from_isolated_daemon_runtime(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    base_prefix = tmp_path / "python-runtime"
+    base_prefix.mkdir()
+    runtime_root = tmp_path / "pipx/venvs/hol-guard"
+    runtime_path = runtime_root / "lib/python3/site-packages/guard/update_commands.py"
+    runtime_path.parent.mkdir(parents=True)
+    (runtime_root / "pipx_metadata.json").write_text("{}", encoding="utf-8")
+    monkeypatch.setattr(update_commands.sys, "prefix", str(base_prefix))
+    monkeypatch.setattr(update_commands, "_runtime_package_path", lambda: runtime_path)
+
+    def status_distribution(**kwargs: object) -> update_commands.InstalledDistribution:
+        assert kwargs["installer"] == "pipx"
+        return update_commands.InstalledDistribution(
+            name="hol-guard",
+            version="3.0.0a160",
+            root=runtime_root,
+        )
+
+    monkeypatch.setattr(update_commands, "_status_installed_distribution", status_distribution)
+    monkeypatch.setattr(
+        update_commands,
+        "_version_check_payload",
+        lambda current_version, **_kwargs: {
+            "source": "pypi",
+            "status": "current",
+            "current_version": current_version,
+            "latest_version": current_version,
+            "update_available": False,
+        },
+    )
+
+    payload = build_guard_update_status_payload(guard_home=tmp_path / "guard-home")
+
+    assert payload["installer"] == "pipx"
+    assert payload["current_version"] == "3.0.0a160"
+    assert payload["auto_updatable"] is True
+    assert payload["blocked_reason"] is None
+    assert "reason_code" not in payload
+
+
 def test_update_status_uses_persisted_alpha_channel(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
     guard_home = tmp_path / "guard-home"
     guard_home.mkdir()