@smilintux/skcapstone 0.9.0 → 0.12.5

package/tests/test_notifications.py

@@ -7,13 +7,31 @@ from unittest.mock import MagicMock, call, patch
 
 import pytest
 
-from skcapstone.notifications import NotificationManager, notify, get_manager
+from skcapstone.notifications import (
+    NotificationManager,
+    desktop_notifications_enabled,
+    notify,
+    get_manager,
+)
+
+
+@pytest.fixture(autouse=True)
+def _enable_desktop_notifications(monkeypatch):
+    """Re-enable the desktop-notification guard for this module.
+
+    The session-wide conftest fixture disables notifications so test runs
+    don't flood the live desktop.  Every test here mocks ``subprocess.run`` /
+    ``osascript``, so nothing real is dispatched — they just need the guard
+    on to exercise the dispatch logic.  Guard-specific tests override this.
+    """
+    monkeypatch.setenv("SKCAPSTONE_DESKTOP_NOTIFY", "1")
 
 
 # ---------------------------------------------------------------------------
 # Helpers
 # ---------------------------------------------------------------------------
 
+
 def _make_mgr(debounce: float = 0.0) -> NotificationManager:
     """Return a fresh NotificationManager with zero debounce by default."""
     return NotificationManager(debounce_seconds=debounce)
@@ -23,14 +41,17 @@ def _make_mgr(debounce: float = 0.0) -> NotificationManager:
 # notify-send (Linux)
 # ---------------------------------------------------------------------------
 
+
 class TestNotifyLinux:
     """Tests for Linux notify-send path."""
 
     def test_notify_send_called_with_correct_args(self):
         """notify-send is invoked with urgency, title, body."""
         mgr = _make_mgr()
-        with patch("skcapstone.notifications.platform.system", return_value="Linux"), \
-             patch("skcapstone.notifications.subprocess.run") as mock_run:
+        with (
+            patch("skcapstone.notifications.platform.system", return_value="Linux"),
+            patch("skcapstone.notifications.subprocess.run") as mock_run,
+        ):
             mock_run.return_value = MagicMock(returncode=0)
             result = mgr.notify("Hello", "World", urgency="normal")
 
@@ -45,8 +66,10 @@ class TestNotifyLinux:
     def test_notify_send_urgency_low(self):
         """Low urgency maps to notify-send --urgency low."""
         mgr = _make_mgr()
-        with patch("skcapstone.notifications.platform.system", return_value="Linux"), \
-             patch("skcapstone.notifications.subprocess.run") as mock_run:
+        with (
+            patch("skcapstone.notifications.platform.system", return_value="Linux"),
+            patch("skcapstone.notifications.subprocess.run") as mock_run,
+        ):
             mock_run.return_value = MagicMock(returncode=0)
             mgr.notify("T", "B", urgency="low")
 
@@ -57,8 +80,10 @@ class TestNotifyLinux:
     def test_notify_send_urgency_critical(self):
         """Critical urgency maps to notify-send --urgency critical."""
         mgr = _make_mgr()
-        with patch("skcapstone.notifications.platform.system", return_value="Linux"), \
-             patch("skcapstone.notifications.subprocess.run") as mock_run:
+        with (
+            patch("skcapstone.notifications.platform.system", return_value="Linux"),
+            patch("skcapstone.notifications.subprocess.run") as mock_run,
+        ):
             mock_run.return_value = MagicMock(returncode=0)
             mgr.notify("T", "B", urgency="critical")
 
@@ -68,8 +93,10 @@ class TestNotifyLinux:
     def test_notify_send_not_found_returns_false(self):
         """Returns False gracefully when notify-send binary is missing."""
         mgr = _make_mgr()
-        with patch("skcapstone.notifications.platform.system", return_value="Linux"), \
-             patch("skcapstone.notifications.subprocess.run", side_effect=FileNotFoundError):
+        with (
+            patch("skcapstone.notifications.platform.system", return_value="Linux"),
+            patch("skcapstone.notifications.subprocess.run", side_effect=FileNotFoundError),
+        ):
             result = mgr.notify("T", "B")
 
         assert result is False
@@ -77,12 +104,15 @@ class TestNotifyLinux:
     def test_notify_send_nonzero_exit_returns_false(self):
         """Returns False when notify-send exits non-zero."""
         import subprocess
+
         mgr = _make_mgr()
-        with patch("skcapstone.notifications.platform.system", return_value="Linux"), \
-             patch(
-                 "skcapstone.notifications.subprocess.run",
-                 side_effect=subprocess.CalledProcessError(1, "notify-send", stderr=b"err"),
-             ):
+        with (
+            patch("skcapstone.notifications.platform.system", return_value="Linux"),
+            patch(
+                "skcapstone.notifications.subprocess.run",
+                side_effect=subprocess.CalledProcessError(1, "notify-send", stderr=b"err"),
+            ),
+        ):
             result = mgr.notify("T", "B")
 
         assert result is False
@@ -90,12 +120,15 @@ class TestNotifyLinux:
     def test_notify_send_timeout_returns_false(self):
         """Returns False when notify-send times out."""
         import subprocess
+
         mgr = _make_mgr()
-        with patch("skcapstone.notifications.platform.system", return_value="Linux"), \
-             patch(
-                 "skcapstone.notifications.subprocess.run",
-                 side_effect=subprocess.TimeoutExpired("notify-send", 5),
-             ):
+        with (
+            patch("skcapstone.notifications.platform.system", return_value="Linux"),
+            patch(
+                "skcapstone.notifications.subprocess.run",
+                side_effect=subprocess.TimeoutExpired("notify-send", 5),
+            ),
+        ):
             result = mgr.notify("T", "B")
 
         assert result is False
@@ -105,6 +138,7 @@ class TestNotifyLinux:
 # osascript (macOS)
 # ---------------------------------------------------------------------------
 
+
 class TestNotifyMacOS:
     """Tests for macOS osascript path."""
 
@@ -159,6 +193,7 @@ class TestNotifyMacOS:
 # Unsupported platform
 # ---------------------------------------------------------------------------
 
+
 class TestNotifyUnsupportedPlatform:
     """Windows and unknown platforms return False without error."""
 
@@ -185,14 +220,17 @@ class TestNotifyUnsupportedPlatform:
 # Debounce logic
 # ---------------------------------------------------------------------------
 
+
 class TestDebounce:
     """Debounce prevents more than one notification per interval."""
 
     def test_second_call_within_window_is_debounced(self):
         """A second notify() within the debounce window returns False."""
         mgr = NotificationManager(debounce_seconds=5.0)
-        with patch("skcapstone.notifications.platform.system", return_value="Linux"), \
-             patch("skcapstone.notifications.subprocess.run") as mock_run:
+        with (
+            patch("skcapstone.notifications.platform.system", return_value="Linux"),
+            patch("skcapstone.notifications.subprocess.run") as mock_run,
+        ):
             mock_run.return_value = MagicMock(returncode=0)
             first = mgr.notify("T", "B")
             second = mgr.notify("T", "B")
@@ -204,8 +242,10 @@ class TestDebounce:
     def test_call_after_window_is_allowed(self):
         """A notify() after the debounce window passes through."""
         mgr = NotificationManager(debounce_seconds=0.05)
-        with patch("skcapstone.notifications.platform.system", return_value="Linux"), \
-             patch("skcapstone.notifications.subprocess.run") as mock_run:
+        with (
+            patch("skcapstone.notifications.platform.system", return_value="Linux"),
+            patch("skcapstone.notifications.subprocess.run") as mock_run,
+        ):
             mock_run.return_value = MagicMock(returncode=0)
             mgr.notify("T", "B")
             time.sleep(0.1)
@@ -217,13 +257,17 @@ class TestDebounce:
     def test_debounce_does_not_update_timestamp_on_failed_dispatch(self):
         """Failed dispatch (notify-send missing) does not reset the debounce clock."""
         mgr = NotificationManager(debounce_seconds=5.0)
-        with patch("skcapstone.notifications.platform.system", return_value="Linux"), \
-             patch("skcapstone.notifications.subprocess.run", side_effect=FileNotFoundError):
+        with (
+            patch("skcapstone.notifications.platform.system", return_value="Linux"),
+            patch("skcapstone.notifications.subprocess.run", side_effect=FileNotFoundError),
+        ):
             mgr.notify("T", "B")  # fails → _last_sent stays 0
 
         # Now try again immediately — should not be debounced
-        with patch("skcapstone.notifications.platform.system", return_value="Linux"), \
-             patch("skcapstone.notifications.subprocess.run") as mock_run2:
+        with (
+            patch("skcapstone.notifications.platform.system", return_value="Linux"),
+            patch("skcapstone.notifications.subprocess.run") as mock_run2,
+        ):
             mock_run2.return_value = MagicMock(returncode=0)
             result = mgr.notify("T", "B")
 
@@ -232,8 +276,10 @@ class TestDebounce:
     def test_zero_debounce_allows_rapid_calls(self):
         """debounce_seconds=0 means every call is dispatched."""
         mgr = NotificationManager(debounce_seconds=0)
-        with patch("skcapstone.notifications.platform.system", return_value="Linux"), \
-             patch("skcapstone.notifications.subprocess.run") as mock_run:
+        with (
+            patch("skcapstone.notifications.platform.system", return_value="Linux"),
+            patch("skcapstone.notifications.subprocess.run") as mock_run,
+        ):
             mock_run.return_value = MagicMock(returncode=0)
             for _ in range(3):
                 mgr.notify("T", "B")
@@ -245,17 +291,21 @@ class TestDebounce:
 # Module-level helpers
 # ---------------------------------------------------------------------------
 
+
 class TestModuleLevelHelpers:
     """notify() convenience function and get_manager() singleton."""
 
     def test_notify_convenience_function(self):
         """Module-level notify() delegates to the singleton manager."""
-        with patch("skcapstone.notifications.platform.system", return_value="Linux"), \
-             patch("skcapstone.notifications.subprocess.run") as mock_run, \
-             patch("skcapstone.notifications._manager", None):
+        with (
+            patch("skcapstone.notifications.platform.system", return_value="Linux"),
+            patch("skcapstone.notifications.subprocess.run") as mock_run,
+            patch("skcapstone.notifications._manager", None),
+        ):
             mock_run.return_value = MagicMock(returncode=0)
             # Reset singleton so debounce is fresh
             import skcapstone.notifications as _notif_mod
+
             _notif_mod._manager = None
             result = notify("Hello", "World")
 
@@ -264,7 +314,47 @@ class TestModuleLevelHelpers:
     def test_get_manager_returns_singleton(self):
         """get_manager() returns the same instance on repeated calls."""
         import skcapstone.notifications as _notif_mod
+
         _notif_mod._manager = None  # reset
         m1 = get_manager()
         m2 = get_manager()
         assert m1 is m2
+
+
+# ---------------------------------------------------------------------------
+# Desktop-notification guard (SKCAPSTONE_DESKTOP_NOTIFY)
+# ---------------------------------------------------------------------------
+
+
+class TestDesktopNotificationGuard:
+    """SKCAPSTONE_DESKTOP_NOTIFY suppresses every dispatch path."""
+
+    def test_enabled_by_default(self, monkeypatch):
+        """Unset env var means notifications are enabled."""
+        monkeypatch.delenv("SKCAPSTONE_DESKTOP_NOTIFY", raising=False)
+        assert desktop_notifications_enabled() is True
+
+    @pytest.mark.parametrize("value", ["0", "false", "no", "off", "silent", "null", "none"])
+    def test_disabled_values(self, monkeypatch, value):
+        """Recognised falsy values disable notifications (case-insensitive)."""
+        monkeypatch.setenv("SKCAPSTONE_DESKTOP_NOTIFY", value.upper())
+        assert desktop_notifications_enabled() is False
+
+    @pytest.mark.parametrize("value", ["1", "true", "yes", "on"])
+    def test_enabled_values(self, monkeypatch, value):
+        """Other values keep notifications enabled."""
+        monkeypatch.setenv("SKCAPSTONE_DESKTOP_NOTIFY", value)
+        assert desktop_notifications_enabled() is True
+
+    def test_notify_short_circuits_when_disabled(self, monkeypatch):
+        """notify() returns False and never shells out when disabled."""
+        monkeypatch.setenv("SKCAPSTONE_DESKTOP_NOTIFY", "0")
+        mgr = _make_mgr()
+        with (
+            patch("skcapstone.notifications.platform.system", return_value="Linux"),
+            patch("skcapstone.notifications.subprocess.run") as mock_run,
+        ):
+            result = mgr.notify("Hello", "World")
+
+        assert result is False
+        mock_run.assert_not_called()

package/tests/test_onboard.py

@@ -7,7 +7,7 @@ Covers:
 - _step_systemd_service(): Linux-only, click.confirm gating
 - _step_doctor_check(): doctor diagnostics output
 - _step_test_consciousness(): consciousness loop test with click.confirm gating
-- TOTAL_STEPS constant updated to 13
+- TOTAL_STEPS constant updated to 16
 """
 
 from __future__ import annotations
@@ -42,13 +42,13 @@ def tmp_home(tmp_path: Path) -> Path:
 
 
 class TestTotalSteps:
-    """Ensure TOTAL_STEPS was updated to 13."""
+    """Ensure TOTAL_STEPS reflects the current 16-step wizard."""
 
-    def test_total_steps_is_13(self) -> None:
-        """Wizard now has 13 numbered steps."""
+    def test_total_steps_is_16(self) -> None:
+        """Wizard now has 16 numbered steps."""
         from skcapstone.onboard import TOTAL_STEPS
 
-        assert TOTAL_STEPS == 13
+        assert TOTAL_STEPS == 16
 
 
 # ---------------------------------------------------------------------------
@@ -152,71 +152,77 @@ class TestStepOllamaModels:
     """Tests for _step_ollama_models()."""
 
     def test_skips_when_ollama_not_available(self) -> None:
-        """Returns False immediately when prereqs['ollama'] is False."""
+        """Returns default structured result when prereqs['ollama'] is False."""
         from skcapstone.onboard import _step_ollama_models
 
         result = _step_ollama_models({"ollama": False})
 
-        assert result is False
+        assert result == {
+            "ok": False,
+            "model": "llama3.2",
+            "host": "http://localhost:11434",
+        }
 
     def test_skips_when_user_declines(self) -> None:
-        """Returns False when user does not confirm the pull."""
+        """Returns a non-ok result when user does not confirm the pull."""
         from skcapstone.onboard import _step_ollama_models
 
-        def fake_which(t: str) -> str | None:
-            return "/usr/local/bin/ollama" if t == "ollama" else None
-
-        with patch("shutil.which", side_effect=fake_which), \
-             patch("subprocess.run", return_value=MagicMock(returncode=0, stdout="")), \
+        with patch("subprocess.run", return_value=MagicMock(returncode=0, stdout="")), \
+             patch("click.prompt", side_effect=["http://localhost:11434", "llama3.2"]), \
              patch("click.confirm", return_value=False):
             result = _step_ollama_models({"ollama": True})
 
-        assert result is False
+        assert result == {
+            "ok": False,
+            "model": "llama3.2",
+            "host": "http://localhost:11434",
+        }
 
     def test_returns_true_when_model_already_present(self) -> None:
-        """Returns True without pulling if model already in 'ollama list'."""
+        """Returns ok=True without pulling if model already in 'ollama list'."""
         from skcapstone.onboard import _step_ollama_models
 
-        with patch("subprocess.run", return_value=MagicMock(returncode=0, stdout="llama3.2  2.0 GB")):
+        with patch("subprocess.run", return_value=MagicMock(returncode=0, stdout="NAME ID SIZE\nllama3.2 abc123 2.0 GB")), \
+             patch("click.prompt", side_effect=["http://localhost:11434", "llama3.2"]):
             result = _step_ollama_models({"ollama": True})
 
-        assert result is True
+        assert result["ok"] is True
+        assert result["model"] == "llama3.2"
 
     def test_returns_true_on_successful_pull(self) -> None:
-        """Returns True after a successful ollama pull."""
+        """Returns ok=True after a successful ollama pull."""
         from skcapstone.onboard import _step_ollama_models
 
-        call_count = {"n": 0}
-
         def fake_run(cmd, **kwargs):
-            call_count["n"] += 1
             if "list" in cmd:
-                return MagicMock(returncode=0, stdout="")  # model not present
-            return MagicMock(returncode=0)  # pull succeeds
+                return MagicMock(returncode=0, stdout="")
+            return MagicMock(returncode=0)
 
         with patch("subprocess.run", side_effect=fake_run), \
+             patch("click.prompt", side_effect=["http://localhost:11434", "llama3.2"]), \
              patch("click.confirm", return_value=True):
             result = _step_ollama_models({"ollama": True})
 
-        assert result is True
+        assert result["ok"] is True
 
     def test_returns_false_on_pull_failure(self) -> None:
-        """Returns False when ollama pull exits non-zero."""
+        """Returns ok=False when ollama pull exits non-zero."""
         from skcapstone.onboard import _step_ollama_models
 
         def fake_run(cmd, **kwargs):
             if "list" in cmd:
                 return MagicMock(returncode=0, stdout="")
-            return MagicMock(returncode=1)  # pull fails
+            return MagicMock(returncode=1)
 
         with patch("subprocess.run", side_effect=fake_run), \
+             patch("click.prompt", side_effect=["http://localhost:11434", "llama3.2"]), \
              patch("click.confirm", return_value=True):
             result = _step_ollama_models({"ollama": True})
 
-        assert result is False
+        assert result["ok"] is False
 
     def test_returns_false_on_timeout(self) -> None:
-        """Returns False when ollama pull times out."""
+        """Returns ok=False when ollama pull times out."""
         from skcapstone.onboard import _step_ollama_models
 
         def fake_run(cmd, **kwargs):
@@ -225,10 +231,11 @@ class TestStepOllamaModels:
             raise subprocess.TimeoutExpired(cmd, 600)
 
         with patch("subprocess.run", side_effect=fake_run), \
+             patch("click.prompt", side_effect=["http://localhost:11434", "llama3.2"]), \
              patch("click.confirm", return_value=True):
             result = _step_ollama_models({"ollama": True})
 
-        assert result is False
+        assert result["ok"] is False
 
 
 # ---------------------------------------------------------------------------
@@ -306,59 +313,55 @@ class TestStepConfigFiles:
 
 
 class TestStepSystemdService:
-    """Tests for _step_systemd_service()."""
+    """Tests for Linux systemd and platform dispatch."""
 
     def test_returns_false_on_non_linux(self) -> None:
-        """Returns False immediately on non-Linux platforms."""
-        from skcapstone.onboard import _step_systemd_service
+        """Returns False immediately on unsupported non-Linux/macOS platforms."""
+        from skcapstone.onboard import _step_autostart_service
 
-        with patch("platform.system", return_value="Darwin"):
-            result = _step_systemd_service()
+        with patch("platform.system", return_value="Windows"):
+            result = _step_autostart_service()
 
         assert result is False
 
     def test_returns_false_when_user_declines(self) -> None:
         """Returns False when user does not confirm the install."""
-        from skcapstone.onboard import _step_systemd_service
+        from skcapstone.onboard import _step_systemd_service_linux
 
-        with patch("platform.system", return_value="Linux"), \
-             patch("click.confirm", return_value=False):
-            result = _step_systemd_service()
+        with patch("click.confirm", return_value=False):
+            result = _step_systemd_service_linux()
 
         assert result is False
 
     def test_returns_false_when_systemd_unavailable(self) -> None:
         """Returns False when systemd user session is not running."""
-        from skcapstone.onboard import _step_systemd_service
+        from skcapstone.onboard import _step_systemd_service_linux
 
-        with patch("platform.system", return_value="Linux"), \
-             patch("click.confirm", return_value=True), \
+        with patch("click.confirm", return_value=True), \
              patch("skcapstone.systemd.systemd_available", return_value=False):
-            result = _step_systemd_service()
+            result = _step_systemd_service_linux()
 
         assert result is False
 
     def test_returns_true_on_successful_install(self) -> None:
         """Returns True when systemd install succeeds."""
-        from skcapstone.onboard import _step_systemd_service
+        from skcapstone.onboard import _step_systemd_service_linux
 
-        with patch("platform.system", return_value="Linux"), \
-             patch("click.confirm", return_value=True), \
+        with patch("click.confirm", return_value=True), \
              patch("skcapstone.systemd.systemd_available", return_value=True), \
              patch("skcapstone.systemd.install_service", return_value={"installed": True, "enabled": True}):
-            result = _step_systemd_service()
+            result = _step_systemd_service_linux()
 
         assert result is True
 
     def test_returns_false_on_install_failure(self) -> None:
         """Returns False when install_service reports not installed."""
-        from skcapstone.onboard import _step_systemd_service
+        from skcapstone.onboard import _step_systemd_service_linux
 
-        with patch("platform.system", return_value="Linux"), \
-             patch("click.confirm", return_value=True), \
+        with patch("click.confirm", return_value=True), \
              patch("skcapstone.systemd.systemd_available", return_value=True), \
              patch("skcapstone.systemd.install_service", return_value={"installed": False}):
-            result = _step_systemd_service()
+            result = _step_systemd_service_linux()
 
         assert result is False
 
@@ -419,54 +422,39 @@ class TestStepTestConsciousness:
         assert result is False
 
     def test_returns_true_when_loop_responds(self, tmp_home: Path) -> None:
-        """Returns True when LLMBridge.generate returns a non-empty response."""
+        """Returns True when the configured Ollama callback yields a response."""
         from skcapstone.onboard import _step_test_consciousness
 
-        mock_bridge = MagicMock()
-        mock_bridge.generate.return_value = "Hello, I am running fine."
-        mock_builder = MagicMock()
-        mock_builder.build.return_value = "system prompt"
-        mock_config = MagicMock()
-        mock_config.max_context_tokens = 8000
+        mock_config = MagicMock(ollama_model="llama3.2", ollama_host="http://localhost:11434")
+        mock_callback = MagicMock(return_value="Hello, I am running fine.")
 
         with patch("click.confirm", return_value=True), \
              patch("skcapstone.consciousness_config.load_consciousness_config", return_value=mock_config), \
-             patch("skcapstone.consciousness_loop.LLMBridge", return_value=mock_bridge), \
-             patch("skcapstone.consciousness_loop.SystemPromptBuilder", return_value=mock_builder), \
-             patch("skcapstone.consciousness_loop._classify_message",
-                   return_value=MagicMock(tags=[], estimated_tokens=10)):
+             patch("skseed.llm.ollama_callback", return_value=mock_callback):
             result = _step_test_consciousness(tmp_home)
 
         assert result is True
 
     def test_returns_false_when_loop_returns_empty(self, tmp_home: Path) -> None:
-        """Returns False when LLMBridge.generate returns an empty string."""
+        """Returns False when the configured Ollama callback yields an empty string."""
         from skcapstone.onboard import _step_test_consciousness
 
-        mock_bridge = MagicMock()
-        mock_bridge.generate.return_value = ""
-        mock_builder = MagicMock()
-        mock_builder.build.return_value = "system prompt"
-        mock_config = MagicMock()
-        mock_config.max_context_tokens = 8000
+        mock_config = MagicMock(ollama_model="llama3.2", ollama_host="http://localhost:11434")
+        mock_callback = MagicMock(return_value="")
 
         with patch("click.confirm", return_value=True), \
              patch("skcapstone.consciousness_config.load_consciousness_config", return_value=mock_config), \
-             patch("skcapstone.consciousness_loop.LLMBridge", return_value=mock_bridge), \
-             patch("skcapstone.consciousness_loop.SystemPromptBuilder", return_value=mock_builder), \
-             patch("skcapstone.consciousness_loop._classify_message",
-                   return_value=MagicMock(tags=[], estimated_tokens=10)):
+             patch("skseed.llm.ollama_callback", return_value=mock_callback):
             result = _step_test_consciousness(tmp_home)
 
         assert result is False
 
     def test_returns_false_on_exception(self, tmp_home: Path) -> None:
-        """Returns False when consciousness config raises an exception."""
+        """Returns False when the Ollama callback raises an exception."""
         from skcapstone.onboard import _step_test_consciousness
 
         with patch("click.confirm", return_value=True), \
-             patch("skcapstone.consciousness_config.load_consciousness_config",
-                   side_effect=RuntimeError("no config")):
+             patch("skseed.llm.ollama_callback", side_effect=RuntimeError("backend down")):
             result = _step_test_consciousness(tmp_home)
 
         assert result is False

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"