plugin-scanner 3.0.136__tar.gz → 3.0.138__tar.gz

{plugin_scanner-3.0.136 → plugin_scanner-3.0.138}/.github/workflows/ci.yml

@@ -397,6 +397,7 @@ jobs:
           tests/test_guard_sandbox.py
           tests/test_guard_js_lockfile_resolution_phase11.py
           tests/test_guard_runtime_hook_scheduler.py
+          tests/test_guard_hook_process_runner.py::test_scheduler_and_runner_complete_48_routine_reviews_without_capacity_denial
           tests/test_guard_continuation_contract.py
           --tb=short
 

{plugin_scanner-3.0.136 → plugin_scanner-3.0.138}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 3.0.136
+Version: 3.0.138
 Summary: Lint, verify, and gate plugin ecosystems for maintainers, CI, and publish workflows.
 Project-URL: Homepage, https://hol.org/guard
 Project-URL: Security, https://hol.org/guard/security

{plugin_scanner-3.0.136 → plugin_scanner-3.0.138}/dashboard/src/command-activity/command-activity-detail.tsx

@@ -169,7 +169,11 @@ export function CommandActivityDetail(props: {
             ))}
           </ul>
         ) : (
-          <p className="mt-2 text-sm text-slate-500">No rule match was recorded.</p>
+          <p className="mt-2 text-sm text-slate-500">
+            {props.activity.decision_reason_code === "no_match"
+              ? "No rule matched this action."
+              : "Rule evidence is unavailable for this record."}
+          </p>
         )}
       </div>
 

{plugin_scanner-3.0.136 → plugin_scanner-3.0.138}/dashboard/src/command-activity/command-activity-table.tsx

@@ -24,6 +24,12 @@ function CommandRow(props: {
     props.onSelect(props.item.activity_id);
   }, [props.item.activity_id, props.onSelect]);
   const firstRule = props.item.matches[0];
+  let ruleLabel = "Rule evidence unavailable";
+  if (firstRule) {
+    ruleLabel = safeEvidenceId(firstRule.rule_id);
+  } else if (props.item.decision_reason_code === "no_match") {
+    ruleLabel = "No rule match";
+  }
   return (
     <tr className={props.selected ? "bg-brand-blue/[0.04]" : "hover:bg-slate-50/70"}>
       <td className="whitespace-nowrap px-3 py-3 text-xs text-slate-600">{recordedTime(props.item.occurred_at)}</td>
@@ -31,7 +37,7 @@ function CommandRow(props: {
       <td className="px-3 py-3 text-sm text-brand-dark">{commandDecisionLabel(props.item.policy_action)}</td>
       <td className="px-3 py-3 text-sm text-brand-dark">{commandExecutionLabel(props.item.execution_status)}</td>
       <td className="px-3 py-3 text-sm text-slate-600">
-        {firstRule ? safeEvidenceId(firstRule.rule_id) : "No rule match"}
+        {ruleLabel}
         {props.item.match_count > 1 ? <Badge tone="info">+{props.item.match_count - 1}</Badge> : null}
       </td>
       <td className="px-3 py-3 text-right">

{plugin_scanner-3.0.136 → plugin_scanner-3.0.138}/pyproject.toml

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

{plugin_scanner-3.0.136 → plugin_scanner-3.0.138}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "3.0.136"
+version = "3.0.138"
 description = "Open-source antivirus and runtime protection for AI agents, tools, MCP servers, plugins, skills, and package installs."
 readme = "README.md"
 license = "Apache-2.0"

plugin_scanner-3.0.136/release-metadata/plugin-scanner-v3.0.136.toolchain.cdx.json → plugin_scanner-3.0.138/release-metadata/plugin-scanner-v3.0.138.toolchain.cdx.json

@@ -27,7 +27,7 @@
     "component": {
       "name": "hol-guard-release-toolchain",
       "type": "application",
-      "version": "3.0.136"
+      "version": "3.0.138"
     }
   },
   "specVersion": "1.6",

{plugin_scanner-3.0.136 → plugin_scanner-3.0.138}/src/codex_plugin_scanner/guard/adapters/grok_hooks.py

@@ -135,6 +135,8 @@ def prepare_grok_hook_payload(payload: Mapping[str, object]) -> dict[str, object
     raw_event = _raw_hook_event_name(normalized)
     if raw_event:
         normalized["hook_event_name"] = _canonical_grok_event_name(raw_event)
+        if raw_event.replace("_", "").replace("-", "").lower() == "posttoolusefailure":
+            normalized["failed"] = True
     tool_name = normalized.get("tool_name")
     if tool_name is None:
         tool_name = normalized.get("toolName")

{plugin_scanner-3.0.136 → plugin_scanner-3.0.138}/src/codex_plugin_scanner/guard/cli/commands_support_command_activity.py

@@ -216,6 +216,10 @@ def hook_post_succeeded(event: str, payload: Mapping[str, object]) -> bool:
 
     if "failure" in event.strip().lower():
         return False
+    for name in ("hook_event_name", "hookEventName"):
+        raw_event = payload.get(name)
+        if isinstance(raw_event, str) and raw_event.replace("_", "").replace("-", "").lower() == "posttoolusefailure":
+            return False
     for key in ("is_error", "isError", "failed"):
         if payload.get(key) is True:
             return False

{plugin_scanner-3.0.136 → plugin_scanner-3.0.138}/src/codex_plugin_scanner/guard/daemon/hook_native_review_approval.py

@@ -47,7 +47,9 @@ def pause_native_pre_tool_for_approval(
         allowed["decision"] = "allow"
         allowed["minimum_action"] = "allow"
         allowed["policy_action"] = "allow"
-        return harness_json_from_native_pre_tool(harness, allowed)
+        response = harness_json_from_native_pre_tool(harness, allowed)
+        response["approval_reuse_status"] = "accepted"
+        return response
     queued = queue_native_pre_tool_review(
         store,
         harness=harness,
@@ -64,7 +66,9 @@ def pause_native_pre_tool_for_approval(
         failed["reason_code"] = "native_review_queue_failed"
         failed["reason"] = "HOL Guard could not record this review for approval."
         return harness_json_from_native_pre_tool(harness, failed)
-    return harness_json_from_native_pre_tool_review(harness, native_result, approval=queued)
+    response = harness_json_from_native_pre_tool_review(harness, native_result, approval=queued)
+    response["prompted"] = True
+    return response
 
 
 def queue_native_pre_tool_review(

{plugin_scanner-3.0.136 → plugin_scanner-3.0.138}/src/codex_plugin_scanner/guard/daemon/hook_worker_native.py

@@ -78,7 +78,30 @@ class _HookWorkerNativeHost(Protocol):
     _native_runtime_status: Callable[[], NativeRuntimeStatus]
     _review_raw_hook_native: Callable[..., dict[str, object] | None]
     _record_post_tool_activity: Callable[..., None]
-    _record_native_decision_receipt: Callable[[object], None]
+    _record_native_decision_receipt: Callable[[object], Mapping[str, object] | None]
+
+
+def _record_native_pre_activity(
+    host: _HookWorkerNativeHost,
+    harness: str,
+    payload: Mapping[str, object],
+    response: dict[str, object],
+    receipt: Mapping[str, object] | None = None,
+) -> dict[str, object]:
+    submit = getattr(host.activity_writer, "submit_command_activity", None)
+    if callable(submit):
+        with suppress(Exception):
+            submit(
+                harness=harness,
+                event="PreToolUse",
+                payload=payload,
+                succeeded=True,
+                policy_action=response.get("policy_action"),
+                receipt_id=receipt.get("decision_id") if receipt is not None else None,
+                prompted=response.get("prompted") is True,
+                approval_reuse_status=response.get("approval_reuse_status", "not-applicable"),
+            )
+    return response
 
 
 def _record_unavailable_native(
@@ -116,6 +139,7 @@ def _record_unavailable_native(
                     event=event_name,
                     payload=payload,
                     succeeded=str(response.get("policy_action") or "") != "block",
+                    policy_action=response.get("policy_action"),
                 )
     return response
 
@@ -187,17 +211,20 @@ class HookWorkerNativeMixin:
                 action = str(native.get("minimum_action") or "")
                 if action != "allow" or native.get("decision") != "allow":
                     native = _watch_native_pre_tool_result(native)
-                    return recording_only_pre_tool_response(
+                    response = recording_only_pre_tool_response(
                         harness,
                         reason_code=str(native.get("reason_code") or "watch_recording_only"),
                         reason=str(native.get("reason") or "Watch recorded this action without stopping it."),
                     )
+                    return _record_native_pre_activity(self, harness, payload, response)
             else:
                 action = str(native.get("minimum_action") or "")
                 if action == "review":
                     record_python_semantic_hook_route()
                     raise HookWorkerUnsupported("native PreToolUse review uses CLI approval coordination")
-            return harness_json_from_native_pre_tool(harness, native)
+            return _record_native_pre_activity(
+                self, harness, payload, harness_json_from_native_pre_tool(harness, native)
+            )
         if recording_only:
             return _record_unavailable_native(
                 self,
@@ -291,21 +318,22 @@ class HookWorkerNativeMixin:
                 guard_home=guard_home,
                 recording_only=recording_only,
             )
-        self._record_native_decision_receipt(edge.get("receipt"))
+        accepted_receipt = self._record_native_decision_receipt(edge.get("receipt"))
         self.metrics.record_route("native_resident")
         if native_event == "PreToolUse":
             if recording_only:
                 action = str(native_result.get("minimum_action") or "")
                 if action != "allow" or native_result.get("decision") != "allow":
                     native_result = _watch_native_pre_tool_result(native_result)
-                    return recording_only_pre_tool_response(
+                    response = recording_only_pre_tool_response(
                         native_harness,
                         reason_code=str(native_result.get("reason_code") or "watch_recording_only"),
                         reason=str(native_result.get("reason") or "Watch recorded this action without stopping it."),
                     )
+                    return _record_native_pre_activity(self, native_harness, payload, response, accepted_receipt)
             action = str(native_result.get("minimum_action") or "")
             if action == "review":
-                return pause_native_pre_tool_for_approval(
+                response = pause_native_pre_tool_for_approval(
                     self.store,
                     harness=native_harness,
                     payload=payload,
@@ -313,7 +341,14 @@ class HookWorkerNativeMixin:
                     workspace=workspace,
                     guard_home=guard_home,
                 )
-            return harness_json_from_native_pre_tool(native_harness, native_result)
+                return _record_native_pre_activity(self, native_harness, payload, response, accepted_receipt)
+            return _record_native_pre_activity(
+                self,
+                native_harness,
+                payload,
+                harness_json_from_native_pre_tool(native_harness, native_result),
+                accepted_receipt,
+            )
         if recording_only:
             native_result = _watch_native_post_tool_result(native_result)
         self._record_post_tool_activity(
@@ -323,14 +358,15 @@ class HookWorkerNativeMixin:
         )
         return harness_json_from_native_post_tool(native_harness, native_result)
 
-    def _record_native_decision_receipt(self: _HookWorkerNativeHost, receipt: object) -> None:
+    def _record_native_decision_receipt(self: _HookWorkerNativeHost, receipt: object) -> Mapping[str, object] | None:
         """Hand Rust evidence to the non-authoritative writer without waiting."""
 
-        if isinstance(receipt, Mapping):
-            self._last_native_decision_receipt = dict(receipt)
+        self._last_native_decision_receipt = dict(receipt) if isinstance(receipt, Mapping) else None
         writer = self.activity_writer
         submit = getattr(writer, "submit_native_decision_receipt", None)
         if not callable(submit) or not isinstance(receipt, Mapping):
-            return
+            return None
         with suppress(Exception):
-            _ = submit(receipt=receipt)
+            if submit(receipt=receipt) is True:
+                return receipt
+        return None

{plugin_scanner-3.0.136 → plugin_scanner-3.0.138}/src/codex_plugin_scanner/guard/daemon/runtime_hook_evidence_journal.py

@@ -9,10 +9,12 @@ import stat
 from collections.abc import Iterator, Mapping
 from contextlib import contextmanager
 from dataclasses import dataclass
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import cast
 from uuid import uuid4
 
+from ..action_lattice import is_guard_action
 from ..native_decision_receipt import (
     NATIVE_HOOK_DECISION_RECEIPT_SCHEMA,
     validate_native_decision_receipt,
@@ -48,6 +50,11 @@ class _CommandActivityRecord:
     succeeded: bool
     payload_bytes: int
     attempts: int = 0
+    policy_action: str | None = None
+    occurred_at: str | None = None
+    receipt_id: str | None = None
+    prompted: bool = False
+    approval_reuse_status: str = "not-applicable"
 
     def serialized(self) -> bytes:
         return (
@@ -69,6 +76,11 @@ class _CommandActivityRecord:
                     ),
                     "has_command": self.has_command,
                     "succeeded": self.succeeded,
+                    "policy_action": self.policy_action,
+                    "occurred_at": self.occurred_at,
+                    "receipt_id": self.receipt_id,
+                    "interaction_observed": self.prompted,
+                    "approval_reuse_status": self.approval_reuse_status,
                 },
                 separators=(",", ":"),
                 sort_keys=True,
@@ -87,6 +99,31 @@ class _CommandActivityRecord:
         correlation_value = fields.get("correlation")
         has_command = fields.get("has_command")
         succeeded = fields.get("succeeded")
+        policy_action = fields.get("policy_action")
+        if policy_action is not None and not is_guard_action(policy_action):
+            return None
+        occurred_at = fields.get("occurred_at")
+        if occurred_at is not None:
+            try:
+                if not isinstance(occurred_at, str) or datetime.fromisoformat(
+                    occurred_at
+                ).utcoffset() != timezone.utc.utcoffset(None):
+                    return None
+            except ValueError:
+                return None
+        if policy_action is not None and (event != "PreToolUse" or occurred_at is None):
+            return None
+        receipt_id = fields.get("receipt_id")
+        prompted = fields.get("interaction_observed", False)
+        reuse = fields.get("approval_reuse_status", "not-applicable")
+        if receipt_id is not None and (not isinstance(receipt_id, str) or not _SAFE_IDENTIFIER.fullmatch(receipt_id)):
+            return None
+        if (
+            type(prompted) is not bool
+            or reuse not in ("not-applicable", "accepted", "rejected")
+            or (prompted and reuse == "accepted")
+        ):
+            return None
         if (
             not isinstance(record_id, str)
             or not isinstance(harness, str)
@@ -109,7 +146,20 @@ class _CommandActivityRecord:
                 )
             except (TypeError, ValueError):
                 return None
-        record = cls(record_id, harness, event, correlation, has_command, succeeded, 0)
+        record = cls(
+            record_id,
+            harness,
+            event,
+            correlation,
+            has_command,
+            succeeded,
+            0,
+            policy_action=cast(str | None, policy_action),
+            occurred_at=cast(str | None, occurred_at),
+            receipt_id=cast(str | None, receipt_id),
+            prompted=prompted,
+            approval_reuse_status=cast(str, reuse),
+        )
         return cls(
             record.record_id,
             record.harness,
@@ -118,6 +168,11 @@ class _CommandActivityRecord:
             record.has_command,
             record.succeeded,
             len(record.serialized()),
+            policy_action=cast(str | None, policy_action),
+            occurred_at=cast(str | None, occurred_at),
+            receipt_id=record.receipt_id,
+            prompted=record.prompted,
+            approval_reuse_status=record.approval_reuse_status,
         )
 
 
@@ -292,7 +347,7 @@ def _write_all(descriptor: int, payload: bytes) -> None:
 
 
 def _payload_has_command(payload: Mapping[str, object]) -> bool:
-    arguments = payload.get("tool_input", payload.get("arguments"))
+    arguments = payload.get("tool_input", payload.get("toolInput", payload.get("arguments")))
     if isinstance(arguments, Mapping):
         command_arguments = cast(Mapping[object, object], arguments)
         for key in ("command", "cmd", "shell_command", "shellCommand"):

{plugin_scanner-3.0.136 → plugin_scanner-3.0.138}/src/codex_plugin_scanner/guard/daemon/runtime_hook_evidence_writer.py

@@ -2,23 +2,29 @@
 
 from __future__ import annotations
 
+import hashlib
 import json
 import threading
 import time
 from collections import OrderedDict, deque
 from collections.abc import Mapping
 from copy import deepcopy
+from dataclasses import replace
+from datetime import datetime, timezone
 from pathlib import Path
-from typing import TypedDict, final
+from typing import TypedDict, cast, final
 from uuid import uuid4
 
+from ..action_lattice import is_guard_action
 from ..cli.commands_support_command_activity import persist_deferred_post_hook_command_activity
+from ..models import GuardAction
 from ..native_decision_receipt import validate_native_decision_receipt
-from ..runtime.command_activity_contract import CorrelationHandle
+from ..runtime.command_activity_contract import ActivityApprovalReuseStatus, CorrelationHandle
 from ..runtime.command_activity_correlation import (
     derive_proven_request_correlation,
     load_or_create_installation_correlation_key,
 )
+from ..runtime.command_activity_lifecycle import build_native_pre_hook_evidence
 from ..runtime.command_activity_privacy import InstallationCorrelationKey
 from ..sqlite_tuning import sqlite_connect_timeout_override
 from ..store import GuardStore
@@ -127,7 +133,13 @@ class RuntimeHookEvidenceWriter:
         event: str,
         payload: Mapping[str, object],
         succeeded: bool,
+        policy_action: str | None = None,
+        receipt_id: str | None = None,
+        prompted: bool = False,
+        approval_reuse_status: str = "not-applicable",
     ) -> bool:
+        if event == "PreToolUse" and not is_guard_action(policy_action):
+            return False
         try:
             snapshot = deepcopy(dict(payload))
             encoded = json.dumps(snapshot, separators=(",", ":"), sort_keys=True).encode("utf-8")
@@ -144,7 +156,14 @@ class RuntimeHookEvidenceWriter:
             has_command=_payload_has_command(snapshot),
             succeeded=succeeded,
             payload_bytes=len(encoded),
+            policy_action=policy_action,
+            occurred_at=datetime.now(timezone.utc).isoformat(),
+            receipt_id=receipt_id,
+            prompted=prompted,
+            approval_reuse_status=approval_reuse_status,
         )
+        if _CommandActivityRecord.from_json(json.loads(record.serialized())) is None:
+            return False
         with self._condition:
             if (
                 self._stopping
@@ -291,6 +310,41 @@ class RuntimeHookEvidenceWriter:
                             )
                             if not persisted:
                                 raise RuntimeError("native receipt persistence was not acknowledged")
+                        elif record.event == "PreToolUse":
+                            if (
+                                record.has_command
+                                and record.policy_action is not None
+                                and record.occurred_at is not None
+                            ):
+                                correlation = record.correlation
+                                # A prevented attempt cannot produce a post event. Keep its
+                                # evidence separate from a later approved retry of the same call.
+                                if correlation is not None and record.policy_action not in ("allow", "warn"):
+                                    digest = hashlib.sha256(
+                                        json.dumps(
+                                            [
+                                                "native-prevented-attempt-v1",
+                                                correlation.digest,
+                                                record.policy_action,
+                                                record.receipt_id,
+                                                record.prompted,
+                                                record.approval_reuse_status,
+                                            ]
+                                        ).encode("utf-8")
+                                    ).hexdigest()
+                                    correlation = replace(correlation, digest=digest)
+                                evidence = build_native_pre_hook_evidence(
+                                    activity_id=record.record_id,
+                                    occurred_at=datetime.fromisoformat(record.occurred_at),
+                                    harness=record.harness,
+                                    policy_action=cast(GuardAction, record.policy_action),
+                                    request_correlation=correlation,
+                                    receipt_id=record.receipt_id,
+                                    prompted=record.prompted,
+                                    approval_reuse_status=ActivityApprovalReuseStatus(record.approval_reuse_status),
+                                )
+                                if not self._store.is_exact_command_activity_pre_replay(evidence):
+                                    _ = self._store.record_command_activity(evidence)
                         else:
                             _ = persist_deferred_post_hook_command_activity(
                                 store=self._store,

{plugin_scanner-3.0.136 → plugin_scanner-3.0.138}/src/codex_plugin_scanner/guard/daemon/server.py

@@ -6077,9 +6077,34 @@ class _GuardDaemonHandler(BaseHTTPRequestHandler):
             queued=scheduler_stats["queued"],
         )
         if review.payload is not None and time.monotonic() < process_deadline:
+            receipt_accepted = False
             if review.receipt is not None:
                 with suppress(Exception):
-                    _ = daemon_server.runtime_hook_evidence_writer.submit_native_decision_receipt(review.receipt)
+                    receipt_accepted = daemon_server.runtime_hook_evidence_writer.submit_native_decision_receipt(
+                        review.receipt
+                    )
+            with suppress(Exception):
+                activity_action = review.payload.get("policy_action")
+                event = payload.get("hook_event_name", payload.get("hookEventName"))
+                if (
+                    isinstance(event, str)
+                    and event.replace("_", "").lower() == "pretooluse"
+                    and _native_mode_requires_rust()
+                    and isinstance(activity_action, str)
+                ):
+                    _ = daemon_server.runtime_hook_evidence_writer.submit_command_activity(
+                        harness=harness,
+                        event="PreToolUse",
+                        payload=payload,
+                        succeeded=True,
+                        policy_action=activity_action,
+                        receipt_id=self._optional_string((review.receipt or {}).get("decision_id"))
+                        if receipt_accepted
+                        else None,
+                        prompted=review.payload.get("prompted") is True,
+                        approval_reuse_status=self._optional_string(review.payload.get("approval_reuse_status"))
+                        or "not-applicable",
+                    )
             self._write_json(review.payload)
             return
         reason_code = (

{plugin_scanner-3.0.136 → plugin_scanner-3.0.138}/src/codex_plugin_scanner/guard/daemon/static/assets/guard-dashboard.js

@@ -25955,7 +25955,7 @@ function CommandActivityDetail(props) {
           controlling: match.rule_id === props.activity.controlling_rule_id
         },
         `${match.ordinal}:${safeEvidenceId(match.rule_id)}`
-      )) }) : /* @__PURE__ */ jsxRuntimeExports.jsx("p", { className: "mt-2 text-sm text-slate-500", children: "No rule match was recorded." })
+      )) }) : /* @__PURE__ */ jsxRuntimeExports.jsx("p", { className: "mt-2 text-sm text-slate-500", children: props.activity.decision_reason_code === "no_match" ? "No rule matched this action." : "Rule evidence is unavailable for this record." })
     ] }),
     /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "border-t border-slate-100 pt-4", children: [
       /* @__PURE__ */ jsxRuntimeExports.jsx(SectionLabel, { children: "Was this interaction expected?" }),
@@ -26392,13 +26392,19 @@ function CommandRow(props) {
     props.onSelect(props.item.activity_id);
   }, [props.item.activity_id, props.onSelect]);
   const firstRule = props.item.matches[0];
+  let ruleLabel = "Rule evidence unavailable";
+  if (firstRule) {
+    ruleLabel = safeEvidenceId(firstRule.rule_id);
+  } else if (props.item.decision_reason_code === "no_match") {
+    ruleLabel = "No rule match";
+  }
   return /* @__PURE__ */ jsxRuntimeExports.jsxs("tr", { className: props.selected ? "bg-brand-blue/[0.04]" : "hover:bg-slate-50/70", children: [
     /* @__PURE__ */ jsxRuntimeExports.jsx("td", { className: "whitespace-nowrap px-3 py-3 text-xs text-slate-600", children: recordedTime(props.item.occurred_at) }),
     /* @__PURE__ */ jsxRuntimeExports.jsx("td", { className: "px-3 py-3 text-sm font-medium text-brand-dark", children: safeEvidenceId(props.item.harness) }),
     /* @__PURE__ */ jsxRuntimeExports.jsx("td", { className: "px-3 py-3 text-sm text-brand-dark", children: commandDecisionLabel(props.item.policy_action) }),
     /* @__PURE__ */ jsxRuntimeExports.jsx("td", { className: "px-3 py-3 text-sm text-brand-dark", children: commandExecutionLabel(props.item.execution_status) }),
     /* @__PURE__ */ jsxRuntimeExports.jsxs("td", { className: "px-3 py-3 text-sm text-slate-600", children: [
-      firstRule ? safeEvidenceId(firstRule.rule_id) : "No rule match",
+      ruleLabel,
       props.item.match_count > 1 ? /* @__PURE__ */ jsxRuntimeExports.jsxs(Badge, { tone: "info", children: [
         "+",
         props.item.match_count - 1

{plugin_scanner-3.0.136 → plugin_scanner-3.0.138}/src/codex_plugin_scanner/guard/runtime/command_activity_contract.py

@@ -329,7 +329,9 @@ def _validate_activity_state(activity: CommandActivity) -> None:
     ):
         raise ValueError("non-exact parse confidence requires a bounded uncertainty class")
     if activity.execution_status is not CommandExecutionStatus.UNPAIRED_POST and (
-        activity.policy_action is None or activity.decision_reason_code is None or activity.parse_confidence is None
+        activity.policy_action is None
+        or activity.decision_reason_code is None
+        or (activity.parse_confidence is None and activity.decision_reason_code is not ActivityDecisionReason.POLICY)
     ):
         raise ValueError("pre and confirmed activity requires complete bounded decision facts")
     if activity.match_count == 0 and activity.controlling_rule_id is not None:
@@ -337,10 +339,17 @@ def _validate_activity_state(activity: CommandActivity) -> None:
     if activity.execution_status is not CommandExecutionStatus.UNPAIRED_POST:
         if activity.decision_reason_code is ActivityDecisionReason.NO_MATCH and activity.match_count != 0:
             raise ValueError("no-match reason cannot carry activity matches")
-        if activity.match_count == 0 and activity.decision_reason_code not in {
-            ActivityDecisionReason.NO_MATCH,
-            ActivityDecisionReason.CAPABILITY,
-        }:
+        if (
+            activity.match_count == 0
+            and activity.decision_reason_code
+            not in {
+                ActivityDecisionReason.NO_MATCH,
+                ActivityDecisionReason.CAPABILITY,
+            }
+            and not (
+                activity.decision_reason_code is ActivityDecisionReason.POLICY and activity.parse_confidence is None
+            )
+        ):
             raise ValueError("an activity without matches requires a no-match reason or capability reason")
     if activity.receipt_link_status is ReceiptLinkStatus.LINKED and activity.receipt_id is None:
         raise ValueError("linked receipt status requires receipt_id")
@@ -350,6 +359,7 @@ def _validate_activity_state(activity: CommandActivity) -> None:
         activity.policy_action is not None
         and guard_action_severity(activity.policy_action) >= guard_action_severity("review")
         and activity.receipt_link_status is not ReceiptLinkStatus.LINKED
+        and not (activity.decision_reason_code is ActivityDecisionReason.POLICY and activity.parse_confidence is None)
     ):
         raise ValueError("review-or-stronger activity requires a linked receipt")
 

{plugin_scanner-3.0.136 → plugin_scanner-3.0.138}/src/codex_plugin_scanner/guard/runtime/command_activity_correlation.py

@@ -32,6 +32,12 @@ _KEY_BYTES: Final = 32
 # Only native, top-level request identifiers documented by these hook adapters
 # can pair pre- and post-execution evidence. Content and session fields are absent.
 _PROVEN_REQUEST_ID_FIELDS: Final[dict[tuple[str, str], str]] = {
+    ("grok", "PreToolUse"): "toolUseId",
+    ("grok", "PostToolUse"): "toolUseId",
+    ("grok", "PostToolUseFailure"): "toolUseId",
+    ("zcode", "PreToolUse"): "tool_use_id",
+    ("zcode", "PostToolUse"): "tool_use_id",
+    ("zcode", "PostToolUseFailure"): "tool_use_id",
     ("codex", "PreToolUse"): "tool_call_id",
     ("codex", "PostToolUse"): "tool_call_id",
     ("codex", "PostToolUseFailure"): "tool_call_id",

{plugin_scanner-3.0.136 → plugin_scanner-3.0.138}/src/codex_plugin_scanner/guard/runtime/command_activity_lifecycle.py

@@ -85,6 +85,48 @@ _UNCERTAINTY_REASON: Final = MappingProxyType(
 )
 
 
+def build_native_pre_hook_evidence(
+    *,
+    activity_id: str,
+    occurred_at: datetime,
+    harness: str,
+    policy_action: GuardAction,
+    request_correlation: CorrelationHandle | None,
+    receipt_id: str | None = None,
+    prompted: bool = False,
+    approval_reuse_status: ActivityApprovalReuseStatus = ActivityApprovalReuseStatus.NOT_APPLICABLE,
+) -> CommandActivityEvidence:
+    """Preserve a final native action without inventing Python rule evaluation."""
+
+    activity = CommandActivity(
+        activity_id=activity_id,
+        occurred_at=occurred_at,
+        harness=harness,
+        hook_phase=CommandHookPhase.PRE,
+        execution_status=(
+            CommandExecutionStatus.PREVENTED
+            if guard_action_severity(policy_action) >= guard_action_severity("review")
+            else CommandExecutionStatus.ALLOWED_UNCONFIRMED
+        ),
+        proof_level=CommandProofLevel.PRE_HOOK,
+        policy_action=policy_action,
+        decision_reason_code=ActivityDecisionReason.POLICY,
+        controlling_rule_id=None,
+        parse_confidence=None,
+        uncertainty_class=None,
+        match_count=0,
+        prompted=prompted,
+        approval_reuse_status=approval_reuse_status,
+        request_correlation=request_correlation,
+        session_correlation=None,
+        receipt_link_status=ReceiptLinkStatus.LINKED if receipt_id is not None else ReceiptLinkStatus.NOT_APPLICABLE,
+        receipt_id=receipt_id,
+        evaluation_latency_bucket=ActivityLatencyBucket.NOT_MEASURED,
+        persistence_latency_bucket=ActivityLatencyBucket.NOT_MEASURED,
+    )
+    return CommandActivityEvidence(activity=activity, matches=())
+
+
 def build_pre_hook_evidence(
     evaluation: CompositeCommandEvaluation,
     decision: CommandActivityDecisionFacts,