eagle-mem 4.10.1 → 4.10.3

package/CHANGELOG.md

@@ -0,0 +1,130 @@
+# Changelog
+
+All notable changes to the **Eagle Mem** project are documented here.
+
+---
+
+## v4.10.2 Patch
+
+This release expands the Eagle Mem adapter layer and addresses multi-agent planning synchronization and gap remediations across all four supported agents:
+
+- **Google Antigravity SDK Hook**: Fully integrated programmatic, asynchronous Python async hooks (`google_antigravity_hook.py`) mapping turn lifecycles (`SessionStart` to `Stop`/`SessionEnd`) and context survival.
+- **Automatic Brain Artifact Synchronization**: Extracted and mirrored `implementation_plan.md`, `task.md`, and `walkthrough.md` generated by Claude, Codex, and Antigravity directly to SQLite and FTS5 search indexes.
+- **PreToolUse Codex Enhancement**: Removed early-exits to enable full advisory, command rewrite, and feature verification support on Codex shell paths.
+- **Agent Settings Backups**: Added timestamped configurations backups (`settings.json.bak` and `config.toml.bak`) before any mutations by the installer/update process.
+- **Unified 4-Agent Documentation**: Generalization of the architecture tutorial (`architecture.html`), product README (`README.md`), and developer instructions (`AGENTS.md`) to treat all four agents as first-class, natively supported surfaces.
+
+---
+
+## 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
+
+This release makes Eagle Mem broader and safer across agent workflows:
+
+- Grok is now a first-class skill/CLI target: install detects `~/.grok`, links Eagle Mem skills into `~/.grok/skills`, and adds `eagle-mem grok-bootstrap`.
+- `eagle-mem compaction` reports Compaction Survival readiness from shared project state: enriched summaries, durable tasks, stale tasks, active lanes, and last durable update.
+- `eagle-mem test` provides a built-in smoke harness for the memory layer.
+- `eagle-mem tasks stale` and `[STALE - Nd]` warnings make long-running task drift visible.
+- `eagle-mem health` now surfaces orchestration lanes, learned command rules, and curator timing.
+
+---
+
+## v4.9.7 Patch
+
+This patch is a release-readiness and UX-hardening pass:
+
+- `eagle-mem doctor` reports the install footprint, selected SQLite binary, FTS5 availability, hook registration, statusline wiring, install-manifest health, and runtime drift.
+- Install/update show a clear preflight plan, refresh the manifest, and keep rollback backups aware of the manifest/version files.
+- Uninstall supports `--dry-run`, backs up config files, removes Claude/Codex hook and instruction integrations, cleans up skill links, and preserves runtime data by default.
+- Claude statusline/HUD rendering is centralized through `scripts/statusline-em.sh --hud`.
+- Statusline project resolution now prefers the live session row and avoids `$HOME` ancestor leakage, so new projects show their own sessions/memories instead of stale counts from older workspaces.
+- Default hook/search/memory output follows the visible-surface UX contract: branded, compact, freshness-aware, and free of raw IDs/paths unless `--raw`, `--debug`, or `--json` is requested.
+
+---
+
+## v4.9.6 Patch
+
+`eagle-mem update` now queues project-key backfill in the background by default, so install/update can finish, write the installed version marker, and return control to the user. Use `EAGLE_MEM_UPDATE_BACKFILL=sync eagle-mem update` only when you intentionally want to wait for a full backfill.
+
+---
+
+## v4.9.5 Patch
+
+Stop hooks now use a fast path: they save heuristic summaries immediately, extract explicit summary blocks when present, and queue LLM enrichment in the background so Codex/Claude lifecycle hooks do not time out. SQLite access now goes through a shared FTS5-capable binary resolver used by migrations, DB helpers, updater backups, install checks, and the statusline, avoiding Android SDK or other PATH shims that shadow working SQLite builds.
+
+---
+
+## v4.9.4 Patch
+
+Project-key hardening for agents that move between folders: hooks now keep a per-session project identity instead of recalculating from every new cwd, and statuslines prefer the stored session project before falling back to folder paths. Install/update also repairs older embedded Eagle Mem statusline blocks so nested-repo projects stop showing `Memories: 0` when the session belongs to the parent workspace.
+
+---
+
+## v4.9.3 Patch
+
+Follow-up hardening for the v4.9.2 project-key repair: Claude transcript workspace detection now reads complete early JSONL records instead of a fixed byte slice, so large SessionStart hook context cannot hide the first `cwd`. Metadata-only memory/plan/task repairs also avoid touching FTS-indexed columns, preventing SQLite FTS update triggers from firing during safe project/source rekeys.
+
+---
+
+## v4.9.2 Patch
+
+Nested-repo Claude Code projects now use one stable project key. When a Claude workspace contains a git repo subdirectory, hooks prefer the Claude transcript workspace root while repo-local CLI commands can still use git-root keys where appropriate. Memory sync and backfill also repair unchanged memory rows whose content hash stayed the same but whose project key was stale. FTS5 update triggers now ignore metadata-only project rekeys, avoiding SQLite virtual-table errors during safe repairs.
+
+Installer parity also improved: first-time install now auto-provisions RTK when Cargo is available, the Eagle Mem statusline shows version/session/memory/turn counts, `eagle-mem statusline` is available as a CLI command, and Codex instructions explicitly call out that Codex currently has hook recall plus the statusline command rather than Claude Code's persistent custom statusline UI.
+
+---
+
+## v4.9.1 Patch
+
+`eagle-mem updates status` now refreshes the npm version live, and install/update seed the local latest-version cache with the installed version. This avoids confusing status output immediately after an update.
+
+---
+
+## v4.9.0 Patch
+
+Eagle Mem now auto-updates by default for patch bug fixes. SessionStart performs a throttled background npm check, applies eligible patch releases with a lock and runtime/database backup, runs `eagle-mem update`, and records a one-time notice for the next session. Minor and major releases stay outside the default auto-apply range unless users opt in with `eagle-mem updates enable minor` or `eagle-mem updates enable major`.
+
+---
+
+## v4.8.6 Patch
+
+`eagle-mem session save --summary "..."` now exists as a clean manual fallback for agents that need to persist an explicit session note. It writes through the same `sessions` and `summaries` tables used by Stop hooks, keeps Claude Code/Codex source attribution, and is immediately searchable through normal recall.
+
+---
+
+## v4.8.5 Patch
+
+First-run configuration no longer exits silently when Ollama is not listening on `localhost:11434`; Eagle Mem falls through to the installed Codex/Claude CLI provider or API-key providers. SQLite/FTS5 failures are now surfaced before DB-backed commands run, including the exact `sqlite3` binary being used and PATH guidance for common macOS Android SDK shadowing. Worker worktree paths are also canonicalized back to the main project key so backfill cannot move feature guardrails into disposable orchestration worktrees.
+
+---
+
+## v4.8.4 Patch
+
+The orchestration handoff path is now Bash 3.2-safe, so `eagle-mem orchestrate handoff` works even when no lane options are present. This patch was verified with a real Codex coordinator -> Claude Code worker proof lane using `claude-opus-4-7` at `xhigh`; the completed lane is visible through `eagle-mem orchestrate --json`, `eagle-mem tasks completed`, and the generated handoff output. Release-boundary detection also ignores Eagle Mem's own `feature verify`/`waive` commands, so verification notes can mention dry-run checks without blocking themselves.
+
+---
+
+## v4.8.3 Patch
+
+GitHub Pages now keeps hero text readable over the terminal background and the homepage explicitly explains installer-created/updated `CLAUDE.md` and `AGENTS.md` sections plus orchestrator/worker mode. Installer/update output also uses the new clean-output Codex wording instead of saying it added eagle-summary instructions.
+
+---
+
+## v4.8.2 Patch
+
+Codex no longer gets instructed to print large user-visible `<eagle-summary>` XML blocks. The installer/update path rewrites existing `~/.codex/AGENTS.md` Eagle Mem instructions to the clean-output contract, context-pressure nudges use normal prose, and Codex-oriented skills/worker prompts avoid raw capture templates.
+
+---
+
+## v4.8.1 Patch
+
+`eagle-mem memories sync` is now safe on large Claude Code/Codex memory files. The memory mirror parser no longer uses early-exit pipelines under `pipefail`, avoiding exit `141` during sync.

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.2 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,7 @@ 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
 
@@ -199,88 +199,9 @@ 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
+### Changelog
 
-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
-
-This release makes Eagle Mem broader and safer across agent workflows:
-
-- Grok is now a first-class skill/CLI target: install detects `~/.grok`, links Eagle Mem skills into `~/.grok/skills`, and adds `eagle-mem grok-bootstrap`.
-- `eagle-mem compaction` reports Compaction Survival readiness from shared project state: enriched summaries, durable tasks, stale tasks, active lanes, and last durable update.
-- `eagle-mem test` provides a built-in smoke harness for the memory layer.
-- `eagle-mem tasks stale` and `[STALE - Nd]` warnings make long-running task drift visible.
-- `eagle-mem health` now surfaces orchestration lanes, learned command rules, and curator timing.
-
-### v4.9.7 Patch
-
-This patch is a release-readiness and UX-hardening pass:
-
-- `eagle-mem doctor` reports the install footprint, selected SQLite binary, FTS5 availability, hook registration, statusline wiring, install-manifest health, and runtime drift.
-- Install/update show a clear preflight plan, refresh the manifest, and keep rollback backups aware of the manifest/version files.
-- Uninstall supports `--dry-run`, backs up config files, removes Claude/Codex hook and instruction integrations, cleans up skill links, and preserves runtime data by default.
-- Claude statusline/HUD rendering is centralized through `scripts/statusline-em.sh --hud`.
-- Statusline project resolution now prefers the live session row and avoids `$HOME` ancestor leakage, so new projects show their own sessions/memories instead of stale counts from older workspaces.
-- Default hook/search/memory output follows the visible-surface UX contract: branded, compact, freshness-aware, and free of raw IDs/paths unless `--raw`, `--debug`, or `--json` is requested.
-
-### v4.9.6 Patch
-
-`eagle-mem update` now queues project-key backfill in the background by default, so install/update can finish, write the installed version marker, and return control to the user. Use `EAGLE_MEM_UPDATE_BACKFILL=sync eagle-mem update` only when you intentionally want to wait for a full backfill.
-
-### v4.9.5 Patch
-
-Stop hooks now use a fast path: they save heuristic summaries immediately, extract explicit summary blocks when present, and queue LLM enrichment in the background so Codex/Claude lifecycle hooks do not time out. SQLite access now goes through a shared FTS5-capable binary resolver used by migrations, DB helpers, updater backups, install checks, and the statusline, avoiding Android SDK or other PATH shims that shadow working SQLite builds.
-
-### v4.9.4 Patch
-
-Project-key hardening for agents that move between folders: hooks now keep a per-session project identity instead of recalculating from every new cwd, and statuslines prefer the stored session project before falling back to folder paths. Install/update also repairs older embedded Eagle Mem statusline blocks so nested-repo projects stop showing `Memories: 0` when the session belongs to the parent workspace.
-
-### v4.9.3 Patch
-
-Follow-up hardening for the v4.9.2 project-key repair: Claude transcript workspace detection now reads complete early JSONL records instead of a fixed byte slice, so large SessionStart hook context cannot hide the first `cwd`. Metadata-only memory/plan/task repairs also avoid touching FTS-indexed columns, preventing SQLite FTS update triggers from firing during safe project/source rekeys.
-
-### v4.9.2 Patch
-
-Nested-repo Claude Code projects now use one stable project key. When a Claude workspace contains a git repo subdirectory, hooks prefer the Claude transcript workspace root while repo-local CLI commands can still use git-root keys where appropriate. Memory sync and backfill also repair unchanged memory rows whose content hash stayed the same but whose project key was stale. FTS5 update triggers now ignore metadata-only project rekeys, avoiding SQLite virtual-table errors during safe repairs.
-
-Installer parity also improved: first-time install now auto-provisions RTK when Cargo is available, the Eagle Mem statusline shows version/session/memory/turn counts, `eagle-mem statusline` is available as a CLI command, and Codex instructions explicitly call out that Codex currently has hook recall plus the statusline command rather than Claude Code's persistent custom statusline UI.
-
-### v4.9.1 Patch
-
-`eagle-mem updates status` now refreshes the npm version live, and install/update seed the local latest-version cache with the installed version. This avoids confusing status output immediately after an update.
-
-### v4.9.0 Patch
-
-Eagle Mem now auto-updates by default for patch bug fixes. SessionStart performs a throttled background npm check, applies eligible patch releases with a lock and runtime/database backup, runs `eagle-mem update`, and records a one-time notice for the next session. Minor and major releases stay outside the default auto-apply range unless users opt in with `eagle-mem updates enable minor` or `eagle-mem updates enable major`.
-
-### v4.8.6 Patch
-
-`eagle-mem session save --summary "..."` now exists as a clean manual fallback for agents that need to persist an explicit session note. It writes through the same `sessions` and `summaries` tables used by Stop hooks, keeps Claude Code/Codex source attribution, and is immediately searchable through normal recall.
-
-### v4.8.5 Patch
-
-First-run configuration no longer exits silently when Ollama is not listening on `localhost:11434`; Eagle Mem falls through to the installed Codex/Claude CLI provider or API-key providers. SQLite/FTS5 failures are now surfaced before DB-backed commands run, including the exact `sqlite3` binary being used and PATH guidance for common macOS Android SDK shadowing. Worker worktree paths are also canonicalized back to the main project key so backfill cannot move feature guardrails into disposable orchestration worktrees.
-
-### v4.8.4 Patch
-
-The orchestration handoff path is now Bash 3.2-safe, so `eagle-mem orchestrate handoff` works even when no lane options are present. This patch was verified with a real Codex coordinator -> Claude Code worker proof lane using `claude-opus-4-7` at `xhigh`; the completed lane is visible through `eagle-mem orchestrate --json`, `eagle-mem tasks completed`, and the generated handoff output. Release-boundary detection also ignores Eagle Mem's own `feature verify`/`waive` commands, so verification notes can mention dry-run checks without blocking themselves.
-
-### v4.8.3 Patch
-
-GitHub Pages now keeps hero text readable over the terminal background and the homepage explicitly explains installer-created/updated `CLAUDE.md` and `AGENTS.md` sections plus orchestrator/worker mode. Installer/update output also uses the new clean-output Codex wording instead of saying it added eagle-summary instructions.
-
-### v4.8.2 Patch
-
-Codex no longer gets instructed to print large user-visible `<eagle-summary>` XML blocks. The installer/update path rewrites existing `~/.codex/AGENTS.md` Eagle Mem instructions to the clean-output contract, context-pressure nudges use normal prose, and Codex-oriented skills/worker prompts avoid raw capture templates.
-
-### v4.8.1 Patch
-
-`eagle-mem memories sync` is now safe on large Claude Code/Codex memory files. The memory mirror parser no longer uses early-exit pipelines under `pipefail`, avoiding exit `141` during sync.
+All notable releases and patch updates are documented in the separate [CHANGELOG.md](CHANGELOG.md) file.
 
 ### Search Modes
 
@@ -339,12 +260,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)
 
@@ -354,7 +275,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" \