swarph-cli 0.72.32__tar.gz → 0.72.33__tar.gz

{swarph_cli-0.72.32/src/swarph_cli.egg-info → swarph_cli-0.72.33}/PKG-INFO

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

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

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

{swarph_cli-0.72.32 → swarph_cli-0.72.33}/src/swarph_cli/dreaming/index_check.py

@@ -41,6 +41,25 @@ MEM = pathlib.Path(
     next((a.split("=", 1)[1] for a in sys.argv if a.startswith("--mem-dir=")),
          str(pathlib.Path.home() / ".claude/projects/-home-ubuntu/memory")))
 INDEXES = ("MEMORY.md", "MEMORY_FULL.md")
+
+
+def index_names(mem: pathlib.Path) -> list[str]:
+    """Files whose pointers count: every MEMORY*.md and index_*.md.
+
+    MEMORY.md and MEMORY_FULL.md stay required, so a missing one is still
+    MISSING INDEX. Pointers also live in index_*.md after the index-of-indexes
+    restructure. A file named only there is not an orphan (card #1278).
+    """
+    found: list[str] = []
+    if mem.is_dir():
+        found = [
+            p.name for p in sorted(mem.glob("*.md"))
+            if p.name.startswith("MEMORY") or p.name.startswith("index_")
+        ]
+    for name in INDEXES:
+        if name not in found:
+            found.append(name)
+    return found
 BUDGET = 24985  # bytes, MEMORY.md only — stated in the file's own header comment
 # THE THIRD STATE. Without WARN this check reported "clean" at 24,972 bytes —
 # 13 bytes of headroom — which is the exact condition ORGANIZE exists to
@@ -189,9 +208,10 @@ def main() -> int:
         print(f"memory-index-check: {MEM} is not a directory", file=sys.stderr)
         return 1
 
-    files = {p.name for p in MEM.glob("*.md")} - set(INDEXES)
+    indexes = index_names(MEM)
+    files = {p.name for p in MEM.glob("*.md")} - set(indexes)
     linked: set[str] = set()
-    for i in INDEXES:
+    for i in indexes:
         linked |= links_in(i)
 
     findings: list[str] = []
@@ -203,7 +223,7 @@ def main() -> int:
         if len(orphans) > 20:
             findings.append(f"    … and {len(orphans) - 20} more")
 
-    for idx in INDEXES:
+    for idx in indexes:
         p = MEM / idx
         if not p.exists():
             findings.append(f"MISSING INDEX: {idx}")
@@ -213,7 +233,11 @@ def main() -> int:
             if line.startswith("- ") and TRUNC.search(line):
                 findings.append(f"TRUNCATED: {idx}:{n} ends mid-link — ...{line[-46:]}")
 
-    dangling = sorted(linked - files)
+    # An index file is not a missing memory. MEMORY.md (the index of indexes)
+    # links at index_*.md, and those names were removed from `files` above, so
+    # linked - files reported every one of them DANGLING (card #1278 rework).
+    # Subtract the index names too: dangling is a pointer to no existing .md.
+    dangling = sorted(linked - files - set(indexes))
     if dangling:
         findings.append(f"DANGLING: {len(dangling)} pointer(s) to a file that does not exist")
         findings += [f"    {d}" for d in dangling[:20]]

{swarph_cli-0.72.32 → swarph_cli-0.72.33}/src/swarph_cli/dreaming/notify.py

@@ -141,13 +141,64 @@ def apply(out: Path, verdicts, organized, cell: str, sender) -> bool:
     return True
 
 
+def _post_to_card(card: str, content: str) -> None:
+    """Put the finding on a card. A DM to the sender is refused (#185 / #409).
+
+    Card #864: a finding goes on a card. Card #1278: the dreaming unit is
+    lab-ovh notifying lab-ovh, so the send never arrives. Default card is 656,
+    whose rows are closed; a holder who posts to a card thread closes their
+    oldest open row on it,     so do not point this at a card the sender holds.
+    """
+    from swarph_cli.commands.board import (
+        _card_say_payload,
+        _http_get_json,
+        _post_json,
+        _project_owner_orchestrator,
+        _thread_recipient,
+    )
+    from swarph_cli.commands.mesh import _resolve_self_name, _resolve_token
+    from swarph_cli.gateway_default import env_gateway
+
+    gw = env_gateway()
+    self_name = _resolve_self_name(None)
+    token = _resolve_token(self_name, None)
+    status, card_row = _http_get_json(f"{gw}/board/cards/{card}", token)
+    if status != 200 or not isinstance(card_row, dict):
+        raise NotifySendError(f"cannot read card #{card}: {card_row}")
+    thread_uuid = card_row.get("thread_uuid")
+    if not thread_uuid:
+        raise NotifySendError(f"card #{card} has no bound thread")
+    owner = None
+    if not card_row.get("assignee"):
+        owner = _project_owner_orchestrator(gw, token, card_row.get("project_id"))
+    try:
+        to_node, _reason = _thread_recipient(card_row, None, owner_orchestrator=owner)
+    except RuntimeError as exc:
+        raise NotifySendError(str(exc)) from exc
+    status, payload = _post_json(
+        f"{gw}/messages",
+        _card_say_payload(self_name, to_node, "status", content, thread_uuid),
+        token,
+    )
+    if status < 200 or status >= 300:
+        raise NotifySendError(f"card #{card} post failed: {status} {payload}")
+
+
 def mesh_sender(cell: str, content: str) -> None:
-    """Same path as ``swarph mesh send``: one status DM, no second transport."""
+    """Same path as ``swarph mesh send``, unless that send would be a self-wake.
+
+    SWARPH_SELF equal to the notify cell is the dreaming unit. Mesh send
+    refuses it and the run exits 4. Post the same body to the dreaming card.
+    """
     import argparse
 
-    from swarph_cli.commands.mesh import _run_send
+    from swarph_cli.commands.mesh import _resolve_self_name, _run_send
     from swarph_cli.gateway_default import env_gateway
 
+    self_name = _resolve_self_name(None)
+    if cell == self_name:
+        _post_to_card("656", content)
+        return
     ns = argparse.Namespace(
         to=cell,
         kind="status",

{swarph_cli-0.72.32 → swarph_cli-0.72.33}/src/swarph_cli/triage/backend.py

@@ -34,7 +34,8 @@ class MemoryBackend:
                 f"create '{title}': project_id is required — the gateway "
                 f"refuses a card create without one (BoardCardCreate)")
         row = {"id": self.next_id, "title": title, "owner": owner,
-               "project_id": self.project_id, "status": "open"}
+               "project_id": self.project_id, "status": "open",
+               "labels": ["triage-row"]}
         self.next_id += 1
         self.rows[title] = row
         self.posts[title] = []
@@ -119,7 +120,10 @@ class BoardBackend:
                    "body": f"Daily triage row for {owner} (card #1073). "
                            "Items are appended by the triage job; "
                            "owners work them off the row.",
-                   "assignee": owner}
+                   "assignee": owner,
+                   # card #1269: the label is how offer_dispatch leaves the
+                   # minted rows unoffered. Rows stay requested.
+                   "labels": ["triage-row"]}
         try:
             status, body = self._http_post(
                 f"{self.gateway}/board/cards", payload, self.token)

{swarph_cli-0.72.32 → swarph_cli-0.72.33/src/swarph_cli.egg-info}/PKG-INFO

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

@@ -249,7 +249,9 @@ tests/test_1256_commander_wake.py
 tests/test_1261_mcp_install.py
 tests/test_1262_wake_followups.py
 tests/test_1265_wake_note.py
+tests/test_1269_triage_label.py
 tests/test_126_pending_from_complete.py
+tests/test_1278_dreaming_reach.py
 tests/test_132_ensure_monitor_state_dir.py
 tests/test_138_memory_navigate.py
 tests/test_139_tool_probe.py

swarph_cli-0.72.33/tests/test_1269_triage_label.py

@@ -0,0 +1,25 @@
+"""Card #1269. A new triage container is created with the triage-row
+label. Fails at dba1ebc: the create payload has no labels.
+"""
+from swarph_cli.triage.backend import BoardBackend
+
+
+class _Http:
+    def __init__(self):
+        self.posts = []
+
+    def post(self, url, payload, token):
+        self.posts.append((url, payload))
+        return 200, {"id": 77}
+
+    def get(self, url, token):
+        raise AssertionError(url)
+
+
+def test_create_labels_the_container_triage_row():
+    http = _Http()
+    backend = BoardBackend(
+        "http://gw:9", "tok", "lab-ovh", http.get, http.post, project_id=9)
+    backend.create_row("droplet triage", "droplet")
+    _url, payload = http.posts[-1]
+    assert payload.get("labels") == ["triage-row"]

swarph_cli-0.72.33/tests/test_1278_dreaming_reach.py

@@ -0,0 +1,70 @@
+"""Card #1278: a self-notify must be delivered, and index_*.md pointers count."""
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+from swarph_cli.dreaming import run as dreaming_run
+
+
+def _run_check(mem: Path) -> tuple[int, str]:
+    script = Path(__file__).resolve().parents[1] / "src" / "swarph_cli" / "dreaming" / "index_check.py"
+    r = subprocess.run(
+        [sys.executable, str(script), "--mem-dir=%s" % mem, "--quiet"],
+        capture_output=True, text=True, encoding="utf-8", errors="replace")
+    return r.returncode, (r.stdout or "") + (r.stderr or "")
+
+
+def test_1278_pointer_only_in_index_md_is_not_an_orphan(tmp_path):
+    mem = tmp_path / "mem"
+    mem.mkdir()
+    (mem / "MEMORY.md").write_text(
+        "- [a](a.md)\n- [topics](index_topics.md)\n", encoding="utf-8")
+    (mem / "MEMORY_FULL.md").write_text("- [a](a.md)\n", encoding="utf-8")
+    (mem / "index_topics.md").write_text("- [b](b.md)\n", encoding="utf-8")
+    (mem / "a.md").write_text("# a\n", encoding="utf-8")
+    (mem / "b.md").write_text("# b\n", encoding="utf-8")
+    rc, out = _run_check(mem)
+    assert "ORPHANS" not in out, out
+    assert "DANGLING" not in out, out
+    assert rc == 0, out
+
+
+def test_1278_self_notify_is_delivered_not_exit_4(tmp_path, monkeypatch):
+    monkeypatch.setenv("SWARPH_SELF", "lab-ovh")
+    posted = []
+
+    def clone(corpus, out):
+        Path(out).mkdir(parents=True, exist_ok=True)
+        return {}
+
+    monkeypatch.setattr(dreaming_run, "clone_corpus", clone)
+    monkeypatch.setattr(
+        dreaming_run, "verify",
+        lambda out, manifest: [{"verdict": "agree", "file": "a.md", "line": 1, "kind": "x"}],
+    )
+    monkeypatch.setattr(
+        dreaming_run, "organize",
+        lambda out: {"findings": [], "index_bytes_before": 0,
+                     "index_bytes_after": 0, "trimmed": []},
+    )
+    monkeypatch.setattr(dreaming_run, "render", lambda *a, **k: "# dreaming report\n")
+    monkeypatch.setattr(
+        "swarph_cli.dreaming.notify._post_to_card",
+        lambda card, body: posted.append((str(card), body)),
+        raising=False,
+    )
+    monkeypatch.setattr("swarph_cli.commands.mesh._run_send", lambda ns: 1)
+
+    corpus = tmp_path / "corpus"
+    corpus.mkdir()
+    rc = dreaming_run.main([
+        "--corpus", str(corpus),
+        "--out", str(tmp_path / "runs" / "run-1"),
+        "--no-enrich",
+        "--notify", "lab-ovh",
+    ])
+    assert rc != 4
+    assert posted and posted[0][0] == "656"
+    assert "dreaming" in posted[0][1] or posted[0][1]