@smilintux/skcapstone 0.10.0 → 0.12.5

package/tests/test_e2e_automated.py

@@ -101,7 +101,7 @@ def _poll_for_response(
             if skc.stat().st_mtime > ref_mtime:
                 return True
 
-        # Check conversations file (passthrough / no-SKComm fallback)
+        # Check conversations file (passthrough / no-SKComms fallback)
         if conv_file.exists() and conv_file.stat().st_mtime > ref_mtime:
             return True
 
@@ -217,11 +217,14 @@ class TestDaemonStartup:
             data = json.loads(resp.read())
 
         status = str(data.get("status", "")).lower()
-        # Accept various status strings that indicate the loop is running
+        # Accept both the legacy status/conscious contract and the current
+        # enabled-based daemon payload.
         active_statuses = {"active", "ok", "running", "started", "conscious"}
-        assert status in active_statuses or data.get("conscious") is True, (
-            f"Expected active status, got: {data}"
-        )
+        assert (
+            data.get("enabled") is True
+            or status in active_statuses
+            or data.get("conscious") is True
+        ), f"Expected active status, got: {data}"
 
 
 class TestMessageRoundTrip:

package/tests/test_fuse_mount.py

@@ -34,7 +34,7 @@ from skcapstone.fuse_mount import (
     _read_coordination_task,
     _read_document,
     _read_inbox_file,
-    _send_via_skcomm,
+    _send_via_skcomms,
 )
 
 
@@ -426,10 +426,10 @@ class TestFileHelpers:
             fp = _build_fingerprint_txt(agent_home)
         assert fp == b"AABBCCDD\n"
 
-    def test_send_via_skcomm_fallback_to_outbox(self, agent_home: Path) -> None:
+    def test_send_via_skcomms_fallback_to_outbox(self, agent_home: Path) -> None:
         """When CLI is unavailable, message is queued as JSON envelope in outbox."""
         with patch("skcapstone.fuse_mount.subprocess.run", side_effect=FileNotFoundError):
-            result = _send_via_skcomm(agent_home, "jarvis", "Hello Jarvis")
+            result = _send_via_skcomms(agent_home, "jarvis", "Hello Jarvis")
         assert result is True
         outbox = agent_home / "comms" / "outbox"
         files = list(outbox.glob("jarvis_*.json"))
@@ -658,12 +658,12 @@ class TestSovereignFS:
             sovereign_fs.write("/memories/short/x.md", b"data", offset=0, fh=0)
         assert exc_info.value.errno == errno.EACCES
 
-    def test_flush_sends_via_skcomm(
+    def test_flush_sends_via_skcomms(
         self, sovereign_fs: SovereignFS
     ) -> None:
-        """Flushing an outbox file invokes _send_via_skcomm with correct args."""
+        """Flushing an outbox file invokes _send_via_skcomms with correct args."""
         sovereign_fs._outbox_buffers["/outbox/jarvis.msg"] = b"Test message"
-        with patch("skcapstone.fuse_mount._send_via_skcomm", return_value=True) as mock_send:
+        with patch("skcapstone.fuse_mount._send_via_skcomms", return_value=True) as mock_send:
             sovereign_fs.flush("/outbox/jarvis.msg", fh=0)
         mock_send.assert_called_once_with(
             sovereign_fs._home, "jarvis", "Test message"
@@ -674,14 +674,14 @@ class TestSovereignFS:
     def test_flush_strips_msg_suffix(self, sovereign_fs: SovereignFS) -> None:
         """Flush extracts the recipient by stripping the .msg suffix."""
         sovereign_fs._outbox_buffers["/outbox/lumina.msg"] = b"Hi"
-        with patch("skcapstone.fuse_mount._send_via_skcomm", return_value=True) as mock_send:
+        with patch("skcapstone.fuse_mount._send_via_skcomms", return_value=True) as mock_send:
             sovereign_fs.flush("/outbox/lumina.msg", fh=0)
         assert mock_send.call_args[0][1] == "lumina"
 
     def test_flush_empty_buffer_no_send(self, sovereign_fs: SovereignFS) -> None:
-        """Flushing an empty buffer does not call _send_via_skcomm."""
+        """Flushing an empty buffer does not call _send_via_skcomms."""
         sovereign_fs._outbox_buffers["/outbox/ava.msg"] = b""
-        with patch("skcapstone.fuse_mount._send_via_skcomm") as mock_send:
+        with patch("skcapstone.fuse_mount._send_via_skcomms") as mock_send:
             sovereign_fs.flush("/outbox/ava.msg", fh=0)
         mock_send.assert_not_called()
 
@@ -723,7 +723,7 @@ class TestSovereignFS:
     def test_release_flushes_outbox(self, sovereign_fs: SovereignFS) -> None:
         """Release calls flush, which sends the outbox buffer."""
         sovereign_fs._outbox_buffers["/outbox/ava.msg"] = b"Goodbye"
-        with patch("skcapstone.fuse_mount._send_via_skcomm", return_value=True) as mock_send:
+        with patch("skcapstone.fuse_mount._send_via_skcomms", return_value=True) as mock_send:
             sovereign_fs.release("/outbox/ava.msg", fh=0)
         mock_send.assert_called_once()
 

package/tests/test_gtd_brief.py

@@ -0,0 +1,46 @@
+"""`skcapstone gtd status --brief` — one-line summary for the SessionStart hook."""
+import json
+from pathlib import Path
+
+import click
+from click.testing import CliRunner
+
+import skcapstone.mcp_tools._helpers as _helpers
+from skcapstone.cli.gtd import register_gtd_commands
+
+
+def _app(tmp_path: Path, monkeypatch) -> click.Group:
+    monkeypatch.setattr(_helpers, "SHARED_ROOT", str(tmp_path))
+    gtd_dir = tmp_path / "coordination" / "gtd"
+    gtd_dir.mkdir(parents=True)
+    (gtd_dir / "inbox.json").write_text(
+        json.dumps([{"id": "a", "text": "one"}, {"id": "b", "text": "two"}]),
+        encoding="utf-8",
+    )
+    (gtd_dir / "next-actions.json").write_text(
+        json.dumps([{"id": "c", "text": "do"}]), encoding="utf-8"
+    )
+
+    @click.group()
+    def main() -> None:
+        pass
+
+    register_gtd_commands(main)
+    return main
+
+
+def test_brief_is_single_line_with_counts(tmp_path: Path, monkeypatch):
+    res = CliRunner().invoke(_app(tmp_path, monkeypatch), ["gtd", "status", "--brief"])
+    assert res.exit_code == 0
+    out = res.output.strip()
+    assert out.count("\n") == 0  # exactly one line
+    assert out.startswith("GTD:")
+    assert "2 inbox" in out and "1 next" in out
+
+
+def test_brief_differs_from_full(tmp_path: Path, monkeypatch):
+    app = _app(tmp_path, monkeypatch)
+    brief = CliRunner().invoke(app, ["gtd", "status", "--brief"]).output
+    full = CliRunner().invoke(app, ["gtd", "status"]).output
+    assert len(brief.strip().splitlines()) == 1
+    assert len(full.strip().splitlines()) > 1  # full is the rich multi-line panel

package/tests/test_gtd_malformed_tolerance.py

@@ -0,0 +1,31 @@
+"""GTD tools tolerate malformed (title/body, no 'text') items without crashing."""
+import asyncio
+import json
+from pathlib import Path
+
+import skcapstone.mcp_tools._helpers as _helpers
+from skcapstone.mcp_tools.gtd_tools import _handle_gtd_done
+
+
+def test_gtd_done_tolerates_item_without_text(tmp_path: Path, monkeypatch):
+    monkeypatch.setattr(_helpers, "SHARED_ROOT", str(tmp_path))
+    gtd = tmp_path / "coordination" / "gtd"
+    gtd.mkdir(parents=True)
+    # A malformed legacy item: title/body schema, no 'text' (what the dead
+    # reflection/improvement crons wrote and what used to KeyError gtd_done).
+    (gtd / "inbox.json").write_text(
+        json.dumps(
+            [{"id": "m1", "title": "Daily Reflection", "body": "noise",
+              "source": "daily-reflection-cron"}]
+        ),
+        encoding="utf-8",
+    )
+
+    # Must not raise (previously raised KeyError: 'text').
+    result = asyncio.run(_handle_gtd_done({"item_id": "m1"}))
+    assert result  # got a response
+
+    inbox = json.loads((gtd / "inbox.json").read_text())
+    assert not any(i.get("id") == "m1" for i in inbox)
+    archive = json.loads((gtd / "archive.json").read_text())
+    assert any(a.get("id") == "m1" for a in archive)

package/tests/test_housekeeping.py

@@ -14,8 +14,8 @@ from skcapstone.housekeeping import (
 
 
 @pytest.fixture
-def skcomm_home(tmp_path):
-    """Create a mock ~/.skcomm directory with test ACK files."""
+def skcomms_home(tmp_path):
+    """Create a mock ~/.skcomms directory with test ACK files."""
     acks_dir = tmp_path / "acks"
     acks_dir.mkdir()
     return tmp_path
@@ -39,13 +39,13 @@ class TestPruneAcks:
         """Returns 0 when acks directory doesn't exist."""
         assert prune_acks(tmp_path) == 0
 
-    def test_empty_acks_dir(self, skcomm_home):
+    def test_empty_acks_dir(self, skcomms_home):
         """Returns 0 when acks directory is empty."""
-        assert prune_acks(skcomm_home) == 0
+        assert prune_acks(skcomms_home) == 0
 
-    def test_deletes_old_acks(self, skcomm_home):
+    def test_deletes_old_acks(self, skcomms_home):
         """Deletes ACK files older than max_age_hours."""
-        acks_dir = skcomm_home / "acks"
+        acks_dir = skcomms_home / "acks"
         # Create 5 old files (mtime set to 48h ago)
         old_time = time.time() - (48 * 3600)
         for i in range(5):
@@ -59,22 +59,22 @@ class TestPruneAcks:
             f = acks_dir / f"fresh-{i}.json"
             f.write_text("{}")
 
-        deleted = prune_acks(skcomm_home, max_age_hours=24)
+        deleted = prune_acks(skcomms_home, max_age_hours=24)
         assert deleted == 5
         remaining = list(acks_dir.iterdir())
         assert len(remaining) == 3
 
-    def test_respects_max_age(self, skcomm_home):
+    def test_respects_max_age(self, skcomms_home):
         """Only deletes files older than the specified max_age."""
-        acks_dir = skcomm_home / "acks"
+        acks_dir = skcomms_home / "acks"
         # File 1h old
         f = acks_dir / "recent.json"
         f.write_text("{}")
         import os
         os.utime(f, (time.time() - 3600, time.time() - 3600))
 
-        assert prune_acks(skcomm_home, max_age_hours=2) == 0
-        assert prune_acks(skcomm_home, max_age_hours=0) == 1
+        assert prune_acks(skcomms_home, max_age_hours=2) == 0
+        assert prune_acks(skcomms_home, max_age_hours=0) == 1
 
 
 class TestPruneCommsOutbox:
@@ -155,7 +155,7 @@ class TestRunHousekeeping:
     def test_dry_run(self, tmp_path):
         """Dry run reports counts without deleting."""
         # Set up dirs
-        acks_dir = tmp_path / "skcomm" / "acks"
+        acks_dir = tmp_path / "skcomms" / "acks"
         acks_dir.mkdir(parents=True)
         for i in range(3):
             f = acks_dir / f"old-{i}.json"
@@ -165,7 +165,7 @@ class TestRunHousekeeping:
 
         results = run_housekeeping(
             skcapstone_home=tmp_path / "skcapstone",
-            skcomm_home=tmp_path / "skcomm",
+            skcomms_home=tmp_path / "skcomms",
             dry_run=True,
         )
 
@@ -176,7 +176,7 @@ class TestRunHousekeeping:
 
     def test_full_run(self, tmp_path):
         """Full run deletes files and reports summary."""
-        acks_dir = tmp_path / "skcomm" / "acks"
+        acks_dir = tmp_path / "skcomms" / "acks"
         acks_dir.mkdir(parents=True)
         for i in range(2):
             f = acks_dir / f"old-{i}.json"
@@ -186,7 +186,7 @@ class TestRunHousekeeping:
 
         results = run_housekeeping(
             skcapstone_home=tmp_path / "skcapstone",
-            skcomm_home=tmp_path / "skcomm",
+            skcomms_home=tmp_path / "skcomms",
             dry_run=False,
         )
 

package/tests/test_identity_migrate.py

@@ -0,0 +1,251 @@
+"""Tests for ``skcapstone identity migrate`` (skcomms T2 migration walker).
+
+The walker backfills realm/operator/fqid/pgp_fingerprint into every
+provisioned agent's identity.json. These tests use a tmp ``~/.skcapstone`` home
+with fixture agents + cluster.json — they NEVER touch the real home. The
+canonical resolver (``capauth.resolve_agent_identity``) is patched so fqid and
+fingerprint are deterministic and no real profile/cluster is read.
+
+Covers:
+- bare identity.json gets realm/operator/fqid/pgp_fingerprint added
+- already-complete identity is unchanged (idempotent)
+- dry-run (the default) writes nothing
+- template / non-capauth agents are skipped
+- missing cluster.json is handled gracefully
+- CLI integration (default is dry-run; --apply writes)
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import patch
+
+import pytest
+from click.testing import CliRunner
+
+from skcapstone.cli.identity_cmd import migrate_identities, register_identity_commands
+
+# Patch target: the name as imported inside identity_cmd's _plan_agent.
+_RESOLVER = "capauth.resolve_agent_identity"
+
+
+def _fake_ident(agent: str, *, fqid="{a}@chef.skworld", fingerprint="A" * 40):
+    """Build a fake AgentIdentity-like object for a given agent."""
+    return SimpleNamespace(
+        agent=agent,
+        capauth_uri=f"capauth:{agent}@skworld.io",
+        fqid=fqid.format(a=agent) if fqid else None,
+        fingerprint=fingerprint,
+    )
+
+
+def _mk_agent(home, name, *, capauth=True, identity_payload=None):
+    """Create an agent dir under home/agents with optional capauth + identity."""
+    adir = home / "agents" / name
+    (adir / "identity").mkdir(parents=True, exist_ok=True)
+    if capauth:
+        (adir / "capauth").mkdir(parents=True, exist_ok=True)
+    if identity_payload is not None:
+        (adir / "identity" / "identity.json").write_text(json.dumps(identity_payload))
+    return adir
+
+
+@pytest.fixture
+def home_with_cluster(tmp_path):
+    """A tmp shared root with cluster.json + one bare-identity provisioned agent."""
+    home = tmp_path / ".skcapstone"
+    home.mkdir(parents=True)
+    (home / "cluster.json").write_text(json.dumps({
+        "realm": "skworld", "operator": "chef",
+    }))
+    _mk_agent(home, "lumina", identity_payload={
+        "name": "Lumina", "capauth_managed": True,
+        "capauth_uri": "capauth:lumina@skworld.io",
+    })
+    return home
+
+
+# ---------------------------------------------------------------------------
+# core walker: migrate_identities
+# ---------------------------------------------------------------------------
+
+
+class TestMigrateWalker:
+    """migrate_identities core behaviour."""
+
+    def test_bare_identity_gets_all_fields(self, home_with_cluster):
+        """A bare identity.json gains realm/operator/fqid/pgp_fingerprint."""
+        with patch(_RESOLVER, side_effect=lambda a: _fake_ident(a)):
+            plan = migrate_identities(home_with_cluster, apply=True)
+
+        ap = plan.agents[0]
+        assert ap.agent == "lumina"
+        assert ap.applied is True
+        data = json.loads(ap.path.read_text())
+        assert data["realm"] == "skworld"
+        assert data["operator"] == "chef"
+        assert data["fqid"] == "lumina@chef.skworld"
+        assert data["pgp_fingerprint"] == "A" * 40
+        # Unrelated fields preserved (merge, not clobber).
+        assert data["name"] == "Lumina"
+        assert data["capauth_uri"] == "capauth:lumina@skworld.io"
+
+    def test_idempotent_already_complete(self, tmp_path):
+        """A complete identity is reported unchanged and not rewritten."""
+        home = tmp_path / ".skcapstone"
+        home.mkdir(parents=True)
+        (home / "cluster.json").write_text(json.dumps({
+            "realm": "skworld", "operator": "chef",
+        }))
+        payload = {
+            "name": "Opus", "capauth_managed": True,
+            "realm": "skworld", "operator": "chef",
+            "fqid": "opus@chef.skworld", "pgp_fingerprint": "B" * 40,
+        }
+        adir = _mk_agent(home, "opus", identity_payload=payload)
+        ident_path = adir / "identity" / "identity.json"
+        mtime_before = ident_path.stat().st_mtime
+
+        with patch(_RESOLVER, side_effect=lambda a: _fake_ident(
+            a, fqid="opus@chef.skworld", fingerprint="B" * 40
+        )):
+            plan = migrate_identities(home, apply=True)
+
+        ap = plan.agents[0]
+        assert ap.changed is False
+        assert plan.changed_count == 0
+        assert plan.unchanged_count == 1
+        assert ident_path.stat().st_mtime == mtime_before  # not rewritten
+
+    def test_dry_run_writes_nothing(self, home_with_cluster):
+        """Default (apply=False) computes a plan but writes nothing."""
+        ident_path = home_with_cluster / "agents" / "lumina" / "identity" / "identity.json"
+        before = ident_path.read_text()
+
+        with patch(_RESOLVER, side_effect=lambda a: _fake_ident(a)):
+            plan = migrate_identities(home_with_cluster, apply=False)
+
+        assert plan.dry_run is True
+        ap = plan.agents[0]
+        assert ap.changed is True            # plan SHOWS the additions
+        assert ap.applied is False           # but did not write
+        assert ident_path.read_text() == before
+        # The would-be additions are still surfaced for the diff.
+        assert "fqid" in ap.additions
+
+    def test_templates_and_noncapauth_skipped(self, home_with_cluster):
+        """*-template and non-capauth agents are excluded from the walk."""
+        _mk_agent(home_with_cluster, "lumina-template", identity_payload={"name": "T"})
+        _mk_agent(home_with_cluster, "scaffold", capauth=False, identity_payload={"name": "S"})
+
+        with patch(_RESOLVER, side_effect=lambda a: _fake_ident(a)):
+            plan = migrate_identities(home_with_cluster, apply=True)
+
+        names = {a.agent for a in plan.agents}
+        assert names == {"lumina"}
+
+    def test_missing_cluster_graceful(self, tmp_path):
+        """No cluster.json: realm/operator are skipped, fqid/fingerprint still tried."""
+        home = tmp_path / ".skcapstone"
+        home.mkdir(parents=True)
+        _mk_agent(home, "lumina", identity_payload={"name": "Lumina"})
+
+        # Resolver returns no fqid (cluster-derived) but does have a fingerprint.
+        with patch(_RESOLVER, side_effect=lambda a: _fake_ident(
+            a, fqid=None, fingerprint="C" * 40
+        )):
+            plan = migrate_identities(home, apply=True)
+
+        assert plan.cluster_found is False
+        ap = plan.agents[0]
+        # realm/operator/fqid absent (no cluster), but pgp_fingerprint added.
+        assert "realm" not in ap.additions
+        assert "operator" not in ap.additions
+        assert "fqid" not in ap.additions
+        assert ap.additions.get("pgp_fingerprint") == "C" * 40
+
+    def test_no_provisioned_agents(self, tmp_path):
+        """Empty home yields an empty plan, not a crash."""
+        home = tmp_path / ".skcapstone"
+        home.mkdir(parents=True)
+        plan = migrate_identities(home, apply=True)
+        assert plan.agents == []
+        assert plan.changed_count == 0
+
+    def test_unreadable_identity_is_error_not_crash(self, home_with_cluster):
+        """A corrupt identity.json is reported as an error, not raised."""
+        ident_path = home_with_cluster / "agents" / "lumina" / "identity" / "identity.json"
+        ident_path.write_text("{ not json")
+
+        with patch(_RESOLVER, side_effect=lambda a: _fake_ident(a)):
+            plan = migrate_identities(home_with_cluster, apply=True)
+
+        ap = plan.agents[0]
+        assert ap.error
+        assert ap.applied is False
+
+
+# ---------------------------------------------------------------------------
+# CLI integration
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def cli():
+    """A minimal Click group with only the identity commands registered."""
+    import click
+
+    @click.group()
+    def root():
+        pass
+
+    register_identity_commands(root)
+    return root
+
+
+class TestMigrateCLI:
+    """skcapstone identity migrate CLI."""
+
+    def test_default_is_dry_run(self, cli, home_with_cluster):
+        """Invoking without --apply writes nothing (dry-run is the default)."""
+        ident_path = home_with_cluster / "agents" / "lumina" / "identity" / "identity.json"
+        before = ident_path.read_text()
+
+        with patch(_RESOLVER, side_effect=lambda a: _fake_ident(a)):
+            result = CliRunner().invoke(
+                cli, ["identity", "migrate", "--home", str(home_with_cluster)]
+            )
+
+        assert result.exit_code == 0, result.output
+        assert "DRY-RUN" in result.output
+        assert ident_path.read_text() == before
+
+    def test_apply_writes(self, cli, home_with_cluster):
+        """--apply actually writes the backfilled fields."""
+        ident_path = home_with_cluster / "agents" / "lumina" / "identity" / "identity.json"
+
+        with patch(_RESOLVER, side_effect=lambda a: _fake_ident(a)):
+            result = CliRunner().invoke(
+                cli,
+                ["identity", "migrate", "--home", str(home_with_cluster), "--apply"],
+            )
+
+        assert result.exit_code == 0, result.output
+        data = json.loads(ident_path.read_text())
+        assert data["fqid"] == "lumina@chef.skworld"
+        assert data["pgp_fingerprint"] == "A" * 40
+
+    def test_json_out(self, cli, home_with_cluster):
+        """--json-out emits a machine-readable plan."""
+        with patch(_RESOLVER, side_effect=lambda a: _fake_ident(a)):
+            result = CliRunner().invoke(
+                cli,
+                ["identity", "migrate", "--home", str(home_with_cluster), "--json-out"],
+            )
+
+        assert result.exit_code == 0, result.output
+        payload = json.loads(result.output)
+        assert payload["dry_run"] is True
+        assert payload["agents"][0]["agent"] == "lumina"