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

{swarph_cli-0.72.32/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.32
+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.32 → swarph_cli-0.72.34}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.72.32"
+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.32 → 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.32"
+__version__ = "0.72.34"
 
 __all__ = ["__version__"]

{swarph_cli-0.72.32 → 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.32 → swarph_cli-0.72.34}/src/swarph_cli/dreaming/index_check.py

@@ -41,6 +41,25 @@ MEM = pathlib.Path(
     next((a.split("=", 1)[1] for a in sys.argv if a.startswith("--mem-dir=")),
          str(pathlib.Path.home() / ".claude/projects/-home-ubuntu/memory")))
 INDEXES = ("MEMORY.md", "MEMORY_FULL.md")
+
+
+def index_names(mem: pathlib.Path) -> list[str]:
+    """Files whose pointers count: every MEMORY*.md and index_*.md.
+
+    MEMORY.md and MEMORY_FULL.md stay required, so a missing one is still
+    MISSING INDEX. Pointers also live in index_*.md after the index-of-indexes
+    restructure. A file named only there is not an orphan (card #1278).
+    """
+    found: list[str] = []
+    if mem.is_dir():
+        found = [
+            p.name for p in sorted(mem.glob("*.md"))
+            if p.name.startswith("MEMORY") or p.name.startswith("index_")
+        ]
+    for name in INDEXES:
+        if name not in found:
+            found.append(name)
+    return found
 BUDGET = 24985  # bytes, MEMORY.md only — stated in the file's own header comment
 # THE THIRD STATE. Without WARN this check reported "clean" at 24,972 bytes —
 # 13 bytes of headroom — which is the exact condition ORGANIZE exists to
@@ -189,9 +208,10 @@ def main() -> int:
         print(f"memory-index-check: {MEM} is not a directory", file=sys.stderr)
         return 1
 
-    files = {p.name for p in MEM.glob("*.md")} - set(INDEXES)
+    indexes = index_names(MEM)
+    files = {p.name for p in MEM.glob("*.md")} - set(indexes)
     linked: set[str] = set()
-    for i in INDEXES:
+    for i in indexes:
         linked |= links_in(i)
 
     findings: list[str] = []
@@ -203,7 +223,7 @@ def main() -> int:
         if len(orphans) > 20:
             findings.append(f"    … and {len(orphans) - 20} more")
 
-    for idx in INDEXES:
+    for idx in indexes:
         p = MEM / idx
         if not p.exists():
             findings.append(f"MISSING INDEX: {idx}")
@@ -213,7 +233,11 @@ def main() -> int:
             if line.startswith("- ") and TRUNC.search(line):
                 findings.append(f"TRUNCATED: {idx}:{n} ends mid-link — ...{line[-46:]}")
 
-    dangling = sorted(linked - files)
+    # An index file is not a missing memory. MEMORY.md (the index of indexes)
+    # links at index_*.md, and those names were removed from `files` above, so
+    # linked - files reported every one of them DANGLING (card #1278 rework).
+    # Subtract the index names too: dangling is a pointer to no existing .md.
+    dangling = sorted(linked - files - set(indexes))
     if dangling:
         findings.append(f"DANGLING: {len(dangling)} pointer(s) to a file that does not exist")
         findings += [f"    {d}" for d in dangling[:20]]

{swarph_cli-0.72.32 → swarph_cli-0.72.34}/src/swarph_cli/dreaming/notify.py

@@ -141,13 +141,64 @@ def apply(out: Path, verdicts, organized, cell: str, sender) -> bool:
     return True
 
 
+def _post_to_card(card: str, content: str) -> None:
+    """Put the finding on a card. A DM to the sender is refused (#185 / #409).
+
+    Card #864: a finding goes on a card. Card #1278: the dreaming unit is
+    lab-ovh notifying lab-ovh, so the send never arrives. Default card is 656,
+    whose rows are closed; a holder who posts to a card thread closes their
+    oldest open row on it,     so do not point this at a card the sender holds.
+    """
+    from swarph_cli.commands.board import (
+        _card_say_payload,
+        _http_get_json,
+        _post_json,
+        _project_owner_orchestrator,
+        _thread_recipient,
+    )
+    from swarph_cli.commands.mesh import _resolve_self_name, _resolve_token
+    from swarph_cli.gateway_default import env_gateway
+
+    gw = env_gateway()
+    self_name = _resolve_self_name(None)
+    token = _resolve_token(self_name, None)
+    status, card_row = _http_get_json(f"{gw}/board/cards/{card}", token)
+    if status != 200 or not isinstance(card_row, dict):
+        raise NotifySendError(f"cannot read card #{card}: {card_row}")
+    thread_uuid = card_row.get("thread_uuid")
+    if not thread_uuid:
+        raise NotifySendError(f"card #{card} has no bound thread")
+    owner = None
+    if not card_row.get("assignee"):
+        owner = _project_owner_orchestrator(gw, token, card_row.get("project_id"))
+    try:
+        to_node, _reason = _thread_recipient(card_row, None, owner_orchestrator=owner)
+    except RuntimeError as exc:
+        raise NotifySendError(str(exc)) from exc
+    status, payload = _post_json(
+        f"{gw}/messages",
+        _card_say_payload(self_name, to_node, "status", content, thread_uuid),
+        token,
+    )
+    if status < 200 or status >= 300:
+        raise NotifySendError(f"card #{card} post failed: {status} {payload}")
+
+
 def mesh_sender(cell: str, content: str) -> None:
-    """Same path as ``swarph mesh send``: one status DM, no second transport."""
+    """Same path as ``swarph mesh send``, unless that send would be a self-wake.
+
+    SWARPH_SELF equal to the notify cell is the dreaming unit. Mesh send
+    refuses it and the run exits 4. Post the same body to the dreaming card.
+    """
     import argparse
 
-    from swarph_cli.commands.mesh import _run_send
+    from swarph_cli.commands.mesh import _resolve_self_name, _run_send
     from swarph_cli.gateway_default import env_gateway
 
+    self_name = _resolve_self_name(None)
+    if cell == self_name:
+        _post_to_card("656", content)
+        return
     ns = argparse.Namespace(
         to=cell,
         kind="status",

{swarph_cli-0.72.32 → swarph_cli-0.72.34}/src/swarph_cli/triage/backend.py

@@ -34,7 +34,8 @@ class MemoryBackend:
                 f"create '{title}': project_id is required — the gateway "
                 f"refuses a card create without one (BoardCardCreate)")
         row = {"id": self.next_id, "title": title, "owner": owner,
-               "project_id": self.project_id, "status": "open"}
+               "project_id": self.project_id, "status": "open",
+               "labels": ["triage-row"]}
         self.next_id += 1
         self.rows[title] = row
         self.posts[title] = []
@@ -119,7 +120,10 @@ class BoardBackend:
                    "body": f"Daily triage row for {owner} (card #1073). "
                            "Items are appended by the triage job; "
                            "owners work them off the row.",
-                   "assignee": owner}
+                   "assignee": owner,
+                   # card #1269: the label is how offer_dispatch leaves the
+                   # minted rows unoffered. Rows stay requested.
+                   "labels": ["triage-row"]}
         try:
             status, body = self._http_post(
                 f"{self.gateway}/board/cards", payload, self.token)

{swarph_cli-0.72.32 → 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.32
+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.32 → swarph_cli-0.72.34}/src/swarph_cli.egg-info/SOURCES.txt

@@ -249,7 +249,10 @@ tests/test_1256_commander_wake.py
 tests/test_1261_mcp_install.py
 tests/test_1262_wake_followups.py
 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_1269_triage_label.py

@@ -0,0 +1,25 @@
+"""Card #1269. A new triage container is created with the triage-row
+label. Fails at dba1ebc: the create payload has no labels.
+"""
+from swarph_cli.triage.backend import BoardBackend
+
+
+class _Http:
+    def __init__(self):
+        self.posts = []
+
+    def post(self, url, payload, token):
+        self.posts.append((url, payload))
+        return 200, {"id": 77}
+
+    def get(self, url, token):
+        raise AssertionError(url)
+
+
+def test_create_labels_the_container_triage_row():
+    http = _Http()
+    backend = BoardBackend(
+        "http://gw:9", "tok", "lab-ovh", http.get, http.post, project_id=9)
+    backend.create_row("droplet triage", "droplet")
+    _url, payload = http.posts[-1]
+    assert payload.get("labels") == ["triage-row"]

swarph_cli-0.72.34/tests/test_1278_dreaming_reach.py

@@ -0,0 +1,70 @@
+"""Card #1278: a self-notify must be delivered, and index_*.md pointers count."""
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+from swarph_cli.dreaming import run as dreaming_run
+
+
+def _run_check(mem: Path) -> tuple[int, str]:
+    script = Path(__file__).resolve().parents[1] / "src" / "swarph_cli" / "dreaming" / "index_check.py"
+    r = subprocess.run(
+        [sys.executable, str(script), "--mem-dir=%s" % mem, "--quiet"],
+        capture_output=True, text=True, encoding="utf-8", errors="replace")
+    return r.returncode, (r.stdout or "") + (r.stderr or "")
+
+
+def test_1278_pointer_only_in_index_md_is_not_an_orphan(tmp_path):
+    mem = tmp_path / "mem"
+    mem.mkdir()
+    (mem / "MEMORY.md").write_text(
+        "- [a](a.md)\n- [topics](index_topics.md)\n", encoding="utf-8")
+    (mem / "MEMORY_FULL.md").write_text("- [a](a.md)\n", encoding="utf-8")
+    (mem / "index_topics.md").write_text("- [b](b.md)\n", encoding="utf-8")
+    (mem / "a.md").write_text("# a\n", encoding="utf-8")
+    (mem / "b.md").write_text("# b\n", encoding="utf-8")
+    rc, out = _run_check(mem)
+    assert "ORPHANS" not in out, out
+    assert "DANGLING" not in out, out
+    assert rc == 0, out
+
+
+def test_1278_self_notify_is_delivered_not_exit_4(tmp_path, monkeypatch):
+    monkeypatch.setenv("SWARPH_SELF", "lab-ovh")
+    posted = []
+
+    def clone(corpus, out):
+        Path(out).mkdir(parents=True, exist_ok=True)
+        return {}
+
+    monkeypatch.setattr(dreaming_run, "clone_corpus", clone)
+    monkeypatch.setattr(
+        dreaming_run, "verify",
+        lambda out, manifest: [{"verdict": "agree", "file": "a.md", "line": 1, "kind": "x"}],
+    )
+    monkeypatch.setattr(
+        dreaming_run, "organize",
+        lambda out: {"findings": [], "index_bytes_before": 0,
+                     "index_bytes_after": 0, "trimmed": []},
+    )
+    monkeypatch.setattr(dreaming_run, "render", lambda *a, **k: "# dreaming report\n")
+    monkeypatch.setattr(
+        "swarph_cli.dreaming.notify._post_to_card",
+        lambda card, body: posted.append((str(card), body)),
+        raising=False,
+    )
+    monkeypatch.setattr("swarph_cli.commands.mesh._run_send", lambda ns: 1)
+
+    corpus = tmp_path / "corpus"
+    corpus.mkdir()
+    rc = dreaming_run.main([
+        "--corpus", str(corpus),
+        "--out", str(tmp_path / "runs" / "run-1"),
+        "--no-enrich",
+        "--notify", "lab-ovh",
+    ])
+    assert rc != 4
+    assert posted and posted[0][0] == "656"
+    assert "dreaming" in posted[0][1] or posted[0][1]

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.32 → 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