plugin-scanner 2.0.898__tar.gz → 2.0.899__tar.gz

{plugin_scanner-2.0.898 → plugin_scanner-2.0.899}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.898
+Version: 2.0.899
 Summary: Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi.
 Project-URL: Homepage, https://github.com/hashgraph-online/hol-guard
 Project-URL: Repository, https://github.com/hashgraph-online/hol-guard

{plugin_scanner-2.0.898 → plugin_scanner-2.0.899}/pyproject.toml

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

{plugin_scanner-2.0.898 → plugin_scanner-2.0.899}/pyproject.toml.bak

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

{plugin_scanner-2.0.898 → plugin_scanner-2.0.899}/src/codex_plugin_scanner/cli.py

@@ -301,6 +301,14 @@ def main(argv: list[str] | None = None) -> int:
         program_name=program_name,
     )
     args = parser.parse_args(resolved_argv)
+    if program_mode == "guard":
+        try:
+            return run_guard_command(args)
+        except ValueError as exc:
+            parser.error(str(exc))
+        except Exception as exc:
+            print(str(exc), file=sys.stderr)
+            return 1
     if getattr(args, "list_ecosystems", False):
         for ecosystem in list_supported_ecosystems():
             print(ecosystem)

{plugin_scanner-2.0.898 → plugin_scanner-2.0.899}/src/codex_plugin_scanner/guard/adapters/cursor_hooks.py

@@ -446,8 +446,11 @@ def _remove_managed_hook_entries(*, hooks_path: Path, script_path: Path) -> bool
 
 
 def _resolve_guard_cli_command() -> list[str]:
-    """Prefer the installed hol-guard CLI so hooks use the same runtime as install."""
+    """Prefer the installed guard-only CLI so hooks use the leanest runtime."""
 
+    plugin_guard = shutil.which("plugin-guard")
+    if plugin_guard:
+        return [plugin_guard]
     hol_guard = shutil.which("hol-guard")
     if hol_guard:
         return [hol_guard]

{plugin_scanner-2.0.898 → plugin_scanner-2.0.899}/src/codex_plugin_scanner/guard/adapters/pi_extension_source.py

@@ -14,20 +14,27 @@ GUARD_HOOK_MAX_SERIALIZED_PAYLOAD_CHARS = 24_000
 
 
 def managed_extension_source(*, guard_home: Path, home_dir: Path, settings_path: Path) -> str:
-    guard_args = ["guard", "hook", "--guard-home", str(guard_home), "--harness", "pi"]
+    guard_args = ["hook", "--guard-home", str(guard_home), "--harness", "pi"]
     if home_dir.resolve() != Path.home().resolve():
         guard_args.extend(["--home", str(home_dir)])
     guard_args_json = json.dumps(guard_args)
+    guard_home_json = json.dumps(str(guard_home))
+    home_dir_json = json.dumps(str(home_dir))
+    home_dir_is_default_json = "true" if home_dir.resolve() == Path.home().resolve() else "false"
     config_path_json = json.dumps(str(settings_path))
     return (
         'import { spawnSync } from "node:child_process";\n'
         'import { createCipheriv, createHash, randomBytes } from "node:crypto";\n'
-        'import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";\n'
+        'import { chmodSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";\n'
         'import { tmpdir } from "node:os";\n'
         'import { join } from "node:path";\n'
         'import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";\n'
         "\n"
+        'const GUARD_COMMAND_CANDIDATES = ["plugin-guard", "hol-guard"] as const;\n'
         f"const GUARD_ARGS = {guard_args_json};\n"
+        f"const GUARD_HOME = {guard_home_json};\n"
+        f"const GUARD_HOME_DIR = {home_dir_json};\n"
+        f"const GUARD_HOME_DIR_IS_DEFAULT = {home_dir_is_default_json};\n"
         f"const GUARD_CONFIG_PATH = {config_path_json};\n"
         f"const GUARD_TIMEOUT_MS = {GUARD_HOOK_TIMEOUT_MS};\n"
         f"const GUARD_TEXT_LIMIT_CHARS = {GUARD_HOOK_TEXT_LIMIT_CHARS};\n"
@@ -242,11 +249,56 @@ def managed_extension_source(*, guard_home: Path, home_dir: Path, settings_path:
         "  };\n"
         "}\n"
         "\n"
-        "function runGuard(\n"
+        "async function daemonGuardResponse(\n"
+        "  serializedPayload: string,\n"
+        "  cwd?: string,\n"
+        "): Promise<GuardResponse | null> {\n"
+        "  if (typeof fetch !== 'function') return null;\n"
+        "  let port = 0;\n"
+        "  let authToken = '';\n"
+        "  try {\n"
+        "    const daemonState = JSON.parse(\n"
+        "      readFileSync(join(GUARD_HOME, 'daemon-state.json'), 'utf8'),\n"
+        "    ) as { port?: unknown };\n"
+        "    port = typeof daemonState.port === 'number' ? daemonState.port : 0;\n"
+        "    authToken = readFileSync(join(GUARD_HOME, 'daemon-auth-token'), 'utf8').trim();\n"
+        "  } catch {\n"
+        "    return null;\n"
+        "  }\n"
+        "  if (!(port > 0) || authToken.length === 0) return null;\n"
+        '  const workspace = typeof cwd === "string" && cwd ? cwd : process.cwd();\n'
+        "  const params = new URLSearchParams({ 'guard-home': GUARD_HOME });\n"
+        "  if (workspace) params.set('workspace', workspace);\n"
+        "  if (!GUARD_HOME_DIR_IS_DEFAULT && GUARD_HOME_DIR) params.set('home', GUARD_HOME_DIR);\n"
+        "  const controller = typeof AbortController === 'function' ? new AbortController() : undefined;\n"
+        "  const timeoutHandle = setTimeout(() => controller?.abort(), Math.max(GUARD_TIMEOUT_MS - 500, 1));\n"
+        "  try {\n"
+        "    const response = await fetch(`http://127.0.0.1:${port}/v1/hooks/pi?${params.toString()}`, {\n"
+        "      method: 'POST',\n"
+        "      headers: {\n"
+        "        'Content-Type': 'application/json',\n"
+        "        'X-Guard-Token': authToken,\n"
+        "      },\n"
+        "      body: serializedPayload,\n"
+        "      signal: controller?.signal,\n"
+        "    });\n"
+        "    if (!response.ok) return null;\n"
+        "    const raw = (await response.text()).trim();\n"
+        "    if (!raw) return {};\n"
+        "    const parsed = JSON.parse(raw) as GuardResponse;\n"
+        "    return parsed && typeof parsed === 'object' ? parsed : null;\n"
+        "  } catch {\n"
+        "    return null;\n"
+        "  } finally {\n"
+        "    clearTimeout(timeoutHandle);\n"
+        "  }\n"
+        "}\n"
+        "\n"
+        "async function runGuard(\n"
         "  payload: Record<string, unknown>,\n"
         "  cwd?: string,\n"
         "  options?: { enforceSizeCap?: boolean },\n"
-        "): GuardResponse {\n"
+        "): Promise<GuardResponse> {\n"
         "  const args = [...GUARD_ARGS];\n"
         '  const workspace = typeof cwd === "string" && cwd ? cwd : process.cwd();\n'
         '  if (workspace) args.push("--workspace", workspace);\n'
@@ -293,12 +345,28 @@ def managed_extension_source(*, guard_home: Path, home_dir: Path, settings_path:
         '        + "the safe size limit.",\n'
         "    };\n"
         "  }\n"
-        '  const result = spawnSync("hol-guard", args, {\n'
-        "    input: `${serializedPayload}\\n`,\n"
-        '    encoding: "utf-8",\n'
-        "    timeout: GUARD_TIMEOUT_MS,\n"
-        "  });\n"
+        "  const daemonResponse = await daemonGuardResponse(serializedPayload, cwd);\n"
+        "  if (daemonResponse) {\n"
+        "    cleanupPayloadReference();\n"
+        "    return daemonResponse;\n"
+        "  }\n"
+        "  let result: ReturnType<typeof spawnSync<string>> | null = null;\n"
+        "  for (const command of GUARD_COMMAND_CANDIDATES) {\n"
+        "    result = spawnSync(command, args, {\n"
+        "      input: `${serializedPayload}\\n`,\n"
+        '      encoding: "utf-8",\n'
+        "      timeout: GUARD_TIMEOUT_MS,\n"
+        "    });\n"
+        "    const resultError = result.error as (Error & { code?: unknown }) | undefined;\n"
+        "    if (!(result.error && resultError?.code === 'ENOENT')) break;\n"
+        "  }\n"
         "  cleanupPayloadReference();\n"
+        "  if (result === null) {\n"
+        "    return {\n"
+        '      decision: "deny",\n'
+        '      reason: "HOL Guard Pi hook failed before completing review: Guard CLI was not found.",\n'
+        "    };\n"
+        "  }\n"
         "  if (result.error) {\n"
         "    const resultError = result.error as (Error & { code?: unknown }) | undefined;\n"
         "    const errorMessage = resultError instanceof Error ? resultError.message : String(result.error);\n"
@@ -356,7 +424,7 @@ def managed_extension_source(*, guard_home: Path, home_dir: Path, settings_path:
         "  const blockedToolResults = new Map<string, string>();\n"
         '  pi.on("input", async (event, ctx) => {\n'
         '    if (event.source === "extension") return { action: "continue" };\n'
-        "    const response = runGuard(\n"
+        "    const response = await runGuard(\n"
         '      { hook_event_name: "UserPromptSubmit", prompt: event.text, config_path: GUARD_CONFIG_PATH },\n'
         "      ctx.cwd,\n"
         "    );\n"
@@ -372,7 +440,7 @@ def managed_extension_source(*, guard_home: Path, home_dir: Path, settings_path:
         "      (event as { toolInput?: Record<string, unknown> }).toolInput ??\n"
         "      (event as { arguments?: Record<string, unknown> }).arguments ??\n"
         "      {};\n"
-        "    const response = runGuard(\n"
+        "    const response = await runGuard(\n"
         "      {\n"
         '        hook_event_name: "PreToolUse",\n'
         "        config_path: GUARD_CONFIG_PATH,\n"
@@ -421,7 +489,7 @@ def managed_extension_source(*, guard_home: Path, home_dir: Path, settings_path:
         '          + "the model receives the reviewed excerpt, not the full output."\n'
         "        : null;\n"
         '    if (oversizeNotice) ctx.ui.notify(oversizeNotice, "info");\n'
-        "    const response = runGuard(\n"
+        "    const response = await runGuard(\n"
         "      {\n"
         '        hook_event_name: "PostToolUse",\n'
         "        config_path: GUARD_CONFIG_PATH,\n"

{plugin_scanner-2.0.898 → plugin_scanner-2.0.899}/src/codex_plugin_scanner/guard/cli/commands_router.py

@@ -122,7 +122,7 @@ def run_guard_command(
         )
         return _normalize_guard_handler_result(result)
 
-    store = GuardStore(guard_home)
+    store = GuardStore(guard_home, prime_policy_integrity=args.guard_command != "hook")
     config = load_guard_config(guard_home, workspace=workspace)
     config = overlay_synced_guard_policy(config, _synced_policy_payload(store))
 

{plugin_scanner-2.0.898 → plugin_scanner-2.0.899}/src/codex_plugin_scanner/guard/daemon/manager.py

@@ -671,11 +671,16 @@ def _reap_stale_ephemeral_guard_daemons(*, exclude_guard_home: Path | None = Non
             continue
         if not _guard_home_is_ephemeral(resolved_guard_home):
             continue
-        if _state_path_age_seconds(state_path) < _EPHEMERAL_GUARD_DAEMON_STALE_SECONDS:
-            continue
-        if not _ephemeral_guard_home_is_inactive(guard_home, fallback_age_seconds=_state_path_age_seconds(state_path)):
+        state_age_seconds = _state_path_age_seconds(state_path)
+        if state_age_seconds < _EPHEMERAL_GUARD_DAEMON_STALE_SECONDS:
             continue
         payload = _load_state(guard_home)
+        if not _ephemeral_guard_home_is_inactive(
+            guard_home,
+            fallback_age_seconds=state_age_seconds,
+            state_payload=payload,
+        ):
+            continue
         if not isinstance(payload, dict) or not _looks_like_guard_daemon_state(payload, guard_home=guard_home):
             continue
         payload = {**payload, "guard_home": str(guard_home)}
@@ -758,7 +763,21 @@ def _guard_home_is_ephemeral(guard_home: Path) -> bool:
     return any(part.startswith("pytest-") or "pytest-of-" in part for part in guard_home.parts)
 
 
-def _ephemeral_guard_home_is_inactive(guard_home: Path, *, fallback_age_seconds: float) -> bool:
+def _ephemeral_guard_home_is_inactive(
+    guard_home: Path,
+    *,
+    fallback_age_seconds: float,
+    state_payload: dict[str, object] | None = None,
+) -> bool:
+    payload = state_payload if isinstance(state_payload, dict) else _load_state(guard_home)
+    if isinstance(payload, dict):
+        pid = payload.get("pid")
+        if not isinstance(pid, int) or pid <= 0:
+            return fallback_age_seconds >= _EPHEMERAL_GUARD_DAEMON_STALE_SECONDS
+        if not _guard_daemon_pid_is_running(pid):
+            return fallback_age_seconds >= _EPHEMERAL_GUARD_DAEMON_STALE_SECONDS
+        if not _guard_daemon_pid_matches_command(pid, expected_guard_home=guard_home):
+            return fallback_age_seconds >= _EPHEMERAL_GUARD_DAEMON_STALE_SECONDS
     heartbeat_age_seconds = _runtime_state_age_seconds(guard_home)
     if heartbeat_age_seconds is None:
         return fallback_age_seconds >= _EPHEMERAL_GUARD_DAEMON_STALE_SECONDS
@@ -1058,7 +1077,10 @@ def _retire_guard_daemon_pid(pid: int, *, expected_guard_home: Path | None = Non
     if not _guard_daemon_pid_is_running(pid):
         return True
     if not _guard_daemon_pid_matches_command(pid, expected_guard_home):
-        return False
+        # The pid is running a different command — not our daemon.
+        # There is nothing to kill; return True so the caller clears
+        # the stale daemon-state.json instead of revisiting it forever.
+        return True
     try:
         os.kill(pid, signal.SIGTERM)
     except OSError:

{plugin_scanner-2.0.898 → plugin_scanner-2.0.899}/src/codex_plugin_scanner/guard/daemon/server.py

@@ -1550,8 +1550,8 @@ class _GuardDaemonHandler(BaseHTTPRequestHandler):
         if parsed.path == "/v1/initialize":
             self._handle_initialize(payload)
             return
-        if parsed.path == "/v1/hooks/claude-code":
-            self._handle_claude_hook(payload, parsed.query)
+        if len(path_parts) == 3 and path_parts[:2] == ["v1", "hooks"]:
+            self._handle_runtime_hook(payload, parsed.query, default_harness=path_parts[2])
             return
         if parsed.path == "/v1/clients/attach":
             self._handle_client_attach(payload)
@@ -3927,7 +3927,7 @@ class _GuardDaemonHandler(BaseHTTPRequestHandler):
             status=410,
         )
 
-    def _handle_claude_hook(self, payload: dict[str, object], query: str) -> None:
+    def _handle_runtime_hook(self, payload: dict[str, object], query: str, *, default_harness: str) -> None:
         params = parse_qs(query)
         try:
             home_dir = self._validated_hook_directory_string(
@@ -3946,7 +3946,7 @@ class _GuardDaemonHandler(BaseHTTPRequestHandler):
             self._write_json({"error": error.code}, status=400)
             return
         runtime_harness = self._optional_string(params.get("runtime-harness", [None])[-1])
-        harness = runtime_harness or "claude-code"
+        harness = runtime_harness or default_harness
         args = argparse.Namespace(
             guard_command="hook",
             home=home_dir,

{plugin_scanner-2.0.898 → plugin_scanner-2.0.899}/src/codex_plugin_scanner/guard/store_connection_schema.py

@@ -533,22 +533,25 @@ class StoreConnectionSchemaMixin:
                 self._record_schema_version(connection, version=2)
             self._enable_wal_mode(connection)
             self._repair_store_permissions()
-        # Prime policy-integrity secrets outside the SQLite transaction. Some
-        # credential-store lookups can block long enough to stall other Guard
-        # processes if initialization still holds the writer lock.
-        self._startup_prefetched_policy_integrity_secret_material = self._policy_integrity_secret_material(create=False)
-        self._startup_prefetched_policy_integrity_trusted_state = self._load_policy_integrity_control_state(
-            create=False
-        )
-        self._startup_prefetched_policy_integrity_repair_failed = False
-        self._prepare_startup_prefetched_policy_integrity_state()
-        try:
-            with self._connect() as connection:
-                self._refresh_policy_integrity_state(connection, now=_now(), create_key=False)
-        finally:
-            self._startup_prefetched_policy_integrity_secret_material = _POLICY_INTEGRITY_LOOKUP_UNSET
-            self._startup_prefetched_policy_integrity_trusted_state = _POLICY_INTEGRITY_LOOKUP_UNSET
+        if getattr(self, "_prime_policy_integrity_on_initialize", True):
+            # Prime policy-integrity secrets outside the SQLite transaction. Some
+            # credential-store lookups can block long enough to stall other Guard
+            # processes if initialization still holds the writer lock.
+            self._startup_prefetched_policy_integrity_secret_material = self._policy_integrity_secret_material(
+                create=False
+            )
+            self._startup_prefetched_policy_integrity_trusted_state = self._load_policy_integrity_control_state(
+                create=False
+            )
             self._startup_prefetched_policy_integrity_repair_failed = False
+            self._prepare_startup_prefetched_policy_integrity_state()
+            try:
+                with self._connect() as connection:
+                    self._refresh_policy_integrity_state(connection, now=_now(), create_key=False)
+            finally:
+                self._startup_prefetched_policy_integrity_secret_material = _POLICY_INTEGRITY_LOOKUP_UNSET
+                self._startup_prefetched_policy_integrity_trusted_state = _POLICY_INTEGRITY_LOOKUP_UNSET
+                self._startup_prefetched_policy_integrity_repair_failed = False
 
     @staticmethod
     def _enable_wal_mode(connection: sqlite3.Connection) -> None:

{plugin_scanner-2.0.898 → plugin_scanner-2.0.899}/src/codex_plugin_scanner/guard/store_policy.py

@@ -201,9 +201,6 @@ class StorePolicyMixin:
         selected_payload: dict[str, object] | None = None
         ignored_local_integrity: dict[str, object] | None = None
         with self._connect() as connection:
-            state = self._refresh_policy_integrity_state(connection, now=current_time, create_key=True)
-            trust_status = TrustStatus.from_policy_integrity_state(state).to_dict()
-            key, key_id = self._policy_integrity_secret_material(create=True)
             local_once_decision = None
             local_once_hashes = tuple(
                 dict.fromkeys(hash_value for hash_value in (artifact_hash, runtime_exact_match_key) if hash_value)
@@ -298,12 +295,62 @@ class StorePolicyMixin:
                     current_time,
                 ),
             ).fetchall()
+            cached_state = self._load_policy_integrity_state(connection) or {}
+            cached_trust_status = TrustStatus.from_policy_integrity_state(cached_state).to_dict()
             if not rows and selected_payload is None:
                 return {
                     "decision": None,
                     "ignored_local_integrity": None,
-                    "trust_status": trust_status,
+                    "trust_status": cached_trust_status,
                 }
+            has_local_rows = any(not is_remote_policy_source(str(candidate["source"])) for candidate in rows)
+            if not has_local_rows:
+                if selected_payload is None:
+                    for candidate in rows:
+                        if _scoped_runtime_row_requires_exact_match(
+                            scope=str(candidate["scope"]),
+                            stored_artifact_id=(
+                                str(candidate["artifact_id"]) if isinstance(candidate["artifact_id"], str) else None
+                            ),
+                            stored_artifact_hash=(
+                                str(candidate["artifact_hash"]) if isinstance(candidate["artifact_hash"], str) else None
+                            ),
+                            source=str(candidate["source"]),
+                            requested_artifact_id=artifact_id,
+                            requested_runtime_exact_match_key=runtime_exact_match_key,
+                        ):
+                            continue
+                        selected_payload = self._policy_row_payload(candidate)
+                        if is_remote_policy_source(str(candidate["source"])):
+                            events.append(
+                                (
+                                    "policy.cloud.applied",
+                                    {
+                                        "decision_id": int(candidate["decision_id"]),
+                                        "harness": str(candidate["harness"]),
+                                        "artifact_id": candidate["artifact_id"],
+                                        "scope": str(candidate["scope"]),
+                                        "source": str(candidate["source"]),
+                                        "action": str(candidate["action"]),
+                                    },
+                                )
+                            )
+                        if _is_approval_gate_one_shot_policy(candidate):
+                            connection.execute(
+                                "delete from policy_decisions where decision_id = ?",
+                                (int(candidate["decision_id"]),),
+                            )
+                        break
+                for event_name, payload in events:
+                    self.add_event(event_name, payload, current_time)
+                return {
+                    "decision": selected_payload,
+                    "ignored_local_integrity": None,
+                    "trust_status": cached_trust_status,
+                }
+            state = self._refresh_policy_integrity_state(connection, now=current_time, create_key=True)
+            trust_status = TrustStatus.from_policy_integrity_state(state).to_dict()
+            key, key_id = self._policy_integrity_secret_material(create=True)
             for candidate in rows if selected_payload is None else ():
                 if _scoped_runtime_row_requires_exact_match(
                     scope=str(candidate["scope"]),

{plugin_scanner-2.0.898 → plugin_scanner-2.0.899}/src/codex_plugin_scanner/guard/store_secret_policy_integrity.py

@@ -46,15 +46,23 @@ def _build_policy_integrity_secret_store_compat() -> SystemKeyringSecretStore |
 
 
 _POLICY_INTEGRITY_LOOKUP_UNSET = object()
+_OAUTH_SECRET_STORE_UNSET = object()
+_POLICY_INTEGRITY_SECRET_STORE_UNSET = object()
 
 
 class StoreSecretPolicyIntegrityMixin:
-    def __init__(self, guard_home: Path, *, guard_event_queue_limit: int = 1000) -> None:
+    def __init__(
+        self,
+        guard_home: Path,
+        *,
+        guard_event_queue_limit: int = 1000,
+        prime_policy_integrity: bool = True,
+    ) -> None:
         self.guard_home = guard_home
         self.guard_home.mkdir(parents=True, exist_ok=True)
         _set_private_mode_compat(self.guard_home, _GUARD_STORE_PRIVATE_DIR_MODE)
-        self._oauth_secret_store = _build_oauth_secret_store_compat(self.guard_home)
-        self._policy_integrity_secret_store = _build_policy_integrity_secret_store_compat()
+        self.__oauth_secret_store = _OAUTH_SECRET_STORE_UNSET
+        self.__policy_integrity_secret_store = _POLICY_INTEGRITY_SECRET_STORE_UNSET
         self._cached_oauth_secret_payload: tuple[str, str, str] | None = None
         self._cached_policy_integrity_secret_material: tuple[str | None, float, tuple[bytes, str]] | None = None
         self._cached_policy_integrity_control_state: tuple[str | None, float, dict[str, object]] | None = None
@@ -69,9 +77,38 @@ class StoreSecretPolicyIntegrityMixin:
         self._policy_integrity_control_ref = self._build_scoped_secret_ref(_POLICY_INTEGRITY_CONTROL_REF)
         self._oauth_local_credentials_ref = self._build_scoped_secret_ref(_OAUTH_LOCAL_CREDENTIALS_REF)
         self._guard_event_queue_limit = max(1, guard_event_queue_limit)
+        self._prime_policy_integrity_on_initialize = prime_policy_integrity
         self.path = self.guard_home / "guard.db"
         self._initialize()
 
+    @property
+    def _oauth_secret_store(self) -> SecretStore:
+        secret_store = getattr(self, "_StoreSecretPolicyIntegrityMixin__oauth_secret_store", _OAUTH_SECRET_STORE_UNSET)
+        if secret_store is _OAUTH_SECRET_STORE_UNSET:
+            secret_store = _build_oauth_secret_store_compat(self.guard_home)
+            self.__oauth_secret_store = secret_store
+        return cast(SecretStore, secret_store)
+
+    @_oauth_secret_store.setter
+    def _oauth_secret_store(self, value: SecretStore | object) -> None:
+        self.__oauth_secret_store = value
+
+    @property
+    def _policy_integrity_secret_store(self) -> SystemKeyringSecretStore | None:
+        secret_store = getattr(
+            self,
+            "_StoreSecretPolicyIntegrityMixin__policy_integrity_secret_store",
+            _POLICY_INTEGRITY_SECRET_STORE_UNSET,
+        )
+        if secret_store is _POLICY_INTEGRITY_SECRET_STORE_UNSET:
+            secret_store = _build_policy_integrity_secret_store_compat()
+            self.__policy_integrity_secret_store = secret_store
+        return cast(SystemKeyringSecretStore | None, secret_store)
+
+    @_policy_integrity_secret_store.setter
+    def _policy_integrity_secret_store(self, value: SystemKeyringSecretStore | None | object) -> None:
+        self.__policy_integrity_secret_store = value
+
     def _build_scoped_secret_ref(self, prefix: str) -> str:
         scoped_home = str(self.guard_home.expanduser().resolve())
         scoped_hash = sha256(scoped_home.encode("utf-8")).hexdigest()[:16]

{plugin_scanner-2.0.898 → plugin_scanner-2.0.899}/src/codex_plugin_scanner/version.py

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

{plugin_scanner-2.0.898 → plugin_scanner-2.0.899}/tests/test_cursor_hooks.py

@@ -197,6 +197,21 @@ def test_cursor_hook_script_source_routes_hook_argv_by_cli_entrypoint(
     assert 'GUARD_HOOK_ARGV = ["guard", "hook"' in module_source
 
 
+def test_cursor_resolve_guard_cli_command_prefers_plugin_guard(monkeypatch: pytest.MonkeyPatch) -> None:
+    from codex_plugin_scanner.guard.adapters.cursor_hooks import _resolve_guard_cli_command
+
+    def fake_which(command: str) -> str | None:
+        if command == "plugin-guard":
+            return "/usr/local/bin/plugin-guard"
+        if command == "hol-guard":
+            return "/usr/local/bin/hol-guard"
+        return None
+
+    monkeypatch.setattr("codex_plugin_scanner.guard.adapters.cursor_hooks.shutil.which", fake_which)
+
+    assert _resolve_guard_cli_command() == ["/usr/local/bin/plugin-guard"]
+
+
 def test_strip_managed_hook_entries_removes_hol_guard_pretooluse(tmp_path: Path) -> None:
     script_path = tmp_path / "hol-guard-cursor-hook.py"
     script_path.write_text("# Managed by HOL Guard\n", encoding="utf-8")

{plugin_scanner-2.0.898 → plugin_scanner-2.0.899}/tests/test_guard_approval_decisions.py

@@ -59,6 +59,56 @@ def _make_store(tmp_path: Path) -> GuardStore:
     return GuardStore(tmp_path / "guard")
 
 
+def test_resolve_policy_without_matching_rules_skips_policy_integrity_refresh(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    store = _make_store(tmp_path)
+
+    def fail_refresh(*_args, **_kwargs):
+        raise AssertionError("policy integrity refresh should not run for an empty policy lookup")
+
+    monkeypatch.setattr(store, "_refresh_policy_integrity_state", fail_refresh)
+    monkeypatch.setattr(store, "_policy_integrity_secret_material", fail_refresh)
+
+    assert store.resolve_policy("codex", "codex:project:none", "hash-none") is None
+
+
+def test_resolve_policy_with_remote_only_rule_skips_policy_integrity_refresh(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    store = _make_store(tmp_path)
+    artifact_id = "codex:project:remote-only"
+    artifact_hash = "hash-remote"
+    store.replace_remote_policies(
+        [
+            PolicyDecision(
+                harness="codex",
+                scope="artifact",
+                artifact_id=artifact_id,
+                artifact_hash=artifact_hash,
+                workspace=None,
+                publisher=None,
+                action="allow",
+                reason="remote policy",
+                owner=None,
+                source="cloud-sync",
+            )
+        ],
+        now="2026-06-26T00:00:00Z",
+        remote_write_authorized=True,
+    )
+
+    def fail_refresh(*_args, **_kwargs):
+        raise AssertionError("policy integrity refresh should not run for remote-only policy lookups")
+
+    monkeypatch.setattr(store, "_refresh_policy_integrity_state", fail_refresh)
+    monkeypatch.setattr(store, "_policy_integrity_secret_material", fail_refresh)
+
+    assert store.resolve_policy("codex", artifact_id, artifact_hash) == "allow"
+
+
 class TestDecideAction:
     def test_allow_policy_passes_through_unchanged(self) -> None:
         config = GuardConfig(guard_home=Path("/tmp/test-guard"), workspace=None)

{plugin_scanner-2.0.898 → plugin_scanner-2.0.899}/tests/test_guard_cli.py

@@ -782,6 +782,22 @@ class TestGuardCli:
         assert exc_info.value.code == 2
         assert "Run `hol-guard guard --help` to inspect available Guard commands." in capsys.readouterr().err
 
+    def test_plugin_guard_program_routes_directly_to_guard_mode(self, monkeypatch) -> None:
+        called: dict[str, object] = {}
+
+        def _fake_run_guard_command(args):
+            called["guard_command"] = args.guard_command
+            called["harness"] = getattr(args, "harness", None)
+            return 7
+
+        monkeypatch.setattr(sys, "argv", ["plugin-guard"])
+        monkeypatch.setattr("codex_plugin_scanner.cli.run_guard_command", _fake_run_guard_command)
+
+        rc = main(["hook", "--harness", "pi"])
+
+        assert rc == 7
+        assert called == {"guard_command": "hook", "harness": "pi"}
+
     def test_guard_detect_reports_supported_harnesses(self, tmp_path, capsys):
         home_dir = tmp_path / "home"
         workspace_dir = tmp_path / "workspace"