plugin-scanner 2.0.855__tar.gz → 2.0.856__tar.gz

{plugin_scanner-2.0.855 → plugin_scanner-2.0.856}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "plugin-scanner"
-version = "2.0.855"
+version = "2.0.856"
 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.855 → plugin_scanner-2.0.856}/pyproject.toml.bak

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

@@ -19,7 +19,10 @@ from .store_oauth import StoreOAuthConnectMixin
 from .store_policy import StorePolicyMixin
 from .store_policy_integrity_runtime import StorePolicyIntegrityAdminMixin
 from .store_receipts import StoreReceiptsRuntimeMixin
-from .store_secret_policy_integrity import StoreSecretPolicyIntegrityMixin
+from .store_secret_policy_integrity import (
+    StoreSecretPolicyIntegrityMixin,
+    _POLICY_INTEGRITY_LOOKUP_UNSET,
+)
 from .store_sessions import StoreSessionsMixin
 
 

{plugin_scanner-2.0.855 → plugin_scanner-2.0.856}/src/codex_plugin_scanner/guard/store_connection_schema.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 
 # ruff: noqa: F403,F405
 from .store_base import *
+from .store_secret_policy_integrity import _POLICY_INTEGRITY_LOOKUP_UNSET
 
 
 def _facade_store_attr(name: str, fallback: object) -> object:
@@ -42,6 +43,14 @@ def _sleep_compat(seconds: float) -> None:
 
 
 class StoreConnectionSchemaMixin:
+    _startup_prefetched_policy_integrity_secret_material: object | tuple[bytes | None, str | None] = (
+        _POLICY_INTEGRITY_LOOKUP_UNSET
+    )
+    _startup_prefetched_policy_integrity_trusted_state: object | dict[str, object] | None = (
+        _POLICY_INTEGRITY_LOOKUP_UNSET
+    )
+    _startup_prefetched_policy_integrity_repair_failed = False
+
     @contextmanager
     def _connect(self) -> Iterator[sqlite3.Connection]:
         connection = sqlite3.connect(self.path, timeout=SQLITE_CONNECT_TIMEOUT_SECONDS)
@@ -524,7 +533,22 @@ class StoreConnectionSchemaMixin:
                 self._record_schema_version(connection, version=2)
             self._enable_wal_mode(connection)
             self._repair_store_permissions()
-            self._refresh_policy_integrity_state(connection, now=_now(), create_key=False)
+        # 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.855 → plugin_scanner-2.0.856}/src/codex_plugin_scanner/guard/store_secret_policy_integrity.py

@@ -4,6 +4,8 @@
 
 from __future__ import annotations
 
+from .policy_integrity import POLICY_INTEGRITY_VERSION
+
 # ruff: noqa: F403,F405
 from .store_base import *
 
@@ -43,6 +45,9 @@ def _build_policy_integrity_secret_store_compat() -> SystemKeyringSecretStore |
     return cast(SystemKeyringSecretStore, secret_store)
 
 
+_POLICY_INTEGRITY_LOOKUP_UNSET = object()
+
+
 class StoreSecretPolicyIntegrityMixin:
     def __init__(self, guard_home: Path, *, guard_event_queue_limit: int = 1000) -> None:
         self.guard_home = guard_home
@@ -53,6 +58,13 @@ class StoreSecretPolicyIntegrityMixin:
         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
+        self._startup_prefetched_policy_integrity_secret_material: object | tuple[bytes | None, str | None] = (
+            _POLICY_INTEGRITY_LOOKUP_UNSET
+        )
+        self._startup_prefetched_policy_integrity_trusted_state: object | dict[str, object] | None = (
+            _POLICY_INTEGRITY_LOOKUP_UNSET
+        )
+        self._startup_prefetched_policy_integrity_repair_failed = False
         self._policy_integrity_key_ref = self._build_scoped_secret_ref(_POLICY_INTEGRITY_KEY_REF)
         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)
@@ -466,6 +478,7 @@ class StoreSecretPolicyIntegrityMixin:
             where source not in {_REMOTE_POLICY_SOURCE_PLACEHOLDERS}
               and (
                 integrity_version is null
+                or integrity_version != {POLICY_INTEGRITY_VERSION}
                 or payload_hash is null
                 or payload_mac is null
                 or integrity_key_id is null
@@ -591,21 +604,57 @@ class StoreSecretPolicyIntegrityMixin:
                 "version": _POLICY_INTEGRITY_CONTROL_VERSION,
             }
         else:
-            pending_valid = 0
-            current_valid = 0
-            for row in rows:
-                pending_result = verify_local_policy_row(
-                    _row_mapping(row),
-                    key=key,
-                    key_id=key_id,
-                    degraded_mode=False,
-                    trusted_generation=pending_generation,
-                )
-                if pending_result.status == "valid":
-                    pending_valid += 1
-                    continue
+            (
+                has_legacy_rows,
+                pending_candidates,
+                pending_valid,
+                current_valid,
+            ) = self._classify_policy_integrity_pending_generation_rows(
+                rows,
+                key=key,
+                key_id=key_id,
+                current_generation=current_generation,
+                pending_generation=pending_generation,
+            )
+            if has_legacy_rows:
+                next_state = dict(trusted_state)
+                if pending_candidates > 0 and current_valid == len(rows):
+                    next_state["pending_generation"] = None
+            elif pending_valid == len(rows):
+                next_state = {
+                    "cutover_complete": True,
+                    "generation": pending_generation,
+                    "pending_generation": None,
+                    "version": _POLICY_INTEGRITY_CONTROL_VERSION,
+                }
+            elif current_valid == len(rows):
+                next_state = dict(trusted_state)
+                next_state["pending_generation"] = None
+            else:
+                next_state = dict(trusted_state)
+        if not self._store_policy_integrity_control_state(next_state):
+            raise RuntimeError("Guard could not persist the policy integrity control state.")
+        return next_state
+
+    def _classify_policy_integrity_pending_generation_rows(
+        self,
+        rows: Sequence[sqlite3.Row],
+        *,
+        key: bytes,
+        key_id: str,
+        current_generation: int,
+        pending_generation: int,
+    ) -> tuple[bool, int, int, int]:
+        has_legacy_rows = False
+        pending_candidates = 0
+        pending_valid = 0
+        current_valid = 0
+        for row in rows:
+            row_payload = _row_mapping(row)
+            if _mapping_int(row_payload, "integrity_version") != POLICY_INTEGRITY_VERSION:
+                has_legacy_rows = True
                 current_result = verify_local_policy_row(
-                    _row_mapping(row),
+                    row_payload,
                     key=key,
                     key_id=key_id,
                     degraded_mode=False,
@@ -613,20 +662,174 @@ class StoreSecretPolicyIntegrityMixin:
                 )
                 if current_result.status == "valid":
                     current_valid += 1
-            if pending_valid > 0 or current_valid == 0:
+                continue
+            pending_candidates += 1
+            pending_result = verify_local_policy_row(
+                row_payload,
+                key=key,
+                key_id=key_id,
+                degraded_mode=False,
+                trusted_generation=pending_generation,
+            )
+            if pending_result.status == "valid":
+                pending_valid += 1
+                continue
+            current_result = verify_local_policy_row(
+                row_payload,
+                key=key,
+                key_id=key_id,
+                degraded_mode=False,
+                trusted_generation=current_generation,
+            )
+            if current_result.status == "valid":
+                current_valid += 1
+        return has_legacy_rows, pending_candidates, pending_valid, current_valid
+
+    def _newer_authenticated_policy_integrity_generation(
+        self,
+        connection: sqlite3.Connection,
+        *,
+        key: bytes,
+        key_id: str,
+        trusted_generation: int | None,
+    ) -> int | None:
+        current_valid = 0
+        newer_generations: set[int] = set()
+        rows = self._load_local_policy_rows(connection)
+        validated_rows = 0
+        for row in rows:
+            row_payload = _row_mapping(row)
+            if _mapping_int(row_payload, "integrity_version") != POLICY_INTEGRITY_VERSION:
+                return None
+            row_generation = _mapping_int(row_payload, "integrity_generation")
+            if row_generation is None:
+                return None
+            result = verify_local_policy_row(
+                row_payload,
+                key=key,
+                key_id=key_id,
+                degraded_mode=False,
+                trusted_generation=row_generation,
+            )
+            if result.status != "valid":
+                return None
+            validated_rows += 1
+            if trusted_generation is not None and row_generation == trusted_generation:
+                current_valid += 1
+                continue
+            if trusted_generation is None or row_generation > trusted_generation:
+                newer_generations.add(row_generation)
+                continue
+            return None
+        if current_valid > 0 or len(newer_generations) != 1 or validated_rows != len(rows):
+            return None
+        return next(iter(newer_generations))
+
+    def _resolved_policy_integrity_pending_generation(
+        self,
+        connection: sqlite3.Connection,
+        *,
+        key: bytes,
+        key_id: str,
+        trusted_state: dict[str, object],
+    ) -> dict[str, object]:
+        current_generation = _mapping_int(trusted_state, "generation")
+        if current_generation is None:
+            raise RuntimeError("Guard policy integrity control state is invalid.")
+        pending_generation = trusted_state.get("pending_generation")
+        if not isinstance(pending_generation, int) or pending_generation <= current_generation:
+            return trusted_state
+        rows = self._load_local_policy_rows(connection)
+        next_state: dict[str, object]
+        if not rows:
+            next_state = {
+                "cutover_complete": True,
+                "generation": pending_generation,
+                "pending_generation": None,
+                "version": _POLICY_INTEGRITY_CONTROL_VERSION,
+            }
+        else:
+            (
+                has_legacy_rows,
+                pending_candidates,
+                pending_valid,
+                current_valid,
+            ) = self._classify_policy_integrity_pending_generation_rows(
+                rows,
+                key=key,
+                key_id=key_id,
+                current_generation=current_generation,
+                pending_generation=pending_generation,
+            )
+            if has_legacy_rows:
+                next_state = dict(trusted_state)
+                if pending_candidates > 0 and current_valid == len(rows):
+                    next_state["pending_generation"] = None
+            elif pending_valid == len(rows):
                 next_state = {
                     "cutover_complete": True,
                     "generation": pending_generation,
                     "pending_generation": None,
                     "version": _POLICY_INTEGRITY_CONTROL_VERSION,
                 }
-            else:
+            elif current_valid == len(rows):
                 next_state = dict(trusted_state)
                 next_state["pending_generation"] = None
-        if not self._store_policy_integrity_control_state(next_state):
-            raise RuntimeError("Guard could not persist the policy integrity control state.")
+            else:
+                next_state = dict(trusted_state)
         return next_state
 
+    def _prepared_startup_policy_integrity_state(
+        self,
+        connection: sqlite3.Connection,
+        *,
+        key: bytes,
+        key_id: str,
+        trusted_state: dict[str, object],
+    ) -> dict[str, object]:
+        has_legacy_rows = self._count_legacy_local_policy_rows(connection) > 0
+        prepared_state = dict(trusted_state)
+        pending_generation = prepared_state.get("pending_generation")
+        if not isinstance(pending_generation, int) and not has_legacy_rows:
+            newer_authenticated_generation = self._newer_authenticated_policy_integrity_generation(
+                connection,
+                key=key,
+                key_id=key_id,
+                trusted_generation=_mapping_int(prepared_state, "generation"),
+            )
+            if newer_authenticated_generation is not None:
+                prepared_state["generation"] = newer_authenticated_generation
+        prepared_state = self._resolved_policy_integrity_pending_generation(
+            connection,
+            key=key,
+            key_id=key_id,
+            trusted_state=prepared_state,
+        )
+        if not bool(prepared_state.get("cutover_complete")) and not has_legacy_rows:
+            prepared_state["cutover_complete"] = True
+        return prepared_state
+
+    def _prefetched_startup_state_still_matches_local_rows(
+        self,
+        connection: sqlite3.Connection,
+        *,
+        key: bytes,
+        key_id: str,
+        trusted_state: dict[str, object],
+    ) -> bool:
+        trusted_generation = _mapping_int(trusted_state, "generation")
+        for row in self._load_local_policy_rows(connection):
+            result = verify_local_policy_row(
+                _row_mapping(row),
+                key=key,
+                key_id=key_id,
+                degraded_mode=False,
+                trusted_generation=trusted_generation,
+            )
+            if result.status != "valid":
+                return False
+        return True
+
     def _refresh_policy_integrity_state(
         self,
         connection: sqlite3.Connection,
@@ -638,19 +841,48 @@ class StoreSecretPolicyIntegrityMixin:
     ) -> dict[str, object]:
         existing = self._load_policy_integrity_state(connection) or {}
         warnings = self._policy_integrity_path_warnings()
-        trusted_state = self._load_policy_integrity_control_state(create=create_key)
-        raw_key, key_id = (
-            secret_material
-            if secret_material is not None
-            else self._policy_integrity_secret_material(create=create_key)
+        prefetched_trusted_state = getattr(
+            self,
+            "_startup_prefetched_policy_integrity_trusted_state",
+            _POLICY_INTEGRITY_LOOKUP_UNSET,
+        )
+        using_prefetched_trusted_state = prefetched_trusted_state is not _POLICY_INTEGRITY_LOOKUP_UNSET
+        if using_prefetched_trusted_state:
+            trusted_state = cast(dict[str, object] | None, prefetched_trusted_state)
+        else:
+            trusted_state = self._load_policy_integrity_control_state(create=create_key)
+        if using_prefetched_trusted_state and getattr(
+            self,
+            "_startup_prefetched_policy_integrity_repair_failed",
+            False,
+        ):
+            trusted_state = None
+            warnings.append(POLICY_INTEGRITY_REASON_CONTROL_UNAVAILABLE)
+        prefetched_secret_material = getattr(
+            self,
+            "_startup_prefetched_policy_integrity_secret_material",
+            _POLICY_INTEGRITY_LOOKUP_UNSET,
         )
+        using_prefetched_secret_material = prefetched_secret_material is not _POLICY_INTEGRITY_LOOKUP_UNSET
+        if secret_material is not None:
+            raw_key, key_id = secret_material
+        elif using_prefetched_secret_material:
+            raw_key, key_id = cast(tuple[bytes | None, str | None], prefetched_secret_material)
+        else:
+            raw_key, key_id = self._policy_integrity_secret_material(create=create_key)
         if self._policy_integrity_secret_store is None:
             warnings.append(POLICY_INTEGRITY_REASON_SYSTEM_KEYRING_UNAVAILABLE)
         elif raw_key is None or key_id is None:
             warnings.append(POLICY_INTEGRITY_REASON_KEY_UNAVAILABLE)
         if trusted_state is None:
             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:
+        if (
+            not warnings
+            and trusted_state is not None
+            and raw_key is not None
+            and key_id is not None
+            and not using_prefetched_trusted_state
+        ):
             try:
                 trusted_state = self._reconcile_policy_integrity_pending_generation(
                     connection,
@@ -666,6 +898,7 @@ class StoreSecretPolicyIntegrityMixin:
             and trusted_state is not None
             and not bool(trusted_state.get("cutover_complete"))
             and has_only_signed_rows
+            and not using_prefetched_trusted_state
         ):
             next_trusted_state = dict(trusted_state)
             next_trusted_state["cutover_complete"] = True
@@ -689,6 +922,74 @@ class StoreSecretPolicyIntegrityMixin:
             self._store_policy_integrity_state(connection, payload, now=now)
         return payload
 
+    def _prepare_startup_prefetched_policy_integrity_state(self) -> None:
+        prefetched_trusted_state = getattr(
+            self,
+            "_startup_prefetched_policy_integrity_trusted_state",
+            _POLICY_INTEGRITY_LOOKUP_UNSET,
+        )
+        prefetched_secret_material = getattr(
+            self,
+            "_startup_prefetched_policy_integrity_secret_material",
+            _POLICY_INTEGRITY_LOOKUP_UNSET,
+        )
+        if (
+            prefetched_trusted_state is _POLICY_INTEGRITY_LOOKUP_UNSET
+            or prefetched_secret_material is _POLICY_INTEGRITY_LOOKUP_UNSET
+        ):
+            return
+        trusted_state = cast(dict[str, object] | None, prefetched_trusted_state)
+        if trusted_state is None:
+            return
+        raw_key, key_id = cast(tuple[bytes | None, str | None], prefetched_secret_material)
+        if raw_key is None or key_id is None:
+            return
+
+        def compute_prepared_state(base_state: dict[str, object]) -> dict[str, object]:
+            connection = sqlite3.connect(self.path, timeout=SQLITE_CONNECT_TIMEOUT_SECONDS)
+            connection.row_factory = sqlite3.Row
+            try:
+                connection.execute(f"pragma busy_timeout={SQLITE_BUSY_TIMEOUT_MS}")
+                return self._prepared_startup_policy_integrity_state(
+                    connection,
+                    key=raw_key,
+                    key_id=key_id,
+                    trusted_state=base_state,
+                )
+            finally:
+                connection.close()
+
+        prepared_state = compute_prepared_state(trusted_state)
+        current_trusted_state = self._load_policy_integrity_control_state(create=False)
+        if current_trusted_state is None:
+            connection = sqlite3.connect(self.path, timeout=SQLITE_CONNECT_TIMEOUT_SECONDS)
+            connection.row_factory = sqlite3.Row
+            try:
+                connection.execute(f"pragma busy_timeout={SQLITE_BUSY_TIMEOUT_MS}")
+                still_matches = self._prefetched_startup_state_still_matches_local_rows(
+                    connection,
+                    key=raw_key,
+                    key_id=key_id,
+                    trusted_state=trusted_state,
+                )
+            finally:
+                connection.close()
+            if prepared_state == trusted_state and still_matches:
+                self._startup_prefetched_policy_integrity_trusted_state = trusted_state
+                return
+            self._startup_prefetched_policy_integrity_repair_failed = True
+            return
+        if current_trusted_state != trusted_state:
+            trusted_state = dict(current_trusted_state)
+            prepared_state = compute_prepared_state(trusted_state)
+        if prepared_state == trusted_state:
+            self._startup_prefetched_policy_integrity_trusted_state = trusted_state
+            return
+        if self._store_policy_integrity_control_state(prepared_state):
+            self._startup_prefetched_policy_integrity_trusted_state = prepared_state
+            return
+        self._startup_prefetched_policy_integrity_repair_failed = True
+
     def _policy_integrity_result_for_row(
         self,
         row: sqlite3.Row,

{plugin_scanner-2.0.855 → plugin_scanner-2.0.856}/src/codex_plugin_scanner/version.py

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

{plugin_scanner-2.0.855 → plugin_scanner-2.0.856}/tests/test_guard_package_shims.py

@@ -12,7 +12,8 @@ import threading
 import time
 from datetime import datetime, timedelta, timezone
 from http.server import HTTPServer
-from multiprocessing import Event, Process
+from io import StringIO
+from multiprocessing import Event, Process, Queue
 from pathlib import Path
 
 import pytest
@@ -308,6 +309,103 @@ def _hold_guard_db_writer_lock(
         connection.close()
 
 
+def _run_guard_protect_command(
+    home_dir: str,
+    workspace_dir: str,
+    *,
+    delay_retry_policy_integrity_seconds: float = 0.0,
+    refresh_started_event: Event | None = None,
+    result_queue: Queue | None = None,
+) -> None:
+    from contextlib import redirect_stderr, redirect_stdout
+
+    from codex_plugin_scanner.cli import main as guard_main
+    from codex_plugin_scanner.guard.store import GuardStore
+
+    if delay_retry_policy_integrity_seconds > 0:
+        secret_lookup_count = 0
+        control_lookup_count = 0
+        original_secret_lookup = GuardStore._policy_integrity_secret_material
+        original_control_lookup = GuardStore._load_policy_integrity_control_state
+        original_refresh = GuardStore._refresh_policy_integrity_state
+
+        def delayed_secret_lookup(self, *, create: bool):
+            nonlocal secret_lookup_count
+            if create:
+                return original_secret_lookup(self, create=create)
+            secret_lookup_count += 1
+            if secret_lookup_count == 1:
+                return None, None
+            time.sleep(delay_retry_policy_integrity_seconds)
+            return None, None
+
+        def delayed_control_lookup(self, *, create: bool):
+            nonlocal control_lookup_count
+            if create:
+                return original_control_lookup(self, create=create)
+            control_lookup_count += 1
+            if control_lookup_count == 1:
+                return None
+            time.sleep(delay_retry_policy_integrity_seconds)
+            return None
+
+        def refresh_with_signal(
+            self,
+            connection,
+            *,
+            now: str,
+            create_key: bool,
+            secret_material=None,
+            allow_cutover_resign: bool = True,
+        ):
+            if refresh_started_event is not None and not refresh_started_event.is_set():
+                refresh_started_event.set()
+            return original_refresh(
+                self,
+                connection,
+                now=now,
+                create_key=create_key,
+                secret_material=secret_material,
+                allow_cutover_resign=allow_cutover_resign,
+            )
+
+        GuardStore._policy_integrity_secret_material = delayed_secret_lookup
+        GuardStore._load_policy_integrity_control_state = delayed_control_lookup
+        GuardStore._refresh_policy_integrity_state = refresh_with_signal
+
+    stdout = StringIO()
+    stderr = StringIO()
+    started = time.monotonic()
+    with redirect_stdout(stdout), redirect_stderr(stderr):
+        return_code = guard_main(
+            [
+                "guard",
+                "protect",
+                "--home",
+                home_dir,
+                "--guard-home",
+                home_dir,
+                "--workspace",
+                workspace_dir,
+                "--dry-run",
+                "--json",
+                "bun",
+                "install",
+                "-g",
+                "@oh-my-pi/pi-coding-agent",
+            ]
+        )
+    if result_queue is not None:
+        result_queue.put(
+            {
+                "returncode": return_code,
+                "elapsed": time.monotonic() - started,
+                "stdout": stdout.getvalue(),
+                "stderr": stderr.getvalue(),
+            }
+        )
+
+
 def test_enable_wal_mode_uses_bounded_busy_timeout(monkeypatch: pytest.MonkeyPatch) -> None:
     sleep_calls: list[float] = []
 
@@ -353,6 +451,40 @@ def test_enable_wal_mode_uses_bounded_busy_timeout(monkeypatch: pytest.MonkeyPat
     assert sleep_calls == [guard_store_module._SQLITE_LOCK_RETRY_DELAY_SECONDS]
 
 
+def test_guard_store_init_does_not_hold_sqlite_writer_during_missing_policy_integrity_retry(tmp_path: Path) -> None:
+    home_dir = tmp_path / "guard-home"
+    workspace_dir = tmp_path / "workspace"
+    home_dir.mkdir(parents=True, exist_ok=True)
+    workspace_dir.mkdir(parents=True, exist_ok=True)
+    refresh_started_event = Event()
+    slow_results: Queue = Queue()
+    slow_process = Process(
+        target=_run_guard_protect_command,
+        args=(str(home_dir), str(workspace_dir)),
+        kwargs={
+            "delay_retry_policy_integrity_seconds": 4.0,
+            "refresh_started_event": refresh_started_event,
+            "result_queue": slow_results,
+        },
+    )
+    slow_process.start()
+    assert refresh_started_event.wait(timeout=5)
+
+    fast_started = time.monotonic()
+    fast_results: Queue = Queue()
+    _run_guard_protect_command(str(home_dir), str(workspace_dir), result_queue=fast_results)
+    fast_elapsed = time.monotonic() - fast_started
+    fast_result = fast_results.get(timeout=1)
+
+    slow_process.join(timeout=20)
+    assert slow_process.exitcode == 0
+    slow_result = slow_results.get(timeout=1)
+
+    assert fast_result["returncode"] == 0
+    assert slow_result["returncode"] == 0
+    assert fast_elapsed < 3.0
+
+
 def _write_npm_ci_workspace(workspace_dir: Path, *, package_name: str, package_version: str) -> None:
     (workspace_dir / "package.json").write_text(
         json.dumps(