swarph-cli 0.9.1__tar.gz → 0.9.3__tar.gz

{swarph_cli-0.9.1/src/swarph_cli.egg-info → swarph_cli-0.9.3}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.9.1
-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.1 hardens the membrane billing-scrub + import path-traversal + watchdog session-scoping (adversarial-sweep).
+Version: 0.9.3
+Summary: The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider spawn (claude/codex/antigravity per cell.provider via a ProviderMembrane), `swarph init` (interactive cell.yaml scaffolder), `swarph mesh` (send/inbox/register) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.3 adds `swarph init` + hardens assisted_memory restore (fail-closed pull, empty-guards, codex AGENTS.md) and the mesh sidecar (no DM-loss on idle-guard).
 Author: Pierre Samson, Claude Opus
 License: MIT
 Project-URL: Homepage, https://github.com/darw007d/swarph-cli

{swarph_cli-0.9.1 → swarph_cli-0.9.3}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.9.1"
-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.1 hardens the membrane billing-scrub + import path-traversal + watchdog session-scoping (adversarial-sweep)."
+version = "0.9.3"
+description = "The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider spawn (claude/codex/antigravity per cell.provider via a ProviderMembrane), `swarph init` (interactive cell.yaml scaffolder), `swarph mesh` (send/inbox/register) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.3 adds `swarph init` + hardens assisted_memory restore (fail-closed pull, empty-guards, codex AGENTS.md) and the mesh sidecar (no DM-loss on idle-guard)."
 readme = "README.md"
 license = { text = "MIT" }
 requires-python = ">=3.10"

{swarph_cli-0.9.1 → swarph_cli-0.9.3}/src/swarph_cli/__init__.py

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

swarph_cli-0.9.3/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.1 → swarph_cli-0.9.3}/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.1 → swarph_cli-0.9.3}/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.1 → swarph_cli-0.9.3}/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.1 → swarph_cli-0.9.3}/src/swarph_cli/commands/watchdog.py

@@ -393,10 +393,24 @@ def _process_alive(tmux_session: str) -> bool:
             capture_output=True, text=True, timeout=5,
         )
         if panes.returncode != 0:
-            return False  # session has no panes / doesn't exist → not alive
+            # list-panes fails for TWO very different reasons:
+            #   (a) the tmux server is reachable but this session is genuinely
+            #       gone → really dead → False (let A2 fire).
+            #   (b) there is no tmux server reachable from THIS uid (e.g. the
+            #       watchdog runs as root while sessions live under ubuntu's
+            #       /tmp/tmux-1000 socket) → we simply CAN'T determine liveness
+            #       via tmux → must NOT false-fire A2.
+            # Distinguish by probing the server itself.
+            server = subprocess.run(
+                ["tmux", "list-sessions"],
+                capture_output=True, text=True, timeout=5,
+            )
+            if server.returncode != 0:
+                return True  # no reachable tmux server here → can't tell → assume alive
+            return False     # server reachable, session absent → genuinely dead
         pane_pids = {int(p) for p in panes.stdout.split() if p.strip().isdigit()}
         if not pane_pids:
-            return False
+            return True  # ambiguous (session with no pane pids) → don't false-fire
 
         pg = subprocess.run(
             ["pgrep", "-f", "claude"],
@@ -434,34 +448,39 @@ def _tmux_send_keys(name: str, text: str) -> bool:
 
 
 def _pane_activity_age_sec(name: str) -> Optional[int]:
-    """Age in seconds since the tmux pane's last activity event.
-
-    Reads tmux's `#{pane_activity}` format variable, which returns a unix
-    epoch timestamp of the most recent activity in the active pane of the
-    target session. Returns None if tmux is missing, the session doesn't
-    exist, or tmux's output isn't parseable as an integer epoch.
-
-    Used by F3 (mother #1087 / drop-on-meta-edge proposal) as a third
-    AND-gate input to distinguish (a) session genuinely stalled from (b)
-    session actively working in a long bash block. cursor-mtime alone
-    measures "time since last turn-end" not "time since last activity";
-    pane_activity covers the mid-turn-active case.
-
-    Returns None on detection error so the caller can fall through to
-    the legacy AND-gate behavior — F3 is a strengthening of the gate,
-    not a replacement of it.
+    """Age in seconds since the target session's most recent tmux activity.
+
+    Reads tmux activity-timestamp format vars and uses the MOST RECENT
+    (max epoch) across pane / window / session. ``#{pane_activity}`` is only
+    populated when monitor-activity is on (empty on a default tmux 3.x), so
+    relying on it alone made F3 a no-op — it returned None and never
+    suppressed A1 for a genuinely-active session (adversarial-deploy finding
+    2026-06-02). ``#{window_activity}`` / ``#{session_activity}`` are tracked
+    unconditionally and give the same "is this session alive right now" signal.
+
+    Used by F3 (mother #1087) as a third AND-gate input to distinguish (a) a
+    session genuinely stalled from (b) one actively working in a long bash
+    block where cursor-mtime (last turn-end) is stale but the session is alive.
+
+    Returns None only when NO activity timestamp is parseable (tmux missing /
+    session absent), so the caller falls through to the legacy AND-gate.
     """
     try:
         result = subprocess.run(
-            ["tmux", "display", "-p", "-t", name, "#{pane_activity}"],
+            ["tmux", "display", "-p", "-t", name,
+             "#{pane_activity}|#{window_activity}|#{session_activity}"],
             capture_output=True, text=True, timeout=5,
         )
         if result.returncode != 0:
             return None
-        out = result.stdout.strip()
-        if not out:
+        epochs = []
+        for tok in result.stdout.strip().split("|"):
+            tok = tok.strip()
+            if tok.isdigit():
+                epochs.append(int(tok))
+        if not epochs:
             return None
-        return max(0, _now() - int(out))
+        return max(0, _now() - max(epochs))
     except (subprocess.TimeoutExpired, FileNotFoundError, OSError, ValueError):
         return None
 

{swarph_cli-0.9.1 → swarph_cli-0.9.3}/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.1 → swarph_cli-0.9.3/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.9.1
-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.1 hardens the membrane billing-scrub + import path-traversal + watchdog session-scoping (adversarial-sweep).
+Version: 0.9.3
+Summary: The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider spawn (claude/codex/antigravity per cell.provider via a ProviderMembrane), `swarph init` (interactive cell.yaml scaffolder), `swarph mesh` (send/inbox/register) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.3 adds `swarph init` + hardens assisted_memory restore (fail-closed pull, empty-guards, codex AGENTS.md) and the mesh sidecar (no DM-loss on idle-guard).
 Author: Pierre Samson, Claude Opus
 License: MIT
 Project-URL: Homepage, https://github.com/darw007d/swarph-cli

{swarph_cli-0.9.1 → swarph_cli-0.9.3}/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.3/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.3/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.1 → swarph_cli-0.9.3}/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.1 → swarph_cli-0.9.3}/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.1 → swarph_cli-0.9.3}/tests/test_spawn_command.py

@@ -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.1 → swarph_cli-0.9.3}/tests/test_watchdog.py

@@ -132,6 +132,7 @@ def test_stale_cursor_alive_process_unread_dms_fires_a1(
     with patch("swarph_cli.commands.watchdog._process_alive", return_value=True), \
          patch("swarph_cli.commands.watchdog._gateway_unread_count", return_value=3), \
          patch("swarph_cli.commands.watchdog._tmux_session_exists", return_value=True), \
+         patch("swarph_cli.commands.watchdog._pane_activity_age_sec", return_value=None), \
          patch("swarph_cli.commands.watchdog._tmux_send_keys", return_value=True) as send_mock:
         rc = run_watchdog(argv=[
             "--check", "--cell", "lab",
@@ -279,6 +280,7 @@ def test_a1_fires_at_most_once_per_stale_window(
     with patch("swarph_cli.commands.watchdog._process_alive", return_value=True), \
          patch("swarph_cli.commands.watchdog._gateway_unread_count", return_value=3), \
          patch("swarph_cli.commands.watchdog._tmux_session_exists", return_value=True), \
+         patch("swarph_cli.commands.watchdog._pane_activity_age_sec", return_value=None), \
          patch("swarph_cli.commands.watchdog._tmux_send_keys", return_value=True) as send_mock:
         # First invocation — A1 fires
         rc1 = run_watchdog(argv=[
@@ -322,6 +324,7 @@ def test_a1_rearms_after_cursor_advance(
     with patch("swarph_cli.commands.watchdog._process_alive", return_value=True), \
          patch("swarph_cli.commands.watchdog._gateway_unread_count", return_value=2), \
          patch("swarph_cli.commands.watchdog._tmux_session_exists", return_value=True), \
+         patch("swarph_cli.commands.watchdog._pane_activity_age_sec", return_value=None), \
          patch("swarph_cli.commands.watchdog._tmux_send_keys", return_value=True) as send_mock:
         # First A1 fires
         run_watchdog(argv=[
@@ -482,6 +485,7 @@ def test_a2_escalation_clears_a1_marker(
     with patch("swarph_cli.commands.watchdog._process_alive", return_value=True), \
          patch("swarph_cli.commands.watchdog._gateway_unread_count", return_value=5), \
          patch("swarph_cli.commands.watchdog._tmux_session_exists", return_value=True), \
+         patch("swarph_cli.commands.watchdog._pane_activity_age_sec", return_value=None), \
          patch("swarph_cli.commands.watchdog._tmux_send_keys", return_value=True):
         # First fire — record marker
         run_watchdog(argv=[
@@ -728,10 +732,13 @@ class _R:
         self.stdout = stdout
 
 
-def _fake_run_factory(tmux_rc, tmux_out, pgrep_rc, pgrep_out):
+def _fake_run_factory(panes_rc, panes_out, pgrep_rc, pgrep_out, sessions_rc=0):
+    """Mock subprocess.run distinguishing tmux list-panes vs list-sessions."""
     def fake_run(cmd, **kw):
-        if cmd[0] == "tmux":
-            return _R(tmux_rc, tmux_out)
+        if cmd[0] == "tmux" and cmd[1] == "list-panes":
+            return _R(panes_rc, panes_out)
+        if cmd[0] == "tmux" and cmd[1] == "list-sessions":
+            return _R(sessions_rc, "" if sessions_rc else "lab: 1 windows\n")
         if cmd[0] == "pgrep":
             return _R(pgrep_rc, pgrep_out)
         return _R(1, "")
@@ -761,14 +768,56 @@ def test_process_alive_true_when_claude_under_session(monkeypatch):
     assert _wd._process_alive("mysess") is True
 
 
-def test_process_alive_false_when_session_absent(monkeypatch):
-    """tmux has no such session → not alive (don't fall through to host-wide)."""
+def test_process_alive_false_when_session_absent_but_server_up(monkeypatch):
+    """Server reachable + this session genuinely gone → dead (A2 may fire)."""
     monkeypatch.setattr(_wd.subprocess, "run",
-                        _fake_run_factory(1, "", 0, "2000\n"))
+                        _fake_run_factory(1, "", 0, "2000\n", sessions_rc=0))
     assert _wd._process_alive("ghost") is False
 
 
+def test_process_alive_assumes_alive_when_no_tmux_server(monkeypatch):
+    """Regression (deploy 2026-06-02): the watchdog runs as ROOT, whose tmux
+    socket is empty — list-panes AND list-sessions both fail. We CANNOT
+    determine liveness via tmux, so must assume alive, NOT false-fire an A2
+    respawn of a session that's actually alive under ubuntu's tmux."""
+    monkeypatch.setattr(_wd.subprocess, "run",
+                        _fake_run_factory(1, "", 0, "2000\n", sessions_rc=1))
+    assert _wd._process_alive("lab") is True
+
+
 def test_process_alive_false_when_no_claude_anywhere(monkeypatch):
     monkeypatch.setattr(_wd.subprocess, "run",
                         _fake_run_factory(0, "1000\n", 1, ""))
     assert _wd._process_alive("mysess") is False
+
+
+# ---------------------------------------------------------------------------
+# _pane_activity_age_sec — fallback across pane/window/session (F3 fix 2026-06-02)
+# ---------------------------------------------------------------------------
+
+
+def test_pane_activity_age_falls_back_when_pane_empty(monkeypatch):
+    """pane_activity is empty without monitor-activity (tmux 3.x). F3 must fall
+    back to window/session activity, NOT return None — returning None made F3 a
+    no-op and let A1 fire against a genuinely-active session."""
+    recent = _wd._now() - 30
+    monkeypatch.setattr(_wd.subprocess, "run",
+                        lambda cmd, **kw: _R(0, f"|{recent}|{recent - 5}\n"))
+    age = _wd._pane_activity_age_sec("lab")
+    assert age is not None
+    assert 25 <= age <= 40  # ~30s, allowing for execution slack
+
+
+def test_pane_activity_age_none_when_all_blank(monkeypatch):
+    monkeypatch.setattr(_wd.subprocess, "run", lambda cmd, **kw: _R(0, "||\n"))
+    assert _wd._pane_activity_age_sec("lab") is None
+
+
+def test_pane_activity_age_takes_most_recent(monkeypatch):
+    """Uses the MAX (most recent) epoch across the three vars."""
+    now = _wd._now()
+    # pane empty, window 500s ago, session 10s ago → most recent = 10s
+    monkeypatch.setattr(_wd.subprocess, "run",
+                        lambda cmd, **kw: _R(0, f"|{now - 500}|{now - 10}\n"))
+    age = _wd._pane_activity_age_sec("lab")
+    assert age is not None and age <= 20

swarph_cli-0.9.1/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