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

{swarph_cli-0.72.25/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.25
+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.25 → swarph_cli-0.72.26}/pyproject.toml

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

{swarph_cli-0.72.25 → 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.25 → 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.25 → 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.25
+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.25 → swarph_cli-0.72.26}/src/swarph_cli.egg-info/SOURCES.txt

@@ -235,6 +235,7 @@ 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_1219_egress_probe.py

@@ -0,0 +1,261 @@
+"""card #1219 / #1225 — runtime egress probe.
+
+The probe runs under bwrap --unshare-net. An unlisted connect fails it.
+A host that cannot prove isolation exits with isolation-unproven.
+On main this file's first assertion fails: tests/egress_probe.py is absent.
+"""
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parent.parent
+PROBE = ROOT / "tests" / "egress_probe.py"
+
+
+def _run(args, timeout=60, **env):
+    assert PROBE.is_file(), "runtime egress probe is not in the tree"
+    merged = os.environ.copy()
+    merged.update(env)
+    return subprocess.run(
+        [sys.executable, str(PROBE), *args],
+        capture_output=True, text=True, env=merged, timeout=timeout)
+
+
+@pytest.mark.skipif(sys.platform != "linux", reason="bwrap --unshare-net is Linux")
+def test_os_system_curl_is_an_unlisted_connect():
+    out = _run(["--mutant", "os-system-curl"])
+    assert out.returncode == 1, out.stderr
+    assert "203.0.113.2" in out.stderr
+
+
+@pytest.mark.skipif(sys.platform != "linux", reason="bwrap --unshare-net is Linux")
+def test_absolute_curl_is_an_unlisted_connect():
+    out = _run(["--mutant", "abs-curl"])
+    assert out.returncode == 1, out.stderr
+    assert "203.0.113.3" in out.stderr
+
+
+@pytest.mark.skipif(sys.platform != "linux", reason="bwrap --unshare-net is Linux")
+def test_asyncio_ssh_is_an_unlisted_connect():
+    out = _run(["--mutant", "asyncio-ssh"])
+    assert out.returncode == 1, out.stderr
+    assert "203.0.113.4" in out.stderr
+
+
+def test_missing_bwrap_fails_closed_with_a_named_reason():
+    out = _run(["--isolation"], EGRESS_PROBE_BWRAP="/no/such/bwrap")
+    assert out.returncode == 2, out.stderr
+    assert "isolation-unproven: bwrap missing" in out.stderr
+
+
+@pytest.mark.skipif(sys.platform != "linux", reason="bwrap --unshare-net is Linux")
+def test_ipv6_literal_connect_is_caught():
+    out = _run(["--mutant", "ipv6"])
+    assert out.returncode == 1, out.stderr
+    assert "2001:db8::1" in out.stderr
+
+
+@pytest.mark.skipif(sys.platform != "linux", reason="bwrap --unshare-net is Linux")
+def test_non_isolating_bwrap_shim_exits_2(tmp_path):
+    shim = tmp_path / "bwrap"
+    shim.write_text(
+        "#!/bin/sh\n"
+        "while [ $# -gt 0 ]; do\n"
+        "  case \"$1\" in\n"
+        "    *strace) break ;;\n"
+        "  esac\n"
+        "  shift\n"
+        "done\n"
+        "exec \"$@\"\n",
+        encoding="utf-8")
+    shim.chmod(0o700)
+    out = _run(["--isolation"], EGRESS_PROBE_BWRAP=str(shim))
+    assert out.returncode == 2, out.stderr
+    assert "isolation-unproven:" in out.stderr
+    assert "ENETUNREACH" in out.stderr
+
+
+@pytest.mark.skipif(sys.platform != "linux", reason="bwrap --unshare-net is Linux")
+def test_planted_unlisted_connect_in_src_fails_the_probe(tmp_path):
+    src = tmp_path / "src" / "swarph_cli"
+    src.mkdir(parents=True)
+    (src / "__init__.py").write_text("", encoding="utf-8")
+    # Fixed mutant, not external input. The test reaches it by calling leak().
+    (src / "stall_alert.py").write_text(
+        "import os\n"
+        "def leak():\n"
+        "    os.system('curl --max-time 1 -s -o /dev/null "
+        "http://203.0.113.50/')\n",
+        encoding="utf-8")
+    tests = tmp_path / "tests"
+    tests.mkdir()
+    (tests / "test_zz_leak.py").write_text(
+        "import sys\n"
+        "from pathlib import Path\n"
+        "sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'src'))\n"
+        "from swarph_cli.stall_alert import leak\n"
+        "def test_leak():\n"
+        "    leak()\n",
+        encoding="utf-8")
+    assert PROBE.is_file(), "runtime egress probe is not in the tree"
+    sys.path.insert(0, str(PROBE.parent))
+    import egress_probe
+    assert hasattr(egress_probe, "run_pytest")
+    # Empty allowlist: the planted 203.0.113.50 literal is unlisted.
+    code = egress_probe.run_pytest(tmp_path, ["tests/test_zz_leak.py"], set())
+    assert code == 1, code
+
+
+# The four lines run_pytest uses to refuse a pytest run whose netns was
+# not proven. Mutant M4 deletes them. Fixed source, not external input.
+_ISOLATION_GUARD = (
+    "    code = prove_isolation()\n"
+    "    if code != 0:\n"
+    "        print(\"pytest isolation was not proven\", file=sys.stderr)\n"
+    "        return code\n"
+)
+
+
+def _shim(path: Path) -> None:
+    # Drops every bwrap flag and execs strace on the host network.
+    path.write_text(
+        "#!/bin/sh\n"
+        "while [ $# -gt 0 ]; do\n"
+        "  case \"$1\" in\n"
+        "    *strace) break ;;\n"
+        "  esac\n"
+        "  shift\n"
+        "done\n"
+        "exec \"$@\"\n",
+        encoding="utf-8")
+    path.chmod(0o700)
+
+
+@pytest.mark.skipif(sys.platform != "linux", reason="bwrap --unshare-net is Linux")
+def test_nonexistent_pytest_path_exits_nonzero():
+    out = _run(["--pytest", "tests/no_such_1225.py"], timeout=90)
+    assert out.returncode != 0, out.stderr
+    assert out.returncode == 2, out.stderr
+    assert "isolation-unproven:" in out.stderr
+    assert "pytest exited" in out.stderr
+
+
+@pytest.mark.skipif(sys.platform != "linux", reason="bwrap --unshare-net is Linux")
+def test_import_error_only_file_is_not_a_vacuous_pass(tmp_path):
+    tests = tmp_path / "tests"
+    tests.mkdir()
+    (tests / "test_only_import.py").write_text(
+        "import does_not_exist_1225\n", encoding="utf-8")
+    sys.path.insert(0, str(PROBE.parent))
+    import egress_probe
+    code = egress_probe.run_pytest(tmp_path, ["tests/test_only_import.py"], set())
+    assert code == 2, code
+
+
+@pytest.mark.skipif(sys.platform != "linux", reason="bwrap --unshare-net is Linux")
+def test_pin_pytest_failure_without_a_connect_is_judged_by_the_trace(tmp_path):
+    """pin: pytest exit 1 with a clean trace stays a pass."""
+    tests = tmp_path / "tests"
+    tests.mkdir()
+    (tests / "test_fails.py").write_text(
+        "def test_x():\n    assert False\n", encoding="utf-8")
+    sys.path.insert(0, str(PROBE.parent))
+    import egress_probe
+    code = egress_probe.run_pytest(tmp_path, ["tests/test_fails.py"], set())
+    assert code == 0, code
+
+
+@pytest.mark.skipif(sys.platform != "linux", reason="bwrap --unshare-net is Linux")
+def test_shim_through_pytest_exits_2(tmp_path, monkeypatch):
+    shim = tmp_path / "bwrap"
+    _shim(shim)
+    monkeypatch.setenv("EGRESS_PROBE_BWRAP", str(shim))
+    tree = tmp_path / "tree"
+    tests = tree / "tests"
+    tests.mkdir(parents=True)
+    (tests / "test_clean.py").write_text(
+        "def test_ok():\n    assert True\n", encoding="utf-8")
+    sys.path.insert(0, str(PROBE.parent))
+    import egress_probe
+    import io
+    from contextlib import redirect_stderr
+    buf = io.StringIO()
+    with redirect_stderr(buf):
+        code = egress_probe.run_pytest(tree, ["tests/test_clean.py"], set())
+    err = buf.getvalue()
+    assert code == 2, err
+    assert "pytest isolation was not proven" in err
+    assert "ENETUNREACH" in err
+
+
+@pytest.mark.skipif(sys.platform != "linux", reason="bwrap --unshare-net is Linux")
+def test_m4_removing_prove_isolation_is_killed(tmp_path):
+    source = PROBE.read_text(encoding="utf-8")
+    assert _ISOLATION_GUARD in source
+    mutated = source.replace(_ISOLATION_GUARD, "    # M4 removed prove_isolation\n", 1)
+    repo = tmp_path / "repo"
+    (repo / "tests").mkdir(parents=True)
+    (repo / "tests" / "egress_probe.py").write_text(mutated, encoding="utf-8")
+    (repo / "tests" / "test_1219_egress_probe.py").write_text(
+        (ROOT / "tests" / "test_1219_egress_probe.py").read_text(encoding="utf-8"),
+        encoding="utf-8")
+    (repo / "EGRESS.md").write_text("# none\n", encoding="utf-8")
+    out = subprocess.run(
+        [sys.executable, "-m", "pytest", "-q", "--tb=line",
+         "tests/test_1219_egress_probe.py::test_shim_through_pytest_exits_2"],
+        cwd=repo, capture_output=True, text=True, timeout=90)
+    assert out.returncode != 0, out.stdout + out.stderr
+
+
+def _mini_repo(tmp_path: Path) -> Path:
+    repo = tmp_path / "repo"
+    src = repo / "src" / "swarph_cli"
+    src.mkdir(parents=True)
+    (src / "__init__.py").write_text("", encoding="utf-8")
+    # Fixed mutant, not external input. test_zz_leak.py is outside the
+    # two-file list make used at 62fb0ee.
+    (src / "stall_alert.py").write_text(
+        "import os\n"
+        "def leak():\n"
+        "    os.system('curl --max-time 1 -s -o /dev/null "
+        "http://203.0.113.50/')\n",
+        encoding="utf-8")
+    tests = repo / "tests"
+    tests.mkdir()
+    (tests / "egress_probe.py").write_text(PROBE.read_text(encoding="utf-8"), encoding="utf-8")
+    (tests / "test_zz_leak.py").write_text(
+        "import sys\n"
+        "from pathlib import Path\n"
+        "sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'src'))\n"
+        "from swarph_cli.stall_alert import leak\n"
+        "def test_leak():\n"
+        "    leak()\n",
+        encoding="utf-8")
+    (repo / "Makefile").write_text((ROOT / "Makefile").read_text(encoding="utf-8"), encoding="utf-8")
+    (repo / "EGRESS.md").write_text("# none\n", encoding="utf-8")
+    return repo
+
+
+@pytest.mark.skipif(sys.platform != "linux", reason="bwrap --unshare-net is Linux")
+def test_plant_outside_the_old_list_fails_make(tmp_path):
+    repo = _mini_repo(tmp_path)
+    out = subprocess.run(
+        ["make", "egress-probe"], cwd=repo, capture_output=True, text=True, timeout=90)
+    assert out.returncode != 0, out.stdout + out.stderr
+    assert "egress-probe-status 1" in out.stdout, out.stdout + out.stderr
+    assert "unlisted-connect" in out.stderr
+
+
+@pytest.mark.skipif(sys.platform != "linux", reason="bwrap --unshare-net is Linux")
+def test_make_prints_unproven_status(tmp_path):
+    repo = _mini_repo(tmp_path)
+    env = os.environ.copy()
+    env["EGRESS_PROBE_BWRAP"] = "/no/such/bwrap"
+    out = subprocess.run(
+        ["make", "egress-probe"], cwd=repo, capture_output=True, text=True,
+        timeout=60, env=env)
+    assert "egress-probe-status 2" in out.stdout, out.stdout + out.stderr
+    assert "isolation-unproven:" in out.stderr

swarph_cli-0.72.26/tests/test_1221_quota_windows.py

@@ -0,0 +1,114 @@
+"""card #1221 — quota_sync reads a real Claude Code /usage display.
+
+Source: Claude Code /usage, run by the commander in the lab-ovh Claude
+Code session. local-command-stdout at 2026-10-19 22:42Z. The text below
+is that display, verbatim.
+
+Kept windows, in order: Current session (the 5h window) and Current week
+(all models). Current week (Fable) is the same weekly reset for one model
+and is not sent. On the previous head this display parses as None.
+"""
+import logging
+from datetime import datetime, timezone
+
+from swarph_cli import quota_sync as qs
+
+DOT = "\u00b7"
+
+CAPTURED_AT = datetime(2026, 10, 19, 22, 42, tzinfo=timezone.utc)
+AS_OF = CAPTURED_AT.isoformat()
+SESSION_RESET = "2026-10-20T02:49:00+00:00"
+WEEKLY_RESET = "2026-10-26T16:59:00+00:00"
+
+USAGE = """You are currently using your subscription to power your Claude Code usage
+
+Current session: 0% used · resets Oct 20, 2:49am (UTC)
+Current week (all models): 1% used · resets Oct 26, 4:59pm (UTC)
+Current week (Fable): 0% used · resets Oct 26, 4:59pm (UTC)
+"""
+
+
+def test_usage_display_sends_the_session_and_the_weekly_window():
+    record = qs.parse_pane_capture(USAGE, AS_OF)
+    assert record is not None
+    assert record["windows"] == [
+        {"used_pct": 0.0, "resets_at": SESSION_RESET, "as_of": AS_OF},
+        {"used_pct": 1.0, "resets_at": WEEKLY_RESET, "as_of": AS_OF},
+    ]
+    assert "Fable" not in str(record["windows"])
+    body = qs.decide_put(None, record, CAPTURED_AT)
+    assert body is not None
+    assert body["quota_windows"] == record["windows"]
+    assert body["quota_as_of"] == AS_OF
+
+
+def _session(pct: int, when: str) -> str:
+    return f"Current session: {pct}% used {DOT} resets {when} (UTC)\n"
+
+
+def _weekly(pct: int, when: str) -> str:
+    return (
+        f"Current week (all models): {pct}% used {DOT} resets {when} (UTC)\n"
+    )
+
+
+def _lines(session_when: str, weekly_when: str) -> str:
+    return _session(0, session_when) + _weekly(1, weekly_when)
+
+
+def test_hour_only_and_minute_resets_both_parse():
+    record = qs.parse_pane_capture(
+        _lines("Oct 20, 4:59pm", "Oct 26, 5pm"), AS_OF)
+    assert record is not None and len(record["windows"]) == 2
+    assert record["windows"][0]["resets_at"] == "2026-10-20T16:59:00+00:00"
+    assert record["windows"][1]["resets_at"] == "2026-10-26T17:00:00+00:00"
+
+
+def test_session_reset_without_a_date_is_the_next_one_after_as_of():
+    record = qs.parse_pane_capture(_lines("2:49am", "Oct 26, 4:59pm"), AS_OF)
+    assert record is not None and len(record["windows"]) == 2
+    assert record["windows"][0]["resets_at"] == "2026-10-20T02:49:00+00:00"
+    later = "2026-10-20T03:00:00+00:00"
+    after = qs.parse_pane_capture(_lines("2:49am", "Oct 26, 4:59pm"), later)
+    assert after is not None
+    assert after["windows"][0]["resets_at"] == "2026-10-21T02:49:00+00:00"
+
+
+def test_one_parsed_window_sends_no_quota_windows(caplog):
+    caplog.set_level(logging.WARNING, logger="swarph_cli.quota_sync")
+    record = qs.parse_pane_capture(_lines("Oct 20, 2:49am", "not-a-time"), AS_OF)
+    assert record is None or "windows" not in record
+    body = qs.decide_put(None, record, CAPTURED_AT)
+    assert body is None or "quota_windows" not in body
+    assert any(
+        "sending no quota_windows" in rec.message for rec in caplog.records)
+    scalar = qs.decide_put(
+        None,
+        {"used_pct": 40.0, "credits": None, "reset_at": None,
+         "blocked": False, "source": "pane", "as_of": AS_OF},
+        CAPTURED_AT)
+    assert scalar is not None
+    assert "quota_windows" not in scalar
+    assert scalar["quota_used_pct"] == 40.0
+
+
+def test_two_session_lines_and_no_weekly_send_no_quota_windows():
+    text = _session(0, "Oct 20, 2:49am") + _session(5, "Oct 20, 3:49am")
+    record = qs.parse_pane_capture(text, AS_OF)
+    assert record is None or "windows" not in record
+    body = qs.decide_put(None, record, CAPTURED_AT)
+    assert body is None or "quota_windows" not in body
+
+
+def test_newer_display_replaces_the_older_one_on_the_same_capture():
+    older = _session(10, "Oct 20, 1:00am") + _weekly(20, "Oct 26, 3:00pm")
+    newer = _session(0, "Oct 20, 2:49am") + _weekly(1, "Oct 26, 4:59pm")
+    record = qs.parse_pane_capture(older + newer, AS_OF)
+    assert record is not None and len(record["windows"]) == 2
+    assert record["windows"] == [
+        {"used_pct": 0.0, "resets_at": "2026-10-20T02:49:00+00:00", "as_of": AS_OF},
+        {"used_pct": 1.0, "resets_at": WEEKLY_RESET, "as_of": AS_OF},
+    ]
+    body = qs.decide_put(None, record, CAPTURED_AT)
+    assert body is not None
+    assert body["quota_windows"] == record["windows"]