swarph-cli 0.72.22__tar.gz → 0.72.24__tar.gz

{swarph_cli-0.72.22/src/swarph_cli.egg-info → swarph_cli-0.72.24}/PKG-INFO

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

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

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

{swarph_cli-0.72.22 → swarph_cli-0.72.24}/src/swarph_cli/orphan_daemons.py

@@ -48,6 +48,9 @@ class DaemonReport:
     rss_kb: int = 0
     reason: str = ""
     self_excluded: bool = False
+    # Scan-time /proc starttime (clock ticks). Reap compares this, not a
+    # snapshot taken at signal time, so a pid recycled after the scan is skipped.
+    starttime: Optional[int] = None
 
 
 @dataclass
@@ -413,6 +416,7 @@ def scan_orphan_daemons(
                 rss_kb=rss,
                 reason=reason,
                 self_excluded=related,
+                starttime=read_starttime(pid, proc_root=proc_root),
             )
         )
     return result
@@ -573,15 +577,45 @@ def reap_orphans(
     poll_s: float = _DEFAULT_REAP_POLL_S,
     sleeper: Callable[[float], None] = time.sleep,
 ) -> list[SignalReport]:
-    """Signal only ORPHANED daemons and their trees. LIVE/UNKNOWN untouched."""
+    """Signal only ORPHANED daemons and their trees. LIVE/UNKNOWN untouched.
+
+    The daemon is re-verified against the identity the scan classified
+    (starttime, cmdline, scope on DaemonReport). A mismatch means the pid
+    was recycled after the scan: skip it and do not walk the reap-time
+    child tree. A child is signalled only when its ppid chain reaches that
+    verified daemon.
+    """
     reports: list[SignalReport] = []
     seen: set[int] = set()
     for daemon in result.orphans:
+        if daemon.pid in seen:
+            continue
+        scan_ident = ProcIdentity(
+            pid=daemon.pid,
+            starttime=daemon.starttime,
+            cmdline=daemon.cmdline,
+            scope=daemon.scope,
+        )
+        if not identities_match(
+            scan_ident, snapshot_identity(daemon.pid, proc_root=proc_root),
+        ):
+            seen.add(daemon.pid)
+            reports.append(SignalReport(
+                daemon.pid, "skipped",
+                "scan identity mismatch (starttime/cmdline/scope) — pid recycle, not killed",
+            ))
+            continue
         for pid in reap_order(daemon.pid, proc_root=proc_root):
             if pid in seen:
                 continue
             seen.add(pid)
-            ident = snapshot_identity(pid, proc_root=proc_root)
+            if pid != daemon.pid and daemon.pid not in ancestry_pids(pid, proc_root=proc_root):
+                reports.append(SignalReport(
+                    pid, "skipped",
+                    "ppid chain does not reach the verified daemon",
+                ))
+                continue
+            ident = scan_ident if pid == daemon.pid else snapshot_identity(pid, proc_root=proc_root)
             if ident is None:
                 reports.append(SignalReport(pid, "already-gone", "gone before snapshot"))
                 continue

{swarph_cli-0.72.22 → swarph_cli-0.72.24/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.22
+Version: 0.72.24
 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.22 → swarph_cli-0.72.24}/tests/test_1206_offer_question.py

@@ -260,3 +260,56 @@ def test_2094_still_renders_extend_flip_kill():
     assert [o["text"] for o in opts] == ["extend", "flip", "kill"]
     assert [o["label"] for o in opts] == ["Extend", "Flip", "Kill"]
     assert all(o["outcome"] == "pass" for o in opts)
+
+
+# Card note 74612, row #2140. Each option is 3-4 words and <= 24 characters.
+TITLE_2140 = (
+    "Plan-review is the missing step in 23 of 26 blocked moves. "
+    "Keep it mandatory, make it optional, or allow a per-card waiver?"
+)
+
+
+def test_2140_medium_phrases_render_three_taps():
+    pub = _load()
+    accept = "[commander] " + TITLE_2140 + " | PASS=the commander picks one"
+    rows = pub.commander_rows([_row(2140, accept)])
+    assert rows[0]["title"] == TITLE_2140
+    opts = pub.build_board._questions(rows)[0]["options"]
+    assert [o["text"] for o in opts] == [
+        "Keep it mandatory",
+        "make it optional",
+        "allow a per-card waiver",
+    ]
+    assert [o["label"] for o in opts] == [
+        "Keep it mandatory",
+        "Make it optional",
+        "Allow a per-card waiver",
+    ]
+    assert all(o["outcome"] == "pass" for o in opts)
+
+
+def test_three_part_stem_stays_display_only():
+    """'hold it' and 'kill it' are two words, so this stem is not a choice list."""
+    pub = _load()
+    accept = "[commander] Should we ship it, hold it, or kill it? | PASS=the commander picks one"
+    rows = pub.commander_rows([_row(3, accept)])
+    _assert_display_only(pub.build_board._questions(rows)[0]["options"])
+
+
+# Review #2144. The long branch turns these stems into taps at 0a7bc65.
+STEMS_2144 = (
+    "Should we ship the release, hold the release, or kill the release?",
+    "Should we keep it mandatory, make it optional, or allow a waiver?",
+)
+
+
+def test_2144_stem_titles_stay_display_only():
+    pub = _load()
+    for title in STEMS_2144:
+        accept = "[commander] " + title + " | PASS=the commander picks one"
+        rows = pub.commander_rows([_row(2144, accept)])
+        assert rows[0]["title"] == title
+        opts = pub.build_board._questions(rows)[0]["options"]
+        assert opts[0]["label"] == "Answer on the card", title
+        assert all(o["outcome"] is None for o in opts), title
+        assert [o["text"] for o in opts] != ["yes", "no"]

{swarph_cli-0.72.22 → swarph_cli-0.72.24}/tests/test_orphan_daemons.py

@@ -262,6 +262,55 @@ def test_identity_change_is_skipped_not_killed(tmp_path):
     assert killed == []
 
 
+def test_recycled_pid_between_scan_and_reap_is_skipped(tmp_path):
+    """A pid recycled after the scan must not be signalled, nor its new children.
+
+    The scan classifies 5000 ORPHANED. Before reap, that pid is replaced by
+    sshd with a new starttime. reap_orphans must skip and send no signal.
+    """
+    scope = "tmux-spawn-dead.scope"
+    orphan_cmd = (
+        "/home/u/.local/bin/claude daemon run --origin transient "
+        f"--spawned-by {json.dumps({'label': 'claude', 'pid': 700337})}"
+    )
+    _write_proc(
+        tmp_path, 5000, cmdline=orphan_cmd, ppid=1,
+        cgroup=f"0::/user.slice/{scope}",
+    )
+
+    def fake_run(cmd, **kwargs):
+        if cmd[:2] == ["tmux", "list-sessions"]:
+            return SimpleNamespace(returncode=0, stdout="lab-ovh\n", stderr="")
+        if cmd[:2] == ["tmux", "list-panes"]:
+            return SimpleNamespace(returncode=0, stdout="42\n", stderr="")
+        return SimpleNamespace(returncode=1, stdout="", stderr="")
+
+    result = scan_orphan_daemons(
+        proc_root=tmp_path, caller_pid=99999, run=fake_run,
+    )
+    assert len(result.orphans) == 1
+    assert result.orphans[0].pid == 5000
+
+    # Recycle the daemon pid. New starttime sits at stat field 22 (after[19]).
+    import shutil
+    shutil.rmtree(tmp_path / "5000")
+    _write_proc(tmp_path, 5000, cmdline="/usr/sbin/sshd -D", ppid=1)
+    (tmp_path / "5000" / "stat").write_text(
+        "5000 (sshd) S 1 " + ("0 " * 17) + "99\n"
+    )
+    _write_proc(tmp_path, 5001, cmdline="sshd: child", ppid=5000)
+
+    killed = []
+    reports = reap_orphans(
+        result, proc_root=tmp_path,
+        kill=lambda pid, sig: killed.append((pid, sig)),
+        wait_s=0.01, poll_s=0.001, sleeper=lambda _s: None,
+    )
+    assert killed == []
+    assert any(r.pid == 5000 and r.action == "skipped" for r in reports)
+    assert all(r.pid != 5001 for r in reports)
+
+
 def test_reap_reports_every_pid_and_never_touches_live(tmp_path):
     """A4: every signalled pid is named. LIVE is not in the reap list."""
     import json