plugin-scanner 2.0.855__py3-none-any.whl → 2.0.856__py3-none-any.whl

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
 
 

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:

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,

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.dist-info → plugin_scanner-2.0.856.dist-info}/METADATA

@@ -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.dist-info → plugin_scanner-2.0.856.dist-info}/RECORD

@@ -27,7 +27,7 @@ codex_plugin_scanner/trust_scoring.py,sha256=t_Lw13HZ766UCJzTtNNwllZK_k2ks_x-8St
 codex_plugin_scanner/trust_skill_scoring.py,sha256=e-SrMBgAruzFn4RD0pGpP9rtPXxc2ji_CKpcnFPRh3M,12542
 codex_plugin_scanner/trust_specs.py,sha256=aYGSB8M9RQp1uwhsRaWlVa1M9Vk51kUIxmBXkW8noZU,10729
 codex_plugin_scanner/verification.py,sha256=J2nsnYlxNYecSvmSQhV_leImLslCOotIK2FSmEoIjg0,27896
-codex_plugin_scanner/version.py,sha256=MJJwS082eTvR2R856BKRIKGrJon1Kfb1eL49CX4aZ1c,72
+codex_plugin_scanner/version.py,sha256=sk9IPKWaSML9BHMqUNXJJlynzAiNrnn5VGEhhvMmv4Y,72
 codex_plugin_scanner/checks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 codex_plugin_scanner/checks/best_practices.py,sha256=uB3DXLggqxjfyBMH_1yvX4nyFhpIvaRHjTyyueoO-GQ,8473
 codex_plugin_scanner/checks/claude.py,sha256=cMucH5pmKgQtBnDcycOzMMlKL-Q5HQemPqUmTLF0DzE,10189
@@ -108,13 +108,13 @@ codex_plugin_scanner/guard/shim_probe.py,sha256=4o_Cwi8B0VSJEcYQ4O15mSnh36l4ovSe
 codex_plugin_scanner/guard/shims.py,sha256=GOhbFcD8sUdNfMnJ3zdx1OhG9NGGOkt_A12_C91kH7s,52729
 codex_plugin_scanner/guard/sqlite_tuning.py,sha256=auE2AaawN-6_pPfzLg4Mj-ZhLyRGXI21CQoTVHR_ug8,243
 codex_plugin_scanner/guard/stable_digest.py,sha256=O4Ts-kGtetRtHZPgMAaFZ8VRC2_x-pSbhZh4X-oZmm4,569
-codex_plugin_scanner/guard/store.py,sha256=gjiHBB0VdX3lkoc9k9DKcU-i4O3Tx_aC4Np89NUIHWI,1470
+codex_plugin_scanner/guard/store.py,sha256=SVXd8r_fCsofln_3ZQQMJ1xUnkrxir5oAfN4ZgYgX9c,1515
 codex_plugin_scanner/guard/store_approval_facade.py,sha256=N10BrWESEbhgb_xtM9NYVFfY-AwHi1xSvPMWW26jg4E,17172
 codex_plugin_scanner/guard/store_approvals.py,sha256=gGF8MeamalcNwgiwG51zBPyoZj-FYUo7hWFRStts7a4,44179
 codex_plugin_scanner/guard/store_base.py,sha256=Qx-secIy8iaBdO1-ocRlpJk5WuidTyyn3BWL2IaEb0w,50267
 codex_plugin_scanner/guard/store_cloud_events.py,sha256=zD_dFMMNs2aaczgR1TNCuK96nOLNBVzhCgNg2PC4KNA,15230
 codex_plugin_scanner/guard/store_connect.py,sha256=rNuZ5F9WOSw9x-GVwFcpLLf-kvwhCvCeMuKzLOF-nhY,8102
-codex_plugin_scanner/guard/store_connection_schema.py,sha256=uMwfSL3e52gJVpEdQnE_MLPE91MWzkqqo5Ss46FZvQg,30090
+codex_plugin_scanner/guard/store_connection_schema.py,sha256=nS60SyagRSe6GyjCeC0ibzQqZf4weWhyy6MCyZ9JWE0,31503
 codex_plugin_scanner/guard/store_event_receipts.py,sha256=RZghgg7rmMSNMzAu5QECNxfL3FxBkUn0qKYZcICXTZc,7340
 codex_plugin_scanner/guard/store_evidence.py,sha256=bmvTq-Y9ctO61uCUygXdGJjPKEjN8zYsjuzMwMoeDrI,13755
 codex_plugin_scanner/guard/store_evidence_facade.py,sha256=tDVUgagZJFOBVNhWXHeC_7FUtKzqZDtSGT4ZqMJebis,2209
@@ -127,7 +127,7 @@ codex_plugin_scanner/guard/store_policy_source_context.py,sha256=H-aIQR3w67o8HOn
 codex_plugin_scanner/guard/store_receipt_rollups.py,sha256=ugJW5Ca-CaSorOSB5chyqCPXYKIILcnArK09SJXsspw,16814
 codex_plugin_scanner/guard/store_receipts.py,sha256=Anh1DIc8M8PKa4NTprKqptV422y9S4dmd72W-XIRHfw,15625
 codex_plugin_scanner/guard/store_resume.py,sha256=7x3Y4tSUMI86j67_463GO-Z7L4cNWQUQJgg5r0mW-Lw,5977
-codex_plugin_scanner/guard/store_secret_policy_integrity.py,sha256=VMqP9cWNb3lpNUTzgYBdYRdKpBqPGiAXL1I4caU1d18,33429
+codex_plugin_scanner/guard/store_secret_policy_integrity.py,sha256=XcjAcMMO9YeVgltU9ZsrUAu-GI-9097JEPY7-9rbkhg,45747
 codex_plugin_scanner/guard/store_sessions.py,sha256=FiYh7f4dYZg-Wo_Alu5YoGqy1qclgNbyzDb3ENzZBog,21347
 codex_plugin_scanner/guard/store_supply_chain.py,sha256=TpNyNfbUZjaci0uOVgmY7-lFIayfl67b4kaFUJesv5U,5901
 codex_plugin_scanner/guard/store_threat_intel.py,sha256=rXmH1E_Wto9BOhAwt9mokfSy7ayWOD6PaEwvD4LnmDo,6449
@@ -335,8 +335,8 @@ codex_plugin_scanner/integrations/cisco_skill_scanner.py,sha256=gF6xJ3ptWpGNPZA1
 codex_plugin_scanner/rules/__init__.py,sha256=bhAnNlVvEiAoksf_-Vd4f74JNz66pTINhUO2mMc8kvs,293
 codex_plugin_scanner/rules/registry.py,sha256=7BaRerM26teDUM0S48d3sPHbqzmq2JhuelC0_ni3364,4580
 codex_plugin_scanner/rules/specs.py,sha256=gpU0lijxqdSEZMMf28vciQxob-lvBEPcMQ4BG6N_r3I,650
-plugin_scanner-2.0.855.dist-info/METADATA,sha256=DXnXrLWX14TxWfAw71B20f9DKg0nZ0Tal-M5tJ7fBoM,40163
-plugin_scanner-2.0.855.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-plugin_scanner-2.0.855.dist-info/entry_points.txt,sha256=SLGKi3GvvSsPwave-k2JQt2meG0pM7aaC6VlUy47Crg,122
-plugin_scanner-2.0.855.dist-info/licenses/LICENSE,sha256=M6h9Xc242NSFZx5h6wBOKJpEQkFl_Wmz03yNrZd0_3E,5688
-plugin_scanner-2.0.855.dist-info/RECORD,,
+plugin_scanner-2.0.856.dist-info/METADATA,sha256=oez7sNDPOnonoZWEUIi3e4ALd-FZx18fOuY8mnPSc-0,40163
+plugin_scanner-2.0.856.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+plugin_scanner-2.0.856.dist-info/entry_points.txt,sha256=SLGKi3GvvSsPwave-k2JQt2meG0pM7aaC6VlUy47Crg,122
+plugin_scanner-2.0.856.dist-info/licenses/LICENSE,sha256=M6h9Xc242NSFZx5h6wBOKJpEQkFl_Wmz03yNrZd0_3E,5688
+plugin_scanner-2.0.856.dist-info/RECORD,,