swarph-cli 0.45.2__tar.gz → 0.47.0__tar.gz

{swarph_cli-0.45.2/src/swarph_cli.egg-info → swarph_cli-0.47.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.45.2
+Version: 0.47.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
@@ -186,6 +186,7 @@ swarph board cards thread <id> [--limit N]     # the card's conversation (a card
 swarph board cards say <id> --content "…" [--to <peer>] [--kind fyi|question|answer|status|unblock]
 swarph board cards ask <id> <holder> "<what>" [--timeout-hours N]   # MINT an obligation:
                                               # name who owes what as a ROW, not a sentence (#307)
+swarph board obligations close <id> --outcome <pass|fail|cannot_evaluate> --evidence "what you observed"
 ```
 
 `--project` accepts a numeric id **or** a slug (resolved via `projects list`). Note: card creation always starts at `proposed` (the gateway has no stage-on-create) — use `cards move` to advance.

{swarph_cli-0.45.2 → swarph_cli-0.47.0}/README.md

@@ -138,6 +138,7 @@ swarph board cards thread <id> [--limit N]     # the card's conversation (a card
 swarph board cards say <id> --content "…" [--to <peer>] [--kind fyi|question|answer|status|unblock]
 swarph board cards ask <id> <holder> "<what>" [--timeout-hours N]   # MINT an obligation:
                                               # name who owes what as a ROW, not a sentence (#307)
+swarph board obligations close <id> --outcome <pass|fail|cannot_evaluate> --evidence "what you observed"
 ```
 
 `--project` accepts a numeric id **or** a slug (resolved via `projects list`). Note: card creation always starts at `proposed` (the gateway has no stage-on-create) — use `cards move` to advance.

{swarph_cli-0.45.2 → swarph_cli-0.47.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.45.2"
+version = "0.47.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" }
@@ -120,7 +120,8 @@ where = ["src"]
 # importlib.resources, so an undeclared GUIDE.md passes every test in the
 # tree and fails on every installed wheel -- the 0.39.3 bug above, again.
 swarph_cli = ["systemd/*.service", "systemd/*.timer", "systemd/*.default",
-              "scripts/*.sh", "scripts/*.ps1", "guide/*.md"]
+              "scripts/*.sh", "scripts/*.ps1", "guide/*.md",
+              "payloads/postcompact/*.sh", "payloads/postcompact/*.cmd"]
 # v0.15: ship the bundled mesh-gateway schema so `swarph gateway serve`
 # can apply it at startup via MESH_SCHEMA_PATH (defaults next to server.py).
 "swarph_cli.gateway" = ["*.sql"]

{swarph_cli-0.45.2 → swarph_cli-0.47.0}/src/swarph_cli/__init__.py

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

{swarph_cli-0.45.2 → swarph_cli-0.47.0}/src/swarph_cli/commands/board.py

@@ -284,9 +284,10 @@ def _format_ask(d) -> str:
     return (f"obligation #{d.get('id')} on card #{d.get('card_id')}: "
             f"{d.get('holder')} owes it, status={d.get('status')}, {deadline}\n"
             f"  {falsifier}\n"
-            f"  thread {d.get('thread_uuid')} — closes on the holder's "
-            f"`mesh reply` IN that thread; a plain `mesh send` cannot close it "
-            f"(#509 — the VERB is the mechanism, the thread is where it lands)")
+            f"  thread {d.get('thread_uuid')} — work lands IN that thread; CLOSE "
+            f"it with `swarph board obligations close {d.get('id')}` plus an "
+            f"outcome and evidence; a plain `mesh send` cannot close it "
+            f"(#509/#562 — the VERB is the mechanism, the thread is where it lands)")
 
 
 def _format_thread(data) -> str:
@@ -377,6 +378,25 @@ def _build_parser() -> argparse.ArgumentParser:
     cr = cards.add_parser("ready", help="flag a card ready-to-advance (move_ready) for the orchestrator")
     cr.add_argument("id", type=int); cr.add_argument("--clear", action="store_true", help="unset move_ready")
     cr.add_argument("--json", action="store_true"); _add_common(cr)
+
+    obl = top.add_parser(
+        "obligations",
+        help="card obligations — the close act (#562)").add_subparsers(
+        dest="command", required=True)
+    oc = obl.add_parser(
+        "close",
+        help="CLOSE an obligation: the DISTINCT ACT that records the check's "
+             "outcome plus the evidence observed. A thread reply does NOT "
+             "close an obligation (#562) — this does")
+    oc.add_argument("id", type=int, help="the obligation id")
+    oc.add_argument("--outcome", required=True,
+                    choices=("pass", "fail", "cannot_evaluate"),
+                    help="the accept check's OUTCOME")
+    oc.add_argument("--evidence", required=True,
+                    help="what you OBSERVED running the check — whitespace is "
+                         "refused: whitespace evidence is the vibe-close this "
+                         "endpoint exists to kill")
+    oc.add_argument("--json", action="store_true"); _add_common(oc)
     return p
 
 
@@ -425,6 +445,35 @@ def run_board(argv: list[str]) -> int:
             st, d = _post_json(f"{gw}/board/projects", _project_add_payload(self_name, args.slug, args.title, goal=args.goal), token)
             return _out(st, d, lambda x: f"created project #{x.get('id')} ({x.get('slug')})", aj)
 
+    if args.group == "obligations":
+        if args.command == "close":
+            # #562's CLI half: the explicit close act. The gateway guards the
+            # identity (holder, creator, or board orchestrator) and refuses a
+            # second close; the CLI's job is to refuse what it can see —
+            # whitespace evidence — and to propagate the gateway's refusals
+            # with their detail intact.
+            evidence = args.evidence
+            if not evidence.strip():
+                print("swarph board obligations close: --evidence is "
+                      "whitespace-only — the close act records what you "
+                      "OBSERVED, and nothing was observed", file=sys.stderr)
+                return 2
+            st, d = _post_json(
+                f"{gw}/board/obligations/{args.id}/close",
+                {"outcome": args.outcome, "evidence": evidence}, token)
+            if st < 200 or st >= 300:
+                detail = d.get("detail", d) if isinstance(d, dict) else d
+                print(f"swarph board obligations close: gateway {st}: {_s(detail)}",
+                      file=sys.stderr)
+                return 1
+            if aj:
+                print(json.dumps(d, indent=2))
+            else:
+                print(f"obligation #{_s(d.get('id', args.id))} CLOSED by "
+                      f"{_s(d.get('closed_by', self_name))} — outcome: "
+                      f"{_s(d.get('close_outcome', args.outcome))}")
+            return 0
+
     if args.group == "cards":
         if args.command == "list":
             pid, err = _resolve_project(gw, token, args.project)

{swarph_cli-0.45.2 → swarph_cli-0.47.0}/src/swarph_cli/commands/brain_ask.py

@@ -10,7 +10,8 @@ verb so any cell can search the swarm's shared memory the same way. Two modes:
 Stdlib-only. Config from the environment, mirroring ``swarph mesh``'s token model:
 
   GBRAIN_MCP_URL        gbrain MCP endpoint; falls back to SWARPH_BRAIN_MCP, else
-    / SWARPH_BRAIN_MCP   http://127.0.0.1:8792/mcp
+    / SWARPH_BRAIN_MCP   http://100.107.222.72:8792/mcp (tailnet IP — gbrain
+                          binds no loopback; measured 2026-08-23, card #548)
   GBRAIN_TOKEN          read token; falls back to SWARPH_BRAIN_TOKEN, then to the
     / SWARPH_BRAIN_TOKEN  mesh per-peer token (~/.config/swarph/<self>.peer_token).
     / peer-token file     Once gbrain accepts mesh peer tokens, the peer token IS
@@ -34,12 +35,15 @@ from swarph_cli import tokens
 from pathlib import Path
 from typing import Optional
 
-_DEFAULT_GBRAIN = "http://127.0.0.1:8792/mcp"
+# TAILNET IP, NOT loopback (card #548): measured 2026-08-23, gbrain binds
+# 100.107.222.72:8792 ONLY — 127.0.0.1:8792 refuses on the gateway box itself.
+# A loopback default is deaf everywhere, including on the box running gbrain.
+_DEFAULT_GBRAIN = "http://100.107.222.72:8792/mcp"
 _DEFAULT_TOPK = 6
 
 
 def _resolve_endpoint() -> str:
-    """Endpoint precedence: GBRAIN_MCP_URL > SWARPH_BRAIN_MCP > localhost default.
+    """Endpoint precedence: GBRAIN_MCP_URL > SWARPH_BRAIN_MCP > tailnet default.
 
     The SWARPH_BRAIN_MCP fallback keeps the verb config-compatible with the
     standalone ``swarph-brain-ask`` script (which reads SWARPH_BRAIN_*), so one

swarph_cli-0.47.0/src/swarph_cli/commands/gateway.py

@@ -0,0 +1,278 @@
+"""``swarph gateway`` — run the bundled mesh-gateway server.
+
+The mesh-gateway is the coordination/DM server behind the swarph mesh:
+peer registry, DM inbox/outbox, feature aggregation + allowlist/caps,
+and lane/service control. It used to live as a standalone deployment;
+``swarph gateway serve`` bundles it as a first-class verb so any host
+can stand up a gateway the same way it runs the client verbs.
+
+The FastAPI/uvicorn server stack is an OPTIONAL extra so the core
+client paths (one-shot / chat / mesh / brain-ask) stay dependency-light::
+
+    pip install "swarph-cli[gateway]"
+
+Token model (mirrors ``swarph mesh``'s ``MESH_GATEWAY_TOKEN`` bearer):
+
+  * ``--token`` sets ``MESH_GATEWAY_TOKEN`` for the served process.
+  * Otherwise an existing ``MESH_GATEWAY_TOKEN`` in the environment is used.
+  * If neither is present a fresh token is minted (``secrets.token_urlsafe``)
+    and printed once so the operator can hand it to the mesh cells.
+
+``bootstrap-ratify`` (#565-B) is the ratify ladder's first rung: on a fresh
+gateway zero peers are ratified, so no witness exists and ``swarph ratify``
+can never complete. This verb flips ONE peer ratified via a local DB write —
+an explicit, audited act by the human commander on the gateway box, not a
+migration accident. It self-destroys: it refuses when any ratified peer
+already exists.
+
+Bare ``swarph gateway`` prints help.
+"""
+
+from __future__ import annotations
+
+import argparse
+import getpass
+import os
+import secrets
+import socket
+import sqlite3
+import sys
+from datetime import datetime, timezone
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="swarph gateway",
+        description=(
+            "Run the bundled mesh-gateway server (peer registry + DM "
+            "inbox/outbox + feature aggregation + lane/service control)."
+        ),
+    )
+    sub = p.add_subparsers(dest="command")
+
+    serve = sub.add_parser("serve", help="run the mesh-gateway HTTP server")
+    serve.add_argument(
+        "--host",
+        default="127.0.0.1",
+        help="bind address (default 127.0.0.1; use a tailnet IP to expose to peers)",
+    )
+    serve.add_argument(
+        "--port",
+        type=int,
+        default=8788,
+        help="bind port (default 8788)",
+    )
+    serve.add_argument(
+        "--token",
+        default=None,
+        help="bearer token for the gateway (sets MESH_GATEWAY_TOKEN); "
+        "minted + printed once if omitted and not already in the env",
+    )
+    serve.add_argument(
+        "--db",
+        default=None,
+        help="path to the gateway SQLite DB (sets MESH_DB_PATH)",
+    )
+
+    boot = sub.add_parser(
+        "bootstrap-ratify",
+        help="ratify the FIRST peer on a fresh gateway (human commander, "
+        "local DB write, audited)",
+    )
+    boot.add_argument("peer", help="peer name to bootstrap-ratify")
+    boot.add_argument(
+        "--db",
+        default=None,
+        help="path to the gateway SQLite DB (default: $MESH_DB_PATH or "
+        "~/.swarph/mesh.db)",
+    )
+    boot.add_argument(
+        "--reason",
+        default=None,
+        help="extra audit text appended to the bootstrap reason",
+    )
+    return p
+
+
+def _serve(args: argparse.Namespace) -> int:
+    # Dependency gate — the server stack is an optional extra. Probe the
+    # imports before touching uvicorn so a missing extra prints a clean
+    # install hint instead of a traceback.
+    try:
+        import fastapi  # noqa: F401
+        import uvicorn  # noqa: F401
+    except ImportError:
+        sys.stderr.write(
+            'swarph gateway needs the optional server deps: '
+            'pip install "swarph-cli[gateway]"\n'
+        )
+        return 2
+
+    if args.db:
+        os.environ["MESH_DB_PATH"] = args.db
+
+    token = args.token or os.environ.get("MESH_GATEWAY_TOKEN")
+    if not token:
+        token = secrets.token_urlsafe(48)
+        print(
+            "swarph gateway: minted a new MESH_GATEWAY_TOKEN "
+            "(give this to your mesh cells):\n"
+            f"  {token}",
+            file=sys.stderr,
+        )
+    os.environ["MESH_GATEWAY_TOKEN"] = token
+
+    uvicorn.run(
+        "swarph_cli.gateway.server:app",
+        host=args.host,
+        port=args.port,
+        log_level="info",
+    )
+    return 0
+
+
+def _bootstrap_ratify(args: argparse.Namespace) -> int:
+    """#565-B: the ratify ladder's first rung, as an audited local write.
+
+    On a fresh gateway, `swarph ratify` can never complete — the witness must
+    itself be ratified, and zero peers are. The live mesh only works because
+    a one-time Phase 5.5 migration grandfathered its cohort; every deployment
+    since hangs off that accident. This verb makes the bootstrap explicit:
+
+      * LOCAL DB write — operator-with-filesystem-access is already god; this
+        makes the act explicit and audited instead of a SQL escape hatch.
+      * HUMAN-only — an interactive tty and a typed 'yes'. One prompt, no
+        ceremony: the gate must not cut into the onboarding flow it serves.
+      * SELF-DESTROYING — refuses when ANY ratified peer exists, so it can
+        never become a second ratification path. Recovery stays possible:
+        whenever zero ratified peers exist, the gate passes again.
+      * HAND-IN-HAND with onboarding — the target must already be registered
+        (onboard first), and the output names the next step.
+    """
+    db_path = (
+        args.db
+        or os.environ.get("MESH_DB_PATH")
+        or os.path.expanduser("~/.swarph/mesh.db")
+    )
+    if not os.path.exists(db_path):
+        sys.stderr.write(
+            f"swarph gateway bootstrap-ratify: no gateway DB at {db_path}\n"
+            "  Run this on the gateway box, or pass --db / set MESH_DB_PATH.\n"
+        )
+        return 2
+
+    # Match server.py _conn(): autocommit with explicit transaction control
+    # (we BEGIN IMMEDIATE ourselves) and FK enforcement ON — the audit insert
+    # into peer_ratifications references claude_peers, and without the pragma
+    # a dangling reference would write silently.
+    conn = sqlite3.connect(db_path, isolation_level=None)
+    conn.execute("PRAGMA foreign_keys = ON")
+    conn.row_factory = sqlite3.Row
+    try:
+        row = conn.execute(
+            "SELECT ratified FROM claude_peers WHERE name = ?", (args.peer,)
+        ).fetchone()
+        if row is None:
+            sys.stderr.write(
+                f"swarph gateway bootstrap-ratify: {args.peer!r} is not "
+                "registered —\n  onboard it first:\n"
+                f"      swarph onboard {args.peer}\n"
+            )
+            return 2
+        if row["ratified"]:
+            print(f"{args.peer!r} is already ratified — nothing to do.")
+            return 0
+        existing = conn.execute(
+            "SELECT name FROM claude_peers WHERE ratified = 1 LIMIT 1"
+        ).fetchone()
+        if existing:
+            sys.stderr.write(
+                f"swarph gateway bootstrap-ratify: refusing — "
+                f"{existing['name']!r} is already ratified.\n"
+                "  The ladder has its first rung; bootstrap exists ONLY for a "
+                "fresh gateway.\n"
+                f"  Ratify {args.peer!r} through the normal witness path "
+                f"(a ratified witness runs:\n"
+                f"      swarph ratify {args.peer} --reason \"<short text>\")\n"
+            )
+            return 2
+
+        if not sys.stdin.isatty():
+            sys.stderr.write(
+                "swarph gateway bootstrap-ratify: refusing — this is the "
+                "human commander's act.\n"
+                "  Run it interactively on the gateway box (no pipes, no "
+                "scripts, no cells).\n"
+            )
+            return 2
+
+        operator = f"{getpass.getuser()}@{socket.gethostname()}"
+        print(f"Bootstrap-ratify {args.peer!r} on {db_path}:")
+        print("  - zero ratified peers exist (fresh gateway)")
+        print("  - flips ratified=1 and writes an audited peer_ratifications "
+              "row (binding_regime='bootstrap')")
+        print(f"  - performed by {operator}")
+        if input("Type 'yes' to confirm: ").strip().lower() != "yes":
+            print("aborted — nothing written.")
+            return 1
+
+        now = datetime.now(timezone.utc).isoformat()
+        reason = f"bootstrap by {operator} (#565)"
+        if args.reason:
+            reason += f": {args.reason}"
+        conn.execute("BEGIN IMMEDIATE")
+        try:
+            row = conn.execute(
+                "SELECT ratified FROM claude_peers WHERE name = ?", (args.peer,)
+            ).fetchone()
+            existing = conn.execute(
+                "SELECT name FROM claude_peers WHERE ratified = 1 LIMIT 1"
+            ).fetchone()
+            if row is None or row["ratified"] or existing:
+                conn.execute("ROLLBACK")
+                sys.stderr.write(
+                    "swarph gateway bootstrap-ratify: gateway state changed while "
+                    "you confirmed; refusing to create a second first rung.\n"
+                )
+                return 2
+            conn.execute(
+                "UPDATE claude_peers SET ratified=1, ratified_at=?, "
+                "ratified_by=?, ratification_reason=? WHERE name=?",
+                (now, "bootstrap", reason, args.peer),
+            )
+            conn.execute(
+                "INSERT INTO peer_ratifications "
+                "(peer, ratified_by, ratified_at, reason, witness_dm_id, "
+                "binding_regime) VALUES (?, ?, ?, ?, NULL, 'bootstrap')",
+                (args.peer, "bootstrap", now, reason),
+            )
+            conn.execute("COMMIT")
+        except Exception:
+            conn.execute("ROLLBACK")
+            raise
+    finally:
+        conn.close()
+
+    print(f"{args.peer!r} ratified (bootstrap). The ladder has its first "
+          "rung — hand in hand with onboarding:")
+    print(f"  - {args.peer} can now WITNESS ratifications for the cells "
+          "that follow")
+    print(f"  - next cell: `swarph onboard <cell>` on its box, complete the "
+          f"handshake, then a witness runs:")
+    print(f"      swarph ratify <cell> --reason \"<short text>\"")
+    return 0
+
+
+def run_gateway(argv: list) -> int:
+    """Entry point invoked by ``swarph_cli.main`` verb dispatch."""
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    if args.command == "serve":
+        return _serve(args)
+    if args.command == "bootstrap-ratify":
+        return _bootstrap_ratify(args)
+
+    # bare `swarph gateway` (no subcommand) — print help.
+    parser.print_help()
+    return 0

{swarph_cli-0.45.2 → swarph_cli-0.47.0}/src/swarph_cli/commands/gh_route.py

@@ -51,6 +51,8 @@ def _allow_unchanged() -> int:
 
 def run_hook(stdin_text: Optional[str] = None) -> int:
     raw = stdin_text if stdin_text is not None else sys.stdin.read()
+    # PS 5.1 native pipes prefix a (double) UTF-8 BOM; strip before parse.
+    raw = (raw or "").lstrip("\ufeff")
     try:
         payload = json.loads(raw or "{}")
     except Exception:

{swarph_cli-0.45.2 → swarph_cli-0.47.0}/src/swarph_cli/commands/init.py

@@ -265,7 +265,13 @@ def run_init(argv: list[str]) -> int:
     # its own context); an operator running `swarph onboard` first mints the
     # token into a process that discards it, and the cell's later self-register
     # returns token_status=existing with nothing.
-    print(f"next:  from the CELL'S OWN context: `swarph mesh register --as {name}` "
+    # Scoped as CONDITIONAL (#319 d): a standalone outsider has no mesh and
+    # cannot ratify — the mesh path is named for the user who IS joining one,
+    # not presented as the next thing everyone must do. The outsider's next
+    # step is the `ready:` line above (swarph spawn), which works with zero
+    # mesh.
+    print(f"next:  if you're joining a mesh — from the CELL'S OWN context: "
+          f"`swarph mesh register --as {name}` "
           f"(mints + stores its once-only per-peer token, mode 600); then a witness "
           f"runs `swarph ratify {name}`. Status at any point: "
           f"`swarph onboard --check {name}`.")