plugin-scanner 2.0.1018__tar.gz → 2.0.1020__tar.gz

{plugin_scanner-2.0.1018 → plugin_scanner-2.0.1020}/PKG-INFO

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

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

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

@@ -123,6 +123,7 @@ def _resolve_trust_attestation_context(
     *,
     generated_at: str,
     include_upload_session_bindings: bool = False,
+    workspace_id: str | None = None,
 ) -> dict[str, object]:
     from .runtime.trust_attestation import (
         resolve_guard_oauth_trust_attestation_signing_config,
@@ -137,6 +138,7 @@ def _resolve_trust_attestation_context(
         guard_home = store.guard_home if include_upload_session_bindings else None
         signing_config = resolve_trust_attestation_signing_config(guard_home=guard_home)
     enable_v2 = trust_attestation_v2_enabled()
+    resolved_workspace_id = workspace_id or store.get_cloud_workspace_id()
     installation_id = store.get_or_create_installation_id() if enable_v2 else None
     context: dict[str, object] = {
         "analyzerId": "hol-guard" if enable_v2 else None,
@@ -151,7 +153,7 @@ def _resolve_trust_attestation_context(
         "sequence": None,
         "signingConfig": signing_config,
         "uploadId": None,
-        "workspaceId": store.get_cloud_workspace_id() if enable_v2 else None,
+        "workspaceId": resolved_workspace_id if enable_v2 else None,
     }
     if not enable_v2 or not include_upload_session_bindings:
         return context
@@ -360,14 +362,23 @@ def sync_aibom_snapshots_if_due(
     force: bool = False,
     options: AibomCliOptions | None = None,
     auth_context: dict[str, object] | None = None,
+    expected_workspace_id: str | None = None,
     home_dir: Path | None = None,
     workspace_dir: Path | None = None,
 ) -> dict[str, object]:
     runner = _runner_module()
     guard_sync_not_configured_error = runner.GuardSyncNotConfiguredError
 
-    if store.get_cloud_workspace_id() is None:
+    current_workspace_id = store.get_cloud_workspace_id()
+    if current_workspace_id is None:
         return {"synced": False, "skipped": True, "reason": "not_configured"}
+    if expected_workspace_id is not None and current_workspace_id != expected_workspace_id:
+        return {
+            "synced": False,
+            "reason": "workspace_changed",
+            "error": "Guard Cloud workspace changed before AIBOM inventory sync.",
+        }
+    bound_workspace_id = expected_workspace_id or current_workspace_id
     if _aibom_guard_events_endpoint_unavailable_recently(store):
         return {
             "synced": False,
@@ -398,6 +409,7 @@ def sync_aibom_snapshots_if_due(
             generated_at=generated_at,
             options=options,
             auth_context=auth_context,
+            expected_workspace_id=bound_workspace_id,
         )
     except guard_sync_not_configured_error:
         return {"synced": False, "skipped": True, "reason": "not_configured"}
@@ -414,20 +426,28 @@ def sync_aibom_snapshots(
     generated_at: str,
     options: AibomCliOptions | None = None,
     auth_context: dict[str, object] | None = None,
+    expected_workspace_id: str | None = None,
 ) -> dict[str, object]:
     runner = _runner_module()
     guard_sync_not_configured_error = runner.GuardSyncNotConfiguredError
 
-    workspace_id = store.get_cloud_workspace_id()
-    if workspace_id is None:
-        raise guard_sync_not_configured_error("Guard Cloud workspace is not configured. Run `hol-guard connect` first.")
+    with store.hold_oauth_credential_lock():
+        current_workspace_id = store.get_cloud_workspace_id()
+        if current_workspace_id is None:
+            raise guard_sync_not_configured_error(
+                "Guard Cloud workspace is not configured. Run `hol-guard connect` first."
+            )
+        if expected_workspace_id is not None and current_workspace_id != expected_workspace_id:
+            raise ValueError("Guard Cloud workspace changed before AIBOM inventory sync.")
+        workspace_id = expected_workspace_id or current_workspace_id
+        trust_attestation_context = _resolve_trust_attestation_context(
+            store,
+            generated_at=generated_at,
+            include_upload_session_bindings=True,
+            workspace_id=workspace_id,
+        )
 
     resolved_options = options or _AIBOM_CLOUD_SYNC_OPTIONS
-    trust_attestation_context = _resolve_trust_attestation_context(
-        store,
-        generated_at=generated_at,
-        include_upload_session_bindings=True,
-    )
     primary_content_sources: list[GuardAibomPrimaryContentSource] = []
     snapshots = collect_aibom_snapshots(
         context,

{plugin_scanner-2.0.1018 → plugin_scanner-2.0.1020}/src/codex_plugin_scanner/guard/daemon/server.py

@@ -197,6 +197,7 @@ _SUPPLY_CHAIN_CONNECT_WAIT_TIMEOUT_SECONDS = 180
 _LOCAL_DASHBOARD_SESSION_REFRESH_GRACE_SECONDS = 7 * 24 * 60 * 60
 _DEFAULT_HEADLESS_CLOUD_SYNC_INTERVAL_SECONDS = 30.0
 _DEFAULT_HEADLESS_CLOUD_SYNC_BACKOFF_SECONDS = 10.0
+_AIBOM_REFRESH_STOP_JOIN_TIMEOUT_SECONDS = 5.0
 
 
 class _HookPathValidationError(ValueError):
@@ -2416,7 +2417,7 @@ class _GuardDaemonHandler(BaseHTTPRequestHandler):
             return
         request_row = self.server.store.get_approval_request(request_id)  # type: ignore[attr-defined]
         if not isinstance(request_row, dict) or request_row.get("status") != "pending":
-            self._write_json({"error": "remote_once_request_expired"}, status=409)
+            self._write_json({"error": "remote_once_request_not_pending"}, status=409)
             return
         request_policy_action = self._optional_string(request_row.get("policy_action"))
         request_recommended_scope = self._optional_string(request_row.get("recommended_scope"))
@@ -5443,6 +5444,9 @@ class GuardDaemonServer:
         self._headless_cloud_sync_interval_seconds = _DEFAULT_HEADLESS_CLOUD_SYNC_INTERVAL_SECONDS
         self._aibom_home_dir = home_dir.expanduser() if home_dir is not None else None
         self._aibom_workspace_dir = workspace_dir.expanduser() if workspace_dir is not None else None
+        self._aibom_context_workspace_id = (
+            store.get_cloud_workspace_id() if self._aibom_workspace_dir is not None else None
+        )
         self._aibom_refresh_thread: threading.Thread | None = None
         self._bundle_refresh_thread: threading.Thread | None = None
         self._command_queue_worker: CommandQueueWorker | None = None
@@ -5478,8 +5482,9 @@ class GuardDaemonServer:
             self._bundle_refresh_thread.join(timeout=5)
             self._bundle_refresh_thread = None
         if self._aibom_refresh_thread is not None:
-            self._aibom_refresh_thread.join(timeout=5)
-            self._aibom_refresh_thread = None
+            self._aibom_refresh_thread.join(timeout=_AIBOM_REFRESH_STOP_JOIN_TIMEOUT_SECONDS)
+            if not self._aibom_refresh_thread.is_alive():
+                self._aibom_refresh_thread = None
         if self._headless_cloud_sync_thread is not None:
             self._headless_cloud_sync_thread.join(timeout=5)
             self._headless_cloud_sync_thread = None
@@ -5487,7 +5492,12 @@ class GuardDaemonServer:
         self._live_request_sync_worker = stop_cloud_sync_sync_worker(self._live_request_sync_worker)
 
     def _begin_service(self) -> None:
+        if self._aibom_refresh_thread is not None:
+            if self._aibom_refresh_thread.is_alive():
+                raise RuntimeError("AIBOM inventory refresh is still stopping")
+            self._aibom_refresh_thread = None
         self._shutdown_started.clear()
+        self._persist_aibom_inventory_context()
         self._server.last_activity_monotonic = time.monotonic()
         write_guard_daemon_state(self._server.store.guard_home, self.port, self._server.auth_token)
         self._server.store.upsert_runtime_state(
@@ -5507,6 +5517,23 @@ class GuardDaemonServer:
             self._live_request_sync_worker,
         )
 
+    def _persist_aibom_inventory_context(self) -> None:
+        workspace_id = self._server.store.get_cloud_workspace_id()
+        if (
+            workspace_id is None
+            or workspace_id != self._aibom_context_workspace_id
+            or self._aibom_workspace_dir is None
+        ):
+            return
+        payload: dict[str, object] = {
+            "workspace_dir": str(self._aibom_workspace_dir),
+            "workspace_id": workspace_id,
+        }
+        if self._aibom_home_dir is not None:
+            payload["home_dir"] = str(self._aibom_home_dir)
+        now = _now()
+        self._server.store.set_sync_payload("aibom_inventory_context", payload, now)
+
     def _serve_forever(self) -> None:
         try:
             self._server.serve_forever()
@@ -5645,25 +5672,33 @@ class GuardDaemonServer:
         )
         self._aibom_refresh_thread.start()
 
-    def _aibom_inventory_context_dirs(self) -> tuple[Path | None, Path | None]:
+    def _aibom_inventory_context_dirs(self) -> tuple[Path | None, Path | None, str | None]:
         payload = self._server.store.get_sync_payload("aibom_inventory_context")
-        if isinstance(payload, dict):
-            home_value = payload.get("home_dir")
-            workspace_value = payload.get("workspace_dir")
+        current_workspace_id = self._server.store.get_cloud_workspace_id()
+        bound_payload: dict[str, object] | None = None
+        if (
+            current_workspace_id is not None
+            and isinstance(payload, dict)
+            and payload.get("workspace_id") == current_workspace_id
+        ):
+            bound_payload = payload
+        if bound_payload is not None:
+            home_value = bound_payload.get("home_dir")
+            workspace_value = bound_payload.get("workspace_dir")
         else:
             home_value = None
             workspace_value = None
-        home_dir = (
-            Path(home_value).expanduser()
-            if isinstance(home_value, str) and home_value.strip()
-            else self._aibom_home_dir
+        explicit_context_is_bound = (
+            self._aibom_workspace_dir is not None and self._aibom_context_workspace_id == current_workspace_id
         )
-        workspace_dir = (
-            Path(workspace_value).expanduser()
-            if isinstance(workspace_value, str) and workspace_value.strip()
-            else self._aibom_workspace_dir
-        )
-        return home_dir, workspace_dir
+        home_dir = self._aibom_home_dir if explicit_context_is_bound else None
+        if home_dir is None and isinstance(home_value, str) and home_value.strip():
+            home_dir = Path(home_value).expanduser()
+        workspace_dir = self._aibom_workspace_dir if explicit_context_is_bound else None
+        if workspace_dir is None and isinstance(workspace_value, str) and workspace_value.strip():
+            workspace_dir = Path(workspace_value).expanduser()
+        bound_workspace_id = current_workspace_id if workspace_dir is not None else None
+        return home_dir, workspace_dir, bound_workspace_id
 
     def _refresh_aibom_inventory_loop(self) -> None:
         interval_seconds = self._aibom_refresh_interval_seconds
@@ -5672,12 +5707,10 @@ class GuardDaemonServer:
         backoff_seconds = (
             self._aibom_refresh_backoff_seconds if self._aibom_refresh_backoff_seconds > 0 else interval_seconds
         )
-        if self._shutdown_started.wait(interval_seconds):
-            return
         while not self._shutdown_started.is_set():
             refreshed_at = _now()
             try:
-                home_dir, workspace_dir = self._aibom_inventory_context_dirs()
+                home_dir, workspace_dir, bound_workspace_id = self._aibom_inventory_context_dirs()
                 if workspace_dir is None:
                     self._server.store.set_sync_payload(
                         "aibom_inventory_daemon",
@@ -5699,16 +5732,23 @@ class GuardDaemonServer:
                         generated_at=refreshed_at,
                         min_interval_seconds=max(int(interval_seconds), 1),
                         auth_context=auth_context,
+                        expected_workspace_id=bound_workspace_id,
                         home_dir=home_dir,
                         workspace_dir=workspace_dir,
                     )
-                status = "synced" if summary.get("synced") is True else str(summary.get("reason") or "skipped")
+                has_error = bool(summary.get("error"))
+                if has_error:
+                    status = "error"
+                elif summary.get("synced") is True:
+                    status = "synced"
+                else:
+                    status = str(summary.get("reason") or "skipped")
                 self._server.store.set_sync_payload(
                     "aibom_inventory_daemon",
                     {**summary, "status": status, "refreshed_at": refreshed_at},
                     refreshed_at,
                 )
-                wait_seconds = interval_seconds
+                wait_seconds = backoff_seconds if has_error or status == "not_configured" else interval_seconds
             except GuardSyncAuthorizationExpiredError as error:
                 self._server.store.set_sync_payload(
                     "aibom_inventory_daemon",

{plugin_scanner-2.0.1018 → plugin_scanner-2.0.1020}/src/codex_plugin_scanner/guard/runtime/live_request_sync.py

@@ -38,7 +38,6 @@ from dataclasses import dataclass
 from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Any
 
-from ..redaction import redact_text
 from ..review_contracts import (
     GuardReviewContractError,
     GuardReviewOAuthMetadata,
@@ -48,6 +47,8 @@ from ..review_contracts import (
 from ..store import GuardStore
 from .local_request_snapshots import (
     _cloud_safe_local_request_payload,
+    _cloud_scrub_text,
+    _local_request_command_text,
     _resolve_cloud_receipt_redaction_level,
 )
 
@@ -84,7 +85,6 @@ SYNC_HEALTH_STATES = frozenset({"healthy", "stale", "auth_failed", "retrying", "
 _EVENT_TYPE_MAP = {
     "pending": "request_created",
     "resolved": "request_resolved",
-    "expired": "request_expired",
     "superseded": "request_superseded",
 }
 
@@ -164,20 +164,20 @@ def _build_display_command(item: dict[str, object], redaction_level: str) -> tup
     risk_headline = str(item.get("risk_headline") or item.get("risk_summary") or "")
     harness = str(item.get("harness") or "guard-review")
 
-    display_command = f"{harness}: {action_identity}"
+    fallback_display = f"{_cloud_scrub_text(harness)}: {_cloud_scrub_text(action_identity)}"
+    envelope_value = item.get("action_envelope_json")
+    envelope = envelope_value if isinstance(envelope_value, dict) else None
+    command_text = _local_request_command_text(item, envelope)
+    safe_command = _cloud_scrub_text(command_text) if command_text else None
+    display_command = safe_command if safe_command and redaction_level != "full" else fallback_display
     display_summary = f"{trigger_summary}"
     if risk_headline:
         display_summary = f"{risk_headline} — {trigger_summary}"
 
-    raw_command: str | None = None
-    redacted_command: str | None = None
-    if redaction_level == "none":
-        raw_command = display_command
-    elif redaction_level == "partial":
-        raw_command = display_command
-        redacted_command = redact_text(display_command).text
-    else:
-        redacted_command = redact_text(display_command).text
+    raw_command = display_command if redaction_level == "none" and safe_command else None
+    redacted_command = (
+        display_command if redaction_level == "full" or (redaction_level == "partial" and safe_command) else None
+    )
     return display_command, display_summary, raw_command, redacted_command
 
 
@@ -193,7 +193,8 @@ def _build_live_request_event(
     if not isinstance(request_id, str) or not request_id:
         return None
 
-    status = str(item.get("status") or "pending")
+    stored_status = str(item.get("status") or "pending")
+    status = "pending" if stored_status == "expired" else stored_status
     event_type = _EVENT_TYPE_MAP.get(status, "request_created")
 
     claim: dict[str, object] | None = None
@@ -212,7 +213,6 @@ def _build_live_request_event(
 
     created_at = str(item.get("created_at") or _now())
     last_seen_at = str(item.get("last_seen_at") or created_at)
-    expires_at = item.get("expires_at")
 
     request_payload = _cloud_safe_local_request_payload(item, redaction_level=redaction_level)
 
@@ -235,7 +235,6 @@ def _build_live_request_event(
         "localCreatedAt": created_at,
         "localUpdatedAt": str(item.get("updated_at") or last_seen_at),
         "localLastSeenAt": last_seen_at,
-        "localExpiresAt": str(expires_at) if isinstance(expires_at, str) and expires_at else None,
         "localEmittedAt": _now(),
         "sentAt": _now(),
     }
@@ -821,21 +820,6 @@ def emit_request_refreshed(
     )
 
 
-def emit_request_expired(
-    store: GuardStore,
-    local_request_id: str,
-    *,
-    resolved_at: str | None = None,
-) -> int:
-    """Local TTL expiry, status expired."""
-    return emit_cloud_sync_event(
-        store,
-        "request_expired",
-        local_request_id,
-        resolved_at=resolved_at or _now(),
-    )
-
-
 def emit_request_resolved_locally(
     store: GuardStore,
     local_request_id: str,

{plugin_scanner-2.0.1018 → plugin_scanner-2.0.1020}/src/codex_plugin_scanner/guard/runtime/local_request_snapshots.py

@@ -4,12 +4,13 @@ from __future__ import annotations
 
 import base64
 import json
+import re
 from collections.abc import Mapping, Sequence
 from contextlib import suppress
 from datetime import datetime, timezone
 
 from ..config import VALID_RECEIPT_REDACTION_LEVELS, load_guard_config
-from ..redaction import redact_text
+from ..redaction import redact_sensitive_text, redact_text
 from ..review_contracts import (
     GuardReviewContractError,
     build_local_review_request_claim,
@@ -446,6 +447,44 @@ def _local_request_snapshot_routing_metadata(
     return metadata
 
 
+_CLOUD_SPACED_SECRET_ARGUMENT_RE = re.compile(
+    r'(?P<prefix>(?:^|\s)--?(?:[\w-]*(?:api[-_]?key|token|secret|password|credential|authorization|cookie)[\w-]*)\s+)(?:"[^"]*"|\'[^\']*\'|\S+)',
+    re.IGNORECASE,
+)
+
+
+def _cloud_scrub_text(value: str) -> str:
+    without_spaced_secret_arguments = _CLOUD_SPACED_SECRET_ARGUMENT_RE.sub(
+        lambda match: f"{match.group('prefix')}[redacted]",
+        value,
+    )
+    return redact_sensitive_text(redact_text(without_spaced_secret_arguments).text)
+
+
+_SENSITIVE_CLOUD_FIELD_MARKERS = (
+    "api_key",
+    "apikey",
+    "authorization",
+    "cookie",
+    "credential",
+    "password",
+    "secret",
+    "token",
+)
+
+
+def _is_sensitive_cloud_field(field_name: str | None) -> bool:
+    if field_name is None:
+        return False
+    normalized = field_name.strip().lower().replace("-", "_")
+    return any(marker in normalized for marker in _SENSITIVE_CLOUD_FIELD_MARKERS)
+
+
+def _is_sensitive_cli_flag(value: str) -> bool:
+    flag = value.strip().split("=", maxsplit=1)[0]
+    return flag.startswith("-") and _is_sensitive_cloud_field(flag.lstrip("-"))
+
+
 def _cloud_safe_local_request_payload(
     item: dict[str, object],
     *,
@@ -483,10 +522,13 @@ def _cloud_safe_local_request_payload(
     ):
         value = item.get(key)
         if isinstance(value, str):
-            payload[key] = _bounded_text(value)
+            payload[key] = _bounded_text(_cloud_scrub_text(value))
         elif isinstance(value, (int, float, bool)) or value is None:
             payload[key] = value
 
+    if payload.get("status") == "expired":
+        payload["status"] = "pending"
+
     if routing_metadata is not None:
         payload.update(routing_metadata)
 
@@ -520,7 +562,7 @@ def _cloud_safe_local_request_payload(
         return payload
 
     if command_text:
-        scrubbed = _bounded_command(redact_text(command_text).text)
+        scrubbed = _bounded_command(_cloud_scrub_text(command_text))
         payload["raw_command_text"] = scrubbed
         payload["rawCommandText"] = scrubbed
         payload["command_text"] = scrubbed
@@ -607,7 +649,7 @@ def _cloud_safe_action_envelope(
     if redaction_level == "none":
         command = envelope.get("command")
         if isinstance(command, str) and command.strip():
-            safe["command"] = _bounded_command(redact_text(command).text)
+            safe["command"] = _bounded_command(_cloud_scrub_text(command))
         for key in ("target_paths", "network_hosts", "package_name", "package_targets"):
             value = envelope.get(key)
             if isinstance(value, list):
@@ -639,20 +681,32 @@ def _set_dual_key(
     payload[camel_key] = normalized
 
 
-def _bounded_cloud_value(value: object) -> object:
+def _bounded_cloud_value(value: object, *, field_name: str | None = None) -> object:
+    if _is_sensitive_cloud_field(field_name):
+        return "[redacted]"
     if isinstance(value, str):
-        return _bounded_text(value)
+        return _bounded_text(_cloud_scrub_text(value))
     if isinstance(value, Mapping):
         return {
-            str(key): _bounded_cloud_value(item)
+            str(key): _bounded_cloud_value(item, field_name=str(key))
             for key, item in list(value.items())[:LOCAL_REQUEST_SNAPSHOT_MAX_LIST_ITEMS]
             if isinstance(key, str)
         }
     if isinstance(value, Sequence) and not isinstance(value, str):
-        return [_bounded_cloud_value(item) for item in list(value)[:LOCAL_REQUEST_SNAPSHOT_MAX_LIST_ITEMS]]
+        scrubbed_items: list[object] = []
+        redact_next_item = False
+        for item in list(value)[:LOCAL_REQUEST_SNAPSHOT_MAX_LIST_ITEMS]:
+            if redact_next_item:
+                scrubbed_items.append("[redacted]")
+                redact_next_item = False
+                continue
+            scrubbed_items.append(_bounded_cloud_value(item, field_name=field_name))
+            if isinstance(item, str) and _is_sensitive_cli_flag(item):
+                redact_next_item = True
+        return scrubbed_items
     if isinstance(value, (int, float, bool)) or value is None:
         return value
-    return _bounded_text(str(value))
+    return _bounded_text(_cloud_scrub_text(str(value)))
 
 
 def _add_action_envelope_aliases(safe: dict[str, object]) -> None:

{plugin_scanner-2.0.1018 → plugin_scanner-2.0.1020}/src/codex_plugin_scanner/guard/runtime/runner.py

@@ -1599,6 +1599,9 @@ def sync_receipts(
         aibom_context["home_dir"] = str(home_dir)
     if workspace_dir is not None:
         aibom_context["workspace_dir"] = str(workspace_dir)
+        workspace_id = store.get_cloud_workspace_id()
+        if workspace_id is not None:
+            aibom_context["workspace_id"] = workspace_id
     if aibom_context:
         store.set_sync_payload("aibom_inventory_context", aibom_context, now)
     if persisted_command_detail_backfill_marker is not None:

{plugin_scanner-2.0.1018 → plugin_scanner-2.0.1020}/src/codex_plugin_scanner/guard/store_approval_facade.py

@@ -466,18 +466,3 @@ class StoreApprovalsMixin:
             purge_request_resumes(connection, request_ids)
             cursor = connection.execute(query, tuple(params))
             return int(cursor.rowcount if cursor.rowcount is not None else 0)
-
-    def expire_pending_approval_requests(self, *, older_than: str, now: str) -> int:
-        with self._connect() as connection:
-            cursor = connection.execute(
-                """
-                update approval_requests
-                set status = 'expired',
-                    reason = 'Expired after waiting for review.',
-                    resolved_at = ?
-                where status = 'pending'
-                  and created_at < ?
-                """,
-                (now, older_than),
-            )
-            return int(cursor.rowcount if cursor.rowcount is not None else 0)

{plugin_scanner-2.0.1018 → plugin_scanner-2.0.1020}/src/codex_plugin_scanner/guard/store_connection_schema.py

@@ -535,6 +535,13 @@ class StoreConnectionSchemaMixin:
             if not self._schema_version_applied(connection, version=2):
                 self._record_schema_version(connection, version=2)
             self._enable_wal_mode(connection)
+            connection.execute(
+                """
+                update approval_requests
+                set status = 'pending', reason = null, resolved_at = null
+                where status = 'expired'
+                """
+            )
             self._repair_store_permissions()
         if getattr(self, "_prime_policy_integrity_on_initialize", True):
             # Prime policy-integrity secrets outside the SQLite transaction. Some

{plugin_scanner-2.0.1018 → plugin_scanner-2.0.1020}/src/codex_plugin_scanner/version.py

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

{plugin_scanner-2.0.1018 → plugin_scanner-2.0.1020}/tests/test_guard_aibom_cli.py

@@ -340,6 +340,48 @@ def test_sync_aibom_snapshots_if_due_skips_recent_sync(tmp_path: Path, monkeypat
     assert summary.get("reason") == "recently_synced"
 
 
+def test_sync_aibom_snapshots_if_due_rejects_changed_workspace(tmp_path: Path, monkeypatch) -> None:
+    from codex_plugin_scanner.guard.aibom_cli import sync_aibom_snapshots_if_due
+
+    store = GuardStore(tmp_path / "guard")
+    monkeypatch.setattr(store, "get_cloud_workspace_id", lambda: "workspace-beta")
+
+    summary = sync_aibom_snapshots_if_due(
+        store,
+        generated_at="2026-06-10T13:00:00+00:00",
+        expected_workspace_id="workspace-alpha",
+    )
+
+    assert summary == {
+        "synced": False,
+        "reason": "workspace_changed",
+        "error": "Guard Cloud workspace changed before AIBOM inventory sync.",
+    }
+
+
+def test_sync_aibom_snapshots_if_due_binds_current_workspace(tmp_path: Path, monkeypatch) -> None:
+    from codex_plugin_scanner.guard import aibom_cli
+
+    store = GuardStore(tmp_path / "guard")
+    monkeypatch.setattr(store, "get_cloud_workspace_id", lambda: "workspace-alpha")
+    calls: list[dict[str, object]] = []
+
+    def _fake_sync(*_args: object, **kwargs: object) -> dict[str, object]:
+        calls.append(kwargs)
+        return {"synced": True}
+
+    monkeypatch.setattr(aibom_cli, "sync_aibom_snapshots", _fake_sync)
+
+    summary = aibom_cli.sync_aibom_snapshots_if_due(
+        store,
+        generated_at="2026-06-10T13:00:00+00:00",
+        force=True,
+    )
+
+    assert summary == {"synced": True}
+    assert calls[0]["expected_workspace_id"] == "workspace-alpha"
+
+
 def test_sync_aibom_snapshots_if_due_skips_recent_empty_sync(tmp_path: Path, monkeypatch) -> None:
     from codex_plugin_scanner.guard.aibom_cli import sync_aibom_snapshots_if_due
 
@@ -489,6 +531,24 @@ def test_resolve_trust_attestation_context_includes_workspace_device_for_v2(
     assert context["installationId"] == "device-1"
     assert context["policyVersion"] == "guard-aibom-trust-policy.v1"
     assert context["uploadId"] is None
+
+
+def test_resolve_trust_attestation_context_uses_workspace_override(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    store = GuardStore(tmp_path / "guard")
+    monkeypatch.setattr(store, "get_cloud_workspace_id", lambda: "workspace-beta")
+    monkeypatch.setattr(store, "get_or_create_installation_id", lambda: "device-1")
+    monkeypatch.setenv("GUARD_AIBOM_TRUST_ATTESTATION_V2", "1")
+
+    context = aibom_cli._resolve_trust_attestation_context(
+        store,
+        generated_at="2026-06-10T12:00:00+00:00",
+        workspace_id="workspace-alpha",
+    )
+
+    assert context["workspaceId"] == "workspace-alpha"
     assert context["challengeId"] is None
     assert context["nonce"] is None
     assert context["sequence"] is None

{plugin_scanner-2.0.1018 → plugin_scanner-2.0.1020}/tests/test_guard_command_snapshot_paging.py

@@ -112,7 +112,7 @@ def test_local_request_snapshot_payload_stays_under_cloud_byte_budget(tmp_path:
     assert isinstance(first_request, dict)
     request_payload = first_request["requestPayload"]
     assert isinstance(request_payload, dict)
-    assert "truncated" in str(request_payload["risk_summary"])
+    assert request_payload["risk_summary"] == "SECRET_[redacted]"
     assert "truncated" in str(request_payload["command_text"])
 
 
@@ -218,7 +218,5 @@ def test_local_request_snapshot_includes_newest_pending_after_truncation(tmp_pat
     assert "req-pending-fresh" in third_ids
     # The persisted snapshot cursor key must NOT contain a pending cursor,
     # otherwise the next call could skip fresh rows.
-    stored_cursor = store.get_sync_payload(
-        "guard_command_local_request_snapshot_cursor"
-    )
+    stored_cursor = store.get_sync_payload("guard_command_local_request_snapshot_cursor")
     assert stored_cursor is None or "pending" not in stored_cursor