plugin-scanner 2.0.806__tar.gz → 2.0.808__tar.gz

{plugin_scanner-2.0.806 → plugin_scanner-2.0.808}/PKG-INFO

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

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

{plugin_scanner-2.0.806 → plugin_scanner-2.0.808}/pyproject.toml.bak

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

@@ -46,6 +46,7 @@ GUARD_DASHBOARD_URL = "https://hol.org/guard"
 GUARD_INBOX_URL = f"{GUARD_DASHBOARD_URL}/inbox"
 GUARD_FLEET_URL = f"{GUARD_DASHBOARD_URL}/protect"
 GUARD_CONNECT_URL = f"{GUARD_DASHBOARD_URL}/connect"
+_APPROVAL_ONCE_POLICY_TTL = timedelta(minutes=15)
 _WORKSPACE_SCOPED_RUNTIME_ARTIFACT_TYPES = frozenset(
     {
         "file_read_request",
@@ -329,7 +330,7 @@ def apply_approval_resolution(
     resolve_scope_matches: bool = True,
     approval_gate_input: ApprovalGateInput | None = None,
     approval_gate_grant: ApprovalGateGrant | None = None,
-    persist_policy: bool = True,
+    persist_policy: bool | None = None,
 ) -> dict[str, object]:
     request = store.get_approval_request(request_id)
     if request is None:
@@ -374,8 +375,17 @@ def apply_approval_resolution(
         approval_gate_grant=approval_gate_grant,
         now=resolved_at,
     )
-    if persist_policy:
+    if persist_policy is True or (persist_policy is None and scope != "artifact"):
         store.upsert_policy(decision, resolved_at, approval_gate_grant=resolved_gate_grant)
+    elif persist_policy is None and scope == "artifact":
+        store.upsert_policy(
+            replace(
+                decision,
+                expires_at=_approval_once_policy_expires_at(resolved_at),
+            ),
+            resolved_at,
+            approval_gate_grant=resolved_gate_grant,
+        )
     resolution_harness = None if scope == "global" else str(request["harness"])
     if return_queue_result:
         result = store.resolve_request_with_queue_result(
@@ -969,6 +979,11 @@ def _now() -> str:
     return datetime.now(timezone.utc).isoformat()
 
 
+def _approval_once_policy_expires_at(resolved_at: str) -> str:
+    parsed = datetime.fromisoformat(resolved_at.replace("Z", "+00:00"))
+    return (parsed + _APPROVAL_ONCE_POLICY_TTL).isoformat()
+
+
 def _build_runtime_cloud_context(
     store: GuardStore,
     latest_connect_state: dict[str, object] | None,

{plugin_scanner-2.0.806 → plugin_scanner-2.0.808}/src/codex_plugin_scanner/guard/cli/approval_commands.py

@@ -28,7 +28,7 @@ _DEFAULT_RETRY_COPY = "Return to your AI assistant and retry"
 
 
 def _build_retry_hint(action: str, harness: str) -> dict[str, str]:
-    title = "Approved. Retry in chat." if action == "allow" else "Blocked. Guard will remember this decision."
+    title = "Approved. Retry in chat." if action == "allow" else "Blocked. Decision saved."
     return {"title": title, "body": _HARNESS_RETRY_COPY.get(harness, _DEFAULT_RETRY_COPY)}
 
 
@@ -54,6 +54,11 @@ def add_approval_parser(
             default="artifact",
         )
         decision_parser.add_argument("--reason")
+        decision_parser.add_argument(
+            "--remember",
+            action="store_true",
+            help="Save an exact-action remembered rule for artifact scope instead of resolving only this request.",
+        )
         add_common_args(decision_parser)
         decision_parser.add_argument("--json", action="store_true")
         decision_parser.set_defaults(approval_action=action)
@@ -235,6 +240,7 @@ def run_approval_command(
             reason=args.reason,
             now=_now(),
             approval_gate_input=gate_input,
+            persist_policy=True if bool(getattr(args, "remember", False)) else None,
         )
     except ApprovalGateError as error:
         return approval_gate_cli_payload(error)

{plugin_scanner-2.0.806 → plugin_scanner-2.0.808}/src/codex_plugin_scanner/guard/daemon/server.py

@@ -1665,6 +1665,7 @@ class _GuardDaemonHandler(BaseHTTPRequestHandler):
             self._write_json({"resolved": False, "error": "missing_required_fields"}, status=400)
             return
         try:
+            persist_policy = self._approval_persist_policy(payload)
             updated = apply_approval_resolution(
                 store=self.server.store,  # type: ignore[attr-defined]
                 request_id=request_id,
@@ -1675,6 +1676,7 @@ class _GuardDaemonHandler(BaseHTTPRequestHandler):
                 return_queue_result=True,
                 resolve_scope_matches=False,
                 approval_gate_input=approval_gate_input_from_mapping(payload),
+                persist_policy=persist_policy,
             )
         except ApprovalRequestNotFoundError:
             self._write_json(
@@ -3356,6 +3358,13 @@ class _GuardDaemonHandler(BaseHTTPRequestHandler):
                 return False
         raise ValueError("invalid boolean value")
 
+    def _approval_persist_policy(self, payload: dict[str, object]) -> bool | None:
+        if "persist_policy" in payload:
+            return True if self._optional_bool(payload.get("persist_policy"), default=False) else None
+        if "remember" in payload:
+            return True if self._optional_bool(payload.get("remember"), default=False) else None
+        return None
+
     def _write_approval_gate_error(self, error: ApprovalGateError, *, resolved: bool | None = None) -> None:
         payload = error.to_payload()
         if resolved is not None:
@@ -5185,7 +5194,7 @@ _DEFAULT_RETRY_COPY = "Return to your AI assistant and retry"
 
 
 def _build_resolution_copy(action: str, harness: str) -> dict[str, str]:
-    title = "Approved. Retry in chat." if action == "allow" else "Blocked. Guard will remember this decision."
+    title = "Approved. Retry in chat." if action == "allow" else "Blocked. Decision saved."
     return {"title": title, "body": _HARNESS_RETRY_COPY.get(harness, _DEFAULT_RETRY_COPY)}
 
 

{plugin_scanner-2.0.806 → plugin_scanner-2.0.808}/src/codex_plugin_scanner/guard/store.py

@@ -183,6 +183,7 @@ _OAUTH_LOCAL_CREDENTIALS_STATE_KEY = "oauth_local_credentials"
 _OAUTH_LOCAL_CREDENTIALS_HASH_KEY = "credentials_sha256"
 _OAUTH_LOCAL_CREDENTIALS_REF_KEY = "credentials_ref"
 _OAUTH_PRIMARY_SECRET_TIMEOUT_SECONDS = 2.0
+_APPROVAL_GATE_POLICY_SOURCE = "approval-gate"
 _GUARD_CLOUD_RESET_STATE_KEYS = (
     "sync_summary",
     "receipt_sync_cursor",
@@ -198,6 +199,12 @@ _GUARD_CLOUD_RESET_STATE_KEYS = (
     "supply_chain_bundle_daemon",
     "headless_app_sync_summary",
 )
+
+
+def _is_approval_gate_one_shot_policy(row: sqlite3.Row) -> bool:
+    return str(row["source"]) == _APPROVAL_GATE_POLICY_SOURCE and row["expires_at"] is not None
+
+
 _DEVICE_ROW_KEY = "local-device"
 _MAX_RESOLVED_SCOPE_IDS = 200
 _SQLITE_ID_BATCH_SIZE = 500
@@ -1006,11 +1013,14 @@ def _system_keyring_is_available(guard_home: Path, *, use_cache: bool = True) ->
 
 
 def _build_oauth_secret_store(guard_home: Path) -> SecretStore:
+    fallback_store = EncryptedFileSecretStore(guard_home)
     if sys.platform == "darwin":
         if _system_keyring_is_available(guard_home, use_cache=False):
-            return SystemKeyringSecretStore(service_name="hol-guard.oauth")
+            return FallbackSecretStore(
+                SystemKeyringSecretStore(service_name="hol-guard.oauth"),
+                fallback_store,
+            )
         return UnavailableSecretStore(guard_home)
-    fallback_store = EncryptedFileSecretStore(guard_home)
     if _system_keyring_is_available(guard_home):
         return FallbackSecretStore(
             SystemKeyringSecretStore(service_name="hol-guard.oauth"),
@@ -1187,7 +1197,10 @@ class GuardStore:
         self._cached_policy_integrity_control_state = None
 
     def _oauth_primary_reads_are_no_ui_safe(self) -> bool:
-        return sys.platform == "darwin" and isinstance(self._oauth_secret_store, SystemKeyringSecretStore)
+        secret_store = self._oauth_secret_store
+        if isinstance(secret_store, FallbackSecretStore):
+            secret_store = secret_store.primary
+        return sys.platform == "darwin" and isinstance(secret_store, SystemKeyringSecretStore)
 
     def _get_secret_candidates(
         self,
@@ -3087,6 +3100,11 @@ class GuardStore:
                         integrity_result=integrity_result,
                         state=state,
                     )
+                    if _is_approval_gate_one_shot_policy(candidate):
+                        connection.execute(
+                            "delete from policy_decisions where decision_id = ?",
+                            (int(candidate["decision_id"]),),
+                        )
                     break
                 events.append(
                     (
@@ -3954,10 +3972,12 @@ class GuardStore:
                    payload_hash, payload_mac, integrity_key_id, signed_at
             from policy_decisions
         """
-        params: tuple[object, ...] = ()
+        params: tuple[object, ...] = (_APPROVAL_GATE_POLICY_SOURCE,)
+        conditions = ["not (source = ? and expires_at is not null)"]
         if harness is not None:
-            query += " where harness = ?"
-            params = (harness,)
+            conditions.append("harness = ?")
+            params = (_APPROVAL_GATE_POLICY_SOURCE, harness)
+        query += " where " + " and ".join(conditions)
         query += " order by updated_at desc"
         with self._connect() as connection:
             state = self._refresh_policy_integrity_state(connection, now=_now(), create_key=True)
@@ -5486,7 +5506,7 @@ class GuardStore:
                 """
                 select request_id
                 from guard_connect_states
-                where status = 'connected'
+                where status in ('connected', 'retry_required')
                   and milestone != 'first_sync_succeeded'
                 order by updated_at desc
                 limit 1

{plugin_scanner-2.0.806 → plugin_scanner-2.0.808}/src/codex_plugin_scanner/version.py

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

{plugin_scanner-2.0.806 → plugin_scanner-2.0.808}/tests/test_guard_approval_copy_commands.py

@@ -686,7 +686,7 @@ class TestApprovalsRetryHintCommand:
         output = json.loads(capsys.readouterr().out)
 
         assert rc == 0
-        assert output["title"] == "Blocked. Guard will remember this decision."
+        assert output["title"] == "Blocked. Decision saved."
 
     def test_retry_hint_missing_request(self, tmp_path: Path, capsys) -> None:
         """T737: retry-hint with unknown request_id returns error."""

{plugin_scanner-2.0.806 → plugin_scanner-2.0.808}/tests/test_guard_approval_gate.py

@@ -41,6 +41,7 @@ from codex_plugin_scanner.guard.consumer.service import record_policy
 from codex_plugin_scanner.guard.daemon import GuardDaemonServer
 from codex_plugin_scanner.guard.mcp_tool_calls import allow_tool_call
 from codex_plugin_scanner.guard.models import GuardApprovalRequest, GuardArtifact, PolicyDecision
+from codex_plugin_scanner.guard.policy_integrity import PolicyIntegrityVerificationResult
 from codex_plugin_scanner.guard.proxy import runtime_mcp as runtime_mcp_module
 from codex_plugin_scanner.guard.proxy.runtime_mcp import RuntimeMcpGuardProxy
 from codex_plugin_scanner.guard.runtime import runner as guard_runner_module
@@ -87,6 +88,21 @@ def _store(tmp_path: Path) -> GuardStore:
     return GuardStore(tmp_path / "guard-home")
 
 
+def _trust_local_policy_rows(monkeypatch: pytest.MonkeyPatch) -> None:
+    def _valid_policy_row(
+        self: GuardStore,
+        row,
+        *,
+        mode: str,
+        key: bytes | None,
+        key_id: str | None,
+        trusted_generation: int | None = None,
+    ) -> PolicyIntegrityVerificationResult:
+        return PolicyIntegrityVerificationResult(status="valid")
+
+    monkeypatch.setattr(GuardStore, "_policy_integrity_result_for_row", _valid_policy_row)
+
+
 def _enable_gate(store: GuardStore, *, cooldown_seconds: int = 0, strict_all_decisions: bool = False) -> None:
     update_approval_gate_settings(
         store.guard_home,
@@ -228,17 +244,80 @@ def test_approval_gate_wrong_password_fails_closed(tmp_path: Path) -> None:
     assert store.list_policy_decisions("codex") == []
 
 
-def test_approval_gate_correct_password_succeeds(tmp_path: Path) -> None:
+def test_approval_gate_approve_once_does_not_persist_policy(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _trust_local_policy_rows(monkeypatch)
+    store = _store(tmp_path)
+    _enable_gate(store)
+    _add_request(store, "req-once")
+
+    resolved = _approve(store, "req-once", gate_input=ApprovalGateInput(password=PASSWORD))
+
+    assert resolved["status"] == "resolved"
+    assert store.list_policy_decisions("codex") == []
+    first_retry = store.resolve_policy_decision(
+        "codex",
+        "codex:project:req-once",
+        "hash-req-once",
+        now="2026-04-11T00:02:00+00:00",
+    )
+    assert first_retry is not None
+    assert first_retry["action"] == "allow"
+    assert (
+        store.resolve_policy_decision(
+            "codex",
+            "codex:project:req-once",
+            "hash-req-once",
+            now="2026-04-11T00:03:00+00:00",
+        )
+        is None
+    )
+    assert store.list_policy_decisions("codex") == []
+
+
+def test_approval_gate_artifact_remember_persists_policy(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _trust_local_policy_rows(monkeypatch)
     store = _store(tmp_path)
     _enable_gate(store)
-    _add_request(store, "req-correct")
+    _add_request(store, "req-remember")
 
-    resolved = _approve(store, "req-correct", gate_input=ApprovalGateInput(password=PASSWORD))
+    resolved = apply_approval_resolution(
+        store=store,
+        request_id="req-remember",
+        action="allow",
+        scope="artifact",
+        workspace=None,
+        reason="reviewed",
+        now="2026-04-11T00:01:00+00:00",
+        approval_gate_input=ApprovalGateInput(password=PASSWORD),
+        persist_policy=True,
+    )
 
     assert resolved["status"] == "resolved"
     policy = store.list_policy_decisions("codex")[0]
     assert policy["action"] == "allow"
-    assert policy["artifact_id"] == "codex:project:req-correct"
+    assert policy["artifact_id"] == "codex:project:req-remember"
+    first_retry = store.resolve_policy_decision(
+        "codex",
+        "codex:project:req-remember",
+        "hash-req-remember",
+        now="2026-04-11T00:02:00+00:00",
+    )
+    second_retry = store.resolve_policy_decision(
+        "codex",
+        "codex:project:req-remember",
+        "hash-req-remember",
+        now="2026-04-11T00:03:00+00:00",
+    )
+    assert first_retry is not None
+    assert second_retry is not None
+    assert first_retry["action"] == "allow"
+    assert second_retry["action"] == "allow"
 
 
 def test_approval_gate_cooldown_works_expires_and_revokes(tmp_path: Path) -> None:
@@ -1179,6 +1258,83 @@ def test_approval_gate_daemon_api_cannot_bypass_password(tmp_path: Path) -> None
     assert store.list_policy_decisions("codex") == []
 
 
+def test_daemon_approval_defaults_artifact_scope_to_one_time(tmp_path: Path) -> None:
+    store = _store(tmp_path)
+    _add_request(store, "req-daemon-once")
+    daemon = GuardDaemonServer(store, host="127.0.0.1", port=0)
+    daemon.start()
+    try:
+        body = _post_daemon_json(daemon, "/v1/requests/req-daemon-once/approve", {"scope": "artifact"})
+    finally:
+        daemon.stop()
+
+    assert body["resolved"] is True
+    assert store.get_approval_request("req-daemon-once")["status"] == "resolved"
+    assert store.list_policy_decisions("codex") == []
+
+
+@pytest.mark.parametrize("field_name", ["remember", "persist_policy"])
+def test_daemon_approval_false_artifact_scope_still_allows_once(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    field_name: str,
+) -> None:
+    _trust_local_policy_rows(monkeypatch)
+    store = _store(tmp_path)
+    request_id = f"req-daemon-false-{field_name.replace('_', '-')}"
+    _add_request(store, request_id)
+    daemon = GuardDaemonServer(store, host="127.0.0.1", port=0)
+    daemon.start()
+    try:
+        body = _post_daemon_json(
+            daemon,
+            f"/v1/requests/{request_id}/approve",
+            {"scope": "artifact", field_name: False},
+        )
+    finally:
+        daemon.stop()
+
+    assert body["resolved"] is True
+    assert store.list_policy_decisions("codex") == []
+    assert (
+        store.resolve_policy(
+            "codex",
+            f"codex:project:{request_id}",
+            f"hash-{request_id}",
+            now="2026-04-11T00:02:00+00:00",
+        )
+        == "allow"
+    )
+    assert (
+        store.resolve_policy(
+            "codex",
+            f"codex:project:{request_id}",
+            f"hash-{request_id}",
+            now="2026-04-11T00:03:00+00:00",
+        )
+        is None
+    )
+
+
+def test_daemon_approval_can_remember_exact_artifact_scope(tmp_path: Path) -> None:
+    store = _store(tmp_path)
+    _add_request(store, "req-daemon-remember")
+    daemon = GuardDaemonServer(store, host="127.0.0.1", port=0)
+    daemon.start()
+    try:
+        body = _post_daemon_json(
+            daemon,
+            "/v1/requests/req-daemon-remember/approve",
+            {"scope": "artifact", "remember": True},
+        )
+    finally:
+        daemon.stop()
+
+    assert body["resolved"] is True
+    policy = store.list_policy_decisions("codex")[0]
+    assert policy["artifact_id"] == "codex:project:req-daemon-remember"
+
+
 def test_approval_gate_direct_lower_layers_cannot_bypass(tmp_path: Path) -> None:
     store = _store(tmp_path)
     _enable_gate(store)

{plugin_scanner-2.0.806 → plugin_scanner-2.0.808}/tests/test_guard_approvals.py

@@ -2602,7 +2602,48 @@ class TestGuardApprovals:
         assert list_output["items"][0]["request_id"] == "req-789"
         assert approve_rc == 0
         assert approve_output["resolved"] is True
-        assert store.resolve_policy("codex", "codex:project:workspace_skill", "hash-789") == "allow"
+        assert store.list_policy_decisions("codex") == []
+
+        store.add_approval_request(
+            GuardApprovalRequest(
+                request_id="req-remember",
+                harness="codex",
+                artifact_id="codex:project:workspace_skill",
+                artifact_name="workspace_skill",
+                artifact_hash="hash-remember",
+                policy_action="require-reapproval",
+                recommended_scope="artifact",
+                changed_fields=("args",),
+                source_scope="project",
+                config_path=str(tmp_path / "workspace" / "config.toml"),
+                review_command="hol-guard approvals approve req-remember",
+                approval_url="http://127.0.0.1/pending",
+            ),
+            "2026-04-11T00:01:00+00:00",
+        )
+        remember_rc = main(
+            [
+                "guard",
+                "approvals",
+                "approve",
+                "req-remember",
+                "--home",
+                str(home_dir),
+                "--scope",
+                "artifact",
+                "--remember",
+                "--reason",
+                "approved",
+                "--json",
+            ]
+        )
+        remember_output = json.loads(capsys.readouterr().out)
+
+        assert remember_rc == 0
+        assert remember_output["resolved"] is True
+        policy = store.list_policy_decisions("codex")[0]
+        assert policy["action"] == "allow"
+        assert policy["artifact_hash"] == "hash-remember"
 
     def test_guard_policies_cli_clears_local_decisions_for_harness(self, tmp_path, capsys):
         home_dir = tmp_path / "home"

{plugin_scanner-2.0.806 → plugin_scanner-2.0.808}/tests/test_guard_connect_flow.py

@@ -356,6 +356,59 @@ def test_connect_status_requires_retry_when_legacy_sync_profile_exists_but_oauth
     assert latest_state["milestone"] == "first_sync_failed"
 
 
+def test_record_latest_guard_connect_sync_success_clears_retry_required_state_when_oauth_exists(
+    tmp_path: Path,
+) -> None:
+    store = GuardStore(tmp_path / "guard-home")
+    store.set_oauth_local_credentials(
+        issuer="https://hol.org",
+        client_id="guard-local-daemon",
+        refresh_token="refresh-token-1",
+        dpop_private_key_pem="private-key",
+        dpop_public_jwk={"kty": "EC", "crv": "P-256", "x": "x-value", "y": "y-value"},
+        dpop_public_jwk_thumbprint="thumbprint-1",
+        grant_id="grant-1",
+        machine_id="machine-1",
+        workspace_id="workspace-1",
+        now="2026-06-11T22:11:11+00:00",
+    )
+    store.record_guard_connect_pairing_completed(
+        sync_url="https://hol.org/api/guard/receipts/sync",
+        allowed_origin="https://hol.org",
+        now="2026-06-11T22:11:11+00:00",
+        request_id="connect-403",
+    )
+    store.record_latest_guard_connect_sync_result(
+        status="retry_required",
+        milestone="first_sync_failed",
+        now="2026-06-11T22:12:11+00:00",
+        reason="Guard authorization expired. Run `hol-guard connect` again.",
+    )
+
+    store.record_latest_guard_connect_sync_success(
+        sync_payload={
+            "synced_at": "2026-06-11T22:13:11+00:00",
+            "receipts_stored": 11,
+            "inventory_items": 261,
+        },
+        now="2026-06-11T22:13:11+00:00",
+    )
+
+    payload = build_connect_status_payload(
+        store=store,
+        sync_url="https://hol.org/api/guard/receipts/sync",
+        connect_url="https://hol.org/guard/connect",
+        action="status",
+    )
+
+    assert payload["status"] == "connected"
+    assert payload["milestone"] == "first_sync_succeeded"
+    latest_state = payload["latest_connect_state"]
+    assert isinstance(latest_state, dict)
+    assert latest_state["status"] == "connected"
+    assert latest_state["milestone"] == "first_sync_succeeded"
+
+
 def test_browser_connect_caches_paid_package_firewall_entitlement(tmp_path: Path) -> None:
     store = GuardStore(tmp_path / "guard-home")
 

{plugin_scanner-2.0.806 → plugin_scanner-2.0.808}/tests/test_guard_launch_env.py

@@ -17,7 +17,9 @@ except ModuleNotFoundError:  # pragma: no cover - Python 3.10
 
 from codex_plugin_scanner.cli import main
 from codex_plugin_scanner.guard.cli import commands as guard_commands_module
+from codex_plugin_scanner.guard.policy_integrity import PolicyIntegrityVerificationResult
 from codex_plugin_scanner.guard.runtime import runner as guard_runner_module
+from codex_plugin_scanner.guard.store import GuardStore
 
 
 def _write_text(path: Path, text: str) -> None:
@@ -29,6 +31,21 @@ def _write_json(path: Path, payload: dict[str, object]) -> None:
     _write_text(path, json.dumps(payload, indent=2) + "\n")
 
 
+def _trust_local_policy_rows(monkeypatch: pytest.MonkeyPatch) -> None:
+    def _valid_policy_row(
+        self: GuardStore,
+        row,
+        *,
+        mode: str,
+        key: bytes | None,
+        key_id: str | None,
+        trusted_generation: int | None = None,
+    ) -> PolicyIntegrityVerificationResult:
+        return PolicyIntegrityVerificationResult(status="valid")
+
+    monkeypatch.setattr(GuardStore, "_policy_integrity_result_for_row", _valid_policy_row)
+
+
 def _build_guard_fixture(home_dir: Path, workspace_dir: Path) -> None:
     _write_text(
         home_dir / ".codex" / "config.toml",
@@ -205,6 +222,7 @@ def test_guard_run_launches_copilot_with_passthrough_args(monkeypatch, tmp_path,
 
 
 def test_guard_run_blocks_direct_env_prompt_until_approved(monkeypatch, tmp_path, capsys):
+    _trust_local_policy_rows(monkeypatch)
     home_dir = tmp_path / "home"
     workspace_dir = tmp_path / "workspace"
     fake_bin = tmp_path / "fake-bin"
@@ -251,6 +269,7 @@ def test_guard_run_blocks_direct_env_prompt_until_approved(monkeypatch, tmp_path
             str(home_dir),
             "--workspace",
             str(workspace_dir),
+            "--remember",
             "--json",
         ]
     )

{plugin_scanner-2.0.806 → plugin_scanner-2.0.808}/tests/test_guard_oauth_device_connect.py

@@ -788,7 +788,7 @@ def test_headless_connect_slows_down_polling_when_server_requests_it(tmp_path: P
     assert sleeps == [7]
 
 
-def test_headless_connect_rejects_unreadable_macos_keychain_credentials_without_prompt(
+def test_headless_connect_persists_encrypted_fallback_when_macos_keychain_reads_are_unavailable(
     tmp_path: Path,
     monkeypatch,
 ) -> None:
@@ -827,28 +827,30 @@ def test_headless_connect_rejects_unreadable_macos_keychain_credentials_without_
         def read(self) -> bytes:
             return json.dumps(self._payload).encode("utf-8")
 
-    with pytest.raises(RuntimeError, match="persist local Guard Cloud authorization"):
-        connect_flow.run_guard_device_connect_command(
-            store=store,
-            connect_url="https://hol.org/guard/connect",
-            request_device_authorization=fake_request,
-            token_urlopen=lambda request, timeout: _Response(
-                {
-                    "access_token": _fake_access_token(
-                        grant_id="grant-123",
-                        machine_id="machine-123",
-                        workspace_id="workspace-123",
-                    ),
-                    "refresh_token": "refresh-123",
-                    "expires_in": 3600,
-                    "scope": "guard:runtime.sync guard:offline_access",
-                    "token_type": "Bearer",
-                }
-            ),
-            now="2026-06-01T12:00:00+00:00",
-        )
+    payload = connect_flow.run_guard_device_connect_command(
+        store=store,
+        connect_url="https://hol.org/guard/connect",
+        request_device_authorization=fake_request,
+        token_urlopen=lambda request, timeout: _Response(
+            {
+                "access_token": _fake_access_token(
+                    grant_id="grant-123",
+                    machine_id="machine-123",
+                    workspace_id="workspace-123",
+                ),
+                "refresh_token": "refresh-123",
+                "expires_in": 3600,
+                "scope": "guard:runtime.sync guard:offline_access",
+                "token_type": "Bearer",
+            }
+        ),
+        now="2026-06-01T12:00:00+00:00",
+    )
 
-    assert store.get_oauth_local_credentials() is None
+    assert payload["status"] == "connected"
+    credentials = store.get_oauth_local_credentials()
+    assert credentials is not None
+    assert credentials["refresh_token"] == "refresh-123"
 
 
 def test_headless_connect_expired_code_surfaces_retry_command(tmp_path: Path) -> None: