swarph-cli 0.72.24__tar.gz → 0.72.26__tar.gz

{swarph_cli-0.72.24/src/swarph_cli.egg-info → swarph_cli-0.72.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.24
+Version: 0.72.26
 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.72.24 → swarph_cli-0.72.26}/pyproject.toml

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

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

{swarph_cli-0.72.24 → swarph_cli-0.72.26}/src/swarph_cli/commands/mesh.py

@@ -97,6 +97,15 @@ def _build_parser() -> argparse.ArgumentParser:
         default=[],
         help="extra recipient (repeatable). from_node in this list is refused.",
     )
+    send.add_argument(
+        "--reply-to",
+        type=int,
+        default=None,
+        metavar="ID",
+        help="id of the message this one answers, sent as reply_to (card #1224). "
+             "The gateway refuses an id that does not exist. It binds nothing "
+             "by itself and does NOT set thread_id.",
+    )
     add_content_args(send)
     _add_common(send)
 
@@ -680,6 +689,8 @@ def _run_send(args: argparse.Namespace) -> int:
     }
     if cc:
         body["cc"] = cc
+    if getattr(args, "reply_to", None) is not None:
+        body["reply_to"] = args.reply_to
     thread_arg = getattr(args, "thread", None)
     if thread_arg:
         if thread_arg == "new":

{swarph_cli-0.72.24 → swarph_cli-0.72.26}/src/swarph_cli/operator/cli.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 
 import argparse
 import json
+import os
 import sys
 from pathlib import Path
 from typing import Sequence
@@ -482,6 +483,18 @@ def main(argv: Sequence[str] | None = None) -> int:
         print(HELP)
         return 0
 
+    # card #1203: inside a cell (SWARPH_SELF set), refuse BEFORE any token
+    # is read -- a cell must not act as the commander by accident. The
+    # explicit --as-operator hatch overrides, loudly (both names on stderr).
+    as_operator = "--as-operator" in stripped
+    if as_operator:
+        stripped = [a for a in stripped if a != "--as-operator"]
+    cell_self = (os.environ.get("SWARPH_SELF") or "").strip()
+    if cell_self and not as_operator:
+        print(f"SWARPH_SELF={cell_self}: this process is inside a cell; "
+              "run swarph-me from a human shell", file=sys.stderr)
+        return 2
+
     try:
         identity, gateway, token = resolve_session(as_name, config_path=config_path)
     except SystemExit as exc:
@@ -490,6 +503,9 @@ def main(argv: Sequence[str] | None = None) -> int:
     except ValueError as exc:
         print(f"swarph-me: {exc}", file=sys.stderr)
         return 2
+    if cell_self and as_operator:
+        print(f"SWARPH_SELF={cell_self}: --as-operator override; "
+              f"acting as operator {identity}", file=sys.stderr)
 
     try:
         return run_verb(identity, gateway, token, stripped)

{swarph_cli-0.72.24 → swarph_cli-0.72.26}/src/swarph_cli/quota_sync.py

@@ -12,10 +12,13 @@ or null, and never clears a prior quota or block.
 """
 from __future__ import annotations
 
+import logging
 import re
 from datetime import datetime, timedelta, timezone
 from typing import Callable, Optional
 
+log = logging.getLogger(__name__)
+
 READ_COOLDOWN = timedelta(minutes=5)
 BLOCK_HOLD = timedelta(minutes=5)
 
@@ -31,6 +34,16 @@ _LOG_LIMIT_RE = re.compile(
     r"usage limit[^\n]*?try again at\s+(.+?)\s*$",
     re.IGNORECASE | re.MULTILINE)
 _RATE_EXCEEDED_RE = re.compile(r"rate limits? exceeded", re.IGNORECASE)
+# card #1221: Claude Code /usage, the 2026-10-19 22:42Z capture. The two
+# runway windows are "Current session" and "Current week (all models)".
+# "Current week (Fable)" is the same weekly reset for one model, so it is
+# not a second window. The gateway ranks on used_pct, resets_at and as_of.
+_CLAUDE_USAGE_RE = re.compile(
+    r"^Current (session|week \(all models\)): "
+    r"([0-9]+(?:\.[0-9]+)?)% used \u00b7 resets "
+    r"(?:([A-Z][a-z]{2} \d{1,2}), )?(\d{1,2}(?::\d{2})?[ap]m) \(UTC\)\s*$",
+    re.MULTILINE,
+)
 
 
 def _iso(dt: datetime) -> str:
@@ -39,40 +52,136 @@ def _iso(dt: datetime) -> str:
     return dt.isoformat()
 
 
+def _clock(clock: str) -> Optional[datetime]:
+    """`4:59pm` or the on-the-hour form `5pm`."""
+    norm = clock[:-2] + clock[-2:].upper()
+    try:
+        return datetime.strptime(norm, "%I:%M%p" if ":" in norm else "%I%p")
+    except ValueError:
+        return None
+
+
+def _claude_reset_iso(date: Optional[str], clock: str, as_of: str) -> Optional[str]:
+    """A dated reset uses as_of's year. A bare clock is the next time after as_of."""
+    try:
+        anchor = datetime.fromisoformat(as_of.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    if anchor.tzinfo is None:
+        return None
+    anchor = anchor.astimezone(timezone.utc)
+    clock_dt = _clock(clock)
+    if clock_dt is None:
+        return None
+    if not date:
+        candidate = anchor.replace(
+            hour=clock_dt.hour, minute=clock_dt.minute,
+            second=0, microsecond=0)
+        if candidate <= anchor:
+            candidate += timedelta(days=1)
+        return candidate.isoformat()
+    norm = clock[:-2] + clock[-2:].upper()
+    try:
+        parsed = datetime.strptime(
+            f"{date} {norm} {anchor.year}",
+            "%b %d " + ("%I:%M%p" if ":" in norm else "%I%p") + " %Y",
+        )
+    except ValueError:
+        return None
+    parsed = parsed.replace(tzinfo=timezone.utc)
+    if parsed < anchor - timedelta(days=1):
+        parsed = parsed.replace(year=anchor.year + 1)
+    return parsed.isoformat()
+
+
+def _window_rows(text: str, as_of: str) -> list:
+    """Last session line and last weekly-all-models line, or neither.
+
+    A pane can repeat a name or hold an older /usage display above a newer
+    one. Counting rows would send two session windows, or stamp the stale
+    display as current, which is the 5h mask card #1217 exists to stop.
+    The set is the last line of each name, and it is sent only when both
+    names parsed.
+    """
+    by_name = {}
+    for match in _CLAUDE_USAGE_RE.finditer(text or ""):
+        reset = _claude_reset_iso(match.group(3), match.group(4), as_of)
+        if reset is None:
+            continue
+        by_name[match.group(1)] = {"used_pct": float(match.group(2)),
+                                   "resets_at": reset,
+                                   "as_of": as_of}
+    session = by_name.get("session")
+    weekly = by_name.get("week (all models)")
+    if session is not None and weekly is not None:
+        return [session, weekly]
+    if session is None and weekly is None:
+        return []
+    found = "session" if session is not None else "week (all models)"
+    missing = "weekly" if session is not None else "session"
+    log.warning(
+        "quota windows dropped: parsed %s only, %s did not parse; "
+        "sending no quota_windows",
+        found, missing)
+    return []
+
+
+def _with_windows(record: Optional[dict], windows: list) -> Optional[dict]:
+    if record is None:
+        return None
+    if windows:
+        record = dict(record)
+        record["windows"] = windows
+    return record
+
+
 def parse_pane_capture(text: str, as_of: str):
     """One read-only pane capture -> a usage record, or None (unknown).
 
     Self-selecting: the codex hit-limit line beats its own heads-up bound;
     a grok modal and a mistral rate error are blocked without figures;
-    anything else (Claude cells, agy labels, empty captures) is None.
+    anything else (a Claude cell transcript, agy labels, empty captures)
+    is None. A Claude Code /usage display keeps two windows: the session
+    and the weekly all-models line (card #1221). The per-model week line
+    is not a second runway window.
     """
     text = text or ""
+    windows = _window_rows(text, as_of)
     low = text.lower()
     # The mistral provider error surfaces in pane output but is classified
     # source 'error' per ruling 2 — it is an API error, not a usage display.
     if _RATE_EXCEEDED_RE.search(text):
-        return {"used_pct": None, "credits": None, "reset_at": None,
-                "blocked": True, "source": "error", "as_of": as_of}
+        return _with_windows(
+            {"used_pct": None, "credits": None, "reset_at": None,
+             "blocked": True, "source": "error", "as_of": as_of}, windows)
     if "buy more credits" in low and "try again" in low:
-        return {"used_pct": None, "credits": None, "reset_at": None,
-                "blocked": True, "source": "pane", "as_of": as_of}
+        return _with_windows(
+            {"used_pct": None, "credits": None, "reset_at": None,
+             "blocked": True, "source": "pane", "as_of": as_of}, windows)
     hit = _CODEX_HIT_RE.search(text)
     if hit:
         # A trailing period is sentence punctuation, not timestamp.
         reset = hit.group(1).strip().rstrip(".").strip() or None
-        return {"used_pct": 100, "credits": None, "reset_at": reset,
-                "blocked": True, "source": "pane", "as_of": as_of}
+        return _with_windows(
+            {"used_pct": 100, "credits": None, "reset_at": reset,
+             "blocked": True, "source": "pane", "as_of": as_of}, windows)
     bound = _CODEX_BOUND_RE.search(text)
     if bound:
         # A bound, not a measurement: used_pct stays null (ruling 2).
-        return {"used_pct": None, "credits": None, "reset_at": None,
-                "blocked": False, "source": "pane", "as_of": as_of,
-                "bound_left_pct": float(bound.group(1))}
+        return _with_windows(
+            {"used_pct": None, "credits": None, "reset_at": None,
+             "blocked": False, "source": "pane", "as_of": as_of,
+             "bound_left_pct": float(bound.group(1))}, windows)
     copilot = _COPILOT_RE.search(text)
     if copilot:
-        return {"used_pct": None, "credits": float(copilot.group(1)),
-                "reset_at": None, "blocked": False, "source": "pane",
-                "as_of": as_of}
+        return _with_windows(
+            {"used_pct": None, "credits": float(copilot.group(1)),
+             "reset_at": None, "blocked": False, "source": "pane",
+             "as_of": as_of}, windows)
+    if windows:
+        return {"used_pct": None, "credits": None, "reset_at": None,
+                "blocked": False, "source": "pane", "as_of": as_of,
+                "windows": windows}
     return None
 
 
@@ -111,6 +220,17 @@ def decide_put(prior: Optional[dict], record: Optional[dict],
     used = record.get("used_pct")
     if used is not None and used != prior.get("quota_used_pct"):
         body["quota_used_pct"] = used
+    windows = []
+    for window in record.get("windows") or []:
+        pct = window.get("used_pct")
+        reset = window.get("resets_at")
+        if pct is None or not reset:
+            continue
+        windows.append({"used_pct": float(pct),
+                        "resets_at": str(reset),
+                        "as_of": window.get("as_of") or as_of})
+    if windows and windows != (prior.get("quota_windows") or []):
+        body["quota_windows"] = windows
     if record.get("blocked"):
         reset = record.get("reset_at")
         until = reset if reset else _iso(now + BLOCK_HOLD)

{swarph_cli-0.72.24 → swarph_cli-0.72.26/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.24
+Version: 0.72.26
 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.72.24 → swarph_cli-0.72.26}/src/swarph_cli.egg-info/SOURCES.txt

@@ -231,7 +231,11 @@ tests/test_1075_task_cli.py
 tests/test_1083_openai_decisions.py
 tests/test_1144_cell_yaml_github.py
 tests/test_1197_commander_taps.py
+tests/test_1203_swarph_me_refusal.py
 tests/test_1206_offer_question.py
+tests/test_1214_egress.py
+tests/test_1219_egress_probe.py
+tests/test_1221_quota_windows.py
 tests/test_124_register_merge.py
 tests/test_126_pending_from_complete.py
 tests/test_132_ensure_monitor_state_dir.py

swarph_cli-0.72.26/tests/test_1203_swarph_me_refusal.py

@@ -0,0 +1,49 @@
+"""card #1203 — swarph-me REFUSES when SWARPH_SELF is set (before any token
+is read), with an explicit, loud --as-operator escape hatch."""
+import os
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "src"))
+
+from swarph_cli.operator import cli  # noqa: E402
+from swarph_cli.operator import config as op_config  # noqa: E402
+
+
+def _cfg(tmp_path):
+    token = tmp_path / "commander.peer_token"
+    token.write_text("test-token\n", encoding="utf-8")
+    cfg = tmp_path / "operator.json"
+    op_config.save_config(identity="commander", gateway="http://example.test:8788",
+                          token_file=str(token), path=cfg)
+    return cfg
+
+
+def test_self_set_refuses_and_no_token_opened(tmp_path, monkeypatch, capsys):
+    monkeypatch.setenv("SWARPH_SELF", "cursor-win")
+    monkeypatch.setattr(cli, "_read_token",
+                        lambda *a, **k: (_ for _ in ()).throw(
+                            AssertionError("token was read before refusal")))
+    rc = cli.main(["cards", "--config", str(_cfg(tmp_path))])
+    assert rc != 0
+    err = capsys.readouterr().err
+    assert "SWARPH_SELF=cursor-win" in err
+    assert "this process is inside a cell" in err
+    assert "run swarph-me from a human shell" in err
+
+
+def test_as_operator_proceeds_and_stderr_names_both(tmp_path, monkeypatch, capsys):
+    monkeypatch.setenv("SWARPH_SELF", "cursor-win")
+    monkeypatch.setattr(cli, "run_verb", lambda identity, gateway, token, rest: 0)
+    rc = cli.main(["cards", "--as-operator", "--config", str(_cfg(tmp_path))])
+    assert rc == 0
+    err = capsys.readouterr().err
+    assert "cursor-win" in err and "commander" in err
+
+
+def test_self_unset_behaviour_unchanged(tmp_path, monkeypatch, capsys):
+    monkeypatch.delenv("SWARPH_SELF", raising=False)
+    monkeypatch.setattr(cli, "run_verb", lambda identity, gateway, token, rest: 0)
+    rc = cli.main(["cards", "--config", str(_cfg(tmp_path))])
+    assert rc == 0
+    assert "inside a cell" not in capsys.readouterr().err