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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.69.2
+Version: 0.69.4
 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
@@ -26,6 +26,7 @@ License-File: LICENSE
 Requires-Dist: swarph-mesh<0.10,>=0.5.0
 Requires-Dist: swarph-shared<0.9,>=0.7.0
 Requires-Dist: PyYAML>=6.0
+Requires-Dist: tomli>=1.1; python_version < "3.11"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Provides-Extra: mcp
@@ -245,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.2 → swarph_cli-0.69.4}/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.2 → swarph_cli-0.69.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.69.2"
+version = "0.69.4"
 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" }
@@ -73,6 +73,9 @@ dependencies = [
     # Stays a swarph-cli dep since file I/O is operator-tooling-layer
     # concern; swarph-shared cell module is pure-stdlib.
     "PyYAML>=6.0",
+    # tomllib is stdlib from 3.11. bench/providers.py (and the tests that read
+    # pyproject.toml) fall back to tomli on the declared 3.10 floor. card #1000.
+    "tomli>=1.1; python_version < \"3.11\"",
 ]
 
 [project.urls]

{swarph_cli-0.69.2 → swarph_cli-0.69.4}/src/swarph_cli/__init__.py

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

{swarph_cli-0.69.2 → swarph_cli-0.69.4}/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.4/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.2 → swarph_cli-0.69.4}/src/swarph_cli/bench/providers.py

@@ -2,7 +2,10 @@
 from __future__ import annotations
 
 import os
-import tomllib
+try:
+    import tomllib
+except ModuleNotFoundError:  # py3.10
+    import tomli as tomllib
 from pathlib import Path
 from urllib.parse import urlparse
 

{swarph_cli-0.69.2 → swarph_cli-0.69.4}/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.2 → swarph_cli-0.69.4}/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.2 → swarph_cli-0.69.4}/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.2 → swarph_cli-0.69.4/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.69.2
+Version: 0.69.4
 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
@@ -26,6 +26,7 @@ License-File: LICENSE
 Requires-Dist: swarph-mesh<0.10,>=0.5.0
 Requires-Dist: swarph-shared<0.9,>=0.7.0
 Requires-Dist: PyYAML>=6.0
+Requires-Dist: tomli>=1.1; python_version < "3.11"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Provides-Extra: mcp
@@ -245,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.2 → swarph_cli-0.69.4}/src/swarph_cli.egg-info/SOURCES.txt

@@ -39,6 +39,7 @@ src/swarph_cli.egg-info/requires.txt
 src/swarph_cli.egg-info/top_level.txt
 src/swarph_cli/bench/__init__.py
 src/swarph_cli/bench/backends.py
+src/swarph_cli/bench/claude_cli.py
 src/swarph_cli/bench/pack.py
 src/swarph_cli/bench/prices.py
 src/swarph_cli/bench/providers.py
@@ -262,6 +263,7 @@ tests/test_artifact_skill.py
 tests/test_artifact_tool.py
 tests/test_artifact_uri.py
 tests/test_bench_backends.py
+tests/test_bench_claude_cli.py
 tests/test_bench_command.py
 tests/test_bench_pack.py
 tests/test_bench_prices.py

{swarph_cli-0.69.2 → swarph_cli-0.69.4}/src/swarph_cli.egg-info/requires.txt

@@ -2,6 +2,9 @@ swarph-mesh<0.10,>=0.5.0
 swarph-shared<0.9,>=0.7.0
 PyYAML>=6.0
 
+[:python_version < "3.11"]
+tomli>=1.1
+
 [bench]
 google-genai>=0.3
 

swarph_cli-0.69.4/tests/test_bench_claude_cli.py

@@ -0,0 +1,67 @@
+"""Subscription bench transport: isolated claude -p, billing guard, no live call."""
+import json
+import types
+
+from swarph_cli.bench import backends as B
+from swarph_cli.bench import claude_cli as C
+
+
+def lines(key="none", result='{"action": "BUY"}', is_error=False, subtype="success", usage=None):
+    u = usage or {"input_tokens": 400, "cache_creation_input_tokens": 0, "cache_read_input_tokens": 21, "output_tokens": 12}
+    return [json.dumps({"type": "system", "subtype": "init", "apiKeySource": key, "tools": []}),
+            json.dumps({"type": "result", "subtype": subtype, "is_error": is_error, "result": result,
+                        "total_cost_usd": 0.001, "usage": u})]
+
+
+def test_argv_isolation_flags():
+    a = C.build_argv("claude-sonnet-5-5", "SYS")
+    for flag in ("--strict-mcp-config", "--setting-sources", "--tools", "--max-turns", "--system-prompt"):
+        assert flag in a
+    assert a[a.index("--mcp-config") + 1] == '{"mcpServers":{}}'
+    assert a[a.index("--tools") + 1] == "" and a[a.index("--setting-sources") + 1] == ""
+    assert "SYS" in a and not any("prompt text" in x for x in a)  # prompt goes to stdin, never argv
+
+
+def test_clean_env_strips_keys():
+    e = C.clean_env({"ANTHROPIC_API_KEY": "k", "ANTHROPIC_AUTH_TOKEN": "t", "SWARPH_CHANNEL": "dev",
+                     "SWARPH_CHANNEL_CELL": "droplet", "PATH": "/usr/bin"})
+    assert set(e) == {"PATH"}
+
+
+def test_clean_env_strips_unseen_swarph_channel_prefix():
+    e = C.clean_env({"SWARPH_CHANNEL_X": "secret", "PATH": "/usr/bin", "HOME": "/root"})
+    assert "SWARPH_CHANNEL_X" not in e
+    assert e == {"PATH": "/usr/bin", "HOME": "/root"}
+
+
+def test_parse_ok():
+    r = C.parse_stream(lines())
+    assert r.text == '{"action": "BUY"}' and r.tokens_in == 421 and r.tokens_out == 12 and r.error is None
+
+
+def test_billing_guard_rejects_api_key_source():
+    r = C.parse_stream(lines(key="ANTHROPIC_API_KEY"))
+    assert r.error == "billing:ANTHROPIC_API_KEY" and r.text == ""
+
+
+def test_rate_limit_is_retryable_not_abstain():
+    r = C.parse_stream(lines(result="Claude usage limit reached", is_error=True, subtype="error_during_execution"))
+    assert r.error == "rate_limit"
+
+
+def test_call_passes_prompt_on_stdin():
+    seen = {}
+
+    def runner(argv, input, capture_output, text, env, timeout):
+        seen.update(argv=argv, input=input, env=env)
+        return types.SimpleNamespace(returncode=0, stdout="\n".join(lines()), stderr="")
+
+    C.call("claude-sonnet-5-5", "PROMPT TEXT", "SYS", runner=runner)
+    assert seen["input"] == "PROMPT TEXT" and "PROMPT TEXT" not in seen["argv"]
+    assert "ANTHROPIC_API_KEY" not in seen["env"]
+
+
+def test_parse_action_normalization():
+    assert B.normalize_judge_action('{"action": " buy "}') == "BUY"
+    assert B.normalize_judge_action('{"action": "hold"}') == "ABSTAIN"
+    assert B.normalize_judge_action("not json") == "ABSTAIN"

{swarph_cli-0.69.2 → swarph_cli-0.69.4}/tests/test_bench_runner.py

@@ -241,3 +241,75 @@ def test_preflight_skips_and_warns_on_missing_creds():
     runnable, warnings = preflight([ModelSpec(id="a", label="model-a")], {"metered": NoCredsBackend()})
     assert runnable == []
     assert warnings and "model-a" in warnings[0] and "SOME_API_KEY" in warnings[0]
+
+
+def _two_tasks():
+    return {
+        "theme": "rate-limit",
+        "system": "s",
+        "tasks": [
+            {"id": "t1", "type": "categorical", "prompt": "one", "expected": "BUY"},
+            {"id": "t2", "type": "categorical", "prompt": "two", "expected": "BUY"},
+        ],
+    }
+
+
+def test_rate_limit_backs_off_then_stops_without_scoring():
+    class Always:
+        def __init__(self):
+            self.n = 0
+
+        def generate(self, model_id, prompt, system=""):
+            self.n += 1
+            return BackendResult("", 0, 0, 0, 0.0, False, error="rate_limit")
+
+        def missing_creds(self):
+            return []
+
+    waits = []
+    backend = Always()
+    result = run_pack(
+        [ModelSpec(id="m", label="m")], _two_tasks(), {"metered": backend}, sleeper=waits.append)
+    assert waits == [60, 300]
+    assert backend.n == 3
+    rows = result["detail"]["m"]
+    assert [r["not_run"] for r in rows] == ["rate_limit", "rate_limit"]
+    assert result["partial"] == "rate_limit"
+    assert all(r["text"] == "" for r in rows)
+
+
+def test_billing_rejection_aborts_every_arm_after_one_call():
+    class Billing:
+        def __init__(self):
+            self.n = 0
+
+        def generate(self, model_id, prompt, system=""):
+            self.n += 1
+            return BackendResult("", 1, 0, 0, 0.0, False, error="billing:ANTHROPIC_API_KEY")
+
+        def missing_creds(self):
+            return []
+
+    backend = Billing()
+    result = run_pack(
+        [ModelSpec(id="a", label="arm-a"), ModelSpec(id="b", label="arm-b")],
+        _two_tasks(),
+        {"metered": backend},
+    )
+    assert backend.n == 1
+    assert result["partial"] == "aborted"
+    assert result["aborted"] is True
+    assert result["detail"]["arm-a"][0]["error"] == "billing:ANTHROPIC_API_KEY"
+    assert result["detail"]["arm-a"][0]["text"] == ""
+    assert all(r["not_run"] == "aborted" for r in result["detail"]["arm-b"])
+
+
+def test_resume_does_not_resend_completed_tasks(tmp_path):
+    backend = ScriptedBackend({"one": "BUY", "two": "BUY"})
+    ledger = tmp_path / "ledger.json"
+    spec = [ModelSpec(id="m", label="m")]
+    run_pack(spec, _two_tasks(), {"metered": backend}, ledger_path=str(ledger))
+    sent = len(backend.calls)
+    run_pack(spec, _two_tasks(), {"metered": backend}, ledger_path=str(ledger))
+    assert len(backend.calls) == sent
+    assert sent == 2

{swarph_cli-0.69.2 → swarph_cli-0.69.4}/tests/test_brain_ask_command.py

@@ -32,7 +32,10 @@ def test_version_matches_the_packaged_version():
     agree, which is what its name promised all along.
     """
     import pathlib
-    import tomllib
+    try:
+        import tomllib
+    except ModuleNotFoundError:  # py3.10
+        import tomli as tomllib
 
     import swarph_cli