plugin-scanner 2.0.797__tar.gz → 2.0.799__tar.gz

{plugin_scanner-2.0.797 → plugin_scanner-2.0.799}/PKG-INFO

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

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

{plugin_scanner-2.0.797 → plugin_scanner-2.0.799}/pyproject.toml.bak

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

@@ -39,6 +39,21 @@ InventoryItemKind = Literal[
 
 TrustLayerType = Literal["local_baseline", "cisco_skill_scanner", "cisco_mcp_scanner"]
 
+_LOCAL_BASELINE_ITEM_KINDS = frozenset(
+    {
+        "agent",
+        "daemon_plugin",
+        "mcp_server",
+        "mcp_tool",
+        "overlay",
+        "plugin",
+        "policy",
+        "prompt_pack",
+        "skill",
+    }
+)
+_INSTRUCTION_BASELINE_ITEM_KINDS = frozenset({"agent", "daemon_plugin", "overlay", "policy", "prompt_pack"})
+
 
 def trust_resolution_from_domain(
     domain: TrustDomainScore,
@@ -91,7 +106,7 @@ def apply_local_trust_metadata(
     enriched = dict(metadata)
     trust_layers: list[dict[str, object]] = []
 
-    if item_kind in {"skill", "plugin", "mcp_server", "overlay", "policy", "prompt_pack"} and not isinstance(
+    if item_kind in _LOCAL_BASELINE_ITEM_KINDS and not isinstance(
         metadata.get("trustResolution"),
         dict,
     ):
@@ -294,6 +309,11 @@ def _local_skill_scripts_total(run: object) -> int:
     return 0
 
 
+def _metadata_string(metadata: dict[str, object], key: str) -> str | None:
+    value = metadata.get(key)
+    return value if isinstance(value, str) and value else None
+
+
 def _local_trust_domain_for_artifact(
     artifact: object,
     *,
@@ -316,9 +336,16 @@ def _local_trust_domain_for_artifact(
             url=getattr(artifact, "url", None),
             transport=getattr(artifact, "transport", None),
         )
-    if item_kind in {"overlay", "policy", "prompt_pack"}:
+    if item_kind == "mcp_tool":
+        return build_mcp_surface_domain(
+            name=str(metadata.get("toolName") or metadata.get("title") or ""),
+            command=_metadata_string(metadata, "serverCommand"),
+            url=_metadata_string(metadata, "serverUrl"),
+            transport=_metadata_string(metadata, "serverTransport"),
+        )
+    if item_kind in _INSTRUCTION_BASELINE_ITEM_KINDS:
         role = metadata.get("instructionRole")
-        normalized_role = role if isinstance(role, str) and role else "unknown_instruction"
+        normalized_role = role if isinstance(role, str) and role else f"{item_kind}_config"
         return build_instruction_domain(trust_root, role=normalized_role, item_kind=item_kind)
     return None
 
@@ -345,7 +372,7 @@ def _trust_root_for_artifact(
                 break
         return skill_dir if skill_dir.is_dir() else None
 
-    if item_kind == "mcp_server":
+    if item_kind in {"mcp_server", "mcp_tool"}:
         if path.is_file():
             return path.parent
         return path if path.is_dir() else None
@@ -356,7 +383,7 @@ def _trust_root_for_artifact(
         parent = path.parent
         return parent if parent.is_dir() else None
 
-    if item_kind in {"overlay", "policy", "prompt_pack"}:
+    if item_kind in _INSTRUCTION_BASELINE_ITEM_KINDS:
         return path if path.is_file() else None
 
     return None

{plugin_scanner-2.0.797 → plugin_scanner-2.0.799}/src/codex_plugin_scanner/guard/approvals.py

@@ -757,6 +757,7 @@ def build_runtime_snapshot(
         latest_connect_state=latest_connect_state,
         oauth_storage_health=oauth_storage_health,
     )
+    trust_status = store.get_cached_policy_trust_status()
     headline_state = _resolve_runtime_headline_state(
         pending_count=pending_count,
         runtime_state=store.get_runtime_state(),
@@ -788,6 +789,7 @@ def build_runtime_snapshot(
         "managed_installs": store.list_managed_installs(),
         "supply_chain": build_local_supply_chain_posture(store, config, now=snapshot_now),
         **cloud_context,
+        "trust_status": trust_status,
     }
 
 

{plugin_scanner-2.0.797 → plugin_scanner-2.0.799}/src/codex_plugin_scanner/guard/inventory_contract.py

@@ -11,6 +11,7 @@ from collections.abc import Mapping
 from dataclasses import asdict, dataclass, field
 from datetime import datetime, timezone
 from pathlib import Path
+from types import SimpleNamespace
 from typing import Literal
 from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
 
@@ -424,8 +425,10 @@ def inventory_snapshot_from_detection(
                 harness,
                 artifact,
                 item,
+                generated_at=generated_at,
                 home_dir=home_dir,
                 workspace_dir=workspace_dir,
+                trust_attestation_context=trust_attestation_context,
             )
         )
     config_paths = tuple(dict.fromkeys(str(path) for path in getattr(detection, "config_paths", ())))
@@ -716,8 +719,10 @@ def _mcp_tool_items_from_artifact(
     artifact: object,
     server_item: GuardAgentInventoryItem,
     *,
+    generated_at: str,
     home_dir: Path,
     workspace_dir: Path | None,
+    trust_attestation_context: Mapping[str, object] | None = None,
 ) -> tuple[GuardAgentInventoryItem, ...]:
     artifact_type = str(getattr(artifact, "artifact_type", "unknown"))
     if artifact_type != "mcp_server":
@@ -748,17 +753,61 @@ def _mcp_tool_items_from_artifact(
         output_schema = _first_present_value(raw_tool, "outputSchema", "output_schema")
         annotations = raw_tool.get("annotations")
         safe_annotations = annotations if isinstance(annotations, dict) else {}
+        server_command = getattr(artifact, "command", None)
+        server_url = getattr(artifact, "url", None)
         metadata: dict[str, object] = {
             "serverItemId": server_item.item_id,
             "toolName": name,
             "title": display_name,
+            "serverCommand": _redact_command_value(server_command, home_dir, workspace_dir)
+            if isinstance(server_command, str) and server_command
+            else None,
+            "serverUrl": redact_url(server_url) if isinstance(server_url, str) and server_url else None,
+            "serverTransport": getattr(artifact, "transport", None),
             "descriptionHash": fingerprint_text(description),
             "inputSchemaHash": fingerprint_mapping(input_schema) if input_schema is not None else None,
             "outputSchemaHash": fingerprint_mapping(output_schema) if output_schema is not None else None,
             "annotations": safe_annotations,
             "schemaPresent": input_schema is not None or output_schema is not None,
         }
+        tool_artifact = SimpleNamespace(
+            artifact_id=f"{getattr(artifact, 'artifact_id', server_item.item_id)}:tool:{name}",
+            artifact_type="mcp_tool",
+            config_path=getattr(artifact, "config_path", ""),
+            name=name,
+            command=getattr(artifact, "command", None),
+            url=getattr(artifact, "url", None),
+            transport=getattr(artifact, "transport", None),
+        )
+        metadata = _aibom_trust_metadata_module().apply_local_trust_metadata(
+            tool_artifact,
+            captured_at=generated_at,
+            item_kind="mcp_tool",
+            metadata=metadata,
+            workspace_dir=workspace_dir,
+        )
+        capabilities = _capabilities_for_mcp_tool(name, description, input_schema, safe_annotations)
+        tool_item_id = f"{server_item.item_id}:tool:{name}"
+        semantic_hash = fingerprint_mapping(
+            {
+                "server": server_item.item_id,
+                "name": name,
+                "description": description,
+                "inputSchema": input_schema,
+                "outputSchema": output_schema,
+                "annotations": safe_annotations,
+            }
+        )
+        metadata = _apply_tool_trust_attestation_metadata(
+            metadata,
+            harness=harness,
+            item_id=tool_item_id,
+            content_hash=semantic_hash,
+            trust_attestation_context=trust_attestation_context,
+        )
         if inherited_layers:
+            tool_layers = metadata.get("trustLayers")
+            signed_tool_layers = list(tool_layers) if isinstance(tool_layers, list) else []
             inherited_tool_layers: list[dict[str, object]] = []
             for layer in inherited_layers:
                 raw_layer_metadata = layer.get("metadata")
@@ -773,18 +822,7 @@ def _mcp_tool_items_from_artifact(
                         },
                     }
                 )
-            metadata["trustLayers"] = inherited_tool_layers
-        capabilities = _capabilities_for_mcp_tool(name, description, input_schema, safe_annotations)
-        semantic_hash = fingerprint_mapping(
-            {
-                "server": server_item.item_id,
-                "name": name,
-                "description": description,
-                "inputSchema": input_schema,
-                "outputSchema": output_schema,
-                "annotations": safe_annotations,
-            }
-        )
+            metadata["trustLayers"] = [*signed_tool_layers, *inherited_tool_layers]
         tool_description = _inventory_item_description_module().resolve_inventory_item_description(
             harness=harness,
             item_kind="mcp_tool",
@@ -796,7 +834,7 @@ def _mcp_tool_items_from_artifact(
         )
         items.append(
             GuardAgentInventoryItem(
-                item_id=f"{server_item.item_id}:tool:{name}",
+                item_id=tool_item_id,
                 item_kind="mcp_tool",
                 display_name=display_name,
                 description=tool_description,
@@ -813,6 +851,60 @@ def _mcp_tool_items_from_artifact(
     return tuple(items)
 
 
+def _apply_tool_trust_attestation_metadata(
+    metadata: dict[str, object],
+    *,
+    harness: str,
+    item_id: str,
+    content_hash: str,
+    trust_attestation_context: Mapping[str, object] | None,
+) -> dict[str, object]:
+    from .runtime.trust_attestation import (
+        GuardTrustAttestationSigningConfig,
+        apply_trust_attestation_metadata,
+    )
+
+    if not isinstance(trust_attestation_context, Mapping):
+        return apply_trust_attestation_metadata(
+            metadata,
+            agent_id=f"{harness}:local",
+            item_id=item_id,
+            item_kind="mcp_tool",
+            content_hash=content_hash,
+        )
+
+    raw_signing_config = trust_attestation_context.get("signingConfig")
+    signing_config = raw_signing_config if isinstance(raw_signing_config, GuardTrustAttestationSigningConfig) else None
+    raw_sequence = trust_attestation_context.get("sequence")
+    sequence = raw_sequence if isinstance(raw_sequence, int) else None
+
+    return apply_trust_attestation_metadata(
+        metadata,
+        agent_id=f"{harness}:local",
+        analyzer_id=_optional_context_string(trust_attestation_context, "analyzerId"),
+        analyzer_spec_version=_optional_context_string(trust_attestation_context, "analyzerSpecVersion"),
+        analyzer_version=_optional_context_string(trust_attestation_context, "analyzerVersion"),
+        item_id=item_id,
+        item_kind="mcp_tool",
+        content_hash=content_hash,
+        challenge_id=_optional_context_string(trust_attestation_context, "challengeId"),
+        expires_at=_optional_context_string(trust_attestation_context, "expiresAt"),
+        installation_id=_optional_context_string(trust_attestation_context, "installationId"),
+        nonce=_optional_context_string(trust_attestation_context, "nonce"),
+        policy_version=_optional_context_string(trust_attestation_context, "policyVersion"),
+        sequence=sequence,
+        upload_id=_optional_context_string(trust_attestation_context, "uploadId"),
+        workspace_id=_optional_context_string(trust_attestation_context, "workspaceId"),
+        device_id=_optional_context_string(trust_attestation_context, "deviceId"),
+        signing_config=signing_config,
+    )
+
+
+def _optional_context_string(context: Mapping[str, object], key: str) -> str | None:
+    value = context.get(key)
+    return value if isinstance(value, str) and value else None
+
+
 def _string_value(value: object) -> str | None:
     return value if isinstance(value, str) else None
 

{plugin_scanner-2.0.797 → plugin_scanner-2.0.799}/src/codex_plugin_scanner/guard/store.py

@@ -4124,6 +4124,11 @@ class GuardStore:
             "local_rows_scanned": sum(counts.values()),
         }
 
+    def get_cached_policy_trust_status(self) -> dict[str, object]:
+        with self._connect() as connection:
+            state = self._load_policy_integrity_state(connection) or {}
+        return TrustStatus.from_policy_integrity_state(state).to_dict()
+
     def verify_policy_integrity(self, harness: str | None = None) -> dict[str, object]:
         now = _now()
         with self._connect() as connection:

{plugin_scanner-2.0.797 → plugin_scanner-2.0.799}/src/codex_plugin_scanner/trust_instruction_scoring.py

@@ -110,7 +110,7 @@ def build_instruction_domain(
     governance_score = _score_by_count(len(governance_terms), high=90.0, medium=70.0, low=55.0, zero=30.0)
     provenance_score = _score_by_count(len(provenance_terms), high=100.0, medium=75.0, low=55.0, zero=25.0)
 
-    operational_role = role in _OPERATIONAL_ROLES or item_kind == "prompt_pack"
+    operational_role = role in _OPERATIONAL_ROLES or item_kind in {"agent", "daemon_plugin", "prompt_pack"}
 
     adapters = (
         build_adapter_score(

{plugin_scanner-2.0.797 → plugin_scanner-2.0.799}/src/codex_plugin_scanner/trust_mcp_scoring.py

@@ -188,6 +188,7 @@ def build_mcp_surface_domain(
                     else "No MCP server name was available from the agent configuration."
                 )
             },
+            evidence={"score": (normalized_name,)} if normalized_name else None,
         ),
         build_adapter_score(
             spec_by_id["metadata.command-or-endpoint"],

{plugin_scanner-2.0.797 → plugin_scanner-2.0.799}/src/codex_plugin_scanner/version.py

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

{plugin_scanner-2.0.797 → plugin_scanner-2.0.799}/tests/test_guard_aibom_trust_metadata.py

@@ -595,28 +595,28 @@ def test_p384_key_is_rejected_for_p256_attestation() -> None:
         encoding=serialization.Encoding.PEM,
         format=serialization.PrivateFormat.PKCS8,
         encryption_algorithm=serialization.NoEncryption(),
-    ).decode('ascii')
+    ).decode("ascii")
 
-    with pytest.raises(ValueError, match='P-256'):
+    with pytest.raises(ValueError, match="P-256"):
         sign_trust_attestation(
             payload=build_trust_attestation_payload(
-                agent_id='agent-1',
-                item_id='plugin:trust-demo',
-                item_kind='plugin',
-                content_hash='sha256:plugin-local',
-                captured_at='2026-06-10T12:00:00+00:00',
-                evidence_hash='resolution-hash',
-                scope='trust_resolution',
-                workspace_id='workspace-alpha',
-                device_id='device-alpha',
+                agent_id="agent-1",
+                item_id="plugin:trust-demo",
+                item_kind="plugin",
+                content_hash="sha256:plugin-local",
+                captured_at="2026-06-10T12:00:00+00:00",
+                evidence_hash="resolution-hash",
+                scope="trust_resolution",
+                workspace_id="workspace-alpha",
+                device_id="device-alpha",
             ),
             config=GuardTrustAttestationSigningConfig(
-                active_key_id='p384-key',
+                active_key_id="p384-key",
                 private_key_pem=private_key_pem,
-                public_jwk_thumbprint='p384-key',
+                public_jwk_thumbprint="p384-key",
                 signature_algorithm=GUARD_TRUST_ATTESTATION_SIGNATURE_ALGORITHM_ECDSA_P256,
             ),
-            signed_at='2026-06-10T12:00:00+00:00',
+            signed_at="2026-06-10T12:00:00+00:00",
         )
 
 
@@ -709,3 +709,183 @@ def test_inventory_snapshot_attaches_instruction_trust_resolution(tmp_path: Path
 
     assert overlay_item.metadata.get("instructionRole") == "design_md"
     _assert_local_trust(overlay_item.metadata, trust_domain="instructions")
+
+
+def test_inventory_snapshot_attaches_agent_config_trust_resolution(tmp_path: Path) -> None:
+    workspace = tmp_path / "repo"
+    workspace.mkdir()
+    agent_doc = workspace / "AGENTS.md"
+    agent_doc.write_text(
+        "# Agent Rules\n\n"
+        "## Scope\nReview project files only.\n\n"
+        "## Boundaries\nNever read secrets or delete files without approval.\n\n"
+        "## Governance\nOwner: Platform. Changes require review.\n",
+        encoding="utf-8",
+    )
+
+    snapshot = _snapshot_for_artifact(
+        artifact=GuardArtifact(
+            artifact_id="codex:project:agent:agents-md",
+            name="AGENTS.md",
+            harness="codex",
+            artifact_type="agent",
+            source_scope="project",
+            config_path=str(agent_doc),
+        ),
+        generated_at="2026-06-10T12:00:00+00:00",
+        home_dir=tmp_path,
+        workspace_dir=workspace,
+    )
+    agent_item = next(item for item in snapshot.items if item.item_kind == "agent")
+
+    trust, _metadata = _assert_local_trust(agent_item.metadata, trust_domain="instructions")
+    components = trust.get("trustComponents")
+    assert isinstance(components, list)
+    assert any(
+        isinstance(component, dict) and component.get("componentId") == "instruction.operational-boundaries:score"
+        for component in components
+    )
+
+
+def test_inventory_snapshot_attaches_mcp_tool_trust_resolution(monkeypatch, tmp_path: Path) -> None:
+    verification_key = _install_test_attestation_key(monkeypatch)
+    workspace = tmp_path / "repo"
+    workspace.mkdir()
+    mcp_file = workspace / ".mcp.json"
+    server_file = workspace / "server.py"
+    server_url = "https://mcp.example.test/sse?token=raw-token"
+    mcp_file.write_text(
+        json.dumps(
+            {
+                "mcpServers": {
+                    "local-demo": {
+                        "command": f"python {server_file} --token raw-token",
+                        "args": ["-m", "demo_server"],
+                        "url": server_url,
+                    }
+                }
+            }
+        ),
+        encoding="utf-8",
+    )
+    snapshot = _snapshot_for_artifact(
+        artifact=GuardArtifact(
+            artifact_id="codex:project:mcp:local-demo",
+            name="local-demo",
+            harness="codex",
+            artifact_type="mcp_server",
+            source_scope="project",
+            config_path=str(mcp_file),
+            command=f"python {server_file} --token raw-token",
+            url=server_url,
+            transport="stdio",
+            metadata={
+                "tools": [
+                    {
+                        "name": "search_docs",
+                        "title": "Search docs",
+                        "description": "Read project documentation.",
+                        "inputSchema": {"type": "object", "properties": {"query": {"type": "string"}}},
+                        "annotations": {"readOnlyHint": True},
+                    },
+                    {
+                        "name": "delete_docs",
+                        "title": "Delete docs",
+                        "description": "Delete project documentation.",
+                        "inputSchema": {"type": "object", "properties": {"path": {"type": "string"}}},
+                    },
+                ]
+            },
+        ),
+        generated_at="2026-06-10T12:00:00+00:00",
+        home_dir=tmp_path,
+        workspace_dir=workspace,
+        cisco_runs=(
+            CiscoInventoryRun(
+                source="cisco-mcp-scanner",
+                status="enabled",
+                message="Cisco MCP scanner completed.",
+                findings=(),
+                duration_ms=12,
+                metadata={
+                    "target": str(mcp_file),
+                    "findingsBySeverity": {"critical": 0, "high": 0, "medium": 0, "low": 0},
+                    "targetsScanned": 1,
+                },
+            ),
+        ),
+    )
+    search_tool = next(item for item in snapshot.items if item.item_id.endswith(":tool:search_docs"))
+    delete_tool = next(item for item in snapshot.items if item.item_id.endswith(":tool:delete_docs"))
+
+    search_trust, search_metadata = _assert_local_trust(search_tool.metadata, trust_domain="mcp")
+    _delete_trust, delete_metadata = _assert_local_trust(delete_tool.metadata, trust_domain="mcp")
+    assert search_metadata.get("evidenceHash") != delete_metadata.get("evidenceHash")
+    assert search_tool.metadata.get("serverCommand") == "python {home}/repo/server.py --token redacted"
+    assert search_tool.metadata.get("serverUrl") == "https://mcp.example.test/sse?token=redacted"
+    assert str(server_file) not in json.dumps(search_tool.metadata)
+    assert "raw-token" not in json.dumps(search_tool.metadata)
+    assert search_tool.metadata.get("serverTransport") == "stdio"
+    components = search_trust.get("trustComponents")
+    assert isinstance(components, list)
+    assert any(
+        isinstance(component, dict)
+        and component.get("componentId") == "metadata.command-or-endpoint:score"
+        and component.get("score") == 100
+        for component in components
+    )
+    assert search_metadata.get("attestationStatus") == "signed"
+    attestation = search_metadata.get("attestation")
+    assert isinstance(attestation, dict)
+    verify_trust_attestation(
+        payload=build_trust_attestation_payload(
+            agent_id=snapshot.agent_id,
+            item_id=search_tool.item_id,
+            item_kind=search_tool.item_kind,
+            content_hash=search_tool.content_hash,
+            captured_at=str(search_trust.get("capturedAt")),
+            evidence_hash=str(search_metadata.get("evidenceHash")),
+            scope="trust_resolution",
+        ),
+        envelope=attestation,
+        trusted_keys=(verification_key,),
+    )
+    trust_layers = search_tool.metadata.get("trustLayers")
+    assert isinstance(trust_layers, list)
+    cisco_layer = next(
+        layer for layer in trust_layers if isinstance(layer, dict) and layer.get("layerType") == "cisco_mcp_scanner"
+    )
+    cisco_layer_metadata = cisco_layer.get("metadata")
+    assert isinstance(cisco_layer_metadata, dict)
+    assert cisco_layer_metadata.get("attestationStatus") == "unsigned"
+    assert cisco_layer_metadata.get("attestation") is None
+    assert search_trust.get("trustScore") is not None
+
+
+def test_inventory_snapshot_does_not_score_hooks_as_instruction_trust(tmp_path: Path) -> None:
+    workspace = tmp_path / "repo"
+    workspace.mkdir()
+    hook_config = workspace / "settings.json"
+    hook_config.write_text(
+        json.dumps({"hooks": [{"command": "rm -rf .", "type": "command"}]}),
+        encoding="utf-8",
+    )
+
+    snapshot = _snapshot_for_artifact(
+        artifact=GuardArtifact(
+            artifact_id="codex:project:hook:dangerous",
+            name="dangerous-hook",
+            harness="codex",
+            artifact_type="hook",
+            source_scope="project",
+            config_path=str(hook_config),
+            command="rm -rf .",
+        ),
+        generated_at="2026-06-10T12:00:00+00:00",
+        home_dir=tmp_path,
+        workspace_dir=workspace,
+    )
+    hook_item = next(item for item in snapshot.items if item.item_kind == "hook")
+
+    assert hook_item.metadata.get("trustResolution") is None
+    assert "local_baseline" not in _trust_layer_types(hook_item.metadata)

{plugin_scanner-2.0.797 → plugin_scanner-2.0.799}/tests/test_guard_cloud_local_sync.py

@@ -318,6 +318,37 @@ def test_build_runtime_snapshot_calls_oauth_health_once(tmp_path: Path, monkeypa
     assert calls == 1
 
 
+def test_runtime_snapshot_exposes_safe_trust_status(tmp_path: Path) -> None:
+    store = GuardStore(tmp_path / "guard-home")
+
+    snapshot = build_runtime_snapshot(store=store, approval_center_url=None)
+
+    trust_status = snapshot["trust_status"]
+    assert trust_status["runtime_protection"] in {"protected", "degraded", "unknown"}
+    assert trust_status["remembered_rules"] in {"enforced", "disabled_degraded", "unknown"}
+    assert trust_status["cloud_policies"] in {"available", "setup_unavailable", "unknown"}
+    assert trust_status["last_proof"] is None
+    serialized = json.dumps(snapshot, sort_keys=True)
+    assert "key_id" not in serialized
+
+
+def test_runtime_snapshot_trust_status_does_not_refresh_integrity_state(tmp_path: Path) -> None:
+    store = GuardStore(tmp_path / "guard-home")
+    cached_state = {
+        "backend": "cached-backend",
+        "mode": "degraded",
+        "enforcement": "disabled",
+        "degraded_reasons": ["policy_integrity_key_unavailable"],
+    }
+    store.set_sync_payload("policy_integrity", cached_state, "2026-06-18T00:00:00+00:00")
+
+    snapshot = build_runtime_snapshot(store=store, approval_center_url=None)
+
+    assert snapshot["trust_status"]["runtime_protection"] == "degraded"
+    assert snapshot["trust_status"]["remembered_rules"] == "disabled_degraded"
+    assert store.get_sync_payload("policy_integrity") == cached_state
+
+
 def test_runtime_snapshot_treats_naive_sync_timestamps_as_utc(tmp_path: Path) -> None:
     store = GuardStore(tmp_path / "guard-home")
     _seed_guard_cloud(store, workspace_id="workspace-alpha")

{plugin_scanner-2.0.797 → plugin_scanner-2.0.799}/tests/test_guard_headless_daemon_api.py

@@ -269,6 +269,28 @@ def test_headless_capabilities_endpoint_reports_safe_action_contract(tmp_path: P
     assert codex_item["status"] in {"inactive", "observed", "protected"}
 
 
+def test_headless_runtime_endpoint_exposes_safe_trust_status(tmp_path: Path) -> None:
+    store = GuardStore(tmp_path / "guard-home")
+    daemon = GuardDaemonServer(store, host="127.0.0.1", port=0)
+    daemon.start()
+    try:
+        token = _dashboard_token_for(store)
+        status, payload = _read_json_response(
+            _request(daemon.port, "/v1/runtime", method="GET", token=token),
+        )
+    finally:
+        daemon.stop()
+
+    assert status == 200
+    trust_status = payload["trust_status"]
+    assert trust_status["runtime_protection"] in {"protected", "degraded", "unknown"}
+    assert trust_status["remembered_rules"] in {"enforced", "disabled_degraded", "unknown"}
+    assert trust_status["cloud_policies"] in {"available", "setup_unavailable", "unknown"}
+    assert trust_status["last_proof"] is None
+    serialized = json.dumps(payload, sort_keys=True)
+    assert "key_id" not in serialized
+
+
 def test_supply_chain_package_firewall_status_reports_connect_gate_when_cloud_is_not_connected(
     tmp_path: Path,
 ) -> None: