DEV Community: Ndonda Daniel

Como Recuperar o Histórico de Conversas no Google Antigravity IDE (Engenharia Reversa, Mistério do Plano e Soluções Prontas)

Ndonda Daniel — Fri, 18 Sep 2026 11:48:54 +0000

Se você já abriu o Google Antigravity IDE e se deparou com a fatídica mensagem "No Conversations Found" no histórico ou percebeu que dezenas de chats com a IA simplesmente sumiram da lista, você não está sozinho.

Muitos desenvolvedores acreditam que suas conversas foram apagadas após:

Atualizar ou reinstalar o IDE (ex: migração manual para pacote Snap ou Flatpak);
Limpar caches ou redefinir configurações do editor;
Períodos de inatividade ou limites de exibição da interface (LRU Cache eviction);
Pequenas desconexões temporárias do motor de linguagem interno.

A grande notícia é: os seus dados nunca foram apagados do seu computador.

Neste artigo, desvendamos a arquitetura interna do Antigravity IDE, explicamos o caso fascinante do "Plano de Implementação" que ressuscitou um chat sozinho, e apresentamos duas soluções definitivas: uma extensão nativa para o editor (antigravity-history-restorer) e um script standalone em Python.

O Caso Curioso do "Plano de Implementação": A Chave da Charada

Antes de olhar para o código, vale analisar um relato real e intrigante:

"Eu já tive um chat que sumiu completamente do histórico, mas eu ainda estava com a aba do Plano de Implementação (Implementation Plan / Artifact) aberta no editor. Em vez de abrir um novo chat, cliquei no menu **Review ▾* do próprio plano e usei a opção Submit comment ('Add a message...'). No segundo seguinte em que enviei o comentário pelo plano, o chat inteiro reapareceu na lista de conversas!"*

Por que isso aconteceu? É coincidência?

Não, é exatamente assim que o ecossistema do Antigravity funciona.

Os Artefatos têm vínculo direto com o chat: Planos de implementação, walk-throughs e artefatos de código guardam internamente o identificador único da conversa que os originou (cascadeId).
A "cutucada" direta pelo Review: Ao enviar um comentário pelo botão Review ▾ → Submit comment do artefato, a interface do editor faz uma chamada direta ao Language Server solicitando que o feedback seja processado na trajetória correspondente àquele cascadeId.
O despertar do banco: O Language Server vai até o disco, localiza o banco de dados correspondente (~/.gemini/antigravity-ide/conversations/<cascadeId>.db), carrega toda a trajetória da conversa para a memória RAM e emite o evento de sincronização interna (antigravityUnifiedStateSync.trajectorySummaries).
O renascimento imediato na UI: Como efeito colateral dessa leitura, a interface do VS Code recebe a notificação de estado unificado e renderiza o chat de volta no histórico e na busca (Search all convos...) instantaneamente.

Em outras palavras: os chats nunca são apagados; eles apenas entram em estado adormecido no disco porque o editor não mantém centenas de conversas pesadas na memória RAM da interface simultaneamente.

A Arquitetura Oculta do Antigravity IDE

Para entender como recuperar qualquer conversa sem depender de ter um plano aberto, precisamos dissecar as camadas do Antigravity:

┌────────────────────────────────────────────────────────┐
│                   VS Code UI (Frontend)                │
│  - Painel do Agent, Histórico, "Search all convos..."  │
│  - Cache volátil: state.vscdb                          │
└───────────────────────────▲────────────────────────────┘
                            │
               RPC Connect (HTTP/POST JSON)
               Porta 127.0.0.1:<random> + CSRF
                            │
┌───────────────────────────▼────────────────────────────┐
│         Language Server (language_server_linux_x64)    │
│  - Motor daemon de IA em segundo plano                 │
│  - Responsável pelo streaming, diffs e contexto        │
└───────────────────────────▲────────────────────────────┘
                            │ Leitura de disco
┌───────────────────────────▼────────────────────────────┐
│            Armazenamento Persistente no Disco          │
│  ~/.gemini/antigravity-ide/conversations/*.db (SQLite) │
│  ~/.gemini/antigravity-ide/brain/* (JSONL & Artifacts) │
└────────────────────────────────────────────────────────┘

A Camada Persistente: Fica em ~/.gemini/antigravity-ide/conversations/. Cada conversa é um banco de dados SQLite com extensão .db contendo todas as mensagens, comandos executados e raciocínios da IA.
A Camada de Visualização (UI): Fica no arquivo ~/.config/Antigravity IDE/User/globalStorage/state.vscdb. É apenas um cache de interface. Se esse arquivo for recriado ou se o editor sofrer um reset, o histórico visual fica em branco.
O Protocolo de Despertar: O Language Server expõe uma API RPC interna via protocolo Connect na porta localhost. Ao chamarmos o método:

   POST /exa.language_server_pb.LanguageServerService/GetCascadeTrajectorySteps

com os headers:

Connect-Protocol-Version: 1
X-Codeium-Csrf-Token: <csrf-do-processo> e o payload {"cascadeId": "<id-do-banco>", "startIndex": 0, "endIndex": 2}, o motor lê o arquivo .db do disco para a memória e o republica para a interface do editor instantaneamente!

Por que as extensões legadas de histórico falham?

Se você pesquisar na loja do VS Code por extensões como antigravity-history, notará que a maioria não funciona mais.

O motivo técnico é simples:

Extensões antigas procuravam por arquivos binários legados com extensão .pb (Protobuf serializado antigo) na pasta do Codeium;
As versões modernas do Google Antigravity IDE migraram sua persistência para bancos SQLite relacionais (.db) e logs JSONL;
Como as extensões legadas não conhecem os arquivos .db nem sabem dialogar com a API RPC do Language Server, elas acusam que nenhuma conversa existe.

Solução 1: A Extensão Nativa (`antigravity-history-restorer`)

Para resolver esse problema de maneira definitiva e integrada ao fluxo do desenvolvedor, desenvolvemos a extensão Antigravity History Restorer.

Como funciona

A extensão roda diretamente dentro do VS Code / Antigravity IDE:

Detecta o processo em execução do Language Server e descobre dinamicamente seu token CSRF e portas locais (com suporte a Linux, macOS e Windows);
Varre as pastas de conversas (~/.gemini/antigravity-ide/conversations);
Exibe uma barra de progresso nativa no rodapé do editor restaurando cada conversa;
Oferece um botão imediato para abrir a busca de conversas ou recarregar a janela.

Código Fonte da Extensão

A extensão foi desenvolvida em TypeScript e organizada de forma modular no repositório oficial:

📄 src/extension.ts — Ponto de entrada, registro do comando na paleta e integração com a barra de notificações do editor.
📄 src/detector.ts — Descoberta dinâmica de portas e extração do token CSRF do processo do Language Server.
📄 src/restorer.ts — Varredura dos arquivos SQLite locais e execução das chamadas RPC para reindexação das conversas.

Como Utilizar no Editor

Abra a paleta de comandos (Ctrl+Shift+P no Linux/Windows ou Cmd+Shift+P no Mac);
Digite e selecione:

   Antigravity: Restore Missing Chats

Acompanhe a restauração em tempo real e volte a pesquisar suas conversas pelo ícone de histórico (🕒) ou atalho Search all convos....

📦 Repositório Open-Source no GitHub:

Todo o código da extensão, scripts de automação e documentação estão disponíveis publicamente em:

https://github.com/NdondaDaniel2020/antigravity-history-restorer

Solução 2: O Script Standalone em Python (`scripts/restore_antigravity_history.py`)

Se você não quer instalar uma extensão ou prefere executar uma solução rápida via terminal, disponibilizamos um script Python autocontido que resolve o problema em menos de 10 segundos utilizando exclusivamente a biblioteca padrão do Python (sem necessidade de instalar pacotes via pip):

🐍 scripts/restore_antigravity_history.py — Código-fonte completo e comentado no GitHub.

Como Executar o Script

Certifique-se de que o Antigravity IDE está aberto;
Execute no seu terminal:

# Opção A: Se você já clonou o repositório
python3 scripts/restore_antigravity_history.py

# Opção B: Download e execução rápida com curl (sem clonar o repositório)
curl -sO https://raw.githubusercontent.com/NdondaDaniel2020/antigravity-history-restorer/main/scripts/restore_antigravity_history.py
python3 restore_antigravity_history.py

Pronto! Todas as conversas retornam imediatamente à interface.

Conclusão

Sistemas de desenvolvimento modernos baseados em IA frequentemente operam com múltiplos processos em segundo plano (daemons, sockets locais e caches em memória). Entender a divisão entre a camada de persistência real (SQLite/JSONL) e a camada de indexação da interface (State Sync) é o que separa o desespero de perder semanas de trabalho da solução elegante com engenharia reversa.

Agora você pode restaurar seu histórico a qualquer momento — seja com um clique pela extensão, seja com uma chamada rápida de script!

Links e Recursos

Repositório oficial no GitHub: https://github.com/NdondaDaniel2020/antigravity-history-restorer
Extensão do Open VSX: https://open-vsx.org/extension/NdondaDaniel2020/antigravity-history-restorer

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

Ndonda Daniel — Fri, 18 Sep 2026 11:47:42 +0000

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.

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).
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.
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).
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) │
└────────────────────────────────────────────────────────┘

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.
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.
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

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:

Detects the running Language Server process and dynamically discovers its local listening ports and CSRF token (with support across Linux, macOS, and Windows);
Scans conversation directories (~/.gemini/antigravity-ide/conversations);
Displays a native VS Code progress bar in the status area while restoring each conversation;
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

Open the Command Palette (Ctrl+Shift+P on Linux/Windows or Cmd+Shift+P on macOS);
Type and select:

   Antigravity: Restore Missing Chats

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):

🐍 scripts/restore_antigravity_history.py — Full source code with detailed inline documentation.

How to Run the Script

Ensure Antigravity IDE is running;
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

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

Extension on Open VSX: https://open-vsx.org/extension/NdondaDaniel2020/antigravity-history-restorer
Official GitHub Repository: https://github.com/NdondaDaniel2020/antigravity-history-restorer