swarph-cli 0.72.37__tar.gz → 0.72.39__tar.gz

{swarph_cli-0.72.37/src/swarph_cli.egg-info → swarph_cli-0.72.39}/PKG-INFO

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

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

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

{swarph_cli-0.72.37 → swarph_cli-0.72.39}/src/swarph_cli/commands/board.py

@@ -1299,6 +1299,15 @@ def _build_parser() -> argparse.ArgumentParser:
     ow.add_argument("--reason", required=True,
                     help="why the row is withdrawn; whitespace is refused")
     ow.add_argument("--json", action="store_true"); _add_common(ow)
+    orel = obl.add_parser(
+        "release",
+        help="RELEASE a taken row back to offered (creator, orchestrator, "
+             "project owner, or the commander's SSO session). Clears the "
+             "holder and the clock. Writes no outcome. A closed row is refused")
+    orel.add_argument("id", type=int, help="the obligation id")
+    orel.add_argument("--reason", required=True,
+                      help="why the row is released; whitespace is refused")
+    orel.add_argument("--json", action="store_true"); _add_common(orel)
     cost = top.add_parser(
         "cost",
         help="tokens by job, the perfect-run rate, and cost per accepted outcome")
@@ -1457,6 +1466,21 @@ def run_board(argv: list[str]) -> int:
                 f"{_s(x.get('closed_by', self_name))}"
                 + (f" task {_s(x.get('task'))}" if x.get("task") else "")
             ), aj)
+        if args.command == "release":
+            reason = args.reason
+            if not reason.strip():
+                print("swarph board obligations release: --reason is "
+                      "whitespace-only", file=sys.stderr)
+                return 2
+            reason = redact_text(reason, opt_out=getattr(args, "no_redact", False), caller="board.obligations")
+            st, d = _post_json(
+                f"{gw}/board/obligations/{args.id}/release",
+                {"reason": reason}, token)
+            return _out(st, d, lambda x: (
+                f"obligation #{_s(x.get('id', args.id))} RELEASED "
+                f"state={_s(x.get('state', 'offered'))} "
+                f"holder={_s(x.get('holder'))}"
+            ), aj)
 
     if args.group == "cards":
         if args.command == "list":

{swarph_cli-0.72.37 → swarph_cli-0.72.39}/src/swarph_cli/duplicate_session.py

@@ -60,6 +60,8 @@ CARD = 513
 CHECK_EVERY = 4
 _OTHER = "drop-on-meta-edge"  # lab-ovh's own alert goes to the other orchestrator
 _PREFIX = f"DUPLICATE-SESSION card #{CARD}"
+_PROC_ROOT: "str | os.PathLike | None" = "/proc"
+_USE_DEFAULT_PROC = object()
 _instance_id: "str | None" = None
 
 
@@ -136,10 +138,32 @@ CLAIM_INTERVAL = 90
 
 
 def _is_desktop_daemon(parts: list[str]) -> bool:
-    for part in parts:
-        base = os.path.basename(str(part))
-        if base in {"swarph-desktop", "swarph_desktop"} or str(part).endswith("swarph_desktop"):
-            return True
+    """True iff argv[0..2] is the swarph-desktop daemon entry point:
+    - argv[0] has basename swarph-desktop or swarph_desktop, OR
+    - argv[0] is a python interpreter and:
+      * argv[1:3] is `-m swarph_desktop` (or `-m swarph-desktop` / `swarph_desktop.*`), or
+      * argv[1] is a path ending in `swarph-desktop` / `swarph_desktop` or the
+        `run-desktop*.py` launcher (`ExecStart=/home/ubuntu/swarph-desktop/venv/bin/python run-desktop-8766.py`).
+    Never scans later argv tokens, so a command that merely mentions or quotes
+    swarph-desktop in flags or positional arguments is never counted."""
+    if not parts or not parts[0]:
+        return False
+    b0 = os.path.basename(str(parts[0]))
+    if b0 in {"swarph-desktop", "swarph_desktop"}:
+        return True
+    if not b0.startswith("python") or len(parts) < 2 or not parts[1]:
+        return False
+    p1 = str(parts[1])
+    b1 = os.path.basename(p1)
+    if p1 == "-m":
+        if len(parts) < 3 or not parts[2]:
+            return False
+        mod = str(parts[2]).split(".")[0]
+        return mod in {"swarph_desktop", "swarph-desktop"}
+    if b1 in {"swarph-desktop", "swarph_desktop"} or p1.endswith(("swarph-desktop", "swarph_desktop")):
+        return True
+    if b1.startswith("run-desktop") and b1.endswith(".py"):
+        return True
     return False
 
 
@@ -211,17 +235,55 @@ def duplicate_session_pids(entries, cell: str, my_pid: int) -> list[int]:
     return sorted(found)
 
 
-def ps_entries() -> list[tuple[int, list[str]]]:
-    """(pid, argv) for every process on the box, via `ps -eo pid,args`. [] on any
-    error — an enumeration that cannot run is not a duplicate, and must never
-    raise into the monitor loop."""
+def _proc_entries(proc_root: "str | os.PathLike | None") -> "list[tuple[int, list[str]]] | None":
+    """Read (pid, argv) from `<proc_root>/<pid>/cmdline` (NUL-separated).
+    Returns None when `proc_root` is None or not a readable directory so
+    `ps_entries` falls back to `ps -eo pid,args`."""
+    if proc_root is None or not os.path.isdir(proc_root):
+        return None
+    try:
+        names = os.listdir(proc_root)
+    except OSError:
+        return None
+    entries: list[tuple[int, list[str]]] = []
+    for name in names:
+        if not name.isdigit():
+            continue
+        cmd_path = os.path.join(proc_root, name, "cmdline")
+        try:
+            with open(cmd_path, "rb") as f:
+                raw = f.read()
+        except OSError:
+            continue
+        raw = raw.rstrip(b"\x00")
+        if not raw:
+            continue
+        argv = [tok.decode("utf-8", errors="replace") for tok in raw.split(b"\x00")]
+        entries.append((int(name), argv))
+    return entries
+
+
+def ps_entries(proc_root: "str | os.PathLike | None" = _USE_DEFAULT_PROC) -> list[tuple[int, list[str]]]:
+    """(pid, argv) for every process on the box.
+
+    On Linux, reads true NUL-separated argv from `/proc/<pid>/cmdline`
+    because `/proc` is a readable directory (`_proc_entries`), so words
+    inside one quoted argument are never split into whitespace tokens.
+
+    Falls back to `ps -eo pid,args` when `/proc` is not a readable directory
+    or when a caller/test passes `proc_root=None` (or monkeypatches
+    `_PROC_ROOT = None` / `_proc_entries`). Returns [] on any error."""
+    root = _PROC_ROOT if proc_root is _USE_DEFAULT_PROC else proc_root
+    from_proc = _proc_entries(root)
+    if from_proc is not None:
+        return from_proc
     try:
         proc = subprocess.run(
             ["ps", "-eo", "pid,args"], capture_output=True, text=True,
             encoding="utf-8", errors="replace", timeout=10)
     except (OSError, subprocess.SubprocessError):
         return []
-    entries: list[tuple[int, list[str]]] = []
+    entries = []
     for line in proc.stdout.splitlines()[1:]:
         line = line.strip()
         if not line:

{swarph_cli-0.72.37 → swarph_cli-0.72.39/src/swarph_cli.egg-info}/PKG-INFO

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

@@ -269,6 +269,8 @@ tests/test_132_ensure_monitor_state_dir.py
 tests/test_1340_router_rollout.py
 tests/test_1346_shell_string_gh.py
 tests/test_1347_shell_depth_cap.py
+tests/test_1353_obligation_release_cli.py
+tests/test_1385_duplicate_session_argv.py
 tests/test_138_memory_navigate.py
 tests/test_139_tool_probe.py
 tests/test_183_card_anchor.py

swarph_cli-0.72.39/tests/test_1353_obligation_release_cli.py

@@ -0,0 +1,14 @@
+"""card #1353 — swarph board obligations release."""
+from swarph_cli.commands import board
+
+
+def test_release_is_a_command():
+    try:
+        args = board._build_parser().parse_args(
+            ["obligations", "release", "3293", "--reason", "the laptop was shut down"])
+    except SystemExit:
+        args = None
+    assert getattr(args, "group", None) == "obligations"
+    assert getattr(args, "command", None) == "release"
+    assert getattr(args, "id", None) == 3293
+    assert getattr(args, "reason", None) == "the laptop was shut down"

swarph_cli-0.72.39/tests/test_1385_duplicate_session_argv.py

@@ -0,0 +1,188 @@
+"""Card #1385 (Obligation #3604) — duplicate_session argv-position fix.
+
+Ensures duplicate_session.is_session_for() counts the desktop daemon ONLY by
+argv POSITION (argv[0] basename swarph-desktop or python argv[0] + argv[1..2] entry point),
+matching how _is_swarph_argv() treats swarph residents.
+
+ps_entries() reads true NUL-separated argv from /proc/<pid>/cmdline so that
+words inside one quoted argument (e.g. `--accept "PASS = ... swarph-desktop ..."`)
+are never split into whitespace tokens.
+"""
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+
+import pytest
+import swarph_cli.duplicate_session as ds
+
+
+def test_bash_command_quoting_swarph_desktop_is_not_a_session():
+    """Test (a): ["/bin/bash", "-c", "gh pr view 34 -R BrainSurfing-tech/swarph-desktop ...; swarph board obligations amend 3597 --as lab-ovh ..."]
+    is NOT a session for lab-ovh."""
+    argv_a = [
+        "/bin/bash",
+        "-c",
+        "gh pr view 34 -R BrainSurfing-tech/swarph-desktop ...; swarph board obligations amend 3597 --as lab-ovh ...",
+    ]
+    assert not ds.is_session_for(argv_a, "lab-ovh")
+    assert ds.duplicate_session_pids([(1754451, argv_a)], "lab-ovh", my_pid=100) == []
+
+    # Even if whitespace-split, it must STILL not be counted as a session
+    argv_a_split = " ".join(argv_a).split()
+    assert not ds.is_session_for(argv_a_split, "lab-ovh")
+    assert ds.duplicate_session_pids([(1754451, argv_a_split)], "lab-ovh", my_pid=100) == []
+
+
+def test_board_cards_ask_mentioning_swarph_desktop_is_not_a_session():
+    """Test (b): ["swarph", "board", "cards", "ask", "1380", "--accept", "PASS = ... swarph-desktop PR 32 ...", "--as", "lab-ovh"]
+    is NOT a session for lab-ovh."""
+    argv_b = [
+        "swarph",
+        "board",
+        "cards",
+        "ask",
+        "1380",
+        "--accept",
+        "PASS = ... swarph-desktop PR 32 ...",
+        "--as",
+        "lab-ovh",
+    ]
+    assert not ds.is_session_for(argv_b, "lab-ovh")
+    assert ds.duplicate_session_pids([(1833816, argv_b)], "lab-ovh", my_pid=100) == []
+
+    # Even if whitespace-split, it must STILL not be counted as a session
+    argv_b_split = " ".join(argv_b).split()
+    assert not ds.is_session_for(argv_b_split, "lab-ovh")
+    assert ds.duplicate_session_pids([(1833816, argv_b_split)], "lab-ovh", my_pid=100) == []
+
+
+def test_synthetic_desktop_launcher_argv_with_as_appended_is_a_session():
+    """Test (c): SYNTHETIC launcher argv with --as appended. The live daemon on lab-ovh runs ["/home/ubuntu/swarph-desktop/venv/bin/python", "run-desktop-8766.py"] with no --as; appending --as lab-ovh is a synthetic launcher argv that counts as a session for lab-ovh."""
+    # Live daemon argv on lab-ovh with no --as is NOT a session for lab-ovh
+    assert not ds.is_session_for(
+        ["/home/ubuntu/swarph-desktop/venv/bin/python", "run-desktop-8766.py"],
+        "lab-ovh",
+    )
+
+    argv_c = [
+        "/home/ubuntu/swarph-desktop/venv/bin/python",
+        "run-desktop-8766.py",
+        "--as",
+        "lab-ovh",
+    ]
+    assert ds.is_session_for(argv_c, "lab-ovh")
+    assert not ds.is_session_for(argv_c, "other-cell")
+    assert ds.duplicate_session_pids([(1800578, argv_c)], "lab-ovh", my_pid=100) == [1800578]
+    assert ds.duplicate_session_pids([(1800578, argv_c)], "other-cell", my_pid=100) == []
+
+    # Other valid desktop daemon entrypoint forms
+    valid_forms = [
+        ["swarph-desktop", "--as", "lab-ovh"],
+        ["/home/ubuntu/swarph-desktop/venv/bin/swarph-desktop", "--as", "lab-ovh"],
+        ["python3", "-m", "swarph_desktop", "--as", "lab-ovh"],
+        ["/home/ubuntu/swarph-desktop/venv/bin/python", "-m", "swarph_desktop", "--as", "lab-ovh"],
+        ["python3", "/opt/swarph/swarph-desktop", "--as", "lab-ovh"],
+        ["python3", "/opt/swarph/swarph_desktop", "--as", "lab-ovh"],
+        ["/usr/bin/python3", "/home/ubuntu/swarph-desktop/run-desktop-8766.py", "--as", "lab-ovh"],
+    ]
+    for form in valid_forms:
+        assert ds.is_session_for(form, "lab-ovh"), f"Failed for {form}"
+        assert not ds.is_session_for(form, "other-cell"), f"Unexpected match for {form}"
+
+
+def test_swarph_monitor_start_is_a_session():
+    """Test (d): swarph monitor start --as lab-ovh still IS a session."""
+    argv_d = ["swarph", "monitor", "start", "--as", "lab-ovh"]
+    assert ds.is_session_for(argv_d, "lab-ovh")
+    assert not ds.is_session_for(argv_d, "other-cell")
+    assert ds.duplicate_session_pids([(200, argv_d)], "lab-ovh", my_pid=100) == [200]
+    assert ds.duplicate_session_pids([(200, argv_d)], "other-cell", my_pid=100) == []
+
+
+def test_ps_entries_proc_cmdline_nul_split(tmp_path, monkeypatch):
+    """Test reading true NUL-separated argv from /proc/<pid>/cmdline via synthetic proc_root."""
+    # (a) bash command
+    p_a = tmp_path / "1754451"
+    p_a.mkdir()
+    argv_a = [
+        "/bin/bash",
+        "-c",
+        "gh pr view 34 -R BrainSurfing-tech/swarph-desktop ...; swarph board obligations amend 3597 --as lab-ovh ...",
+    ]
+    (p_a / "cmdline").write_bytes(b"\x00".join(tok.encode("utf-8") for tok in argv_a) + b"\x00")
+
+    # (b) swarph board cards ask
+    p_b = tmp_path / "1833816"
+    p_b.mkdir()
+    argv_b = [
+        "swarph",
+        "board",
+        "cards",
+        "ask",
+        "1380",
+        "--accept",
+        "PASS = ... swarph-desktop PR 32 ...",
+        "--as",
+        "lab-ovh",
+    ]
+    (p_b / "cmdline").write_bytes(b"\x00".join(tok.encode("utf-8") for tok in argv_b) + b"\x00")
+
+    # (c) synthetic desktop launcher argv with --as appended
+    p_c = tmp_path / "1800578"
+    p_c.mkdir()
+    argv_c = [
+        "/home/ubuntu/swarph-desktop/venv/bin/python",
+        "run-desktop-8766.py",
+        "--as",
+        "lab-ovh",
+    ]
+    (p_c / "cmdline").write_bytes(b"\x00".join(tok.encode("utf-8") for tok in argv_c) + b"\x00")
+
+    # Non-digit dir and empty cmdline (kernel thread) to verify edge cases
+    (tmp_path / "self").mkdir()
+    p_kthread = tmp_path / "2"
+    p_kthread.mkdir()
+    (p_kthread / "cmdline").write_bytes(b"")
+
+    # 1. Call via explicit proc_root parameter
+    entries = ds.ps_entries(proc_root=tmp_path)
+    by_pid = dict(entries)
+    assert 1833816 in by_pid
+    assert by_pid[1833816] == argv_b
+    assert "PASS = ... swarph-desktop PR 32 ..." in by_pid[1833816]
+    assert 2 not in by_pid  # empty cmdline skipped
+    assert ds.duplicate_session_pids(entries, "lab-ovh", my_pid=100) == [1800578]
+
+    # 2. Call via monkeypatched _PROC_ROOT
+    monkeypatch.setattr(ds, "_PROC_ROOT", str(tmp_path))
+    entries_mp = ds.ps_entries()
+    assert ds.duplicate_session_pids(entries_mp, "lab-ovh", my_pid=100) == [1800578]
+
+
+def test_live_proc_preserves_quoted_args():
+    """Test against live /proc on Linux with a spawned subprocess."""
+    if not os.path.isdir("/proc"):
+        pytest.skip("/proc not available on this platform")
+
+    quoted_arg = "PASS = ... swarph-desktop PR 32 ..."
+    proc = subprocess.Popen([
+        sys.executable,
+        "-c",
+        "import time; time.sleep(10)",
+        "--accept",
+        quoted_arg,
+        "--as",
+        "lab-ovh",
+    ])
+    try:
+        entries = ds.ps_entries()
+        match = [argv for pid, argv in entries if pid == proc.pid]
+        assert match, f"Process {proc.pid} not found in ps_entries"
+        found_argv = match[0]
+        assert quoted_arg in found_argv, f"Quoted argument was split: {found_argv}"
+        assert not ds.is_session_for(found_argv, "lab-ovh")
+    finally:
+        proc.terminate()
+        proc.wait(timeout=5)

{swarph_cli-0.72.37 → swarph_cli-0.72.39}/tests/test_513_duplicate_session.py

@@ -81,6 +81,7 @@ def test_ps_output_is_parsed_into_pid_argv(monkeypatch):
     class _P:
         stdout = out
 
+    monkeypatch.setattr(ds, "_PROC_ROOT", None)
     monkeypatch.setattr(ds.subprocess, "run", lambda *a, **k: _P())
     entries = ds.ps_entries()
     assert (100, ["swarph", "monitor", "start", "--as", "opencode"]) in entries