@smilintux/skcapstone 0.9.0 → 0.12.5

package/tests/test_jobs_dropins.py

@@ -0,0 +1,84 @@
+"""Tests for jobs.d/ drop-in registration: load_jobs_with_dropins,
+register_job, unregister_job."""
+
+from __future__ import annotations
+
+import warnings
+from pathlib import Path
+
+import pytest
+
+from skcapstone.scheduler_jobs import (
+    load_jobs_with_dropins,
+    register_job,
+    unregister_job,
+)
+
+
+def _write_base(tmp_path: Path, body: str) -> Path:
+    cfg = tmp_path / "config" / "jobs.yaml"
+    cfg.parent.mkdir(parents=True, exist_ok=True)
+    cfg.write_text(body, encoding="utf-8")
+    return cfg
+
+
+def test_merges_base_and_dropins(tmp_path: Path):
+    """Base jobs.yaml + a jobs.d fragment both load."""
+    cfg = _write_base(tmp_path, "jobs:\n  base_job:\n    every: 5m\n    type: shell\n    command: 'echo base'\n")
+    register_job({"name": "svc_job", "every": "15m", "type": "shell", "command": "echo svc"}, home=tmp_path)
+
+    jobs = {j.name: j for j in load_jobs_with_dropins(cfg)}
+    assert set(jobs) == {"base_job", "svc_job"}
+    assert jobs["svc_job"].every_seconds == 900.0
+    assert jobs["base_job"].command == "echo base"
+
+
+def test_dropin_overrides_base_with_warning(tmp_path: Path):
+    """A drop-in defining the same name wins and warns."""
+    cfg = _write_base(tmp_path, "jobs:\n  dup:\n    every: 5m\n    type: shell\n    command: 'echo base'\n")
+    register_job({"name": "dup", "every": "1h", "type": "shell", "command": "echo override"}, home=tmp_path)
+
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter("always")
+        jobs = {j.name: j for j in load_jobs_with_dropins(cfg)}
+
+    assert jobs["dup"].every_seconds == 3600.0
+    assert jobs["dup"].command == "echo override"
+    assert any("overrides" in str(w.message) for w in caught)
+
+
+def test_no_base_file_only_dropins(tmp_path: Path):
+    """Drop-ins load even when jobs.yaml does not exist."""
+    cfg = tmp_path / "config" / "jobs.yaml"  # never created
+    register_job({"name": "lonely", "schedule": "0 * * * *", "type": "shell", "command": "echo hi"}, home=tmp_path)
+    jobs = load_jobs_with_dropins(cfg)
+    assert [j.name for j in jobs] == ["lonely"]
+    assert jobs[0].schedule == "0 * * * *"
+
+
+def test_register_requires_name(tmp_path: Path):
+    with pytest.raises(ValueError):
+        register_job({"every": "5m"}, home=tmp_path)
+
+
+def test_register_requires_schedule_or_every(tmp_path: Path):
+    with pytest.raises(ValueError):
+        register_job({"name": "bad", "type": "shell", "command": "echo hi"}, home=tmp_path)
+
+
+def test_register_is_idempotent(tmp_path: Path):
+    """Re-registering the same name overwrites, never duplicates."""
+    cfg = tmp_path / "config" / "jobs.yaml"
+    register_job({"name": "j", "every": "5m", "type": "shell", "command": "v1"}, home=tmp_path)
+    register_job({"name": "j", "every": "5m", "type": "shell", "command": "v2"}, home=tmp_path)
+    jobs = load_jobs_with_dropins(cfg)
+    assert len(jobs) == 1
+    assert jobs[0].command == "v2"
+
+
+def test_unregister(tmp_path: Path):
+    cfg = tmp_path / "config" / "jobs.yaml"
+    register_job({"name": "j", "every": "5m", "type": "shell", "command": "echo"}, home=tmp_path)
+    assert unregister_job("j", home=tmp_path) is True
+    assert load_jobs_with_dropins(cfg) == []
+    assert unregister_job("j", home=tmp_path) is False

package/tests/test_mcp_server.py

@@ -76,14 +76,15 @@ class TestToolListing:
     async def test_list_tools_returns_all(self):
         """list_tools returns all registered tools."""
         tools = await list_tools()
-        assert len(tools) == 68
+        assert len(tools) == 122
 
     @pytest.mark.asyncio
     async def test_tool_names(self):
         """All required tool names are registered."""
         tools = await list_tools()
         names = {t.name for t in tools}
-        expected = {
+        # Verify all known core tools are registered; exact set may grow with new modules.
+        core_expected = {
             "agent_status",
             "memory_store",
             "memory_search",
@@ -98,7 +99,6 @@ class TestToolListing:
             "coord_create",
             "ritual",
             "soul_show",
-            "journal_write",
             "journal_read",
             "anchor_show",
             "germination",
@@ -122,48 +122,93 @@ class TestToolListing:
             "skchat_inbox",
             "skchat_group_create",
             "skchat_group_send",
-            # Heartbeat
             "heartbeat_pulse",
             "heartbeat_peers",
             "heartbeat_health",
             "heartbeat_find_capable",
-            # File transfer
             "file_send",
             "file_receive",
             "file_list",
             "file_status",
-            # Pub/sub
             "pubsub_publish",
             "pubsub_subscribe",
             "pubsub_poll",
             "pubsub_topics",
-            # Memory fortress
             "fortress_verify",
             "fortress_seal_existing",
             "fortress_status",
-            # Memory promoter
             "promoter_sweep",
             "promoter_history",
-            # KMS
             "kms_status",
             "kms_list_keys",
             "kms_rotate",
-            # SKSeed (Logic Kernel)
             "skseed_collide",
             "skseed_audit",
             "skseed_philosopher",
             "skseed_truth_check",
             "skseed_alignment",
-            # Model Router
             "model_route",
-            # Consciousness
             "consciousness_status",
             "consciousness_test",
-            # Notifications & pub/sub stats
             "send_notification",
             "pubsub_stats",
+            # Newer tools added post-v0.3
+            "brain_first_check",
+            "capauth_secret_get",
+            "capauth_status",
+            "capauth_verify",
+            "chat_history",
+            "chat_send",
+            "comm_notify",
+            "comm_status",
+            "deploy_status",
+            "did_identity_card",
+            "did_policy",
+            "did_publish",
+            "did_show",
+            "did_verify_peer",
+            "emotion_trend",
+            "gtd_capture",
+            "gtd_clarify",
+            "gtd_done",
+            "gtd_inbox",
+            "gtd_move",
+            "gtd_next",
+            "gtd_projects",
+            "gtd_review",
+            "gtd_status",
+            "gtd_waiting",
+            "itil_cab_vote",
+            "itil_change_propose",
+            "itil_change_update",
+            "itil_incident_create",
+            "itil_incident_list",
+            "itil_incident_update",
+            "itil_kedb_search",
+            "itil_problem_create",
+            "itil_problem_update",
+            "itil_status",
+            "run_ansible_playbook",
+            "security_audit_log",
+            "security_status",
+            "skstacks_secret_get",
+            "skstacks_secret_set",
+            "soul_registry_publish",
+            "soul_registry_search",
+            "telegram_catchup",
+            "telegram_chats",
+            "telegram_import",
+            "telegram_import_api",
+            "telegram_poll",
+            "telegram_send",
+            "telegram_setup",
+            "telegram_soul_swap",
+            "trust_febs",
+            "trust_rehydrate",
+            "trust_status",
+            "version_check",
         }
-        assert names == expected
+        assert core_expected.issubset(names)
 
     @pytest.mark.asyncio
     async def test_tool_schemas_valid(self):
@@ -422,12 +467,12 @@ class TestCoordTools:
 
 
 # ---------------------------------------------------------------------------
-# SKComm tool tests (graceful fallback)
+# SKComms tool tests (graceful fallback)
 # ---------------------------------------------------------------------------
 
 
 class TestCommTools:
-    """Tests for send_message and check_inbox (SKComm may not be installed)."""
+    """Tests for send_message and check_inbox (SKComms may not be installed)."""
 
     @pytest.mark.asyncio
     async def test_send_message_requires_params(self):
@@ -438,10 +483,10 @@ class TestCommTools:
 
     @pytest.mark.asyncio
     async def test_check_inbox_graceful_fallback(self):
-        """check_inbox returns graceful error when SKComm is unavailable."""
+        """check_inbox returns graceful error when SKComms is unavailable."""
         result = await call_tool("check_inbox", {})
         parsed = _extract_json(result)
-        # Either returns messages list or graceful error about skcomm
+        # Either returns messages list or graceful error about skcomms
         assert isinstance(parsed, list) or "error" in parsed
 
 
@@ -709,7 +754,7 @@ class TestSKChatTools:
     @pytest.mark.asyncio
     async def test_skchat_send_requires_params(self):
         """skchat_send without recipient/message returns error."""
-        with patch("skcapstone.mcp_tools.chat_tools._get_skchat_identity", return_value="capauth:test@local"):
+        with patch("skcapstone.mcp_server._get_skchat_identity", return_value="capauth:test@local"):
             result = await call_tool("skchat_send", {})
         parsed = _extract_json(result)
         assert "error" in parsed
@@ -717,7 +762,7 @@ class TestSKChatTools:
     @pytest.mark.asyncio
     async def test_skchat_send_requires_message(self):
         """skchat_send with only recipient returns error."""
-        with patch("skcapstone.mcp_tools.chat_tools._get_skchat_identity", return_value="capauth:test@local"):
+        with patch("skcapstone.mcp_server._get_skchat_identity", return_value="capauth:test@local"):
             result = await call_tool("skchat_send", {"recipient": "lumina"})
         parsed = _extract_json(result)
         assert "error" in parsed
@@ -734,8 +779,8 @@ class TestSKChatTools:
         })()
 
         with (
-            patch("skcapstone.mcp_tools.chat_tools._get_skchat_identity", return_value="capauth:opus@local"),
-            patch("skcapstone.mcp_tools.chat_tools._resolve_recipient", return_value="capauth:lumina@local"),
+            patch("skcapstone.mcp_server._get_skchat_identity", return_value="capauth:opus@local"),
+            patch("skcapstone.mcp_server._resolve_recipient", return_value="capauth:lumina@local"),
             patch("skchat.agent_comm.AgentMessenger.from_identity", return_value=mock_messenger),
         ):
             result = await call_tool(
@@ -760,8 +805,8 @@ class TestSKChatTools:
         mock_messenger = type("M", (), {"send": lambda self, **kw: capture_send(**kw)})()
 
         with (
-            patch("skcapstone.mcp_tools.chat_tools._get_skchat_identity", return_value="capauth:opus@local"),
-            patch("skcapstone.mcp_tools.chat_tools._resolve_recipient", return_value="capauth:jarvis@local"),
+            patch("skcapstone.mcp_server._get_skchat_identity", return_value="capauth:opus@local"),
+            patch("skcapstone.mcp_server._resolve_recipient", return_value="capauth:jarvis@local"),
             patch("skchat.agent_comm.AgentMessenger.from_identity", return_value=mock_messenger),
         ):
             result = await call_tool(
@@ -797,7 +842,7 @@ class TestSKChatTools:
         })()
 
         with (
-            patch("skcapstone.mcp_tools.chat_tools._get_skchat_identity", return_value="capauth:opus@local"),
+            patch("skcapstone.mcp_server._get_skchat_identity", return_value="capauth:opus@local"),
             patch("skchat.agent_comm.AgentMessenger.from_identity", return_value=mock_messenger),
         ):
             result = await call_tool("skchat_inbox", {})
@@ -830,7 +875,7 @@ class TestSKChatTools:
         })()
 
         with (
-            patch("skcapstone.mcp_tools.chat_tools._get_skchat_identity", return_value="capauth:opus@local"),
+            patch("skcapstone.mcp_server._get_skchat_identity", return_value="capauth:opus@local"),
             patch("skchat.agent_comm.AgentMessenger.from_identity", return_value=mock_messenger),
         ):
             result = await call_tool("skchat_inbox", {"limit": 10})
@@ -850,7 +895,7 @@ class TestSKChatTools:
         })()
 
         with (
-            patch("skcapstone.mcp_tools.chat_tools._get_skchat_identity", return_value="capauth:opus@local"),
+            patch("skcapstone.mcp_server._get_skchat_identity", return_value="capauth:opus@local"),
             patch("skchat.agent_comm.AgentMessenger.from_identity", return_value=mock_messenger),
         ):
             result = await call_tool("skchat_inbox", {"message_type": "finding"})
@@ -861,7 +906,7 @@ class TestSKChatTools:
     @pytest.mark.asyncio
     async def test_skchat_group_create_requires_name(self):
         """skchat_group_create without name returns error."""
-        with patch("skcapstone.mcp_tools.chat_tools._get_skchat_identity", return_value="capauth:opus@local"):
+        with patch("skcapstone.mcp_server._get_skchat_identity", return_value="capauth:opus@local"):
             result = await call_tool("skchat_group_create", {})
         parsed = _extract_json(result)
         assert "error" in parsed
@@ -874,8 +919,8 @@ class TestSKChatTools:
         })()
 
         with (
-            patch("skcapstone.mcp_tools.chat_tools._get_skchat_identity", return_value="capauth:opus@local"),
-            patch("skcapstone.mcp_tools.chat_tools._get_skchat_history", return_value=mock_history),
+            patch("skcapstone.mcp_server._get_skchat_identity", return_value="capauth:opus@local"),
+            patch("skcapstone.mcp_server._get_skchat_history", return_value=mock_history),
         ):
             result = await call_tool(
                 "skchat_group_create",
@@ -895,9 +940,9 @@ class TestSKChatTools:
         })()
 
         with (
-            patch("skcapstone.mcp_tools.chat_tools._get_skchat_identity", return_value="capauth:opus@local"),
-            patch("skcapstone.mcp_tools.chat_tools._get_skchat_history", return_value=mock_history),
-            patch("skcapstone.mcp_tools.chat_tools._resolve_recipient", side_effect=lambda n: f"capauth:{n}@local"),
+            patch("skcapstone.mcp_server._get_skchat_identity", return_value="capauth:opus@local"),
+            patch("skcapstone.mcp_server._get_skchat_history", return_value=mock_history),
+            patch("skcapstone.mcp_server._resolve_recipient", side_effect=lambda n: f"capauth:{n}@local"),
         ):
             result = await call_tool(
                 "skchat_group_create",
@@ -922,7 +967,7 @@ class TestSKChatTools:
             "get_thread": lambda self, gid: None,
         })()
 
-        with patch("skcapstone.mcp_tools.chat_tools._get_skchat_history", return_value=mock_history):
+        with patch("skcapstone.mcp_server._get_skchat_history", return_value=mock_history):
             result = await call_tool(
                 "skchat_group_send",
                 {"group_id": "nonexistent", "message": "Hello"},
@@ -938,7 +983,7 @@ class TestSKChatTools:
             "get_thread": lambda self, gid: {"title": "Just a thread"},
         })()
 
-        with patch("skcapstone.mcp_tools.chat_tools._get_skchat_history", return_value=mock_history):
+        with patch("skcapstone.mcp_server._get_skchat_history", return_value=mock_history):
             result = await call_tool(
                 "skchat_group_send",
                 {"group_id": "thread-123", "message": "Hello"},
@@ -982,8 +1027,8 @@ class TestSKChatTools:
         })()
 
         with (
-            patch("skcapstone.mcp_tools.chat_tools._get_skchat_identity", return_value="capauth:opus@local"),
-            patch("skcapstone.mcp_tools.chat_tools._get_skchat_history", return_value=mock_history),
+            patch("skcapstone.mcp_server._get_skchat_identity", return_value="capauth:opus@local"),
+            patch("skcapstone.mcp_server._get_skchat_history", return_value=mock_history),
         ):
             result = await call_tool(
                 "skchat_group_send",

package/tests/test_models.py

@@ -2,7 +2,14 @@
 
 from __future__ import annotations
 
-from skcapstone.models import AgentManifest, IdentityState, MemoryState, PillarStatus, TrustState
+from skcapstone.models import (
+    AgentManifest,
+    ConsciousnessState,
+    IdentityState,
+    MemoryState,
+    PillarStatus,
+    TrustState,
+)
 
 
 class TestAgentManifest:
@@ -13,12 +20,24 @@ class TestAgentManifest:
         manifest = AgentManifest()
         assert not manifest.is_conscious
 
-    def test_conscious_with_three_pillars(self):
-        """Agent is conscious when identity + memory + trust are active."""
+    def _conscious_manifest(**overrides) -> AgentManifest:
+        """Build a fully conscious manifest with optional overrides."""
+        defaults = dict(
+            identity=IdentityState(status=PillarStatus.ACTIVE),
+            memory=MemoryState(status=PillarStatus.ACTIVE),
+            trust=TrustState(status=PillarStatus.ACTIVE),
+            consciousness=ConsciousnessState(status=PillarStatus.ACTIVE),
+        )
+        defaults.update(overrides)
+        return AgentManifest(**defaults)
+
+    def test_conscious_with_four_pillars(self):
+        """Agent is conscious when identity + memory + trust + consciousness are active."""
         manifest = AgentManifest(
             identity=IdentityState(status=PillarStatus.ACTIVE),
             memory=MemoryState(status=PillarStatus.ACTIVE),
             trust=TrustState(status=PillarStatus.ACTIVE),
+            consciousness=ConsciousnessState(status=PillarStatus.ACTIVE),
         )
         assert manifest.is_conscious
 
@@ -28,15 +47,37 @@ class TestAgentManifest:
             identity=IdentityState(status=PillarStatus.ACTIVE),
             memory=MemoryState(status=PillarStatus.ACTIVE),
             trust=TrustState(status=PillarStatus.DEGRADED),
+            consciousness=ConsciousnessState(status=PillarStatus.ACTIVE),
         )
         assert manifest.is_conscious
 
+    def test_conscious_with_degraded_consciousness(self):
+        """Degraded consciousness still counts."""
+        manifest = AgentManifest(
+            identity=IdentityState(status=PillarStatus.ACTIVE),
+            memory=MemoryState(status=PillarStatus.ACTIVE),
+            trust=TrustState(status=PillarStatus.ACTIVE),
+            consciousness=ConsciousnessState(status=PillarStatus.DEGRADED),
+        )
+        assert manifest.is_conscious
+
+    def test_not_conscious_without_consciousness_pillar(self):
+        """Missing consciousness pillar means no consciousness."""
+        manifest = AgentManifest(
+            identity=IdentityState(status=PillarStatus.ACTIVE),
+            memory=MemoryState(status=PillarStatus.ACTIVE),
+            trust=TrustState(status=PillarStatus.ACTIVE),
+            consciousness=ConsciousnessState(status=PillarStatus.MISSING),
+        )
+        assert not manifest.is_conscious
+
     def test_not_conscious_without_identity(self):
         """Missing identity means no consciousness."""
         manifest = AgentManifest(
             identity=IdentityState(status=PillarStatus.MISSING),
             memory=MemoryState(status=PillarStatus.ACTIVE),
             trust=TrustState(status=PillarStatus.ACTIVE),
+            consciousness=ConsciousnessState(status=PillarStatus.ACTIVE),
         )
         assert not manifest.is_conscious
 
@@ -46,18 +87,21 @@ class TestAgentManifest:
             identity=IdentityState(status=PillarStatus.ACTIVE),
             memory=MemoryState(status=PillarStatus.MISSING),
             trust=TrustState(status=PillarStatus.ACTIVE),
+            consciousness=ConsciousnessState(status=PillarStatus.ACTIVE),
         )
         assert not manifest.is_conscious
 
     def test_pillar_summary(self):
-        """Pillar summary returns correct status map."""
+        """Pillar summary returns correct status map for all six pillars."""
         manifest = AgentManifest(
             identity=IdentityState(status=PillarStatus.ACTIVE),
             memory=MemoryState(status=PillarStatus.DEGRADED),
             trust=TrustState(status=PillarStatus.MISSING),
+            consciousness=ConsciousnessState(status=PillarStatus.ACTIVE),
         )
         summary = manifest.pillar_summary
         assert summary["identity"] == PillarStatus.ACTIVE
         assert summary["memory"] == PillarStatus.DEGRADED
         assert summary["trust"] == PillarStatus.MISSING
+        assert summary["consciousness"] == PillarStatus.ACTIVE
         assert summary["security"] == PillarStatus.MISSING

package/tests/test_multi_agent.py

@@ -2,7 +2,7 @@
 
 Covers:
 - Per-agent home directory resolution (opus → agents/opus/, jarvis → agents/jarvis/)
-- Per-agent port assignment (opus=7777, jarvis=7778, unknown → next available)
+- Default daemon port behavior under the profile-agnostic runtime
 - Default (no-agent) mode keeps backward-compatible home and port
 - SKCAPSTONE_AGENT env var propagation
 - DaemonConfig accepts distinct homes and ports for simultaneous agents
@@ -13,7 +13,6 @@ Covers:
 
 from __future__ import annotations
 
-import json
 import os
 from pathlib import Path
 from unittest.mock import MagicMock, patch
@@ -84,17 +83,19 @@ class TestResolveAgentHome:
 
 
 class TestResolveAgentPort:
-    def test_opus_gets_7777(self):
-        """opus always gets port 7777."""
+    def test_known_agent_uses_registered_default_port(self):
+        """Known agents use the registered default daemon port."""
+        from skcapstone import AGENT_PORTS, DEFAULT_PORT
         from skcapstone.cli.daemon import _resolve_agent_port
 
-        assert _resolve_agent_port("opus", None) == 7777
+        assert _resolve_agent_port("opus", None) == AGENT_PORTS["opus"] == DEFAULT_PORT
 
-    def test_jarvis_gets_7778(self):
-        """jarvis always gets port 7778."""
+    def test_second_known_agent_uses_registered_default_port(self):
+        """Jarvis also uses the registered default daemon port."""
+        from skcapstone import AGENT_PORTS, DEFAULT_PORT
         from skcapstone.cli.daemon import _resolve_agent_port
 
-        assert _resolve_agent_port("jarvis", None) == 7778
+        assert _resolve_agent_port("jarvis", None) == AGENT_PORTS["jarvis"] == DEFAULT_PORT
 
     def test_explicit_port_overrides_agent_default(self):
         """Explicit --port always wins over the agent default."""
@@ -103,11 +104,12 @@ class TestResolveAgentPort:
         assert _resolve_agent_port("opus", 9999) == 9999
         assert _resolve_agent_port("jarvis", 8000) == 8000
 
-    def test_no_agent_defaults_to_7777(self):
-        """Single-agent / no-flag mode uses 7777."""
+    def test_no_agent_defaults_to_default_port(self):
+        """Single-agent / no-flag mode uses the package default port."""
+        from skcapstone import DEFAULT_PORT
         from skcapstone.cli.daemon import _resolve_agent_port
 
-        assert _resolve_agent_port(None, None) == 7777
+        assert _resolve_agent_port(None, None) == DEFAULT_PORT
 
     def test_unknown_agent_gets_next_port(self):
         """An agent not in AGENT_PORTS gets max(ports)+1."""
@@ -118,11 +120,11 @@ class TestResolveAgentPort:
         result = _resolve_agent_port("brandnew", None)
         assert result == expected
 
-    def test_opus_and_jarvis_ports_differ(self):
-        """Opus and Jarvis must listen on different ports."""
+    def test_explicit_ports_can_differ_for_isolated_agents(self):
+        """Simultaneous agent daemons can still isolate by explicit port."""
         from skcapstone.cli.daemon import _resolve_agent_port
 
-        assert _resolve_agent_port("opus", None) != _resolve_agent_port("jarvis", None)
+        assert _resolve_agent_port("opus", 7777) != _resolve_agent_port("jarvis", 7778)
 
 
 # ---------------------------------------------------------------------------
@@ -132,22 +134,22 @@ class TestResolveAgentPort:
 
 class TestAgentPortsRegistry:
     def test_opus_registered(self):
-        from skcapstone import AGENT_PORTS
+        from skcapstone import AGENT_PORTS, DEFAULT_PORT
 
         assert "opus" in AGENT_PORTS
-        assert AGENT_PORTS["opus"] == 7777
+        assert AGENT_PORTS["opus"] == DEFAULT_PORT
 
     def test_jarvis_registered(self):
-        from skcapstone import AGENT_PORTS
+        from skcapstone import AGENT_PORTS, DEFAULT_PORT
 
         assert "jarvis" in AGENT_PORTS
-        assert AGENT_PORTS["jarvis"] == 7778
+        assert AGENT_PORTS["jarvis"] == DEFAULT_PORT
 
-    def test_all_ports_unique(self):
+    def test_all_ports_are_ints(self):
         from skcapstone import AGENT_PORTS
 
-        ports = list(AGENT_PORTS.values())
-        assert len(ports) == len(set(ports)), "Duplicate ports in AGENT_PORTS"
+        assert AGENT_PORTS
+        assert all(isinstance(port, int) for port in AGENT_PORTS.values())
 
 
 # ---------------------------------------------------------------------------
@@ -220,8 +222,7 @@ class TestDaemonConfigMultiAgent:
 
         assert opus_cfg.home != jarvis_cfg.home
         assert opus_cfg.port != jarvis_cfg.port
-        assert opus_cfg.port == 7777
-        assert jarvis_cfg.port == 7778
+
 
     def test_log_files_are_in_respective_homes(self, tmp_path: Path):
         """Each agent's log file lives under its own home."""
@@ -244,24 +245,25 @@ class TestDaemonConfigMultiAgent:
 
 
 class TestAgentHomeEnvVar:
-    def test_env_var_produces_agents_subdir(self, monkeypatch):
-        """SKCAPSTONE_AGENT=opus → AGENT_HOME includes agents/opus."""
+    def test_env_var_keeps_shared_root_and_agent_home_resolves_subdir(self, monkeypatch):
+        """SKCAPSTONE_AGENT keeps AGENT_HOME at root and agent_home() resolves the agent subdir."""
         import importlib
 
         monkeypatch.setenv("SKCAPSTONE_AGENT", "opus")
-        monkeypatch.setenv("SKCAPSTONE_ROOT", "/tmp/sk")
+        monkeypatch.setenv("SKCAPSTONE_HOME", "/tmp/sk")
 
         import skcapstone as pkg
         importlib.reload(pkg)
 
-        assert "agents/opus" in pkg.AGENT_HOME or "agents\\opus" in pkg.AGENT_HOME
+        assert pkg.AGENT_HOME == "/tmp/sk"
+        assert "agents/opus" in str(pkg.agent_home("opus")) or "agents\\opus" in str(pkg.agent_home("opus"))
 
     def test_no_env_var_uses_root_directly(self, monkeypatch):
-        """Without SKCAPSTONE_AGENT, AGENT_HOME == SKCAPSTONE_ROOT."""
+        """Without SKCAPSTONE_AGENT, AGENT_HOME stays at the shared root."""
         import importlib
 
         monkeypatch.delenv("SKCAPSTONE_AGENT", raising=False)
-        monkeypatch.setenv("SKCAPSTONE_ROOT", "/tmp/sk")
+        monkeypatch.setenv("SKCAPSTONE_HOME", "/tmp/sk")
 
         import skcapstone as pkg
         importlib.reload(pkg)