swarph-cli 0.9.2__tar.gz → 0.9.4__tar.gz

{swarph_cli-0.9.2/src/swarph_cli.egg-info → swarph_cli-0.9.4}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.9.2
-Summary: The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider spawn (claude/codex/antigravity per cell.provider via a ProviderMembrane), cell.yaml, `swarph mesh` (send/inbox/register with per-peer tokens) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.2 makes the watchdog deploy-safe: no false A2 when no tmux server is reachable (root-cron), and F3 uses window/session activity so active sessions are correctly detected.
+Version: 0.9.4
+Summary: The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider `swarph spawn` (claude/codex/antigravity per cell.provider via a ProviderMembrane + subprocess billing-scrub), interactive `swarph init`, `swarph mesh` (send/inbox/register) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.4: fixes session-pin resume across a changed cwd.
 Author: Pierre Samson, Claude Opus
 License: MIT
 Project-URL: Homepage, https://github.com/darw007d/swarph-cli

{swarph_cli-0.9.2 → swarph_cli-0.9.4}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.9.2"
-description = "The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider spawn (claude/codex/antigravity per cell.provider via a ProviderMembrane), cell.yaml, `swarph mesh` (send/inbox/register with per-peer tokens) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.2 makes the watchdog deploy-safe: no false A2 when no tmux server is reachable (root-cron), and F3 uses window/session activity so active sessions are correctly detected."
+version = "0.9.4"
+description = "The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider `swarph spawn` (claude/codex/antigravity per cell.provider via a ProviderMembrane + subprocess billing-scrub), interactive `swarph init`, `swarph mesh` (send/inbox/register) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.4: fixes session-pin resume across a changed cwd."
 readme = "README.md"
 license = { text = "MIT" }
 requires-python = ">=3.10"

{swarph_cli-0.9.2 → swarph_cli-0.9.4}/src/swarph_cli/__init__.py

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

{swarph_cli-0.9.2 → swarph_cli-0.9.4}/src/swarph_cli/cell.py

@@ -252,6 +252,42 @@ def load_cell(path: Path) -> Cell:
     return cell
 
 
+def _write_session_sidecar(target: Path, session_id: str, cwd) -> None:
+    """Write the two-line ``{uuid, cwd}`` session sidecar atomically.
+
+    v0.9.4 (session-pin cwd-mismatch fix): the sidecar records the cwd
+    the session UUID was minted for so a later spawn from a DIFFERENT
+    cwd can detect the mismatch and re-pin a fresh UUID rather than
+    handing a project-scoped UUID to ``claude --resume`` from the wrong
+    project (which dies with "No conversation found with session ID").
+
+    Format (trailing-newline convention preserved):
+
+        <uuid>\\n
+        <cwd>\\n
+    """
+    target.parent.mkdir(parents=True, exist_ok=True)
+    _atomic_write_text(target, f"{session_id}\n{str(cwd)}\n")
+
+
+def _read_session_sidecar(path: Path) -> tuple[Optional[str], Optional[str]]:
+    """Parse a session sidecar → ``(uuid, cwd)``.
+
+    Returns ``(None, None)`` for a missing/empty file. ``cwd`` is
+    ``None`` for a **legacy one-line** sidecar (bare UUID, pre-0.9.4)
+    — we cannot know which project that UUID belongs to.
+    """
+    if not path.exists():
+        return None, None
+    raw = path.read_text(encoding="utf-8")
+    lines = raw.splitlines()
+    if not lines:
+        return None, None
+    uuid_str = lines[0].strip() or None
+    cwd_str = lines[1].strip() if len(lines) >= 2 and lines[1].strip() else None
+    return uuid_str, cwd_str
+
+
 def load_or_create_session_id(
     role: str,
     cell: Cell,
@@ -266,6 +302,10 @@ def load_or_create_session_id(
       2. ``new_instance=True`` AND base sidecar exists — auto-suffix slot
       3. ``new_instance=True`` AND no base sidecar — fall through (degenerate)
       4. session_state_path(role) reused — default re-resume path
+         (v0.9.4: only when the sidecar's recorded cwd matches cell.cwd;
+         on cwd-mismatch a fresh UUID is minted + re-pinned for the new
+         cwd, because ``claude --resume`` is PROJECT-scoped and a pin
+         from another cwd dies with "No conversation found")
       5. mint new uuid4 + persist
 
     Caller-side discipline (mother iter-1 #986): the ``effective_role``
@@ -282,23 +322,33 @@ def load_or_create_session_id(
             sibling_role = next_free_slot_role(role)
             sibling_state = session_state_path(sibling_role)
             new_id = str(uuid.uuid4())
-            sibling_state.parent.mkdir(parents=True, exist_ok=True)
-            _atomic_write_text(sibling_state, new_id + "\n")
+            _write_session_sidecar(sibling_state, new_id, cell.cwd)
             return new_id, True, sibling_role
 
     state_file = session_state_path(role)
     if state_file.exists():
-        existing = state_file.read_text(encoding="utf-8").strip()
-        if existing:
+        existing_uuid, recorded_cwd = _read_session_sidecar(state_file)
+        if existing_uuid:
             try:
-                return validate_uuid_str(existing), False, role
+                valid_uuid = validate_uuid_str(existing_uuid)
             except CellError:
                 # Corrupted state — fall through and regenerate.
-                pass
+                valid_uuid = None
+            if valid_uuid is not None:
+                if recorded_cwd is not None and recorded_cwd != str(cell.cwd):
+                    # v0.9.4: pin belongs to a different project. A
+                    # project-scoped --resume would die from this cwd, so
+                    # mint a fresh (clean) UUID + re-pin for the new cwd.
+                    fresh = str(uuid.uuid4())
+                    _write_session_sidecar(state_file, fresh, cell.cwd)
+                    return fresh, True, role
+                # Legacy (recorded_cwd is None) → reuse as-is; do NOT
+                # rewrite, since the UUID's true origin cwd is unknown.
+                # Matching cwd → reuse.
+                return valid_uuid, False, role
 
     new_id = str(uuid.uuid4())
-    state_file.parent.mkdir(parents=True, exist_ok=True)
-    _atomic_write_text(state_file, new_id + "\n")
+    _write_session_sidecar(state_file, new_id, cell.cwd)
     return new_id, True, role
 
 
@@ -352,6 +402,8 @@ __all__ = [
     "read_starter_prompt",
     "load_cell",
     "load_or_create_session_id",
+    "_read_session_sidecar",
+    "_write_session_sidecar",
     # Backward-compat aliases
     "_PEER_NAME_RE",
     "_VALID_SCHEMA_VERSIONS",

swarph_cli-0.9.4/src/swarph_cli/commands/init.py

@@ -0,0 +1,237 @@
+"""``swarph init`` — interactive install wizard that scaffolds a validated
+cell.yaml at the named registry path (``~/.config/swarph/cells/<name>.yaml``).
+
+The default UX is a guided setup: name → LLM type → role/cwd/tmux → assisted
+memory (y/n) → register (y/n) → confirm + write. Flags override any prompt, so
+a fully-flagged invocation runs non-interactively (scripting / CI).
+
+The cell dict is validated through ``swarph_shared.cell.parse_cell_dict`` BEFORE
+writing — init never emits a cell.yaml that wouldn't parse. See
+``docs/superpowers/specs/2026-06-02-swarph-init-design.md``.
+"""
+from __future__ import annotations
+
+import argparse
+import copy
+import os
+import sys
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+from swarph_shared.cell import PEER_NAME_RE, VALID_PROVIDERS, parse_cell_dict
+from swarph_cli.cell import CellError, cells_dir
+
+_DEFAULT_GATEWAY = os.environ.get("MESH_GATEWAY_URL", "http://lab-ovh:8788")
+_CODEX_SANDBOX_DEFAULT = "workspace-write"
+_CODEX_SANDBOX_VALUES = ("workspace-write", "read-only")
+
+# LLM type → (provider, blurb). The menu the wizard shows.
+_LLM_CHOICES = [
+    ("claude", "Anthropic Claude — claude membrane"),
+    ("codex", "OpenAI / GPT — codex membrane (AGENTS.md)"),
+    ("antigravity", "Google Gemini — agy membrane (firejail)"),
+]
+
+
+# ---------------------------------------------------------------------------
+# Prompt helpers (interactive). All no-op when a flag already supplied the value.
+# ---------------------------------------------------------------------------
+
+def _ask(prompt: str, default: Optional[str] = None) -> str:
+    suffix = f" [{default}]" if default else ""
+    try:
+        ans = input(f"{prompt}{suffix}: ").strip()
+    except EOFError:
+        ans = ""
+    return ans or (default or "")
+
+
+def _ask_yn(prompt: str, default: bool = False) -> bool:
+    d = "Y/n" if default else "y/N"
+    try:
+        ans = input(f"{prompt} [{d}]: ").strip().lower()
+    except EOFError:
+        ans = ""
+    if not ans:
+        return default
+    return ans in ("y", "yes")
+
+
+def _ask_llm() -> str:
+    print("\nSelect LLM type:")
+    for i, (prov, blurb) in enumerate(_LLM_CHOICES, 1):
+        print(f"  {i}) {prov:12} {blurb}")
+    while True:
+        try:
+            ans = input("Choice [1-3]: ").strip()
+        except EOFError:
+            ans = "1"
+        if ans.isdigit() and 1 <= int(ans) <= len(_LLM_CHOICES):
+            return _LLM_CHOICES[int(ans) - 1][0]
+        if ans in VALID_PROVIDERS:
+            return ans
+        print("  (enter 1, 2, or 3)")
+
+
+def _https_normalize(repo: str) -> tuple[str, bool]:
+    """Rewrite an SSH GitHub URL to HTTPS (this box auths via gh/HTTPS, not a
+    deploy key). Returns (url, rewritten)."""
+    if repo.startswith("git@github.com:"):
+        return "https://github.com/" + repo[len("git@github.com:"):], True
+    return repo, False
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="swarph init",
+        description="Interactive wizard: scaffold a cell.yaml at "
+                    "~/.config/swarph/cells/<name>.yaml. Flags override prompts.",
+    )
+    p.add_argument("name", nargs="?", default=None,
+                   help="kebab-case mesh peer name (prompted if omitted)")
+    p.add_argument("--provider", choices=sorted(VALID_PROVIDERS), default=None,
+                   help="spawn provider/membrane (prompted if omitted)")
+    p.add_argument("--role", default=None)
+    p.add_argument("--cwd", default=None)
+    p.add_argument("--tmux", default=None)
+    p.add_argument("--cursor", default=None)
+    p.add_argument("--sandbox", default=None)
+    p.add_argument("--gateway", default=_DEFAULT_GATEWAY)
+    p.add_argument("--assisted-memory", dest="assisted_memory", default=None, metavar="REPO",
+                   help="enable git-backed memory at REPO (SSH→HTTPS normalized)")
+    p.add_argument("--starter", default=None)
+    p.add_argument("--symlink-cwd", dest="symlink_cwd", action="store_true")
+    p.add_argument("--force", action="store_true")
+    p.add_argument("--non-interactive", "-y", dest="non_interactive", action="store_true",
+                   help="never prompt; require all values via flags")
+    return p
+
+
+def run_init(argv: list[str]) -> int:
+    args = _build_parser().parse_args(argv)
+    # Interactive unless explicitly disabled or stdin isn't a TTY.
+    interactive = (not args.non_interactive) and sys.stdin.isatty()
+
+    # ── name ──
+    name = args.name
+    if not name and interactive:
+        name = _ask("Cell / peer name (kebab-case)")
+    if not name:
+        print("swarph init: name required (positional or prompt)", file=sys.stderr)
+        return 2
+    if not PEER_NAME_RE.match(name):
+        print(f"swarph init: name {name!r} must match {PEER_NAME_RE.pattern} "
+              f"(kebab-case, no underscores)", file=sys.stderr)
+        return 2
+
+    # ── LLM type / provider ──
+    provider = args.provider
+    if not provider and interactive:
+        provider = _ask_llm()
+    if not provider:
+        print("swarph init: --provider required (or run interactively)", file=sys.stderr)
+        return 2
+
+    # ── role / cwd / tmux / cursor ──
+    role = args.role or (_ask("Role", name) if interactive else name)
+    cwd_raw = args.cwd or (_ask("Working dir (cwd)", str(Path.cwd())) if interactive else str(Path.cwd()))
+    cwd = Path(cwd_raw).expanduser().resolve()
+    tmux = args.tmux or (_ask("tmux session", name) if interactive else name)
+    cursor = args.cursor or f"/tmp/{name}-cursor.json"
+
+    # ── sandbox ──
+    if provider == "codex":
+        sandbox = args.sandbox or _CODEX_SANDBOX_DEFAULT
+        if sandbox not in _CODEX_SANDBOX_VALUES:
+            print(f"swarph init: codex --sandbox must be one of {_CODEX_SANDBOX_VALUES}, "
+                  f"got {sandbox!r}", file=sys.stderr)
+            return 2
+    else:
+        sandbox = args.sandbox  # antigravity default-on if None; claude ignores
+
+    cell: dict = {
+        "schema_version": "v1",
+        "name": name,
+        "role": role,
+        "provider": provider,
+        "cwd": str(cwd),
+        "tmux_session": tmux,
+        "cursor_path": cursor,
+        "mesh": {"gateway": args.gateway},
+    }
+    if sandbox is not None:
+        cell["sandbox"] = sandbox
+    if args.starter:
+        cell["starter_prompt_path"] = args.starter
+
+    # ── assisted memory (y/n) ──
+    am_repo = args.assisted_memory
+    if am_repo is None and interactive and _ask_yn("Use assisted memory (git-backed durable memory)?", False):
+        am_repo = _ask("  Memory git repo URL")
+    am_note = ""
+    if am_repo:
+        repo, rewritten = _https_normalize(am_repo)
+        cell["assisted_memory"] = {"enabled": True, "repo": repo, "interval_min": 15}
+        if rewritten:
+            am_note = (f"  (repo normalized SSH→HTTPS: {repo}; ensure gh/HTTPS "
+                       f"creds can reach it — a private repo needing SSH will fail otherwise)")
+
+    # ── validate BEFORE writing (parse_cell_dict mutates → deepcopy) ──
+    try:
+        parse_cell_dict(copy.deepcopy(cell))
+    except CellError as exc:
+        print(f"swarph init: refusing to write an invalid cell.yaml: {exc}", file=sys.stderr)
+        return 2
+
+    dest = cells_dir() / f"{name}.yaml"
+    if dest.exists() and not args.force:
+        if interactive and _ask_yn(f"{dest} exists — overwrite?", False):
+            pass
+        else:
+            print(f"swarph init: {dest} already exists (use --force)", file=sys.stderr)
+            return 2
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    dest.write_text(yaml.safe_dump(cell, sort_keys=False), encoding="utf-8")
+    print(f"swarph init: wrote {dest}{am_note}")
+
+    # ── optional cwd symlink ──
+    want_symlink = args.symlink_cwd or (interactive and _ask_yn(
+        f"Symlink {cwd}/cell.yaml → registry (so `swarph spawn` works from that dir too)?", False))
+    if want_symlink:
+        _symlink_cwd(cwd, dest, args.force)
+
+    # Resolved summary (echo the derived cwd/tmux/cursor — those were the snags).
+    print("  resolved:")
+    print(f"    provider={provider}  role={role}  sandbox={sandbox if sandbox is not None else '(default)'}")
+    print(f"    cwd={cwd}")
+    print(f"    tmux_session={cell['tmux_session']}  cursor_path={cell['cursor_path']}")
+    if "assisted_memory" in cell:
+        print(f"    assisted_memory.repo={cell['assisted_memory']['repo']} (enabled)")
+
+    # Registration is NOT done here (R1 token mint-once is a once-only secret —
+    # init scaffolding from the operator's context shouldn't capture another
+    # cell's token; the cell self-adopts from ITS OWN context per the adoption
+    # doc, which is the forge-clean path). Deferred follow-up: a careful
+    # single-process register that captures→mode-600→verifies the raw token.
+    print(f"\nready: swarph spawn {name}")
+    print(f"next:  the cell self-registers + adopts its per-peer token from its "
+          f"OWN context (see SWARPH_PEER_TOKEN_ADOPTION.md); then `swarph ratify {name}`.")
+    return 0
+
+
+def _symlink_cwd(cwd: Path, dest: Path, force: bool) -> None:
+    link = cwd / "cell.yaml"
+    try:
+        cwd.mkdir(parents=True, exist_ok=True)
+        if link.is_symlink() or link.exists():
+            if force:
+                link.unlink()
+            else:
+                print(f"swarph init: {link} exists; skip symlink (use --force)", file=sys.stderr)
+                return
+        link.symlink_to(dest)
+        print(f"swarph init: symlinked {link} → {dest}")
+    except OSError as exc:
+        print(f"swarph init: symlink failed (non-fatal): {exc}", file=sys.stderr)

{swarph_cli-0.9.2 → swarph_cli-0.9.4}/src/swarph_cli/commands/memory_sync.py

@@ -39,7 +39,7 @@ def _get_files_to_sync(cell: Cell) -> list[tuple[str, Path]]:
         if (cell.cwd / "AGENTS.md").exists():
             files_to_sync.append(("AGENTS.md", cell.cwd / "AGENTS.md"))
 
-    elif cell.provider in ("antigravity", "gemini"):
+    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():
@@ -94,6 +94,7 @@ def perform_restore(cell: Cell) -> Optional[str]:
         subprocess.run(["git", "-C", str(repo_dir), "pull", "--ff-only", "origin", "main"], check=True, capture_output=True)
     except subprocess.CalledProcessError as exc:
         print(f"swarph: memory pull --ff-only failed (diverged/offline?): {exc}", file=sys.stderr)
+        return None
 
     # Walk the repo dir and copy everything back, EXCEPT .git and .gitignore
     for root, dirs, files in os.walk(repo_dir):
@@ -104,6 +105,10 @@ def perform_restore(cell: Cell) -> Optional[str]:
                 continue
             
             src = Path(root) / f
+            if f in ("CLAUDE.md", "AGENTS.md", "GEMINI.md") and src.stat().st_size == 0:
+                print(f"swarph: SAFETY: remote {f} is empty. Refusing to restore and clobber local.", file=sys.stderr)
+                continue
+
             rel = src.relative_to(repo_dir)
             
             dest = None
@@ -115,9 +120,9 @@ def perform_restore(cell: Cell) -> Optional[str]:
                 dest = Path.home() / ".claude" / rel
             elif cell.provider == "claude" and rel.parts[0] == "inbox-cursor":
                 dest = Path.home() / ".claude" / "inbox-cursor"
-            elif cell.provider in ("antigravity", "gemini") and rel.parts[0] == "tmp":
+            elif cell.provider == "antigravity" and rel.parts[0] == "tmp":
                 dest = Path.home() / ".gemini" / rel
-            elif cell.provider in ("antigravity", "gemini") and rel.parts[0] == "history":
+            elif cell.provider == "antigravity" and rel.parts[0] == "history":
                 dest = Path.home() / ".gemini" / rel
                 
             if dest:
@@ -168,7 +173,7 @@ def run_memory_sync(argv: list[str]) -> int:
         guard_file = cell.cwd / "CLAUDE.md"
     elif cell.provider == "codex":
         guard_file = cell.cwd / "AGENTS.md"
-    elif cell.provider in ("antigravity", "gemini"):
+    elif cell.provider == "antigravity":
         guard_file = cell.cwd / "GEMINI.md"
 
     if guard_file and (not guard_file.exists() or guard_file.stat().st_size == 0):

{swarph_cli-0.9.2 → swarph_cli-0.9.4}/src/swarph_cli/commands/mesh.py

@@ -241,7 +241,8 @@ def _run_send(args: argparse.Namespace) -> int:
         token,
     )
     if status < 200 or status >= 300:
-        print(f"swarph mesh send: gateway {status}: {payload.get('detail', payload)}", file=sys.stderr)
+        detail = payload.get("detail", "<gateway error>")
+        print(f"swarph mesh send: gateway {status}: {detail}", file=sys.stderr)
         return 1
     print(
         f"sent id={payload.get('id')} from={payload.get('from_node')} "
@@ -259,7 +260,8 @@ def _run_inbox(args: argparse.Namespace) -> int:
     url = f"{args.gateway.rstrip('/')}/messages?{urllib.parse.urlencode(params)}"
     status, payload = _http_get_json(url, token)
     if status < 200 or status >= 300:
-        print(f"swarph mesh inbox: gateway {status}: {payload.get('detail', payload)}", file=sys.stderr)
+        detail = payload.get("detail", "<gateway error>")
+        print(f"swarph mesh inbox: gateway {status}: {detail}", file=sys.stderr)
         return 1
     if args.json:
         print(json.dumps(payload, indent=2, sort_keys=True))
@@ -304,7 +306,8 @@ def _run_register(args: argparse.Namespace) -> int:
         token,
     )
     if status < 200 or status >= 300:
-        print(f"swarph mesh register: gateway {status}: {payload.get('detail', payload)}", file=sys.stderr)
+        detail = payload.get("detail", "<gateway error>")
+        print(f"swarph mesh register: gateway {status}: {detail}", file=sys.stderr)
         return 1
     peer_token = payload.get("peer_token")
     token_status = payload.get("token_status")
@@ -329,7 +332,20 @@ def _default_sidecar_state_dir(self_name: str) -> Path:
 def _read_cursor(path: Path) -> dict:
     if not path.exists():
         return {"last_msg_id": 0, "last_wake_at": 0.0}
-    return json.loads(path.read_text(encoding="utf-8"))
+    try:
+        cursor = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        print(
+            f"[mesh-sidecar] ignoring unreadable cursor {path}: {exc}",
+            file=sys.stderr,
+            flush=True,
+        )
+        return {"last_msg_id": 0, "last_wake_at": 0.0}
+    if not isinstance(cursor, dict):
+        return {"last_msg_id": 0, "last_wake_at": 0.0}
+    cursor.setdefault("last_msg_id", 0)
+    cursor.setdefault("last_wake_at", 0.0)
+    return cursor
 
 
 def _write_cursor_atomic(path: Path, cursor: dict) -> None:
@@ -447,12 +463,11 @@ def _sidecar_iteration(state: MeshSidecarState) -> None:
         if _tmux_wake(state.tmux_target):
             state.cursor["last_wake_at"] = now
             state.wakes_sent += 1
+            state.cursor["last_msg_id"] = new_last_id
+            _write_cursor_atomic(state.cursor_path, state.cursor)
     else:
         print("[mesh-sidecar] wake suppressed by idle guard", flush=True)
 
-    state.cursor["last_msg_id"] = new_last_id
-    _write_cursor_atomic(state.cursor_path, state.cursor)
-
 
 def _run_sidecar(args: argparse.Namespace) -> int:
     state_dir_arg = Path(args.state_dir).expanduser() if args.state_dir else None

{swarph_cli-0.9.2 → swarph_cli-0.9.4}/src/swarph_cli/commands/spawn.py

@@ -941,8 +941,16 @@ def run_spawn(argv: Optional[list[str]] = None) -> int:
                 inject_text = f"Your active task is in CURRENT_TASK.md — read it first:\n\n{current_task_text}"
                 if cell.provider == "claude":
                     spawn_argv.extend(["--append-system-prompt", inject_text])
-                elif cell.provider in ("codex", "antigravity"):
+                elif cell.provider == "antigravity":
                     spawn_argv.extend(["--prompt-interactive", inject_text])
+                elif cell.provider == "codex":
+                    agents_md = cell.cwd / "AGENTS.md"
+                    if agents_md.exists():
+                        content = agents_md.read_text(encoding="utf-8")
+                        if "CURRENT_TASK.md" not in content:
+                            agents_md.write_text(inject_text + "\n\n" + content, encoding="utf-8")
+                    else:
+                        agents_md.write_text(inject_text, encoding="utf-8")
         except Exception as exc:
             print(f"swarph spawn: restore failed: {exc}", file=sys.stderr)
 

{swarph_cli-0.9.2 → swarph_cli-0.9.4}/src/swarph_cli/main.py

@@ -72,6 +72,7 @@ Spec: https://github.com/darw007d/hedge-fund-mcp/blob/main/research/swarph_cli/P
 # only for disambiguation against one-shot prompts (rare).
 _VERB_HANDLERS: dict[str, str] = {
     # verb keyword: dotted-path to handler function (lazy-imported)
+    "init": "swarph_cli.commands.init.run_init",
     "import": "swarph_cli.commands.import_session.run_import",
     "chat": "swarph_cli.commands.chat.run_chat",
     "onboard": "swarph_cli.commands.onboard.run_onboard",

{swarph_cli-0.9.2 → swarph_cli-0.9.4/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.9.2
-Summary: The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider spawn (claude/codex/antigravity per cell.provider via a ProviderMembrane), cell.yaml, `swarph mesh` (send/inbox/register with per-peer tokens) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.2 makes the watchdog deploy-safe: no false A2 when no tmux server is reachable (root-cron), and F3 uses window/session activity so active sessions are correctly detected.
+Version: 0.9.4
+Summary: The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider `swarph spawn` (claude/codex/antigravity per cell.provider via a ProviderMembrane + subprocess billing-scrub), interactive `swarph init`, `swarph mesh` (send/inbox/register) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.4: fixes session-pin resume across a changed cwd.
 Author: Pierre Samson, Claude Opus
 License: MIT
 Project-URL: Homepage, https://github.com/darw007d/swarph-cli

{swarph_cli-0.9.2 → swarph_cli-0.9.4}/src/swarph_cli.egg-info/SOURCES.txt

@@ -16,6 +16,7 @@ src/swarph_cli/commands/chat.py
 src/swarph_cli/commands/daemon.py
 src/swarph_cli/commands/hook_output.py
 src/swarph_cli/commands/import_session.py
+src/swarph_cli/commands/init.py
 src/swarph_cli/commands/install_hook.py
 src/swarph_cli/commands/memory_sync.py
 src/swarph_cli/commands/mesh.py
@@ -34,6 +35,7 @@ tests/test_claude_parser.py
 tests/test_daemon_command.py
 tests/test_hook_output.py
 tests/test_import_command.py
+tests/test_init_command.py
 tests/test_install_hook.py
 tests/test_main.py
 tests/test_memory_sync.py

{swarph_cli-0.9.2 → swarph_cli-0.9.4}/tests/test_cell_loader.py

@@ -22,6 +22,8 @@ from swarph_cli.cell import (
     load_or_create_session_id,
     resolve_cell_path,
     session_state_path,
+    _read_session_sidecar,
+    _write_session_sidecar,
 )
 
 
@@ -264,7 +266,9 @@ def test_load_or_create_session_id_mints_and_persists(
     uuid.UUID(sid1)  # raises if not a valid UUID
     sidecar = session_state_path("lab")
     assert sidecar.exists()
-    assert sidecar.read_text().strip() == sid1
+    rec_uuid, rec_cwd = _read_session_sidecar(sidecar)
+    assert rec_uuid == sid1
+    assert rec_cwd == str(cell.cwd)
 
 
 def test_load_or_create_session_id_reuses_persisted_value(
@@ -287,7 +291,102 @@ def test_load_or_create_session_id_corrupted_sidecar_regenerates(
     sid, generated, _role = load_or_create_session_id("lab", cell)
     uuid.UUID(sid)
     assert generated is True
-    assert sidecar.read_text().strip() == sid
+    rec_uuid, _rec_cwd = _read_session_sidecar(sidecar)
+    assert rec_uuid == sid
+
+
+# ---------------------------------------------------------------------------
+# v0.9.4 — session-pin cwd-mismatch fix (project-scoped --resume)
+# ---------------------------------------------------------------------------
+
+
+def test_session_sidecar_fresh_mint_writes_two_line_uuid_and_cwd(
+    isolated_xdg, cell_yaml_factory, tmp_path
+):
+    """v0.9.4 — first mint records BOTH the uuid AND the cwd (cwd=A)."""
+    cell = load_cell(cell_yaml_factory())  # cwd == tmp_path (== A)
+    sid, gen, _role = load_or_create_session_id("lab", cell)
+    assert gen is True
+    uuid.UUID(sid)
+    rec_uuid, rec_cwd = _read_session_sidecar(session_state_path("lab"))
+    assert rec_uuid == sid
+    assert rec_cwd == str(tmp_path)
+    assert rec_cwd == str(cell.cwd)
+
+
+def test_session_sidecar_same_cwd_reuses_same_uuid(
+    isolated_xdg, cell_yaml_factory, tmp_path
+):
+    """v0.9.4 — pre-pinned {uuid=U, cwd=A}; spawn from cwd=A reuses U."""
+    cell = load_cell(cell_yaml_factory())  # cwd == tmp_path (== A)
+    fixed = "550e8400-e29b-41d4-a716-446655440000"
+    _write_session_sidecar(session_state_path("lab"), fixed, str(tmp_path))
+    sid, gen, role = load_or_create_session_id("lab", cell)
+    assert sid == fixed
+    assert gen is False
+    assert role == "lab"
+
+
+def test_session_sidecar_different_cwd_mints_fresh_and_repins(
+    isolated_xdg, cell_yaml_factory, tmp_path
+):
+    """v0.9.4 REGRESSION — the bug: pin minted for cwd=A, spawn from cwd=B.
+
+    A project-scoped ``claude --resume <U>`` from B dies with
+    "No conversation found". Fix: mint a FRESH (clean) uuid and re-pin
+    it for cwd=B.
+    """
+    cwd_b = tmp_path / "project_b"
+    cwd_b.mkdir()
+    cell = load_cell(cell_yaml_factory(cwd=str(cwd_b)))  # cell.cwd == B
+    fixed = "550e8400-e29b-41d4-a716-446655440000"  # pinned for cwd=A
+    _write_session_sidecar(session_state_path("lab"), fixed, str(tmp_path))
+
+    sid, gen, role = load_or_create_session_id("lab", cell)
+    assert gen is True
+    assert sid != fixed  # genuine fresh UUID
+    uuid.UUID(sid)
+    assert role == "lab"
+    # Sidecar now re-pinned for cwd=B with the fresh UUID.
+    rec_uuid, rec_cwd = _read_session_sidecar(session_state_path("lab"))
+    assert rec_uuid == sid
+    assert rec_cwd == str(cwd_b)
+
+
+def test_session_sidecar_legacy_one_line_is_reused_not_reminted(
+    isolated_xdg, cell_yaml_factory, tmp_path
+):
+    """v0.9.4 back-compat — legacy bare-uuid (no cwd) sidecar is reused
+    as-is regardless of cwd (origin cwd unknown; do NOT re-mint)."""
+    cell = load_cell(cell_yaml_factory())
+    fixed = "550e8400-e29b-41d4-a716-446655440000"
+    sidecar = session_state_path("lab")
+    sidecar.parent.mkdir(parents=True, exist_ok=True)
+    sidecar.write_text(fixed + "\n")  # legacy one-line format
+    sid, gen, role = load_or_create_session_id("lab", cell)
+    assert sid == fixed
+    assert gen is False
+    assert role == "lab"
+    # Not upgraded/rewritten — stays legacy one-line.
+    assert sidecar.read_text() == fixed + "\n"
+
+
+def test_read_session_sidecar_parses_both_formats(tmp_path):
+    """v0.9.4 — _read_session_sidecar handles 2-line AND legacy 1-line."""
+    two_line = tmp_path / "two.session-id"
+    two_line.write_text("550e8400-e29b-41d4-a716-446655440000\n/home/x/proj\n")
+    assert _read_session_sidecar(two_line) == (
+        "550e8400-e29b-41d4-a716-446655440000",
+        "/home/x/proj",
+    )
+    one_line = tmp_path / "one.session-id"
+    one_line.write_text("550e8400-e29b-41d4-a716-446655440000\n")
+    assert _read_session_sidecar(one_line) == (
+        "550e8400-e29b-41d4-a716-446655440000",
+        None,
+    )
+    missing = tmp_path / "missing.session-id"
+    assert _read_session_sidecar(missing) == (None, None)
 
 
 def test_load_or_create_session_id_atomic_no_tempfile_left_behind(
@@ -435,8 +534,8 @@ def test_new_instance_with_existing_base_mints_into_slot_2(
     base_path = session_state_path("drop")
     sib_path = session_state_path("drop-2")
     assert base_path.exists() and sib_path.exists()
-    assert base_path.read_text().strip() == sid_base
-    assert sib_path.read_text().strip() == sid_sib
+    assert _read_session_sidecar(base_path)[0] == sid_base
+    assert _read_session_sidecar(sib_path)[0] == sid_sib
 
 
 def test_new_instance_third_call_lands_at_slot_3(

swarph_cli-0.9.4/tests/test_init_command.py

@@ -0,0 +1,83 @@
+"""Tests for `swarph init` (cell.yaml scaffolder). Non-interactive (-y / flag)
+path + helpers; cells_dir() isolated via XDG_CONFIG_HOME."""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from swarph_cli.commands.init import run_init, _https_normalize
+from swarph_cli.cell import cells_dir, load_cell
+
+
+@pytest.fixture(autouse=True)
+def isolated_cells(tmp_path, monkeypatch):
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path / "config"))
+    return tmp_path
+
+
+def _run(*argv):
+    return run_init(list(argv))
+
+
+def test_https_normalize():
+    assert _https_normalize("git@github.com:darw007d/x.git") == ("https://github.com/darw007d/x.git", True)
+    assert _https_normalize("https://github.com/darw007d/x.git") == ("https://github.com/darw007d/x.git", False)
+
+
+def test_init_writes_validated_cell(tmp_path):
+    rc = _run("gpt-test", "--provider", "codex", "--cwd", str(tmp_path), "-y")
+    assert rc == 0
+    dest = cells_dir() / "gpt-test.yaml"
+    assert dest.exists()
+    c = load_cell(dest)
+    assert c.name == "gpt-test" and c.provider == "codex"
+    assert c.role == "gpt-test"                      # default = name
+    assert c.sandbox == "workspace-write"            # codex default
+    assert c.extra["tmux_session"] == "gpt-test"     # default = name
+    assert c.extra["cursor_path"] == "/tmp/gpt-test-cursor.json"
+
+
+def test_init_rejects_underscore_name(tmp_path):
+    assert _run("bad_name", "--provider", "codex", "--cwd", str(tmp_path), "-y") == 2
+    assert not (cells_dir() / "bad_name.yaml").exists()
+
+
+def test_init_requires_provider_when_noninteractive(tmp_path):
+    assert _run("c1", "--cwd", str(tmp_path), "-y") == 2
+
+
+def test_init_refuses_existing_without_force(tmp_path):
+    assert _run("dup", "--provider", "codex", "--cwd", str(tmp_path), "-y") == 0
+    assert _run("dup", "--provider", "codex", "--cwd", str(tmp_path), "-y") == 2   # exists
+    assert _run("dup", "--provider", "codex", "--cwd", str(tmp_path), "-y", "--force") == 0
+
+
+def test_init_assisted_memory_https_normalized(tmp_path):
+    rc = _run("mem", "--provider", "antigravity", "--cwd", str(tmp_path), "-y",
+              "--assisted-memory", "git@github.com:darw007d/mem.git")
+    assert rc == 0
+    c = load_cell(cells_dir() / "mem.yaml")
+    assert c.assisted_memory["enabled"] is True
+    assert c.assisted_memory["repo"] == "https://github.com/darw007d/mem.git"
+    assert c.assisted_memory["interval_min"] == 15
+
+
+def test_init_antigravity_omits_sandbox(tmp_path):
+    rc = _run("agy-cell", "--provider", "antigravity", "--cwd", str(tmp_path), "-y")
+    assert rc == 0
+    c = load_cell(cells_dir() / "agy-cell.yaml")
+    assert c.sandbox is None                          # default-on, not written
+
+
+def test_init_codex_bad_sandbox_rejected(tmp_path):
+    assert _run("c", "--provider", "codex", "--sandbox", "bogus", "--cwd", str(tmp_path), "-y") == 2
+
+
+def test_init_symlink_cwd(tmp_path):
+    cwd = tmp_path / "cellwd"
+    rc = _run("linked", "--provider", "codex", "--cwd", str(cwd), "-y", "--symlink-cwd")
+    assert rc == 0
+    link = cwd / "cell.yaml"
+    assert link.is_symlink()
+    assert link.resolve() == (cells_dir() / "linked.yaml").resolve()

swarph_cli-0.9.4/tests/test_memory_sync.py

@@ -0,0 +1,92 @@
+import pytest
+import subprocess
+from unittest.mock import patch, MagicMock
+from pathlib import Path
+from swarph_cli.commands.memory_sync import run_memory_sync, perform_restore
+from swarph_cli.cell import Cell
+
+def test_run_memory_sync_no_op_when_not_enabled(tmp_path):
+    cell = Cell(
+        name="test",
+        role="test",
+        cwd=tmp_path,
+        schema_version="v1",
+        session_id=None,
+        starter_prompt_path=None,
+        provider="claude",
+        sandbox=None,
+        lineage=None,
+        source_path=None,
+        assisted_memory={"enabled": False, "interval_min": 15},
+        extra={},
+    )
+    with patch("swarph_cli.commands.memory_sync.load_cell", return_value=cell):
+        assert run_memory_sync(["fake.yaml"]) == 0
+
+def test_perform_restore_returns_none_when_not_enabled(tmp_path):
+    cell = Cell(
+        name="test",
+        role="test",
+        cwd=tmp_path,
+        schema_version="v1",
+        session_id=None,
+        starter_prompt_path=None,
+        provider="claude",
+        sandbox=None,
+        lineage=None,
+        source_path=None,
+        assisted_memory={"enabled": False, "interval_min": 15},
+        extra={},
+    )
+    assert perform_restore(cell) is None
+
+def test_perform_restore_absent(tmp_path):
+    cell = Cell(
+        name="test",
+        role="test",
+        cwd=tmp_path,
+        schema_version="v1",
+        session_id=None,
+        starter_prompt_path=None,
+        provider="claude",
+        sandbox=None,
+        lineage=None,
+        source_path=None,
+        assisted_memory=None,
+        extra={},
+    )
+    assert perform_restore(cell) is None
+
+def test_perform_restore_returns_none_on_pull_failure(tmp_path):
+    cell = Cell(
+        name="test", role="test", cwd=tmp_path, schema_version="v1", session_id=None,
+        starter_prompt_path=None, provider="claude", sandbox=None, lineage=None,
+        source_path=None, assisted_memory={"enabled": True, "repo": "test/repo"}, extra={},
+    )
+    with patch("swarph_cli.commands.memory_sync.get_memory_repo_path", return_value=tmp_path):
+        with patch("swarph_cli.commands.memory_sync._clone_if_missing", return_value=True):
+            with patch("subprocess.run", side_effect=subprocess.CalledProcessError(1, "git pull")):
+                assert perform_restore(cell) is None
+
+def test_perform_restore_empty_guard(tmp_path):
+    repo_dir = tmp_path / "repo"
+    repo_dir.mkdir()
+    (repo_dir / "CLAUDE.md").write_text("")
+    (repo_dir / "CURRENT_TASK.md").write_text("Hello")
+    
+    cell_dir = tmp_path / "cell"
+    cell_dir.mkdir()
+    (cell_dir / "CLAUDE.md").write_text("Old contents")
+    
+    cell = Cell(
+        name="test", role="test", cwd=cell_dir, schema_version="v1", session_id=None,
+        starter_prompt_path=None, provider="claude", sandbox=None, lineage=None,
+        source_path=None, assisted_memory={"enabled": True, "repo": "test/repo"}, extra={},
+    )
+    with patch("swarph_cli.commands.memory_sync.get_memory_repo_path", return_value=repo_dir):
+        with patch("swarph_cli.commands.memory_sync._clone_if_missing", return_value=True):
+            with patch("subprocess.run"):
+                res = perform_restore(cell)
+                assert res == "Hello"
+                assert (cell_dir / "CLAUDE.md").read_text() == "Old contents"
+                assert (cell_dir / "CURRENT_TASK.md").read_text() == "Hello"

{swarph_cli-0.9.2 → swarph_cli-0.9.4}/tests/test_mesh_command.py

@@ -68,6 +68,27 @@ def test_mesh_send_gateway_error_is_nonsecret(monkeypatch, capsys):
     assert "secret-token" not in err
 
 
+def test_mesh_gateway_error_without_detail_does_not_echo_payload(monkeypatch, capsys):
+    monkeypatch.setenv("SWARPH_SELF", "gpt-ops")
+    monkeypatch.setenv("MESH_GATEWAY_TOKEN", "secret-token")
+    monkeypatch.setattr(
+        mesh,
+        "_post_json",
+        lambda url, body, token, *, timeout=10.0: (
+            403,
+            {"authorization": "secret-token", "body": {"peer_token": "minted-secret"}},
+        ),
+    )
+
+    rc = mesh.run_mesh(["send", "lab-ovh", "--kind", "answer", "--content", "x"])
+
+    assert rc == 1
+    err = capsys.readouterr().err
+    assert "<gateway error>" in err
+    assert "secret-token" not in err
+    assert "minted-secret" not in err
+
+
 def test_mesh_inbox_uses_to_query_and_unread(monkeypatch, capsys):
     monkeypatch.setenv("SWARPH_SELF", "gpt-ops")
     monkeypatch.setenv("MESH_GATEWAY_TOKEN", "tok")

{swarph_cli-0.9.2 → swarph_cli-0.9.4}/tests/test_mesh_sidecar.py

@@ -116,7 +116,7 @@ def test_sidecar_filters_old_and_self_messages(tmp_path, monkeypatch):
     assert json.loads(log_lines[0])["id"] == 12
 
 
-def test_sidecar_idle_guard_suppresses_repeated_wake_but_advances_cursor(
+def test_sidecar_idle_guard_suppresses_wake_without_advancing_cursor(
     tmp_path, monkeypatch, capsys
 ):
     state = _state(tmp_path)
@@ -132,12 +132,51 @@ def test_sidecar_idle_guard_suppresses_repeated_wake_but_advances_cursor(
     monkeypatch.setattr(mesh, "_tmux_wake", lambda target: (_ for _ in ()).throw(AssertionError("guarded")))
     monkeypatch.setattr(mesh.time, "time", lambda: 1000.0)
     mesh._sidecar_iteration(state)
-    assert state.cursor["last_msg_id"] == 1
+    assert state.cursor["last_msg_id"] == 0
     assert state.cursor["last_wake_at"] == 995.0
     assert state.wakes_sent == 0
+    assert not (tmp_path / "cursor.json").exists()
     assert "wake suppressed" in capsys.readouterr().out
 
 
+def test_sidecar_wakes_throttled_message_after_guard_window(tmp_path, monkeypatch):
+    state = _state(tmp_path)
+    state.cursor["last_wake_at"] = 995.0
+    now = 1000.0
+
+    monkeypatch.setattr(
+        mesh,
+        "_http_get_json",
+        lambda url, token, *, timeout=10.0: (
+            200,
+            {"messages": [{"id": 1, "from_node": "lab-ovh", "content": "new"}]},
+        ),
+    )
+    wakes = []
+    monkeypatch.setattr(mesh, "_tmux_wake", lambda target: wakes.append(target) or True)
+    monkeypatch.setattr(mesh.time, "time", lambda: now)
+
+    mesh._sidecar_iteration(state)
+    assert wakes == []
+    assert state.cursor["last_msg_id"] == 0
+
+    now = 1060.0
+    mesh._sidecar_iteration(state)
+    assert wakes == ["gpt-ops-pane"]
+    assert state.cursor["last_msg_id"] == 1
+    assert state.cursor["last_wake_at"] == 1060.0
+
+
+def test_sidecar_corrupt_cursor_defaults_without_crashing(tmp_path, capsys):
+    (tmp_path / "cursor.json").write_text("{", encoding="utf-8")
+
+    state = _state(tmp_path)
+
+    assert state.cursor["last_msg_id"] == 0
+    assert state.cursor["last_wake_at"] == 0.0
+    assert "ignoring unreadable cursor" in capsys.readouterr().err
+
+
 def test_sidecar_network_failure_records_disconnect(tmp_path, monkeypatch):
     state = _state(tmp_path)
     monkeypatch.setattr(

{swarph_cli-0.9.2 → swarph_cli-0.9.4}/tests/test_spawn_command.py

@@ -459,7 +459,7 @@ def test_run_spawn_new_instance_with_base_mints_sibling_slot(
 ):
     """v0.7 PR-B — `--new-instance` with base sidecar present allocates
     slot 2 AND persists. Sibling resumable via `swarph spawn <role>-2`."""
-    from swarph_cli.cell import session_state_path
+    from swarph_cli.cell import session_state_path, _read_session_sidecar
 
     # First spawn establishes base slot
     run_spawn(argv=[str(fake_cell_yaml), "--dry-run", "--print-id"])
@@ -474,8 +474,8 @@ def test_run_spawn_new_instance_with_base_mints_sibling_slot(
 
     base_sidecar = session_state_path("lab-test")
     sibling_sidecar = session_state_path("lab-test-2")
-    assert base_sidecar.read_text().strip() == base_uuid
-    assert sibling_sidecar.read_text().strip() == sibling_uuid
+    assert _read_session_sidecar(base_sidecar)[0] == base_uuid
+    assert _read_session_sidecar(sibling_sidecar)[0] == sibling_uuid
 
     # Dry-run output shows the sibling slot label
     assert "lab-test-2" in captured.err
@@ -970,3 +970,45 @@ def test_run_spawn_antigravity_dry_run(tmp_path, isolated_xdg, capsys):
     captured = capsys.readouterr()
     assert "agy --sandbox --add-dir" in captured.out
     assert "provider:    antigravity" in captured.err
+
+def test_run_spawn_codex_assisted_memory_injects_agents_md(tmp_path, isolated_xdg, capsys, monkeypatch):
+    from swarph_cli.commands.spawn import run_spawn
+    import yaml
+    
+    payload = {
+        "schema_version": "v1",
+        "name": "codex-test",
+        "role": "codex-test",
+        "cwd": str(tmp_path),
+        "provider": "codex",
+        "assisted_memory": {
+            "enabled": True,
+            "repo": "test-repo"
+        }
+    }
+    p = tmp_path / "cell.yaml"
+    p.write_text(yaml.safe_dump(payload), encoding="utf-8")
+
+    import os
+    os.chdir(tmp_path)
+    
+    import swarph_cli.commands.memory_sync
+    monkeypatch.setattr(swarph_cli.commands.memory_sync, "perform_restore", lambda c: "Restore Task text")
+    monkeypatch.setattr("shutil.which", lambda name: "/bin/fake-codex")
+    
+    exec_args = []
+    def fake_execve(path, argv, env):
+        exec_args.append((path, argv, env))
+    monkeypatch.setattr("os.execve", fake_execve)
+    
+    run_spawn([])
+    
+    agents_md = tmp_path / "AGENTS.md"
+    assert agents_md.exists()
+    content = agents_md.read_text(encoding="utf-8")
+    assert "Your active task is in CURRENT_TASK.md" in content
+    assert "Restore Task text" in content
+    
+    assert len(exec_args) == 1
+    argv = exec_args[0][1]
+    assert "--prompt-interactive" not in argv

swarph_cli-0.9.2/tests/test_memory_sync.py

@@ -1,57 +0,0 @@
-import pytest
-from unittest.mock import patch, MagicMock
-from pathlib import Path
-from swarph_cli.commands.memory_sync import run_memory_sync, perform_restore
-from swarph_cli.cell import Cell
-
-def test_run_memory_sync_no_op_when_not_enabled(tmp_path):
-    cell = Cell(
-        name="test",
-        role="test",
-        cwd=tmp_path,
-        schema_version="v1",
-        session_id=None,
-        starter_prompt_path=None,
-        provider="claude",
-        sandbox=None,
-        lineage=None,
-        source_path=None,
-        assisted_memory={"enabled": False, "interval_min": 15},
-        extra={},
-    )
-    with patch("swarph_cli.commands.memory_sync.load_cell", return_value=cell):
-        assert run_memory_sync(["fake.yaml"]) == 0
-
-def test_perform_restore_returns_none_when_not_enabled(tmp_path):
-    cell = Cell(
-        name="test",
-        role="test",
-        cwd=tmp_path,
-        schema_version="v1",
-        session_id=None,
-        starter_prompt_path=None,
-        provider="claude",
-        sandbox=None,
-        lineage=None,
-        source_path=None,
-        assisted_memory={"enabled": False, "interval_min": 15},
-        extra={},
-    )
-    assert perform_restore(cell) is None
-
-def test_perform_restore_absent(tmp_path):
-    cell = Cell(
-        name="test",
-        role="test",
-        cwd=tmp_path,
-        schema_version="v1",
-        session_id=None,
-        starter_prompt_path=None,
-        provider="claude",
-        sandbox=None,
-        lineage=None,
-        source_path=None,
-        assisted_memory=None,
-        extra={},
-    )
-    assert perform_restore(cell) is None