plugin-scanner 2.0.830__tar.gz → 2.0.832__tar.gz

{plugin_scanner-2.0.830 → plugin_scanner-2.0.832}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.830
+Version: 2.0.832
 Summary: Lint, verify, and gate plugin ecosystems for maintainers, CI, and publish workflows.
 Project-URL: Homepage, https://github.com/hashgraph-online/hol-guard
 Project-URL: Repository, https://github.com/hashgraph-online/hol-guard

{plugin_scanner-2.0.830 → plugin_scanner-2.0.832}/pyproject.toml

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

{plugin_scanner-2.0.830 → plugin_scanner-2.0.832}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.830"
+version = "2.0.832"
 description = "Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, and OpenCode."
 readme = "README.md"
 license = "Apache-2.0"

{plugin_scanner-2.0.830 → plugin_scanner-2.0.832}/src/codex_plugin_scanner/guard/cli/commands_dispatch_trust.py

@@ -13,8 +13,9 @@ from ..adapters.base import HarnessContext
 from ..config import GuardConfig
 from ..daemon.manager import _guard_daemon_url_port, load_guard_daemon_url, read_approval_center_locator
 from ..local_trust_contract import TrustStatus
+from ..local_trust_controller import macos_native_backend_supported, resolve_passive_trust_state
 from ..policy_integrity import is_remote_policy_source
-from ..store import GuardStore, SystemKeyringSecretStore
+from ..store import GuardStore
 from .commands_support_interaction import _emit
 
 
@@ -30,49 +31,9 @@ def _require_guard_store(store: GuardStore | None) -> GuardStore:
     return _shared_require_guard_store(store)
 
 
-def _degraded_safe_trust_status() -> dict[str, object]:
-    return TrustStatus(
-        runtime_protection="degraded",
-        remembered_rules="disabled_degraded",
-        cloud_policies="setup_unavailable",
-        backend="degraded-safe",
-        setup_available=False,
-    ).to_dict()
-
-
-def _unsupported_backend_payload(*, command: str, backend: str) -> dict[str, object]:
-    return {
-        "generated_at": _now(),
-        "command": command,
-        "backend_requested": backend,
-        "backend": backend,
-        "runtime_protection": "degraded",
-        "remembered_rules": "disabled_degraded",
-        "cloud_policies": "setup_unavailable",
-        "degraded_reasons": ["trust_backend_unavailable"],
-        "degraded_reason_labels": {"trust_backend_unavailable": "Local trust backend unavailable"},
-        "setup_available": backend == "macos-native",
-        "no_ui_passive": True,
-        "passive_prompt_allowed": False,
-        "one_time_approvals": "available",
-        "durable_local_rules": "limited",
-        "cloud_policy_status": "setup_unavailable",
-        "error": (
-            f"Backend {backend!r} is not available for passive {command}. "
-            "Guard will not probe it in the background because that could open an OS credential prompt."
-        ),
-        "next_action": "Use --backend auto or run an explicit setup command when a backend is available.",
-    }
-
-
 def _trust_status_payload(store: GuardStore, *, command: str, backend: str) -> dict[str, object]:
-    if backend == "degraded-safe":
-        trust_status = _degraded_safe_trust_status()
-    else:
-        status_payload = store.get_policy_integrity_status()
-        trust_status = status_payload.get("trust_status")
-        if not isinstance(trust_status, dict):
-            trust_status = TrustStatus.from_policy_integrity_state(status_payload).to_dict()
+    resolved = resolve_passive_trust_state(store, backend_requested=backend)
+    trust_status = resolved.trust_status.to_dict()
     degraded_reasons = trust_status.get("degraded_reasons")
     reasons = (
         [reason for reason in degraded_reasons if isinstance(reason, str)] if isinstance(degraded_reasons, list) else []
@@ -80,11 +41,31 @@ def _trust_status_payload(store: GuardStore, *, command: str, backend: str) -> d
     runtime_protection = str(trust_status.get("runtime_protection") or "unknown")
     remembered_rules = str(trust_status.get("remembered_rules") or "unknown")
     cloud_policies = str(trust_status.get("cloud_policies") or "unknown")
+    actual_backend = trust_status.get("backend")
+    backend_name = (
+        str(actual_backend)
+        if isinstance(actual_backend, str) and actual_backend and actual_backend != "unknown"
+        else resolved.backend_selected
+    )
+    mode = resolved.mode
+    if mode == "unsupported":
+        message = "This local trust backend is unsupported on this platform. Runtime blocking stays active."
+    elif mode == "setup_required":
+        message = "Local trust setup is available. Broad remembered local rules stay limited until you finish it."
+    elif remembered_rules != "enforced":
+        message = (
+            "Guard is blocking risky actions. Broad remembered local rules are limited until local trust is protected."
+        )
+    else:
+        message = "Guard local trust is protected. Remembered local rules are enforced."
     return {
         "generated_at": _now(),
         "command": command,
-        "backend_requested": backend,
-        "backend": trust_status.get("backend") or "unknown",
+        "mode": mode,
+        "backend_requested": resolved.backend_requested,
+        "backend_selected": resolved.backend_selected,
+        "backend_supported": resolved.backend_supported,
+        "backend": backend_name or "unknown",
         "runtime_protection": runtime_protection,
         "remembered_rules": remembered_rules,
         "cloud_policies": cloud_policies,
@@ -96,11 +77,7 @@ def _trust_status_payload(store: GuardStore, *, command: str, backend: str) -> d
         "one_time_approvals": "available",
         "durable_local_rules": "enforced" if remembered_rules == "enforced" else "limited",
         "cloud_policy_status": cloud_policies,
-        "message": (
-            "Guard is blocking risky actions. Broad remembered local rules are limited until local trust is protected."
-            if remembered_rules != "enforced"
-            else "Guard local trust is protected. Remembered local rules are enforced."
-        ),
+        "message": message,
     }
 
 
@@ -303,15 +280,6 @@ def build_trust_explain_payload(store: GuardStore, *, rule_id: int, backend: str
     }
 
 
-def _macos_native_backend_supported(store: GuardStore) -> bool:
-    secret_store = getattr(store, "_policy_integrity_secret_store", None)
-    return (
-        sys.platform == "darwin"
-        and isinstance(secret_store, SystemKeyringSecretStore)
-        and secret_store._supports_native_macos_security_reads()
-    )
-
-
 def _run_guard_trust_command(
     args: argparse.Namespace,
     *,
@@ -327,10 +295,6 @@ def _run_guard_trust_command(
     store = _require_guard_store(store)
     trust_command = getattr(args, "trust_command", None) or "status"
     backend = str(getattr(args, "backend", None) or "auto")
-    if backend == "macos-native" and not _macos_native_backend_supported(store):
-        payload = _unsupported_backend_payload(command=trust_command, backend=backend)
-        _emit(f"trust.{trust_command}", payload, getattr(args, "json", False))
-        return 2
     payload = (
         build_trust_doctor_payload(store, backend=backend)
         if trust_command == "doctor"
@@ -345,8 +309,8 @@ def _run_guard_trust_command(
             _emit("trust.test", payload, getattr(args, "json", False))
             return 2
         payload["probe"] = "passive_no_ui"
-        payload["ok"] = payload["passive_prompt_allowed"] is False
-        payload["trust_health"] = "protected" if payload["remembered_rules"] == "enforced" else "degraded_safe"
+        payload["ok"] = payload["passive_prompt_allowed"] is False and payload.get("mode") != "unsupported"
+        payload["trust_health"] = str(payload.get("mode") or "degraded_safe")
         _emit("trust.test", payload, getattr(args, "json", False))
         return 0
     if trust_command == "explain":
@@ -392,7 +356,7 @@ def _run_guard_trust_command(
             )
             _emit(f"trust.{trust_command}", payload, getattr(args, "json", False))
             return 2
-        if not _macos_native_backend_supported(store):
+        if not macos_native_backend_supported(store):
             payload["error"] = (
                 f"macOS native trust {trust_command} is unavailable. "
                 "Guard will not fall back to a prompt-capable backend."

{plugin_scanner-2.0.830 → plugin_scanner-2.0.832}/src/codex_plugin_scanner/guard/cli/render.py

@@ -727,6 +727,7 @@ def _render_doctor(console: Console, payload: dict[str, object]) -> None:
 
 def _build_trust_doctor_panel(trust: dict[str, object]) -> Panel:
     body = Table.grid(padding=(0, 1))
+    body.add_row("Mode", str(trust.get("mode") or "unknown"))
     body.add_row("Runtime", str(trust.get("runtime_protection") or "unknown"))
     body.add_row("Remembered rules", str(trust.get("remembered_rules") or "unknown"))
     body.add_row("Cloud policies", str(trust.get("cloud_policies") or "unknown"))

{plugin_scanner-2.0.830 → plugin_scanner-2.0.832}/src/codex_plugin_scanner/guard/cli/update_commands.py

@@ -150,6 +150,7 @@ def run_guard_update(
         local_source_install=local_source_install,
     )
     command = _update_command(installer, use_pypi=use_pypi)
+    execution_command = _execution_update_command(command, installer=installer, context=context)
     if force_pypi_reinstall:
         payload["recovery_reinstall"] = True
     payload.update(
@@ -167,7 +168,8 @@ def run_guard_update(
         payload["changed"] = False
         payload["message"] = _planned_update_message(version_check=version_check, use_pypi=use_pypi)
         return payload, 0
-    active_command = command
+    active_command = execution_command
+    active_display_command = command
     attempted_force_retry = False
     nonzero_success_note: str | None = None
     while True:
@@ -184,7 +186,7 @@ def run_guard_update(
             payload["error"] = redact_sensitive_text(str(error))
             payload["message"] = "HOL Guard update failed before the installer started."
             return payload, 1
-        payload["command"] = active_command
+        payload["command"] = active_display_command
         payload["stdout"] = _normalize_output_text(result.stdout)
         payload["stderr"] = _normalize_output_text(result.stderr)
         payload["return_code"] = result.returncode
@@ -231,9 +233,14 @@ def run_guard_update(
                 if isinstance(latest, str) and latest.strip():
                     target_version = latest.strip()
             retry_command = _update_command(installer, use_pypi=True, target_version=target_version)
-            if retry_command != active_command:
+            if retry_command != active_display_command:
                 attempted_force_retry = True
-                active_command = retry_command
+                active_display_command = retry_command
+                active_command = _execution_update_command(
+                    retry_command,
+                    installer=installer,
+                    context=context,
+                )
                 payload["upgrade_source"] = "pypi"
                 continue
         break
@@ -784,6 +791,22 @@ def _update_command(installer: str, *, use_pypi: bool = False, target_version: s
     return [sys.executable, "-m", "pip", "install", "--upgrade", "hol-guard"]
 
 
+def _execution_update_command(
+    command: list[str],
+    *,
+    installer: str,
+    context: HarnessContext | None,
+) -> list[str]:
+    if (
+        installer == "pipx"
+        and context is not None
+        and _package_shim_manifest_has_installed_managers(context)
+        and (real_binary := _resolve_unshimmed_binary(command[0], context))
+    ):
+        return [real_binary, *command[1:]]
+    return command
+
+
 def _vcs_install_payload(direct_url: dict[str, object] | None) -> dict[str, object] | None:
     if not isinstance(direct_url, dict):
         return None
@@ -864,6 +887,28 @@ def _current_version_from_subprocess() -> str:
     return version or _current_version()
 
 
+def _resolve_unshimmed_binary(command_name: str, context: HarnessContext) -> str | None:
+    filtered_path = _path_without_guard_package_shims(context)
+    if not filtered_path:
+        return None
+    return shutil.which(command_name, path=filtered_path)
+
+
+def _path_without_guard_package_shims(context: HarnessContext) -> str:
+    shim_dir = (context.guard_home / "package-shims" / "bin").expanduser().resolve()
+    filtered_entries = []
+    for entry in os.environ.get("PATH", "").split(os.pathsep):
+        if not entry:
+            continue
+        try:
+            if Path(entry).expanduser().resolve() == shim_dir:
+                continue
+        except OSError:
+            pass
+        filtered_entries.append(entry)
+    return os.pathsep.join(filtered_entries)
+
+
 def _refresh_package_shims_after_update(
     *,
     context: HarnessContext | None,

plugin_scanner-2.0.832/src/codex_plugin_scanner/guard/local_trust_controller.py

@@ -0,0 +1,176 @@
+"""Local trust backend selection and passive status resolution."""
+
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass
+
+from .local_trust_contract import (
+    POLICY_INTEGRITY_REASON_BACKEND_TIMEOUT,
+    LocalTrustMode,
+    TrustBackend,
+    TrustBackendUnavailableError,
+    TrustStatus,
+    degraded_reason_for_backend_error,
+    run_trust_backend_check,
+    select_trust_backend,
+)
+from .store import GuardStore, SystemKeyringSecretStore
+
+PASSIVE_TRUST_TIMEOUT_SECONDS = 0.25
+
+
+def macos_native_backend_supported(store: GuardStore) -> bool:
+    secret_store = getattr(store, "_policy_integrity_secret_store", None)
+    return (
+        sys.platform == "darwin"
+        and isinstance(secret_store, SystemKeyringSecretStore)
+        and secret_store._supports_native_macos_security_reads()
+    )
+
+
+def _degraded_safe_status(*, backend: str, reason: str, setup_available: bool = False) -> TrustStatus:
+    return TrustStatus(
+        runtime_protection="degraded",
+        remembered_rules="disabled_degraded",
+        cloud_policies="setup_unavailable",
+        backend=backend,
+        degraded_reasons=(reason,),
+        setup_available=setup_available,
+    )
+
+
+class _DegradedSafeTrustBackend:
+    name = "degraded-safe"
+    priority = 0
+    supported = True
+    passive_no_ui_safe = True
+
+    def status(self) -> TrustStatus:
+        return _degraded_safe_status(backend=self.name, reason="trust_backend_unavailable")
+
+    def sign(self, payload: bytes) -> str:
+        raise TrustBackendUnavailableError("degraded_safe_backend_has_no_signing_material")
+
+    def verify(self, payload: bytes, signature: str) -> bool:
+        del payload, signature
+        return False
+
+    def setup(self) -> TrustStatus:
+        return self.status()
+
+    def revoke(self) -> TrustStatus:
+        return self.status()
+
+
+class _MacOSNativeTrustBackend:
+    name = "macos-native"
+    priority = 100
+
+    def __init__(self, store: GuardStore) -> None:
+        self._store = store
+        self.supported = sys.platform == "darwin"
+        self.passive_no_ui_safe = macos_native_backend_supported(store)
+
+    def status(self) -> TrustStatus:
+        return TrustStatus.from_policy_integrity_state(self._store.get_policy_integrity_status())
+
+    def sign(self, payload: bytes) -> str:
+        raise TrustBackendUnavailableError("macos_native_backend_signing_is_managed_by_guard_store")
+
+    def verify(self, payload: bytes, signature: str) -> bool:
+        del payload, signature
+        return False
+
+    def setup(self) -> TrustStatus:
+        raise TrustBackendUnavailableError("macos_native_backend_setup_is_managed_by_guard_store")
+
+    def revoke(self) -> TrustStatus:
+        raise TrustBackendUnavailableError("macos_native_backend_reset_is_managed_by_guard_store")
+
+
+@dataclass(frozen=True)
+class ResolvedTrustState:
+    mode: LocalTrustMode
+    backend_requested: str
+    backend_selected: str
+    backend_supported: bool
+    passive_no_ui_safe: bool
+    trust_status: TrustStatus
+
+
+def _trust_backends(store: GuardStore) -> tuple[TrustBackend, ...]:
+    return (_MacOSNativeTrustBackend(store), _DegradedSafeTrustBackend())
+
+
+def _backend_by_name(store: GuardStore, backend_requested: str) -> TrustBackend:
+    backends = {backend.name: backend for backend in _trust_backends(store)}
+    return backends.get(backend_requested, _DegradedSafeTrustBackend())
+
+
+def _trust_mode_for_backend(
+    trust_status: TrustStatus,
+    *,
+    backend_requested: str,
+    backend_selected: str,
+    backend_supported: bool,
+    passive_no_ui_safe: bool,
+) -> LocalTrustMode:
+    if trust_status.runtime_protection == "protected" and trust_status.remembered_rules == "enforced":
+        return "protected"
+    if backend_requested != "auto" and not backend_supported:
+        return "unsupported"
+    if backend_selected == "macos-native" and passive_no_ui_safe and trust_status.setup_available:
+        return "setup_required"
+    return "degraded_safe"
+
+
+def resolve_passive_trust_state(
+    store: GuardStore,
+    *,
+    backend_requested: str,
+    timeout_seconds: float = PASSIVE_TRUST_TIMEOUT_SECONDS,
+) -> ResolvedTrustState:
+    if backend_requested == "auto":
+        selected = select_trust_backend(_trust_backends(store), passive=True) or _DegradedSafeTrustBackend()
+    else:
+        selected = _backend_by_name(store, backend_requested)
+    timeout_result = _degraded_safe_status(
+        backend=selected.name,
+        reason=POLICY_INTEGRITY_REASON_BACKEND_TIMEOUT,
+        setup_available=bool(selected.name == "macos-native" and selected.supported and selected.passive_no_ui_safe),
+    )
+    trust_status = run_trust_backend_check(
+        selected.status,
+        timeout_seconds=timeout_seconds,
+        timeout_result=timeout_result,
+        on_error=lambda error: _degraded_safe_status(
+            backend=selected.name,
+            reason=degraded_reason_for_backend_error(error),
+            setup_available=bool(
+                selected.name == "macos-native" and selected.supported and selected.passive_no_ui_safe
+            ),
+        ),
+    )
+    return ResolvedTrustState(
+        mode=_trust_mode_for_backend(
+            trust_status,
+            backend_requested=backend_requested,
+            backend_selected=selected.name,
+            backend_supported=selected.supported,
+            passive_no_ui_safe=selected.passive_no_ui_safe,
+        ),
+        backend_requested=backend_requested,
+        backend_selected=selected.name,
+        backend_supported=selected.supported,
+        passive_no_ui_safe=selected.passive_no_ui_safe,
+        trust_status=trust_status,
+    )
+
+
+__all__ = [
+    "PASSIVE_TRUST_TIMEOUT_SECONDS",
+    "ResolvedTrustState",
+    "macos_native_backend_supported",
+    "resolve_passive_trust_state",
+]

{plugin_scanner-2.0.830 → plugin_scanner-2.0.832}/src/codex_plugin_scanner/version.py

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

{plugin_scanner-2.0.830 → plugin_scanner-2.0.832}/tests/test_guard_phase03_local_install.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import argparse
 import json
+import os
 import subprocess
 from pathlib import Path
 
@@ -133,6 +134,51 @@ def test_update_binary_diagnostics_treats_pipx_shim_as_healthy(monkeypatch: pyte
     assert payload["binary_diagnostics"]["expected_script_dir"] is None
 
 
+def test_update_uses_real_pipx_binary_when_guard_package_shims_are_installed(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    context = _context(tmp_path)
+    manifest_path = context.guard_home / "package-shims" / "manifest.json"
+    manifest_path.parent.mkdir(parents=True, exist_ok=True)
+    manifest_path.write_text(json.dumps({"installed_managers": ["pipx"]}), encoding="utf-8")
+    shim_dir = context.guard_home / "package-shims" / "bin"
+    shim_dir.mkdir(parents=True, exist_ok=True)
+    monkeypatch.setenv("PATH", f"{shim_dir}{os.pathsep}/opt/homebrew/bin")
+    monkeypatch.setattr(update_commands, "_current_version", lambda: "2.0.829")
+    monkeypatch.setattr(update_commands, "_current_version_from_subprocess", lambda: "2.0.830")
+    monkeypatch.setattr(update_commands, "_latest_version_from_pypi", lambda: "2.0.830")
+    monkeypatch.setattr(update_commands, "_direct_url_payload", lambda: None)
+    monkeypatch.setattr(update_commands, "_installer_kind", lambda: "pipx")
+
+    def fake_which(name: str, path: str | None = None) -> str | None:
+        if name == "pipx" and isinstance(path, str) and "/package-shims/bin" not in path:
+            return "/opt/homebrew/bin/pipx"
+        if name == "hol-guard":
+            return "/mock-home/.local/bin/hol-guard"
+        return None
+
+    monkeypatch.setattr(
+        update_commands.shutil,
+        "which",
+        fake_which,
+    )
+    monkeypatch.setattr(update_commands, "_sync_dashboard_assets", lambda: None)
+    monkeypatch.setattr(update_commands, "_refresh_package_shims_after_update", lambda **_: (None, None))
+
+    def fake_run(command: list[str], **kwargs: object) -> subprocess.CompletedProcess[str]:
+        assert command == ["/opt/homebrew/bin/pipx", "upgrade", "hol-guard"]
+        return subprocess.CompletedProcess(command, 0, "installed hol-guard 2.0.830", "")
+
+    monkeypatch.setattr(update_commands.subprocess, "run", fake_run)
+
+    payload, exit_code = update_commands.run_guard_update(dry_run=False, context=context)
+
+    assert exit_code == 0
+    assert payload["status"] == "updated"
+    assert payload["command"] == ["pipx", "upgrade", "hol-guard"]
+
+
 def test_version_check_reports_python_incompatible_latest_release(monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setattr(update_commands, "_latest_version_from_pypi", lambda: "2.0.807")
     monkeypatch.setattr(update_commands, "_latest_version_python_requirements", lambda latest: (">=3.10,<3.14",))

{plugin_scanner-2.0.830 → plugin_scanner-2.0.832}/tests/test_guard_policy_integrity.py

@@ -1058,12 +1058,10 @@ def test_remote_policy_integrity_failure_does_not_emit_local_rule_event(
 
     assert resolved is None
     assert any(
-        event.get("payload", {}).get("artifact_id") == "codex:project:remote-tampered"
-        for event in integrity_events
+        event.get("payload", {}).get("artifact_id") == "codex:project:remote-tampered" for event in integrity_events
     )
     assert not any(
-        event.get("payload", {}).get("artifact_id") == "codex:project:remote-tampered"
-        for event in ignored_events
+        event.get("payload", {}).get("artifact_id") == "codex:project:remote-tampered" for event in ignored_events
     )
 
 
@@ -1460,9 +1458,7 @@ def test_guard_doctor_includes_safe_trust_diagnostics(tmp_path: Path, capsys) ->
     assert trust_payload["one_time_approvals"] == "available"
     assert trust_payload["durable_local_rules"] in {"enforced", "limited"}
     assert trust_payload["checks"]["passive_no_ui"] is True
-    assert trust_payload["checks"]["runtime_protection"] is (
-        trust_payload["runtime_protection"] == "protected"
-    )
+    assert trust_payload["checks"]["runtime_protection"] is (trust_payload["runtime_protection"] == "protected")
     assert trust_payload["official_install"]["package"] == "hol-guard"
     assert trust_payload["official_install"]["update_command"] == "hol-guard update"
     assert trust_payload["approval_center"]["active"] is False
@@ -1497,6 +1493,7 @@ def test_trust_cli_doctor_human_output_uses_trust_renderer(tmp_path: Path, capsy
 
     assert rc == 0
     assert "Local trust" in output
+    assert "Mode" in output
     assert "Passive OS prompts" in output
     assert "Install mode" in output
     assert "hol-guard update" in output
@@ -1721,51 +1718,6 @@ def test_trust_cli_explain_reports_guard_cloud_rule(tmp_path: Path, capsys) -> N
     assert "integrity_status" not in payload["rule"]
 
 
-def test_trust_cli_rejects_unavailable_backend_status(tmp_path: Path, capsys) -> None:
-    home_dir = tmp_path / "home"
-    rc = main(
-        [
-            "guard",
-            "trust",
-            "status",
-            "--backend",
-            "macos-native",
-            "--home",
-            str(home_dir),
-            "--json",
-        ]
-    )
-    payload = json.loads(capsys.readouterr().out)
-
-    assert rc == 2
-    assert payload["backend_requested"] == "macos-native"
-    assert "not available for passive status" in payload["error"]
-    assert payload["passive_prompt_allowed"] is False
-
-
-def test_trust_cli_degraded_safe_backend_is_explicit(tmp_path: Path, capsys) -> None:
-    home_dir = tmp_path / "home"
-    rc = main(
-        [
-            "guard",
-            "trust",
-            "status",
-            "--backend",
-            "degraded-safe",
-            "--home",
-            str(home_dir),
-            "--json",
-        ]
-    )
-    payload = json.loads(capsys.readouterr().out)
-
-    assert rc == 0
-    assert payload["backend_requested"] == "degraded-safe"
-    assert payload["backend"] == "degraded-safe"
-    assert payload["remembered_rules"] == "disabled_degraded"
-    assert payload["durable_local_rules"] == "limited"
-
-
 def test_trust_cli_doctor_degraded_safe_does_not_pass_runtime_check(tmp_path: Path, capsys) -> None:
     home_dir = tmp_path / "home"
     rc = main(