plugin-scanner 2.0.563__tar.gz → 2.0.565__tar.gz

{plugin_scanner-2.0.563 → plugin_scanner-2.0.565}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.563
+Version: 2.0.565
 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.563 → plugin_scanner-2.0.565}/docs/guard/get-started.md

@@ -5,6 +5,12 @@ Install `plugin-scanner` separately when you want maintainer or CI checks for pl
 
 Use it when you want to protect a harness before local MCP servers, skills, hooks, or plugin surfaces run.
 
+Local Guard protects your machine without requiring sign-in. Guard Cloud is an optional
+paid service providing cloud history, visibility, sync, and management on top of that
+protection. See
+[Local Guard vs Guard Cloud](./local-vs-cloud.md) for the full subscription
+boundary.
+
 ## The everyday flow
 
 1. Start the guided first-run setup:

{plugin_scanner-2.0.563 → plugin_scanner-2.0.565}/docs/guard/harness-support.md

@@ -1,5 +1,9 @@
 # Harness Support Matrix
 
+Local harness protection works without signing in to Guard Cloud. Cloud adds synced
+history, visibility, and team controls around the same adapters. See
+[Local Guard vs Guard Cloud](./local-vs-cloud.md).
+
 Current Guard support in this repo:
 
 - `codex`

plugin_scanner-2.0.565/docs/guard/local-vs-cloud.md

@@ -0,0 +1,105 @@
+# Local Guard vs Guard Cloud
+
+Guard protects your machine first. Guard Cloud is an optional paid service
+providing cloud history, visibility, sync, and management around that protection.
+
+## Local Guard baseline
+
+Available without a Cloud subscription or sign-in:
+
+- **Launch interception and wrappers** — `hol-guard install` and `hol-guard run`
+  sit in front of supported AI harnesses before tools, MCP servers, or skills
+  execute.
+- **Local policy decisions** — home config, project overrides, saved allow/deny
+  rules, and built-in recommendations resolve on this machine.
+- **Local blocking and warnings** — Guard can stop or warn on supported risky
+  shell commands, file reads, MCP tool calls, skill loads, and prompt-sensitive
+  actions before side effects occur.
+- **Package-manager protection where supported** — supported managers (for
+  example npm and PyPI) can be intercepted locally through shims and runtime
+  evaluation. Unsupported or monitor-only managers stay advisory only.
+- **Local receipts and explain output** — `hol-guard receipts`, `hol-guard
+  explain`, and the local approval center record what Guard decided and why.
+- **Local approval and review paths** — inline harness approval, the local
+  approval center on `127.0.0.1`, and `hol-guard approvals` resolve decisions
+  without Cloud.
+- **Cloud-outage independence** — if Guard Cloud is unavailable, you are signed
+  out, or never connected, local interception, policy, blocking, receipts, and
+  approvals continue on the machine.
+
+Guard does not meter local safety features. You can detect harnesses, install
+launchers, diff changes, prompt for approval, and inspect receipts without
+signing in.
+
+Safe Decode runs locally too. It inspects encoded payload layers for review
+evidence, but never executes decoded payloads and only syncs redacted summaries
+when optional Cloud receipt sync is enabled.
+
+## Guard Cloud for individual developers
+
+Guard Cloud is a personal AI safety cockpit and memory layer. It does not gate
+baseline local protection.
+
+Paid Cloud value for a solo developer or vibe coder includes:
+
+- **Synced history** across sessions, devices, and hosted or local agents
+- **Searchable activity** — blocked actions, approvals, package installs,
+  MCP/Skill changes, and risky activity in one timeline
+- **Decision memory and policy suggestions** — safe repeated choices stop
+  becoming repeated interruptions
+- **MCP/Skill drift visibility over time** — changed schemas, commands,
+  transports, scopes, and dependencies stay visible after first trust
+- **Incident-style summaries** — what happened, why it mattered, and what to
+  do next without digging through raw logs
+- **Cloud Firewall UI** — package risk, feed freshness, remediation guidance,
+  and safer fix paths on top of local enforcement
+- **Exports and shareable records** — audit-ready evidence packages when you
+  need to show what Guard handled
+- **Digests and notifications** — calm routing for what needs attention
+
+Optional Cloud pairing commands:
+
+```bash
+hol-guard connect
+hol-guard connect status
+hol-guard connect repair
+hol-guard sync
+hol-guard supply-chain sync
+```
+
+`hol-guard connect` is the canonical way to pair a machine with Guard Cloud.
+`hol-guard connect --headless` uses OAuth Device Code for SSH/CI hosts.
+`hol-guard login` remains only as a redirecting compatibility alias. These
+commands add sync and visibility; they do not unlock core local protection.
+
+## Guard Cloud for teams
+
+Team plans add shared ownership, routing, RBAC, billing, and evidence exports
+on top of the individual Cloud value:
+
+- **Shared workspaces** with members, roles, service principals, and ownership
+- **Shared review workflow** with assignment, SLA, policy memory, cases, and
+  audit history
+- **Integrations** — Slack, GitHub, Jira, PagerDuty, email, and webhooks where
+  setup and delivery are available
+- **Team package firewall visibility** and exception governance
+- **Billing, plan limits, admin controls, exports, and enterprise materials**
+
+## Quick comparison
+
+| Capability | Local Guard | Guard Cloud |
+| --- | --- | --- |
+| Launch interception and local policy | Included | Included |
+| Local blocking/warnings on supported actions | Included | Included |
+| Local receipts and approvals | Included | Included |
+| Works when Cloud is offline | Yes | Local protection continues; sync pauses |
+| Cross-device history and search | Device-local only | Included on paid plans |
+| Decision memory across machines | No | Included on paid plans |
+| Cloud Firewall UI and exports | No | Included on paid plans |
+| Team RBAC, routing, and shared policy | No | Team plans |
+
+## Related docs
+
+- [Get started](./get-started.md)
+- [Harness support](./harness-support.md)
+- [Remediation](./remediation.md)

{plugin_scanner-2.0.563 → plugin_scanner-2.0.565}/pyproject.toml

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

{plugin_scanner-2.0.563 → plugin_scanner-2.0.565}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.563"
+version = "2.0.565"
 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.563 → plugin_scanner-2.0.565}/src/codex_plugin_scanner/guard/daemon/server.py

@@ -90,7 +90,6 @@ from ..desktop_notifications import (
 from ..insights_share import publish_insights_share
 from ..local_dashboard_session import LOCAL_DASHBOARD_SESSION_AUDIENCE, build_local_dashboard_session_token
 from ..local_supply_chain import (
-    audit_receipt_metadata,
     build_workspace_audit_payload,
     resolve_package_firewall_entitlement_with_refresh,
     resolve_supply_chain_audit_workspace_dir,
@@ -103,6 +102,7 @@ from ..package_firewall_entitlement import (
     package_firewall_block_details,
     package_firewall_operation_allowed,
 )
+from ..package_firewall_receipts import package_firewall_receipt_metadata
 from ..package_shim_status import record_package_shim_audit_result
 from ..receipts.manager import build_receipt
 from ..runtime.runner import (
@@ -1869,6 +1869,12 @@ class _GuardDaemonHandler(BaseHTTPRequestHandler):
             "manager": manager,
             **activation_result,
         }
+        receipt_overrides = package_firewall_receipt_metadata(
+            operation=action,
+            result=result,
+            managers=(manager,),
+            workspace_dir=context.workspace_dir,
+        )
         receipt = self._record_headless_receipt(
             harness="package-firewall",
             operation=action,
@@ -1876,6 +1882,14 @@ class _GuardDaemonHandler(BaseHTTPRequestHandler):
             result=result,
             workspace_id=self._optional_string(payload.get("workspace_id"))
             or self.server.store.get_cloud_workspace_id(),  # type: ignore[attr-defined]
+            policy_decision=self._optional_string(receipt_overrides.get("policy_decision")),
+            capabilities_summary=self._optional_string(receipt_overrides.get("capabilities_summary")),
+            artifact_name=self._optional_string(receipt_overrides.get("artifact_name")),
+            scanner_evidence_extra=(
+                receipt_overrides.get("scanner_evidence")
+                if isinstance(receipt_overrides.get("scanner_evidence"), dict)
+                else None
+            ),
         )
         self._write_json(
             {
@@ -1963,9 +1977,12 @@ class _GuardDaemonHandler(BaseHTTPRequestHandler):
         except ValueError as error:
             self._write_json({"error": str(error), "operation": operation}, status=400)
             return
-        receipt_overrides: dict[str, object] = {}
-        if operation == "audit":
-            receipt_overrides = audit_receipt_metadata(result)
+        receipt_overrides = package_firewall_receipt_metadata(
+            operation=operation,
+            result=result,
+            managers=managers,
+            workspace_dir=context.workspace_dir,
+        )
         receipt = self._record_headless_receipt(
             harness="package-firewall",
             operation=operation,

{plugin_scanner-2.0.563 → plugin_scanner-2.0.565}/src/codex_plugin_scanner/guard/local_supply_chain.py

@@ -464,7 +464,24 @@ def _audit_package_findings_for_receipt(
     return [item for _, _, item in ranked[:limit]]
 
 
-def audit_receipt_metadata(result: dict[str, object]) -> dict[str, object]:
+def workspace_audit_path_hashes(
+    workspace_dir: Path | None,
+    manifest_paths: Sequence[str],
+    lockfile_paths: Sequence[str],
+) -> dict[str, list[str]]:
+    if workspace_dir is None:
+        return {"manifest_hashes": [], "lockfile_hashes": []}
+    return {
+        "manifest_hashes": _hash_existing_paths(workspace_dir, manifest_paths),
+        "lockfile_hashes": _hash_existing_paths(workspace_dir, lockfile_paths),
+    }
+
+
+def audit_receipt_metadata(
+    result: dict[str, object],
+    *,
+    workspace_dir: Path | None = None,
+) -> dict[str, object]:
     evaluation = result.get("evaluation")
     if not isinstance(evaluation, dict):
         return {}
@@ -480,6 +497,9 @@ def audit_receipt_metadata(result: dict[str, object]) -> dict[str, object]:
         policy_decision = "ask"
     inventory = result.get("inventory")
     inventory_summary = inventory if isinstance(inventory, dict) else {}
+    manifest_paths = [str(path) for path in result.get("manifest_paths") or () if isinstance(path, str)]
+    lockfile_paths = [str(path) for path in result.get("lockfile_paths") or () if isinstance(path, str)]
+    path_hashes = workspace_audit_path_hashes(workspace_dir, manifest_paths, lockfile_paths)
     return {
         "policy_decision": policy_decision,
         "capabilities_summary": (
@@ -491,8 +511,10 @@ def audit_receipt_metadata(result: dict[str, object]) -> dict[str, object]:
             "operation": "audit",
             "audit_decision": decision,
             "blocked_package_count": len(blocked_packages),
-            "lockfile_paths": list(result.get("lockfile_paths") or ()),
-            "manifest_paths": list(result.get("manifest_paths") or ()),
+            "lockfile_paths": lockfile_paths,
+            "manifest_paths": manifest_paths,
+            "manifest_hashes": path_hashes["manifest_hashes"],
+            "lockfile_hashes": path_hashes["lockfile_hashes"],
             "total_packages": inventory_summary.get("total_packages", len(package_items)),
             "package_findings": package_findings,
         },

plugin_scanner-2.0.565/src/codex_plugin_scanner/guard/package_firewall_receipts.py

@@ -0,0 +1,122 @@
+"""Receipt metadata helpers for package-firewall daemon operations (SCSR181-183)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from .local_supply_chain import audit_receipt_metadata
+
+
+def _read_string_list(value: object) -> list[str]:
+    if not isinstance(value, list):
+        return []
+    return [str(manager) for manager in value if isinstance(manager, str)]
+
+
+def _audit_installed_managers(result: dict[str, object]) -> list[str]:
+    supply_chain = result.get("supply_chain")
+    if not isinstance(supply_chain, dict):
+        return []
+    protection = supply_chain.get("package_manager_protection")
+    if not isinstance(protection, dict):
+        return []
+    return _read_string_list(protection.get("installed_managers"))
+
+
+def _resolve_manager_subset(
+    managers: tuple[str, ...] | None,
+    result: dict[str, object],
+    operation: str,
+) -> list[str]:
+    if managers:
+        return [str(manager) for manager in managers if isinstance(manager, str)]
+    tested_managers = result.get("tested_managers")
+    if isinstance(tested_managers, list):
+        return _read_string_list(tested_managers)
+    if operation == "audit":
+        installed = _audit_installed_managers(result)
+        if installed:
+            return installed
+        package_shims = result.get("package_shims")
+        if isinstance(package_shims, dict):
+            detected = _read_string_list(package_shims.get("detected_managers"))
+            if detected:
+                return detected
+    installed_managers = result.get("installed_managers")
+    if isinstance(installed_managers, list):
+        return _read_string_list(installed_managers)
+    return []
+
+
+def _test_intercept_proofs(result: dict[str, object]) -> list[dict[str, object]]:
+    manager_results = result.get("manager_results")
+    if not isinstance(manager_results, list):
+        return []
+    proofs: list[dict[str, object]] = []
+    for entry in manager_results:
+        if not isinstance(entry, dict):
+            continue
+        manager = entry.get("manager")
+        if not isinstance(manager, str):
+            continue
+        proof: dict[str, object] = {"manager": manager}
+        command_hash = entry.get("command_hash")
+        if isinstance(command_hash, str) and command_hash:
+            proof["command_hash"] = command_hash
+        evaluator_source = entry.get("evaluator_source")
+        if isinstance(evaluator_source, str) and evaluator_source:
+            proof["evaluator_source"] = evaluator_source
+        if "evaluator_invoked" in entry:
+            proof["evaluator_invoked"] = bool(entry.get("evaluator_invoked"))
+        proofs.append(proof)
+    return proofs
+
+
+def package_firewall_receipt_metadata(
+    *,
+    operation: str,
+    result: dict[str, object],
+    managers: tuple[str, ...] | None = None,
+    workspace_dir: Path | None = None,
+) -> dict[str, object]:
+    """Build receipt override fields for package-firewall headless operations."""
+
+    manager_subset = _resolve_manager_subset(managers, result, operation)
+    if operation == "audit":
+        metadata = audit_receipt_metadata(result, workspace_dir=workspace_dir)
+        scanner_evidence = metadata.get("scanner_evidence")
+        if isinstance(scanner_evidence, dict):
+            enriched = dict(scanner_evidence)
+            enriched["manager_subset"] = manager_subset
+            metadata = {**metadata, "scanner_evidence": enriched}
+        return metadata
+
+    scanner_evidence: dict[str, object] = {
+        "operation": operation,
+        "manager_subset": manager_subset,
+    }
+    if operation == "test":
+        scanner_evidence["intercept_proofs"] = _test_intercept_proofs(result)
+        intercept_proved = result.get("intercept_proved")
+        if isinstance(intercept_proved, bool):
+            scanner_evidence["intercept_proved"] = intercept_proved
+
+    capabilities_summary = f"Package firewall {operation} completed for {len(manager_subset)} manager(s)."
+    if operation == "test" and scanner_evidence.get("intercept_proofs"):
+        proved_count = sum(
+            1
+            for proof in scanner_evidence["intercept_proofs"]
+            if isinstance(proof, dict) and proof.get("evaluator_invoked") is True
+        )
+        capabilities_summary = (
+            f"Intercept test recorded evaluator proof for {proved_count} of {len(manager_subset)} manager(s)."
+        )
+
+    return {
+        "capabilities_summary": capabilities_summary,
+        "artifact_name": f"Package firewall {operation}",
+        "scanner_evidence": scanner_evidence,
+    }
+
+
+__all__ = ["package_firewall_receipt_metadata"]

{plugin_scanner-2.0.563 → plugin_scanner-2.0.565}/src/codex_plugin_scanner/guard/shim_probe.py

@@ -58,8 +58,16 @@ def protect_evaluator_evidence(payload: dict[str, Any]) -> dict[str, object]:
     normalized_evidence_ids = (
         [str(item) for item in evidence_ids if item is not None] if isinstance(evidence_ids, list) else []
     )
+    evaluator_source = supply_chain_dict.get("source")
+    if not isinstance(evaluator_source, str) or not evaluator_source.strip():
+        evaluator_source = supply_chain_dict.get("decision_source")
+    if not isinstance(evaluator_source, str) or not evaluator_source.strip():
+        evaluator_source = verdict_dict.get("source")
+    if not isinstance(evaluator_source, str) or not evaluator_source.strip():
+        evaluator_source = "local-heuristic"
     return {
         "evaluator_invoked": "supply_chain_evaluation" in payload or "verdict" in payload,
+        "evaluator_source": evaluator_source,
         "protect_decision": verdict_dict.get("action"),
         "evidence_ids": normalized_evidence_ids,
         "dry_run": payload.get("dry_run"),

{plugin_scanner-2.0.563 → plugin_scanner-2.0.565}/src/codex_plugin_scanner/guard/shims.py

@@ -21,6 +21,7 @@ from .shim_probe import (
     parse_protect_json_stdout,
     protect_evaluator_evidence,
 )
+from .stable_digest import stable_digest_hex
 
 if TYPE_CHECKING:
     from .adapters.base import HarnessContext
@@ -950,9 +951,14 @@ def probe_package_shim_intercepts(
             continue
         protect_payload = parse_protect_json_stdout(result.stdout)
         evaluator_evidence = protect_evaluator_evidence(protect_payload)
+        command_hash = stable_digest_hex(
+            json.dumps([manager, *probe_args]).encode("utf-8"),
+        )
         manager_results.append(
             {
+                "command_hash": command_hash,
                 "evaluator_invoked": evaluator_evidence["evaluator_invoked"],
+                "evaluator_source": evaluator_evidence["evaluator_source"],
                 "evidence_ids": evaluator_evidence["evidence_ids"],
                 "intercept_ran": bool(evaluator_evidence["evaluator_invoked"]),
                 "manager": manager,

{plugin_scanner-2.0.563 → plugin_scanner-2.0.565}/src/codex_plugin_scanner/version.py

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

plugin_scanner-2.0.565/tests/test_guard_phase11_package_firewall_receipts.py

@@ -0,0 +1,139 @@
+"""Phase 11 package firewall receipt proofs (SCSR181-183)."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+from codex_plugin_scanner.guard.local_supply_chain import audit_receipt_metadata
+from codex_plugin_scanner.guard.package_firewall_receipts import package_firewall_receipt_metadata
+from codex_plugin_scanner.guard.shims import install_package_shims, probe_package_shim_intercepts
+from codex_plugin_scanner.guard.shim_probe import protect_evaluator_evidence
+from codex_plugin_scanner.guard.stable_digest import stable_digest_hex
+from tests.shim_execution_helpers import write_fake_manager_script
+
+
+def _harness_context(tmp_path: Path) -> MagicMock:
+    home_dir = tmp_path / "home"
+    home_dir.mkdir(parents=True, exist_ok=True)
+    guard_home = tmp_path / "guard-home"
+    guard_home.mkdir(parents=True, exist_ok=True)
+    workspace_dir = tmp_path / "workspace"
+    workspace_dir.mkdir(parents=True, exist_ok=True)
+    context = MagicMock()
+    context.home_dir = home_dir
+    context.workspace_dir = workspace_dir
+    context.guard_home = guard_home
+    return context
+
+
+def test_protect_evaluator_evidence_includes_evaluator_source() -> None:
+    evidence = protect_evaluator_evidence(
+        {
+            "supply_chain_evaluation": {"source": "guard-cloud", "evidence_ids": ["ev-1"]},
+            "verdict": {"action": "allow"},
+        },
+    )
+    assert evidence["evaluator_source"] == "guard-cloud"
+
+
+def test_package_firewall_receipt_metadata_records_audit_manager_subset_from_posture() -> None:
+    metadata = package_firewall_receipt_metadata(
+        operation="audit",
+        result={
+            "manifest_paths": ["package.json"],
+            "lockfile_paths": ["package-lock.json"],
+            "inventory": {"total_packages": 1},
+            "evaluation": {"decision": "monitor", "packages": []},
+            "supply_chain": {
+                "package_manager_protection": {
+                    "installed_managers": ["npm", "pnpm"],
+                },
+            },
+        },
+    )
+    evidence = metadata["scanner_evidence"]
+    assert isinstance(evidence, dict)
+    assert evidence["manager_subset"] == ["npm", "pnpm"]
+
+
+def test_package_firewall_receipt_metadata_records_manager_subset_for_test() -> None:
+    metadata = package_firewall_receipt_metadata(
+        operation="test",
+        managers=("npm", "pnpm"),
+        result={
+            "tested_managers": ["npm", "pnpm"],
+            "intercept_proved": True,
+            "manager_results": [
+                {
+                    "manager": "npm",
+                    "command_hash": "abc123",
+                    "evaluator_source": "guard-cloud",
+                    "evaluator_invoked": True,
+                },
+            ],
+        },
+    )
+    evidence = metadata["scanner_evidence"]
+    assert isinstance(evidence, dict)
+    assert evidence["operation"] == "test"
+    assert evidence["manager_subset"] == ["npm", "pnpm"]
+    intercept_proofs = evidence["intercept_proofs"]
+    assert isinstance(intercept_proofs, list)
+    assert intercept_proofs[0]["command_hash"] == "abc123"
+    assert intercept_proofs[0]["evaluator_source"] == "guard-cloud"
+
+
+def test_audit_receipt_metadata_includes_manifest_and_lockfile_hashes(tmp_path: Path) -> None:
+    workspace_dir = tmp_path / "workspace"
+    workspace_dir.mkdir()
+    manifest_path = workspace_dir / "package.json"
+    lockfile_path = workspace_dir / "package-lock.json"
+    manifest_path.write_text('{"name":"demo"}', encoding="utf-8")
+    lockfile_path.write_text('{"lockfileVersion":1}', encoding="utf-8")
+    manifest_hash = stable_digest_hex(manifest_path.read_bytes())
+    lockfile_hash = stable_digest_hex(lockfile_path.read_bytes())
+
+    metadata = audit_receipt_metadata(
+        {
+            "manifest_paths": ["package.json"],
+            "lockfile_paths": ["package-lock.json"],
+            "inventory": {"total_packages": 1},
+            "evaluation": {"decision": "monitor", "packages": []},
+        },
+        workspace_dir=workspace_dir,
+    )
+    evidence = metadata["scanner_evidence"]
+    assert isinstance(evidence, dict)
+    assert evidence["manifest_hashes"] == [manifest_hash]
+    assert evidence["lockfile_hashes"] == [lockfile_hash]
+
+
+def test_probe_package_shim_intercepts_records_command_hash_and_evaluator_source(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    context = _harness_context(tmp_path)
+    install_package_shims(context, managers=("npm",))
+    shim_dir = context.guard_home / "package-shims" / "bin"
+    fake_bin = tmp_path / "fake-bin"
+    fake_bin.mkdir(parents=True)
+    write_fake_manager_script(
+        fake_bin=fake_bin,
+        manager="npm",
+        marker_path=tmp_path / "npm-probe-marker.json",
+        exit_code=0,
+    )
+    monkeypatch.setenv("PATH", os.pathsep.join([str(shim_dir), str(fake_bin)]))
+
+    result = probe_package_shim_intercepts(context, managers=("npm",), workspace_dir=context.workspace_dir)
+    manager_results = result["manager_results"]
+    assert isinstance(manager_results, list)
+    assert manager_results
+    npm_result = manager_results[0]
+    assert isinstance(npm_result.get("command_hash"), str)
+    assert npm_result["command_hash"]
+    assert isinstance(npm_result.get("evaluator_source"), str)

plugin_scanner-2.0.563/docs/guard/local-vs-cloud.md

@@ -1,39 +0,0 @@
-# Works Locally First
-
-Guard works on your machine before you sign in anywhere.
-
-Local features available without sign-in:
-
-- harness discovery
-- artifact snapshots
-- local diffs
-- local policy decisions
-- wrapper-mode launch enforcement
-- local receipts and explain output
-- local policy overrides from home or workspace config
-
-Guard does not meter local safety features. You can detect harnesses, install launchers, diff changes, prompt for approval, and inspect receipts without signing in.
-
-Safe Decode runs locally too. It inspects encoded payload layers for review evidence, but never executes decoded payloads and only syncs redacted summaries when optional cloud receipt sync is enabled.
-
-Optional cloud features:
-
-- receipt sync to an optional Guard endpoint
-- trust enrichment
-- revocation feeds
-- billing and entitlements
-- shared team policy
-
-The local runtime does not require any hosted service. `hol-guard connect` is the canonical way to pair a machine with Guard Cloud later, and `hol-guard connect --headless` uses OAuth Device Code for SSH/CI hosts. `hol-guard login` remains only as a redirecting compatibility alias. These commands do not unlock the core safety workflow.
-
-Use these commands when you need to check or repair optional cloud pairing without disturbing local protection:
-
-```bash
-hol-guard connect status
-hol-guard connect repair
-hol-guard sync
-hol-guard supply-chain sync
-hol-guard supply-chain scan
-hol-guard supply-chain explain minimist@1.2.5 --ecosystem npm
-hol-guard explain install-connect
-```