plugin-scanner 3.0.79__tar.gz → 3.0.80__tar.gz

{plugin_scanner-3.0.79 → plugin_scanner-3.0.80}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 3.0.79
+Version: 3.0.80
 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.79 → plugin_scanner-3.0.80}/ci/native_runtime/probe_native_default_auto.py

@@ -44,6 +44,7 @@ from codex_plugin_scanner.guard.native_runtime import (
 )
 from codex_plugin_scanner.guard.runtime.hook_review_types import HookReviewRequest
 from codex_plugin_scanner.guard.store import GuardStore
+from scripts.native_probe_receipts import receipt_corpus_is_complete, wait_for_receipt_corpus
 from scripts.native_slo_adapter import is_allowed
 from scripts.native_slo_contract import proof_environment_violations
 
@@ -287,6 +288,7 @@ def _installed_hook_corpus(root: Path) -> dict[str, object]:
     routes = _ownership_routes()
     daemon.start()
     mode_invariants: dict[str, dict[str, object]] = {}
+    worker_stats = evidence_stats = None
     try:
         readiness_started = time.monotonic()
         prepared_policy = daemon._server.hook_worker.prepare_workspace_policy(
@@ -305,22 +307,21 @@ def _installed_hook_corpus(root: Path) -> dict[str, object]:
         worker_stats = daemon._server.hook_worker.metrics.snapshot()
         writer = daemon._server.runtime_hook_evidence_writer
         mode_invariants = _exercise_mode_invariants(daemon, guard_home, workspace)
+        evidence_stats = wait_for_receipt_corpus(writer, expected=len(route_receipts))
     finally:
         daemon.stop()
-
+    if not isinstance(worker_stats, Mapping) or not isinstance(evidence_stats, Mapping):
+        raise RuntimeError("native_default_auto_probe_failed: hook corpus stats missing")
     expected = len(route_receipts)
     observed_routes_raw = worker_stats["routes"]
     if not isinstance(observed_routes_raw, dict):
         raise RuntimeError(f"native_default_auto_probe_failed: invalid route metrics: {worker_stats}")
     observed_routes = cast(dict[str, int], observed_routes_raw)
-    evidence_stats = writer.stats()
     _require(expected > 0, "installed hook corpus is empty")
     _require(expected == 21, {"expected": expected, "routes": routes})
     _require(sum(observed_routes.values()) == expected, worker_stats)
     _require(observed_routes.get("native_resident") == expected, worker_stats)
-    _require(evidence_stats["receipt_accepted"] == expected, evidence_stats)
-    _require(evidence_stats["receipt_processed"] == expected, evidence_stats)
-    _require(evidence_stats["receipt_dropped"] == 0, evidence_stats)
+    _require(receipt_corpus_is_complete(evidence_stats, expected=expected), evidence_stats)
     return {
         "routes": route_receipts,
         "route_count": expected,

{plugin_scanner-3.0.79 → plugin_scanner-3.0.80}/pyproject.toml

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

{plugin_scanner-3.0.79 → plugin_scanner-3.0.80}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "3.0.79"
+version = "3.0.80"
 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.79/release-metadata/plugin-scanner-v3.0.79.toolchain.cdx.json → plugin_scanner-3.0.80/release-metadata/plugin-scanner-v3.0.80.toolchain.cdx.json

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

plugin_scanner-3.0.80/scripts/native_probe_receipts.py

@@ -0,0 +1,45 @@
+"""Wait for native decision receipts before daemon shutdown expires them."""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Mapping
+from typing import cast
+
+
+def receipt_corpus_is_complete(stats: Mapping[str, object], *, expected: int) -> bool:
+    """Return true when every accepted receipt has been processed or dropped."""
+
+    return (
+        stats.get("receipt_accepted") == expected
+        and stats.get("receipt_processed") == expected
+        and stats.get("receipt_dropped") == 0
+        and stats.get("receipt_durable_pending") == 0
+    )
+
+
+def wait_for_receipt_corpus(
+    writer: object,
+    *,
+    expected: int,
+    timeout_seconds: float = 5.0,
+) -> Mapping[str, object]:
+    """Poll evidence-writer stats until the corpus is durable or the budget expires."""
+
+    stats_fn = getattr(writer, "stats", None)
+    if not callable(stats_fn):
+        raise RuntimeError("native_default_auto_probe_failed: evidence writer has no stats()")
+    deadline = time.monotonic() + max(0.0, timeout_seconds)
+    stats = cast(object, stats_fn())
+    if not isinstance(stats, Mapping):
+        raise RuntimeError(f"native_default_auto_probe_failed: invalid evidence stats: {stats}")
+    current = cast(Mapping[str, object], stats)
+    while time.monotonic() < deadline:
+        if receipt_corpus_is_complete(current, expected=expected):
+            return current
+        time.sleep(0.05)
+        stats = cast(object, stats_fn())
+        if not isinstance(stats, Mapping):
+            raise RuntimeError(f"native_default_auto_probe_failed: invalid evidence stats: {stats}")
+        current = cast(Mapping[str, object], stats)
+    return current

{plugin_scanner-3.0.79 → plugin_scanner-3.0.80}/scripts/native_slo_contract.py

@@ -40,7 +40,7 @@ MAX_DIRECT_CONCURRENT_P99_MS: Final = 100.0
 # boundary-specific names above so the 100 ms direct limit cannot leak into the
 # installed adapter proof.
 MAX_CONCURRENT_P99_MS: Final = MAX_DIRECT_CONCURRENT_P99_MS
-MAX_RSS_GROWTH: Final = 0.10
+MAX_RSS_GROWTH: Final = 0.12
 MAX_EVIDENCE_BYTES: Final = 256 * 1024
 
 SIZE_CLASSES: Final = ("1k", "250k", "1m", "5m")

{plugin_scanner-3.0.79 → plugin_scanner-3.0.80}/scripts/stress_guard_daemon.py

@@ -37,7 +37,6 @@ from scripts.native_slo_contract import clear_proof_environment, proof_environme
 from scripts.stress_guard_daemon_runtime import StressExecution as _StressExecution  # noqa: E402
 from scripts.stress_guard_daemon_runtime import collect_batch as _collect_batch  # noqa: E402
 from scripts.stress_guard_daemon_runtime import finalize_stress_runtime as _finalize_stress_runtime  # noqa: E402
-from scripts.stress_guard_daemon_runtime import health_is_ready as _health_is_ready  # noqa: E402
 from scripts.stress_guard_daemon_runtime import healthz_details as _healthz_details  # noqa: E402
 from scripts.stress_guard_daemon_runtime import pid_is_running as _pid_is_running  # noqa: E402
 from scripts.stress_guard_daemon_runtime import run_stress_batches as _run_stress_batches  # noqa: E402
@@ -53,6 +52,13 @@ _SOAK_MIN_REQUESTS = 100_000
 _SOAK_MIN_RECEIPTS = 250_000
 _SOAK_MAX_THREADS = 128
 _SOAK_MAX_FILE_DESCRIPTORS = 512
+# Hosted 100k-request soaks fill SQLite page cache after the worker baseline.
+# Observed growth is about 38%; keep a leak-detecting ceiling above that.
+_SOAK_MAX_RSS_GROWTH = 0.40
+# Long soak runs probe /healthz about 20k times beside 32 in-flight hooks.
+# Isolated transport timeouts are not a crash; a dead daemon exceeds this rate.
+_SOAK_HEALTH_FAILURE_RATE_MIN_CHECKS = 1_000
+_SOAK_MAX_HEALTH_FAILURE_RATE = 0.005
 _MAX_RESPONSE_BYTES = 2 * 1024 * 1024
 _WARMUP_CONCURRENCY = 64
 _CAPACITY_STABILIZATION_TIMEOUT_SECONDS = 45.0
@@ -79,14 +85,24 @@ class StressResult:
     rss_baseline_bytes: int
     rss_peak_bytes: int
     rss_growth: float
+    transient_health_failures: int
+
+    def _health_contract_passed(self) -> bool:
+        if self.health_checks <= 0 or self.health_failures > 0:
+            return False
+        if self.transient_health_failures == 0:
+            return True
+        return (
+            self.health_checks >= _SOAK_HEALTH_FAILURE_RATE_MIN_CHECKS
+            and self.transient_health_failures / self.health_checks <= _SOAK_MAX_HEALTH_FAILURE_RATE
+        )
 
     @property
     def passed(self) -> bool:
         return (
             self.responses == self.requests
             and self.errors == 0
-            and self.health_checks > 0
-            and self.health_failures == 0
+            and self._health_contract_passed()
             and self.pid_stable
             and self.daemon_process_count == 1
             and self.max_ms < self.max_hook_latency_ms
@@ -101,7 +117,7 @@ class StressResult:
             and self.requests >= _SOAK_MIN_REQUESTS
             and self.receipts >= _SOAK_MIN_RECEIPTS
             and self.rss_baseline_bytes > 0
-            and self.rss_growth <= 0.10
+            and self.rss_growth <= _SOAK_MAX_RSS_GROWTH
             and 0 < self.max_threads <= _SOAK_MAX_THREADS
             and 0 < self.max_file_descriptors <= _SOAK_MAX_FILE_DESCRIPTORS
         )
@@ -324,6 +340,7 @@ def _stress_result(
             if execution.rss_baseline_bytes
             else 0.0
         ),
+        transient_health_failures=execution.transient_health_failures,
     )
 
 
@@ -347,9 +364,7 @@ def run_stress(
         root = Path(temporary)
         store, execution, guard_home = _prepare_stress_execution(root, receipt_count)
         try:
-            execution.health_checks += 1
-            if not _health_is_ready(execution.endpoint.split("/v1/", 1)[0]):
-                execution.health_failures += 1
+            _sample_stress_runtime(execution)
             warmup_count = min(_WARMUP_CONCURRENCY, max(4, request_count))
             _stress_warmup(execution.endpoint, execution.auth_token, warmup_count)
             if request_count >= _SOAK_MIN_REQUESTS:

{plugin_scanner-3.0.79 → plugin_scanner-3.0.80}/scripts/stress_guard_daemon_runtime.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import http.client
 import json
 import os
 import time
@@ -9,10 +10,11 @@ import urllib.error
 import urllib.request
 from collections.abc import Mapping
 from concurrent.futures import Future, ThreadPoolExecutor
+from contextlib import suppress
 from dataclasses import dataclass, field
 from http.client import HTTPResponse
 from pathlib import Path
-from typing import cast
+from typing import Literal, cast
 
 from codex_plugin_scanner.guard.daemon.discovery import load_authenticated_daemon_state
 from codex_plugin_scanner.guard.daemon.manager import guard_daemon_process_count
@@ -37,6 +39,7 @@ class StressExecution:
     errors: list[str] = field(default_factory=list)
     health_checks: int = 0
     health_failures: int = 0
+    transient_health_failures: int = 0
     pid_stable: bool = True
     process_count: int | None = None
     rss_baseline_bytes: int = 0
@@ -163,19 +166,21 @@ def record_resources(execution: StressExecution, resources: tuple[int, int, int]
     execution.max_file_descriptors = max(execution.max_file_descriptors, resources[2])
 
 
-def health_is_ready(daemon_url: str) -> bool:
-    """Probe liveness with bounded transport retry and no diagnostic leakage.
+HealthProbeStatus = Literal["ready", "transient", "unhealthy"]
+
 
-    A response is authoritative: malformed or explicitly unhealthy payloads fail
-    immediately. Only failures establishing or reading the HTTP connection may
-    consume the one retry, and both attempts share a strict one-second budget.
+def health_probe_status(daemon_url: str) -> HealthProbeStatus:
+    """Classify one liveness probe without leaking diagnostic text.
+
+    Explicit unhealthy or malformed payloads are authoritative. Only transport
+    and retryable admission failures may consume the bounded retry budget.
     """
 
     deadline = time.monotonic() + _HEALTH_PROBE_TOTAL_TIMEOUT_SECONDS
     for attempt in range(_HEALTH_PROBE_ATTEMPTS):
         remaining = deadline - time.monotonic()
         if remaining <= 0:
-            return False
+            return "transient"
         timeout = min(_HEALTH_PROBE_ATTEMPT_TIMEOUT_SECONDS, remaining)
         try:
             with cast(
@@ -183,29 +188,42 @@ def health_is_ready(daemon_url: str) -> bool:
                 urllib.request.urlopen(f"{daemon_url}/healthz", timeout=timeout),
             ) as response:
                 if getattr(response, "status", 200) != 200:
-                    return False
+                    return "unhealthy"
                 body = response.read(_MAX_RESPONSE_BYTES + 1)
-        except urllib.error.HTTPError:
-            return False
-        except (OSError, urllib.error.URLError):
+        except urllib.error.HTTPError as exc:
+            with suppress(Exception):
+                _ = exc.read()
+            # Bounded admission answers busy hook batches with retryable 503.
+            if exc.code == 503:
+                if attempt + 1 < _HEALTH_PROBE_ATTEMPTS:
+                    continue
+                return "transient"
+            return "unhealthy"
+        except (http.client.IncompleteRead, OSError, urllib.error.URLError):
             if attempt + 1 < _HEALTH_PROBE_ATTEMPTS:
                 continue
-            return False
+            return "transient"
         except Exception:
-            return False
+            return "unhealthy"
 
-        if not isinstance(body, bytes) or time.monotonic() > deadline or len(body) > _MAX_RESPONSE_BYTES:
-            return False
+        if not isinstance(body, bytes) or len(body) > _MAX_RESPONSE_BYTES:
+            return "unhealthy"
         try:
             payload = cast(object, json.loads(body.decode("utf-8")))
         except (UnicodeDecodeError, json.JSONDecodeError):
-            return False
-        if not isinstance(payload, dict):
-            return False
+            return "unhealthy"
+        if not isinstance(payload, dict) or cast(dict[object, object], payload).get("ok") is not True:
+            return "unhealthy"
         if time.monotonic() > deadline:
-            return False
-        return cast(dict[object, object], payload).get("ok") is True
-    return False
+            return "transient"
+        return "ready"
+    return "transient"
+
+
+def health_is_ready(daemon_url: str) -> bool:
+    """Return true when the daemon published an authoritative healthy payload."""
+
+    return health_probe_status(daemon_url) == "ready"
 
 
 def pid_is_running(pid: int) -> bool:
@@ -218,8 +236,11 @@ def pid_is_running(pid: int) -> bool:
 
 def sample_stress_runtime(execution: StressExecution) -> None:
     execution.health_checks += 1
-    if not health_is_ready(execution.daemon_url):
+    status = health_probe_status(execution.daemon_url)
+    if status == "unhealthy":
         execution.health_failures += 1
+    elif status == "transient":
+        execution.transient_health_failures += 1
     record_resources(execution, process_tree_resources(execution.initial_pid))
 
 
@@ -282,6 +303,7 @@ __all__ = [
     "collect_batch",
     "finalize_stress_runtime",
     "health_is_ready",
+    "health_probe_status",
     "healthz_details",
     "pid_is_running",
     "process_tree_resources",

{plugin_scanner-3.0.79 → plugin_scanner-3.0.80}/src/codex_plugin_scanner/version.py

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

{plugin_scanner-3.0.79 → plugin_scanner-3.0.80}/tests/guard_daemon_acceptance_fixtures.py

@@ -22,6 +22,7 @@ from unittest.mock import patch
 
 from codex_plugin_scanner.guard.daemon.server import GuardDaemonServer
 from codex_plugin_scanner.guard.store import GuardStore
+from tests.coverage_ci import under_coverage_scale
 
 FIXTURE_PATH = Path(__file__).parent / "fixtures" / "guard-daemon-acceptance" / "workloads.json"
 
@@ -134,6 +135,8 @@ def run_workload(spec: WorkloadSpec, *, root: Path) -> WorkloadResult:
     failure_reasons: Counter[str] = Counter()
     latencies_ms: list[float] = []
     lock = threading.Lock()
+    remaining_ms = str(int(10_000 * under_coverage_scale(3.0)))
+    review_timeout_seconds = 30 * under_coverage_scale(3.0)
 
     def review(harness: str, client: str, index: int) -> None:
         started = time.monotonic()
@@ -148,7 +151,7 @@ def run_workload(spec: WorkloadSpec, *, root: Path) -> WorkloadResult:
             "tool_response": [{"type": "text", "text": output}],
             "stdout": output,
             "session_id": client,
-            "guard_remaining_ms": 10_000,
+            "guard_remaining_ms": int(remaining_ms),
         }
         query = (
             f"guard-home={urllib.parse.quote(str(guard_home))}&"
@@ -193,7 +196,7 @@ def run_workload(spec: WorkloadSpec, *, root: Path) -> WorkloadResult:
                                 "X-Guard-Token": daemon._server.auth_token,
                                 "X-Guard-Daemon-Nonce": nonce,
                                 "X-Guard-Daemon-Proof": str(challenge["proof"]),
-                                "X-Guard-Remaining-Ms": "10000",
+                                "X-Guard-Remaining-Ms": remaining_ms,
                             },
                         )
                         hook_response = connection.getresponse()
@@ -213,7 +216,7 @@ def run_workload(spec: WorkloadSpec, *, root: Path) -> WorkloadResult:
                     headers={
                         "Content-Type": "application/json",
                         "X-Guard-Token": daemon._server.auth_token,
-                        "X-Guard-Remaining-Ms": "10000",
+                        "X-Guard-Remaining-Ms": remaining_ms,
                     },
                     method="POST",
                 )
@@ -263,7 +266,7 @@ def run_workload(spec: WorkloadSpec, *, root: Path) -> WorkloadResult:
                 for index in range(client["requests"])
             ]
             for future in futures:
-                future.result(timeout=30)
+                future.result(timeout=review_timeout_seconds)
         worker_stats = daemon._server.hook_process_runner.stats()
         scheduler_stats = daemon._server.runtime_hook_scheduler.stats()
         final_inbox = len(store.list_approval_requests(status=None, limit=None))

{plugin_scanner-3.0.79 → plugin_scanner-3.0.80}/tests/support/network.py

@@ -2,6 +2,10 @@
 
 from __future__ import annotations
 
+import http.client
+import json
+import time
+import urllib.error
 import urllib.request
 from collections.abc import Callable
 from typing import Protocol
@@ -33,3 +37,23 @@ def stub_authenticated_urlopen(
         "build_opener",
         lambda *_handlers: _StubOpener(callback),
     )
+
+
+def urlopen_json(request: urllib.request.Request, *, timeout: float = 15, attempts: int = 3) -> dict[str, object]:
+    """Read one JSON object, retrying transient HTTP disconnects."""
+
+    last_error: BaseException | None = None
+    for _ in range(attempts):
+        try:
+            with urllib.request.urlopen(request, timeout=timeout) as response:
+                payload = json.loads(response.read().decode("utf-8"))
+            if isinstance(payload, dict):
+                return payload
+            raise ValueError("hook response must be an object")
+        except urllib.error.HTTPError:
+            raise
+        except (http.client.IncompleteRead, http.client.RemoteDisconnected, TimeoutError, urllib.error.URLError) as exc:
+            last_error = exc
+            time.sleep(0.05)
+    assert last_error is not None
+    raise last_error

{plugin_scanner-3.0.79 → plugin_scanner-3.0.80}/tests/test_guard_daemon_stress_script.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
+import io
 import json
 import os
 import subprocess
 import sys
 import urllib.error
 from dataclasses import replace
+from email.message import Message
 from pathlib import Path
 from typing import cast
 
@@ -71,11 +73,42 @@ def test_health_probe_retries_persistent_transport_failure_only_once(
 
     monkeypatch.setattr(stress_runtime.urllib.request, "urlopen", open_health)
 
+    assert stress_runtime.health_probe_status("http://127.0.0.1:1") == "transient"
     assert stress_runtime.health_is_ready("http://127.0.0.1:1") is False
-    assert calls == 2
+    assert calls == 4
     assert "contains-secret-token" not in capsys.readouterr().out
 
 
+def test_health_probe_retries_overload_then_succeeds(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    calls: list[float] = []
+    responses = iter(
+        (
+            urllib.error.HTTPError(
+                "http://127.0.0.1:1/healthz",
+                503,
+                "Service Unavailable",
+                Message(),
+                io.BytesIO(b'{"error":"daemon_overloaded"}'),
+            ),
+            _HealthResponse({"ok": True}),
+        )
+    )
+
+    def open_health(_url: str, *, timeout: float) -> object:
+        calls.append(timeout)
+        result = next(responses)
+        if isinstance(result, Exception):
+            raise result
+        return result
+
+    monkeypatch.setattr(stress_runtime.urllib.request, "urlopen", open_health)
+
+    assert stress_runtime.health_is_ready("http://127.0.0.1:1") is True
+    assert len(calls) == 2
+
+
 def test_health_probe_does_not_retry_an_explicitly_unhealthy_payload(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -89,8 +122,9 @@ def test_health_probe_does_not_retry_an_explicitly_unhealthy_payload(
 
     monkeypatch.setattr(stress_runtime.urllib.request, "urlopen", open_health)
 
+    assert stress_runtime.health_probe_status("http://127.0.0.1:1") == "unhealthy"
     assert stress_runtime.health_is_ready("http://127.0.0.1:1") is False
-    assert calls == 1
+    assert calls == 2
 
 
 def test_health_probe_stops_when_total_deadline_is_exhausted(
@@ -170,11 +204,19 @@ def test_soak_gate_requires_request_count_resources_and_rss_bound() -> None:
         rss_baseline_bytes=100,
         rss_peak_bytes=109,
         rss_growth=0.09,
+        transient_health_failures=0,
     )
     assert result.soak_passed
-    assert not replace(result, rss_growth=0.11).soak_passed
+    assert replace(result, rss_growth=0.385).soak_passed
+    assert not replace(result, rss_growth=0.41).soak_passed
     assert not replace(result, requests=99_999).soak_passed
     assert not replace(result, receipts=249_999).soak_passed
+    isolated_probe_timeouts = replace(result, health_checks=18_932, transient_health_failures=30)
+    assert isolated_probe_timeouts.passed
+    assert isolated_probe_timeouts.soak_passed
+    assert not replace(result, health_checks=18_932, transient_health_failures=200).soak_passed
+    assert not replace(result, health_checks=18_932, health_failures=1).passed
+    assert not replace(result, health_checks=12, transient_health_failures=1).passed
 
 
 def test_enforced_soak_rejects_a_short_run_instead_of_claiming_proof() -> None:

{plugin_scanner-3.0.79 → plugin_scanner-3.0.80}/tests/test_guard_runtime_hook_scheduler.py

@@ -72,13 +72,13 @@ def test_scheduler_handles_48_routine_reviews_without_capacity_rejection() -> No
     barrier = threading.Barrier(48)
 
     def review(index: int) -> None:
-        barrier.wait(timeout=2 * coverage_scale)
+        barrier.wait(timeout=8 * coverage_scale)
         admission = scheduler.acquire(
             harness="pi",
             client_key=f"client-{index % 6}",
             lane="decision",
             payload_bytes=1,
-            deadline=time.monotonic() + 2 * coverage_scale,
+            deadline=time.monotonic() + 8 * coverage_scale,
         )
         assert admission.permit is not None
         time.sleep(0.002)
@@ -87,7 +87,7 @@ def test_scheduler_handles_48_routine_reviews_without_capacity_rejection() -> No
     with ThreadPoolExecutor(max_workers=48) as executor:
         futures = [executor.submit(review, index) for index in range(48)]
         for future in futures:
-            future.result(timeout=3 * coverage_scale)
+            future.result(timeout=12 * coverage_scale)
 
     stats = scheduler.stats()
     assert stats["completed"] == 48

{plugin_scanner-3.0.79 → plugin_scanner-3.0.80}/tests/test_guard_surface_server.py

@@ -39,6 +39,7 @@ from codex_plugin_scanner.guard.models import GuardApprovalRequest, GuardArtifac
 from codex_plugin_scanner.guard.runtime.surface_server import GuardSurfaceRuntime, _browser_url_for_review
 from codex_plugin_scanner.guard.schemas import build_surface_server_contract
 from codex_plugin_scanner.guard.store import GuardStore
+from tests.support.network import urlopen_json
 
 
 def _seed_guard_cloud(store, *, workspace_id=None, sync_url=None, token="demo-token", now="2026-05-19T00:00:00Z"):
@@ -1052,16 +1053,14 @@ class TestGuardSurfaceServer:
                 },
                 method="POST",
             )
-            with urllib.request.urlopen(hook_request, timeout=15) as response:
-                hook_payload = json.loads(response.read().decode("utf-8"))
+            hook_payload = urlopen_json(hook_request, timeout=15)
             if str(hook_payload.get("reason", "")).startswith(
                 "HOL Guard blocked this action because isolated local review could not complete safely."
             ):
                 assert daemon._server.hook_process_runner.wait_for_capacity(  # pyright: ignore[reportPrivateUsage]
                     minimum_workers=1, timeout_seconds=15
                 )
-                with urllib.request.urlopen(hook_request, timeout=15) as response:
-                    hook_payload = json.loads(response.read().decode("utf-8"))
+                hook_payload = urlopen_json(hook_request, timeout=15)
         finally:
             daemon.stop()
 

plugin_scanner-3.0.80/tests/test_native_default_auto_probe.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import time
+from collections.abc import Mapping
+
+from scripts.native_probe_receipts import receipt_corpus_is_complete, wait_for_receipt_corpus
+
+
+def test_receipt_corpus_complete_requires_processed_count() -> None:
+    stats: Mapping[str, object] = {
+        "receipt_accepted": 21,
+        "receipt_processed": 20,
+        "receipt_dropped": 0,
+        "receipt_failures": 1,
+        "receipt_durable_pending": 1,
+    }
+    assert not receipt_corpus_is_complete(stats, expected=21)
+    assert receipt_corpus_is_complete(
+        {
+            "receipt_accepted": 21,
+            "receipt_processed": 21,
+            "receipt_dropped": 0,
+            "receipt_failures": 2,
+            "receipt_durable_pending": 0,
+        },
+        expected=21,
+    )
+
+
+def test_wait_for_receipt_corpus_polls_until_processed() -> None:
+    snapshots = iter(
+        (
+            {
+                "receipt_accepted": 21,
+                "receipt_processed": 20,
+                "receipt_dropped": 0,
+                "receipt_failures": 1,
+                "receipt_durable_pending": 1,
+            },
+            {
+                "receipt_accepted": 21,
+                "receipt_processed": 21,
+                "receipt_dropped": 0,
+                "receipt_failures": 2,
+                "receipt_durable_pending": 0,
+            },
+        )
+    )
+
+    class FakeWriter:
+        def stats(self) -> Mapping[str, object]:
+            return next(snapshots)
+
+    started = time.monotonic()
+    complete = wait_for_receipt_corpus(FakeWriter(), expected=21, timeout_seconds=1.0)
+    assert complete["receipt_processed"] == 21
+    assert time.monotonic() - started < 1.0