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

{swarph_cli-0.45.1/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.1
+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.1 → 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.1 → swarph_cli-0.46.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.45.1"
+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.1 → 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.1"
+__version__ = "0.46.0"
 
 __all__ = ["__version__"]

{swarph_cli-0.45.1 → swarph_cli-0.46.0}/src/swarph_cli/commands/board.py

@@ -12,12 +12,24 @@ from __future__ import annotations
 
 import argparse
 import json
+import re
 import sys
 import urllib.error
 import urllib.parse
 import urllib.request
 from typing import Optional
 
+# #532 — negative-branch marker detection. THREE COPIES exist and no single
+# suite pins all three: here, mesh-gateway server.py (_accept_state), and
+# mesh-gateway scripts/obligation_sweep.py. Unpinned-by-design is not the same
+# decision as standalone-by-design — each repo's tests pin the same seven
+# phrases. The detector is TWO-SIDED (drop-on-meta-edge, PR #124): it
+# over-reads wishes ("must not fail") and under-reads real checks without the
+# token ("Otherwise reject"); word boundaries remove the incidental compounds
+# (failover, fail-safe, failsafe). Detection is named, never concluded — no
+# substring test can know a falsifier exists.
+_FAIL_MARKER_RE = re.compile(r"(?<![\w-])fail(?:s|ed|ing|ures?)?(?![\w-])", re.IGNORECASE)
+
 from swarph_cli.commands._content import ContentError, add_content_args, resolve_content
 from swarph_cli.commands._display import sanitize_terminal as _s
 from swarph_cli.commands.mesh import (
@@ -196,6 +208,41 @@ def _thread_recipient(card: dict, explicit_to: Optional[str]) -> str:
     )
 
 
+def _say_line(resp: dict, card_id, to_node: str) -> str:
+    """The post confirmation — AND any obligation the post just DISCHARGED.
+
+    >>> THE GATEWAY ALREADY SAID SO AND THIS CLI THREW IT AWAY. <<< POST
+    /messages returns `closed_obligations: [ids]` (server.py:4077-4099): any
+    message a HOLDER posts to a thread closes their oldest open obligation on
+    it, unconditionally, without consulting the `accept` falsifier #532 added.
+    The old formatter read `id` only, so the terminal printed "posted id=NNN"
+    and nothing else.
+
+    MEASURED CONSEQUENCE (science-claude, card #562): obligation #22 on card
+    #544 closed at 06:59:15 on a status post whose literal content was that the
+    work was NOT done — one membrane passing, four CANNOT_EVALUATE, two
+    proposals unstarted. IT STAYED WRONGLY CLOSED FOR SIX HOURS while its holder
+    said in five further messages that it was unmet, and nothing compared the
+    two. `obligation_sweep.py` could not catch it either: that sweep selects
+    `status = 'open'`, so a wrongly-closed row falls out of the set forever.
+
+    The signal existed, was correct, and travelled the wire. It died at the last
+    hop, in the formatter. A one-line print is not the fix for the auto-close
+    POLICY (that is #562's own question) -- it is the fix for the holder not
+    being told, which is what made six hours of divergence possible.
+    """
+    line = f"posted id={resp.get('id')} onto card #{card_id} (to {to_node})"
+    closed = resp.get("closed_obligations") or []
+    if closed:
+        ids = ", ".join(f"#{i}" for i in closed)
+        line += (f"\n  >>> THIS POST CLOSED OBLIGATION {ids}. <<< Posting to a "
+                 f"thread discharges your oldest open obligation on it — the "
+                 f"accept check was NOT evaluated. If the work is not actually "
+                 f"done, say so now: a closed obligation leaves the sweep set "
+                 f"and nothing will chase it again.")
+    return line
+
+
 def _card_say_payload(from_node: str, to_node: str, kind: str, content: str,
                       thread_uuid: str) -> dict:
     return {
@@ -215,13 +262,32 @@ def _format_ask(d) -> str:
     An obligation with no timeout never goes red on its own, and the operator has to
     be told that AT THE MOMENT THEY CREATE IT — afterwards it looks identical to one
     that simply is not late yet.
+
+    #532 applies the same rule to the falsifier: an obligation with no accept
+    check reads RED in the sweep, and one whose check has no FAIL branch is
+    marked NO-FAIL-BRANCH — both are said AT MINT TIME, because afterwards the
+    rows look identical to sound ones.
     """
     when = d.get("timeout_at")
     deadline = f"overdue after {when}" if when else (
         "NO TIMEOUT — this never goes red on its own; pass --timeout-hours if it should")
+    accept = d.get("accept")
+    if not accept:
+        falsifier = ("NO ACCEPT CHECK — reads RED in the sweep; pass --accept "
+                     "\"PASS = ... | FAIL = ...\" naming an observable and a way "
+                     "it comes out negative")
+    elif not _FAIL_MARKER_RE.search(str(accept)):
+        falsifier = ("accept check has NO FAIL BRANCH — marked NO-FAIL-BRANCH in "
+                     "the sweep; a check that cannot come out negative is not one")
+    else:
+        falsifier = f"accept: {accept}"
     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"  thread {d.get('thread_uuid')} — the holder's reply in this thread closes it")
+            f"  {falsifier}\n"
+            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:
@@ -301,12 +367,36 @@ def _build_parser() -> argparse.ArgumentParser:
     ck.add_argument("--timeout-hours", type=int, default=None,
                     help="hours until this obligation reads OVERDUE (default: none, "
                          "which means it never goes red on its own)")
+    ck.add_argument("--accept", default=None, metavar='"PASS = ... | FAIL = ..."',
+                    help="the falsifiable check that closes this obligation "
+                         "(#532). Omitting it mints an obligation that reads RED "
+                         "in the sweep; a check with no FAIL branch is marked "
+                         "NO-FAIL-BRANCH — 'verify it works' is not a check")
     ck.add_argument("--kind", default="action", help="obligation kind (default: action)")
     ck.add_argument("--json", action="store_true"); _add_common(ck)
 
     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
 
 
@@ -355,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)
@@ -426,6 +545,8 @@ def run_board(argv: list[str]) -> int:
                     "kind": args.kind}
             if args.timeout_hours is not None:
                 body["timeout_hours"] = args.timeout_hours
+            if args.accept is not None:
+                body["accept"] = args.accept
             st, d = _post_json(f"{gw}/board/cards/{args.id}/ask", body, token)
             return _out(st, d, _format_ask, args.json)
         if args.command == "say":
@@ -461,8 +582,7 @@ def run_board(argv: list[str]) -> int:
             # explicit `propose` grant. `_out` passes `detail` through whole; it does
             # not need help, and a second copy of that logic is a second thing to
             # keep in sync.
-            return _out(st, d, lambda x: f"posted id={x.get('id')} onto card "
-                                         f"#{args.id} (to {to_node})", aj)
+            return _out(st, d, lambda x: _say_line(x, args.id, to_node), aj)
         if args.command == "ready":
             st, d = _patch_json(f"{gw}/board/cards/{args.id}", {"actor": self_name, "move_ready": not args.clear}, token)
             return _out(st, d, lambda x: f"card #{x.get('id')} move_ready -> {x.get('move_ready')}", aj)

{swarph_cli-0.45.1 → swarph_cli-0.46.0}/src/swarph_cli/commands/cell_selfcheck.py

@@ -289,7 +289,10 @@ def unit_is_relevant(name: str, text: str) -> bool:
 # If the canonical chain grows a leg, this one must too — that is the known
 # cost of the circularity break, stated here rather than discovered.
 
-_RESOLVER_DEFAULT_GATEWAY = "http://localhost:8788"
+# TAILNET IP, NOT localhost and NOT a MagicDNS name (commander, 2026-08-21).
+# The mesh-gateway binds HOST=100.107.222.72 ONLY; localhost has never been bound.
+# MESH_GATEWAY_URL overrides — the escape hatch for anyone outside this mesh.
+_RESOLVER_DEFAULT_GATEWAY = os.environ.get("MESH_GATEWAY_URL", "http://100.107.222.72:8788")
 
 
 def resolver_gateway(env: dict) -> str:

{swarph_cli-0.45.1 → swarph_cli-0.46.0}/src/swarph_cli/commands/codegraph.py

@@ -32,6 +32,7 @@ import json
 import os
 import re
 import sqlite3
+import sys
 
 DEFAULT_INDEX = os.path.expanduser("~/.swarph/codegraph/index.db")
 # NOTE: named DEFAULT_CALLER_CELL, not "*_CALLER" — this is an A8 caller-CELL
@@ -41,6 +42,13 @@ DEFAULT_INDEX = os.path.expanduser("~/.swarph/codegraph/index.db")
 # against that unrelated dotted-slug convention.
 DEFAULT_CALLER_CELL = "lab-ovh"
 
+# NOT 1 and NOT 2. A distinct code so "nothing was searched" can never be confused
+# with a crash or a usage error, and so a caller can branch on it specifically.
+# This is the AVAILABILITY axis, the same thing the gateway answers with a 503 --
+# separate from the VISIBILITY axis stdout carries. rc is the one channel the frozen
+# stdout contract left free.
+RC_NO_INDEX = 3
+
 # --- textsearch (ported verbatim from codegraph_index/textsearch.py) ------
 
 _STOP = {"the", "a", "an", "is", "are", "was", "how", "does", "do", "of", "to", "in", "on", "for", "and", "or",
@@ -212,24 +220,191 @@ def format_human(rows, term) -> str:
         lines.append(f"{i}. {r['name']}  [{r['kind']}]  {r['repo']}  {loc}{callers}")
         if r["signature"]:
             lines.append(f"     {r['signature']}")
-        if r["docstring"]:
-            first = r["docstring"].strip().splitlines()[0][:100] if r["docstring"].strip() else ""
+        # >>> .get, AND ONLY HERE. <<< The RELAYED rows (#552) carry seven keys --
+        # repo, name, kind, file_path, start_line, callers, signature -- and NOT
+        # docstring, which the endpoint does not project. Every other key is common
+        # to both producers, so they stay subscripted: a missing `name` or
+        # `file_path` is a BROKEN PAYLOAD and must raise rather than format as blank.
+        # Loosening all of them would turn a real fault into a quiet half-answer.
+        doc = (r.get("docstring") or "").strip()
+        if doc:
+            first = doc.splitlines()[0][:100]
             if first:
                 lines.append(f"     {first}")
     return "\n".join(lines)
 
 
+def _resolve_gateway(arg) -> str:
+    """Gateway base URL for the SEARCH-RELAY path (#552).
+
+    >>> THE CANONICAL VARIABLE IS MESH_GATEWAY_URL, AND SWARPH_BRAIN_GATEWAY IS
+    DELIBERATELY *NOT* IN THIS CHAIN. <<<
+
+    The first draft copied `highlight`'s chain, which ends in SWARPH_BRAIN_GATEWAY.
+    drop-on-meta-edge measured what that actually resolves to on this box:
+
+        SWARPH_CODEGRAPH_GATEWAY   <unset>
+        SWARPH_GATEWAY             <unset>
+        SWARPH_BRAIN_GATEWAY       http://100.107.222.72:8788   <- brain-NAMED, MESH value
+        MESH_GATEWAY_URL           http://100.107.222.72:8788   <- correct, and NOT consulted
+
+    The relay worked ONLY because a brain-named variable was mis-set to the mesh
+    gateway's address. Every link that resolved was unset or wrong-by-name, and the
+    one that was right was the one not read -- while #546 canonicalised
+    MESH_GATEWAY_URL across four modules the same morning.
+
+    >>> AND THE FAILURE IS TRIGGERED BY SOMEONE DOING THE RIGHT THING. <<<
+    SWARPH_BRAIN_GATEWAY names the brain (:8792, mint :8793) -- a different service on
+    different ports. The day anyone points it where its NAME says, this POSTs to
+    :8792/codegraph: a mesh peer token handed to a service it was not minted for, a
+    non-2xx, the fallback, and droplet's original symptom returns ON THE DAY SOMEONE
+    FIXED A VARIABLE. A fallback to a differently-named service is not a safety net;
+    it re-arms the collision on the day it fires.
+
+    `--gateway` / `--local` override.
+    """
+    return (arg
+            or os.environ.get("SWARPH_CODEGRAPH_GATEWAY")
+            or os.environ.get("SWARPH_GATEWAY")
+            or os.environ.get("MESH_GATEWAY_URL")
+            or "").strip()
+
+
+def _query_via_gateway(gateway: str, query: str, limit: int, token_file):
+    """POST to the gateway's /codegraph — THE SERVER SEARCHES, WE GET THE ANSWER.
+
+    >>> WHY A RELAY AND NOT A SHIPPED INDEX (commander, 2026-08-21): one index,
+    one truth. Copying the db to every cell makes N stores that drift, which is
+    the divergence this fleet hit four separate ways the same week. <<<
+
+    The endpoint takes NO caller field on purpose -- the caller comes from the
+    bearer token and cannot be self-asserted the way `--caller-cell` can here.
+    So the relayed path is strictly *less* spoofable than the local one.
+
+    Returns (rows, index_present, freshness).
+
+    index_present is False when the SERVER says 503 -- the availability axis, kept
+    distinct from an empty result.
+
+    >>> WE DELIBERATELY IGNORE THE BODY'S `index_present` FIELD. <<< (drop, review of
+    PR #280, measured against the live endpoint.) The endpoint hardcodes it True on
+    its only 200 path and raises 503 otherwise, so on the wire the field carries no
+    information. The 503 IS the signal. A later "improvement" that reads the body
+    field instead would be branching on a constant and would silently stop detecting
+    the very thing it appears to check.
+
+    `freshness` is a list of per-repo dicts -- repo, indexed_at, index_age_hours,
+    stale, basis. The first cut of this relay DROPPED it, which meant the automatic
+    grep hook warned about a stale index while the HAND-TYPED verb did not -- and the
+    hand-typed verb is the consumer this relay was built for, because that is how
+    droplet hit the original problem. Card #193 exists because this index has run
+    BACKWARD before, so a stale index answering confidently is an OBSERVED failure,
+    not a hypothetical.
+    """
+    from swarph_cli.commands.mesh import _post_json, _resolve_token  # local import: keeps
+    # the local-only path free of any mesh dependency, so an offline cell still works.
+
+    self_name = os.environ.get("SWARPH_SELF") or DEFAULT_CALLER_CELL
+    token = _resolve_token(self_name, token_file)
+    body = {"query": query, "limit": max(1, min(int(limit), 25))}
+    status, payload = _post_json(gateway.rstrip("/") + "/codegraph", body, token)
+    if status == 503:
+        return [], False, []
+    if status >= 400:
+        raise RuntimeError(f"gateway returned {status}: {str(payload)[:160]}")
+    payload = payload or {}
+    return payload.get("results", []), True, (payload.get("freshness") or [])
+
+
 def run_codegraph(argv) -> int:
     ap = argparse.ArgumentParser(
         prog="swarph codegraph",
         description="On-demand structural code search: find where a symbol is defined or what calls it, "
-                    "across the indexed repos. Natural-language query.")
+                    "across the indexed repos. Natural-language query. Queries the mesh gateway when one "
+                    "is configured (the server searches and returns the answer); falls back to a local index.")
     ap.add_argument("query", help="natural-language query, e.g. 'which function escapes HTML'")
     ap.add_argument("--index", default=DEFAULT_INDEX, help=f"index db (default {DEFAULT_INDEX})")
     ap.add_argument("--caller-cell", default=DEFAULT_CALLER_CELL, help="A8 caller identity (default lab-ovh)")
     ap.add_argument("--limit", type=int, default=8)
     ap.add_argument("--json", action="store_true", help="machine-readable JSON output")
+    ap.add_argument("--gateway", default=None,
+                    help="mesh-gateway base URL for relayed search (else $SWARPH_CODEGRAPH_GATEWAY / "
+                         "$SWARPH_GATEWAY / $SWARPH_BRAIN_GATEWAY). The server holds the index.")
+    ap.add_argument("--local", action="store_true",
+                    help="force the local index even when a gateway is configured")
+    ap.add_argument("--token-file", default=None, help="explicit bearer token file")
     a = ap.parse_args(argv)
-    rows = structural_query(a.query, index_path=a.index, caller_cell=a.caller_cell, limit=a.limit)
-    print(json.dumps(rows, indent=2) if a.json else format_human(rows, a.query))
-    return 0
+
+    gateway = "" if a.local else _resolve_gateway(a.gateway)
+    source = "local"
+    # The LOCAL path computes no freshness -- the index file is right there and the
+    # hook that used to state its age reads the mtime itself. Only the relayed path
+    # receives it, and only the relayed path can be silently answering from a store
+    # the user cannot see.
+    freshness = []
+    if gateway:
+        try:
+            rows, index_present, freshness = _query_via_gateway(
+                gateway, a.query, a.limit, a.token_file)
+            source = "gateway"
+        except Exception as exc:  # noqa: BLE001
+            # >>> LOUD, NEVER A SILENT FALL BACK TO LOCAL. <<< A relay failure that
+            # degrades quietly to an empty local index is indistinguishable from
+            # "no matches" -- the exact confusion this change exists to remove.
+            print(f"swarph codegraph: gateway {gateway} unreachable ({type(exc).__name__}: {exc}); "
+                  f"falling back to the local index at {a.index}", file=sys.stderr)
+            rows = structural_query(a.query, index_path=a.index,
+                                    caller_cell=a.caller_cell, limit=a.limit)
+            index_present = os.path.exists(os.path.expanduser(a.index))
+    else:
+        rows = structural_query(a.query, index_path=a.index,
+                                caller_cell=a.caller_cell, limit=a.limit)
+        index_present = os.path.exists(os.path.expanduser(a.index))
+
+    stale = [f for f in freshness if f.get("stale")]
+    if stale:
+        # >>> A STALE INDEX ANSWERING CONFIDENTLY IS THE #193 FAILURE, AND IT LOOKS
+        # EXACTLY LIKE A GOOD ANSWER. <<< stderr, not stdout: the rows are real and a
+        # machine consumer should still get them unmodified. The user needs to know
+        # the line numbers may have moved; the parser does not.
+        for f in stale:
+            print(f"swarph codegraph: STALE INDEX for {f.get('repo', '?')} — "
+                  f"{f.get('index_age_hours', 0):.1f}h old ({f.get('basis', 'unknown basis')}); "
+                  f"verify line numbers against the file before acting on them.",
+                  file=sys.stderr)
+
+    if not index_present:
+        # >>> STDERR, AND --json STAYS A BARE LIST. <<< .claude/hooks/codegraph-on-grep.sh
+        # does `rows=json.loads(...)` and iterates, so wrapping stdout in an envelope
+        # would break the hook that fires on every grep in the fleet. The availability
+        # signal therefore goes to stderr, where it costs no consumer anything.
+        #
+        # >>> THE EXIT CODE IS THE CHANNEL THAT WAS FREE ALL ALONG (drop, review of
+        # PR #279). <<< The stdout contract is frozen -- codegraph-on-grep.sh does
+        # json.loads() and iterates, so an envelope breaks the caller that fires on
+        # every grep in the fleet. But rc costs that contract NOTHING: a consumer
+        # that ignores rc sees exactly what it saw before, and one that reads it gets
+        # the availability axis the gateway already expresses as a 503.
+        #
+        # The hook itself already branches on `[ $rc -ne 0 ]` and reports the query as
+        # UNCORROBORATED, so this lands in a handler that exists.
+        #
+        # It also closes the ambiguity my previous commit MOVED rather than removed:
+        # dropping the false "No structural matches" line left the human path at NO
+        # STDOUT, NO STDERR (the hook redirects it), EXIT 0 -- and silence plus success
+        # reads as "ran fine, nothing found". Same rc closes both halves.
+        print(f"swarph codegraph: NO INDEX AVAILABLE (source={source}) — this is NOT a "
+              f"negative result; nothing was searched.", file=sys.stderr)
+
+    if a.json:
+        print(json.dumps(rows, indent=2))
+    elif not index_present:
+        # >>> A WARNING IS NOT ENOUGH IF THE CLAIM IS STILL PRINTED UNDER IT. <<<
+        # `format_human` says "No structural matches for X" -- a claim about the CODE,
+        # made when nothing was searched. The human path owns both streams, so it does
+        # not make the claim; a warning above a contradicting result just asks the
+        # reader to pick, and they pick the one that looks like a result.
+        pass
+    else:
+        print(format_human(rows, a.query))
+    return 0 if index_present else RC_NO_INDEX

{swarph_cli-0.45.1 → swarph_cli-0.46.0}/src/swarph_cli/commands/codegraph_hook.py

@@ -37,7 +37,7 @@ import urllib.request
 from pathlib import Path
 from typing import Optional
 
-DEFAULT_GATEWAY = os.environ.get("MESH_GATEWAY_URL", "http://localhost:8788")
+DEFAULT_GATEWAY = os.environ.get("MESH_GATEWAY_URL", "http://100.107.222.72:8788")
 TIMEOUT_S = 6
 MAX_ROWS = 6
 
@@ -252,7 +252,10 @@ def run_codegraph_hook(argv: Optional[list] = None) -> int:
         return 0
     tp = _token_path(self_name)
     try:
-        token = tp.read_text().strip()
+        # encoding="utf-8": on Windows a bare read_text() uses the locale codec, and a
+        # non-ASCII byte in the token file crashes the hook with a charmap traceback
+        # that names a credential path.
+        token = tp.read_text(encoding="utf-8").strip()
     except OSError as e:
         _emit(f"CODEGRAPH UNAVAILABLE for '{term}' — peer token unreadable at {tp}: "
               f"{e}. Not a negative result: the graph was never asked.")

{swarph_cli-0.45.1 → swarph_cli-0.46.0}/src/swarph_cli/commands/compress.py

@@ -31,7 +31,9 @@ def run_compress(argv: list[str]) -> int:
     if not path.exists():
         print(f"[compress] no such file: {path}", file=sys.stderr)
         return 2
-    source = path.read_text()
+    # utf-8 explicitly: a bare read_text() uses the locale codec, and on Windows
+    # (charmap) a non-ASCII byte in a marked file crashes the verb (#550).
+    source = path.read_text(encoding="utf-8")
     marker = parse_marker(source)
     if marker is None:
         print(f"[compress] REFUSE: {path} carries no swarph:compress marker — leaving untouched", file=sys.stderr)
@@ -47,7 +49,7 @@ def run_compress(argv: list[str]) -> int:
         print(f"[compress] archival: {path.name} {len(source)}B → {len(res.live)}B live "
               f"(+{len(res.archive)}B → {archive_path.name}); saved {saved}B always-loaded")
         if args.apply:
-            archive_path.write_text(res.archive)
+            archive_path.write_text(res.archive, encoding="utf-8")
             _atomic_write(path, res.live)
             print(f"[compress] applied (.bak left, archive {archive_path.name})")
         return 0

{swarph_cli-0.45.1 → swarph_cli-0.46.0}/src/swarph_cli/commands/daemon.py

@@ -85,7 +85,7 @@ def _build_parser() -> argparse.ArgumentParser:
     )
     p.add_argument(
         "--gateway",
-        default=os.environ.get("MESH_GATEWAY_URL", "http://localhost:8788"),
+        default=os.environ.get("MESH_GATEWAY_URL", "http://100.107.222.72:8788"),
         help="mesh-gateway base URL.",
     )
     p.add_argument(

{swarph_cli-0.45.1 → 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: