swarph-cli 0.72.1__tar.gz → 0.72.3__tar.gz

{swarph_cli-0.72.1/src/swarph_cli.egg-info → swarph_cli-0.72.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.1
+Version: 0.72.3
 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
@@ -248,6 +248,8 @@ Task types: `numeric` (rel-err), `categorical` (exact), `ranking` (Kendall-tau),
 
 `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.
 
+`gpt-5.6-sol:codex` runs `codex exec` on the ChatGPT subscription when `codex` is on PATH. The argv is fixed: `--json`, `--ephemeral`, `--skip-git-repo-check`, `--ignore-user-config`, `--ignore-rules`, `--sandbox read-only`, in an empty temporary directory. `codex exec` has no system-prompt flag, so the pack's `system` goes on stdin ahead of the prompt. The child environment drops `OPENAI_API_KEY`, `CODEX_API_KEY`, and every `SWARPH_CHANNEL*` name. The billing guard runs **before** the call: the codex stream reports no key source, so the arm reads `auth_mode` from `$CODEX_HOME/auth.json` and refuses with `billing:<mode>` unless it is `chatgpt` (`billing:unknown` when the file cannot be read). Usage limits follow the claude arm: retried, then resumable with `--ledger`, never scored. The isolation flags drop the operator's MCP servers and plugins only. Measured on codex-cli 0.157.0 with a one-line prompt: 15,472 input tokens by default, 14,410 with the flags. The rest is the CLI's own agent instructions, so this arm's input tokens are not comparable with the claude arm's.
+
 ### `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.72.1 → swarph_cli-0.72.3}/README.md

@@ -199,6 +199,8 @@ Task types: `numeric` (rel-err), `categorical` (exact), `ranking` (Kendall-tau),
 
 `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.
 
+`gpt-5.6-sol:codex` runs `codex exec` on the ChatGPT subscription when `codex` is on PATH. The argv is fixed: `--json`, `--ephemeral`, `--skip-git-repo-check`, `--ignore-user-config`, `--ignore-rules`, `--sandbox read-only`, in an empty temporary directory. `codex exec` has no system-prompt flag, so the pack's `system` goes on stdin ahead of the prompt. The child environment drops `OPENAI_API_KEY`, `CODEX_API_KEY`, and every `SWARPH_CHANNEL*` name. The billing guard runs **before** the call: the codex stream reports no key source, so the arm reads `auth_mode` from `$CODEX_HOME/auth.json` and refuses with `billing:<mode>` unless it is `chatgpt` (`billing:unknown` when the file cannot be read). Usage limits follow the claude arm: retried, then resumable with `--ledger`, never scored. The isolation flags drop the operator's MCP servers and plugins only. Measured on codex-cli 0.157.0 with a one-line prompt: 15,472 input tokens by default, 14,410 with the flags. The rest is the CLI's own agent instructions, so this arm's input tokens are not comparable with the claude arm's.
+
 ### `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.72.1 → swarph_cli-0.72.3}/pyproject.toml

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

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

swarph_cli-0.72.3/src/swarph_cli/bench/codex_cli.py

@@ -0,0 +1,127 @@
+"""codex exec transport for the bench `codex` backend. Subscription-only, isolated,
+billing-guarded. Sibling of :mod:`swarph_cli.bench.claude_cli`, and it differs from it
+in three places that matter.
+
+Measured 2026-10-02, codex-cli 0.157.0, macOS arm64, a one-line prompt:
+    default config                              15,472 input tokens
+    --ignore-user-config --ignore-rules         14,410 input tokens
+The isolation flags remove the operator's MCP servers and plugins, and that is all
+they remove. The floor is the CLI's own agent instructions: there is no flag here that
+turns `codex exec` into a bare completion, so this arm does not reach the ~421 tokens
+`claude -p --tools ""` does. Compare arms on quality and on OUTPUT tokens; the input
+count carries this fixed load.
+
+THE BILLING GUARD IS CHECKED BEFORE THE CALL, NOT READ FROM THE RESULT. The claude
+stream names its key source (`apiKeySource`). The codex stream names nothing about
+billing, so the guard reads `auth_mode` from `$CODEX_HOME/auth.json` and refuses to
+call unless it is `chatgpt`. A file that cannot be read is `billing:unknown`: not
+knowing is a refusal, never a pass.
+
+NO SYSTEM-PROMPT FLAG. `codex exec` has none, so the pack's `system` is sent on stdin
+ahead of the prompt, separated by a blank line.
+
+The child runs in an empty temporary directory under a read-only sandbox, so there is
+no repository for the agent to read and nothing it can write.
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+from swarph_cli.bench.claude_cli import CliResult
+
+_STRIP_EXACT = ("OPENAI_API_KEY", "CODEX_API_KEY")
+_RATE = ("usage limit", "rate limit", "429", "too many requests")
+_SUBSCRIPTION_MODE = "chatgpt"
+
+
+def build_argv(model_id: str) -> list:
+    """Fixed argv. The trailing `-` reads the prompt from stdin, never from argv."""
+    return ["codex", "exec", "--model", model_id, "--json", "--ephemeral",
+            "--skip-git-repo-check", "--ignore-user-config", "--ignore-rules",
+            "--sandbox", "read-only", "-"]
+
+
+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 codex_home(env: dict) -> Path:
+    return Path(env.get("CODEX_HOME") or (Path.home() / ".codex"))
+
+
+def auth_mode(home: Path) -> Optional[str]:
+    """`auth_mode` from auth.json, or None when it cannot be read. None is not a pass."""
+    try:
+        data = json.loads((home / "auth.json").read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    mode = data.get("auth_mode") if isinstance(data, dict) else None
+    return mode if isinstance(mode, str) and mode else None
+
+
+def stdin_text(prompt: str, system: str) -> str:
+    return f"{system}\n\n{prompt}" if system else prompt
+
+
+def _is_rate(text: str) -> bool:
+    low = (text or "").lower()
+    return any(t in low for t in _RATE)
+
+
+def parse_stream(lines, stderr: str = "", key: Optional[str] = _SUBSCRIPTION_MODE) -> CliResult:
+    """JSONL from `codex exec --json` -> CliResult.
+
+    The answer is the LAST agent_message. Usage is the LAST turn.completed: that event
+    carries the thread's running total, so adding two of them would double-count.
+    A usage limit is `rate_limit` whether it arrives as an event or on stderr — the
+    runner retries that string and never scores it as an answer.
+    """
+    text, usage, failure = None, None, None
+    for ln in lines:
+        try:
+            e = json.loads(ln)
+        except Exception:
+            continue
+        if not isinstance(e, dict):
+            continue
+        kind = e.get("type")
+        if kind == "item.completed":
+            item = e.get("item") or {}
+            if item.get("type") == "agent_message" and isinstance(item.get("text"), str):
+                text = item["text"]
+        elif kind == "turn.completed":
+            usage = e.get("usage") or {}
+        elif kind in ("error", "turn.failed"):
+            detail = e.get("message") or e.get("error") or ""
+            failure = (kind, detail if isinstance(detail, str) else json.dumps(detail))
+    u = usage or {}
+    tin, tout = int(u.get("input_tokens") or 0), int(u.get("output_tokens") or 0)
+    if failure is not None:
+        err = "rate_limit" if _is_rate(failure[1]) or _is_rate(stderr) else f"cli_error:{failure[0]}"
+        return CliResult("", tin, tout, key, None, error=err)
+    if text is None or usage is None:
+        err = "rate_limit" if _is_rate(stderr) else "no_result"
+        return CliResult("", tin, tout, key, None, error=err)
+    return CliResult(text, tin, tout, key, None)
+
+
+def call(model_id: str, prompt: str, system: str, *, runner=subprocess.run,
+         timeout: int = 300, env: Optional[dict] = None) -> CliResult:
+    source = dict(os.environ) if env is None else dict(env)
+    mode = auth_mode(codex_home(source))
+    if mode != _SUBSCRIPTION_MODE:
+        # Refused before any call: nothing was spent, and nothing is scored.
+        return CliResult("", 0, 0, mode, None, error=f"billing:{mode or 'unknown'}")
+    with tempfile.TemporaryDirectory(prefix="swarph-bench-codex-") as cwd:
+        p = runner(build_argv(model_id), input=stdin_text(prompt, system), capture_output=True,
+                   text=True, env=clean_env(source), timeout=timeout, cwd=cwd)
+    return parse_stream((p.stdout or "").splitlines(), p.stderr or "", key=mode)

{swarph_cli-0.72.1 → swarph_cli-0.72.3}/src/swarph_cli/commands/bench.py

@@ -61,10 +61,17 @@ def _default_backends() -> dict[str, Backend]:
     if shutil.which("claude"):
         from swarph_cli.bench.claude_cli import call as claude_call
         subscription = SubscriptionBackend(call_fn=claude_call)
+    # codex on PATH wires its own lane to an isolated `codex exec`. Its own key,
+    # like mistral: `id:subscription` keeps meaning claude.
+    codex = SubscriptionBackend()
+    if shutil.which("codex"):
+        from swarph_cli.bench.codex_cli import call as codex_call
+        codex = SubscriptionBackend(call_fn=codex_call)
     return {
         "metered": MeteredGeminiBackend(),
         "mistral": MeteredMistralBackend(),
         "subscription": subscription,
+        "codex": codex,
         "rule": RuleBackend(),
         "signal": SignalBackend(),
         "typed-http": TypedHttpBackend(),

{swarph_cli-0.72.1 → swarph_cli-0.72.3}/src/swarph_cli/commands/spawn.py

@@ -581,9 +581,16 @@ def _spawn_env_base(cell: Cell) -> dict[str, str]:
     # NOTE: the marketplace/validity gate lives in _validate_channel, which
     # _build_claude_argv (and the muse env builder) run. This base stays a
     # pure reflection of the resolved mode so every provider's env agrees.
+    # #1022: SWARPH_CHANNEL must be exported too, whatever the mode's source.
+    # channel_opted_in() (channel.py) gates on SWARPH_CHANNEL alone, so a
+    # mode that came from cell.yaml — not from the parent env — left the
+    # session with SWARPH_CHANNEL_CELL set and the channel deaf: the server
+    # never declared claude/channel (droplet 4 days, gridiron on lab).
     if mode in {"allowlisted", "dev"}:
+        env["SWARPH_CHANNEL"] = mode
         env["SWARPH_CHANNEL_CELL"] = cell.name
     else:
+        env.pop("SWARPH_CHANNEL", None)
         env.pop("SWARPH_CHANNEL_CELL", None)
     return env
 

{swarph_cli-0.72.1 → swarph_cli-0.72.3}/src/swarph_cli/commands/wake_hook_output.py

@@ -10,6 +10,11 @@ distinction is not WHICH harness, it is WHERE THE WAKE LIVES):
 * ``claude`` / ``codex`` → ARM-INSTRUCTION. The wake lives in the harness:
   emit the watch pipeline (tail -F inbox.log | dm_notify_filter) as
   additionalContext so the agent arms it as a background watch.
+* ``grok`` → the same arm instruction, with the pipeline wrapped in
+  ``timeout -k 5s 590m`` and one ``[MESH WAKE EXPIRED]`` line. Grok caps a
+  background task at 10h (measured 2026-10-01); the wrapper exits 10
+  minutes early so the stop is a wake, not a SIGKILL the session never
+  sees. The duration is one unit: coreutils timeout rejects ``9h50m``.
 * ``cursor`` → ARM-INSTRUCTION, same pipeline as claude/codex, emitted in
   Cursor's ``additional_context`` envelope (the ``~/.cursor/hooks.json``
   sessionStart shape). The wake is the session-armed tail. A missing or
@@ -43,7 +48,7 @@ from swarph_cli.cell import (
     load_cell,
 )
 
-_ARM_HARNESSES = ("claude", "codex", "muse", "opencode")
+_ARM_HARNESSES = ("claude", "codex", "muse", "opencode", "grok")
 _INJECT_HARNESSES = ("antigravity",)
 _VERIFY_HARNESSES = ("cursor",)
 _KNOWN_HARNESSES = _ARM_HARNESSES + _INJECT_HARNESSES + _VERIFY_HARNESSES
@@ -52,6 +57,12 @@ _KNOWN_HARNESSES = _ARM_HARNESSES + _INJECT_HARNESSES + _VERIFY_HARNESSES
 _FILTER_MODULE = "swarph_cli.scripts.dm_notify_filter"
 # Same default as `swarph monitor arm-check --max-age-s` (15 minutes).
 _INBOX_MAX_AGE_S = 15 * 60
+_EXPIRED_LINE = "[MESH WAKE EXPIRED] re-arm the inbox tail now"
+# Harnesses whose background tasks die at a cap. The wrapper is that cap
+# minus 10 minutes, as one unit coreutils timeout accepts. Grok's cap is
+# 10h (grok-researcher, 2026-10-01); "9h50m" is rejected as an invalid
+# time interval on this box.
+_HARNESS_TIMEOUT = {"grok": "590m"}
 
 
 def _read_stdin_payload() -> dict[str, Any]:
@@ -233,7 +244,27 @@ def _provenance_note(source: str) -> str:
     return f" (identity from {source})"
 
 
-def _arm_instruction(cell_name: Optional[str], source: str = "unresolved") -> str:
+def _watch_pipeline(inbox: Path, interpreter: str) -> str:
+    return f'tail -n 0 -F "{inbox}" | "{interpreter}" -u -m {_FILTER_MODULE}'
+
+
+def _loud_stop(pipeline: str, duration: str) -> str:
+    """Self-expire before the harness kills the task, then say so.
+
+    ``-k 5s`` sends KILL if the tail is still up after TERM. A single-quoted
+    ``sh -c`` matches the pipeline, which quotes paths with double quotes.
+    """
+    return (
+        f"timeout -k 5s {duration} sh -c '{pipeline}'; "
+        f"echo '{_EXPIRED_LINE}'"
+    )
+
+
+def _arm_instruction(
+    cell_name: Optional[str],
+    source: str = "unresolved",
+    harness: str = "",
+) -> str:
     interpreter = sys.executable
     if not cell_name:
         # CANNOT-RESOLVE is a LOUD REFUSAL, never a placeholder (card #527
@@ -259,8 +290,10 @@ def _arm_instruction(cell_name: Optional[str], source: str = "unresolved") -> st
         f'"{interpreter}" -m swarph_cli monitor arm-check '
         f'--as {cell_name} --path "{inbox}"'
     )
-    tail = f'tail -n 0 -F "{inbox}"'
-    pipeline = f'{tail} | "{interpreter}" -u -m {_FILTER_MODULE}'
+    pipeline = _watch_pipeline(inbox, interpreter)
+    cap = _HARNESS_TIMEOUT.get(harness)
+    if cap:
+        pipeline = _loud_stop(pipeline, cap)
     return (
         "[swarph silent-wake] This cell's DM wake lives in THIS harness. "
         "BEFORE arming, refuse a missing/stale inbox.log (#729):\n"
@@ -490,7 +523,8 @@ def run_wake_hook_output(argv: Optional[list[str]] = None) -> int:
         )
     if harness in _ARM_HARNESSES:
         return _emit(
-            {"context": _arm_instruction(cell_name, cell_source)}, harness=harness
+            {"context": _arm_instruction(cell_name, cell_source, harness)},
+            harness=harness,
         )
     return _emit(
         {"context": _verify_report(cell_name, cell_source)}, harness=harness

{swarph_cli-0.72.1 → swarph_cli-0.72.3/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.1
+Version: 0.72.3
 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
@@ -248,6 +248,8 @@ Task types: `numeric` (rel-err), `categorical` (exact), `ranking` (Kendall-tau),
 
 `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.
 
+`gpt-5.6-sol:codex` runs `codex exec` on the ChatGPT subscription when `codex` is on PATH. The argv is fixed: `--json`, `--ephemeral`, `--skip-git-repo-check`, `--ignore-user-config`, `--ignore-rules`, `--sandbox read-only`, in an empty temporary directory. `codex exec` has no system-prompt flag, so the pack's `system` goes on stdin ahead of the prompt. The child environment drops `OPENAI_API_KEY`, `CODEX_API_KEY`, and every `SWARPH_CHANNEL*` name. The billing guard runs **before** the call: the codex stream reports no key source, so the arm reads `auth_mode` from `$CODEX_HOME/auth.json` and refuses with `billing:<mode>` unless it is `chatgpt` (`billing:unknown` when the file cannot be read). Usage limits follow the claude arm: retried, then resumable with `--ledger`, never scored. The isolation flags drop the operator's MCP servers and plugins only. Measured on codex-cli 0.157.0 with a one-line prompt: 15,472 input tokens by default, 14,410 with the flags. The rest is the CLI's own agent instructions, so this arm's input tokens are not comparable with the claude arm's.
+
 ### `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.72.1 → swarph_cli-0.72.3}/src/swarph_cli.egg-info/SOURCES.txt

@@ -40,6 +40,7 @@ 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/codex_cli.py
 src/swarph_cli/bench/pack.py
 src/swarph_cli/bench/prices.py
 src/swarph_cli/bench/providers.py
@@ -270,6 +271,7 @@ tests/test_959_venv_interpreter.py
 tests/test_960_channel.py
 tests/test_960_ensure_monitor_heartbeat.py
 tests/test_961_cursor_grok_footer.py
+tests/test_961_loud_stop.py
 tests/test_963_plugin_manifest.py
 tests/test_964_channel_cell.py
 tests/test_965_mesh_wait.py
@@ -284,6 +286,7 @@ tests/test_artifact_tool.py
 tests/test_artifact_uri.py
 tests/test_bench_backends.py
 tests/test_bench_claude_cli.py
+tests/test_bench_codex_cli.py
 tests/test_bench_command.py
 tests/test_bench_pack.py
 tests/test_bench_prices.py

{swarph_cli-0.72.1 → swarph_cli-0.72.3}/tests/test_1013_spawn_channel.py

@@ -244,3 +244,28 @@ def test_parent_channel_cell_does_not_reach_a_different_cell(tmp_path, monkeypat
     assert rc == 0
     assert env_added.get("SWARPH_CHANNEL_CELL") == "science-claude"
 
+
+def test_field_channel_exports_swarph_channel_so_serve_is_not_deaf(tmp_path, monkeypatch, capsys):
+    """Card #1022. A mode that came from cell.yaml must reach channel-serve:
+    the spawned env carries SWARPH_CHANNEL=mode (not just SWARPH_CHANNEL_CELL),
+    and channel_opted_in() is True under that env. On 7afd16b the field path
+    set only SWARPH_CHANNEL_CELL, so the server never declared claude/channel
+    and the cell ran deaf (droplet ~4 days, gridiron on lab).
+    """
+    from swarph_cli.channel import channel_opted_in
+
+    _registry(tmp_path, monkeypatch, with_swarph=True)
+    monkeypatch.delenv("SWARPH_CHANNEL", raising=False)
+    p = _cell_yaml(tmp_path, "claude", channel="allowlisted", name="gridiron")
+    rc, argv, env_added = _print(tmp_path, p, capsys)
+    assert rc == 0
+    assert "--channels" in argv and "plugin:swarph@swarph" in argv
+    # The env handed to claude names the mode, whatever its source was.
+    assert env_added.get("SWARPH_CHANNEL") == "allowlisted"
+    assert env_added.get("SWARPH_CHANNEL_CELL") == "gridiron"
+    # And the server's own gate agrees under exactly that env.
+    with monkeypatch.context() as ctx:
+        ctx.setenv("SWARPH_CHANNEL", env_added["SWARPH_CHANNEL"])
+        ctx.setenv("SWARPH_CHANNEL_CELL", env_added["SWARPH_CHANNEL_CELL"])
+        assert channel_opted_in() is True
+

swarph_cli-0.72.3/tests/test_961_loud_stop.py

@@ -0,0 +1,106 @@
+"""Card #961. A capped harness self-expires its inbox tail and says so.
+
+Grok kills a background task at 10h. The hook wraps that tail in
+``timeout -k 5s 590m`` (one unit; ``9h50m`` is rejected) and echoes one
+EXPIRED line. Claude, cursor, and codex have no known cap and stay the
+bare pipeline. On main, ``--harness grok`` is an unsupported-harness
+refusal and this file fails.
+"""
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+import time
+
+import pytest
+
+from swarph_cli.commands import wake_hook_output as who
+
+_EXPIRED = "[MESH WAKE EXPIRED] re-arm the inbox tail now"
+
+
+def _context(monkeypatch, capsys, harness: str, tmp_path, cell: str = "probe-cell"):
+    def _dir(name):
+        return tmp_path / "swarph_state" / name / "mesh-sidecar"
+
+    monkeypatch.setattr(who, "_sidecar_dir", _dir)
+    monkeypatch.setattr(who, "_resolve_cell", lambda explicit=None: (cell, "test"))
+    side = _dir(cell)
+    side.mkdir(parents=True, exist_ok=True)
+    inbox = side / "inbox.log"
+    inbox.write_text("", encoding="utf-8")
+    rc = who.run_wake_hook_output(["--harness", harness])
+    assert rc == 0
+    raw = json.loads(capsys.readouterr().out)
+    if harness == "cursor":
+        ctx = raw["additional_context"]
+    else:
+        ctx = raw["hookSpecificOutput"]["additionalContext"]
+    return ctx, inbox
+
+
+def _timeout_line(ctx: str) -> str:
+    lines = [line.strip() for line in ctx.splitlines() if "timeout -k 5s" in line]
+    assert len(lines) == 1
+    return lines[0]
+
+
+def test_grok_emits_a_single_unit_timeout_and_the_expired_echo(monkeypatch, capsys, tmp_path):
+    ctx, _inbox = _context(monkeypatch, capsys, "grok", tmp_path)
+    line = _timeout_line(ctx)
+    assert line.startswith("timeout -k 5s 590m sh -c '")
+    assert line.endswith(f"'; echo '{_EXPIRED}'")
+    assert "9h50m" not in ctx
+    assert "9h" not in line
+
+
+def test_claude_cursor_and_codex_stay_the_bare_pipeline(monkeypatch, capsys, tmp_path):
+    for harness in ("claude", "cursor", "codex"):
+        ctx, _inbox = _context(monkeypatch, capsys, harness, tmp_path)
+        assert "timeout" not in ctx
+        assert "MESH WAKE EXPIRED" not in ctx
+        assert "tail -n 0 -F" in ctx
+        assert "dm_notify_filter" in ctx
+
+
+def _coreutils_timeout() -> bool:
+    """A coreutils timeout that honors ``-k`` and a duration.
+
+    GNU and uutils both do. A macOS stand-in returns at once, so the
+    elapsed check would fail for the wrong reason.
+    """
+    if shutil.which("timeout") is None:
+        return False
+    proc = subprocess.run(
+        ["timeout", "--version"],
+        capture_output=True,
+        text=True,
+    )
+    text = f"{proc.stdout or ''}{proc.stderr or ''}".lower()
+    return proc.returncode == 0 and "coreutils" in text
+
+
+def test_a_two_second_cap_prints_exactly_one_expired_line(monkeypatch, capsys, tmp_path):
+    """Run the emitted command with the duration swapped to 2s.
+
+    The scratch inbox is empty, so the filter prints nothing. After the
+    timeout, the shell echoes the re-arm line once.
+    """
+    ctx, inbox = _context(monkeypatch, capsys, "grok", tmp_path)
+    script = _timeout_line(ctx).replace("590m", "2s", 1)
+    assert "590m" not in script
+    assert inbox.is_file()
+    if not _coreutils_timeout():
+        pytest.skip("the 2s run needs a coreutils timeout")
+    started = time.monotonic()
+    proc = subprocess.run(
+        ["sh", "-c", script],
+        capture_output=True,
+        text=True,
+        timeout=20,
+    )
+    elapsed = time.monotonic() - started
+    expired = [line for line in proc.stdout.splitlines() if "MESH WAKE EXPIRED" in line]
+    assert expired == [_EXPIRED]
+    assert elapsed >= 1.5

swarph_cli-0.72.3/tests/test_bench_codex_cli.py

@@ -0,0 +1,138 @@
+"""Codex bench transport: isolated codex exec, billing guard before the call, no live call."""
+import json
+import types
+
+from swarph_cli.bench import backends as B
+from swarph_cli.bench import codex_cli as C
+
+
+def lines(text='{"answer": 68}', usage=None, extra=()):
+    u = usage or {"input_tokens": 14410, "cached_input_tokens": 12160,
+                  "cache_write_input_tokens": 0, "output_tokens": 10, "reasoning_output_tokens": 0}
+    out = [json.dumps({"type": "thread.started", "thread_id": "t"}),
+           json.dumps({"type": "turn.started"})]
+    out += [json.dumps(e) for e in extra]
+    if text is not None:
+        out.append(json.dumps({"type": "item.completed",
+                               "item": {"id": "item_0", "type": "agent_message", "text": text}}))
+    out.append(json.dumps({"type": "turn.completed", "usage": u}))
+    return out
+
+
+def home(tmp_path, payload='{"auth_mode": "chatgpt", "OPENAI_API_KEY": null}'):
+    if payload is not None:
+        (tmp_path / "auth.json").write_text(payload, encoding="utf-8")
+    return {"CODEX_HOME": str(tmp_path), "PATH": "/usr/bin"}
+
+
+def recording_runner(stdout="", stderr=""):
+    seen = {"calls": 0}
+
+    def runner(argv, input, capture_output, text, env, timeout, cwd):
+        seen.update(argv=argv, input=input, env=env, cwd=cwd, calls=seen["calls"] + 1)
+        return types.SimpleNamespace(returncode=0, stdout=stdout, stderr=stderr)
+
+    return runner, seen
+
+
+def test_argv_isolation_flags():
+    a = C.build_argv("gpt-5.6-sol")
+    for flag in ("--json", "--ephemeral", "--skip-git-repo-check", "--ignore-user-config", "--ignore-rules"):
+        assert flag in a
+    assert a[a.index("--sandbox") + 1] == "read-only"
+    assert a[a.index("--model") + 1] == "gpt-5.6-sol"
+    assert a[-1] == "-"  # prompt is read from stdin, never argv
+
+
+def test_clean_env_strips_keys():
+    e = C.clean_env({"OPENAI_API_KEY": "k", "CODEX_API_KEY": "c", "SWARPH_CHANNEL": "dev",
+                     "SWARPH_CHANNEL_CELL": "droplet", "PATH": "/usr/bin", "CODEX_HOME": "/h"})
+    assert set(e) == {"PATH", "CODEX_HOME"}
+
+
+def test_parse_ok():
+    r = C.parse_stream(lines())
+    assert r.text == '{"answer": 68}' and r.tokens_in == 14410 and r.tokens_out == 10
+    assert r.error is None and r.cost_equiv is None and r.api_key_source == "chatgpt"
+
+
+def test_parse_takes_the_last_message_and_the_last_usage():
+    first = {"type": "item.completed", "item": {"type": "agent_message", "text": "draft"}}
+    early = {"type": "turn.completed", "usage": {"input_tokens": 5, "output_tokens": 1}}
+    r = C.parse_stream(lines(extra=(first, early)))
+    assert r.text == '{"answer": 68}' and r.tokens_in == 14410  # running total, never summed
+
+
+def test_tool_items_are_not_the_answer():
+    tool = {"type": "item.completed", "item": {"type": "command_execution", "text": "ls"}}
+    r = C.parse_stream(lines(extra=(tool,)))
+    assert r.text == '{"answer": 68}'
+
+
+def test_no_answer_is_no_result_not_an_empty_answer():
+    r = C.parse_stream(lines(text=None))
+    assert r.error == "no_result" and r.text == ""
+    assert C.parse_stream([]).error == "no_result"
+
+
+def test_rate_limit_is_retryable_from_event_or_stderr():
+    ev = {"type": "error", "message": "You've hit your usage limit. Try again later."}
+    assert C.parse_stream([json.dumps(ev)]).error == "rate_limit"
+    assert C.parse_stream([], stderr="ERROR: You've hit your usage limit").error == "rate_limit"
+
+
+def test_other_failure_is_a_cli_error_and_discards_the_text():
+    ev = {"type": "turn.failed", "error": {"message": "model not found"}}
+    r = C.parse_stream(lines(extra=(ev,)))
+    assert r.error == "cli_error:turn.failed" and r.text == ""
+
+
+def test_call_passes_system_and_prompt_on_stdin_in_an_empty_cwd(tmp_path):
+    runner, seen = recording_runner(stdout="\n".join(lines()))
+    env = dict(home(tmp_path), OPENAI_API_KEY="k")
+    r = C.call("gpt-5.6-sol", "PROMPT TEXT", "SYS", runner=runner, env=env)
+    assert r.error is None and r.text == '{"answer": 68}'
+    assert seen["input"] == "SYS\n\nPROMPT TEXT" and "PROMPT TEXT" not in seen["argv"]
+    assert "OPENAI_API_KEY" not in seen["env"] and seen["env"]["CODEX_HOME"] == str(tmp_path)
+    assert seen["cwd"] != str(tmp_path) and "swarph-bench-codex-" in seen["cwd"]
+
+
+def test_billing_guard_refuses_before_any_call(tmp_path):
+    runner, seen = recording_runner(stdout="\n".join(lines()))
+    r = C.call("gpt-5.6-sol", "P", "S", runner=runner,
+               env=home(tmp_path, '{"auth_mode": "apikey", "OPENAI_API_KEY": "k"}'))
+    assert r.error == "billing:apikey" and r.text == "" and seen["calls"] == 0
+
+
+def test_unreadable_auth_is_unknown_never_a_pass(tmp_path):
+    runner, seen = recording_runner(stdout="\n".join(lines()))
+    for payload in (None, "not json", '{"OPENAI_API_KEY": null}', '["chatgpt"]'):
+        d = tmp_path / str(abs(hash(payload)))
+        d.mkdir()
+        r = C.call("gpt-5.6-sol", "P", "S", runner=runner, env=home(d, payload))
+        assert r.error == "billing:unknown", payload
+    assert seen["calls"] == 0
+
+
+def test_backend_reports_real_usage_and_carries_the_error(tmp_path):
+    runner, _ = recording_runner(stdout="\n".join(lines()))
+    ok = B.SubscriptionBackend(
+        call_fn=lambda m, p, s: C.call(m, p, s, runner=runner, env=home(tmp_path)))
+    res = ok.generate("gpt-5.6-sol", "P", "S")
+    assert res.text == '{"answer": 68}' and res.tokens_in == 14410 and res.estimated is False
+
+    bad = tmp_path / "bad"
+    bad.mkdir()
+    refused = B.SubscriptionBackend(
+        call_fn=lambda m, p, s: C.call(m, p, s, runner=runner, env=home(bad, None)))
+    res = refused.generate("gpt-5.6-sol", "P", "S")
+    assert res.error == "billing:unknown" and res.text == ""
+
+
+def test_codex_lane_is_selectable(monkeypatch):
+    from swarph_cli.commands import bench
+
+    monkeypatch.setattr(bench.shutil, "which", lambda name: None)
+    assert bench._default_backends()["codex"].missing_creds()  # stub: preflight skips it
+    monkeypatch.setattr(bench.shutil, "which", lambda name: "/usr/bin/" + name)
+    assert bench._default_backends()["codex"].missing_creds() == []