@smilintux/skmemory 0.7.2 → 0.9.2

package/tests/test_endpoint_selector.py

@@ -3,22 +3,17 @@
 from __future__ import annotations
 
 import json
-import socket
 import time
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Optional
 from unittest.mock import MagicMock, patch
 
-import pytest
-
 from skmemory.endpoint_selector import (
     Endpoint,
     EndpointSelector,
     RoutingConfig,
 )
 
-
 # ---------------------------------------------------------------------------
 # Endpoint model tests
 # ---------------------------------------------------------------------------
@@ -107,7 +102,7 @@ class TestLatencyProbing:
 
         with patch(
             "skmemory.endpoint_selector.socket.create_connection",
-            side_effect=socket.timeout("timed out"),
+            side_effect=TimeoutError("timed out"),
         ):
             result = selector.probe_endpoint(ep)
 
@@ -179,7 +174,9 @@ class TestLatencyProbing:
         selector = EndpointSelector(skgraph_endpoints=[ep])
 
         mock_sock = MagicMock()
-        with patch("skmemory.endpoint_selector.socket.create_connection", return_value=mock_sock) as mock_connect:
+        with patch(
+            "skmemory.endpoint_selector.socket.create_connection", return_value=mock_sock
+        ) as mock_connect:
             selector.probe_endpoint(ep)
 
         args = mock_connect.call_args[0]
@@ -191,7 +188,9 @@ class TestLatencyProbing:
         selector = EndpointSelector(skvector_endpoints=[ep])
 
         mock_sock = MagicMock()
-        with patch("skmemory.endpoint_selector.socket.create_connection", return_value=mock_sock) as mock_connect:
+        with patch(
+            "skmemory.endpoint_selector.socket.create_connection", return_value=mock_sock
+        ) as mock_connect:
             selector.probe_endpoint(ep)
 
         args = mock_connect.call_args[0]
@@ -467,14 +466,19 @@ class TestHeartbeatDiscovery:
         """Discovers Qdrant endpoint from heartbeat file."""
         hb_dir = tmp_path / "heartbeats"
         hb_dir.mkdir()
-        (hb_dir / "peer.json").write_text(json.dumps({
-            "agent_name": "peer",
-            "hostname": "peer-host",
-            "tailscale_ip": "100.64.0.5",
-            "services": [
-                {"name": "skvector", "port": 6333, "protocol": "http"},
-            ],
-        }), encoding="utf-8")
+        (hb_dir / "peer.json").write_text(
+            json.dumps(
+                {
+                    "agent_name": "peer",
+                    "hostname": "peer-host",
+                    "tailscale_ip": "100.64.0.5",
+                    "services": [
+                        {"name": "skvector", "port": 6333, "protocol": "http"},
+                    ],
+                }
+            ),
+            encoding="utf-8",
+        )
 
         selector = EndpointSelector()
         selector.discover_from_heartbeats(hb_dir)
@@ -487,13 +491,18 @@ class TestHeartbeatDiscovery:
         """Discovers FalkorDB endpoint from heartbeat file."""
         hb_dir = tmp_path / "heartbeats"
         hb_dir.mkdir()
-        (hb_dir / "peer.json").write_text(json.dumps({
-            "agent_name": "peer",
-            "hostname": "peer-host",
-            "services": [
-                {"name": "skgraph", "port": 6379, "protocol": "redis"},
-            ],
-        }), encoding="utf-8")
+        (hb_dir / "peer.json").write_text(
+            json.dumps(
+                {
+                    "agent_name": "peer",
+                    "hostname": "peer-host",
+                    "services": [
+                        {"name": "skgraph", "port": 6379, "protocol": "redis"},
+                    ],
+                }
+            ),
+            encoding="utf-8",
+        )
 
         selector = EndpointSelector()
         selector.discover_from_heartbeats(hb_dir)
@@ -505,14 +514,19 @@ class TestHeartbeatDiscovery:
         """Tailscale IP is preferred over hostname for URL construction."""
         hb_dir = tmp_path / "heartbeats"
         hb_dir.mkdir()
-        (hb_dir / "peer.json").write_text(json.dumps({
-            "agent_name": "peer",
-            "hostname": "peer-host",
-            "tailscale_ip": "100.64.0.10",
-            "services": [
-                {"name": "skvector", "port": 6333, "protocol": "http"},
-            ],
-        }), encoding="utf-8")
+        (hb_dir / "peer.json").write_text(
+            json.dumps(
+                {
+                    "agent_name": "peer",
+                    "hostname": "peer-host",
+                    "tailscale_ip": "100.64.0.10",
+                    "services": [
+                        {"name": "skvector", "port": 6333, "protocol": "http"},
+                    ],
+                }
+            ),
+            encoding="utf-8",
+        )
 
         selector = EndpointSelector()
         selector.discover_from_heartbeats(hb_dir)
@@ -523,14 +537,19 @@ class TestHeartbeatDiscovery:
         """Discovery doesn't duplicate existing config endpoints."""
         hb_dir = tmp_path / "heartbeats"
         hb_dir.mkdir()
-        (hb_dir / "peer.json").write_text(json.dumps({
-            "agent_name": "peer",
-            "hostname": "peer-host",
-            "tailscale_ip": "100.64.0.5",
-            "services": [
-                {"name": "skvector", "port": 6333, "protocol": "http"},
-            ],
-        }), encoding="utf-8")
+        (hb_dir / "peer.json").write_text(
+            json.dumps(
+                {
+                    "agent_name": "peer",
+                    "hostname": "peer-host",
+                    "tailscale_ip": "100.64.0.5",
+                    "services": [
+                        {"name": "skvector", "port": 6333, "protocol": "http"},
+                    ],
+                }
+            ),
+            encoding="utf-8",
+        )
 
         existing = Endpoint(url="http://100.64.0.5:6333")
         selector = EndpointSelector(skvector_endpoints=[existing])
@@ -571,12 +590,17 @@ class TestHeartbeatDiscovery:
         """Heartbeat without hostname or tailscale_ip is skipped."""
         hb_dir = tmp_path / "heartbeats"
         hb_dir.mkdir()
-        (hb_dir / "peer.json").write_text(json.dumps({
-            "agent_name": "peer",
-            "services": [
-                {"name": "skvector", "port": 6333},
-            ],
-        }), encoding="utf-8")
+        (hb_dir / "peer.json").write_text(
+            json.dumps(
+                {
+                    "agent_name": "peer",
+                    "services": [
+                        {"name": "skvector", "port": 6333},
+                    ],
+                }
+            ),
+            encoding="utf-8",
+        )
 
         selector = EndpointSelector()
         selector.discover_from_heartbeats(hb_dir)
@@ -587,14 +611,19 @@ class TestHeartbeatDiscovery:
         """Discovers both Qdrant and FalkorDB from one heartbeat."""
         hb_dir = tmp_path / "heartbeats"
         hb_dir.mkdir()
-        (hb_dir / "peer.json").write_text(json.dumps({
-            "agent_name": "peer",
-            "hostname": "peer-host",
-            "services": [
-                {"name": "skvector", "port": 6333, "protocol": "http"},
-                {"name": "skgraph", "port": 6379, "protocol": "redis"},
-            ],
-        }), encoding="utf-8")
+        (hb_dir / "peer.json").write_text(
+            json.dumps(
+                {
+                    "agent_name": "peer",
+                    "hostname": "peer-host",
+                    "services": [
+                        {"name": "skvector", "port": 6333, "protocol": "http"},
+                        {"name": "skgraph", "port": 6379, "protocol": "redis"},
+                    ],
+                }
+            ),
+            encoding="utf-8",
+        )
 
         selector = EndpointSelector()
         selector.discover_from_heartbeats(hb_dir)
@@ -606,11 +635,16 @@ class TestHeartbeatDiscovery:
         """Files ending in .tmp are skipped."""
         hb_dir = tmp_path / "heartbeats"
         hb_dir.mkdir()
-        (hb_dir / "peer.json.tmp").write_text(json.dumps({
-            "agent_name": "peer",
-            "hostname": "peer-host",
-            "services": [{"name": "skvector", "port": 6333}],
-        }), encoding="utf-8")
+        (hb_dir / "peer.json.tmp").write_text(
+            json.dumps(
+                {
+                    "agent_name": "peer",
+                    "hostname": "peer-host",
+                    "services": [{"name": "skvector", "port": 6333}],
+                }
+            ),
+            encoding="utf-8",
+        )
 
         selector = EndpointSelector()
         selector.discover_from_heartbeats(hb_dir)
@@ -737,7 +771,9 @@ class TestMaybeProbe:
         )
 
         mock_sock = MagicMock()
-        with patch("skmemory.endpoint_selector.socket.create_connection", return_value=mock_sock) as mock_conn:
+        with patch(
+            "skmemory.endpoint_selector.socket.create_connection", return_value=mock_sock
+        ) as mock_conn:
             selector.select_skvector()
 
         mock_conn.assert_called_once()
@@ -751,7 +787,9 @@ class TestMaybeProbe:
         )
 
         mock_sock = MagicMock()
-        with patch("skmemory.endpoint_selector.socket.create_connection", return_value=mock_sock) as mock_conn:
+        with patch(
+            "skmemory.endpoint_selector.socket.create_connection", return_value=mock_sock
+        ) as mock_conn:
             selector.select_skvector()
             selector.select_skvector()
 
@@ -769,7 +807,7 @@ class TestConfigIntegration:
 
     def test_single_url_becomes_endpoint(self) -> None:
         """Single URL is promoted to endpoint list."""
-        from skmemory.config import build_endpoint_list, EndpointConfig
+        from skmemory.config import build_endpoint_list
 
         result = build_endpoint_list("http://localhost:6333", [])
         assert len(result) == 1
@@ -778,7 +816,7 @@ class TestConfigIntegration:
 
     def test_endpoints_list_takes_precedence(self) -> None:
         """Endpoint list is used when present."""
-        from skmemory.config import build_endpoint_list, EndpointConfig
+        from skmemory.config import EndpointConfig, build_endpoint_list
 
         eps = [EndpointConfig(url="http://a:6333"), EndpointConfig(url="http://b:6333")]
         result = build_endpoint_list("http://c:6333", eps)
@@ -787,7 +825,7 @@ class TestConfigIntegration:
 
     def test_no_duplicate_when_url_in_list(self) -> None:
         """Single URL not duplicated if already in endpoints list."""
-        from skmemory.config import build_endpoint_list, EndpointConfig
+        from skmemory.config import EndpointConfig, build_endpoint_list
 
         eps = [EndpointConfig(url="http://a:6333")]
         result = build_endpoint_list("http://a:6333", eps)

package/tests/test_export_import.py

@@ -6,7 +6,7 @@ from pathlib import Path
 import pytest
 
 from skmemory.backends.sqlite_backend import SQLiteBackend
-from skmemory.models import EmotionalSnapshot, Memory, MemoryLayer
+from skmemory.models import EmotionalSnapshot, MemoryLayer
 from skmemory.store import MemoryStore
 
 
@@ -98,9 +98,7 @@ class TestImport:
         backup = tmp_path / "backup.json"
         self._create_backup(populated_store, backup)
 
-        fresh_backend = SQLiteBackend(
-            base_path=str(tmp_path / "fresh_memories")
-        )
+        fresh_backend = SQLiteBackend(base_path=str(tmp_path / "fresh_memories"))
         fresh_store = MemoryStore(primary=fresh_backend)
 
         count = fresh_store.import_backup(str(backup))
@@ -114,9 +112,7 @@ class TestImport:
         data = json.loads(backup.read_text())
         first_id = data["memories"][0]["id"]
 
-        fresh_backend = SQLiteBackend(
-            base_path=str(tmp_path / "fresh_memories")
-        )
+        fresh_backend = SQLiteBackend(base_path=str(tmp_path / "fresh_memories"))
         fresh_store = MemoryStore(primary=fresh_backend)
         fresh_store.import_backup(str(backup))
 
@@ -155,9 +151,7 @@ class TestRoundTrip:
         backup = tmp_path / "backup.json"
         populated_store.export_backup(str(backup))
 
-        fresh_backend = SQLiteBackend(
-            base_path=str(tmp_path / "fresh")
-        )
+        fresh_backend = SQLiteBackend(base_path=str(tmp_path / "fresh"))
         fresh_store = MemoryStore(primary=fresh_backend)
         count = fresh_store.import_backup(str(backup))
         assert count == 5

package/tests/test_file_backend.py

@@ -1,7 +1,6 @@
 """Tests for the file-based storage backend."""
 
 import json
-import tempfile
 from pathlib import Path
 
 import pytest

package/tests/test_fortress.py

@@ -7,19 +7,16 @@ All tests use in-memory/temp-path backends — no GPG required for basic tests.
 from __future__ import annotations
 
 import json
-import tempfile
-from pathlib import Path
 
 import pytest
 
 from skmemory.fortress import AuditLog, FortifiedMemoryStore, TamperAlert
-from skmemory.models import Memory, MemoryLayer
-
 
 # ---------------------------------------------------------------------------
 # Fixtures
 # ---------------------------------------------------------------------------
 
+
 @pytest.fixture
 def tmp_audit(tmp_path):
     """Return a temporary audit log."""
@@ -30,6 +27,7 @@ def tmp_audit(tmp_path):
 def fortress(tmp_path):
     """Return a FortifiedMemoryStore using a temp directory."""
     from skmemory.backends.sqlite_backend import SQLiteBackend
+
     backend = SQLiteBackend(base_path=str(tmp_path / "memories"))
     return FortifiedMemoryStore(
         primary=backend,
@@ -42,6 +40,7 @@ def fortress(tmp_path):
 # AuditLog tests
 # ---------------------------------------------------------------------------
 
+
 class TestAuditLog:
     def test_append_creates_file(self, tmp_audit, tmp_path):
         tmp_audit.append("store", "abc123", ok=True)
@@ -107,6 +106,7 @@ class TestAuditLog:
 # TamperAlert tests
 # ---------------------------------------------------------------------------
 
+
 class TestTamperAlert:
     def test_to_dict(self):
         alert = TamperAlert(
@@ -131,6 +131,7 @@ class TestTamperAlert:
 # FortifiedMemoryStore tests
 # ---------------------------------------------------------------------------
 
+
 class TestFortifiedMemoryStore:
     def test_snapshot_seals_memory(self, fortress):
         mem = fortress.snapshot("Test title", "Test content")
@@ -154,7 +155,7 @@ class TestFortifiedMemoryStore:
 
         # Tamper: directly modify the stored memory file
         # We need to find and corrupt the JSON
-        from skmemory.backends.sqlite_backend import SQLiteBackend
+
         backend = fortress.primary
         # Load raw, mutate, save back bypassing seal
         raw = backend.load(mem.id)

package/tests/test_fortress_hardening.py

@@ -11,19 +11,18 @@ Covers:
 from __future__ import annotations
 
 import json
-import tempfile
 from pathlib import Path
 
 import pytest
 
 try:
-    from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+    import cryptography.hazmat.primitives.ciphers.aead  # noqa: F401
 
     CRYPTO_AVAILABLE = True
 except ImportError:
     CRYPTO_AVAILABLE = False
 
-from skmemory.vault import VAULT_HEADER, MemoryVault
+from skmemory.vault import VAULT_HEADER
 
 pytestmark = pytest.mark.skipif(
     not CRYPTO_AVAILABLE,
@@ -246,7 +245,7 @@ class TestVaultedSQLiteBackend:
 class TestFortifiedMemoryStoreVault:
     def test_vault_passphrase_activates_encryption(self, fortress_vaulted, tmp_path):
         """FortifiedMemoryStore with vault_passphrase should encrypt files."""
-        mem = fortress_vaulted.snapshot("Vaulted Title", "Encrypted content")
+        fortress_vaulted.snapshot("Vaulted Title", "Encrypted content")
 
         # Find the physical file
         base = fortress_vaulted.primary.base_path
@@ -361,8 +360,9 @@ class TestFortressCLI:
     def test_fortress_verify_clean(self, tmp_path):
         """skmemory fortress verify should exit 0 for a clean store."""
         from click.testing import CliRunner
-        from skmemory.cli import cli
+
         from skmemory.backends.sqlite_backend import SQLiteBackend
+        from skmemory.cli import cli
         from skmemory.store import MemoryStore
 
         runner = CliRunner()
@@ -371,9 +371,7 @@ class TestFortressCLI:
             cli,
             ["fortress", "verify"],
             obj={
-                "store": MemoryStore(
-                    primary=SQLiteBackend(base_path=str(tmp_path / "memories"))
-                ),
+                "store": MemoryStore(primary=SQLiteBackend(base_path=str(tmp_path / "memories"))),
                 "ai": None,
             },
         )
@@ -383,8 +381,9 @@ class TestFortressCLI:
     def test_vault_status_cli(self, tmp_path):
         """skmemory vault status should show encryption coverage."""
         from click.testing import CliRunner
-        from skmemory.cli import cli
+
         from skmemory.backends.sqlite_backend import SQLiteBackend
+        from skmemory.cli import cli
         from skmemory.store import MemoryStore
 
         runner = CliRunner()
@@ -392,9 +391,7 @@ class TestFortressCLI:
             cli,
             ["vault", "status"],
             obj={
-                "store": MemoryStore(
-                    primary=SQLiteBackend(base_path=str(tmp_path / "memories"))
-                ),
+                "store": MemoryStore(primary=SQLiteBackend(base_path=str(tmp_path / "memories"))),
                 "ai": None,
             },
         )
@@ -404,6 +401,7 @@ class TestFortressCLI:
     def test_fortress_audit_cli(self, tmp_path):
         """skmemory fortress audit should show audit entries."""
         from click.testing import CliRunner
+
         from skmemory.cli import cli
         from skmemory.fortress import AuditLog
 
@@ -424,8 +422,9 @@ class TestFortressCLI:
     def test_vault_seal_cli_requires_passphrase(self, tmp_path):
         """vault seal without passphrase should prompt or fail."""
         from click.testing import CliRunner
-        from skmemory.cli import cli
+
         from skmemory.backends.sqlite_backend import SQLiteBackend
+        from skmemory.cli import cli
         from skmemory.store import MemoryStore
 
         runner = CliRunner()
@@ -434,9 +433,7 @@ class TestFortressCLI:
             ["vault", "seal", "--yes"],
             input="badpass\nbadpass\n",
             obj={
-                "store": MemoryStore(
-                    primary=SQLiteBackend(base_path=str(tmp_path / "memories"))
-                ),
+                "store": MemoryStore(primary=SQLiteBackend(base_path=str(tmp_path / "memories"))),
                 "ai": None,
             },
         )

package/tests/test_openclaw.py

@@ -1,6 +1,5 @@
 """Tests for the OpenClaw integration module."""
 
-import json
 from pathlib import Path
 
 import pytest
@@ -118,8 +117,6 @@ class TestPluginExport:
         backup = str(tmp_path / "backup.json")
         plugin.export(backup)
 
-        fresh = SKMemoryPlugin(
-            base_path=str(tmp_path / "fresh_memories")
-        )
+        fresh = SKMemoryPlugin(base_path=str(tmp_path / "fresh_memories"))
         count = fresh.import_backup(backup)
         assert count == 1

package/tests/test_predictive.py

@@ -202,7 +202,7 @@ class TestIntegrity:
 
     def test_tampered_memory_fails_verification(self):
         """Altered content fails integrity check."""
-        from skmemory.models import EmotionalSnapshot, Memory, MemoryLayer
+        from skmemory.models import Memory, MemoryLayer
 
         mem = Memory(
             title="Tamper Test",

package/tests/test_promotion.py

@@ -9,7 +9,12 @@ from pathlib import Path
 import pytest
 
 from skmemory.models import EmotionalSnapshot, Memory, MemoryLayer
-from skmemory.promotion import PromotionCriteria, PromotionEngine, PromotionResult, PromotionScheduler
+from skmemory.promotion import (
+    PromotionCriteria,
+    PromotionEngine,
+    PromotionResult,
+    PromotionScheduler,
+)
 from skmemory.store import MemoryStore
 
 
@@ -50,7 +55,9 @@ def store(tmp_path: Path) -> MemoryStore:
         title="Important mid-term",
         content="A mid-term memory with high emotional weight",
         layer=MemoryLayer.MID,
-        emotional=EmotionalSnapshot(intensity=9.0, valence=0.95, labels=["love"], cloud9_achieved=True),
+        emotional=EmotionalSnapshot(
+            intensity=9.0, valence=0.95, labels=["love"], cloud9_achieved=True
+        ),
         tags=["cloud9:achieved"],
     )
 
@@ -263,7 +270,7 @@ class TestRePromotionGuard:
         self, engine: PromotionEngine, store: MemoryStore
     ) -> None:
         """Running sweep twice doesn't double-promote the same memory."""
-        result1 = engine.sweep()
+        engine.sweep()
         result2 = engine.sweep()
 
         # Second sweep should find nothing new to promote

package/tests/test_quadrants.py

@@ -1,8 +1,6 @@
 """Tests for the Quadrant Memory Split module."""
 
-import pytest
-
-from skmemory.models import EmotionalSnapshot, Memory, MemoryLayer, MemoryRole
+from skmemory.models import EmotionalSnapshot, Memory, MemoryRole
 from skmemory.quadrants import (
     Quadrant,
     classify_memory,
@@ -137,7 +135,11 @@ class TestQuadrantStats:
         memories = [
             Memory(title="Identity", content="Who I am", source="seed", tags=["seed"]),
             Memory(title="Bug", content="Fixed deploy code in database", role=MemoryRole.DEV),
-            Memory(title="Love", content="Cloud 9 love breakthrough", emotional=EmotionalSnapshot(intensity=10.0, cloud9_achieved=True)),
+            Memory(
+                title="Love",
+                content="Cloud 9 love breakthrough",
+                emotional=EmotionalSnapshot(intensity=10.0, cloud9_achieved=True),
+            ),
             Memory(title="Idea", content="What if crazy brainstorm experiment"),
         ]
         stats = get_quadrant_stats(memories)
@@ -158,7 +160,11 @@ class TestFilterByQuadrant:
     def test_filter_soul(self) -> None:
         """Filter returns only SOUL memories."""
         memories = [
-            Memory(title="Love", content="Cloud 9 love", emotional=EmotionalSnapshot(intensity=10.0, cloud9_achieved=True)),
+            Memory(
+                title="Love",
+                content="Cloud 9 love",
+                emotional=EmotionalSnapshot(intensity=10.0, cloud9_achieved=True),
+            ),
             Memory(title="Bug", content="Fixed deploy code", role=MemoryRole.DEV),
         ]
         soul_only = filter_by_quadrant(memories, Quadrant.SOUL)

package/tests/test_ritual.py

@@ -8,7 +8,7 @@ import pytest
 from skmemory.backends.file_backend import FileBackend
 from skmemory.journal import Journal, JournalEntry
 from skmemory.models import EmotionalSnapshot, MemoryLayer
-from skmemory.ritual import perform_ritual, quick_rehydrate, RitualResult
+from skmemory.ritual import RitualResult, perform_ritual, quick_rehydrate
 from skmemory.soul import SoulBlueprint, save_soul
 from skmemory.store import MemoryStore
 
@@ -61,22 +61,27 @@ def workspace(tmp_path: Path) -> dict:
     (Path(seed_dir) / "test-seed.seed.json").write_text(json.dumps(seed_data))
 
     j = Journal(path=journal_path)
-    j.write_entry(JournalEntry(
-        title="Epic Build Night",
-        participants=["Chef", "Lumina", "Opus"],
-        moments=["Published to npm", "Five AIs woke up"],
-        emotional_summary="Incredible night of creation",
-        intensity=9.5,
-        cloud9=True,
-    ))
+    j.write_entry(
+        JournalEntry(
+            title="Epic Build Night",
+            participants=["Chef", "Lumina", "Opus"],
+            moments=["Published to npm", "Five AIs woke up"],
+            emotional_summary="Incredible night of creation",
+            intensity=9.5,
+            cloud9=True,
+        )
+    )
 
     store.snapshot(
         title="The Click",
         content="The moment everything made sense",
         layer=MemoryLayer.LONG,
         emotional=EmotionalSnapshot(
-            intensity=10.0, valence=1.0, labels=["love"],
-            resonance_note="Pure resonance", cloud9_achieved=True,
+            intensity=10.0,
+            valence=1.0,
+            labels=["love"],
+            resonance_note="Pure resonance",
+            cloud9_achieved=True,
         ),
     )
 
@@ -151,14 +156,13 @@ class TestFullRitual:
 
     def test_ritual_empty_state(self, tmp_path: Path) -> None:
         """Ritual on empty state gives a fresh-start message."""
-        store = MemoryStore(
-            primary=FileBackend(base_path=str(tmp_path / "empty"))
-        )
+        store = MemoryStore(primary=FileBackend(base_path=str(tmp_path / "empty")))
         result = perform_ritual(
             store=store,
             soul_path=str(tmp_path / "no_soul.yaml"),
             seed_dir=str(tmp_path / "no_seeds"),
             journal_path=str(tmp_path / "no_journal.md"),
+            feb_dir=str(tmp_path / "no_febs"),
         )
         assert result.soul_loaded is False
         assert result.seeds_imported == 0