DEV Community

Ndonda Daniel
Ndonda Daniel

Posted on

How to Restore Lost Chat History in Google Antigravity IDE (Reverse Engineering, The Plan Mystery, and Ready-to-Use Solutions)

#architecture #debugging #programming #tutorial

If you have ever launched Google Antigravity IDE only to be greeted by the dreaded "No Conversations Found" message in your history, or noticed that dozens of past AI chat sessions have vanished from your sidebar, you are not alone.

Many developers assume their conversation data was permanently wiped out after:

  • Updating or reinstalling the IDE (e.g. migrating between tarball, Ubuntu Snap, or Flatpak packages);
  • Clearing editor caches or resetting application state;
  • Extended periods of inactivity or UI cache eviction (LRU cache limits);
  • Transient disconnections from the internal language daemon.

The great news is: your data was never deleted from your computer.

In this article, we dissect the internal architecture of Google Antigravity IDE, uncover the intriguing case of the "Implementation Plan" that resurrected a lost conversation on its own, and provide two production-ready open-source solutions: a native editor extension (antigravity-history-restorer) and a standalone, dependency-free Python script.

The Curious Case of the "Implementation Plan": The Key Clue

Before diving into code, consider this real-world diagnostic scenario:

"I once had a chat that disappeared entirely from my history panel, but I still had its Implementation Plan (Artifact) tab open in the editor. Instead of starting a new chat, I clicked the **Review ▾* menu on the artifact and used Submit comment ('Add a message...'). The exact second the comment went through, the entire missing conversation reappeared in my chat history list!"*

Why did that happen? Was it a coincidence?

No, this is precisely how Antigravity's internal architecture is designed.

  1. Artifacts are intrinsically bound to their parent conversation: Implementation plans, code diffs, and walk-through artifacts store the unique identifier of the conversation that originated them (cascadeId).
  2. Direct wake-up via Review: Submitting feedback via Review ▾ → Submit comment invokes an RPC method on the local Language Server daemon, instructing it to process user input on the trajectory associated with that cascadeId.
  3. Waking up the SQLite database: The Language Server reads the disk, locates the corresponding database file (~/.gemini/antigravity-ide/conversations/<cascadeId>.db), loads the trajectory into memory, and emits an internal synchronization event (antigravityUnifiedStateSync.trajectorySummaries).
  4. Immediate UI re-indexing: Upon receiving the state synchronization event, the VS Code frontend immediately updates its conversation cache and restores the chat in the sidebar and the Search all convos... palette.

In short: conversations are never deleted; they simply enter a dormant state on disk because the IDE does not keep hundreds of heavy conversation trajectories in frontend memory simultaneously.

The Hidden Architecture of Antigravity IDE

To restore any conversation on demand without having an artifact open, we must understand the three distinct tiers of Antigravity:

┌────────────────────────────────────────────────────────┐
│                   VS Code UI (Frontend)                │
│  - Agent Panel, History, "Search all convos..."        │
│  - Volatile frontend cache: state.vscdb                │
└───────────────────────────▲────────────────────────────┘
                            │
               RPC Connect (HTTP/POST JSON)
               Port 127.0.0.1:<random> + CSRF Token
                            │
┌───────────────────────────▼────────────────────────────┐
│         Language Server (language_server_linux_x64)    │
│  - Background AI daemon engine                         │
│  - Handles agent streaming, diffs, and indexing        │
└───────────────────────────▲────────────────────────────┘
                            │ On-Disk Read
┌───────────────────────────▼────────────────────────────┐
│            Persistent Storage on Disk                  │
│  ~/.gemini/antigravity-ide/conversations/*.db (SQLite) │
│  ~/.gemini/antigravity-ide/brain/* (JSONL & Artifacts) │
└────────────────────────────────────────────────────────┘
Enter fullscreen mode Exit fullscreen mode
  1. The Persistent Layer: Located at ~/.gemini/antigravity-ide/conversations/. Every conversation is an individual SQLite database file (.db) containing messages, agent tool calls, diffs, and trajectories.
  2. The Presentation Layer (UI Cache): Stored in ~/.config/Antigravity IDE/User/globalStorage/state.vscdb. This is merely an ephemeral frontend cache. If this cache is cleared or rebuilt, the history panel appears blank.
  3. The Awakening Protocol: The Language Server exposes an internal RPC API via the Connect protocol over localhost. When issuing an HTTP POST to: 
   POST /exa.language_server_pb.LanguageServerService/GetCascadeTrajectorySteps
Enter fullscreen mode Exit fullscreen mode

with the headers:

  • Connect-Protocol-Version: 1
  • X-Codeium-Csrf-Token: <process-csrf-token> and the JSON payload {"cascadeId": "<conversation-id>", "startIndex": 0, "endIndex": 2}, the engine loads the .db file into memory and pushes it to the editor UI immediately.

Why Legacy History Extensions Fail

If you search extension marketplaces for older extensions like antigravity-history, you will find that most of them no longer work.

The technical reason is straightforward:

  • Older extensions searched for deprecated .pb (Protobuf binary) files inside legacy Codeium directories;
  • Modern releases of Google Antigravity IDE migrated persistence to relational SQLite databases (.db) and JSONL trajectory logs;
  • Because legacy tools do not recognize .db files and cannot communicate with the modern Language Server Connect RPC, they report zero conversations found.

Solution 1: The Native Extension (antigravity-history-restorer)

To provide a seamless, 1-click recovery workflow integrated directly into the editor, we developed the Antigravity History Restorer extension.

How It Works

The extension executes directly inside the VS Code / Antigravity IDE environment:

  1. Detects the running Language Server process and dynamically discovers its local listening ports and CSRF token (with support across Linux, macOS, and Windows);
  2. Scans conversation directories (~/.gemini/antigravity-ide/conversations);
  3. Displays a native VS Code progress bar in the status area while restoring each conversation;
  4. Provides an immediate prompt to open the conversation search palette or reload the window.

Extension Source Code

The extension is written in TypeScript and cleanly modularized in the official open-source repository:

  • 📄 src/extension.ts — Extension entry point, command registration, and native progress notification lifecycle.
  • 📄 src/detector.ts — Dynamic port discovery and CSRF token extraction from the active Language Server process.
  • 📄 src/restorer.ts — Local SQLite database scanner and Connect RPC dispatcher.

How to Use in Antigravity IDE

  1. Open the Command Palette (Ctrl+Shift+P on Linux/Windows or Cmd+Shift+P on macOS);
  2. Type and select: 
   Antigravity: Restore Missing Chats
Enter fullscreen mode Exit fullscreen mode
  1. Watch the recovery progress in real time. Once finished, reopen your conversations via the history icon (🕒) or the Search all convos... shortcut.

📦 Open VSX Marketplace: Antigravity History Restorer

🌟 GitHub Repository: NdondaDaniel2020/antigravity-history-restorer

Solution 2: Standalone Python Script (scripts/restore_antigravity_history.py)

If you prefer a terminal-based solution or do not wish to install an extension, we also provide a self-contained Python script that accomplishes the same recovery in under 10 seconds using only Python's standard library (no pip install required):

How to Run the Script

  1. Ensure Antigravity IDE is running;
  2. Run in your terminal: 
# Option A: If you have already cloned the repository
python3 scripts/restore_antigravity_history.py

# Option B: Download and run directly via curl (no git clone required)
curl -sO https://raw.githubusercontent.com/NdondaDaniel2020/antigravity-history-restorer/main/scripts/restore_antigravity_history.py
python3 restore_antigravity_history.py
Enter fullscreen mode Exit fullscreen mode
  1. Done! All conversations are immediately re-indexed into the editor.

Conclusion

Modern AI-augmented IDEs rely on complex multi-tier architectures: persistent on-disk databases (SQLite/JSONL), local language server daemons, and ephemeral UI caches. Understanding the boundary between true persistent storage and presentation-layer caching turns a panicked moment of perceived data loss into a 10-second fix.

You can now recover your lost conversations anytime — whether with a single click through the native extension, or via a quick terminal script!

Resources & Links

Top comments (0)