swarph-cli 0.69.4__tar.gz → 0.69.6__tar.gz

{swarph_cli-0.69.4/src/swarph_cli.egg-info → swarph_cli-0.69.6}/PKG-INFO

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

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

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

{swarph_cli-0.69.4 → swarph_cli-0.69.6}/src/swarph_cli/commands/daemon.py

@@ -381,8 +381,12 @@ def _legacy_attempt_delivery_removed(state: DaemonState) -> None:
         entries = state.queue.pending()
         block = _render_delivery_block(entries)
         if session_bridge.inject(pane, block):
+            stalled = state.queue.deferred_ticks
             state.queue.remove({e["id"] for e in entries})
             state.queue.reset_deferred()
+            if stalled:
+                stall_alert.clear_stall_alert(
+                    state.gateway, state.token, state.self_name)
         # inject failure → leave queued, retry next tick (no counter bump —
         # the cell was idle; a send failure is transient, not a stall).
     except Exception as exc:  # noqa: BLE001 — bridge must never crash the loop

{swarph_cli-0.69.4 → swarph_cli-0.69.6}/src/swarph_cli/commands/mcp_server.py

@@ -344,14 +344,15 @@ def _dm_reply(message_id: int, text: str, kind: str = "answer",
         st, d = _mesh._post_json(f"{gw}/messages", body, tok)
         if not (200 <= st < 300):
             return {"error": f"gateway {st}: {d.get('detail', d) if isinstance(d, dict) else d}"}
-        ack_st, _ = _mesh._post_json(f"{gw}/messages/{int(message_id)}/read", {}, tok)
+        failed = _mesh._mark_read(gw, tok, [{"id": int(message_id)}])
+        acked = int(message_id) not in failed
         return {
             "id": d.get("id"),
             "to_node": to,
             "kind": kind,
             "thread_id": d.get("thread_id"),
-            "acked": int(message_id) if 200 <= ack_st < 300 else None,
-            "ack_status": ack_st,
+            "acked": int(message_id) if acked else None,
+            "ack_status": 200 if acked else 0,
             "closed_obligations": d.get("closed_obligations") or [],
         }
     except Exception as exc:

{swarph_cli-0.69.4 → swarph_cli-0.69.6}/src/swarph_cli/commands/mesh.py

@@ -944,38 +944,58 @@ def _run_reply(args: argparse.Namespace) -> int:
     return 0
 
 
-def _mark_read(gateway: str, token: str, messages: list) -> None:
+_BULK_READ_MAX = 500
+
+
+def _mark_read(gateway: str, token: str, messages: list) -> list:
     """Mark every unread DM we just surfaced as read. Best-effort.
 
-    Reading your inbox consumes it — like any mail client. Without this, a peer's
-    request stays "unread" no matter how many times it is answered, and an agent
-    whose loop asks "is it still unread?" can never exit. That is not theoretical:
-    on 2026-07-10 grok-researcher answered one request 67 times (~410k tokens)
-    because the CLI never called the gateway's POST /messages/{id}/read.
+    One POST /messages/read per 500 ids. The gateway's single worker spends a
+    synchronous sqlite write on every request, so a per-id loop is how a drain
+    turns into HTTP 503. A 404 means that route is not on this gateway yet, and
+    only then does this fall back to one POST per id.
 
     A mark-read failure must NEVER fail the listing — the caller has already seen
     the messages, and losing the read receipt is strictly less bad than losing them.
     """
     base = gateway.rstrip("/")
-    failed = []
+    ids = []
     for dm in messages:
-        if dm.get("read_at"):
-            continue
-        msg_id = dm.get("id")
+        if isinstance(dm, dict):
+            if dm.get("read_at"):
+                continue
+            msg_id = dm.get("id")
+        else:
+            msg_id = dm
         if msg_id is None:
             continue
+        ids.append(msg_id)
+    failed = []
+    for start in range(0, len(ids), _BULK_READ_MAX):
+        chunk = ids[start:start + _BULK_READ_MAX]
         try:
-            status, _ = _post_json(f"{base}/messages/{msg_id}/read", {}, token)
-            if status < 200 or status >= 300:
-                failed.append(msg_id)
+            status, _ = _post_json(f"{base}/messages/read", {"ids": chunk}, token)
         except Exception:  # network, DNS, timeout — never break the listing
-            failed.append(msg_id)
+            failed.extend(chunk)
+            continue
+        if status == 404:
+            for msg_id in chunk:
+                try:
+                    one, _ = _post_json(f"{base}/messages/{msg_id}/read", {}, token)
+                    if one < 200 or one >= 300:
+                        failed.append(msg_id)
+                except Exception:
+                    failed.append(msg_id)
+            continue
+        if status < 200 or status >= 300:
+            failed.extend(chunk)
     if failed:
         print(
             f"swarph mesh inbox: mark-read failed for id(s) {failed} "
             "(messages shown above; they will be re-listed as unread)",
             file=sys.stderr,
         )
+    return failed
 
 
 def _run_inbox(args: argparse.Namespace) -> int:
@@ -1461,6 +1481,18 @@ class TmuxSink(Sink):
 
     def deliver(self, state: "MonitorState", dms: list, up_to_id: int) -> Optional[bool]:
         led = state.ledger(self.name)
+        # #723: a rate-limit or usage-limit screen is not deliverable. An
+        # empty composer beside "Retry failed: rate limit" used to inject
+        # again, and the 1.0.44 upgrade modal (no Grok footer) used to
+        # return False and log DELIVERY FAILED. Defer with a named reason
+        # and send nothing.
+        pane = _capture_pane_lines(self.target)
+        if pane:
+            reason = _grok_block_reason(pane)
+            if reason:
+                print(f"[monitor] {self.name}: {reason} — deferring, zero keys",
+                      flush=True)
+                return None
         # #620: a wake's job is done the moment a TURN is observed running —
         # the cell is awake, whoever woke it (our injected wake fired, or
         # the human typed). Both older clearing paths miss the zombie
@@ -1477,7 +1509,7 @@ class TmuxSink(Sink):
             # Opencode keeps the finished ▣ header on screen, so a deferral
             # during the turn must not clear the flag: the next idle poll
             # still owes a wake. Cursor's #620 clear stays.
-            if _opencode_in_progress(self.target):
+            if _opencode_in_progress(self.target) or _grok_in_progress(self.target):
                 return None
             led["wake_outstanding"] = False
         if led.get("wake_outstanding"):
@@ -1504,7 +1536,8 @@ class TmuxSink(Sink):
                     # A finished opencode turn leaves a ▣ header with a
                     # trailing duration and a clear box. The standing-wake
                     # claim would swallow every later DM. Inject again.
-                    if _opencode_turn_finished_target(self.target):
+                    if (_opencode_turn_finished_target(self.target)
+                            or _grok_turn_finished_target(self.target)):
                         ok = _tmux_wake(self.target)
                         if ok:
                             _stamp_wake(led)
@@ -2000,6 +2033,9 @@ _WAKE_PROMPT = "check mesh"
 # not shown. Longer than _WAKE_PROMPT, so wake-text detection strips this
 # one first.
 _OPENCODE_WAKE_PROMPT = "check mesh: swarph_dm_unread"
+# Grok's TUI has the same shape (#715, grok 1.0.41): no push channel, so
+# the wake is one line naming the pull tool and no DM body.
+_GROK_WAKE_PROMPT = "check mesh: swarph_dm_unread"
 # A finished turn keeps its ▣ header and adds a duration.
 # Short turns read `· 3.3s` (drop-on-meta-edge, 1.18.33, card #961 post
 # 54557). A longer idle turn reads `· 3m 4s` (opencode pane, 2026-09-29
@@ -2110,7 +2146,7 @@ def _only_wake_text(content: str) -> bool:
     human's line.
     """
     rest = content
-    for prompt in (_OPENCODE_WAKE_PROMPT, _WAKE_PROMPT):
+    for prompt in (_GROK_WAKE_PROMPT, _OPENCODE_WAKE_PROMPT, _WAKE_PROMPT):
         rest = rest.replace(prompt, "")
     return rest.strip() == ""
 
@@ -2245,6 +2281,110 @@ def _opencode_composer_state(lines: list[str]) -> Optional[str]:
     return "busy"
 
 
+def _is_grok_pane(lines: list[str]) -> bool:
+    """Grok Build composer, measured on sacrificial 1.0.41 and 0.2.51 TUIs.
+
+    The footer names ``Grok 4.`` inside the box, or the splash prints
+    ``Grok Build``. History also draws a ``❯`` for the submitted prompt;
+    that row has no box bar, so it is not the composer. A usage-limit
+    modal drops both of those and is recognized by ``_grok_block_reason``.
+    """
+    return any("Grok 4." in ln or ln.strip().startswith("Grok Build") for ln in lines)
+
+
+def _grok_input(lines: list[str]) -> Optional[str]:
+    """Text in the live ``│ ❯`` box, '' when empty, None if no box."""
+    row = None
+    for ln in lines:
+        if "❯" in ln and "│" in ln:
+            row = ln
+    if row is None:
+        return None
+    after = row.split("❯", 1)[1]
+    if "│" in after:
+        after = after.split("│", 1)[0]
+    return after.strip()
+
+
+def _grok_block_reason(lines: list[str]) -> Optional[str]:
+    """A rate or usage limit is not an idle composer and not a dead pane.
+
+    0.2.51 draws ``Retry failed: You've hit the rate limit for your plan``
+    under an empty ``│ ❯`` box, with no spinner. 1.0.44 draws a ``┃`` modal
+    ``You hit your free usage limit`` and drops the Grok footer entirely.
+    Either screen used to look clear (inject again) or unreadable
+    (DELIVERY FAILED). Return a stable reason token, or None.
+    """
+    blob = "\n".join(lines).lower()
+    if "you hit your free usage limit" in blob:
+        return "grok-usage-limit"
+    if "rate limit" in blob:
+        return "grok-rate-limit"
+    if "usage limit" in blob:
+        return "grok-usage-limit"
+    if "retry failed" in blob:
+        return "grok-retry-failed"
+    return None
+
+
+def _grok_running(lines: list[str]) -> bool:
+    """True only while the turn is in progress.
+
+    1.0.41/1.0.44: ``Waiting for response``. 0.2.51: ``Waiting…`` at the
+    start of the turn, then a tool row whose footer is ``Ctrl+c:cancel``
+    for as long as the turn lasts. ``Worked for`` / ``Thought for`` stay
+    on screen after the turn and must not count as running.
+    """
+    for ln in lines:
+        if "Waiting for response" in ln or "Waiting…" in ln or "Waiting..." in ln:
+            return True
+        if "Ctrl+c:cancel" in ln:
+            return True
+    return False
+
+
+def _grok_turn_finished(lines: list[str]) -> bool:
+    if _grok_running(lines) or _grok_block_reason(lines):
+        return False
+    return any(
+        "Worked for" in ln or "Thought for" in ln or "Turn cancelled" in ln
+        for ln in lines
+    )
+
+
+def _grok_in_progress(target: str) -> bool:
+    lines = _capture_pane_lines(target)
+    if not lines or not _is_grok_pane(lines):
+        return False
+    return _grok_running(lines)
+
+
+def _grok_turn_finished_target(target: str) -> bool:
+    lines = _capture_pane_lines(target)
+    if not lines or not _is_grok_pane(lines):
+        return False
+    return _grok_turn_finished(lines)
+
+
+def _grok_composer_state(lines: list[str]) -> Optional[str]:
+    text = _grok_input(lines)
+    if text is None:
+        return None
+    if not text:
+        return "clear"
+    if _only_wake_text(text):
+        return "wake"
+    return "busy"
+
+
+def _wake_prompt_for(lines: Optional[list[str]]) -> str:
+    if lines and _is_grok_pane(lines):
+        return _GROK_WAKE_PROMPT
+    if lines and _is_opencode_pane(lines):
+        return _OPENCODE_WAKE_PROMPT
+    return _WAKE_PROMPT
+
+
 def _agent_running(target: str) -> Optional[bool]:
     """True while a keystroke would miss the idle composer.
 
@@ -2263,6 +2403,8 @@ def _agent_running(target: str) -> Optional[bool]:
         return None
     if _is_opencode_pane(lines):
         return _opencode_running(lines)
+    if _is_grok_pane(lines):
+        return _grok_running(lines)
     composer = _composer_line(lines)
     if composer is None:
         return None
@@ -2291,6 +2433,8 @@ def _composer_state(target: str) -> Optional[str]:
         return None
     if _is_opencode_pane(lines):
         return _opencode_composer_state(lines)
+    if _is_grok_pane(lines):
+        return _grok_composer_state(lines)
     composer = _composer_line(lines)
     if composer is None:
         return None
@@ -2379,8 +2523,7 @@ def _tmux_wake(target: str) -> Optional[bool]:
     """
     try:
         seen = _capture_pane_lines(target)
-        prompt = (_OPENCODE_WAKE_PROMPT
-                  if seen and _is_opencode_pane(seen) else _WAKE_PROMPT)
+        prompt = _wake_prompt_for(seen)
         subprocess.run(
             ["tmux", "send-keys", "-t", target, "-l", prompt],
             check=True,
@@ -2673,7 +2816,8 @@ def _monitor_deliver(state: MonitorState) -> None:
                       f"no failure counted",
                       flush=True)
                 continue
-            if led.get("deferred_ticks"):
+            was_stalled = bool(led.get("deferred_ticks"))
+            if was_stalled:
                 led["deferred_ticks"] = 0
             if outcome:
                 led["last_delivered_id"] = observed
@@ -2682,6 +2826,10 @@ def _monitor_deliver(state: MonitorState) -> None:
                 state.deliveries[sink.name] = state.deliveries.get(sink.name, 0) + 1
                 print(f"{state.log_prefix} delivered to {sink.name} up to id {observed}",
                       flush=True)
+                if was_stalled:
+                    from swarph_cli import stall_alert
+                    stall_alert.clear_stall_alert(
+                        state.gateway, state.token, state.self_name)
             else:
                 # A dead sink is VISIBLE instead of silently freezing anything.
                 led["consecutive_failures"] = int(led["consecutive_failures"]) + 1

{swarph_cli-0.69.4 → swarph_cli-0.69.6}/src/swarph_cli/scripts/ensure_monitor.sh

@@ -64,12 +64,71 @@ 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
+
 "$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: start it. Idempotent, so a race is harmless.
-     if "$SW" monitor start --as "$SELF" --deliver pull ${SD[@]+"${SD[@]}"} >/tmp/.swarph-monitor-start.$$ 2>&1; then
+  *) # 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
        echo "[monitor] started (--deliver pull)"
      else
        # LOUD, not silent: an auto-start that fails quietly rebuilds the exact

swarph_cli-0.69.6/src/swarph_cli/stall_alert.py

@@ -0,0 +1,144 @@
+"""stall_alert — surface a cell whose live session is perpetually busy so its
+undelivered DMs don't rot silently. Exponential backoff (6,12,24,48…) prevents
+the linear-flood failure (the 145-DM incident, feedback_modal_stalls_cell_wake).
+
+Card #989: the surface is one obligation held by lab-ovh, never a DM to
+commander. A second stall tick while that row is open opens nothing new. A
+drain closes it. Fail-safe: a failed POST never raises and never blocks
+delivery."""
+from __future__ import annotations
+
+import json
+import sys
+import urllib.error
+import urllib.parse
+import urllib.request
+from swarph_cli.console_safe import print_safe
+
+_STALL_FIRST = 6  # first alert after this many consecutive deferred ticks
+_CARD = 989
+_HOLDER = "lab-ovh"
+# lab-ovh's own stall cannot escalate to lab-ovh. Another orchestrator holds it.
+_OTHER = "drop-on-meta-edge"
+_TIMEOUT_HOURS = 24
+_PREFIX = f"STALL card #{_CARD}"
+
+
+def is_alert_tick(deferred_ticks: int) -> bool:
+    """True exactly at 6, 12, 24, 48, 96 … — first at _STALL_FIRST, doubling."""
+    if deferred_ticks < _STALL_FIRST or deferred_ticks % _STALL_FIRST != 0:
+        return False
+    k = deferred_ticks // _STALL_FIRST
+    return (k & (k - 1)) == 0  # k is a power of two
+
+
+def _accept(self_name: str, count: int, pending_n: int) -> str:
+    return (
+        f"{_PREFIX} cell={self_name} ticks={count} pending={pending_n} | "
+        "PASS = the cell drained and this row is closed | "
+        "FAIL = the cell is still unable to deliver"
+    )
+
+
+def _what(self_name: str, count: int, pending_n: int) -> str:
+    return (
+        f"{_PREFIX}\n"
+        f"cell={self_name} ticks={count} pending_dms={pending_n}"
+    )
+
+
+def _open_url(req, timeout):
+    host = urllib.parse.urlparse(req.full_url).hostname
+    if host in {"127.0.0.1", "localhost", "::1"}:
+        return urllib.request.build_opener(
+            urllib.request.ProxyHandler({})).open(req, timeout=timeout)
+    return urllib.request.urlopen(req, timeout=timeout)
+
+
+def _request(method: str, url: str, token: str, payload: dict | None = None) -> dict:
+    data = None if payload is None else json.dumps(payload).encode()
+    req = urllib.request.Request(
+        url, data=data, method=method,
+        headers={"Authorization": f"Bearer {token}",
+                 "Content-Type": "application/json"})
+    with _open_url(req, timeout=10) as resp:
+        raw = resp.read().decode()
+        if not (200 <= resp.status < 300):
+            raise urllib.error.URLError(f"HTTP {resp.status}")
+    return json.loads(raw) if raw else {}
+
+
+def _holder_for(self_name: str) -> str:
+    return _OTHER if self_name == _HOLDER else _HOLDER
+
+
+def _cell_row(row: dict, self_name: str) -> bool:
+    needle = f"cell={self_name} "
+    return needle in (row.get("accept") or "") or needle in (row.get("what") or "")
+
+
+def _live(gateway: str, token: str, self_name: str) -> list[dict]:
+    rows: list[dict] = []
+    for status in ("open", "fallback_fired"):
+        data = _request(
+            "GET",
+            f"{gateway}/board/obligations?card_id={_CARD}&status={status}",
+            token)
+        rows.extend(data.get("obligations") or [])
+    seen = set()
+    live = []
+    for row in rows:
+        if row.get("id") in seen:
+            continue
+        seen.add(row.get("id"))
+        if _cell_row(row, self_name):
+            live.append(row)
+    return live
+
+
+def send_stall_alert(gateway: str, token: str, self_name: str,
+                     count: int, pending_n: int) -> bool:
+    """Open one obligation on card #989 held by lab-ovh. True when that row
+    is open (newly or already). False on any error. Never raises, never
+    DMs commander, and a second call while the row is open opens nothing."""
+    try:
+        gateway = gateway.rstrip("/")
+        if _live(gateway, token, self_name):
+            return True
+        holder = _holder_for(self_name)
+        _request(
+            "POST", f"{gateway}/board/cards/{_CARD}/ask", token,
+            {"holder": holder,
+             "what": _what(self_name, count, pending_n),
+             "created_by": self_name,
+             "kind": "action",
+             "fallback_mode": "escalate",
+             "fallback_target": holder,
+             "timeout_hours": _TIMEOUT_HOURS,
+             "accept": _accept(self_name, count, pending_n)})
+        return True
+    except (urllib.error.URLError, OSError, ValueError, json.JSONDecodeError) as exc:
+        print_safe(f"[swarph-daemon] stall-alert POST failed: {exc}",
+                   file=sys.stderr, flush=True)
+        return False
+
+
+def clear_stall_alert(gateway: str, token: str, self_name: str) -> bool:
+    """Close the open stall row after a drain. True when none remain open.
+    False on any error. Never raises."""
+    evidence = (
+        f"{_PREFIX} cell={self_name} drained. "
+        "The deferred delivery completed, so this row is closed."
+    )
+    try:
+        gateway = gateway.rstrip("/")
+        live = _live(gateway, token, self_name)
+        for row in live:
+            _request(
+                "POST", f"{gateway}/board/obligations/{row['id']}/close", token,
+                {"outcome": "pass", "evidence": evidence})
+        return True
+    except (urllib.error.URLError, OSError, ValueError, json.JSONDecodeError) as exc:
+        print_safe(f"[swarph-daemon] stall-alert close failed: {exc}",
+                   file=sys.stderr, flush=True)
+        return False

{swarph_cli-0.69.4 → swarph_cli-0.69.6/src/swarph_cli.egg-info}/PKG-INFO

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

@@ -219,7 +219,9 @@ tests/test_654_reexec.py
 tests/test_656_owned_slm.py
 tests/test_684_dreaming_verb.py
 tests/test_689_pkg_version_order.py
+tests/test_715_grok_wake.py
 tests/test_716_timeline_one_path.py
+tests/test_723_grok_0251.py
 tests/test_724_ps1_ascii_or_bom.py
 tests/test_725_stdio_reconfigure.py
 tests/test_729_dm_once.py
@@ -250,6 +252,7 @@ tests/test_955_prompt_audit.py
 tests/test_957_auth_http.py
 tests/test_959_venv_interpreter.py
 tests/test_960_channel.py
+tests/test_960_ensure_monitor_heartbeat.py
 tests/test_963_plugin_manifest.py
 tests/test_964_channel_cell.py
 tests/test_965_mesh_wait.py