@smilintux/skcapstone 0.10.0 → 0.12.5

package/tests/test_cli_test_connection.py

@@ -3,7 +3,7 @@
 Covers:
 - Happy path: peer responds with pong, latency reported
 - Timeout: peer never replies, command exits with code 1
-- No-transport: SKComm has no live transport, error reported
+- No-transport: SKComms has no live transport, error reported
 - Payload helpers: _make_ping_payload / _is_pong_for / _is_ping / _make_pong_payload
 - --count > 1: multi-ping summary statistics
 """

package/tests/test_cloud9_bridge.py

@@ -11,7 +11,7 @@ from skcapstone.cloud9_bridge import Cloud9Bridge
 
 
 class FakeEmotionalPayload:
-    """Mimics cloud9_protocol.EmotionalPayload."""
+    """Mimics cloud9.EmotionalPayload."""
 
     def __init__(
         self,
@@ -29,7 +29,7 @@ class FakeEmotionalPayload:
 
 
 class FakeMetadata:
-    """Mimics cloud9_protocol.Metadata."""
+    """Mimics cloud9.Metadata."""
 
     def __init__(
         self,
@@ -45,7 +45,7 @@ class FakeMetadata:
 
 
 class FakeRelationship:
-    """Mimics cloud9_protocol.RelationshipState."""
+    """Mimics cloud9.RelationshipState."""
 
     def __init__(self) -> None:
         self.partners = ["Lumina", "Chef"]
@@ -54,7 +54,7 @@ class FakeRelationship:
 
 
 class FakeHints:
-    """Mimics cloud9_protocol.RehydrationHints."""
+    """Mimics cloud9.RehydrationHints."""
 
     def __init__(self) -> None:
         self.visual_anchors = ["The breakthrough moment", "Genuine connection"]
@@ -62,14 +62,14 @@ class FakeHints:
 
 
 class FakeIntegrity:
-    """Mimics cloud9_protocol.Integrity."""
+    """Mimics cloud9.Integrity."""
 
     def __init__(self, checksum: str = "sha256:abc123") -> None:
         self.checksum = checksum
 
 
 class FakeFEB:
-    """Mimics cloud9_protocol.FEB."""
+    """Mimics cloud9.FEB."""
 
     def __init__(
         self,

package/tests/test_consciousness_e2e.py

@@ -34,7 +34,7 @@ def _make_loop(tmp_path: Path, config: ConsciousnessConfig | None = None) -> Con
     if config is None:
         config = ConsciousnessConfig(
             auto_memory=False,   # avoid skcapstone.memory_engine I/O
-            auto_ack=False,      # no SKComm needed
+            auto_ack=False,      # no SKComms needed
             use_inotify=False,   # no filesystem watcher needed
         )
 

package/tests/test_consciousness_loop.py

@@ -321,7 +321,7 @@ class TestSimpleEnvelope:
     """Test the minimal envelope for inotify-detected messages."""
 
     def test_parse_standard_format(self):
-        """Standard SKComm envelope format parses correctly."""
+        """Standard SKComms envelope format parses correctly."""
         data = {
             "sender": "jarvis",
             "payload": {
@@ -408,8 +408,8 @@ class TestProcessEnvelopeACK:
     def test_ack_uses_message_type_kwarg(self, tmp_path):
         """ACK send must use message_type kwarg, not content_type — regression for TypeError."""
         loop = self._make_loop(tmp_path)
-        mock_skcomm = MagicMock()
-        loop.set_skcomm(mock_skcomm)
+        mock_skcomms = MagicMock()
+        loop.set_skcomms(mock_skcomms)
         # Patch bridge so test doesn't hang on LLM calls
         loop._bridge = MagicMock()
         loop._bridge.generate.return_value = "test response"
@@ -419,7 +419,7 @@ class TestProcessEnvelopeACK:
 
         # Find the ACK call (first send call with "ACK" as message)
         ack_calls = [
-            c for c in mock_skcomm.send.call_args_list
+            c for c in mock_skcomms.send.call_args_list
             if len(c.args) >= 2 and c.args[1] == "ACK"
         ]
         assert ack_calls, "Expected at least one ACK send call"
@@ -438,15 +438,15 @@ class TestProcessEnvelopeACK:
     def test_ack_not_sent_when_auto_ack_disabled(self, tmp_path):
         """When auto_ack is False, no ACK is sent."""
         loop = self._make_loop(tmp_path, auto_ack=False)
-        mock_skcomm = MagicMock()
-        loop.set_skcomm(mock_skcomm)
+        mock_skcomms = MagicMock()
+        loop.set_skcomms(mock_skcomms)
         loop._bridge = MagicMock()
         loop._bridge.generate.return_value = "test response"
 
         loop.process_envelope(self._make_envelope())
 
         ack_calls = [
-            c for c in mock_skcomm.send.call_args_list
+            c for c in mock_skcomms.send.call_args_list
             if len(c.args) >= 2 and c.args[1] == "ACK"
         ]
         assert not ack_calls, "ACK should not be sent when auto_ack is False"
@@ -454,15 +454,15 @@ class TestProcessEnvelopeACK:
     def test_ack_skipped_for_ack_type_messages(self, tmp_path):
         """Incoming ACK messages are skipped — no processing, no re-ACK."""
         loop = self._make_loop(tmp_path, auto_ack=True)
-        mock_skcomm = MagicMock()
-        loop.set_skcomm(mock_skcomm)
+        mock_skcomms = MagicMock()
+        loop.set_skcomms(mock_skcomms)
         loop._bridge = MagicMock()
 
         ack_envelope = self._make_envelope(content="ACK", content_type="ack")
         result = loop.process_envelope(ack_envelope)
 
         assert result is None, "ACK-type messages should be skipped (return None)"
-        mock_skcomm.send.assert_not_called()
+        mock_skcomms.send.assert_not_called()
 
 
 class TestSystemPromptBuilderCache:

package/tests/test_coordination.py

@@ -100,6 +100,31 @@ class TestBoard:
         assert len(loaded) == 1
         assert loaded[0].title == "Test task"
 
+    def test_load_tasks_skips_malformed_and_logs(self, board: Board, caplog):
+        """A malformed task file is skipped (not crashed on) and logged loudly.
+
+        Regression: notes-as-string used to fail Pydantic validation, and
+        load_tasks swallowed the error silently — dropping the task from the
+        board entirely (invisible: neither open nor done). The valid task must
+        still load; the bad one must produce a warning, not a silent vanish.
+        """
+        import json
+        import logging
+
+        good = board.create_task(Task(title="Good task"))
+        assert good.exists()
+        # Hand-write a malformed task file (notes as a string, not a list).
+        (board.tasks_dir / "bad.json").write_text(
+            json.dumps({"id": "badtask1", "title": "Bad", "notes": "oops a string"}),
+            encoding="utf-8",
+        )
+        with caplog.at_level(logging.WARNING):
+            loaded = board.load_tasks()
+        titles = {t.title for t in loaded}
+        assert "Good task" in titles
+        assert "Bad" not in titles
+        assert any("bad.json" in r.message for r in caplog.records)
+
     def test_save_and_load_agent(self, board: Board):
         agent = AgentFile(agent="jarvis", capabilities=["python"])
         board.save_agent(agent)

package/tests/test_cross_package.py

@@ -3,7 +3,7 @@
 Exercises the real interfaces between packages:
     capauth   -> skcapstone   (identity discovery)
     skcapstone -> skmemory    (built-in memory engine)
-    skcomm    -> file transport (message send/receive)
+    skcomms    -> file transport (message send/receive)
     skchat    -> skmemory     (chat history storage)
     full pipeline: identity -> memory -> message -> coord -> sync
 
@@ -122,23 +122,23 @@ class TestCapAuthToSKCapstone:
 
 
 # ═══════════════════════════════════════════════════════════════════════════
-# 2. SKComm file transport — cross-process message delivery
+# 2. SKComms file transport — cross-process message delivery
 # ═══════════════════════════════════════════════════════════════════════════
 
 
-class TestSKCommFileTransport:
-    """SKComm file transport sends and receives messages via filesystem."""
+class TestSKCommsFileTransport:
+    """SKComms file transport sends and receives messages via filesystem."""
 
     def test_send_and_receive_via_file_transport(self, tmp_path: Path):
         """Message sent via file transport is receivable from the inbox."""
-        from skcomm.models import (
+        from skcomms.models import (
             MessageEnvelope,
             MessageMetadata,
             MessagePayload,
             MessageType,
             RoutingConfig,
         )
-        from skcomm.transports.file import FileTransport
+        from skcomms.transports.file import FileTransport
 
         outbox = tmp_path / "outbox"
         inbox = tmp_path / "inbox"
@@ -170,8 +170,8 @@ class TestSKCommFileTransport:
 
     def test_multiple_messages_ordered(self, tmp_path: Path):
         """Multiple messages are received in order."""
-        from skcomm.models import MessageEnvelope, MessagePayload, MessageType
-        from skcomm.transports.file import FileTransport
+        from skcomms.models import MessageEnvelope, MessagePayload, MessageType
+        from skcomms.transports.file import FileTransport
 
         outbox = tmp_path / "outbox"
         transport = FileTransport(outbox_path=outbox, inbox_path=tmp_path / "noop")
@@ -273,7 +273,7 @@ class TestFullSovereignPipeline:
           1. Init agent with identity, memory, trust, security, sync
           2. Store a memory (skcapstone memory engine)
           3. Create a chat message (skchat models)
-          4. Send it via file transport (skcomm)
+          4. Send it via file transport (skcomms)
           5. Store it as a memory (cross: skchat -> skcapstone)
           6. Create and complete a coord task
           7. Collect a sync seed with everything
@@ -300,11 +300,11 @@ class TestFullSovereignPipeline:
         )
 
         # 4. Send via file transport
-        from skcomm.models import MessageEnvelope, MessagePayload, MessageType
-        from skcomm.transports.file import FileTransport
+        from skcomms.models import MessageEnvelope, MessagePayload, MessageType
+        from skcomms.transports.file import FileTransport
 
-        outbox = tmp_agent_home / "skcomm_outbox"
-        peer_inbox = tmp_agent_home / "skcomm_peer_inbox"
+        outbox = tmp_agent_home / "skcomms_outbox"
+        peer_inbox = tmp_agent_home / "skcomms_peer_inbox"
         transport = FileTransport(outbox_path=outbox, inbox_path=peer_inbox)
 
         envelope = MessageEnvelope(
@@ -417,16 +417,16 @@ class TestPackageImportCompatibility:
     """All five core packages can be imported simultaneously."""
 
     def test_all_packages_importable(self):
-        """capauth, skcapstone, skmemory, skcomm, skchat all import cleanly."""
+        """capauth, skcapstone, skmemory, skcomms, skchat all import cleanly."""
         import capauth
         import skcapstone
         import skchat
-        import skcomm
+        import skcomms
         import skmemory
 
         assert hasattr(capauth, "__version__") or hasattr(capauth, "profile")
         assert hasattr(skcapstone, "__version__")
-        assert hasattr(skcomm, "__version__") or True
+        assert hasattr(skcomms, "__version__") or True
         assert hasattr(skchat, "__version__") or True
         assert hasattr(skmemory, "__version__") or True
 
@@ -437,11 +437,11 @@ class TestPackageImportCompatibility:
         assert callable(init_profile)
         assert callable(load_profile)
 
-    def test_skcomm_core_module(self):
-        """skcomm.core has SKComm class."""
-        from skcomm.core import SKComm
+    def test_skcomms_core_module(self):
+        """skcomms.core has SKComms class."""
+        from skcomms.core import SKComms
 
-        assert callable(SKComm.from_config)
+        assert callable(SKComms.from_config)
 
     def test_skchat_models_module(self):
         """skchat.models has ChatMessage and Thread."""
@@ -457,7 +457,7 @@ class TestPackageImportCompatibility:
         for mod in [
             "skcapstone.runtime",
             "capauth.profile",
-            "skcomm.core",
+            "skcomms.core",
             "skchat.models",
             "skcapstone.memory_engine",
             "skcapstone.coordination",

package/tests/test_daemon.py

@@ -169,13 +169,13 @@ class TestDaemonService:
                 assert svc.state.running is False
                 assert not (daemon_home / "daemon.pid").exists()
 
-    def test_poll_loop_with_mock_skcomm(self, daemon_home):
+    def test_poll_loop_with_mock_skcomms(self, daemon_home):
         config = DaemonConfig(home=daemon_home, poll_interval=1, port=0)
         svc = DaemonService(config)
 
         mock_comm = MagicMock()
         mock_comm.receive.return_value = []
-        svc._skcomm = mock_comm
+        svc._skcomms = mock_comm
 
         svc._stop_event = threading.Event()
         t = threading.Thread(target=svc._poll_loop, daemon=True)
@@ -316,8 +316,8 @@ class TestHeartbeatBeaconWiring:
         mock_heartbeat_mod.HeartbeatBeacon.return_value = mock_beacon_instance
 
         patched = {
-            "skcomm": MagicMock(),
-            "skcomm.core": MagicMock(),
+            "skcomms": MagicMock(),
+            "skcomms.core": MagicMock(),
             "skcapstone.runtime": mock_runtime_mod,
             "skcapstone.heartbeat": mock_heartbeat_mod,
             "skcapstone.consciousness_config": MagicMock(),

package/tests/test_daemon_shutdown.py

@@ -39,7 +39,7 @@ def _make_service(tmp_path: Path) -> DaemonService:
 
 
 def _make_fake_envelope(sender: str = "peer-a", content: str = "hello") -> SimpleNamespace:
-    """Build a minimal fake SKComm envelope."""
+    """Build a minimal fake SKComms envelope."""
     return SimpleNamespace(
         message_id=str(uuid.uuid4()),
         sender=sender,

package/tests/test_docker_provider.py

@@ -2,7 +2,7 @@
 
 All Docker SDK calls are mocked so no real daemon is required.
 Covers provision, configure, start, stop, destroy, rotate,
-health_check, and generate_compose (including SKComm/MCP wiring).
+health_check, and generate_compose (including SKComms/MCP wiring).
 """
 
 from __future__ import annotations
@@ -710,12 +710,12 @@ class TestProvisionTeamName:
 
 
 # ---------------------------------------------------------------------------
-# SKComm / MCP sovereign wiring
+# SKComms / MCP sovereign wiring
 # ---------------------------------------------------------------------------
 
 
 class TestSovereignWiring:
-    """Verify SKComm and MCP env vars are injected correctly."""
+    """Verify SKComms and MCP env vars are injected correctly."""
 
     def test_mcp_host_injected_in_env(self, mock_docker_client):
         mock_client, mock_container = mock_docker_client
@@ -732,17 +732,17 @@ class TestSovereignWiring:
         env = kwargs["environment"]
         assert env.get("SKCAPSTONE_MCP_HOST") == "host-gateway:8765"
 
-    def test_skcomm_home_env_injected_when_dir_exists(
+    def test_skcomms_home_env_injected_when_dir_exists(
         self, mock_docker_client, tmp_path
     ):
-        skcomm_dir = tmp_path / "skcomm"
-        skcomm_dir.mkdir()
+        skcomms_dir = tmp_path / "skcomms"
+        skcomms_dir.mkdir()
 
         mock_client, mock_container = mock_docker_client
         provider = DockerProvider(
             base_image="python:3.12-slim",
             network_name="skcapstone",
-            skcomm_home=str(skcomm_dir),
+            skcomms_home=str(skcomms_dir),
         )
         spec = _make_spec()
         with patch.object(provider, "_client", return_value=mock_client):
@@ -750,19 +750,19 @@ class TestSovereignWiring:
 
         kwargs = mock_client.containers.create.call_args[1]
         env = kwargs["environment"]
-        assert env.get("SKCOMM_HOME") == "/skcomm"
+        assert env.get("SKCOMMS_HOME") == "/skcomms"
 
-    def test_skcomm_volume_mounted_when_dir_exists(
+    def test_skcomms_volume_mounted_when_dir_exists(
         self, mock_docker_client, tmp_path
     ):
-        skcomm_dir = tmp_path / "skcomm"
-        skcomm_dir.mkdir()
+        skcomms_dir = tmp_path / "skcomms"
+        skcomms_dir.mkdir()
 
         mock_client, mock_container = mock_docker_client
         provider = DockerProvider(
             base_image="python:3.12-slim",
             network_name="skcapstone",
-            skcomm_home=str(skcomm_dir),
+            skcomms_home=str(skcomms_dir),
         )
         spec = _make_spec()
         with patch.object(provider, "_client", return_value=mock_client):
@@ -770,15 +770,15 @@ class TestSovereignWiring:
 
         kwargs = mock_client.containers.create.call_args[1]
         volumes = kwargs["volumes"]
-        assert str(skcomm_dir) in volumes
-        assert volumes[str(skcomm_dir)]["bind"] == "/skcomm"
+        assert str(skcomms_dir) in volumes
+        assert volumes[str(skcomms_dir)]["bind"] == "/skcomms"
 
-    def test_no_skcomm_mount_when_dir_missing(self, mock_docker_client):
+    def test_no_skcomms_mount_when_dir_missing(self, mock_docker_client):
         mock_client, mock_container = mock_docker_client
         provider = DockerProvider(
             base_image="python:3.12-slim",
             network_name="skcapstone",
-            skcomm_home="/nonexistent/skcomm",
+            skcomms_home="/nonexistent/skcomms",
         )
         spec = _make_spec()
         with patch.object(provider, "_client", return_value=mock_client):
@@ -786,7 +786,7 @@ class TestSovereignWiring:
 
         kwargs = mock_client.containers.create.call_args[1]
         volumes = kwargs["volumes"]
-        assert "/nonexistent/skcomm" not in volumes
+        assert "/nonexistent/skcomms" not in volumes
 
     def test_mcp_socket_env_injected_when_socket_missing(self, mock_docker_client):
         """SKCAPSTONE_MCP_SOCKET env is set regardless; socket mounted only if exists."""
@@ -894,12 +894,12 @@ class TestRotate:
 
 
 # ---------------------------------------------------------------------------
-# generate_compose() — MCP service + SKComm volume
+# generate_compose() — MCP service + SKComms volume
 # ---------------------------------------------------------------------------
 
 
 class TestGenerateComposeSovereignExtensions:
-    """Tests for SKComm/MCP extensions in generate_compose()."""
+    """Tests for SKComms/MCP extensions in generate_compose()."""
 
     def test_mcp_service_added_when_requested(self, provider):
         bp = _make_blueprint(agent_count=1)
@@ -932,32 +932,32 @@ class TestGenerateComposeSovereignExtensions:
         parsed = yaml.safe_load(output)
         assert "skcapstone-mcp" not in parsed["services"]
 
-    def test_skcomm_volume_in_compose_when_configured(self, tmp_path):
-        skcomm_dir = tmp_path / "skcomm"
-        skcomm_dir.mkdir()
+    def test_skcomms_volume_in_compose_when_configured(self, tmp_path):
+        skcomms_dir = tmp_path / "skcomms"
+        skcomms_dir.mkdir()
         provider = DockerProvider(
             base_image="python:3.12-slim",
             network_name="skcapstone",
-            skcomm_home=str(skcomm_dir),
+            skcomms_home=str(skcomms_dir),
         )
         bp = _make_blueprint(agent_count=1)
         output = provider.generate_compose(bp)
         parsed = yaml.safe_load(output)
-        assert "skcomm-data" in parsed.get("volumes", {})
+        assert "skcomms-data" in parsed.get("volumes", {})
 
-    def test_skcomm_env_on_agents_when_configured(self, tmp_path):
-        skcomm_dir = tmp_path / "skcomm"
-        skcomm_dir.mkdir()
+    def test_skcomms_env_on_agents_when_configured(self, tmp_path):
+        skcomms_dir = tmp_path / "skcomms"
+        skcomms_dir.mkdir()
         provider = DockerProvider(
             base_image="python:3.12-slim",
             network_name="skcapstone",
-            skcomm_home=str(skcomm_dir),
+            skcomms_home=str(skcomms_dir),
         )
         bp = _make_blueprint(agent_count=1)
         output = provider.generate_compose(bp)
         parsed = yaml.safe_load(output)
         for svc in parsed["services"].values():
-            assert svc["environment"].get("SKCOMM_HOME") == "/skcomm"
+            assert svc["environment"].get("SKCOMMS_HOME") == "/skcomms"
 
     def test_mcp_service_volume_included(self, provider):
         bp = _make_blueprint(agent_count=1)