swarph-cli 0.65.0__tar.gz → 0.66.0__tar.gz

{swarph_cli-0.65.0/src/swarph_cli.egg-info → swarph_cli-0.66.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.65.0
+Version: 0.66.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
@@ -347,7 +347,7 @@ $ swarph codegraph "cron expression validator" --json --limit 5
 
 It queries a locally-built index at `~/.swarph/codegraph/index.db` (override with `--index` or `SWARPH_CODEGRAPH_INDEX`); the index is built out-of-band from your repos (tree-sitter → SQLite FTS5, BM25-ranked). If no index is present the verb simply returns no matches — it never touches the network and never reads code it wasn't pointed at. Results are scoped by an owner-allowlist gate (`--caller-cell` / `SWARPH_CELL`, default: your cell): public repos are always visible; private repos are visible to the owning cell.
 
-The same capability is exposed as an **MCP tool** — running `swarph mcp-server` publishes `swarph_codegraph_query` alongside `swarph_search`/`swarph_add`/`swarph_describe`, so any MCP host's agent auto-discovers it and can reach for code-structure lookups while reading, writing, or debugging code. (Why a tool and not an always-on retrieval lane? Because *intent* to consult code structure lives with the calling agent — which already knows it's working on code — not in a similarity score.)
+The same capability is exposed as an **MCP tool** — running `swarph mcp-server` publishes `swarph_codegraph_query` alongside `swarph_search`/`swarph_add`/`swarph_describe` (and the mesh DM tools `swarph_dm_unread`, which returns every unread DM with full bodies in one call without marking them read; `swarph_dm_reply`, which replies by message id and marks that message read; and `swarph_dm_thread`, which returns a DM's whole conversation), so any MCP host's agent auto-discovers it and can reach for code-structure lookups while reading, writing, or debugging code. (Why a tool and not an always-on retrieval lane? Because *intent* to consult code structure lives with the calling agent — which already knows it's working on code — not in a similarity score.)
 
 ### `swarph gateway`
 

{swarph_cli-0.65.0 → swarph_cli-0.66.0}/README.md

@@ -299,7 +299,7 @@ $ swarph codegraph "cron expression validator" --json --limit 5
 
 It queries a locally-built index at `~/.swarph/codegraph/index.db` (override with `--index` or `SWARPH_CODEGRAPH_INDEX`); the index is built out-of-band from your repos (tree-sitter → SQLite FTS5, BM25-ranked). If no index is present the verb simply returns no matches — it never touches the network and never reads code it wasn't pointed at. Results are scoped by an owner-allowlist gate (`--caller-cell` / `SWARPH_CELL`, default: your cell): public repos are always visible; private repos are visible to the owning cell.
 
-The same capability is exposed as an **MCP tool** — running `swarph mcp-server` publishes `swarph_codegraph_query` alongside `swarph_search`/`swarph_add`/`swarph_describe`, so any MCP host's agent auto-discovers it and can reach for code-structure lookups while reading, writing, or debugging code. (Why a tool and not an always-on retrieval lane? Because *intent* to consult code structure lives with the calling agent — which already knows it's working on code — not in a similarity score.)
+The same capability is exposed as an **MCP tool** — running `swarph mcp-server` publishes `swarph_codegraph_query` alongside `swarph_search`/`swarph_add`/`swarph_describe` (and the mesh DM tools `swarph_dm_unread`, which returns every unread DM with full bodies in one call without marking them read; `swarph_dm_reply`, which replies by message id and marks that message read; and `swarph_dm_thread`, which returns a DM's whole conversation), so any MCP host's agent auto-discovers it and can reach for code-structure lookups while reading, writing, or debugging code. (Why a tool and not an always-on retrieval lane? Because *intent* to consult code structure lives with the calling agent — which already knows it's working on code — not in a similarity score.)
 
 ### `swarph gateway`
 

{swarph_cli-0.65.0 → swarph_cli-0.66.0}/pyproject.toml

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

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

{swarph_cli-0.65.0 → swarph_cli-0.66.0}/src/swarph_cli/bench/backends.py

@@ -7,7 +7,7 @@ thought / out, latency, text, whether tokens are ESTIMATED). ``system``
 threads to every backend (metered: ``system_instruction``; a CLI-shelling
 backend would prepend it — see :class:`SubscriptionBackend`).
 
-Ships two backends:
+Ships these backends:
 
 - :class:`MeteredGeminiBackend` — google-genai Developer API, DEFAULT for v1
   (real ``usage_metadata``: prompt/candidates/thoughts tokens). CRITICAL:
@@ -19,13 +19,21 @@ Ships two backends:
   NOT couple to any specific subscription lane map; a caller wires an actual
   $0 CLI/OIDC path in by passing ``call_fn``. Not exercised against a live
   provider anywhere in this package.
+- :class:`RuleBackend` — in-process ``rule:<module:callable>``. No credentials.
+- :class:`TypedHttpBackend` — POST to a Jev-compatible ``/v1/systemone``
+  (laya-serve). No credentials; per-item latency is the HTTP round trip.
 """
 from __future__ import annotations
 
+import importlib
+import inspect
+import json
 import os
 import time
+import urllib.error
+import urllib.request
 from dataclasses import dataclass
-from typing import Callable, Optional, Protocol
+from typing import Any, Callable, Optional, Protocol
 
 
 @dataclass
@@ -275,3 +283,216 @@ class SubscriptionBackend:
             latency_s=latency_s,
             estimated=True,
         )
+
+
+def _load_rule(spec: str) -> Callable[..., Any]:
+    """``module:callable`` -> the callable. The module path uses dots; the
+    callable name is the segment after the last colon."""
+    mod_name, sep, fn_name = spec.rpartition(":")
+    if not sep or not mod_name or not fn_name:
+        raise ValueError(f"rule model id must be module:callable, got {spec!r}")
+    fn = getattr(importlib.import_module(mod_name), fn_name)
+    if not callable(fn):
+        raise TypeError(f"{spec} is not callable")
+    return fn
+
+
+def _rule_subject(prompt: str) -> Any:
+    """A JSON bench prompt is the systemone template. The rule sees its
+    ``state`` (the item), not the question text. A plain prompt is unchanged.
+    """
+    try:
+        parsed = json.loads(prompt) if isinstance(prompt, str) else None
+    except json.JSONDecodeError:
+        parsed = None
+    if isinstance(parsed, dict) and "state" in parsed:
+        return parsed["state"]
+    return prompt
+
+
+def _call_rule(fn: Callable[..., Any], prompt: Any, system: str) -> Any:
+    params = inspect.signature(fn).parameters
+    if len(params) >= 2:
+        return fn(prompt, system)
+    return fn(prompt)
+
+
+def _request_body(prompt: str, system: str) -> dict:
+    """The POST body for ``/v1/systemone``.
+
+    A prompt that is itself a JSON object with ``state`` and ``questions``
+    is sent unchanged. That is how a pack carries a pre-registered template
+    (question type, instructions, criteria) without this backend inventing
+    them. Anything else is wrapped as one choice question whose instructions
+    are the prompt. That wrapper has no criteria, so a live laya-serve
+    rejects it; the gold packs must send the JSON form.
+    """
+    try:
+        parsed = json.loads(prompt) if isinstance(prompt, str) else None
+    except json.JSONDecodeError:
+        parsed = None
+    if isinstance(parsed, dict) and "state" in parsed and "questions" in parsed:
+        return parsed
+    return {
+        "state": {"system": system, "prompt": prompt},
+        "questions": {
+            "answer": {"type": "choice", "instructions": prompt},
+        },
+    }
+
+
+def _systemone_url(model_id: str) -> str:
+    url = (model_id or "").strip()
+    if not url:
+        raise ValueError("typed-http model id is empty")
+    if url.rstrip("/").endswith("/v1/systemone"):
+        return url.rstrip("/")
+    return url.rstrip("/") + "/v1/systemone"
+
+
+# Frozen on card #941 (lab-ovh msg 48915): the verdict uses 0.50 only.
+_NOUL_THRESHOLD = 0.50
+
+
+def _noul_question(body: dict) -> Optional[dict]:
+    questions = body.get("questions") if isinstance(body, dict) else None
+    if not isinstance(questions, dict):
+        return None
+    named = questions.get("answer")
+    if isinstance(named, dict) and named.get("type") == "noul":
+        return named
+    for block in questions.values():
+        if isinstance(block, dict) and block.get("type") == "noul":
+            return block
+    return None
+
+
+def _noul_labels(question: Optional[dict]) -> tuple[str, str]:
+    """Positive and negative labels named on the template.
+
+    ``labels.true`` / ``labels.false`` when the pack set them. Otherwise the
+    frozen S1 pair YES / NO (msg 48915: P(true) >= 0.50 -> YES).
+    """
+    labels = {}
+    if isinstance(question, dict) and isinstance(question.get("labels"), dict):
+        labels = question["labels"]
+    pos = labels.get("true")
+    neg = labels.get("false")
+    return (
+        str(pos) if pos is not None else "YES",
+        str(neg) if neg is not None else "NO",
+    )
+
+
+def _typed_value(payload: dict, request: Optional[dict] = None) -> tuple[Any, Optional[float]]:
+    """Pull the typed answer out of a Jev /v1/systemone response.
+
+    Prefers the question named ``answer``; otherwise the first question.
+    ``choice``, ``noul``, ``yes``, then ``score``. A ``noul`` value is
+    P(true): >= 0.50 maps to the template's positive label, below that to
+    the negative. The raw probability is returned alongside the label.
+    Choice and score are returned as the server sent them.
+    """
+    answers = payload.get("answers")
+    if not isinstance(answers, dict) or not answers:
+        raise ValueError("systemone response has no answers")
+    block = answers.get("answer")
+    if not isinstance(block, dict):
+        block = next(iter(answers.values()))
+    if not isinstance(block, dict):
+        raise ValueError("systemone answer is not an object")
+    for key in ("choice", "noul", "yes", "score"):
+        if key in block and block[key] is not None:
+            if key == "noul":
+                p_true = float(block[key])
+                pos, neg = _noul_labels(_noul_question(request or {}))
+                label = pos if p_true >= _NOUL_THRESHOLD else neg
+                return label, p_true
+            return block[key], None
+    raise ValueError("systemone answer has no choice, noul, yes, or score")
+
+
+class RuleBackend:
+    """In-process callable. ``model_id`` is ``module:callable``.
+
+    The callable receives ``(prompt, system)`` when it takes two arguments,
+    otherwise ``(prompt)``. A JSON prompt with ``state`` is unwrapped first:
+    the callable sees that state, not the template. Its return value is the
+    categorical label. No credentials. Latency is the call itself.
+    """
+
+    def missing_creds(self) -> list[str]:
+        return []
+
+    def generate(self, model_id: str, prompt: str, system: str = "") -> BackendResult:
+        t0 = time.perf_counter()
+        try:
+            label = _call_rule(_load_rule(model_id), _rule_subject(prompt), system)
+            text = json.dumps({"answer": label})
+        except Exception as exc:
+            return BackendResult(
+                text="", tokens_in=0, tokens_thought=0, tokens_out=0,
+                latency_s=round(time.perf_counter() - t0, 6),
+                estimated=False, error=str(exc),
+            )
+        return BackendResult(
+            text=text,
+            tokens_in=0,
+            tokens_thought=0,
+            tokens_out=0,
+            latency_s=round(time.perf_counter() - t0, 6),
+            estimated=False,
+        )
+
+
+class TypedHttpBackend:
+    """POST a bench item to a Jev-compatible ``/v1/systemone`` server.
+
+    ``model_id`` is the server base (``http://127.0.0.1:<port>``) or a full
+    ``.../v1/systemone`` URL. A prompt that is a JSON object with ``state``
+    and ``questions`` is the POST body, unchanged — that is the pre-registered
+    template. No API key is read or sent. Latency is the round trip.
+    A ``noul`` answer is P(true): >= 0.50 becomes the template's positive
+    label and below 0.50 the negative. The raw P(true) stays in the result
+    text. Choice answers are the server's label, unthresholded.
+    """
+
+    def missing_creds(self) -> list[str]:
+        return []
+
+    def generate(self, model_id: str, prompt: str, system: str = "") -> BackendResult:
+        t0 = time.perf_counter()
+        try:
+            endpoint = _systemone_url(model_id)
+            body = _request_body(prompt, system)
+            req = urllib.request.Request(
+                endpoint,
+                data=json.dumps(body).encode(),
+                headers={"Content-Type": "application/json"},
+                method="POST",
+            )
+            with urllib.request.urlopen(req, timeout=60) as resp:
+                raw = resp.read()
+            payload = json.loads(raw.decode() or "{}")
+            if not isinstance(payload, dict):
+                raise ValueError("systemone response is not an object")
+            label, p_true = _typed_value(payload, body)
+            rendered = {"answer": label}
+            if p_true is not None:
+                rendered["p_true"] = p_true
+            text = json.dumps(rendered)
+            usage = payload.get("usage") if isinstance(payload.get("usage"), dict) else {}
+        except Exception as exc:
+            return BackendResult(
+                text="", tokens_in=0, tokens_thought=0, tokens_out=0,
+                latency_s=round(time.perf_counter() - t0, 6),
+                estimated=False, error=str(exc),
+            )
+        return BackendResult(
+            text=text,
+            tokens_in=int(usage.get("input_tokens") or 0),
+            tokens_thought=0,
+            tokens_out=int(usage.get("output_tokens") or 0),
+            latency_s=round(time.perf_counter() - t0, 6),
+            estimated=False,
+        )

swarph_cli-0.66.0/src/swarph_cli/bench/rules.py

@@ -0,0 +1,40 @@
+"""Thin adapters from the rules the mesh runs today to card #941's labels.
+
+Frozen by lab-ovh (card #941, msg 48944). Each function calls the current
+rule and adds no decision of its own. That message's closing line says the
+rubric (science-claude, msg 48930) wins where the two vocabularies differ,
+so claim/mention are returned as CLAIM/MENTION and act-now/routine as
+ACT/ROUTINE. S1's YES/NO already matches the rubric.
+"""
+from __future__ import annotations
+
+from swarph_cli.commands.codegraph_hook import prompt_has_coding_keywords
+from swarph_cli.dreaming.verify import _is_dated_record, _is_superseded
+from swarph_cli.scripts.dm_notify_filter import _format_dm
+
+
+def s1_code_question(state) -> str:
+    """YES when the live codegraph gate would keep the prompt."""
+    text = state["text"] if isinstance(state, dict) else state
+    return "YES" if prompt_has_coding_keywords(text) else "NO"
+
+
+def s2_claim_vs_mention(state) -> str:
+    """mention when the extractor found no value, or the line is superseded
+    or a dated record; otherwise claim. verify.py's current decision.
+    """
+    text = state["text"]
+    asserted = state["asserted"]
+    mention = (
+        asserted is None
+        or _is_superseded(text)
+        or _is_dated_record(text, asserted)
+    )
+    return "MENTION" if mention else "CLAIM"
+
+
+def s3_dm_triage(state) -> str:
+    """routine when today's notify filter would drop the DM; otherwise act-now."""
+    if _format_dm(state["dm"]) is None:
+        return "ROUTINE"
+    return "ACT"

{swarph_cli-0.65.0 → swarph_cli-0.66.0}/src/swarph_cli/bench/runner.py

@@ -40,11 +40,18 @@ def parse_models(arg: str) -> list[ModelSpec]:
         tok = tok.strip()
         if not tok:
             continue
-        parts = tok.split(":")
-        mid = parts[0]
-        backend = parts[1] if len(parts) > 1 and parts[1] else "metered"
-        label = parts[2] if len(parts) > 2 and parts[2] else mid
-        specs.append(ModelSpec(id=mid, backend=backend, label=label))
+        # rule:<module:callable> and typed-http:<url> carry colons in the
+        # payload, so they cannot go through the id:backend:label split.
+        for prefix, backend in (("typed-http:", "typed-http"), ("rule:", "rule")):
+            if tok.startswith(prefix):
+                specs.append(ModelSpec(id=tok[len(prefix):], backend=backend, label=tok))
+                break
+        else:
+            parts = tok.split(":")
+            mid = parts[0]
+            backend = parts[1] if len(parts) > 1 and parts[1] else "metered"
+            label = parts[2] if len(parts) > 2 and parts[2] else mid
+            specs.append(ModelSpec(id=mid, backend=backend, label=label))
     return specs
 
 

{swarph_cli-0.65.0 → swarph_cli-0.66.0}/src/swarph_cli/commands/bench.py

@@ -26,7 +26,9 @@ from swarph_cli.bench.backends import (
     Backend,
     MeteredGeminiBackend,
     MeteredMistralBackend,
+    RuleBackend,
     SubscriptionBackend,
+    TypedHttpBackend,
 )
 from swarph_cli.bench.pack import PackError, load_pack, slugify_theme, validate_schema
 from swarph_cli.bench.runner import ModelSpec, parse_models, preflight, run_pack
@@ -53,6 +55,8 @@ def _default_backends() -> dict[str, Backend]:
         "metered": MeteredGeminiBackend(),
         "mistral": MeteredMistralBackend(),
         "subscription": SubscriptionBackend(),
+        "rule": RuleBackend(),
+        "typed-http": TypedHttpBackend(),
     }
 
 

{swarph_cli-0.65.0 → swarph_cli-0.66.0}/src/swarph_cli/commands/board.py

@@ -165,7 +165,9 @@ def _card_edit_payload(actor, title, body, *, due_at=_SENTINEL, project_id=None,
     if body is not None:
         patch["body"] = body
     if due_at is not _SENTINEL:
-        patch["due_at"] = _normalize_due_at(due_at) if due_at else None
+        # "" is the gateway's CLEAR sentinel; None means "not mentioned" and the
+        # write is skipped while the old date is echoed back (#901).
+        patch["due_at"] = _normalize_due_at(due_at) if due_at else ""
     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:

{swarph_cli-0.65.0 → swarph_cli-0.66.0}/src/swarph_cli/commands/brain_ask.py

@@ -233,7 +233,7 @@ def _synthesize(facade_url: str, facade_token: str, question: str, chunks: list)
     body = {"model": os.environ.get("SWARPH_FACADE_MODEL", "claude"),
             "messages": [{"role": "system", "content": sys_prompt},
                          {"role": "user", "content": user}],
-            "max_tokens": 700, "temperature": 0.2}
+            }
     raw = _http_post(facade_url, body, facade_token, accept="application/json")
     doc = json.loads(raw)
     return doc["choices"][0]["message"]["content"].strip()