[AI-1160] Antigravity ingest (Phase 4, CLI): historical import

[realtonyyoung]

Draft — stacked on #256 (Phase 2 CLI). Base is tonyyoung/ai-1158-antigravity-cli for a clean diff; retarget to main once #256 merges. Depends on Phase 1 (kcap-server#933) + Phase 2 (#256).

Phase 4 (AI-1160) of Google Antigravity ingest — historical import kcap import --antigravity, the last phase of the epic (parent AI-1150).

What's here (3 commits)

• AntigravitySubagents.BuildParentMap (Core) — child→parent conversation map from each brain dir's .system_generated/messages/*.json ({sender:child, recipient:parent}). This linkage is unreliable at live child-start (why live nesting is deferred) but complete on disk at import time.
• AntigravityImportSource — mirrors GeminiImportSource (routed phase, JSONL transcript, watermark-idempotent — no ledger since the transcript is append-only). Discovers ~/.gemini/antigravity/brain/* dirs, treats roots (non-children) as top-level sessions, and imports their children as subagents (subagent-start → child transcript routed by agent_id → subagent-stop, fail-closed). Wired into Program.cs allSources + VendorSelection (turns on the --antigravity import flag deferred from Phase 2).
• AntigravityImportTests (WireMock) + README/help-import.txt.

Notes for review

• Session id: the import uses the raw (dashed) conversation id, which the server normalizes to the canonical dashless form in session-start/end, the transcript pipeline, AND the /last-line watermark probe (CanonicalSessionId.Normalize in all four). So a re-import and a live-captured session converge on the same dashless stream; no client-side dedup issue applies to import (unlike the live disable marker, which [AI-1158] Antigravity ingest (Phase 2, CLI): plugin, hook dispatch, watcher, cost backfill #256 fixed).
• cwd is left null (Antigravity records no machine-readable workspace path in the transcript — same v1 limitation as Gemini; live capture gets it from the hook payload).
• Cost on import is deferred (a documented follow-up): Antigravity's cost is off-transcript in gen_metadata, so importing it needs completeness tracking so a failed USAGE send after a complete transcript still retries. Imported sessions currently carry content + subagent nesting but not cost; live capture has cost.

Testing

41 antigravity CLI unit tests + 2 import WireMock integration tests green (full import with subagent nesting + AlreadyLoaded idempotency). AOT publish clean on the Phase 2 base.

Linear: AI-1160. Closes # (GitHub issue to be linked).

🤖 Generated with Claude Code

[linear-code]

AI-1160

[realtonyyoung]

Reviewed only the three commits unique to PR #262 on top of #256. I found issues in Antigravity subagent retry/idempotency, child watermark resume, non-tree parent-map handling, and the import help text. Per request, I did not run tests or builds.

[realtonyyoung]

Returning here means an AlreadyLoaded root never reaches ImportChildrenAsync. If the first import posts the parent transcript and session-end but a child was skipped (watermark probe failure, subagent-start failure, missing transcript, or transcript POST failure), the next run classifies the root from the parent watermark as AlreadyLoaded and permanently skips the child. That breaks the intended child-retry behavior; child completeness needs to participate in classification, or AlreadyLoaded roots with children need a child repair pass before skipping.

[realtonyyoung]

Fixed in 3280754. ImportSessionAsync no longer returns early for AlreadyLoaded: it now runs ImportChildrenAsync as a repair pass (each child classifies independently by its own (rootId, childId) HWM) before reporting Skipped, so a subagent skipped on a prior run is retried instead of lost. New test: ImportSession_AlreadyLoaded_root_repairs_a_missing_child.

[realtonyyoung]

Here the child HWM is applied as a line-number offset while still reading from line 0. For a child whose server HWM is 1, the next repair sends local lines 0 and 1 again as line_numbers 2 and 3, duplicating already imported content instead of resuming at raw line 2. Antigravity is append-only JSONL like the parent/Gemini path, so this should use the HWM as startLine (hwm + 1) rather than re-numbering the whole child transcript.

[realtonyyoung]

Fixed in 3280754. Children now resume via startLine: hwm + 1 with lineNumberOffset: 0 (removed), so surviving lines keep their true file position — matching the parent/Gemini resume. Also skips a child whose HWM already covers its last import-relevant line before touching any hook. New test: ImportChildren_resumes_by_line_position_without_shifting_numbers asserts a resumed child posts line_numbers:[1], not the shifted [1,2].

[realtonyyoung]

Keeping the first parent for any sender makes invalid/non-tree linkages look valid. Because discovery later drops every key from top-level roots and only imports direct Children for each root, a chain like P<-C<-G imports C under P but never imports G, and a cycle A<->B produces no roots at all; conflicting parents are also nondeterministic because enumeration order is not guaranteed. We should either reject/ignore non-tree edges (multiple parents, cycles, child that is also a parent) or traverse/import recursively so these conversations are not silently lost or mis-nested.

[realtonyyoung]

Fixed in 3280754. BuildParentMap is now deterministic on conflicts (smallest-ordinal parent wins). Added ResolveTopLevelAncestor (cycle-safe walk-up — a cycle member resolves to itself) and BuildRootDescendants (root → all transitive descendants). Discovery enumerates every brain dir and nests grandchildren+; so P<-C<-G imports both C and G under P, and A<->B import standalone rather than vanishing. New tests cover deterministic conflict, deep-chain, cycle, and transitive discovery.

[realtonyyoung]

This now says all eight, but Program registers nine import sources and the vendor list below includes both OpenCode and Antigravity. The source table above also still omits the OpenCode DB path, so kcap import --help understates what the command actually walks.

[realtonyyoung]

Fixed in 3280754. Help text now says "all nine", adds OpenCode/Antigravity to the intro sentence, and adds the OpenCode SQLite db source line (~/.local/share/opencode/opencode.db) to the path table.

[realtonyyoung]

Re-reviewed commit 3280754 and its interaction with the Antigravity import path. The four prior fixes look correct for parent skip/child repair, child resume-by-position, transitive subagent grouping, and help text/vendor count, but I found one remaining lifecycle retry issue in the new fully-loaded-child skip path. Per request, I did not run tests or builds.

[realtonyyoung]

This HWM-only skip makes fully ingested child content imply a complete child lifecycle, but subagent-stop is still best-effort below: if the child transcript POST succeeds and then the stop hook returns non-2xx or throws, the next import sees done >= childLastImportable here and skips before retrying any hook. That leaves the subagent without its completion event permanently, even though the failure happened after content import and should be repairable on re-import. Consider either treating stop failure as an incomplete child or still posting an idempotent stop for fully-loaded children when lifecycle completeness is not otherwise known.

[realtonyyoung]

Fixed in a125072. A fully-ingested child no longer returns before the stop hook: it now re-posts subagent-stop (idempotent server-side — deterministic SubagentCompleted id via AgentLifecycleDeterministicId) so a prior run's failed-after-content stop is repaired, while an already-recorded stop dedupes. subagent-start is not re-posted (content is fail-closed behind it, so its success is implied by the ingested content) and the child content is not re-sent. New test: ImportChildren_fullyIngestedChild_reposts_idempotent_stop_without_resending_content asserts subagent-stop is posted but neither transcript nor subagent-start.

[realtonyyoung]

Re-reviewed commit a125072. The focused change prevents content and subagent-start from being resent and keeps AlreadyLoaded-root outcome as Skipped, but I found one remaining repair gap around the server's transient active-agent guard for stop-only retries. I did not run tests or builds.

[realtonyyoung]

This stop-only repair still depends on the server remembering the child as active. Server-side RecordAgentStopAsync returns before appending SubagentCompleted when SessionStateTracker.TryClearActiveAgent(sessionId, agentId) is false, and that tracker is transient in-memory state. So if the first import successfully posted subagent-start and child content, then subagent-stop failed and the server restarts before the re-import, this branch posts only stop, the server treats it as inactive/duplicate, and no completion event is written; the child HWM remains content-complete, so future imports repeat the no-op. To make the repair durable across process boundaries, the fully-ingested branch needs to re-post the idempotent start before stop (or the server stop endpoint needs to allow deterministic stop repair without an active mark).

[realtonyyoung]

Fixed in 57065cd. The fully-ingested branch now re-posts subagent-start THEN subagent-stop. Start re-marks the agent active (idempotent — deterministic SubagentStarted id via AgentLifecycleDeterministicId; already-active is a no-op), so a stop that follows clears the mark and appends SubagentCompleted even after a server restart wiped the transient active mark. This makes the completion repair durable across process boundaries. Child content is not re-sent. Test updated: ImportChildren_fullyIngestedChild_reposts_idempotent_start_and_stop_without_resending_content (asserts start-before-stop, no transcript).

[realtonyyoung]

Found one remaining issue: the new start-before-stop repair still needs strict lifecycle payloads so server-side start failures are visible to the importer. I did not run tests or builds.

[realtonyyoung]

[P2] Make the repair start hook strict. This branch treats a successful subagent-start POST as proof that the server re-marked the child active before posting stop, but BuildSubagentPayload does not send strict=true. On the server, SubagentStartHook.Strict defaults false, and HandleSubagentStart returns 200 even when RecordAgentStartAsync throws after rolling back the active mark. In that case this code still posts subagent-stop, which no-ops without an active agent, so the durable stop repair can silently fail. Please include strict=true on the synthetic subagent lifecycle payloads so lifecycle write failures surface as non-2xx and are retried.

[realtonyyoung]

Fixed in 93be269. The repair now sends strict=true on both synthetic subagent lifecycle payloads (BuildSubagentPayload gained a strict param). HandleSubagentStart returns 500 under strict when RecordAgentStartAsync throws+rolls back the active mark, so a start that actually failed no longer reads as 200 — stop is posted only when start truly re-marked the agent active, and a re-import retries otherwise. Test asserts the repair subagent-start body carries "strict":true.

[realtonyyoung]

Found one remaining issue: the strict repair payloads are now gated correctly for start, but the stop payload still needs the full SubagentStopHook shape before the server can honor strict on the stop route. I did not run tests or builds.

[realtonyyoung]

[P1] Build the full stop-hook payload before relying on strict. This builder is now used for the strict repair subagent-stop POST, but it still only emits the start-shaped fields. The server stop route binds SubagentStopHook, whose required fields include stop_hook_active, agent_transcript_path, and last_assistant_message; Cursor/Gemini/OpenCode send those because an incomplete body can be rejected before HandleSubagentStop runs. If this Antigravity stop payload is rejected at binding, strict is never honored by the stop handler, PostHookAsync returns false, and this repair repeats start->failed-stop forever while the child remains without SubagentCompleted. Please split start/stop payload builders or add the stop-only fields for subagent_stop, and cover the stop body in the repair test.

[realtonyyoung]

Fixed in a0ee6d2. Split the payload builder into BuildSubagentStartPayload / BuildSubagentStopPayload; the stop builder now emits the full SubagentStopHook shape (stop_hook_active, agent_transcript_path, last_assistant_message) mirroring GeminiSubagentDiscovery.BuildStopPayload, so the strict stop body binds and the strict handler actually runs (no more start→failed-stop loop). Test asserts the repair stop body carries those fields alongside strict:true.

[realtonyyoung]

NO FINDINGS

[qodo-code-review]

PR Summary by Qodo

Add Antigravity historical import (kcap import --antigravity) with subagent nesting

✨ Enhancement 🐞 Bug fix 🧪 Tests 📝 Documentation 🕐 40+ Minutes

AI Description

• Add kcap import --antigravity to backfill Antigravity brain transcripts via watermark
 idempotency.
• Infer parent/child conversation nesting from on-disk messages and import children as subagents.
• Fix Antigravity live plugin install path by writing a required GUI plugin.json manifest.

Diagram

graph TD
  CLI["kcap import --antigravity"] --> SRC[["AntigravityImportSource"]] --> FS[("Antigravity brain dirs")]
  SRC --> SUB[["AntigravitySubagents"]] --> FS
  SRC --> HWM{{"GET /api/sessions/:id/last-line"}} --> SRV["kcap-server"]
  SRC --> HK{{"POST /hooks/*"}} --> SRV

  subgraph Legend
    direction LR
    _cli["CLI cmd"] ~~~ _mod[["CLI/Core module"]] ~~~ _fs[("Filesystem") ] ~~~ _api{{"HTTP endpoint"}} ~~~ _srv["Server"]
  end

Loading

High-Level Assessment

The following are alternative approaches to this PR:

1. Factor a shared routed-import base class (Gemini/Antigravity)

• ➕ Reduces duplicated watermark/statistics/payload boilerplate across vendors
• ➕ Centralizes edge-case handling (last-relevant-line logic, resume semantics, retry behavior)
• ➖ Adds abstraction overhead while only 2 vendors currently need it
• ➖ Harder to keep vendor-specific lifecycle quirks readable

2. Add an import ledger instead of watermark-only idempotency

• ➕ More robust recovery if server watermark endpoint changes or is unavailable
• ➕ Could track lifecycle completion separately from content watermark
• ➖ Extra local state to manage and migrate
• ➖ Less aligned with append-only transcript model and existing Gemini approach

3. Inject cost from gen_metadata during import (now)

• ➕ Imported sessions would match live capture completeness (usage/cost)
• ➖ Requires completeness tracking to safely retry cost sends independently of transcript
• ➖ Increases failure modes and review surface for this phase

Recommendation: Current approach (Gemini-style watermark idempotency + routed transcript ingestion) is the right fit for Antigravity’s append-only JSONL transcripts and matches server normalizer expectations. The most valuable follow-up is cost injection once an idempotent completeness model exists; factoring a shared routed-import base can wait until another vendor shares the same shape.

Files changed (16) +1314 / -60

Enhancement (4) +550 / -3

AntigravitySubagents.csResolve Antigravity child→parent conversation map for import-time nesting +101/-0

Resolve Antigravity child→parent conversation map for import-time nesting

• Adds import-time subagent linkage resolution by scanning each brain dir’s '.system_generated/messages/*.json'. Builds a deterministic child→parent map, provides cycle-safe ancestor resolution, and groups conversations into root→descendants for session/subagent import.

src/Capacitor.Cli.Core/Antigravity/AntigravitySubagents.cs

AntigravityImportSource.csImplement Antigravity historical import with watermark resume and subagent routing +444/-0

Implement Antigravity historical import with watermark resume and subagent routing

• Adds a full 'IImportSource' implementation that discovers Antigravity brain transcripts, classifies sessions via '/last-line' watermarks using the last import-relevant line, and imports lifecycle + transcript batches. Imports children as subagents (routed by 'agent_id') with fail-closed start/stop ordering, strict lifecycle repair for fully-ingested children, and correct resume-by-file-position semantics.

src/Capacitor.Cli/Commands/AntigravityImportSource.cs

VendorSelection.csAdd '--antigravity' vendor filter parsing and validation +4/-3

Add '--antigravity' vendor filter parsing and validation

• Extends vendor flag recognition to include '--antigravity', including unknown-option validation and hinting logic consistency with other vendor-specific flags.

src/Capacitor.Cli/Commands/VendorSelection.cs

Program.csWire AntigravityImportSource into import source registry +1/-0

Wire AntigravityImportSource into import source registry

• Registers 'AntigravityImportSource' in the CLI’s 'allSources' list so 'kcap import --antigravity' is selectable via vendor filtering and participates in discovery/classification/import flows.

src/Capacitor.Cli/Program.cs

Bug fix (3) +103 / -19

AntigravityHooks.csAdd Antigravity GUI plugin manifest builder and version +20/-0

Add Antigravity GUI plugin manifest builder and version

• Introduces a 'plugin.json' manifest payload ('BuildPluginManifest') and a conservative dotted 'PluginVersion'. This supports installing Antigravity capture as a GUI-recognized plugin directory rather than a CLI-only config location.

src/Capacitor.Cli.Core/Antigravity/AntigravityHooks.cs

AntigravityHooksInstaller.csInstall/remove Antigravity capture as a GUI plugin dir (plugin.json + hooks.json) +56/-10

Install/remove Antigravity capture as a GUI plugin dir (plugin.json + hooks.json)

• Changes install to write a required 'plugin.json' first (failing the install if it cannot be written), then merges/writes 'hooks.json' and the version marker. Updates removal behavior to delete 'hooks.json' when it becomes empty, and to keep 'plugin.json' as long as any hooks remain (to avoid disabling user blocks).

src/Capacitor.Cli.Core/Antigravity/AntigravityHooksInstaller.cs

AntigravityPaths.csMove Antigravity hook/plugin paths under GUI config root +27/-9

Move Antigravity hook/plugin paths under GUI config root

• Replaces the previous CLI-root hooks path with GUI plugin paths under '~/.gemini/config/plugins/kcap/'. Adds helpers for GUI config root, plugin dir, plugin manifest, and workspace plugin dir; updates global/workspace hooks.json locations accordingly.

src/Capacitor.Cli.Core/Antigravity/AntigravityPaths.cs

Tests (5) +623 / -6

AntigravityImportTests.csWireMock integration coverage for Antigravity import + subagent lifecycle repair +282/-0

WireMock integration coverage for Antigravity import + subagent lifecycle repair

• Adds end-to-end WireMock tests asserting hook call ordering for root + subagent import, AlreadyLoaded root child repair behavior, strict lifecycle reposting without resending content for fully ingested children, and correct resume line numbering for partial child imports.

test/Capacitor.Cli.Tests.Integration/AntigravityImportTests.cs

AntigravityHooksInstallerTests.csUnit tests for plugin.json manifest lifecycle and failure modes +58/-0

Unit tests for plugin.json manifest lifecycle and failure modes

• Adds tests ensuring 'Install' writes 'plugin.json', 'Remove' deletes it only when safe, install fails hard if manifest cannot be written, and removal preserves the manifest when user-authored hook blocks remain.

test/Capacitor.Cli.Tests.Unit/AntigravityHooksInstallerTests.cs

AntigravityImportSourceTests.csUnit tests for Antigravity import discovery and relevance filtering +131/-0

Unit tests for Antigravity import discovery and relevance filtering

• Validates that only roots are discovered as top-level sessions, descendants are attached transitively, session filtering is honored, and 'IsImportRelevantLine' matches only event-producing step types used for watermark comparisons.

test/Capacitor.Cli.Tests.Unit/AntigravityImportSourceTests.cs

AntigravityPathsTests.csUpdate path tests for GUI plugin directory layout +16/-6

Update path tests for GUI plugin directory layout

• Replaces CLI-root expectations with assertions that plugin dir, hooks.json, and plugin.json live under the GUI config root. Updates workspace hooks location tests to match '.agents/plugins/kcap/hooks.json'.

test/Capacitor.Cli.Tests.Unit/AntigravityPathsTests.cs

AntigravitySubagentsTests.csUnit tests for child→parent mapping, determinism, and cycle safety +136/-0

Unit tests for child→parent mapping, determinism, and cycle safety

• Adds coverage for building the parent map from messages files, ignoring malformed/self-linkage, resolving deep ancestors, handling cycles safely, and grouping root descendants for import nesting.

test/Capacitor.Cli.Tests.Unit/AntigravitySubagentsTests.cs

Documentation (4) +38 / -32

README.mdDocument Antigravity import flag and historical import behavior +8/-7

Document Antigravity import flag and historical import behavior

• Adds Antigravity to the supported import vendor list and documents 'kcap import --antigravity'. Updates Antigravity plugin notes to reflect GUI plugin installation location and that historical import nests subagents and is watermark-idempotent.

README.md

help-import.txtExpose '--antigravity' vendor filter and Antigravity transcript location +15/-11

Expose '--antigravity' vendor filter and Antigravity transcript location

• Updates import help text to include Antigravity and its transcript path under '~/.gemini/antigravity/brain/.../transcript_full.jsonl'. Adds '--antigravity' to the vendor filters list alongside existing sources.

src/Capacitor.Cli.Core/Resources/help-import.txt

help-plugin.txtUpdate Antigravity plugin help to reflect GUI plugin installation +13/-12

Update Antigravity plugin help to reflect GUI plugin installation

• Changes help text to describe installing/removing the Antigravity capture plugin under '~/.gemini/config/plugins/kcap/' (manifest + hooks file). Removes references to the deprecated '~/.gemini/antigravity-cli/hooks.json' location.

src/Capacitor.Cli.Core/Resources/help-plugin.txt

UninstallCommand.csUpdate uninstall messaging for Antigravity plugin directory removal +2/-2

Update uninstall messaging for Antigravity plugin directory removal

• Adjusts uninstall output and plugin removal invocation comments to reflect removing the Antigravity GUI plugin directory rather than deleting a hooks block in the old CLI location.

src/Capacitor.Cli/Commands/UninstallCommand.cs

[qodo-code-review]

Code Review by Qodo

🐞 Bugs (1) 📘 Rule violations (0) 📎 Requirement gaps (0) 🎨 UX issues (0) 🔗 Cross-repo conflicts (0) 📜 Skill insights (0)

1. AlreadyLoaded skips lifecycle ✓ Resolved 🐞 Bug ≡ Correctness

Description

AntigravityImportSource.ImportSessionAsync returns early for AlreadyLoaded, so it never re-posts
session-start/antigravity and session-end/antigravity. If a prior run advanced the transcript
watermark but lifecycle posting failed (especially session-end), the import pipeline will keep
routing AlreadyLoaded sessions for repair but Antigravity will never repair the missing lifecycle
events.

Code

src/Capacitor.Cli/Commands/AntigravityImportSource.cs[R164-172]

+        // An AlreadyLoaded root's parent transcript is fully imported, but a subagent may have
+        // been skipped on a prior run (watermark probe / subagent-start / transcript POST
+        // failure). Children classify independently by their own HWM, so still run a child-repair
+        // pass — complete children are no-ops, incomplete ones resume — then report Skipped.
+        // Without this, a once-skipped child would be lost forever (AI-1160 review).
+        if (c.Status == ImportCommand.ClassificationStatus.AlreadyLoaded) {
+            await ImportChildrenAsync(ctx.HttpClient, ctx.BaseUrl, c.SessionId, c.SourceMeta!, ct);
+            return ImportOutcome.Skipped;
+        }

Evidence

Antigravity currently returns before any parent lifecycle POSTs on AlreadyLoaded, while the import
orchestrator explicitly routes AlreadyLoaded routed-phase sessions so sources can re-assert
lifecycle after watermark-only progress. Cursor demonstrates the expected pattern by always posting
lifecycle and letting the transcript leg become a no-op for AlreadyLoaded.

src/Capacitor.Cli/Commands/AntigravityImportSource.cs[159-172]
src/Capacitor.Cli/Commands/ImportCommand.cs[880-894]
src/Capacitor.Cli/Commands/CursorImportSource.cs[353-413]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
`AntigravityImportSource.ImportSessionAsync` short-circuits on `ClassificationStatus.AlreadyLoaded` and only repairs children. This prevents lifecycle repair for the parent session (session-start/session-end), despite `ImportCommand` routing `AlreadyLoaded` routed-phase sessions specifically to enable lifecycle re-assertion.

## Issue Context
- `ImportCommand` includes `AlreadyLoaded` in the routed set so sources can re-emit lifecycle hooks when a previous run advanced the transcript watermark but lifecycle failed.
- Cursor (and Gemini) keep posting lifecycle even when there is no transcript content to send.

## Fix Focus Areas
- src/Capacitor.Cli/Commands/AntigravityImportSource.cs[159-204]
- src/Capacitor.Cli/Commands/ImportCommand.cs[880-894]

## Suggested fix
- In the `AlreadyLoaded` branch, post parent lifecycle hooks (at least `session-end/antigravity`, ideally both start+end) using the same payload builders, then run `ImportChildrenAsync`, and only then return `ImportOutcome.Skipped`.
- Consider failing the import (return `ImportOutcome.Failed`) if lifecycle repair POSTs fail, so reruns can retry repair (mirrors Cursor’s hard-fail posture for lifecycle).

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

---

2. Unescaped agentId query ✓ Resolved 🐞 Bug ☼ Reliability

Description

FetchServerLastLineAsync interpolates agentId directly into the ?agentId= query string without
URL escaping. If agentId ever contains reserved characters, watermark probing for subagents can
hit the wrong endpoint or fail, breaking resume/repair logic.

Code

src/Capacitor.Cli/Commands/AntigravityImportSource.cs[R419-422]

+    static async Task<int?> FetchServerLastLineAsync(
+            HttpClient http, string baseUrl, string sessionId, string? agentId, CancellationToken ct) {
+        var url = $"{baseUrl}/api/sessions/{sessionId}/last-line" + (agentId is not null ? $"?agentId={agentId}" : "");
+        using var resp = await http.GetWithRetryAsync(url, ct: ct);

Evidence

Antigravity uses raw ?agentId={agentId} while Cursor escapes agentId for the same endpoint,
indicating the safe/expected contract is to encode the query parameter.

src/Capacitor.Cli/Commands/AntigravityImportSource.cs[419-422]
src/Capacitor.Cli/Commands/CursorImportSource.cs[634-639]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
`FetchServerLastLineAsync` constructs `/last-line?agentId=...` using raw string interpolation. This is fragile for IDs containing reserved URI characters.

## Issue Context
Cursor’s implementation of the same probe escapes `agentId` with `Uri.EscapeDataString`, which avoids malformed URLs and unintended query parsing.

## Fix Focus Areas
- src/Capacitor.Cli/Commands/AntigravityImportSource.cs[419-429]

## Suggested fix
- Build the URL using `Uri.EscapeDataString(agentId)` (and consider using `UriBuilder`/`QueryHelpers` style composition if available).
- Keep behavior identical when `agentId` is null (no query string).

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

---

3. Full scan despite filter 🐞 Bug ➹ Performance

Description

DiscoverAsync always builds a global parent map by scanning every
brain/*/.system_generated/messages/*.json before applying FilterSession, so `kcap import
--session <id> --antigravity` still performs O(total history) filesystem IO. This scan also cannot
be cancelled because BuildParentMap has no CancellationToken integration.

Code

src/Capacitor.Cli/Commands/AntigravityImportSource.cs[R55-71]

+        // Resolve every conversation to its top-level ancestor: roots (no parent) import as
+        // sessions; ALL transitive descendants (children, grandchildren, …) import as their
+        // root's subagents. Cycle-/non-tree-safe (BuildRootDescendants) so a deep chain isn't
+        // lost and a cycle imports standalone rather than vanishing. Linkage is complete on disk.
+        var parentMap = AntigravitySubagents.BuildParentMap(_home, _geminiCliHome);
+        var convIds   = Directory.EnumerateDirectories(BrainRoot).Select(Path.GetFileName).OfType<string>().ToList();
+        var byRoot    = AntigravitySubagents.BuildRootDescendants(convIds, parentMap);
+
+        var sinceUtc = filters.Since is { } since
+            ? new DateTimeOffset(since.ToDateTime(TimeOnly.MinValue, DateTimeKind.Utc), TimeSpan.Zero)
+            : (DateTimeOffset?)null;
+
+        foreach (var (convId, descendants) in byRoot) {
+            ct.ThrowIfCancellationRequested();
+
+            if (filters.FilterSession is { } fs && !string.Equals(convId, fs, StringComparison.Ordinal)) continue;
+

Evidence

Discovery constructs parentMap and byRoot before checking FilterSession, and the parent map
builder enumerates all brain directories and message JSON files without any cancellation checks.

src/Capacitor.Cli/Commands/AntigravityImportSource.cs[51-71]
src/Capacitor.Cli.Core/Antigravity/AntigravitySubagents.cs[22-54]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
Antigravity discovery eagerly scans the entire brain tree’s messages to build a complete child→parent map even when the caller requests a single session via `FilterSession`. This makes targeted imports unnecessarily slow and ignores cancellation during that scan.

## Issue Context
- `AntigravitySubagents.BuildParentMap` enumerates all brain dirs and parses all message JSON files.
- `DiscoverAsync` only checks `filters.FilterSession` after building the full map.

## Fix Focus Areas
- src/Capacitor.Cli/Commands/AntigravityImportSource.cs[51-71]
- src/Capacitor.Cli.Core/Antigravity/AntigravitySubagents.cs[22-54]

## Suggested fix
- Add a `CancellationToken` parameter to `AntigravitySubagents.BuildParentMap` and check it inside both directory and file loops.
- In `DiscoverAsync`, if `filters.FilterSession` is set, consider a fast path:
 - validate that `brain/<id>` exists and the transcript exists;
 - either (a) skip nesting for that fast path, or (b) compute descendants via a targeted scan rather than scanning every brain directory.
- At minimum, pass the cancellation token through so Ctrl+C (or pipeline cancellation) can interrupt the scan.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

---