Expose missing MCP tools for Pinned Slots, Actions, and crystallization (Crystals)

AGENTS.md

@@ -91,6 +91,45 @@ Auth: all endpoints check `AGENTMEMORY_SECRET` via timing-safe `hmac.compare_dig
 
 WebSocket at `/stream/mem-live/viewer` broadcasts raw + compressed observations to connected viewers.
 
+## MCP Tools
+
+The server exposes 30 MCP tools via `GET /agentmemory/mcp/tools` (schema) and `POST /agentmemory/mcp/tools` (execution).
+
+| Tool | Description | Status |
+|------|-------------|--------|
+| `memory_recall` | Search past session observations | Working |
+| `memory_save` | Save long-term memory (concepts/files as string or array) | Working |
+| `memory_sessions` | List recent sessions | Working |
+| `memory_sessions_list` | Retrieve all memory sessions | Working |
+| `memory_smart_search` | Hybrid semantic+keyword search | Working |
+| `memory_timeline` | Chronological observations | Working |
+| `memory_observations` | Get observations for session | Working |
+| `memory_profile` | User/project profile | Working |
+| `memory_lessons` | List saved lessons | Working |
+| `memory_lesson_save` | Save lesson from session | Working |
+| `memory_lesson_recall` | Search lessons by query | Working |
+| `memory_lesson_search` | Search lessons (keywords) | Working |
+| `memory_consolidate` | Summarize sessions, extract memory | Working |
+| `memory_reflect` | Reflect on session, update context | Working |
+| `memory_diagnose` | Health check subsystems | Working |
+| `memory_forget` | Delete memory/session/observations | Working |
+| `memory_export` | Export all data as JSON | Working |
+| `agent_observe` | Log agent execution observation | Working |
+| `agent_remember` | Save agent memory to long-term | Working |
+| `memory_antigravity_sync` | Sync Antigravity transcripts | Working |
+| `memory_slot_list` | List all pinned memory slots | Working |
+| `memory_slot_get` | Retrieve a specific pinned slot | Working |
+| `memory_slot_create` | Create/overwrite pinned slot | Working |
+| `memory_slot_append` | Append text content to slot | Working |
+| `memory_slot_replace` | Replace slot content | Working |
+| `memory_slot_delete` | Delete pinned memory slot | Working |
+| `memory_action_create` | Create a new work item / action | Working |
+| `memory_action_update` | Update fields of existing action | Working |
+| `memory_frontier` | Get active/pending actions | Working |
+| `memory_crystallize` | Summarize session observations | Working |
+
+**MCP stdio wrapper:** `src/mcp_stdio.py` reads `AGENTMEMORY_URL` and `AGENTMEMORY_SECRET` from environment variables dynamically.
+
 ## Consistency rules
 
 **When adding a REST endpoint:**

README.md

@@ -106,7 +106,7 @@ curl -X POST http://localhost:3111/agentmemory/search \
 |---------|--------|-------|
 | REST API — sessions, memories, observations | ✅ | Full surface |
 | WebSocket live stream | ✅ | `/stream/mem-live/viewer` |
-| MCP tools endpoint | ✅ | 16 tools |
+| MCP tools endpoint | ✅ | 30 tools |
 | Built-in HTML viewer | ✅ | Real-time dashboard at `/viewer` |
 | BM25 keyword search | ✅ | Always on, no API key needed |
 | Hybrid BM25 + vector search | ✅ | Requires `GEMINI_API_KEY` |
@@ -171,7 +171,7 @@ Verify with: curl http://localhost:3111/agentmemory/livez
 Open the viewer at: http://localhost:3111/viewer
 ```
 
-### Available MCP Tools (16)
+### Available MCP Tools (30)
 
 | Tool | Description |
 |------|-------------|
@@ -179,18 +179,32 @@ Open the viewer at: http://localhost:3111/viewer
 | `memory_recall` | Search past observations by keyword |
 | `memory_smart_search` | Hybrid BM25 + vector semantic search |
 | `memory_sessions` | List recent sessions |
-| `memory_sessions_list` | Paginated sessions list |
+| `memory_sessions_list` | Retrieve all memory sessions |
 | `memory_timeline` | Chronological observations for a session |
 | `memory_observations` | Observations for a session |
 | `memory_profile` | Per-project concept + file profile |
 | `memory_lessons` | List active lessons with confidence scores |
 | `memory_lesson_save` | Save a lesson (duplicate saves strengthen it) |
-| `memory_lesson_search` | Search lessons semantically |
+| `memory_lesson_recall` | Search lessons by query |
+| `memory_lesson_search` | Search lessons by keywords |
 | `memory_consolidate` | Run 4-tier memory consolidation |
-| `memory_reflect` | Auto-populate slots from session observations |
+| `memory_reflect` | Reflect on session, update context |
 | `memory_diagnose` | Health check across all subsystems |
-| `memory_forget` | Delete an observation or session |
+| `memory_forget` | Delete memory, session, or observations |
 | `memory_export` | Export all memory data as JSON |
+| `agent_observe` | Log agent execution observation |
+| `agent_remember` | Save agent memory to long-term storage |
+| `memory_antigravity_sync` | Sync Antigravity transcripts to memory |
+| `memory_slot_list` | List all pinned memory slots |
+| `memory_slot_get` | Retrieve a specific pinned memory slot |
+| `memory_slot_create` | Create/overwrite a pinned memory slot |
+| `memory_slot_append` | Append text content to a pinned memory slot |
+| `memory_slot_replace` | Replace pinned memory slot content |
+| `memory_slot_delete` | Delete a pinned memory slot |
+| `memory_action_create` | Create a new work item / action |
+| `memory_action_update` | Update fields of an existing action |
+| `memory_frontier` | Get active and pending actions sorted by priority |
+| `memory_crystallize` | Crystallize/summarize observations in a session |
 
 ---
 
@@ -453,7 +467,7 @@ Query
 | Storage | Dolt SQL (git-versioned MySQL) | SQLite WAL (single file) |
 | Engine dependency | iii-engine (separate binary) | None — just Flask |
 | Embeddings | 6 providers + local `@xenova/transformers` | Gemini 768-dim |
-| MCP tools | 53 | 16 |
+| MCP tools | 53 | 30 |
 | REST endpoints | 128 | ~50 |
 | Deploy | npm, Docker, fly.io, Railway, Render | Docker, HuggingFace Spaces |
 | Cold boot | ~7s (iii engine warm-up) | <2s |

plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agentmemory",
   "version": "0.9.27",
-  "description": "Persistent memory for AI coding agents -- captures tool usage, compresses via LLM, injects context into future sessions. 12 hooks, 16 MCP tools, 16 skills, real-time viewer.",
+  "description": "Persistent memory for AI coding agents -- captures tool usage, compresses via LLM, injects context into future sessions. 12 hooks, 30 MCP tools, 16 skills, real-time viewer.",
   "author": {
     "name": "Rohit Ghumare",
     "url": "https://github.com/rohitg00"

plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agentmemory",
   "version": "0.9.27",
-  "description": "Persistent memory for AI coding agents -- captures tool usage, compresses via LLM, injects context into future sessions. 12 hooks, 16 MCP tools, 16 skills, real-time viewer.",
+  "description": "Persistent memory for AI coding agents -- captures tool usage, compresses via LLM, injects context into future sessions. 12 hooks, 30 MCP tools, 16 skills, real-time viewer.",
   "author": {
     "name": "Rohit Ghumare",
     "url": "https://github.com/rohitg00"

plugin/scripts/prompt_submit.py

@@ -7,25 +7,26 @@ from datetime import datetime, timezone
 from hook_utils import resolve_project, is_sdk_child, api_call_bg
 
 def main():
-    try:
-        input_data = sys.stdin.read()
-    except Exception:
-        return
-
-    # Log to file for debugging
+    # Log to file for debugging - write early before any potential errors
     log_path = os.path.expanduser("~/.agentmemory/hook_log.txt")
     try:
         with open(log_path, "a", encoding="utf-8") as f:
             f.write(f"[{datetime.now(timezone.utc).isoformat()}] prompt_submit hook called\n")
-            f.write(f"stdin content: {input_data[:500]}\n")
+            f.write(f"sys.argv: {sys.argv}\n")
     except Exception as e:
         pass
 
     try:
+        input_data = sys.stdin.read()
         if not input_data:
             return
         data = json.loads(input_data)
-    except Exception:
+    except Exception as e:
+        try:
+            with open(log_path, "a", encoding="utf-8") as f:
+                f.write(f"Error parsing stdin: {e}\n")
+        except:
+            pass
         return
 
     if is_sdk_child(data):

src/app.py

@@ -1998,6 +1998,131 @@ def mcp_tools_list():
                 },
                 "required": ["mode"]
             }
+        },
+        {
+            "name": "memory_slot_list",
+            "description": "List all pinned memory slots.",
+            "inputSchema": {"type": "object", "properties": {}}
+        },
+        {
+            "name": "memory_slot_get",
+            "description": "Retrieve the content of a specific pinned memory slot.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "label": {"type": "string", "description": "The label of the pinned slot to fetch"}
+                },
+                "required": ["label"]
+            }
+        },
+        {
+            "name": "memory_slot_create",
+            "description": "Create a new pinned memory slot or overwrite an existing one.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "label": {"type": "string", "description": "The label of the pinned slot"},
+                    "content": {"type": "string", "description": "Initial content for the slot (optional)"},
+                    "scope": {"type": "string", "description": "Scope: global or session (optional, default 'global')"},
+                    "sizeLimit": {"type": "number", "description": "Character limit (optional)"},
+                    "pinned": {"type": "boolean", "description": "Whether pinned to context (optional, default true)"}
+                },
+                "required": ["label"]
+            }
+        },
+        {
+            "name": "memory_slot_append",
+            "description": "Append text content to a pinned memory slot.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "label": {"type": "string", "description": "The label of the pinned slot"},
+                    "text": {"type": "string", "description": "Text to append"}
+                },
+                "required": ["label", "text"]
+            }
+        },
+        {
+            "name": "memory_slot_replace",
+            "description": "Replace the content of a pinned memory slot.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "label": {"type": "string", "description": "The label of the pinned slot"},
+                    "content": {"type": "string", "description": "New content"}
+                },
+                "required": ["label", "content"]
+            }
+        },
+        {
+            "name": "memory_slot_delete",
+            "description": "Delete a pinned memory slot.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "label": {"type": "string", "description": "The label of the pinned slot to delete"}
+                },
+                "required": ["label"]
+            }
+        },
+        {
+            "name": "memory_action_create",
+            "description": "Create a new work item / action.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "title": {"type": "string", "description": "Title of the action"},
+                    "description": {"type": "string", "description": "Detailed description of the action (optional)"},
+                    "priority": {"type": "number", "description": "Priority score, higher is more urgent (optional, default 0)"},
+                    "status": {"type": "string", "description": "Status: pending, active, completed (optional, default 'pending')"},
+                    "tags": {
+                        "oneOf": [
+                            {"type": "string", "description": "Comma-separated tags (optional)"},
+                            {"type": "array", "items": {"type": "string"}, "description": "List of tags (optional)"}
+                        ]
+                    },
+                    "sessionId": {"type": "string", "description": "Link to a specific session ID (optional)"}
+                },
+                "required": ["title"]
+            }
+        },
+        {
+            "name": "memory_action_update",
+            "description": "Update fields of an existing action.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "actionId": {"type": "string", "description": "ID of the action to update"},
+                    "title": {"type": "string", "description": "Updated title (optional)"},
+                    "description": {"type": "string", "description": "Updated description (optional)"},
+                    "priority": {"type": "number", "description": "Updated priority (optional)"},
+                    "status": {"type": "string", "description": "Updated status: pending, active, completed, discarded (optional)"},
+                    "tags": {
+                        "oneOf": [
+                            {"type": "string", "description": "Comma-separated tags (optional)"},
+                            {"type": "array", "items": {"type": "string"}, "description": "List of tags (optional)"}
+                        ]
+                    },
+                    "sessionId": {"type": "string", "description": "Updated session ID (optional)"}
+                },
+                "required": ["actionId"]
+            }
+        },
+        {
+            "name": "memory_frontier",
+            "description": "Get pending and active actions sorted by priority.",
+            "inputSchema": {"type": "object", "properties": {}}
+        },
+        {
+            "name": "memory_crystallize",
+            "description": "Crystallize/summarize all observations in a session.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "sessionId": {"type": "string", "description": "Session ID to crystallize"}
+                },
+                "required": ["sessionId"]
+            }
         }
     ]
     return jsonify({"tools": tools}), 200
@@ -2184,6 +2309,102 @@ def mcp_tools_call():
             res = perform_antigravity_sync(mode, current_convo, current_folder)
             text_out = json.dumps(res)
             
+        elif name == "memory_slot_list":
+            res = functions.slot_list(kv)
+            text_out = json.dumps(res, indent=2)
+            
+        elif name == "memory_slot_get":
+            label = args.get("label")
+            if not label:
+                return jsonify({"error": "label is required"}), 400
+            res = functions.slot_get(kv, label)
+            text_out = json.dumps(res, indent=2)
+            
+        elif name == "memory_slot_create":
+            label = args.get("label")
+            if not label:
+                return jsonify({"error": "label is required"}), 400
+            res = functions.slot_create(kv, {
+                "label": label,
+                "content": args.get("content"),
+                "scope": args.get("scope") or "global",
+                "sizeLimit": args.get("sizeLimit"),
+                "pinned": args.get("pinned", True)
+            })
+            text_out = json.dumps(res, indent=2)
+            
+        elif name == "memory_slot_append":
+            label = args.get("label")
+            text = args.get("text")
+            if not label or not text:
+                return jsonify({"error": "label and text are required"}), 400
+            res = functions.slot_append(kv, label, text)
+            text_out = json.dumps(res, indent=2)
+            
+        elif name == "memory_slot_replace":
+            label = args.get("label")
+            content = args.get("content")
+            if not label or content is None:
+                return jsonify({"error": "label and content are required"}), 400
+            res = functions.slot_replace(kv, label, content)
+            text_out = json.dumps(res, indent=2)
+            
+        elif name == "memory_slot_delete":
+            label = args.get("label")
+            if not label:
+                return jsonify({"error": "label is required"}), 400
+            res = functions.slot_delete(kv, label)
+            text_out = json.dumps(res, indent=2)
+            
+        elif name == "memory_action_create":
+            action_id = functions.generate_id("act")
+            from datetime import datetime, timezone
+            now = datetime.now(timezone.utc).isoformat()
+            tags = parse_mcp_list_arg(args.get("tags"))
+            action = {
+                "id": action_id,
+                "title": args.get("title") or "",
+                "description": args.get("description"),
+                "priority": args.get("priority", 0),
+                "status": args.get("status", "pending"),
+                "tags": tags,
+                "sessionId": args.get("sessionId"),
+                "createdAt": now,
+                "updatedAt": now,
+            }
+            kv.set(KV.actions, action_id, action)
+            text_out = json.dumps({"action": action, "success": True}, indent=2)
+            
+        elif name == "memory_action_update":
+            action_id = args.get("actionId")
+            if not action_id:
+                return jsonify({"error": "actionId is required"}), 400
+            existing = kv.get(KV.actions, action_id)
+            if not existing:
+                return jsonify({"error": "action not found"}), 404
+            from datetime import datetime, timezone
+            allowed_fields = {"title", "description", "priority", "status", "tags", "sessionId"}
+            updates = {k: v for k, v in args.items() if k in allowed_fields}
+            if "tags" in args:
+                updates["tags"] = parse_mcp_list_arg(args.get("tags"))
+            existing.update(updates)
+            existing["updatedAt"] = datetime.now(timezone.utc).isoformat()
+            kv.set(KV.actions, action_id, existing)
+            text_out = json.dumps({"action": existing, "success": True}, indent=2)
+            
+        elif name == "memory_frontier":
+            items = kv.list(KV.actions)
+            frontier = [a for a in items if a.get("status") in ("pending", "active")]
+            frontier.sort(key=lambda a: (-(a.get("priority") or 0), a.get("createdAt", "")))
+            text_out = json.dumps({"frontier": frontier[:50], "total": len(frontier)}, indent=2)
+            
+        elif name == "memory_crystallize":
+            session_id = args.get("sessionId")
+            if not session_id:
+                return jsonify({"error": "sessionId is required"}), 400
+            res = functions.summarize(kv, {"sessionId": session_id})
+            text_out = json.dumps(res, indent=2)
+            
         else:
             return jsonify({"error": f"unknown tool: {name}"}), 400
             

src/mcp_stdio.py

@@ -27,6 +27,244 @@ def send(msg):
     sys.stdout.write(line + "\n")
     sys.stdout.flush()
 
+def perform_antigravity_sync_local(args):
+    import os
+    import json
+    import glob
+    import re
+    import requests
+    
+    mode = args.get("mode") or "current_session"
+    current_conversation_id = args.get("currentConversationId")
+    current_folder = args.get("currentFolder")
+
+    brain_dir = os.path.join(os.path.expanduser("~"), ".gemini", "antigravity", "brain")
+    if not os.path.exists(brain_dir):
+        return {
+            "content": [{"type": "text", "text": json.dumps({
+                "success": False,
+                "syncedSessions": [],
+                "observationsAdded": 0,
+                "error": f"Brain directory not found at {brain_dir}"
+            })}]
+        }
+
+    pattern = os.path.join(brain_dir, "*", ".system_generated", "logs", "transcript.jsonl")
+    files = glob.glob(pattern)
+    if not files:
+        return {
+            "content": [{"type": "text", "text": json.dumps({
+                "success": True,
+                "syncedSessions": [],
+                "observationsAdded": 0
+            })}]
+        }
+
+    conversations = []
+    for fpath in files:
+        try:
+            mtime = os.path.getmtime(fpath)
+            convo_id = os.path.basename(os.path.dirname(os.path.dirname(os.path.dirname(fpath))))
+            conversations.append({
+                "id": convo_id,
+                "transcriptPath": fpath,
+                "mtime": mtime
+            })
+        except Exception:
+            pass
+
+    if not conversations:
+        return {
+            "content": [{"type": "text", "text": json.dumps({
+                "success": True,
+                "syncedSessions": [],
+                "observationsAdded": 0
+            })}]
+        }
+
+    conversations.sort(key=lambda x: x["mtime"], reverse=True)
+
+    targets = []
+    if mode == "current_session":
+        if current_conversation_id:
+            match = next((c for c in conversations if c["id"] == current_conversation_id), None)
+            if match:
+                targets = [match]
+        else:
+            targets = [conversations[0]]
+    elif mode == "current_folder":
+        target_folder = current_folder if current_folder else ""
+        if not target_folder:
+            target_folder = os.getcwd()
+            
+        target_folder_norm = target_folder.replace("\\", "/").lower().strip()
+        
+        for convo in conversations:
+            try:
+                with open(convo["transcriptPath"], "r", encoding="utf-8") as tf:
+                    text = tf.read().lower()
+                    text_norm = text.replace("\\/", "/").replace("\\\\", "/")
+                    if target_folder_norm in text_norm:
+                        targets.append(convo)
+            except Exception:
+                pass
+    elif mode == "all":
+        targets = conversations
+    else:
+        return {
+            "content": [{"type": "text", "text": json.dumps({
+                "success": False,
+                "syncedSessions": [],
+                "observationsAdded": 0,
+                "error": f"Invalid mode: {mode}"
+            })}]
+        }
+
+    if not targets:
+        return {
+            "content": [{"type": "text", "text": json.dumps({
+                "success": True,
+                "syncedSessions": [],
+                "observationsAdded": 0
+            })}]
+        }
+
+    synced_sessions = []
+    observations_added = 0
+
+    headers_dict = headers()
+
+    for convo in targets:
+        convo_id = convo["id"]
+        tpath = convo["transcriptPath"]
+        session_id = f"antigravity_{convo_id[:18].replace('-', '_')}"
+        
+        project_path = None
+        try:
+            with open(tpath, "r", encoding="utf-8") as tf:
+                first_line = tf.readline()
+                if first_line:
+                    step = json.loads(first_line)
+                    match = re.search(r"\[([^\]]+)\]\s*->\s*\[([^\]]+)\]", step.get("content", ""))
+                    if match:
+                        project_path = match.group(2)
+        except Exception:
+            pass
+            
+        if not project_path:
+            project_path = os.getcwd()
+
+        turns = []
+        current_prompt = None
+        current_timestamp = None
+
+        try:
+            with open(tpath, "r", encoding="utf-8") as tf:
+                for line in tf:
+                    if not line.strip():
+                        continue
+                    try:
+                        step = json.loads(line)
+                        step_type = step.get("type")
+                        if step_type == "USER_INPUT":
+                            p_text = step.get("content", "")
+                            if "<USER_REQUEST>" in p_text:
+                                parts = p_text.split("<USER_REQUEST>")
+                                if len(parts) > 1:
+                                    p_text = parts[1]
+                            if "</USER_REQUEST>" in p_text:
+                                p_text = p_text.split("</USER_REQUEST>")[0]
+                            current_prompt = p_text.strip()
+                            current_timestamp = step.get("created_at")
+                        elif step_type == "PLANNER_RESPONSE" and current_prompt:
+                            ts = current_timestamp or step.get("created_at")
+                            if not ts:
+                                import datetime
+                                ts = datetime.datetime.utcnow().isoformat() + "Z"
+                            turns.append({
+                                "prompt": current_prompt,
+                                "response": step.get("content", ""),
+                                "timestamp": ts
+                            })
+                            current_prompt = None
+                            current_timestamp = None
+                    except Exception:
+                        pass
+        except Exception:
+            continue
+
+        if not turns:
+            continue
+
+        existing_inputs = set()
+        
+        try:
+            r = requests.get(f"{BASE}/observations?sessionId={session_id}", headers=headers_dict, timeout=10)
+            if r.status_code == 200:
+                obs_list = r.json().get("observations", [])
+                for obs in obs_list:
+                    tool_input = obs.get("toolInput") or (obs.get("raw") or {}).get("tool_input")
+                    if tool_input:
+                        existing_inputs.add(tool_input.strip())
+        except Exception:
+            pass
+
+        try:
+            sess_check = requests.get(f"{BASE}/sessions", headers=headers_dict, timeout=5)
+            session_exists = False
+            if sess_check.status_code == 200:
+                sessions_list = sess_check.json().get("sessions", [])
+                session_exists = any(s.get("id") == session_id for s in sessions_list)
+            
+            if not session_exists:
+                session_payload = {
+                    "sessionId": session_id,
+                    "project": project_path,
+                    "cwd": project_path,
+                    "title": f"Antigravity Pair Programming ({convo_id[:8]})",
+                    "agentId": "antigravity"
+                }
+                requests.post(f"{BASE}/session/start", headers=headers_dict, json=session_payload, timeout=10)
+        except Exception:
+            pass
+
+        convo_synced = False
+        for turn in turns:
+            prompt = turn["prompt"]
+            if prompt.strip() in existing_inputs:
+                continue
+
+            payload = {
+                "sessionId": session_id,
+                "project": project_path,
+                "cwd": project_path,
+                "hookType": "post_tool_use",
+                "timestamp": turn["timestamp"],
+                "agentId": "antigravity",
+                "data": {
+                    "tool_name": "conversation",
+                    "tool_input": prompt,
+                    "tool_output": turn["response"],
+                }
+            }
+            try:
+                requests.post(f"{BASE}/observe", headers=headers_dict, json=payload, timeout=10)
+                observations_added += 1
+                convo_synced = True
+            except Exception:
+                pass
+
+        if convo_synced:
+            synced_sessions.append(convo_id)
+
+    return {
+        "content": [{"type": "text", "text": json.dumps({
+            "success": True,
+            "syncedSessions": synced_sessions,
+            "observationsAdded": observations_added
+        })}]
+    }
+
 def handle(req):
     method = req.get("method", "")
     req_id = req.get("id")
@@ -61,14 +299,17 @@ def handle(req):
         name = params.get("name")
         args = params.get("arguments") or {}
         try:
-            r = requests.post(f"{BASE}/mcp/tools",
-                              headers=headers(),
-                              json={"name": name, "arguments": args},
-                              timeout=30)
-            result = r.json()
-            # MCP expects content array
-            if "content" not in result:
-                result = {"content": [{"type": "text", "text": json.dumps(result)}]}
+            if name == "memory_antigravity_sync":
+                result = perform_antigravity_sync_local(args)
+            else:
+                r = requests.post(f"{BASE}/mcp/tools",
+                                  headers=headers(),
+                                  json={"name": name, "arguments": args},
+                                  timeout=30)
+                result = r.json()
+                # MCP expects content array
+                if "content" not in result:
+                    result = {"content": [{"type": "text", "text": json.dumps(result)}]}
             send({"jsonrpc": "2.0", "id": req_id, "result": result})
         except Exception as e:
             send({"jsonrpc": "2.0", "id": req_id,