@smilintux/skcapstone 0.6.2 → 0.6.4

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)

package/tests/test_operator_link.py

@@ -0,0 +1,78 @@
+"""Tests for human-operator manifest linking."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from skcapstone.operator_link import build_agent_manifest, discover_human_operator
+
+
+def test_discover_human_operator_reads_capauth_profile(tmp_path: Path) -> None:
+    """A CapAuth human profile is converted into operator metadata."""
+    capauth_home = tmp_path / ".capauth"
+    profile = capauth_home / "identity" / "profile.json"
+    profile.parent.mkdir(parents=True)
+    profile.write_text(
+        json.dumps(
+            {
+                "entity": {
+                    "name": "Casey",
+                    "entity_type": "human",
+                    "email": "casey@example.com",
+                    "handle": "casey@example.com",
+                },
+                "key_info": {
+                    "fingerprint": "ABCDEF1234567890",
+                },
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    operator = discover_human_operator(capauth_home)
+
+    assert operator == {
+        "name": "Casey",
+        "relationship": "human-operator",
+        "entity_type": "human",
+        "source": "capauth",
+        "email": "casey@example.com",
+        "handle": "casey@example.com",
+        "fingerprint": "ABCDEF1234567890",
+    }
+
+
+def test_discover_human_operator_ignores_non_human_profile(tmp_path: Path) -> None:
+    """AI CapAuth profiles are not treated as human operators."""
+    capauth_home = tmp_path / ".capauth"
+    profile = capauth_home / "identity" / "profile.json"
+    profile.parent.mkdir(parents=True)
+    profile.write_text(
+        json.dumps(
+            {
+                "entity": {
+                    "name": "Jarvis",
+                    "entity_type": "ai",
+                }
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    assert discover_human_operator(capauth_home) is None
+
+
+def test_build_agent_manifest_includes_operator_when_available() -> None:
+    """Operator metadata is persisted directly in the manifest."""
+    manifest = build_agent_manifest(
+        "jarvis",
+        "0.6.0",
+        created_at="2026-01-01T00:00:00+00:00",
+        operator={"name": "Casey", "fingerprint": "FP123", "relationship": "human-operator"},
+    )
+
+    assert manifest["name"] == "jarvis"
+    assert manifest["entity_type"] == "ai-agent"
+    assert manifest["operator"]["name"] == "Casey"
+    assert manifest["operator"]["fingerprint"] == "FP123"

package/tests/test_runtime.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 from pathlib import Path
 
 from skcapstone.runtime import AgentRuntime
@@ -28,6 +29,26 @@ class TestAgentRuntime:
         assert manifest.name == "test-agent"
         assert manifest.last_awakened is not None
 
+    def test_awaken_prefers_identity_name_over_shared_config(self, tmp_path: Path):
+        """Agent-local identity should beat a shared-root fallback config name."""
+        shared_root = tmp_path / ".skcapstone"
+        agent_home = shared_root / "agents" / "aster"
+        (agent_home / "identity").mkdir(parents=True)
+        (agent_home / "config").mkdir(parents=True)
+
+        (shared_root / "config").mkdir(parents=True)
+        (shared_root / "config" / "config.yaml").write_text("agent_name: Jarvis\n")
+        (agent_home / "manifest.json").write_text(json.dumps({"name": "aster"}))
+        (agent_home / "identity" / "identity.json").write_text(json.dumps({
+            "name": "Aster",
+            "fingerprint": "A" * 40,
+            "capauth_managed": True,
+        }))
+
+        runtime = AgentRuntime(home=agent_home)
+        manifest = runtime.awaken()
+        assert manifest.name == "Aster"
+
     def test_register_connector(self, initialized_agent_home: Path):
         """Registering a connector should persist it."""
         runtime = AgentRuntime(home=initialized_agent_home)

package/tests/test_session_briefing.py

@@ -0,0 +1,130 @@
+"""Tests for the native SKCapstone session briefing."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+
+from click.testing import CliRunner
+
+from skcapstone.cli import main
+from skcapstone.session_briefing import (
+    build_session_briefing,
+    format_session_briefing_text,
+    load_hammertime_briefing,
+)
+
+
+def test_load_hammertime_briefing_respects_disable_env(monkeypatch, tmp_path: Path) -> None:
+    """It returns None when HammerTime briefing is explicitly disabled."""
+    monkeypatch.setenv("SK_INCLUDE_HAMMERTIME_BRIEFING", "0")
+    assert load_hammertime_briefing(root=tmp_path) is None
+
+
+def test_load_hammertime_briefing_parses_json(monkeypatch, tmp_path: Path) -> None:
+    """It parses JSON output from the HammerTime briefing script."""
+    script = tmp_path / "scripts" / "case-briefing.py"
+    script.parent.mkdir(parents=True)
+    script.write_text("#!/usr/bin/env python3\n", encoding="utf-8")
+
+    payload = {"summary": {"queue_size": 2}, "alert_count": 1}
+
+    def fake_run(*args, **kwargs):  # noqa: ANN002, ANN003
+        return subprocess.CompletedProcess(
+            args=args[0],
+            returncode=0,
+            stdout=json.dumps(payload),
+            stderr="",
+        )
+
+    monkeypatch.delenv("SK_INCLUDE_HAMMERTIME_BRIEFING", raising=False)
+    monkeypatch.setattr("skcapstone.session_briefing.subprocess.run", fake_run)
+
+    assert load_hammertime_briefing(root=tmp_path) == payload
+
+
+def test_build_session_briefing_includes_skcapstone_and_hammertime(monkeypatch, tmp_path: Path) -> None:
+    """It builds a combined payload for startup consumers."""
+    ctx = {"agent": {"name": "Aster"}, "memories": []}
+    briefing = {"summary": {"queue_size": 1}, "alert_count": 0}
+
+    monkeypatch.setattr("skcapstone.session_briefing.gather_context", lambda home, memory_limit=10: ctx)
+    monkeypatch.setattr(
+        "skcapstone.session_briefing.load_hammertime_briefing",
+        lambda python_bin=None: briefing,
+    )
+
+    payload = build_session_briefing(tmp_path, memory_limit=3)
+
+    assert payload["agent_home"] == str(tmp_path)
+    assert payload["skcapstone_context"] == ctx
+    assert payload["hammertime_briefing"] == briefing
+    assert "generated_at" in payload
+
+
+def test_format_session_briefing_text_contains_hammertime_section() -> None:
+    """It renders a readable summary including the HammerTime section."""
+    payload = {
+        "generated_at": "2026-04-09T00:00:00+00:00",
+        "agent_home": "/tmp/aster",
+        "skcapstone_context": {
+            "agent": {"name": "Aster", "is_conscious": True, "fingerprint": "abc123"},
+            "pillars": {},
+            "board": {"total": 0},
+            "memories": [],
+            "soul": {"active": None},
+            "mcp": {"available": False},
+            "gathered_at": "2026-04-09T00:00:00+00:00",
+        },
+        "hammertime_briefing": {
+            "alert_count": 1,
+            "summary": {"queue_size": 2},
+            "top_priority": {
+                "incident_id": "INC-001",
+                "problem_slug": "example-problem",
+                "action": "File claim of exemption",
+                "status": "in-progress",
+            },
+            "focus_items": [
+                {
+                    "incident_id": "INC-001",
+                    "action": "Review preferred filing",
+                    "status": "in-progress",
+                }
+            ],
+        },
+    }
+
+    output = format_session_briefing_text(payload)
+
+    assert "# SKCapstone Session Briefing" in output
+    assert "## hammertime briefing" in output
+    assert "INC-001" in output
+    assert "File claim of exemption" in output
+
+
+def test_session_briefing_cli_json(monkeypatch, tmp_path: Path) -> None:
+    """The CLI exposes the combined payload as JSON."""
+    runner = CliRunner()
+    payload = {
+        "generated_at": "2026-04-09T00:00:00+00:00",
+        "agent_home": str(tmp_path),
+        "skcapstone_context": {"agent": {"name": "Aster"}},
+        "hammertime_briefing": {"summary": {"queue_size": 1}, "alert_count": 0},
+    }
+
+    monkeypatch.setattr(
+        "skcapstone.session_briefing.build_session_briefing",
+        lambda home, memory_limit=10: payload,
+    )
+
+    result = runner.invoke(
+        main,
+        ["session", "briefing", "--home", str(tmp_path), "--format", "json"],
+    )
+
+    assert result.exit_code == 0
+    parsed = json.loads(result.output)
+    assert parsed["skcapstone_context"]["agent"]["name"] == "Aster"
+    assert parsed["hammertime_briefing"]["summary"]["queue_size"] == 1

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."""