swarph-cli 0.72.0__tar.gz → 0.72.2__tar.gz

{swarph_cli-0.72.0/src/swarph_cli.egg-info → swarph_cli-0.72.2}/PKG-INFO

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

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

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

swarph_cli-0.72.2/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.0 → swarph_cli-0.72.2}/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.0 → swarph_cli-0.72.2}/src/swarph_cli/commands/mesh.py

@@ -2302,6 +2302,9 @@ _OPENCODE_WAKE_PROMPT = "check mesh: swarph_dm_unread"
 # Grok's TUI has the same shape (#715, grok 1.0.41): no push channel, so
 # the wake is one line naming the pull tool and no DM body.
 _GROK_WAKE_PROMPT = "check mesh: swarph_dm_unread"
+# Muse 1.4.1 has no push channel either. The wake names the pull tool,
+# same text the grok and opencode sinks inject.
+_MUSE_WAKE_PROMPT = "check mesh: swarph_dm_unread"
 # A finished turn keeps its ▣ header and adds a duration.
 # Short turns read `· 3.3s` (drop-on-meta-edge, 1.18.33, card #961 post
 # 54557). A longer idle turn reads `· 3m 4s` (opencode pane, 2026-09-29
@@ -2439,7 +2442,7 @@ def _only_wake_text(content: str) -> bool:
     human's line.
     """
     rest = content
-    for prompt in (_GROK_WAKE_PROMPT, _OPENCODE_WAKE_PROMPT, _WAKE_PROMPT):
+    for prompt in (_MUSE_WAKE_PROMPT, _GROK_WAKE_PROMPT, _OPENCODE_WAKE_PROMPT, _WAKE_PROMPT):
         rest = rest.replace(prompt, "")
     return rest.strip() == ""
 
@@ -2611,8 +2614,13 @@ def _is_muse_rule(line: str) -> bool:
 
 
 def _is_muse_status(line: str) -> bool:
-    """The status under the lower rule. Measured: ``muse-spark-… · … · YOLO``."""
-    return "muse-spark" in line and "·" in line
+    """A status row under the lower rule.
+
+    Measured muse-spark is ``model · effort · path · YOLO``. An echo
+    provider is ``echo · ~/x · YOLO``. The anchor is two or more `` · ``
+    separators, not the model name. A model switch must not blind the sink.
+    """
+    return line.count(" · ") >= 2
 
 
 def _is_muse_composer_row(lines: list[str], index: int) -> bool:
@@ -2853,6 +2861,8 @@ def _wake_prompt_for(lines: Optional[list[str]]) -> str:
         return _GROK_WAKE_PROMPT
     if lines and _is_opencode_pane(lines):
         return _OPENCODE_WAKE_PROMPT
+    if lines and _is_muse_pane(lines):
+        return _MUSE_WAKE_PROMPT
     return _WAKE_PROMPT
 
 

{swarph_cli-0.72.0 → swarph_cli-0.72.2}/src/swarph_cli/commands/spawn.py

@@ -393,14 +393,21 @@ _CLAUDE_CHANNELS = frozenset({"allowlisted", "dev"})
 _MUSE_CHANNELS = frozenset({"ingress"})
 
 
-def _resolve_channel(cell: Cell) -> str:
-    """Effective channel mode: $SWARPH_CHANNEL wins (incl. "off"), else the
-    cell.yaml `channel` field (kept by swarph-shared in the forward-compat
-    `extra` bag), else "" (absent). Never launches anything; callers validate.
-    """
-    env_mode = os.environ.get("SWARPH_CHANNEL") or ""
-    if env_mode:
-        return env_mode
+# Providers whose spawn consumes $SWARPH_CHANNEL. Anything else ignores an
+# inherited value (a Claude cell's shell carries allowlisted; spawning grok
+# from it must not refuse). Measured 2026-10-01: 0.72.0 blamed cell.yaml
+# for that env and exited on grok-researcher.yaml, which has no channel field.
+_ENV_CHANNEL_PROVIDERS = frozenset({"claude", "muse"})
+
+
+def _channel_where(source: str) -> str:
+    """Name the place the mode came from. An env value must not read as cell.yaml."""
+    if source == "env":
+        return "SWARPH_CHANNEL"
+    return "cell.yaml: 'channel'"
+
+
+def _field_channel(cell: Cell) -> str:
     extra = getattr(cell, "extra", None) or {}
     value = extra.get("channel", "") if isinstance(extra, dict) else ""
     if value is None:
@@ -413,64 +420,88 @@ def _resolve_channel(cell: Cell) -> str:
     return value
 
 
-def _channel_marketplace_dir() -> Path:
+def _resolve_channel(cell: Cell) -> tuple[str, str]:
+    """Effective channel mode and where it came from.
+
+    ``$SWARPH_CHANNEL`` wins (incl. "off") only for providers that support
+    it: claude (allowlisted/dev/off) and muse (ingress/off). Other providers
+    ignore the inherited env, as before 0.72.0, and the cell.yaml field is
+    still read. Returns ``(mode, source)`` with source ``env``, ``cell.yaml``,
+    or ``""``. Never launches anything; callers validate.
+    """
+    env_mode = os.environ.get("SWARPH_CHANNEL") or ""
+    provider = getattr(cell, "provider", None)
+    # No provider attribute: the stamp probes construct a name-only cell.
+    # Those are claude-shaped; the env still applies.
+    if env_mode and (provider is None or provider in _ENV_CHANNEL_PROVIDERS):
+        return env_mode, "env"
+    field = _field_channel(cell)
+    return field, ("cell.yaml" if field else "")
+
+
+def _channel_marketplace_dir(source: str = "cell.yaml") -> Path:
     """Install location of the `swarph` Claude marketplace (the allowlist).
 
     Resolved through ~/.claude/plugins/known_marketplaces.json, the same
     registry claude reads — never a second hardcoded copy that drifts.
+    ``source`` names env vs cell.yaml so a missing registry is not blamed
+    on the file when the mode came from ``$SWARPH_CHANNEL``.
     """
+    where = _channel_where(source)
     registry = Path.home() / ".claude" / "plugins" / "known_marketplaces.json"
     try:
         data = json.loads(registry.read_text(encoding="utf-8"))
     except (OSError, ValueError) as exc:
         raise CellError(
-            f"cell.yaml: channel 'allowlisted' needs the swarph marketplace, "
+            f"{where} 'allowlisted' needs the swarph marketplace, "
             f"but its registry is unreadable: {registry} ({exc})."
         ) from exc
     try:
         location = data["swarph"]["installLocation"]
     except (KeyError, TypeError) as exc:
         raise CellError(
-            f"cell.yaml: channel 'allowlisted' needs the swarph marketplace, "
+            f"{where} 'allowlisted' needs the swarph marketplace, "
             f"but it is not registered in {registry}."
         ) from exc
     path = Path(location)
     if not path.is_dir():
         raise CellError(
-            f"cell.yaml: channel 'allowlisted' needs the swarph marketplace "
+            f"{where} 'allowlisted' needs the swarph marketplace "
             f"at {path}, which is not a directory."
         )
     return path
 
 
-def _validate_channel(cell: Cell, mode: str) -> str:
+def _validate_channel(cell: Cell, mode: str, source: str = "cell.yaml") -> str:
     """Fail closed on any channel mode the provider cannot consume.
 
     Returns the mode unchanged. "" and "off" are valid everywhere (no-op).
-    Raises CellError naming the field (and the file, for a missing
-    marketplace) so the operator fixes config, never debugs a deaf cell.
+    Raises CellError naming the source (``SWARPH_CHANNEL`` or the cell.yaml
+    field) and the file, for a missing marketplace, so the operator fixes
+    config, never debugs a deaf cell.
     """
     if mode in ("", "off"):
         return mode
+    where = _channel_where(source)
     provider = cell.provider
     if provider == "claude":
         if mode not in _CLAUDE_CHANNELS:
             raise CellError(
-                f"cell.yaml: 'channel' {mode!r} is not valid for provider "
+                f"{where} {mode!r} is not valid for provider "
                 f"'claude'. Valid values: {sorted(_CLAUDE_CHANNELS | {'off'})}."
             )
         if mode == "allowlisted":
-            _channel_marketplace_dir()
+            _channel_marketplace_dir(source)
         return mode
     if provider == "muse":
         if mode not in _MUSE_CHANNELS:
             raise CellError(
-                f"cell.yaml: 'channel' {mode!r} is not valid for provider "
+                f"{where} {mode!r} is not valid for provider "
                 f"'muse'. Valid values: {sorted(_MUSE_CHANNELS | {'off'})}."
             )
         return mode
     raise CellError(
-        f"cell.yaml: 'channel' {mode!r} is only valid for providers "
+        f"{where} {mode!r} is only valid for providers "
         f"'claude' and 'muse'; provider is {provider!r}."
     )
 
@@ -498,7 +529,8 @@ def _build_claude_argv(
             argv.extend(["--append-system-prompt", starter])
 
     argv.extend(passthrough)
-    mode = _validate_channel(cell, _resolve_channel(cell))
+    mode, source = _resolve_channel(cell)
+    mode = _validate_channel(cell, mode, source)
     if mode == "allowlisted":
         argv.extend(["--channels", "plugin:swarph@swarph"])
     elif mode == "dev":
@@ -545,7 +577,7 @@ def _spawn_env_base(cell: Cell) -> dict[str, str]:
     env = scrub_env_for_subprocess()
     env["SWARPH_SPAWN"] = "1"
     env["SWARPH_SELF"] = cell.name
-    mode = _resolve_channel(cell)
+    mode, _source = _resolve_channel(cell)
     # 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.
@@ -587,7 +619,8 @@ def _muse_env(cell: Cell) -> dict[str, str]:
     run_spawn choke point; the mode read here agrees with it by construction.
     """
     env = _claude_env(cell)
-    if _resolve_channel(cell) == "ingress":
+    mode, _source = _resolve_channel(cell)
+    if mode == "ingress":
         env["MUSE_EXPERIMENTAL_EXTERNAL_AGENT_INGRESS"] = "on"
     return env
 
@@ -3308,7 +3341,8 @@ def run_spawn(argv: Optional[list[str]] = None) -> int:
     # must not leave a minted sidecar behind). One choke point for every
     # provider; builders below see only validated modes.
     try:
-        _validate_channel(cell, _resolve_channel(cell))
+        mode, source = _resolve_channel(cell)
+        _validate_channel(cell, mode, source)
     except CellError as exc:
         print(f"swarph spawn: {exc}", file=sys.stderr)
         return 1

{swarph_cli-0.72.0 → swarph_cli-0.72.2}/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.0 → swarph_cli-0.72.2/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.0
+Version: 0.72.2
 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.0 → swarph_cli-0.72.2}/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.0 → swarph_cli-0.72.2}/tests/test_1006_board_publisher.py

@@ -309,3 +309,40 @@ def test_live_entry_drops_a_closed_row_and_a_failed_read_sends_nothing(tmp_path,
     assert all(argv[:3] != ["swarph", "mesh", "send"] for argv in calls)
     assert all("inbox" not in argv for argv in calls)
     assert not hasattr(pub, "commander_replies")
+
+
+def test_in_session_marker_sets_the_flag_and_strips_the_title():
+    """An accept starting [commander][in-session] Re-login... builds
+    in_session=true and a title without the marker. A plain [commander]
+    row with no deploy or hard-gate words stays false. On main the title
+    keeps [in-session] and the flag stays false.
+    """
+    pub = _load()
+    listing = (ROOT / "tests" / "fixtures" / "session-board" / "listagents-lab.txt").read_text(encoding="utf-8")
+    rows = pub.commander_rows([
+        {
+            "id": 5,
+            "holder": "droplet",
+            "card_id": 1006,
+            "state": "open",
+            "accept": "[commander][in-session] Re-login to the board | PASS=the commander re-logs",
+        },
+        {
+            "id": 6,
+            "holder": "droplet",
+            "card_id": 1006,
+            "state": "open",
+            "accept": "[commander] Note the weather today | PASS=nothing",
+        },
+    ])
+    board = pub.build_board.build(listing, rows)
+    questions = [
+        q for sess in board["sessions"] if sess["name"] == "droplet" for q in sess["questions"]
+    ]
+    marked = next(q for q in questions if q["obligation"] == 5)
+    plain = next(q for q in questions if q["obligation"] == 6)
+    assert marked["in_session"] is True
+    assert marked["title"] == "Re-login to the board"
+    assert "[in-session]" not in marked["title"]
+    assert "[commander]" not in marked["title"]
+    assert plain["in_session"] is False