Antigravity → Claude Code migration

Bring a user's Google Antigravity context into Claude Code in four steps: extract conversations + brain artifacts from disk → document them as readable Markdown plus an index → migrate project settings/rules into Claude Code equivalents → continue the most recent conversation.

Antigravity stores agent data locally under ~/.gemini/ (two surfaces: the Agent Manager and the IDE). Nothing is fetched from the network.

When to use

• "extract / recover / export / back up my Antigravity conversations or artifacts"
• "I'm migrating from Antigravity (Google Antigravity) to Claude Code"
• "document / summarize what I did with Antigravity"
• "continue my last Antigravity conversation" / "pick up where Antigravity left off"

What's bundled (resolve paths from this skill's directory)

• scripts/extract_antigravity.py — standalone, no-dependency extractor. Discovers both Antigravity surfaces, decodes the SQLite/protobuf conversation format, copies brain artifacts, reads conversation titles from the summaries protobuf, and exports project permission grants + MCP config. Writes one Markdown transcript per decodable conversation + manifest.json + antigravity-settings.json. Run it — do not re-implement the parsing.
• references/storage-and-formats.md — exactly where Antigravity stores what, the step-type table for the SQLite format, and which files are encrypted. Read it if discovery finds nothing or to explain the mechanics to the user.

Procedure

1 — Extract (deterministic, read-only)

List first, then extract:

python3 <skill>/scripts/extract_antigravity.py --list           # discover + preview
python3 <skill>/scripts/extract_antigravity.py --out <out-dir>  # write everything

• Pick <out-dir>: if the project has a docs/ directory, use docs/antigravity-history/; otherwise ./antigravity-history/.
• To scope to one project, add --filter <substring> (matches workspace path, title or content). --no-reasoning drops model thinking; --tool-output includes truncated tool results.
• Expect some conversations to be encrypted (kind: encrypted-pb in the manifest): older/Manager conversations are stored as encrypted blobs that cannot be decoded. Their titles, timestamps and brain artifacts are still recovered — the artifacts usually carry the substance (plan, tasks, walkthrough). Tell the user this honestly; do not present it as data loss without mentioning what was recovered.
• If --list finds nothing: read references/storage-and-formats.md, check the candidate paths printed to stderr, and ask the user where they ran Antigravity (different machine / remote host).
• Output: transcripts/*.md (faithful), artifacts/<conv>/… (brain Markdown copied verbatim), manifest.json, antigravity-settings.json. Skim manifest.json (sorted oldest → newest; the last row is the most recent conversation) to decide what matters.

2 — Document (you write these)

In <out-dir>:

• sessions/<same-filename>.md — a tight summary per conversation: title, date, goal, what was done, files changed, key decisions, outcome, open threads. For encrypted conversations, summarize from their brain artifacts instead of a transcript. If there are many, fan out subagents (one per conversation).
• README.md — an index: 2–3 sentence intro, a chronological table (date | linked conversation | one-line outcome), a grouping by theme, and a pointer to the brain artifacts.

3 — Migrate settings & context into Claude Code

This step is what makes the move complete; use judgement, ask before overwriting.

• CLAUDE.md — distill the durable project context (architecture decisions, conventions, constraints recorded in brain artifacts and transcripts) into the project's CLAUDE.md (create it, or merge if it exists). Don't paste history; extract only what a fresh agent needs to know going forward.
• Permissions — antigravity-settings.json contains Antigravity's per-project permission grants. Map them into .claude/settings.json → permissions.allow: command(npm run) → Bash(npm run:*), command(npx) → Bash(npx:*), mcp(server/tool) → mcp__server__tool. Skip read_url(*)/execute_url(...) unless the user wants WebFetch rules.
• MCP servers — if mcp_config is non-null, translate each server into .mcp.json at the project root (same command/args/env shape).
• Rules & workflows — repo-level AGENTS.md / GEMINI.md / .agent/rules/ content belongs in CLAUDE.md (or stays in AGENTS.md, which Claude Code also reads). Global rules, if found under the data roots, go to ~/.claude/CLAUDE.md — propose, don't silently write.
• Skills — a repo .agents/skills/ directory (agent-agnostic skills) works with Claude Code as-is; mention it rather than duplicating into .claude/skills/.

4 — Continue the most recent conversation

This is usually the user's real goal.

• Take the last row of manifest.json; read its full transcript (or brain artifacts if encrypted). Cross-reference against the current repo state (git log, the files it touched) to separate what actually landed from what was only discussed.
• Write <out-dir>/CONTINUE_HERE.md: where it left off (exact stop point), what landed vs. discussed, verified vs. unverified, open problems, and a prioritized next-steps checklist referencing concrete files/commands.
• Then offer to do the next step.

Notes & guarantees

• The extractor is read-only on Antigravity storage: SQLite files are copied to a temp dir before opening (WAL-safe), and it writes only under --out. No network, no extra packages (standard library only).
• The conversation protobufs carry no public schema; the extractor decodes them generically and classifies steps by observed type (user / assistant / tool / error). Unknown step types are skipped silently rather than guessed.
• The division of labor is deliberate: the script does the exact, verbatim extraction (no hallucination risk); you do the summarizing, the settings mapping, and the judgement calls.
• This skill is distributable: no hard-coded paths or project assumptions — discovery, --root and --filter are fully general.