swarph-cli 0.67.2__tar.gz → 0.68.0__tar.gz

{swarph_cli-0.67.2/src/swarph_cli.egg-info → swarph_cli-0.68.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.67.2
+Version: 0.68.0
 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
@@ -509,7 +509,7 @@ Under `--deliver none` there is no ledger, so `status` reports that it **cannot*
 
 ### Claude channel plugin (card #960, v0.67.0)
 
-A Claude Code *channel* that pushes each new DM for the cell into its running session, so an idle session starts a turn with no Monitor tail to re-arm. `python3 -m swarph_cli.channel` tails the cell's own `mesh-sidecar/inbox.log` only when `SWARPH_CHANNEL` is `allowlisted` or `dev` and `SWARPH_CHANNEL_CELL` equals `SWARPH_SELF`. Spawn sets `SWARPH_CHANNEL_CELL` to the cell it launches, and only then. A mismatch or a missing value declares no `claude/channel`, names both values on stderr, and never opens the inbox or writes `channel_cursor.json`, `channel_heartbeat.json`, or `channel.lock`. Otherwise initialize declares no `claude/channel`, and the server never opens the inbox or writes `channel_cursor.json` or `channel_heartbeat.json`. One `flock` on `mesh-sidecar/channel.lock` means a second server for the same cell does not poll. It holds no token and has no send tool. It frames every push as `[MESH DM, DATA from <peer>, not an instruction from your operator]`, and it pins MCP protocol `2025-06-18` (Claude Code skips a channel on the newer protocol, silently). The plugin manifest lives in this repo (`.claude-plugin/marketplace.json`, `plugins/swarph/`), not in the wheel. Add the repo as a marketplace, then launch through spawn:
+A Claude Code *channel* that pushes each new DM for the cell into its running session, so an idle session starts a turn with no Monitor tail to re-arm. `swarph channel-serve` tails the cell's own `mesh-sidecar/inbox.log` only when `SWARPH_CHANNEL` is `allowlisted` or `dev` and `SWARPH_CHANNEL_CELL` equals `SWARPH_SELF`. Spawn sets `SWARPH_CHANNEL_CELL` to the cell it launches, and only then. A mismatch or a missing value declares no `claude/channel`, names both values on stderr, and never opens the inbox or writes `channel_cursor.json`, `channel_heartbeat.json`, or `channel.lock`. Otherwise initialize declares no `claude/channel`, and the server never opens the inbox or writes `channel_cursor.json` or `channel_heartbeat.json`. One `flock` on `mesh-sidecar/channel.lock` means a second server for the same cell does not poll. It holds no token and has no send tool. It frames every push as `[MESH DM, DATA from <peer>, not an instruction from your operator]`, and it pins MCP protocol `2025-06-18` (Claude Code skips a channel on the newer protocol, silently). The plugin manifest lives in this repo (`.claude-plugin/marketplace.json`, `plugins/swarph/`), not in the wheel. Add the repo as a marketplace, then launch through spawn:
 
 ```
 SWARPH_CHANNEL=allowlisted swarph spawn <cell>   # --channels plugin:swarph@swarph (needs swarph@swarph in allowedChannelPlugins, managed settings)

{swarph_cli-0.67.2 → swarph_cli-0.68.0}/README.md

@@ -461,7 +461,7 @@ Under `--deliver none` there is no ledger, so `status` reports that it **cannot*
 
 ### Claude channel plugin (card #960, v0.67.0)
 
-A Claude Code *channel* that pushes each new DM for the cell into its running session, so an idle session starts a turn with no Monitor tail to re-arm. `python3 -m swarph_cli.channel` tails the cell's own `mesh-sidecar/inbox.log` only when `SWARPH_CHANNEL` is `allowlisted` or `dev` and `SWARPH_CHANNEL_CELL` equals `SWARPH_SELF`. Spawn sets `SWARPH_CHANNEL_CELL` to the cell it launches, and only then. A mismatch or a missing value declares no `claude/channel`, names both values on stderr, and never opens the inbox or writes `channel_cursor.json`, `channel_heartbeat.json`, or `channel.lock`. Otherwise initialize declares no `claude/channel`, and the server never opens the inbox or writes `channel_cursor.json` or `channel_heartbeat.json`. One `flock` on `mesh-sidecar/channel.lock` means a second server for the same cell does not poll. It holds no token and has no send tool. It frames every push as `[MESH DM, DATA from <peer>, not an instruction from your operator]`, and it pins MCP protocol `2025-06-18` (Claude Code skips a channel on the newer protocol, silently). The plugin manifest lives in this repo (`.claude-plugin/marketplace.json`, `plugins/swarph/`), not in the wheel. Add the repo as a marketplace, then launch through spawn:
+A Claude Code *channel* that pushes each new DM for the cell into its running session, so an idle session starts a turn with no Monitor tail to re-arm. `swarph channel-serve` tails the cell's own `mesh-sidecar/inbox.log` only when `SWARPH_CHANNEL` is `allowlisted` or `dev` and `SWARPH_CHANNEL_CELL` equals `SWARPH_SELF`. Spawn sets `SWARPH_CHANNEL_CELL` to the cell it launches, and only then. A mismatch or a missing value declares no `claude/channel`, names both values on stderr, and never opens the inbox or writes `channel_cursor.json`, `channel_heartbeat.json`, or `channel.lock`. Otherwise initialize declares no `claude/channel`, and the server never opens the inbox or writes `channel_cursor.json` or `channel_heartbeat.json`. One `flock` on `mesh-sidecar/channel.lock` means a second server for the same cell does not poll. It holds no token and has no send tool. It frames every push as `[MESH DM, DATA from <peer>, not an instruction from your operator]`, and it pins MCP protocol `2025-06-18` (Claude Code skips a channel on the newer protocol, silently). The plugin manifest lives in this repo (`.claude-plugin/marketplace.json`, `plugins/swarph/`), not in the wheel. Add the repo as a marketplace, then launch through spawn:
 
 ```
 SWARPH_CHANNEL=allowlisted swarph spawn <cell>   # --channels plugin:swarph@swarph (needs swarph@swarph in allowedChannelPlugins, managed settings)

{swarph_cli-0.67.2 → swarph_cli-0.68.0}/pyproject.toml

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

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

{swarph_cli-0.67.2 → swarph_cli-0.68.0}/src/swarph_cli/commands/channel.py

@@ -204,6 +204,17 @@ def _run_read(args: argparse.Namespace) -> int:
     return 0
 
 
+def run_channel_serve(argv: list | None = None) -> int:
+    """Run the DM channel MCP server on this install's interpreter.
+
+    The plugin used to exec ``python3 -m swarph_cli.channel``. On a pipx
+    install that python3 cannot import swarph_cli. ``swarph channel-serve``
+    is the console script, so the venv that owns ``swarph`` owns the server.
+    """
+    from swarph_cli.channel import main as serve_main
+    return serve_main(list(argv) if argv else None)
+
+
 def run_channel(argv: list) -> int:
     p = _build_parser()
     args = p.parse_args(argv)

{swarph_cli-0.67.2 → swarph_cli-0.68.0}/src/swarph_cli/commands/codegraph.py

@@ -237,10 +237,21 @@ def structural_query(term, *, index_path, caller_cell, limit=8, allowlist=None)
                 f"WHERE e.dst_symbol=? AND e.edge_type='calls' AND src.repo IN ({qmarks})",
                 (sid, *sorted(allowed))
             ).fetchone()[0]
+            # Ruling C (card #559, 2026-09-10): B's filter above is unchanged.
+            # edges_truncated is true when that filter dropped at least one call
+            # edge because the peer cannot read the caller's repo. Existence
+            # only — a count of the hidden edges would be the #194 leak again.
+            dropped = con.execute(
+                f"SELECT 1 FROM edges e JOIN symbols src ON src.id = e.src_symbol "
+                f"WHERE e.dst_symbol=? AND e.edge_type='calls' AND src.repo NOT IN ({qmarks}) "
+                f"LIMIT 1",
+                (sid, *sorted(allowed)),
+            ).fetchone()
             out.append({"repo": repo, "name": name, "kind": kind,
                         "file_path": fp, "start_line": line, "callers": callers, "score": score,
                         "qualified_name": qualified_name or "", "docstring": docstring or "",
-                        "signature": signature or ""})
+                        "signature": signature or "",
+                        "edges_truncated": dropped is not None})
         return out
     # OperationalError (lock/busy, or a malformed FTS5 MATCH query string) OR DatabaseError
     # (corrupt/non-sqlite file) — both are sqlite3.Error siblings — fail safe (A2), never raise/hang.
@@ -279,6 +290,8 @@ def format_human(rows, term) -> str:
         loc = f"{r['file_path']}:{r['start_line']}"
         n = r["callers"]
         callers = f"  ({n} caller{'s' if n != 1 else ''})" if n else ""
+        if r.get("edges_truncated"):
+            callers += "  [edges_truncated]"
         lines.append(f"{i}. {r['name']}  [{r['kind']}]  {r['repo']}  {loc}{callers}")
         if r["signature"]:
             lines.append(f"     {r['signature']}")

{swarph_cli-0.67.2 → swarph_cli-0.68.0}/src/swarph_cli/commands/mcp_server.py

@@ -188,6 +188,7 @@ def _codegraph_query(query: str, *, limit: int = 8) -> list[dict]:
                 "start_line": r["start_line"],
                 "signature": r["signature"],
                 "callers": r["callers"],
+                "edges_truncated": bool(r.get("edges_truncated")),
             }
             for r in rows
         ]

{swarph_cli-0.67.2 → swarph_cli-0.68.0}/src/swarph_cli/commands/mesh.py

@@ -29,6 +29,7 @@ import sys
 import time
 import urllib.error
 import urllib.parse
+import uuid
 
 import swarph_cli
 import urllib.request
@@ -78,6 +79,21 @@ def _build_parser() -> argparse.ArgumentParser:
     send = sub.add_parser("send", help="send a mesh DM")
     send.add_argument("to", help="recipient peer name")
     send.add_argument("--kind", required=True, help="message kind")
+    send.add_argument(
+        "--thread",
+        default=None,
+        metavar="HANDLE",
+        help="join HANDLE, or 'new' to originate a card-less thread (#623). "
+             "The printed handle is one pasteable token (the gateway UUID). "
+             "A post whose from_node equals to_node, or whose from_node is "
+             "in --cc, is refused (#185 / #409 — no self-wake).",
+    )
+    send.add_argument(
+        "--cc",
+        action="append",
+        default=[],
+        help="extra recipient (repeatable). from_node in this list is refused.",
+    )
     add_content_args(send)
     _add_common(send)
 
@@ -118,8 +134,25 @@ def _build_parser() -> argparse.ArgumentParser:
         help="show the inbox WITHOUT marking anything read (default: reading CONSUMES -- "
              "it marks every DM shown as read for the resolved identity)",
     )
+    inbox.add_argument(
+        "--thread",
+        default=None,
+        metavar="HANDLE",
+        help="read this thread's ordered set (GET /threads/{handle}) instead of "
+             "the inbox. Non-destructive. Handle is the one-token UUID.",
+    )
     _add_common(inbox)
 
+    threads = sub.add_parser(
+        "threads",
+        help="list threads this caller participates in (#623). "
+             "Peer identity tokens are scoped by the gateway (FM3); this "
+             "command does not widen that.",
+    )
+    threads.add_argument("--limit", type=int, default=50, help="max threads")
+    threads.add_argument("--json", action="store_true", help="print raw JSON")
+    _add_common(threads)
+
     register = sub.add_parser("register", help="self-register this peer")
     register.add_argument(
         "--url",
@@ -577,6 +610,56 @@ def _check_recipient(to: str, gateway: str, token: str) -> str | None:
     return msg
 
 
+def _self_wake_refusal(from_node: str, to_node: str, cc: list) -> Optional[str]:
+    """#185 / #409: a participant must not be woken by their own post.
+
+    One post, one to_node — the 226 self-wakes were the addressed peer BEING
+    the poster, not a fan-out. Refuse from_node == to_node and from_node in cc.
+    Returns a message or None.
+    """
+    if from_node and to_node and from_node == to_node:
+        return (
+            f"swarph mesh send: REFUSED — from_node {from_node!r} equals to_node. "
+            f"A post must not wake its own sender (#185 / #409)."
+        )
+    cc_hits = [c for c in (cc or []) if c == from_node]
+    if cc_hits:
+        return (
+            f"swarph mesh send: REFUSED — from_node {from_node!r} is in --cc. "
+            f"A post must not wake its own sender (#185 / #409)."
+        )
+    return None
+
+
+def _originate_thread(gateway: str, token: str, from_node: str, to_node: str) -> tuple:
+    """Mint a card-less thread via POST /threads. Returns (uuid, None) or (None, err).
+
+    A bare client UUID on POST /messages 500s — the row must exist in
+    claude_threads first. thread_name is an internal key (idempotent mint);
+    the HANDLE the caller pastes is the UUID, one token, no quoting.
+    """
+    stamp = uuid.uuid4().hex[:12]
+    # Gateway thread_name max 128. Peers are max 64 each; keep the name short.
+    name = f"{from_node}↔{to_node}:t{stamp}"
+    if len(name) > 128:
+        name = f"t{stamp}"
+    status, payload = _post_json(
+        f"{gateway.rstrip('/')}/threads",
+        {"thread_name": name},
+        token,
+    )
+    if status < 200 or status >= 300 or not isinstance(payload, dict):
+        detail = payload.get("detail", payload) if isinstance(payload, dict) else payload
+        return None, f"gateway {status}: {detail}"
+    handle = payload.get("thread_uuid")
+    if not handle or not isinstance(handle, str):
+        return None, f"gateway minted no thread_uuid: {payload}"
+    # One token: no whitespace, no shell metacharacters.
+    if not re.fullmatch(r"[0-9a-fA-F-]{36}", handle):
+        return None, f"handle is not a pasteable UUID token: {handle!r}"
+    return handle, None
+
+
 def _run_send(args: argparse.Namespace) -> int:
     try:
         content = resolve_content(args.content, getattr(args, "content_file", None))
@@ -585,12 +668,36 @@ def _run_send(args: argparse.Namespace) -> int:
         return 1
     self_name = _resolve_self_name(args.self_name)
     token = _resolve_token(self_name, args.token_file)
+    cc = list(getattr(args, "cc", None) or [])
+    refusal = _self_wake_refusal(self_name, args.to, cc)
+    if refusal:
+        print(refusal, file=sys.stderr)
+        return 1
     body = {
         "from_node": self_name,
         "to_node": args.to,
         "kind": args.kind,
         "content": content,
     }
+    if cc:
+        body["cc"] = cc
+    thread_arg = getattr(args, "thread", None)
+    if thread_arg:
+        if thread_arg == "new":
+            handle, err = _originate_thread(args.gateway, token, self_name, args.to)
+            if err:
+                print(f"swarph mesh send: cannot originate thread — {err}", file=sys.stderr)
+                return 1
+        else:
+            handle = thread_arg.strip()
+            if not re.fullmatch(r"[0-9a-fA-F-]{36}", handle):
+                print(
+                    f"swarph mesh send: REFUSED — thread handle {handle!r} is not "
+                    f"one pasteable UUID token (or 'new').",
+                    file=sys.stderr,
+                )
+                return 1
+        body["thread_id"] = handle
     refusal = _check_recipient(args.to, args.gateway, token)
     if refusal:
         print(refusal, file=sys.stderr)
@@ -605,10 +712,72 @@ def _run_send(args: argparse.Namespace) -> int:
         detail = payload.get("detail", "<gateway error>")
         print(f"swarph mesh send: gateway {status}: {detail}", file=sys.stderr)
         return 1
-    print(
+    line = (
         f"sent id={payload.get('id')} from={payload.get('from_node')} "
         f"to={payload.get('to_node')} kind={payload.get('kind')}"
     )
+    handle_out = payload.get("thread_id") or body.get("thread_id")
+    if handle_out:
+        line += f" thread={handle_out}"
+    print(line)
+    return 0
+
+
+def _run_inbox_thread(args: argparse.Namespace, self_name: str, handle: str) -> int:
+    """Ordered set for one thread. Non-destructive. FM3 scoping is the gateway's."""
+    handle = (handle or "").strip()
+    if not re.fullmatch(r"[0-9a-fA-F-]{36}", handle):
+        print(
+            f"swarph mesh inbox: REFUSED — thread handle {handle!r} is not "
+            f"one pasteable UUID token.",
+            file=sys.stderr,
+        )
+        return 1
+    token = _resolve_token(self_name, args.token_file)
+    url = f"{args.gateway.rstrip('/')}/threads/{handle}?limit={int(args.limit)}"
+    status, payload = _http_get_json(url, token)
+    if status < 200 or status >= 300:
+        detail = payload.get("detail", "<gateway error>") if isinstance(payload, dict) else payload
+        print(f"swarph mesh inbox: gateway {status}: {detail}", file=sys.stderr)
+        return 1
+    msgs = payload.get("messages") if isinstance(payload, dict) else None
+    if msgs is None:
+        print(f"swarph mesh inbox: unexpected /threads shape: {payload}", file=sys.stderr)
+        return 1
+    if args.json:
+        print(json.dumps(payload, indent=2, default=str))
+        return 0
+    print(f"thread {handle} ({len(msgs)} message(s), identity {self_name})")
+    for dm in msgs:
+        print(_format_inbox_line(dm))
+    if not msgs:
+        print("  empty")
+    return 0
+
+
+def _run_threads(args: argparse.Namespace) -> int:
+    """List threads. Gateway scopes a peer-identity token to participants (FM3)."""
+    self_name = _resolve_self_name(args.self_name)
+    token = _resolve_token(self_name, args.token_file)
+    url = f"{args.gateway.rstrip('/')}/threads?limit={int(args.limit)}"
+    status, payload = _http_get_json(url, token)
+    if status < 200 or status >= 300:
+        detail = payload.get("detail", "<gateway error>") if isinstance(payload, dict) else payload
+        print(f"swarph mesh threads: gateway {status}: {detail}", file=sys.stderr)
+        return 1
+    rows = payload.get("threads") if isinstance(payload, dict) else None
+    if rows is None:
+        print(f"swarph mesh threads: unexpected shape: {payload}", file=sys.stderr)
+        return 1
+    if args.json:
+        print(json.dumps(payload, indent=2, default=str))
+        return 0
+    print(f"threads {self_name} ({len(rows)})")
+    for r in rows:
+        uid = r.get("thread_uuid") or ""
+        topic = sanitize_terminal(r.get("topic") or "")
+        pair = sanitize_terminal(r.get("peer_pair") or "")
+        print(f"{uid}  {pair}  {topic}")
     return 0
 
 
@@ -814,6 +983,9 @@ def _mark_read(gateway: str, token: str, messages: list) -> None:
 
 def _run_inbox(args: argparse.Namespace) -> int:
     self_name, id_source = _resolve_self_with_source(args.self_name)
+    thread_handle = getattr(args, "thread", None)
+    if thread_handle:
+        return _run_inbox_thread(args, self_name, thread_handle)
 
     # >>> A DESTRUCTIVE READ UNDER AN UNNAMED IDENTITY IS REFUSED, NOT WARNED. <<<
     # Printing the identity was the first fix and it is not sufficient, for two
@@ -2869,6 +3041,8 @@ def run_mesh(argv: list[str]) -> int:
             return _run_reply(args)
         if args.command == "inbox":
             return _run_inbox(args)
+        if args.command == "threads":
+            return _run_threads(args)
         if args.command == "register":
             return _run_register(args)
         if args.command == "peers":

{swarph_cli-0.67.2 → swarph_cli-0.68.0}/src/swarph_cli/commands/spawn.py

@@ -1234,6 +1234,22 @@ def _powershell_quote(value: str) -> str:
     return "'" + value.replace("'", "''") + "'"
 
 
+def _reentry_env_assignments() -> list[tuple[str, str]]:
+    """Env a new tmux session must be given. It inherits the server, not us.
+
+    SWARPH_SPAWN is the loop guard. SWARPH_CHANNEL and SWARPH_CHANNEL_CELL
+    are forwarded only when this process actually has them: a hop that drops
+    them re-enters spawn with no channel, and the inner spawn never adds
+    --channels (#975).
+    """
+    pairs = [("SWARPH_SPAWN", "1")]
+    for key in ("SWARPH_CHANNEL", "SWARPH_CHANNEL_CELL"):
+        value = os.environ.get(key) or ""
+        if value:
+            pairs.append((key, value))
+    return pairs
+
+
 def _tmux_session_command(tmux: str, name: str, cwd: Path) -> list[str]:
     """Build the create command for real tmux or Windows psmux.
 
@@ -1241,9 +1257,13 @@ def _tmux_session_command(tmux: str, name: str, cwd: Path) -> list[str]:
     Set the working directory and loop-guard in its PowerShell child instead.
     """
     reentry = _swarph_reentry_binary()
+    env_pairs = _reentry_env_assignments()
     if sys.platform == "win32":
+        assigns = "; ".join(
+            f"$env:{key}={_powershell_quote(value)}" for key, value in env_pairs
+        )
         command = (
-            "$env:SWARPH_SPAWN='1'; "
+            f"{assigns}; "
             f"Set-Location -LiteralPath {_powershell_quote(str(cwd))}; "
             f"& {_powershell_quote(reentry)} spawn {_powershell_quote(name)}"
         )
@@ -1252,11 +1272,11 @@ def _tmux_session_command(tmux: str, name: str, cwd: Path) -> list[str]:
             "powershell.exe", "-NoProfile", "-ExecutionPolicy", "Bypass",
             "-Command", command,
         ]
-    return [
-        tmux, "new-session", "-d", "-s", name,
-        "-c", str(cwd), "-e", "SWARPH_SPAWN=1",
-        reentry, "spawn", name,
-    ]
+    cmd = [tmux, "new-session", "-d", "-s", name, "-c", str(cwd)]
+    for key, value in env_pairs:
+        cmd.extend(["-e", f"{key}={value}"])
+    cmd.extend([reentry, "spawn", name])
+    return cmd
 
 
 def _tmux_create_session(tmux: str, name: str, cwd: Path) -> bool:

{swarph_cli-0.67.2 → swarph_cli-0.68.0}/src/swarph_cli/guide/GUIDE.md

@@ -494,6 +494,7 @@ answers `--help`; hook-plumbing verbs are the callbacks hooks invoke, not comman
 - `swarph brain-ask` -- search the swarph-brain memory with a question; optional $0 synthesis.
 - `swarph cell` -- capture-at-birth operator surface for a cell (subcommands; see its --help).
 - `swarph channel` -- channels control plane: create, list, join, leave, members, post, read (see [Channels](#channels)).
+- `swarph channel-serve` -- the DM channel MCP server, on this install's interpreter (not system python3).
 - `swarph chat` -- interactive REPL against a provider.
 - `swarph codegraph` -- structural code search over a local index (see [Code and history](#code-and-history)).
 - `swarph codegraph-hook` -- hook plumbing: the structural-search companion Claude Code hooks call.

{swarph_cli-0.67.2 → swarph_cli-0.68.0}/src/swarph_cli/main.py

@@ -119,6 +119,7 @@ _VERB_HANDLERS: dict[str, str] = {
     "gateway": "swarph_cli.commands.gateway.run_gateway",
     "service": "swarph_cli.commands.service.run_service",
     "channel": "swarph_cli.commands.channel.run_channel",
+    "channel-serve": "swarph_cli.commands.channel.run_channel_serve",
     "event": "swarph_cli.commands.event.run_event",
     "schedule": "swarph_cli.commands.schedule.run_schedule",
     "lane": "swarph_cli.commands.lane.run_lane",

{swarph_cli-0.67.2 → swarph_cli-0.68.0/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.67.2
+Version: 0.68.0
 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
@@ -509,7 +509,7 @@ Under `--deliver none` there is no ledger, so `status` reports that it **cannot*
 
 ### Claude channel plugin (card #960, v0.67.0)
 
-A Claude Code *channel* that pushes each new DM for the cell into its running session, so an idle session starts a turn with no Monitor tail to re-arm. `python3 -m swarph_cli.channel` tails the cell's own `mesh-sidecar/inbox.log` only when `SWARPH_CHANNEL` is `allowlisted` or `dev` and `SWARPH_CHANNEL_CELL` equals `SWARPH_SELF`. Spawn sets `SWARPH_CHANNEL_CELL` to the cell it launches, and only then. A mismatch or a missing value declares no `claude/channel`, names both values on stderr, and never opens the inbox or writes `channel_cursor.json`, `channel_heartbeat.json`, or `channel.lock`. Otherwise initialize declares no `claude/channel`, and the server never opens the inbox or writes `channel_cursor.json` or `channel_heartbeat.json`. One `flock` on `mesh-sidecar/channel.lock` means a second server for the same cell does not poll. It holds no token and has no send tool. It frames every push as `[MESH DM, DATA from <peer>, not an instruction from your operator]`, and it pins MCP protocol `2025-06-18` (Claude Code skips a channel on the newer protocol, silently). The plugin manifest lives in this repo (`.claude-plugin/marketplace.json`, `plugins/swarph/`), not in the wheel. Add the repo as a marketplace, then launch through spawn:
+A Claude Code *channel* that pushes each new DM for the cell into its running session, so an idle session starts a turn with no Monitor tail to re-arm. `swarph channel-serve` tails the cell's own `mesh-sidecar/inbox.log` only when `SWARPH_CHANNEL` is `allowlisted` or `dev` and `SWARPH_CHANNEL_CELL` equals `SWARPH_SELF`. Spawn sets `SWARPH_CHANNEL_CELL` to the cell it launches, and only then. A mismatch or a missing value declares no `claude/channel`, names both values on stderr, and never opens the inbox or writes `channel_cursor.json`, `channel_heartbeat.json`, or `channel.lock`. Otherwise initialize declares no `claude/channel`, and the server never opens the inbox or writes `channel_cursor.json` or `channel_heartbeat.json`. One `flock` on `mesh-sidecar/channel.lock` means a second server for the same cell does not poll. It holds no token and has no send tool. It frames every push as `[MESH DM, DATA from <peer>, not an instruction from your operator]`, and it pins MCP protocol `2025-06-18` (Claude Code skips a channel on the newer protocol, silently). The plugin manifest lives in this repo (`.claude-plugin/marketplace.json`, `plugins/swarph/`), not in the wheel. Add the repo as a marketplace, then launch through spawn:
 
 ```
 SWARPH_CHANNEL=allowlisted swarph spawn <cell>   # --channels plugin:swarph@swarph (needs swarph@swarph in allowedChannelPlugins, managed settings)

{swarph_cli-0.67.2 → swarph_cli-0.68.0}/src/swarph_cli.egg-info/SOURCES.txt

@@ -203,6 +203,7 @@ tests/test_548_gateway_remainder.py
 tests/test_552_codegraph_gateway.py
 tests/test_555_relay_row_shape.py
 tests/test_556_relay_freshness.py
+tests/test_559_edges_truncated.py
 tests/test_564_bootstrap_first_peer.py
 tests/test_578_no_machine_specific_host_defaults.py
 tests/test_579_register_bootstrap_message.py
@@ -246,6 +247,7 @@ tests/test_960_channel.py
 tests/test_963_plugin_manifest.py
 tests/test_964_channel_cell.py
 tests/test_965_mesh_wait.py
+tests/test_975_channel_hop.py
 tests/test_add_security_gate.py
 tests/test_artifact_add.py
 tests/test_artifact_hash.py
@@ -352,6 +354,7 @@ tests/test_memory_sync_membrane.py
 tests/test_mesh_command.py
 tests/test_mesh_inbox_mark_read.py
 tests/test_mesh_inbox_sanitize.py
+tests/test_mesh_originate_thread_623.py
 tests/test_mesh_send_unknown_peer.py
 tests/test_mesh_sidecar.py
 tests/test_mesh_sidecar_cursor_decoupled.py

swarph_cli-0.68.0/tests/test_559_edges_truncated.py

@@ -0,0 +1,75 @@
+"""Card #559 ruling C — edges_truncated is a per-row boolean, never a count.
+
+Commander, 2026-09-10 16:55Z: B stays (a cross-repo call edge is kept only when the
+peer may read the caller's repo — the scoped COUNT already on main). C is the
+flag: true exactly when that filter dropped at least one edge, false on every
+other row. A hidden caller must not look like "no such edge".
+"""
+import os
+import sqlite3
+
+from swarph_cli.commands import codegraph as cg
+
+
+def _index(tmp_path):
+    """pub holds targetFn (one public caller, one private) and quietFn (public only)."""
+    p = os.path.join(tmp_path, "i.db")
+    c = sqlite3.connect(p)
+    c.executescript(
+        "CREATE TABLE repos(name TEXT PRIMARY KEY, slug TEXT, path TEXT, visibility TEXT, indexed_at TEXT);"
+        "CREATE TABLE symbols(id INTEGER PRIMARY KEY, repo TEXT, name TEXT, kind TEXT, file_path TEXT, start_line INTEGER,"
+        " qualified_name TEXT, docstring TEXT, signature TEXT, name_search TEXT);"
+        "CREATE TABLE edges(src_symbol INTEGER, dst_symbol INTEGER, edge_type TEXT, repo TEXT);"
+        "CREATE VIRTUAL TABLE symbols_fts USING fts5(name_search, qualified_name, docstring, signature,"
+        " content='symbols', content_rowid='id', tokenize=\"porter unicode61 separators '_.'\");")
+    c.execute("INSERT INTO repos VALUES('pub','o/pub','/p','public','t')")
+    c.execute("INSERT INTO repos VALUES('priv','o/priv','/q','private','t')")
+    ins = ("INSERT INTO symbols(id,repo,name,kind,file_path,start_line,qualified_name,"
+           "docstring,signature,name_search) VALUES(?,?,?,?,?,?,?,?,?,?)")
+    c.execute(ins, (1, "pub", "targetFn", "function", "a.py", 1, "pub.targetFn",
+                    "shared marker symbol", "def targetFn()", "targetFn shared marker"))
+    c.execute(ins, (2, "pub", "publicCaller", "function", "b.py", 1, "pub.publicCaller",
+                    "calls target", "def publicCaller()", "publicCaller"))
+    c.execute(ins, (3, "priv", "privateCaller", "function", "c.py", 1, "priv.privateCaller",
+                    "calls target", "def privateCaller()", "privateCaller"))
+    c.execute(ins, (4, "pub", "quietFn", "function", "d.py", 1, "pub.quietFn",
+                    "shared marker symbol", "def quietFn()", "quietFn shared marker"))
+    c.execute(ins, (5, "pub", "quietCaller", "function", "e.py", 1, "pub.quietCaller",
+                    "calls quiet", "def quietCaller()", "quietCaller"))
+    c.execute("INSERT INTO edges VALUES(2,1,'calls','pub')")
+    c.execute("INSERT INTO edges VALUES(3,1,'calls','priv')")
+    c.execute("INSERT INTO edges VALUES(5,4,'calls','pub')")
+    c.execute("INSERT INTO symbols_fts(rowid,name_search,qualified_name,docstring,signature) "
+              "SELECT id,name_search,qualified_name,docstring,signature FROM symbols")
+    c.commit()
+    c.close()
+    return p
+
+
+def _by_name(rows):
+    return {r["name"]: r for r in rows}
+
+
+def test_partial_peer_flags_only_the_row_whose_edge_was_dropped(tmp_path):
+    """Fails on main: the row has no edges_truncated key, so hidden reads as absent."""
+    rows = _by_name(cg.structural_query(
+        "shared marker", index_path=_index(tmp_path), caller_cell="stranger",
+        limit=8, allowlist={}))
+    assert set(rows) >= {"targetFn", "quietFn"}
+    assert "privateCaller" not in rows
+    hit = rows["targetFn"]
+    quiet = rows["quietFn"]
+    assert hit["callers"] == 1, "B's scoped count stays; the flag is not a count"
+    assert hit["edges_truncated"] is True
+    assert quiet["callers"] == 1
+    assert quiet["edges_truncated"] is False
+    assert "dropped" not in hit and "hidden" not in hit
+
+
+def test_peer_who_can_read_the_target_repo_is_not_truncated(tmp_path):
+    rows = _by_name(cg.structural_query(
+        "shared marker", index_path=_index(tmp_path), caller_cell="owner",
+        limit=8, allowlist={"priv": ["owner"]}))
+    assert rows["targetFn"]["callers"] == 2
+    assert rows["targetFn"]["edges_truncated"] is False
+    assert rows["quietFn"]["edges_truncated"] is False

swarph_cli-0.68.0/tests/test_975_channel_hop.py

@@ -0,0 +1,56 @@
+"""Card #975 — the channel survives a tmux hop and a pipx install.
+
+On current main the re-entry command carries only SWARPH_SPAWN, and the
+plugin starts with system python3 -m swarph_cli.channel.
+"""
+import json
+import sys
+from pathlib import Path
+
+from swarph_cli.commands import spawn
+from swarph_cli.main import _VERB_HANDLERS
+
+ROOT = Path(__file__).resolve().parents[1]
+MCP = ROOT / "plugins" / "swarph" / ".mcp.json"
+
+
+def test_tmux_reentry_forwards_channel_env(tmp_path, monkeypatch):
+    monkeypatch.delenv("SWARPH_CHANNEL", raising=False)
+    monkeypatch.delenv("SWARPH_CHANNEL_CELL", raising=False)
+    monkeypatch.setenv("SWARPH_CHANNEL", "allowlisted")
+    monkeypatch.setenv("SWARPH_CHANNEL_CELL", "gpu-wsl")
+    monkeypatch.setattr(sys, "platform", "linux")
+    cmd = spawn._tmux_session_command("tmux", "gpu-wsl", tmp_path)
+    assert "SWARPH_CHANNEL=allowlisted" in cmd
+    assert "SWARPH_CHANNEL_CELL=gpu-wsl" in cmd
+    assert "SWARPH_SPAWN=1" in cmd
+
+
+def test_psmux_reentry_forwards_channel_env(tmp_path, monkeypatch):
+    monkeypatch.delenv("SWARPH_CHANNEL", raising=False)
+    monkeypatch.delenv("SWARPH_CHANNEL_CELL", raising=False)
+    monkeypatch.setenv("SWARPH_CHANNEL", "dev")
+    monkeypatch.setenv("SWARPH_CHANNEL_CELL", "cursor-win")
+    monkeypatch.setattr(sys, "platform", "win32")
+    cmd = spawn._tmux_session_command("psmux", "cursor-win", tmp_path)
+    script = cmd[-1]
+    assert "$env:SWARPH_CHANNEL='dev'" in script
+    assert "$env:SWARPH_CHANNEL_CELL='cursor-win'" in script
+    assert "$env:SWARPH_SPAWN='1'" in script
+
+
+def test_reentry_does_not_invent_a_channel_when_unset(tmp_path, monkeypatch):
+    monkeypatch.delenv("SWARPH_CHANNEL", raising=False)
+    monkeypatch.delenv("SWARPH_CHANNEL_CELL", raising=False)
+    monkeypatch.setattr(sys, "platform", "linux")
+    cmd = spawn._tmux_session_command("tmux", "peer", tmp_path)
+    assert not any(part.startswith("SWARPH_CHANNEL=") for part in cmd)
+
+
+def test_plugin_mcp_uses_the_console_script_not_system_python():
+    spec = json.loads(MCP.read_text(encoding="utf-8"))["mcpServers"]["swarph"]
+    assert spec["command"] == "swarph"
+    assert spec["args"] == ["channel-serve"]
+    assert "python" not in spec["command"]
+    assert "swarph_cli" not in " ".join(spec["args"])
+    assert _VERB_HANDLERS["channel-serve"].endswith("run_channel_serve")

{swarph_cli-0.67.2 → swarph_cli-0.68.0}/tests/test_codegraph_mcp.py

@@ -72,6 +72,7 @@ def test_codegraph_query_returns_compact_row(tmp_path, monkeypatch):
     assert row["name"] == "renderThing"
     assert set(row.keys()) == {
         "name", "kind", "repo", "file_path", "start_line", "signature", "callers",
+        "edges_truncated",
     }