swarph-cli 0.72.33__tar.gz → 0.72.34__tar.gz

{swarph_cli-0.72.33/src/swarph_cli.egg-info → swarph_cli-0.72.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.33
+Version: 0.72.34
 Summary: The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.72.33 → swarph_cli-0.72.34}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.72.33"
+version = "0.72.34"
 description = "The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`."
 readme = "README.md"
 license = { text = "MIT" }

{swarph_cli-0.72.33 → swarph_cli-0.72.34}/src/swarph_cli/__init__.py

@@ -16,6 +16,6 @@ The architecture splits CLI from substrate so:
 
 from __future__ import annotations
 
-__version__ = "0.72.33"
+__version__ = "0.72.34"
 
 __all__ = ["__version__"]

{swarph_cli-0.72.33 → swarph_cli-0.72.34}/src/swarph_cli/commands/mcp_server.py

@@ -33,9 +33,11 @@ without the SDK installed.
 from __future__ import annotations
 
 import argparse
+import datetime
 import importlib.metadata
 import json
 import os
+import time
 import urllib.error
 import urllib.request
 
@@ -301,17 +303,82 @@ def _dm_error(exc_or_text) -> dict:
     return {"error": str(exc_or_text), "messages": [], "n": 0}
 
 
+# One poll records the cursor at the newest id it saw. The earlier DMs in that
+# poll are behind the cursor and were not delivered. They stay visible while
+# they are younger than this (card #1286). Older than this, they are hidden
+# and counted.
+_DM_GRACE_S = 24 * 60 * 60
+
+
+def _created_epoch(message: dict) -> float | None:
+    raw = message.get("created_at")
+    if raw is None or raw == "":
+        return None
+    if isinstance(raw, bool):
+        return None
+    if isinstance(raw, (int, float)):
+        return float(raw)
+    text = str(raw).strip()
+    if text.endswith("Z"):
+        text = text[:-1] + "+00:00"
+    try:
+        return datetime.datetime.fromisoformat(text).timestamp()
+    except ValueError:
+        return None
+
+
+def _younger_than_grace(message: dict, now: float) -> bool:
+    ts = _created_epoch(message)
+    if ts is None:
+        return False
+    return (now - ts) < _DM_GRACE_S
+
+
+def _observation_cursor(who: str) -> int:
+    """The monitor's last_msg_id for this cell. Missing or unreadable is 0.
+
+    Peek only: nothing here writes cursor.json or marks a message read.
+    """
+    path = _mesh._default_sidecar_state_dir(who) / "cursor.json"
+    try:
+        return int(_mesh._read_cursor(path).get("last_msg_id") or 0)
+    except (TypeError, ValueError):
+        return 0
+
+
 def _dm_unread(self_name: str | None = None) -> dict:
-    """ALL unread DMs for self, full bodies, one call. Peek semantics: marks nothing
-    read. Above DM_CEILING the oldest DM_CEILING are returned in full and
-    `not_returned` says how many remain — never a shortened body, never silence."""
+    """Unread DMs the monitor has not yet delivered, full bodies, one call.
+
+    `read_at` is still the reply-ack (#735). The observation cursor advances
+    before delivery, so a DM with `id == last_msg_id` was observed and must
+    be returned (card #1286). One poll records the cursor at the newest id,
+    so the earlier DMs in that batch are behind it. A DM younger than 24 h
+    (`created_at`) is never hidden for that reason. A DM strictly behind the
+    cursor and not younger than 24 h stays hidden, and `hidden_stale` counts
+    those read_at-null DMs. Peek semantics: marks nothing read and does not
+    advance the cursor. Above DM_CEILING the oldest DM_CEILING are returned
+    in full and `not_returned` says how many remain.
+    """
     try:
         who, gw, tok = _dm_session(self_name)
         st, d = _mesh._http_get_json(
             f"{gw}/messages?to={who}&unread_only=true&limit={DM_GATEWAY_WINDOW}", tok)
         if not (200 <= st < 300):
             return _dm_error(f"gateway {st}: {d.get('detail', d) if isinstance(d, dict) else d}")
-        msgs = sorted(d.get("messages", []), key=lambda m: int(m.get("id", 0)))
+        raw = sorted(d.get("messages", []), key=lambda m: int(m.get("id") or 0))
+        last_id = _observation_cursor(who)
+        now = time.time()
+        msgs = []
+        hidden_stale = 0
+        for message in raw:
+            if message.get("from_node") == who:
+                continue
+            mid = int(message.get("id") or 0)
+            if mid >= last_id or _younger_than_grace(message, now):
+                msgs.append(message)
+                continue
+            if message.get("read_at") in (None, ""):
+                hidden_stale += 1
         keep = msgs[:DM_CEILING]
         return {
             "self": who,
@@ -319,7 +386,8 @@ def _dm_unread(self_name: str | None = None) -> dict:
             "n": len(keep),
             "unread_seen": len(msgs),
             "not_returned": len(msgs) - len(keep),
-            "window_full": len(msgs) >= DM_GATEWAY_WINDOW,
+            "hidden_stale": hidden_stale,
+            "window_full": len(raw) >= DM_GATEWAY_WINDOW,
         }
     except Exception as exc:  # loud, never an empty inbox
         return _dm_error(f"{type(exc).__name__}: {exc}")
@@ -473,10 +541,16 @@ try:
 
     @mcp.tool()
     def swarph_dm_unread() -> dict:
-        """ALL unread DMs for this cell, FULL bodies, ONE call (card #735). Peek semantics:
-        nothing is marked read. No paging, no cursor. Replying with swarph_dm_reply is the
-        ack; anything unanswered keeps appearing here. `not_returned` > 0 means more than
-        the ceiling were unread and the oldest were returned in full."""
+        """Unread DMs for this cell, FULL bodies, ONE call (card #735, card #1286).
+
+        Peek semantics: nothing is marked read and the monitor cursor is not moved.
+        The DM whose id equals the cursor was observed and not yet delivered, so
+        it is returned. A DM strictly behind the cursor is still returned when
+        its created_at is younger than 24 h. Older than that, it stays hidden
+        and hidden_stale counts it. No paging parameter.
+        Replying with swarph_dm_reply is the ack.
+        `not_returned` > 0 means more than the ceiling were unread and the oldest
+        were returned in full."""
         return _dm_unread()
 
     @mcp.tool()

{swarph_cli-0.72.33 → swarph_cli-0.72.34/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.33
+Version: 0.72.34
 Summary: The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.72.33 → swarph_cli-0.72.34}/src/swarph_cli.egg-info/SOURCES.txt

@@ -252,6 +252,7 @@ tests/test_1265_wake_note.py
 tests/test_1269_triage_label.py
 tests/test_126_pending_from_complete.py
 tests/test_1278_dreaming_reach.py
+tests/test_1286_dm_unread_cursor.py
 tests/test_132_ensure_monitor_state_dir.py
 tests/test_138_memory_navigate.py
 tests/test_139_tool_probe.py

swarph_cli-0.72.34/tests/test_1286_dm_unread_cursor.py

@@ -0,0 +1,192 @@
+"""Card #1286: swarph_dm_unread agrees with the monitor cursor.
+
+A DM with read_at NULL that the cursor has already passed is not unread.
+The call is a peek: cursor.json is not rewritten and nothing is marked read.
+"""
+from __future__ import annotations
+
+import datetime
+import json
+import time
+
+from swarph_cli.commands import mesh
+from swarph_cli.commands import mcp_server
+from swarph_cli.dm_frame import frame_text
+
+
+def test_1286_stale_unread_behind_the_cursor_is_not_new(monkeypatch, tmp_path):
+    monkeypatch.setattr(
+        mcp_server, "_dm_session", lambda self_name=None: ("lab-ovh", "http://gw", "tok"),
+    )
+    state = tmp_path / "mesh-sidecar"
+    state.mkdir()
+    # Path.home() ignores HOME on Windows, so point the sidecar helper itself.
+    monkeypatch.setattr(mcp_server._mesh, "_default_sidecar_state_dir", lambda who: state)
+    cursor = state / "cursor.json"
+    cursor.write_text(json.dumps({"last_msg_id": 200}), encoding="utf-8")
+    before = cursor.read_bytes()
+    rows = [
+        {"id": 100, "from_node": "cursor-lin", "to_node": "lab-ovh", "kind": "status",
+         "content": "STALE1286", "read_at": None},
+        {"id": 200, "from_node": "cursor-lin", "to_node": "lab-ovh", "kind": "status",
+         "content": "BOUNDARY1286", "read_at": None},
+        {"id": 300, "from_node": "cursor-lin", "to_node": "lab-ovh", "kind": "status",
+         "content": "NEW1286 full body", "read_at": None},
+        {"id": 400, "from_node": "lab-ovh", "to_node": "cursor-lin", "kind": "status",
+         "content": "SELF1286", "read_at": None},
+    ]
+
+    def fake_get(url, token, **kw):
+        assert "unread_only=true" in url
+        return 200, {"messages": list(reversed(rows)), "n": len(rows)}
+
+    monkeypatch.setattr(mcp_server._mesh, "_http_get_json", fake_get)
+    out = mcp_server._dm_unread()
+    # 200 equals the cursor: observed, not yet delivered, so it is returned.
+    # 100 is strictly behind and stays hidden.
+    assert [m["id"] for m in out["messages"]] == [200, 300]
+    assert out["messages"][1]["content"] == frame_text(rows[2])
+    assert "NEW1286 full body" in out["messages"][1]["content"]
+    assert "BOUNDARY1286" in out["messages"][0]["content"]
+    assert "STALE1286" not in json.dumps(out)
+    assert "SELF1286" not in json.dumps(out)
+    assert out["n"] == 2 and out["not_returned"] == 0
+    # 100 is behind the cursor and has no created_at, so it is not within 24 h.
+    assert out.get("hidden_stale") == 1
+    assert cursor.read_bytes() == before
+
+
+def test_1286_monitor_iteration_then_unread_returns_the_woken_dm(monkeypatch, tmp_path):
+    """One real monitor iteration observes a new DM, then unread still returns it.
+
+    The cursor advances before delivery, so the woken id equals last_msg_id.
+    On 74347164 unread uses a strict `>` and the DM is gone.
+    """
+    state_dir = tmp_path / "mesh-sidecar"
+    state_dir.mkdir()
+    (state_dir / "cursor.json").write_text(
+        json.dumps({"last_msg_id": 100}), encoding="utf-8")
+    monkeypatch.setattr(mcp_server._mesh, "_default_sidecar_state_dir", lambda who: state_dir)
+    monkeypatch.setattr(
+        mcp_server, "_dm_session", lambda self_name=None: ("lab-ovh", "http://gw", "tok"),
+    )
+    woken = {
+        "id": 501, "from_node": "cursor-lin", "to_node": "lab-ovh", "kind": "question",
+        "content": "WOKEN1286 full body", "read_at": None,
+    }
+    stale = {
+        "id": 50, "from_node": "cursor-lin", "to_node": "lab-ovh", "kind": "status",
+        "content": "BEHIND1286", "read_at": None,
+    }
+
+    def fake_get(url, token, **kw):
+        return 200, {"messages": [stale, woken]}
+
+    monkeypatch.setattr(mesh, "_http_get_json", fake_get)
+    state = mesh.MonitorState(
+        self_name="lab-ovh",
+        state_dir=state_dir,
+        gateway="http://gw",
+        token="tok",
+        sinks=[mesh.parse_sink("none")],
+    )
+    mesh._monitor_iteration(state, poll_channels=False)
+    out = mcp_server._dm_unread()
+    ids = [m["id"] for m in out["messages"]]
+    assert ids == [501]
+    assert "WOKEN1286 full body" in out["messages"][0]["content"]
+    assert "BEHIND1286" not in json.dumps(out)
+    assert out.get("hidden_stale") == 1
+
+
+def _iso(offset_s: float) -> str:
+    stamp = datetime.datetime.fromtimestamp(time.time() + offset_s, datetime.timezone.utc)
+    return stamp.isoformat()
+
+
+def _row(mid: int, content: str, created_at: str) -> dict:
+    return {
+        "id": mid, "from_node": "cursor-lin", "to_node": "lab-ovh", "kind": "question",
+        "content": content, "read_at": None, "created_at": created_at,
+    }
+
+
+def _monitor(monkeypatch, tmp_path, rows, *, polls: int = 1, windows=None):
+    state_dir = tmp_path / "mesh-sidecar"
+    state_dir.mkdir()
+    (state_dir / "cursor.json").write_text(
+        json.dumps({"last_msg_id": 100}), encoding="utf-8")
+    monkeypatch.setattr(mcp_server._mesh, "_default_sidecar_state_dir", lambda who: state_dir)
+    monkeypatch.setattr(
+        mcp_server, "_dm_session", lambda self_name=None: ("lab-ovh", "http://gw", "tok"),
+    )
+    seen = {"n": 0}
+
+    def fake_get(url, token, **kw):
+        if "unread_only" in url:
+            return 200, {"messages": list(rows)}
+        if windows is None:
+            return 200, {"messages": list(rows)}
+        index = min(seen["n"], len(windows) - 1)
+        seen["n"] += 1
+        wanted = windows[index]
+        return 200, {"messages": [row for row in rows if row["id"] in wanted]}
+
+    monkeypatch.setattr(mesh, "_http_get_json", fake_get)
+    state = mesh.MonitorState(
+        self_name="lab-ovh",
+        state_dir=state_dir,
+        gateway="http://gw",
+        token="tok",
+        sinks=[mesh.parse_sink("none")],
+    )
+    for _ in range(polls):
+        mesh._monitor_iteration(state, poll_channels=False)
+    return mcp_server._dm_unread(), state
+
+
+def test_1286_one_poll_observing_three_returns_all_three(monkeypatch, tmp_path):
+    """One poll records the cursor at the newest id. The two earlier DMs are young."""
+    young = _iso(0)
+    rows = [
+        _row(501, "ONE1286", young),
+        _row(502, "TWO1286", young),
+        _row(503, "THREE1286", young),
+    ]
+    out, state = _monitor(monkeypatch, tmp_path, rows)
+    assert state.observed["last_msg_id"] == 503
+    assert [m["id"] for m in out["messages"]] == [501, 502, 503]
+    assert out.get("hidden_stale") == 0
+
+
+def test_1286_three_polls_then_unread_returns_all_three(monkeypatch, tmp_path):
+    """A busy host calls the tool after three polls, one new DM each."""
+    young = _iso(-60)
+    rows = [
+        _row(501, "POLL1286a", young),
+        _row(502, "POLL1286b", young),
+        _row(503, "POLL1286c", young),
+    ]
+    out, state = _monitor(
+        monkeypatch, tmp_path, rows, polls=3, windows=([501], [501, 502], [501, 502, 503]),
+    )
+    assert state.observed["last_msg_id"] == 503
+    assert [m["id"] for m in out["messages"]] == [501, 502, 503]
+    assert "POLL1286a" in out["messages"][0]["content"]
+    assert out.get("hidden_stale") == 0
+
+
+def test_1286_old_dm_behind_the_cursor_is_hidden_and_counted(monkeypatch, tmp_path):
+    young = _iso(0)
+    old = _iso(-(25 * 60 * 60))
+    rows = [
+        _row(50, "OLD1286", old),
+        _row(80, "YOUNGBEHIND1286", young),
+        _row(501, "FRESH1286", young),
+    ]
+    out, state = _monitor(monkeypatch, tmp_path, rows)
+    assert state.observed["last_msg_id"] == 501
+    assert "OLD1286" not in json.dumps(out)
+    assert out.get("hidden_stale") == 1
+    assert [m["id"] for m in out["messages"]] == [80, 501]
+    assert "YOUNGBEHIND1286" in out["messages"][0]["content"]

{swarph_cli-0.72.33 → swarph_cli-0.72.34}/tests/test_735_dm_mcp_tools.py

@@ -44,7 +44,10 @@ FIXTURE = [
 
 
 @pytest.fixture(autouse=True)
-def _session(monkeypatch: pytest.MonkeyPatch):
+def _session(monkeypatch: pytest.MonkeyPatch, tmp_path):
+    # Card #1286 reads the monitor cursor. These tests are about the unread
+    # payload, so they observe from a private home whose cursor is absent.
+    monkeypatch.setenv("HOME", str(tmp_path))
     monkeypatch.setattr(mcp_server, "_dm_session", lambda self_name=None: ("lab-ovh", "http://gw", "tok"))
     if MUTATE == "truncate":
         real = mcp_server._lean