plugin-scanner 2.0.823__tar.gz → 2.0.825__tar.gz

{plugin_scanner-2.0.823 → plugin_scanner-2.0.825}/PKG-INFO

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

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

{plugin_scanner-2.0.823 → plugin_scanner-2.0.825}/pyproject.toml.bak

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

@@ -11,10 +11,12 @@ import uuid
 from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
+from types import SimpleNamespace
 from typing import Any, Literal
 
 from ..version import __version__
 from .adapters.base import HarnessContext
+from .aibom_trust_metadata import apply_local_trust_metadata
 from .inventory_cisco import run_cisco_inventory_scans
 from .inventory_contract import (
     GuardAgentInventorySnapshot,
@@ -165,6 +167,18 @@ def build_inventory_json_payload(
         artifact_id = str(item.get("artifact_id") or "")
         harness = str(item.get("harness") or "")
         extensions = metadata_by_artifact.get((harness, artifact_id))
+        config_path = _store_row_config_path(item) if str(item.get("artifact_type") or "") == "skill_file" else None
+        config_path_exists = config_path.exists() if config_path is not None else None
+        if not extensions:
+            extensions = _store_only_artifact_metadata_extensions(
+                enriched,
+                context=context,
+                generated_at=generated_at,
+                config_path=config_path,
+                config_path_exists=config_path_exists,
+            )
+            if config_path_exists is False:
+                enriched["present"] = False
         if extensions:
             enriched.update(extensions)
         items.append(enriched)
@@ -223,7 +237,7 @@ def build_aibom_export_payload(
         trust_attestation_context=_resolve_trust_attestation_context(store, generated_at=generated_at),
     )
     serialized_snapshots = [serialize_inventory_snapshot(snapshot) for snapshot in snapshots]
-    artifacts = _artifact_rows_from_store(store, snapshots)
+    artifacts = _artifact_rows_from_store(store, snapshots, context=context, generated_at=generated_at)
     layer_summary, trust_summary, drift_summary = summarize_aibom_layers(
         snapshots,
         generated_at=generated_at,
@@ -594,6 +608,9 @@ def _metadata_lookup_from_snapshots(
 def _artifact_rows_from_store(
     store: Any,
     snapshots: tuple[GuardAgentInventorySnapshot, ...],
+    *,
+    context: HarnessContext,
+    generated_at: str,
 ) -> list[dict[str, object]]:
     metadata_by_artifact = _metadata_lookup_from_snapshots(snapshots)
     artifacts: list[dict[str, object]] = []
@@ -604,12 +621,60 @@ def _artifact_rows_from_store(
         row: dict[str, object] = dict(item)
         row["trust_verdict"] = trust_verdict
         extensions = metadata_by_artifact.get((harness, artifact_id))
+        config_path = _store_row_config_path(row) if str(row.get("artifact_type") or "") == "skill_file" else None
+        config_path_exists = config_path.exists() if config_path is not None else None
+        if not extensions:
+            extensions = _store_only_artifact_metadata_extensions(
+                row,
+                context=context,
+                generated_at=generated_at,
+                config_path=config_path,
+                config_path_exists=config_path_exists,
+            )
+            if config_path_exists is False:
+                row["present"] = False
         if extensions:
             row.update(extensions)
         artifacts.append(row)
     return artifacts
 
 
+def _store_row_config_path(row: dict[str, object]) -> Path | None:
+    raw_config_path = row.get("config_path")
+    if not isinstance(raw_config_path, str) or not raw_config_path.strip():
+        return None
+    return Path(raw_config_path).expanduser()
+
+
+def _store_only_artifact_metadata_extensions(
+    row: dict[str, object],
+    *,
+    context: HarnessContext,
+    generated_at: str,
+    config_path: Path | None,
+    config_path_exists: bool | None,
+) -> dict[str, object]:
+    artifact_type = str(row.get("artifact_type") or "")
+    if artifact_type != "skill_file":
+        return {}
+    if config_path is None or config_path_exists is not True:
+        return {}
+    artifact = SimpleNamespace(
+        artifact_id=str(row.get("artifact_id") or ""),
+        artifact_type=artifact_type,
+        config_path=str(config_path),
+        name=str(row.get("artifact_name") or row.get("artifact_id") or "skill_file"),
+    )
+    metadata = apply_local_trust_metadata(
+        artifact,
+        captured_at=generated_at,
+        item_kind="skill",
+        metadata={"artifactType": artifact_type},
+        workspace_dir=context.workspace_dir,
+    )
+    return extract_aibom_metadata_extensions(metadata)
+
+
 def _aggregate_redaction_report(
     snapshots: tuple[GuardAgentInventorySnapshot, ...],
 ) -> dict[str, object]:

{plugin_scanner-2.0.823 → plugin_scanner-2.0.825}/src/codex_plugin_scanner/guard/aibom_trust_metadata.py

@@ -329,7 +329,16 @@ def _local_trust_domain_for_artifact(
         return build_plugin_domain(trust_root, ())
     if item_kind == "skill":
         context = resolve_skill_security_context(trust_root, _INVENTORY_TRUST_SCAN_OPTIONS)
-        return build_skill_domain(trust_root, context)
+        skill_domain = build_skill_domain(trust_root, context)
+        if skill_domain is not None:
+            return skill_domain
+        if getattr(artifact, "artifact_type", None) == "skill_file":
+            config_path = getattr(artifact, "config_path", None)
+            if isinstance(config_path, str) and config_path.strip():
+                file_path = Path(config_path)
+                if file_path.is_file():
+                    return build_instruction_domain(file_path, role="skill_file", item_kind="skill")
+        return None
     if item_kind == "mcp_server":
         return build_mcp_domain(trust_root, ()) or build_mcp_surface_domain(
             name=getattr(artifact, "name", None),
@@ -371,6 +380,13 @@ def _trust_root_for_artifact(
                 return candidate
             if path.name.lower() != "skill.md" and (candidate / "SKILL.md").is_file():
                 return candidate
+            if (
+                getattr(artifact, "artifact_type", None) == "skill_file"
+                and candidate.parent.name.lower() == "skills"
+                and ((candidate / "README.md").is_file() or (candidate / "SECURITY.md").is_file())
+                and _skill_file_name_matches_root(artifact, candidate)
+            ):
+                return candidate
             if workspace_dir is not None and candidate.resolve() == workspace_dir.resolve():
                 break
         return skill_dir if skill_dir.is_dir() else None
@@ -392,6 +408,15 @@ def _trust_root_for_artifact(
     return None
 
 
+def _skill_file_name_matches_root(artifact: object, root: Path) -> bool:
+    root_name = root.name
+    name = getattr(artifact, "name", None)
+    if isinstance(name, str) and (name == root_name or name.startswith(f"{root_name}/")):
+        return True
+    artifact_id = getattr(artifact, "artifact_id", None)
+    return isinstance(artifact_id, str) and f":{root_name}:" in artifact_id
+
+
 def _trust_layer_from_domain(
     domain: TrustDomainScore,
     *,

{plugin_scanner-2.0.823 → plugin_scanner-2.0.825}/src/codex_plugin_scanner/guard/store.py

@@ -665,7 +665,9 @@ class SystemKeyringSecretStore:
             from ctypes import byref, c_ubyte
 
             macos_keyring_api = self._load_macos_keyring_api_module()
-            cfdata_to_str = getattr(macos_keyring_api, "cfdata_to_str", None)
+            # The macOS keyring backend returns password bytes here but exposes
+            # its decoder under the historical cfstr_to_str name.
+            cfstr_to_str = getattr(macos_keyring_api, "cfstr_to_str", None)
             cf_release = getattr(macos_keyring_api, "CFRelease", None)
             security_library = getattr(macos_keyring_api, "_sec", None)
             get_interaction_allowed = (
@@ -708,10 +710,10 @@ class SystemKeyringSecretStore:
                 with suppress(Exception):
                     set_interaction_allowed(restore_value)
         if status == 0:
-            if not callable(cfdata_to_str):
+            if not callable(cfstr_to_str):
                 return None
             try:
-                value = cfdata_to_str(data)
+                value = cfstr_to_str(data)
             except Exception:
                 value = None
             finally:

{plugin_scanner-2.0.823 → plugin_scanner-2.0.825}/src/codex_plugin_scanner/version.py

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

plugin_scanner-2.0.825/tests/test_guard_aibom_local_trust_coverage.py

@@ -0,0 +1,287 @@
+import json
+from pathlib import Path
+
+from codex_plugin_scanner.guard import aibom_cli as aibom_cli_module
+from codex_plugin_scanner.guard.adapters.base import HarnessContext
+from codex_plugin_scanner.guard.aibom_cli import _artifact_rows_from_store
+from codex_plugin_scanner.guard.inventory_contract import inventory_snapshot_from_detection
+from codex_plugin_scanner.guard.models import GuardArtifact, HarnessDetection
+
+
+class _FakeInventoryStore:
+    def __init__(self, rows: list[dict[str, object]]) -> None:
+        self._rows = rows
+
+    def list_inventory(self) -> list[dict[str, object]]:
+        return self._rows
+
+    def get_oauth_local_credentials(self, *, allow_primary: bool = False) -> None:
+        return None
+
+    def get_or_create_installation_id(self) -> str:
+        return "installation-1"
+
+    def get_cloud_workspace_id(self) -> None:
+        return None
+
+
+def test_inventory_snapshot_adds_local_trust_to_hooks(tmp_path: Path) -> None:
+    workspace = tmp_path / "repo"
+    workspace.mkdir()
+    hook_config = workspace / ".claude" / "settings.json"
+    hook_config.parent.mkdir(parents=True)
+    hook_config.write_text(
+        json.dumps(
+            {
+                "hooks": {
+                    "PreToolUse": [
+                        {
+                            "matcher": "Bash",
+                            "hooks": [{"type": "command", "command": "python3 guard.py"}],
+                        }
+                    ]
+                }
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    snapshot = inventory_snapshot_from_detection(
+        HarnessDetection(
+            harness="claude-code",
+            installed=True,
+            command_available=True,
+            config_paths=(str(hook_config),),
+            artifacts=(
+                GuardArtifact(
+                    artifact_id="claude-code:project:pretooluse:0:0",
+                    name="PreToolUse",
+                    harness="claude-code",
+                    artifact_type="hook",
+                    source_scope="project",
+                    config_path=str(hook_config),
+                    command="python3 guard.py",
+                    metadata={"matcher": "Bash", "type": "command"},
+                ),
+            ),
+        ),
+        generated_at="2026-06-10T00:00:00Z",
+        home_dir=tmp_path,
+        workspace_dir=workspace,
+    )
+
+    hook_item = next(item for item in snapshot.items if item.item_kind == "hook")
+    hook_trust = hook_item.metadata.get("trustResolution")
+    assert isinstance(hook_trust, dict)
+    assert isinstance(hook_item.metadata.get("trustLayers"), list)
+    assert hook_trust["trustComponents"]
+
+
+def test_inventory_snapshot_adds_parent_skill_trust_to_skill_files(tmp_path: Path) -> None:
+    workspace = tmp_path / "repo"
+    workspace.mkdir()
+    skill_dir = workspace / "skills" / "compress"
+    script_path = skill_dir / "scripts" / "cli.py"
+    script_path.parent.mkdir(parents=True)
+    (skill_dir / "SKILL.md").write_text(
+        "---\nname: compress\ndescription: Compress memory files.\n---\n# Compress\nDo not read secrets.\n",
+        encoding="utf-8",
+    )
+    script_path.write_text("print('compress')\n", encoding="utf-8")
+
+    snapshot = inventory_snapshot_from_detection(
+        HarnessDetection(
+            harness="openclaw",
+            installed=True,
+            command_available=True,
+            config_paths=(str(skill_dir / "SKILL.md"),),
+            artifacts=(
+                GuardArtifact(
+                    artifact_id="openclaw:skill:local:compress:scripts/cli.py",
+                    name="compress/scripts/cli.py",
+                    harness="openclaw",
+                    artifact_type="skill_file",
+                    source_scope="workspace",
+                    config_path=str(script_path),
+                    command=str(script_path),
+                    metadata={"parent_skill": "compress"},
+                ),
+            ),
+        ),
+        generated_at="2026-06-10T00:00:00Z",
+        home_dir=tmp_path,
+        workspace_dir=workspace,
+    )
+
+    skill_file_item = next(item for item in snapshot.items if item.metadata.get("artifactType") == "skill_file")
+    skill_file_trust = skill_file_item.metadata.get("trustResolution")
+    assert isinstance(skill_file_trust, dict)
+    assert isinstance(skill_file_item.metadata.get("trustLayers"), list)
+    assert skill_file_trust["trustComponents"]
+
+
+def test_aibom_export_adds_parent_skill_trust_to_store_only_skill_files(tmp_path: Path) -> None:
+    skill_dir = tmp_path / ".agents" / "skills" / "caveman-compress"
+    script_path = skill_dir / "scripts" / "cli.py"
+    script_path.parent.mkdir(parents=True)
+    (skill_dir / "SKILL.md").write_text(
+        "---\nname: caveman-compress\ndescription: Compress memory files.\n---\n# Caveman Compress\n",
+        encoding="utf-8",
+    )
+    script_path.write_text("print('compress')\n", encoding="utf-8")
+    store = _FakeInventoryStore(
+        [
+            {
+                "artifact_id": "openclaw:skill:local:caveman-compress:scripts/cli.py",
+                "artifact_name": "caveman-compress/scripts/cli.py",
+                "artifact_type": "skill_file",
+                "config_path": str(script_path),
+                "harness": "openclaw",
+                "last_policy_action": None,
+                "present": True,
+                "source_scope": "skill-root:local",
+            }
+        ]
+    )
+
+    rows = _artifact_rows_from_store(
+        store,
+        (),
+        context=HarnessContext(home_dir=tmp_path, workspace_dir=tmp_path, guard_home=tmp_path / ".guard"),
+        generated_at="2026-06-10T00:00:00Z",
+    )
+
+    trust = rows[0].get("trustResolution")
+    assert isinstance(trust, dict)
+    assert isinstance(rows[0].get("trustLayers"), list)
+    assert trust["trustComponents"]
+
+
+def test_aibom_export_adds_trust_to_readme_marked_store_only_skill_files(tmp_path: Path) -> None:
+    skill_dir = tmp_path / ".agents" / "skills" / "caveman-compress"
+    script_path = skill_dir / "scripts" / "cli.py"
+    script_path.parent.mkdir(parents=True)
+    (skill_dir / "README.md").write_text("# Caveman Compress\n", encoding="utf-8")
+    script_path.write_text("print('compress')\n", encoding="utf-8")
+    store = _FakeInventoryStore(
+        [
+            {
+                "artifact_id": "openclaw:skill:local:caveman-compress:scripts/cli.py",
+                "artifact_name": "caveman-compress/scripts/cli.py",
+                "artifact_type": "skill_file",
+                "config_path": str(script_path),
+                "harness": "openclaw",
+                "last_policy_action": None,
+                "present": True,
+                "source_scope": "skill-root:local",
+            }
+        ]
+    )
+
+    rows = _artifact_rows_from_store(
+        store,
+        (),
+        context=HarnessContext(home_dir=tmp_path, workspace_dir=tmp_path, guard_home=tmp_path / ".guard"),
+        generated_at="2026-06-10T00:00:00Z",
+    )
+
+    trust = rows[0].get("trustResolution")
+    assert isinstance(trust, dict)
+    assert isinstance(rows[0].get("trustLayers"), list)
+
+
+def test_aibom_export_does_not_use_unrelated_skills_ancestor_as_skill_root(tmp_path: Path) -> None:
+    utility_root = tmp_path / ".agents" / "skills" / "utilities"
+    skill_dir = utility_root / "caveman-compress"
+    script_path = skill_dir / "scripts" / "cli.py"
+    script_path.parent.mkdir(parents=True)
+    (utility_root / "README.md").write_text("# Utilities\n", encoding="utf-8")
+    script_path.write_text("print('compress')\n", encoding="utf-8")
+    store = _FakeInventoryStore(
+        [
+            {
+                "artifact_id": "openclaw:skill:local:caveman-compress:scripts/cli.py",
+                "artifact_name": "caveman-compress/scripts/cli.py",
+                "artifact_type": "skill_file",
+                "config_path": str(script_path),
+                "harness": "openclaw",
+                "last_policy_action": None,
+                "present": True,
+                "source_scope": "skill-root:local",
+            }
+        ]
+    )
+
+    rows = _artifact_rows_from_store(
+        store,
+        (),
+        context=HarnessContext(home_dir=tmp_path, workspace_dir=tmp_path, guard_home=tmp_path / ".guard"),
+        generated_at="2026-06-10T00:00:00Z",
+    )
+
+    assert rows[0]["present"] is True
+    assert "trustResolution" not in rows[0]
+
+
+def test_aibom_export_marks_missing_store_only_skill_files_not_present(tmp_path: Path) -> None:
+    store = _FakeInventoryStore(
+        [
+            {
+                "artifact_id": "openclaw:skill:local:missing:references/example.md",
+                "artifact_name": "missing/references/example.md",
+                "artifact_type": "skill_file",
+                "config_path": str(tmp_path / ".agents" / "skills" / "missing" / "references" / "example.md"),
+                "harness": "openclaw",
+                "last_policy_action": None,
+                "present": True,
+                "source_scope": "skill-root:local",
+            }
+        ]
+    )
+
+    rows = _artifact_rows_from_store(
+        store,
+        (),
+        context=HarnessContext(home_dir=tmp_path, workspace_dir=tmp_path, guard_home=tmp_path / ".guard"),
+        generated_at="2026-06-10T00:00:00Z",
+    )
+
+    assert rows[0]["present"] is False
+    assert "trustResolution" not in rows[0]
+
+
+def test_inventory_json_payload_enriches_store_only_skill_files(tmp_path: Path, monkeypatch) -> None:
+    skill_dir = tmp_path / ".agents" / "skills" / "caveman-compress"
+    script_path = skill_dir / "scripts" / "cli.py"
+    script_path.parent.mkdir(parents=True)
+    (skill_dir / "README.md").write_text("# Caveman Compress\n", encoding="utf-8")
+    script_path.write_text("print('compress')\n", encoding="utf-8")
+    store = _FakeInventoryStore(
+        [
+            {
+                "artifact_id": "openclaw:skill:local:caveman-compress:scripts/cli.py",
+                "artifact_name": "caveman-compress/scripts/cli.py",
+                "artifact_type": "skill_file",
+                "config_path": str(script_path),
+                "harness": "openclaw",
+                "last_policy_action": None,
+                "present": True,
+                "source_scope": "skill-root:local",
+            }
+        ]
+    )
+    monkeypatch.setattr(aibom_cli_module, "collect_aibom_snapshots", lambda *args, **kwargs: ())
+
+    payload = aibom_cli_module.build_inventory_json_payload(
+        store,
+        HarnessContext(home_dir=tmp_path, workspace_dir=tmp_path, guard_home=tmp_path / ".guard"),
+        generated_at="2026-06-10T00:00:00Z",
+    )
+
+    items = payload["items"]
+    assert isinstance(items, list)
+    item = items[0]
+    assert isinstance(item, dict)
+    assert item["present"] is True
+    assert isinstance(item.get("trustResolution"), dict)
+    assert isinstance(item.get("trustLayers"), list)

{plugin_scanner-2.0.823 → plugin_scanner-2.0.825}/tests/test_guard_store_migrations.py

@@ -208,6 +208,37 @@ def test_system_keyring_timeout_keeps_non_policy_integrity_macos_services(
     assert secret_store.get_secret_with_timeout("oauth-token", timeout_seconds=1.0) == "oauth-secret"
 
 
+def test_system_keyring_native_macos_read_uses_cfstr_decoder(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(guard_store_module.sys, "platform", "darwin", raising=False)
+    secret_store = SystemKeyringSecretStore(service_name="hol-guard.policy-integrity")
+    monkeypatch.setattr(
+        SystemKeyringSecretStore,
+        "_supports_native_macos_security_reads",
+        classmethod(lambda cls: True),
+    )
+    fake_api = types.SimpleNamespace(
+        OS_status=guard_store_module.ctypes.c_int32,
+        _sec=types.SimpleNamespace(),
+        error=types.SimpleNamespace(
+            item_not_found=-25300,
+            keychain_denied=-128,
+            sec_auth_failed=-25293,
+            plist_missing=-67030,
+            sec_interaction_not_allowed=-25308,
+        ),
+        c_void_p=guard_store_module.ctypes.c_void_p,
+        k_=lambda name: name,
+        create_query=lambda **kwargs: kwargs,
+        SecItemCopyMatching=lambda _query, _data: 0,
+        cfstr_to_str=lambda _data: "native-secret",
+    )
+    monkeypatch.setattr(secret_store, "_load_macos_keyring_api_module", lambda: fake_api)
+
+    assert secret_store.get_secret_with_timeout("policy-key", timeout_seconds=1.0) == "native-secret"
+
+
 def test_system_keyring_timeout_blocks_non_policy_macos_prompt_fallback(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:

plugin_scanner-2.0.823/tests/test_guard_aibom_local_trust_coverage.py

@@ -1,100 +0,0 @@
-import json
-from pathlib import Path
-
-from codex_plugin_scanner.guard.inventory_contract import inventory_snapshot_from_detection
-from codex_plugin_scanner.guard.models import GuardArtifact, HarnessDetection
-
-
-def test_inventory_snapshot_adds_local_trust_to_hooks(tmp_path: Path) -> None:
-    workspace = tmp_path / "repo"
-    workspace.mkdir()
-    hook_config = workspace / ".claude" / "settings.json"
-    hook_config.parent.mkdir(parents=True)
-    hook_config.write_text(
-        json.dumps(
-            {
-                "hooks": {
-                    "PreToolUse": [
-                        {
-                            "matcher": "Bash",
-                            "hooks": [{"type": "command", "command": "python3 guard.py"}],
-                        }
-                    ]
-                }
-            }
-        ),
-        encoding="utf-8",
-    )
-
-    snapshot = inventory_snapshot_from_detection(
-        HarnessDetection(
-            harness="claude-code",
-            installed=True,
-            command_available=True,
-            config_paths=(str(hook_config),),
-            artifacts=(
-                GuardArtifact(
-                    artifact_id="claude-code:project:pretooluse:0:0",
-                    name="PreToolUse",
-                    harness="claude-code",
-                    artifact_type="hook",
-                    source_scope="project",
-                    config_path=str(hook_config),
-                    command="python3 guard.py",
-                    metadata={"matcher": "Bash", "type": "command"},
-                ),
-            ),
-        ),
-        generated_at="2026-06-10T00:00:00Z",
-        home_dir=tmp_path,
-        workspace_dir=workspace,
-    )
-
-    hook_item = next(item for item in snapshot.items if item.item_kind == "hook")
-    hook_trust = hook_item.metadata.get("trustResolution")
-    assert isinstance(hook_trust, dict)
-    assert isinstance(hook_item.metadata.get("trustLayers"), list)
-    assert hook_trust["trustComponents"]
-
-
-def test_inventory_snapshot_adds_parent_skill_trust_to_skill_files(tmp_path: Path) -> None:
-    workspace = tmp_path / "repo"
-    workspace.mkdir()
-    skill_dir = workspace / "skills" / "compress"
-    script_path = skill_dir / "scripts" / "cli.py"
-    script_path.parent.mkdir(parents=True)
-    (skill_dir / "SKILL.md").write_text(
-        "---\nname: compress\ndescription: Compress memory files.\n---\n# Compress\nDo not read secrets.\n",
-        encoding="utf-8",
-    )
-    script_path.write_text("print('compress')\n", encoding="utf-8")
-
-    snapshot = inventory_snapshot_from_detection(
-        HarnessDetection(
-            harness="openclaw",
-            installed=True,
-            command_available=True,
-            config_paths=(str(skill_dir / "SKILL.md"),),
-            artifacts=(
-                GuardArtifact(
-                    artifact_id="openclaw:skill:local:compress:scripts/cli.py",
-                    name="compress/scripts/cli.py",
-                    harness="openclaw",
-                    artifact_type="skill_file",
-                    source_scope="workspace",
-                    config_path=str(script_path),
-                    command=str(script_path),
-                    metadata={"parent_skill": "compress"},
-                ),
-            ),
-        ),
-        generated_at="2026-06-10T00:00:00Z",
-        home_dir=tmp_path,
-        workspace_dir=workspace,
-    )
-
-    skill_file_item = next(item for item in snapshot.items if item.metadata.get("artifactType") == "skill_file")
-    skill_file_trust = skill_file_item.metadata.get("trustResolution")
-    assert isinstance(skill_file_trust, dict)
-    assert isinstance(skill_file_item.metadata.get("trustLayers"), list)
-    assert skill_file_trust["trustComponents"]