plugin-scanner 2.0.543__tar.gz → 2.0.545__tar.gz

{plugin_scanner-2.0.543 → plugin_scanner-2.0.545}/PKG-INFO

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

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

{plugin_scanner-2.0.543 → plugin_scanner-2.0.545}/pyproject.toml.bak

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

@@ -71,10 +71,6 @@ def _is_guard_program(program_name: str) -> bool:
     return normalized_name in {"plugin-guard"}
 
 
-def _is_hol_guard_binary(program_name: str) -> bool:
-    return Path(program_name).stem.lower() == "hol-guard"
-
-
 def _is_scanner_program(program_name: str) -> bool:
     normalized_name = Path(program_name).stem.lower()
     return normalized_name in {"plugin-scanner", "plugin-ecosystem-scanner"}
@@ -184,8 +180,19 @@ def _build_parser(program_name: str, *, program_mode: str) -> argparse.ArgumentP
     return parser
 
 
-def _resolve_legacy_args(argv: list[str] | None, *, program_mode: str) -> list[str] | None:
+def _is_hol_guard_program(program_name: str) -> bool:
+    return Path(program_name).stem.lower() == "hol-guard"
+
+
+def _resolve_legacy_args(
+    argv: list[str] | None,
+    *,
+    program_mode: str,
+    program_name: str = "",
+) -> list[str] | None:
     if not argv:
+        if program_mode == "combined" and _is_hol_guard_program(program_name):
+            return ["guard"]
         return argv
     if program_mode == "guard":
         if argv[0] == "guard":
@@ -261,6 +268,15 @@ def _resolve_legacy_args(argv: list[str] | None, *, program_mode: str) -> list[s
         "bridge",
         "daemon",
         "hook",
+        "admin",
+        "cloud",
+        "supply-chain",
+        "service",
+        "codex-mcp-proxy",
+        "opencode-mcp-proxy",
+        "copilot-mcp-proxy",
+        "cursor-mcp-proxy",
+        "hermes-mcp-proxy",
     }
     if program_mode == "combined" and argv[0] in _guard_subcommands and "--format" not in argv:
         return ["guard", *argv]
@@ -552,9 +568,11 @@ def main(argv: list[str] | None = None) -> int:
     else:
         program_mode = "combined"
     parser = _build_parser(program_name, program_mode=program_mode)
-    resolved_argv = _resolve_legacy_args(argv or sys.argv[1:], program_mode=program_mode)
-    if _is_hol_guard_binary(program_name) and not resolved_argv:
-        parser.error("the following arguments are required: command")
+    resolved_argv = _resolve_legacy_args(
+        argv or sys.argv[1:],
+        program_mode=program_mode,
+        program_name=program_name,
+    )
     args = parser.parse_args(resolved_argv)
     if getattr(args, "list_ecosystems", False):
         for ecosystem in list_supported_ecosystems():

plugin_scanner-2.0.545/src/codex_plugin_scanner/guard/contracts/__init__.py

@@ -0,0 +1 @@
+"""Guard shared contract helpers."""

plugin_scanner-2.0.545/src/codex_plugin_scanner/guard/contracts/supply_chain_decision_evidence_v1.py

@@ -0,0 +1,109 @@
+"""Shared Guard supply-chain decision evidence contract v1."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+from codex_plugin_scanner.guard.runtime.supply_chain_package_eval import PackageRequestEvaluation
+
+DECISION_EVIDENCE_CONTRACT_VERSION = "guard-supply-chain-decision-evidence.v1"
+
+DECISION_VALUES = frozenset({"allow", "monitor", "warn", "ask", "block"})
+ENFORCEMENT_VALUES = frozenset({"premium_cloud", "local_fallback", "upgrade_required", "free_local", "offline_cached"})
+ENTITLEMENT_VALUES = frozenset({"premium", "free", "limit_reached"})
+CACHE_STATUS_VALUES = frozenset({"miss", "stale", "upgrade-gated", "hit", "empty"})
+
+REQUIRED_DECISION_EVIDENCE_FIELDS = (
+    "contractVersion",
+    "decision",
+    "recommendation",
+    "enforcement",
+    "entitlementState",
+    "cacheStatus",
+    "policyVersion",
+    "packageIntentHash",
+    "commandShape",
+    "reasons",
+    "evidenceIds",
+)
+
+
+def validate_decision_evidence_v1(payload: Mapping[str, object]) -> list[str]:
+    errors: list[str] = []
+    missing = {field for field in REQUIRED_DECISION_EVIDENCE_FIELDS if field not in payload}
+    for field in missing:
+        errors.append(f"missing field: {field}")
+    contract_version = payload.get("contractVersion")
+    if "contractVersion" not in missing and contract_version != DECISION_EVIDENCE_CONTRACT_VERSION:
+        errors.append(f"unexpected contractVersion: {contract_version!r}")
+    decision = payload.get("decision")
+    if "decision" not in missing and decision not in DECISION_VALUES:
+        errors.append(f"invalid decision: {decision!r}")
+    recommendation = payload.get("recommendation")
+    if recommendation not in DECISION_VALUES:
+        errors.append(f"invalid recommendation: {recommendation!r}")
+    enforcement = payload.get("enforcement")
+    if "enforcement" not in missing and enforcement not in ENFORCEMENT_VALUES:
+        errors.append(f"invalid enforcement: {enforcement!r}")
+    entitlement_state = payload.get("entitlementState")
+    if "entitlementState" not in missing and entitlement_state not in ENTITLEMENT_VALUES:
+        errors.append(f"invalid entitlementState: {entitlement_state!r}")
+    cache_status = payload.get("cacheStatus")
+    if "cacheStatus" not in missing and cache_status not in CACHE_STATUS_VALUES:
+        errors.append(f"invalid cacheStatus: {cache_status!r}")
+    command_shape = payload.get("commandShape")
+    if not isinstance(command_shape, dict):
+        errors.append("commandShape must be an object")
+    elif not isinstance(command_shape.get("redacted"), bool):
+        errors.append("commandShape.redacted must be boolean")
+    reasons = payload.get("reasons")
+    if not isinstance(reasons, list):
+        errors.append("reasons must be an array")
+    evidence_ids = payload.get("evidenceIds")
+    if not isinstance(evidence_ids, list):
+        errors.append("evidenceIds must be an array")
+    return errors
+
+
+def package_evaluation_to_decision_evidence_v1(
+    evaluation: PackageRequestEvaluation,
+    *,
+    command_shape: Mapping[str, object],
+    package_intent_hash: str,
+    recommendation: str | None = None,
+) -> dict[str, object]:
+    resolved_recommendation = recommendation or evaluation.decision
+    return {
+        "contractVersion": DECISION_EVIDENCE_CONTRACT_VERSION,
+        "decision": evaluation.decision,
+        "recommendation": resolved_recommendation,
+        "enforcement": evaluation.enforcement,
+        "entitlementState": evaluation.entitlement_state,
+        "cacheStatus": evaluation.cache_status,
+        "policyVersion": evaluation.policy_version,
+        "packageIntentHash": package_intent_hash,
+        "commandShape": dict(command_shape),
+        "reasons": [dict(item) for item in evaluation.reasons],
+        "evidenceIds": list(evaluation.evidence_ids),
+    }
+
+
+def cloud_evaluate_response_to_decision_evidence_v1(
+    response: Mapping[str, object],
+    *,
+    package_intent_hash: str,
+    command_shape: Mapping[str, object],
+) -> dict[str, object]:
+    return {
+        "contractVersion": DECISION_EVIDENCE_CONTRACT_VERSION,
+        "decision": response.get("decision"),
+        "recommendation": response.get("recommendation", response.get("decision")),
+        "enforcement": response.get("enforcement"),
+        "entitlementState": response.get("entitlementState"),
+        "cacheStatus": response.get("cacheStatus"),
+        "policyVersion": response.get("policyVersion"),
+        "packageIntentHash": package_intent_hash,
+        "commandShape": dict(command_shape),
+        "reasons": list(response.get("reasons") or []),
+        "evidenceIds": list(response.get("evidenceIds") or []),
+    }

{plugin_scanner-2.0.543 → plugin_scanner-2.0.545}/src/codex_plugin_scanner/guard/daemon/server.py

@@ -119,7 +119,7 @@ from ..shims import (
     activate_package_shims,
     package_shim_status,
     package_shim_supported_managers,
-    test_package_shim_intercepts,
+    probe_package_shim_intercepts,
     uninstall_package_shims,
 )
 from ..stable_digest import stable_digest_hex
@@ -1980,7 +1980,7 @@ class _GuardDaemonHandler(BaseHTTPRequestHandler):
         if operation == "remove":
             return uninstall_package_shims(context, managers=managers)
         if operation == "test":
-            return test_package_shim_intercepts(
+            return probe_package_shim_intercepts(
                 context,
                 managers=managers,
                 workspace_dir=context.workspace_dir,

{plugin_scanner-2.0.543 → plugin_scanner-2.0.545}/src/codex_plugin_scanner/guard/protect.py

@@ -123,6 +123,18 @@ def build_protect_payload(
     if len(command) == 0:
         raise ValueError("Guard protect requires a command to wrap.")
     request = parse_protect_command(command)
+    package_payload = build_package_protect_payload(
+        command=command,
+        store=store,
+        workspace_dir=workspace_dir,
+        dry_run=dry_run,
+        now=now,
+        config=config,
+        unsafe_raw_output=unsafe_raw_output,
+        timeout_seconds=_protect_command_timeout_seconds(),
+    )
+    if package_payload is not None:
+        return package_payload
     advisories = store.list_cached_advisories(limit=None)
     verdict = evaluate_protect_request(request, advisories)
     receipt = _build_install_receipt(request, verdict)
@@ -136,33 +148,6 @@ def build_protect_payload(
         "receipt": receipt.to_dict(),
         "matched_advisories": list(verdict.matched_advisories),
     }
-    if verdict.blocking:
-        store.add_receipt(receipt)
-        store.add_event(
-            f"install_time_{verdict.action}",
-            {
-                "artifact_id": request.targets[0].artifact_id,
-                "artifact_name": request.targets[0].artifact_name,
-                "executor": request.executor,
-                "install_kind": request.install_kind,
-                "action": verdict.action,
-                "risk_signals": list(verdict.risk_signals),
-            },
-            now,
-        )
-        return (payload, 2)
-    package_payload = build_package_protect_payload(
-        command=command,
-        store=store,
-        workspace_dir=workspace_dir,
-        dry_run=dry_run,
-        now=now,
-        config=config,
-        unsafe_raw_output=unsafe_raw_output,
-        timeout_seconds=_protect_command_timeout_seconds(),
-    )
-    if package_payload is not None:
-        return package_payload
     if verdict.blocking or dry_run:
         store.add_receipt(receipt)
         store.add_event(

{plugin_scanner-2.0.543 → plugin_scanner-2.0.545}/src/codex_plugin_scanner/guard/runtime/supply_chain_package_eval.py

@@ -249,53 +249,6 @@ def evaluate_package_request_artifact(
         if bundle_response is not None
         else None
     )
-    if bundle_evaluation is not None and bundle_meta is not None and bundle_evaluation.decision != "monitor":
-        result = _finalize_evaluation(
-            bundle_evaluation, package_intent_hash=package_intent_hash, workspace_fingerprint=workspace_fingerprint
-        )
-        store.cache_supply_chain_evaluation(
-            workspace_id=workspace_id or bundle_payload["bundle"]["workspaceId"],
-            package_intent_hash=package_intent_hash,
-            feed_snapshot_hash=bundle_meta["feed_snapshot_hash"],
-            policy_hash=bundle_meta["policy_hash"],
-            scoring_version=bundle_meta["scoring_version"],
-            bundle_version=bundle_meta["bundle_version"],
-            decision=result.to_cache_dict(),
-            now=now_value,
-        )
-        _persist_evidence(store=store, artifact=artifact, evaluation=result, now=now_value)
-        if result.refresh_required:
-            store.add_event(
-                "supply_chain_bundle_refresh_requested",
-                {
-                    "artifact_id": artifact.artifact_id,
-                    "artifact_name": artifact.name,
-                    "reason": "feed_stale",
-                },
-                now_value,
-            )
-        return result
-    if (
-        bundle_evaluation is not None
-        and bundle_evaluation.refresh_required
-        and not bool(store.get_oauth_local_credential_health().get("configured"))
-    ):
-        fallback = _finalize_evaluation(
-            bundle_evaluation,
-            package_intent_hash=package_intent_hash,
-            workspace_fingerprint=workspace_fingerprint,
-        )
-        _persist_evidence(store=store, artifact=artifact, evaluation=fallback, now=now_value)
-        store.add_event(
-            "supply_chain_bundle_refresh_requested",
-            {
-                "artifact_id": artifact.artifact_id,
-                "artifact_name": artifact.name,
-                "reason": "feed_stale",
-            },
-            now_value,
-        )
-        return fallback
     if not _artifact_has_package_material(artifact, targets):
         no_material_result = _empty_package_material_result(
             artifact=artifact,
@@ -306,6 +259,9 @@ def evaluate_package_request_artifact(
         )
         _persist_evidence(store=store, artifact=artifact, evaluation=no_material_result, now=now_value)
         return no_material_result
+    bundle_defer_eligible = bundle_evaluation is not None and (
+        bundle_evaluation.decision == "block" or not bundle_evaluation.refresh_required
+    )
     cloud_result, cloud_fallback_reason = _evaluate_with_cloud(
         artifact=artifact,
         targets=targets,
@@ -313,8 +269,17 @@ def evaluate_package_request_artifact(
         workspace_id=workspace_id,
         workspace_fingerprint=workspace_fingerprint,
         bundle_meta=bundle_meta,
+        bundle_defer_eligible=bundle_defer_eligible,
         store=store,
     )
+    if cloud_result is not None and _cloud_result_should_defer_to_bundle(
+        cloud_result, bundle_evaluation=bundle_evaluation
+    ):
+        if cloud_fallback_reason is None and cloud_result.reasons:
+            first_reason = cloud_result.reasons[0]
+            if isinstance(first_reason, dict):
+                cloud_fallback_reason = dict(first_reason)
+        cloud_result = None
     if cloud_result is not None:
         upgraded = cloud_result
         if cloud_result.enforcement == "upgrade_required":
@@ -345,12 +310,52 @@ def evaluate_package_request_artifact(
                 )
         _persist_evidence(store=store, artifact=artifact, evaluation=upgraded, now=now_value)
         return upgraded
+    if (
+        bundle_evaluation is not None
+        and bundle_evaluation.refresh_required
+        and not bool(store.get_oauth_local_credential_health().get("configured"))
+    ):
+        fallback = _finalize_evaluation(
+            bundle_evaluation,
+            package_intent_hash=package_intent_hash,
+            workspace_fingerprint=workspace_fingerprint,
+        )
+        _persist_evidence(store=store, artifact=artifact, evaluation=fallback, now=now_value)
+        store.add_event(
+            "supply_chain_bundle_refresh_requested",
+            {
+                "artifact_id": artifact.artifact_id,
+                "artifact_name": artifact.name,
+                "reason": "feed_stale",
+            },
+            now_value,
+        )
+        return fallback
     if bundle_evaluation is not None:
         fallback = _finalize_evaluation(
             bundle_evaluation, package_intent_hash=package_intent_hash, workspace_fingerprint=workspace_fingerprint
         )
         if cloud_fallback_reason is not None:
             fallback = _with_additional_reason(fallback, cloud_fallback_reason)
+        if bundle_meta is not None and bundle_evaluation.decision != "monitor" and isinstance(bundle_payload, dict):
+            cache_workspace_id = workspace_id
+            if cache_workspace_id is None:
+                bundle_section = bundle_payload.get("bundle")
+                if isinstance(bundle_section, dict):
+                    bundle_workspace_id = bundle_section.get("workspaceId")
+                    if isinstance(bundle_workspace_id, str) and bundle_workspace_id:
+                        cache_workspace_id = bundle_workspace_id
+            if cache_workspace_id:
+                store.cache_supply_chain_evaluation(
+                    workspace_id=cache_workspace_id,
+                    package_intent_hash=package_intent_hash,
+                    feed_snapshot_hash=bundle_meta["feed_snapshot_hash"],
+                    policy_hash=bundle_meta["policy_hash"],
+                    scoring_version=bundle_meta["scoring_version"],
+                    bundle_version=bundle_meta["bundle_version"],
+                    decision=fallback.to_cache_dict(),
+                    now=now_value,
+                )
         _persist_evidence(store=store, artifact=artifact, evaluation=fallback, now=now_value)
         if fallback.refresh_required:
             store.add_event(
@@ -594,6 +599,7 @@ def _evaluate_with_cloud(
     workspace_id: str | None,
     workspace_fingerprint: str | None,
     bundle_meta: dict[str, str] | None,
+    bundle_defer_eligible: bool,
     store: GuardStore,
 ) -> tuple[PackageRequestEvaluation | None, dict[str, object] | None]:
     if workspace_id is None or workspace_fingerprint is None:
@@ -610,6 +616,13 @@ def _evaluate_with_cloud(
     try:
         auth_context = _resolve_guard_sync_auth_context(store)
     except GuardSyncAuthorizationExpiredError:
+        if bundle_meta is not None and bundle_defer_eligible and resolve_fail_closed_decision() != "block":
+            return None, _cloud_fallback_reason(
+                code="cloud_auth_error",
+                message=(
+                    "Guard cloud evaluation was not authorized, so Guard fell back to signed bundle intelligence."
+                ),
+            )
         return (
             _cloud_fail_closed_evaluation(
                 code="cloud_auth_error",
@@ -3567,6 +3580,26 @@ def _with_additional_reason(
     return replace(evaluation, reasons=updated_reasons, packages=tuple(updated_packages))
 
 
+def _cloud_result_should_defer_to_bundle(
+    evaluation: PackageRequestEvaluation,
+    *,
+    bundle_evaluation: _EvaluationDraft | None,
+) -> bool:
+    if bundle_evaluation is None:
+        return False
+    if not (bundle_evaluation.decision == "block" or not bundle_evaluation.refresh_required):
+        return False
+    reason_codes = {str(reason.get("code") or "") for reason in evaluation.reasons if isinstance(reason, dict)}
+    if evaluation.decision == "block" and evaluation.policy_action == "block":
+        if "cloud_validation_error" in reason_codes and "cloud_timeout" not in reason_codes:
+            return False
+        return False
+    defer_codes = {"cloud_auth_error", "cloud_http_error", "cloud_timeout"}
+    if not any(code in defer_codes for code in reason_codes):
+        return False
+    return _decision_rank(bundle_evaluation.decision) > _decision_rank(evaluation.decision)
+
+
 def _cloud_fallback_reason(*, code: str, message: str) -> dict[str, object]:
     return {
         "code": code,

plugin_scanner-2.0.545/src/codex_plugin_scanner/guard/shim_probe.py

@@ -0,0 +1,62 @@
+"""Shared helpers for package-shim intercept probes."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+_PACKAGE_SHIM_PROBE_ARGS: dict[str, tuple[str, ...]] = {
+    "npm": ("install", "--dry-run", "lodash@4.17.21"),
+    "pnpm": ("add", "--dry-run", "lodash@4.17.21"),
+    "yarn": ("add", "--dry-run", "lodash@4.17.21"),
+    "bun": ("add", "--dry-run", "lodash@4.17.21"),
+    "pip": ("install", "--dry-run", "requests==2.32.3"),
+    "pip3": ("install", "--dry-run", "requests==2.32.3"),
+    "uv": ("add", "--dry-run", "requests==2.32.3"),
+    "poetry": ("add", "--dry-run", "requests@2.32.3"),
+    "pipenv": ("install", "--dry-run", "requests==2.32.3"),
+    "pipx": ("install", "--dry-run", "requests==2.32.3"),
+    "cargo": ("add", "serde@1.0.203"),
+    "go": ("install", "-n", "github.com/pkg/errors@v0.9.1"),
+    "composer": ("require", "--dry-run", "monolog/monolog:3.6.0"),
+    "bundle": ("add", "rails", "--version", "7.1.3"),
+}
+
+
+def package_shim_probe_args(manager: str) -> tuple[str, ...]:
+    """Return install-shaped probe args that route through package protect."""
+
+    return _PACKAGE_SHIM_PROBE_ARGS.get(manager, ("--version",))
+
+
+def parse_protect_json_stdout(stdout: str) -> dict[str, Any]:
+    """Parse the first JSON object emitted by `hol-guard protect --json`."""
+
+    text = stdout.lstrip()
+    if not text:
+        return {}
+    decoder = json.JSONDecoder()
+    try:
+        payload, _index = decoder.raw_decode(text)
+    except json.JSONDecodeError:
+        return {}
+    return payload if isinstance(payload, dict) else {}
+
+
+def protect_evaluator_evidence(payload: dict[str, Any]) -> dict[str, object]:
+    """Extract evaluator invocation evidence from a protect payload."""
+
+    supply_chain = payload.get("supply_chain_evaluation")
+    supply_chain_dict = supply_chain if isinstance(supply_chain, dict) else {}
+    verdict = payload.get("verdict")
+    verdict_dict = verdict if isinstance(verdict, dict) else {}
+    evidence_ids = supply_chain_dict.get("evidence_ids")
+    normalized_evidence_ids = (
+        [str(item) for item in evidence_ids if item is not None] if isinstance(evidence_ids, list) else []
+    )
+    return {
+        "evaluator_invoked": "supply_chain_evaluation" in payload or "verdict" in payload,
+        "protect_decision": verdict_dict.get("action"),
+        "evidence_ids": normalized_evidence_ids,
+        "dry_run": payload.get("dry_run"),
+    }

{plugin_scanner-2.0.543 → plugin_scanner-2.0.545}/src/codex_plugin_scanner/guard/shims.py

@@ -12,6 +12,11 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 from .launcher import merge_guard_launcher_env
+from .shim_probe import (
+    package_shim_probe_args,
+    parse_protect_json_stdout,
+    protect_evaluator_evidence,
+)
 
 if TYPE_CHECKING:
     from .adapters.base import HarnessContext
@@ -775,7 +780,7 @@ def _path_export_hints(shim_dir: Path) -> dict[str, str]:
     }
 
 
-def test_package_shim_intercepts(
+def probe_package_shim_intercepts(
     context: HarnessContext,
     *,
     managers: tuple[str, ...] | None = None,
@@ -789,14 +794,32 @@ def test_package_shim_intercepts(
     tested_managers = list(managers or tuple(sorted(installed)))
     path_repair_required = [manager for manager in tested_managers if manager in installed and manager not in protected]
     manager_results: list[dict[str, object]] = []
+    manager_details = status.get("manager_details", [])
+    detail_by_manager = {
+        str(item.get("manager")): item
+        for item in manager_details
+        if isinstance(item, dict) and isinstance(item.get("manager"), str)
+    }
     target_workspace = workspace_dir or context.workspace_dir or context.home_dir
     shim_dir = context.guard_home / "package-shims" / "bin"
     for manager in tested_managers:
         if manager not in installed:
             continue
+        manager_detail = detail_by_manager.get(manager)
+        if manager_detail is not None and manager_detail.get("integrity") == "tampered":
+            manager_results.append(
+                {
+                    "evaluator_invoked": False,
+                    "intercept_ran": False,
+                    "manager": manager,
+                    "skipped_reason": "shim_tampered",
+                },
+            )
+            continue
         if manager not in protected:
             manager_results.append(
                 {
+                    "evaluator_invoked": False,
                     "intercept_ran": False,
                     "manager": manager,
                     "skipped_reason": "path_inactive",
@@ -807,6 +830,7 @@ def test_package_shim_intercepts(
         if command is None:
             manager_results.append(
                 {
+                    "evaluator_invoked": False,
                     "intercept_ran": False,
                     "manager": manager,
                     "skipped_reason": "unsupported_manager",
@@ -817,16 +841,18 @@ def test_package_shim_intercepts(
         if not shim_path.exists():
             manager_results.append(
                 {
+                    "evaluator_invoked": False,
                     "intercept_ran": False,
                     "manager": manager,
                     "skipped_reason": "shim_missing",
                 },
             )
             continue
+        probe_args = package_shim_probe_args(manager)
         try:
             # codeql[py/path-injection] target_workspace is home_dir or a validated daemon workspace_dir.
             result = subprocess.run(
-                [str(shim_path), "--version"],
+                [str(shim_path), *probe_args],
                 capture_output=True,
                 check=False,
                 cwd=target_workspace,
@@ -836,20 +862,27 @@ def test_package_shim_intercepts(
         except (subprocess.TimeoutExpired, OSError):
             manager_results.append(
                 {
+                    "evaluator_invoked": False,
                     "intercept_ran": False,
                     "manager": manager,
                     "skipped_reason": "probe_failed",
                 },
             )
             continue
+        protect_payload = parse_protect_json_stdout(result.stdout)
+        evaluator_evidence = protect_evaluator_evidence(protect_payload)
         manager_results.append(
             {
-                "intercept_ran": True,
+                "evaluator_invoked": evaluator_evidence["evaluator_invoked"],
+                "evidence_ids": evaluator_evidence["evidence_ids"],
+                "intercept_ran": bool(evaluator_evidence["evaluator_invoked"]),
                 "manager": manager,
+                "protect_decision": evaluator_evidence["protect_decision"],
+                "probe_args": list(probe_args),
                 "shim_exit_code": result.returncode,
             },
         )
-    intercept_proved = any(bool(result.get("intercept_ran")) for result in manager_results)
+    intercept_proved = any(bool(result.get("evaluator_invoked")) for result in manager_results)
     return {
         "blocked_execution": bool(tested_managers) and all(manager in protected for manager in tested_managers),
         "intercept_proved": intercept_proved,
@@ -870,7 +903,7 @@ __all__ = [
     "package_shim_cloud_coverage",
     "package_shim_status",
     "package_shim_supported_managers",
+    "probe_package_shim_intercepts",
     "remove_guard_shim",
-    "test_package_shim_intercepts",
     "uninstall_package_shims",
 ]

{plugin_scanner-2.0.543 → plugin_scanner-2.0.545}/src/codex_plugin_scanner/version.py

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

plugin_scanner-2.0.545/tests/bundle_first_cloud.py

@@ -0,0 +1,12 @@
+"""Force bundle-first evaluation in integration tests that seed offline bundles."""
+
+from __future__ import annotations
+
+import pytest
+
+from tests.test_guard_supply_chain_evaluator import _force_cloud_fallback
+
+
+@pytest.fixture
+def bundle_first_cloud(monkeypatch: pytest.MonkeyPatch) -> None:
+    _force_cloud_fallback(monkeypatch)