nmem-cli 0.9.0__tar.gz → 0.9.3__tar.gz

{nmem_cli-0.9.0 → nmem_cli-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nmem-cli
-Version: 0.9.0
+Version: 0.9.3
 Summary: CLI and TUI for Nowledge Mem - AI memory management
 Project-URL: Homepage, https://mem.nowledge.co/
 Project-URL: Repository, https://github.com/nowledge-co/
@@ -119,6 +119,9 @@ nmem t
 | `nmem t save --from claude-code` | Save Claude Code session as thread |
 | `nmem t save --from codex` | Save Codex session as thread |
 | `nmem t save --from gemini-cli` | Save Gemini CLI session as thread |
+| `nmem t sync --from codex --all-projects` | Preview historical Codex sessions across projects |
+| `nmem t sync --from pi` | Preview historical Pi sessions |
+| `nmem t sync --from pi --apply` | Import historical Pi sessions |
 | `nmem t delete <id>` | Delete a thread |
 | `nmem t delete <id> --dry-run` | Preview what would be deleted |
 
@@ -347,7 +350,7 @@ nmem t append openclaw-session-abc123 \
 
 ### Saving AI Coding Sessions
 
-Import conversations from Claude Code, Codex, or Gemini CLI as threads:
+Import conversations from Claude Code, Codex, Gemini CLI, OpenCode, or Pi as threads:
 
 ```bash
 # Save current Claude Code session (uses current directory)
@@ -364,6 +367,16 @@ nmem t save --from codex -s "Implemented auth feature"
 
 # Save Gemini CLI session from the current project
 nmem t save --from gemini-cli
+
+# Preview older Pi sessions, then import them
+nmem t sync --from pi
+nmem t sync --from pi --apply
+
+# Preview older sessions across all projects for hosts with project-scoped storage
+nmem t sync --from codex --all-projects --limit 20
+nmem t sync --from claude-code --all-projects --limit 20
+nmem t sync --from gemini-cli --all-projects --limit 20
+nmem t sync --from opencode --all-projects --limit 20
 ```
 
 How it works:
@@ -372,21 +385,29 @@ How it works:
 - it parses those transcripts into normalized thread messages
 - it then uploads the resulting thread data to your configured Mem server
 
-By default, Claude Code and Codex are discovered from `~/.claude` and `~/.codex`. If you keep them somewhere else, `nmem` also respects `CLAUDE_CONFIG_DIR` and `CODEX_HOME` automatically.
+By default, Claude Code, Codex, and Pi are discovered from `~/.claude`, `~/.codex`, and `~/.pi/agent`. If you keep them somewhere else, `nmem` also respects `CLAUDE_CONFIG_DIR`, `CODEX_HOME`, `PI_CODING_AGENT_DIR`, and `PI_CODING_AGENT_SESSION_DIR` automatically.
 
 That means `nmem t save --from ...` works correctly with remote Mem too: the server does not need direct access to those local agent directories on your laptop.
 
 Options:
-- `--from`: Source app (`claude-code`, `codex`, or `gemini-cli`) - required
+- `--from`: Source app (`claude-code`, `codex`, `gemini-cli`, `opencode`, or `pi`) - required
 - `-p, --project`: Project directory (default: current dir)
 - `-m, --mode`: `current` (latest session) or `all` (all sessions)
 - `-s, --summary`: Brief session summary
 - `--session-id`: Specific session ID
 - `--truncate`: Truncate large tool results (>10KB)
 
-Re-running the command appends new messages with deduplication.
+Use `nmem t sync --from ...` for deliberate historical backfills. It previews by default and requires `--apply` before writing. For Pi, `sync` scans all Pi sessions by default; pass `--session-dir` or `--project` to narrow it. For Claude Code, Codex, Gemini CLI, and OpenCode, the default stays scoped to the current project; add `--all-projects` when you intentionally want a broader import.
+
+Re-running the command is safe. Each discovered session is processed independently. If a previous run stopped halfway through a batch, or created a thread but stopped before the batch finished, the next run detects the existing thread and appends with deduplication. If another process creates the thread between the existence check and the create request, the command falls through to the same deduplicated append path. Stable thread IDs, stable per-message `external_id`s, and an idempotency key keep repeated imports from duplicating messages.
+
+This import path is distinct from desktop auto-sync and watcher-based ingestion:
+
+- desktop auto-sync watches transcript files on the same machine as the Mem server
+- plugin hooks and `nmem t save` / `nmem t sync` run on the machine where the agent is running, then upload to local or remote Mem through the same client config
+- all paths use the same canonical source and thread IDs, so rerunning a hook, desktop watcher, or historical sync appends to the same thread instead of creating duplicates
 
-This import path is distinct from desktop auto-sync and watcher-based ingestion. File watching remains a local server-side capability; explicit CLI save is a client-side capture path.
+Use the client-side path for remote Mem. A remote Mem server cannot scan your laptop's `~/.codex`, `~/.claude`, `~/.gemini`, `~/.pi`, or OpenCode session database by itself.
 
 ## Related
 

{nmem_cli-0.9.0 → nmem_cli-0.9.3}/README.md

@@ -86,6 +86,9 @@ nmem t
 | `nmem t save --from claude-code` | Save Claude Code session as thread |
 | `nmem t save --from codex` | Save Codex session as thread |
 | `nmem t save --from gemini-cli` | Save Gemini CLI session as thread |
+| `nmem t sync --from codex --all-projects` | Preview historical Codex sessions across projects |
+| `nmem t sync --from pi` | Preview historical Pi sessions |
+| `nmem t sync --from pi --apply` | Import historical Pi sessions |
 | `nmem t delete <id>` | Delete a thread |
 | `nmem t delete <id> --dry-run` | Preview what would be deleted |
 
@@ -314,7 +317,7 @@ nmem t append openclaw-session-abc123 \
 
 ### Saving AI Coding Sessions
 
-Import conversations from Claude Code, Codex, or Gemini CLI as threads:
+Import conversations from Claude Code, Codex, Gemini CLI, OpenCode, or Pi as threads:
 
 ```bash
 # Save current Claude Code session (uses current directory)
@@ -331,6 +334,16 @@ nmem t save --from codex -s "Implemented auth feature"
 
 # Save Gemini CLI session from the current project
 nmem t save --from gemini-cli
+
+# Preview older Pi sessions, then import them
+nmem t sync --from pi
+nmem t sync --from pi --apply
+
+# Preview older sessions across all projects for hosts with project-scoped storage
+nmem t sync --from codex --all-projects --limit 20
+nmem t sync --from claude-code --all-projects --limit 20
+nmem t sync --from gemini-cli --all-projects --limit 20
+nmem t sync --from opencode --all-projects --limit 20
 ```
 
 How it works:
@@ -339,21 +352,29 @@ How it works:
 - it parses those transcripts into normalized thread messages
 - it then uploads the resulting thread data to your configured Mem server
 
-By default, Claude Code and Codex are discovered from `~/.claude` and `~/.codex`. If you keep them somewhere else, `nmem` also respects `CLAUDE_CONFIG_DIR` and `CODEX_HOME` automatically.
+By default, Claude Code, Codex, and Pi are discovered from `~/.claude`, `~/.codex`, and `~/.pi/agent`. If you keep them somewhere else, `nmem` also respects `CLAUDE_CONFIG_DIR`, `CODEX_HOME`, `PI_CODING_AGENT_DIR`, and `PI_CODING_AGENT_SESSION_DIR` automatically.
 
 That means `nmem t save --from ...` works correctly with remote Mem too: the server does not need direct access to those local agent directories on your laptop.
 
 Options:
-- `--from`: Source app (`claude-code`, `codex`, or `gemini-cli`) - required
+- `--from`: Source app (`claude-code`, `codex`, `gemini-cli`, `opencode`, or `pi`) - required
 - `-p, --project`: Project directory (default: current dir)
 - `-m, --mode`: `current` (latest session) or `all` (all sessions)
 - `-s, --summary`: Brief session summary
 - `--session-id`: Specific session ID
 - `--truncate`: Truncate large tool results (>10KB)
 
-Re-running the command appends new messages with deduplication.
+Use `nmem t sync --from ...` for deliberate historical backfills. It previews by default and requires `--apply` before writing. For Pi, `sync` scans all Pi sessions by default; pass `--session-dir` or `--project` to narrow it. For Claude Code, Codex, Gemini CLI, and OpenCode, the default stays scoped to the current project; add `--all-projects` when you intentionally want a broader import.
+
+Re-running the command is safe. Each discovered session is processed independently. If a previous run stopped halfway through a batch, or created a thread but stopped before the batch finished, the next run detects the existing thread and appends with deduplication. If another process creates the thread between the existence check and the create request, the command falls through to the same deduplicated append path. Stable thread IDs, stable per-message `external_id`s, and an idempotency key keep repeated imports from duplicating messages.
+
+This import path is distinct from desktop auto-sync and watcher-based ingestion:
+
+- desktop auto-sync watches transcript files on the same machine as the Mem server
+- plugin hooks and `nmem t save` / `nmem t sync` run on the machine where the agent is running, then upload to local or remote Mem through the same client config
+- all paths use the same canonical source and thread IDs, so rerunning a hook, desktop watcher, or historical sync appends to the same thread instead of creating duplicates
 
-This import path is distinct from desktop auto-sync and watcher-based ingestion. File watching remains a local server-side capability; explicit CLI save is a client-side capture path.
+Use the client-side path for remote Mem. A remote Mem server cannot scan your laptop's `~/.codex`, `~/.claude`, `~/.gemini`, `~/.pi`, or OpenCode session database by itself.
 
 ## Related
 

{nmem_cli-0.9.0 → nmem_cli-0.9.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nmem-cli"
-version = "0.9.0"
+version = "0.9.3"
 description = "CLI and TUI for Nowledge Mem - AI memory management"
 authors = [
     {name = "Nowledge Labs"}

{nmem_cli-0.9.0 → nmem_cli-0.9.3}/src/nmem_cli/__init__.py

@@ -20,7 +20,7 @@ Environment (overrides config file):
     NMEM_API_KEY         Optional API key (Bearer auth)
 """
 
-__version__ = "0.9.0"
+__version__ = "0.9.3"
 __author__ = "Nowledge Labs"
 
 from .cli import main

{nmem_cli-0.9.0 → nmem_cli-0.9.3}/src/nmem_cli/cli.py

@@ -52,7 +52,13 @@ from .memory_relations_cli import (
     handle_memory_relation_command,
     register_memory_relation_parser,
 )
-from .session_import import SessionImportError, discover_sessions, parse_session
+from .session_import import (
+    SUPPORTED_SESSION_CLIENTS,
+    SUPPORTED_SESSION_CLIENTS_TEXT,
+    SessionImportError,
+    discover_sessions,
+    parse_session,
+)
 
 try:
     from nowledge_graph_server.utils.app_paths import resolve_config_file_path
@@ -5000,23 +5006,23 @@ def cmd_threads_save(
 ) -> None:
     """Save coding session(s) as conversation thread(s).
 
-    Supports Claude Code, Codex, Gemini CLI, and OpenCode. Auto-detects
+    Supports Claude Code, Codex, Gemini CLI, OpenCode, and Pi. Auto-detects
     sessions from project path.
     """
     # Validate client
-    if client not in ["claude-code", "codex", "gemini-cli", "opencode"]:
+    if client not in SUPPORTED_SESSION_CLIENTS:
         if is_json_mode():
             output_json(
                 {
                     "error": "invalid_client",
-                    "message": "Must be claude-code, codex, gemini-cli, or opencode",
+                    "message": f"Must be one of: {SUPPORTED_SESSION_CLIENTS_TEXT}",
                 }
             )
         else:
             print_error(
                 "Invalid Client",
                 f"'{client}' is not supported",
-                "Use 'claude-code', 'codex', 'gemini-cli', or 'opencode'",
+                f"Use one of: {SUPPORTED_SESSION_CLIENTS_TEXT}",
             )
         sys.exit(1)
 
@@ -5171,6 +5177,339 @@ def cmd_threads_save(
             )
 
 
+def _write_thread_from_session_data(
+    *,
+    thread_data: dict[str, Any],
+    session_id: str,
+    session_file: Path,
+    source_app: str,
+    space_id: str | None,
+    metadata_updates: dict[str, Any] | None = None,
+    idempotency_prefix: str | None = None,
+) -> dict[str, Any]:
+    external_id_keys = (
+        "external_id",
+        "source_message_id",
+        "message_id",
+        "openclaw_entry_id",
+    )
+
+    def message_external_id(message: dict[str, Any]) -> str:
+        for key in external_id_keys:
+            value = message.get(key)
+            if isinstance(value, str) and value.strip():
+                return value.strip()
+        metadata = message.get("metadata")
+        if isinstance(metadata, dict):
+            for key in external_id_keys:
+                value = metadata.get(key)
+                if isinstance(value, str) and value.strip():
+                    return value.strip()
+        return ""
+
+    def messages_with_stable_external_ids(
+        raw_messages: list[dict[str, Any]],
+    ) -> list[dict[str, Any]]:
+        if not idempotency_prefix:
+            return raw_messages
+        stable_batch_key = f"{idempotency_prefix}:{session_id}"
+        normalized: list[dict[str, Any]] = []
+        for index, message in enumerate(raw_messages):
+            if not isinstance(message, dict):
+                continue
+            message_copy = dict(message)
+            metadata = dict(message_copy.get("metadata") or {})
+            if not message_external_id(message_copy):
+                metadata["external_id"] = f"idem:{stable_batch_key}:{index}"
+            message_copy["metadata"] = metadata
+            normalized.append(message_copy)
+        return normalized
+
+    def post_thread_create(payload: dict[str, Any]) -> tuple[int, dict[str, Any]]:
+        """Create a thread without treating an existing thread as fatal.
+
+        Historical sync is intentionally rerunnable. A previous process may
+        have created the thread and then stopped before finishing the batch, or
+        another sync may race between our existence check and create request.
+        In those cases we should append/deduplicate, not fail the whole session.
+        """
+        url = f"{get_api_url()}/threads"
+
+        def response_payload(response: httpx.Response) -> dict[str, Any]:
+            try:
+                parsed = response.json()
+                return parsed if isinstance(parsed, dict) else {"detail": parsed}
+            except Exception:
+                return {"detail": response.text}
+
+        try:
+            response = api_request("POST", url, json=payload, timeout=60.0)
+            parsed = response_payload(response)
+            if response.status_code == 409 or (
+                response.status_code == 422
+                and "exist" in json_module.dumps(parsed).lower()
+            ):
+                return response.status_code, parsed
+            response.raise_for_status()
+            return response.status_code, parsed
+        except httpx.ConnectError:
+            error = {
+                "error": "connection_failed",
+                "message": f"Cannot connect to {get_api_url()}",
+            }
+            if is_json_mode():
+                output_json(error)
+            else:
+                _print_connection_error()
+            sys.exit(1)
+        except httpx.HTTPStatusError as e:
+            error = {"error": "api_error", "status_code": e.response.status_code}
+            try:
+                error["detail"] = e.response.json().get("detail", "")
+            except Exception:
+                pass
+            if is_json_mode():
+                output_json(error)
+            else:
+                print_error(
+                    f"API Error ({e.response.status_code})",
+                    error.get("detail", "Request failed"),
+                )
+            sys.exit(1)
+
+    thread_id = thread_data["thread_id"]
+    messages = messages_with_stable_external_ids(thread_data["messages"])
+    metadata = dict(thread_data.get("metadata") or {})
+    if metadata_updates:
+        metadata.update(metadata_updates)
+
+    existing_params = {"space_id": space_id} if space_id else None
+    existing_thread = api_get_optional(
+        f"/threads/{quote(thread_id, safe='')}",
+        params=existing_params,
+    )
+    if existing_thread is None:
+        payload = {
+            "thread_id": thread_id,
+            "title": thread_data["title"],
+            "messages": messages,
+            "source": thread_data.get("source", source_app),
+            "project": thread_data.get("project"),
+            "workspace": thread_data.get("workspace"),
+            "metadata": metadata,
+        }
+        if space_id:
+            payload["space_id"] = space_id
+        create_status, create_data = post_thread_create(payload)
+        if create_status not in {409, 422}:
+            return {
+                "action": "created",
+                "session_id": session_id,
+                "thread_id": thread_id,
+                "message_count": len(create_data.get("messages", [])) or len(messages),
+                "file": str(session_file),
+            }
+
+    append_payload: dict[str, Any] = {
+        "messages": messages,
+        "deduplicate": True,
+        **({"space_id": space_id} if space_id else {}),
+    }
+    if metadata_updates:
+        append_payload.update(metadata_updates)
+    if idempotency_prefix:
+        append_payload["idempotency_key"] = f"{idempotency_prefix}:{session_id}"
+    append_data = api_post(
+        f"/threads/{quote(thread_id, safe='')}/append",
+        append_payload,
+    )
+    return {
+        "action": "appended",
+        "session_id": session_id,
+        "thread_id": thread_id,
+        "message_count": append_data.get("total_messages", 0),
+        "messages_added": append_data.get("messages_added", 0),
+        "total_messages": append_data.get("total_messages", 0),
+        "file": str(session_file),
+    }
+
+
+def cmd_threads_sync(
+    client: str,
+    project_path: str | None = None,
+    all_projects: bool = False,
+    apply: bool = False,
+    limit: int | None = None,
+    session_id: str | None = None,
+    truncate: bool = False,
+    space_id: str | None = None,
+    source_roots: list[str] | None = None,
+) -> None:
+    """Preview or import historical sessions for a supported local agent host."""
+    if client not in SUPPORTED_SESSION_CLIENTS:
+        data = {
+            "status": "error",
+            "error": "invalid_client",
+            "message": f"Must be one of: {SUPPORTED_SESSION_CLIENTS_TEXT}",
+        }
+        if is_json_mode():
+            output_json(data)
+        else:
+            print_error("Invalid Client", f"'{client}' is not supported", data["message"])
+        sys.exit(1)
+
+    if all_projects and project_path:
+        data = {
+            "status": "error",
+            "error": "conflicting_scope",
+            "message": "Use either --project or --all-projects, not both.",
+        }
+        if is_json_mode():
+            output_json(data)
+        else:
+            print_error("Conflicting Scope", data["message"])
+        sys.exit(1)
+
+    # Pi can safely preview all projects by default. Other clients historically
+    # key discovery by project path, so keep their default scoped to cwd.
+    discovery_path = project_path
+    if all_projects:
+        discovery_path = "__all__"
+    elif discovery_path is None:
+        discovery_path = "*" if client == "pi" else "."
+    resolved_path = (
+        Path(discovery_path).expanduser().absolute()
+        if discovery_path not in {"", "*", "__all__"}
+        else None
+    )
+    if resolved_path is not None and not resolved_path.exists():
+        if is_json_mode():
+            output_json({"error": "path_not_found", "path": str(resolved_path)})
+        else:
+            print_error("Path Not Found", str(resolved_path))
+        sys.exit(1)
+
+    try:
+        sessions = discover_sessions(
+            client,
+            str(resolved_path) if resolved_path is not None else discovery_path,
+            "all",
+            session_id,
+            source_roots=source_roots,
+        )
+    except SessionImportError as exc:
+        data = {
+            "status": "error",
+            "client": client,
+            "project_path": str(resolved_path) if resolved_path is not None else discovery_path,
+            "results": [],
+            "error": exc.error,
+            "hint": exc.hint,
+        }
+        if is_json_mode():
+            output_json(data)
+        else:
+            print_error("Sync Failed", exc.error, exc.hint)
+        sys.exit(1)
+
+    if limit is not None:
+        sessions = sessions[:limit]
+
+    results: list[dict[str, Any]] = []
+    for session in sessions:
+        try:
+            thread_data = parse_session(
+                client,
+                session.file,
+                truncate,
+                session_id=session.session_id,
+            )
+        except Exception as exc:
+            results.append(
+                {
+                    "action": "failed",
+                    "session_id": session.session_id,
+                    "file": str(session.file),
+                    "error": str(exc),
+                }
+            )
+            continue
+
+        preview = {
+            "action": "ready",
+            "session_id": session.session_id,
+            "thread_id": thread_data["thread_id"],
+            "title": thread_data["title"],
+            "message_count": len(thread_data.get("messages") or []),
+            "file": str(session.file),
+            "workspace": thread_data.get("workspace"),
+        }
+        if not apply:
+            results.append(preview)
+            continue
+
+        try:
+            results.append(
+                _write_thread_from_session_data(
+                    thread_data=thread_data,
+                    session_id=session.session_id,
+                    session_file=session.file,
+                    source_app=client,
+                    space_id=space_id,
+                    metadata_updates={
+                        "historical_import": True,
+                        "analysis": "searchable-now-distill-on-demand",
+                        "sync_reason": "history_sync",
+                    },
+                    idempotency_prefix=f"{client}:history",
+                )
+            )
+        except SystemExit:
+            raise
+        except Exception as exc:
+            results.append({**preview, "action": "failed", "error": str(exc)})
+
+    data = {
+        "status": "success",
+        "client": client,
+        "apply": apply,
+        "project_path": str(resolved_path) if resolved_path is not None else discovery_path,
+        "count": len(results),
+        "created": sum(1 for r in results if r.get("action") == "created"),
+        "appended": sum(1 for r in results if r.get("action") == "appended"),
+        "failed": sum(1 for r in results if r.get("action") == "failed"),
+        "results": results,
+    }
+    if is_json_mode():
+        output_json(data)
+        return
+
+    if not apply:
+        console.print(
+            f"[bold]Preview[/bold] — {len(results)} {client} session(s). "
+            "No changes made; re-run with [cyan]--apply[/cyan] to import."
+        )
+        for item in results[:20]:
+            if item.get("action") == "failed":
+                console.print(f"  [red]![/red] {item.get('file')}: {item.get('error')}")
+                continue
+            console.print(
+                f"  [cyan]{item['thread_id']}[/cyan] "
+                f"({item['message_count']} messages) {item.get('title', '')}"
+            )
+        if len(results) > 20:
+            console.print(f"  [dim]... {len(results) - 20} more; use --json for full output[/dim]")
+        return
+
+    if data["failed"]:
+        print_error("Sync Finished With Errors", f"{data['failed']} session(s) failed")
+    else:
+        print_success(
+            "Synced",
+            f"{data['created']} created, {data['appended']} updated",
+        )
+
+
 # ═══════════════════════════════════════════════════════════════════════════════
 # Thread Triage & Distillation Commands
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -10246,13 +10585,14 @@ PRIORITY
         # save - Save coding session as thread
         sv = thr_subs.add_parser(
             "save",
-            help="Save Claude Code, Codex, Gemini CLI, or OpenCode session as thread",
+            help="Save Claude Code, Codex, Gemini CLI, OpenCode, or Pi session as thread",
             parents=[_space_parent],
             epilog="""examples:
   nmem t save --from claude-code
   nmem t save --from claude-code -p /path/to/project -m all
   nmem t save --from codex --session-id sess_abc123
   nmem t save --from opencode -p /path/to/project
+  nmem t save --from pi -p /path/to/project
   nmem t save --from gemini-cli --summary "Refactored auth module" """,
             formatter_class=argparse.RawDescriptionHelpFormatter,
         )
@@ -10260,8 +10600,8 @@ PRIORITY
             "--from",
             dest="source_app",
             required=True,
-            choices=["claude-code", "codex", "gemini-cli", "opencode"],
-            help="Source app: claude-code, codex, gemini-cli, or opencode",
+            choices=list(SUPPORTED_SESSION_CLIENTS),
+            help=f"Source app: {SUPPORTED_SESSION_CLIENTS_TEXT}",
         )
         sv.add_argument(
             "-p",
@@ -10288,6 +10628,58 @@ PRIORITY
             help="Truncate large tool results (>10KB)",
         )
 
+        sync = thr_subs.add_parser(
+            "sync",
+            help="Preview or import historical local agent sessions",
+            parents=[_space_parent],
+            epilog="""examples:
+  nmem t sync --from pi
+  nmem t sync --from pi --apply
+  nmem t sync --from codex --all-projects --limit 20
+  nmem t sync --from pi --session-dir ~/.pi/agent/sessions --limit 20
+  nmem t sync --from codex -p /path/to/project --apply""",
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+        )
+        sync.add_argument(
+            "--from",
+            dest="source_app",
+            required=True,
+            choices=list(SUPPORTED_SESSION_CLIENTS),
+            help=f"Source app: {SUPPORTED_SESSION_CLIENTS_TEXT}",
+        )
+        sync.add_argument(
+            "-p",
+            "--project",
+            default=None,
+            help=(
+                "Project directory path. Defaults to all Pi sessions for Pi, "
+                "and current directory for other clients."
+            ),
+        )
+        sync.add_argument(
+            "--all-projects",
+            action="store_true",
+            help="Scan all discoverable local sessions for this host.",
+        )
+        sync.add_argument(
+            "--apply",
+            action="store_true",
+            help="Import sessions. Without this, only preview what would sync.",
+        )
+        sync.add_argument("--limit", type=int, help="Limit sessions after discovery")
+        sync.add_argument("--session-id", help="Specific session ID")
+        sync.add_argument(
+            "--session-dir",
+            dest="session_dirs",
+            action="append",
+            help="Pi session directory or JSONL file to scan. May be repeated.",
+        )
+        sync.add_argument(
+            "--truncate",
+            action="store_true",
+            help="Truncate large tool results where supported",
+        )
+
         # triage - Check if conversation is worth distilling
         tr = thr_subs.add_parser(
             "triage",
@@ -11429,6 +11821,18 @@ def main() -> int:
                 truncate=getattr(args, "truncate", False),
                 space_id=getattr(args, "space", None),
             )
+        elif action == "sync":
+            cmd_threads_sync(
+                client=args.source_app,
+                project_path=getattr(args, "project", None),
+                all_projects=getattr(args, "all_projects", False),
+                apply=getattr(args, "apply", False),
+                limit=getattr(args, "limit", None),
+                session_id=getattr(args, "session_id", None),
+                truncate=getattr(args, "truncate", False),
+                space_id=getattr(args, "space", None),
+                source_roots=getattr(args, "session_dirs", None),
+            )
         elif action == "triage":
             cmd_threads_triage(
                 thread_id=getattr(args, "thread_id", None),