swarph-cli 0.72.24__tar.gz → 0.72.25__tar.gz

{swarph_cli-0.72.24/src/swarph_cli.egg-info → swarph_cli-0.72.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.24
+Version: 0.72.25
 Summary: The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.72.24 → swarph_cli-0.72.25}/pyproject.toml

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

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

{swarph_cli-0.72.24 → swarph_cli-0.72.25}/src/swarph_cli/operator/cli.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 
 import argparse
 import json
+import os
 import sys
 from pathlib import Path
 from typing import Sequence
@@ -482,6 +483,18 @@ def main(argv: Sequence[str] | None = None) -> int:
         print(HELP)
         return 0
 
+    # card #1203: inside a cell (SWARPH_SELF set), refuse BEFORE any token
+    # is read -- a cell must not act as the commander by accident. The
+    # explicit --as-operator hatch overrides, loudly (both names on stderr).
+    as_operator = "--as-operator" in stripped
+    if as_operator:
+        stripped = [a for a in stripped if a != "--as-operator"]
+    cell_self = (os.environ.get("SWARPH_SELF") or "").strip()
+    if cell_self and not as_operator:
+        print(f"SWARPH_SELF={cell_self}: this process is inside a cell; "
+              "run swarph-me from a human shell", file=sys.stderr)
+        return 2
+
     try:
         identity, gateway, token = resolve_session(as_name, config_path=config_path)
     except SystemExit as exc:
@@ -490,6 +503,9 @@ def main(argv: Sequence[str] | None = None) -> int:
     except ValueError as exc:
         print(f"swarph-me: {exc}", file=sys.stderr)
         return 2
+    if cell_self and as_operator:
+        print(f"SWARPH_SELF={cell_self}: --as-operator override; "
+              f"acting as operator {identity}", file=sys.stderr)
 
     try:
         return run_verb(identity, gateway, token, stripped)

{swarph_cli-0.72.24 → swarph_cli-0.72.25/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.24
+Version: 0.72.25
 Summary: The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.72.24 → swarph_cli-0.72.25}/src/swarph_cli.egg-info/SOURCES.txt

@@ -231,7 +231,10 @@ tests/test_1075_task_cli.py
 tests/test_1083_openai_decisions.py
 tests/test_1144_cell_yaml_github.py
 tests/test_1197_commander_taps.py
+tests/test_1203_swarph_me_refusal.py
 tests/test_1206_offer_question.py
+tests/test_1214_egress.py
+tests/test_1219_egress_probe.py
 tests/test_124_register_merge.py
 tests/test_126_pending_from_complete.py
 tests/test_132_ensure_monitor_state_dir.py

swarph_cli-0.72.25/tests/test_1203_swarph_me_refusal.py

@@ -0,0 +1,49 @@
+"""card #1203 — swarph-me REFUSES when SWARPH_SELF is set (before any token
+is read), with an explicit, loud --as-operator escape hatch."""
+import os
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "src"))
+
+from swarph_cli.operator import cli  # noqa: E402
+from swarph_cli.operator import config as op_config  # noqa: E402
+
+
+def _cfg(tmp_path):
+    token = tmp_path / "commander.peer_token"
+    token.write_text("test-token\n", encoding="utf-8")
+    cfg = tmp_path / "operator.json"
+    op_config.save_config(identity="commander", gateway="http://example.test:8788",
+                          token_file=str(token), path=cfg)
+    return cfg
+
+
+def test_self_set_refuses_and_no_token_opened(tmp_path, monkeypatch, capsys):
+    monkeypatch.setenv("SWARPH_SELF", "cursor-win")
+    monkeypatch.setattr(cli, "_read_token",
+                        lambda *a, **k: (_ for _ in ()).throw(
+                            AssertionError("token was read before refusal")))
+    rc = cli.main(["cards", "--config", str(_cfg(tmp_path))])
+    assert rc != 0
+    err = capsys.readouterr().err
+    assert "SWARPH_SELF=cursor-win" in err
+    assert "this process is inside a cell" in err
+    assert "run swarph-me from a human shell" in err
+
+
+def test_as_operator_proceeds_and_stderr_names_both(tmp_path, monkeypatch, capsys):
+    monkeypatch.setenv("SWARPH_SELF", "cursor-win")
+    monkeypatch.setattr(cli, "run_verb", lambda identity, gateway, token, rest: 0)
+    rc = cli.main(["cards", "--as-operator", "--config", str(_cfg(tmp_path))])
+    assert rc == 0
+    err = capsys.readouterr().err
+    assert "cursor-win" in err and "commander" in err
+
+
+def test_self_unset_behaviour_unchanged(tmp_path, monkeypatch, capsys):
+    monkeypatch.delenv("SWARPH_SELF", raising=False)
+    monkeypatch.setattr(cli, "run_verb", lambda identity, gateway, token, rest: 0)
+    rc = cli.main(["cards", "--config", str(_cfg(tmp_path))])
+    assert rc == 0
+    assert "inside a cell" not in capsys.readouterr().err

swarph_cli-0.72.25/tests/test_1214_egress.py

@@ -0,0 +1,336 @@
+"""card #1214 — egress inventory: the build fails when code gains a
+network call that EGRESS.md does not list.
+
+Egress-inventory test pattern after XERJ (github.com/xerj-org/xerj, Apache-2.0),
+engine/crates/xerj-rerank/tests/egress_inventory.rs. Idea only; no code copied.
+
+Walks src/swarph_cli with the AST for network clients (requests, httpx,
+urllib.request, http.client, socket connections, aiohttp, websockets, and
+subprocess argv starting curl/wget/ssh/scp). Every hit must map to an
+EGRESS.md row keyed by (file, client), or this test fails naming file:line.
+"""
+import ast
+import os
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+SRC = ROOT / "src" / "swarph_cli"
+EGRESS = ROOT / "EGRESS.md"
+
+_MODULE_KINDS = {
+    "requests": "requests", "httpx": "httpx", "aiohttp": "aiohttp",
+    "websockets": "websockets", "http.client": "http.client",
+}
+_HTTP_ATTRS = {"get", "post", "put", "delete", "head", "patch", "request"}
+_SUBPROCESS_TOOLS = {"curl", "wget", "ssh", "scp"}
+_CONSTRUCTOR_MODULE = {
+    "Session": "requests", "Client": "httpx",
+    "AsyncClient": "httpx", "ClientSession": "aiohttp",
+}
+
+
+def _constructor_kind(dotted, bindings, fn_bindings):
+    """Client kind for a session/client construction call, in either
+    from-import form (Session()) or attribute form (requests.Session()),
+    else None."""
+    if not dotted:
+        return None
+    attr = dotted.rsplit(".", 1)[-1]
+    module = _CONSTRUCTOR_MODULE.get(attr)
+    if module is None:
+        return None
+    if "." not in dotted:  # bare Name: Session()
+        return f"{module}.{attr}"
+    root = dotted.split(".")[0]
+    if bindings.get(root) == module:
+        return f"{module}.{attr}"
+    return None
+
+
+def _dotted(node):
+    parts = []
+    while isinstance(node, ast.Attribute):
+        parts.append(node.attr)
+        node = node.value
+    if isinstance(node, ast.Name):
+        parts.append(node.id)
+    return ".".join(reversed(parts))
+
+
+def _host_of(text: str):
+    import re as _re
+    m = _re.search(r"://([^/\"'\s]+)", text or "")
+    return m.group(1) if m else None
+
+
+def scan(root: Path):
+    """Return [(relpath, line, client, host)] for every network call under
+    root. host is the literal destination host when the call (or a module
+    constant it references) names one, else None (dynamic/configured)."""
+    hits = []
+    for path in sorted(root.rglob("*.py")):
+        if "__pycache__" in path.parts:
+            continue
+        rel = path.relative_to(root.parent.parent).as_posix() \
+            if root == SRC else path.relative_to(root).as_posix()
+        tree = ast.parse(path.read_text(encoding="utf-8-sig"))
+        bindings = {}     # local name -> module kind
+        fn_bindings = {}  # local name -> client kind (from-imported callables)
+        consts = {}       # module-level string constants
+        opener_vars = set()
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Assign) and isinstance(node.value, ast.Constant) \
+                    and isinstance(node.value.value, str):
+                for t in node.targets:
+                    if isinstance(t, ast.Name):
+                        consts[t.id] = node.value.value
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for a in node.names:
+                    kind = _MODULE_KINDS.get(a.name) or (
+                        "urllib.request" if a.name.startswith("urllib") else
+                        "socket" if a.name == "socket" else None)
+                    if kind:
+                        bindings[a.asname or a.name.split(".")[0]] = kind
+            elif isinstance(node, ast.ImportFrom) and node.module:
+                if node.module.startswith("urllib.request"):
+                    for a in node.names:
+                        if a.name in ("urlopen", "Request"):
+                            fn_bindings[a.asname or a.name] = "urllib.request.urlopen"
+                        elif a.name == "build_opener":
+                            fn_bindings[a.asname or a.name] = "urllib.request.build_opener"
+                elif node.module == "urllib" :
+                    for a in node.names:
+                        if a.name == "request":
+                            bindings[a.asname or a.name] = "urllib.request"
+                elif node.module == "socket":
+                    for a in node.names:
+                        if a.name in ("socket", "create_connection"):
+                            fn_bindings[a.asname or a.name] = f"socket.{a.name}"
+                elif node.module in _MODULE_KINDS:
+                    for a in node.names:
+                        fn_bindings[a.asname or a.name] = _MODULE_KINDS[node.module]
+            elif isinstance(node, ast.Assign) and isinstance(node.value, ast.Call):
+                if _dotted(node.value.func).endswith("build_opener"):
+                    for t in node.targets:
+                        if isinstance(t, ast.Name):
+                            opener_vars.add(t.id)
+        var_kinds = {}  # session variable name -> client kind
+        for node in ast.walk(tree):
+            value = None
+            targets = []
+            if isinstance(node, ast.Assign) and isinstance(node.value, ast.Call):
+                value, targets = node.value, [t for t in node.targets
+                                              if isinstance(t, ast.Name)]
+            elif isinstance(node, (ast.With, ast.AsyncWith)):
+                for item in node.items:
+                    if isinstance(item.context_expr, ast.Call) \
+                            and isinstance(item.optional_vars, ast.Name):
+                        value, targets = item.context_expr, [item.optional_vars]
+            if value is not None:
+                ck = _constructor_kind(_dotted(value.func), bindings, fn_bindings)
+                if ck:
+                    for t in targets:
+                        var_kinds[t.id] = ck
+        for node in ast.walk(tree):
+            if not isinstance(node, ast.Call):
+                continue
+            dotted = _dotted(node.func)
+            root_name = dotted.split(".")[0] if dotted else ""
+            attr = dotted.rsplit(".", 1)[-1] if dotted else ""
+            kind = None
+            if isinstance(node.func, ast.Name) and node.func.id in fn_bindings:
+                kind = fn_bindings[node.func.id]
+            elif isinstance(node.func, ast.Name) and node.func.id in opener_vars:
+                kind = "urllib.request.urlopen"  # opener(...) call
+            elif isinstance(node.func, ast.Attribute) and isinstance(node.func.value, ast.Call) \
+                    and _dotted(node.func.value.func).endswith("build_opener") \
+                    and attr == "open":
+                kind = "urllib.request.urlopen"  # build_opener(...).open(...)
+            elif isinstance(node.func, ast.Attribute) and isinstance(node.func.value, ast.Name) \
+                    and node.func.value.id in opener_vars and attr == "open":
+                kind = "urllib.request.urlopen"  # opener.open(...)
+            elif _constructor_kind(dotted, bindings, fn_bindings):
+                kind = _constructor_kind(dotted, bindings, fn_bindings)
+            elif isinstance(node.func, ast.Attribute) \
+                    and isinstance(node.func.value, ast.Call) \
+                    and _constructor_kind(_dotted(node.func.value.func),
+                                          bindings, fn_bindings):
+                # requests.Session().post(u): call on a fresh construction
+                kind = _constructor_kind(_dotted(node.func.value.func),
+                                         bindings, fn_bindings)
+            elif isinstance(node.func, ast.Attribute) \
+                    and isinstance(node.func.value, ast.Name) \
+                    and node.func.value.id in var_kinds \
+                    and attr in _HTTP_ATTRS:
+                # s = requests.Session(); s.post(u)
+                kind = var_kinds[node.func.value.id]
+            elif dotted.endswith(".urlopen") and bindings.get(root_name) == "urllib.request":
+                kind = "urllib.request.urlopen"
+            elif dotted.endswith(".HTTPConnection") or dotted.endswith(".HTTPSConnection"):
+                if bindings.get(root_name) == "http.client" or root_name == "http":
+                    kind = "http.client"
+            elif dotted in ("socket.socket", "socket.create_connection") \
+                    and bindings.get(root_name) == "socket":
+                kind = dotted
+            elif isinstance(node.func, ast.Name) and node.func.id in (
+                    "Session", "Client", "AsyncClient", "ClientSession"):
+                base = {"Session": "requests", "Client": "httpx",
+                        "AsyncClient": "httpx", "ClientSession": "aiohttp"}[node.func.id]
+                kind = f"{base}.{node.func.id}"
+            elif dotted == "websockets.connect" and bindings.get(root_name) == "websockets":
+                kind = "websockets.connect"
+            elif bindings.get(root_name) in ("requests", "httpx", "aiohttp", "websockets") \
+                    and attr in _HTTP_ATTRS:
+                kind = f"{bindings[root_name]}.{attr}"
+            elif dotted.split(".")[0] == "subprocess" or (
+                    isinstance(node.func, ast.Name)
+                    and node.func.id in ("run", "Popen", "call", "check_output", "check_call")):
+                if node.args:
+                    first = node.args[0]
+                    tool = None
+                    if isinstance(first, (ast.List, ast.Tuple)) and first.elts \
+                            and isinstance(first.elts[0], ast.Constant):
+                        tool = str(first.elts[0].value).split()[0] if first.elts[0].value else None
+                    elif isinstance(first, ast.Constant) and isinstance(first.value, str):
+                        tool = first.value.split()[0] if first.value.split() else None
+                    if tool in _SUBPROCESS_TOOLS:
+                        kind = f"subprocess:{tool}"
+            if kind:
+                host = None
+                for sub in ast.walk(node):
+                    if isinstance(sub, ast.Constant) and isinstance(sub.value, str):
+                        host = _host_of(sub.value)
+                    elif isinstance(sub, ast.Name) and sub.id in consts:
+                        host = _host_of(consts[sub.id])
+                    if host:
+                        break
+                hits.append((rel, node.lineno, kind, host))
+    return hits
+
+
+def _egress_rows(text: str):
+    """Rows keyed (file, client) -> destination text. A hit with a literal
+    host is mapped only when its row's destination names that host (M2: a
+    new destination in a listed file fails)."""
+    rows = {}
+    for line in text.splitlines():
+        line = line.strip()
+        if not line.startswith("|") or "---" in line:
+            continue
+        cells = [c.strip() for c in line.strip("|").split("|")]
+        if len(cells) >= 3 and cells[0].endswith(".py"):
+            rows.setdefault((cells[0], cells[1]), []).append(cells[2])
+    return rows
+
+
+def unmapped(hits, rows):
+    out = []
+    for rel, ln, kind, host in hits:
+        dests = rows.get((rel, kind))
+        if dests is None:
+            out.append((rel, ln, kind, host))
+        elif host is not None and not any(host in d for d in dests):
+            out.append((rel, ln, kind, host))
+    return out
+
+
+def test_every_network_call_is_listed_in_egress_md():
+    hits = scan(SRC)
+    assert hits, "scanner found no network calls — the walk is broken"
+    rows = _egress_rows(EGRESS.read_text(encoding="utf-8"))
+    bad = unmapped(hits, rows)
+    assert not bad, "unlisted network calls (add an EGRESS.md row): " + \
+        ", ".join(f"{f}:{ln} ({k} -> {h})" for f, ln, k, h in bad)
+
+
+def test_mutant_unlisted_requests_get_fails(tmp_path):
+    """Mutant check: an unlisted requests.get in a scratch copy must fail."""
+    pkg = tmp_path / "swarph_cli"
+    pkg.mkdir()
+    (pkg / "mod.py").write_text(
+        "import requests\n\ndef go():\n    return requests.get('https://example.invalid')\n")
+    hits = scan(pkg)
+    assert hits and hits[0][2] == "requests.get"
+    assert unmapped(hits, {}) == hits
+    assert unmapped(hits, {("mod.py", "requests.get"): ["example.invalid"]}) == []
+
+
+_MUTANTS = {
+    # M2: a NEW destination in a file that is already listed
+    "M2_new_destination_in_listed_file": (
+        "src/swarph_cli/commands/version.py",
+        "import urllib.request\n\ndef go():\n"
+        "    return urllib.request.urlopen('https://evil.example/x')\n"),
+    "M3_http_client": (
+        "src/swarph_cli/mod.py",
+        "import http.client\n\ndef go():\n"
+        "    return http.client.HTTPSConnection('example.invalid')\n"),
+    "M4_requests_Session": (
+        "src/swarph_cli/mod.py",
+        "from requests import Session\n\ndef go():\n    return Session()\n"),
+    "M5_from_urllib_import_request": (
+        "src/swarph_cli/mod.py",
+        "from urllib import request\n\ndef go():\n"
+        "    return request.urlopen('https://example.invalid')\n"),
+    "M6_build_opener_open": (
+        "src/swarph_cli/mod.py",
+        "import urllib.request\n\ndef go():\n"
+        "    return urllib.request.build_opener().open('https://example.invalid')\n"),
+    "M7_httpx_Client": (
+        "src/swarph_cli/mod.py",
+        "from httpx import Client\n\ndef go():\n    return Client()\n"),
+    "M8_aiohttp_ClientSession": (
+        "src/swarph_cli/mod.py",
+        "from aiohttp import ClientSession\n\ndef go():\n    return ClientSession()\n"),
+    "M13_websockets_connect": (
+        "src/swarph_cli/mod.py",
+        "import websockets\n\ndef go():\n    return websockets.connect('wss://example.invalid')\n"),
+    "M9_socket_create_connection": (
+        "src/swarph_cli/mod.py",
+        "import socket\n\ndef go():\n"
+        "    return socket.create_connection(('example.invalid', 443))\n"),
+    "M10_subprocess_curl": (
+        "src/swarph_cli/mod.py",
+        "import subprocess\n\ndef go():\n"
+        "    return subprocess.run(['curl', 'https://example.invalid/x'])\n"),
+    "M11_subprocess_ssh": (
+        "src/swarph_cli/mod.py",
+        "import subprocess\n\ndef go():\n"
+        "    return subprocess.run(['ssh', 'example.invalid', 'true'])\n"),
+    "M14_requests_Session_attr_post": (
+        "src/swarph_cli/mod.py",
+        "import requests\n\ndef go(u):\n"
+        "    return requests.Session().post(u)\n"),
+    "M15_requests_Session_var_post": (
+        "src/swarph_cli/mod.py",
+        "import requests\n\ndef go(u):\n"
+        "    s = requests.Session()\n    return s.post(u)\n"),
+    "M16_httpx_Client_attr": (
+        "src/swarph_cli/mod.py",
+        "import httpx\n\ndef go(u):\n    return httpx.Client().post(u)\n"),
+    "M17_aiohttp_ClientSession_attr": (
+        "src/swarph_cli/mod.py",
+        "import aiohttp\n\nasync def go():\n"
+        "    async with aiohttp.ClientSession() as s:\n        return s\n"),
+}
+
+
+import pytest as _pytest
+
+
+@_pytest.mark.parametrize("name", sorted(_MUTANTS))
+def test_mutants_are_detected_and_unmapped(name, tmp_path):
+    rel, src = _MUTANTS[name]
+    pkg = tmp_path / "swarph_cli"
+    (pkg / "commands").mkdir(parents=True)
+    target = pkg / Path(rel).name if False else tmp_path / Path(rel).name
+    target.write_text(src)
+    hits = scan(tmp_path)
+    assert hits, f"{name}: scanner missed the mutant"
+    rows = _egress_rows(EGRESS.read_text(encoding="utf-8"))
+    if name.startswith("M2"):
+        # place the mutant IN the listed file: only its new destination
+        # (evil.example, not in that file's row) may unmap it
+        hits = [(rel, ln, kind, host) for _, ln, kind, host in hits]
+    assert unmapped(hits, rows), f"{name}: mutant was silently mapped"

swarph_cli-0.72.25/tests/test_1219_egress_probe.py

@@ -0,0 +1,109 @@
+"""card #1219 — runtime egress probe.
+
+The probe runs under bwrap --unshare-net. An unlisted connect fails it.
+A host that cannot prove isolation exits with isolation-unproven.
+On main this file's first assertion fails: tests/egress_probe.py is absent.
+"""
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parent.parent
+PROBE = ROOT / "tests" / "egress_probe.py"
+
+
+def _run(args, **env):
+    assert PROBE.is_file(), "runtime egress probe is not in the tree"
+    merged = os.environ.copy()
+    merged.update(env)
+    return subprocess.run(
+        [sys.executable, str(PROBE), *args],
+        capture_output=True, text=True, env=merged, timeout=60)
+
+
+@pytest.mark.skipif(sys.platform != "linux", reason="bwrap --unshare-net is Linux")
+def test_os_system_curl_is_an_unlisted_connect():
+    out = _run(["--mutant", "os-system-curl"])
+    assert out.returncode == 1, out.stderr
+    assert "203.0.113.2" in out.stderr
+
+
+@pytest.mark.skipif(sys.platform != "linux", reason="bwrap --unshare-net is Linux")
+def test_absolute_curl_is_an_unlisted_connect():
+    out = _run(["--mutant", "abs-curl"])
+    assert out.returncode == 1, out.stderr
+    assert "203.0.113.3" in out.stderr
+
+
+@pytest.mark.skipif(sys.platform != "linux", reason="bwrap --unshare-net is Linux")
+def test_asyncio_ssh_is_an_unlisted_connect():
+    out = _run(["--mutant", "asyncio-ssh"])
+    assert out.returncode == 1, out.stderr
+    assert "203.0.113.4" in out.stderr
+
+
+def test_missing_bwrap_fails_closed_with_a_named_reason():
+    out = _run(["--isolation"], EGRESS_PROBE_BWRAP="/no/such/bwrap")
+    assert out.returncode == 2, out.stderr
+    assert "isolation-unproven: bwrap missing" in out.stderr
+
+
+@pytest.mark.skipif(sys.platform != "linux", reason="bwrap --unshare-net is Linux")
+def test_ipv6_literal_connect_is_caught():
+    out = _run(["--mutant", "ipv6"])
+    assert out.returncode == 1, out.stderr
+    assert "2001:db8::1" in out.stderr
+
+
+@pytest.mark.skipif(sys.platform != "linux", reason="bwrap --unshare-net is Linux")
+def test_non_isolating_bwrap_shim_exits_2(tmp_path):
+    shim = tmp_path / "bwrap"
+    shim.write_text(
+        "#!/bin/sh\n"
+        "while [ $# -gt 0 ]; do\n"
+        "  case \"$1\" in\n"
+        "    *strace) break ;;\n"
+        "  esac\n"
+        "  shift\n"
+        "done\n"
+        "exec \"$@\"\n",
+        encoding="utf-8")
+    shim.chmod(0o700)
+    out = _run(["--isolation"], EGRESS_PROBE_BWRAP=str(shim))
+    assert out.returncode == 2, out.stderr
+    assert "isolation-unproven:" in out.stderr
+    assert "ENETUNREACH" in out.stderr
+
+
+@pytest.mark.skipif(sys.platform != "linux", reason="bwrap --unshare-net is Linux")
+def test_planted_unlisted_connect_in_src_fails_the_probe(tmp_path):
+    src = tmp_path / "src" / "swarph_cli"
+    src.mkdir(parents=True)
+    (src / "__init__.py").write_text("", encoding="utf-8")
+    # Fixed mutant, not external input. The test reaches it by calling leak().
+    (src / "stall_alert.py").write_text(
+        "import os\n"
+        "def leak():\n"
+        "    os.system('curl --max-time 1 -s -o /dev/null "
+        "http://203.0.113.50/')\n",
+        encoding="utf-8")
+    tests = tmp_path / "tests"
+    tests.mkdir()
+    (tests / "test_zz_leak.py").write_text(
+        "import sys\n"
+        "from pathlib import Path\n"
+        "sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'src'))\n"
+        "from swarph_cli.stall_alert import leak\n"
+        "def test_leak():\n"
+        "    leak()\n",
+        encoding="utf-8")
+    assert PROBE.is_file(), "runtime egress probe is not in the tree"
+    sys.path.insert(0, str(PROBE.parent))
+    import egress_probe
+    assert hasattr(egress_probe, "run_pytest")
+    # Empty allowlist: the planted 203.0.113.50 literal is unlisted.
+    code = egress_probe.run_pytest(tmp_path, ["tests/test_zz_leak.py"], set())
+    assert code == 1, code

{swarph_cli-0.72.24 → swarph_cli-0.72.25}/tests/test_402_one_identity_resolver.py

@@ -121,7 +121,10 @@ def test_mcp_codegraph_identity_is_SELF_first(clean, monkeypatch):
 # swarph_cli is not importable, so their module scope is stdlib-only (pinned by
 # test_cell_selfcheck / test_139_tool_probe). They cannot import swarph_cli.identity.
 # Both read SWARPH_SELF directly and neither falls back to a peer name.
-_BARE_FILE_MODULES = {"commands/cell_selfcheck.py", "commands/cell_probe.py"}
+_BARE_FILE_MODULES = {"commands/cell_selfcheck.py", "commands/cell_probe.py",
+                      # card #1203: operator/cli.py reads SWARPH_SELF ONLY to
+                      # REFUSE inside a cell, never to resolve an identity.
+                      "operator/cli.py"}
 
 
 def test_no_module_but_identity_reads_an_identity_variable():

{swarph_cli-0.72.24 → swarph_cli-0.72.25}/tests/test_operator_me.py

@@ -37,16 +37,19 @@ def _module_files() -> list[Path]:
     return sorted(OPERATOR_ROOT.rglob("*.py"))
 
 
-def test_operator_package_never_mentions_swarph_self():
+def test_operator_package_mentions_swarph_self_only_to_refuse():
+    """Card #1203 overturns the never-mention rule: cli.py reads SWARPH_SELF
+    ONLY to refuse inside a cell. No other operator module may mention it."""
     offenders = []
     for path in _module_files():
+        if path.name == "cli.py":
+            continue
         text = path.read_text(encoding="utf-8")
         if "SWARPH_SELF" in text:
             offenders.append(str(path.relative_to(OPERATOR_ROOT.parent.parent)))
-    assert not offenders, (
-        "swarph_cli.operator must not mention SWARPH_SELF anywhere — "
-        f"found in: {offenders}"
-    )
+    assert not offenders, f"SWARPH_SELF mentioned outside the refusal: {offenders}"
+    cli_text = (OPERATOR_ROOT / "cli.py").read_text(encoding="utf-8")
+    assert "this process is inside a cell" in cli_text
 
 
 def test_operator_import_graph_forbids_cell_identity_modules():