swarph-cli 0.35.0__tar.gz → 0.37.0__tar.gz

{swarph_cli-0.35.0/src/swarph_cli.egg-info → swarph_cli-0.37.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.35.0
+Version: 0.37.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`, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.35.0 → swarph_cli-0.37.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.35.0"
+version = "0.37.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`, session `import`, and a stranded-session `watchdog`."
 readme = "README.md"
 license = { text = "MIT" }

{swarph_cli-0.35.0 → swarph_cli-0.37.0}/src/swarph_cli/__init__.py

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

{swarph_cli-0.35.0 → swarph_cli-0.37.0}/src/swarph_cli/commands/board.py

@@ -167,6 +167,9 @@ def _build_parser() -> argparse.ArgumentParser:
     ck.add_argument("--json", action="store_true"); _add_common(ck)
     cn = cards.add_parser("assign", help="set a card's assignee")
     cn.add_argument("id", type=int); cn.add_argument("assignee"); cn.add_argument("--json", action="store_true"); _add_common(cn)
+    cr = cards.add_parser("ready", help="flag a card ready-to-advance (move_ready) for the orchestrator")
+    cr.add_argument("id", type=int); cr.add_argument("--clear", action="store_true", help="unset move_ready")
+    cr.add_argument("--json", action="store_true"); _add_common(cr)
     return p
 
 
@@ -232,6 +235,9 @@ def run_board(argv: list[str]) -> int:
         if args.command == "assign":
             st, d = _patch_json(f"{gw}/board/cards/{args.id}", {"actor": self_name, "assignee": args.assignee}, token)
             return _out(st, d, lambda x: f"card #{x.get('id')} assignee -> {x.get('assignee')}", aj)
+        if args.command == "ready":
+            st, d = _patch_json(f"{gw}/board/cards/{args.id}", {"actor": self_name, "move_ready": not args.clear}, token)
+            return _out(st, d, lambda x: f"card #{x.get('id')} move_ready -> {x.get('move_ready')}", aj)
         if args.command == "link":
             gst, gcard = _http_get_json(f"{gw}/board/cards/{args.id}", token)
             if not (gst and 200 <= gst < 300):

{swarph_cli-0.35.0 → swarph_cli-0.37.0}/src/swarph_cli/commands/memory_sync.py

@@ -10,6 +10,7 @@ from pathlib import Path
 from typing import Optional
 
 from swarph_cli.cell import Cell, load_cell, CellError
+from swarph_cli.commands.spawn import MEMBRANES
 
 
 def get_memory_repo_path(cell: Cell) -> Path:
@@ -19,44 +20,13 @@ def get_memory_repo_path(cell: Cell) -> Path:
 
 def _get_files_to_sync(cell: Cell) -> list[tuple[str, Path]]:
     files_to_sync = []
-
-    # Common
+    # Common (provider-agnostic)
     if (cell.cwd / "CURRENT_TASK.md").exists():
         files_to_sync.append(("CURRENT_TASK.md", cell.cwd / "CURRENT_TASK.md"))
-
-    if cell.provider == "claude":
-        if (cell.cwd / "CLAUDE.md").exists():
-            files_to_sync.append(("CLAUDE.md", cell.cwd / "CLAUDE.md"))
-        mem_dir = Path.home() / ".claude"
-        if (mem_dir / "MEMORY.md").exists():
-            files_to_sync.append(("MEMORY.md", mem_dir / "MEMORY.md"))
-        for p in mem_dir.glob("memory/*.md"):
-            files_to_sync.append((f"memory/{p.name}", p))
-        if (mem_dir / "inbox-cursor").exists():
-            files_to_sync.append(("inbox-cursor", mem_dir / "inbox-cursor"))
-
-    elif cell.provider == "codex":
-        if (cell.cwd / "AGENTS.md").exists():
-            files_to_sync.append(("AGENTS.md", cell.cwd / "AGENTS.md"))
-
-    elif cell.provider == "antigravity":
-        if (cell.cwd / "GEMINI.md").exists():
-            files_to_sync.append(("GEMINI.md", cell.cwd / "GEMINI.md"))
-        if (cell.cwd / "inbox-cursor.json").exists():
-            files_to_sync.append(("inbox-cursor.json", cell.cwd / "inbox-cursor.json"))
-        
-        gemini_tmp = Path.home() / ".gemini" / "tmp"
-        if gemini_tmp.is_dir():
-            for proj_dir in gemini_tmp.iterdir():
-                if proj_dir.is_dir():
-                    for p in proj_dir.glob("memory/*.md"):
-                        rel = f"tmp/{proj_dir.name}/memory/{p.name}"
-                        files_to_sync.append((rel, p))
-
-        history_proj = Path.home() / ".gemini" / "history" / ".project_root"
-        if history_proj.exists():
-            files_to_sync.append(("history/.project_root", history_proj))
-
+    # Provider-specific memory lives in the membrane (non-discriminatory dispatch)
+    membrane = MEMBRANES.get(cell.provider)
+    if membrane is not None:
+        files_to_sync += membrane.memory_sync_files(cell)
     return files_to_sync
 
 
@@ -110,21 +80,15 @@ def perform_restore(cell: Cell) -> Optional[str]:
                 continue
 
             rel = src.relative_to(repo_dir)
-            
+
             dest = None
             if rel.parts[0] in ("CURRENT_TASK.md", "CLAUDE.md", "AGENTS.md", "GEMINI.md", "inbox-cursor.json"):
                 dest = cell.cwd / rel
-            elif cell.provider == "claude" and rel.parts[0] == "MEMORY.md":
-                dest = Path.home() / ".claude" / "MEMORY.md"
-            elif cell.provider == "claude" and rel.parts[0] == "memory":
-                dest = Path.home() / ".claude" / rel
-            elif cell.provider == "claude" and rel.parts[0] == "inbox-cursor":
-                dest = Path.home() / ".claude" / "inbox-cursor"
-            elif cell.provider == "antigravity" and rel.parts[0] == "tmp":
-                dest = Path.home() / ".gemini" / rel
-            elif cell.provider == "antigravity" and rel.parts[0] == "history":
-                dest = Path.home() / ".gemini" / rel
-                
+            else:
+                membrane = MEMBRANES.get(cell.provider)
+                if membrane is not None:
+                    dest = membrane.memory_restore_dest(rel.parts, cell)
+
             if dest:
                 dest.parent.mkdir(parents=True, exist_ok=True)
                 shutil.copy2(src, dest)
@@ -168,13 +132,8 @@ def run_memory_sync(argv: list[str]) -> int:
         pass
 
     # EMPTY-GUARD check
-    guard_file = None
-    if cell.provider == "claude":
-        guard_file = cell.cwd / "CLAUDE.md"
-    elif cell.provider == "codex":
-        guard_file = cell.cwd / "AGENTS.md"
-    elif cell.provider == "antigravity":
-        guard_file = cell.cwd / "GEMINI.md"
+    membrane = MEMBRANES.get(cell.provider)
+    guard_file = membrane.memory_guard_file(cell) if membrane is not None else None
 
     if guard_file and (not guard_file.exists() or guard_file.stat().st_size == 0):
         print(f"[auto_sync] {datetime.datetime.now(datetime.timezone.utc).strftime('%FT%TZ')} SAFETY: {guard_file} missing or empty — skipping sync", file=sys.stderr)

{swarph_cli-0.35.0 → swarph_cli-0.37.0}/src/swarph_cli/commands/spawn.py

@@ -1246,6 +1246,22 @@ class ProviderMembrane:
         """chdir + env setup + exec-replace. Only returns on exec failure."""
         raise NotImplementedError
 
+    def memory_sync_files(self, cell) -> list:
+        """Provider-specific memory files to snapshot: (repo-relative, source-abs)
+        pairs. Base = none; each provider declares its own. The COMMON files
+        (CURRENT_TASK.md) are handled provider-agnostically in memory_sync."""
+        return []
+
+    def memory_restore_dest(self, rel_parts, cell):
+        """Where a provider-specific repo-relative path restores to (None = not
+        mine; the common cwd files are restored by memory_sync)."""
+        return None
+
+    def memory_guard_file(self, cell):
+        """The empty-guard file whose emptiness means 'skip sync' (None = no
+        guard, always sync)."""
+        return None
+
 
 class ClaudeMembrane(ProviderMembrane):
     name = "claude"
@@ -1361,6 +1377,31 @@ class ClaudeMembrane(ProviderMembrane):
             return 1
         return 0  # unreachable on POSIX (execve replaces); keeps type checker happy
 
+    def memory_sync_files(self, cell) -> list:
+        files = []
+        if (cell.cwd / "CLAUDE.md").exists():
+            files.append(("CLAUDE.md", cell.cwd / "CLAUDE.md"))
+        mem_dir = Path.home() / ".claude"
+        if (mem_dir / "MEMORY.md").exists():
+            files.append(("MEMORY.md", mem_dir / "MEMORY.md"))
+        for p in mem_dir.glob("memory/*.md"):
+            files.append((f"memory/{p.name}", p))
+        if (mem_dir / "inbox-cursor").exists():
+            files.append(("inbox-cursor", mem_dir / "inbox-cursor"))
+        return files
+
+    def memory_restore_dest(self, rel_parts, cell):
+        if rel_parts[0] == "MEMORY.md":
+            return Path.home() / ".claude" / "MEMORY.md"
+        if rel_parts[0] == "memory":
+            return Path.home() / ".claude" / Path(*rel_parts)
+        if rel_parts[0] == "inbox-cursor":
+            return Path.home() / ".claude" / "inbox-cursor"
+        return None
+
+    def memory_guard_file(self, cell):
+        return cell.cwd / "CLAUDE.md"
+
 
 class CodexMembrane(ProviderMembrane):
     name = "codex"
@@ -1395,6 +1436,15 @@ class CodexMembrane(ProviderMembrane):
             return 1
         return 0  # unreachable, keeps type checker happy
 
+    def memory_sync_files(self, cell) -> list:
+        files = []
+        if (cell.cwd / "AGENTS.md").exists():
+            files.append(("AGENTS.md", cell.cwd / "AGENTS.md"))
+        return files
+
+    def memory_guard_file(self, cell):
+        return cell.cwd / "AGENTS.md"
+
 
 class AntigravityMembrane(ProviderMembrane):
     name = "antigravity"
@@ -1436,6 +1486,31 @@ class AntigravityMembrane(ProviderMembrane):
             return 1
         return 0  # unreachable, keeps type checker happy
 
+    def memory_sync_files(self, cell) -> list:
+        files = []
+        if (cell.cwd / "GEMINI.md").exists():
+            files.append(("GEMINI.md", cell.cwd / "GEMINI.md"))
+        if (cell.cwd / "inbox-cursor.json").exists():
+            files.append(("inbox-cursor.json", cell.cwd / "inbox-cursor.json"))
+        gemini_tmp = Path.home() / ".gemini" / "tmp"
+        if gemini_tmp.is_dir():
+            for proj_dir in gemini_tmp.iterdir():
+                if proj_dir.is_dir():
+                    for p in proj_dir.glob("memory/*.md"):
+                        files.append((f"tmp/{proj_dir.name}/memory/{p.name}", p))
+        history_proj = Path.home() / ".gemini" / "history" / ".project_root"
+        if history_proj.exists():
+            files.append(("history/.project_root", history_proj))
+        return files
+
+    def memory_restore_dest(self, rel_parts, cell):
+        if rel_parts[0] in ("tmp", "history"):
+            return Path.home() / ".gemini" / Path(*rel_parts)
+        return None
+
+    def memory_guard_file(self, cell):
+        return cell.cwd / "GEMINI.md"
+
 
 class GrokMembrane(ProviderMembrane):
     """Local ``grok`` CLI as a durable swarph CELL ($0 OIDC / subscription).
@@ -1514,6 +1589,25 @@ class GrokMembrane(ProviderMembrane):
             return 1
         return 0  # unreachable on POSIX (execve replaces); keeps type checker happy
 
+    def memory_sync_files(self, cell) -> list:
+        # Grok cells run under an isolated HOME (_GROK_CELL_HOME_SUBDIR); memory
+        # lives at <cell_home>/.grok/memory/**/*.md.
+        files = []
+        mem_dir = cell.cwd / _GROK_CELL_HOME_SUBDIR / ".grok" / "memory"
+        if mem_dir.is_dir():
+            for p in mem_dir.rglob("*.md"):
+                files.append((f"grok-memory/{p.relative_to(mem_dir).as_posix()}", p))
+        return files
+
+    def memory_restore_dest(self, rel_parts, cell):
+        if rel_parts[0] == "grok-memory":
+            return (cell.cwd / _GROK_CELL_HOME_SUBDIR / ".grok" / "memory"
+                    / Path(*rel_parts[1:]))
+        return None
+
+    def memory_guard_file(self, cell):
+        return None  # grok has no cwd project-doc; always-sync
+
 
 MEMBRANES: dict[str, ProviderMembrane] = {
     "claude": ClaudeMembrane(),

{swarph_cli-0.35.0 → swarph_cli-0.37.0/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.35.0
+Version: 0.37.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`, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.35.0 → swarph_cli-0.37.0}/src/swarph_cli.egg-info/SOURCES.txt

@@ -139,6 +139,7 @@ tests/test_mcp_server.py
 tests/test_memory_command.py
 tests/test_memory_gateway.py
 tests/test_memory_sync.py
+tests/test_memory_sync_membrane.py
 tests/test_mesh_command.py
 tests/test_mesh_inbox_mark_read.py
 tests/test_mesh_inbox_sanitize.py

{swarph_cli-0.35.0 → swarph_cli-0.37.0}/tests/test_brain_ask_command.py

@@ -17,7 +17,7 @@ from swarph_cli.commands import brain_ask as ba
 
 def test_version_is_0_33_0():
     import swarph_cli
-    assert swarph_cli.__version__ == "0.35.0"
+    assert swarph_cli.__version__ == "0.37.0"
 
 
 # --- request / response plumbing -------------------------------------------

swarph_cli-0.37.0/tests/test_memory_sync_membrane.py

@@ -0,0 +1,94 @@
+import types
+from pathlib import Path
+
+from swarph_cli.commands import spawn
+
+
+def _cell(tmp_path):
+    return types.SimpleNamespace(cwd=tmp_path, provider="x")
+
+
+def test_base_membrane_returns_empty(tmp_path):
+    m = spawn.ProviderMembrane()
+    assert m.memory_sync_files(_cell(tmp_path)) == []
+    assert m.memory_restore_dest(("anything",), _cell(tmp_path)) is None
+    assert m.memory_guard_file(_cell(tmp_path)) is None
+
+
+def test_claude_membrane_files_and_dests(tmp_path, monkeypatch):
+    home = tmp_path / "home"; (home / ".claude" / "memory").mkdir(parents=True)
+    (home / ".claude" / "MEMORY.md").write_text("m")
+    (home / ".claude" / "memory" / "a.md").write_text("a")
+    (home / ".claude" / "inbox-cursor").write_text("c")
+    cwd = tmp_path / "cwd"; cwd.mkdir(); (cwd / "CLAUDE.md").write_text("C")
+    monkeypatch.setattr(Path, "home", staticmethod(lambda: home))
+    m = spawn.MEMBRANES["claude"]
+    rels = {r for r, _ in m.memory_sync_files(types.SimpleNamespace(cwd=cwd, provider="claude"))}
+    assert rels == {"CLAUDE.md", "MEMORY.md", "memory/a.md", "inbox-cursor"}
+    assert m.memory_restore_dest(("MEMORY.md",), None) == home / ".claude" / "MEMORY.md"
+    assert m.memory_restore_dest(("memory", "a.md"), None) == home / ".claude" / "memory" / "a.md"
+    assert m.memory_restore_dest(("CLAUDE.md",), None) is None   # CLAUDE.md restores via common cwd path
+    assert m.memory_guard_file(types.SimpleNamespace(cwd=cwd, provider="claude")) == cwd / "CLAUDE.md"
+
+
+def test_codex_membrane(tmp_path):
+    cwd = tmp_path; (cwd / "AGENTS.md").write_text("A")
+    m = spawn.MEMBRANES["codex"]
+    assert {r for r, _ in m.memory_sync_files(types.SimpleNamespace(cwd=cwd, provider="codex"))} == {"AGENTS.md"}
+    assert m.memory_restore_dest(("AGENTS.md",), None) is None
+    assert m.memory_guard_file(types.SimpleNamespace(cwd=cwd, provider="codex")) == cwd / "AGENTS.md"
+
+
+def test_antigravity_restore_dest(tmp_path, monkeypatch):
+    home = tmp_path / "home"; monkeypatch.setattr(Path, "home", staticmethod(lambda: home))
+    m = spawn.MEMBRANES["antigravity"]
+    assert m.memory_restore_dest(("tmp", "proj", "memory", "x.md"), None) == home / ".gemini" / "tmp" / "proj" / "memory" / "x.md"
+    assert m.memory_restore_dest(("history", ".project_root"), None) == home / ".gemini" / "history" / ".project_root"
+    assert m.memory_restore_dest(("GEMINI.md",), None) is None   # common cwd path
+    c = tmp_path; (c / "GEMINI.md").write_text("G")
+    assert m.memory_guard_file(types.SimpleNamespace(cwd=c, provider="antigravity")) == c / "GEMINI.md"
+
+
+def test_grok_membrane_isolated_home(tmp_path):
+    cwd = tmp_path
+    mem = cwd / spawn._GROK_CELL_HOME_SUBDIR / ".grok" / "memory" / "proj"
+    mem.mkdir(parents=True)
+    (cwd / spawn._GROK_CELL_HOME_SUBDIR / ".grok" / "memory" / "MEMORY.md").write_text("m")
+    (mem / "MEMORY.md").write_text("p")
+    m = spawn.MEMBRANES["grok"]
+    files = m.memory_sync_files(types.SimpleNamespace(cwd=cwd, provider="grok"))
+    rels = {r for r, _ in files}
+    assert rels == {"grok-memory/MEMORY.md", "grok-memory/proj/MEMORY.md"}
+    # Verify no backslashes in keys (cross-OS restore safety)
+    assert all("\\" not in r for r, _ in files)
+    assert m.memory_restore_dest(("grok-memory", "proj", "MEMORY.md"), types.SimpleNamespace(cwd=cwd, provider="grok")) \
+        == cwd / spawn._GROK_CELL_HOME_SUBDIR / ".grok" / "memory" / "proj" / "MEMORY.md"
+    assert m.memory_guard_file(types.SimpleNamespace(cwd=cwd, provider="grok")) is None   # no cwd doc
+
+
+# Tests for memory_sync.py dispatch (Task 2)
+from swarph_cli.commands import memory_sync
+
+
+def test_get_files_to_sync_dispatches_to_membrane(tmp_path):
+    cwd = tmp_path; (cwd / "CURRENT_TASK.md").write_text("t"); (cwd / "AGENTS.md").write_text("A")
+    cell = types.SimpleNamespace(cwd=cwd, provider="codex")
+    rels = {r for r, _ in memory_sync._get_files_to_sync(cell)}
+    assert rels == {"CURRENT_TASK.md", "AGENTS.md"}   # common + codex membrane
+
+
+def test_get_files_unknown_provider_is_common_only(tmp_path):
+    cwd = tmp_path; (cwd / "CURRENT_TASK.md").write_text("t")
+    cell = types.SimpleNamespace(cwd=cwd, provider="nonesuch")
+    assert {r for r, _ in memory_sync._get_files_to_sync(cell)} == {"CURRENT_TASK.md"}
+
+
+def test_grok_roundtrip_sync_then_restore_dest(tmp_path):
+    cwd = tmp_path
+    mem = cwd / spawn._GROK_CELL_HOME_SUBDIR / ".grok" / "memory"
+    mem.mkdir(parents=True); (mem / "MEMORY.md").write_text("m")
+    cell = types.SimpleNamespace(cwd=cwd, provider="grok")
+    files = memory_sync._get_files_to_sync(cell)
+    rel = next(r for r, _ in files if r.startswith("grok-memory"))
+    dest = spawn.MEMBRANES["grok"].memory_restore_dest(tuple(Path(rel).parts), cell)
+    assert dest == mem / "MEMORY.md"   # snapshot rel round-trips to the isolated-HOME source

{swarph_cli-0.35.0 → swarph_cli-0.37.0}/tests/test_watchdog.py

@@ -1043,4 +1043,4 @@ def test_parser_defaults_process_name_claude_liveness_cmd_none():
 
 def test_version_is_0_33_0():
     import swarph_cli
-    assert swarph_cli.__version__ == "0.35.0"
+    assert swarph_cli.__version__ == "0.37.0"