@smilintux/skcapstone 0.10.0 → 0.12.5

package/tests/test_sync_pipeline.py

@@ -5,11 +5,11 @@ Pipeline under test:
     {shared_root}/sync/comms/inbox/{peer}/*.skc.json   ← Syncthing writes here
     → inotify detects file  (ConsciousnessLoop._run_inotify)
     → ConsciousnessLoop.process_envelope()
-    → skcomm.send(sender, response)
+    → skcomms.send(sender, response)
     → {shared_root}/sync/comms/outbox/{peer}/*.skc.json ← Syncthing syncs this out
 
 Three test classes:
-    TestInboxToOutboxFlow      — mock LLM, drop inbox file, verify skcomm.send called
+    TestInboxToOutboxFlow      — mock LLM, drop inbox file, verify skcomms.send called
     TestOutboxEnvelopeFormat   — verify envelope spec compliance and path layout
     TestSyncStatusInHealth     — verify health snapshot includes sync_pipeline key
 """
@@ -61,11 +61,11 @@ def agent_home(shared_root: Path) -> Path:
 
 
 @pytest.fixture
-def mock_skcomm() -> MagicMock:
-    skcomm = MagicMock()
-    skcomm.send.return_value = None
-    skcomm.receive.return_value = []
-    return skcomm
+def mock_skcomms() -> MagicMock:
+    skcomms = MagicMock()
+    skcomms.send.return_value = None
+    skcomms.receive.return_value = []
+    return skcomms
 
 
 # ---------------------------------------------------------------------------
@@ -76,7 +76,7 @@ def mock_skcomm() -> MagicMock:
 class TestInboxToOutboxFlow:
     """Drop a file in the inbox and verify the consciousness loop responds."""
 
-    def _make_loop(self, agent_home: Path, shared_root: Path, mock_skcomm):
+    def _make_loop(self, agent_home: Path, shared_root: Path, mock_skcomms):
         """Return a ConsciousnessLoop with a mocked LLM bridge."""
         from skcapstone.consciousness_loop import ConsciousnessConfig, ConsciousnessLoop
 
@@ -100,14 +100,14 @@ class TestInboxToOutboxFlow:
                 shared_root=shared_root,
             )
 
-        loop.set_skcomm(mock_skcomm)
+        loop.set_skcomms(mock_skcomms)
         return loop
 
     def test_inbox_to_outbox_flow(
-        self, shared_root: Path, agent_home: Path, mock_skcomm: MagicMock
+        self, shared_root: Path, agent_home: Path, mock_skcomms: MagicMock
     ):
-        """File dropped in inbox triggers process_envelope and skcomm.send."""
-        loop = self._make_loop(agent_home, shared_root, mock_skcomm)
+        """File dropped in inbox triggers process_envelope and skcomms.send."""
+        loop = self._make_loop(agent_home, shared_root, mock_skcomms)
 
         peer = "alice"
         inbox_peer = get_inbox_dir(shared_root) / peer
@@ -130,15 +130,15 @@ class TestInboxToOutboxFlow:
         loop._on_inbox_file(inbox_file)
         loop._executor.shutdown(wait=True)
 
-        assert mock_skcomm.send.called, "skcomm.send() must be called with the LLM response"
-        recipient_arg = mock_skcomm.send.call_args[0][0]
+        assert mock_skcomms.send.called, "skcomms.send() must be called with the LLM response"
+        recipient_arg = mock_skcomms.send.call_args[0][0]
         assert recipient_arg == peer, "Response must be addressed to the original sender"
 
     def test_skipped_when_sender_missing(
-        self, shared_root: Path, agent_home: Path, mock_skcomm: MagicMock
+        self, shared_root: Path, agent_home: Path, mock_skcomms: MagicMock
     ):
         """Envelopes without a sender field are silently dropped."""
-        loop = self._make_loop(agent_home, shared_root, mock_skcomm)
+        loop = self._make_loop(agent_home, shared_root, mock_skcomms)
 
         inbox_peer = get_inbox_dir(shared_root) / "ghost"
         inbox_peer.mkdir(parents=True, exist_ok=True)
@@ -149,13 +149,13 @@ class TestInboxToOutboxFlow:
         loop._on_inbox_file(inbox_file)
         loop._executor.shutdown(wait=True)
 
-        mock_skcomm.send.assert_not_called()
+        mock_skcomms.send.assert_not_called()
 
     def test_duplicate_envelope_not_reprocessed(
-        self, shared_root: Path, agent_home: Path, mock_skcomm: MagicMock
+        self, shared_root: Path, agent_home: Path, mock_skcomms: MagicMock
     ):
         """The same envelope_id is never processed twice."""
-        loop = self._make_loop(agent_home, shared_root, mock_skcomm)
+        loop = self._make_loop(agent_home, shared_root, mock_skcomms)
 
         peer = "bob"
         inbox_peer = get_inbox_dir(shared_root) / peer
@@ -173,7 +173,7 @@ class TestInboxToOutboxFlow:
         # First call
         loop._on_inbox_file(inbox_file)
         loop._executor.shutdown(wait=True)
-        first_count = mock_skcomm.send.call_count
+        first_count = mock_skcomms.send.call_count
 
         # Recreate the loop's executor for a second submission attempt
         from concurrent.futures import ThreadPoolExecutor
@@ -184,7 +184,7 @@ class TestInboxToOutboxFlow:
         loop._executor.shutdown(wait=True)
 
         # Exactly the same number of sends — second call was deduped
-        assert mock_skcomm.send.call_count == first_count
+        assert mock_skcomms.send.call_count == first_count
 
 
 # ---------------------------------------------------------------------------
@@ -193,7 +193,7 @@ class TestInboxToOutboxFlow:
 
 
 class TestOutboxEnvelopeFormat:
-    """Verify that outbox envelopes comply with the SKComm envelope spec."""
+    """Verify that outbox envelopes comply with the SKComms envelope spec."""
 
     def test_required_fields_preserved(self, shared_root: Path):
         """write_outbox_envelope writes all envelope fields to the .skc.json."""
@@ -348,7 +348,7 @@ class TestSyncStatusInHealth:
 
     def test_verify_pipeline_detects_transport_misalignment(self, shared_root: Path):
         """verify_pipeline_paths flags a SyncthingTransport with a wrong comms_root."""
-        # Build a mock SKComm with a Syncthing transport pointing to the wrong path
+        # Build a mock SKComms with a Syncthing transport pointing to the wrong path
         wrong_transport = MagicMock()
         wrong_transport.name = "syncthing"
         wrong_transport._root = Path("/tmp/wrong/path")
@@ -356,9 +356,9 @@ class TestSyncStatusInHealth:
         mock_router = MagicMock()
         mock_router.transports = [wrong_transport]
 
-        mock_skcomm = MagicMock()
-        mock_skcomm.router = mock_router
+        mock_skcomms = MagicMock()
+        mock_skcomms.router = mock_router
 
-        result = verify_pipeline_paths(shared_root, skcomm=mock_skcomm)
+        result = verify_pipeline_paths(shared_root, skcomms=mock_skcomms)
         assert result["transport_aligned"] is False
         assert any("mismatch" in issue.lower() for issue in result["issues"])

package/tests/test_team_comms.py

@@ -301,9 +301,9 @@ class TestBuildEnvelope:
     """Tests for the internal _build_envelope helper."""
 
     def test_required_fields_present(self) -> None:
-        """Envelope dict has all required SKComm fields."""
+        """Envelope dict has all required SKComms fields."""
         env = _build_envelope("agent-a", "agent-b", "hello")
-        assert env["skcomm_version"] == "1.0.0"
+        assert env["skcomms_version"] == "1.0.0"
         assert env["sender"] == "agent-a"
         assert env["recipient"] == "agent-b"
         assert env["payload"]["content"] == "hello"

package/tests/test_testrunner.py

@@ -233,6 +233,6 @@ class TestRunAllTests:
 
     def test_filter_by_package_names(self, tmp_path: Path):
         """Only requested packages appear in the report."""
-        report = run_all_tests(tmp_path, packages=["skcomm", "skchat"])
+        report = run_all_tests(tmp_path, packages=["skcomms", "skchat"])
         names = [r.name for r in report.results]
-        assert names == ["skcomm", "skchat"]
+        assert names == ["skcomms", "skchat"]

package/tests/test_trust_graph.py

@@ -121,6 +121,24 @@ class TestBuildGraph:
         sync_edges = [e for e in graph.edges if e.edge_type == "sync"]
         assert len(sync_edges) >= 1
 
+    def test_manifest_operator_creates_human_link(self, tmp_agent_home: Path):
+        """Manifest operator metadata appears as an explicit trust relationship."""
+        _init_agent(tmp_agent_home, "operator-graph")
+        manifest_path = tmp_agent_home / "manifest.json"
+        manifest = json.loads(manifest_path.read_text())
+        manifest["operator"] = {
+            "name": "Casey",
+            "fingerprint": "FP1234567890",
+            "relationship": "human-operator",
+            "entity_type": "human",
+        }
+        manifest_path.write_text(json.dumps(manifest), encoding="utf-8")
+
+        graph = build_trust_graph(tmp_agent_home)
+
+        assert any(n.label == "Casey" for n in graph.nodes)
+        assert any(e.edge_type == "operator" and e.label == "human-operator" for e in graph.edges)
+
 
 class TestFormatDot:
     """Tests for DOT format output."""

package/tests/test_unified_search.py

@@ -232,10 +232,10 @@ class TestSearchConversations:
 # ---------------------------------------------------------------------------
 
 class TestSearchMessages:
-    """Tests for searching SKComm messages."""
+    """Tests for searching SKComms messages."""
 
     def test_finds_skc_message(self, agent_home: Path):
-        """Search should find text inside an archived SKComm envelope."""
+        """Search should find text inside an archived SKComms envelope."""
         _write_message(agent_home, "env001", "jarvis", "lumina",
                        "Queen Lumina — welcome to the coordination board!")
         results = search(agent_home, "coordination", sources=frozenset({"message"}))

package/tests/test_version_check.py

@@ -0,0 +1,10 @@
+"""Tests for ecosystem package version checks."""
+
+from __future__ import annotations
+
+from skcapstone.version_check import _get_installed_version
+
+
+def test_missing_package_returns_none_without_name_error():
+    """Missing package lookup should not raise when logging the fallback failure."""
+    assert _get_installed_version("definitely-not-an-sk-package") is None

package/tests/test_version_cmd.py

@@ -181,7 +181,7 @@ class TestGatherVersionInfo:
         assert "daemon_pid" in info
 
     def test_optional_deps_has_four_packages(self, agent_home: Path):
-        """optional_deps covers watchdog, skcomm, skchat, skseed."""
+        """optional_deps covers watchdog, skcomms, skchat, skseed."""
         from skcapstone.cli.version_cmd import gather_version_info
 
         with patch("urllib.request.urlopen", side_effect=OSError), \
@@ -189,7 +189,7 @@ class TestGatherVersionInfo:
             info = gather_version_info(agent_home)
 
         deps = info["optional_deps"]
-        assert set(deps.keys()) == {"watchdog", "skcomm", "skchat", "skseed"}
+        assert set(deps.keys()) == {"watchdog", "skcomms", "skchat", "skseed"}
 
     def test_package_version_matches_module(self, agent_home: Path):
         """package_version matches skcapstone.__version__."""
@@ -214,7 +214,7 @@ class TestVersionCommand:
     def _run(self, args: list[str], agent_home: Path):
         from skcapstone.cli import main
 
-        runner = CliRunner(mix_stderr=False)
+        runner = CliRunner()
         with patch("urllib.request.urlopen", side_effect=OSError), \
              patch("skcapstone.daemon.read_pid", return_value=None):
             return runner.invoke(
@@ -235,7 +235,7 @@ class TestVersionCommand:
         """Normal output lists all four optional dep names."""
         result = self._run([], agent_home)
         assert result.exit_code == 0
-        for pkg in ("watchdog", "skcomm", "skchat", "skseed"):
+        for pkg in ("watchdog", "skcomms", "skchat", "skseed"):
             assert pkg in result.output
 
     def test_json_output_is_valid_and_complete(self, agent_home: Path):
@@ -253,7 +253,7 @@ class TestVersionCommand:
         """Shows running + PID when daemon is alive."""
         from skcapstone.cli import main
 
-        runner = CliRunner(mix_stderr=False)
+        runner = CliRunner()
         with patch("urllib.request.urlopen", side_effect=OSError), \
              patch("skcapstone.daemon.read_pid", return_value=42001):
             result = runner.invoke(
@@ -276,7 +276,7 @@ class TestVersionCommand:
         mock_resp.__exit__ = MagicMock(return_value=False)
         mock_resp.read.return_value = payload
 
-        runner = CliRunner(mix_stderr=False)
+        runner = CliRunner()
         with patch("urllib.request.urlopen", return_value=mock_resp), \
              patch("skcapstone.daemon.read_pid", return_value=None):
             result = runner.invoke(
@@ -299,7 +299,7 @@ class TestDoctorVerbose:
     def _run_doctor(self, args: list[str], agent_home: Path):
         from skcapstone.cli import main
 
-        runner = CliRunner(mix_stderr=False)
+        runner = CliRunner()
         return runner.invoke(
             main,
             ["doctor", "--home", str(agent_home)] + args,
@@ -349,7 +349,7 @@ class TestDoctorVerbose:
         """--help output documents the --verbose flag."""
         from skcapstone.cli import main
 
-        runner = CliRunner(mix_stderr=False)
+        runner = CliRunner()
         result = runner.invoke(main, ["doctor", "--help"])
         assert result.exit_code == 0
         assert "--verbose" in result.output

package/tests/test_whoami.py

@@ -81,7 +81,7 @@ class TestIdentityCard:
             name="Opus",
             fingerprint="AABB1122",
             entity_type="ai",
-            capabilities=["capauth:identity", "skcomm:messaging"],
+            capabilities=["capauth:identity", "skcomms:messaging"],
             contact_uris=["capauth:AABB1122"],
         )
         json_str = card.model_dump_json()

package/systemd/skcomm-heartbeat.service

@@ -1,18 +0,0 @@
-[Unit]
-Description=SKComm Heartbeat Emission
-Documentation=https://github.com/smilinTux/skcomm
-After=network-online.target
-
-[Service]
-Type=oneshot
-ExecStart=skcomm heartbeat --no-emit
-ExecStart=skcomm heartbeat
-Nice=19
-
-NoNewPrivileges=true
-ProtectSystem=strict
-ProtectHome=read-only
-ReadWritePaths=%h/.skcapstone %h/.skcomm
-PrivateTmp=true
-
-Environment=PYTHONUNBUFFERED=1

package/systemd/skcomm-queue-drain.service

@@ -1,17 +0,0 @@
-[Unit]
-Description=SKComm Queue Drain — retry undelivered messages
-Documentation=https://github.com/smilinTux/skcomm
-After=network-online.target
-
-[Service]
-Type=oneshot
-ExecStart=skcomm queue drain
-Nice=19
-
-NoNewPrivileges=true
-ProtectSystem=strict
-ProtectHome=read-only
-ReadWritePaths=%h/.skcapstone %h/.skcomm
-PrivateTmp=true
-
-Environment=PYTHONUNBUFFERED=1