swarph-cli 0.69.7__tar.gz → 0.69.8__tar.gz

{swarph_cli-0.69.7/src/swarph_cli.egg-info → swarph_cli-0.69.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.69.7
+Version: 0.69.8
 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.69.7 → swarph_cli-0.69.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.69.7"
+version = "0.69.8"
 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.69.7 → swarph_cli-0.69.8}/src/swarph_cli/__init__.py

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

{swarph_cli-0.69.7 → swarph_cli-0.69.8}/src/swarph_cli/scripts/ensure_monitor.sh

@@ -64,71 +64,19 @@ STATE_DIR="${1:-${SWARPH_STATE_DIR:-}}"
 SD=()
 [ -n "$STATE_DIR" ] && SD=(--state-dir "$STATE_DIR")
 
-# >>> #960: a fresh channel heartbeat is already a reader. <<<
-# swarph channel-serve writes channel_heartbeat.json beside the inbox every
-# 60s and names no path on its command line, so `monitor status` cannot see
-# it. Starting a pull monitor beside a heartbeat younger than 180s is the
-# duplicate this script exists to prevent. Absent or older: start, as before.
-# A missing python3 is treated as absent (start), never as a failed caller.
-_heartbeat_fresh() {
-  local f="$1"
-  [ -n "$f" ] && [ -f "$f" ] || return 1
-  command -v python3 >/dev/null 2>&1 || return 1
-  python3 -c 'import json,os,sys,time
-try:
-    data=json.load(open(sys.argv[1],encoding="utf-8"))
-    ts=float(data.get("ts") or 0)
-except Exception:
-    raise SystemExit(1)
-age=time.time()-ts
-# A clock a few seconds ahead is still a live writer. An hour ahead is not.
-if age < -30 or age >= 180:
-    raise SystemExit(1)
-pid=data.get("pid")
-if pid is None:
-    raise SystemExit(0)
-try:
-    pid=int(pid)
-except (TypeError, ValueError):
-    raise SystemExit(1)
-# pid 0 is this process group and pid -1 is every process we can signal.
-# Neither is the channel server. os.kill would report both as alive.
-if pid <= 0:
-    raise SystemExit(1)
-try:
-    os.kill(pid, 0)
-except PermissionError:
-    pass
-except OSError:
-    raise SystemExit(1)
-try:
-    raw=open("/proc/%s/cmdline" % pid, "rb").read()
-except OSError:
-    # No command line to read (macOS, or a pid we may not inspect).
-    # A live pid still counts, which is the check this host can make.
-    raise SystemExit(0)
-text=raw.replace(b"\x00", b" ").decode("utf-8", "replace")
-if "channel-serve" in text or "swarph_cli.channel" in text:
-    raise SystemExit(0)
-raise SystemExit(1)' "$f"
-}
-
-HB_ROOT="${STATE_DIR:-$HOME/swarph_state/$SELF}"
-HB_FILE=""
-if [ -f "$HB_ROOT/channel_heartbeat.json" ]; then
-  HB_FILE="$HB_ROOT/channel_heartbeat.json"
-elif [ -f "$HB_ROOT/mesh-sidecar/channel_heartbeat.json" ]; then
-  HB_FILE="$HB_ROOT/mesh-sidecar/channel_heartbeat.json"
-fi
-
+# >>> #960: the heartbeat is the READER, the monitor is the WRITER. <<<
+# channel-serve writes channel_heartbeat.json every 60s and only reads
+# inbox.log. The pull monitor is the only writer of that log. A fresh
+# heartbeat means the reader is up, not the writer. `monitor status` is
+# the check for the writer. Not running: start one, even when the
+# heartbeat is fresh. Running (status 0 or 1): start nothing. A second
+# monitor is the duplicate. The heartbeat file is not that check.
 "$SW" monitor status --as "$SELF" ${SD[@]+"${SD[@]}"} >/dev/null 2>&1
 case $? in
   0) ;;                                   # running, nothing pending
   1) ;;                                   # running, DMs pending — reported below
-  *) # not running (2) or unknown.
-     if _heartbeat_fresh "$HB_FILE"; then
-       echo "[monitor] channel heartbeat is under 180s old — not starting a monitor"
-     elif "$SW" monitor start --as "$SELF" --deliver pull ${SD[@]+"${SD[@]}"} >/tmp/.swarph-monitor-start.$$ 2>&1; then
+  *) # not running (2) or unknown. The heartbeat does not cover this.
+     if "$SW" monitor start --as "$SELF" --deliver pull ${SD[@]+"${SD[@]}"} >/tmp/.swarph-monitor-start.$$ 2>&1; then
        echo "[monitor] started (--deliver pull)"
      else
        # LOUD, not silent: an auto-start that fails quietly rebuilds the exact

{swarph_cli-0.69.7 → swarph_cli-0.69.8/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.69.7
+Version: 0.69.8
 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.69.7 → swarph_cli-0.69.8}/src/swarph_cli.egg-info/SOURCES.txt

@@ -178,6 +178,7 @@ src/swarph_cli/systemd/swarph-peer-reply-drain@.timer
 src/swarph_cli/systemd/swarph-watchdog.default
 src/swarph_cli/systemd/swarph-watchdog.service
 src/swarph_cli/systemd/swarph-watchdog.timer
+tests/test_1006_session_board.py
 tests/test_124_register_merge.py
 tests/test_126_pending_from_complete.py
 tests/test_132_ensure_monitor_state_dir.py

swarph_cli-0.69.8/tests/test_1006_session_board.py

@@ -0,0 +1,291 @@
+"""card #1006 — CLI session board. The desktop tool names must not appear."""
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+SKILL = ROOT / "plugins" / "swarph" / "skills" / "lej-session-board"
+FIX = ROOT / "tests" / "fixtures" / "session-board"
+SCRIPT = SKILL / "scripts" / "build_board.py"
+
+# Names that exist only on Claude Desktop. Referencing one is a fail.
+DESKTOP_TOOLS = (
+    "mcp__ccd_session_mgmt__",
+    "list_sessions",
+    "list_events",
+    "archive_session",
+    "set_pinned",
+    "get_session",
+)
+
+
+def _skill_texts():
+    files = [SKILL / "SKILL.md", SKILL / "references" / "coordination-rule.md", SCRIPT]
+    return {p.relative_to(SKILL).as_posix(): p.read_text(encoding="utf-8") for p in files}
+
+
+def desktop_hits(text: str) -> list[str]:
+    return [name for name in DESKTOP_TOOLS if name in text]
+
+
+def test_desktop_tool_name_is_not_referenced():
+    for rel, text in _skill_texts().items():
+        assert desktop_hits(text) == [], rel
+
+
+def test_the_scanner_fails_when_a_desktop_tool_name_is_added():
+    poisoned = "call mcp__ccd_session_mgmt__list_sessions here"
+    assert "mcp__ccd_session_mgmt__" in desktop_hits(poisoned)
+
+
+def test_license_and_attribution_kept():
+    lic = (SKILL / "LICENSE").read_text(encoding="utf-8")
+    assert "MIT License" in lic
+    assert "Jonathan Edwards" in lic
+    readme = (SKILL / "README.md").read_text(encoding="utf-8")
+    assert "Jonathan Edwards" in readme
+    assert "MIT" in readme
+
+
+def test_coordination_rule_uses_listagents_and_sendmessage_by_name():
+    text = (SKILL / "references" / "coordination-rule.md").read_text(encoding="utf-8")
+    assert "ListAgents" in text
+    assert "SendMessage" in text
+    assert "by the name" in text
+    assert "approves building, not deploying" in text
+    assert desktop_hits(text) == []
+
+
+def _run_board():
+    proc = subprocess.run(
+        [sys.executable, str(SCRIPT),
+         "--listing", str(FIX / "listagents-lab.txt"),
+         "--rows", str(FIX / "commander-170.json")],
+        check=True, capture_output=True, text=True,
+    )
+    return json.loads(proc.stdout)
+
+
+def _validate(board: dict):
+    """The fields references/data-schema.md says the page reads."""
+    schema = (SKILL / "references" / "data-schema.md").read_text(encoding="utf-8")
+    for field in ("updated", "projectFolder", "manager", "sessions", "groups"):
+        assert field in schema
+        assert field in board
+    assert isinstance(board["sessions"], list) and board["sessions"]
+    for sess in board["sessions"]:
+        for field in ("id", "name", "state", "tone", "where", "questions"):
+            assert field in sess
+        assert sess["tone"] in ("needs", "done", "")
+        assert 2 <= len(sess["where"]) <= 4
+        for q in sess["questions"]:
+            for field in ("id", "to", "title", "options", "to_node", "in_session"):
+                assert field in q
+                assert field in schema
+            assert "card" in schema and "obligation" in schema
+            assert q["to_node"] == q["to"]
+            assert isinstance(q["in_session"], bool)
+            assert 2 <= len(q["options"]) <= 3
+            assert sum(1 for opt in q["options"] if opt.get("rec")) == 1
+            for opt in q["options"]:
+                assert opt["label"] and opt["text"]
+    for group in board["groups"]:
+        assert "title" in group and "items" in group
+
+
+def test_skill_maps_a_name_through_the_sessions_file_and_lists_shell():
+    text = (SKILL / "SKILL.md").read_text(encoding="utf-8")
+    step = text.split("## 1. Take the roster", 1)[1].split("## 2.", 1)[0]
+    assert "~/.claude/sessions/<pid>.json" in step
+    assert "name" in step and "sessionId" in step and "cwd" in step
+    assert "`shell`" in step
+    assert "in progress" in step.lower() or "In progress" in step
+
+
+def test_shell_status_is_in_progress():
+    sys.path.insert(0, str(SCRIPT.parent))
+    import build_board
+    listing = "This session is lab-ovh [1e23f6]\npeer [abc123] · interactive · shell · running a command\n"
+    board = build_board.build(listing, [])
+    sess = next(s for s in board["sessions"] if s["name"] == "peer")
+    assert sess["bucket"] == "in_progress"
+    assert sess["tone"] == ""
+
+
+def test_schema_documents_the_four_new_question_fields():
+    schema = (SKILL / "references" / "data-schema.md").read_text(encoding="utf-8")
+    for field in ("to_node", "card", "obligation", "in_session"):
+        assert f"`{field}`" in schema
+
+
+def test_skill_builds_schema_valid_json_without_desktop_tools():
+    board = _run_board()
+    _validate(board)
+    assert board["manager"] == "lab-ovh"
+
+
+def test_lab_roster_sorts_offline_remote_control_into_stale():
+    listing = (FIX / "listagents-lab.txt").read_text(encoding="utf-8")
+    board = _run_board()
+    by_id = {s["id"]: s for s in board["sessions"]}
+    # every offline Remote Control row from the real listing is stale
+    seen = 0
+    for line in listing.splitlines():
+        if "Remote Control" in line and "offline" in line:
+            sid = line.split("[", 1)[1].split("]", 1)[0]
+            assert by_id[sid]["bucket"] == "stale"
+            assert by_id[sid]["tone"] == "done"
+            seen += 1
+    assert seen >= 40
+
+
+def test_droplet_section_carries_the_commander_row_with_a_recommendation():
+    board = _run_board()
+    droplet = next(s for s in board["sessions"] if s["name"] == "droplet")
+    assert droplet["bucket"] == "needs_followup"
+    assert droplet["tone"] == "needs"
+    q = droplet["questions"][0]
+    assert "687" in q["title"] or "rebalancer" in q["title"]
+    rec = [opt for opt in q["options"] if opt["rec"]]
+    assert len(rec) == 1
+    assert rec[0]["label"] == "Retire"
+
+
+def test_filling_the_template_does_not_change_the_markup():
+    sys.path.insert(0, str(SCRIPT.parent))
+    import build_board
+    template = (SKILL / "assets" / "board-template.html").read_text(encoding="utf-8")
+    board = _run_board()
+    # the page does not read the sort bucket
+    public = json.loads(json.dumps(board))
+    for sess in public["sessions"]:
+        sess.pop("bucket", None)
+    filled = build_board.fill_template(template, public)
+    start = template.find('<script type="application/json" id="board-data">')
+    end = template.find("</script>", start)
+    assert template[:start] == filled[:start]
+    assert template[end:] == filled[filled.find("</script>", start):]
+    data = json.loads(filled[filled.find(">", start) + 1:filled.find("</script>", start)])
+    _validate(data)
+
+
+def test_envelope_header_and_new_fields():
+    sys.path.insert(0, str(SCRIPT.parent))
+    import build_board
+    board = _run_board()
+    body = build_board.envelope(board)
+    header, payload = body.split("\n", 1)
+    assert header == "SWARPH-BOARD v1"
+    parsed = json.loads(payload)
+    _validate(parsed)
+    droplet = next(s for s in parsed["sessions"] if s["name"] == "droplet")
+    q = droplet["questions"][0]
+    assert q["to_node"] == "droplet"
+    assert q["card"] == 687
+    assert q["obligation"] == 170
+    assert q["in_session"] is False
+    assert "bucket" not in droplet
+
+
+def test_unchanged_board_sends_nothing():
+    sys.path.insert(0, str(SCRIPT.parent))
+    import build_board
+    board = _run_board()
+    sent = []
+    assert build_board.publish_if_changed(board, build_board.envelope(board), sent.append) is False
+    assert sent == []
+    # a clock-only difference is not a change
+    later = json.loads(json.dumps(board))
+    later["updated"] = "2099-01-01 00:00 UTC"
+    assert build_board.publish_if_changed(later, build_board.envelope(board), sent.append) is False
+    assert sent == []
+
+
+def test_a_changed_board_sends_the_envelope_once():
+    sys.path.insert(0, str(SCRIPT.parent))
+    import build_board
+    board = _run_board()
+    changed = json.loads(json.dumps(board))
+    droplet = next(s for s in changed["sessions"] if s["name"] == "droplet")
+    droplet["questions"][0]["title"] = "A different question"
+    sent = []
+    assert build_board.publish_if_changed(changed, build_board.envelope(board), sent.append) is True
+    assert len(sent) == 1
+    assert sent[0].startswith("SWARPH-BOARD v1\n")
+    assert "A different question" in sent[0]
+
+
+def test_deploy_accept_sets_in_session_and_every_question_has_to_node():
+    sys.path.insert(0, str(SCRIPT.parent))
+    import build_board
+    listing = (FIX / "listagents-lab.txt").read_text(encoding="utf-8")
+    rows = json.loads((FIX / "commander-170.json").read_text(encoding="utf-8"))
+    rows.append({
+        "cell": "droplet",
+        "card_id": 9001,
+        "obligation_id": 9001,
+        "title": "Production deploy of the board tab",
+        "accept": "The commander types the production deploy go in that session. This row is a hard gate.",
+        "options": [
+            {"label": "Go", "text": "go", "rec": True},
+            {"label": "Hold", "text": "hold", "rec": False},
+        ],
+    })
+    board = build_board.build(listing, rows)
+    questions = []
+    for sess in board["sessions"]:
+        questions.extend(sess["questions"])
+    assert questions
+    assert all(q.get("to_node") for q in questions)
+    deploy = next(q for q in questions if q["title"] == "Production deploy of the board tab")
+    retire = next(q for q in questions if q["obligation"] == 170)
+    assert deploy["in_session"] is True
+    assert deploy["to_node"] == "droplet"
+    assert deploy["card"] == 9001
+    assert retire["in_session"] is False
+
+
+def test_an_answer_dm_drops_that_question():
+    sys.path.insert(0, str(SCRIPT.parent))
+    import build_board
+    rows = json.loads((FIX / "commander-170.json").read_text(encoding="utf-8"))
+    title = rows[0]["title"]
+    kept = build_board.drop_answered(
+        rows, [("commander", f"Re: {title}\nRetire.\n")], commander="commander")
+    assert kept == []
+
+
+def test_only_the_commander_can_drop_a_question():
+    """A Re: line from any other cell must leave the question up.
+
+    On 61c5f49 drop_answered took bare bodies and dropped the row for any sender.
+    """
+    sys.path.insert(0, str(SCRIPT.parent))
+    import build_board
+    rows = json.loads((FIX / "commander-170.json").read_text(encoding="utf-8"))
+    title = rows[0]["title"]
+    body = f"Re: {title}\nRetire.\n"
+    kept = build_board.drop_answered(rows, [("lab-ovh", body)], commander="commander")
+    assert len(kept) == 1
+    assert kept[0]["title"] == title
+    cleared = build_board.drop_answered(rows, [("commander", body)], commander="commander")
+    assert cleared == []
+
+
+def test_redeploy_is_in_session_and_deployment_notes_are_not():
+    sys.path.insert(0, str(SCRIPT.parent))
+    import build_board
+    assert build_board._in_session({"accept": "redeploy the gateway"}) is True
+    assert build_board._in_session({"accept": "deployment notes for the board"}) is False
+    assert build_board._in_session({"accept": "production deploy go"}) is True
+
+
+def test_skill_step_4_names_the_sender_and_the_trigger_words():
+    text = (SKILL / "SKILL.md").read_text(encoding="utf-8")
+    step = text.split("## 4. Answers", 1)[1].split("## ", 1)[0]
+    assert "from_node" in step
+    assert "commander" in step
+    assert "any other cell" in step
+    for word in ("deploy", "redeploy", "hard gate"):
+        assert word in step

{swarph_cli-0.69.7 → swarph_cli-0.69.8}/tests/test_960_ensure_monitor_heartbeat.py

@@ -1,9 +1,8 @@
-"""#960: a fresh channel heartbeat is a reader. Do not start a monitor beside it.
+"""#960: a fresh channel heartbeat is the reader, not the writer.
 
-channel-serve writes channel_heartbeat.json beside the inbox and puts nothing
-on its command line, so monitor status reports "not running" while the channel
-is alive. On main, that status is enough to start a second reader. The head
-starts only when the file is absent or older than 180s.
+channel-serve writes channel_heartbeat.json and only reads inbox.log. The
+pull monitor is the only writer. A fresh heartbeat must not stop that
+monitor from starting. A live monitor (status 0) still starts nothing.
 """
 from __future__ import annotations
 
@@ -61,11 +60,14 @@ def _run(tmp_path: Path, *, age: float | None):
     return proc, calls
 
 
-def test_fresh_heartbeat_does_not_start(tmp_path):
+def test_fresh_heartbeat_with_no_monitor_starts(tmp_path):
+    """The shim exits 2, so no monitor is running. A 10s-old heartbeat
+    still has to start the pull monitor. On main this asserts the opposite.
+    """
     proc, calls = _run(tmp_path, age=10)
     assert proc.returncode == 0
-    assert "monitor start" not in calls
-    assert "under 180s" in proc.stdout
+    assert "monitor start" in calls
+    assert "under 180s" not in proc.stdout
 
 
 def test_stale_heartbeat_still_starts(tmp_path):
@@ -107,10 +109,10 @@ def test_a_future_timestamp_an_hour_ahead_starts(tmp_path):
     assert "monitor start" in calls
 
 
-def test_a_timestamp_within_skew_stays_fresh(tmp_path):
+def test_a_timestamp_within_skew_still_starts_when_no_monitor(tmp_path):
     proc, calls = _run_payload(tmp_path, {"ts": time.time() + 10})
     assert proc.returncode == 0
-    assert "monitor start" not in calls
+    assert "monitor start" in calls
 
 
 def test_a_fresh_heartbeat_with_a_dead_pid_starts(tmp_path):
@@ -120,12 +122,8 @@ def test_a_fresh_heartbeat_with_a_dead_pid_starts(tmp_path):
     assert "monitor start" in calls
 
 
-def test_a_fresh_heartbeat_with_a_live_pid_skips(tmp_path):
-    """A live channel-server process still suppresses the start.
-
-    Where /proc is missing the command line cannot be checked, so any live pid
-    still counts, which is what this host can see.
-    """
+def test_a_fresh_heartbeat_with_a_live_reader_pid_still_starts(tmp_path):
+    """A live channel-serve pid is the reader. It does not stand in for the monitor."""
     child = None
     if os.path.isdir("/proc/self"):
         child = subprocess.Popen(
@@ -140,7 +138,40 @@ def test_a_fresh_heartbeat_with_a_live_pid_skips(tmp_path):
             child.kill()
             child.wait(timeout=5)
     assert proc.returncode == 0
+    assert "monitor start" in calls
+
+
+def test_fresh_heartbeat_and_a_live_monitor_starts_nothing(tmp_path):
+    """Status 0 is the writer. A fresh heartbeat beside it must not start a second one."""
+    bindir = tmp_path / "bin"
+    bindir.mkdir()
+    shim = bindir / "swarph"
+    shim.write_text(
+        "#!/usr/bin/env bash\n"
+        "printf '%s\\n' \"$*\" >> \"$FAKE_LOG\"\n"
+        "case \"$*\" in\n"
+        "  *'monitor status'*) exit 0 ;;\n"
+        "  *) exit 2 ;;\n"
+        "esac\n",
+        encoding="utf-8",
+    )
+    shim.chmod(0o755)
+    log = tmp_path / "calls.log"
+    side = tmp_path / "state" / "mesh-sidecar"
+    side.mkdir(parents=True)
+    (side / "channel_heartbeat.json").write_text(
+        json.dumps({"ts": time.time()}), encoding="utf-8")
+    env = dict(os.environ)
+    env["PATH"] = f"{bindir}{os.pathsep}{env.get('PATH', '')}"
+    env["SWARPH_SELF"] = "cursor-lin"
+    env["SWARPH_STATE_DIR"] = str(tmp_path / "state")
+    env["FAKE_LOG"] = str(log)
+    proc = subprocess.run(
+        [_bash(), str(SCRIPT)], env=env, capture_output=True, text=True, timeout=60)
+    calls = log.read_text(encoding="utf-8") if log.exists() else ""
+    assert proc.returncode == 0
     assert "monitor start" not in calls
+    assert "monitor status" in calls
 
 
 def test_pid_zero_starts(tmp_path):