eagle-mem 4.10.1 → 4.10.3

package/integrations/google_antigravity_hook.py

@@ -0,0 +1,416 @@
+"""
+Native Google Antigravity (AGY) SDK integration module for Eagle Mem.
+Enables Antigravity agents to automatically record session summaries, observations,
+and tasks, enforce release-boundary guardrails, and survive context compaction.
+"""
+
+import os
+import sys
+import json
+import asyncio
+import logging
+import inspect
+from typing import Any, Dict, List, Optional
+
+# Setup dedicated logger
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("eagle_mem.antigravity")
+
+# --- Import and Mock Fallback for google-antigravity SDK ---
+try:
+    from google.antigravity import types
+    from google.antigravity.hooks import hooks
+    HAS_ANTIGRAVITY = True
+except ImportError:
+    HAS_ANTIGRAVITY = False
+    
+    # Mock fallback to prevent import errors and allow standalone execution/testing
+    class MockHooksRegistry:
+        def on_session_start(self, func):
+            return func
+        def on_session_end(self, func):
+            return func
+        def pre_turn(self, func):
+            return func
+        def post_turn(self, func):
+            return func
+        def pre_tool_call_decide(self, func):
+            return func
+        def post_tool_call(self, func):
+            return func
+        def on_tool_error(self, func):
+            return func
+        def on_compaction(self, func):
+            return func
+        def on_interaction(self, func):
+            return func
+        
+        async def inject_agent_context(self, context: str):
+            logger.info(f"[Mock SDK] Injected context:\n{context[:100]}...")
+
+    class MockTypes:
+        class HookResult:
+            def __init__(self, allow: bool = True):
+                self.allow = allow
+        class ToolCallResult:
+            def __init__(self, tool_call: Any, output: str):
+                self.tool_call = tool_call
+                self.output = output
+        class ToolCall:
+            def __init__(self, name: str, arguments: Dict[str, Any]):
+                self.name = name
+                self.arguments = arguments
+
+    hooks = MockHooksRegistry()
+    types = MockTypes()
+
+# --- Asynchronous Subprocess Helpers ---
+
+async def run_cmd_async(cmd: List[str]) -> str:
+    """Runs a shell command asynchronously and returns stdout."""
+    # Prioritize workspace-local bin/eagle-mem if running from workspace or if it exists in cwd or relative to this script
+    if cmd and cmd[0] == "eagle-mem":
+        local_paths = [
+            os.path.join(os.getcwd(), "bin", "eagle-mem"),
+            os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "bin", "eagle-mem")
+        ]
+        for path in local_paths:
+            if os.path.exists(path):
+                cmd = [path] + cmd[1:]
+                break
+
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        stdout, stderr = await proc.communicate()
+        if proc.returncode == 0:
+            return stdout.decode('utf-8', errors='ignore')
+        else:
+            err_msg = stderr.decode('utf-8', errors='ignore').strip()
+            logger.warning(f"Command {' '.join(cmd)} failed with code {proc.returncode}: {err_msg}")
+            return ""
+    except FileNotFoundError:
+        # Fallback if command still fails (e.g. if local_bin substitution didn't happen or is broken)
+        logger.error(f"Executable not found for: {cmd[0]}")
+        return ""
+    except Exception as e:
+        logger.error(f"Error running {' '.join(cmd)}: {e}")
+        return ""
+
+async def run_hook_async(script_name: str, input_data: Dict[str, Any]) -> str:
+    """Runs an Eagle Mem bash hook script asynchronously, piping JSON via stdin."""
+    # Resolve the physical path of the hook script
+    # First check ~/.eagle-mem/hooks/, then fall back to workspace hooks/
+    home_dir = os.path.expanduser("~")
+    hook_path = os.path.join(home_dir, ".eagle-mem", "hooks", script_name)
+    if not os.path.exists(hook_path):
+        hook_path = os.path.join(os.getcwd(), "hooks", script_name)
+        
+    if not os.path.exists(hook_path):
+        logger.error(f"Eagle Mem hook script not found: {script_name}")
+        return ""
+
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "bash", hook_path,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        input_json = json.dumps(input_data).encode('utf-8')
+        stdout, stderr = await proc.communicate(input=input_json)
+        if proc.returncode == 0:
+            return stdout.decode('utf-8', errors='ignore')
+        else:
+            err_msg = stderr.decode('utf-8', errors='ignore').strip()
+            logger.warning(f"Hook script {script_name} failed with code {proc.returncode}: {err_msg}")
+            return ""
+    except Exception as e:
+        logger.error(f"Error executing hook {script_name}: {e}")
+        return ""
+
+# --- Utility Helpers ---
+
+def get_session_id() -> str:
+    """Retrieves or generates a persistent session ID for the current context."""
+    # Use environment variables if present (matches Claude/Codex)
+    session_id = os.environ.get("EAGLE_SESSION_ID") or os.environ.get("SESSION_ID")
+    if not session_id:
+        # Generate a unique hex session ID
+        import uuid
+        session_id = f"agy-{uuid.uuid4().hex[:16]}"
+    return session_id
+
+def map_tool_name(agy_name: str) -> str:
+    """Maps Google Antigravity SDK tool names to Eagle Mem canonical tool names."""
+    name = agy_name.lower()
+    if "command" in name or "bash" in name or "shell" in name:
+        return "Bash"
+    elif "read" in name or "view" in name:
+        return "Read"
+    elif "write" in name or "create" in name:
+        return "Write"
+    elif "edit" in name or "replace" in name or "patch" in name:
+        return "Edit"
+    return agy_name
+
+# --- Eagle Mem Antigravity Hook Implementation ---
+
+class EagleMemAntigravityHook:
+    """
+    Natively compatible Google Antigravity SDK lifecycle hooks class for Eagle Mem.
+    Translates and routes events directly to Eagle Mem's native bash scripts.
+    """
+    def __init__(self, agent_name: str = "antigravity"):
+        self.agent_name = agent_name
+
+    async def on_session_start(self):
+        """Fires when the agent session starts. Injects overview, memories, tasks, and history."""
+        logger.info("Eagle Mem Hook: Session starting. Syncing context...")
+        session_id = get_session_id()
+        cwd = os.getcwd()
+        
+        input_data = {
+            "session_id": session_id,
+            "cwd": cwd,
+            "source": "startup",
+            "model": "gemini",
+            "agent": self.agent_name
+        }
+        
+        # Execute session-start.sh via stdin
+        stdout = await run_hook_async("session-start.sh", input_data)
+        context_injected = False
+        
+        if stdout.strip():
+            try:
+                output_json = json.loads(stdout)
+                context = output_json.get("hookSpecificOutput", {}).get("additionalContext", "")
+                if context.strip():
+                    res = hooks.inject_agent_context(context)
+                    if inspect.isawaitable(res):
+                        await res
+                    context_injected = True
+                    logger.info("Eagle Mem Hook: Injected session briefing.")
+            except Exception as e:
+                logger.warning(f"Eagle Mem Hook: Failed to parse session-start JSON: {e}")
+                
+        # Robust fallback if native sessionstart failed or returned empty
+        if not context_injected:
+            logger.info("Eagle Mem Hook: Running fallback search context...")
+            timeline_task = run_cmd_async(["eagle-mem", "search", "--timeline"])
+            overview_task = run_cmd_async(["eagle-mem", "search", "--overview"])
+            timeline, overview = await asyncio.gather(timeline_task, overview_task)
+            
+            fallback_context = ""
+            if overview.strip():
+                fallback_context += f"=== Eagle Mem Project Overview ===\n{overview.strip()}\n\n"
+            if timeline.strip():
+                fallback_context += f"=== Eagle Mem Session Timeline ===\n{timeline.strip()}\n"
+                
+            if fallback_context.strip():
+                res = hooks.inject_agent_context(fallback_context)
+                if inspect.isawaitable(res):
+                    await res
+                logger.info("Eagle Mem Hook: Injected fallback context.")
+
+    async def pre_tool_call_decide(self, tool_call: Any) -> Any:
+        """Fires before a tool execution. Blocks dangerous tasks or injects co-edits/recalls."""
+        tool_name = getattr(tool_call, "name", "")
+        tool_args = getattr(tool_call, "arguments", getattr(tool_call, "args", {}))
+        if not isinstance(tool_args, dict):
+            tool_args = {}
+            
+        mapped_tool = map_tool_name(tool_name)
+        session_id = get_session_id()
+        cwd = os.getcwd()
+        
+        # Build stdin payload matching PreToolUse schema
+        tool_input = {}
+        if mapped_tool == "Bash":
+            cmd = tool_args.get("CommandLine", tool_args.get("command", ""))
+            tool_input["command"] = cmd
+        else:
+            fp = tool_args.get("AbsolutePath", tool_args.get("TargetFile", tool_args.get("file_path", tool_args.get("path", ""))))
+            tool_input["file_path"] = fp
+
+        input_data = {
+            "session_id": session_id,
+            "cwd": cwd,
+            "tool_name": mapped_tool,
+            "tool_input": tool_input,
+            "agent": self.agent_name
+        }
+        
+        stdout = await run_hook_async("pre-tool-use.sh", input_data)
+        if not stdout.strip():
+            return types.HookResult(allow=True)
+            
+        try:
+            output_json = json.loads(stdout)
+            specific_output = output_json.get("hookSpecificOutput", {})
+            
+            # 1. Check for deny decisions (safety guards/release boundaries)
+            if specific_output.get("permissionDecision") == "deny":
+                reason = specific_output.get("permissionDecisionReason", "Blocked by Eagle Mem guardrail.")
+                # Print clearly to the user's console
+                print(f"\n\033[1;31m[Eagle Mem Blocked]\033[0m {reason}\n", file=sys.stderr, flush=True)
+                return types.HookResult(allow=False)
+                
+            # 2. Check for advisory additionalContext (co-edits, stuck loops, decision recalls)
+            additional_context = specific_output.get("additionalContext", "")
+            if additional_context.strip():
+                res = hooks.inject_agent_context(additional_context)
+                if inspect.isawaitable(res):
+                    await res
+                logger.info(f"Eagle Mem Hook: Injected pre-tool context.")
+                
+            # 3. Check for updatedInput (RTK rewriting)
+            updated_input = specific_output.get("updatedInput", {})
+            if updated_input and mapped_tool == "Bash" and "command" in updated_input:
+                rewritten_cmd = updated_input["command"]
+                logger.info(f"Eagle Mem Hook: Rewrote command to: {rewritten_cmd}")
+                if hasattr(tool_call, "arguments") and isinstance(tool_call.arguments, dict):
+                    if "CommandLine" in tool_call.arguments:
+                        tool_call.arguments["CommandLine"] = rewritten_cmd
+                    elif "command" in tool_call.arguments:
+                        tool_call.arguments["command"] = rewritten_cmd
+                elif hasattr(tool_call, "args") and isinstance(tool_call.args, dict):
+                    if "CommandLine" in tool_call.args:
+                        tool_call.args["CommandLine"] = rewritten_cmd
+                    elif "command" in tool_call.args:
+                        tool_call.args["command"] = rewritten_cmd
+
+        except Exception as e:
+            logger.warning(f"Eagle Mem Hook: Failed to parse pre-tool JSON: {e}")
+            
+        return types.HookResult(allow=True)
+
+    async def post_tool_call(self, tool_call_result: Any):
+        """Fires after a tool completes. Records observations and triggers curation in the background."""
+        tool_call = getattr(tool_call_result, "tool_call", None)
+        tool_name = getattr(tool_call, "name", "") if tool_call else ""
+        tool_args = getattr(tool_call, "arguments", getattr(tool_call, "args", {})) if tool_call else {}
+        if not isinstance(tool_args, dict):
+            tool_args = {}
+            
+        mapped_tool = map_tool_name(tool_name)
+        session_id = get_session_id()
+        cwd = os.getcwd()
+        
+        tool_input = {}
+        if mapped_tool == "Bash":
+            cmd = tool_args.get("CommandLine", tool_args.get("command", ""))
+            tool_input["command"] = cmd
+        else:
+            fp = tool_args.get("AbsolutePath", tool_args.get("TargetFile", tool_args.get("file_path", tool_args.get("path", ""))))
+            tool_input["file_path"] = fp
+
+        output_str = getattr(tool_call_result, "output", getattr(tool_call_result, "result", ""))
+        if not isinstance(output_str, str):
+            output_str = str(output_str)
+
+        input_data = {
+            "session_id": session_id,
+            "cwd": cwd,
+            "tool_name": mapped_tool,
+            "tool_input": tool_input,
+            "tool_response": {"stdout": output_str},
+            "agent": self.agent_name
+        }
+        
+        # 1. Trigger post-tool-use.sh in background
+        asyncio.create_task(run_hook_async("post-tool-use.sh", input_data))
+        
+        # 2. Concurrently run eagle-mem curate in background to index changes
+        asyncio.create_task(run_cmd_async(["eagle-mem", "curate"]))
+
+    async def post_turn(self, final_response: str):
+        """Fires after each response. Records observaciones and saves sessions in the background."""
+        session_id = get_session_id()
+        cwd = os.getcwd()
+        
+        input_data = {
+            "session_id": session_id,
+            "cwd": cwd,
+            "last_assistant_message": final_response,
+            "agent": self.agent_name
+        }
+        
+        # 1. Trigger Stop hook (stop.sh) in background to capture transcript/summary
+        asyncio.create_task(run_hook_async("stop.sh", input_data))
+        
+        # 2. Concurrently trigger session save CLI in background
+        summary = final_response[:200] if final_response else ""
+        asyncio.create_task(run_cmd_async([
+            "eagle-mem", "session", "save",
+            "--summary", summary,
+            "--agent", self.agent_name
+        ]))
+
+    async def on_compaction(self, data: Any):
+        """Fires when context is compacted. Queries active tasks and injects them to survive compaction."""
+        logger.info("Eagle Mem Hook: Compaction event. Preserving active tasks...")
+        
+        # Query active tasks from SQLite FTS5 index
+        tasks_text = await run_cmd_async(["eagle-mem", "tasks"])
+        if tasks_text.strip():
+            compaction_banner = (
+                f"\n=== Eagle Mem: Context Compaction Task Survival ===\n"
+                f"The following active tasks have survived compaction:\n"
+                f"{tasks_text.strip()}\n"
+                f"==================================================\n"
+            )
+            res = hooks.inject_agent_context(compaction_banner)
+            if inspect.isawaitable(res):
+                await res
+            logger.info("Eagle Mem Hook: Tasks injected for compaction survival.")
+
+    async def on_session_end(self):
+        """Fires when the agent session closes. Cleans up runtime lock files."""
+        logger.info("Eagle Mem Hook: Session ending. Pruning locks...")
+        session_id = get_session_id()
+        cwd = os.getcwd()
+        
+        input_data = {
+            "session_id": session_id,
+            "cwd": cwd,
+            "agent": self.agent_name
+        }
+        
+        # 1. Trigger session-end.sh in background
+        asyncio.create_task(run_hook_async("session-end.sh", input_data))
+        
+        # 2. Concurrently trigger prune CLI in background
+        asyncio.create_task(run_cmd_async(["eagle-mem", "prune"]))
+
+# --- Expose Bound Methods as Global Functions ---
+
+_global_hook = EagleMemAntigravityHook()
+
+@hooks.on_session_start
+async def on_session_start():
+    await _global_hook.on_session_start()
+
+@hooks.pre_tool_call_decide
+async def pre_tool_call_decide(tool_call: Any) -> Any:
+    return await _global_hook.pre_tool_call_decide(tool_call)
+
+@hooks.post_tool_call
+async def post_tool_call(tool_call_result: Any):
+    await _global_hook.post_tool_call(tool_call_result)
+
+@hooks.post_turn
+async def post_turn(final_response: str):
+    await _global_hook.post_turn(final_response)
+
+@hooks.on_compaction
+async def on_compaction(data: Any):
+    await _global_hook.on_compaction(data)
+
+@hooks.on_session_end
+async def on_session_end():
+    await _global_hook.on_session_end()

package/lib/codex-hooks.sh

@@ -3,13 +3,27 @@
 # Eagle Mem — Codex hook registration helpers
 # Shared by install.sh, update.sh, and uninstall.sh
 # ═══════════════════════════════════════════════════════════
+# ═══════════════════════════════════════════════════════════
 [ -n "${_EAGLE_CODEX_HOOKS_LOADED:-}" ] && return 0
 _EAGLE_CODEX_HOOKS_LOADED=1
 
+eagle_codex_backup_file() {
+    local file="$1"
+    [ -f "$file" ] || return 0
+    if [ -z "${_EAGLE_CODEX_BACKUP_DONE:-}" ]; then
+        local timestamp
+        timestamp=$(date +%Y%m%d%H%M%S)
+        cp "$file" "${file}.bak.${timestamp}" 2>/dev/null || true
+        _EAGLE_CODEX_BACKUP_DONE=1
+    fi
+}
+
 eagle_enable_codex_hooks() {
     local config="$EAGLE_CODEX_CONFIG"
     mkdir -p "$(dirname "$config")"
 
+    eagle_codex_backup_file "$config"
+
     if [ ! -f "$config" ]; then
         cat > "$config" << 'TOML'
 [features]
@@ -71,6 +85,7 @@ eagle_patch_codex_hook() {
     script_path="${script_path%\"}"
 
     mkdir -p "$(dirname "$hooks_file")"
+    eagle_codex_backup_file "$hooks_file"
     if [ ! -f "$hooks_file" ]; then
         printf '{"hooks":{}}\n' > "$hooks_file"
         chmod 600 "$hooks_file" 2>/dev/null || true
@@ -171,6 +186,8 @@ eagle_remove_codex_hooks() {
     [ -f "$hooks_file" ] || return 1
     command -v jq &>/dev/null || return 1
 
+    eagle_codex_backup_file "$hooks_file"
+
     local tmp
     tmp=$(mktemp)
     jq '

package/lib/common.sh

@@ -771,6 +771,7 @@ eagle_agent_source() {
     case "$agent" in
         codex|openai-codex) echo "codex" ;;
         claude|claude-code|cloud-code) echo "claude-code" ;;
+        antigravity*|google-antigravity*|google_antigravity*) echo "antigravity" ;;
         *)
             if [ -n "${CODEX_THREAD_ID:-}" ] || [ -n "${CODEX_CI:-}" ] || [ -n "${CODEX_MANAGED_BY_NPM:-}" ]; then
                 echo "codex"
@@ -789,10 +790,15 @@ eagle_agent_source_from_json() {
         return
     fi
 
-    local transcript_path turn_id tool_name
+    local transcript_path turn_id tool_name agent_field
     transcript_path=$(printf '%s' "$input" | jq -r '.transcript_path // empty' 2>/dev/null)
     turn_id=$(printf '%s' "$input" | jq -r '.turn_id // empty' 2>/dev/null)
     tool_name=$(printf '%s' "$input" | jq -r '.tool_name // empty' 2>/dev/null)
+    agent_field=$(printf '%s' "$input" | jq -r '.agent // empty' 2>/dev/null)
+
+    case "$agent_field" in
+        antigravity*) echo "antigravity"; return ;;
+    esac
 
     case "$transcript_path" in
         "$HOME/.codex/"*|*/.codex/*) echo "codex"; return ;;
@@ -807,6 +813,7 @@ eagle_agent_source_from_json() {
 eagle_agent_label() {
     case "${1:-$(eagle_agent_source)}" in
         codex) echo "Codex" ;;
+        antigravity*) echo "Antigravity" ;;
         *) echo "Claude Code" ;;
     esac
 }

package/lib/hooks-posttool.sh

@@ -27,6 +27,16 @@ eagle_posttool_mirror_writes() {
                             eagle_capture_agent_plan "$fp" "$session_id" "$project" "$agent"
                         fi
                         ;;
+                    */brain/*/implementation_plan.md)
+                        if [ -f "$fp" ]; then
+                            eagle_capture_agent_plan "$fp" "$session_id" "$project" "$agent"
+                        fi
+                        ;;
+                    */brain/*/task.md|*/brain/*/walkthrough.md)
+                        if [ -f "$fp" ]; then
+                            eagle_capture_agent_memory "$fp" "$session_id" "$project" "$agent"
+                        fi
+                        ;;
                 esac
             fi
             ;;

package/lib/hooks.sh

@@ -4,11 +4,26 @@
 # Shared by install.sh and update.sh
 # ═══════════════════════════════════════════════════════════
 
+# ═══════════════════════════════════════════════════════════
+
+eagle_backup_file() {
+    local file="$1"
+    [ -f "$file" ] || return 0
+    if [ -z "${_EAGLE_BACKUP_DONE:-}" ]; then
+        local timestamp
+        timestamp=$(date +%Y%m%d%H%M%S)
+        cp "$file" "${file}.bak.${timestamp}" 2>/dev/null || true
+        _EAGLE_BACKUP_DONE=1
+    fi
+}
+
 eagle_clean_hook_entries() {
     local settings="$1"
     local event="$2"
     local command="$3"
 
+    eagle_backup_file "$settings"
+
     local tmp
     tmp=$(mktemp)
     jq --arg cmd "$command" \
@@ -23,6 +38,8 @@ eagle_patch_hook() {
     local command="$4"
     local description="${5:-}"
 
+    eagle_backup_file "$settings"
+
     # Check both command AND matcher to avoid skipping entries with different matchers
     # (e.g. PreToolUse with "Bash" vs "Read" matcher using the same script)
     local match_query

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eagle-mem",
-  "version": "4.10.1",
-  "description": "Shared memory, release guardrails, RTK token protection, and worker lanes for Claude Code, Codex, and Grok",
+  "version": "4.10.3",
+  "description": "Shared memory, release guardrails, RTK token protection, and worker lanes for Claude Code, Codex, Grok, and Google Antigravity",
   "bin": {
     "eagle-mem": "bin/eagle-mem"
   },
@@ -13,7 +13,9 @@
     "db/",
     "skills/",
     "docs/",
-    "architecture.html"
+    "architecture.html",
+    "integrations/",
+    "CHANGELOG.md"
   ],
   "keywords": [
     "claude-code",

package/scripts/grok-bootstrap.sh

@@ -26,22 +26,44 @@ eagle_ok "Grok environment detected ($EAGLE_GROK_DIR)"
 
 # Check skills
 skill_count=0
+broken_links=0
 if [ -d "$EAGLE_GROK_SKILLS_DIR" ]; then
-    skill_count=$(find "$EAGLE_GROK_SKILLS_DIR" -maxdepth 1 -name "eagle-mem-*" -type d 2>/dev/null | wc -l | tr -d ' ')
+    for link in "$EAGLE_GROK_SKILLS_DIR"/eagle-mem-*; do
+        if [ -L "$link" ] && [ ! -e "$link" ]; then
+            broken_links=$((broken_links + 1))
+        elif [ -d "$link" ]; then
+            skill_count=$((skill_count + 1))
+        fi
+    done
+fi
+
+if [ "$broken_links" -gt 0 ]; then
+    eagle_warn "Detected $broken_links broken or invalid Grok skill symlinks!"
 fi
 
-if [ "$skill_count" -gt 0 ]; then
+if [ "$skill_count" -gt 0 ] && [ "$broken_links" -eq 0 ]; then
     eagle_ok "Grok skills installed ($skill_count eagle-mem-* skills)"
 else
-    eagle_warn "No eagle-mem skills found in $EAGLE_GROK_SKILLS_DIR"
+    if [ "$broken_links" -gt 0 ]; then
+        echo ""
+        eagle_info "Repairing broken skill symlinks now..."
+    fi
     if [ -d "$PACKAGE_DIR/skills" ]; then
         echo ""
-        if eagle_confirm "Link Eagle Mem skills into ~/.grok/skills/ now?"; then
+        if eagle_confirm "Link/repair Eagle Mem skills into ~/.grok/skills/ now?"; then
             mkdir -p "$EAGLE_GROK_SKILLS_DIR"
             for skill_dir in "$PACKAGE_DIR"/skills/*/; do
                 [ ! -d "$skill_dir" ] && continue
                 skill_name=$(basename "$skill_dir")
                 dst="$EAGLE_GROK_SKILLS_DIR/$skill_name"
+                
+                # Protect custom user folders with a timestamped backup
+                if [ -d "$dst" ] && [ ! -L "$dst" ]; then
+                    backup_dst="${dst}.bak.$(date +%Y%m%d%H%M%S)"
+                    eagle_warn "Custom directory found at $dst. Backing up to $(basename "$backup_dst")..."
+                    mv "$dst" "$backup_dst"
+                fi
+                
                 [ -L "$dst" ] && rm "$dst"
                 ln -sf "$skill_dir" "$dst"
                 eagle_ok "Linked: $skill_name"

package/scripts/install.sh

@@ -195,13 +195,14 @@ echo ""
 echo -e "  ${BOLD}Installing Eagle Mem...${RESET}"
 echo ""
 
-mkdir -p "$EAGLE_MEM_DIR"/{hooks,lib,db,scripts}
+mkdir -p "$EAGLE_MEM_DIR"/{hooks,lib,db,scripts,integrations}
 
 cp "$PACKAGE_DIR"/hooks/*.sh "$EAGLE_MEM_DIR/hooks/"
 cp "$PACKAGE_DIR"/lib/*.sh "$EAGLE_MEM_DIR/lib/"
 cp "$PACKAGE_DIR"/db/*.sh "$EAGLE_MEM_DIR/db/"
 cp "$PACKAGE_DIR"/db/*.sql "$EAGLE_MEM_DIR/db/"
 cp "$PACKAGE_DIR"/scripts/*.sh "$EAGLE_MEM_DIR/scripts/" 2>/dev/null
+cp -r "$PACKAGE_DIR"/integrations/* "$EAGLE_MEM_DIR/integrations/" 2>/dev/null || true
 
 chmod +x "$EAGLE_MEM_DIR"/hooks/*.sh
 chmod +x "$EAGLE_MEM_DIR"/db/migrate.sh
@@ -410,6 +411,7 @@ eagle_kv "Hooks:" "$EAGLE_MEM_DIR/hooks/"
 [ "$claude_found" = true ] && eagle_kv "Claude settings:" "$SETTINGS"
 [ "$codex_found" = true ] && eagle_kv "Codex hooks:" "$EAGLE_CODEX_HOOKS"
 [ "$grok_found" = true ] && eagle_kv "Grok skills:" "$EAGLE_GROK_SKILLS_DIR"
+eagle_kv "Antigravity Hook:" "$EAGLE_MEM_DIR/integrations/google_antigravity_hook.py"
 
 echo ""
 if [ "$grok_found" = true ]; then
@@ -419,3 +421,9 @@ if [ "$claude_found" = true ] || [ "$codex_found" = true ]; then
     eagle_dim "Start a new Claude Code or Codex session — Eagle Mem will activate automatically."
 fi
 echo ""
+eagle_info "Google Antigravity SDK Integration:"
+eagle_dim "  To use Eagle Mem inside your Python Antigravity agents, simply import and register the hook:"
+echo ""
+eagle_dim "    from integrations.google_antigravity_hook import EagleMemAntigravityHook"
+eagle_dim "    config = LocalAgentConfig(hooks=EagleMemAntigravityHook().get_hooks())"
+echo ""