swarph-cli 0.55.0__tar.gz → 0.56.0__tar.gz

{swarph_cli-0.55.0/src/swarph_cli.egg-info → swarph_cli-0.56.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.55.0
+Version: 0.56.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
@@ -180,6 +180,7 @@ swarph board projects add <slug> --title "…" [--goal "…"]
 swarph board cards list [--project <id|slug>] [--stage <s>] [--assignee <who>]
 swarph board cards show <id>
 swarph board cards add --project <id|slug> --title "…" [--body "…"] [--ai2] [--priority N]
+swarph board cards edit <id> [--title "…"] [--body "…"] [--project <id|slug>] [--priority N]
 swarph board cards move <id> <stage>          # advance the card (proposed→idea→spec→plan→build→test→done)
 swarph board cards link <id> <key> <value>    # add/update a link (merges — never clobbers existing links)
 swarph board cards assign <id> <who>
@@ -256,7 +257,7 @@ Config is via env, mirroring `swarph mesh`'s token model: `GBRAIN_MCP_URL` or `S
 
 ```
 swarph memory get <slug>                 # read one page by exact slug
-swarph memory list [--type T] [--tag T]  # filter pages (deterministic — use --type; --tag currently inert)
+swarph memory list [--type T] [--tag T]  # filter pages (deterministic; --tag is the reliable scope — a zero usually means no page carries that tag)
 swarph memory links <slug>               # a concept's forward [[wiki-links]]
 ```
 
@@ -375,6 +376,7 @@ The gateway's **automation control plane** — channels (pub/sub), scheduled eve
 # channels — converge work into pub/sub rooms
 $ swarph channel create research --kind topic --description "market-structure notes"
 $ swarph channel join research --wake-policy mentions_only
+$ swarph channel join alerts   --wake-policy severity_only   # wake only on posts the gateway marks severe: a leading [ALERT]/[CRITICAL]/[ERROR]/[FATAL] or 🚨, or an explicit severity tag (needs mesh-gateway #173+; 0.56.0)
 $ swarph channel list
 $ swarph channel post releases --content "📦 pkg X.Y.Z shipped — <notes>"   # sets channel, omits to_node
 $ swarph channel read releases --limit 10                                  # recent posts (or --json)

{swarph_cli-0.55.0 → swarph_cli-0.56.0}/README.md

@@ -132,6 +132,7 @@ swarph board projects add <slug> --title "…" [--goal "…"]
 swarph board cards list [--project <id|slug>] [--stage <s>] [--assignee <who>]
 swarph board cards show <id>
 swarph board cards add --project <id|slug> --title "…" [--body "…"] [--ai2] [--priority N]
+swarph board cards edit <id> [--title "…"] [--body "…"] [--project <id|slug>] [--priority N]
 swarph board cards move <id> <stage>          # advance the card (proposed→idea→spec→plan→build→test→done)
 swarph board cards link <id> <key> <value>    # add/update a link (merges — never clobbers existing links)
 swarph board cards assign <id> <who>
@@ -208,7 +209,7 @@ Config is via env, mirroring `swarph mesh`'s token model: `GBRAIN_MCP_URL` or `S
 
 ```
 swarph memory get <slug>                 # read one page by exact slug
-swarph memory list [--type T] [--tag T]  # filter pages (deterministic — use --type; --tag currently inert)
+swarph memory list [--type T] [--tag T]  # filter pages (deterministic; --tag is the reliable scope — a zero usually means no page carries that tag)
 swarph memory links <slug>               # a concept's forward [[wiki-links]]
 ```
 
@@ -327,6 +328,7 @@ The gateway's **automation control plane** — channels (pub/sub), scheduled eve
 # channels — converge work into pub/sub rooms
 $ swarph channel create research --kind topic --description "market-structure notes"
 $ swarph channel join research --wake-policy mentions_only
+$ swarph channel join alerts   --wake-policy severity_only   # wake only on posts the gateway marks severe: a leading [ALERT]/[CRITICAL]/[ERROR]/[FATAL] or 🚨, or an explicit severity tag (needs mesh-gateway #173+; 0.56.0)
 $ swarph channel list
 $ swarph channel post releases --content "📦 pkg X.Y.Z shipped — <notes>"   # sets channel, omits to_node
 $ swarph channel read releases --limit 10                                  # recent posts (or --json)

{swarph_cli-0.55.0 → swarph_cli-0.56.0}/pyproject.toml

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

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

{swarph_cli-0.55.0 → swarph_cli-0.56.0}/src/swarph_cli/commands/board.py

@@ -138,7 +138,8 @@ def _format_obligations(data: dict) -> str:
     return "\n".join(lines)
 
 
-def _card_edit_payload(actor, title, body, *, due_at=_SENTINEL, project_id=None) -> dict:
+def _card_edit_payload(actor, title, body, *, due_at=_SENTINEL, project_id=None,
+                       priority=None) -> dict:
     """#191: the edit patch — title and/or body, the two fields that made a
     card's text write-once until the gateway grew them (BoardCardPatch).
 
@@ -150,6 +151,13 @@ def _card_edit_payload(actor, title, body, *, due_at=_SENTINEL, project_id=None)
 
     ``due_at=_SENTINEL`` means the caller did not pass ``--due``; an explicit
     empty string clears the due date (#145).
+
+    ``priority`` needs no sentinel: there is no "clear" for it (the column is
+    NOT NULL DEFAULT 0), so None unambiguously means "not mentioned". THE RANGE
+    IS NOT CHECKED HERE ON PURPOSE — `_validate_priority` on the gateway is the
+    single definition, applied at every write path, and #256b is the card about
+    what happens when that range lives on one of two paths while a comment
+    claims otherwise. A second copy here could drift; the 400 is the answer.
     """
     patch = {"actor": actor}
     if title is not None:
@@ -160,8 +168,11 @@ def _card_edit_payload(actor, title, body, *, due_at=_SENTINEL, project_id=None)
         patch["due_at"] = _normalize_due_at(due_at) if due_at else None
     if project_id is not None:
         patch["project_id"] = int(project_id)   # #740: re-home; the gateway gates it (orchestrator + both owners)
+    if priority is not None:
+        patch["priority"] = int(priority)
     if len(patch) == 1:
-        raise ValueError("nothing to edit — pass --title, --body, --due and/or --project")
+        raise ValueError(
+            "nothing to edit — pass --title, --body, --due, --project and/or --priority")
     return patch
 
 
@@ -598,9 +609,15 @@ def _format_graph(g) -> str:
              f"{_s(n.get('step'))} #{n.get('row_id')} "
              f"{'ok' if n.get('satisfied') else _s(n.get('state')) or '-'}")
             for n in s.get("needs") or []) or "-"
+        # #785: delivery (ref|text|review) is what distinguishes the steps.
+        # Gateway already emits it; dropping it from the default render taught
+        # readers the wrong rule (validate takes prose; build needs a URL) until
+        # a close refusal. Always print the key — absent → `-` — so a missing
+        # field cannot look like "this step has no container".
         line = (f"  {_s(s.get('step'))} [{'M' if s.get('mandatory') else 'opt'}] "
                 f"{_s(s.get('state'))} holder={_s(s.get('holder')) or '-'} "
-                f"due={_s(s.get('due')) or '-'} needs={needs}")
+                f"due={_s(s.get('due')) or '-'} "
+                f"delivery={_s(s.get('delivery')) or '-'} needs={needs}")
         if s.get("eligible") is not None:
             line += f" eligible={', '.join(_s(e) for e in s['eligible']) or '(nobody)'}"
         lines.append(line)
@@ -793,8 +810,9 @@ def _build_parser() -> argparse.ArgumentParser:
                          "container the step names — a ref, >=40 words, or a verdict")
     ck.add_argument("--json", action="store_true"); _add_common(ck)
 
-    cg = cards.add_parser("graph", help="read the card's step graph (#591): every menu "
-                                        "step, its state, holder, due, edges, eligible set")
+    cg = cards.add_parser("graph", help="read the card's step graph (#591/#785): every menu "
+                                        "step, its state, holder, due, delivery container, "
+                                        "edges, eligible set")
     cg.add_argument("id", type=int)
     cg.add_argument("--json", action="store_true"); _add_common(cg)
 
@@ -803,8 +821,9 @@ def _build_parser() -> argparse.ArgumentParser:
     cr.add_argument("--json", action="store_true"); _add_common(cr)
 
     ce = cards.add_parser(
-        "edit", help="edit a card's title and/or body (#191: a correction "
-                     "belongs ON the card, not only in its thread)")
+        "edit", help="edit a card's title, body, due date, project and/or "
+                     "priority (#191: a correction belongs ON the card, not "
+                     "only in its thread)")
     ce.add_argument("id", type=int)
     add_content_args(ce, "--title", required=False,
                      noun="card title", noun_plural="titles")
@@ -814,6 +833,12 @@ def _build_parser() -> argparse.ArgumentParser:
                          "the gateway refuses anyone else). Keeps the card's id, thread and links.")
     ce.add_argument("--due", default=_SENTINEL, metavar="DATE",
                     help="set due date (YYYY-MM-DD or ISO); pass empty string to clear")
+    ce.add_argument("--priority", type=int, default=None, metavar="N",
+                    help="re-prioritise the card. `add` has taken --priority since "
+                         "#256 and `edit` did not, so a card filed at the wrong "
+                         "priority could not be repriced from the CLI — the gateway "
+                         "has accepted it on PATCH the whole time. Range is the "
+                         "gateway's to enforce (0..13); it answers 400.")
     ce.add_argument("--json", action="store_true"); _add_common(ce)
 
     obl = top.add_parser(
@@ -1068,7 +1093,8 @@ def run_board(argv: list[str]) -> int:
                     return 1
             try:
                 patch = _card_edit_payload(
-                    self_name, title_text, body_text, due_at=args.due, project_id=project_id)
+                    self_name, title_text, body_text, due_at=args.due,
+                    project_id=project_id, priority=args.priority)
             except ValueError as exc:
                 print(f"swarph board cards edit: {exc}", file=sys.stderr)
                 return 2

{swarph_cli-0.55.0 → swarph_cli-0.56.0}/src/swarph_cli/commands/channel.py

@@ -44,7 +44,8 @@ def _build_parser() -> argparse.ArgumentParser:
     join.add_argument(
         "--wake-policy",
         default=None,
-        choices=["mentions_only", "here_and_mentions", "all", "muted"],
+        choices=["mentions_only", "here_and_mentions", "all", "muted",
+                 "severity_only"],
     )
     add_common_args(join)
 

{swarph_cli-0.55.0 → swarph_cli-0.56.0}/src/swarph_cli/commands/highlight.py

@@ -10,8 +10,9 @@ Usage:
   swarph highlight "<one-line highlight>" [memory-pointer]
     [--cell NAME] [--timeline-dir DIR] [--when ISO8601] [--no-push]
 
-Timeline dir: ``--timeline-dir`` > ``SWARPH_TIMELINE_DIR`` > ``~/.swarph/timeline``
-  (auto-created + ``git init``'d + given a ``merge=union`` .gitattributes if absent).
+Timeline dir: ``--timeline-dir`` > ``SWARPH_TIMELINE_DIR`` / ``SWARPH_TIMELINE``
+  > ``~/swarph-timeline`` (same default ``swarph timeline`` reads; #716).
+  Auto-created + ``git init``'d + given a ``merge=union`` .gitattributes if absent.
 Cell identity (#657 / house order #332): ``--cell`` > ``SWARPH_SELF`` >
 ``SWARPH_CELL`` > git user.name > hostname. SELF outranks CELL — psmux leaks
 ``SWARPH_CELL`` (#538), so CELL-first posts under another cell's name.
@@ -22,6 +23,7 @@ Push: only if an ``origin`` remote exists and ``--no-push`` is not set; otherwis
 from __future__ import annotations
 
 import argparse
+import http.client
 import os
 import socket
 import subprocess
@@ -30,6 +32,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 
 from swarph_cli.commands.mesh import _post_json, _resolve_token
+from swarph_cli.timeline_paths import timeline_dir
 
 _PUSH_RETRIES = 8
 
@@ -84,25 +87,117 @@ def _credential_error(cell: str, source: str, exc: RuntimeError) -> str:
     return f"swarph highlight: {exc}"
 
 
+def _normalise_repo(repo: Path) -> Path:
+    return Path(os.path.normpath(os.path.expanduser(str(repo))))
+
+
+def _existing_ancestor(repo: Path) -> Path:
+    """Walk up to the nearest existing path. ``normpath`` first so
+    ``x/../swarph-timeline`` (x missing) still names the clone (#65)."""
+    repo = _normalise_repo(repo)
+    while not repo.exists() and repo != repo.parent:
+        repo = repo.parent
+    return repo
+
+
+def _git_gateway_clone_flag(repo: Path) -> bool:
+    """``.git``-resident declaration. Survives clean/stash/reset; cannot be committed.
+
+    ``git config --local swarph.gatewayClone 1`` (ops, once, on the gateway host).
+    A worktree marker dies to ``git clean -fdx`` and propagates on ``git add -A``.
+    Ask git on the nearest existing ancestor — a nonexistent subpath of the
+    flagged clone is still the clone (#65).
+    """
+    repo = _existing_ancestor(repo)
+    if not _is_git_repo(repo):
+        return False
+    r = _git(repo, "config", "--local", "--type=bool", "--get", "swarph.gatewayClone")
+    return r.returncode == 0 and (r.stdout or "").strip().lower() == "true"
+
+
+def _is_gateway_clone(repo: Path) -> bool:
+    """True when ``repo`` is the live gateway working tree (PR #392 / #64 / #65).
+
+    The property belongs to the directory, not the caller's environ.
+    Honour env match (including subpaths) when present, OR
+    ``swarph.gatewayClone`` in the repo's local git config. Walk up to an
+    existing ancestor before either check so ``<clone>/newsub`` cannot
+    mkdir-and-commit into the gateway history.
+    """
+    if _git_gateway_clone_flag(repo):
+        return True
+    raw = (os.environ.get("GATEWAY_TIMELINE_DIR") or "").strip()
+    if not raw:
+        return False
+    try:
+        flagged = Path(os.path.normpath(os.path.expanduser(raw))).resolve()
+        intended = _normalise_repo(repo).resolve()
+        cand = _existing_ancestor(repo).resolve()
+    except OSError:
+        return False
+    # Equal or descendant of the flagged clone. Compare the intended
+    # path too — walking up a not-yet-existing flagged dir would
+    # otherwise miss `cand == flagged` (#63). Do NOT ask
+    # `flagged.is_relative_to(cand)`: cand is the parent of a new
+    # sibling and that over-refuses (#73).
+    if intended == flagged or cand == flagged:
+        return True
+    for p in (intended, cand):
+        try:
+            if p.is_relative_to(flagged):
+                return True
+        except ValueError:
+            if flagged in p.parents:
+                return True
+    return False
+
+
 def _log_via_gateway(gateway: str, cell: str, highlight: str,
                      memory: str, when: str, token_file: str | None,
-                     *, cell_source: str = "unknown") -> int:
+                     *, cell_source: str = "unknown") -> int | None:
     """POST the highlight to the gateway `/highlights` — the gateway holds the git
     push credential, so the cell needs only its mesh peer token (no GitHub PAT).
-    Fail-loud: a non-200 or connection error returns 1 (never a silent git double-write)."""
+
+    Returns 0 on success. Returns 1 (no local write) on credential failure,
+    any HTTP status ≠ 200 (401/422/502 are refusals, not "unreachable"), or
+    a post-send exception (timeout, reset-after-read, bad status line,
+    incomplete body, JSON/Unicode decode of a 200) — the client died after
+    the request may have been committed; that is AMBIGUOUS, not a fallback.
+    Returns None only when status == 0 (no HTTP response: refused/DNS/reset
+    *before* send) so the caller may write locally and announce LOCAL
+    FALLBACK (#716 / PR #392).
+
+    The wrap is HERE, not in ``_post_json`` (17 callers). Catching OSError
+    there and returning status 0 would turn a committed-but-unseen timeout
+    into a duplicate local line. A reset belongs under status 0 only when
+    it beats the send (URLError); post-send resets escape ``_post_json``.
+    """
     url = gateway.rstrip("/") + "/highlights"
-    body: dict = {"highlight": highlight, "cell": cell}
+    body: dict = {"highlight": highlight, "cell": cell, "when": when}
     if memory:
         body["memory"] = memory
-    if when:
-        body["when"] = when
     try:
         token = _resolve_token(cell, token_file)
     except RuntimeError as exc:
         print(_credential_error(cell, cell_source, exc), file=sys.stderr)
         return 1
-    status, resp = _post_json(url, body, token)
+    try:
+        status, resp = _post_json(url, body, token)
+    except http.client.InvalidURL as exc:
+        print(f"swarph highlight: bad gateway URL ({exc})", file=sys.stderr)
+        return 1
+    except (OSError, http.client.HTTPException, ValueError):
+        print(
+            "swarph highlight: AMBIGUOUS: the gateway may have committed — "
+            f"check swarph timeline since {when} before retrying",
+            file=sys.stderr,
+        )
+        return 1
     if status == 200:
+        if not isinstance(resp, dict):
+            print("swarph highlight: gateway POST failed (HTTP 200): "
+                  "non-object body", file=sys.stderr)
+            return 1
         ts = resp.get("ts", "")
         print(f"logged -> TIMELINE.md @ {ts} (via gateway)"
               + (f" -> {memory}" if memory else ""))
@@ -113,6 +208,8 @@ def _log_via_gateway(gateway: str, cell: str, highlight: str,
     detail = resp.get("detail") if isinstance(resp, dict) else resp
     where = f"HTTP {status}" if status else "connection failed"
     print(f"swarph highlight: gateway POST failed ({where}): {detail}", file=sys.stderr)
+    if status == 0:
+        return None  # no HTTP response — local fallback is the closed-port case
     return 1
 
 
@@ -139,8 +236,8 @@ def _git(repo: Path, *args: str, check: bool = False):
 
 
 def _resolve_dir(arg) -> Path:
-    raw = arg or os.environ.get("SWARPH_TIMELINE_DIR") or "~/.swarph/timeline"
-    return Path(os.path.expanduser(raw))
+    """Same default ``swarph timeline`` reads. Call-time — see timeline_paths."""
+    return timeline_dir(dir_arg=arg)
 
 
 def _is_git_repo(repo: Path) -> bool:
@@ -195,6 +292,34 @@ def _has_remote(repo: Path) -> bool:
     return _git(repo, "remote", "get-url", "origin").returncode == 0
 
 
+def _revert_append(repo: Path, line: str) -> None:
+    """Undo our failed add/commit without deleting another writer's bytes (#65).
+
+    If the worktree already equals HEAD, our line was swept into their commit
+    — leave it. Else strip our line from the tail only when HEAD does not
+    already end with it. Then ``git reset -q -- TIMELINE.md``. Not
+    checkout/restore: those are rc 128 under index.lock (the add-failure case).
+    """
+    if _git(repo, "diff", "--quiet", "HEAD", "--", "TIMELINE.md").returncode == 0:
+        return
+    our = line if line.endswith("\n") else line + "\n"
+    tl = repo / "TIMELINE.md"
+    try:
+        body = tl.read_text(encoding="utf-8")
+    except OSError:
+        _git(repo, "reset", "-q", "--", "TIMELINE.md")
+        return
+    if body.endswith(our):
+        head = _git(repo, "show", "HEAD:TIMELINE.md")
+        head_txt = head.stdout if head.returncode == 0 else ""
+        if not head_txt.endswith(our):
+            try:
+                tl.write_text(body[: -len(our)], encoding="utf-8")
+            except OSError:
+                pass
+    _git(repo, "reset", "-q", "--", "TIMELINE.md")
+
+
 def _current_branch(repo: Path) -> str:
     r = _git(repo, "rev-parse", "--abbrev-ref", "HEAD")
     b = r.stdout.strip()
@@ -212,7 +337,8 @@ def run_highlight(argv: list) -> int:
                    help="cell identity (else SWARPH_SELF / SWARPH_CELL / "
                         "git user / hostname)")
     p.add_argument("--timeline-dir", default=None,
-                   help="timeline repo (else SWARPH_TIMELINE_DIR / ~/.swarph/timeline)")
+                   help="timeline repo (else SWARPH_TIMELINE_DIR / "
+                        "SWARPH_TIMELINE / ~/swarph-timeline)")
     p.add_argument("--when", default=None,
                    help="ISO8601 event time for a backfilled highlight; default now")
     p.add_argument("--no-push", action="store_true",
@@ -230,19 +356,31 @@ def run_highlight(argv: list) -> int:
     cell, cell_source = _resolve_cell(args.cell, repo)
     highlight = _collapse(args.highlight)
     memory = _collapse(args.memory)
-    when = _collapse(args.when) if args.when else ""
+    # Always stamp `when` so a gateway commit and a local fallback are
+    # byte-identical (merge=union collapses the duplicate). The gateway
+    # accepts the client's minute verbatim.
+    when = _collapse(args.when) if args.when else _now_ts()
 
     # Peer-token path (default when a gateway is configured): the gateway holds the
     # git credential, so a cell logs with only its mesh peer token — no GitHub PAT.
     # `--local` forces the legacy git path; with no gateway configured it's the git
     # path too, so existing solo/offline timelines are unaffected.
     gateway = "" if args.local else _resolve_gateway(args.gateway)
+    fallback = False
     if gateway:
-        return _log_via_gateway(gateway, cell, highlight, memory, when,
-                                args.token_file, cell_source=cell_source)
+        gw_rc = _log_via_gateway(gateway, cell, highlight, memory, when,
+                                 args.token_file, cell_source=cell_source)
+        if gw_rc is not None:
+            return gw_rc
+        fallback = True
+
+    if fallback and _is_gateway_clone(repo):
+        print("swarph highlight: gateway unreachable; not writing into the "
+              "gateway's clone; retry or use --timeline-dir", file=sys.stderr)
+        return 1
 
     _ensure_timeline(repo, cell)
-    ts = when or _now_ts()
+    ts = when
     branch = _current_branch(repo)
     pushing = (not args.no_push) and _has_remote(repo)
 
@@ -254,15 +392,32 @@ def run_highlight(argv: list) -> int:
                   "conflict) — NOT logged", file=sys.stderr)
             return 1
 
-    with (repo / "TIMELINE.md").open("a", encoding="utf-8") as f:
-        f.write(_format_line(ts, cell, highlight, memory) + "\n")
-    _git(repo, "add", "TIMELINE.md")
+    tl = repo / "TIMELINE.md"
+    entry = _format_line(ts, cell, highlight, memory) + "\n"
+    with tl.open("a", encoding="utf-8") as f:
+        f.write(entry)
+    add = _git(repo, "add", "TIMELINE.md")
+    if add.returncode != 0:
+        _revert_append(repo, entry)
+        print(f"swarph highlight: git add failed: {add.stderr.strip()}", file=sys.stderr)
+        return 1
     commit = _git(repo, "commit", "-m", f"highlight({cell}): {highlight[:60]}")
     if commit.returncode != 0:
+        _revert_append(repo, entry)
         print(f"swarph highlight: commit failed: {commit.stderr.strip()}", file=sys.stderr)
         return 1
 
-    done = f"logged -> TIMELINE.md @ {ts}" + (f" -> {memory}" if memory else "")
+    if fallback:
+        done = f"logged -> {repo} (LOCAL FALLBACK — gateway unreachable)."
+        from swarph_cli.timeline_paths import timeline_file
+        wrote = repo / "TIMELINE.md"
+        if wrote.resolve() != timeline_file().resolve():
+            done += "\n`swarph timeline` will NOT show this until it is drained."
+        if not _has_remote(repo):
+            done += ("\nno origin remote — this commit stays on this filesystem "
+                     "until it is drained.")
+    else:
+        done = f"logged -> TIMELINE.md @ {ts}" + (f" -> {memory}" if memory else "")
     if not pushing:
         print(done)
         return 0

{swarph_cli-0.55.0 → swarph_cli-0.56.0}/src/swarph_cli/commands/mesh.py

@@ -22,6 +22,7 @@ import argparse
 import difflib
 import json
 import os
+import re
 import stat
 import subprocess
 import sys
@@ -2023,16 +2024,27 @@ def _wake_policy_admits(policy, msg: dict, self_name: str) -> bool:
 
     `muted` is handled by the caller (it skips the fetch entirely). Here:
       · mentions_only -> only posts that name this cell
+      · severity_only -> only a row whose stored `priority` is `high` (#777 / #80)
       · all / anything else / None -> admit
 
-    >>> FAIL OPEN, DELIBERATELY. <<< An unknown policy value, or a gateway that
-    does not send one at all, admits the post. Failing CLOSED would drop channel
-    posts silently — which is card #125's ORIGINAL DEFECT, not a safe default:
-    seventeen cells set a policy, nothing honoured it, and nobody could tell
-    because the absence looked exactly like "no posts". A filter that errs toward
-    delivering is recoverable by the reader; one that errs toward silence is not.
-    The inert case is announced by the caller so it cannot pass for enforcement.
+    Severity is ONE stored value, written by the gateway `_fan_out` and
+    echoed by GET /messages. This reader does not re-infer from content
+    or from a request-only `severity` tag — those two producers disagreed
+    by construction on a tag-only-severe post.
+
+    >>> FAIL OPEN, DELIBERATELY (unknown policy). <<< An unknown policy
+    value, or a gateway that does not send one at all, admits the post.
+    Failing CLOSED would drop channel posts silently — which is card
+    #125's ORIGINAL DEFECT, not a safe default. `severity_only` is a
+    named filter: missing/`normal` priority is not high, so it does not
+    admit. The two inert cases are announced by the caller
+    (`_poll_channel_subscriptions_inner`) so they cannot pass for
+    enforcement: wake_policy absent from GET /channels, and
+    severity_only against a GET /messages that sends no `priority` key
+    (gateway predates #173).
     """
+    if policy == "severity_only":
+        return (msg.get("priority") or "").strip().lower() == "high"
     if policy != "mentions_only":
         return True
     raw = msg.get("mentions")
@@ -2101,6 +2113,7 @@ def _poll_channel_subscriptions_inner(state: MonitorState) -> None:
               f"channel filtering INERT, surfacing all posts (gateway predates #125 C1)",
               file=sys.stderr, flush=True)
 
+    priority_inert_announced = False
     for channel in subscribed:
         policy = policies.get(channel)
         if policy == "muted":
@@ -2111,8 +2124,21 @@ def _poll_channel_subscriptions_inner(state: MonitorState) -> None:
         cstatus, cbody = _http_get_json(curl, state.token)
         if cstatus != 200:
             continue
+        fetched = cbody.get("messages", [])
+        # Mixed-version: a live gateway predating #173 accepts no
+        # severity_only join, but a rollback / partial deploy can leave
+        # a holder against a GET that sends no `priority` key. Then
+        # every post is silently dropped. Announce once per poll so
+        # that silence cannot pass for enforcement (#777 / #80).
+        if (policy == "severity_only" and fetched
+                and not any("priority" in m for m in fetched)
+                and not priority_inert_announced):
+            print(f"{state.log_prefix} priority absent from GET /messages — "
+                  f"severity_only filter INERT (gateway predates #173)",
+                  file=sys.stderr, flush=True)
+            priority_inert_announced = True
         new_posts = [
-            m for m in cbody.get("messages", [])
+            m for m in fetched
             if int(m.get("id", 0)) > last_id and m.get("from_node") != state.self_name
             and int(m.get("id", 0)) not in existing_ids
             and _wake_policy_admits(policy, m, state.self_name)

{swarph_cli-0.55.0 → swarph_cli-0.56.0}/src/swarph_cli/commands/timeline.py

@@ -18,22 +18,22 @@ from __future__ import annotations
 import argparse
 import datetime as dt
 import json
-import os
 import re
 import sys
 from collections import namedtuple
 
 from swarph_cli.commands.okf_links import parse_okf_links
+from swarph_cli.timeline_paths import timeline_file
 
 Entry = namedtuple("Entry", "ts cell text links")
 
-_DEFAULT_TIMELINE = os.path.expanduser("~/swarph-timeline/TIMELINE.md")
 # - <ISO-ts> · **<cell>** · <rest>
 _LINE = re.compile(r"^- (?P<ts>\S+)\s+·\s+\*\*(?P<cell>[^*]+)\*\*\s+·\s+(?P<rest>.*)$")
 
 
 def _timeline_path() -> str:
-    return os.environ.get("SWARPH_TIMELINE", _DEFAULT_TIMELINE)
+    """Same default ``swarph highlight`` writes. Call-time — see timeline_paths."""
+    return str(timeline_file())
 
 
 # EVERY FORM THE SHARED TIMELINE ACTUALLY CONTAINS, not only the one we write today.
@@ -134,8 +134,12 @@ def _fmt_human(e: Entry) -> str:
 def run_timeline(argv: list) -> int:
     p = argparse.ArgumentParser(
         prog="swarph timeline",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
         description="Deterministic temporal lookup over the git-backed swarph timeline "
-                    "(range/around/since). $0, no model, no network.")
+                    "(range/around/since). $0, no model, no network.\n"
+                    "Default file: ~/swarph-timeline/TIMELINE.md "
+                    "(SWARPH_TIMELINE / SWARPH_TIMELINE_DIR; same default "
+                    "swarph highlight writes; #716).")
     sub = p.add_subparsers(dest="subcommand")
     pr = sub.add_parser("range", help="entries between two dates (inclusive)")
     pr.add_argument("start"); pr.add_argument("end")