plugin-scanner 2.0.584__tar.gz → 2.0.586__tar.gz

{plugin_scanner-2.0.584 → plugin_scanner-2.0.586}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.584
+Version: 2.0.586
 Summary: Lint, verify, and gate plugin ecosystems for maintainers, CI, and publish workflows.
 Project-URL: Homepage, https://github.com/hashgraph-online/hol-guard
 Project-URL: Repository, https://github.com/hashgraph-online/hol-guard

{plugin_scanner-2.0.584 → plugin_scanner-2.0.586}/action/action.yml

@@ -198,7 +198,14 @@ runs:
       env:
         INSTALL_SOURCE: ${{ inputs.install_source }}
         INSTALL_CISCO: ${{ inputs.install_cisco }}
+        PYTHONNOUSERSITE: "1"
+        PYTHONSAFEPATH: "1"
       run: |
+        ACTION_RUNTIME_ROOT="${RUNNER_TEMP:-${TMPDIR:-/tmp}}"
+        ACTION_RUNTIME_DIR="$(mktemp -d "$ACTION_RUNTIME_ROOT/hol-guard-action-XXXXXX")"
+        trap 'cd "$ACTION_RUNTIME_ROOT" 2>/dev/null || cd /; rm -rf "$ACTION_RUNTIME_DIR"' EXIT
+        cd "$ACTION_RUNTIME_DIR"
+
         LOCAL_SOURCE=""
         for candidate in "$GITHUB_ACTION_PATH" "$GITHUB_ACTION_PATH/.."; do
           if [ -f "$candidate/pyproject.toml" ] && [ -d "$candidate/src/codex_plugin_scanner" ]; then
@@ -212,7 +219,7 @@ runs:
             echo "install_source=local requires the hol-guard source checkout (for example: uses: ./action inside hol-guard)." >&2
             exit 1
           fi
-          python3 -m pip install "$LOCAL_SOURCE[cisco]"
+          python3 -P -m pip install "$LOCAL_SOURCE[cisco]"
         elif [ "$INSTALL_SOURCE" = "pypi" ]; then
           SCANNER_VERSION_FILE="$GITHUB_ACTION_PATH/scanner-version.txt"
           SCANNER_SHA256_FILE="$GITHUB_ACTION_PATH/scanner-sha256.txt"
@@ -228,18 +235,18 @@ runs:
           CISCO_VERSION="$(tr -d '[:space:]' < "$CISCO_VERSION_FILE")"
           PYPI_ATTESTATIONS_VERSION="$(tr -d '[:space:]' < "$PYPI_ATTESTATIONS_VERSION_FILE")"
           SCANNER_REPOSITORY="https://github.com/hashgraph-online/hol-guard"
-          DIST_DIR="${RUNNER_TEMP:-$GITHUB_WORKSPACE/.ai-plugin-scanner-dist}"
+          DIST_DIR="$ACTION_RUNTIME_DIR/ai-plugin-scanner-dist"
           mkdir -p "$DIST_DIR"
 
-          python3 -m pip install "pypi-attestations==${PYPI_ATTESTATIONS_VERSION}"
-          python3 -m pip download --only-binary=:all: --no-deps --dest "$DIST_DIR" "plugin-scanner==${SCANNER_VERSION}"
+          python3 -P -m pip install "pypi-attestations==${PYPI_ATTESTATIONS_VERSION}"
+          python3 -P -m pip download --only-binary=:all: --no-deps --dest "$DIST_DIR" "plugin-scanner==${SCANNER_VERSION}"
 
           DIST_BASENAME="$(
-            DIST_DIR="$DIST_DIR" python3 -c "import os, sys; from pathlib import Path; candidates = sorted(Path(os.environ['DIST_DIR']).glob('plugin_scanner-*.whl')); (len(candidates) == 1) or sys.exit(f'Expected exactly one downloaded scanner wheel, found {len(candidates)}'); print(candidates[0].name)"
+            DIST_DIR="$DIST_DIR" python3 -P -c "import os, sys; from pathlib import Path; candidates = sorted(Path(os.environ['DIST_DIR']).glob('plugin_scanner-*.whl')); (len(candidates) == 1) or sys.exit(f'Expected exactly one downloaded scanner wheel, found {len(candidates)}'); print(candidates[0].name)"
           )"
 
           ACTUAL_SHA256="$(
-            DIST_DIR="$DIST_DIR" DIST_BASENAME="$DIST_BASENAME" python3 -c "import hashlib, os; from pathlib import Path; wheel = Path(os.environ['DIST_DIR']) / os.environ['DIST_BASENAME']; print(hashlib.sha256(wheel.read_bytes()).hexdigest())"
+            DIST_DIR="$DIST_DIR" DIST_BASENAME="$DIST_BASENAME" python3 -P -c "import hashlib, os; from pathlib import Path; wheel = Path(os.environ['DIST_DIR']) / os.environ['DIST_BASENAME']; print(hashlib.sha256(wheel.read_bytes()).hexdigest())"
           )"
           if [ "$ACTUAL_SHA256" != "$EXPECTED_SHA256" ]; then
             echo "Downloaded scanner wheel SHA256 does not match scanner-sha256.txt." >&2
@@ -247,16 +254,16 @@ runs:
           fi
 
           WHEEL_PATH="$DIST_DIR/$DIST_BASENAME"
-          if ! python3 -m pypi_attestations verify pypi \
+          if ! python3 -P -m pypi_attestations verify pypi \
             --repository "$SCANNER_REPOSITORY" \
             "$WHEEL_PATH"; then
             echo "Failed to verify PyPI provenance for plugin-scanner==${SCANNER_VERSION}." >&2
             exit 1
           fi
 
-          python3 -m pip install "$WHEEL_PATH"
+          python3 -P -m pip install "$WHEEL_PATH"
           if [ "$INSTALL_CISCO" = "true" ]; then
-            python3 -m pip install "cisco-ai-skill-scanner==${CISCO_VERSION}"
+            python3 -P -m pip install "cisco-ai-skill-scanner==${CISCO_VERSION}"
           fi
         else
           echo "Unsupported install_source: $INSTALL_SOURCE" >&2
@@ -296,7 +303,9 @@ runs:
         PR_COMMENT_STYLE: ${{ inputs.pr_comment_style }}
         PR_COMMENT_MAX_FINDINGS: ${{ inputs.pr_comment_max_findings }}
         GITHUB_STEP_SUMMARY: ${{ env.GITHUB_STEP_SUMMARY }}
-      run: python3 -m codex_plugin_scanner.action_runner
+        PYTHONNOUSERSITE: "1"
+        PYTHONSAFEPATH: "1"
+      run: python3 -P -m codex_plugin_scanner.action_runner
 
     - name: Upload SARIF
       if: ${{ inputs.upload_sarif == 'true' && inputs.mode == 'scan' && steps.scan.outputs.report_path != '' }}

{plugin_scanner-2.0.584 → plugin_scanner-2.0.586}/pyproject.toml

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

{plugin_scanner-2.0.584 → plugin_scanner-2.0.586}/pyproject.toml.bak

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

{plugin_scanner-2.0.584 → plugin_scanner-2.0.586}/src/codex_plugin_scanner/guard/local_supply_chain.py

@@ -315,8 +315,13 @@ def resolve_package_firewall_entitlement_with_refresh(store: GuardStore) -> dict
         return entitlement
     if store.get_cloud_sync_profile() is None:
         return entitlement
-    if str(entitlement.get("reason") or "") not in {"guard_cloud_reconnect_required", "paid_guard_cloud_required"}:
+    if str(entitlement.get("reason") or "") not in {
+        "guard_cloud_connect_required",
+        "guard_cloud_reconnect_required",
+        "paid_guard_cloud_required",
+    }:
         return entitlement
+    now_iso = datetime.now(timezone.utc).isoformat()
     now = time.time()
     with _PACKAGE_FIREWALL_REFRESH_LOCK:
         state = _read_package_firewall_refresh_state(store.guard_home)
@@ -330,13 +335,16 @@ def resolve_package_firewall_entitlement_with_refresh(store: GuardStore) -> dict
     for refresh in (sync_local_guard_cloud_proof, sync_supply_chain_bundle):
         try:
             refresh(store)
-        except (
-            GuardSyncAuthorizationExpiredError,
-            GuardSyncNotAvailableError,
-            GuardSyncNotConfiguredError,
-            OSError,
-            RuntimeError,
-        ):
+        except GuardSyncAuthorizationExpiredError as error:
+            if str(entitlement.get("reason") or "") == "guard_cloud_connect_required":
+                store.record_latest_guard_connect_sync_result(
+                    status="retry_required",
+                    milestone="first_sync_failed",
+                    now=now_iso,
+                    reason=str(error),
+                )
+            break
+        except (GuardSyncNotAvailableError, GuardSyncNotConfiguredError, OSError, RuntimeError):
             continue
     return resolve_package_firewall_entitlement(store)
 

{plugin_scanner-2.0.584 → plugin_scanner-2.0.586}/src/codex_plugin_scanner/guard/runtime/runner.py

@@ -2341,6 +2341,15 @@ def _refresh_guard_oauth_access_token(
     dpop_nonce: str | None = None
     nonce_retry_count = 0
     while True:
+        try:
+            dpop_proof = _sign_guard_dpop_proof(
+                request_url=token_endpoint,
+                method="POST",
+                dpop_key_material=dpop_key_material,
+                nonce=dpop_nonce,
+            )
+        except (RuntimeError, TypeError, ValueError) as error:
+            raise GuardSyncAuthorizationExpiredError(f"{_guard_oauth_reauthorization_message()} {error}") from error
         request = urllib.request.Request(
             token_endpoint,
             data=request_body,
@@ -2349,12 +2358,7 @@ def _refresh_guard_oauth_access_token(
                 "Content-Type": "application/x-www-form-urlencoded",
                 "Accept": "application/json",
                 "User-Agent": _GUARD_SYNC_USER_AGENT,
-                "DPoP": _sign_guard_dpop_proof(
-                    request_url=token_endpoint,
-                    method="POST",
-                    dpop_key_material=dpop_key_material,
-                    nonce=dpop_nonce,
-                ),
+                "DPoP": dpop_proof,
             },
         )
         try:

{plugin_scanner-2.0.584 → plugin_scanner-2.0.586}/src/codex_plugin_scanner/version.py

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

plugin_scanner-2.0.586/tests/conftest.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import os
+import sys
+from collections.abc import Callable
+from pathlib import Path
+
+import pytest
+
+SRC_PATH = Path(__file__).resolve().parents[1] / "src"
+
+if str(SRC_PATH) not in sys.path:
+    sys.path.insert(0, str(SRC_PATH))
+
+existing_pythonpath = os.environ.get("PYTHONPATH", "")
+pythonpath_entries = [entry for entry in existing_pythonpath.split(os.pathsep) if entry]
+if str(SRC_PATH) not in pythonpath_entries:
+    os.environ["PYTHONPATH"] = os.pathsep.join([str(SRC_PATH), *pythonpath_entries])
+
+
+@pytest.fixture(autouse=True)
+def _disable_real_macos_keychain(monkeypatch: pytest.MonkeyPatch) -> None:
+    from codex_plugin_scanner.guard.store import KeychainSecretStore
+
+    monkeypatch.setattr(KeychainSecretStore, "_is_available", staticmethod(lambda: False))
+
+
+@pytest.fixture
+def seed_connected_oauth_without_entitlement() -> Callable[["GuardStore"], None]:
+    from codex_plugin_scanner.guard.store import GuardStore
+
+    def _seed(store: GuardStore) -> None:
+        store.set_oauth_local_credentials(
+            issuer="https://hol.org",
+            client_id="guard-local-daemon",
+            refresh_token="refresh-token-1",
+            dpop_private_key_pem="private-key",
+            dpop_public_jwk={"kty": "EC", "crv": "P-256", "x": "x-value", "y": "y-value"},
+            dpop_public_jwk_thumbprint="thumbprint-1",
+            grant_id="grant-1",
+            machine_id="machine-1",
+            workspace_id="workspace-1",
+            now="2026-06-05T01:39:51+00:00",
+        )
+        store.record_guard_connect_pairing_completed(
+            sync_url="https://hol.org/api/guard/receipts/sync",
+            allowed_origin="https://hol.org",
+            now="2026-06-05T01:39:51+00:00",
+            request_id="connect-1",
+        )
+
+    return _seed

{plugin_scanner-2.0.584 → plugin_scanner-2.0.586}/tests/test_action_bundle.py

@@ -1,5 +1,8 @@
 """Regression checks for the GitHub Action bundle and Marketplace packaging."""
 
+import os
+import subprocess
+import sys
 from pathlib import Path
 
 import pytest
@@ -24,28 +27,34 @@ def test_action_metadata_includes_marketplace_branding_and_pypi_install() -> Non
     assert 'icon: "check-circle"' in action_text
     assert 'color: "blue"' in action_text
     assert "actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405" in action_text
-    assert 'python3 -m pip install "pypi-attestations==' in action_text
+    assert 'python3 -P -m pip install "pypi-attestations==' in action_text
     assert "install_source:" in action_text
     assert 'default: "pypi"' in action_text
     assert "INSTALL_SOURCE: ${{ inputs.install_source }}" in action_text
     assert "install_cisco:" in action_text
     assert "INSTALL_CISCO: ${{ inputs.install_cisco }}" in action_text
+    assert 'PYTHONNOUSERSITE: "1"' in action_text
+    assert 'PYTHONSAFEPATH: "1"' in action_text
+    assert 'ACTION_RUNTIME_ROOT="${RUNNER_TEMP:-${TMPDIR:-/tmp}}"' in action_text
+    assert 'ACTION_RUNTIME_DIR="$(mktemp -d "$ACTION_RUNTIME_ROOT/hol-guard-action-XXXXXX")"' in action_text
+    assert 'trap \'cd "$ACTION_RUNTIME_ROOT" 2>/dev/null || cd /; rm -rf "$ACTION_RUNTIME_DIR"\' EXIT' in action_text
+    assert 'cd "$ACTION_RUNTIME_DIR"' in action_text
     assert 'if [ "$INSTALL_CISCO" = "true" ]; then' in action_text
     assert 'if [ "$INSTALL_SOURCE" = "local" ]; then' in action_text
     assert "install_source=local requires the hol-guard source checkout" in action_text
-    assert 'python3 -m pip install "$LOCAL_SOURCE[cisco]"' in action_text
+    assert 'python3 -P -m pip install "$LOCAL_SOURCE[cisco]"' in action_text
     assert 'elif [ "$INSTALL_SOURCE" = "pypi" ]; then' in action_text
     assert (
-        'python3 -m pip download --only-binary=:all: --no-deps --dest "$DIST_DIR" '
+        'python3 -P -m pip download --only-binary=:all: --no-deps --dest "$DIST_DIR" '
         '"plugin-scanner==${SCANNER_VERSION}"'
     ) in action_text
     assert "scanner-sha256.txt" in action_text
     assert 'SCANNER_SHA256_FILE="$GITHUB_ACTION_PATH/scanner-sha256.txt"' in action_text
     assert 'echo "Downloaded scanner wheel SHA256 does not match scanner-sha256.txt."' in action_text
-    assert "python3 -m pypi_attestations verify pypi \\" in action_text
+    assert "python3 -P -m pypi_attestations verify pypi" in action_text
     assert '"$WHEEL_PATH"' in action_text
-    assert 'python3 -m pip install "$WHEEL_PATH"' in action_text
-    assert 'python3 -m pip install "cisco-ai-skill-scanner==${CISCO_VERSION}"' in action_text
+    assert 'python3 -P -m pip install "$WHEEL_PATH"' in action_text
+    assert 'python3 -P -m pip install "cisco-ai-skill-scanner==${CISCO_VERSION}"' in action_text
     assert "scanner-version.txt" in action_text
     scanner_version = (ROOT / "action" / "scanner-version.txt").read_text(encoding="utf-8").strip()
     scanner_sha256 = (ROOT / "action" / "scanner-sha256.txt").read_text(encoding="utf-8").strip()
@@ -54,10 +63,77 @@ def test_action_metadata_includes_marketplace_branding_and_pypi_install() -> Non
     assert "cisco-version.txt" in action_text
     assert "pypi-attestations-version.txt" in action_text
     assert 'SCANNER_REPOSITORY="https://github.com/hashgraph-online/hol-guard"' in action_text
-    assert "python3 -m codex_plugin_scanner.action_runner" in action_text
+    assert "python3 -P -m codex_plugin_scanner.action_runner" in action_text
     assert "github/codeql-action/upload-sarif@" in action_text
 
 
+def test_action_steps_enable_python_safe_path() -> None:
+    yaml = pytest.importorskip("yaml")
+
+    parsed = yaml.safe_load((ROOT / "action" / "action.yml").read_text(encoding="utf-8"))
+    steps = parsed["runs"]["steps"]
+    install_step = next(step for step in steps if step["name"] == "Install scanner")
+    scan_step = next(step for step in steps if step["name"] == "Run scanner")
+
+    assert install_step["env"]["PYTHONNOUSERSITE"] == "1"
+    assert install_step["env"]["PYTHONSAFEPATH"] == "1"
+    assert 'cd "$ACTION_RUNTIME_DIR"' in install_step["run"]
+    assert "python3 -P -m pip install" in install_step["run"]
+    assert scan_step["env"]["PYTHONNOUSERSITE"] == "1"
+    assert scan_step["env"]["PYTHONSAFEPATH"] == "1"
+    assert scan_step["run"] == "python3 -P -m codex_plugin_scanner.action_runner"
+
+
+def test_python_safe_path_blocks_workspace_module_shadowing(tmp_path: Path) -> None:
+    if sys.version_info < (3, 11):
+        pytest.skip("python -P requires Python 3.11+")
+
+    module_name = "shadowdemo_pkg"
+    trusted_root = tmp_path / "trusted-root"
+    trusted_package = trusted_root / module_name
+    trusted_package.mkdir(parents=True)
+    (trusted_package / "__main__.py").write_text(
+        "print('trusted-module')\n",
+        encoding="utf-8",
+    )
+    workspace = tmp_path / "workspace"
+    shadow_package = workspace / module_name
+    shadow_package.mkdir(parents=True)
+    (shadow_package / "__main__.py").write_text(
+        "raise SystemExit('workspace-shadowed')\n",
+        encoding="utf-8",
+    )
+    hijacked_env = {
+        key: value
+        for key, value in os.environ.items()
+        if key not in {"PYTHONSAFEPATH", "PYTHONNOUSERSITE"}
+    }
+    hijacked_env["PYTHONPATH"] = str(trusted_root)
+
+    hijacked = subprocess.run(
+        [sys.executable, "-m", module_name],
+        cwd=workspace,
+        env=hijacked_env,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert hijacked.returncode != 0
+    assert "workspace-shadowed" in f"{hijacked.stdout}{hijacked.stderr}"
+
+    protected = subprocess.run(
+        [sys.executable, "-P", "-m", module_name],
+        cwd=workspace,
+        env=hijacked_env,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert protected.returncode == 0
+    assert "trusted-module" in protected.stdout
+    assert "workspace-shadowed" not in f"{protected.stdout}{protected.stderr}"
+
+
 def test_publish_action_repo_workflow_syncs_action_repository() -> None:
     workflow_text = (
         ROOT / ".github" / "workflows" / "publish-action-repo.yml"

{plugin_scanner-2.0.584 → plugin_scanner-2.0.586}/tests/test_guard_headless_daemon_api.py

@@ -476,6 +476,68 @@ def test_supply_chain_package_firewall_install_requires_reconnect_when_cloud_aut
     assert payload["entitlement"]["tier"] == "unknown"
 
 
+def test_supply_chain_package_firewall_status_self_heals_connected_cloud_auth_without_cached_entitlement(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    seed_connected_oauth_without_entitlement,
+) -> None:
+    store = GuardStore(tmp_path / "guard-home")
+    seed_connected_oauth_without_entitlement(store)
+    calls: list[str] = []
+
+    def fake_sync_local_guard_cloud_proof(current_store: GuardStore) -> dict[str, object]:
+        assert current_store is store
+        calls.append("proof")
+        current_store.record_latest_guard_connect_sync_success(
+            sync_payload={"synced_at": "2026-06-05T01:41:00+00:00", "receipts_stored": 1},
+            now="2026-06-05T01:41:00+00:00",
+        )
+        return {"synced_at": "2026-06-05T01:41:00+00:00", "receipts_stored": 1}
+
+    def fake_sync_supply_chain_bundle(current_store: GuardStore) -> dict[str, object]:
+        assert current_store is store
+        calls.append("bundle")
+        current_store.set_sync_payload(
+            "supply_chain_bundle_entitlement",
+            {
+                "bundle_version": "bundle-version-test",
+                "key_id": "bundle-key-test",
+                "policy_hash": "policy-hash-test",
+                "tier": "pro",
+                "workspace_id": "workspace-1",
+            },
+            "2026-06-05T01:41:05+00:00",
+        )
+        return {"bundle_version": "bundle-version-test", "tier": "pro"}
+
+    monkeypatch.setattr(local_supply_chain_module, "sync_local_guard_cloud_proof", fake_sync_local_guard_cloud_proof)
+    monkeypatch.setattr(local_supply_chain_module, "sync_supply_chain_bundle", fake_sync_supply_chain_bundle)
+    daemon = GuardDaemonServer(store, host="127.0.0.1", port=0)
+    daemon.start()
+    try:
+        token = _dashboard_token_for(store)
+        status, payload = _read_json_response(
+            _request(
+                daemon.port,
+                "/v1/supply-chain/package-shims",
+                method="GET",
+                token=token,
+            ),
+        )
+    finally:
+        daemon.stop()
+
+    assert status == 200
+    assert calls == ["proof", "bundle"]
+    assert payload["entitlement"] == {
+        "allowed": True,
+        "reason": "paid_entitlement_active",
+        "tier": "pro",
+        "upgrade_cta": None,
+    }
+    assert payload["actions"]["install"] == "available"
+
+
 def test_supply_chain_package_firewall_install_self_heals_retry_required_cloud_auth(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,

{plugin_scanner-2.0.584 → plugin_scanner-2.0.586}/tests/test_guard_oauth_reconnect.py

@@ -115,3 +115,17 @@ def test_prepare_guard_cloud_connect_authorization_tolerates_network_errors(tmp_
     assert result["cleared_stale_sign_in"] is False
     assert result["existing_sign_in_valid"] is True
     assert store.get_oauth_local_credentials(allow_primary=True) is not None
+
+
+def test_invalid_dpop_curve_refresh_uses_reconnect_message(tmp_path, monkeypatch) -> None:
+    store = _store_with_oauth_credentials(tmp_path)
+
+    def _raise_invalid_curve(**_kwargs):
+        raise RuntimeError("Guard DPoP key must be a P-256 EC private key.")
+
+    monkeypatch.setattr(guard_runner_module, "_sign_guard_dpop_proof", _raise_invalid_curve)
+
+    with pytest.raises(guard_runner_module.GuardSyncAuthorizationExpiredError) as error:
+        guard_runner_module._resolve_guard_sync_auth_context(store)
+
+    assert "hol-guard connect" in str(error.value)

{plugin_scanner-2.0.584 → plugin_scanner-2.0.586}/tests/test_guard_package_shims_cli.py

@@ -139,6 +139,92 @@ def test_package_shims_status_reports_reconnect_required_when_cloud_auth_expired
     assert payload["actions"]["remove"] == "disabled"
 
 
+def test_package_shims_status_self_heals_connected_cloud_auth_without_cached_entitlement(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+    seed_connected_oauth_without_entitlement,
+) -> None:
+    guard_home = tmp_path / "guard-home"
+    seed_connected_oauth_without_entitlement(GuardStore(guard_home))
+    calls: list[str] = []
+
+    def _fake_sync_local_guard_cloud_proof(store: GuardStore) -> dict[str, object]:
+        calls.append("proof")
+        store.record_latest_guard_connect_sync_success(
+            sync_payload={"synced_at": "2026-06-05T01:41:00+00:00", "receipts_stored": 1},
+            now="2026-06-05T01:41:00+00:00",
+        )
+        return {"synced_at": "2026-06-05T01:41:00+00:00", "receipts_stored": 1}
+
+    def _fake_sync_supply_chain_bundle(store: GuardStore) -> dict[str, object]:
+        calls.append("bundle")
+        store.set_sync_payload(
+            "supply_chain_bundle_entitlement",
+            {
+                "bundle_version": "bundle-version-test",
+                "key_id": "bundle-key-test",
+                "policy_hash": "policy-hash-test",
+                "tier": "pro",
+                "workspace_id": "workspace-1",
+            },
+            "2026-06-05T01:41:05+00:00",
+        )
+        return {"bundle_version": "bundle-version-test", "tier": "pro"}
+
+    monkeypatch.setattr(local_supply_chain_module, "sync_local_guard_cloud_proof", _fake_sync_local_guard_cloud_proof)
+    monkeypatch.setattr(local_supply_chain_module, "sync_supply_chain_bundle", _fake_sync_supply_chain_bundle)
+
+    rc = main(["guard", "package-shims", "status", "--home", str(guard_home), "--json"])
+
+    payload = json.loads(capsys.readouterr().out)
+    assert rc == 0
+    assert calls == ["proof", "bundle"]
+    assert payload["entitlement"] == {
+        "allowed": True,
+        "reason": "paid_entitlement_active",
+        "tier": "pro",
+        "upgrade_cta": None,
+    }
+    assert payload["actions"]["install"] == "available"
+
+
+def test_package_shims_status_preserves_reconnect_gate_when_connected_auth_refresh_expires(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+    seed_connected_oauth_without_entitlement,
+) -> None:
+    guard_home = tmp_path / "guard-home"
+    seed_connected_oauth_without_entitlement(GuardStore(guard_home))
+    monkeypatch.setattr(
+        local_supply_chain_module,
+        "sync_local_guard_cloud_proof",
+        lambda _store: (_ for _ in ()).throw(
+            local_supply_chain_module.GuardSyncAuthorizationExpiredError(
+                "Guard authorization expired. Run `hol-guard connect` again."
+            )
+        ),
+    )
+    monkeypatch.setattr(
+        local_supply_chain_module,
+        "sync_supply_chain_bundle",
+        lambda _store: (_ for _ in ()).throw(RuntimeError("bundle refresh blocked")),
+    )
+
+    rc = main(["guard", "package-shims", "status", "--home", str(guard_home), "--json"])
+
+    payload = json.loads(capsys.readouterr().out)
+    assert rc == 0
+    assert payload["entitlement"] == {
+        "allowed": False,
+        "reason": "guard_cloud_reconnect_required",
+        "tier": "unknown",
+        "upgrade_cta": "Reconnect HOL Guard Cloud to refresh package firewall access.",
+    }
+    assert payload["actions"]["install"] == "reconnect_required"
+
+
 def test_package_shims_install_requires_reconnect_when_cloud_auth_expired(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,

plugin_scanner-2.0.584/tests/conftest.py

@@ -1,24 +0,0 @@
-from __future__ import annotations
-
-import os
-import sys
-from pathlib import Path
-
-import pytest
-
-SRC_PATH = Path(__file__).resolve().parents[1] / "src"
-
-if str(SRC_PATH) not in sys.path:
-    sys.path.insert(0, str(SRC_PATH))
-
-existing_pythonpath = os.environ.get("PYTHONPATH", "")
-pythonpath_entries = [entry for entry in existing_pythonpath.split(os.pathsep) if entry]
-if str(SRC_PATH) not in pythonpath_entries:
-    os.environ["PYTHONPATH"] = os.pathsep.join([str(SRC_PATH), *pythonpath_entries])
-
-
-@pytest.fixture(autouse=True)
-def _disable_real_macos_keychain(monkeypatch: pytest.MonkeyPatch) -> None:
-    from codex_plugin_scanner.guard.store import KeychainSecretStore
-
-    monkeypatch.setattr(KeychainSecretStore, "_is_available", staticmethod(lambda: False))