plugin-scanner 2.0.785__tar.gz → 2.0.786__tar.gz

{plugin_scanner-2.0.785 → plugin_scanner-2.0.786}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.785
+Version: 2.0.786
 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.785 → plugin_scanner-2.0.786}/pyproject.toml

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

{plugin_scanner-2.0.785 → plugin_scanner-2.0.786}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.785"
+version = "2.0.786"
 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.785 → plugin_scanner-2.0.786}/src/codex_plugin_scanner/guard/config.py

@@ -781,6 +781,7 @@ def _copy_guard_database(*, source: Path, destination: Path) -> None:
                 progress=lambda *_: _raise_when_backup_deadline_elapsed(deadline),
                 sleep=GUARD_DB_BACKUP_SLEEP_SECONDS,
             )
+        _prune_retired_guard_db_sync_state(temporary_destination)
         temporary_destination.replace(destination)
     except (TimeoutError, sqlite3.Error):
         if temporary_destination.exists():
@@ -788,6 +789,14 @@ def _copy_guard_database(*, source: Path, destination: Path) -> None:
         raise GuardHomeMigrationError("guard.db migration failed") from None
 
 
+def _prune_retired_guard_db_sync_state(database_path: Path) -> None:
+    try:
+        with sqlite3.connect(database_path) as connection:
+            connection.execute("delete from sync_state where state_key in ('credentials', 'oauth_local_credentials')")
+    except sqlite3.Error:
+        return
+
+
 def _raise_when_backup_deadline_elapsed(deadline: float) -> None:
     if time.monotonic() >= deadline:
         raise TimeoutError("guard.db migration timed out")

plugin_scanner-2.0.786/src/codex_plugin_scanner/guard/local_trust_contract.py

@@ -0,0 +1,51 @@
+"""Stable local trust vocabulary shared by Guard runtime and UI APIs."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+LocalTrustMode = Literal[
+    "protected",
+    "cloud_authoritative",
+    "degraded_safe",
+    "setup_required",
+    "unsupported",
+]
+
+PolicyIntegrityMode = Literal["protected", "degraded"]
+PolicyIntegrityEnforcement = Literal["enforce", "warn"]
+
+POLICY_INTEGRITY_MODE_PROTECTED: PolicyIntegrityMode = "protected"
+POLICY_INTEGRITY_MODE_DEGRADED: PolicyIntegrityMode = "degraded"
+POLICY_INTEGRITY_ENFORCEMENT_ENFORCE: PolicyIntegrityEnforcement = "enforce"
+POLICY_INTEGRITY_ENFORCEMENT_WARN: PolicyIntegrityEnforcement = "warn"
+
+LOCAL_TRUST_MODES: tuple[LocalTrustMode, ...] = (
+    "protected",
+    "cloud_authoritative",
+    "degraded_safe",
+    "setup_required",
+    "unsupported",
+)
+
+POLICY_INTEGRITY_DEGRADED_REASONS: tuple[str, ...] = (
+    "system_keyring_unavailable",
+    "policy_integrity_key_unavailable",
+    "policy_integrity_control_unavailable",
+    "guard_home_symlink",
+    "guard_db_symlink",
+    "guard_home_permissions",
+    "guard_db_permissions",
+    "guard_home_inaccessible",
+    "guard_db_inaccessible",
+)
+
+POLICY_INTEGRITY_REASON_SYSTEM_KEYRING_UNAVAILABLE = "system_keyring_unavailable"
+POLICY_INTEGRITY_REASON_KEY_UNAVAILABLE = "policy_integrity_key_unavailable"
+POLICY_INTEGRITY_REASON_CONTROL_UNAVAILABLE = "policy_integrity_control_unavailable"
+POLICY_INTEGRITY_REASON_GUARD_HOME_SYMLINK = "guard_home_symlink"
+POLICY_INTEGRITY_REASON_GUARD_DB_SYMLINK = "guard_db_symlink"
+POLICY_INTEGRITY_REASON_GUARD_HOME_PERMISSIONS = "guard_home_permissions"
+POLICY_INTEGRITY_REASON_GUARD_DB_PERMISSIONS = "guard_db_permissions"
+POLICY_INTEGRITY_REASON_GUARD_HOME_INACCESSIBLE = "guard_home_inaccessible"
+POLICY_INTEGRITY_REASON_GUARD_DB_INACCESSIBLE = "guard_db_inaccessible"

{plugin_scanner-2.0.785 → plugin_scanner-2.0.786}/src/codex_plugin_scanner/guard/runtime/runner.py

@@ -1169,7 +1169,7 @@ def sync_receipts(
     """Push local receipts to the configured sync endpoint."""
 
     resolved_auth_context = auth_context if auth_context is not None else _resolve_guard_sync_auth_context(store)
-    sync_url = _normalized_receipts_sync_url(_auth_context_sync_url(resolved_auth_context))
+    sync_url = _normalized_receipts_sync_url(_validate_guard_sync_url(_auth_context_sync_url(resolved_auth_context)))
     prior_receipt_cursor = _receipt_sync_cursor_rowid(store)
     receipts = _receipt_sync_rows_for_upload(store, cursor_rowid=prior_receipt_cursor)
     inventory = store.list_inventory()
@@ -1777,7 +1777,7 @@ def sync_guard_events(
     """Push pending GuardEventV1 envelopes to Guard Cloud."""
 
     resolved_auth_context = auth_context if auth_context is not None else _resolve_guard_sync_auth_context(store)
-    sync_url = _guard_events_sync_url(_auth_context_sync_url(resolved_auth_context))
+    sync_url = _guard_events_sync_url(_validate_guard_sync_url(_auth_context_sync_url(resolved_auth_context)))
     previous_summary = store.get_sync_payload("guard_events_v1_summary")
     total_events = 0
     total_accepted = 0
@@ -1931,7 +1931,9 @@ def sync_runtime_session(
     """Publish the active Guard runtime session so the dashboard can show the machine immediately."""
 
     resolved_auth_context = auth_context or _resolve_guard_sync_auth_context(store)
-    sync_url = _normalized_runtime_sessions_sync_url(_auth_context_sync_url(resolved_auth_context))
+    sync_url = _normalized_runtime_sessions_sync_url(
+        _validate_guard_sync_url(_auth_context_sync_url(resolved_auth_context))
+    )
     session_payload = _cloud_runtime_session_payload(store, session)
     body = json.dumps({"session": session_payload}).encode("utf-8")
     request = _guard_sync_request(
@@ -2067,7 +2069,9 @@ def sync_pain_signals(
         raise
     except GuardSyncNotConfiguredError:
         return 0
-    normalized_sync_url = _normalized_receipts_sync_url(_auth_context_sync_url(resolved_auth_context))
+    normalized_sync_url = _normalized_receipts_sync_url(
+        _validate_guard_sync_url(_auth_context_sync_url(resolved_auth_context))
+    )
     cursor_payload = store.get_sync_payload("pain_signal_cursor")
     last_event_id = _last_uploaded_event_id(cursor_payload)
     uploaded_count = 0

{plugin_scanner-2.0.785 → plugin_scanner-2.0.786}/src/codex_plugin_scanner/guard/runtime/supply_chain_package_eval.py

@@ -47,6 +47,7 @@ from .runner import (
     _normalized_receipts_sync_url,
     _resolve_guard_sync_auth_context,
     _urlopen_json_with_timeout_retry,
+    _validate_guard_sync_url,
 )
 from .supply_chain import detect_supply_chain_risk
 from .supply_chain_bundle import (
@@ -277,6 +278,7 @@ def evaluate_package_request_artifact(
         workspace_fingerprint=workspace_fingerprint,
         bundle_meta=bundle_meta,
         bundle_defer_eligible=bundle_defer_eligible,
+        bundle_decision=bundle_evaluation.decision if bundle_evaluation is not None else None,
         store=store,
     )
     if cloud_result is not None and _cloud_result_should_defer_to_bundle(
@@ -611,6 +613,7 @@ def _evaluate_with_cloud(
     workspace_fingerprint: str | None,
     bundle_meta: dict[str, str] | None,
     bundle_defer_eligible: bool,
+    bundle_decision: str | None,
     store: GuardStore,
 ) -> tuple[PackageRequestEvaluation | None, dict[str, object] | None]:
     if workspace_id is None or workspace_fingerprint is None:
@@ -624,10 +627,15 @@ def _evaluate_with_cloud(
         result: str = fail_closed_decision
         return result
 
+    def can_defer_auth_failure_to_bundle() -> bool:
+        if bundle_meta is None or not bundle_defer_eligible:
+            return False
+        return bundle_decision == "block" or resolve_fail_closed_decision() != "block"
+
     try:
         auth_context = _resolve_guard_sync_auth_context(store, allow_primary_repair=False)
     except GuardSyncAuthorizationExpiredError:
-        if bundle_meta is not None and bundle_defer_eligible and resolve_fail_closed_decision() != "block":
+        if can_defer_auth_failure_to_bundle():
             return None, _cloud_fallback_reason(
                 code="cloud_auth_error",
                 message=(
@@ -649,9 +657,46 @@ def _evaluate_with_cloud(
         )
     except GuardSyncNotConfiguredError:
         return None, None
+    except RuntimeError:
+        if can_defer_auth_failure_to_bundle():
+            return None, _cloud_fallback_reason(
+                code="cloud_auth_error",
+                message=(
+                    "Guard cloud evaluation was not authorized, so Guard fell back to signed bundle intelligence."
+                ),
+            )
+        return (
+            _cloud_fail_closed_evaluation(
+                code="cloud_auth_error",
+                message="Guard cloud evaluation was not authorized, so this package request needs review.",
+                artifact=artifact,
+                targets=targets,
+                workspace_dir=workspace_dir,
+                workspace_fingerprint=workspace_fingerprint,
+                bundle_meta=bundle_meta,
+                fail_closed_decision=resolve_fail_closed_decision(),
+            ),
+            None,
+        )
     sync_url = _optional_string(auth_context.get("sync_url"))
     if sync_url is None:
         return None, None
+    try:
+        sync_url = _validate_guard_sync_url(sync_url, issuer=_optional_string(auth_context.get("issuer")))
+    except GuardSyncNotConfiguredError:
+        return (
+            _cloud_fail_closed_evaluation(
+                code="cloud_validation_error",
+                message="Guard cloud evaluation endpoint was not trusted, so this package request needs review.",
+                artifact=artifact,
+                targets=targets,
+                workspace_dir=workspace_dir,
+                workspace_fingerprint=workspace_fingerprint,
+                bundle_meta=bundle_meta,
+                fail_closed_decision=resolve_fail_closed_decision(),
+            ),
+            None,
+        )
     evaluate_url = _normalized_supply_chain_evaluate_url(sync_url, workspace_id)
     request_payload = _build_request_payload(
         artifact=artifact,

{plugin_scanner-2.0.785 → plugin_scanner-2.0.786}/src/codex_plugin_scanner/guard/store.py

@@ -26,6 +26,20 @@ from cryptography.fernet import Fernet, InvalidToken
 from .approval_gate import ApprovalGateGrant, require_policy_clear, require_policy_write, require_request_resolution
 from .cli.oauth_client import resolve_guard_oauth_client_config
 from .edge_events import build_receipt_event
+from .local_trust_contract import (
+    POLICY_INTEGRITY_ENFORCEMENT_ENFORCE,
+    POLICY_INTEGRITY_MODE_DEGRADED,
+    POLICY_INTEGRITY_MODE_PROTECTED,
+    POLICY_INTEGRITY_REASON_CONTROL_UNAVAILABLE,
+    POLICY_INTEGRITY_REASON_GUARD_DB_INACCESSIBLE,
+    POLICY_INTEGRITY_REASON_GUARD_DB_PERMISSIONS,
+    POLICY_INTEGRITY_REASON_GUARD_DB_SYMLINK,
+    POLICY_INTEGRITY_REASON_GUARD_HOME_INACCESSIBLE,
+    POLICY_INTEGRITY_REASON_GUARD_HOME_PERMISSIONS,
+    POLICY_INTEGRITY_REASON_GUARD_HOME_SYMLINK,
+    POLICY_INTEGRITY_REASON_KEY_UNAVAILABLE,
+    POLICY_INTEGRITY_REASON_SYSTEM_KEYRING_UNAVAILABLE,
+)
 from .models import GuardApprovalRequest, GuardArtifact, GuardReceipt, GuardRuntimeState, PolicyDecision
 from .policy_integrity import (
     REMOTE_POLICY_SOURCES,
@@ -162,6 +176,7 @@ from .types import CapabilitySet, TransportKind
 
 _POLICY_INTEGRITY_KEY_REF = "guard-policy-integrity-key"
 _POLICY_INTEGRITY_CONTROL_REF = "guard-policy-integrity-control"
+_POLICY_INTEGRITY_SERVICE_NAME = "hol-guard.policy-integrity"
 _OAUTH_LOCAL_CREDENTIALS_REF = "guard-oauth-local-credentials"
 _OAUTH_LOCAL_CREDENTIALS_STATE_KEY = "oauth_local_credentials"
 _OAUTH_LOCAL_CREDENTIALS_HASH_KEY = "credentials_sha256"
@@ -592,10 +607,18 @@ class SystemKeyringSecretStore:
 
     def get_secret_with_timeout(self, secret_id: str, *, timeout_seconds: float = 0.0) -> str | None:
         _ = timeout_seconds
-        if self._supports_native_macos_security_reads():
-            return self._get_secret_without_macos_ui(secret_id)
         if sys.platform == "darwin":
+            if self.service_name == _POLICY_INTEGRITY_SERVICE_NAME:
+                # Passive Guard paths must never touch macOS Keychain. Even
+                # no-UI Security-framework reads can regress into OS prompts
+                # when the user keychain is missing, locked, or owned by
+                # another ACL.
+                return None
+            if self._supports_native_macos_security_reads():
+                return self._get_secret_without_macos_ui(secret_id)
             return None
+        if self._supports_native_macos_security_reads():
+            return self._get_secret_without_macos_ui(secret_id)
         return self.get_secret(secret_id)
 
     def delete_secret(self, secret_id: str) -> None:
@@ -900,7 +923,7 @@ def _build_policy_integrity_secret_store() -> SystemKeyringSecretStore | None:
         # Policy integrity is passive hardening; it must never raise Keychain UI.
         return None
     if SystemKeyringSecretStore._backend_is_available():
-        return SystemKeyringSecretStore(service_name="hol-guard.policy-integrity")
+        return SystemKeyringSecretStore(service_name=_POLICY_INTEGRITY_SERVICE_NAME)
     return None
 
 
@@ -1223,23 +1246,23 @@ class GuardStore:
     def _policy_integrity_path_warnings(self) -> list[str]:
         warnings: list[str] = []
         if self.guard_home.is_symlink():
-            warnings.append("guard_home_symlink")
+            warnings.append(POLICY_INTEGRITY_REASON_GUARD_HOME_SYMLINK)
         if self.path.exists() and self.path.is_symlink():
-            warnings.append("guard_db_symlink")
+            warnings.append(POLICY_INTEGRITY_REASON_GUARD_DB_SYMLINK)
         if os.name == "nt":
             return warnings
         try:
             if self.guard_home.stat().st_mode & 0o077:
-                warnings.append("guard_home_permissions")
+                warnings.append(POLICY_INTEGRITY_REASON_GUARD_HOME_PERMISSIONS)
         except OSError:
-            warnings.append("guard_home_inaccessible")
+            warnings.append(POLICY_INTEGRITY_REASON_GUARD_HOME_INACCESSIBLE)
         if not self.path.exists():
             return warnings
         try:
             if self.path.stat().st_mode & 0o077:
-                warnings.append("guard_db_permissions")
+                warnings.append(POLICY_INTEGRITY_REASON_GUARD_DB_PERMISSIONS)
         except OSError:
-            warnings.append("guard_db_inaccessible")
+            warnings.append(POLICY_INTEGRITY_REASON_GUARD_DB_INACCESSIBLE)
         return warnings
 
     @staticmethod
@@ -1481,11 +1504,11 @@ class GuardStore:
             else self._policy_integrity_secret_material(create=create_key)
         )
         if self._policy_integrity_secret_store is None:
-            warnings.append("system_keyring_unavailable")
+            warnings.append(POLICY_INTEGRITY_REASON_SYSTEM_KEYRING_UNAVAILABLE)
         elif raw_key is None or key_id is None:
-            warnings.append("policy_integrity_key_unavailable")
+            warnings.append(POLICY_INTEGRITY_REASON_KEY_UNAVAILABLE)
         if trusted_state is None:
-            warnings.append("policy_integrity_control_unavailable")
+            warnings.append(POLICY_INTEGRITY_REASON_CONTROL_UNAVAILABLE)
         if not warnings and trusted_state is not None and raw_key is not None and key_id is not None:
             try:
                 trusted_state = self._reconcile_policy_integrity_pending_generation(
@@ -1495,7 +1518,7 @@ class GuardStore:
                     trusted_state=trusted_state,
                 )
             except RuntimeError:
-                warnings.append("policy_integrity_control_unavailable")
+                warnings.append(POLICY_INTEGRITY_REASON_CONTROL_UNAVAILABLE)
         has_only_signed_rows = self._count_legacy_local_policy_rows(connection) == 0
         if (
             not warnings
@@ -1506,12 +1529,12 @@ class GuardStore:
             next_trusted_state = dict(trusted_state)
             next_trusted_state["cutover_complete"] = True
             if not self._store_policy_integrity_control_state(next_trusted_state):
-                warnings.append("policy_integrity_control_unavailable")
+                warnings.append(POLICY_INTEGRITY_REASON_CONTROL_UNAVAILABLE)
             else:
                 trusted_state = next_trusted_state
-        mode = "protected" if not warnings else "degraded"
+        mode = POLICY_INTEGRITY_MODE_PROTECTED if not warnings else POLICY_INTEGRITY_MODE_DEGRADED
         cutover_complete = bool(trusted_state.get("cutover_complete")) if trusted_state is not None else False
-        enforcement = "enforce" if mode == "protected" and cutover_complete else "warn"
+        enforcement = POLICY_INTEGRITY_ENFORCEMENT_ENFORCE
         payload: dict[str, object] = {
             "backend": self._policy_integrity_backend_name(),
             "cutover_complete": cutover_complete,
@@ -2932,33 +2955,6 @@ class GuardStore:
                         state=state,
                     )
                     break
-                if _warn_only_policy_integrity_status(
-                    integrity_result.status,
-                    state,
-                    source=str(candidate["source"]),
-                ):
-                    events.append(
-                        (
-                            "policy_integrity_warning",
-                            {
-                                "decision_id": int(candidate["decision_id"]),
-                                "harness": str(candidate["harness"]),
-                                "artifact_id": candidate["artifact_id"],
-                                "integrity_status": integrity_result.status,
-                            },
-                        )
-                    )
-                    _store_logger.warning(
-                        "Guard honored local policy decision %s while integrity enforcement is warn (%s).",
-                        candidate["decision_id"],
-                        integrity_result.status,
-                    )
-                    selected_payload = self._policy_row_payload(
-                        candidate,
-                        integrity_result=integrity_result,
-                        state=state,
-                    )
-                    break
                 events.append(
                     (
                         "policy_integrity_violation",

{plugin_scanner-2.0.785 → plugin_scanner-2.0.786}/src/codex_plugin_scanner/version.py

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

{plugin_scanner-2.0.785 → plugin_scanner-2.0.786}/tests/test_guard_daemon_manager.py

@@ -24,7 +24,7 @@ def _disable_duplicate_retire(monkeypatch) -> None:
     monkeypatch.setattr(
         daemon_manager_module,
         "_retire_duplicate_guard_daemons",
-        lambda _guard_home, *, keep_port: None,
+        lambda _guard_home, *, keep_port, start_lock_held=False: None,
     )
 
 

{plugin_scanner-2.0.785 → plugin_scanner-2.0.786}/tests/test_guard_policy_integrity.py

@@ -12,6 +12,15 @@ from typing import cast
 import pytest
 
 from codex_plugin_scanner.cli import main
+from codex_plugin_scanner.guard import store as guard_store_module
+from codex_plugin_scanner.guard.local_trust_contract import (
+    LOCAL_TRUST_MODES,
+    POLICY_INTEGRITY_DEGRADED_REASONS,
+    POLICY_INTEGRITY_ENFORCEMENT_ENFORCE,
+    POLICY_INTEGRITY_ENFORCEMENT_WARN,
+    POLICY_INTEGRITY_MODE_DEGRADED,
+    POLICY_INTEGRITY_MODE_PROTECTED,
+)
 from codex_plugin_scanner.guard.models import PolicyDecision
 from codex_plugin_scanner.guard.store import GuardStore, SystemKeyringSecretStore
 
@@ -21,10 +30,36 @@ def _fake_policy_integrity_keyring(install_fake_system_keyring) -> None:
     install_fake_system_keyring()
 
 
+@pytest.fixture(autouse=True)
+def _default_store_platform(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(guard_store_module.sys, "platform", "linux", raising=False)
+
+
 def _store(tmp_path: Path) -> GuardStore:
     return GuardStore(tmp_path / "guard-home")
 
 
+def test_local_trust_contract_exports_stable_status_vocabulary() -> None:
+    assert LOCAL_TRUST_MODES == (
+        "protected",
+        "cloud_authoritative",
+        "degraded_safe",
+        "setup_required",
+        "unsupported",
+    )
+    assert POLICY_INTEGRITY_MODE_PROTECTED == "protected"
+    assert POLICY_INTEGRITY_MODE_DEGRADED == "degraded"
+    assert POLICY_INTEGRITY_ENFORCEMENT_ENFORCE == "enforce"
+    assert POLICY_INTEGRITY_ENFORCEMENT_WARN == "warn"
+    assert "system_keyring_unavailable" in POLICY_INTEGRITY_DEGRADED_REASONS
+    assert "policy_integrity_key_unavailable" in POLICY_INTEGRITY_DEGRADED_REASONS
+    assert "policy_integrity_control_unavailable" in POLICY_INTEGRITY_DEGRADED_REASONS
+    assert "guard_home_symlink" in POLICY_INTEGRITY_DEGRADED_REASONS
+    assert "guard_db_symlink" in POLICY_INTEGRITY_DEGRADED_REASONS
+    assert "guard_home_permissions" in POLICY_INTEGRITY_DEGRADED_REASONS
+    assert "guard_db_permissions" in POLICY_INTEGRITY_DEGRADED_REASONS
+
+
 def test_guard_store_init_does_not_create_policy_integrity_keyring_material(tmp_path: Path) -> None:
     store = _store(tmp_path)
     secret_store = store._policy_integrity_secret_store
@@ -173,7 +208,7 @@ def test_upsert_policy_signs_local_row_and_resolve_honors_it(tmp_path: Path) ->
     assert resolved["integrity_status"] == "valid"
 
 
-def test_direct_sqlite_insert_is_ignored_in_enforce_mode(tmp_path: Path) -> None:
+def test_direct_sqlite_insert_is_ignored_when_integrity_is_degraded(tmp_path: Path) -> None:
     store = _store(tmp_path)
     store.upsert_policy(
         _decision(artifact_id="codex:project:baseline", artifact_hash="hash-baseline"),
@@ -365,9 +400,9 @@ def test_policy_integrity_status_and_verify_do_not_create_keyring_material_on_fr
     verify = store.verify_policy_integrity()
 
     assert status["mode"] == "degraded"
-    assert status["enforcement"] == "warn"
+    assert status["enforcement"] == "enforce"
     assert verify["mode"] == "degraded"
-    assert verify["enforcement"] == "warn"
+    assert verify["enforcement"] == "enforce"
     assert verify["local_rows_scanned"] == 0
     assert secret_store.get_secret(store._policy_integrity_key_ref) is None
     assert secret_store.get_secret(store._policy_integrity_control_ref) is None
@@ -377,33 +412,19 @@ def test_policy_integrity_status_skips_passive_macos_keychain_reads(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
+    monkeypatch.setattr(guard_store_module.sys, "platform", "darwin", raising=False)
     store = _store(tmp_path)
     store.upsert_policy(
         _decision(artifact_id="codex:project:passive-skip", artifact_hash="hash-passive-skip"),
         "2026-06-14T00:00:00Z",
     )
-    secret_store = store._policy_integrity_secret_store
-    assert isinstance(secret_store, SystemKeyringSecretStore)
+    assert store._policy_integrity_secret_store is None
     store._clear_policy_integrity_cache()
     monkeypatch.setattr(sys, "platform", "darwin", raising=False)
     monkeypatch.setattr(
         SystemKeyringSecretStore,
         "_supports_native_macos_security_reads",
-        classmethod(lambda cls: False),
-    )
-    monkeypatch.setattr(
-        secret_store,
-        "get_secret_with_timeout",
-        lambda *_args, **_kwargs: (_ for _ in ()).throw(
-            AssertionError("passive policy-integrity status should skip macOS keychain reads")
-        ),
-    )
-    monkeypatch.setattr(
-        store,
-        "_get_secret_from_store",
-        lambda *_args, **_kwargs: (_ for _ in ()).throw(
-            AssertionError("passive policy-integrity status should not use interactive keychain reads")
-        ),
+        classmethod(lambda cls: (_ for _ in ()).throw(AssertionError("passive macOS keychain probe should not run"))),
     )
 
     status = store.get_policy_integrity_status()
@@ -411,8 +432,7 @@ def test_policy_integrity_status_skips_passive_macos_keychain_reads(
 
     assert status["mode"] == "degraded"
     assert verify["mode"] == "degraded"
-    assert "policy_integrity_key_unavailable" in status["degraded_reasons"]
-    assert "policy_integrity_control_unavailable" in status["degraded_reasons"]
+    assert status["degraded_reasons"] == ["system_keyring_unavailable", "policy_integrity_control_unavailable"]
     assert verify["local_rows_scanned"] == 1
 
 
@@ -479,7 +499,7 @@ def test_remote_policy_row_is_honored_without_local_mac(tmp_path: Path) -> None:
     assert resolved == "allow"
 
 
-def test_legacy_unsigned_row_warn_mode_then_trusted_local_write_enforces(tmp_path: Path) -> None:
+def test_legacy_unsigned_row_stays_ignored_before_and_after_trusted_write(tmp_path: Path) -> None:
     store = _store(tmp_path)
     store.upsert_policy(
         _decision(artifact_id="codex:project:legacy", artifact_hash="hash-legacy"),
@@ -507,9 +527,8 @@ def test_legacy_unsigned_row_warn_mode_then_trusted_local_write_enforces(tmp_pat
         now="2026-06-14T00:03:00Z",
     )
 
-    assert warned_status["enforcement"] == "warn"
-    assert warned is not None
-    assert warned["integrity_status"] == "missing_integrity"
+    assert warned_status["enforcement"] == "enforce"
+    assert warned is None
     assert enforced_status["enforcement"] == "enforce"
     assert enforced is None
 
@@ -725,14 +744,14 @@ def test_policies_cli_verify_status_migrate_and_repair(
 
     verify_rc = main(["guard", "policies", "verify", "--home", str(home_dir), "--json"])
     verify_payload = json.loads(capsys.readouterr().out)
-    assert verify_rc == 0
+    assert verify_rc == 1
     assert verify_payload["mode"] == "degraded"
     assert verify_payload["counts"]["degraded_mode"] == 1
 
     status_rc = main(["guard", "policies", "integrity-status", "--home", str(home_dir), "--json"])
     status_payload = json.loads(capsys.readouterr().out)
     assert status_rc == 0
-    assert status_payload["enforcement"] == "warn"
+    assert status_payload["enforcement"] == "enforce"
 
     migrate_rc = main(
         [

{plugin_scanner-2.0.785 → plugin_scanner-2.0.786}/tests/test_guard_runtime.py

@@ -16412,10 +16412,8 @@ def test_sync_receipts_retries_once_after_timeout(tmp_path, monkeypatch):
 def test_sync_receipts_rejects_untrusted_sync_host_before_network(tmp_path, monkeypatch):
     store = GuardStore(tmp_path / "guard-home")
     _seed_guard_cloud(store)
-    credentials_payload = store.get_sync_payload("credentials")
-    assert isinstance(credentials_payload, dict)
-    credentials_payload["sync_url"] = "https://evil.example/api/guard/receipts/sync"
-    store.set_sync_payload("credentials", credentials_payload, "2026-04-19T00:00:01+00:00")
+    assert guard_runner_module._test_sync_auth_context_override is not None
+    guard_runner_module._test_sync_auth_context_override["sync_url"] = "https://evil.example/api/guard/receipts/sync"
     attempted_request = False
 
     def _fake_urlopen(request, timeout):
@@ -16431,6 +16429,46 @@ def test_sync_receipts_rejects_untrusted_sync_host_before_network(tmp_path, monk
     assert attempted_request is False
 
 
+def test_sync_guard_events_rejects_untrusted_sync_host_before_network(tmp_path, monkeypatch):
+    store = GuardStore(tmp_path / "guard-home")
+    attempted_request = False
+
+    def _fake_urlopen(request, timeout):
+        nonlocal attempted_request
+        attempted_request = True
+        raise AssertionError("network call should be blocked before urlopen")
+
+    monkeypatch.setattr(guard_runner_module.urllib.request, "urlopen", _fake_urlopen)
+
+    with pytest.raises(guard_runner_module.GuardSyncNotConfiguredError, match="not trusted"):
+        guard_runner_module.sync_guard_events(
+            store,
+            auth_context={"sync_url": "https://evil.example/api/guard/receipts/sync"},
+        )
+
+    assert attempted_request is False
+
+
+def test_sync_pain_signals_rejects_untrusted_sync_host_before_network(tmp_path, monkeypatch):
+    store = GuardStore(tmp_path / "guard-home")
+    attempted_request = False
+
+    def _fake_urlopen(request, timeout):
+        nonlocal attempted_request
+        attempted_request = True
+        raise AssertionError("network call should be blocked before urlopen")
+
+    monkeypatch.setattr(guard_runner_module.urllib.request, "urlopen", _fake_urlopen)
+
+    with pytest.raises(guard_runner_module.GuardSyncNotConfiguredError, match="not trusted"):
+        guard_runner_module.sync_pain_signals(
+            store,
+            auth_context={"sync_url": "https://evil.example/api/guard/receipts/sync"},
+        )
+
+    assert attempted_request is False
+
+
 def test_sync_receipts_batches_large_local_history(tmp_path, monkeypatch):
     store = GuardStore(tmp_path / "guard-home")
     _seed_guard_cloud(store)
@@ -17978,10 +18016,8 @@ def test_sync_runtime_session_rejects_untrusted_oauth_issuer_before_network(tmp_
 def test_sync_runtime_session_rejects_non_https_legacy_sync_url_before_network(tmp_path, monkeypatch):
     store = GuardStore(tmp_path / "guard-home")
     _seed_guard_cloud(store, workspace_id="workspace-1")
-    credentials_payload = store.get_sync_payload("credentials")
-    assert isinstance(credentials_payload, dict)
-    credentials_payload["sync_url"] = "http://hol.org/api/guard/receipts/sync"
-    store.set_sync_payload("credentials", credentials_payload, "2026-06-01T00:00:01+00:00")
+    assert guard_runner_module._test_sync_auth_context_override is not None
+    guard_runner_module._test_sync_auth_context_override["sync_url"] = "http://hol.org/api/guard/receipts/sync"
     attempted_request = False
 
     def _fake_urlopen(request, timeout):
@@ -18016,10 +18052,8 @@ def test_sync_runtime_session_rejects_non_https_legacy_sync_url_before_network(t
 def test_sync_runtime_session_rejects_unallowlisted_legacy_sync_url_before_network(tmp_path, monkeypatch):
     store = GuardStore(tmp_path / "guard-home")
     _seed_guard_cloud(store, workspace_id="workspace-1")
-    credentials_payload = store.get_sync_payload("credentials")
-    assert isinstance(credentials_payload, dict)
-    credentials_payload["sync_url"] = "https://evil.example/api/guard/receipts/sync"
-    store.set_sync_payload("credentials", credentials_payload, "2026-06-01T00:00:01+00:00")
+    assert guard_runner_module._test_sync_auth_context_override is not None
+    guard_runner_module._test_sync_auth_context_override["sync_url"] = "https://evil.example/api/guard/receipts/sync"
     attempted_request = False
 
     def _fake_urlopen(request, timeout):