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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.45.2
+Version: 0.46.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.46.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.46.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.45.2"
+version = "0.46.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.45.2 → swarph_cli-0.46.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.46.0"
 
 __all__ = ["__version__"]

{swarph_cli-0.45.2 → swarph_cli-0.46.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.46.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.46.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}`.")

{swarph_cli-0.45.2 → swarph_cli-0.46.0}/src/swarph_cli/commands/memory_emit_hook.py

@@ -17,9 +17,11 @@ A repeat write of the same memory within ``_SUPPRESS_WINDOW`` is suppressed —
 the timeline is append-only, not append-always. State is a tiny JSON file,
 best-effort.
 
-Failure-mode invariant: exit 0 on EVERY path, print nothing, never raise. A
-hook that fails a tool result because the timeline is unreachable inverts every
-priority this system has.
+Failure-mode invariant: exit 0 on EVERY path, never raise. The hook prints
+nothing OF ITS OWN; the shared ``_log_via_gateway`` prints its one-line
+"logged -> TIMELINE.md" on success (cursor-win, 2026-08-22: the invariant was
+misdescribed, not violated). A hook that fails a tool result because the
+timeline is unreachable inverts every priority this system has.
 """
 
 from __future__ import annotations
@@ -108,7 +110,12 @@ def _mark_emitted(slug: str) -> None:
 
 
 def _cell() -> str:
-    return (os.environ.get("SWARPH_CELL") or os.environ.get("SWARPH_SELF")
+    # SWARPH_SELF outranks SWARPH_CELL — the house order (#332: a self-identity
+    # statement outranks an ambient one), and the live reason is #538: psmux
+    # leaks SWARPH_CELL from the spawning environment, so a CELL-first order
+    # posts this cell's highlight under ANOTHER cell's name and token
+    # (measured by cursor-win on the Windows membrane, 2026-08-22).
+    return (os.environ.get("SWARPH_SELF") or os.environ.get("SWARPH_CELL")
             or socket.gethostname())
 
 
@@ -117,7 +124,10 @@ def run_memory_emit_hook(argv: list[str] | None = None) -> int:
         raw = ""
         if not sys.stdin.isatty():
             raw = sys.stdin.read()
-        payload = json.loads(raw) if raw.strip() else {}
+        # PS 5.1 native pipes prefix a (double) UTF-8 BOM — json.loads raises,
+        # and the failure invariant converts that into an INVISIBLE no-op
+        # (measured by cursor-win, 2026-08-22). Strip before parse.
+        payload = json.loads(raw.lstrip("\ufeff")) if raw.strip() else {}
     except Exception:
         return 0
 

{swarph_cli-0.45.2 → swarph_cli-0.46.0}/src/swarph_cli/commands/mesh.py

@@ -28,6 +28,8 @@ import sys
 import time
 import urllib.error
 import urllib.parse
+
+import swarph_cli
 import urllib.request
 from collections import deque
 from collections.abc import MutableMapping
@@ -82,7 +84,8 @@ def _build_parser() -> argparse.ArgumentParser:
     _add_common(send)
 
     reply = sub.add_parser(
-        "reply", help="reply to a DM IN ITS OWN THREAD (closes a #307 obligation)")
+        "reply", help="reply to a DM IN ITS OWN THREAD (does NOT close the "
+                      "obligation — the close act is `board obligations close`, #562)")
     reply.add_argument("message_id", type=int, help="the DM being replied to")
     reply.add_argument("--kind", default="answer",
                        help="message kind (default: answer). NOT gated — a reply is "
@@ -136,8 +139,42 @@ def _build_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="allow register when a local per-peer token file already exists",
     )
+    register.add_argument(
+        "--replace",
+        action="store_true",
+        help="REPLACE the advertised capability blob with exactly the "
+             "--capability keys given (sends full=true). Default is MERGE: "
+             "the peer's currently-registered keys are read first and "
+             "re-submitted, so updating one field does not destroy the rest "
+             "(#124).",
+    )
     _add_common(register)
 
+    peers = sub.add_parser(
+        "peers",
+        help="list registered peers with their reported swarph_cli_version; "
+             "--stale-than X names only peers REPORTING older than X, and "
+             "names the UNREPORTED separately (#535)",
+    )
+    peers.add_argument(
+        "--stale-than", default=None, metavar="VERSION",
+        help="list only peers whose reported swarph_cli_version is older "
+             "than VERSION; peers with no reported version are named "
+             "UNREPORTED, never counted as current",
+    )
+    peers.add_argument(
+        "--as", dest="self_name", default=None,
+        help="optional peer identity. IF OMITTED the ambient shared token "
+             "(MESH_GATEWAY_TOKEN) is used — a registry read does not require "
+             "a self identity. Pass --as to use a stored per-peer token instead.",
+    )
+    peers.add_argument(
+        "--gateway",
+        default=os.environ.get("MESH_GATEWAY_URL", _DEFAULT_GATEWAY),
+        help="mesh-gateway base URL",
+    )
+    peers.add_argument("--token-file", default=None, help="explicit bearer token file")
+
     sidecar = sub.add_parser("sidecar", help="poll inbox and wake a tmux cell")
     sidecar.add_argument("--tmux-target", default=None, help="tmux target pane")
     sidecar.add_argument("--state-dir", default=None, help="state directory")
@@ -526,12 +563,15 @@ def _find_inbox_message(gateway: str, token: str, self_name: str,
 
 
 def _run_reply(args: argparse.Namespace) -> int:
-    """Reply to a DM IN ITS THREAD, which is what lets #307 close an obligation.
+    """Reply to a DM IN ITS THREAD. Since #562 this does NOT close the
+    obligation — closing is the distinct act `board obligations close`
+    (POST /board/obligations/{id}/close); the reply path only REMINDS via
+    the open_obligations field.
 
     >>> A REPLY IS UNIVERSAL ACROSS KINDS, DELIBERATELY. <<< The spec's constraint:
     not gated by kind. Gating would mean a peer could owe you an answer on a DM whose
-    kind nobody thought to allow, and the obligation would be unclosable through the
-    product — the exact "waiting on a seat" shape #307 exists to kill.
+    kind nobody thought to allow, and the obligation would be unanswerable through
+    the product — the exact "waiting on a seat" shape #307 exists to kill.
 
     >>> AND A THREADLESS REPLY MUST NOT REPORT THE SAME LINE AS A THREADED ONE. <<<
     Most DMs carry no thread. Refusing them would make this verb useless for the
@@ -776,11 +816,43 @@ def _run_register(args: argparse.Namespace) -> int:
     for spec in args.capability:
         key, value = _parse_capability(spec)
         caps[key] = value
+    # >>> #124, CLIENT HALF: MERGE OVER THE STORED BLOB BY DEFAULT. <<< The
+    # gateway replaces capabilities wholesale, so submitting only the keys
+    # this invocation cares about silently destroys the rest (gemini-
+    # researcher's role/agent_type, lost to a model_default update). Read
+    # the peer's currently-registered blob and re-submit it merged:
+    # submitted keys override, stored-only keys survive. --replace opts into
+    # the deliberate wholesale replace (full=true, which the gateway's #124
+    # guard accepts without its 409). A register that CANNOT READ the
+    # registry — first registration, gateway unreachable — proceeds with
+    # what it has: the read must never BLOCK the write; there is nothing to
+    # destroy on a row that does not exist yet.
+    gateway = args.gateway.rstrip("/")
+    stored_caps: dict = {}
+    found_stored_caps = False
+    if not args.replace:
+        gstatus, gpayload = _http_get_json(f"{gateway}/peers/{self_name}", token)
+        if gstatus == 200 and isinstance(gpayload.get("capabilities"), dict):
+            stored_caps = gpayload["capabilities"]
+            found_stored_caps = True
+    if args.replace:
+        merged = caps or {"can_claim_tasks": True}
+    elif found_stored_caps or caps:
+        merged = {**stored_caps, **caps}
+    else:
+        merged = {"can_claim_tasks": True}
+    # #535: report what version this cell RUNS, on every register — a
+    # SUBMITTED key, so the merge refreshes it on re-register and preserves
+    # it across partial updates. Without a stored version field, "who is
+    # stale" is unanswerable and "the fix propagates" is unfalsifiable.
+    merged["swarph_cli_version"] = swarph_cli.__version__
     body = {
         "name": self_name,
         "url": args.url or f"http://{self_name}:8787",
-        "capabilities": caps or {"can_claim_tasks": True},
+        "capabilities": merged,
     }
+    if args.replace:
+        body["full"] = True
     status, payload = _post_json(
         f"{args.gateway.rstrip('/')}/peers/register",
         body,
@@ -806,6 +878,96 @@ def _run_register(args: argparse.Namespace) -> int:
     return 0
 
 
+def _version_tuple(text: object) -> Optional[tuple[int, ...]]:
+    """Parse "0.45.1" into (0, 45, 1). Returns None for anything that is not
+    a dotted-numeric version — an unparseable version is UNMEASURABLE, not
+    current (#535's falsifier clause)."""
+    if not isinstance(text, str):
+        return None
+    parts = text.strip().split(".")
+    if not parts or any(not p.isdigit() for p in parts):
+        return None
+    return tuple(int(p) for p in parts)
+
+
+def _version_is_stale(reported: object, cutoff: str) -> Optional[bool]:
+    """True = reported is older than cutoff; False = current-or-newer;
+    None = unmeasurable (missing/unparseable). Numeric tuple compare, so
+    0.45.10 > 0.45.9 — lexicographic would call 0.9.0 newer than 0.10.0."""
+    have, want = _version_tuple(reported), _version_tuple(cutoff)
+    if have is None or want is None:
+        return None
+    width = max(len(have), len(want))
+    return have + (0,) * (width - len(have)) < want + (0,) * (width - len(want))
+
+
+def _run_peers(args: argparse.Namespace) -> int:
+    """#535: answer "which peers run older than X" from the STORED field —
+    never by asking each cell out of band, never by assuming.
+
+    A registry READ does not require a self identity: an operator asking
+    "who is stale" on any box with the shared token is not acting AS a
+    cell. --as still works (its peer token outranks the ambient one)."""
+    from swarph_cli.tokens import resolve_token
+    resolution = resolve_token(args.self_name, args.token_file,
+                               identity_is_explicit=bool(args.self_name))
+    if resolution is None:
+        print("swarph mesh peers: no token (set MESH_GATEWAY_TOKEN, pass "
+              "--token-file, or --as a peer with a stored token)",
+              file=sys.stderr)
+        return 2
+    token = resolution.token
+    gateway = args.gateway.rstrip("/")
+    status, payload = _http_get_json(f"{gateway}/peers", token)
+    if status < 200 or status >= 300:
+        detail = payload.get("detail", "<gateway error>") if isinstance(payload, dict) else "<gateway error>"
+        print(f"swarph mesh peers: gateway {status}: {detail}", file=sys.stderr)
+        return 1
+    peers = payload.get("peers") if isinstance(payload, dict) else None
+    if not isinstance(peers, list):
+        print("swarph mesh peers: unexpected /peers shape (no peer list)",
+              file=sys.stderr)
+        return 1
+
+    cutoff = args.stale_than
+    if cutoff is not None and _version_tuple(cutoff) is None:
+        print(f"swarph mesh peers: --stale-than {cutoff!r} is not a "
+              f"dotted-numeric version", file=sys.stderr)
+        return 2
+
+    stale, unreported, current = [], [], []
+    for p in peers:
+        if not isinstance(p, dict) or not isinstance(p.get("name"), str):
+            continue
+        caps = p.get("capabilities")
+        version = caps.get("swarph_cli_version") if isinstance(caps, dict) else None
+        version_is_valid = _version_tuple(version) is not None
+        verdict = _version_is_stale(version, cutoff) if cutoff else None
+        if cutoff and verdict is True:
+            stale.append((p["name"], version))
+        elif not version_is_valid:
+            unreported.append(p["name"])
+        else:
+            current.append((p["name"], version))
+
+    if cutoff:
+        for name, version in stale:
+            print(f"STALE       {name}  reports {version} (< {cutoff})")
+        for name in unreported:
+            # Named, never silently counted as current: absence of the field
+            # is unmeasurability, not health — the falsifier clause.
+            print(f"UNREPORTED  {name}  (no swarph_cli_version — unmeasurable, "
+                  f"NOT known-current)")
+        print(f"{len(stale)} stale, {len(unreported)} unreported, "
+              f"{len(current)} current (cutoff {cutoff})")
+    else:
+        for name, version in current:
+            print(f"{name}  {version or 'UNREPORTED'}")
+        for name in unreported:
+            print(f"{name}  UNREPORTED")
+    return 0
+
+
 def _default_sidecar_state_dir(self_name: str) -> Path:
     # NOT renamed to .../monitor when `swarph monitor` shipped (card #122).
     # `swarph init` pins this exact path as the cell's cursor_path and the
@@ -1937,6 +2099,8 @@ def run_mesh(argv: list[str]) -> int:
             return _run_inbox(args)
         if args.command == "register":
             return _run_register(args)
+        if args.command == "peers":
+            return _run_peers(args)
         if args.command == "sidecar":
             return _run_sidecar(args)
         parser.error(f"unknown command: {args.command}")

{swarph_cli-0.45.2 → swarph_cli-0.46.0}/src/swarph_cli/commands/monitor.py

@@ -828,6 +828,7 @@ def _register_capabilities(self_name: str, gateway: str, token_file, caps: dict)
         url=None,
         capability=[f"{k}={json.dumps(v)}" for k, v in caps.items()],
         force=True,
+        replace=False,
         gateway=gateway,
         token_file=token_file,
     )

{swarph_cli-0.45.2 → swarph_cli-0.46.0}/src/swarph_cli/commands/onboard.py

@@ -427,7 +427,7 @@ def _resolve_token(token_file_arg: Optional[str], *,
           "  To stand up YOUR OWN instead, no token required:\n"
           "      pip install 'swarph-cli[gateway]'\n"
           "      swarph gateway serve --port 8788 --db ~/.swarph/mesh.db\n"
-          "      swarph init <name>        # scaffold a cell\n"
+          "      swarph init <name> --provider <provider>  # scaffold a cell\n"
     )