plugin-scanner 2.0.1016__tar.gz → 2.0.1017__tar.gz

{plugin_scanner-2.0.1016 → plugin_scanner-2.0.1017}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.1016
+Version: 2.0.1017
 Summary: Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi.
 Project-URL: Homepage, https://github.com/hashgraph-online/hol-guard
 Project-URL: Repository, https://github.com/hashgraph-online/hol-guard

{plugin_scanner-2.0.1016 → plugin_scanner-2.0.1017}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "plugin-scanner"
-version = "2.0.1016"
+version = "2.0.1017"
 description = "Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi."
 readme = "README.md"
 license = "Apache-2.0"

{plugin_scanner-2.0.1016 → plugin_scanner-2.0.1017}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.1016"
+version = "2.0.1017"
 description = "Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi."
 readme = "README.md"
 license = "Apache-2.0"

{plugin_scanner-2.0.1016 → plugin_scanner-2.0.1017}/src/codex_plugin_scanner/guard/adapters/hermes.py

@@ -463,7 +463,7 @@ class HermesHarnessAdapter(HarnessAdapter):
                     if isinstance(hermes_related, str):
                         related = hermes_related
 
-        content_hash = _content_hash(content)
+        content_hash = _primary_content_hash(skill_md, fallback_content=content)
         env_mentions = _extract_env_mentions(content)
 
         metadata: dict[str, object] = {
@@ -868,6 +868,18 @@ def _content_hash(content: str) -> str:
     return hashlib.sha256(content.encode("utf-8")).hexdigest()[:16]
 
 
+def _primary_content_hash(path: Path, *, fallback_content: str) -> str:
+    """Hash the exact primary artifact body using the cloud content format."""
+    digest = hashlib.sha256()
+    try:
+        with path.open("rb") as handle:
+            while chunk := handle.read(64 * 1024):
+                digest.update(chunk)
+    except OSError:
+        digest = hashlib.sha256(fallback_content.encode("utf-8"))
+    return f"sha256:{digest.hexdigest()}"
+
+
 def _safe_read(path: Path) -> str:
     """Read file content with error handling and size enforcement.
 

{plugin_scanner-2.0.1016 → plugin_scanner-2.0.1017}/src/codex_plugin_scanner/guard/aibom_cli.py

@@ -16,10 +16,18 @@ from typing import Any, Literal
 
 from ..version import __version__
 from .adapters.base import HarnessContext
+from .aibom_content_upload import (
+    GuardAibomPrimaryContentSource,
+    empty_content_upload_summary,
+    merge_content_upload_summary,
+    primary_content_sources_from_artifacts,
+    upload_primary_content_sources,
+)
 from .aibom_trust_metadata import apply_local_trust_metadata
 from .inventory_cisco import run_cisco_inventory_scans
 from .inventory_contract import (
     GuardAgentInventorySnapshot,
+    cloud_inventory_artifacts_from_detection,
     extract_aibom_metadata_extensions,
     inventory_snapshot_from_detection,
     redact_local_path,
@@ -60,6 +68,7 @@ def collect_aibom_snapshots(
     generated_at: str,
     options: AibomCliOptions | None = None,
     trust_attestation_context: dict[str, object] | None = None,
+    primary_content_sources: list[GuardAibomPrimaryContentSource] | None = None,
 ) -> tuple[GuardAgentInventorySnapshot, ...]:
     resolved = options or AibomCliOptions()
     snapshots: list[GuardAgentInventorySnapshot] = []
@@ -81,18 +90,31 @@ def collect_aibom_snapshots(
                 remaining_cisco_timeout_seconds - max(time.monotonic() - cisco_started, 0.0),
                 0.0,
             )
-        snapshots.append(
-            inventory_snapshot_from_detection(
-                detection,
-                generated_at=generated_at,
-                home_dir=context.home_dir,
-                workspace_dir=context.workspace_dir,
-                cisco_runs=cisco_runs,
-                include_symlinks=resolved.include_symlinks,
-                follow_unsafe_symlinks=resolved.follow_unsafe_symlinks,
-                trust_attestation_context=trust_attestation_context,
-            )
+        artifacts = cloud_inventory_artifacts_from_detection(
+            detection,
+            home_dir=context.home_dir,
+            workspace_dir=context.workspace_dir,
+        )
+        snapshot = inventory_snapshot_from_detection(
+            detection,
+            generated_at=generated_at,
+            home_dir=context.home_dir,
+            workspace_dir=context.workspace_dir,
+            cisco_runs=cisco_runs,
+            include_symlinks=resolved.include_symlinks,
+            follow_unsafe_symlinks=resolved.follow_unsafe_symlinks,
+            trust_attestation_context=trust_attestation_context,
+            artifacts=artifacts,
         )
+        snapshots.append(snapshot)
+        if primary_content_sources is not None:
+            primary_content_sources.extend(
+                primary_content_sources_from_artifacts(
+                    artifacts,
+                    snapshot,
+                    workspace_dir=context.workspace_dir,
+                )
+            )
     return tuple(snapshots)
 
 
@@ -406,11 +428,13 @@ def sync_aibom_snapshots(
         generated_at=generated_at,
         include_upload_session_bindings=True,
     )
+    primary_content_sources: list[GuardAibomPrimaryContentSource] = []
     snapshots = collect_aibom_snapshots(
         context,
         generated_at=generated_at,
         options=resolved_options,
         trust_attestation_context=trust_attestation_context,
+        primary_content_sources=primary_content_sources,
     )
     if not snapshots:
         synced_at = generated_at
@@ -440,6 +464,13 @@ def sync_aibom_snapshots(
         for snapshot in snapshots
     ]
     event_batches, oversized_events = _batch_inventory_events(events)
+    content_sources_by_snapshot: dict[str, tuple[GuardAibomPrimaryContentSource, ...]] = {}
+    for snapshot in snapshots:
+        content_sources_by_snapshot[snapshot.snapshot_id] = tuple(
+            source for source in primary_content_sources if source.snapshot_id == snapshot.snapshot_id
+        )
+    content_upload_summary = empty_content_upload_summary()
+    content_uploaded_snapshot_ids: set[str] = set()
     oversized_statuses: list[dict[str, object]] = [
         {
             "eventId": str(event.get("eventId") or ""),
@@ -459,6 +490,7 @@ def sync_aibom_snapshots(
             "partial": False,
             "reason": "snapshot_too_large",
             "error": "Guard Cloud AIBOM sync failed because an inventory snapshot exceeds the request limit.",
+            "content_upload": content_upload_summary,
         }
         store.set_sync_payload("aibom_sync_summary", failure_summary, generated_at)
         return failure_summary
@@ -526,6 +558,7 @@ def sync_aibom_snapshots(
                     "statuses": all_statuses,
                     "partial": batches_sent > 0 or bool(oversized_events),
                     "reason": "guard_events_endpoint_unavailable",
+                    "content_upload": content_upload_summary,
                 }
                 if batches_sent == 0:
                     summary["skipped"] = True
@@ -540,6 +573,7 @@ def sync_aibom_snapshots(
                 "statuses": all_statuses,
                 "partial": batches_sent > 0 or bool(oversized_events),
                 "error": "Guard Cloud AIBOM sync failed due to an HTTP error.",
+                "content_upload": content_upload_summary,
             }
             store.set_sync_payload("aibom_sync_summary", failure_summary, synced_at)
             raise RuntimeError("Guard Cloud AIBOM sync failed due to an HTTP error.") from error
@@ -553,10 +587,11 @@ def sync_aibom_snapshots(
                 "statuses": all_statuses,
                 "partial": batches_sent > 0 or bool(oversized_events),
                 "error": "Guard Cloud AIBOM sync failed due to a network error.",
+                "content_upload": content_upload_summary,
             }
             store.set_sync_payload("aibom_sync_summary", failure_summary, synced_at)
             raise RuntimeError("Guard Cloud AIBOM sync failed due to a network error.") from error
-        batches_sent += 1  # noqa: SIM113
+        batches_sent += 1
         events_sent += len(batch)
         batch_accepted = payload.get("accepted")
         if isinstance(batch_accepted, int):
@@ -570,17 +605,40 @@ def sync_aibom_snapshots(
         batch_synced_at = _sync_timestamp_from_payload(payload)
         if isinstance(batch_synced_at, str):
             synced_at = batch_synced_at
+        for snapshot_id in _accepted_snapshot_ids(batch, payload):
+            if snapshot_id in content_uploaded_snapshot_ids:
+                continue
+            sources = content_sources_by_snapshot.get(snapshot_id, ())
+            upload_summary, resolved_auth_context = upload_primary_content_sources(
+                store,
+                runner,
+                resolved_auth_context,
+                sources=sources,
+                workspace_id=workspace_id,
+            )
+            merge_content_upload_summary(content_upload_summary, upload_summary)
+            content_uploaded_snapshot_ids.add(snapshot_id)
+    content_eligible_value = content_upload_summary.get("eligible")
+    content_stored_value = content_upload_summary.get("stored")
+    content_eligible = content_eligible_value if isinstance(content_eligible_value, int) else 0
+    content_stored = content_stored_value if isinstance(content_stored_value, int) else 0
+    content_upload_complete = content_stored == content_eligible
     summary: dict[str, object] = {
-        "synced": True,
+        "synced": content_upload_complete,
         "synced_at": synced_at,
         "snapshots": len(snapshots),
         "accepted": total_accepted,
         "rejected": total_rejected,
         "statuses": all_statuses,
+        "content_upload": content_upload_summary,
+        "content_upload_complete": content_upload_complete,
     }
     if oversized_events:
         summary["partial"] = True
         summary["reason"] = "snapshot_too_large"
+    if not content_upload_complete:
+        summary["partial"] = True
+        summary["reason"] = "content_upload_incomplete"
     store.set_sync_payload("aibom_sync_summary", summary, synced_at)
     return summary
 
@@ -891,6 +949,32 @@ def _sync_timestamp_from_payload(payload: dict[str, object]) -> str | None:
     return None
 
 
+def _accepted_snapshot_ids(
+    batch: list[dict[str, object]],
+    payload: dict[str, object],
+) -> set[str]:
+    snapshot_by_event_id: dict[str, str] = {}
+    for event in batch:
+        event_id = event.get("eventId")
+        event_payload = event.get("payload")
+        snapshot_payload = event_payload.get("snapshot") if isinstance(event_payload, dict) else None
+        snapshot_id = snapshot_payload.get("snapshotId") if isinstance(snapshot_payload, dict) else None
+        if isinstance(event_id, str) and isinstance(snapshot_id, str):
+            snapshot_by_event_id[event_id] = snapshot_id
+    accepted_event_ids: set[str] = set()
+    statuses = payload.get("statuses")
+    if isinstance(statuses, list):
+        for status in statuses:
+            if not isinstance(status, dict) or status.get("status") != "accepted":
+                continue
+            event_id = status.get("eventId")
+            if isinstance(event_id, str):
+                accepted_event_ids.add(event_id)
+    if not accepted_event_ids and payload.get("accepted") == len(batch):
+        accepted_event_ids = set(snapshot_by_event_id)
+    return {snapshot_by_event_id[event_id] for event_id in accepted_event_ids if event_id in snapshot_by_event_id}
+
+
 def _render_aibom_markdown(payload: dict[str, object]) -> str:
     layer_summary = payload.get("layer_summary")
     trust_summary = payload.get("trust_summary")

plugin_scanner-2.0.1017/src/codex_plugin_scanner/guard/aibom_content_upload.py

@@ -0,0 +1,351 @@
+"""Bounded upload of exact primary AIBOM artifact bodies."""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import re
+import urllib.error
+import urllib.parse
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, TypedDict
+
+from ..path_support import resolves_within_root
+from .inventory_contract import GuardAgentInventorySnapshot
+
+_CONTENT_HASH_PATTERN = re.compile(r"^sha256:[0-9a-f]{64}$")
+_MAX_CONTENT_ITEMS_PER_BATCH = 100
+_MAX_CONTENT_ITEM_BYTES = 1024 * 1024
+_MAX_CONTENT_RAW_BYTES_PER_BATCH = 5 * 1024 * 1024
+_MAX_CONTENT_REQUEST_BYTES = 7 * 1024 * 1024
+
+
+@dataclass(frozen=True, slots=True)
+class GuardAibomPrimaryContentSource:
+    agent_id: str
+    allowed_root: Path
+    content_hash: str
+    harness_id: str
+    item_id: str
+    item_kind: str
+    mime_type: str
+    path: Path
+    snapshot_id: str
+    version_id: str
+
+
+class _GuardAibomContentUploadCounts(TypedDict):
+    eligible: int
+    attempted: int
+    stored: int
+    hash_only: int
+    uploaded: int
+    failed: int
+    skipped: int
+    batches: int
+
+
+class GuardAibomContentUploadSummary(_GuardAibomContentUploadCounts, total=False):
+    reason: str
+
+
+def empty_content_upload_summary() -> GuardAibomContentUploadSummary:
+    return {
+        "eligible": 0,
+        "attempted": 0,
+        "stored": 0,
+        "hash_only": 0,
+        "uploaded": 0,
+        "failed": 0,
+        "skipped": 0,
+        "batches": 0,
+    }
+
+
+def merge_content_upload_summary(
+    target: GuardAibomContentUploadSummary,
+    source: GuardAibomContentUploadSummary,
+) -> None:
+    target["eligible"] += source["eligible"]
+    target["attempted"] += source["attempted"]
+    target["stored"] += source["stored"]
+    target["hash_only"] += source["hash_only"]
+    target["uploaded"] += source["uploaded"]
+    target["failed"] += source["failed"]
+    target["skipped"] += source["skipped"]
+    target["batches"] += source["batches"]
+    reason = source.get("reason")
+    if isinstance(reason, str) and reason:
+        target["reason"] = reason
+
+
+def primary_content_sources_from_artifacts(
+    artifacts: tuple[object, ...],
+    snapshot: GuardAgentInventorySnapshot,
+    *,
+    workspace_dir: Path | None,
+) -> tuple[GuardAibomPrimaryContentSource, ...]:
+    if snapshot.agent_type != "hermes":
+        return ()
+    items_by_id = {item.item_id: item for item in snapshot.items}
+    sources: list[GuardAibomPrimaryContentSource] = []
+    for artifact in artifacts:
+        artifact_type = str(getattr(artifact, "artifact_type", ""))
+        if artifact_type not in {"skill", "instruction"}:
+            continue
+        item_id = str(getattr(artifact, "artifact_id", ""))
+        item = items_by_id.get(item_id)
+        if item is None or not _CONTENT_HASH_PATTERN.fullmatch(item.content_hash):
+            continue
+        path_value = getattr(artifact, "config_path", None)
+        if not isinstance(path_value, str) or not path_value.strip():
+            continue
+        path = Path(path_value).expanduser()
+        allowed_root = _primary_allowed_root(
+            artifact_type=artifact_type,
+            path=path,
+            workspace_dir=workspace_dir,
+        )
+        if allowed_root is None or not _safe_primary_path(path, allowed_root=allowed_root):
+            continue
+        sources.append(
+            GuardAibomPrimaryContentSource(
+                agent_id=snapshot.agent_id,
+                allowed_root=allowed_root,
+                content_hash=item.content_hash,
+                harness_id=snapshot.agent_type,
+                item_id=item.item_id,
+                item_kind=item.item_kind,
+                mime_type=_content_mime_type(path),
+                path=path,
+                snapshot_id=snapshot.snapshot_id,
+                version_id=item.source_fingerprint,
+            )
+        )
+    return tuple(sources)
+
+
+def _primary_allowed_root(
+    *,
+    artifact_type: str,
+    path: Path,
+    workspace_dir: Path | None,
+) -> Path | None:
+    if artifact_type == "instruction":
+        if workspace_dir is None or path.suffix.lower() not in {".md", ".mdc"}:
+            return None
+        return workspace_dir
+    if path.name != "SKILL.md":
+        return None
+    parents = list(path.parents)
+    skills_root = next((parent for parent in parents if parent.name.lower() == "skills"), None)
+    if skills_root is None:
+        return None
+    try:
+        relative = path.relative_to(skills_root)
+    except ValueError:
+        return None
+    return skills_root if len(relative.parts) >= 2 else None
+
+
+def _safe_primary_path(path: Path, *, allowed_root: Path) -> bool:
+    if not path.is_file() or not resolves_within_root(allowed_root, path, require_exists=True):
+        return False
+    try:
+        relative = path.relative_to(allowed_root)
+    except ValueError:
+        return False
+    current = allowed_root
+    if current.is_symlink():
+        return False
+    for part in relative.parts:
+        current = current / part
+        if current.is_symlink():
+            return False
+    return True
+
+
+def _content_mime_type(path: Path) -> str:
+    if path.suffix.lower() in {".md", ".mdc"}:
+        return "text/markdown; charset=utf-8"
+    return "text/plain; charset=utf-8"
+
+
+def _prepared_upload_item(source: GuardAibomPrimaryContentSource) -> tuple[dict[str, object], int] | None:
+    if not _safe_primary_path(source.path, allowed_root=source.allowed_root):
+        return None
+    try:
+        with source.path.open("rb") as handle:
+            body = handle.read(_MAX_CONTENT_ITEM_BYTES + 1)
+    except OSError:
+        return None
+    if len(body) > _MAX_CONTENT_ITEM_BYTES:
+        return None
+    content_hash = f"sha256:{hashlib.sha256(body).hexdigest()}"
+    if content_hash != source.content_hash:
+        return None
+    return (
+        {
+            "bodyBase64": base64.b64encode(body).decode("ascii"),
+            "contentHash": source.content_hash,
+            "itemKind": source.item_kind,
+            "itemId": source.item_id,
+            "versionId": source.version_id,
+            "mimeType": source.mime_type,
+        },
+        len(body),
+    )
+
+
+def _content_upload_url(sync_url: str, workspace_id: str) -> str:
+    parsed = urllib.parse.urlsplit(sync_url)
+    path = f"/api/guard/aibom/workspaces/{urllib.parse.quote(workspace_id, safe='')}/content-upload"
+    return urllib.parse.urlunsplit((parsed.scheme, parsed.netloc, path, "", ""))
+
+
+def _encoded_batch(
+    *,
+    items: list[dict[str, object]],
+) -> bytes:
+    return json.dumps(
+        {
+            "items": items,
+        },
+        separators=(",", ":"),
+    ).encode("utf-8")
+
+
+def _bounded_response_count(
+    payload: object,
+    key: str,
+    *,
+    upper_bound: int,
+) -> int | None:
+    if not isinstance(payload, dict):
+        return None
+    value = payload.get(key)
+    if isinstance(value, bool) or not isinstance(value, int):
+        return None
+    return value if 0 <= value <= upper_bound else None
+
+
+def upload_primary_content_sources(
+    store: Any,
+    runner: Any,
+    auth_context: dict[str, object],
+    *,
+    sources: tuple[GuardAibomPrimaryContentSource, ...],
+    workspace_id: str,
+) -> tuple[GuardAibomContentUploadSummary, dict[str, object]]:
+    summary = empty_content_upload_summary()
+    summary["eligible"] = len(sources)
+    if not sources:
+        return summary, auth_context
+
+    resolved_auth_context = auth_context
+    batch_items: list[dict[str, object]] = []
+    batch_raw_bytes = 0
+
+    def send_batch() -> bool:
+        nonlocal batch_items, batch_raw_bytes, resolved_auth_context
+        if not batch_items:
+            return True
+        body = _encoded_batch(items=batch_items)
+        content_url = _content_upload_url(str(resolved_auth_context["sync_url"]), workspace_id)
+        request = runner._guard_sync_request(
+            resolved_auth_context,
+            request_url=content_url,
+            method="POST",
+            data=body,
+            extra_headers=None,
+        )
+        summary["attempted"] += len(batch_items)
+        summary["batches"] += 1
+        try:
+            payload = runner._urlopen_json_with_timeout_retry(
+                request=request,
+                timeout_seconds=60,
+                retry_timeout_seconds=90,
+            )
+        except urllib.error.HTTPError as error:
+            if error.code == 401:
+                try:
+                    resolved_auth_context = runner._resolve_guard_sync_auth_context(store, force_refresh=True)
+                    content_url = _content_upload_url(str(resolved_auth_context["sync_url"]), workspace_id)
+                    request = runner._guard_sync_request(
+                        resolved_auth_context,
+                        request_url=content_url,
+                        method="POST",
+                        data=body,
+                        extra_headers=None,
+                    )
+                    payload = runner._urlopen_json_with_timeout_retry(
+                        request=request,
+                        timeout_seconds=60,
+                        retry_timeout_seconds=90,
+                    )
+                except (OSError, RuntimeError, urllib.error.HTTPError):
+                    summary["failed"] += len(batch_items)
+                    summary["reason"] = "authorization_failed"
+                    return False
+            else:
+                summary["failed"] += len(batch_items)
+                summary["reason"] = "endpoint_unavailable" if error.code == 404 else "http_error"
+                return False
+        except (OSError, RuntimeError):
+            summary["failed"] += len(batch_items)
+            summary["reason"] = "network_error"
+            return False
+
+        batch_size = len(batch_items)
+        stored = _bounded_response_count(payload, "storedCount", upper_bound=batch_size)
+        hash_only = _bounded_response_count(payload, "hashOnlyCount", upper_bound=batch_size)
+        server_failed = _bounded_response_count(payload, "failedCount", upper_bound=batch_size)
+        if stored is None or hash_only is None or server_failed is None:
+            summary["failed"] += batch_size
+            summary["reason"] = "invalid_response"
+            return False
+        accounted = stored + hash_only + server_failed
+        if accounted > batch_size:
+            summary["failed"] += batch_size
+            summary["reason"] = "invalid_response"
+            return False
+        summary["stored"] += stored
+        summary["hash_only"] += hash_only
+        summary["uploaded"] += stored + hash_only
+        summary["failed"] += server_failed + batch_size - accounted
+        if accounted < batch_size:
+            summary["reason"] = "incomplete_response"
+            return False
+        batch_items = []
+        batch_raw_bytes = 0
+        return True
+
+    for index, source in enumerate(sources):
+        prepared = _prepared_upload_item(source)
+        if prepared is None:
+            summary["skipped"] += 1
+            continue
+        item, raw_bytes = prepared
+        candidate_items = [*batch_items, item]
+        candidate_body = _encoded_batch(items=candidate_items)
+        if batch_items and (
+            len(candidate_items) > _MAX_CONTENT_ITEMS_PER_BATCH
+            or batch_raw_bytes + raw_bytes > _MAX_CONTENT_RAW_BYTES_PER_BATCH
+            or len(candidate_body) > _MAX_CONTENT_REQUEST_BYTES
+        ):
+            if not send_batch():
+                summary["failed"] += len(sources) - index
+                return summary, resolved_auth_context
+            candidate_items = [item]
+            candidate_body = _encoded_batch(items=candidate_items)
+        if raw_bytes > _MAX_CONTENT_RAW_BYTES_PER_BATCH or len(candidate_body) > _MAX_CONTENT_REQUEST_BYTES:
+            summary["skipped"] += 1
+            continue
+        batch_items = candidate_items
+        batch_raw_bytes += raw_bytes
+
+    send_batch()
+    return summary, resolved_auth_context

{plugin_scanner-2.0.1016 → plugin_scanner-2.0.1017}/src/codex_plugin_scanner/guard/aibom_detection.py

@@ -506,7 +506,8 @@ def _instruction_artifact(
     artifact_name: str | None = None,
     artifact_id: str | None = None,
 ) -> GuardArtifact:
-    content_hash = file_content_hash(path) or fingerprint_text(path.name)
+    content_digest = file_content_hash(path) or fingerprint_text(path.name)
+    content_hash = f"sha256:{content_digest}"
     name = display_name or path.name
     artifact_suffix = artifact_name or name
     resolved_artifact_id = artifact_id or f"{harness}:{scope}:instruction:{role}:{artifact_suffix}"

{plugin_scanner-2.0.1016 → plugin_scanner-2.0.1017}/src/codex_plugin_scanner/guard/inventory_contract.py

@@ -383,18 +383,17 @@ def extract_aibom_metadata_extensions(metadata: dict[str, object]) -> dict[str,
     return extensions
 
 
-def inventory_snapshot_from_detection(
+def cloud_inventory_artifacts_from_detection(
     detection: object,
     *,
-    generated_at: str,
     home_dir: Path,
     workspace_dir: Path | None = None,
-    runtime_version: str | None = None,
-    cisco_runs: tuple[object, ...] = (),
-    include_symlinks: bool = True,
-    follow_unsafe_symlinks: bool = False,
-    trust_attestation_context: Mapping[str, object] | None = None,
-) -> GuardAgentInventorySnapshot:
+) -> tuple[object, ...]:
+    """Return artifacts eligible for the cloud inventory contract.
+
+    Hermes supplementary skill files remain part of local detection and policy
+    evaluation, but the cloud inventory represents the primary SKILL.md once.
+    """
     harness = str(getattr(detection, "harness", "unknown"))
     artifacts: list[object] = list(getattr(detection, "artifacts", ()))
     if workspace_dir is not None:
@@ -407,7 +406,34 @@ def inventory_snapshot_from_detection(
             if artifact.artifact_id not in existing_ids:
                 artifacts.append(artifact)
                 existing_ids.add(artifact.artifact_id)
-    artifact_tuple = tuple(artifacts)
+    if harness == "hermes":
+        artifacts = [artifact for artifact in artifacts if str(getattr(artifact, "artifact_type", "")) != "skill_file"]
+    return tuple(artifacts)
+
+
+def inventory_snapshot_from_detection(
+    detection: object,
+    *,
+    generated_at: str,
+    home_dir: Path,
+    workspace_dir: Path | None = None,
+    runtime_version: str | None = None,
+    cisco_runs: tuple[object, ...] = (),
+    include_symlinks: bool = True,
+    follow_unsafe_symlinks: bool = False,
+    trust_attestation_context: Mapping[str, object] | None = None,
+    artifacts: tuple[object, ...] | None = None,
+) -> GuardAgentInventorySnapshot:
+    harness = str(getattr(detection, "harness", "unknown"))
+    artifact_tuple = (
+        artifacts
+        if artifacts is not None
+        else cloud_inventory_artifacts_from_detection(
+            detection,
+            home_dir=home_dir,
+            workspace_dir=workspace_dir,
+        )
+    )
     items: list[GuardAgentInventoryItem] = []
     for artifact in artifact_tuple:
         item = _item_from_artifact(