eagle-mem 4.10.0 → 4.10.2

package/README.md

@@ -7,11 +7,11 @@
 
 # Eagle Mem
 
-**Shared memory, release guardrails, and worker lanes for Claude Code, Codex, and Grok-assisted workflows.**
+**Shared memory, release guardrails, and worker lanes for Claude Code, Codex, Grok, and Google Antigravity.**
 
-Eagle Mem turns AI coding sessions into compounding project knowledge. It gives Claude Code and Codex hook-backed shared memory, gives Grok the same skills and CLI memory surface, labels which agent created each memory, blocks risky release commands until affected features are verified, and lets broad work split into durable worker lanes.
+Eagle Mem turns AI coding sessions into compounding project knowledge. It gives Claude Code, Codex, and Google Antigravity hook-backed shared memory, gives Grok the same skills and CLI memory surface, labels which agent created each memory, blocks risky release commands until affected features are verified, and lets broad work split into durable worker lanes.
 
-**v4.10.0 focuses on Grok support and Compaction Survival:** Grok users now get first-class skill linking and `eagle-mem grok-bootstrap`, while all agents can inspect project-level compaction readiness with `eagle-mem compaction`. Claude Code and Codex continue to get the deepest automatic lifecycle support through hooks; Grok currently uses the shared CLI and skill workflow until native lifecycle hooks are available.
+**v4.10.0 and onward focuses on Grok, Google Antigravity support, and Compaction Survival:** Grok users get first-class skill linking and `eagle-mem grok-bootstrap`, while Antigravity users get native Python SDK hook integration via `google_antigravity_hook.py`. Claude Code, Codex, and Antigravity receive the deepest automatic lifecycle support through hooks; Grok currently uses the shared CLI and skill workflow.
 
 **Website:** [Product](https://eagleisbatman.github.io/eagle-mem/) |
 [Architecture](https://eagleisbatman.github.io/eagle-mem/architecture.html) |
@@ -22,12 +22,12 @@ Eagle Mem turns AI coding sessions into compounding project knowledge. It gives
 - **Start warmer** - every new session can recall project overviews, decisions, gotchas, summaries, hot files, mirrored memories, plans, and tasks.
 - **Ship safer** - feature-mapped changes create pending verification records, and release-boundary commands stay blocked until the current diff is verified or waived.
 - **Waste fewer tokens** - Eagle Mem injects compact context, nudges duplicate reads, and can route noisy shell output through RTK.
-- **Coordinate agents** - Codex and Claude Code can share one project memory while worker lanes record owner, model, effort, worktree, logs, validation, and handoff.
+- **Coordinate agents** - Claude, Codex, Grok, and Antigravity can share one project memory while worker lanes record owner, model, effort, worktree, logs, validation, and handoff.
 - **Stay local** - no daemon, no hosted memory service, no vector database. The core is hooks plus SQLite/FTS5.
 
 ## The Problem
 
-Claude Code and Codex start every session with amnesia. They don't remember what you built yesterday, what decisions you made, what files matter, or what broke last time. Every `/compact` wipes context. Every new session is a cold start. You waste tokens re-explaining your project, re-reading files, and watching agents repeat mistakes you already corrected.
+Claude Code, Codex, Grok, and Google Antigravity start every session with amnesia. They don't remember what you built yesterday, what decisions you made, what files matter, or what broke last time. Every `/compact` wipes context. Every new session is a cold start. You waste tokens re-explaining your project, re-reading files, and watching agents repeat mistakes you already corrected.
 
 The longer you work with Claude Code, the worse this gets. Projects accumulate history — decisions, gotchas, architectural patterns, feature dependencies — and none of it survives across sessions.
 
@@ -41,9 +41,9 @@ Eagle Mem is a local runtime layer for AI coding agents. It adds three things th
 | **Guardrails** | "The agent cannot casually undo known decisions or push unverified feature changes." | Surfaces decisions before edits and enforces feature verification on push, PR, and publish boundaries. |
 | **Lanes** | "A big task can survive compaction and split across agents." | Persists orchestrations, worker lanes, worktrees, logs, validation commands, and handoffs. |
 
-Claude Code and Codex share the same SQLite database at `~/.eagle-mem/memory.db`, and captured rows are source-attributed as `Claude Code` or `Codex`. Grok uses the same database through skills and CLI commands, with native lifecycle capture reserved for a future adapter.
+Claude Code, Codex, and Google Antigravity share the same SQLite database at `~/.eagle-mem/memory.db`, and captured rows are source-attributed as `Claude Code`, `Codex`, or `Antigravity`. Grok uses the same database through skills and CLI commands.
 
-**Zero per-instance overhead.** No daemon, no vector DB, no MCP server. Just bash scripts, sqlite3 (WAL mode, FTS5 full-text search), and jq.
+**Zero per-instance overhead.** No daemon, no vector DB, no MCP server. Just bash/python hooks, sqlite3 (WAL mode, FTS5 full-text search), and jq.
 
 ```
 ======================================
@@ -66,17 +66,17 @@ eagle-mem install
 eagle-mem doctor
 ```
 
-That's it. `doctor` should report a healthy install. Open Claude Code or Codex in any project directory and Eagle Mem activates automatically. For Grok, run `eagle-mem grok-bootstrap` after install to confirm the linked skills and CLI workflow.
+That's it. `doctor` should report a healthy install. Open Claude Code or Codex, or import the Antigravity hook in your agent config, and Eagle Mem activates automatically. For Grok, run `eagle-mem grok-bootstrap` after install to confirm the linked skills and CLI workflow.
 
-For Claude Code and Codex, everything is automatic from here. Eagle Mem scans your codebase, indexes source files, captures session summaries, mirrors Claude's memories and tasks, learns which commands are noisy, prunes stale data, and installs patch bug fixes — all in the background via hooks.
+For Claude Code, Codex, and Google Antigravity, everything is automatic. Eagle Mem scans your codebase, indexes source files, captures session summaries, mirrors memories and tasks (including planning-mode artifacts like `implementation_plan.md`, `task.md`, and `walkthrough.md`), learns which commands are noisy, and prunes stale data — all in the background via hooks.
 
-For Codex, the installer enables `codex_hooks` in `~/.codex/config.toml`, registers hooks in `~/.codex/hooks.json`, symlinks Eagle Mem skills into `~/.codex/skills`, and patches `~/.codex/AGENTS.md`. For Claude Code, it integrates with `~/.claude/settings.json`, `CLAUDE.md`, and `~/.claude/skills`. Grok users get skill symlinks into `~/.grok/skills/` and can run `eagle-mem grok-bootstrap` for setup guidance and self-linking.
+For Google Antigravity, the installer copies the native Python integration to `~/.eagle-mem/integrations/google_antigravity_hook.py`. For Codex, the installer enables `codex_hooks` in `~/.codex/config.toml`, registers hooks in `~/.codex/hooks.json`, symlinks Eagle Mem skills into `~/.codex/skills`, and patches `~/.codex/AGENTS.md`. For Claude Code, it integrates with `~/.claude/settings.json`, `CLAUDE.md`, and `~/.claude/skills`. Grok users get skill symlinks into `~/.grok/skills/` and can run `eagle-mem grok-bootstrap` for setup guidance and self-linking.
 
 ### Prerequisites
 
 - `sqlite3` with FTS5 support (ships with macOS; Eagle Mem prefers known system/Homebrew SQLite binaries before PATH shims)
 - `jq` (the installer offers to install if missing)
-- [Claude Code](https://docs.anthropic.com/en/docs/claude-code), Codex, or a Grok environment (`~/.grok/`)
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code), Codex, Google Antigravity SDK, or a Grok environment (`~/.grok/`)
 
 ## How It Works
 
@@ -110,7 +110,7 @@ Eagle Mem actively reduces token consumption:
 
 ### Compaction Survival
 
-One of the core promises of Eagle Mem is protecting against `/compact` and session amnesia. Compaction Survival is project-level, not Grok-specific: it reads shared Eagle Mem state such as durable tasks, enriched summaries, stale work, and orchestration lanes. Claude Code and Codex get automatic hook-backed recovery through SessionStart, Stop, task mirroring, and context-pressure nudges. Grok can inspect and use the same state through `eagle-mem compaction`, `eagle-mem tasks`, and the linked skills, but does not yet have native lifecycle hooks.
+One of the core promises of Eagle Mem is protecting against `/compact` and session amnesia. Compaction Survival is project-level: it reads shared Eagle Mem state such as durable tasks, enriched summaries, stale work, and orchestration lanes. Claude Code, Codex, and Google Antigravity get automatic hook-backed recovery through `SessionStart`, `Stop`/`post_turn`, and context-pressure nudges. Grok can inspect and use the same state through `eagle-mem compaction`, `eagle-mem tasks`, and the linked skills.
 
 Run `eagle-mem compaction` anytime to check readiness.
 
@@ -134,7 +134,7 @@ Eagle Mem prevents Claude from repeating past mistakes:
 - **Gotcha surfacing** — past surprises and gotchas are surfaced when editing related files
 - **Stale memory detection** — warns when edits may contradict stored memories
 - **Token guard** — when `rtk` is installed, raw shell output commands are rewritten or blocked with an RTK equivalent so large output is compacted before it enters agent context
-- **Orchestration lanes** — long-running work can be split into durable worker lanes with owners, validation commands, worktree paths, status notes, and handoff output shared by Claude Code and Codex
+- **Orchestration lanes** — long-running work can be split into durable worker lanes with owners, validation commands, worktree paths, status notes, and handoff output shared across Claude Code, Codex, Grok, and Google Antigravity
 
 ## Commands
 
@@ -175,7 +175,37 @@ eagle-mem uninstall --dry-run
 
 Install and update print the files/configs they intend to touch before they change the runtime. The installed runtime writes `~/.eagle-mem/install-manifest.json` with file sizes, modes, and SHA-256 hashes, so `doctor` can tell whether hooks, scripts, libraries, and database helpers still match the package that installed them.
 
-Uninstall removes Claude Code and Codex hook registrations, Eagle Mem instruction blocks, custom Claude statusline integration, and skill links. It backs up user config files before editing them and keeps `~/.eagle-mem/memory.db` unless you explicitly confirm data deletion.
+Uninstall removes Claude Code, Codex, Grok, and Google Antigravity hook registrations, Eagle Mem instruction blocks, custom Claude statusline integration, and skill links. It backs up user config files before editing them and keeps `~/.eagle-mem/memory.db` unless you explicitly confirm data deletion.
+
+### Download Counts, Privacy, and Telemetry
+
+npm download graphs are public registry aggregates, not user analytics. A download count means the npm registry served package tarballs. It does not tell package authors who downloaded the package, which project installed it, whether it was a human, or whether it became an active user.
+
+Large single-day spikes can come from normal registry behavior:
+
+- package mirrors and caches fetching a newly published version
+- CI jobs, disposable containers, and build farms reinstalling dependencies
+- bots and scanners that analyze public npm packages
+- repeated installs during local testing or release verification
+
+Eagle Mem does not add phone-home telemetry, install tracking, analytics beacons, or a hosted usage service. Runtime memory stays local in `~/.eagle-mem/memory.db` unless you explicitly choose to move or publish it yourself.
+
+You can inspect the same public aggregate counts shown by npm with:
+
+```bash
+curl https://api.npmjs.org/downloads/range/last-week/eagle-mem
+curl https://api.npmjs.org/downloads/range/last-month/eagle-mem
+```
+
+Use these numbers as directional popularity signals only. They are useful for spotting broad distribution patterns, but they are not a reliable count of users, installs, projects, or companies.
+
+### v4.10.1 Patch
+
+This documentation patch clarifies npm download-count behavior and Eagle Mem privacy expectations:
+
+- npm download counts are aggregate tarball-serving statistics.
+- Package maintainers cannot identify who downloaded the package from npm's public stats.
+- Eagle Mem remains local-first and does not include install telemetry or phone-home analytics.
 
 ### v4.10.0 Minor Release
 
@@ -309,12 +339,12 @@ Each lane is stored in `orchestration_lanes` and mirrored into `agent_tasks`, so
 
 Both agents write to `~/.eagle-mem/memory.db`:
 
-- `sessions.agent` records whether a session came from Claude Code or Codex
+- `sessions.agent` records whether a session came from Claude Code, Codex, or Antigravity
 - `summaries.agent` records which agent produced the session summary
 - mirrored memories, plans, and tasks include `origin_agent`
-- SessionStart recall labels sources as `Claude Code` or `Codex`
+- SessionStart recall labels sources as `Claude Code`, `Codex`, or `Antigravity`
 
-That means opening the same project in Claude Code and Codex does not create two isolated memory worlds. They recall the same project history while preserving the source of each memory. Grok can search, inspect, and update that same project memory through the linked skills and CLI commands.
+That means opening the same project in Claude Code, Codex, and Google Antigravity does not create isolated memory worlds. They recall the same project history while preserving the source of each memory. Grok can search, inspect, and update that same project memory through the linked skills and CLI commands.
 
 ## Skills (Inside Claude Code, Codex, and Grok)
 
@@ -324,7 +354,7 @@ That means opening the same project in Claude Code and Codex does not create two
 | `/eagle-mem-overview` | Build a rich project briefing from README, entry points, and git history |
 | `/eagle-mem-memories` | View and search mirrored agent memories and plans |
 | `/eagle-mem-tasks` | TaskAware Compact Loop — break complex work into tasks that survive `/compact` |
-| `/eagle-mem-orchestrate` | Orchestrator/worker lane handoffs across Claude Code and Codex, with shared CLI visibility for Grok |
+| `/eagle-mem-orchestrate` | Orchestrator/worker lane handoffs across Claude Code, Codex, Grok, and Google Antigravity |
 
 ## Data
 

package/architecture.html

@@ -683,7 +683,7 @@
       <div class="brand">
         <span class="brand-label">Eagle Mem</span>
         <h1>Agent Architecture Tutorial</h1>
-        <p>Technical architecture plus UX architecture for Claude Code, Codex, Grok, and future coding agents.</p>
+        <p>Technical architecture plus UX architecture for Claude Code, Codex, Grok, Google Antigravity, and future coding agents.</p>
       </div>
 
       <p class="nav-title">Start Here</p>
@@ -719,7 +719,7 @@
     <main id="main">
       <section class="hero" id="purpose">
         <div class="hero-inner">
-          <p class="eyebrow">Architecture guide - technical + UX - updated 2026-05-22</p>
+          <p class="eyebrow">Architecture guide - technical + UX - updated 2026-05-26</p>
           <h2>Eagle Mem is a local memory and safety layer that makes AI coding agents start warmer, ship safer, and coordinate better.</h2>
           <p class="hero-summary">
             This tutorial explains the project from first principles. You do not need to know the codebase first. Read it like a guided tour: what problem Eagle Mem solves, how hooks move data through the system, how SQLite stores shared memory, and why the user experience is intentionally quiet until the agent needs help.
@@ -728,11 +728,11 @@
           <div class="hero-meta">
             <div class="meta-box">
               <strong>Runtime</strong>
-              <span>Bash hooks, CLI scripts, SQLite/FTS5, jq, optional RTK.</span>
+              <span>Bash hooks, Python integrations, SQLite/FTS5, jq, optional RTK.</span>
             </div>
             <div class="meta-box">
               <strong>Agents</strong>
-              <span>Claude Code and Codex with hooks; Grok through skills and CLI today.</span>
+              <span>Claude Code, Codex, and Google Antigravity with hooks; Grok via skills.</span>
             </div>
             <div class="meta-box">
               <strong>Core Promise</strong>
@@ -793,7 +793,7 @@
 
           <div class="callout">
             <h3>Compaction Survival is shared state</h3>
-            <p><code>eagle-mem compaction</code> is not a Grok-only feature. It reads project-level state from SQLite: enriched summaries, durable tasks, stale tasks, active orchestration lanes, and recent durable updates. Claude Code and Codex have hook-backed automatic recovery around compact and clear events. Grok can use the same state through linked skills and CLI commands until native lifecycle hooks exist.</p>
+            <p><code>eagle-mem compaction</code> reads project-level state from SQLite: enriched summaries, durable tasks, stale tasks, active orchestration lanes, and recent durable updates. Claude Code, Codex, and Google Antigravity have hook-backed automatic recovery around compact and clear events. Grok can use the same state through linked skills and CLI commands.</p>
           </div>
 
           <h3>Vocabulary</h3>
@@ -862,7 +862,7 @@
               <text x="40" y="42" class="label">User Layer</text>
               <rect x="40" y="58" width="220" height="72" class="box-cyan"></rect>
               <text x="62" y="90">Developer</text>
-              <text x="62" y="112" class="small">Works in Claude Code, Codex, or Grok</text>
+              <text x="62" y="112" class="small">Works in Claude, Codex, Grok, or Antigravity</text>
 
               <text x="40" y="178" class="label">Agent Layer</text>
               <rect x="40" y="194" width="220" height="78" class="box"></rect>
@@ -871,6 +871,12 @@
               <rect x="300" y="194" width="220" height="78" class="box"></rect>
               <text x="322" y="225">Codex</text>
               <text x="322" y="247" class="small">config.toml, hooks.json, AGENTS.md</text>
+              <rect x="560" y="194" width="220" height="78" class="box"></rect>
+              <text x="582" y="225">Grok</text>
+              <text x="582" y="247" class="small">skills link, grok-bootstrap</text>
+              <rect x="820" y="194" width="220" height="78" class="box"></rect>
+              <text x="842" y="225">Antigravity (AGY)</text>
+              <text x="842" y="247" class="small">google_antigravity_hook.py</text>
 
               <text x="40" y="320" class="label">Hook Runtime</text>
               <rect x="40" y="336" width="160" height="68" class="box-soft"></rect>
@@ -902,8 +908,12 @@
 
               <path d="M150,130 L150,190" class="arrow"></path>
               <path d="M260,232 L300,232" class="arrow"></path>
+              <path d="M520,232 L560,232" class="arrow"></path>
+              <path d="M780,232 L820,232" class="arrow"></path>
               <path d="M150,272 L150,330" class="arrow"></path>
               <path d="M410,272 L410,330" class="arrow"></path>
+              <path d="M670,272 L670,330" class="arrow"></path>
+              <path d="M870,272 L870,330" class="arrow"></path>
               <path d="M840,404 L735,462" class="arrow"></path>
               <path d="M660,404 L452,462" class="arrow"></path>
               <path d="M300,404 L182,462" class="arrow"></path>
@@ -964,7 +974,7 @@
               <div class="step-num">5</div>
               <div>
                 <h3>Agent hooks are registered</h3>
-                <p>Claude Code hooks are patched into <code>~/.claude/settings.json</code>. Codex hooks are registered in <code>~/.codex/hooks.json</code>, and <code>codex_hooks = true</code> is enabled in <code>~/.codex/config.toml</code>. Grok currently has skills and CLI access rather than hook registration.</p>
+                <p>Claude Code hooks are patched into <code>~/.claude/settings.json</code>. Codex hooks are registered in <code>~/.codex/hooks.json</code>. Google Antigravity SDK hooks are registered programmatically in <code>google_antigravity_hook.py</code> using native Python async hooks. Grok has skills and CLI access.</p>
               </div>
             </article>
 
@@ -972,7 +982,7 @@
               <div class="step-num">6</div>
               <div>
                 <h3>Skills and instructions are linked</h3>
-                <p>Eagle Mem skills are symlinked into each agent's skill directory. Claude receives <code>CLAUDE.md</code> summary instructions. Codex receives <code>AGENTS.md</code> clean-output memory instructions. Grok receives the same Eagle Mem skills under <code>~/.grok/skills</code> and can run <code>eagle-mem grok-bootstrap</code> for setup guidance.</p>
+                <p>Eagle Mem skills are symlinked into each agent's skill directory. Claude receives <code>CLAUDE.md</code> instructions. Codex receives <code>AGENTS.md</code> instructions. Google Antigravity SDK maps and mirrors standard brain planning artifacts (plans, tasks, walkthroughs). Grok receives skills under <code>~/.grok/skills</code>.</p>
               </div>
             </article>
           </div>
@@ -1015,7 +1025,7 @@
               <tr>
                 <td><code>~/.eagle-mem/memory.db</code></td>
                 <td>Single source of local memory</td>
-                <td>Stores shared state across Claude Code, Codex, Grok skills, compactions, and sessions.</td>
+                <td>Stores shared state across Claude Code, Codex, Grok skills, Google Antigravity hooks, compactions, and sessions.</td>
               </tr>
             </tbody>
           </table>
@@ -1087,7 +1097,7 @@
           <p class="section-number">06 / Technical Architecture</p>
           <h2>The Agent Adapter Layer</h2>
           <p class="lead">
-            The project is agent-generic below the adapter layer. Claude Code and Codex have different config files, tool names, transcript formats, and output expectations, while Grok currently participates through skills and CLI commands. Eagle Mem normalizes each supported surface into the same project memory model.
+            The project is agent-generic below the adapter layer. Claude Code, Codex, and Google Antigravity have direct lifecycle hook adapters, while Grok participates through skills and CLI commands. Eagle Mem normalizes each supported surface into the same project memory model.
           </p>
 
           <div class="grid-2">
@@ -1125,6 +1135,17 @@
                 <span class="tag">tasks</span>
               </div>
             </article>
+
+            <article class="adapter-rule">
+              <h3>Google Antigravity SDK adapter</h3>
+              <p>Integrated programmatically via <code>integrations/google_antigravity_hook.py</code>. Connects Antigravity's async Python hook triggers directly to Eagle Mem's lifecycle events, enabling direct database writes and background curation/sync.</p>
+              <div class="tag-row">
+                <span class="tag">on_session_start</span>
+                <span class="tag">pre_tool_call_decide</span>
+                <span class="tag">post_tool_call</span>
+                <span class="tag">on_compaction</span>
+              </div>
+            </article>
           </div>
 
           <h3>Normalization rules</h3>
@@ -1275,7 +1296,7 @@
               </tr>
               <tr>
                 <td><code>agent_memories</code>, <code>agent_plans</code>, <code>agent_tasks</code></td>
-                <td>What durable agent artifacts should be shared across Claude Code and Codex?</td>
+                <td>What durable agent artifacts should be shared across Claude Code, Codex, Grok, and Antigravity?</td>
                 <td>PostToolUse, SessionEnd, skills, search CLI</td>
               </tr>
               <tr>
@@ -1464,7 +1485,7 @@
 
           <h3>Default routing</h3>
           <p>
-            Eagle Mem can route broad work to the opposite agent by default. A Codex coordinator can spawn Claude Code workers; a Claude Code coordinator can spawn Codex workers. The goal is not to make agents compete. The goal is to let each lane have one owner and one validation path.
+            Eagle Mem can route broad work to different agents by default. For example, a Codex or Antigravity coordinator can spawn Claude Code or Grok workers; any agent can coordinate or execute worker lanes. The goal is not to make agents compete, but to let each lane have one owner and one validation path.
           </p>
 
           <pre><code># Agent-run protocol, not usually a user task
@@ -1476,7 +1497,7 @@ eagle-mem orchestrate handoff --write docs/handoff-context.md</code></pre>
 
           <h3>Why lanes matter for all agents</h3>
           <p>
-            Context windows end. Tools fail. A user may switch from Claude Code to Codex. A worker may finish while the coordinator is compacted. Lanes make this survivable because the state is outside any one transcript.
+            Context windows end. Tools fail. A user may switch from Claude Code to Codex, Grok, or Antigravity. A worker may finish while the coordinator is compacted. Lanes make this survivable because the state is outside any one transcript.
           </p>
         </div>
       </section>
@@ -1492,7 +1513,7 @@ eagle-mem orchestrate handoff --write docs/handoff-context.md</code></pre>
           <div class="grid-2">
             <article class="principle">
               <h3>1. Stay in the agent's flow</h3>
-              <p>Users already live in Claude Code or Codex. Eagle Mem should not require them to open a dashboard before every task. Hooks inject context where the agent already is.</p>
+              <p>Users already live in Claude Code, Codex, Grok, or Antigravity. Eagle Mem should not require them to open a dashboard before every task. Hooks/skills inject context where the agent already is.</p>
             </article>
             <article class="principle">
               <h3>2. Show up only when useful</h3>
@@ -1512,7 +1533,7 @@ eagle-mem orchestrate handoff --write docs/handoff-context.md</code></pre>
             </article>
             <article class="principle">
               <h3>6. Respect each agent's display model</h3>
-              <p>Claude can handle richer hook context. Codex should keep user-facing replies clean and let Stop capture summaries from normal prose.</p>
+              <p>Claude and Antigravity can handle richer hook context. Codex and Grok should keep user-facing replies clean and let Turn Stop/Stop capture summaries from normal prose.</p>
             </article>
           </div>
         </div>
@@ -1583,7 +1604,7 @@ eagle-mem orchestrate handoff --write docs/handoff-context.md</code></pre>
           <p class="section-number">13 / Tutorial</p>
           <h2>Walkthrough: From Empty Memory To Safer Release</h2>
           <p class="lead">
-            This walkthrough explains how the system feels to a beginner. The same flow works whether the active agent is Claude Code or Codex.
+            This walkthrough explains how the system feels to a beginner. The same flow works whether the active agent is Claude Code, Codex, Grok, or Antigravity.
           </p>
 
           <div class="step-list">
@@ -1641,7 +1662,7 @@ eagle-mem install</code></pre>
               <div class="step-num">7</div>
               <div>
                 <h3>The turn ends with durable memory</h3>
-                <p>Stop saves what happened so the next session can recall it. Codex can keep the final reply clean; Claude can use richer summary fields when appropriate. Either way, the durable memory lands in SQLite.</p>
+                <p>Stop saves what happened so the next session can recall it. Codex and Grok can keep the final reply clean; Claude and Antigravity can use richer summary fields/artifacts when appropriate. Either way, the durable memory lands in SQLite.</p>
               </div>
             </article>
           </div>
@@ -1661,7 +1682,7 @@ eagle-mem install</code></pre>
           <p class="section-number">14 / All-Agent Applicability</p>
           <h2>How To Add Another Agent</h2>
           <p class="lead">
-            The project supports Claude Code and Codex with lifecycle hooks, and Grok with skills plus CLI workflows. The architecture should scale to any coding agent that can run local hooks, wrapper scripts, or a skill-like command surface. The integration work should live at the edge, not inside the database model.
+            The project natively supports Claude Code, Codex, and Google Antigravity with lifecycle hooks, and Grok with skills plus CLI workflows. The architecture should scale to any coding agent that can run local hooks, wrapper scripts, or a skill-like command surface. The integration work should live at the edge, not inside the database model.
           </p>
 
           <h3>Minimum viable adapter</h3>
@@ -1705,7 +1726,7 @@ eagle-mem install</code></pre>
           <h3>Adapter checklist</h3>
           <ol>
             <li>Register the agent's lifecycle events to call the installed scripts in <code>~/.eagle-mem/hooks/</code>.</li>
-            <li>Set <code>EAGLE_AGENT_SOURCE</code> to a stable value, such as <code>codex</code>, <code>claude-code</code>, or a future agent key.</li>
+            <li>Set <code>EAGLE_AGENT_SOURCE</code> to a stable value, such as <code>codex</code>, <code>claude-code</code>, <code>grok</code>, <code>antigravity</code>, or a future agent key.</li>
             <li>Map the agent's shell and file tools into Eagle Mem's known categories.</li>
             <li>Pass enough JSON to identify <code>session_id</code>, <code>cwd</code>, tool name, tool input, and optional transcript path.</li>
             <li>Teach output formatting for the agent: compact JSON, plain additional context, or deny decisions.</li>

package/hooks/pre-tool-use.sh

@@ -318,12 +318,8 @@ esac
 
 [ -z "$context" ] && [ -z "$updated_input" ] && exit 0
 
-if [ "$agent" = "codex" ]; then
-    # Codex PreToolUse currently supports deny decisions, but not advisory
-    # additionalContext or updatedInput. Deny paths above already returned JSON;
-    # non-blocking reminders are delivered through SessionStart/UserPromptSubmit.
-    exit 0
-fi
+# Codex PreToolUse now natively receives both blocking decisions and advisory context.
+# Removing the old early-exit to align Codex's pre-tool capabilities with Claude and Antigravity.
 
 if [ -n "$updated_input" ]; then
     jq -nc --arg ctx "$context" --argjson ui "$updated_input" \

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.0",
-  "description": "Shared memory, release guardrails, RTK token protection, and worker lanes for Claude Code, Codex, and Grok",
+  "version": "4.10.2",
+  "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,8 @@
     "db/",
     "skills/",
     "docs/",
-    "architecture.html"
+    "architecture.html",
+    "integrations/"
   ],
   "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 ""

package/scripts/memories.sh

@@ -636,7 +636,7 @@ memories_sync() {
 
             if [ "$existing_hash" = "$new_hash" ] && { [ -z "$mem_project" ] || [ "$existing_project" = "$mem_project" ]; }; then
                 mem_skipped=$((mem_skipped + 1))
-                continue
+                return 0
             fi
 
             eagle_capture_agent_memory "$memfile" "" "$mem_project" "claude-code"
@@ -762,6 +762,84 @@ EOF
     eagle_kv "Tasks:" "$task_synced synced, $task_skipped unchanged"
     echo ""
 
+    # ─── Sync brain planning artifacts ───────────────────
+    eagle_info "Scanning for agent brain planning artifacts..."
+    echo ""
+
+    local artifact_synced=0
+    local artifact_skipped=0
+
+    # Determine brain paths to scan
+    local brain_paths=(
+        "$HOME/.claude/brain"
+        "$HOME/.codex/brain"
+        "$HOME/.gemini/antigravity/brain"
+    )
+
+    for bdir in "${brain_paths[@]}"; do
+        [ ! -d "$bdir" ] && continue
+
+        # 1. Sync plans (implementation_plan.md)
+        while IFS= read -r -d '' planfile; do
+            [ ! -f "$planfile" ] && continue
+
+            local existing_hash
+            existing_hash=$(eagle_db "SELECT content_hash FROM agent_plans WHERE file_path = '$(eagle_sql_escape "$planfile")';")
+            local new_hash
+            new_hash=$(shasum -a 256 "$planfile" | awk '{print $1}')
+
+            if [ "$existing_hash" = "$new_hash" ]; then
+                artifact_skipped=$((artifact_skipped + 1))
+                continue
+            fi
+
+            # Determine agent name based on brain folder path
+            local origin_agent="claude-code"
+            [[ "$planfile" == *".codex"* ]] && origin_agent="codex"
+            [[ "$planfile" == *"antigravity"* ]] && origin_agent="antigravity"
+
+            local artifact_project="$project"
+            [ -z "$artifact_project" ] && artifact_project=$(eagle_project_from_cwd "$(pwd)")
+
+            eagle_capture_agent_plan "$planfile" "" "$artifact_project" "$origin_agent"
+            artifact_synced=$((artifact_synced + 1))
+            local ptitle
+            ptitle=$(awk '/^# /{print; exit}' "$planfile" | sed 's/^# //')
+            [ -z "$ptitle" ] && ptitle="Implementation Plan"
+            eagle_ok "Mirrored plan [$(eagle_agent_label "$origin_agent")]: $ptitle"
+        done < <(find "$bdir" -name "implementation_plan.md" -print0 2>/dev/null)
+
+        # 2. Sync tasks and walkthroughs (task.md, walkthrough.md)
+        while IFS= read -r -d '' memfile; do
+            [ ! -f "$memfile" ] && continue
+
+            local existing_hash
+            existing_hash=$(eagle_db "SELECT content_hash FROM agent_memories WHERE file_path = '$(eagle_sql_escape "$memfile")';")
+            local new_hash
+            new_hash=$(shasum -a 256 "$memfile" | awk '{print $1}')
+
+            if [ "$existing_hash" = "$new_hash" ]; then
+                artifact_skipped=$((artifact_skipped + 1))
+                continue
+            fi
+
+            # Determine agent name based on brain folder path
+            local origin_agent="claude-code"
+            [[ "$memfile" == *".codex"* ]] && origin_agent="codex"
+            [[ "$memfile" == *"antigravity"* ]] && origin_agent="antigravity"
+
+            local artifact_project="$project"
+            [ -z "$artifact_project" ] && artifact_project=$(eagle_project_from_cwd "$(pwd)")
+
+            eagle_capture_agent_memory "$memfile" "" "$artifact_project" "$origin_agent"
+            artifact_synced=$((artifact_synced + 1))
+            eagle_ok "Mirrored $(basename "$memfile") [$(eagle_agent_label "$origin_agent")]"
+        done < <(find "$bdir" \( -name "task.md" -o -name "walkthrough.md" \) -print0 2>/dev/null)
+    done
+
+    eagle_kv "Brain Artifacts:" "$artifact_synced synced, $artifact_skipped unchanged"
+    echo ""
+
     # ─── Backfill project names ──────────────────────────
     eagle_info "Resolving project names from agent transcripts..."
 

package/scripts/session.sh

@@ -164,8 +164,9 @@ save_session() {
         case "$agent" in
             codex|openai-codex) agent="codex" ;;
             claude|claude-code|cloud-code) agent="claude-code" ;;
+            antigravity*|google-antigravity*|google_antigravity*) agent="antigravity" ;;
             *)
-                eagle_err "--agent must be codex or claude-code"
+                eagle_err "--agent must be codex, claude-code, or antigravity"
                 exit 1
                 ;;
         esac

package/scripts/uninstall.sh

@@ -99,6 +99,13 @@ else
     eagle_info "Statusline integration not present or not auto-removable"
 fi
 
+# ─── Remove integration files ─────────────────────────────
+
+if [ -d "$EAGLE_MEM_DIR/integrations" ]; then
+    rm -rf "$EAGLE_MEM_DIR/integrations"
+    eagle_ok "Antigravity integration files removed"
+fi
+
 # ─── Remove skill symlinks ────────────────────────────────
 
 if [ -d "$EAGLE_SKILLS_DIR" ]; then