@smilintux/skcapstone 0.1.0 → 0.2.3

package/tests/test_response_cache.py

@@ -0,0 +1,312 @@
+"""Tests for ResponseCache — TTL, cache hit/miss, skip_cache wiring."""
+
+from __future__ import annotations
+
+import time
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from skcapstone.blueprints.schema import ModelTier
+from skcapstone.response_cache import ResponseCache, _TTL_CODE, _TTL_FAST, _ttl_for_tier, hash_prompt
+
+
+# ---------------------------------------------------------------------------
+# hash_prompt
+# ---------------------------------------------------------------------------
+
+
+class TestHashPrompt:
+    """hash_prompt produces stable, distinct digests."""
+
+    def test_deterministic(self):
+        """Same inputs always produce the same hash."""
+        h1 = hash_prompt("system", "hello")
+        h2 = hash_prompt("system", "hello")
+        assert h1 == h2
+
+    def test_distinct_messages(self):
+        """Different user messages produce different hashes."""
+        h1 = hash_prompt("system", "hello")
+        h2 = hash_prompt("system", "goodbye")
+        assert h1 != h2
+
+    def test_distinct_systems(self):
+        """Different system prompts produce different hashes even with same user message."""
+        h1 = hash_prompt("system-A", "hello")
+        h2 = hash_prompt("system-B", "hello")
+        assert h1 != h2
+
+    def test_returns_hex_string(self):
+        """Result is a 64-char lowercase hex string (SHA-256)."""
+        h = hash_prompt("s", "u")
+        assert len(h) == 64
+        assert h == h.lower()
+        int(h, 16)  # must parse as hex
+
+
+# ---------------------------------------------------------------------------
+# TTL helper
+# ---------------------------------------------------------------------------
+
+
+class TestTtlForTier:
+    """_ttl_for_tier maps tiers to correct TTLs."""
+
+    def test_fast_tier_ttl(self):
+        assert _ttl_for_tier(ModelTier.FAST) == _TTL_FAST
+
+    def test_code_tier_ttl(self):
+        assert _ttl_for_tier(ModelTier.CODE) == _TTL_CODE
+
+    def test_other_tiers_default_to_fast(self):
+        """REASON, NUANCE, LOCAL, CUSTOM all get the FAST TTL (1 h)."""
+        for tier in (ModelTier.REASON, ModelTier.NUANCE, ModelTier.LOCAL, ModelTier.CUSTOM):
+            assert _ttl_for_tier(tier) == _TTL_FAST
+
+
+# ---------------------------------------------------------------------------
+# ResponseCache — basic put/get
+# ---------------------------------------------------------------------------
+
+
+class TestResponseCacheBasic:
+    """Basic put/get, miss, empty-response guard."""
+
+    def test_miss_on_empty_cache(self):
+        """get() returns None for a key that was never stored."""
+        cache = ResponseCache()
+        assert cache.get("deadbeef" * 8, "gpt-4") is None
+
+    def test_hit_after_put(self):
+        """A stored entry is returned on subsequent get()."""
+        cache = ResponseCache()
+        ph = hash_prompt("sys", "hello")
+        cache.put(ph, "llama3.2", ModelTier.FAST, "Hi there!")
+        assert cache.get(ph, "llama3.2") == "Hi there!"
+
+    def test_miss_different_model(self):
+        """Cache is keyed by model name; wrong model → miss."""
+        cache = ResponseCache()
+        ph = hash_prompt("sys", "hello")
+        cache.put(ph, "llama3.2", ModelTier.FAST, "Hi there!")
+        assert cache.get(ph, "gpt-4") is None
+
+    def test_miss_different_prompt(self):
+        """Cache is keyed by prompt hash; different prompt → miss."""
+        cache = ResponseCache()
+        ph1 = hash_prompt("sys", "hello")
+        ph2 = hash_prompt("sys", "goodbye")
+        cache.put(ph1, "llama3.2", ModelTier.FAST, "Hi there!")
+        assert cache.get(ph2, "llama3.2") is None
+
+    def test_empty_response_not_stored(self):
+        """put() silently ignores empty responses."""
+        cache = ResponseCache()
+        ph = hash_prompt("sys", "q")
+        cache.put(ph, "llama3.2", ModelTier.FAST, "")
+        assert cache.get(ph, "llama3.2") is None
+
+    def test_size_tracks_entries(self):
+        cache = ResponseCache()
+        assert cache.size == 0
+        ph = hash_prompt("sys", "x")
+        cache.put(ph, "m1", ModelTier.FAST, "resp")
+        assert cache.size == 1
+
+
+# ---------------------------------------------------------------------------
+# TTL expiry
+# ---------------------------------------------------------------------------
+
+
+class TestResponseCacheTTL:
+    """Entries expire after their TTL elapses."""
+
+    def test_entry_expires(self, monkeypatch):
+        """An entry is evicted once monotonic time exceeds its expiry."""
+        cache = ResponseCache()
+        ph = hash_prompt("s", "u")
+
+        # Freeze time at T=0 for put
+        fake_time = [0.0]
+        monkeypatch.setattr("skcapstone.response_cache.time.monotonic", lambda: fake_time[0])
+
+        cache.put(ph, "llama3.2", ModelTier.FAST, "answer")
+        assert cache.get(ph, "llama3.2") == "answer"  # alive at T=0
+
+        # Advance past TTL
+        fake_time[0] = _TTL_FAST + 1.0
+        result = cache.get(ph, "llama3.2")
+        assert result is None  # expired
+
+    def test_code_tier_longer_ttl(self, monkeypatch):
+        """CODE tier entries survive for 24 h but expire after."""
+        cache = ResponseCache()
+        ph = hash_prompt("s", "u")
+
+        fake_time = [0.0]
+        monkeypatch.setattr("skcapstone.response_cache.time.monotonic", lambda: fake_time[0])
+
+        cache.put(ph, "claude-code", ModelTier.CODE, "code answer")
+
+        # Still alive after 23 h
+        fake_time[0] = 3600 * 23
+        assert cache.get(ph, "claude-code") == "code answer"
+
+        # Expired after 24 h + 1 s
+        fake_time[0] = _TTL_CODE + 1.0
+        assert cache.get(ph, "claude-code") is None
+
+
+# ---------------------------------------------------------------------------
+# Eviction
+# ---------------------------------------------------------------------------
+
+
+class TestResponseCacheEviction:
+    """evict() removes expired entries; max_size cap is enforced."""
+
+    def test_evict_removes_expired(self, monkeypatch):
+        cache = ResponseCache()
+        fake_time = [0.0]
+        monkeypatch.setattr("skcapstone.response_cache.time.monotonic", lambda: fake_time[0])
+
+        ph = hash_prompt("s", "u")
+        cache.put(ph, "m1", ModelTier.FAST, "r1")
+        assert cache.size == 1
+
+        fake_time[0] = _TTL_FAST + 1.0
+        removed = cache.evict()
+        assert removed == 1
+        assert cache.size == 0
+
+    def test_max_size_enforced(self):
+        """When max_size is exceeded, oldest entries are dropped."""
+        cache = ResponseCache(max_size=3)
+        for i in range(5):
+            ph = hash_prompt("s", str(i))
+            cache.put(ph, "m", ModelTier.FAST, f"resp-{i}")
+        assert cache.size <= 3
+
+    def test_clear_empties_cache(self):
+        cache = ResponseCache()
+        for i in range(5):
+            ph = hash_prompt("s", str(i))
+            cache.put(ph, "m", ModelTier.FAST, "resp")
+        cache.clear()
+        assert cache.size == 0
+
+
+# ---------------------------------------------------------------------------
+# Stats
+# ---------------------------------------------------------------------------
+
+
+class TestResponseCacheStats:
+    """hits and misses are tracked correctly."""
+
+    def test_hit_increments_hits(self):
+        cache = ResponseCache()
+        ph = hash_prompt("s", "u")
+        cache.put(ph, "m", ModelTier.FAST, "r")
+        cache.get(ph, "m")
+        assert cache.stats["hits"] == 1
+        assert cache.stats["misses"] == 0
+
+    def test_miss_increments_misses(self):
+        cache = ResponseCache()
+        cache.get("no-such-hash", "model")
+        assert cache.stats["misses"] == 1
+        assert cache.stats["hits"] == 0
+
+
+# ---------------------------------------------------------------------------
+# LLMBridge integration — cache wired into generate()
+# ---------------------------------------------------------------------------
+
+
+class TestLLMBridgeCacheIntegration:
+    """LLMBridge.generate() uses the cache and respects skip_cache."""
+
+    def _make_bridge(self, cache):
+        from skcapstone.consciousness_loop import ConsciousnessConfig, LLMBridge
+
+        config = ConsciousnessConfig()
+        with patch.object(LLMBridge, "_probe_available_backends"):
+            bridge = LLMBridge(config, cache=cache)
+        bridge._available = {"passthrough": True}
+        return bridge
+
+    def test_cache_hit_skips_llm(self):
+        """When cache has a matching entry, the LLM callback is never called."""
+        from skcapstone.model_router import TaskSignal
+
+        cache = ResponseCache()
+        bridge = self._make_bridge(cache)
+
+        # Pre-populate the cache
+        ph = hash_prompt("system", "hello")
+        model = bridge._router.route(
+            TaskSignal(description="hello", tags=["simple"])
+        ).model_name
+        cache.put(ph, model, ModelTier.FAST, "cached answer")
+
+        with patch.object(bridge, "_resolve_callback") as mock_cb:
+            result = bridge.generate("system", "hello", TaskSignal(description="hello", tags=["simple"]))
+
+        mock_cb.assert_not_called()
+        assert result == "cached answer"
+
+    def test_skip_cache_bypasses_lookup_and_store(self):
+        """When skip_cache=True the cache is never consulted or written."""
+        from skcapstone.model_router import TaskSignal
+
+        cache = ResponseCache()
+        bridge = self._make_bridge(cache)
+
+        fake_callback = MagicMock(return_value="live answer")
+        with patch.object(bridge, "_resolve_callback", return_value=fake_callback):
+            with patch.object(bridge, "_timed_call", return_value="live answer"):
+                result = bridge.generate(
+                    "system", "hello",
+                    TaskSignal(description="hello", tags=["simple"]),
+                    skip_cache=True,
+                )
+
+        assert result == "live answer"
+        assert cache.size == 0  # nothing was stored
+
+    def test_successful_call_populates_cache(self):
+        """A successful LLM call populates the cache for next time."""
+        from skcapstone.model_router import TaskSignal
+
+        cache = ResponseCache()
+        bridge = self._make_bridge(cache)
+
+        with patch.object(bridge, "_timed_call", return_value="fresh answer"):
+            with patch.object(bridge, "_resolve_callback", return_value=MagicMock()):
+                bridge.generate(
+                    "system", "hello",
+                    TaskSignal(description="hello", tags=["simple"]),
+                    skip_cache=False,
+                )
+
+        assert cache.size == 1
+
+    def test_out_info_backend_is_cache_on_hit(self):
+        """_out_info['backend'] is set to 'cache' on a cache hit."""
+        from skcapstone.model_router import TaskSignal
+
+        cache = ResponseCache()
+        bridge = self._make_bridge(cache)
+
+        signal = TaskSignal(description="hello", tags=["simple"])
+        decision = bridge._router.route(signal)
+        ph = hash_prompt("system", "hello")
+        cache.put(ph, decision.model_name, decision.tier, "cached")
+
+        out: dict = {}
+        result = bridge.generate("system", "hello", signal, _out_info=out)
+        assert result == "cached"
+        assert out.get("backend") == "cache"

package/tests/test_response_scorer.py

@@ -0,0 +1,294 @@
+"""Tests for skcapstone.response_scorer."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from skcapstone.response_scorer import (
+    ResponseScore,
+    _score_coherence,
+    _score_latency,
+    _score_length,
+    score_response,
+)
+
+
+# ---------------------------------------------------------------------------
+# ResponseScore dataclass
+# ---------------------------------------------------------------------------
+
+
+class TestResponseScore:
+    """Tests for ResponseScore construction and overall computation."""
+
+    def test_overall_is_weighted_average(self) -> None:
+        """overall = coherence*0.4 + length*0.3 + latency*0.3."""
+        s = ResponseScore(length_score=1.0, coherence_score=1.0, latency_score=1.0)
+        assert s.overall == 1.0
+
+    def test_overall_zero_all_zeros(self) -> None:
+        """All-zero dimensions → overall 0.0."""
+        s = ResponseScore(length_score=0.0, coherence_score=0.0, latency_score=0.0)
+        assert s.overall == 0.0
+
+    def test_overall_mixed(self) -> None:
+        """Verify weighted formula with asymmetric scores."""
+        s = ResponseScore(length_score=0.0, coherence_score=1.0, latency_score=0.0)
+        # overall = 1.0*0.4 + 0.0*0.3 + 0.0*0.3 = 0.4
+        assert abs(s.overall - 0.4) < 1e-4
+
+    def test_to_dict_has_all_keys(self) -> None:
+        """to_dict contains length, coherence, latency, overall."""
+        s = ResponseScore(length_score=0.8, coherence_score=0.7, latency_score=0.9)
+        d = s.to_dict()
+        assert set(d.keys()) == {"length", "coherence", "latency", "overall"}
+
+    def test_to_dict_values_match(self) -> None:
+        """to_dict values match the dataclass attributes."""
+        s = ResponseScore(length_score=0.5, coherence_score=0.6, latency_score=0.7)
+        d = s.to_dict()
+        assert d["length"] == s.length_score
+        assert d["coherence"] == s.coherence_score
+        assert d["latency"] == s.latency_score
+        assert d["overall"] == s.overall
+
+
+# ---------------------------------------------------------------------------
+# Length scoring
+# ---------------------------------------------------------------------------
+
+
+class TestScoreLength:
+    """Tests for _score_length."""
+
+    def test_empty_response_is_zero(self) -> None:
+        """Empty response → 0.0."""
+        assert _score_length("Tell me about Python", "") == 0.0
+
+    def test_response_in_ideal_range_is_one(self) -> None:
+        """Response in [lo, hi] word range → 1.0."""
+        question = "What is Python?"
+        # question has 3 words → lo=max(10,3)=10, hi=max(50,30)=50
+        response = " ".join(["word"] * 20)
+        assert _score_length(question, response) == 1.0
+
+    def test_very_short_response_penalised(self) -> None:
+        """One-word response for a normal question → score < 0.5."""
+        question = "Explain the history of artificial intelligence in detail."
+        score = _score_length(question, "ok")
+        assert score < 0.5
+
+    def test_very_long_response_penalised_gently(self) -> None:
+        """Extremely long response → score 0.3 (verbose floor)."""
+        question = "Hi"
+        response = " ".join(["word"] * 5000)
+        score = _score_length(question, response)
+        assert score <= 0.5
+
+    def test_long_response_floor_is_0_3(self) -> None:
+        """Length score never drops below 0.3 even for very long responses."""
+        score = _score_length("hello", " ".join(["x"] * 10_000))
+        assert score >= 0.3
+
+    def test_single_word_question(self) -> None:
+        """Single-word question — lo=10; response of 15 words → 1.0."""
+        score = _score_length("Hi", " ".join(["word"] * 15))
+        assert score == 1.0
+
+
+# ---------------------------------------------------------------------------
+# Coherence scoring
+# ---------------------------------------------------------------------------
+
+
+class TestScoreCoherence:
+    """Tests for _score_coherence."""
+
+    def test_empty_response_is_zero(self) -> None:
+        """Empty response → 0.0."""
+        assert _score_coherence("What is Python?", "") == 0.0
+
+    def test_whitespace_response_is_zero(self) -> None:
+        """Whitespace-only response → 0.0."""
+        assert _score_coherence("What is Python?", "   ") == 0.0
+
+    def test_all_keywords_present_is_one(self) -> None:
+        """Response contains all question content words → 1.0."""
+        question = "What is Python?"
+        # 'python' and 'what'? 'what' is a stopword, 'is' is a stopword.
+        # Only 'python' is a content word → 1 keyword
+        response = "Python is a high-level programming language."
+        assert _score_coherence(question, response) == 1.0
+
+    def test_no_keywords_present_is_zero(self) -> None:
+        """Response unrelated to question → low coherence."""
+        question = "Explain neural networks"
+        response = "The weather today is sunny and warm in Paris."
+        score = _score_coherence(question, response)
+        assert score < 0.5
+
+    def test_partial_overlap(self) -> None:
+        """Partial keyword overlap → intermediate score."""
+        question = "Compare Python and JavaScript performance"
+        # Content words: compare, python, javascript, performance
+        response = "Python is great for scripting."
+        # 'python' matches — 1/4 = 0.25
+        score = _score_coherence(question, response)
+        assert 0.0 < score < 1.0
+
+    def test_question_all_stopwords_returns_neutral(self) -> None:
+        """Question with only stopwords → neutral 0.5."""
+        assert _score_coherence("is it the", "yes it is") == 0.5
+
+    def test_case_insensitive(self) -> None:
+        """Matching is case-insensitive."""
+        score = _score_coherence("What is PYTHON?", "python is a language")
+        assert score == 1.0
+
+
+# ---------------------------------------------------------------------------
+# Latency scoring
+# ---------------------------------------------------------------------------
+
+
+class TestScoreLatency:
+    """Tests for _score_latency."""
+
+    def test_zero_latency_is_one(self) -> None:
+        """Zero (or negative) latency → 1.0."""
+        assert _score_latency(0.0) == 1.0
+        assert _score_latency(-100.0) == 1.0
+
+    def test_under_500ms_is_one(self) -> None:
+        """Under 500 ms → 1.0."""
+        assert _score_latency(499.9) == 1.0
+        assert _score_latency(500.0) == 1.0
+
+    def test_1000ms_is_0_9(self) -> None:
+        """1000 ms → 0.9."""
+        assert _score_latency(1000.0) == 0.9
+
+    def test_3000ms_is_0_7(self) -> None:
+        """3000 ms → 0.7."""
+        assert _score_latency(3000.0) == 0.7
+
+    def test_10000ms_is_0_4(self) -> None:
+        """10 s → 0.4."""
+        assert _score_latency(10_000.0) == 0.4
+
+    def test_20000ms_is_0_2(self) -> None:
+        """20 s → 0.2."""
+        assert _score_latency(20_000.0) == 0.2
+
+    def test_over_30s_is_0_1(self) -> None:
+        """Over 30 s → 0.1 (floor)."""
+        assert _score_latency(60_000.0) == 0.1
+        assert _score_latency(30_001.0) == 0.1
+
+
+# ---------------------------------------------------------------------------
+# score_response (integration)
+# ---------------------------------------------------------------------------
+
+
+class TestScoreResponse:
+    """Tests for the public score_response function."""
+
+    def test_returns_response_score(self) -> None:
+        """score_response returns a ResponseScore instance."""
+        result = score_response("What is Python?", "Python is a language.", 300.0)
+        assert isinstance(result, ResponseScore)
+
+    def test_overall_in_range(self) -> None:
+        """overall is always in [0, 1]."""
+        result = score_response("", "", 99999.0)
+        assert 0.0 <= result.overall <= 1.0
+
+    def test_good_response_high_score(self) -> None:
+        """Coherent, appropriately-length, fast response scores >= 0.6."""
+        question = "Explain what Python programming language is used for"
+        response = (
+            "Python is a versatile programming language used for web development, "
+            "data science, automation, and artificial intelligence. It is known for "
+            "its readable syntax and large ecosystem of libraries."
+        )
+        result = score_response(question, response, 800.0)
+        assert result.overall >= 0.6
+
+    def test_empty_response_low_score(self) -> None:
+        """Empty response → low overall score."""
+        result = score_response("Explain the universe", "", 200.0)
+        assert result.overall < 0.4
+
+    def test_slow_response_penalises_latency(self) -> None:
+        """Latency score is low for slow responses."""
+        result = score_response("Hi", "Hello!", 60_000.0)
+        assert result.latency_score == 0.1
+
+    def test_to_dict_is_json_serializable(self) -> None:
+        """score_response().to_dict() can be serialized to JSON."""
+        result = score_response("test question", "test answer", 500.0)
+        serialized = json.dumps(result.to_dict())
+        assert isinstance(serialized, str)
+
+
+# ---------------------------------------------------------------------------
+# ConsciousnessMetrics integration
+# ---------------------------------------------------------------------------
+
+
+class TestConsciousnessMetricsQuality:
+    """Tests for quality scoring integration in ConsciousnessMetrics."""
+
+    @pytest.fixture
+    def cm(self, tmp_path: Path):
+        """ConsciousnessMetrics with no background thread."""
+        from skcapstone.metrics import ConsciousnessMetrics
+        return ConsciousnessMetrics(home=tmp_path, persist_interval=0)
+
+    def test_initial_quality_avg_zeros(self, cm) -> None:
+        """quality_avg returns zeros when nothing recorded."""
+        q = cm.quality_avg()
+        assert q["count"] == 0
+        assert q["overall"] == 0.0
+
+    def test_record_quality_increments_count(self, cm) -> None:
+        """record_quality increments the count."""
+        score = score_response("What is 2+2?", "2+2 equals 4.", 100.0)
+        cm.record_quality(score)
+        cm.record_quality(score)
+        assert cm.quality_avg()["count"] == 2
+
+    def test_quality_avg_computes_mean(self, cm) -> None:
+        """quality_avg computes the average across recorded scores."""
+        s1 = ResponseScore(length_score=1.0, coherence_score=1.0, latency_score=1.0)
+        s2 = ResponseScore(length_score=0.0, coherence_score=0.0, latency_score=0.0)
+        cm.record_quality(s1)
+        cm.record_quality(s2)
+        avg = cm.quality_avg()
+        assert avg["length"] == pytest.approx(0.5, abs=1e-4)
+        assert avg["coherence"] == pytest.approx(0.5, abs=1e-4)
+        assert avg["latency"] == pytest.approx(0.5, abs=1e-4)
+
+    def test_to_dict_includes_quality_avg(self, cm) -> None:
+        """to_dict includes quality_avg key."""
+        d = cm.to_dict()
+        assert "quality_avg" in d
+        assert "count" in d["quality_avg"]
+
+    def test_quality_persists_and_reloads(self, tmp_path: Path) -> None:
+        """Quality sums persist to disk and reload correctly."""
+        from skcapstone.metrics import ConsciousnessMetrics
+
+        cm1 = ConsciousnessMetrics(home=tmp_path, persist_interval=0)
+        score = score_response("capital of France?", "Paris is the capital.", 400.0)
+        cm1.record_quality(score)
+        cm1.save()
+
+        cm2 = ConsciousnessMetrics(home=tmp_path, persist_interval=0)
+        avg = cm2.quality_avg()
+        assert avg["count"] == 1
+        assert abs(avg["overall"] - score.overall) < 1e-4

package/tests/test_runtime.py

@@ -58,3 +58,62 @@ class TestAgentRuntime:
         runtime2.awaken()
         assert len(runtime2.manifest.connectors) == 1
         assert runtime2.manifest.connectors[0].platform == "terminal"
+
+    def test_awaken_populates_skills_state(self, initialized_agent_home: Path):
+        """Awaken should populate manifest.skills from SKSkills discovery."""
+        from skcapstone.models import SkillsState
+
+        runtime = AgentRuntime(home=initialized_agent_home)
+        manifest = runtime.awaken()
+        assert isinstance(manifest.skills, SkillsState)
+
+    def test_pillar_summary_includes_skills(self, initialized_agent_home: Path):
+        """pillar_summary property should include the skills pillar."""
+        runtime = AgentRuntime(home=initialized_agent_home)
+        manifest = runtime.awaken()
+        summary = manifest.pillar_summary
+        assert "skills" in summary
+
+    def test_load_skills_handles_missing_skskills(self, initialized_agent_home: Path):
+        """load_skills() should return None gracefully when skskills is unavailable."""
+        import sys
+        from unittest.mock import patch
+
+        runtime = AgentRuntime(home=initialized_agent_home)
+        runtime.awaken()
+
+        # Patch ImportError to simulate skskills not installed
+        with patch.dict(sys.modules, {"skskills.loader": None, "skskills.registry": None}):
+            result = runtime.load_skills()
+
+        # Returns None when not installed, or a loader when installed
+        assert result is None or hasattr(result, "all_tools")
+
+    def test_load_skills_with_installed_skills(self, initialized_agent_home: Path, tmp_path: Path):
+        """load_skills() should load skills from SKSkills registry."""
+        import os
+        from textwrap import dedent
+        from unittest.mock import patch
+
+        # Create a minimal SKSkills installation
+        skskills_home = tmp_path / "skskills"
+        installed_dir = skskills_home / "installed"
+        skill_dir = installed_dir / "test-skill"
+        skill_dir.mkdir(parents=True)
+        (skill_dir / "skill.yaml").write_text(dedent("""\
+            name: test-skill
+            version: "0.1.0"
+            description: A test skill
+            author:
+              name: tester
+        """))
+
+        runtime = AgentRuntime(home=initialized_agent_home)
+        runtime.awaken()
+
+        with patch.dict(os.environ, {"SKSKILLS_HOME": str(skskills_home)}):
+            loader = runtime.load_skills(agent="global")
+
+        if loader is not None:
+            # SKSkills is installed — verify the skill was loaded
+            assert runtime.manifest.skills.loaded >= 0