swarph-cli 0.72.18__tar.gz → 0.72.20__tar.gz

{swarph_cli-0.72.18/src/swarph_cli.egg-info → swarph_cli-0.72.20}/PKG-INFO

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

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

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

{swarph_cli-0.72.18 → swarph_cli-0.72.20}/src/swarph_cli/bench/providers.py

@@ -99,3 +99,23 @@ def load_registry(path: str | Path | None) -> dict[str, dict]:
     raw = Path(path).read_text(encoding="utf-8")
     data = tomllib.loads(raw)
     return {name: _check(name, entry) for name, entry in data.items()}
+
+
+def provider_arm(name: str, entry: dict, noul_threshold):
+    """The registry arm for ``provider:<name>``.
+
+    ``kind = "decisions"`` is the OpenAI Decisions translator. ``typed`` and
+    ``semantic`` stay on :class:`~swarph_cli.bench.backends.HttpBackend`,
+    which posts a typed pack body unchanged.
+    """
+    from .backends import DecisionsBackend, HttpBackend
+
+    common = dict(
+        name=name, base_url=entry["base_url"], path=entry["path"],
+        auth=entry.get("auth"), usage=entry.get("usage"),
+        price=entry.get("price"), egress=entry["egress"],
+        noul_threshold=noul_threshold,
+    )
+    if entry["kind"] == "decisions":
+        return DecisionsBackend(**common)
+    return HttpBackend(kind=entry["kind"], **common)

{swarph_cli-0.72.18 → swarph_cli-0.72.20}/src/swarph_cli/bench/validate.py

@@ -22,7 +22,7 @@ import json
 from .backends import Backend
 from .pack import validate_schema
 from .quality import d_text
-from .runner import ModelSpec, preflight, run_pack
+from .runner import ModelSpec, parse_models, preflight, run_pack
 
 DISCRIMINATION_MIN_SPREAD = 0.05  # min stdev of mean_distance across reference models
 # Conservative: text prompts and their expected answers naturally share topical
@@ -199,13 +199,48 @@ CALIBRATION_NOTICE = (
 )
 
 
-def gate_calibration(pack: dict, backends: Optional[dict[str, Backend]] = None) -> list[str]:
+def _calibration_spec(model: str, pack: dict, registry: Optional[dict]):
+    """One spec from the same grammar ``--models`` uses.
+
+    ``provider:<name>`` is not runnable until its registry arm is attached.
+    A bare id stays on the metered default, which is what ``parse_models``
+    already does — this does not reimplement that split.
+    """
+    from .providers import RegistryError, load_registry, provider_arm, registry_path
+
+    specs = parse_models(model)
+    if len(specs) != 1:
+        return None
+    spec = specs[0]
+    if spec.backend != "provider":
+        return spec
+    try:
+        if registry is None:
+            registry = load_registry(registry_path())
+    except (OSError, RegistryError) as exc:
+        raise RegistryError(str(exc)) from exc
+    entry = (registry or {}).get(spec.provider)
+    if entry is not None:
+        spec.arm = provider_arm(spec.provider, entry, pack.get("noul_threshold"))
+    return spec
+
+
+def gate_calibration(
+    pack: dict,
+    backends: Optional[dict[str, Backend]] = None,
+    *,
+    registry: Optional[dict] = None,
+) -> list[str]:
     """ALWAYS emits the context-calibration requirement as a warning (§5d is
     guidance, not automatable in full). If the pack declares
     ``meta.calibration`` ({model, task_ids, expected_mean_distance_max}),
     additionally checks that the declared model+system reproduces it — full
     standardization of this format is DEFERRED (decision #4); this is the
-    minimal v1 check."""
+    minimal v1 check.
+
+    ``meta.calibration.model`` is one ``parse_models`` token: ``id[:backend[:label]]``
+    or ``provider:<name>``. A bare id keeps the metered backend.
+    """
     warnings = [CALIBRATION_NOTICE]
     calib = (pack.get("meta") or {}).get("calibration")
     if not calib:
@@ -214,7 +249,7 @@ def gate_calibration(pack: dict, backends: Optional[dict[str, Backend]] = None)
     model = calib.get("model")
     task_ids = calib.get("task_ids")
     expected_max = calib.get("expected_mean_distance_max")
-    if not (model and task_ids and expected_max is not None):
+    if not (isinstance(model, str) and model.strip() and task_ids and expected_max is not None):
         warnings.append(
             "meta.calibration is present but malformed (need model, task_ids, "
             "expected_mean_distance_max) — skipping the reproduction check"
@@ -229,10 +264,26 @@ def gate_calibration(pack: dict, backends: Optional[dict[str, Backend]] = None)
         )
         return warnings
 
-    runnable, preflight_warnings = preflight([ModelSpec(id=model)], backends)
+    from .providers import RegistryError
+
+    try:
+        spec = _calibration_spec(model, pack, registry)
+    except RegistryError as exc:
+        warnings.append(f"meta.calibration provider registry unreadable: {exc}")
+        return warnings
+    if spec is None:
+        warnings.append(
+            f"meta.calibration model={model!r} must be one model spec "
+            f"(id[:backend[:label]] or provider:<name>) — skipping the reproduction check"
+        )
+        return warnings
+
+    runnable, preflight_warnings = preflight([spec], backends, pack=pack)
     warnings.extend(preflight_warnings)
     if not runnable:
-        warnings.append(f"meta.calibration check could not run: {model!r} lacks credentials")
+        # The preflight warning already names the refusal (credentials, kind
+        # mismatch, on_box_only egress). A second "lacks credentials" line
+        # mislabels every other refusal as a missing key.
         return warnings
 
     result = run_pack(runnable, pack, backends, task_ids=task_ids)

{swarph_cli-0.72.18 → swarph_cli-0.72.20}/src/swarph_cli/commands/bench.py

@@ -32,7 +32,6 @@ from swarph_cli.bench.backends import (
     SubscriptionBackend,
     TypedHttpBackend,
     HttpBackend,
-    DecisionsBackend,
 )
 from swarph_cli.bench.pack import PackError, load_pack, slugify_theme, validate_schema
 from swarph_cli.bench.providers import RegistryError, load_registry, registry_path
@@ -223,21 +222,9 @@ def _default_packs_dir() -> Path:
 
 
 def _provider_arm(name: str, entry: dict, noul_threshold):
-    """The registry arm for ``provider:<name>``.
-
-    ``kind = "decisions"`` is the OpenAI Decisions translator. ``typed`` and
-    ``semantic`` stay on :class:`HttpBackend`, which posts a typed pack body
-    unchanged.
-    """
-    common = dict(
-        name=name, base_url=entry["base_url"], path=entry["path"],
-        auth=entry.get("auth"), usage=entry.get("usage"),
-        price=entry.get("price"), egress=entry["egress"],
-        noul_threshold=noul_threshold,
-    )
-    if entry["kind"] == "decisions":
-        return DecisionsBackend(**common)
-    return HttpBackend(kind=entry["kind"], **common)
+    """The registry arm for ``provider:<name>``. Same constructor validate uses."""
+    from swarph_cli.bench.providers import provider_arm
+    return provider_arm(name, entry, noul_threshold)
 
 
 # ── dispatch ───────────────────────────────────────────────────────────────

{swarph_cli-0.72.18 → swarph_cli-0.72.20}/src/swarph_cli/scripts/wake_watchdog.py

@@ -14,6 +14,7 @@ from pathlib import Path
 from typing import Iterable
 
 GAP_SECONDS = 60
+WAIT_REARM_GRACE = 600
 
 
 def writer_verdict(*, reader_alive: bool, monitor_rc: int) -> str:
@@ -132,16 +133,33 @@ def _channel_alive(inbox: str, now: float | None = None) -> bool:
     return (time.time() if now is None else now) - ts < 180
 
 
+def _waiter_just_delivered(inbox: str, now: float | None = None) -> bool:
+    """`swarph mesh wait --once` writes wait_cursor.json beside the inbox when it
+    delivers, then exits. The cell re-arms only after acting on the DM, which can
+    take minutes; inside that window no waiter is running but the wake is not dead.
+    """
+    try:
+        mtime = (Path(inbox).parent / "wait_cursor.json").stat().st_mtime
+    except OSError:
+        return False
+    age = (time.time() if now is None else now) - mtime
+    return 0 <= age < WAIT_REARM_GRACE  # a future mtime is not a delivery
+
+
 def _watching(inbox: str, cmdlines: Iterable[str]) -> bool:
     """A reader is tail or dm_notify_filter with the inbox path as its own argument,
-    or a channel server whose heartbeat is fresh.
+    a channel server whose heartbeat is fresh, or a one-shot `swarph mesh wait`
+    for this cell (running, or delivered within WAIT_REARM_GRACE).
 
     A process that merely mentions the path (a prompt, a log line) is not a reader.
     """
-    if _channel_alive(inbox):
+    if _channel_alive(inbox) or _waiter_just_delivered(inbox):
         return True
+    cell = Path(inbox).parent.parent.name
     for cmd in cmdlines:
         parts = cmd.split()
+        if _waits_on(parts, cell):
+            return True
         if inbox not in parts:
             continue
         if any(os.path.basename(p) == "tail" for p in parts):
@@ -151,6 +169,27 @@ def _watching(inbox: str, cmdlines: Iterable[str]) -> bool:
     return False
 
 
+def _waits_on(parts: list[str], cell: str) -> bool:
+    """`swarph mesh wait --once --as <cell>` names the cell, not the inbox path.
+
+    copilot wakes on this waiter's exit (card #387). The process must BE swarph
+    (argv[0], or argv[1] after an interpreter), so a prompt that quotes the
+    command is not a reader.
+    """
+    for i in (0, 1):
+        if len(parts) < i + 3 or os.path.basename(parts[i]) != "swarph":
+            continue
+        if i == 1 and not os.path.basename(parts[0]).startswith("python"):
+            continue
+        if parts[i + 1:i + 3] != ["mesh", "wait"]:
+            continue
+        rest = parts[i + 3:]
+        named = f"--as={cell}" in rest or any(
+            a == "--as" and b == cell for a, b in zip(rest, rest[1:]))
+        return "--once" in rest and named
+    return False
+
+
 def _cron_watched(name: str, crontab: str) -> bool:
     """An active crontab line that runs dm_wake.py for this cell is its poller."""
     for line in crontab.splitlines():

{swarph_cli-0.72.18 → swarph_cli-0.72.20/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.18
+Version: 0.72.20
 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.18 → swarph_cli-0.72.20}/tests/test_729_wake_watchdog.py

@@ -240,3 +240,54 @@ def test_a_channel_cell_with_a_fresh_heartbeat_is_watched(tmp_path):
     hb.write_text(json.dumps({"pid": 1, "ts": _t.time() - 600}))  # server died 10 min ago
     assert scan(cells, channel_ps, state, now=130) == []
     assert scan(cells, channel_ps, state, now=200) == ["drop"]
+
+
+def test_a_one_shot_mesh_wait_for_the_cell_is_a_watcher(tmp_path):
+    """Live 2026-10-12 23:34Z: copilot wakes on `swarph mesh wait --once` exiting (card #387,
+    probe 69717), and that command line names the cell, not the inbox path, so the watchdog
+    paged copilot 'DM wake is dead' (msgs 69720/69721). Fails on main.
+    tmp_path, not the live path: a live wait_cursor.json would count as watched."""
+    inbox = str(tmp_path / "copilot" / "mesh-sidecar" / "inbox.log")
+    cells = {"copilot": inbox}
+    waiter = ["/usr/bin/python3 /home/ubuntu/.local/bin/swarph mesh wait --once --as copilot --max-wait-s 1500"]
+    state = {}
+    assert scan(cells, waiter, state, now=0) == []
+    assert scan(cells, waiter, state, now=120) == []
+    assert scan(cells, ["swarph mesh wait --once --as=copilot"], {}, now=120) == []
+    other = ["/usr/bin/python3 /home/ubuntu/.local/bin/swarph mesh wait --once --as lab-ovh"]
+    quoted = ["claude -p run swarph mesh wait --once --as copilot then reply"]
+    no_once = ["/home/ubuntu/.local/bin/swarph mesh wait --as copilot"]
+    # drop-on-meta-edge #1682: argv[1] counted without checking argv[0] is an interpreter.
+    echo = ["echo swarph mesh wait --once --as copilot"]
+    grep = ["grep swarph mesh wait --once --as copilot notes.txt"]
+    claude = ["claude swarph mesh wait --once --as copilot and report"]
+    for listing in (other, quoted, no_once, echo, grep, claude):
+        st = {}
+        assert scan(cells, listing, st, now=0) == []
+        assert scan(cells, listing, st, now=120) == ["copilot"], listing
+
+
+def test_the_re_arm_gap_after_a_one_shot_delivery_is_not_an_outage(tmp_path):
+    """The waiter exits on delivery and copilot re-arms only after acting on the DM;
+    a turn longer than GAP_SECONDS paged copilot under the waiter-only fix. A cursor
+    written 30 s ago covers the gap; one written 700 s ago does not."""
+    import os, time
+    inbox = tmp_path / "copilot" / "mesh-sidecar" / "inbox.log"
+    inbox.parent.mkdir(parents=True)
+    inbox.write_text("")
+    cursor = inbox.parent / "wait_cursor.json"
+    cursor.write_text('{"last_delivered_id": 69717}')
+    cells = {"copilot": str(inbox)}
+    t = time.time()
+    os.utime(cursor, (t - 30, t - 30))
+    st = {}
+    assert scan(cells, [], st, now=0) == []
+    assert scan(cells, [], st, now=120) == []
+    os.utime(cursor, (t - 700, t - 700))
+    st = {}
+    assert scan(cells, [], st, now=0) == []
+    assert scan(cells, [], st, now=120) == ["copilot"]
+    os.utime(cursor, (t + 3600, t + 3600))  # #1682: a future mtime hid the outage unboundedly
+    st = {}
+    assert scan(cells, [], st, now=0) == []
+    assert scan(cells, [], st, now=120) == ["copilot"]

{swarph_cli-0.72.18 → swarph_cli-0.72.20}/tests/test_bench_validate.py

@@ -294,7 +294,147 @@ def test_calibration_missing_creds_flagged_gracefully():
             return ["SOME_KEY"]
 
     warnings = gate_calibration(p, backends={"metered": NoCreds()})
-    assert any("lacks credentials" in w for w in warnings)
+    assert any("requires SOME_KEY" in w and "skipped" in w for w in warnings)
+    assert not any("lacks credentials" in w for w in warnings)
+
+
+class _Recording:
+    def __init__(self, inner):
+        self.inner = inner
+        self.calls = []
+
+    def generate(self, model_id, prompt, system=""):
+        self.calls.append(model_id)
+        return self.inner.generate(model_id, prompt, system)
+
+    def missing_creds(self):
+        return []
+
+
+def test_calibration_subscription_backend_is_called():
+    p = _pack(meta={"calibration": {
+        "model": "m:subscription",
+        "task_ids": ["arith_mult"],
+        "expected_mean_distance_max": 0.1,
+    }})
+    subscription = _Recording(ScriptedBackend(PERFECT_ANSWERS))
+    metered = _Recording(ScriptedBackend({}))
+    warnings = gate_calibration(p, backends={"subscription": subscription, "metered": metered})
+    assert subscription.calls == ["m"]
+    assert metered.calls == []
+    assert any("meta.calibration OK" in w or "MISMATCH" in w for w in warnings)
+    assert not any("could not run" in w for w in warnings)
+
+
+def test_calibration_bare_id_binds_metered_backend():
+    p = _pack(meta={"calibration": {
+        "model": "bare-id",
+        "task_ids": ["arith_mult"],
+        "expected_mean_distance_max": 0.1,
+    }})
+    subscription = _Recording(ScriptedBackend(PERFECT_ANSWERS))
+    metered = _Recording(ScriptedBackend(PERFECT_ANSWERS))
+    warnings = gate_calibration(p, backends={"subscription": subscription, "metered": metered})
+    assert metered.calls == ["bare-id"]
+    assert subscription.calls == []
+    assert any("meta.calibration OK" in w for w in warnings)
+
+
+def test_calibration_provider_resolves_registry_arm(monkeypatch):
+    from swarph_cli.bench import providers as providers_mod
+    from swarph_cli.bench.backends import HttpBackend
+
+    built = []
+    seen = []
+    real = providers_mod.provider_arm
+
+    def wrapped(name, entry, noul):
+        arm = real(name, entry, noul)
+        built.append((name, entry, arm))
+        inner = ScriptedBackend(PERFECT_ANSWERS)
+
+        def generate(model_id, prompt, system=""):
+            seen.append(model_id)
+            return inner.generate(model_id, prompt, system)
+
+        arm.generate = generate
+        return arm
+
+    monkeypatch.setattr(providers_mod, "provider_arm", wrapped)
+    entry = {
+        "kind": "typed",
+        "base_url": "http://127.0.0.1:9",
+        "path": "/v1/systemone",
+        "egress": "local",
+    }
+    p = _pack(meta={"calibration": {
+        "model": "provider:openai",
+        "task_ids": ["arith_mult"],
+        "expected_mean_distance_max": 0.1,
+    }})
+    metered = _Recording(ScriptedBackend(PERFECT_ANSWERS))
+    warnings = gate_calibration(
+        p, backends={"metered": metered}, registry={"openai": entry},
+    )
+    assert built and built[0][0] == "openai" and built[0][1] is entry
+    assert isinstance(built[0][2], HttpBackend)
+    assert seen == ["openai"]
+    assert metered.calls == []
+    assert any("meta.calibration OK" in w or "MISMATCH" in w for w in warnings)
+    assert not any("could not run" in w for w in warnings)
+
+
+def test_calibration_on_box_only_refuses_external_provider(monkeypatch):
+    from swarph_cli.bench import providers as providers_mod
+
+    calls = []
+    real = providers_mod.provider_arm
+
+    def wrapped(name, entry, noul):
+        arm = real(name, entry, noul)
+
+        def generate(model_id, prompt, system=""):
+            calls.append(model_id)
+            raise AssertionError("external arm must not be dispatched")
+
+        arm.generate = generate
+        return arm
+
+    monkeypatch.setattr(providers_mod, "provider_arm", wrapped)
+    entry = {
+        "kind": "typed",
+        "base_url": "https://api.example.com",
+        "path": "/v1/systemone",
+        "egress": "external",
+    }
+    p = _pack(
+        egress="on_box_only",
+        meta={"calibration": {
+            "model": "provider:openai",
+            "task_ids": ["arith_mult"],
+            "expected_mean_distance_max": 0.1,
+        }},
+    )
+    warnings = gate_calibration(p, backends={}, registry={"openai": entry})
+    assert calls == []
+    assert any("on_box_only" in w and "external" in w for w in warnings)
+    assert not any("lacks credentials" in w for w in warnings)
+
+
+def test_calibration_kind_mismatch_refuses_the_arm():
+    p = _pack(
+        request_kind="typed",
+        meta={"calibration": {
+            "model": "m:subscription",
+            "task_ids": ["arith_mult"],
+            "expected_mean_distance_max": 0.1,
+        }},
+    )
+    subscription = _Recording(ScriptedBackend(PERFECT_ANSWERS))
+    warnings = gate_calibration(p, backends={"subscription": subscription})
+    assert subscription.calls == []
+    assert any("kind mismatch: pack=typed arm=semantic" in w for w in warnings)
+    assert not any("lacks credentials" in w for w in warnings)
 
 
 # ── orchestration: validate_pack ───────────────────────────────────────────