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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.33
+Version: 0.72.35
 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.35}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.72.33"
+version = "0.72.35"
 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.35}/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.35"
 
 __all__ = ["__version__"]

swarph_cli-0.72.35/src/swarph_cli/commands/commander.py

@@ -0,0 +1,95 @@
+"""``swarph commander`` — propose a decision or an action. Card #1297.
+
+The cell asks. The commander decides, from the desktop, with a credential
+this command never holds. ``ask`` posts a decision. ``request`` posts
+``merge_pr`` or ``release_finish``. An MCP tool for the same queue is a
+later card.
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+
+from swarph_cli.commands import mesh as mesh_cmd
+
+
+def ask_body(question: str, options: list[str], card: int | None) -> dict:
+    body: dict = {"type": "decision", "question": question, "options": options}
+    if card is not None:
+        body["card_id"] = card
+    return body
+
+
+def request_body(kind: str, *, repo: str | None, pr: int | None,
+                 head: str | None, version: str | None, card: int | None) -> dict:
+    body: dict = {"type": kind, "pr": pr, "head_sha": head}
+    if kind == "merge_pr":
+        body["repo"] = repo
+    if kind == "release_finish":
+        body["version"] = version
+    if card is not None:
+        body["card_id"] = card
+    return body
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="swarph commander")
+    sub = p.add_subparsers(dest="command", required=True)
+
+    ask = sub.add_parser("ask", help="propose a decision")
+    mesh_cmd._add_common(ask)
+    ask.add_argument("--question", required=True)
+    ask.add_argument("--options", default=None,
+                     help="comma-separated choices, e.g. yes,no")
+    ask.add_argument("--card", type=int, default=None)
+
+    req = sub.add_parser("request", help="propose merge_pr or release_finish")
+    mesh_cmd._add_common(req)
+    req.add_argument("type", choices=["merge_pr", "release_finish"])
+    req.add_argument("--repo", default=None)
+    req.add_argument("--pr", type=int, default=None)
+    req.add_argument("--head", default=None)
+    req.add_argument("--version", default=None)
+    req.add_argument("--card", type=int, default=None)
+    return p
+
+
+def _options(raw: str | None) -> list[str]:
+    if not raw:
+        return []
+    return [part.strip() for part in raw.split(",") if part.strip()]
+
+
+def run_commander(argv: list[str]) -> int:
+    args = _build_parser().parse_args(argv)
+    try:
+        self_name = mesh_cmd._resolve_self_name(args.self_name)
+        token = mesh_cmd._resolve_token(self_name, args.token_file)
+    except RuntimeError as exc:
+        print(f"swarph commander: {exc}", file=sys.stderr)
+        return 1
+    gw = args.gateway.rstrip("/")
+    if args.command == "ask":
+        body = ask_body(args.question, _options(args.options), args.card)
+    else:
+        if args.pr is None or not args.head:
+            print("swarph commander request: --pr and --head are required",
+                  file=sys.stderr)
+            return 2
+        if args.type == "merge_pr" and not args.repo:
+            print("swarph commander request: merge_pr requires --repo",
+                  file=sys.stderr)
+            return 2
+        if args.type == "release_finish" and not args.version:
+            print("swarph commander request: release_finish requires --version",
+                  file=sys.stderr)
+            return 2
+        body = request_body(args.type, repo=args.repo, pr=args.pr, head=args.head,
+                            version=args.version, card=args.card)
+    status, payload = mesh_cmd._post_json(f"{gw}/commander/requests", body, token)
+    if status in (200, 201):
+        print(f"commander request #{payload.get('id')} {payload.get('status')}")
+        return 0
+    detail = payload.get("detail") if isinstance(payload, dict) else payload
+    print(f"swarph commander: {detail}", file=sys.stderr)
+    return 1

{swarph_cli-0.72.33 → swarph_cli-0.72.35}/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.35}/src/swarph_cli/guide/GUIDE.md

@@ -328,6 +328,13 @@ swarph board cards say <id> --to <peer> --content-file <path>
 swarph board cards ask <id> "<what is owed>" --step <step> --holder <peer>    # mint an obligation
 ```
 
+Propose a decision or an action. The commander decides it from the desktop; this
+command only posts the request (card #1297).
+
+`swarph commander ask --question "..." --options a,b --card N`
+`swarph commander request merge_pr --repo ORG/REPO --pr N --head SHA --card N`
+`swarph commander request release_finish --version V --pr N --head SHA --card N`
+
 **Obligations** exist because "waiting on a review" in someone's prose is not a fact
 anyone can query. `ask` writes a row: who owes what, since when. It closes when the holder
 **replies in the thread** -- which is why the distinction between `reply` and `send` above

{swarph_cli-0.72.33 → swarph_cli-0.72.35}/src/swarph_cli/main.py

@@ -108,6 +108,8 @@ _VERB_HANDLERS: dict[str, str] = {
     "peer-reply-drain": "swarph_cli.commands.peer_reply_drain.run_peer_reply_drain",
     "monitor": "swarph_cli.commands.monitor.run_monitor",
     "board": "swarph_cli.commands.board.run_board",
+    # card #1297: propose a decision or an action. The commander decides.
+    "commander": "swarph_cli.commands.commander.run_commander",
     "group": "swarph_cli.commands.group.run_group",
     "rights": "swarph_cli.commands.group.run_rights",
     "roster": "swarph_cli.commands.roster.run_roster",

{swarph_cli-0.72.33 → swarph_cli-0.72.35/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.35
 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.35}/src/swarph_cli.egg-info/SOURCES.txt

@@ -82,6 +82,7 @@ src/swarph_cli/commands/codegraph.py
 src/swarph_cli/commands/codegraph_hook.py
 src/swarph_cli/commands/codex_hook_output.py
 src/swarph_cli/commands/codex_waker.py
+src/swarph_cli/commands/commander.py
 src/swarph_cli/commands/compress.py
 src/swarph_cli/commands/daemon.py
 src/swarph_cli/commands/dreaming.py
@@ -252,6 +253,9 @@ 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_1297_commander.py
+tests/test_1301_restart_skew.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.33 → swarph_cli-0.72.35}/tests/test_1065_release.py

@@ -146,6 +146,7 @@ esac
     env["RELEASE_UNITS_FILE"] = str(units)
     env["RELEASE_VERIFY_CMD"] = "true"
     env["RELEASE_PYPI_SLEEP"] = "0"
+    env["RELEASE_INSTALL_EPOCH"] = "1"
     proc = _run(["bash", str(RELEASE), "--resume", "9.9.9"], env)
     assert proc.returncode == 0, proc.stderr + proc.stdout
     text = log.read_text()
@@ -201,6 +202,7 @@ esac
     env["RELEASE_UNITS_FILE"] = str(units)
     env["RELEASE_VERIFY_CMD"] = "true"
     env["RELEASE_PYPI_SLEEP"] = "0"
+    env["RELEASE_INSTALL_EPOCH"] = "1"
     if extra_env:
         env.update(extra_env)
     proc = _run(["bash", str(RELEASE), "--resume", "9.9.9"], env)

swarph_cli-0.72.35/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.35/tests/test_1297_commander.py

@@ -0,0 +1,60 @@
+"""card #1297 — `swarph commander ask` and `swarph commander request`.
+
+On current main the verb is unknown, so these assert exit 0 and fail there.
+"""
+from swarph_cli.main import main
+
+HEAD = "a" * 40
+
+
+def _patch(monkeypatch):
+    posted = {}
+
+    def fake_post(url, body, token, timeout=10.0):
+        posted["url"] = url
+        posted["body"] = body
+        posted["token"] = token
+        return 201, {"id": 7, "status": "pending"}
+
+    monkeypatch.setattr("swarph_cli.commands.mesh._post_json", fake_post)
+    monkeypatch.setattr("swarph_cli.commands.mesh._resolve_token", lambda *a, **k: "tok")
+    return posted
+
+
+def test_commander_ask_posts_a_decision(monkeypatch):
+    posted = _patch(monkeypatch)
+    rc = main(["commander", "ask", "--question", "ship it?", "--options", "yes,no",
+               "--card", "1297", "--gateway", "http://127.0.0.1:9", "--as", "cursor-lin"])
+    assert rc == 0
+    assert posted["url"].endswith("/commander/requests")
+    assert posted["body"] == {
+        "type": "decision",
+        "question": "ship it?",
+        "options": ["yes", "no"],
+        "card_id": 1297,
+    }
+
+
+def test_commander_request_posts_merge_and_release(monkeypatch):
+    posted = _patch(monkeypatch)
+    rc = main(["commander", "request", "merge_pr",
+               "--repo", "BrainSurfing-tech/swarph-cli", "--pr", "12",
+               "--head", HEAD, "--card", "1297",
+               "--gateway", "http://127.0.0.1:9", "--as", "cursor-lin"])
+    assert rc == 0
+    assert posted["body"]["type"] == "merge_pr"
+    assert posted["body"]["repo"] == "BrainSurfing-tech/swarph-cli"
+    assert posted["body"]["pr"] == 12
+    assert posted["body"]["head_sha"] == HEAD
+    assert posted["body"]["card_id"] == 1297
+
+    rc = main(["commander", "request", "release_finish",
+               "--version", "0.9.0", "--pr", "12", "--head", HEAD,
+               "--gateway", "http://127.0.0.1:9", "--as", "cursor-lin"])
+    assert rc == 0
+    assert posted["body"] == {
+        "type": "release_finish",
+        "pr": 12,
+        "head_sha": HEAD,
+        "version": "0.9.0",
+    }

swarph_cli-0.72.35/tests/test_1301_restart_skew.py

@@ -0,0 +1,64 @@
+"""card #1301: a same-second restart is not a failed restart.
+
+/proc btime is a whole second, so the derived start can read up to 1s
+before the install cutoff. A process that did not restart still fails.
+"""
+import os
+import subprocess
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+CHECK = ROOT / "scripts" / "release_check.py"
+RELEASE = ROOT / "release.sh"
+
+
+def _run(args, env):
+    return subprocess.run(args, cwd=ROOT, env=env, text=True, capture_output=True)
+
+
+def test_1301_same_second_restart_passes_and_an_old_process_fails(tmp_path):
+    image = tmp_path / "image"
+    image.write_bytes(b"swarph_cli-9.9.9.dist-info")
+    env = os.environ.copy()
+    env["RELEASE_IMAGE"] = str(image)
+    env["RELEASE_START_EPOCH"] = "648.800"
+    ok = _run(
+        ["python3", str(CHECK), "verify", "--pid", "42", "--expected", "9.9.9",
+         "--install-epoch", "649.000"],
+        env,
+    )
+    assert ok.returncode == 0, ok.stderr
+    assert "before the install" not in ok.stderr
+    env["RELEASE_START_EPOCH"] = "100.000"
+    bad = _run(
+        ["python3", str(CHECK), "verify", "--pid", "42", "--expected", "9.9.9",
+         "--install-epoch", "649.000"],
+        env,
+    )
+    assert bad.returncode != 0
+    assert "before the install" in bad.stderr
+    env["RELEASE_START_EPOCH"] = "648.800"
+    image.write_bytes(b"swarph_cli-0.1.0.dist-info")
+    wrong = _run(
+        ["python3", str(CHECK), "verify", "--pid", "42", "--expected", "9.9.9",
+         "--install-epoch", "649.000"],
+        env,
+    )
+    assert wrong.returncode != 0
+    assert "0.1.0" in wrong.stderr
+
+
+def test_1301_record_mtime_is_the_install_moment(tmp_path):
+    record = tmp_path / "RECORD"
+    record.write_bytes(b"x")
+    os.utime(record, (649.0, 649.0))
+    proc = _run(
+        ["python3", str(CHECK), "record-mtime", "--version", "9.9.9",
+         "--record", str(record)],
+        os.environ.copy(),
+    )
+    assert proc.returncode == 0, proc.stderr
+    assert abs(float(proc.stdout.strip()) - 649.0) < 0.01
+    text = RELEASE.read_text()
+    assert 'record-mtime --version "$VERSION"' in text
+    assert "install_epoch=$(date +%s)" not in text

{swarph_cli-0.72.33 → swarph_cli-0.72.35}/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