swarph-cli 0.69.3__tar.gz → 0.69.5__tar.gz

{swarph_cli-0.69.3/src/swarph_cli.egg-info → swarph_cli-0.69.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.69.3
+Version: 0.69.5
 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
@@ -246,6 +246,8 @@ Task types: `numeric` (rel-err), `categorical` (exact), `ranking` (Kendall-tau),
 
 `provider:<name>` reads a TOML registry (`--providers`, else `$SWARPH_BENCH_PROVIDERS`, else `~/.config/swarph/bench_providers.toml`). The file names an env var; it does not hold the key. A worked example is `docs/examples/bench_providers.toml` (Jev, `env = "JEV_API_KEY"`, 0.42 USD per 1M input tokens, output free). `--max-usd` stops the run at the cap. A pack with `egress = "on_box_only"` refuses an external arm unless `--allow-egress <provider>` names it.
 
+`claude-sonnet-5-5:subscription` runs `claude -p` on the Claude subscription when `claude` is on PATH. The argv is fixed: `--max-turns 1`, `--output-format stream-json`, `--strict-mcp-config`, an empty MCP config, `--tools ""`, `--setting-sources ""`. The prompt goes on stdin. The child environment drops `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN`, and every `SWARPH_CHANNEL*` name. A result whose `apiKeySource` is not `none` is `billing:<source>`, is not scored, and aborts the rest of the run on every arm. A usage limit is retried after 60s and then 300s; the arm then stops with `--ledger`, and the next run skips tasks that already completed. It is not scored as an answer.
+
 ### `swarph brain-ask` (v0.14.0)
 
 Search the **swarph-brain** (gbrain) — the swarm's sovereign $0 semantic-retrieval memory — over MCP. The "does the swarm already know X?" reflex, as a one-shot.

{swarph_cli-0.69.3 → swarph_cli-0.69.5}/README.md

@@ -197,6 +197,8 @@ Task types: `numeric` (rel-err), `categorical` (exact), `ranking` (Kendall-tau),
 
 `provider:<name>` reads a TOML registry (`--providers`, else `$SWARPH_BENCH_PROVIDERS`, else `~/.config/swarph/bench_providers.toml`). The file names an env var; it does not hold the key. A worked example is `docs/examples/bench_providers.toml` (Jev, `env = "JEV_API_KEY"`, 0.42 USD per 1M input tokens, output free). `--max-usd` stops the run at the cap. A pack with `egress = "on_box_only"` refuses an external arm unless `--allow-egress <provider>` names it.
 
+`claude-sonnet-5-5:subscription` runs `claude -p` on the Claude subscription when `claude` is on PATH. The argv is fixed: `--max-turns 1`, `--output-format stream-json`, `--strict-mcp-config`, an empty MCP config, `--tools ""`, `--setting-sources ""`. The prompt goes on stdin. The child environment drops `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN`, and every `SWARPH_CHANNEL*` name. A result whose `apiKeySource` is not `none` is `billing:<source>`, is not scored, and aborts the rest of the run on every arm. A usage limit is retried after 60s and then 300s; the arm then stops with `--ledger`, and the next run skips tasks that already completed. It is not scored as an answer.
+
 ### `swarph brain-ask` (v0.14.0)
 
 Search the **swarph-brain** (gbrain) — the swarm's sovereign $0 semantic-retrieval memory — over MCP. The "does the swarm already know X?" reflex, as a one-shot.

{swarph_cli-0.69.3 → swarph_cli-0.69.5}/pyproject.toml

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

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

{swarph_cli-0.69.3 → swarph_cli-0.69.5}/src/swarph_cli/bench/backends.py

@@ -14,11 +14,11 @@ Ships these backends:
   passes ``vertexai=False`` EXPLICITLY — a ``GOOGLE_GENAI_USE_VERTEXAI=true``
   env 401s API-key auth (this exact bug bit the reference lab; see
   ``model_showdown.py::run_metered``).
-- :class:`SubscriptionBackend` — a STUB/interface only. Tokens are always
-  ESTIMATED (``~len(text)/4``, flagged via ``estimated=True``) and it does
-  NOT couple to any specific subscription lane map; a caller wires an actual
-  $0 CLI/OIDC path in by passing ``call_fn``. Not exercised against a live
-  provider anywhere in this package.
+- :class:`SubscriptionBackend` — a stub until a ``call_fn`` is wired. A
+  string return is still ESTIMATED (``~len(text)/4``). A
+  :class:`~swarph_cli.bench.claude_cli.CliResult` uses the CLI's reported
+  usage (``estimated=False``). ``swarph bench`` wires ``claude -p`` when
+  the ``claude`` binary is on PATH.
 - :class:`RuleBackend` — in-process ``rule:<module:callable>``. No credentials.
 - :class:`TypedHttpBackend` — POST to a Jev-compatible ``/v1/systemone``
   (laya-serve). No credentials; per-item latency is the HTTP round trip.
@@ -229,6 +229,15 @@ class MeteredMistralBackend:
         )
 
 
+def normalize_judge_action(text: str) -> str:
+    """BUY or SKIP, after trimming and uppercasing. Anything else is ABSTAIN."""
+    try:
+        action = str(json.loads(text).get("action", "")).strip().upper()
+    except Exception:
+        return "ABSTAIN"
+    return action if action in ("BUY", "SKIP") else "ABSTAIN"
+
+
 class SubscriptionBackend:
     KIND = "semantic"
     """STUB/interface-only backend for a $0 subscription path (e.g. a node's
@@ -271,20 +280,35 @@ class SubscriptionBackend:
             )
         t0 = time.time()
         try:
-            text = self._call_fn(model_id, prompt, system) or ""
+            raw = self._call_fn(model_id, prompt, system)
         except Exception as exc:
             return BackendResult(
                 text="", tokens_in=0, tokens_thought=0, tokens_out=0,
                 latency_s=round(time.time() - t0, 2), estimated=True, error=str(exc),
             )
         latency_s = round(time.time() - t0, 2)
+        if raw is None or isinstance(raw, str):
+            text = raw or ""
+            return BackendResult(
+                text=text,
+                tokens_in=estimate_tokens(prompt),
+                tokens_thought=0,
+                tokens_out=estimate_tokens(text),
+                latency_s=latency_s,
+                estimated=True,
+            )
+        # CliResult from claude_cli: real usage, and the billing/rate-limit error
+        # is the result, not an exception. An error discards the answer text.
+        err = getattr(raw, "error", None)
+        text = "" if err else (getattr(raw, "text", "") or "")
         return BackendResult(
             text=text,
-            tokens_in=estimate_tokens(prompt),
+            tokens_in=int(getattr(raw, "tokens_in", 0) or 0),
             tokens_thought=0,
-            tokens_out=estimate_tokens(text),
+            tokens_out=int(getattr(raw, "tokens_out", 0) or 0),
             latency_s=latency_s,
-            estimated=True,
+            estimated=False,
+            error=err,
         )
 
 

swarph_cli-0.69.5/src/swarph_cli/bench/claude_cli.py

@@ -0,0 +1,68 @@
+"""claude -p transport for the bench `subscription` backend (#999). Subscription-only,
+isolated, billing-guarded. Measured 2026-09-29: without the isolation flags one call loaded
+286 tools and 213k cache-write tokens; with them, 0 tools and ~421 input tokens."""
+from __future__ import annotations
+
+import json
+import subprocess
+from dataclasses import dataclass
+from typing import Optional
+
+_STRIP_EXACT = ("ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN")
+_RATE = ("usage limit", "rate limit", "429", "overloaded")
+
+
+@dataclass
+class CliResult:
+    text: str
+    tokens_in: int
+    tokens_out: int
+    api_key_source: Optional[str]
+    cost_equiv: Optional[float]
+    error: Optional[str] = None
+
+
+def build_argv(model_id: str, system: str) -> list:
+    return ["claude", "-p", "--model", model_id, "--system-prompt", system, "--max-turns", "1",
+            "--output-format", "stream-json", "--verbose", "--strict-mcp-config",
+            "--mcp-config", '{"mcpServers":{}}', "--tools", "", "--setting-sources", ""]
+
+
+def clean_env(env: dict) -> dict:
+    """Drop billing keys and every SWARPH_CHANNEL* name, including ones not listed yet."""
+    return {
+        k: v for k, v in env.items()
+        if k not in _STRIP_EXACT and not k.startswith("SWARPH_CHANNEL")
+    }
+
+
+def parse_stream(lines) -> CliResult:
+    key, res = None, None
+    for ln in lines:
+        try:
+            e = json.loads(ln)
+        except Exception:
+            continue
+        if e.get("type") == "system" and e.get("subtype") == "init":
+            key = e.get("apiKeySource")
+        elif e.get("type") == "result":
+            res = e
+    if res is None:
+        return CliResult("", 0, 0, key, None, error="no_result")
+    u = res.get("usage") or {}
+    tin = sum(int(u.get(k) or 0) for k in ("input_tokens", "cache_creation_input_tokens", "cache_read_input_tokens"))
+    out = CliResult(res.get("result") or "", tin, int(u.get("output_tokens") or 0), key, res.get("total_cost_usd"))
+    if key != "none":
+        return CliResult("", tin, out.tokens_out, key, out.cost_equiv, error=f"billing:{key}")
+    if res.get("is_error"):
+        msg = (res.get("result") or "").lower()
+        out.text = ""
+        out.error = "rate_limit" if any(t in msg for t in _RATE) else f"cli_error:{res.get('subtype')}"
+    return out
+
+
+def call(model_id: str, prompt: str, system: str, *, runner=subprocess.run, timeout: int = 300) -> CliResult:
+    import os
+    p = runner(build_argv(model_id, system), input=prompt, capture_output=True, text=True,
+               env=clean_env(dict(os.environ)), timeout=timeout)
+    return parse_stream((p.stdout or "").splitlines())

{swarph_cli-0.69.3 → swarph_cli-0.69.5}/src/swarph_cli/bench/runner.py

@@ -12,6 +12,7 @@ alongside the aggregate, and the CLI always PRINTS it.
 from __future__ import annotations
 
 import json
+import time
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from typing import Optional
@@ -95,6 +96,7 @@ class TaskRow:
     estimated: bool
     error: Optional[str] = None
     not_run: Optional[str] = None
+    text: str = ""
 
 
 @dataclass
@@ -225,6 +227,33 @@ def _secrets_of(specs, backends) -> list:
     return found
 
 
+def _taskrow_from_ledger(item: dict) -> TaskRow:
+    return TaskRow(
+        task_id=item["task_id"],
+        cls=item.get("cls") or "",
+        distance=float(item.get("distance") or 0.0),
+        parse_ok=bool(item.get("parse_ok")),
+        tokens_in=int(item.get("tokens_in") or 0),
+        tokens_thought=int(item.get("tokens_thought") or 0),
+        tokens_out=int(item.get("tokens_out") or 0),
+        latency_s=float(item.get("latency_s") or 0.0),
+        cost_usd=float(item.get("cost_usd") or 0.0),
+        estimated=bool(item.get("estimated")),
+        error=item.get("error"),
+        not_run=item.get("not_run"),
+        text=item.get("text") or "",
+    )
+
+
+def _skipped(task: dict, reason: str) -> TaskRow:
+    """A task that was not scored. rate_limit is retryable, never an ABSTAIN."""
+    return TaskRow(
+        task_id=task["id"], cls=class_of(task), distance=0.0, parse_ok=False,
+        tokens_in=0, tokens_thought=0, tokens_out=0, latency_s=0.0,
+        cost_usd=0.0, estimated=False, error=reason, not_run=reason, text="",
+    )
+
+
 def run_pack(
     specs: list[ModelSpec],
     pack: dict,
@@ -235,6 +264,7 @@ def run_pack(
     max_usd_per_arm: Optional[float] = None,
     allow_egress: Optional[set[str]] = None,
     ledger_path: Optional[str] = None,
+    sleeper=None,
 ) -> dict:
     """Run every spec against every task in ``pack`` (or a ``task_ids``
     subset). ``backends`` maps backend-name ("metered"/"subscription"/...) ->
@@ -260,6 +290,17 @@ def run_pack(
     secrets = _secrets_of(specs, backends)
     allow_egress = allow_egress or set()
     overrides = []
+    sleep = sleeper or time.sleep
+    run_aborted = False
+    prior_detail: dict = {}
+    if ledger_path:
+        from pathlib import Path
+        ledger = Path(ledger_path)
+        if ledger.is_file():
+            try:
+                prior_detail = json.loads(ledger.read_text(encoding="utf-8")).get("detail") or {}
+            except (OSError, json.JSONDecodeError):
+                prior_detail = {}
 
     for spec in specs:
         backend = _bound(spec, backends)
@@ -272,9 +313,24 @@ def run_pack(
                 "at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
             })
 
+        resumed = {}
+        for item in prior_detail.get(spec.label) or []:
+            if isinstance(item, dict) and item.get("task_id") and item.get("error") is None and not item.get("not_run"):
+                resumed[item["task_id"]] = _taskrow_from_ledger(item)
+
         rows: list[TaskRow] = []
         arm_spent = 0.0
+        arm_stopped = False
         for task in tasks:
+            if task["id"] in resumed:
+                rows.append(resumed[task["id"]])
+                continue
+            if run_aborted:
+                rows.append(_skipped(task, "aborted"))
+                continue
+            if arm_stopped:
+                rows.append(_skipped(task, "rate_limit"))
+                continue
             if (max_usd is not None and spent >= max_usd) or (
                     max_usd_per_arm is not None and arm_spent >= max_usd_per_arm):
                 partial = "spend_cap"
@@ -286,8 +342,31 @@ def run_pack(
                 ))
                 continue
             result = _dispatch(backend, spec.id, task["prompt"], system)
+            rate_hits = 0
+            while result.error == "rate_limit" and rate_hits < 2:
+                sleep(60 if rate_hits == 0 else 300)
+                rate_hits += 1
+                result = _dispatch(backend, spec.id, task["prompt"], system)
             if result.error:
                 result.error = _redact(result.error, secrets)
+            if result.error and str(result.error).startswith("billing:"):
+                # A billing leak aborts every remaining task on every arm.
+                # The answer is already empty. One such call stops the run.
+                partial = "aborted"
+                run_aborted = True
+                rows.append(TaskRow(
+                    task_id=task["id"], cls=class_of(task), distance=0.0, parse_ok=False,
+                    tokens_in=result.tokens_in, tokens_thought=result.tokens_thought,
+                    tokens_out=result.tokens_out, latency_s=result.latency_s,
+                    cost_usd=0.0, estimated=result.estimated, error=result.error,
+                    not_run="aborted", text="",
+                ))
+                continue
+            if result.error == "rate_limit":
+                partial = "rate_limit"
+                arm_stopped = True
+                rows.append(_skipped(task, "rate_limit"))
+                continue
             if result.error:
                 rows.append(TaskRow(
                     task_id=task["id"], cls=class_of(task), distance=1.0, parse_ok=False,
@@ -308,6 +387,7 @@ def run_pack(
                 latency_s=result.latency_s,
                 cost_usd=usd,
                 estimated=result.estimated or unknown,
+                text=result.text,
             ))
         detail[spec.label] = rows
 
@@ -340,7 +420,9 @@ def run_pack(
             estimated=any(r.estimated for r in done),
             per_class=per_class,
             errors=sum(1 for r in rows if r.error and not r.not_run),
-            partial="spend_cap" if any(r.not_run for r in rows) else None,
+            partial=("aborted" if any(r.not_run == "aborted" for r in rows)
+                     else "rate_limit" if any(r.not_run == "rate_limit" for r in rows)
+                     else "spend_cap" if any(r.not_run for r in rows) else None),
             price_source=(getattr(backend, "price", None) or {}).get("source", "")
             if isinstance(getattr(backend, "price", None), dict) else "",
             egress=_arm_egress(spec, backend),
@@ -354,6 +436,7 @@ def run_pack(
         "theme": pack.get("theme"),
         "tasks_total": len(tasks),
         "partial": partial,
+        "aborted": partial == "aborted",
         "exit_code": 1 if partial else 0,
         "egress_overrides": overrides,
         "board": [vars(b) for b in board],

{swarph_cli-0.69.3 → swarph_cli-0.69.5}/src/swarph_cli/commands/bench.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 
 import argparse
 import json
+import shutil
 import sys
 from pathlib import Path
 from typing import Optional
@@ -53,10 +54,16 @@ def _default_backends() -> dict[str, Backend]:
     `metered` stays bound to Gemini so existing `id:metered` specs keep their
     meaning; mistral is its own key rather than a redefinition.
     """
+    # claude on PATH wires the subscription lane to an isolated `claude -p`
+    # (card #999). Without the binary the stub stays, and preflight skips it.
+    subscription = SubscriptionBackend()
+    if shutil.which("claude"):
+        from swarph_cli.bench.claude_cli import call as claude_call
+        subscription = SubscriptionBackend(call_fn=claude_call)
     return {
         "metered": MeteredGeminiBackend(),
         "mistral": MeteredMistralBackend(),
-        "subscription": SubscriptionBackend(),
+        "subscription": subscription,
         "rule": RuleBackend(),
         "typed-http": TypedHttpBackend(),
         # Selectable class for the wiring lock. A real call is provider:<name>,
@@ -138,6 +145,9 @@ def _build_parser() -> argparse.ArgumentParser:
     r.add_argument("--max-usd-per-arm", type=float, default=None)
     r.add_argument("--allow-egress", action="append", default=[], help="provider allowed off-box")
     r.add_argument("--allow-unpriced", action="append", default=[], help="provider allowed with no price under a cap")
+    r.add_argument("--ledger", default=None,
+                   help="JSON path. A re-run skips tasks that already completed; "
+                        "a usage limit stops the arm here and the next run resumes")
     r.add_argument("--strict", action="store_true",
                     help="abort (no dispatch) if ANY requested model lacks credentials, "
                          "instead of skipping it and running the rest")
@@ -223,7 +233,8 @@ def _cmd_run(args) -> int:
 
     result = run_pack(
         runnable, pack, backends, max_usd=args.max_usd,
-        max_usd_per_arm=args.max_usd_per_arm, allow_egress=allow_egress)
+        max_usd_per_arm=args.max_usd_per_arm, allow_egress=allow_egress,
+        ledger_path=args.ledger)
     if args.report == "json":
         print(json.dumps(result, indent=2))
     else:

{swarph_cli-0.69.3 → swarph_cli-0.69.5}/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.3 → swarph_cli-0.69.5}/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.3 → swarph_cli-0.69.5}/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:
@@ -2673,7 +2693,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 +2703,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.3 → swarph_cli-0.69.5}/src/swarph_cli/guide/GUIDE.md

@@ -488,7 +488,7 @@ registry name the SAME set, so a verb shipped without a line here is a red test.
 answers `--help`; hook-plumbing verbs are the callbacks hooks invoke, not commands you type.
 
 - `swarph add` -- install a swarph artifact by `swarph://` URI (magnet-link style).
-- `swarph bench` -- deterministic LLM benchmark-pack runner (card #101). `provider:<name>` uses a TOML registry of env-var names (example `docs/examples/bench_providers.toml`, Jev at 0.42 USD per 1M input tokens, output free). `--max-usd` is a hard cap. `egress = "on_box_only"` refuses an external arm unless `--allow-egress` names that provider.
+- `swarph bench` -- deterministic LLM benchmark-pack runner (card #101). `provider:<name>` uses a TOML registry of env-var names (example `docs/examples/bench_providers.toml`, Jev at 0.42 USD per 1M input tokens, output free). `--max-usd` is a hard cap. `egress = "on_box_only"` refuses an external arm unless `--allow-egress` names that provider. `claude-sonnet-5-5:subscription` is `claude -p` on the Claude subscription (isolation flags, billing guard requires `apiKeySource=none` and aborts every arm, prompt on stdin, every `SWARPH_CHANNEL*` name stripped). A usage limit retries 60s then 300s and resumes from `--ledger`; it is not scored.
 - `swarph board` -- the mesh board: projects, cards, obligations (see [The board](#the-board)).
 - `swarph brain` -- run the gbrain HTTP brain server, the $0 semantic memory.
 - `swarph brain-ask` -- search the swarph-brain memory with a question; optional $0 synthesis.

{swarph_cli-0.69.3 → swarph_cli-0.69.5}/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