swarph-cli 0.53.2__tar.gz → 0.53.3__tar.gz

{swarph_cli-0.53.2/src/swarph_cli.egg-info → swarph_cli-0.53.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.53.2
+Version: 0.53.3
 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

{swarph_cli-0.53.2 → swarph_cli-0.53.3}/pyproject.toml

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

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

{swarph_cli-0.53.2 → swarph_cli-0.53.3}/src/swarph_cli/commands/board.py

@@ -199,16 +199,77 @@ def _cards_of(data):
     return data.get("cards", []) if isinstance(data, dict) else (data or [])
 
 
+def _rel_due(days_until) -> str:
+    """Spell the relative age — a bare date makes the reader compute (#145)."""
+    if days_until is None:
+        return "?"
+    n = int(days_until)
+    if n < 0:
+        d = -n
+        return "1 day ago" if d == 1 else f"{d} days ago"
+    if n == 0:
+        return "today"
+    return "in 1 day" if n == 1 else f"in {n} days"
+
+
+def _format_due_head(data) -> list[str]:
+    """Render the list endpoint's `due` summary + dated cards at the head.
+
+    Built ONLY from the LIST response (#661: GET /board/cards/{id} returns
+    due_state=None even when due_at is set — a single-card readout would
+    report zero overdue forever with no error).
+    """
+    if not isinstance(data, dict):
+        return []
+    due = data.get("due")
+    if not isinstance(due, dict):
+        return []
+    lines = [
+        f"due:  overdue={due.get('overdue', 0)}  today={due.get('today', 0)}  "
+        f"upcoming={due.get('upcoming', 0)}  undated={due.get('undated', 0)}"
+    ]
+    # Prefer overdue, then today, then upcoming — sorted by days_until ascending
+    # so the most overdue sits first. Pull rows from the cards array (the due
+    # block itself is counts only).
+    dated = [c for c in _cards_of(data)
+             if c.get("due_state") in ("overdue", "today", "upcoming")]
+    order = {"overdue": 0, "today": 1, "upcoming": 2}
+    dated.sort(key=lambda c: (
+        order.get(c.get("due_state"), 9),
+        c.get("days_until") is None,
+        c.get("days_until") if c.get("days_until") is not None else 0,
+    ))
+    for c in dated:
+        title = _s(c.get("title") or "")
+        if len(title) > 60:
+            title = title[:57] + "..."
+        lines.append(
+            f"  #{c.get('id')}  {c.get('due_state'):<9}  "
+            f"{_rel_due(c.get('days_until')):<14}  {title}"
+        )
+    if not dated and (due.get("overdue") or due.get("today") or due.get("upcoming")):
+        # Counts say something is dated but this page's cards don't carry them
+        # (filtered list / pagination). Say so — silent empty is the #145 lie.
+        lines.append("  (dated cards not in this page — widen the list filter)")
+    elif not dated:
+        lines.append("  (none dated in this list)")
+    return lines
+
+
 def _format_cards(data) -> str:
+    head = _format_due_head(data)
     rows = _cards_of(data)
     if not rows:
-        return "(no cards)"
-    lines = [f"{'ID':>4}  {'STAGE':<9} {'PRJ':>4} {'AI²':<3} TITLE"]
-    for c in rows:
-        ai2 = "AI²" if c.get("ai2") else ""
-        lines.append(f"{c.get('id',''):>4}  {c.get('stage',''):<9} "
-                     f"{c.get('project_id',''):>4} {ai2:<3} {_s(c.get('title'))}")
-    return "\n".join(lines)
+        body = ["(no cards)"]
+    else:
+        body = [f"{'ID':>4}  {'STAGE':<9} {'PRJ':>4} {'AI²':<3} TITLE"]
+        for c in rows:
+            ai2 = "AI²" if c.get("ai2") else ""
+            body.append(f"{c.get('id',''):>4}  {c.get('stage',''):<9} "
+                        f"{c.get('project_id',''):>4} {ai2:<3} {_s(c.get('title'))}")
+    if head:
+        return "\n".join(head + [""] + body)
+    return "\n".join(body)
 
 
 def _format_card(card: dict) -> str:

{swarph_cli-0.53.2 → swarph_cli-0.53.3}/src/swarph_cli/commands/highlight.py

@@ -12,7 +12,9 @@ Usage:
 
 Timeline dir: ``--timeline-dir`` > ``SWARPH_TIMELINE_DIR`` > ``~/.swarph/timeline``
   (auto-created + ``git init``'d + given a ``merge=union`` .gitattributes if absent).
-Cell identity: ``--cell`` > ``SWARPH_CELL`` > git user.name > hostname.
+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.
 Push: only if an ``origin`` remote exists and ``--no-push`` is not set; otherwise
   the highlight is committed locally (solo/offline timelines work).
 """
@@ -44,8 +46,47 @@ def _resolve_gateway(arg: str | None) -> str:
             or "").strip()
 
 
+def _peer_token_near_match(name: str) -> str | None:
+    """Case-insensitive near-match against on-disk peer tokens (#657 / #510 shape).
+
+    When the resolved cell name has no credential, suggesting `mesh register`
+    mints a DUPLICATE peer if the real name differs only in case (Lab-ovh vs
+    lab-ovh). Prefer "did you mean …" over that advice.
+    """
+    root = Path.home() / ".config" / "swarph"
+    if not root.is_dir():
+        return None
+    want = name.casefold()
+    for path in sorted(root.glob("*.peer_token")):
+        peer = path.name[: -len(".peer_token")]
+        if peer.casefold() == want and peer != name:
+            return peer
+    return None
+
+
+def _credential_error(cell: str, source: str, exc: RuntimeError) -> str:
+    """Name WHERE the cell identity came from; never push register on a near-match."""
+    near = _peer_token_near_match(cell)
+    header = (
+        f"swarph highlight: cannot resolve a mesh credential for {cell!r} "
+        f"(resolved from {source})"
+    )
+    if near is not None:
+        return (
+            f"{header}.\n"
+            f"  did you mean {near!r}? A peer token exists at "
+            f"{Path.home() / '.config' / 'swarph' / (near + '.peer_token')}.\n"
+            f"  Do NOT `swarph mesh register` under {cell!r} — that mints a "
+            f"second identity for a cell that already has one (#657)."
+        )
+    # No near-match: keep the underlying resolver text (includes register advice
+    # for a genuinely unknown name).
+    return f"swarph highlight: {exc}"
+
+
 def _log_via_gateway(gateway: str, cell: str, highlight: str,
-                     memory: str, when: str, token_file: str | None) -> int:
+                     memory: str, when: str, token_file: str | None,
+                     *, cell_source: str = "unknown") -> int:
     """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)."""
@@ -58,7 +99,7 @@ def _log_via_gateway(gateway: str, cell: str, highlight: str,
     try:
         token = _resolve_token(cell, token_file)
     except RuntimeError as exc:
-        print(f"swarph highlight: {exc}", file=sys.stderr)
+        print(_credential_error(cell, cell_source, exc), file=sys.stderr)
         return 1
     status, resp = _post_json(url, body, token)
     if status == 200:
@@ -109,17 +150,27 @@ def _is_git_repo(repo: Path) -> bool:
     return r.returncode == 0 and r.stdout.strip() == "true"
 
 
-def _resolve_cell(arg, repo: Path) -> str:
+def _resolve_cell(arg, repo: Path) -> tuple[str, str]:
+    """Return ``(cell, source)``.
+
+    Order is the house rule (#332 / #538 / #657), matching
+    ``memory_emit_hook._cell``: flag, then SWARPH_SELF, then SWARPH_CELL, then
+    git user.name, then hostname. NEVER case-fold — the FAIL condition on #657
+    is normalising case instead of fixing this order.
+    """
     if arg:
-        return _collapse(arg)
-    env = os.environ.get("SWARPH_CELL")
-    if env:
-        return _collapse(env)
+        return _collapse(arg), "--cell"
+    self_env = os.environ.get("SWARPH_SELF")
+    if self_env:
+        return _collapse(self_env), "$SWARPH_SELF"
+    cell_env = os.environ.get("SWARPH_CELL")
+    if cell_env:
+        return _collapse(cell_env), "$SWARPH_CELL"
     if _is_git_repo(repo):
         r = _git(repo, "config", "user.name")
         if r.returncode == 0 and r.stdout.strip():
-            return _collapse(r.stdout.strip())
-    return socket.gethostname()
+            return _collapse(r.stdout.strip()), "git user.name"
+    return socket.gethostname(), "hostname"
 
 
 def _ensure_timeline(repo: Path, cell: str) -> None:
@@ -158,7 +209,8 @@ def run_highlight(argv: list) -> int:
     p.add_argument("memory", nargs="?", default="",
                    help="optional memory pointer, e.g. [[some-memory]]")
     p.add_argument("--cell", default=None,
-                   help="cell identity (else SWARPH_CELL / git user / hostname)")
+                   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)")
     p.add_argument("--when", default=None,
@@ -175,7 +227,7 @@ def run_highlight(argv: list) -> int:
     args = p.parse_args(argv)
 
     repo = _resolve_dir(args.timeline_dir)
-    cell = _resolve_cell(args.cell, repo)
+    cell, cell_source = _resolve_cell(args.cell, repo)
     highlight = _collapse(args.highlight)
     memory = _collapse(args.memory)
     when = _collapse(args.when) if args.when else ""
@@ -186,7 +238,8 @@ def run_highlight(argv: list) -> int:
     # path too, so existing solo/offline timelines are unaffected.
     gateway = "" if args.local else _resolve_gateway(args.gateway)
     if gateway:
-        return _log_via_gateway(gateway, cell, highlight, memory, when, args.token_file)
+        return _log_via_gateway(gateway, cell, highlight, memory, when,
+                                args.token_file, cell_source=cell_source)
 
     _ensure_timeline(repo, cell)
     ts = when or _now_ts()

{swarph_cli-0.53.2 → swarph_cli-0.53.3}/src/swarph_cli/commands/monitor.py

@@ -1500,15 +1500,39 @@ def _sleep(seconds: float) -> None:
     time.sleep(seconds)
 
 
-def _unit_owned_instances() -> "list[str]":
-    """The peers whose monitor systemd is running RIGHT NOW, from systemd's own
-    registry — the property, not a process pattern (#517's lesson: a pattern
-    matches what you expect the world to look like; this asks the owner).
-    Empty when systemctl cannot answer, and the CALLER hears why via the
-    exception — an unreadable registry must not render as an empty fleet."""
+def _peer_from_monitor_unit(unit: str) -> "str | None":
+    """Mesh peer for a running ``swarph-monitor*.service`` unit.
+
+    Template instances encode the peer in the unit name; bespoke units carry
+    it in ``ExecStart --as`` (#665).
+    """
+    if unit.startswith("swarph-monitor@") and unit.endswith(".service"):
+        return unit[len("swarph-monitor@"):-len(".service")]
+    try:
+        proc = subprocess.run(
+            ["systemctl", "show", unit, "-p", "ExecStart", "--value"],
+            capture_output=True, text=True, check=True,
+            encoding="utf-8", errors="replace", timeout=10,
+        )
+    except (OSError, subprocess.CalledProcessError, subprocess.TimeoutExpired):
+        return None
+    text = proc.stdout.strip()
+    if "monitor start" not in text:
+        return None
+    m = re.search(r"--as\s+(\S+)", text)
+    return m.group(1) if m else None
+
+
+def _supervised_monitor_units() -> "list[tuple[str, str]]":
+    """Every running swarph-monitor unit → ``(peer, unit.service)``.
+
+    Lists ``swarph-monitor*`` from systemd — template AND bespoke names — and
+    confirms each unit's ExecStart is ``monitor start``. The old
+    ``swarph-monitor@*`` glob alone missed bespoke-named units (#665).
+    """
     try:
         out = subprocess.run(
-            ["systemctl", "list-units", "swarph-monitor@*", "--state=running",
+            ["systemctl", "list-units", "swarph-monitor*", "--state=running",
              "--no-legend", "--no-pager", "--plain"],
             capture_output=True, text=True, check=True,
             encoding="utf-8", errors="replace").stdout
@@ -1516,12 +1540,40 @@ def _unit_owned_instances() -> "list[str]":
         raise RuntimeError(
             "systemctl cannot list running swarph-monitor instances"
         ) from exc
-    peers = []
+    by_peer: dict[str, str] = {}
     for line in out.splitlines():
-        first = line.split()[0] if line.split() else ""
-        if first.startswith("swarph-monitor@") and first.endswith(".service"):
-            peers.append(first[len("swarph-monitor@"):-len(".service")])
-    return sorted(peers)
+        unit = line.split()[0] if line.split() else ""
+        if not unit.endswith(".service"):
+            continue
+        if unit == "swarph-monitor-reexec.service":
+            continue
+        if not unit.startswith("swarph-monitor"):
+            continue
+        peer = _peer_from_monitor_unit(unit)
+        if peer:
+            by_peer[peer] = unit
+    return sorted(by_peer.items(), key=lambda t: t[0])
+
+
+def _unit_owned_instances() -> "list[str]":
+    """Peer names whose monitor is running under a systemd unit RIGHT NOW."""
+    return [peer for peer, _ in _supervised_monitor_units()]
+
+
+def _count_pidfile_state_dirs(state_root: Path) -> int:
+    """State dirs that have ever claimed a monitor pidfile (#665 denominator)."""
+    if not state_root.is_dir():
+        return 0
+    n = 0
+    for peer_dir in state_root.iterdir():
+        if peer_dir.is_dir() and (peer_dir / "mesh-sidecar" / mesh._MONITOR_PIDFILE).exists():
+            n += 1
+    return n
+
+
+def _is_swarph_monitor_unit_name(unit_leaf: str) -> bool:
+    """True when a cgroup-derived unit leaf names a swarph monitor service."""
+    return unit_leaf.startswith("swarph-monitor") and unit_leaf.endswith(".service")
 
 
 def _cmd_reexec_on_change(args: argparse.Namespace) -> int:
@@ -1540,49 +1592,61 @@ def _cmd_reexec_on_change(args: argparse.Namespace) -> int:
     print("  note: a RUNNING process's build is unknowable from outside "
           "(#649) — 'running since' is the honest old-side coordinate")
 
-    unit_owned = _unit_owned_instances()
+    supervised = _supervised_monitor_units()
+    supervised_peers = {peer for peer, _ in supervised}
+    pidfile_dirs = _count_pidfile_state_dirs(state_root)
     held, out_of_scope, not_running, failed = [], [], [], []
-    plan = []  # (peer, since-string)
-    for peer in unit_owned:
+    plan = []  # (peer, unit.service, since-string)
+    for peer, unit in supervised:
         state_dir = state_root / peer / "mesh-sidecar"
         hold = _read_reexec_hold(state_dir)
         if hold:
-            held.append(f"{peer} — {_fmt_reexec_hold(hold)}")
+            held.append(f"{peer} ({unit}) — {_fmt_reexec_hold(hold)}")
             continue
         pstatus, rec = mesh.pidfile_status(state_dir / mesh._MONITOR_PIDFILE)
         since = (_proc_start_iso(rec["pid"]) if pstatus == "live_ours"
                  else None) or f"unknown (pidfile {pstatus})"
-        plan.append((peer, since))
+        plan.append((peer, unit, since))
 
     # R6: monitors with a LIVE pidfile that no unit owns — tmux-scoped or
     # hand-started — are named, never omitted.
     if state_root.is_dir():
         for peer_dir in sorted(state_root.iterdir()):
             peer = peer_dir.name
-            if peer in unit_owned or not peer_dir.is_dir():
+            if peer in supervised_peers or not peer_dir.is_dir():
                 continue
             state_dir = peer_dir / "mesh-sidecar"
             pstatus, rec = mesh.pidfile_status(state_dir / mesh._MONITOR_PIDFILE)
             if pstatus == "live_ours":
+                derived = _derive_systemd_unit(rec["pid"])
                 cgroup = _read_cgroup(rec["pid"]) or ""
                 scope = next((p for p in reversed(cgroup.replace("\n", " ").split("/"))
                               if p), "unreadable cgroup")
-                out_of_scope.append(f"{peer} (pid {rec['pid']} in {scope})")
+                if derived and _is_swarph_monitor_unit_name(f"{derived}.service"):
+                    # Enumerator missed a unit-owned monitor — name it loudly.
+                    out_of_scope.append(
+                        f"{peer} (pid {rec['pid']} in {derived}.service — "
+                        f"unit-owned but not enumerated; fix the enumerator)"
+                    )
+                else:
+                    out_of_scope.append(f"{peer} (pid {rec['pid']} in {scope})")
             elif pstatus in ("stale", "foreign"):
                 not_running.append(f"{peer} (pidfile {pstatus} — revival is "
                                    f"the watchdog's job, not this verb's)")
 
-    for i, (peer, since) in enumerate(plan):
+    restarted_n = 0
+    for i, (peer, unit, since) in enumerate(plan):
         if not args.apply:
-            print(f"  would restart: {peer} (running since {since})")
+            print(f"  would restart: {peer} via {unit} (running since {since})")
             continue
-        rc = _systemctl_run(["restart", f"swarph-monitor@{peer}.service"])
+        rc = _systemctl_run(["restart", unit])
         if rc == 0:
-            print(f"  reexec: {peer} restarted onto {version} "
+            restarted_n += 1
+            print(f"  reexec: {peer} restarted onto {version} via {unit} "
                   f"(was running since {since})")
         else:
-            failed.append(f"{peer} (systemctl restart rc={rc})")
-            print(f"  reexec FAILED: {peer} (systemctl rc={rc})")
+            failed.append(f"{peer} ({unit}, systemctl restart rc={rc})")
+            print(f"  reexec FAILED: {peer} ({unit}, systemctl rc={rc})")
         if i < len(plan) - 1:
             _sleep(args.stagger_s)  # R3: serial, never simultaneous
 
@@ -1593,8 +1657,10 @@ def _cmd_reexec_on_change(args: argparse.Namespace) -> int:
     # R6: the report is where out-of-scope cells exist at all.
     for line in out_of_scope:
         print(f"  OUT OF SCOPE (not unit-owned; cannot be re-exec'd here): {line}")
-    print(f"reexec-on-change: {len(plan)} restarted"
+    action = "restarted" if args.apply else "would restart"
+    print(f"reexec-on-change: {restarted_n if args.apply else len(plan)} {action}"
           f"{'' if args.apply else ' (DRY RUN — pass --apply to act)'}, "
+          f"{len(supervised)} unit-supervised, {pidfile_dirs} state dirs with pidfile, "
           f"{len(held)} held, {len(out_of_scope)} out of scope, "
           f"{len(not_running)} not running, {len(failed)} failed")
     return 1 if failed else 0

{swarph_cli-0.53.2 → swarph_cli-0.53.3}/src/swarph_cli/commands/watchdog.py

@@ -162,6 +162,7 @@ Usage:
                           [--peer-health-window-sec SEC]
                           [--peer-health-recovery-threshold SEC]
                           [--log PATH] [--verbose]
+  swarph watchdog --orphan-daemons
   swarph watchdog --install-service [--cell ROLE] [--dry-run]
 
 Detects stranded Claude sessions (API throttle / harness death) and attempts
@@ -1916,6 +1917,12 @@ def _build_parser() -> argparse.ArgumentParser:
         "--check", action="store_true",
         help="One-shot check (cron-callable; exits with status code).",
     )
+    p.add_argument(
+        "--orphan-daemons", action="store_true",
+        help="#666 T1: read-only scan for orphaned `claude daemon run` "
+             "processes (spawner dead + tmux-spawn scope gone). Prints a "
+             "report; never signals. UNKNOWN ≠ ORPHANED.",
+    )
     p.add_argument(
         "--install-service", action="store_true",
         help="Install systemd timer + service for periodic --check invocation. "
@@ -2093,6 +2100,10 @@ def run_watchdog(argv: Optional[list[str]] = None) -> int:
     if args.install_service:
         return run_install_service(args)
 
+    if args.orphan_daemons:
+        from swarph_cli.orphan_daemons import run_orphan_daemons_report
+        return run_orphan_daemons_report()
+
     if not args.check:
         print(_USAGE, file=sys.stderr)
         return 4