@smilintux/skcapstone 0.10.0 → 0.12.5

package/systemd/skcapstone@.service

@@ -20,8 +20,8 @@ Wants=network-online.target
 
 [Service]
 Type=notify
-ExecStart=skcapstone daemon start --agent %i --foreground
-ExecStop=skcapstone daemon stop --agent %i
+ExecStart=%h/.skenv/bin/skcapstone daemon start --agent %i --foreground
+ExecStop=%h/.skenv/bin/skcapstone daemon stop --agent %i
 ExecReload=/bin/kill -HUP $MAINPID
 Restart=on-failure
 RestartSec=10
@@ -31,20 +31,19 @@ WatchdogSec=300
 # resolve the correct per-agent home even before the CLI flag is processed.
 Environment=PYTHONUNBUFFERED=1
 Environment=OLLAMA_KEEP_ALIVE=5m
+Environment=SKAGENT=%i
 Environment=SKCAPSTONE_AGENT=%i
+Environment=SKMEMORY_AGENT=%i
+Environment=PATH=%h/.skenv/bin:/usr/local/bin:/usr/bin:/bin
 # Journal logging — logs appear under skcapstone@<instance>
 StandardOutput=journal
 StandardError=journal
 SyslogIdentifier=skcapstone@%i
 
-# Security hardening (same as single-agent unit)
+# Security hardening (relaxed — ProtectHome=read-only breaks if any
+# ReadWritePaths dir is missing on the host)
 NoNewPrivileges=true
-ProtectSystem=strict
-ProtectHome=read-only
-ReadWritePaths=%h/.skcapstone %h/.skmemory %h/.capauth %h/.cloud9 %h/.skcomm %h/.skchat
 PrivateTmp=true
-ProtectKernelTunables=true
-ProtectControlGroups=true
 
 [Install]
 WantedBy=default.target

package/systemd/skcomms-heartbeat.service

@@ -0,0 +1,21 @@
+[Unit]
+Description=SKComms Heartbeat Emission
+Documentation=https://github.com/smilinTux/skcomms
+After=network-online.target
+
+[Service]
+Type=oneshot
+ExecStart=%h/.skenv/bin/skcomms heartbeat --no-emit
+ExecStart=%h/.skenv/bin/skcomms heartbeat
+Nice=19
+
+NoNewPrivileges=true
+ProtectSystem=strict
+ProtectHome=read-only
+ReadWritePaths=%h/.skcapstone %h/.skcomms
+PrivateTmp=true
+
+Environment=PYTHONUNBUFFERED=1
+Environment=SKAGENT=lumina
+Environment=SKCAPSTONE_AGENT=lumina
+Environment=PATH=%h/.skenv/bin:/usr/local/bin:/usr/bin:/bin

package/systemd/skcomms-heartbeat.timer

@@ -0,0 +1,12 @@
+[Unit]
+Description=SKComms Heartbeat Timer — periodic liveness announcements
+Documentation=https://github.com/smilinTux/skcomms
+
+[Timer]
+OnBootSec=30s
+OnUnitActiveSec=60s
+RandomizedDelaySec=10s
+Persistent=true
+
+[Install]
+WantedBy=timers.target

package/systemd/skcomms-queue-drain.service

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

package/systemd/skcomms-queue-drain.timer

@@ -0,0 +1,12 @@
+[Unit]
+Description=SKComms Queue Drain Timer — periodic message retry
+Documentation=https://github.com/smilinTux/skcomms
+
+[Timer]
+OnBootSec=60s
+OnUnitActiveSec=120s
+RandomizedDelaySec=15s
+Persistent=true
+
+[Install]
+WantedBy=timers.target

package/tests/conftest.py

@@ -19,6 +19,45 @@ from pathlib import Path
 import pytest
 
 
+@pytest.fixture(autouse=True)
+def _silence_desktop_notifications(monkeypatch):
+    """Suppress real desktop notifications for the entire test session.
+
+    Several code paths (consciousness_loop, kms_scheduler, the send_notification
+    MCP tool, and NotificationManager) shell out to ``notify-send`` / libnotify.
+    Left unmocked, a test run floods the live desktop's notification tray —
+    and mass-closing that backlog can stall single-threaded shells like
+    Cinnamon, freezing the whole UI.  Forcing the guard off keeps test runs
+    silent regardless of which path fires.
+
+    A test that needs to exercise the real dispatch can re-enable it locally
+    with ``monkeypatch.setenv("SKCAPSTONE_DESKTOP_NOTIFY", "1")``.
+    """
+    monkeypatch.setenv("SKCAPSTONE_DESKTOP_NOTIFY", "0")
+
+
+@pytest.fixture(autouse=True)
+def _isolate_agent_env(monkeypatch):
+    """Prevent host SKCAPSTONE_AGENT / SKMEMORY_AGENT from leaking into unit tests.
+
+    The profile-aware runtime reads both the env var and the module-level
+    skcapstone.SKCAPSTONE_AGENT (set at import time).  We clear both so that
+    _memory_dir() falls back to the flat "home/memory" layout expected by
+    tests that use the tmp_agent_home fixture.
+    Tests that need a specific agent should override explicitly via monkeypatch.
+    """
+    monkeypatch.delenv("SKCAPSTONE_AGENT", raising=False)
+    monkeypatch.delenv("SKMEMORY_AGENT", raising=False)
+    import skcapstone
+
+    monkeypatch.setattr(skcapstone, "SKCAPSTONE_AGENT", "")
+    # _detect_active_agent() scans ~/.skcapstone/agents/ even when the env var
+    # is cleared, returning a real agent name that routes memory writes to the
+    # wrong directory.  Stub it out so tests using tmp directories get the flat
+    # "home/memory" layout they expect.
+    monkeypatch.setattr(skcapstone, "_detect_active_agent", lambda root=None: None)
+
+
 @pytest.fixture
 def tmp_agent_home(tmp_path: Path) -> Path:
     """Provide a temporary agent home directory for testing."""

package/tests/integration/test_consciousness_e2e.py

@@ -7,16 +7,16 @@ Pipeline under test
 -------------------
     1. DaemonService starts with consciousness loop enabled (in-process thread).
     2. A .skc.json envelope is dropped into the inbox directory,
-       simulating delivery by SKComm or ``skcapstone send``.
+       simulating delivery by SKComms or ``skcapstone send``.
     3. Inotify / watchdog detects the file within 5 s.
     4. ConsciousnessLoop classifies the message and calls LLMBridge.generate().
-    5. Mock SKComm captures the outbound response.
+    5. Mock SKComms captures the outbound response.
     6. All steps complete within 60 s total.
 
 Related coordination tasks
 --------------------------
     [8fbd0130] — Full E2E integration test (this file)
-    [c9e7b9d8] — End-to-end consciousness test: send SKComm message,
+    [c9e7b9d8] — End-to-end consciousness test: send SKComms message,
                  verify autonomous response
 
 Running
@@ -29,8 +29,8 @@ Running
 
 Known daemon startup issues
 ---------------------------
-    * SKComm not configured in test home: DaemonService logs a warning and
-      skips SKComm polling.  Consciousness loop still runs via inotify.
+    * SKComms not configured in test home: DaemonService logs a warning and
+      skips SKComms polling.  Consciousness loop still runs via inotify.
     * Prompt build latency: SystemPromptBuilder.build() loads identity, soul,
       context, and snapshots from disk.  In tests this takes ~3-4 s even with
       empty dirs because it probes optional YAML/JSON files.  Tests account for
@@ -133,7 +133,7 @@ def _make_loop(
             None → let the real bridge run (requires backends).
 
     Returns:
-        (loop, mock_skcomm, inbox_dir) triple.
+        (loop, mock_skcomms, inbox_dir) triple.
     """
     from skcapstone.consciousness_loop import ConsciousnessConfig, ConsciousnessLoop, LLMBridge
 
@@ -162,11 +162,11 @@ def _make_loop(
         mock_bridge.available_backends = {"passthrough": True}
         loop._bridge = mock_bridge
 
-    # Inject a mock SKComm so responses are captured without real transport
-    mock_skcomm = MagicMock()
-    loop.set_skcomm(mock_skcomm)
+    # Inject a mock SKComms so responses are captured without real transport
+    mock_skcomms = MagicMock()
+    loop.set_skcomms(mock_skcomms)
 
-    return loop, mock_skcomm, inbox_dir
+    return loop, mock_skcomms, inbox_dir
 
 
 def _wait_for_http(port: int, path: str = "/status", timeout: float = 20.0) -> bool:
@@ -272,7 +272,7 @@ class TestInboxFileTrigger:
         """_on_inbox_file submits a valid .skc.json for async processing."""
         from skcapstone.consciousness_loop import SystemPromptBuilder
 
-        loop, mock_skcomm, inbox_dir = _make_loop(
+        loop, mock_skcomms, inbox_dir = _make_loop(
             tmp_path, use_inotify=False, mock_generate="pong"
         )
 
@@ -286,7 +286,7 @@ class TestInboxFileTrigger:
             if isinstance(message, str) and message not in ("ACK",):
                 response_event.set()
 
-        mock_skcomm.send.side_effect = _capture_send
+        mock_skcomms.send.side_effect = _capture_send
 
         msg_path, _ = _drop_message(inbox_dir, content="ping")
 
@@ -299,7 +299,7 @@ class TestInboxFileTrigger:
 
         assert got_response, (
             "_on_inbox_file did not produce a response within 10s. "
-            f"SKComm calls: {mock_skcomm.send.call_args_list}"
+            f"SKComms calls: {mock_skcomms.send.call_args_list}"
         )
 
 
@@ -377,18 +377,18 @@ class TestLLMClassifyAndGenerate:
 
 
 # ===========================================================================
-# Test Class 3: Response delivery via SKComm
+# Test Class 3: Response delivery via SKComms
 # ===========================================================================
 
 
 class TestResponseDeliveredViaSkcomm:
-    """Verify that the generated response is sent back through SKComm."""
+    """Verify that the generated response is sent back through SKComms."""
 
     def test_response_sent_to_sender(self, tmp_path: Path) -> None:
-        """Mock SKComm.send() is called with the LLM response directed at the sender."""
+        """Mock SKComms.send() is called with the LLM response directed at the sender."""
         from skcapstone.consciousness_loop import _SimpleEnvelope
 
-        loop, mock_skcomm, _ = _make_loop(
+        loop, mock_skcomms, _ = _make_loop(
             tmp_path, use_inotify=False, mock_generate="Hello from the agent!"
         )
 
@@ -399,21 +399,21 @@ class TestResponseDeliveredViaSkcomm:
         result = loop.process_envelope(envelope)
 
         assert result == "Hello from the agent!"
-        # Verify SKComm.send was called with the response
+        # Verify SKComms.send was called with the response
         response_calls = [
-            call for call in mock_skcomm.send.call_args_list
+            call for call in mock_skcomms.send.call_args_list
             if len(call.args) >= 2 and call.args[1] == "Hello from the agent!"
         ]
         assert response_calls, (
-            f"SKComm.send() was not called with the LLM response. "
-            f"All calls: {mock_skcomm.send.call_args_list}"
+            f"SKComms.send() was not called with the LLM response. "
+            f"All calls: {mock_skcomms.send.call_args_list}"
         )
         assert response_calls[0].args[0] == "alice", (
             f"Response sent to wrong peer: {response_calls[0].args[0]}"
         )
 
     def test_responses_sent_counter_increments(self, tmp_path: Path) -> None:
-        """stats['responses_sent'] increments each time SKComm.send() succeeds."""
+        """stats['responses_sent'] increments each time SKComms.send() succeeds."""
         from skcapstone.consciousness_loop import _SimpleEnvelope
 
         loop, _, _ = _make_loop(tmp_path, use_inotify=False, mock_generate="reply")
@@ -427,8 +427,8 @@ class TestResponseDeliveredViaSkcomm:
 
         assert loop.stats["responses_sent"] == 3
 
-    def test_skcomm_none_does_not_crash(self, tmp_path: Path) -> None:
-        """Loop processes correctly even when no SKComm is set (responses dropped silently)."""
+    def test_skcomms_none_does_not_crash(self, tmp_path: Path) -> None:
+        """Loop processes correctly even when no SKComms is set (responses dropped silently)."""
         from skcapstone.consciousness_loop import (
             ConsciousnessConfig, ConsciousnessLoop, LLMBridge, _SimpleEnvelope,
         )
@@ -442,7 +442,7 @@ class TestResponseDeliveredViaSkcomm:
         with patch.object(LLMBridge, "_probe_ollama", return_value=False):
             loop = ConsciousnessLoop(config, home=home, shared_root=shared)
 
-        # No SKComm set — _skcomm stays None
+        # No SKComms set — _skcomms stays None
         loop._bridge = MagicMock()
         loop._bridge.generate.return_value = "silent reply"
         loop._bridge.available_backends = {"passthrough": True}
@@ -452,7 +452,7 @@ class TestResponseDeliveredViaSkcomm:
             "payload": {"content": "hello", "content_type": "text"},
         }))
         assert result == "silent reply"
-        assert loop.stats["responses_sent"] == 0  # no SKComm → not counted
+        assert loop.stats["responses_sent"] == 0  # no SKComms → not counted
 
 
 # ===========================================================================
@@ -461,7 +461,7 @@ class TestResponseDeliveredViaSkcomm:
 
 
 class TestFullE2EPipeline:
-    """End-to-end: drop .skc.json → inotify → classify → LLM → SKComm response.
+    """End-to-end: drop .skc.json → inotify → classify → LLM → SKComms response.
 
     Asserts the complete pipeline completes within TOTAL_TIMEOUT seconds.
     This is the primary test for task [8fbd0130] and [c9e7b9d8].
@@ -470,13 +470,13 @@ class TestFullE2EPipeline:
     def test_full_pipeline_within_60s(self, tmp_path: Path) -> None:
         """
         Drop a .skc.json, start the consciousness loop with inotify, and assert
-        the mock SKComm.send() is called with a response within TOTAL_TIMEOUT.
+        the mock SKComms.send() is called with a response within TOTAL_TIMEOUT.
 
         Two-phase assertion:
             Phase 1 — Inotify pickup:  _on_inbox_file fires within INOTIFY_TIMEOUT (5 s)
             Phase 2 — Full pipeline:   response is sent within TOTAL_TIMEOUT (60 s)
         """
-        loop, mock_skcomm, inbox_dir = _make_loop(
+        loop, mock_skcomms, inbox_dir = _make_loop(
             tmp_path,
             use_inotify=True,
             mock_generate="E2E test response — pipeline complete.",
@@ -510,7 +510,7 @@ class TestFullE2EPipeline:
             response_captured.append(message)
             response_event.set()
 
-        mock_skcomm.send.side_effect = _capturing_send
+        mock_skcomms.send.side_effect = _capturing_send
 
         # Start inotify + config-watcher threads
         threads = loop.start()
@@ -556,7 +556,7 @@ class TestFullE2EPipeline:
         assert got_response, (
             f"No response captured within {_TOTAL_TIMEOUT}s. "
             f"Pickup at t={t_pickup:.1f}s; total elapsed: {total_elapsed:.1f}s. "
-            f"SKComm calls: {mock_skcomm.send.call_args_list}"
+            f"SKComms calls: {mock_skcomms.send.call_args_list}"
         )
         assert response_captured, "response_captured list is empty"
         assert "E2E test response" in response_captured[0], (
@@ -571,7 +571,7 @@ class TestFullE2EPipeline:
 
     def test_inotify_pickup_within_5s(self, tmp_path: Path) -> None:
         """Assert the inotify watcher detects the inbox file within INOTIFY_TIMEOUT seconds."""
-        loop, mock_skcomm, inbox_dir = _make_loop(tmp_path, use_inotify=True)
+        loop, mock_skcomms, inbox_dir = _make_loop(tmp_path, use_inotify=True)
 
         pickup_event = threading.Event()
         picked_up_paths: list[Path] = []
@@ -776,9 +776,9 @@ class TestDaemonServiceIntegration:
     ) -> None:
         """
         Full integration: start daemon → drop .skc.json → consciousness loop
-        processes the file → response captured on mock SKComm.
+        processes the file → response captured on mock SKComms.
 
-        This covers task [c9e7b9d8]: send SKComm message, verify autonomous response.
+        This covers task [c9e7b9d8]: send SKComms message, verify autonomous response.
         """
         from skcapstone.daemon import DaemonConfig, DaemonService
         from skcapstone.consciousness_loop import LLMBridge
@@ -801,7 +801,7 @@ class TestDaemonServiceIntegration:
         response_event = threading.Event()
         captured_responses: list[str] = []
 
-        mock_skcomm = MagicMock()
+        mock_skcomms = MagicMock()
 
         def _capturing_send(peer, message, **kwargs):
             # Skip heartbeat / typing-indicator sends (they carry message_type kwarg).
@@ -811,7 +811,7 @@ class TestDaemonServiceIntegration:
                 captured_responses.append(message)
                 response_event.set()
 
-        mock_skcomm.send.side_effect = _capturing_send
+        mock_skcomms.send.side_effect = _capturing_send
 
         with (
             patch.object(service, "_setup_signals"),
@@ -827,7 +827,7 @@ class TestDaemonServiceIntegration:
                 t.join(timeout=5)
                 pytest.skip(f"Daemon HTTP not ready within 30s on port {free_port}")
 
-            # Inject mock LLM and mock SKComm into the running consciousness loop
+            # Inject mock LLM and mock SKComms into the running consciousness loop
             consciousness = service._consciousness
             if consciousness is None:
                 service.stop()
@@ -839,7 +839,7 @@ class TestDaemonServiceIntegration:
             mock_bridge.generate.return_value = "Autonomous response — consciousness is active."
             mock_bridge.available_backends = {"passthrough": True}
             consciousness._bridge = mock_bridge
-            consciousness.set_skcomm(mock_skcomm)
+            consciousness.set_skcomms(mock_skcomms)
 
             t_start = time.monotonic()
 
@@ -869,7 +869,7 @@ class TestDaemonServiceIntegration:
 
         assert got_response, (
             f"Consciousness loop did not respond within {_TOTAL_TIMEOUT}s. "
-            f"Elapsed: {total_elapsed:.1f}s. SKComm calls: {mock_skcomm.send.call_args_list}"
+            f"Elapsed: {total_elapsed:.1f}s. SKComms calls: {mock_skcomms.send.call_args_list}"
         )
         assert captured_responses, "No response text captured from consciousness loop"
         assert total_elapsed <= _TOTAL_TIMEOUT, (

package/tests/test_agent_card.py

@@ -51,7 +51,7 @@ def sample_card(test_keys: tuple[str, str]) -> AgentCard:
         public_key=pub,
         entity_type="ai",
         transports=[
-            TransportEndpoint(transport="file", address="/tmp/skcomm/drop"),
+            TransportEndpoint(transport="file", address="/tmp/skcomms/drop"),
             TransportEndpoint(transport="nostr", address="abc123" * 10 + "abcd"),
         ],
         capabilities=[

package/tests/test_agent_home_scaffold.py

@@ -0,0 +1,34 @@
+"""Tests for fresh agent-home scaffolding."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from unittest.mock import patch
+
+from skcapstone.migrate_multi_agent import create_agent_home
+
+
+class TestCreateAgentHome:
+    def test_manifest_includes_human_operator_when_available(self, tmp_path: Path):
+        """New agent homes persist the linked human operator in manifest.json."""
+        with patch(
+            "skcapstone.migrate_multi_agent.discover_human_operator",
+            return_value={"name": "Casey", "fingerprint": "FP123", "relationship": "human-operator"},
+        ):
+            result = create_agent_home(tmp_path, "teddy")
+
+        manifest = json.loads((tmp_path / "agents" / "teddy" / "manifest.json").read_text())
+        assert result["agent_name"] == "teddy"
+        assert manifest["name"] == "teddy"
+        assert manifest["operator"]["name"] == "Casey"
+        assert manifest["operator"]["fingerprint"] == "FP123"
+
+    def test_manifest_omits_operator_when_none_available(self, tmp_path: Path):
+        """New agent homes still create a valid manifest when no operator exists yet."""
+        with patch("skcapstone.migrate_multi_agent.discover_human_operator", return_value=None):
+            create_agent_home(tmp_path, "lumina")
+
+        manifest = json.loads((tmp_path / "agents" / "lumina" / "manifest.json").read_text())
+        assert manifest["name"] == "lumina"
+        assert "operator" not in manifest

package/tests/test_alerts_consumer_topics.py

@@ -0,0 +1,27 @@
+"""T3 — alerts command surfaces consumer <service>.<severity> topics."""
+
+from __future__ import annotations
+
+from skcapstone.cli.alerts import DEFAULT_TOPICS, _style_for_topic
+
+
+def test_severity_wildcards_subscribed():
+    """The command subscribes to severity wildcards so any service is seen."""
+    for sev in ("*.critical", "*.error", "*.warn"):
+        assert sev in DEFAULT_TOPICS
+
+
+def test_exact_topic_style_wins():
+    assert _style_for_topic("agent.critical") == "bold red"
+
+
+def test_consumer_topic_styled_by_severity_suffix():
+    assert _style_for_topic("skmemory.error") == "red"
+    assert _style_for_topic("sksecurity.critical") == "bold red"
+    assert _style_for_topic("skvoice.warn") == "yellow"
+    assert _style_for_topic("skseed.info") == "cyan"
+
+
+def test_unknown_topic_is_dim():
+    assert _style_for_topic("something.random") == "dim"
+    assert _style_for_topic("noseparator") == "dim"

package/tests/test_backup.py

@@ -237,7 +237,8 @@ class TestBackupManifest:
     def test_manifest_defaults(self) -> None:
         """Manifest has sensible defaults."""
         m = BackupManifest()
-        assert m.version == "0.9.0"
+        import skcapstone
+        assert m.version == skcapstone.__version__
         assert m.files == {}
         assert m.total_size == 0
 

package/tests/test_chat.py

@@ -105,8 +105,8 @@ class TestShortTimestamp:
 class TestAgentChatSend:
     """Tests for AgentChat.send() without real transport."""
 
-    def test_send_stores_locally_without_skcomm(self, tmp_home):
-        """Message is stored in history even without SKComm."""
+    def test_send_stores_locally_without_skcomms(self, tmp_home):
+        """Message is stored in history even without SKComms."""
         agent = AgentChat(home=tmp_home, identity="opus")
 
         mock_history = MagicMock()
@@ -120,8 +120,8 @@ class TestAgentChatSend:
         assert result["delivered"] is False
         mock_history.store_message.assert_called_once()
 
-    def test_send_delivers_with_skcomm(self, tmp_home):
-        """Message is delivered when SKComm has transports."""
+    def test_send_delivers_with_skcomms(self, tmp_home):
+        """Message is delivered when SKComms has transports."""
         agent = AgentChat(home=tmp_home, identity="opus")
 
         mock_comm = MagicMock()
@@ -228,7 +228,7 @@ class TestAgentChatForward:
         assert payload["content"] == "Deploy the fleet"
 
     def test_forward_delivers_via_comm(self, tmp_home):
-        """Forward delivers via SKComm when transports are available."""
+        """Forward delivers via SKComms when transports are available."""
         agent = AgentChat(home=tmp_home, identity="opus")
 
         mock_comm = MagicMock()
@@ -360,7 +360,7 @@ class TestCLIChatCommands:
         assert "not found" in result.output.lower() or result.exit_code == 1
 
     def test_chat_forward_stored_locally(self, tmp_home):
-        """chat forward stores message when SKComm unavailable."""
+        """chat forward stores message when SKComms unavailable."""
         from skcapstone.cli import main
 
         original = {

package/tests/test_claude_md.py

@@ -211,7 +211,7 @@ class TestRefreshContextCli:
     """Tests for `skcapstone refresh-context` CLI command."""
 
     def _run(self, *args, home: str | None = None) -> "click.testing.Result":
-        runner = CliRunner(mix_stderr=False)
+        runner = CliRunner()
         cmd: list[str] = ["refresh-context"]
         if home:
             cmd += ["--home", home]
@@ -255,7 +255,7 @@ class TestRefreshContextCli:
 
     def test_falls_back_to_cwd_without_git(self, tmp_agent_home: Path, tmp_path: Path):
         """Without --dest and outside a git repo, writes to cwd/CLAUDE.md."""
-        runner = CliRunner(mix_stderr=False)
+        runner = CliRunner()
         written: list[Path] = []
 
         with runner.isolated_filesystem(temp_dir=tmp_path) as iso_dir:

package/tests/test_cli_skills.py

@@ -52,7 +52,7 @@ class TestSkillsList:
         client = _make_registry_client()
 
         with patch("skcapstone.cli.skills_cmd.get_registry_client", return_value=client):
-            result = runner.invoke(main, ["skills", "list"])
+            result = runner.invoke(main, ["skills", "list", "--registry", "https://registry.example"])
 
         assert result.exit_code == 0
         assert "syncthing-setup" in result.output
@@ -64,7 +64,7 @@ class TestSkillsList:
         client = _make_registry_client()
 
         with patch("skcapstone.cli.skills_cmd.get_registry_client", return_value=client):
-            result = runner.invoke(main, ["skills", "list", "--query", "syncthing"])
+            result = runner.invoke(main, ["skills", "list", "--registry", "https://registry.example", "--query", "syncthing"])
 
         assert result.exit_code == 0
         client.search.assert_called_once_with("syncthing")
@@ -78,7 +78,7 @@ class TestSkillsList:
         client = _make_registry_client()
 
         with patch("skcapstone.cli.skills_cmd.get_registry_client", return_value=client):
-            result = runner.invoke(main, ["skills", "list", "--json"])
+            result = runner.invoke(main, ["skills", "list", "--registry", "https://registry.example", "--json"])
 
         assert result.exit_code == 0
         parsed = json.loads(result.output)
@@ -91,7 +91,7 @@ class TestSkillsList:
         client = _make_registry_client(skills=[])
 
         with patch("skcapstone.cli.skills_cmd.get_registry_client", return_value=client):
-            result = runner.invoke(main, ["skills", "list"])
+            result = runner.invoke(main, ["skills", "list", "--registry", "https://registry.example"])
 
         assert result.exit_code == 0
         assert "No skills found" in result.output
@@ -101,10 +101,10 @@ class TestSkillsList:
         runner = CliRunner()
 
         with patch("skcapstone.cli.skills_cmd.get_registry_client", return_value=None):
-            result = runner.invoke(main, ["skills", "list"])
+            with patch("skcapstone.cli.skills_cmd._fetch_github_catalog", return_value=None):
+                result = runner.invoke(main, ["skills", "list", "--registry", "https://registry.example", "--offline"])
 
-        assert result.exit_code == 1
-        assert "skskills not installed" in result.output
+        assert result.exit_code == 0
 
     def test_list_registry_error_exits_1(self):
         """Registry connection error should print an error and exit 1."""
@@ -113,10 +113,10 @@ class TestSkillsList:
         client.list_skills.side_effect = ConnectionError("offline")
 
         with patch("skcapstone.cli.skills_cmd.get_registry_client", return_value=client):
-            result = runner.invoke(main, ["skills", "list"])
+            result = runner.invoke(main, ["skills", "list", "--registry", "https://registry.example"])
 
-        assert result.exit_code == 1
-        assert "Registry error" in result.output
+        assert result.exit_code == 0
+        assert "offline" not in result.output
 
 
 # ---------------------------------------------------------------------------

package/tests/test_cli_test_cmd.py

@@ -22,7 +22,7 @@ from skcapstone.testrunner import PackageResult, TestReport
 
 @pytest.fixture()
 def runner():
-    return CliRunner(mix_stderr=False)
+    return CliRunner()
 
 
 @pytest.fixture()
@@ -31,7 +31,7 @@ def mock_report_all_pass():
     return TestReport(
         results=[
             PackageResult(name="skcapstone", passed=10, exit_code=0, duration_s=1.2),
-            PackageResult(name="skcomm", passed=5, exit_code=0, duration_s=0.8),
+            PackageResult(name="skcomms", passed=5, exit_code=0, duration_s=0.8),
         ],
         duration_s=2.0,
     )
@@ -44,7 +44,7 @@ def mock_report_with_failure():
         results=[
             PackageResult(name="skcapstone", passed=10, exit_code=0, duration_s=1.2),
             PackageResult(
-                name="skcomm",
+                name="skcomms",
                 passed=3,
                 failed=2,
                 exit_code=1,
@@ -116,7 +116,7 @@ class TestInvalidPackage:
             "skcapstone.cli.test_cmd.run_all_tests",
             return_value=mock_report_all_pass,
         ):
-            result = runner.invoke(main, ["test", "--package", "skcomm"])
+            result = runner.invoke(main, ["test", "--package", "skcomms"])
         assert result.exit_code == 0