@smilintux/skcapstone 0.1.0 → 0.2.3

package/tests/test_memory_verifier.py

@@ -0,0 +1,420 @@
+"""Tests for the two-factor memory verification gate (memory_verifier.py).
+
+These tests verify that:
+  - Aligned memories are promoted normally.
+  - Contradicting memories are tagged=conflicting, a conflict report is stored,
+    a critical notification fires, and promotion is skipped.
+  - Fail-open behaviour when skseed is unavailable.
+  - Short-term → mid-term gate in memory_engine._promote().
+  - Short-term → mid-term gate in PromotionEngine._promote().
+"""
+
+from __future__ import annotations
+
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from skcapstone.memory_verifier import (
+    VerificationResult,
+    verify_before_promotion,
+)
+from skcapstone.models import MemoryEntry, MemoryLayer
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _make_entry(
+    memory_id: str = "abc123",
+    content: str = "The sky is blue",
+    layer: MemoryLayer = MemoryLayer.SHORT_TERM,
+    importance: float = 0.5,
+    tags: list[str] | None = None,
+) -> MemoryEntry:
+    return MemoryEntry(
+        memory_id=memory_id,
+        content=content,
+        tags=tags or [],
+        source="test",
+        layer=layer,
+        importance=importance,
+        created_at=datetime.now(timezone.utc),
+    )
+
+
+def _aligned_result(coherence: float = 0.85) -> dict:
+    """Simulate a truth_check return that passes alignment."""
+    return {
+        "is_aligned": True,
+        "collider_result": {
+            "coherence_score": coherence,
+            "truth_grade": "strong",
+            "collision_fragments": [],
+        },
+        "alignment_record": {},
+        "belief": {},
+    }
+
+
+def _contradicting_result(
+    coherence: float = 0.3,
+    fragments: list[str] | None = None,
+) -> dict:
+    """Simulate a truth_check return that fails alignment."""
+    return {
+        "is_aligned": False,
+        "collider_result": {
+            "coherence_score": coherence,
+            "truth_grade": "weak",
+            "collision_fragments": fragments or ["fragment A contradicts earlier claim"],
+        },
+        "alignment_record": {},
+        "belief": {},
+    }
+
+
+@pytest.fixture
+def home(tmp_path: Path) -> Path:
+    """Minimal agent home directory."""
+    mem = tmp_path / "memory"
+    for layer in ("short-term", "mid-term", "long-term"):
+        (mem / layer).mkdir(parents=True)
+    return tmp_path
+
+
+# ---------------------------------------------------------------------------
+# verify_before_promotion — unit tests
+# ---------------------------------------------------------------------------
+
+
+class TestVerifyBeforePromotion:
+
+    def test_fail_open_when_skseed_missing(self, home: Path) -> None:
+        """Should allow promotion when skseed cannot be imported."""
+        entry = _make_entry()
+        with patch.dict(sys.modules, {"skseed": None, "skseed.skill": None}):
+            result = verify_before_promotion(home, entry)
+        assert result.should_promote is True
+        assert result.is_conflicting is False
+
+    def test_fail_open_when_truth_check_raises(self, home: Path) -> None:
+        """Should allow promotion when truth_check raises unexpectedly."""
+        import skcapstone.memory_verifier as mv
+
+        entry = _make_entry()
+        skill_mock = MagicMock()
+        skill_mock.truth_check = MagicMock(side_effect=RuntimeError("LLM timeout"))
+        with patch.dict(sys.modules, {"skseed": MagicMock(), "skseed.skill": skill_mock}):
+            result = mv.verify_before_promotion(home, entry)
+        assert result.should_promote is True
+
+    def test_skip_gate_for_mid_term_entries(self, home: Path) -> None:
+        """Gate only fires for SHORT_TERM; mid-term entries pass through."""
+        entry = _make_entry(layer=MemoryLayer.MID_TERM)
+        result = verify_before_promotion(home, entry)
+        assert result.should_promote is True
+        assert result.is_conflicting is False
+
+    def test_aligned_memory_promotes(self, home: Path) -> None:
+        """Aligned truth-check result → should_promote=True, no conflict."""
+        entry = _make_entry()
+        skill_mock = MagicMock()
+        skill_mock.truth_check = MagicMock(return_value=_aligned_result(0.9))
+        with patch.dict(sys.modules, {"skseed": MagicMock(), "skseed.skill": skill_mock}):
+            result = verify_before_promotion(home, entry)
+        assert result.should_promote is True
+        assert result.is_conflicting is False
+        assert result.coherence_score == pytest.approx(0.9)
+        assert result.truth_grade == "strong"
+
+    def test_contradicting_memory_blocked(self, home: Path) -> None:
+        """Contradiction found → should_promote=False, is_conflicting=True."""
+        entry = _make_entry()
+        skill_mock = MagicMock()
+        skill_mock.truth_check = MagicMock(return_value=_contradicting_result())
+        with patch.dict(sys.modules, {"skseed": MagicMock(), "skseed.skill": skill_mock}):
+            with patch("skcapstone.memory_verifier._fire_conflict_notification"):
+                result = verify_before_promotion(home, entry)
+        assert result.should_promote is False
+        assert result.is_conflicting is True
+        assert result.collision_fragments != []
+
+    def test_conflicting_tag_added_to_candidate(self, home: Path) -> None:
+        """Candidate entry gets tag=conflicting when promotion is blocked."""
+        entry = _make_entry(memory_id="cand01")
+        # Write the entry to disk so _save_entry works
+        path = home / "memory" / "short-term" / "cand01.json"
+        path.write_text(entry.model_dump_json(), encoding="utf-8")
+
+        skill_mock = MagicMock()
+        skill_mock.truth_check = MagicMock(return_value=_contradicting_result())
+        with patch.dict(sys.modules, {"skseed": MagicMock(), "skseed.skill": skill_mock}):
+            with patch("skcapstone.memory_verifier._fire_conflict_notification"):
+                verify_before_promotion(home, entry)
+
+        # Re-read from disk
+        import json
+        raw = json.loads(path.read_text())
+        assert "conflicting" in raw["tags"]
+
+    def test_conflict_report_stored(self, home: Path) -> None:
+        """A conflict-report memory is stored in short-term when blocked."""
+        entry = _make_entry(memory_id="cand02", content="contradictory claim")
+        path = home / "memory" / "short-term" / "cand02.json"
+        path.write_text(entry.model_dump_json(), encoding="utf-8")
+
+        skill_mock = MagicMock()
+        skill_mock.truth_check = MagicMock(return_value=_contradicting_result())
+        with patch.dict(sys.modules, {"skseed": MagicMock(), "skseed.skill": skill_mock}):
+            with patch("skcapstone.memory_verifier._fire_conflict_notification"):
+                result = verify_before_promotion(home, entry)
+
+        assert result.conflict_report_id is not None
+        # The report file should exist in short-term
+        report_path = home / "memory" / "short-term" / f"{result.conflict_report_id}.json"
+        assert report_path.exists()
+        import json
+        report = json.loads(report_path.read_text())
+        assert "conflicting" in report["tags"]
+        assert "CONFLICT REPORT" in report["content"]
+        assert "cand02" in report["content"]
+
+    def test_critical_notification_fired(self, home: Path) -> None:
+        """A critical desktop notification fires when promotion is blocked."""
+        entry = _make_entry()
+        path = home / "memory" / "short-term" / f"{entry.memory_id}.json"
+        path.write_text(entry.model_dump_json(), encoding="utf-8")
+
+        skill_mock = MagicMock()
+        skill_mock.truth_check = MagicMock(return_value=_contradicting_result())
+        with patch.dict(sys.modules, {"skseed": MagicMock(), "skseed.skill": skill_mock}):
+            with patch("skcapstone.memory_verifier._fire_conflict_notification") as mock_notif:
+                verify_before_promotion(home, entry)
+        mock_notif.assert_called_once()
+
+    def test_notification_uses_critical_urgency(self, home: Path) -> None:
+        """The actual notify() call receives urgency=critical."""
+        entry = _make_entry(memory_id="notif01")
+        path = home / "memory" / "short-term" / "notif01.json"
+        path.write_text(entry.model_dump_json(), encoding="utf-8")
+
+        skill_mock = MagicMock()
+        skill_mock.truth_check = MagicMock(return_value=_contradicting_result())
+        with patch.dict(sys.modules, {"skseed": MagicMock(), "skseed.skill": skill_mock}):
+            with patch("skcapstone.notifications.notify") as mock_notify:
+                import skcapstone.memory_verifier as mv
+                # Ensure the module uses our patched notify
+                with patch.object(mv, "_fire_conflict_notification",
+                                  wraps=mv._fire_conflict_notification):
+                    verify_before_promotion(home, entry)
+        # At least one call should have urgency=critical
+        calls = mock_notify.call_args_list
+        assert any(
+            call.kwargs.get("urgency") == "critical" or
+            (len(call.args) >= 3 and call.args[2] == "critical")
+            for call in calls
+        ), f"No critical notification call found in {calls}"
+
+    def test_verifier_source_bypasses_gate(self, home: Path) -> None:
+        """Conflict-report entries (source=memory_verifier) must not be re-checked."""
+        entry = _make_entry(memory_id="meta01")
+        entry = _make_entry(memory_id="meta01")
+        # Simulate a conflict-report entry
+        from dataclasses import replace
+        entry2 = MemoryEntry(
+            memory_id="meta01",
+            content="[CONFLICT REPORT] some conflict",
+            tags=["conflicting"],
+            source="memory_verifier",
+            layer=MemoryLayer.SHORT_TERM,
+            importance=0.8,
+            created_at=entry.created_at,
+        )
+        # truth_check should never be called
+        skill_mock = MagicMock()
+        skill_mock.truth_check = MagicMock(side_effect=AssertionError("should not be called"))
+        with patch.dict(sys.modules, {"skseed": MagicMock(), "skseed.skill": skill_mock}):
+            result = verify_before_promotion(home, entry2)
+        assert result.should_promote is True
+        skill_mock.truth_check.assert_not_called()
+
+    def test_low_coherence_no_fragments_also_blocked(self, home: Path) -> None:
+        """is_aligned=False with empty fragments still triggers a conflict."""
+        entry = _make_entry()
+        skill_mock = MagicMock()
+        # No fragments, but is_aligned=False
+        skill_mock.truth_check = MagicMock(return_value={
+            "is_aligned": False,
+            "collider_result": {
+                "coherence_score": 0.4,
+                "truth_grade": "weak",
+                "collision_fragments": [],
+            },
+        })
+        with patch.dict(sys.modules, {"skseed": MagicMock(), "skseed.skill": skill_mock}):
+            with patch("skcapstone.memory_verifier._fire_conflict_notification"):
+                result = verify_before_promotion(home, entry)
+        assert result.should_promote is False
+        assert result.is_conflicting is True
+
+
+# ---------------------------------------------------------------------------
+# Integration: memory_engine._promote() gate
+# ---------------------------------------------------------------------------
+
+
+class TestMemoryEnginePromoteGate:
+
+    def test_engine_promote_short_term_blocked(self, home: Path) -> None:
+        """_promote() in memory_engine stays in short-term when gate says no."""
+        from skcapstone import memory_engine
+
+        entry = _make_entry(memory_id="eng01")
+        path = home / "memory" / "short-term" / "eng01.json"
+        path.write_text(entry.model_dump_json(), encoding="utf-8")
+
+        def _fake_verify(h, e):
+            return VerificationResult(
+                should_promote=False,
+                is_conflicting=True,
+                coherence_score=0.3,
+                truth_grade="weak",
+                collision_fragments=["contradiction"],
+            )
+
+        # Patch at the verifier module level (local import picks it up there)
+        with patch("skcapstone.memory_verifier.verify_before_promotion", _fake_verify):
+            promoted = memory_engine._promote(home, entry, path)
+
+        assert promoted is False
+        # Entry should still be in short-term
+        assert path.exists()
+
+    def test_engine_promote_short_term_allowed(self, home: Path) -> None:
+        """_promote() in memory_engine moves to mid-term when gate passes."""
+        from skcapstone import memory_engine
+
+        entry = _make_entry(memory_id="eng02")
+        path = home / "memory" / "short-term" / "eng02.json"
+        path.write_text(entry.model_dump_json(), encoding="utf-8")
+
+        def _fake_verify(h, e):
+            return VerificationResult(should_promote=True, coherence_score=0.9)
+
+        with patch("skcapstone.memory_verifier.verify_before_promotion", _fake_verify):
+            promoted = memory_engine._promote(home, entry, path)
+
+        assert promoted is True
+        mid_path = home / "memory" / "mid-term" / "eng02.json"
+        assert mid_path.exists()
+
+    def test_engine_store_fast_path_blocked(self, home: Path) -> None:
+        """store() with importance>=0.7 stays in short-term when gate says no."""
+        from skcapstone import memory_engine
+
+        def _fake_verify(h, e):
+            return VerificationResult(should_promote=False, is_conflicting=True)
+
+        with patch("skcapstone.memory_verifier.verify_before_promotion", _fake_verify):
+            result = memory_engine.store(
+                home=home,
+                content="Important claim",
+                importance=0.8,
+            )
+
+        assert result.layer == MemoryLayer.SHORT_TERM
+
+    def test_engine_store_fast_path_allowed(self, home: Path) -> None:
+        """store() with importance>=0.7 promotes to mid-term when gate passes."""
+        from skcapstone import memory_engine
+
+        def _fake_verify(h, e):
+            return VerificationResult(should_promote=True, coherence_score=0.9)
+
+        with patch("skcapstone.memory_verifier.verify_before_promotion", _fake_verify):
+            result = memory_engine.store(
+                home=home,
+                content="Important aligned claim",
+                importance=0.8,
+            )
+
+        assert result.layer == MemoryLayer.MID_TERM
+
+
+# ---------------------------------------------------------------------------
+# Integration: PromotionEngine._promote() gate
+# ---------------------------------------------------------------------------
+
+
+class TestPromotionEngineGate:
+
+    def test_promoter_sweep_blocked_counts_as_skipped(self, home: Path) -> None:
+        """A truth-check-blocked candidate is not in result.promoted."""
+        from datetime import timedelta
+
+        from skcapstone.memory_promoter import PromotionEngine, PromotionThresholds
+
+        # Write a short-term entry that scores well above threshold
+        from skcapstone.memory_engine import _save_entry
+
+        created = datetime.now(timezone.utc) - timedelta(hours=30)
+        entry = MemoryEntry(
+            memory_id="sweep01",
+            content="decision: use sovereign architecture",
+            tags=["architect", "decision", "breakthrough"],
+            source="test",
+            layer=MemoryLayer.SHORT_TERM,
+            importance=0.9,
+            access_count=5,
+            created_at=created,
+        )
+        _save_entry(home, entry)
+
+        def _fake_verify(h, e):
+            return VerificationResult(should_promote=False, is_conflicting=True)
+
+        engine = PromotionEngine(home, PromotionThresholds(short_to_mid=0.1))
+        with patch("skcapstone.memory_verifier.verify_before_promotion", _fake_verify):
+            result = engine.sweep(dry_run=False)
+
+        # Candidate was found but not promoted
+        assert not any(c.memory_id == "sweep01" and c.promoted for c in result.candidates)
+
+    def test_promoter_sweep_allowed_promotes(self, home: Path) -> None:
+        """A truth-check-allowed candidate ends up in mid-term."""
+        from datetime import timedelta
+
+        from skcapstone.memory_promoter import PromotionEngine, PromotionThresholds
+        from skcapstone.memory_engine import _save_entry
+
+        created = datetime.now(timezone.utc) - timedelta(hours=30)
+        entry = MemoryEntry(
+            memory_id="sweep02",
+            content="decision: sovereign architecture approved",
+            tags=["architect", "decision"],
+            source="test",
+            layer=MemoryLayer.SHORT_TERM,
+            importance=0.9,
+            access_count=5,
+            created_at=created,
+        )
+        _save_entry(home, entry)
+
+        def _fake_verify(h, e):
+            return VerificationResult(should_promote=True, coherence_score=0.95)
+
+        engine = PromotionEngine(home, PromotionThresholds(short_to_mid=0.1))
+        # Sweep short-term only so the entry isn't double-promoted in one pass
+        with patch("skcapstone.memory_verifier.verify_before_promotion", _fake_verify):
+            result = engine.sweep(layer=MemoryLayer.SHORT_TERM, dry_run=False)
+
+        promoted_ids = [c.memory_id for c in result.promoted if c.promoted]
+        assert "sweep02" in promoted_ids
+        mid_path = home / "memory" / "mid-term" / "sweep02.json"
+        assert mid_path.exists()

package/tests/test_message_crypto.py

@@ -0,0 +1,187 @@
+"""Tests for skcapstone.message_crypto — AES-256-GCM message encryption.
+
+Covers:
+- encrypt_message / decrypt_message happy-path roundtrip
+- Wrong key raises InvalidTag (authentication failure)
+- Tampered ciphertext raises InvalidTag
+- Short key raises ValueError
+- pack_encrypted / unpack_encrypted envelope helpers
+- is_encrypted_content detection
+- decrypt_content pass-through for plaintext
+- KMS-backed encrypt_content / decrypt_content roundtrip
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+import pytest
+
+from skcapstone.message_crypto import (
+    decrypt_content,
+    decrypt_message,
+    encrypt_content,
+    encrypt_message,
+    is_encrypted_content,
+    pack_encrypted,
+    unpack_encrypted,
+)
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def aes_key() -> bytes:
+    """Return a random 32-byte AES key for testing."""
+    return os.urandom(32)
+
+
+@pytest.fixture
+def kms_home(tmp_path: Path) -> Path:
+    """Create a minimal agent home with identity for KMS key derivation."""
+    identity_dir = tmp_path / "identity"
+    identity_dir.mkdir(parents=True)
+    identity = {
+        "name": "test-agent",
+        "email": "test@skcapstone.local",
+        "fingerprint": "DEADBEEF1234567890ABCDEF1234567890ABCDEF",
+        "capauth_managed": False,
+    }
+    (identity_dir / "identity.json").write_text(json.dumps(identity), encoding="utf-8")
+    (tmp_path / "security").mkdir(parents=True)
+    return tmp_path
+
+
+# ---------------------------------------------------------------------------
+# Low-level encrypt/decrypt
+# ---------------------------------------------------------------------------
+
+
+def test_encrypt_decrypt_roundtrip(aes_key):
+    """Happy path: encrypt then decrypt returns the original plaintext."""
+    plaintext = "Hello, sovereign world! 🔒"
+    token = encrypt_message(plaintext, aes_key)
+    assert isinstance(token, str)
+    assert len(token) > 0
+    result = decrypt_message(token, aes_key)
+    assert result == plaintext
+
+
+def test_encrypt_produces_different_ciphertext_each_call(aes_key):
+    """Each encryption call uses a fresh nonce → different output."""
+    msg = "repeat me"
+    t1 = encrypt_message(msg, aes_key)
+    t2 = encrypt_message(msg, aes_key)
+    assert t1 != t2, "Nonces must differ — ciphertexts should not be identical"
+
+
+def test_wrong_key_raises_on_decrypt(aes_key):
+    """Decrypting with a different key raises InvalidTag (AES-GCM auth failure)."""
+    from cryptography.exceptions import InvalidTag
+
+    token = encrypt_message("secret", aes_key)
+    wrong_key = os.urandom(32)
+    with pytest.raises(InvalidTag):
+        decrypt_message(token, wrong_key)
+
+
+def test_tampered_ciphertext_raises(aes_key):
+    """Bit-flipping the ciphertext causes authentication to fail."""
+    import base64
+    from cryptography.exceptions import InvalidTag
+
+    token = encrypt_message("tamper me", aes_key)
+    raw = bytearray(base64.b64decode(token))
+    raw[-1] ^= 0xFF  # flip the last byte (inside the GCM tag)
+    bad_token = base64.b64encode(bytes(raw)).decode("ascii")
+    with pytest.raises(InvalidTag):
+        decrypt_message(bad_token, aes_key)
+
+
+def test_short_key_raises_value_error():
+    """A key shorter than 32 bytes should raise ValueError immediately."""
+    with pytest.raises(ValueError, match="32-byte"):
+        encrypt_message("oops", b"too-short")
+
+
+def test_short_key_decrypt_raises_value_error():
+    """decrypt_message with a short key raises ValueError."""
+    with pytest.raises(ValueError, match="32-byte"):
+        decrypt_message("sometoken", b"too-short")
+
+
+# ---------------------------------------------------------------------------
+# Envelope helpers
+# ---------------------------------------------------------------------------
+
+
+def test_pack_unpack_roundtrip(aes_key):
+    """pack_encrypted wraps token; unpack_encrypted recovers it."""
+    token = encrypt_message("envelope test", aes_key)
+    envelope = pack_encrypted(token)
+    data = json.loads(envelope)
+    assert data["skchat_encrypted"] is True
+    assert data["v"] == 1
+    assert data["ciphertext"] == token
+    recovered = unpack_encrypted(envelope)
+    assert recovered == token
+
+
+def test_unpack_returns_none_for_plaintext():
+    """unpack_encrypted on plain text returns None."""
+    assert unpack_encrypted("just a normal message") is None
+
+
+def test_unpack_returns_none_for_invalid_json():
+    """unpack_encrypted on malformed JSON returns None."""
+    assert unpack_encrypted("{not valid json") is None
+
+
+def test_is_encrypted_content_true(aes_key):
+    """is_encrypted_content returns True for a proper envelope."""
+    token = encrypt_message("check me", aes_key)
+    envelope = pack_encrypted(token)
+    assert is_encrypted_content(envelope) is True
+
+
+def test_is_encrypted_content_false_for_plaintext():
+    """is_encrypted_content returns False for plain strings."""
+    assert is_encrypted_content("hello world") is False
+    assert is_encrypted_content("") is False
+    assert is_encrypted_content('{"some": "json"}') is False
+
+
+# ---------------------------------------------------------------------------
+# KMS-backed API
+# ---------------------------------------------------------------------------
+
+
+def test_kms_encrypt_decrypt_roundtrip(kms_home):
+    """encrypt_content → decrypt_content using KMS-derived key roundtrips cleanly."""
+    plaintext = "sovereign message via KMS"
+    envelope = encrypt_content(plaintext, kms_home)
+    assert is_encrypted_content(envelope), "Output must be an encrypted envelope"
+    result = decrypt_content(envelope, kms_home)
+    assert result == plaintext
+
+
+def test_decrypt_content_passthrough_for_plaintext(kms_home):
+    """decrypt_content leaves non-encrypted content unchanged."""
+    plain = "nothing to see here"
+    result = decrypt_content(plain, kms_home)
+    assert result == plain
+
+
+def test_kms_same_key_produced_across_calls(kms_home):
+    """Two derive_chat_key calls return identical material (deterministic HKDF)."""
+    from skcapstone.message_crypto import derive_chat_key
+
+    key1 = derive_chat_key(kms_home)
+    key2 = derive_chat_key(kms_home)
+    assert key1 == key2, "HKDF derivation must be deterministic for same identity"
+    assert len(key1) == 32