Support Antigravity CLI SQLite sessions (#580)

## Summary

*Resolves a breaking change in antigravity-cli release 1.0.4
(2026-06-01) release.*

Adds support for newer Antigravity CLI sessions that are stored as
per-conversation SQLite `.db` files under
`~/.gemini/antigravity-cli/conversations/`.

This keeps the existing encrypted `.pb` + `agy-reader` sidecar flow
intact, while allowing Agentsview to index the newer DB-backed sessions
directly.

## Changes

- Discover Antigravity CLI `conversations/<uuid>.db` files and prefer
them over same-ID `.pb` files.
- Classify `.db`, `.db-wal`, and `.db-shm` filesystem events back to the
canonical DB source.
- Parse CLI SQLite DB steps through the existing Antigravity
SQLite/protobuf path.
- Include SQLite WAL/SHM mtimes in effective file info so live session
updates resync reliably.
- Clean noisy internal strings from DB-decoded transcripts, including
step headers, UUIDs, opaque request IDs, model placeholders, AGY config
paths, and tool-action JSON blobs.
- Tighten prompt replacement from `history.jsonl` so sparse or blank
history rows do not misassign prompts.
- Update README guidance for the two Antigravity CLI storage formats.

## Root Cause

Recent Antigravity CLI releases now write `conversations/<uuid>.db`
instead of the older encrypted `conversations/<uuid>.pb` format.
Agentsview only discovered `.pb` files for Antigravity CLI, so newer
sessions were invisible. Once DB discovery was added, the old protobuf
string-extraction heuristic surfaced internal protocol strings in the
visible transcript; this PR filters those strings and prefers
human-facing prompt text.

## Follow-up

Tracked in #579: newer `history.jsonl` rows may omit `conversationId`,
so DB sessions can parse cleanly but still lack project inference from
history. That should be handled conservatively by matching
prompt/timestamp proximity rather than assuming every nearby history row
belongs to a DB.

## Validation

- `go test ./internal/parser ./internal/sync`
- Tested against local Antigravity CLI `.db` sessions before and after
the code changes; transcript parsing produced a clean first user message
without step headers or internal IDs.

---------

Co-authored-by: Wes McKinney <wesmckinn+git@gmail.com>

Author: mjacobs

README.md

@@ -255,12 +255,14 @@ Each directory can be overridden with an environment variable. See the
 
 ### Antigravity CLI: high-resolution transcripts
 
-By default, agentsview indexes Antigravity CLI sessions in **summary mode**:
-your prompts from `history.jsonl` plus any plain-text artifacts under `brain/`
-(plans, walkthroughs, checkpoints). Assistant turns and tool calls live in
-AES-GCM-encrypted `.pb` files and are not visible in this mode.
-
-To unlock full transcripts, run
+Antigravity CLI sessions now appear in two on-disk formats. Newer releases
+store conversation trajectories as SQLite `.db` files, which agentsview indexes
+directly. Older releases stored assistant turns and tool calls in
+AES-GCM-encrypted `.pb` files; for those sessions, agentsview falls back to
+**summary mode** using your prompts from `history.jsonl` plus any plain-text
+artifacts under `brain/` (plans, walkthroughs, checkpoints).
+
+To unlock full transcripts for older `.pb` sessions, run
 [agy-reader](https://github.com/mjacobs/agy-reader) alongside agentsview.
 agy-reader talks to the local Antigravity daemon, decrypts each conversation,
 and writes a `<uuid>.trajectory.json` sidecar next to the encrypted `.pb` file.

internal/db/db.go

@@ -28,12 +28,22 @@ import (
 // trigger a non-destructive re-sync (mtime reset + skip cache
 // clear) so existing session data is preserved.
 //
-// Bumped to 30: Hermes parser no longer treats cost_status
+// Bumped to 32: Antigravity DB parsers now filter internal
+// protocol strings from visible message content, remove raw step
+// headers, prefer prompt-like user text, and merge matching
+// Antigravity CLI history prompts when DB decoding drops short user
+// turns. Existing Antigravity DB rows need re-parsing so previously
+// indexed noisy or assistant-only transcripts are rewritten.
+//
+// (31: Copilot shutdown usage events use positional DedupKey to
+// handle multi-segment sessions correctly.)
+//
+// (30: Hermes parser no longer treats cost_status
 // "included" as a confident $0 when cost_source is "none"/empty (its
 // default for models it does not price, e.g. gpt-5.5). Such rows now
 // leave cost_usd nil so they are catalog-priced. Existing Hermes rows
 // need re-parsing so their usage cost reflects the catalog instead of a
-// baked-in $0.
+// baked-in $0.)
 //
 // (29: secret findings now record tool_result_event
 // coordinates by the persisted slice position (matching
@@ -102,9 +112,7 @@ import (
 //
 // (17: Codex <skill> template filtering.)
 // (16: <turn_aborted> system messages.)
-// (31: Copilot shutdown usage events use positional DedupKey to
-// handle multi-segment sessions correctly.)
-const dataVersion = 31
+const dataVersion = 32
 
 const tokenCoverageRepairStatsKey = "token_coverage_repair_v1"
 

internal/parser/antigravity.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"regexp"
 	"sort"
 	"strings"
 	"time"
@@ -24,6 +25,10 @@ import (
 
 const antigravityIDPrefix = "antigravity:"
 
+var antigravityUUIDLikeRE = regexp.MustCompile(
+	`^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$`,
+)
+
 // DiscoverAntigravitySessions returns one DiscoveredFile per
 // conversations/<uuid>.db under the IDE root.
 func DiscoverAntigravitySessions(root string) []DiscoveredFile {
@@ -172,43 +177,61 @@ func ParseAntigravitySession(
 }
 
 func loadAntigravitySteps(db *sql.DB) ([]ParsedMessage, error) {
+	result, err := loadAntigravityStepsWithRawCount(db)
+	if err != nil {
+		return nil, err
+	}
+	return result.messages, nil
+}
+
+type antigravityStepLoadResult struct {
+	messages     []ParsedMessage
+	rawStepCount int
+}
+
+func loadAntigravityStepsWithRawCount(
+	db *sql.DB,
+) (antigravityStepLoadResult, error) {
 	rows, err := db.Query(
 		`SELECT idx, step_type, step_payload FROM steps ` +
 			`ORDER BY idx`,
 	)
 	if err != nil {
-		return nil, fmt.Errorf("query steps: %w", err)
+		return antigravityStepLoadResult{}, fmt.Errorf("query steps: %w", err)
 	}
 	defer rows.Close()
-	var out []ParsedMessage
+	var result antigravityStepLoadResult
 	for rows.Next() {
 		var (
 			idx      int
 			stepType int
 			payload  []byte
 		)
 		if err := rows.Scan(&idx, &stepType, &payload); err != nil {
-			return nil, fmt.Errorf("scan step: %w", err)
+			return antigravityStepLoadResult{}, fmt.Errorf("scan step: %w", err)
 		}
+		result.rawStepCount++
 		msg, ok := decodeAntigravityStep(idx, stepType, payload)
 		if !ok {
 			continue
 		}
-		out = append(out, msg)
+		result.messages = append(result.messages, msg)
 	}
 	if err := rows.Err(); err != nil {
-		return nil, fmt.Errorf("iterate steps: %w", err)
+		return antigravityStepLoadResult{}, fmt.Errorf("iterate steps: %w", err)
 	}
-	return out, nil
+	return result, nil
 }
 
 // decodeAntigravityStep extracts a ParsedMessage from one step's
 // protobuf payload. Without an upstream .proto we use heuristics:
 //   - role: step_type 14 has been observed to carry user prompts.
 //     Every other type is rendered as assistant. (TODO: refine
 //     when more sample data is available.)
-//   - content: concatenation of every UTF-8 string >= 20 chars
-//     found anywhere in the payload tree, deduped.
+//   - content: best-effort human-facing strings found in the
+//     payload tree. Internal ids, local Antigravity config paths,
+//     model placeholders, and duplicate payload echoes are filtered
+//     out. User-input steps prefer a single prompt-like string.
 //   - timestamp: earliest google.protobuf.Timestamp-shaped field.
 func decodeAntigravityStep(
 	idx, stepType int, payload []byte,
@@ -220,7 +243,9 @@ func decodeAntigravityStep(
 	if err != nil || len(fields) == 0 {
 		return ParsedMessage{}, false
 	}
-	strs := dedupeStrings(agProtoCollectStrings(fields, 20))
+	strs := cleanAntigravityStepStrings(
+		dedupeStrings(agProtoCollectStrings(fields, 20)), stepType,
+	)
 	ts := earliestAntigravityTimestamp(fields)
 	if len(strs) == 0 {
 		return ParsedMessage{}, false
@@ -229,10 +254,7 @@ func decodeAntigravityStep(
 	if stepType == 14 {
 		role = RoleUser
 	}
-	header := fmt.Sprintf(
-		"[step %d · type %d]", idx, stepType,
-	)
-	content := header + "\n" + strings.Join(strs, "\n\n")
+	content := strings.Join(strs, "\n\n")
 	return ParsedMessage{
 		Role:          role,
 		Content:       content,
@@ -254,6 +276,135 @@ func dedupeStrings(in []string) []string {
 	return out
 }
 
+func cleanAntigravityStepStrings(
+	strs []string, stepType int,
+) []string {
+	var cleaned []string
+	for _, s := range strs {
+		s = strings.TrimSpace(s)
+		if isNoisyAntigravityStepString(s) {
+			continue
+		}
+		cleaned = append(cleaned, s)
+	}
+	cleaned = dedupeStrings(cleaned)
+	if stepType == 14 {
+		if prompt := bestAntigravityUserPrompt(cleaned); prompt != "" {
+			return []string{prompt}
+		}
+	}
+	return cleaned
+}
+
+func isNoisyAntigravityStepString(s string) bool {
+	if s == "" {
+		return true
+	}
+	if antigravityUUIDLikeRE.MatchString(s) {
+		return true
+	}
+	if strings.HasPrefix(s, "MODEL_PLACEHOLDER_") {
+		return true
+	}
+	if strings.HasPrefix(s, "{") &&
+		(strings.Contains(s, `"toolAction"`) ||
+			strings.Contains(s, `"toolSummary"`) ||
+			strings.Contains(s, `"DirectoryPath"`)) {
+		return true
+	}
+	if looksLikeAntigravityOpaqueID(s) {
+		return true
+	}
+	if strings.HasPrefix(s, "file:///home/") {
+		return true
+	}
+	if strings.HasPrefix(s, "/home/") &&
+		strings.Contains(s, "/.gemini/") {
+		return true
+	}
+	if strings.HasPrefix(s, "/Users/") &&
+		strings.Contains(s, "/.gemini/") {
+		return true
+	}
+	if strings.HasPrefix(s, `C:\Users\`) &&
+		strings.Contains(s, `\.gemini\`) {
+		return true
+	}
+	if strings.HasPrefix(s, "command(") ||
+		strings.HasPrefix(s, "execute_url(") ||
+		strings.HasPrefix(s, "read_url(") ||
+		strings.HasPrefix(s, "mcp(") {
+		return true
+	}
+	return false
+}
+
+func looksLikeAntigravityOpaqueID(s string) bool {
+	if strings.ContainsAny(s, " \n\t") {
+		return false
+	}
+	if len(s) < 16 || len(s) > 128 {
+		return false
+	}
+	var alpha, digit, symbol int
+	for _, r := range s {
+		switch {
+		case r >= 'a' && r <= 'z', r >= 'A' && r <= 'Z':
+			alpha++
+		case r >= '0' && r <= '9':
+			digit++
+		case r == '_' || r == '-' || r == '.':
+			symbol++
+		default:
+			return false
+		}
+	}
+	if alpha+digit+symbol != len(s) {
+		return false
+	}
+	if digit == len(s) || digit+symbol == len(s) {
+		return true
+	}
+	return alpha > 0 && digit > 0
+}
+
+func bestAntigravityUserPrompt(strs []string) string {
+	var best string
+	bestScore := -1
+	for _, s := range strs {
+		score := antigravityPromptScore(s)
+		if score > bestScore {
+			best = s
+			bestScore = score
+		}
+	}
+	if bestScore <= 0 {
+		return ""
+	}
+	return best
+}
+
+func antigravityPromptScore(s string) int {
+	trimmed := strings.TrimSpace(s)
+	if trimmed == "" || isNoisyAntigravityStepString(trimmed) {
+		return -1
+	}
+	score := len(trimmed)
+	if strings.ContainsAny(trimmed, " \n\t") {
+		score += 50
+	}
+	if strings.HasPrefix(trimmed, "{") || strings.HasPrefix(trimmed, "[") {
+		score -= 100
+	}
+	if strings.HasPrefix(trimmed, "/") || strings.HasPrefix(trimmed, "file://") {
+		score -= 100
+	}
+	if !strings.ContainsAny(trimmed, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") {
+		score -= 100
+	}
+	return score
+}
+
 // earliestAntigravityTimestamp walks the field tree and returns
 // the earliest plausible google.protobuf.Timestamp value.
 // Plausible = seconds field in the year 2000..2100 range.