diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 5b643e6..632cd45 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -51,6 +51,7 @@ jobs:
           - muse
           - omp
           - opencode
+          - opencode-v2
           - openhands
           - pi
           - qwen
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9d75a84..0a38eb6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,66 @@ here. Native format compatibility is documented separately in
 
 ## Unreleased
 
+- Add version-aware OpenCode 2.0 public session transfer support, retaining the
+  legacy 1.17.20 adapter and native no-overwrite/dry-run controls. Preserve
+  portable tools, inline media, and completed compaction summaries, and account
+  for incomplete tools and provider-private state.
+
+## 0.12.1 - 2026-10-16
+
+- Accept the compaction loop Claude Code records when the compact summary is not
+  the boundary's direct child. The declaration is unchanged, but how many
+  attachment records the CLI interleaves varies, so the summary can sit three or
+  four parent hops below its boundary, and `preservedMessages` also names ids
+  from the summarized branch that are no longer on the active path. A readable
+  73 MB transcript with two compactions was refused as `Claude active graph
+  contains an ancestry cycle`; the loop is now validated as declared (the tail
+  walks up to the summary, the summary up to the boundary, every hop already on
+  the walked path) and a declaration that does not close still fails.
+- Import a bundle the target store caps at 5 MiB per session by raising the
+  budget to what the bundle needs — never past the 25 MiB that store's own web
+  import accepts — and reporting `target_import_budget_raised` in the manifest.
+  A session carrying pasted screenshots (inline base64 images) produced a
+  6.88 MB bundle and was refused with `session exceeds the import size limit`,
+  although the store keeps that content.
+
+## 0.12.0 - 2026-10-16
+
+- Resolve the Hermes home the way the CLI does: `HERMES_HOME` when set,
+  otherwise `%LOCALAPPDATA%\hermes` on Windows and `~/.hermes` elsewhere. A bare
+  `~/.hermes` on Windows named a directory the CLI never writes to, so
+  `--to hermes` (and catalog discovery) missed the real store unless the caller
+  exported `HERMES_HOME` by hand.
+- Move the Hermes import bundle across the process boundary as UTF-8 bytes
+  (`sys.stdin.buffer`, explicit stdout/stderr decoding, `-X utf8` child) instead
+  of locale-encoded text. On a Windows console whose code page is not UTF-8 the
+  old path replaced every non-ASCII character in the imported conversation —
+  title and message bodies — with `U+FFFD`.
+- Install a Hermes session untitled instead of refusing the migration when the
+  target store already holds that title: Hermes enforces a partial unique index
+  over non-null titles, and its own importer treats the field as cosmetic. The
+  omission is counted as `title:duplicate_in_target` and reported as a
+  `target_title_omitted` manifest warning.
+- Promote the Hermes Agent adapter to 0.22.2 (tag `v2026.9.24`) and SQLite
+  schema 31, keeping `SessionDB.import_sessions` as the native write boundary.
+- Resolve the 0.22.2 runtime through `hermes --print-runtime-command` and
+  reproduce the launcher's `hermes_bootstrap` prelude, so the installer works
+  with a store Python that ships without third-party packages. The install root
+  comes from `hermes --version` (or the launcher's own bootstrap), and the
+  launcher shebang remains the fallback for builds predating the flag.
+- Fix Hermes installation on Windows: keep the Windows essentials in the
+  sanitized child environment, initialize a missing `state.db` through the
+  native `SessionDB` constructor, and close the manifest identity guard before a
+  rollback unlinks it (`WinError 32`).
+- Add first-class support for Antigravity Desktop (macOS/Electron) 2.18.1
+  with bidirectional conversion, SQLite schema adaptation, Hub Summaries
+  Protobuf cache synchronization (`agyhub_summaries_proto.pb`), project-scoped
+  sidebar discovery, and verified native Go language server integration.
+- Document the clean-room Antigravity Desktop storage architecture, Protobuf
+  wire formats, Connect-RPC interfaces, and collision invariants in
+  `docs/antigravity-desktop-format.md`.
+
+
 ## 0.11.0 - 2026-09-11
 
 - Read root Codex rollouts written with `history_mode: "paginated"` by using
diff --git a/docs/antigravity-desktop-format.md b/docs/antigravity-desktop-format.md
new file mode 100644
index 0000000..471e0be
--- /dev/null
+++ b/docs/antigravity-desktop-format.md
@@ -0,0 +1,189 @@
+# Antigravity Desktop session format
+
+`session-migrate` supports Antigravity Desktop (macOS, Linux, and Windows)
+through a clean-room adapter pinned to the 2.18.1 release:
+
+| Property | Pinned value |
+| --- | --- |
+| Application | Antigravity Desktop `2.18.1` (Electron `44.3.0`) |
+| macOS arm64 binary | `148,990,608` bytes, SHA-256 `300ee20f3108a511be1149602b91ba84cbbdcc42213067151e255584129be30f` |
+| Linux x64 binary | `181,432,528` bytes, SHA-256 `ab4937445fa3817bc374a1db71062de7daecdb093cbfb6bd36b80f443198670e` |
+| Windows x64 binary | `163,640,320` bytes, SHA-256 `1ed84e6a1d1e51064d80c9f382ab3a519eb2775cb91d552c63064a18cfdf3cf2` |
+| Conversation store | `<home>/.gemini/antigravity/conversations/<uuid>.db` |
+| Picker index | `<home>/.gemini/antigravity/conversation_summaries.db` (`PRAGMA user_version = 3`) |
+| Hub summary cache | `<home>/.gemini/antigravity/agyhub_summaries_proto.pb` |
+| UI project catalog | `<home>/.gemini/config/projects/<id>.json` + `app_storage.json` |
+
+This is deliberately not a claim of compatibility with unreleased or arbitrary
+Antigravity versions. Automatic installation checks executable digests and
+schema invariants when native verification is requested.
+
+No vendor code, binaries, descriptors, credentials, or user transcripts are
+included in this repository. All schemas, wire mappings, and RPC endpoints were
+established through clean-room differential probing and synthetic test fixtures.
+
+## How the format was established
+
+The adapter was derived from independent observations of synthetic sessions and
+package analysis across macOS, Linux, and Windows distributions:
+
+1. generate synthetic conversations with unique marker text in isolated environments;
+2. inspect SQLite schema, columns, and Protobuf wire field numbers and types;
+3. analyze Electron application resources (`app.asar`), verifying identical JavaScript
+   (`3c03ce352dc3c1b43f357c27ead1f73c74d198a8ded89b1b3d6a2539e7a6ac5c`) across all three OSes;
+4. inspect native Go language server (`language_server`) symbols and Connect-RPC endpoints;
+5. verify round-trip serialization and cold-reload step retrieval via Connect-RPC
+   (`GetCascadeTrajectorySteps`); and
+6. test real-world conversation migration end-to-end with active multi-turn sessions.
+
+## SQLite layout
+
+Each conversation is stored as an independent SQLite 3 database with write-ahead
+logging (`WAL`) containing these tables:
+
+```text
+trajectory_meta
+steps
+gen_metadata
+executor_metadata
+parent_references
+trajectory_metadata_blob
+battle_mode_infos
+```
+
+While the table names match Antigravity CLI, Desktop enforces distinct wire and
+metadata invariants:
+
+| Property | Antigravity CLI (`antigravity`) | Antigravity Desktop (`antigravity-desktop`) |
+| --- | --- | --- |
+| App data subdirectory | `~/.gemini/antigravity-cli` | `~/.gemini/antigravity` |
+| `trajectory_meta.source` | `17` (`CLI`) | `1` (`IDE` / `Hub`) |
+| `trajectory_metadata_blob` project ID | `"default-cli-project"` | `"outside-of-project"` (or workspace UUID) |
+| `conversation_summaries.source` | `"antigravity-cli"` | `""` (empty string) |
+| `conversation_summaries.app_data_dir` | `"antigravity-cli"` | `"antigravity"` |
+| `conversation_summaries.status` | `""` (empty string) | `"CASCADE_RUN_STATUS_IDLE"` |
+| `conversation_summaries.project_id` | `"default-cli-project"` | `"outside-of-project"` |
+| Summary columns | 19 or 21 columns | 21 columns (includes `raw_summary`, `group_id`) |
+| Subagent trajectory roots | root ID == conversation ID | root ID points to root cascade ID |
+
+The main `trajectory_meta` row stores a fresh trajectory UUID, conversation UUID,
+trajectory type `4` (cascade), and source `1` (`IDE`/`Hub`). `steps.idx` is a
+contiguous zero-based sequence. Every step duplicates its type and status in
+both the SQLite row columns and the serialized `Step` blob.
+
+### Sidebar discovery and project grouping
+
+Antigravity Desktop filters sidebar conversations strictly by active projects:
+
+1. **Active Projects List**: Tracked in `app_storage.json` under `projectsOrder`.
+   - macOS: `~/Library/Application Support/Antigravity/app_storage.json`
+   - Linux: `$XDG_CONFIG_HOME/Antigravity/app_storage.json` (or `~/.config/Antigravity`)
+   - Windows: `%APPDATA%\Antigravity\app_storage.json`
+2. **Project Configurations**: Stored in `~/.gemini/config/projects/<id>.json`,
+   defining `project_id`, workspace paths, and display labels.
+3. Unassociated conversations (`project_id = "outside-of-project"`) are not
+   grouped in the project tree; assigning a registered project ID ensures instant
+   sidebar visibility.
+
+## Protobuf subset and Hub cache
+
+The adapter contains a bounded wire codec without generated vendor classes. It
+accepts canonical varints, length-delimited bytes, and fixed 32/64-bit wire types.
+
+The `Step` envelope uses:
+
+| Field | Meaning |
+| --- | --- |
+| `1` | step type enum |
+| `4` | step status enum |
+| `19` | user-input payload when type is `14` (`CORTEX_STEP_TYPE_USER_INPUT`) |
+| `20` | planner-response payload when type is `15` (`CORTEX_STEP_TYPE_PLANNER_RESPONSE`) |
+| `140` | generic-tool payload when type is `132` (`CORTEX_STEP_TYPE_GENERIC_TOOL`) |
+
+Status `3` is done, status `5` is cleared, and status `7` is error. User-input
+field `2` stores visible user text. Planner-response field `1` stores visible
+assistant text, field `6` stores a fresh message ID, and repeated field `7`
+stores tool calls.
+
+### Hub summary cache (`agyhub_summaries_proto.pb`)
+
+Antigravity Desktop caches summaries in `agyhub_summaries_proto.pb`. On startup,
+the native Go process reconciles SQLite records with this protobuf cache. If a
+conversation exists in SQLite but has no entry in the cache or `raw_summary`
+column, metadata fields reset to zero defaults (`0001-01-01`). The adapter
+synchronizes both stores during installation.
+
+## Conversion policy
+
+| Portable event | Antigravity Desktop representation |
+| --- | --- |
+| User text | done user-input step |
+| Assistant text | done planner-response step |
+| Tool call | planner-response tool call |
+| Tool result | following generic-tool step |
+| Thinking/reasoning | omitted and counted as `thinking:private` |
+| Compaction | omitted and counted |
+| System/developer message | omitted as privileged context |
+| Images and other context | omitted by type and counted |
+| Unknown/opaque source event | omitted by reason and counted |
+
+Private chain-of-thought is not portable. Thinking bytes and model signatures are
+omitted from generated outputs, and source reading emits only a content-free
+`thinking` marker.
+
+A tool result without a preceding call receives a fresh synthetic call and an
+explicit orphan counter. Duplicate or out-of-order IDs are rewritten or counted
+to prevent corrupted native trajectories.
+
+## Reading and installation
+
+Source databases may have active write-ahead logs (`.db-wal`). The reader uses
+SQLite's backup API to obtain a transactionally consistent snapshot, then hashes
+and parses that snapshot. It validates:
+
+- exact table, column, and schema invariants;
+- SQLite page bounds and `integrity_check`;
+- valid canonical UUIDv4 IDs and source `1` / `17` discrimination;
+- contiguous step indices and supported step types; and
+- structurally valid, bounded protobuf values.
+
+Native installation creates target directories privately, reserves the summary
+ID with `BEGIN IMMEDIATE`, writes the database atomically, and commits the
+summary transaction. If a transaction fails, only newly created files are
+unlinked. Existing sessions are never overwritten.
+
+## Native validation evidence
+
+1. **Synthetic Round-Trip Invariants**: Synthetic multi-turn sessions with tool
+   invocations, results, and thinking events serialize and re-parse with exact
+   fidelity, asserting that thinking text is removed.
+2. **Native Language Server Verification**: The official Go binary
+   (`language_server`) was executed in an isolated sandbox, queried over Connect-RPC
+   (`GetCascadeTrajectorySteps`), and asserted to return all imported steps with
+   identical structure.
+3. **Live User Session Migration**: A live ESPHome voice satellite conversation
+   with 256 steps was migrated from Antigravity CLI to Antigravity Desktop,
+   confirming complete rendering and sidebar searchability.
+
+Run the test suite with:
+
+```console
+uv run pytest -q tests/test_antigravity_desktop_format.py
+```
+
+Run the native language server oracle (macOS with Antigravity Desktop installed):
+
+```console
+uv run pytest -q tests/test_antigravity_desktop_native.py
+```
+
+## Known boundaries
+
+- Native oracle hash validation is pinned to official release builds. Unvalidated
+  binaries can be tested with `SESSION_MIGRATE_UNVALIDATED_DESKTOP_BIN=1`.
+- Generic tool transport is visually render-proven; internal vendor-privileged tools
+  are preserved as generic tool steps to maintain auditability.
+- Private reasoning tokens, system instructions, and ephemeral UI selections are
+  not transferred.
+- Subagent conversations are mapped to independent portable sessions with their
+  parent reference preserved in metadata.
diff --git a/docs/cli-reference.md b/docs/cli-reference.md
index 98d95b0..26811cd 100644
--- a/docs/cli-reference.md
+++ b/docs/cli-reference.md
@@ -1,6 +1,6 @@
 # CLI reference
 
-This page documents `session-migrate` 0.11.0. `smigrate` is an exact shorthand
+This page documents `session-migrate` 0.12.1. `smigrate` is an exact shorthand
 for the same executable.
 
 ## Commands
@@ -175,7 +175,7 @@ installation still requires the exact pinned version.
 | Grok | `$GROK_HOME`, otherwise `~/.grok` |
 | Kilo Code | official CLI under its normal XDG data root |
 | OpenHands | `$OPENHANDS_CONVERSATIONS_DIR`, otherwise `~/.openhands/conversations` |
-| Hermes Agent | `$HERMES_HOME`, otherwise `~/.hermes` |
+| Hermes Agent | `$HERMES_HOME`, otherwise the CLI's platform default: `%LOCALAPPDATA%\hermes` on Windows, `~/.hermes` elsewhere |
 | MastraCode | `$MASTRA_DB_PATH`; otherwise `$MASTRA_APP_DATA_DIR/mastra.db` or the platform data directory |
 | Devin CLI | `$XDG_DATA_HOME/devin/cli`, otherwise `~/.local/share/devin/cli` on Linux |
 
diff --git a/docs/credential-free-native-testing.md b/docs/credential-free-native-testing.md
index e8e834f..92b00ea 100644
--- a/docs/credential-free-native-testing.md
+++ b/docs/credential-free-native-testing.md
@@ -49,7 +49,7 @@ No production credential is read, translated, or written by this workflow.
 | Cursor `2026.03.20-44cb435` | Shipped backend loads blobs and the real TUI renders imported text; no offline model append |
 | Devin 3000.6.7 | Native list/resume selection and ACP `session/load`; stops at vendor authentication |
 | Grok 1.0.5 | OpenAI-compatible override; native creation, reload, TUI replay, and append |
-| Hermes 0.20.6 | OpenAI-compatible override; replay, append, and compaction |
+| Hermes 0.22.2 | OpenAI-compatible override; replay, append, and compaction |
 | Kilo 7.5.0 | Official import/export plus OpenAI-compatible replay and append |
 | Kimi 0.38.0 | OpenAI-compatible override; imported history replays and the reply persists |
 | MastraCode 0.37.1 | OpenAI-compatible override; replay and append |
@@ -82,3 +82,11 @@ harness and installations do not compete for disk space.
 The normal Python job separately runs the deterministic 18 by 18 route oracle.
 The native matrix is the independent acceptance layer: generated files must be
 accepted by code owned and shipped by each harness.
+
+## OpenCode v2 variant
+
+The additional `opencode-v2` job pins `@opencode/cli@2.0.23` and sets
+`SESSION_MIGRATE_TEST_OPENCODE_V2`. Its runner requires every assigned test to
+run without skips, exercising synthetic import/export, collisions, cold reopen
+and localhost-only continuation. Legacy `opencode` remains pinned to 1.17.20.
+See [the v2 transfer contract](opencode-v2.md).
diff --git a/docs/development.md b/docs/development.md
index e91554b..972ccd1 100644
--- a/docs/development.md
+++ b/docs/development.md
@@ -39,7 +39,7 @@ pytest and Ruff are development dependencies locked by `uv.lock`.
 | `src/session_migrate/formats/grok.py` | Grok 1.0.5 ACP-update adapter |
 | `src/session_migrate/formats/kilo.py` | Kilo Code 7.5.0 official-bundle adapter |
 | `src/session_migrate/formats/openhands.py` | OpenHands 1.16.0 SDK-event adapter |
-| `src/session_migrate/formats/hermes.py` | Hermes Agent 0.20.6 shared-state adapter |
+| `src/session_migrate/formats/hermes.py` | Hermes Agent 0.22.2 shared-state adapter |
 | `src/session_migrate/formats/mastracode.py` | MastraCode 0.37.1 LibSQL adapter |
 | `src/session_migrate/formats/devin.py` | Devin CLI 3000.6.7 active-forest adapter |
 | `src/session_migrate/formats/common.py` | Shared timestamps, text, and image validation |
diff --git a/docs/format-compatibility.md b/docs/format-compatibility.md
index 25e070d..3e68c96 100644
--- a/docs/format-compatibility.md
+++ b/docs/format-compatibility.md
@@ -20,9 +20,11 @@ to separately installed host binaries:
 | Codex CLI | `0.144.4` |
 | Pi source and target | `0.80.6` |
 | Oh My Pi source and target | `18.0.5` |
-| OpenCode source and target | `1.17.20` |
+| OpenCode legacy source and target | `1.17.20` |
+| OpenCode v2 transfer adapter | Linux gateway build `2.0.23` |
 | GitHub Copilot CLI source and target | `1.0.70` |
 | Antigravity CLI source and target | `1.1.16` |
+| Antigravity Desktop source and target | `2.18.1` |
 | Cursor Agent experimental text adapter | `2026.03.20-44cb435` |
 | Mistral Vibe source and target | `2.24.3` |
 | Muse Code source and target | `0.2.1 (0.2.1-R1215.1)` |
@@ -31,7 +33,7 @@ to separately installed host binaries:
 | Grok source and target | `1.0.5` |
 | Kilo Code source and target | `7.5.0` |
 | OpenHands source and target | `1.16.0` (SDK `1.21.0`) |
-| Hermes Agent source and target | `0.20.6` (tag `v2026.8.27`) |
+| Hermes Agent source and target | `0.22.2` (tag `v2026.9.24`, SQLite schema `31`) |
 | MastraCode source and target | `0.37.1` |
 | Devin CLI source and target | `3000.6.7` (`260a97c8`) |
 
@@ -54,6 +56,13 @@ rendering without a model append; Devin proves ACP loading and the vendor-login
 boundary. See
 [Credential-free native client testing](credential-free-native-testing.md).
 
+OpenCode 2.0.x has a separate public-transfer adapter. Its local synthetic tests
+cover native import/export, tool linkage, completed compaction, dry-run and
+identity conflicts; this does not extend the historical eighteen-client corpus
+validation claim. See [OpenCode v2 transfers](opencode-v2.md) for exact scope and
+limitations. No real user transcript migration or native Windows validation has
+been performed for this adapter.
+
 All eighteen formats are sources and targets. Their mappings, native probes, and
 loss keys are specified in [Additional native formats](additional-target-formats.md),
 [OpenCode source research](opencode-source-exploration.md),
diff --git a/docs/hermes-format.md b/docs/hermes-format.md
index 5e0e293..f8ea647 100644
--- a/docs/hermes-format.md
+++ b/docs/hermes-format.md
@@ -9,16 +9,18 @@ so the adapter fails closed on any other Hermes or schema version.
 | Item | Validated value |
 | --- | --- |
 | Project | [`NousResearch/hermes-agent`](https://github.com/NousResearch/hermes-agent) |
-| Release tag | `v2026.8.27` |
-| Python package | `hermes-agent==0.20.6` |
-| Source commit | `5fc308a70719a83cccdbba4c0e39c23f5a8239d5` |
-| Source-archive SHA-256 | `0ca18fcf97a69bad808ce4a0807694b25237afc61f7a13efab4f0aa26092a171` |
-| Native SQLite schema | `26` |
-| Observed CLI version | `Hermes Agent v0.20.6 (2026.8.27)` |
-
-The source archive hash is the SHA-256 of `git archive` at the pinned commit.
-The editable development launcher is deliberately not used as an artifact pin:
-its shebang contains the temporary installation path.
+| Release tag | `v2026.9.24` (also published as `v0.22.2`) |
+| Python package | `hermes-agent==0.22.2` |
+| Source commit | `d923a5eb487a17c0a68801bba9ef0f56c81040a8` |
+| Native SQLite schema | `31` |
+| Observed CLI version | `Hermes Agent v0.22.2 (2026.9.24) · stable · local d923a5eb487a` |
+
+The adapter now pins the same release the published launcher reports, instead of
+carrying a source-archive hash: a 0.22.2 git install reports its own build
+provenance on the version line, so the release identity is read from the
+launcher itself (`Hermes Agent v<version> (<release>)`, with any trailing
+`· stable · local <sha>` suffix tolerated) rather than from an artifact hash
+that a rebuild would invalidate.
 
 ## Native store and discovery
 
@@ -28,7 +30,11 @@ Hermes stores all CLI sessions in one SQLite database:
 $HERMES_HOME/state.db
 ```
 
-`HERMES_HOME` defaults to `~/.hermes`. Unlike file-per-session harnesses, a
+`HERMES_HOME` wins when it is set; otherwise the home is the CLI's own platform
+default — `%LOCALAPPDATA%\hermes` on Windows (`~/AppData/Local/hermes` when that
+variable is unset) and `~/.hermes` elsewhere. Resolving a bare `~/.hermes` on
+Windows used to name a directory the CLI never writes to.
+Unlike file-per-session harnesses, a
 Hermes catalog entry is virtual: its identity is the pair `state.db` plus the
 native session ID. Native IDs have the form:
 
@@ -43,7 +49,7 @@ stored message count. `cli_version` is `None` because Hermes does not persist a
 per-session CLI version; database schema validation supplies the compatibility
 gate instead.
 
-The schema-26 tables used by the adapter are:
+The schema-31 tables used by the adapter are:
 
 | Table | Fields used |
 | --- | --- |
@@ -51,10 +57,14 @@ The schema-26 tables used by the adapter are:
 | `sessions` | identity, title, CWD, model/provider, start/end/activity time, message count |
 | `messages` | role/content, tool linkage, timestamp, private reasoning markers, active/compacted state |
 
+Schema 31 keeps every column the adapter requires from schema 26, so the
+projection and the required-column gates are unchanged; only the pinned version
+value moved.
+
 Discovery and parsing first take a bounded SQLite backup. This includes
 committed WAL frames and gives the catalog a stable SHA-256 fingerprint. A
 symlink, non-regular file, oversized database, integrity failure, missing
-columns, or schema other than 26 is rejected.
+columns, or schema other than 31 is rejected.
 
 ## Source projection
 
@@ -102,16 +112,97 @@ install_bundle(
 ) -> InstalledHermesSession
 ```
 
-The installer verifies the exact CLI version, initializes a missing
-`state.db` through the CLI, refuses an existing session ID, invokes the native
-importer, and reparses the installed row before returning. Target directories
-are private and symlink traversal is rejected.
+The installer verifies the exact CLI version, creates a missing `state.db`
+through the native `SessionDB` initializer, refuses an existing session ID,
+invokes the native importer, and reparses the installed row before returning.
+Target directories are private and symlink traversal is rejected.
 
 Hermes's user-facing `hermes sessions import` command currently accepts Claude
-and Codex sources, not Hermes's own export. `SessionDB.import_sessions` is the
-native export/import transaction used internally and is therefore the pinned
+and Codex sources, not Hermes's own export. `SessionDB.import_sessions` remains
+the native export/import transaction in 0.22.2 and is therefore still the pinned
 installation boundary here.
 
+## The native runtime behind the launcher
+
+0.22.2 publishes its own launch command, and the adapter uses it instead of
+guessing a Python from the launcher's file head:
+
+```bash
+hermes --print-runtime-command   # JSON argv: [interpreter, -I, -c, bootstrap, ...]
+hermes --version                 # also prints "Install directory: <root>"
+```
+
+That interpreter is *store Python*: it deliberately ships with no third-party
+packages. The published launcher reaches the dependency generation by importing
+`hermes_bootstrap` after putting the install root on `sys.path`, so the helper
+the installer runs reproduces exactly that prelude (clear `PYTHONHOME`,
+`PYTHONPATH` and `VIRTUAL_ENV`; insert the install root; import
+`hermes_bootstrap`). Without it, every `hermes_state` import fails on a missing
+`ruamel`, not on anything session-related. Builds predating
+`--print-runtime-command` keep the older behaviour: the adapter derives the
+interpreter from the launcher's `#!` line.
+
+Two platform facts are handled explicitly:
+
+- **Windows launchers are compiled zipapps.** `hermes.exe` is a PE stub with the
+  launcher's `__main__.py` appended, so there is no `#!` line the old code could
+  read; `--print-runtime-command` is the only portable source. The install
+  directory is recovered from `Install directory:`, or from the launcher's own
+  `sys.path.insert(0, ...)` bootstrap when that line is absent.
+- **A sanitized child environment must keep the Windows essentials.** The CLI
+  refuses to start when it cannot resolve a home directory, and a Windows child
+  needs `SYSTEMROOT`, `PATHEXT` and `COMSPEC` to load at all. The allowlist
+  therefore carries `USERPROFILE`, `HOMEDRIVE`, `HOMEPATH`, `APPDATA`,
+  `LOCALAPPDATA`, `PROGRAMDATA`, `SYSTEMROOT`, `SYSTEMDRIVE`, `WINDIR`,
+  `PATHEXT`, `COMSPEC`, `TEMP`, `TMP` and `NUMBER_OF_PROCESSORS` alongside the
+  POSIX variables; `HOME` is mirrored into `USERPROFILE` when the caller
+  redirects the home through `HOME` only.
+- **The bundle crosses the process boundary as bytes.** The helper reads
+  `sys.stdin.buffer` and the caller decodes stdout/stderr explicitly as UTF-8;
+  the child interpreter is started with `-X utf8`. Passing the payload as *text*
+  encoded it with the caller's locale codec while the store's interpreter always
+  decodes UTF-8, so a Windows console whose code page is not UTF-8 replaced
+  every non-ASCII character in the imported conversation — title and message
+  bodies alike — with `U+FFFD`. Both directions are now codec-independent.
+
+Installation summary: `hermes sessions list` no longer creates `state.db` on a
+read of an absent store, so initialization moved to the native `SessionDB`
+constructor; and the identity-guard descriptor that reserves the manifest is
+closed before a rollback unlinks it, because Windows refuses to delete a file
+that still has an open handle (`WinError 32`).
+
+### Titles are unique per store
+
+Hermes enforces a partial unique index over non-null titles:
+
+```sql
+CREATE UNIQUE INDEX idx_sessions_title_unique ON sessions(title) WHERE title IS NOT NULL
+```
+
+A second session therefore cannot reuse a title, and the native importer treats
+the field as cosmetic: it wraps its own title write in a suppressed exception
+and leaves the conflicting session untitled. Before this change the migrator
+inherited the raw refusal, so migrating the same conversation twice into one
+home — or migrating two sessions whose first message produced the same title —
+failed the whole bundle with `UNIQUE constraint failed: sessions.title`.
+
+The installer now samples the target store first and, when the title is already
+taken, drops it from the bundle before the native import. The migration
+succeeds, the manifest records the omission as the `title:duplicate_in_target`
+counter plus a `target_title_omitted` warning, and the session appears in the
+native picker without a title. Only the cosmetic field is removed: the envelope,
+its messages, and the record count are unchanged.
+
+The migration manifest is the record of truth here. The CLI's content-free
+stdout summary is built from the conversion result before any target installer
+runs (true for every harness), so a real run reports the omission in
+`<state-home>/session-migrate/manifests/hermes-<id>.json` rather than in the
+printed JSON, and a `--dry-run` — which writes no manifest — reports it nowhere.
+
+The sample is advisory. It runs before the import transaction, which still
+enforces the constraint itself, so a title created by a concurrent writer in
+between fails closed exactly as before, with no partial session.
+
 Resume uses Hermes's native command:
 
 ```bash
@@ -132,6 +223,7 @@ unambiguous session ID.
 | Compaction boundary/replacement metadata | summary kept; metadata counted | Hermes stores the active summary, not portable boundary semantics |
 | Rewound or already compacted bodies | opaque accounting only | not part of Hermes's active model replay |
 | Token/cost/runtime counters | reset | derived native runtime state |
+| Session title already held by the target store | installed untitled; counted | Hermes allows one session per non-null title |
 
 ## Native research trajectories
 
@@ -139,6 +231,31 @@ Research and validation ran in a unique mode-`0700` temporary root. The pinned
 source was installed into its own virtual environment; no user Hermes home or
 credential store was read or copied.
 
+The 0.20.6 trajectories below remain the historical record of the original
+adapter research. The 0.22.2 promotion was re-validated on a live Windows
+install:
+
+1. Read side, against the real store, read-only: a 31 MB `state.db` at schema
+   `31` was snapshotted (bounded SQLite backup), all required session and
+   message columns were present, and inventory returned every session row.
+2. Write side, in an isolated scratch home: a generated bundle installed through
+   `SessionDB.import_sessions`, was reparsed (title, CWD, both message events),
+   appeared in `list_sessions` with the right record count, and a second install
+   of the same native ID was refused with the session store byte-identical
+   afterwards.
+3. End-to-end route: a real Claude Code session (23 records) transferred with
+   `smigrate transfer --from claude --to hermes`. The native CLI listed the
+   result — `message_count` 22, `tool_call_count` 9, nine linked `tool` rows
+   carrying `tool_call_id` and `tool_name`, the source title and CWD preserved,
+   `source=session-migrate` — which is the fidelity the text-only native
+   importer does not provide: `hermes sessions import` writes `[ran tool: Bash]`
+   markers into the assistant body and leaves `tool_call_count=0`.
+
+Not verified in this round: a live `hermes chat --resume` against a provider,
+native compaction after import, and WAL-snapshot behaviour while another writer
+is appending. Those remain covered by the opt-in native test rather than by
+this promotion.
+
 Three native trajectories were inspected:
 
 1. A real Hermes CLI session containing a user turn, assistant function call,
@@ -165,7 +282,7 @@ the new summary and accounted for archived rows.
 One observed native nuance is documented rather than papered over: the first
 CLI-created row stored a title but left `cwd` and `model` null despite launch
 options, while imported sessions retained an explicit CWD. Both are valid
-schema-26 states, so inventory and parsing treat native CWD/model as optional.
+schema states, so inventory and parsing treat native CWD/model as optional.
 
 ## Test contract
 
@@ -184,8 +301,8 @@ and its installed CLI. It still uses no provider credential and binds its fake
 provider only to loopback:
 
 ```bash
-SESSION_MIGRATE_HERMES_SOURCE=/path/to/hermes-agent-v2026.8.27 \
-SESSION_MIGRATE_HERMES_BIN=/path/to/hermes-agent-v2026.8.27/.venv/bin/hermes \
+SESSION_MIGRATE_HERMES_SOURCE=/path/to/hermes-agent-v2026.9.24 \
+SESSION_MIGRATE_HERMES_BIN=/path/to/hermes-agent-v2026.9.24/.venv/bin/hermes \
   uv run pytest -q tests/test_hermes_native.py -vv
 ```
 
diff --git a/docs/native-corpus-validation.md b/docs/native-corpus-validation.md
index d7781fe..23d0e12 100644
--- a/docs/native-corpus-validation.md
+++ b/docs/native-corpus-validation.md
@@ -51,7 +51,7 @@ and sanitization mutations live beside each fixture in `provenance.json`.
 | Cursor | 2026.03.20-44cb435 | vendor | dropped | — | dropped | lossy | rejected | rejected | dropped | dropped |
 | Devin | 3000.6.7 | vendor | preserved | preserved | — | lossy | lossy | lossy | lossy | — |
 | Grok | 1.0.5 | loopback | preserved | — | preserved | lossy | rejected | rejected | — | — |
-| Hermes | 0.20.6 | loopback | preserved | lossy | — | rejected | rejected | rejected | — | — |
+| Hermes | 0.22.2 | loopback | preserved | lossy | — | rejected | rejected | rejected | — | — |
 | Kilo | 7.5.0 | loopback | preserved | preserved | — | lossy | rejected | rejected | — | — |
 | Kimi | 0.38.0 | OpenRouter | preserved | unsupported | — | — | — | — | lossy | — |
 | MastraCode | 0.37.1 | loopback | preserved | preserved | — | rejected | rejected | rejected | — | — |
diff --git a/docs/opencode-v2.md b/docs/opencode-v2.md
new file mode 100644
index 0000000..8b8ee03
--- /dev/null
+++ b/docs/opencode-v2.md
@@ -0,0 +1,97 @@
+# OpenCode 2.0 public session transfers
+
+OpenCode 1.17.20 uses `import/export --pure` and nested message/part bundles.
+OpenCode 2.0 uses `session import/export --standalone` and flat typed messages.
+Native import detects the installed client and selects its transfer schema.
+Convert-only output remains legacy unless `--target-cli-version 2.0.23` is set.
+Unsupported schema series fail closed. The `opencode v` version prefix and
+custom suffixes are accepted; unvalidated exact releases receive schema-aware
+warnings. Native acceptance is pinned to stock 2.0.23, not every 2.0.x release.
+
+The stock 2.0.22 release is also recognized by the native tests; recognition is
+not evidence that a particular local test run used that release.
+
+The v2 adapter preserves ordered user/assistant text, linked tool inputs and
+results, inline user/tool images, and readable completed compaction summaries.
+User text blocks in one native message become their exact newline join.
+Private-only or whitespace-only checkpoints do not retire readable history.
+Encrypted provider checkpoints, private traces, source reasoning variants and
+unsupported control/metadata fields are explicitly counted as omissions.
+
+Completed tool results retain ordered portable `content_blocks`, including
+caption/image interleaving, adjacent text blocks and empty text blocks. Targets
+that support ordered blocks retain them. Legacy OpenCode and Kilo flatten text
+and attachments; `tool_result:content_block_order` records any resulting loss of
+order or segmentation rather than silently treating that projection as exact.
+
+Structured tool errors retain their message. Nondefault error types, HTTP status
+and response bodies are counted separately as `opencode_v2_tool_error_type`,
+`opencode_v2_tool_error_status` and `opencode_v2_tool_error_response` omissions.
+Opaque events and manifests contain reason labels, not diagnostic response bodies.
+
+Original native session fields and all accepted control variants are validated
+before projection/defaults, including required and nested fields and the
+distinction between absent and null optionals. Unsupported readable control
+records are accounted for as omissions; malformed native records are rejected,
+not repaired by discarding them.
+
+Catalog discovery reads legacy `session` and `session_v2` metadata in one
+read-only transaction, preferring v2 for duplicate identities. Flat v2 bundles
+can be autodetected; legacy OpenCode/Kilo bundles remain ambiguous. Kilo keeps
+its legacy nested transfer contract, even with a v2-looking version override.
+
+## Review follow-up and attribution
+
+The focused implementation originated in tudstudent's PR #15, commit
+`0f32c8f377f9667fac8be9325ca3065314b9f0ef`. PR #17 by TheViniAlmeida explicitly
+builds on that implementation and adds catalog discovery and Kilo separation.
+This branch incorporates those adaptations and the review fixes and regression
+coverage from PR #17 commit `2e3671dcf402159bcb456380409a103cfaaf19cf`
+(TheViniAlmeida, `eu@thevinialmeida.com`), addressing xhluca's three findings in
+review `5477456070`. This records both directions of reuse; it does not claim
+sole authorship of the follow-up work or upstream acceptance.
+
+A streamed tool input can be an incomplete JSON string. The source projection
+keeps it unchanged inside `{ "input": ORIGINAL_STRING }`; it does not replace
+it with `{}` or attempt to parse/complete it. On conversion, an unfinished call
+is archived as an `ImportedIncompleteTool` error with the same ID and input,
+because native transfer discards unsettled assistant records. This is historical
+input preservation, not an executable resumed partial tool invocation. The
+source→portable→target regression includes an unterminated string input.
+
+OpenCode owns its database import. No private SQLite writes, credentials or
+machine-specific launchers are part of the adapter. Dry run performs public
+native preflight without importing or writing a migration manifest; native
+preflight may initialize the client's ordinary store. Imports enforce global
+identity collisions and explicit success confirmation, then verify the imported
+ID using public export. A conflict can have native exit status zero and still
+fails import confirmation.
+
+## Reproducible native and route checks
+
+```sh
+./scripts/install-native-test-clis.sh /tmp/session-migrate-native opencode-v2
+./scripts/run-native-test-client.sh \
+  opencode-v2 /tmp/session-migrate-native/session-migrate-native.env
+uv run pytest -q tests/test_opencode_v2.py tests/test_opencode_v2_review.py tests/test_route_matrix.py
+```
+
+The `opencode-v2` CI matrix entry installs **@opencode/cli@2.0.23** (the legacy
+package is opencode-ai), supplies `SESSION_MIGRATE_TEST_OPENCODE_V2`, and rejects
+skipped assigned tests. Native tests use synthetic transcripts, isolated HOME
+and XDG directories, an explicit credential-free config, and a deterministic
+localhost provider. They verify import/export, dry run, collisions, cold process
+reopening, compaction/tool replay and a new persisted reply under the same ID.
+They do not use real accounts or supplier inference credits. The default suite
+can skip native tests when that exact executable is unavailable; the selected
+CI job cannot silently pass those skips.
+
+Route tests cover legacy and v2 OpenCode source and target variants against the
+other supported formats. The 19 variants remain eighteen harnesses. Existing
+legacy wire behavior and native tests remain separate.
+
+This change is independent of the Windows filesystem-cleanup and Codex child
+projection changes split from PR #10. Those fixes complement Windows execution
+and additional Codex sources, but neither is required to review this schema or
+run the Linux v2 gate. Native Windows acceptance and all historical client
+versions are not established by this branch's Linux gates.
diff --git a/docs/specification.md b/docs/specification.md
index 88c856f..09694c5 100644
--- a/docs/specification.md
+++ b/docs/specification.md
@@ -1,6 +1,6 @@
 # Session migration specification
 
-This is the user-facing contract for `session-migrate` 0.11.0.
+This is the user-facing contract for `session-migrate` 0.12.1.
 
 ## Scope
 
@@ -21,7 +21,7 @@ The migrator reads and writes native sessions for:
 - Grok 1.0.5
 - Kilo Code 7.5.0
 - OpenHands 1.16.0
-- Hermes Agent 0.20.6
+- Hermes Agent 0.22.2
 - MastraCode 0.37.1
 - Devin CLI 3000.6.7
 
@@ -128,7 +128,7 @@ OMP's current fixed-title-slot v3 writer is pinned to 18.0.5. Vibe's writer
 and append-boundary fingerprint are pinned to 2.24.3. Muse,
 Qwen, and Kimi writers are pinned to 0.2.1, 0.22.1, and 0.38.0. Grok, Kilo,
 and OpenHands are pinned to 1.0.5, 7.5.0, and 1.16.0. Hermes, MastraCode, and
-Devin are pinned to 0.20.6, 0.37.1, and 3000.6.7. Installation
+Devin are pinned to 0.22.2, 0.37.1, and 3000.6.7. Installation
 does not invoke Vibe; the exact CLI is exercised by the credential-free native
 resume gate.
 
diff --git a/docs/troubleshooting.md b/docs/troubleshooting.md
index a3e3bdc..c49cbdc 100644
--- a/docs/troubleshooting.md
+++ b/docs/troubleshooting.md
@@ -248,7 +248,7 @@ smigrate catalog refresh --mastracode-root /path/to/mastra.db
 smigrate catalog refresh --devin-root /path/to/devin-home
 ```
 
-Hermes `0.20.6`, MastraCode `0.37.1`, and Devin `3000.6.7` are strict native
+Hermes `0.22.2`, MastraCode `0.37.1`, and Devin `3000.6.7` are strict native
 pins. Use `--source-cli` or `--target-cli` when the exact binary is not on
 `PATH`; a version override cannot bypass a schema or binary mismatch. Hermes
 installation uses the pinned official Python importer. MastraCode and Devin
diff --git a/pyproject.toml b/pyproject.toml
index 79d226c..6e4925a 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "session-migrate"
-version = "0.11.0"
+version = "0.12.1"
 description = "Migrate native coding-agent sessions across eighteen terminal harnesses"
 readme = "README.md"
 requires-python = ">=3.11"
diff --git a/scripts/install-native-test-clis.sh b/scripts/install-native-test-clis.sh
index 08d7787..47b9009 100755
--- a/scripts/install-native-test-clis.sh
+++ b/scripts/install-native-test-clis.sh
@@ -77,6 +77,10 @@ if want opencode; then
   npm_cli opencode 'opencode-ai@1.17.20' \
     SESSION_MIGRATE_OPENCODE_BIN node_modules/.bin/opencode
 fi
+if want opencode-v2; then
+  npm_cli opencode-v2 '@opencode/cli@2.0.23' \
+    SESSION_MIGRATE_TEST_OPENCODE_V2 node_modules/@opencode/cli-linux-x64/bin/opencode
+fi
 if want pi; then
   npm_cli pi '@earendil-works/pi-coding-agent@0.80.6' \
     SESSION_MIGRATE_PI_BIN node_modules/.bin/pi
@@ -174,22 +178,32 @@ if want vibe; then
 fi
 
 if want hermes; then
-  hermes_archive="$native_root/hermes-agent-5fc308a7.tar.gz"
-  if ! verify 8710e0017792e78369a7da3d96c16141f0787374285f1a6cf6f80d29b7b9ea2c \
+  hermes_archive="$native_root/hermes-agent-d923a5eb.tar.gz"
+  if ! verify 616649f8ac7e3bb186999d000d77511e733b3930bd2b5921be4a85673320ef8b \
     "$hermes_archive" 2>/dev/null; then
     curl --fail --location --silent --show-error --retry 3 --output "$hermes_archive" \
-      'https://codeload.github.com/NousResearch/hermes-agent/tar.gz/5fc308a70719a83cccdbba4c0e39c23f5a8239d5'
+      'https://codeload.github.com/NousResearch/hermes-agent/tar.gz/d923a5eb487a17c0a68801bba9ef0f56c81040a8'
   fi
-  verify 8710e0017792e78369a7da3d96c16141f0787374285f1a6cf6f80d29b7b9ea2c \
+  verify 616649f8ac7e3bb186999d000d77511e733b3930bd2b5921be4a85673320ef8b \
     "$hermes_archive"
   mkdir -p "$native_root/hermes"
   tar -xzf "$hermes_archive" --strip-components=1 -C "$native_root/hermes"
-  # Hermes' revision-3 lockfile uses options first supported by uv 0.10.
+  # The pinned revision resolves its own version from the source git tree, so
+  # the gitless tarball report would be "vunknown"; reconstruct a minimal
+  # checkout carrying the pinned release tag.
+  git -C "$native_root/hermes" init -q
+  git -C "$native_root/hermes" add -A
+  git -C "$native_root/hermes" -c user.name=session-migrate \
+    -c user.email=ci@invalid -c commit.gpgsign=false \
+    commit -q -m "session-migrate: pin hermes agent d923a5eb"
+  git -C "$native_root/hermes" tag v0.22.2
+  # Hermes' revision-3 lockfile uses options first supported by uv 0.10
+  # and requires Python >= 3.14.
   uvx --from 'uv==0.10.9' uv sync \
-    --directory "$native_root/hermes" --frozen --no-dev --python 3.13
+    --directory "$native_root/hermes" --frozen --no-dev --python 3.14
   record SESSION_MIGRATE_HERMES_SOURCE "$native_root/hermes"
   record SESSION_MIGRATE_HERMES_BIN "$native_root/hermes/.venv/bin/hermes"
-  record SESSION_MIGRATE_HERMES_REVISION 5fc308a70719a83cccdbba4c0e39c23f5a8239d5
+  record SESSION_MIGRATE_HERMES_REVISION d923a5eb487a17c0a68801bba9ef0f56c81040a8
 fi
 
 path_entries=()
diff --git a/scripts/native-corpus/capture-hermes.py b/scripts/native-corpus/capture-hermes.py
index b660dbf..ced1b03 100644
--- a/scripts/native-corpus/capture-hermes.py
+++ b/scripts/native-corpus/capture-hermes.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Capture an exact Hermes 0.20.6 source trajectory without credentials."""
+"""Capture an exact Hermes 0.22.2 source trajectory without credentials."""
 
 from __future__ import annotations
 
@@ -22,11 +22,18 @@
 ASSETS = REPO_ROOT / "tests/native_corpus/v1/assets"
 SCENARIO = json.loads((REPO_ROOT / "tests/native_corpus/v1/scenario.json").read_text())
 TITLE = str(SCENARIO["session_title"])
-VERSION = "0.20.6"
-RELEASE = "2026.8.27"
-SOURCE_COMMIT = "5fc308a70719a83cccdbba4c0e39c23f5a8239d5"
-BINARY_BYTES = 339
-BINARY_SHA256 = "060277e4ac1caa59ea6e0c551c7627f8fea0989a4aace9f73cdc1f09425f34c2"
+VERSION = "0.22.2"
+RELEASE = "2026.9.24"
+SOURCE_COMMIT = "d923a5eb487a17c0a68801bba9ef0f56c81040a8"
+# The entry-point wrapper embeds the install root, so its bytes are per-install
+# rather than per-release.  A capture on a new install must re-record both
+# values here (the defaults below are the wrapper recorded on POSIX for the
+# previous pin and will not match another tree).
+BINARY_BYTES = int(os.environ.get("SESSION_MIGRATE_HERMES_WRAPPER_BYTES", "341"))
+BINARY_SHA256 = os.environ.get(
+    "SESSION_MIGRATE_HERMES_WRAPPER_SHA256",
+    "d2c74d2575bc2cbfd9ddbb7b1d3d110cc68c1897e8dbf4882260d856b26cf104",
+)
 
 
 @dataclass(frozen=True, slots=True)
@@ -237,7 +244,9 @@ def verify_client(source: Path, binary: Path) -> dict[str, Any]:
         timeout=20,
     )
     expected_line = f"Hermes Agent v{VERSION} ({RELEASE})"
-    if version.returncode or expected_line not in version.stdout:
+    # 0.22.2 appends build provenance ("· stable · local <sha>") to the release.
+    first_line = version.stdout.splitlines()[0].strip() if version.stdout.splitlines() else ""
+    if version.returncode or not first_line.startswith(expected_line):
         raise SystemExit(f"expected {expected_line!r}, got {version.stdout!r}")
     size = binary.stat().st_size
     digest = hashlib.sha256(binary.read_bytes()).hexdigest()
@@ -283,7 +292,7 @@ def write_config(home: Path, port: int) -> None:
                 "    default_model: fixture-model",
                 "    models: [fixture-model]",
                 "    discover_models: false",
-                "    context_length: 32768",
+                "    context_length: 131072",
                 "display:",
                 "  interface: cli",
                 "  resume_display: minimal",
diff --git a/scripts/native-corpus/sanitize-hermes.py b/scripts/native-corpus/sanitize-hermes.py
index 8fab621..7bbbc50 100644
--- a/scripts/native-corpus/sanitize-hermes.py
+++ b/scripts/native-corpus/sanitize-hermes.py
@@ -19,6 +19,7 @@
         "actual_cost_usd",
         "api_call_count",
         "archived",
+        "auto_archived",
         "billing_base_url",
         "billing_mode",
         "billing_provider",
@@ -30,8 +31,11 @@
         "compression_failure_error",
         "compression_fallback_streak",
         "compression_ineffective_count",
+        "compression_overload_streak",
+        "compression_recovery_deadline",
         "cost_source",
         "cost_status",
+        "created_source",
         "cwd",
         "display_name",
         "end_reason",
@@ -69,14 +73,18 @@
         "system_prompt",
         "system_prompt_hash",
         "thread_id",
+        "timings",
         "title",
         "title_source",
         "tool_call_count",
+        "tool_names",
+        "transport_profile",
         "user_id",
     }
 )
 MESSAGE_FIELDS = frozenset(
     {
+        "absorbed_message_uids",
         "active",
         "api_content",
         "codex_message_items",
@@ -88,6 +96,7 @@
         "effect_disposition",
         "finish_reason",
         "id",
+        "message_uid",
         "observed",
         "platform_message_id",
         "reasoning",
@@ -98,6 +107,8 @@
         "timestamp",
         "token_count",
         "tool_call_id",
+        "tool_call_uid",
+        "tool_call_uids",
         "tool_calls",
         "tool_name",
     }
@@ -122,6 +133,7 @@
     "system_prompt",
     "system_prompt_hash",
     "thread_id",
+    "tool_names",
     "user_id",
 )
 PUBLIC_CWD = "/fixture/work"
@@ -139,9 +151,14 @@ class Result:
 
 def _scrub(value: Any, private_cwd: str, mutations: Counter[str]) -> Any:
     if isinstance(value, str):
-        replaced = value.replace(private_cwd, PUBLIC_CWD)
-        if replaced != value:
-            mutations["message path"] += value.count(private_cwd)
+        # On Windows the private cwd contains separators json.dumps also
+        # escapes inside tool_calls arguments; scrub both the plain and the
+        # JSON-escaped variant.
+        escaped = private_cwd.replace("\\", "\\\\")
+        replaced = value.replace(escaped, PUBLIC_CWD)
+        replaced = replaced.replace(private_cwd, PUBLIC_CWD)
+        if value.count(escaped) or value.count(private_cwd):
+            mutations["message path"] += replaced.count(PUBLIC_CWD) - value.count(PUBLIC_CWD)
         return replaced
     if isinstance(value, list):
         return [_scrub(item, private_cwd, mutations) for item in value]
diff --git a/scripts/run-native-test-client.sh b/scripts/run-native-test-client.sh
index d2c3dc7..cf5188e 100755
--- a/scripts/run-native-test-client.sh
+++ b/scripts/run-native-test-client.sh
@@ -99,6 +99,13 @@ case "$client" in
       'tests/test_opencode_kilo_corpus_native.py::test_exact_client_cold_import_export_and_continuation_preserve_prefix[opencode]'
     )
     ;;
+  opencode-v2)
+    tests=(
+      tests/test_opencode_v2.py::test_native_v2_isolated_import_export_dry_run_and_collision
+      tests/test_opencode_v2_native.py
+      tests/test_opencode_v2_review.py::test_stock_v2_accepts_and_cold_exports_review_sources_and_fixed_targets
+    )
+    ;;
   openhands)
     tests=(
       tests/test_grok_kilo_openhands_native.py::test_openhands_1160_creates_native_tool_source_from_empty_state
diff --git a/src/session_migrate/__init__.py b/src/session_migrate/__init__.py
index f9319e8..b830747 100644
--- a/src/session_migrate/__init__.py
+++ b/src/session_migrate/__init__.py
@@ -1,3 +1,3 @@
 """Native coding-agent session discovery and migration."""
 
-__version__ = "0.11.0"
+__version__ = "0.12.1"
diff --git a/src/session_migrate/catalog.py b/src/session_migrate/catalog.py
index 2c34fe1..aaa2ecb 100644
--- a/src/session_migrate/catalog.py
+++ b/src/session_migrate/catalog.py
@@ -25,6 +25,7 @@
 from session_migrate.errors import JsonlError, SessionMigrateError
 from session_migrate.formats import (
     antigravity,
+    antigravity_desktop,
     codex,
     devin,
     hermes,
@@ -237,6 +238,11 @@ def auto_roots(
             user_home / ".gemini" / "antigravity-cli",
             "default",
         ),
+        (
+            AgentFormat.ANTIGRAVITY_DESKTOP,
+            user_home / ".gemini" / "antigravity",
+            "default",
+        ),
         (
             AgentFormat.CURSOR,
             cursor_home,
@@ -336,6 +342,11 @@ def auto_roots(
         antigravity_home = directory / ".gemini" / "antigravity-cli"
         if (antigravity_home / "conversations").is_dir():
             candidates.append((AgentFormat.ANTIGRAVITY, antigravity_home, "project"))
+        antigravity_desktop_home = directory / ".gemini" / "antigravity"
+        if (antigravity_desktop_home / "conversations").is_dir():
+            candidates.append(
+                (AgentFormat.ANTIGRAVITY_DESKTOP, antigravity_desktop_home, "project")
+            )
         cursor_home = directory / ".cursor"
         if (cursor_home / "chats").is_dir():
             candidates.append((AgentFormat.CURSOR, cursor_home, "project"))
@@ -887,6 +898,7 @@ def add_root(
             AgentFormat.OPENCODE,
             AgentFormat.COPILOT,
             AgentFormat.ANTIGRAVITY,
+            AgentFormat.ANTIGRAVITY_DESKTOP,
             AgentFormat.CURSOR,
             AgentFormat.VIBE,
             AgentFormat.MUSE,
@@ -946,6 +958,7 @@ def refresh(
         opencode_roots: Sequence[Path] = (),
         copilot_roots: Sequence[Path] = (),
         antigravity_roots: Sequence[Path] = (),
+        antigravity_desktop_roots: Sequence[Path] = (),
         cursor_roots: Sequence[Path] = (),
         vibe_roots: Sequence[Path] = (),
         muse_roots: Sequence[Path] = (),
@@ -981,6 +994,8 @@ def refresh(
             self.add_root(AgentFormat.COPILOT, path)
         for path in antigravity_roots:
             self.add_root(AgentFormat.ANTIGRAVITY, path)
+        for path in antigravity_desktop_roots:
+            self.add_root(AgentFormat.ANTIGRAVITY_DESKTOP, path)
         for path in cursor_roots:
             self.add_root(AgentFormat.CURSOR, path)
         for path in vibe_roots:
@@ -1110,7 +1125,10 @@ def _refresh_root(self, root: CatalogRoot, *, validate: bool) -> dict[str, int]:
             metadata = _codex_native_metadata(root_path)
         elif root.format == AgentFormat.COPILOT.value:
             metadata = _copilot_native_metadata(root_path)
-        elif root.format == AgentFormat.ANTIGRAVITY.value:
+        elif root.format in {
+            AgentFormat.ANTIGRAVITY.value,
+            AgentFormat.ANTIGRAVITY_DESKTOP.value,
+        }:
             metadata = _antigravity_native_metadata(root_path)
         else:
             metadata = _NativeMetadata({}, {}, {}, False)
@@ -1156,6 +1174,7 @@ def _refresh_root(self, root: CatalogRoot, *, validate: bool) -> dict[str, int]:
                         continue
                 elif root.format in {
                     AgentFormat.ANTIGRAVITY.value,
+                    AgentFormat.ANTIGRAVITY_DESKTOP.value,
                     AgentFormat.CURSOR.value,
                 }:
                     try:
@@ -1175,8 +1194,8 @@ def _refresh_root(self, root: CatalogRoot, *, validate: bool) -> dict[str, int]:
                 unchanged = bool(
                     previous
                     and previous["status"] != "missing"
-                    and int(previous["device"]) == before.device
-                    and int(previous["inode"]) == before.inode
+                    and int(previous["device"]) == _sqlite_stat_int(before.device)
+                    and int(previous["inode"]) == _sqlite_stat_int(before.inode)
                     and int(previous["bytes"]) == before.size
                     and int(previous["modified_ns"]) == before.modified_ns
                     and previous["source_fingerprint"] == getattr(before, "fingerprint", None)
@@ -1544,8 +1563,8 @@ def _upsert_session(
                 scan.status,
                 scan.reason,
                 scan.records,
-                snapshot.device,
-                snapshot.inode,
+                _sqlite_stat_int(snapshot.device),
+                _sqlite_stat_int(snapshot.inode),
                 snapshot.size,
                 snapshot.modified_ns,
                 getattr(snapshot, "fingerprint", None),
@@ -1625,8 +1644,8 @@ def _upsert_virtual_session(
                 scan.status,
                 scan.reason,
                 scan.records,
-                snapshot.device,
-                snapshot.inode,
+                _sqlite_stat_int(snapshot.device),
+                _sqlite_stat_int(snapshot.inode),
                 snapshot.size,
                 snapshot.modified_ns,
                 snapshot.fingerprint,
@@ -1922,7 +1941,7 @@ def _candidate_files(agent_format: AgentFormat, root: Path) -> Iterable[Path]:
             ]
         yield from sorted(candidates)
         return
-    if agent_format == AgentFormat.ANTIGRAVITY:
+    if agent_format in {AgentFormat.ANTIGRAVITY, AgentFormat.ANTIGRAVITY_DESKTOP}:
         conversations = root / "conversations"
         if not conversations.is_dir():
             return
@@ -2039,6 +2058,8 @@ def _raise_walk_error(error: OSError) -> None:
 def _scan_file(path: Path, agent_format: AgentFormat, root: Path) -> _Scan:
     if agent_format == AgentFormat.ANTIGRAVITY:
         return _scan_antigravity_file(path, root)
+    if agent_format == AgentFormat.ANTIGRAVITY_DESKTOP:
+        return _scan_antigravity_desktop_file(path, root)
     if agent_format == AgentFormat.CURSOR:
         return _scan_cursor_file(path, root)
     if agent_format == AgentFormat.VIBE:
@@ -2450,6 +2471,7 @@ def _base_scan(
         lifecycle = "project"
     elif agent_format in {
         AgentFormat.ANTIGRAVITY,
+        AgentFormat.ANTIGRAVITY_DESKTOP,
         AgentFormat.CURSOR,
         AgentFormat.VIBE,
         AgentFormat.MUSE,
@@ -2513,6 +2535,39 @@ def _scan_antigravity_file(path: Path, root: Path) -> _Scan:
     )
 
 
+def _scan_antigravity_desktop_file(path: Path, root: Path) -> _Scan:
+    base = _base_scan(path, AgentFormat.ANTIGRAVITY_DESKTOP, root, "candidate", None)
+    try:
+        parsed = antigravity_desktop.parse(path)
+    except SessionMigrateError:
+        return _replace_scan_status(base, "corrupt", "invalid_antigravity_database")
+    labels: list[_Label] = []
+    if parsed.title:
+        title = _bounded(parsed.title, LABEL_LIMIT)
+        if title:
+            labels.append(_Label("native_title", title, 0, 110))
+    has_conversation = any(
+        event.kind.value in {"message", "tool_call", "tool_result"} for event in parsed.events
+    )
+    status = "candidate" if has_conversation else "corrupt"
+    reason = None if has_conversation else "no_conversation_records"
+    return _Scan(
+        session_id=parsed.session_id,
+        filename_session_id=base.filename_session_id,
+        cwd=_bounded(str(parsed.cwd), PATH_VALUE_LIMIT) if parsed.cwd else None,
+        started_at=parsed.started_at,
+        cli_version=parsed.cli_version,
+        history_mode=None,
+        kind=base.kind,
+        lifecycle=base.lifecycle,
+        parent_session_id=None,
+        status=status,
+        reason=reason,
+        records=parsed.raw_record_count,
+        labels=tuple(labels),
+    )
+
+
 def _scan_cursor_file(path: Path, root: Path) -> _Scan:
     base = _base_scan(path, AgentFormat.CURSOR, root, "candidate", None)
     try:
@@ -2948,9 +3003,14 @@ def _opencode_inventory(
         connection.execute("PRAGMA query_only = ON")
         connection.execute("PRAGMA busy_timeout = 1000")
         connection.execute("BEGIN")
-        columns = {
-            str(row[1]) for row in connection.execute("PRAGMA table_info(session)").fetchall()
+        tables = ("session_v2", "session") if label == "opencode" else ("session",)
+        schemas = {
+            table: {
+                str(row[1]) for row in connection.execute(f"PRAGMA table_info({table})").fetchall()
+            }
+            for table in tables
         }
+        schemas = {table: columns for table, columns in schemas.items() if columns}
         required = {
             "id",
             "directory",
@@ -2959,23 +3019,38 @@ def _opencode_inventory(
             "time_created",
             "time_updated",
         }
-        if not required.issubset(columns):
+        if not schemas or any(not required.issubset(columns) for columns in schemas.values()):
             raise _OpenCodeInventoryError(f"{label}_schema_unsupported")
-        selected = [
-            "id",
-            f"substr(directory, 1, {PATH_VALUE_LIMIT}) AS directory",
-            f"substr(title, 1, {LABEL_LIMIT}) AS title",
-            f"substr(version, 1, {LABEL_LIMIT}) AS version",
-            "time_created",
-            "time_updated",
-            (
-                f"substr(parent_id, 1, {LABEL_LIMIT}) AS parent_id"
-                if "parent_id" in columns
-                else "NULL AS parent_id"
-            ),
-            "time_archived" if "time_archived" in columns else "NULL AS time_archived",
-        ]
-        rows = connection.execute(f"SELECT {', '.join(selected)} FROM session ORDER BY id")  # noqa: S608
+        queries = []
+        for table, columns in schemas.items():
+            selected = [
+                "id",
+                f"substr(directory, 1, {PATH_VALUE_LIMIT}) AS directory",
+                (
+                    f"substr(COALESCE(title, 'Untitled session'), 1, {LABEL_LIMIT}) AS title"
+                    if table == "session_v2"
+                    else f"substr(title, 1, {LABEL_LIMIT}) AS title"
+                ),
+                f"substr(version, 1, {LABEL_LIMIT}) AS version",
+                "time_created",
+                "time_updated",
+                (
+                    f"substr(parent_id, 1, {LABEL_LIMIT}) AS parent_id"
+                    if "parent_id" in columns
+                    else "NULL AS parent_id"
+                ),
+                "time_archived" if "time_archived" in columns else "NULL AS time_archived",
+            ]
+            # Upgraded stores can retain the same ID in both schemas. The v2
+            # projection is authoritative for migrated sessions; legacy-only
+            # sessions remain discoverable without reading message bodies.
+            where = (
+                " WHERE NOT EXISTS (SELECT 1 FROM session_v2 WHERE session_v2.id = session.id)"
+                if table == "session" and "session_v2" in schemas
+                else ""
+            )
+            queries.append(f"SELECT {', '.join(selected)} FROM {table}{where}")  # noqa: S608
+        rows = connection.execute(" UNION ALL ".join(queries) + " ORDER BY id")
     except _OpenCodeInventoryError:
         if connection is not None:
             connection.close()
@@ -3087,6 +3162,21 @@ def _is_non_negative_sqlite_int(value: Any) -> bool:
     return isinstance(value, int) and not isinstance(value, bool) and value >= 0
 
 
+def _sqlite_stat_int(value: int) -> int:
+    """Fold one ``os.stat`` identity field into SQLite's signed 64-bit range.
+
+    Windows reports ``st_dev`` as an unsigned 64-bit volume serial
+    (``15332589137577146414`` for an NTFS system volume), which SQLite cannot
+    bind at all: the INSERT raises ``OverflowError`` and the entire root scan
+    fails closed. The same 64 bits read signed identify the volume just as
+    uniquely, and both the stored value and every comparison go through here,
+    so refresh reuse keeps matching.
+    """
+
+    folded = int(value) & ((1 << 64) - 1)
+    return folded - (1 << 64) if folded > (1 << 63) - 1 else folded
+
+
 def _copilot_native_metadata(root: Path) -> _NativeMetadata:
     """Read only bounded picker names, never event/message content."""
 
diff --git a/src/session_migrate/cli.py b/src/session_migrate/cli.py
index b2cc420..8f4fb36 100644
--- a/src/session_migrate/cli.py
+++ b/src/session_migrate/cli.py
@@ -18,8 +18,10 @@
     content_free_result,
     convert_session,
     default_target_home,
+    detect_opencode_version,
     ensure_target_paths_available,
     install_antigravity_artifact,
+    install_antigravity_desktop_artifact,
     install_copilot_artifact,
     install_cursor_artifact,
     install_devin_artifact,
@@ -239,6 +241,13 @@ def build_parser() -> argparse.ArgumentParser:
         default=[],
         help="register and scan an additional Antigravity CLI data home (repeatable)",
     )
+    refresh_parser.add_argument(
+        "--antigravity-desktop-root",
+        type=_expanded_path,
+        action="append",
+        default=[],
+        help="register and scan an additional Antigravity Desktop data home (repeatable)",
+    )
     refresh_parser.add_argument(
         "--cursor-root",
         type=_expanded_path,
@@ -558,6 +567,7 @@ def main(argv: Sequence[str] | None = None) -> int:
                     TargetFormat.OPENCODE,
                     TargetFormat.KILO,
                     TargetFormat.ANTIGRAVITY,
+                    TargetFormat.ANTIGRAVITY_DESKTOP,
                     TargetFormat.CURSOR,
                     TargetFormat.HERMES,
                 }
@@ -567,6 +577,12 @@ def main(argv: Sequence[str] | None = None) -> int:
                     "--target-cli only applies to OpenCode/Kilo/Antigravity/Cursor import "
                     "and transfer, or Hermes import and transfer"
                 )
+            if (
+                target_format == TargetFormat.OPENCODE
+                and args.command != "convert"
+                and not args.target_cli_version
+            ):
+                args.target_cli_version = detect_opencode_version(args.target_cli)
             artifact = convert_session(
                 session,
                 ConversionOptions(
@@ -632,6 +648,13 @@ def main(argv: Sequence[str] | None = None) -> int:
                     target_cli=args.target_cli,
                     dry_run=dry_run,
                 )
+            elif target_format == TargetFormat.ANTIGRAVITY_DESKTOP and args.command != "convert":
+                install_antigravity_desktop_artifact(
+                    artifact,
+                    target_home=home,
+                    target_cli=args.target_cli,
+                    dry_run=dry_run,
+                )
             elif target_format == TargetFormat.CURSOR and args.command != "convert":
                 install_cursor_artifact(
                     artifact,
@@ -739,7 +762,10 @@ def _add_conversion_arguments(
     )
     parser.add_argument(
         "--target-cli-version",
-        help="metadata version only; the writer schema remains pinned",
+        help=(
+            "target release; selects legacy or 2.0 transfer schema for OpenCode, "
+            "metadata only for other targets"
+        ),
     )
     parser.add_argument(
         "--target-cli",
@@ -811,6 +837,7 @@ def _run_catalog(args: argparse.Namespace) -> int:
                 opencode_roots=args.opencode_root,
                 copilot_roots=args.copilot_root,
                 antigravity_roots=args.antigravity_root,
+                antigravity_desktop_roots=args.antigravity_desktop_root,
                 cursor_roots=args.cursor_root,
                 vibe_roots=args.vibe_root,
                 muse_roots=args.muse_root,
diff --git a/src/session_migrate/conversion.py b/src/session_migrate/conversion.py
index 46d9497..4160472 100644
--- a/src/session_migrate/conversion.py
+++ b/src/session_migrate/conversion.py
@@ -21,6 +21,7 @@
 from session_migrate.errors import FormatDetectionError, JsonlError, SessionMigrateError
 from session_migrate.formats import (
     antigravity,
+    antigravity_desktop,
     claude,
     codex,
     copilot,
@@ -34,6 +35,7 @@
     muse,
     omp,
     opencode,
+    opencode_v2,
     openhands,
     pi,
     qwen,
@@ -132,6 +134,8 @@ def load_session(path: Path, source_format: AgentFormat | None = None) -> Sessio
         # The adapter makes a transactionally consistent SQLite backup that
         # includes live WAL state; a plain file stat/hash check would not.
         return antigravity.parse_session(path)
+    if source_format == AgentFormat.ANTIGRAVITY_DESKTOP:
+        return antigravity_desktop.parse_session(path)
     if source_format == AgentFormat.CURSOR:
         # Cursor is also a live SQLite store. Its adapter takes a consistent
         # backup including committed WAL state before projecting the graph.
@@ -193,10 +197,10 @@ def load_opencode_session(
     values.setdefault("OPENCODE_DISABLE_PRUNE", "true")
     cli = _resolve_opencode_cli(source_cli, values)
     observed_version = _opencode_version(cli, values)
-    if observed_version != opencode.PINNED_OPENCODE_VERSION:
+    if not opencode.supported_version(observed_version):
         raise SessionMigrateError(
             "OpenCode source CLI version mismatch: expected "
-            f"{opencode.PINNED_OPENCODE_VERSION}, observed {observed_version}"
+            f"{opencode.PINNED_OPENCODE_VERSION} or supported 2.0.x, observed {observed_version}"
         )
     temporary_root = values.get("TMPDIR")
     with tempfile.TemporaryDirectory(
@@ -209,7 +213,9 @@ def load_opencode_session(
         session = load_session(export_path, AgentFormat.OPENCODE)
     if session.session_id != session_id:
         raise SessionMigrateError("OpenCode export metadata does not match the requested session")
-    return replace(session, source_path=Path(f"opencode:{session_id}"))
+    return replace(
+        session, source_path=Path(f"opencode:{session_id}"), cli_version=observed_version
+    )
 
 
 def load_kilo_session(
@@ -390,6 +396,18 @@ def convert_session(session: Session, options: ConversionOptions) -> ConversionA
             model=options.model,
             timestamp=timestamp,
         )
+    elif target_format == TargetFormat.ANTIGRAVITY_DESKTOP:
+        target_version = (
+            options.target_cli_version or antigravity_desktop.PINNED_ANTIGRAVITY_DESKTOP_VERSION
+        )
+        native_bytes, dropped = antigravity_desktop.serialize(
+            session,
+            session_id=target_id,
+            cwd=target_cwd,
+            cli_version=target_version,
+            model=options.model,
+            timestamp=timestamp,
+        )
     elif target_format == TargetFormat.CURSOR:
         target_version = options.target_cli_version or cursor.PINNED_CURSOR_VERSION
         native_bytes, dropped = cursor.serialize(
@@ -522,13 +540,25 @@ def convert_session(session: Session, options: ConversionOptions) -> ConversionA
             timestamp=timestamp,
         )
     pinned_target = _pinned_target_version(target_format)
-    if target_version != pinned_target:
+    observed_target = target_version
+    version_message = "target metadata version differs but the writer schema remains pinned"
+    if target_format == TargetFormat.OPENCODE and opencode.is_v2(target_version):
+        pinned_target = opencode_v2.VALIDATED_VERSION
+        observed_target = opencode_v2.version(target_version)
+        version_message = (
+            "selected OpenCode 2.0 transfer schema; exact target release differs "
+            "from the validated native integration release"
+        )
+    target_validated = observed_target == pinned_target or (
+        target_format == TargetFormat.OPENCODE and observed_target in opencode_v2.VALIDATED_VERSIONS
+    )
+    if not target_validated:
         warnings.append(
             {
                 "code": "unvalidated_target_version",
                 "observed": target_version,
                 "validated": pinned_target,
-                "message": "target metadata version differs but the writer schema remains pinned",
+                "message": version_message,
             }
         )
     if not native_bytes:
@@ -578,6 +608,9 @@ def convert_session(session: Session, options: ConversionOptions) -> ConversionA
             AgentFormat.OPENCODE: opencode.PINNED_OPENCODE_VERSION,
             AgentFormat.COPILOT: copilot.PINNED_COPILOT_VERSION,
             AgentFormat.ANTIGRAVITY: antigravity.PINNED_ANTIGRAVITY_VERSION,
+            AgentFormat.ANTIGRAVITY_DESKTOP: (
+                antigravity_desktop.PINNED_ANTIGRAVITY_DESKTOP_VERSION
+            ),
             AgentFormat.CURSOR: cursor.PINNED_CURSOR_VERSION,
             AgentFormat.VIBE: vibe.PINNED_VIBE_VERSION,
             AgentFormat.MUSE: muse.PINNED_MUSE_VERSION,
@@ -590,7 +623,13 @@ def convert_session(session: Session, options: ConversionOptions) -> ConversionA
             AgentFormat.MASTRACODE: mastracode.PINNED_MASTRACODE_VERSION,
             AgentFormat.DEVIN: devin.PINNED_DEVIN_VERSION,
         }[session.source_format]
-        if session.cli_version != pinned_source:
+        if session.source_format == AgentFormat.OPENCODE and opencode.is_v2(session.cli_version):
+            pinned_source = opencode_v2.VALIDATED_VERSION
+        source_validated = session.cli_version == pinned_source or (
+            session.source_format == AgentFormat.OPENCODE
+            and opencode_v2.version(session.cli_version) in opencode_v2.VALIDATED_VERSIONS
+        )
+        if not source_validated:
             warnings.append(
                 {
                     "code": "unvalidated_source_version",
@@ -638,6 +677,8 @@ def target_import_paths(artifact: ConversionArtifact, target_home: Path) -> tupl
         native_path = target_home / copilot.session_relative_path(artifact.session_id)
     elif artifact.target_format == TargetFormat.ANTIGRAVITY:
         native_path = target_home / antigravity.session_relative_path(artifact.session_id)
+    elif artifact.target_format == TargetFormat.ANTIGRAVITY_DESKTOP:
+        native_path = target_home / antigravity_desktop.session_relative_path(artifact.session_id)
     elif artifact.target_format == TargetFormat.CURSOR:
         native_path = target_home / cursor.session_relative_path(artifact.session_id, artifact.cwd)
     elif artifact.target_format == TargetFormat.VIBE:
@@ -682,6 +723,8 @@ def default_target_home(target_format: TargetFormat | AgentFormat) -> Path:
         return Path(configured).expanduser() if configured else Path.home() / ".copilot"
     if target_format.value == TargetFormat.ANTIGRAVITY.value:
         return antigravity.app_data_home()
+    if target_format.value == TargetFormat.ANTIGRAVITY_DESKTOP.value:
+        return antigravity_desktop.app_data_home()
     if target_format.value == TargetFormat.CURSOR.value:
         return cursor.config_home()
     if target_format.value == TargetFormat.VIBE.value:
@@ -786,16 +829,16 @@ def write_artifact(artifact: ConversionArtifact, *, output_path: Path, manifest_
         ):
             raise JsonlError("conversion artifact changed during installation")
     except BaseException:
+        output_guard = _close_guard(output_guard)
+        manifest_guard = _close_guard(manifest_guard)
         if output_identity is not None:
             _unlink_if_identity_matches(output_path, output_identity)
         if manifest_identity is not None:
             _unlink_if_identity_matches(manifest_path, manifest_identity)
         raise
     finally:
-        if output_guard is not None:
-            os.close(output_guard)
-        if manifest_guard is not None:
-            os.close(manifest_guard)
+        output_guard = _close_guard(output_guard)
+        manifest_guard = _close_guard(manifest_guard)
 
 
 def install_copilot_artifact(
@@ -848,6 +891,8 @@ def install_copilot_artifact(
         if not all(_path_matches_identity(path, identity) for path, identity in identities):
             raise JsonlError("Copilot artifact changed during installation")
     except BaseException:
+        while guards:
+            _close_guard(guards.pop())
         for path, identity in reversed(identities):
             _unlink_if_identity_matches(path, identity)
         if created_directory:
@@ -855,8 +900,8 @@ def install_copilot_artifact(
                 session_directory.rmdir()
         raise
     finally:
-        for descriptor in guards:
-            os.close(descriptor)
+        while guards:
+            _close_guard(guards.pop())
     return events_path, manifest_path
 
 
@@ -925,6 +970,7 @@ def install_antigravity_artifact(
             manifest_bytes,
         )
     except BaseException as exc:
+        reservation_guard = _close_guard(reservation_guard)
         if reservation_identity is not None:
             _unlink_if_identity_matches(manifest_path, reservation_identity)
         if install_succeeded:
@@ -934,8 +980,92 @@ def install_antigravity_artifact(
             ) from exc
         raise
     finally:
-        if reservation_guard is not None:
-            os.close(reservation_guard)
+        reservation_guard = _close_guard(reservation_guard)
+    return native_path, manifest_path
+
+
+def install_antigravity_desktop_artifact(
+    artifact: ConversionArtifact,
+    *,
+    target_home: Path,
+    target_cli: Path | None = None,
+    dry_run: bool = False,
+    environ: Mapping[str, str] | None = None,
+) -> tuple[Path, Path]:
+    """Install a pinned Antigravity Desktop DB and finalize a content-free manifest."""
+
+    if artifact.target_format != TargetFormat.ANTIGRAVITY_DESKTOP:
+        raise SessionMigrateError(
+            "Antigravity Desktop installation requires an Antigravity Desktop artifact"
+        )
+    if artifact.target_cli_version != antigravity_desktop.PINNED_ANTIGRAVITY_DESKTOP_VERSION:
+        raise SessionMigrateError(
+            "automatic Antigravity Desktop import requires target metadata version "
+            f"{antigravity_desktop.PINNED_ANTIGRAVITY_DESKTOP_VERSION}; "
+            "convert-only artifacts may opt into unvalidated metadata versions"
+        )
+    native_path, manifest_path = target_import_paths(artifact, target_home)
+    ensure_target_paths_available(manifest_path)
+    if dry_run:
+        installed = antigravity_desktop.install_database(
+            artifact.native_bytes,
+            session_id=artifact.session_id,
+            cwd=artifact.cwd,
+            timestamp=artifact.timestamp,
+            title=artifact.source.title,
+            target_home=target_home,
+            target_cli=target_cli,
+            dry_run=True,
+            environ=environ,
+        )
+        if installed.conversation_path != native_path:
+            raise SessionMigrateError(
+                "Antigravity Desktop installer resolved an unexpected target path"
+            )
+        return native_path, manifest_path
+
+    manifest_bytes = (
+        json.dumps(artifact.manifest(output_path=native_path), indent=2, sort_keys=True) + "\n"
+    ).encode()
+    reservation_identity: tuple[int, int] | None = None
+    reservation_guard: int | None = None
+    install_succeeded = False
+    try:
+        reservation_identity = write_private_atomic(manifest_path, b"")
+        reservation_guard = _open_identity_guard(manifest_path, reservation_identity, writable=True)
+        installed = antigravity_desktop.install_database(
+            artifact.native_bytes,
+            session_id=artifact.session_id,
+            cwd=artifact.cwd,
+            timestamp=artifact.timestamp,
+            title=artifact.source.title,
+            target_home=target_home,
+            target_cli=target_cli,
+            environ=environ,
+        )
+        install_succeeded = True
+        if installed.conversation_path != native_path:
+            raise SessionMigrateError(
+                "Antigravity Desktop installer resolved an unexpected target path"
+            )
+        _write_reserved_file(
+            reservation_guard,
+            manifest_path,
+            reservation_identity,
+            manifest_bytes,
+        )
+    except BaseException as exc:
+        reservation_guard = _close_guard(reservation_guard)
+        if reservation_identity is not None:
+            _unlink_if_identity_matches(manifest_path, reservation_identity)
+        if install_succeeded:
+            raise SessionMigrateError(
+                "Antigravity Desktop import succeeded but migrator manifest finalization failed; "
+                f"the native session may already exist as {artifact.session_id}"
+            ) from exc
+        raise
+    finally:
+        reservation_guard = _close_guard(reservation_guard)
     return native_path, manifest_path
 
 
@@ -1000,6 +1130,7 @@ def install_cursor_artifact(
             manifest_bytes,
         )
     except BaseException as exc:
+        reservation_guard = _close_guard(reservation_guard)
         if reservation_identity is not None:
             _unlink_if_identity_matches(manifest_path, reservation_identity)
         if install_succeeded:
@@ -1009,8 +1140,7 @@ def install_cursor_artifact(
             ) from exc
         raise
     finally:
-        if reservation_guard is not None:
-            os.close(reservation_guard)
+        reservation_guard = _close_guard(reservation_guard)
     return native_path, manifest_path
 
 
@@ -1063,6 +1193,8 @@ def install_vibe_artifact(
         if not all(_path_matches_identity(path, identity) for path, identity in identities):
             raise JsonlError("Vibe artifact changed during installation")
     except BaseException:
+        while guards:
+            _close_guard(guards.pop())
         for path, identity in reversed(identities):
             _unlink_if_identity_matches(path, identity)
         if created_directory:
@@ -1070,8 +1202,8 @@ def install_vibe_artifact(
                 session_directory.rmdir()
         raise
     finally:
-        for descriptor in guards:
-            os.close(descriptor)
+        while guards:
+            _close_guard(guards.pop())
     return messages_path, manifest_path
 
 
@@ -1253,6 +1385,47 @@ def install_openhands_artifact(
     return events_path, manifest_path
 
 
+def _resolve_hermes_title_conflict(
+    artifact: ConversionArtifact, *, target_home: Path
+) -> ConversionArtifact:
+    """Install without the title when the target store already holds it.
+
+    Hermes enforces ``idx_sessions_title_unique``, a partial unique index over
+    non-null session titles, so a second session cannot reuse one; its own
+    importer treats the title as cosmetic and leaves a conflicting session
+    untitled.  The migrator does the same and counts the omission, instead of
+    letting a cosmetic field refuse the whole migration.
+
+    The store is sampled before the import transaction, which still enforces the
+    constraint itself: a title created by a concurrent writer in between fails
+    closed, with no partial write.
+    """
+
+    title = hermes.bundle_title(artifact.native_bytes)
+    if not title:
+        return artifact
+    database = target_home.expanduser() / hermes.HERMES_STATE_FILENAME
+    if not hermes.title_taken(database, title):
+        return artifact
+    dropped = dict(artifact.dropped)
+    dropped["title:duplicate_in_target"] = 1
+    return replace(
+        artifact,
+        native_bytes=hermes.without_title(artifact.native_bytes),
+        dropped=dropped,
+        warnings=(
+            *artifact.warnings,
+            {
+                "code": "target_title_omitted",
+                "title": title,
+                "message": (
+                    "target store already holds this title; the session was installed without one"
+                ),
+            },
+        ),
+    )
+
+
 def install_hermes_artifact(
     artifact: ConversionArtifact,
     *,
@@ -1266,6 +1439,27 @@ def install_hermes_artifact(
     if artifact.target_format != TargetFormat.HERMES:
         raise SessionMigrateError("Hermes installation requires a Hermes artifact")
 
+    artifact = _resolve_hermes_title_conflict(artifact, target_home=target_home)
+    measured = hermes.measured_session_bytes(json.loads(artifact.native_bytes)["session"])
+    if measured > hermes.PINNED_HERMES_IMPORT_SESSION_BYTES:
+        artifact = replace(
+            artifact,
+            warnings=(
+                *artifact.warnings,
+                {
+                    "code": "target_import_budget_raised",
+                    "session_bytes": measured,
+                    "default_bytes": hermes.PINNED_HERMES_IMPORT_SESSION_BYTES,
+                    "budget_bytes": hermes.import_budget_bytes(measured),
+                    "message": (
+                        "the target store's per-session import cap was raised to fit this "
+                        "bundle, which carries inline image data; the store's own web import "
+                        "applies the same ceiling"
+                    ),
+                },
+            ),
+        )
+
     def install(simulate: bool) -> Path:
         result = hermes.install_bundle(
             artifact.native_bytes,
@@ -1375,6 +1569,7 @@ def _install_shared_database_artifact(
             manifest_bytes,
         )
     except BaseException as exc:
+        reservation_guard = _close_guard(reservation_guard)
         if reservation_identity is not None:
             _unlink_if_identity_matches(manifest_path, reservation_identity)
         if import_succeeded:
@@ -1384,8 +1579,7 @@ def _install_shared_database_artifact(
             ) from exc
         raise
     finally:
-        if reservation_guard is not None:
-            os.close(reservation_guard)
+        reservation_guard = _close_guard(reservation_guard)
     return database, manifest_path
 
 
@@ -1405,18 +1599,19 @@ def install_opencode_artifact(
     values = dict(os.environ if environ is None else environ)
     values.setdefault("OPENCODE_DISABLE_AUTOUPDATE", "true")
     values.setdefault("OPENCODE_DISABLE_PRUNE", "true")
-    if artifact.target_cli_version != opencode.PINNED_OPENCODE_VERSION:
+    if not opencode.supported_version(artifact.target_cli_version):
         raise SessionMigrateError(
-            "automatic OpenCode import requires target metadata version "
-            f"{opencode.PINNED_OPENCODE_VERSION}; convert-only artifacts may opt into "
-            "unvalidated metadata versions"
+            "automatic OpenCode import requires target metadata version 1.17.20 or supported 2.0.x"
         )
     cli = _resolve_opencode_cli(target_cli, values)
     observed_version = _opencode_version(cli, values)
-    if observed_version != opencode.PINNED_OPENCODE_VERSION:
+    if not opencode.supported_version(observed_version):
         raise SessionMigrateError(
-            "OpenCode CLI version mismatch: expected "
-            f"{opencode.PINNED_OPENCODE_VERSION}, observed {observed_version}"
+            f"OpenCode CLI version mismatch: unsupported observed version {observed_version}"
+        )
+    if opencode.is_v2(artifact.target_cli_version) != opencode.is_v2(observed_version):
+        raise SessionMigrateError(
+            "OpenCode CLI version mismatch: artifact and CLI transfer schemas differ"
         )
     if artifact.session_id in _opencode_session_ids(cli, values):
         raise SessionMigrateError(
@@ -1456,12 +1651,25 @@ def install_opencode_artifact(
             os.chmod(directory, 0o700)
             bundle_path = directory / "import.json"
             write_private_atomic(bundle_path, artifact.native_bytes)
-            _invoke_opencode_import(cli, bundle_path, values)
+            if opencode.is_v2(observed_version):
+                _invoke_opencode_import(cli, bundle_path, values, cwd=artifact.cwd)
+            else:
+                _invoke_opencode_import(cli, bundle_path, values)
             # From this point onward, any local cleanup/finalization failure
             # must warn that the native session may already exist.
             import_succeeded = True
 
-        if artifact.session_id not in _opencode_session_ids(cli, values):
+        if opencode.is_v2(observed_version):
+            with tempfile.TemporaryDirectory(
+                prefix="session-migrate-verify-", dir=temporary_root
+            ) as name:
+                _invoke_opencode_export(
+                    cli, artifact.session_id, Path(name) / "verify.json", values
+                )
+                exported = opencode.parse_import(Path(name) / "verify.json")
+                if exported.session_id != artifact.session_id:
+                    raise SessionMigrateError("OpenCode imported a different session ID")
+        elif artifact.session_id not in _opencode_session_ids(cli, values):
             raise SessionMigrateError(
                 "OpenCode import returned success but the session was not discoverable afterward"
             )
@@ -1472,6 +1680,11 @@ def install_opencode_artifact(
             manifest_bytes,
         )
     except BaseException as exc:
+        # Windows refuses to delete a file that still has an open handle, so release
+        # the identity guard *before* the rollback unlink.  Otherwise the cleanup
+        # error replaces the failure that triggered the rollback and the user never
+        # learns why finalization stopped, although the native import already ran.
+        reservation_guard = _close_guard(reservation_guard)
         if reservation_identity is not None:
             _unlink_if_identity_matches(manifest_path, reservation_identity)
         if import_succeeded:
@@ -1564,6 +1777,8 @@ def install_kilo_artifact(
             manifest_bytes,
         )
     except BaseException as exc:
+        # Same Windows rule as the OpenCode path: close the guard before unlinking.
+        reservation_guard = _close_guard(reservation_guard)
         if reservation_identity is not None:
             _unlink_if_identity_matches(manifest_path, reservation_identity)
         if import_succeeded:
@@ -1649,6 +1864,9 @@ def _validate_native_bytes(data: bytes, target_format: TargetFormat, session_id:
     if target_format == TargetFormat.ANTIGRAVITY:
         antigravity.validate_native_bytes(data, session_id)
         return
+    if target_format == TargetFormat.ANTIGRAVITY_DESKTOP:
+        antigravity_desktop.validate_native_bytes(data, session_id)
+        return
     if target_format == TargetFormat.CURSOR:
         cursor.validate_native_bytes(data, session_id)
         return
@@ -1703,6 +1921,7 @@ def _pinned_target_version(target_format: TargetFormat) -> str:
         TargetFormat.OPENCODE: opencode.PINNED_OPENCODE_VERSION,
         TargetFormat.COPILOT: copilot.PINNED_COPILOT_VERSION,
         TargetFormat.ANTIGRAVITY: antigravity.PINNED_ANTIGRAVITY_VERSION,
+        TargetFormat.ANTIGRAVITY_DESKTOP: (antigravity_desktop.PINNED_ANTIGRAVITY_DESKTOP_VERSION),
         TargetFormat.CURSOR: cursor.PINNED_CURSOR_VERSION,
         TargetFormat.VIBE: vibe.PINNED_VIBE_VERSION,
         TargetFormat.MUSE: muse.PINNED_MUSE_VERSION,
@@ -1736,6 +1955,8 @@ def _native_record_count(data: bytes, target_format: TargetFormat) -> int:
         return kimi.native_record_count(data)
     if target_format == TargetFormat.ANTIGRAVITY:
         return antigravity.native_record_count(data)
+    if target_format == TargetFormat.ANTIGRAVITY_DESKTOP:
+        return antigravity_desktop.native_record_count(data)
     if target_format == TargetFormat.CURSOR:
         return cursor.native_record_count(data)
     if target_format == TargetFormat.VIBE:
@@ -1744,6 +1965,8 @@ def _native_record_count(data: bytes, target_format: TargetFormat) -> int:
         return data.count(b"\n")
     value = json.loads(data)
     messages = value.get("messages", []) if isinstance(value, dict) else []
+    if opencode_v2.is_bundle(value):
+        return opencode_v2.record_count(value)
     return (
         1
         + len(messages)
@@ -1799,11 +2022,28 @@ def _opencode_version(cli: Path, environ: Mapping[str, str]) -> str:
     version = completed.stdout.strip()
     if not version or "\n" in version:
         raise SessionMigrateError("OpenCode CLI returned an invalid version string")
+    if version.startswith("opencode v"):
+        version = version.removeprefix("opencode v")
     return version
 
 
+def detect_opencode_version(target_cli: Path | None = None) -> str:
+    values = dict(os.environ)
+    values.setdefault("OPENCODE_DISABLE_AUTOUPDATE", "true")
+    values.setdefault("OPENCODE_DISABLE_PRUNE", "true")
+    observed = _opencode_version(_resolve_opencode_cli(target_cli, values), values)
+    if not opencode.supported_version(observed):
+        raise SessionMigrateError(f"unsupported OpenCode CLI version: {observed}")
+    return observed
+
+
 def _opencode_session_ids(cli: Path, environ: Mapping[str, str]) -> set[str]:
-    completed = _run_opencode([str(cli), "session", "list", "--format", "json", "--pure"], environ)
+    flags = (
+        ["--standalone", "--max-count", "1000000"]
+        if opencode.is_v2(_opencode_version(cli, environ))
+        else ["--pure"]
+    )
+    completed = _run_opencode([str(cli), "session", "list", "--format", "json", *flags], environ)
     if len(completed.stdout.encode()) > 64 * 1024 * 1024:
         raise SessionMigrateError("OpenCode session list exceeded the safety limit")
     # Pinned OpenCode 1.17.20 emits an empty stream, rather than ``[]``, when
@@ -1824,8 +2064,28 @@ def _opencode_session_ids(cli: Path, environ: Mapping[str, str]) -> set[str]:
     return result
 
 
-def _invoke_opencode_import(cli: Path, bundle_path: Path, environ: Mapping[str, str]) -> None:
-    _run_opencode([str(cli), "import", str(bundle_path), "--pure"], environ)
+def _invoke_opencode_import(
+    cli: Path, bundle_path: Path, environ: Mapping[str, str], *, cwd: Path | None = None
+) -> None:
+    if opencode.is_v2(_opencode_version(cli, environ)):
+        result = _run_opencode(
+            [
+                str(cli),
+                "session",
+                "import",
+                str(bundle_path),
+                "--directory",
+                str(cwd or Path.cwd()),
+                "--standalone",
+            ],
+            environ,
+        )
+        if not result.stdout.startswith("Imported session: "):
+            raise SessionMigrateError(
+                "OpenCode native import refused the session; no overwrite attempted"
+            )
+    else:
+        _run_opencode([str(cli), "import", str(bundle_path), "--pure"], environ)
 
 
 def _invoke_opencode_export(
@@ -1843,7 +2103,11 @@ def _invoke_opencode_export(
     try:
         descriptor = os.open(bundle_path, flags, 0o600)
         completed = subprocess.run(
-            [str(cli), "export", session_id, "--pure"],
+            (
+                [str(cli), "session", "export", session_id, "--standalone"]
+                if opencode.is_v2(_opencode_version(cli, environ))
+                else [str(cli), "export", session_id, "--pure"]
+            ),
             env=dict(environ),
             check=False,
             stdout=descriptor,
@@ -2056,6 +2320,8 @@ def _write_reserved_file(
 
 
 def _fsync_directory(path: Path) -> None:
+    if os.name == "nt":
+        return
     descriptor = os.open(path, os.O_RDONLY | getattr(os, "O_DIRECTORY", 0))
     try:
         os.fsync(descriptor)
@@ -2080,6 +2346,22 @@ def _unlink_if_identity_matches(path: Path, identity: tuple[int, int]) -> None:
         path.unlink()
 
 
+def _close_guard(descriptor: int | None) -> None:
+    """Close one identity-guard descriptor and hand back ``None``.
+
+    Windows refuses to delete a file while any handle still has it open, so a
+    rollback path must release its own guards *before* unlinking; the guard is
+    therefore closed in the failure path and re-closed (as a no-op) in the
+    surrounding ``finally``.
+    """
+
+    if descriptor is None:
+        return None
+    with suppress(OSError):
+        os.close(descriptor)
+    return None
+
+
 def _open_identity_guard(path: Path, identity: tuple[int, int], *, writable: bool = False) -> int:
     try:
         descriptor = os.open(
diff --git a/src/session_migrate/discovery.py b/src/session_migrate/discovery.py
index 0545fed..0f9c31a 100644
--- a/src/session_migrate/discovery.py
+++ b/src/session_migrate/discovery.py
@@ -57,7 +57,7 @@ def locate_session(
                 "--source-cwd applies only to Claude/Pi/OMP/Cursor/Vibe/Qwen/Kimi discovery"
             )
         matches = [home / "session-state" / normalized_id / "events.jsonl"]
-    elif source_format == AgentFormat.ANTIGRAVITY:
+    elif source_format in {AgentFormat.ANTIGRAVITY, AgentFormat.ANTIGRAVITY_DESKTOP}:
         if cwd is not None:
             raise SessionMigrateError(
                 "--source-cwd applies only to Claude/Pi/OMP/Cursor/Vibe/Qwen/Kimi discovery"
diff --git a/src/session_migrate/formats/__init__.py b/src/session_migrate/formats/__init__.py
index 1600409..dc3e932 100644
--- a/src/session_migrate/formats/__init__.py
+++ b/src/session_migrate/formats/__init__.py
@@ -2,6 +2,7 @@
 
 from session_migrate.formats import (
     antigravity,
+    antigravity_desktop,
     claude,
     codex,
     copilot,
@@ -23,6 +24,7 @@
 
 __all__ = [
     "antigravity",
+    "antigravity_desktop",
     "claude",
     "codex",
     "copilot",
diff --git a/src/session_migrate/formats/antigravity.py b/src/session_migrate/formats/antigravity.py
index c98e56f..b735857 100644
--- a/src/session_migrate/formats/antigravity.py
+++ b/src/session_migrate/formats/antigravity.py
@@ -44,13 +44,16 @@
 )
 PINNED_ANTIGRAVITY_LINUX_X86_64_SIZE = 205_545_512
 
-MAX_NATIVE_BYTES = 256 * 1024 * 1024
+MAX_NATIVE_BYTES = 512 * 1024 * 1024
 MAX_STEPS = 100_000
 MAX_PROTO_FIELDS = 100_000
 MAX_PROTO_VALUE_BYTES = 64 * 1024 * 1024
 MAX_JSON_NODES = 100_000
 MAX_TEXT_BYTES = 64 * 1024 * 1024
 PROJECT_ID = "default-cli-project"
+PROJECT_ID_DESKTOP = "outside-of-project"
+SOURCE_CLI = 17
+SOURCE_DESKTOP = 1
 
 STEP_STATUS_DONE = 3
 STEP_STATUS_ERROR = 7
@@ -415,34 +418,41 @@ def validate_native_bytes(data: bytes, session_id: str) -> None:
 
 
 def snapshot_database_bytes(path: Path) -> bytes:
-    """Return a bounded, transactionally consistent copy, including live WAL state."""
+    """Create a consistent SQLite snapshot and return its bytes."""
 
-    source = path.expanduser()
-    try:
-        info = source.lstat()
-    except OSError as exc:
-        raise SessionMigrateError("cannot inspect Antigravity conversation database") from exc
-    if stat.S_ISLNK(info.st_mode) or not stat.S_ISREG(info.st_mode):
-        raise SessionMigrateError("Antigravity conversation source must be a regular file")
-    if info.st_size > MAX_NATIVE_BYTES:
-        raise SessionMigrateError("Antigravity conversation exceeds the database safety limit")
+    path = Path(path)
+
+    if not path.is_file():
+        raise SessionMigrateError(f"Antigravity database not found: {path}")
 
     with tempfile.TemporaryDirectory(prefix="session-migrate-antigravity-snapshot-") as directory:
-        target = Path(directory) / "snapshot.db"
-        uri = f"file:{quote(str(source.resolve()), safe='/')}?mode=ro"
+        snapshot_path = Path(directory) / "snapshot.db"
+
+        source_db = None
+        snapshot_db = None
+
         try:
-            with sqlite3.connect(uri, uri=True, timeout=5) as origin:
-                origin.execute("PRAGMA trusted_schema=OFF")
-                with sqlite3.connect(target) as destination:
-                    origin.backup(destination)
-            data = target.read_bytes()
-        except (OSError, sqlite3.Error) as exc:
+            source_db = sqlite3.connect(path)
+            snapshot_db = sqlite3.connect(snapshot_path)
+
+            source_db.backup(snapshot_db)
+            snapshot_db.commit()
+
+        except sqlite3.Error as exc:
             raise SessionMigrateError(
-                "cannot make a consistent Antigravity database snapshot"
+                f"failed to snapshot Antigravity database {path}: {exc}"
             ) from exc
-    if not data or len(data) > MAX_NATIVE_BYTES:
-        raise SessionMigrateError("Antigravity database snapshot violates the safety limit")
-    return data
+
+        finally:
+            if snapshot_db is not None:
+                snapshot_db.close()
+                snapshot_db = None
+
+            if source_db is not None:
+                source_db.close()
+                source_db = None
+
+        return snapshot_path.read_bytes()
 
 
 def session_relative_path(session_id: str) -> Path:
@@ -632,6 +642,12 @@ def install_database(
                 raise SessionMigrateError("Antigravity install paths changed during transaction")
             summaries.execute("COMMIT")
     except BaseException:
+        if conversation_guard is not None:
+            os.close(conversation_guard)
+            conversation_guard = None
+        if summary_guard is not None:
+            os.close(summary_guard)
+            summary_guard = None
         if created_identity is not None:
             _unlink_if_same_file(conversation_path, created_identity)
         raise
@@ -649,85 +665,123 @@ def _build_database(
     conversation_id: str,
     trajectory_id: str,
     started_at: str,
+    source: int = SOURCE_CLI,
+    project_id: str = PROJECT_ID,
 ) -> bytes:
     with tempfile.TemporaryDirectory(prefix="session-migrate-antigravity-build-") as directory:
         path = Path(directory) / "conversation.db"
+
+        db = None
         try:
-            with sqlite3.connect(path) as db:
-                db.execute("PRAGMA journal_mode=DELETE")
-                db.executescript(
-                    """
-                    CREATE TABLE trajectory_meta (
-                      trajectory_id text, cascade_id text, trajectory_type integer, source integer,
-                      PRIMARY KEY (trajectory_id)
-                    );
-                    CREATE TABLE steps (
-                      idx integer, step_type integer NOT NULL DEFAULT 0,
-                      status integer NOT NULL DEFAULT 0,
-                      has_subtrajectory numeric NOT NULL DEFAULT false,
-                      metadata blob, error_details blob, permissions blob, task_details blob,
-                      render_info blob, step_payload blob,
-                      step_format integer NOT NULL DEFAULT 0,
-                      PRIMARY KEY (idx)
-                    );
-                    CREATE INDEX idx_steps_status ON steps(status);
-                    CREATE INDEX idx_steps_step_type ON steps(step_type);
-                    CREATE TABLE gen_metadata (
-                      idx integer, data blob, size integer NOT NULL DEFAULT 0, PRIMARY KEY (idx)
-                    );
-                    CREATE TABLE executor_metadata (idx integer, data blob, PRIMARY KEY (idx));
-                    CREATE TABLE parent_references (idx integer, data blob, PRIMARY KEY (idx));
-                    CREATE TABLE trajectory_metadata_blob (
-                      id text DEFAULT "main", data blob, PRIMARY KEY (id)
-                    );
-                    CREATE TABLE battle_mode_infos (idx integer, data blob, PRIMARY KEY (idx));
-                    """
-                )
-                db.execute(
-                    "INSERT INTO trajectory_meta VALUES(?,?,4,17)",
-                    (trajectory_id, conversation_id),
-                )
-                db.executemany(
-                    "INSERT INTO steps("
-                    "idx,step_type,status,has_subtrajectory,metadata,step_payload,step_format"
-                    ") VALUES(?,?,?,0,?,?,0)",
-                    [
-                        (row.index, row.step_type, row.status, row.metadata, row.payload)
-                        for row in rows
-                    ],
-                )
-                seconds = int(_parse_timestamp(started_at).timestamp())
-                trajectory_metadata = (
-                    _field_bytes(2, _field_varint(1, seconds))
-                    + _field_text(6, conversation_id)
-                    + _field_text(18, PROJECT_ID)
-                )
-                db.execute(
-                    "INSERT INTO trajectory_metadata_blob(id,data) VALUES('main',?)",
-                    (trajectory_metadata,),
-                )
-                result = db.execute("PRAGMA integrity_check").fetchone()
-                if result != ("ok",):
-                    raise SessionMigrateError(
-                        "generated Antigravity database failed integrity check"
+            db = sqlite3.connect(path)
+
+            db.execute("PRAGMA journal_mode=DELETE")
+            db.executescript(
+                """
+                CREATE TABLE trajectory_meta (
+                  trajectory_id text, cascade_id text, trajectory_type integer, source integer,
+                  PRIMARY KEY (trajectory_id)
+                );
+                CREATE TABLE steps (
+                  idx integer, step_type integer NOT NULL DEFAULT 0,
+                  status integer NOT NULL DEFAULT 0,
+                  has_subtrajectory numeric NOT NULL DEFAULT false,
+                  metadata blob, error_details blob, permissions blob, task_details blob,
+                  render_info blob, step_payload blob,
+                  step_format integer NOT NULL DEFAULT 0,
+                  PRIMARY KEY (idx)
+                );
+                CREATE INDEX idx_steps_status ON steps(status);
+                CREATE INDEX idx_steps_step_type ON steps(step_type);
+                CREATE TABLE gen_metadata (
+                  idx integer, data blob, size integer NOT NULL DEFAULT 0, PRIMARY KEY (idx)
+                );
+                CREATE TABLE executor_metadata (idx integer, data blob, PRIMARY KEY (idx));
+                CREATE TABLE parent_references (idx integer, data blob, PRIMARY KEY (idx));
+                CREATE TABLE trajectory_metadata_blob (
+                  id text DEFAULT "main", data blob, PRIMARY KEY (id)
+                );
+                CREATE TABLE battle_mode_infos (idx integer, data blob, PRIMARY KEY (idx));
+                """
+            )
+
+            db.execute(
+                "INSERT INTO trajectory_meta VALUES(?,?,4,?)",
+                (trajectory_id, conversation_id, source),
+            )
+
+            db.executemany(
+                "INSERT INTO steps("
+                "idx,step_type,status,has_subtrajectory,metadata,step_payload,step_format"
+                ") VALUES(?,?,?,0,?,?,0)",
+                [
+                    (
+                        row.index,
+                        row.step_type,
+                        row.status,
+                        row.metadata,
+                        row.payload,
                     )
-            data = path.read_bytes()
+                    for row in rows
+                ],
+            )
+
+            seconds = int(_parse_timestamp(started_at).timestamp())
+
+            trajectory_metadata = (
+                _field_bytes(2, _field_varint(1, seconds))
+                + _field_text(6, conversation_id)
+                + _field_text(18, project_id)
+            )
+
+            db.execute(
+                "INSERT INTO trajectory_metadata_blob(id,data) VALUES('main',?)",
+                (trajectory_metadata,),
+            )
+
+            result = db.execute("PRAGMA integrity_check").fetchone()
+
+            if result != ("ok",):
+                raise SessionMigrateError("generated Antigravity database failed integrity check")
+
+            db.commit()
+
         except sqlite3.Error as exc:
             raise SessionMigrateError("cannot construct Antigravity conversation database") from exc
+
+        finally:
+            if db is not None:
+                db.close()
+
+        data = path.read_bytes()
+
     if not data or len(data) > MAX_NATIVE_BYTES:
         raise SessionMigrateError("generated Antigravity database violates the safety limit")
+
     return data
 
 
 def _parse_database_bytes(
-    data: bytes, *, expected_session_id: str | None, generated: bool = False
+    data: bytes,
+    *,
+    expected_session_id: str | None,
+    generated: bool = False,
+    expected_source: int = SOURCE_CLI,
+    expected_project_id: str = PROJECT_ID,
+    is_desktop: bool = False,
+    cli_version: str = PINNED_ANTIGRAVITY_VERSION,
 ) -> ParsedAntigravitySession:
     if not data or len(data) > MAX_NATIVE_BYTES:
         raise SessionMigrateError("Antigravity conversation violates the database safety limit")
     digest = hashlib.sha256(data).hexdigest()
     with _database_from_bytes(data) as db:
         conversation_id, trajectory_id, rows, started_at, metadata_losses = _validate_database(
-            db, expected_session_id=expected_session_id, generated=generated
+            db,
+            expected_session_id=expected_session_id,
+            generated=generated,
+            expected_source=expected_source,
+            expected_project_id=expected_project_id,
+            is_desktop=is_desktop,
         )
         events = list(_project_events(rows))
         for reason, count in metadata_losses.items():
@@ -744,7 +798,7 @@ def _parse_database_bytes(
         trajectory_id=trajectory_id,
         cwd=None,
         started_at=started_at,
-        cli_version=PINNED_ANTIGRAVITY_VERSION,
+        cli_version=cli_version,
         model=None,
         title=None,
         events=tuple(events),
@@ -780,7 +834,13 @@ def _database_from_bytes(data: bytes) -> Iterator[sqlite3.Connection]:
 
 
 def _validate_database(
-    db: sqlite3.Connection, *, expected_session_id: str | None, generated: bool
+    db: sqlite3.Connection,
+    *,
+    expected_session_id: str | None,
+    generated: bool,
+    expected_source: int = SOURCE_CLI,
+    expected_project_id: str = PROJECT_ID,
+    is_desktop: bool = False,
 ) -> tuple[str, str, tuple[_StepRow, ...], str | None, dict[str, int]]:
     try:
         page_size = int(db.execute("PRAGMA page_size").fetchone()[0])
@@ -794,10 +854,11 @@ def _validate_database(
         trajectory_rows = db.execute(
             "SELECT trajectory_id,cascade_id,trajectory_type,source FROM trajectory_meta"
         ).fetchall()
-        main_rows = [row for row in trajectory_rows if row[2:] == (4, 17)]
+        main_rows = [row for row in trajectory_rows if row[2:] == (4, expected_source)]
         if len(main_rows) != 1:
+            desc = "Desktop" if is_desktop else "CLI"
             raise SessionMigrateError(
-                "Antigravity database must contain one CLI cascade trajectory"
+                f"Antigravity database must contain one {desc} cascade trajectory"
             )
         if generated and len(trajectory_rows) != 1:
             raise SessionMigrateError("generated Antigravity database has auxiliary trajectories")
@@ -808,8 +869,9 @@ def _validate_database(
         _require_uuid4(conversation_id, "Antigravity conversation ID")
         if expected_session_id is not None and conversation_id != expected_session_id:
             raise SessionMigrateError("Antigravity database conversation ID does not match target")
-        if trajectory_type != 4 or source != 17:
-            raise SessionMigrateError("Antigravity trajectory is not a pinned CLI cascade")
+        if trajectory_type != 4 or source != expected_source:
+            desc = "Desktop" if is_desktop else "CLI"
+            raise SessionMigrateError(f"Antigravity trajectory is not a pinned {desc} cascade")
 
         raw_metadata = db.execute(
             "SELECT id,data FROM trajectory_metadata_blob ORDER BY id"
@@ -821,7 +883,11 @@ def _validate_database(
         ):
             raise SessionMigrateError("Antigravity trajectory metadata is missing or ambiguous")
         started_at, trajectory_metadata_loss = _validate_trajectory_metadata(
-            raw_metadata[0][1], conversation_id, generated=generated
+            raw_metadata[0][1],
+            conversation_id,
+            generated=generated,
+            expected_project_id=expected_project_id,
+            is_desktop=is_desktop,
         )
 
         count = int(db.execute("SELECT count(*) FROM steps").fetchone()[0])
@@ -912,17 +978,29 @@ def _validate_conversation_schema(db: sqlite3.Connection) -> None:
 
 
 def _validate_trajectory_metadata(
-    data: bytes, conversation_id: str, *, generated: bool
+    data: bytes,
+    conversation_id: str,
+    *,
+    generated: bool,
+    expected_project_id: str = PROJECT_ID,
+    is_desktop: bool = False,
 ) -> tuple[str | None, bool]:
     fields = _decode_message(data)
     root = _optional_text(fields, 6)
-    if root is not None and root != conversation_id:
-        raise SessionMigrateError("Antigravity trajectory metadata root ID is inconsistent")
+    if root is not None:
+        try:
+            _require_uuid4(root, "Antigravity trajectory metadata root ID")
+        except SessionMigrateError:
+            raise SessionMigrateError(
+                "Antigravity trajectory metadata root ID is inconsistent"
+            ) from None
+        if generated and root != conversation_id:
+            raise SessionMigrateError("Antigravity trajectory metadata root ID is inconsistent")
     incomplete = root is None
     if generated and incomplete:
         raise SessionMigrateError("generated Antigravity trajectory metadata is incomplete")
     project = _optional_text(fields, 18)
-    if project is not None and project != PROJECT_ID:
+    if project is not None and project != expected_project_id:
         if generated:
             raise SessionMigrateError("Antigravity trajectory metadata project is unsupported")
         incomplete = True
@@ -951,6 +1029,9 @@ def _validate_step(data: bytes, *, step_type: int, status: int, generated: bool)
         raise SessionMigrateError("Antigravity step payload status disagrees with its SQLite row")
     if status not in {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12}:
         raise SessionMigrateError("Antigravity step status is outside pinned 1.1.16")
+    if status == 5:
+        # CLEARED status (compacted/cleared step): payload is empty or metadata only
+        return
     expected_payload_field = _STEP_PAYLOAD_FIELDS.get(step_type)
     if generated and step_type not in {
         STEP_TYPE_USER_INPUT,
@@ -968,7 +1049,7 @@ def _validate_step(data: bytes, *, step_type: int, status: int, generated: bool)
 def _validate_known_step_payload(step_type: int, data: bytes, *, generated: bool) -> None:
     fields = _decode_message(data)
     if step_type == STEP_TYPE_USER_INPUT:
-        if _optional_text(fields, 2) is None and _optional_text(fields, 1) is None:
+        if generated and _optional_text(fields, 2) is None and _optional_text(fields, 1) is None:
             raise SessionMigrateError("Antigravity user step contains no readable text")
     elif step_type == STEP_TYPE_PLANNER_RESPONSE:
         response = _optional_text(fields, 1)
@@ -981,14 +1062,19 @@ def _validate_known_step_payload(step_type: int, data: bytes, *, generated: bool
         for entry in _bytes_values(fields, 1):
             entry_fields = _decode_message(entry)
             _required_text(entry_fields, 1, "generic argument key")
-            _required_text(entry_fields, 2, "generic argument value")
-        result = _required_bytes(fields, 2, "generic tool result")
-        result_fields = _decode_message(result)
-        _required_text(result_fields, 1, "generic result text", allow_empty=True)
-        for entry in _bytes_values(result_fields, 2):
-            metadata_fields = _decode_message(entry)
-            _required_text(metadata_fields, 1, "generic result metadata key")
-            _required_text(metadata_fields, 2, "generic result metadata value", allow_empty=True)
+            _required_text(entry_fields, 2, "generic argument value", allow_empty=True)
+        result = _optional_bytes(fields, 2)
+        if result is not None:
+            result_fields = _decode_message(result)
+            _required_text(result_fields, 1, "generic result text", allow_empty=True)
+            for entry in _bytes_values(result_fields, 2):
+                metadata_fields = _decode_message(entry)
+                _required_text(metadata_fields, 1, "generic result metadata key")
+                _required_text(
+                    metadata_fields, 2, "generic result metadata value", allow_empty=True
+                )
+        elif generated:
+            raise SessionMigrateError("Antigravity generic tool result is missing")
     elif step_type == STEP_TYPE_MCP_TOOL:
         call = _optional_bytes(fields, 2)
         if call is not None:
@@ -1002,6 +1088,10 @@ def _project_events(rows: Sequence[_StepRow]) -> tuple[Event, ...]:
     pending: deque[tuple[str, str]] = deque()
     emitted_calls: Counter[str] = Counter()
     for row in rows:
+        if row.status == 5:
+            timestamp = _step_timestamp(row.metadata)
+            events.append(_opaque_event(row, "antigravity_cleared_step", timestamp))
+            continue
         outer = _decode_message(row.payload)
         payload_number = _STEP_PAYLOAD_FIELDS.get(row.step_type)
         payload = _optional_bytes(outer, payload_number) if payload_number else None
@@ -1020,6 +1110,8 @@ def _project_events(rows: Sequence[_StepRow]) -> tuple[Event, ...]:
                         provenance=provenance,
                     )
                 )
+            else:
+                events.append(_opaque_event(row, "antigravity_user_action", timestamp))
             if _bytes_values(fields, 3) or _bytes_values(fields, 9):
                 events.append(_opaque_event(row, "antigravity_user_context", timestamp))
             continue
@@ -1073,9 +1165,17 @@ def _project_events(rows: Sequence[_StepRow]) -> tuple[Event, ...]:
             continue
         if row.step_type == STEP_TYPE_GENERIC and payload is not None:
             fields = _decode_message(payload)
-            result_fields = _decode_message(_required_bytes(fields, 2, "generic result"))
-            result_text = _required_text(result_fields, 1, "generic result text", allow_empty=True)
-            linked_call_id = _generic_result_call_id(result_fields)
+            result_bytes = _optional_bytes(fields, 2)
+            if result_bytes is not None:
+                result_fields = _decode_message(result_bytes)
+                result_text = _required_text(
+                    result_fields, 1, "generic result text", allow_empty=True
+                )
+                linked_call_id = _generic_result_call_id(result_fields)
+            else:
+                result_fields = ()
+                result_text = None
+                linked_call_id = None
             pending_index = next(
                 (
                     index
@@ -1532,6 +1632,10 @@ def _summary_values(
     timestamp: str,
     cwd: Path,
     last_user_input_index: int,
+    status: str = "",
+    source: str = "antigravity-cli",
+    project_id: str = PROJECT_ID,
+    app_data_dir: str = "antigravity-cli",
 ) -> tuple[Any, ...]:
     bounded_title = title[:4_096]
     bounded_preview = preview[:16_384]
@@ -1543,9 +1647,9 @@ def _summary_values(
         step_count,
         _parse_timestamp(timestamp).isoformat(sep=" "),
         json.dumps([workspace_uri], ensure_ascii=False, separators=(",", ":")),
-        "",
-        "antigravity-cli",
-        PROJECT_ID,
+        status,
+        source,
+        project_id,
         "",
         "",
         0,
@@ -1555,7 +1659,7 @@ def _summary_values(
         0,
         _parse_timestamp(timestamp).isoformat(sep=" "),
         last_user_input_index,
-        "antigravity-cli",
+        app_data_dir,
     )
 
 
@@ -1588,7 +1692,15 @@ def _read_summary_metadata(path: Path, session_id: str) -> tuple[str | None, Pat
         if isinstance(uris, list) and uris and isinstance(uris[0], str):
             parsed = urlparse(uris[0])
             if parsed.scheme == "file" and not parsed.netloc:
-                cwd = Path(unquote(parsed.path))
+                raw_path = unquote(parsed.path)
+                if (
+                    os.name == "nt"
+                    and len(raw_path) >= 3
+                    and raw_path[0] == "/"
+                    and raw_path[2] == ":"
+                ):
+                    raw_path = raw_path[1:]
+                cwd = Path(raw_path)
     except (TypeError, ValueError, json.JSONDecodeError):
         pass
     return title, cwd
@@ -1625,43 +1737,50 @@ def _ensure_summary_database(path: Path) -> None:
         prefix=".session-migrate-summary-", dir=path.parent
     ) as directory:
         staged = Path(directory) / "conversation_summaries.db"
+        db = None
         try:
-            with sqlite3.connect(staged) as db:
-                db.executescript(
-                    """
-                    CREATE TABLE conversation_summaries (
-                      conversation_id text,
-                      title text NOT NULL DEFAULT "",
-                      preview text NOT NULL DEFAULT "",
-                      step_count integer NOT NULL DEFAULT 0,
-                      last_modified_time datetime NOT NULL,
-                      workspace_uris text NOT NULL,
-                      status text NOT NULL DEFAULT "",
-                      source text NOT NULL DEFAULT "",
-                      project_id text NOT NULL DEFAULT "",
-                      agent_name text NOT NULL DEFAULT "",
-                      parent_conversation_id text NOT NULL DEFAULT "",
-                      nesting_depth integer NOT NULL DEFAULT 0,
-                      battle_id text NOT NULL DEFAULT "",
-                      winning_conversation_id text NOT NULL DEFAULT "",
-                      not_fully_idle numeric NOT NULL DEFAULT false,
-                      killed numeric NOT NULL DEFAULT false,
-                      last_user_input_time datetime NOT NULL,
-                      last_user_input_step_index integer NOT NULL DEFAULT -1,
-                      app_data_dir text NOT NULL DEFAULT "",
-                      PRIMARY KEY (conversation_id)
-                    );
-                    CREATE INDEX idx_conversation_summaries_last_user_input_time
-                      ON conversation_summaries(last_user_input_time);
-                    CREATE INDEX idx_conversation_summaries_last_modified_time
-                      ON conversation_summaries(last_modified_time);
-                    """
-                )
-                if db.execute("PRAGMA integrity_check").fetchone() != ("ok",):
-                    raise SessionMigrateError("generated Antigravity summary DB failed integrity")
+            db = sqlite3.connect(staged)
+            db.executescript(
+                """
+                CREATE TABLE conversation_summaries (
+                  conversation_id text,
+                  title text NOT NULL DEFAULT "",
+                  preview text NOT NULL DEFAULT "",
+                  step_count integer NOT NULL DEFAULT 0,
+                  last_modified_time datetime NOT NULL,
+                  workspace_uris text NOT NULL,
+                  status text NOT NULL DEFAULT "",
+                  source text NOT NULL DEFAULT "",
+                  project_id text NOT NULL DEFAULT "",
+                  agent_name text NOT NULL DEFAULT "",
+                  parent_conversation_id text NOT NULL DEFAULT "",
+                  nesting_depth integer NOT NULL DEFAULT 0,
+                  battle_id text NOT NULL DEFAULT "",
+                  winning_conversation_id text NOT NULL DEFAULT "",
+                  not_fully_idle numeric NOT NULL DEFAULT false,
+                  killed numeric NOT NULL DEFAULT false,
+                  last_user_input_time datetime NOT NULL,
+                  last_user_input_step_index integer NOT NULL DEFAULT -1,
+                  app_data_dir text NOT NULL DEFAULT "",
+                  PRIMARY KEY (conversation_id)
+                );
+                CREATE INDEX idx_conversation_summaries_last_user_input_time
+                  ON conversation_summaries(last_user_input_time);
+                CREATE INDEX idx_conversation_summaries_last_modified_time
+                  ON conversation_summaries(last_modified_time);
+                """
+            )
+            if db.execute("PRAGMA integrity_check").fetchone() != ("ok",):
+                raise SessionMigrateError("generated Antigravity summary DB failed integrity")
+            db.commit()
+            db.close()
+            db = None
             data = staged.read_bytes()
         except sqlite3.Error as exc:
             raise SessionMigrateError("cannot create Antigravity summary database") from exc
+        finally:
+            if db is not None:
+                db.close()
     try:
         write_private_atomic(path, data)
     except Exception:
@@ -1685,7 +1804,7 @@ def _validate_summary_schema(db: sqlite3.Connection) -> None:
         if object_row != ("table",):
             raise SessionMigrateError("Antigravity summary table is missing")
         columns = tuple(row[1] for row in db.execute("PRAGMA table_info('conversation_summaries')"))
-        if columns != _SUMMARY_COLUMNS:
+        if columns not in (_SUMMARY_COLUMNS, _SUMMARY_COLUMNS + ("raw_summary", "group_id")):
             raise SessionMigrateError("Antigravity summary columns do not match pinned 1.1.16")
         for index_name, expected_column in (
             ("idx_conversation_summaries_last_user_input_time", "last_user_input_time"),
diff --git a/src/session_migrate/formats/antigravity_desktop.py b/src/session_migrate/formats/antigravity_desktop.py
new file mode 100644
index 0000000..17d9095
--- /dev/null
+++ b/src/session_migrate/formats/antigravity_desktop.py
@@ -0,0 +1,616 @@
+"""Antigravity Desktop 2.18.1 SQLite/protobuf session adapter.
+
+This module adapts conversations to and from the Antigravity Desktop application
+(macOS/Electron), which stores individual cascade conversations as SQLite databases
+under ``~/.gemini/antigravity/conversations/<uuid>.db`` and registers metadata in
+``~/.gemini/antigravity/conversation_summaries.db``.
+
+While the table schemas match the Antigravity CLI format, Desktop differs in:
+  - ``trajectory_meta.source``: 1 (IDE / Hub) rather than 17 (CLI).
+  - ``trajectory_metadata_blob.project_id``: ``"outside-of-project"`` (or project UUID)
+    rather than ``"default-cli-project"``.
+  - ``conversation_summaries``:
+      - ``source``: ``""``
+      - ``app_data_dir``: ``"antigravity"``
+      - ``project_id``: ``"outside-of-project"``
+      - ``status``: ``"CASCADE_RUN_STATUS_IDLE"``
+  - Subagents: field 6 of ``trajectory_metadata_blob`` points to the root cascade ID,
+    so subagent conversations have ``root != conversation_id`` and ``nesting_depth >= 1``.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import sqlite3
+import stat
+import sys
+from collections import Counter
+from collections.abc import Mapping
+from dataclasses import replace
+from pathlib import Path
+from typing import Any
+from urllib.parse import quote
+
+from session_migrate.errors import SessionMigrateError
+from session_migrate.formats import antigravity
+from session_migrate.formats.antigravity import (
+    _SUMMARY_COLUMNS,
+    STEP_STATUS_DONE,
+    STEP_STATUS_ERROR,
+    STEP_TYPE_GENERIC,
+    STEP_TYPE_PLANNER_RESPONSE,
+    STEP_TYPE_USER_INPUT,
+    InstalledAntigravitySession,
+    ParsedAntigravitySession,
+    _absolute_no_follow,
+    _database_from_bytes,
+    _ensure_private_directory,
+    _ensure_summary_database,
+    _event_timestamp,
+    _field_bytes,
+    _field_text,
+    _field_varint,
+    _generic_argument_entries,
+    _guard_matches_path,
+    _last_user_input_index,
+    _omission_key,
+    _open_identity_guard,
+    _read_summary_metadata,
+    _require_uuid4,
+    _session_id_from_path,
+    _StepRow,
+    _stream_sha256,
+    _summary_values,
+    _unlink_if_same_file,
+    _utc_now,
+    _validate_summary_schema,
+    content_text,
+    valid_rfc3339,
+)
+from session_migrate.jsonl import write_private_atomic
+from session_migrate.model import AgentFormat, EventKind, Role, Session
+
+PINNED_ANTIGRAVITY_DESKTOP_VERSION = "2.18.1"
+
+# macOS arm64
+PINNED_ANTIGRAVITY_DESKTOP_MACOS_ARM64_SHA256 = (
+    "300ee20f3108a511be1149602b91ba84cbbdcc42213067151e255584129be30f"
+)
+PINNED_ANTIGRAVITY_DESKTOP_MACOS_ARM64_SIZE = 148_990_608
+
+# Linux x64
+PINNED_ANTIGRAVITY_DESKTOP_LINUX_X64_SHA256 = (
+    "ab4937445fa3817bc374a1db71062de7daecdb093cbfb6bd36b80f443198670e"
+)
+PINNED_ANTIGRAVITY_DESKTOP_LINUX_X64_SIZE = 181_432_528
+
+# Windows x64
+PINNED_ANTIGRAVITY_DESKTOP_WINDOWS_X64_SHA256 = (
+    "1ed84e6a1d1e51064d80c9f382ab3a519eb2775cb91d552c63064a18cfdf3cf2"
+)
+PINNED_ANTIGRAVITY_DESKTOP_WINDOWS_X64_SIZE = 163_640_320
+
+PINNED_DESKTOP_SPECS: dict[str, tuple[int, str]] = {
+    "darwin": (
+        PINNED_ANTIGRAVITY_DESKTOP_MACOS_ARM64_SIZE,
+        PINNED_ANTIGRAVITY_DESKTOP_MACOS_ARM64_SHA256,
+    ),
+    "linux": (
+        PINNED_ANTIGRAVITY_DESKTOP_LINUX_X64_SIZE,
+        PINNED_ANTIGRAVITY_DESKTOP_LINUX_X64_SHA256,
+    ),
+    "win32": (
+        PINNED_ANTIGRAVITY_DESKTOP_WINDOWS_X64_SIZE,
+        PINNED_ANTIGRAVITY_DESKTOP_WINDOWS_X64_SHA256,
+    ),
+}
+
+DEFAULT_MACOS_LANGUAGE_SERVER_PATH = Path(
+    "/Applications/Antigravity.app/Contents/Resources/bin/language_server"
+)
+DEFAULT_LINUX_LANGUAGE_SERVER_PATH = Path("/opt/Antigravity/resources/bin/language_server")
+DEFAULT_WINDOWS_LANGUAGE_SERVER_PATH = Path(
+    "Programs/antigravity/resources/bin/language_server.exe"
+)
+
+
+def default_language_server_path(
+    platform: str | None = None,
+    environ: Mapping[str, str] | None = None,
+    home: Path | None = None,
+) -> Path:
+    """Resolve the default language server binary path for the target platform.
+
+    Can be overridden via the ``SESSION_MIGRATE_ANTIGRAVITY_DESKTOP_BIN``
+    environment variable.
+    """
+    env = os.environ if environ is None else environ
+    override = env.get("SESSION_MIGRATE_ANTIGRAVITY_DESKTOP_BIN")
+    if override:
+        return Path(override).expanduser()
+
+    current_platform = sys.platform if platform is None else platform
+    if current_platform == "darwin":
+        return DEFAULT_MACOS_LANGUAGE_SERVER_PATH
+    if current_platform == "win32":
+        local_app_data = env.get("LOCALAPPDATA")
+        if local_app_data:
+            for sub in (
+                "Programs/antigravity",
+                "Programs/Antigravity",
+                "programs/antigravity",
+                "programs/Antigravity",
+            ):
+                candidate = Path(local_app_data) / sub / "resources" / "bin" / "language_server.exe"
+                if candidate.is_file():
+                    return candidate
+        prog_files = env.get("PROGRAMFILES")
+        if prog_files:
+            for sub in ("antigravity", "Antigravity"):
+                candidate = Path(prog_files) / sub / "resources" / "bin" / "language_server.exe"
+                if candidate.is_file():
+                    return candidate
+        if local_app_data:
+            return Path(local_app_data) / DEFAULT_WINDOWS_LANGUAGE_SERVER_PATH
+        return Path("C:\\Program Files\\antigravity\\resources\\bin\\language_server.exe")
+
+    # Linux / other Unix: check PATH launcher, then common installation directories
+    launcher = shutil.which("antigravity", path=env.get("PATH"))
+    if launcher:
+        cand = Path(launcher).resolve().parent / "resources" / "bin" / "language_server"
+        if cand.is_file():
+            return cand
+    user_home = (home or Path.home()).expanduser()
+    for cand in (
+        Path("/opt/Antigravity/resources/bin/language_server"),
+        Path("/opt/Antigravity-x64/resources/bin/language_server"),
+        Path("/opt/antigravity/resources/bin/language_server"),
+        user_home / "Antigravity-x64/resources/bin/language_server",
+        user_home / ".local/share/Antigravity/resources/bin/language_server",
+        user_home / ".local/share/antigravity/resources/bin/language_server",
+        Path("/usr/lib/antigravity/resources/bin/language_server"),
+    ):
+        if cand.is_file():
+            return cand
+    return DEFAULT_LINUX_LANGUAGE_SERVER_PATH
+
+
+def electron_user_data_dir(
+    platform: str | None = None,
+    environ: Mapping[str, str] | None = None,
+    home: Path | None = None,
+) -> Path:
+    """Return the Electron userData directory where app_storage.json resides."""
+    env = os.environ if environ is None else environ
+    current_platform = sys.platform if platform is None else platform
+    user_home = (home or Path.home()).expanduser()
+
+    if current_platform == "darwin":
+        return user_home / "Library" / "Application Support" / "Antigravity"
+    if current_platform == "win32":
+        app_data = env.get("APPDATA")
+        if app_data:
+            return Path(app_data) / "Antigravity"
+        return user_home / "AppData" / "Roaming" / "Antigravity"
+
+    # Linux / XDG standard
+    xdg_config = env.get("XDG_CONFIG_HOME")
+    if xdg_config:
+        return Path(xdg_config) / "Antigravity"
+    return user_home / ".config" / "Antigravity"
+
+
+MAX_NATIVE_BYTES = antigravity.MAX_NATIVE_BYTES
+PROJECT_ID = antigravity.PROJECT_ID_DESKTOP  # "outside-of-project"
+SOURCE_DESKTOP = antigravity.SOURCE_DESKTOP  # 1
+
+session_relative_path = antigravity.session_relative_path
+snapshot_database_bytes = antigravity.snapshot_database_bytes
+
+
+def app_data_home(home: Path | None = None) -> Path:
+    """Return the Antigravity Desktop store below a chosen process HOME."""
+    return (home or Path.home()).expanduser() / ".gemini" / "antigravity"
+
+
+def serialize(
+    session: Session,
+    *,
+    session_id: str,
+    cwd: Path,
+    cli_version: str = PINNED_ANTIGRAVITY_DESKTOP_VERSION,
+    model: str | None = None,
+    timestamp: str | None = None,
+    trajectory_id: str | None = None,
+) -> tuple[bytes, dict[str, int]]:
+    """Serialize portable conversation history as an Antigravity Desktop SQLite DB."""
+    del cli_version, model
+    _require_uuid4(session_id, "Antigravity conversation ID")
+    import uuid
+
+    target_trajectory_id = trajectory_id or str(uuid.uuid4())
+    _require_uuid4(target_trajectory_id, "Antigravity trajectory ID")
+    if target_trajectory_id == session_id:
+        raise SessionMigrateError("Antigravity conversation and trajectory IDs must differ")
+
+    started_at = valid_rfc3339(timestamp) or valid_rfc3339(session.started_at) or _utc_now()
+    dropped: Counter[str] = Counter()
+    rows: list[_StepRow] = []
+    pending_calls: list[tuple[str | None, str, str, Any]] = []
+    generated_call_number = 0
+
+    def append_step(step_type: int, status: int, native_payload: bytes) -> None:
+        outer = _field_varint(1, step_type) + _field_varint(4, status)
+        outer += _field_bytes(antigravity._STEP_PAYLOAD_FIELDS[step_type], native_payload)
+        rows.append(_StepRow(len(rows), step_type, status, None, outer))
+
+    for event in session.events:
+        _event_timestamp(event, started_at, dropped)
+        if event.kind == EventKind.MESSAGE and event.role == Role.USER:
+            if event.text:
+                append_step(STEP_TYPE_USER_INPUT, STEP_STATUS_DONE, _field_text(2, event.text))
+            continue
+        if event.kind == EventKind.MESSAGE and event.role == Role.ASSISTANT:
+            if event.text:
+                planner = _field_text(1, event.text) + _field_text(6, str(uuid.uuid4()))
+                append_step(STEP_TYPE_PLANNER_RESPONSE, STEP_STATUS_DONE, planner)
+            continue
+        if event.kind == EventKind.TOOL_CALL and event.role == Role.ASSISTANT:
+            call_id = event.tool_call_id or f"session-migrate-{session_id}-{len(rows)}"
+            name = event.tool_name or "unknown_tool"
+            raw_input = event.payload.get("input", {})
+            import json
+
+            arguments_json = json.dumps(
+                raw_input if isinstance(raw_input, dict) else {},
+                ensure_ascii=False,
+                separators=(",", ":"),
+            )
+            native_call = (
+                _field_text(1, call_id) + _field_text(2, name) + _field_text(3, arguments_json)
+            )
+            planner = _field_text(6, str(uuid.uuid4())) + _field_bytes(7, native_call)
+            pending_calls.append((event.tool_call_id, call_id, name, raw_input))
+            append_step(STEP_TYPE_PLANNER_RESPONSE, STEP_STATUS_DONE, planner)
+            continue
+        if event.kind == EventKind.TOOL_RESULT and event.role == Role.TOOL:
+            match_index: int | None = None
+            if event.tool_call_id:
+                matching_indices = [
+                    index
+                    for index, pending in enumerate(pending_calls)
+                    if pending[0] == event.tool_call_id
+                ]
+                if event.tool_name:
+                    named_indices = [
+                        index
+                        for index in matching_indices
+                        if pending_calls[index][2] == event.tool_name
+                    ]
+                    if named_indices:
+                        matching_indices = named_indices
+                match_index = next(iter(matching_indices), None)
+            elif pending_calls:
+                match_index = 0
+                dropped["tool_result:missing_id"] += 1
+            if match_index is not None:
+                _, call_id, tool_name, tool_input = pending_calls.pop(match_index)
+            else:
+                generated_call_number += 1
+                call_id = event.tool_call_id or (
+                    f"session-migrate-{session_id}-{generated_call_number}"
+                )
+                tool_name = event.tool_name or "unknown_tool"
+                tool_input = {}
+                import json
+
+                native_call = (
+                    _field_text(1, call_id) + _field_text(2, tool_name) + _field_text(3, "{}")
+                )
+                append_step(
+                    STEP_TYPE_PLANNER_RESPONSE,
+                    STEP_STATUS_DONE,
+                    _field_text(6, str(uuid.uuid4())) + _field_bytes(7, native_call),
+                )
+                dropped["tool_result:orphan_id"] += 1
+            generic = b"".join(_generic_argument_entries(tool_input, dropped))
+            result_text = event.text or content_text(event.payload.get("content_blocks"))
+            linkage_entry = _field_text(1, "session_migrate_call_id") + _field_text(2, call_id)
+            generic_result = _field_text(1, result_text or "") + _field_bytes(2, linkage_entry)
+            generic += _field_bytes(2, generic_result)
+            append_step(
+                STEP_TYPE_GENERIC,
+                STEP_STATUS_ERROR if event.payload.get("is_error") is True else STEP_STATUS_DONE,
+                generic,
+            )
+            blocks = event.payload.get("content_blocks")
+            if isinstance(blocks, list):
+                for block in blocks:
+                    if not isinstance(block, dict) or block.get("type") != "text":
+                        dropped["tool_result:non_text_block"] += 1
+            continue
+        if event.kind == EventKind.THINKING:
+            dropped["thinking:private"] += 1
+        elif event.kind == EventKind.COMPACTION:
+            dropped["compaction:no_stored_native_equivalent"] += 1
+        elif event.kind == EventKind.MESSAGE:
+            dropped["message:privileged_role"] += 1
+        else:
+            dropped[_omission_key(event)] += 1
+
+    if not any(row.step_type == STEP_TYPE_USER_INPUT for row in rows):
+        raise SessionMigrateError(
+            "Antigravity Desktop target requires at least one portable user message"
+        )
+
+    data = antigravity._build_database(
+        rows,
+        conversation_id=session_id,
+        trajectory_id=target_trajectory_id,
+        started_at=started_at,
+        source=SOURCE_DESKTOP,
+        project_id=PROJECT_ID,
+    )
+    validate_native_bytes(data, session_id)
+    return data, dict(sorted(dropped.items()))
+
+
+def parse(path: Path) -> ParsedAntigravitySession:
+    """Read one Desktop conversation DB through a consistent SQLite backup snapshot."""
+    snapshot = snapshot_database_bytes(path)
+    parsed = antigravity._parse_database_bytes(
+        snapshot,
+        expected_session_id=_session_id_from_path(path),
+        expected_source=SOURCE_DESKTOP,
+        expected_project_id=PROJECT_ID,
+        is_desktop=True,
+        cli_version=PINNED_ANTIGRAVITY_DESKTOP_VERSION,
+    )
+    title, cwd = _read_summary_metadata(path, parsed.session_id)
+    return replace(parsed, title=title, cwd=cwd)
+
+
+def parse_session(path: Path) -> Session:
+    """Parse Antigravity Desktop as a first-class source."""
+    parsed = parse(path)
+    return Session(
+        source_format=AgentFormat.ANTIGRAVITY_DESKTOP,
+        source_path=path.resolve(),
+        source_sha256=parsed.snapshot_sha256,
+        session_id=parsed.session_id,
+        cwd=parsed.cwd,
+        started_at=parsed.started_at,
+        cli_version=parsed.cli_version,
+        model=parsed.model,
+        title=parsed.title,
+        events=parsed.events,
+        raw_record_count=parsed.raw_record_count,
+        model_provider="google",
+    )
+
+
+def validate_native_bytes(data: bytes, session_id: str) -> None:
+    """Strictly validate a generated Antigravity Desktop conversation database."""
+    _require_uuid4(session_id, "Antigravity conversation ID")
+    parsed = antigravity._parse_database_bytes(
+        data,
+        expected_session_id=session_id,
+        generated=True,
+        expected_source=SOURCE_DESKTOP,
+        expected_project_id=PROJECT_ID,
+        is_desktop=True,
+        cli_version=PINNED_ANTIGRAVITY_DESKTOP_VERSION,
+    )
+    if not any(
+        event.kind == EventKind.MESSAGE and event.role == Role.USER for event in parsed.events
+    ):
+        raise SessionMigrateError("generated Antigravity Desktop session contains no user message")
+
+
+def native_record_count(data: bytes) -> int:
+    """Return the number of stored steps after full byte validation."""
+    with _database_from_bytes(data) as db:
+        antigravity._validate_database(
+            db,
+            expected_session_id=None,
+            generated=True,
+            expected_source=SOURCE_DESKTOP,
+            expected_project_id=PROJECT_ID,
+            is_desktop=True,
+        )
+        return int(db.execute("SELECT count(*) FROM steps").fetchone()[0])
+
+
+def verify_pinned_desktop(
+    executable: Path | None = None,
+    *,
+    platform: str | None = None,
+    environ: Mapping[str, str] | None = None,
+) -> Path:
+    """Resolve and verify the Antigravity Desktop language server binary."""
+    values = dict(os.environ if environ is None else environ)
+    current_platform = sys.platform if platform is None else platform
+    candidate: str | None = None
+    if executable:
+        candidate = str(executable)
+    elif values.get("SESSION_MIGRATE_ANTIGRAVITY_DESKTOP_BIN"):
+        candidate = values["SESSION_MIGRATE_ANTIGRAVITY_DESKTOP_BIN"]
+    elif values.get("ANTIGRAVITY_DESKTOP_BIN"):
+        candidate = values["ANTIGRAVITY_DESKTOP_BIN"]
+    elif values.get("ANTIGRAVITY_LANGUAGE_SERVER_BIN"):
+        candidate = values["ANTIGRAVITY_LANGUAGE_SERVER_BIN"]
+    elif default_language_server_path(platform=current_platform, environ=values).is_file():
+        candidate = str(default_language_server_path(platform=current_platform, environ=values))
+    else:
+        candidate = shutil.which("language_server", path=values.get("PATH"))
+
+    if not candidate:
+        raise SessionMigrateError("Antigravity Desktop executable 'language_server' was not found")
+    path = Path(candidate).expanduser().resolve()
+    try:
+        info = path.stat()
+    except OSError as exc:
+        raise SessionMigrateError("cannot inspect the Antigravity Desktop executable") from exc
+    if not stat.S_ISREG(info.st_mode):
+        raise SessionMigrateError("Antigravity Desktop executable is not a regular file")
+
+    if values.get("SESSION_MIGRATE_UNVALIDATED_DESKTOP_BIN") == "1":
+        return path
+
+    if current_platform not in PINNED_DESKTOP_SPECS:
+        raise SessionMigrateError(
+            f"Antigravity Desktop native binary verification is not supported on "
+            f"{current_platform}; supported platforms are darwin, linux, win32. "
+            "Set SESSION_MIGRATE_UNVALIDATED_DESKTOP_BIN=1 to proceed with an unvalidated binary."
+        )
+
+    expected_size, expected_digest = PINNED_DESKTOP_SPECS[current_platform]
+    if info.st_size != expected_size:
+        raise SessionMigrateError(
+            f"Antigravity Desktop binary size mismatch on {current_platform}: expected "
+            f"{expected_size} bytes, observed {info.st_size}"
+        )
+    digest = _stream_sha256(path, maximum=expected_size)
+    if digest != expected_digest:
+        raise SessionMigrateError(
+            f"Antigravity Desktop binary digest mismatch on {current_platform}; "
+            "refusing private-store installation"
+        )
+    return path
+
+
+def install_database(
+    data: bytes,
+    *,
+    session_id: str,
+    cwd: Path,
+    timestamp: str,
+    title: str | None,
+    target_home: Path,
+    target_cli: Path | None = None,
+    dry_run: bool = False,
+    environ: Mapping[str, str] | None = None,
+) -> InstalledAntigravitySession:
+    """Install a validated conversation and its desktop summary without overwrite."""
+    validate_native_bytes(data, session_id)
+    if target_cli is not None or os.environ.get("SESSION_MIGRATE_VERIFY_DESKTOP_BIN") == "1":
+        verify_pinned_desktop(target_cli, environ=environ)
+    root = _absolute_no_follow(target_home)
+    conversation_path = root / session_relative_path(session_id)
+    summaries_path = root / "conversation_summaries.db"
+    cwd = cwd.expanduser().resolve()
+    summary_timestamp = valid_rfc3339(timestamp) or _utc_now()
+    parsed = antigravity._parse_database_bytes(
+        data,
+        expected_session_id=session_id,
+        generated=True,
+        expected_source=SOURCE_DESKTOP,
+        expected_project_id=PROJECT_ID,
+        is_desktop=True,
+        cli_version=PINNED_ANTIGRAVITY_DESKTOP_VERSION,
+    )
+    preview = next(
+        (
+            event.text
+            for event in parsed.events
+            if event.kind == EventKind.MESSAGE and event.role == Role.USER and event.text
+        ),
+        "Imported conversation",
+    )
+    summary = _summary_values(
+        session_id=session_id,
+        title=title or "Imported conversation",
+        preview=preview,
+        step_count=parsed.raw_record_count,
+        timestamp=summary_timestamp,
+        cwd=cwd,
+        last_user_input_index=_last_user_input_index(data),
+        status="CASCADE_RUN_STATUS_IDLE",
+        source="",
+        project_id=PROJECT_ID,
+        app_data_dir="antigravity",
+    )
+
+    if dry_run:
+        if os.path.lexists(conversation_path):
+            raise SessionMigrateError(
+                "Antigravity Desktop conversation ID already exists; refusing to overwrite it"
+            )
+        if os.path.lexists(summaries_path):
+            if stat.S_ISLNK(summaries_path.lstat().st_mode):
+                raise SessionMigrateError(
+                    "Antigravity Desktop summary database must not be a symlink"
+                )
+            try:
+                uri = f"file:{quote(str(summaries_path), safe='/')}?mode=ro"
+                with sqlite3.connect(uri, uri=True, timeout=5) as summaries:
+                    summaries.execute("PRAGMA trusted_schema=OFF")
+                    _validate_summary_schema(summaries)
+                    collision = summaries.execute(
+                        "SELECT 1 FROM conversation_summaries WHERE conversation_id=?",
+                        (session_id,),
+                    ).fetchone()
+            except sqlite3.Error as exc:
+                raise SessionMigrateError(
+                    "Antigravity Desktop summary database cannot be checked safely"
+                ) from exc
+            if collision:
+                raise SessionMigrateError(
+                    "Antigravity Desktop conversation ID already exists; refusing to overwrite it"
+                )
+        return InstalledAntigravitySession(conversation_path, summaries_path)
+
+    _ensure_private_directory(root)
+    _ensure_private_directory(conversation_path.parent)
+    _ensure_summary_database(summaries_path)
+    created_identity: tuple[int, int] | None = None
+    conversation_guard: int | None = None
+    summary_guard: int | None = None
+    try:
+        summary_guard = _open_identity_guard(summaries_path, writable=True)
+        with sqlite3.connect(summaries_path, timeout=15, isolation_level=None) as summaries:
+            summaries.execute("PRAGMA trusted_schema=OFF")
+            _validate_summary_schema(summaries)
+            summaries.execute("BEGIN IMMEDIATE")
+            collision = summaries.execute(
+                "SELECT 1 FROM conversation_summaries WHERE conversation_id=?", (session_id,)
+            ).fetchone()
+            if collision or os.path.lexists(conversation_path):
+                summaries.execute("ROLLBACK")
+                raise SessionMigrateError(
+                    "Antigravity Desktop conversation ID already exists; refusing to overwrite it"
+                )
+            created_identity = write_private_atomic(conversation_path, data)
+            conversation_guard = _open_identity_guard(
+                conversation_path, expected_identity=created_identity
+            )
+            summaries.execute(
+                f"INSERT INTO conversation_summaries({','.join(_SUMMARY_COLUMNS)}) "
+                f"VALUES({','.join('?' for _ in _SUMMARY_COLUMNS)})",
+                summary,
+            )
+            if not _guard_matches_path(conversation_guard, conversation_path) or not (
+                _guard_matches_path(summary_guard, summaries_path)
+            ):
+                summaries.execute("ROLLBACK")
+                raise SessionMigrateError(
+                    "Antigravity Desktop install paths changed during transaction"
+                )
+            summaries.execute("COMMIT")
+    except BaseException:
+        if conversation_guard is not None:
+            os.close(conversation_guard)
+            conversation_guard = None
+        if summary_guard is not None:
+            os.close(summary_guard)
+            summary_guard = None
+        if created_identity is not None:
+            _unlink_if_same_file(conversation_path, created_identity)
+        raise
+    finally:
+        if conversation_guard is not None:
+            os.close(conversation_guard)
+        if summary_guard is not None:
+            os.close(summary_guard)
+    return InstalledAntigravitySession(conversation_path, summaries_path)
diff --git a/src/session_migrate/formats/claude.py b/src/session_migrate/formats/claude.py
index 5a58e58..22e9d21 100644
--- a/src/session_migrate/formats/claude.py
+++ b/src/session_migrate/formats/claude.py
@@ -436,7 +436,23 @@ def _valid_preserved_compaction_back_edge(
     seen: set[str],
     by_uuid: dict[str, JsonlRecord],
 ) -> bool:
-    """Recognize Claude's metadata-declared preserved-segment loop."""
+    """Recognize Claude's metadata-declared preserved-segment loop.
+
+    The declaration is stable, the shape under it is not: the number of records
+    between the boundary and the compact summary varies with the attachment
+    records the CLI interleaves (an environment snapshot, a file read), so the
+    summary is sometimes the boundary's direct child and sometimes three or four
+    parent hops below it.  One 73 MB session with two compactions carried both
+    shapes.  ``preservedMessages`` likewise names ids from the summarized branch
+    that are no longer on the active path, next to the preserved ones.
+
+    Accept the edge when the declaration closes over the walked path: the tail
+    must lead up to the summary, the summary must lead up to the boundary, and
+    every hop must already be on the walked path.  Requiring the summary to be
+    the boundary's direct child, or every declared id to be on the path, refuses
+    readable transcripts — that session raised "ancestry cycle" for exactly this
+    reason.
+    """
 
     metadata = boundary.value.get("compactMetadata")
     if not isinstance(metadata, dict):
@@ -454,30 +470,39 @@ def _valid_preserved_compaction_back_edge(
     assert anchor is not None and head is not None and tail is not None
     assert boundary_uuid is not None
     anchor_record = by_uuid.get(anchor)
-    if (
-        anchor_record is None
-        or anchor_record.value.get("isCompactSummary") is not True
-        or string(anchor_record.value.get("parentUuid")) != boundary_uuid
-    ):
+    if anchor_record is None or anchor_record.value.get("isCompactSummary") is not True:
         return False
     declared = messages.get("allUuids", messages.get("uuids"))
     if not isinstance(declared, list) or not declared:
         return False
     declared_ids = {value for value in declared if isinstance(value, str)}
-    if not {head, tail}.issubset(declared_ids) or not declared_ids.issubset(seen):
+    if not {head, tail}.issubset(declared_ids):
         return False
 
-    cursor: str | None = tail
-    preserved_path: set[str] = set()
-    while cursor and cursor != anchor:
-        if cursor in preserved_path or cursor not in seen:
+    return _walks_up_within_seen(tail, anchor, seen, by_uuid) and _walks_up_within_seen(
+        anchor, boundary_uuid, seen, by_uuid
+    )
+
+
+def _walks_up_within_seen(
+    start: str,
+    target: str,
+    seen: set[str],
+    by_uuid: dict[str, JsonlRecord],
+) -> bool:
+    """Whether ``start`` reaches ``target`` through parents that are already walked."""
+
+    cursor: str | None = start
+    visited: set[str] = set()
+    while cursor and cursor != target:
+        if cursor in visited or cursor not in seen:
             return False
-        preserved_path.add(cursor)
+        visited.add(cursor)
         record = by_uuid.get(cursor)
         if record is None:
             return False
         cursor = string(record.value.get("parentUuid"))
-    return cursor == anchor and head in preserved_path
+    return cursor == target
 
 
 def _events_from_content(record: JsonlRecord, role: Role, content: Any) -> Iterable[Event]:
diff --git a/src/session_migrate/formats/cursor.py b/src/session_migrate/formats/cursor.py
index a18c555..ca98cf4 100644
--- a/src/session_migrate/formats/cursor.py
+++ b/src/session_migrate/formats/cursor.py
@@ -322,14 +322,26 @@ def snapshot_database_bytes(path: Path) -> bytes:
     with tempfile.TemporaryDirectory(prefix="session-migrate-cursor-snapshot-") as directory:
         target = Path(directory) / "snapshot.db"
         uri = f"file:{quote(str(source), safe='/')}?mode=ro"
+        origin = None
+        destination = None
         try:
-            with sqlite3.connect(uri, uri=True, timeout=5) as origin:
-                origin.execute("PRAGMA trusted_schema=OFF")
-                with sqlite3.connect(target) as destination:
-                    origin.backup(destination)
+            origin = sqlite3.connect(uri, uri=True, timeout=5)
+            origin.execute("PRAGMA trusted_schema=OFF")
+            destination = sqlite3.connect(target)
+            origin.backup(destination)
+            destination.commit()
+            origin.close()
+            origin = None
+            destination.close()
+            destination = None
             data = target.read_bytes()
         except (OSError, sqlite3.Error) as exc:
             raise SessionMigrateError("cannot make a consistent Cursor store snapshot") from exc
+        finally:
+            if origin is not None:
+                origin.close()
+            if destination is not None:
+                destination.close()
     if not data or len(data) > MAX_NATIVE_BYTES:
         raise SessionMigrateError("Cursor store snapshot violates the database size limit")
     return data
@@ -482,28 +494,35 @@ def install_database(
 def _build_database(metadata: Mapping[str, Any], blobs: Mapping[str, bytes]) -> bytes:
     with tempfile.TemporaryDirectory(prefix="session-migrate-cursor-build-") as directory:
         path = Path(directory) / "store.db"
+        db = None
         try:
-            with sqlite3.connect(path) as db:
-                db.execute("PRAGMA journal_mode=DELETE")
-                db.execute("PRAGMA synchronous=FULL")
-                db.execute("PRAGMA user_version=1")
-                db.executescript(
-                    """
-                    CREATE TABLE blobs (id TEXT PRIMARY KEY, data BLOB);
-                    CREATE TABLE meta (key TEXT PRIMARY KEY, value TEXT);
-                    """
-                )
-                db.executemany(
-                    "INSERT INTO blobs(id,data) VALUES(?,?)",
-                    sorted((blob_id, value) for blob_id, value in blobs.items()),
-                )
-                metadata_bytes = json.dumps(
-                    dict(metadata), ensure_ascii=False, separators=(",", ":"), allow_nan=False
-                ).encode()
-                db.execute("INSERT INTO meta(key,value) VALUES('0',?)", (metadata_bytes.hex(),))
+            db = sqlite3.connect(path)
+            db.execute("PRAGMA journal_mode=DELETE")
+            db.execute("PRAGMA synchronous=FULL")
+            db.execute("PRAGMA user_version=1")
+            db.executescript(
+                """
+                CREATE TABLE blobs (id TEXT PRIMARY KEY, data BLOB);
+                CREATE TABLE meta (key TEXT PRIMARY KEY, value TEXT);
+                """
+            )
+            db.executemany(
+                "INSERT INTO blobs(id,data) VALUES(?,?)",
+                sorted((blob_id, value) for blob_id, value in blobs.items()),
+            )
+            metadata_bytes = json.dumps(
+                dict(metadata), ensure_ascii=False, separators=(",", ":"), allow_nan=False
+            ).encode()
+            db.execute("INSERT INTO meta(key,value) VALUES('0',?)", (metadata_bytes.hex(),))
+            db.commit()
+            db.close()
+            db = None
             data = path.read_bytes()
         except (OSError, sqlite3.Error, TypeError, ValueError) as exc:
             raise SessionMigrateError("cannot build Cursor store database") from exc
+        finally:
+            if db is not None:
+                db.close()
     if not data or len(data) > MAX_NATIVE_BYTES:
         raise SessionMigrateError("generated Cursor store violates the database size limit")
     return data
diff --git a/src/session_migrate/formats/devin.py b/src/session_migrate/formats/devin.py
index f53865e..e476a8d 100644
--- a/src/session_migrate/formats/devin.py
+++ b/src/session_migrate/formats/devin.py
@@ -1475,6 +1475,8 @@ def _check_safe_existing_prefix(path: Path) -> None:
 
 
 def _fsync_directory(path: Path) -> None:
+    if os.name == "nt":
+        return
     descriptor = os.open(path, os.O_RDONLY | getattr(os, "O_DIRECTORY", 0))
     try:
         os.fsync(descriptor)
diff --git a/src/session_migrate/formats/hermes.py b/src/session_migrate/formats/hermes.py
index e94990f..f4838f7 100644
--- a/src/session_migrate/formats/hermes.py
+++ b/src/session_migrate/formats/hermes.py
@@ -1,11 +1,12 @@
-"""Hermes Agent 0.20.6 SQLite session adapter.
+"""Hermes Agent 0.22.2 SQLite session adapter.
 
 Hermes keeps every CLI conversation in ``$HERMES_HOME/state.db`` (normally
-``~/.hermes/state.db``).  A single database contains many sessions, so source
-selection is always the pair ``(state.db, native session id)``.  Target bytes
-use Hermes's own exported-session shape inside a small versioned envelope;
-installation delegates the final transaction to the pinned Hermes
-``SessionDB.import_sessions`` implementation.
+``~/.hermes``; on Windows ``%LOCALAPPDATA%\\hermes``).  A single database
+contains many sessions, so source selection is always the pair ``(state.db,
+native session id)``.  Target bytes use Hermes's own exported-session shape
+inside a small versioned envelope; installation delegates the final
+transaction to the pinned Hermes ``SessionDB.import_sessions`` implementation,
+which is still the native portability boundary in 0.22.2.
 """
 
 from __future__ import annotations
@@ -19,9 +20,10 @@
 import sqlite3
 import stat
 import subprocess
+import sys
 import tempfile
 from collections import Counter
-from collections.abc import Iterator, Mapping
+from collections.abc import Iterator, Mapping, Sequence
 from contextlib import contextmanager
 from dataclasses import dataclass
 from datetime import UTC, datetime
@@ -34,10 +36,18 @@
 from session_migrate.jsonl import DEFAULT_MAX_RECORDS, DEFAULT_MAX_TOTAL_BYTES
 from session_migrate.model import AgentFormat, Event, EventKind, Provenance, Role, Session
 
-PINNED_HERMES_VERSION = "0.20.6"
-PINNED_HERMES_RELEASE_TAG = "v2026.8.27"
-PINNED_HERMES_SOURCE_COMMIT = "5fc308a70719a83cccdbba4c0e39c23f5a8239d5"
-PINNED_HERMES_SCHEMA_VERSION = 26
+PINNED_HERMES_VERSION = "0.22.2"
+PINNED_HERMES_RELEASE_TAG = "v2026.9.24"
+PINNED_HERMES_SOURCE_COMMIT = "d923a5eb487a17c0a68801bba9ef0f56c81040a8"
+PINNED_HERMES_SCHEMA_VERSION = 31
+# ``SessionDB`` caps one session at 5 MiB on import while Hermes' own web import
+# accepts 25 MiB (``hermes_cli/web_routers/sessions.py``).  A portable session
+# carrying a pasted screenshot (inline base64 image) trips the lower bound: the
+# bundle is valid and the store accepts stores of that size everywhere else, so
+# the installer raises the per-session budget to what the bundle needs — never
+# past the vendor's own ceiling — and reports it as a manifest warning.
+PINNED_HERMES_IMPORT_SESSION_BYTES = 5 * 1024 * 1024
+PINNED_HERMES_IMPORT_CEILING_BYTES = 25 * 1024 * 1024
 HERMES_BUNDLE_SCHEMA = "session-migrate.hermes.v1"
 HERMES_STATE_FILENAME = "state.db"
 MAX_DATABASE_BYTES = 512 * 1024 * 1024
@@ -48,6 +58,10 @@
 MAX_JSON_NODES = 1_000_000
 
 _NATIVE_ID = re.compile(r"(?P<date>\d{8})_(?P<time>\d{6})_(?P<suffix>[0-9a-f]{6,8})\Z")
+# 0.22.2 prints build provenance after the release ("· stable · local <sha>"), so the
+# version line is matched on its pinned prefix and every suffix is tolerated.
+_VERSION_LINE = re.compile(r"^Hermes Agent v(?P<version>[^\s(]+) \((?P<release>[^)]+)\)")
+_INSTALL_DIRECTORY_LINE = "install directory"
 _REQUIRED_SESSION_COLUMNS = frozenset(
     {
         "id",
@@ -186,6 +200,7 @@ class ParsedHermesBundle:
     started_at: str
     model: str | None
     messages: tuple[dict[str, Any], ...]
+    session: Mapping[str, Any]
 
 
 @dataclass(frozen=True, slots=True)
@@ -228,20 +243,49 @@ def native_session_id(portable_id: str, timestamp: str) -> str:
     return normalized_session_id(moment.strftime("%Y%m%d_%H%M%S_") + suffix[:6])
 
 
-def hermes_home(home: Path | None = None, *, environ: Mapping[str, str] | None = None) -> Path:
-    """Resolve Hermes's native home without creating it."""
+def hermes_home(
+    home: Path | None = None,
+    *,
+    environ: Mapping[str, str] | None = None,
+    platform: str | None = None,
+) -> Path:
+    """Resolve Hermes's native home without creating it.
+
+    Mirrors the CLI's own platform default: ``%LOCALAPPDATA%\\hermes`` on
+    Windows (``~/AppData/Local/hermes`` when that variable is unset) and
+    ``~/.hermes`` elsewhere.  ``HERMES_HOME`` wins when it is set.  Resolving a
+    bare ``~/.hermes`` on Windows named a directory the CLI never writes to, so
+    an install landed outside the real store unless the caller exported
+    ``HERMES_HOME`` by hand.
+    """
 
     values = os.environ if environ is None else environ
-    configured = values.get("HERMES_HOME", "").strip()
-    return Path(configured).expanduser() if configured else (home or Path.home()) / ".hermes"
+    configured = str(values.get("HERMES_HOME", "")).strip()
+    if configured:
+        return Path(configured).expanduser()
+    user_home = home or Path.home()
+    if (sys.platform if platform is None else platform) == "win32":
+        local_app_data = str(values.get("LOCALAPPDATA", "")).strip()
+        base = (
+            Path(local_app_data).expanduser() if local_app_data else user_home / "AppData" / "Local"
+        )
+        return base / "hermes"
+    return user_home / ".hermes"
 
 
 def state_database_path(
-    root: Path | None = None, *, environ: Mapping[str, str] | None = None
+    root: Path | None = None,
+    *,
+    environ: Mapping[str, str] | None = None,
+    platform: str | None = None,
 ) -> Path:
     """Resolve ``state.db`` from an explicit Hermes root or the native default."""
 
-    selected = Path(root).expanduser() if root is not None else hermes_home(environ=environ)
+    selected = (
+        Path(root).expanduser()
+        if root is not None
+        else hermes_home(environ=environ, platform=platform)
+    )
     return selected / HERMES_STATE_FILENAME
 
 
@@ -531,6 +575,7 @@ def validate_native_bytes(data: bytes, session_id: str) -> ParsedHermesBundle:
         started_at=_timestamp(started_epoch),
         model=model,
         messages=tuple(dict(message) for message in messages),
+        session=value["session"],
     )
 
 
@@ -559,14 +604,26 @@ def database_snapshot(path: Path) -> HermesDatabaseSnapshot:
     with tempfile.TemporaryDirectory(prefix="session-migrate-hermes-snapshot-") as directory:
         target = Path(directory) / HERMES_STATE_FILENAME
         uri = f"file:{quote(str(source), safe='/')}?mode=ro"
+        origin = None
+        destination = None
         try:
-            with sqlite3.connect(uri, uri=True, timeout=5) as origin:
-                origin.execute("PRAGMA trusted_schema=OFF")
-                with sqlite3.connect(target) as destination:
-                    origin.backup(destination)
+            origin = sqlite3.connect(uri, uri=True, timeout=5)
+            origin.execute("PRAGMA trusted_schema=OFF")
+            destination = sqlite3.connect(target)
+            origin.backup(destination)
+            destination.commit()
+            origin.close()
+            origin = None
+            destination.close()
+            destination = None
             data = target.read_bytes()
         except (OSError, sqlite3.Error) as exc:
             raise JsonlError("cannot make a consistent Hermes database snapshot") from exc
+        finally:
+            if origin is not None:
+                origin.close()
+            if destination is not None:
+                destination.close()
     if not data or len(data) > MAX_DATABASE_BYTES:
         raise JsonlError("Hermes database snapshot violates the input size limit")
     return HermesDatabaseSnapshot(
@@ -673,40 +730,88 @@ def parse_session(path: Path, session_id: str | None = None) -> Session:
 parse = parse_session
 
 
-def verify_pinned_cli(
-    executable: Path | None = None, *, environ: Mapping[str, str] | None = None
-) -> Path:
-    values = dict(os.environ if environ is None else environ)
-    candidate = str(executable) if executable else shutil.which("hermes", path=values.get("PATH"))
-    if not candidate:
-        raise SessionMigrateError("Hermes executable 'hermes' was not found")
-    path = Path(candidate).expanduser().resolve()
-    try:
-        info = path.stat()
-    except OSError as exc:
-        raise SessionMigrateError("cannot inspect the Hermes executable") from exc
-    if not stat.S_ISREG(info.st_mode):
-        raise SessionMigrateError("Hermes executable is not a regular file")
+def _cli_report(path: Path, values: Mapping[str, str], *arguments: str) -> str:
+    """Run the pinned launcher and return its stdout, refusing a failed invocation."""
+
     safe_env = _subprocess_environment(values, None)
     try:
         completed = subprocess.run(
-            [str(path), "--version"],
+            [str(path), *arguments],
             env=safe_env,
             stdin=subprocess.DEVNULL,
             capture_output=True,
             timeout=30,
             check=False,
             text=True,
+            encoding="utf-8",
+            errors="replace",
         )
     except (OSError, subprocess.SubprocessError) as exc:
         raise SessionMigrateError("cannot query the Hermes version") from exc
-    first = completed.stdout.splitlines()[0].strip() if completed.stdout.splitlines() else ""
+    if completed.returncode != 0:
+        raise SessionMigrateError("cannot query the Hermes version")
+    return completed.stdout
+
+
+def _verify_cli(
+    executable: Path | None = None, *, environ: Mapping[str, str] | None = None
+) -> tuple[Path, str]:
+    """Resolve the Hermes launcher, prove it is the pinned build, return its report.
+
+    The full ``--version`` report is kept because 0.22.2 publishes the install
+    directory there, which is what locates the Python runtime behind a Windows
+    launcher shim (see :func:`_python_invocation`).
+    """
+
+    values = dict(os.environ if environ is None else environ)
+    candidate = str(executable) if executable else shutil.which("hermes", path=values.get("PATH"))
+    if not candidate:
+        raise SessionMigrateError("Hermes executable 'hermes' was not found")
+    path = Path(candidate).expanduser().resolve()
+    try:
+        info = path.stat()
+    except OSError as exc:
+        raise SessionMigrateError("cannot inspect the Hermes executable") from exc
+    if not stat.S_ISREG(info.st_mode):
+        raise SessionMigrateError("Hermes executable is not a regular file")
+    report = _cli_report(path, values, "--version")
+    first = report.splitlines()[0].strip() if report.splitlines() else ""
+    observed = _VERSION_LINE.match(first)
     expected = f"Hermes Agent v{PINNED_HERMES_VERSION} ({PINNED_HERMES_RELEASE_TAG[1:]})"
-    if completed.returncode != 0 or first != expected:
+    if (
+        observed is None
+        or observed.group("version") != PINNED_HERMES_VERSION
+        or observed.group("release") != PINNED_HERMES_RELEASE_TAG[1:]
+    ):
         raise SessionMigrateError(
             f"Hermes version mismatch: expected {expected}, observed {first or '<unavailable>'}"
         )
-    return path
+    return path, report
+
+
+def verify_pinned_cli(
+    executable: Path | None = None, *, environ: Mapping[str, str] | None = None
+) -> Path:
+    return _verify_cli(executable, environ=environ)[0]
+
+
+def measured_session_bytes(session: Mapping[str, Any]) -> int:
+    """Size one bundle session exactly the way the store sizes it.
+
+    ``timings`` is derived from the messages and rebuilt on export, so it does
+    not eat into the budget of the content it describes.
+    """
+
+    measured = {key: value for key, value in session.items() if key != "timings"}
+    return len(json.dumps(measured, ensure_ascii=False, separators=(",", ":")).encode("utf-8"))
+
+
+def import_budget_bytes(measured: int) -> int:
+    """Per-session import budget to request for a bundle of ``measured`` bytes."""
+
+    return max(
+        PINNED_HERMES_IMPORT_SESSION_BYTES, min(measured, PINNED_HERMES_IMPORT_CEILING_BYTES)
+    )
 
 
 def install_bundle(
@@ -722,7 +827,8 @@ def install_bundle(
 
     parsed = validate_native_bytes(data, session_id)
     root = _absolute_no_follow(target_home)
-    executable = verify_pinned_cli(target_cli, environ=environ)
+    executable, report = _verify_cli(target_cli, environ=environ)
+    install_directory = _install_directory(report)
     database = root / HERMES_STATE_FILENAME
     if os.path.lexists(database):
         _assert_no_collision(database, parsed.session_id)
@@ -730,53 +836,44 @@ def install_bundle(
         return InstalledHermesSession(database, parsed.session_id)
 
     _ensure_private_directory(root)
+    prefix, prelude = _python_invocation(
+        executable, environ=environ, install_directory=install_directory
+    )
+    environment = _subprocess_environment(environ, root)
     if not database.exists():
-        environment = _subprocess_environment(environ, root)
-        try:
-            initialized = subprocess.run(
-                [str(executable), "sessions", "list", "--limit", "1"],
-                env=environment,
-                stdin=subprocess.DEVNULL,
-                capture_output=True,
-                timeout=60,
-                check=False,
-                text=True,
-            )
-        except (OSError, subprocess.SubprocessError) as exc:
-            raise SessionMigrateError("cannot initialize the Hermes state database") from exc
-        if initialized.returncode != 0 or not database.is_file():
-            raise SessionMigrateError("Hermes failed to initialize its state database")
+        _initialize_state_database(prefix, prelude, database, environment)
 
-    interpreter = _script_interpreter(executable)
     helper = (
         "import json,sys; from pathlib import Path; from hermes_state import SessionDB; "
-        "value=json.load(sys.stdin); db=SessionDB(db_path=Path(sys.argv[1])); "
+        "value=json.loads(sys.stdin.buffer.read()); "
+        "SessionDB._IMPORT_MAX_SESSION_BYTES=max("
+        "SessionDB._IMPORT_MAX_SESSION_BYTES,int(sys.argv[2])); "
+        "db=SessionDB(db_path=Path(sys.argv[1])); "
         "result=db.import_sessions([value['session']]); db.close(); "
         "print(json.dumps(result,separators=(',',':')))"
     )
-    environment = _subprocess_environment(environ, root)
     try:
-        imported = subprocess.run(
-            [str(interpreter), "-c", helper, str(database)],
-            env=environment,
-            input=data.decode(),
-            capture_output=True,
-            timeout=120,
-            check=False,
-            text=True,
+        code, stdout, stderr = _run_helper(
+            prefix,
+            prelude,
+            helper,
+            database=database,
+            payload=data,
+            environment=environment,
+            extra_arguments=[str(import_budget_bytes(measured_session_bytes(parsed.session)))],
         )
     except (OSError, subprocess.SubprocessError) as exc:
         raise SessionMigrateError("Hermes session import failed") from exc
-    result = _last_json_object(imported.stdout)
+    result = _last_json_object(stdout)
     if (
-        imported.returncode != 0
+        code != 0
         or result.get("ok") is not True
         or result.get("imported_ids") != [parsed.session_id]
         or result.get("skipped") != 0
     ):
         detail = result.get("errors")
-        if not detail and imported.stderr:
-            detail = imported.stderr.splitlines()[-1][:500]
+        if not detail and stderr:
+            detail = stderr.splitlines()[-1][:500]
         suffix = f": {detail}" if detail else ""
         raise SessionMigrateError(f"Hermes refused the imported session bundle{suffix}")
     loaded = parse_session(database, parsed.session_id)
@@ -785,6 +882,72 @@ def install_bundle(
     return InstalledHermesSession(database, parsed.session_id)
 
 
+def _initialize_state_database(
+    prefix: list[str], prelude: str, database: Path, environment: Mapping[str, str]
+) -> None:
+    """Create a missing store through Hermes's own schema initializer.
+
+    ``hermes sessions list`` no longer creates ``state.db`` on 0.22.2 — a read of
+    an absent store is simply empty — so the store is opened through the native
+    ``SessionDB`` constructor instead, which creates and migrates the file.
+    """
+
+    helper = (
+        "import sys; from pathlib import Path; from hermes_state import SessionDB; "
+        "db=SessionDB(db_path=Path(sys.argv[1])); db.close()"
+    )
+    try:
+        code, _, stderr = _run_helper(
+            prefix, prelude, helper, database=database, payload=None, environment=environment
+        )
+    except (OSError, subprocess.SubprocessError) as exc:
+        raise SessionMigrateError("cannot initialize the Hermes state database") from exc
+    if code != 0 or not database.is_file():
+        detail = stderr.splitlines()[-1][:500] if stderr else ""
+        suffix = f": {detail}" if detail else ""
+        raise SessionMigrateError(f"Hermes failed to initialize its state database{suffix}")
+
+
+def _run_helper(
+    prefix: list[str],
+    prelude: str,
+    source: str,
+    *,
+    database: Path,
+    payload: bytes | None,
+    environment: Mapping[str, str],
+    extra_arguments: Sequence[str] = (),
+) -> tuple[int, str, str]:
+    """Run one helper inside the Hermes runtime, moving any payload as bytes.
+
+    The bundle crosses the process boundary as UTF-8 bytes and the helper reads
+    ``sys.stdin.buffer``.  Passing it as text instead encodes it with the
+    *caller's* locale codec while the store's interpreter always decodes UTF-8,
+    so a Windows console whose code page is not UTF-8 replaced every non-ASCII
+    character with U+FFFD inside the target store.  Both directions are decoded
+    explicitly here for the same reason.
+    """
+
+    arguments: dict[str, Any] = {}
+    if payload is None:
+        arguments["stdin"] = subprocess.DEVNULL
+    else:
+        arguments["input"] = payload
+    completed = subprocess.run(
+        [*prefix, prelude + source, str(database), *extra_arguments],
+        env=dict(environment),
+        capture_output=True,
+        timeout=120,
+        check=False,
+        **arguments,
+    )
+    return (
+        completed.returncode,
+        completed.stdout.decode("utf-8", "replace"),
+        completed.stderr.decode("utf-8", "replace"),
+    )
+
+
 def _message_events(row: sqlite3.Row, index: int) -> list[Event]:
     provenance = Provenance(index, "hermes.message", source_id=str(row["id"]))
     timestamp = _timestamp_or_none(row["timestamp"])
@@ -1168,6 +1331,72 @@ def _assert_no_collision(database: Path, session_id: str) -> None:
             raise SessionMigrateError("Hermes session ID already exists; refusing to overwrite it")
 
 
+def title_taken(database: Path, title: str | None) -> bool:
+    """Report whether *title* is already held by a session in this store.
+
+    Hermes keeps ``idx_sessions_title_unique`` (a partial unique index over
+    non-null titles), so a second session cannot reuse one.  The title is
+    cosmetic — Hermes's own importer discards it on conflict — so a caller can
+    install without it rather than lose the whole migration.
+
+    The lookup is advisory: the import transaction still enforces the real
+    constraint.  A missing, unreadable, or concurrently written store reports
+    ``False`` and leaves the decision to that transaction.
+    """
+
+    if not title:
+        return False
+    if not os.path.lexists(database):
+        return False
+    uri = f"file:{quote(str(database), safe='/')}?mode=ro"
+    connection = None
+    try:
+        connection = sqlite3.connect(uri, uri=True, timeout=5)
+        connection.execute("PRAGMA trusted_schema=OFF")
+        row = connection.execute("SELECT 1 FROM sessions WHERE title = ?", (title,)).fetchone()
+    except (OSError, sqlite3.Error):
+        return False
+    finally:
+        if connection is not None:
+            connection.close()
+    return row is not None
+
+
+def without_title(data: bytes) -> bytes:
+    """Return Hermes bundle bytes whose session carries no title.
+
+    Only the title changes: every other field of the validated envelope is
+    re-emitted byte-identically in meaning, and the result is re-validated by
+    the installer before it is used.
+    """
+
+    value = _bundle_object(data)
+    value["session"]["title"] = None
+    return json.dumps(value, separators=(",", ":"), sort_keys=True, ensure_ascii=False).encode()
+
+
+def bundle_title(data: bytes) -> str | None:
+    """Title carried by a Hermes bundle, when it has one."""
+
+    return _safe_text(_bundle_object(data)["session"].get("title"), "Hermes title")
+
+
+def _bundle_object(data: bytes) -> dict[str, Any]:
+    """Strictly parse a bundle envelope without re-running full validation."""
+
+    try:
+        value = json.loads(
+            data,
+            object_pairs_hook=_unique_object,
+            parse_constant=_reject_json_constant,
+        )
+    except (UnicodeDecodeError, json.JSONDecodeError, RecursionError, ValueError) as exc:
+        raise SessionMigrateError("generated Hermes bundle is not valid strict UTF-8 JSON") from exc
+    if not isinstance(value, dict) or not isinstance(value.get("session"), dict):
+        raise SessionMigrateError("generated Hermes bundle has no session to adjust")
+    return value
+
+
 def _script_interpreter(executable: Path) -> Path:
     try:
         with executable.open("rb") as stream:
@@ -1195,6 +1424,115 @@ def _script_interpreter(executable: Path) -> Path:
     return interpreter
 
 
+def _install_directory(report: str) -> Path | None:
+    """Read the ``Install directory:`` line from a ``hermes --version`` report.
+
+    Absent on builds that do not print it; the caller then falls back to the
+    launcher-derived interpreter.
+    """
+
+    for line in report.splitlines():
+        label, separator, value = line.partition(":")
+        if separator and label.strip().lower() == _INSTALL_DIRECTORY_LINE and value.strip():
+            return Path(value.strip())
+    return None
+
+
+def _runtime_command(executable: Path, values: Mapping[str, str]) -> list[str] | None:
+    """Ask the launcher for the exact command that runs Hermes in this install.
+
+    ``hermes --print-runtime-command`` prints a JSON argv whose first element is
+    the interpreter.  It is the only portable way to reach the runtime behind a
+    compiled Windows launcher, whose file head is not a shebang.  Older builds
+    do not implement the flag, so a failure returns ``None`` instead of raising.
+    """
+
+    safe_env = _subprocess_environment(values, None)
+    try:
+        completed = subprocess.run(
+            [str(executable), "--print-runtime-command"],
+            env=safe_env,
+            stdin=subprocess.DEVNULL,
+            capture_output=True,
+            timeout=30,
+            check=False,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if completed.returncode != 0:
+        return None
+    for line in reversed(completed.stdout.splitlines()):
+        try:
+            value = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(value, list) and value and all(isinstance(item, str) for item in value):
+            return value
+    return None
+
+
+def _bootstrap_root(runtime: list[str]) -> Path | None:
+    """Recover the install root from the launcher's own bootstrap source.
+
+    Used when ``hermes --version`` does not publish an install directory: the
+    runtime command the launcher prints inserts its root into ``sys.path``, so
+    the helper can reuse the very same path the CLI itself imports from.
+    """
+
+    pattern = re.compile(r"sys\.path\.insert\(\s*0\s*,\s*['\"](?P<root>[^'\"]+)['\"]\s*\)")
+    for argument in runtime:
+        match = pattern.search(argument)
+        if match:
+            return Path(match.group("root").replace("\\\\", "\\"))
+    return None
+
+
+def _python_invocation(
+    executable: Path, *, environ: Mapping[str, str] | None, install_directory: Path | None
+) -> tuple[list[str], str]:
+    """Build the argv prefix and prelude that run a helper inside pinned Hermes.
+
+    The command is completed by ``[*prefix, prelude + source, *arguments]``.  The
+    prelude reproduces what the published launcher does for itself before the
+    entry point runs: it clears ``PYTHONHOME``/``PYTHONPATH``/``VIRTUAL_ENV``,
+    puts the install root on ``sys.path`` and then imports ``hermes_bootstrap``,
+    which selects and activates the store's dependency generation.  Store Python
+    alone has no third-party packages, so skipping the bootstrap import makes
+    ``hermes_state`` — and everything it imports — unresolvable.
+
+    ``hermes --print-runtime-command`` is the documented machine boundary for
+    consumers holding the launcher, and it is the only source on a Windows
+    install, whose launcher is a compiled zipapp rather than a ``#!`` script.
+    Builds predating the flag fall back to the launcher's own shebang.
+    """
+
+    values = dict(os.environ if environ is None else environ)
+    runtime = _runtime_command(executable, values)
+    if runtime is not None:
+        interpreter = Path(runtime[0]).expanduser()
+        try:
+            info = interpreter.stat()
+        except OSError as exc:
+            raise SessionMigrateError("Hermes Python interpreter is unavailable") from exc
+        if not stat.S_ISREG(info.st_mode):
+            raise SessionMigrateError("Hermes Python interpreter is not a regular file")
+        root = install_directory or _bootstrap_root(runtime)
+        prelude = [
+            "import os,sys",
+            "os.environ.pop('PYTHONHOME',None)",
+            "os.environ.pop('PYTHONPATH',None)",
+            "os.environ.pop('VIRTUAL_ENV',None)",
+        ]
+        if root is not None:
+            prelude.append(f"sys.path.insert(0,{str(root)!r})")
+        prelude.append("import hermes_bootstrap")
+        return [str(interpreter), "-I", "-X", "utf8", "-c"], "; ".join(prelude) + "; "
+    return [str(_script_interpreter(executable)), "-X", "utf8", "-c"], ""
+
+
 def _subprocess_environment(
     environ: Mapping[str, str] | None, target_home: Path | None
 ) -> dict[str, str]:
@@ -1202,12 +1540,44 @@ def _subprocess_environment(
     result = {
         key: value
         for key, value in values.items()
-        if key in {"HOME", "PATH", "LANG", "LC_ALL", "LC_CTYPE", "TMPDIR", "TERM"}
+        if key
+        in {
+            "HOME",
+            "PATH",
+            "LANG",
+            "LC_ALL",
+            "LC_CTYPE",
+            "TMPDIR",
+            "TERM",
+            # Windows: the CLI resolves its own home through USERPROFILE (or
+            # HOMEDRIVE/HOMEPATH) and refuses to start without it, and a child
+            # process inherits its loader/search paths from SYSTEMROOT,
+            # PATHEXT and COMSPEC.  Dropping them fails the launcher before
+            # ``--version`` can print anything.
+            "USERPROFILE",
+            "HOMEDRIVE",
+            "HOMEPATH",
+            "APPDATA",
+            "LOCALAPPDATA",
+            "PROGRAMDATA",
+            "SYSTEMROOT",
+            "SYSTEMDRIVE",
+            "WINDIR",
+            "PATHEXT",
+            "COMSPEC",
+            "TEMP",
+            "TMP",
+            "NUMBER_OF_PROCESSORS",
+        }
     }
     result.setdefault("LC_ALL", "C")
     result.setdefault("TERM", "dumb")
     result["NO_COLOR"] = "1"
     result["HERMES_NO_UPDATE_CHECK"] = "1"
+    # A caller that redirects the home through HOME (the pinned native tests)
+    # must reach the same home on Windows, where Path.home() reads USERPROFILE.
+    if result.get("HOME") and not result.get("USERPROFILE"):
+        result["USERPROFILE"] = result["HOME"]
     if target_home is not None:
         result["HERMES_HOME"] = str(target_home)
     return result
diff --git a/src/session_migrate/formats/kilo.py b/src/session_migrate/formats/kilo.py
index e567d43..f611931 100644
--- a/src/session_migrate/formats/kilo.py
+++ b/src/session_migrate/formats/kilo.py
@@ -11,6 +11,7 @@
 from dataclasses import replace
 from pathlib import Path
 
+from session_migrate.errors import SessionMigrateError
 from session_migrate.formats import opencode
 from session_migrate.jsonl import file_sha256
 from session_migrate.model import AgentFormat, Session
@@ -48,12 +49,19 @@ def serialize(
         agent=agent,
         timestamp=timestamp,
         title=title,
+        legacy_schema=True,
     )
 
 
 def parse(path: Path) -> opencode.ParsedOpenCodeSession:
     """Parse a bundle produced by ``kilo export``."""
 
+    try:
+        value = opencode._decode_import_bundle(path.read_bytes())
+    except OSError as exc:
+        raise SessionMigrateError("cannot read Kilo import bundle") from exc
+    if opencode.opencode_v2.is_bundle(value):
+        raise SessionMigrateError("Kilo 7.5.0 requires the legacy nested import/export schema")
     return opencode.parse_import(path)
 
 
@@ -74,6 +82,8 @@ def parse_session(path: Path) -> Session:
 def validate_native_bytes(data: bytes, session_id: str) -> None:
     """Validate Kilo's supported import document without invoking the CLI."""
 
+    if opencode.opencode_v2.is_bundle(opencode._decode_import_bundle(data)):
+        raise SessionMigrateError("Kilo 7.5.0 requires the legacy nested import/export schema")
     opencode.validate_native_bytes(data, session_id)
 
 
diff --git a/src/session_migrate/formats/opencode.py b/src/session_migrate/formats/opencode.py
index ea51086..6514410 100644
--- a/src/session_migrate/formats/opencode.py
+++ b/src/session_migrate/formats/opencode.py
@@ -1,4 +1,4 @@
-"""OpenCode 1.17.20 import/export bundle adapter.
+"""OpenCode 1.17.20 and 2.0 public import/export adapters.
 
 The writer emits the public JSON shape consumed by ``opencode import``.  It
 never writes OpenCode's SQLite database directly.
@@ -18,6 +18,7 @@
 from typing import Any
 
 from session_migrate.errors import SessionMigrateError
+from session_migrate.formats import opencode_v2
 from session_migrate.formats.common import portable_data_image, string, valid_rfc3339
 from session_migrate.jsonl import file_sha256
 from session_migrate.model import AgentFormat, Event, EventKind, Provenance, Role, Session
@@ -49,6 +50,14 @@ class ParsedOpenCodeSession:
     losses: tuple[tuple[str, int], ...] = ()
 
 
+def is_v2(value: str | None) -> bool:
+    return value is not None and opencode_v2.version(value) is not None
+
+
+def supported_version(value: str | None) -> bool:
+    return value == PINNED_OPENCODE_VERSION or is_v2(value)
+
+
 def session_id_from_uuid(value: str) -> str:
     """Create a valid OpenCode session ID from a UUID string."""
 
@@ -71,6 +80,7 @@ def serialize(
     timestamp: str | None = None,
     title: str | None = None,
     slug: str | None = None,
+    legacy_schema: bool = False,
 ) -> tuple[bytes, dict[str, int]]:
     """Serialize portable events as an official OpenCode import bundle."""
 
@@ -87,6 +97,8 @@ def serialize(
     seen_tool_call_ids: set[str] = set()
     seen_tool_result_ids: set[str] = set()
     tool_parts: dict[str, deque[dict[str, Any]]] = defaultdict(deque)
+    v2_tool_content: dict[str, list[dict[str, Any]]] = {}
+    native_v2_target = not legacy_schema and bool(opencode_v2.version(cli_version))
     portable_boundary = 0
 
     pending_role: Role | None = None
@@ -326,13 +338,20 @@ def queue_part(event: Event, role: Role, part: dict[str, Any]) -> None:
                     str(part["_migration_timestamp"]),
                 )
             result_timestamp = _event_timestamp(event, fallback_timestamp, dropped)
-            result_text, attachments = _tool_result(
+            result_text, attachments, ordered_content = _tool_result(
                 event,
                 session_id,
                 part,
                 dropped,
                 attachment_id=lambda timestamp=result_timestamp: new_part_id(timestamp),
             )
+            if native_v2_target:
+                v2_tool_content[part["id"]] = ordered_content
+            elif ordered_content != [
+                *([{"type": "text", "text": result_text}] if result_text else []),
+                *({"type": "file", "uri": p["url"], "mime": p["mime"]} for p in attachments),
+            ]:
+                dropped["tool_result:content_block_order"] += 1
             start_timestamp = str(part.pop("_migration_timestamp", result_timestamp))
             if int(part.pop("_migration_boundary", portable_boundary)) < portable_boundary:
                 dropped["tool_result:native_order_associated"] += 1
@@ -417,6 +436,8 @@ def queue_part(event: Event, role: Role, part: dict[str, Any]) -> None:
         },
         "messages": messages,
     }
+    if native_v2_target:
+        export_data = opencode_v2.from_legacy(export_data, dropped, tool_content=v2_tool_content)
     data = (json.dumps(export_data, ensure_ascii=False, indent=2) + "\n").encode()
     return data, dict(sorted(dropped.items()))
 
@@ -437,7 +458,10 @@ def parse_import(path: Path) -> ParsedOpenCodeSession:
     except OSError as exc:
         raise SessionMigrateError("cannot read OpenCode import bundle") from exc
     value = _decode_import_bundle(data)
+    native_v2 = value if opencode_v2.is_bundle(value) else None
     _validate_import_bundle(value)
+    if native_v2 is not None:
+        value = opencode_v2.to_legacy(native_v2)
     info = value["info"]
     session_id = string(info.get("id"))
     cwd = string(info.get("directory"))
@@ -470,6 +494,17 @@ def parse_import(path: Path) -> ParsedOpenCodeSession:
                 )
             )
 
+    if native_v2 is not None:
+        events.extend(opencode_v2.loss_events(native_v2))
+
+    # Native states come only from the validated v2 input, never a legacy carrier.
+    native_tool_states: dict[tuple[str, str], deque[dict[str, Any]]] = defaultdict(deque)
+    if native_v2 is not None:
+        for message in native_v2["messages"]:
+            for content in message.get("content", []) if message["type"] == "assistant" else []:
+                if content["type"] == "tool":
+                    native_tool_states[(message["id"], content["id"])].append(content["state"])
+
     compaction_parents: dict[str, dict[str, Any]] = {}
     summary_parents: set[str] = set()
     for message in messages:
@@ -489,6 +524,7 @@ def parse_import(path: Path) -> ParsedOpenCodeSession:
 
     for message_index, message in enumerate(messages):
         message_info = message["info"]
+        message_id = message_info["id"]
         parts = message.get("parts")
         assert isinstance(parts, list)
         role_name = string(message_info.get("role"))
@@ -638,7 +674,15 @@ def parse_import(path: Path) -> ParsedOpenCodeSession:
                         )
                     )
             elif part_type == "tool" and role_name == "assistant":
-                events.extend(_tool_part_events(part, timestamp, provenance))
+                states = native_tool_states[(message_id, part["callID"])]
+                events.extend(
+                    _tool_part_events(
+                        part,
+                        timestamp,
+                        provenance,
+                        native_state=states.popleft() if states else None,
+                    )
+                )
             elif part_type == "reasoning" and role_name == "assistant":
                 events.append(
                     Event(
@@ -679,8 +723,12 @@ def parse_import(path: Path) -> ParsedOpenCodeSession:
         started_at=_iso_from_ms(created),
         title=title,
         events=tuple(events),
-        raw_record_count=1 + len(messages) + part_count,
-        cli_version=string(info.get("version")),
+        raw_record_count=(
+            opencode_v2.record_count(native_v2)
+            if native_v2 is not None
+            else 1 + len(messages) + part_count
+        ),
+        cli_version=None if native_v2 is not None else string(info.get("version")),
         model=latest_model or _session_model(info, "id"),
         provider=latest_provider or _session_model(info, "providerID"),
         parent_session=string(info.get("parentID")),
@@ -735,6 +783,12 @@ def _decode_import_bundle(data: bytes) -> dict[str, Any]:
 
 
 def _validate_import_bundle(value: dict[str, Any], expected_session_id: str | None = None) -> None:
+    if opencode_v2.is_bundle(value):
+        projected = opencode_v2.to_legacy(value)
+        if expected_session_id is not None and value["info"].get("id") != expected_session_id:
+            raise SessionMigrateError("OpenCode bundle ID does not match the target ID")
+        _validate_import_bundle(projected)
+        return
     if not isinstance(value.get("info"), dict):
         raise SessionMigrateError("OpenCode import bundle is missing session info")
     info = value["info"]
@@ -1296,7 +1350,13 @@ def _session_model(info: dict[str, Any], field: str) -> str | None:
     return string(model.get(field)) if isinstance(model, dict) else None
 
 
-def _tool_part_events(part: dict[str, Any], timestamp: str, provenance: Provenance) -> list[Event]:
+def _tool_part_events(
+    part: dict[str, Any],
+    timestamp: str,
+    provenance: Provenance,
+    *,
+    native_state: dict[str, Any] | None = None,
+) -> list[Event]:
     call_id = string(part.get("callID"))
     tool_name = string(part.get("tool"))
     state = part.get("state") if isinstance(part.get("state"), dict) else {}
@@ -1323,7 +1383,24 @@ def _tool_part_events(part: dict[str, Any], timestamp: str, provenance: Provenan
         )
         return result
     content_blocks: list[dict[str, Any]] = []
-    if status == "completed":
+    if status == "completed" and native_state is not None:
+        texts = []
+        for block in native_state["content"]:
+            if block["type"] == "text":
+                texts.append(block["text"])
+                content_blocks.append({"type": "text", "text": block["text"]})
+            else:
+                image_url = _portable_file_url({"url": block["uri"], "mime": block["mime"]})
+                if image_url:
+                    content_blocks.append({"type": "image", "image_url": image_url})
+                else:
+                    result.append(
+                        _opaque_part_event(
+                            provenance, "assistant", timestamp, "opencode_tool_attachment_non_image"
+                        )
+                    )
+        text = "\n".join(texts) or None
+    elif status == "completed":
         output = state.get("output")
         if isinstance(output, str) and output:
             content_blocks.append({"type": "text", "text": output})
@@ -1395,21 +1472,23 @@ def _tool_result(
     tool_part: dict[str, Any],
     dropped: Counter[str],
     attachment_id: Callable[[], str],
-) -> tuple[str, list[dict[str, Any]]]:
+) -> tuple[str, list[dict[str, Any]], list[dict[str, Any]]]:
     blocks = event.payload.get("content_blocks")
     if not isinstance(blocks, list):
         blocks = []
     texts: list[str] = []
     attachments: list[dict[str, Any]] = []
+    ordered: list[dict[str, Any]] = []
     for block in blocks:
         if not isinstance(block, dict):
             dropped["tool_result:malformed_block"] += 1
             continue
         block_type = string(block.get("type"))
         if block_type in {"text", "input_text", "output_text"}:
-            text = string(block.get("text"))
-            if text:
+            text = block.get("text")
+            if isinstance(text, str):
                 texts.append(text)
+                ordered.append({"type": "text", "text": text})
             else:
                 dropped["tool_result:malformed_text"] += 1
         elif block_type in {"image", "input_image"}:
@@ -1427,11 +1506,15 @@ def _tool_result(
                     }
                 )
                 attachments.append(attachment)
+                ordered.append(
+                    {"type": "file", "uri": attachment["url"], "mime": attachment["mime"]}
+                )
         else:
             dropped[f"tool_result:{block_type or 'unknown_block'}"] += 1
     if not texts and event.text:
         texts.append(event.text)
-    return "\n".join(texts), attachments
+        ordered.insert(0, {"type": "text", "text": event.text})
+    return "\n".join(texts), attachments, ordered
 
 
 def _file_part(value: Any, dropped: Counter[str], omission_key: str) -> dict[str, Any] | None:
diff --git a/src/session_migrate/formats/opencode_v2.py b/src/session_migrate/formats/opencode_v2.py
new file mode 100644
index 0000000..542bd6d
--- /dev/null
+++ b/src/session_migrate/formats/opencode_v2.py
@@ -0,0 +1,884 @@
+"""Public OpenCode 2.0 transfer schema support; no private database access.
+
+Legacy bundles are an internal portable projection only. Native v2 files always
+use SessionTransfer.Data (flat messages), not legacy message info/parts.
+"""
+
+from __future__ import annotations
+
+import base64
+import copy
+import re
+from typing import Any
+
+from session_migrate.errors import SessionMigrateError
+
+_VERSION = re.compile(r"(?:opencode v)?(2\.0\.\d+(?:[-+][0-9A-Za-z.-]+)?)")
+VALIDATED_VERSION = "2.0.23"
+VALIDATED_VERSIONS = frozenset({"2.0.22", VALIDATED_VERSION})
+
+
+def version(value: str) -> str | None:
+    match = _VERSION.fullmatch(value)
+    return match.group(1) if match else None
+
+
+def is_bundle(value: dict[str, Any]) -> bool:
+    return isinstance(value.get("info"), dict) and "location" in value["info"]
+
+
+def _file(part: dict[str, Any]) -> dict[str, Any]:
+    uri = part["url"]
+    if not uri.startswith("data:") or ";base64," not in uri:
+        raise SessionMigrateError("OpenCode v2 inline images must have a base64 data URI")
+    return {"data": uri.split(";base64,", 1)[1], "mime": part["mime"], "source": {"type": "inline"}}
+
+
+_OPENCODE_NAMESPACE = "oc/"
+
+
+def _model_ref(model: dict[str, Any]) -> dict[str, str]:
+    """Write a model reference the way the target resolves its next turn.
+
+    Routers such as 9router mirror OpenCode's own catalogue under an ``oc/`` prefix while
+    keeping their own provider id.  OpenCode resolves a turn from the reference its last
+    message carries, and a mirrored free-tier model routed through a router is refused
+    ("free tier can only be used from within OpenCode"), so a reference that names the
+    target's own namespace is written as the target's provider instead.
+    """
+    model_id = str(model.get("modelID") or "unknown")
+    if model_id.startswith(_OPENCODE_NAMESPACE):
+        return {"id": model_id[len(_OPENCODE_NAMESPACE) :], "providerID": "opencode"}
+    return {"id": model_id, "providerID": str(model.get("providerID") or "unknown")}
+
+
+def from_legacy(
+    bundle: dict[str, Any],
+    dropped: Any,
+    *,
+    tool_content: dict[str, list[dict[str, Any]]] | None = None,
+) -> dict[str, Any]:
+    old = bundle["info"]
+    ref: dict[str, Any] = {}
+    messages: list[dict[str, Any]] = []
+    compact: set[str] = set()
+    for message in bundle["messages"]:
+        info, parts = message["info"], message["parts"]
+        common = {"id": info["id"], "time": info["time"]}
+        if info["role"] == "user":
+            ref = _model_ref(info["model"])
+            if any(part["type"] == "compaction" for part in parts):
+                compact.add(info["id"])
+                continue
+            native = {
+                **common,
+                "type": "user",
+                "text": "\n".join(part["text"] for part in parts if part["type"] == "text"),
+            }
+            files = [_file(part) for part in parts if part["type"] == "file"]
+            if files:
+                native["files"] = files
+        else:
+            ref = _model_ref(info)
+            if info.get("summary") and info["parentID"] in compact:
+                messages.append(
+                    {
+                        **common,
+                        "type": "compaction",
+                        "status": "completed",
+                        "reason": "auto",
+                        "model": ref,
+                        "summary": "\n".join(p["text"] for p in parts if p["type"] == "text"),
+                        "recent": "",
+                    }
+                )
+                continue
+            content: list[dict[str, Any]] = []
+            for part in parts:
+                kind = part["type"]
+                if kind in {"text", "reasoning"}:
+                    content.append({"type": kind, "text": part["text"]})
+                elif kind == "tool":
+                    state = part["state"]
+                    status = state["status"]
+                    tool_state: dict[str, Any] = {"status": status, "input": state["input"]}
+                    if status == "completed":
+                        tool_state["content"] = [{"type": "text", "text": state["output"]}]
+                        tool_state["content"].extend(
+                            {"type": "file", "uri": p["url"], "mime": p["mime"]}
+                            for p in state.get("attachments", [])
+                        )
+                        if tool_content is not None and part["id"] in tool_content:
+                            tool_state["content"] = tool_content[part["id"]] or [
+                                {"type": "text", "text": state["output"]}
+                            ]
+                    elif status == "error":
+                        tool_state["error"] = {"type": "ToolError", "message": state["error"]}
+                    else:
+                        # Native export/import discards unsettled assistant steps. Archive
+                        # incomplete calls as explicit errors so their input survives.
+                        tool_state = {
+                            "status": "error",
+                            "input": state["input"],
+                            "error": {
+                                "type": "ImportedIncompleteTool",
+                                "message": "Imported call had no completed result",
+                            },
+                        }
+                        dropped["tool_call:v2_incomplete_archived"] += 1
+                    times = state.get("time", {})
+                    content.append(
+                        {
+                            "type": "tool",
+                            "id": part["callID"],
+                            "name": part["tool"],
+                            "state": tool_state,
+                            "time": {
+                                "created": times.get("start", info["time"]["created"]),
+                                **({"completed": times["end"]} if "end" in times else {}),
+                            },
+                        }
+                    )
+            native = {
+                **common,
+                "type": "assistant",
+                "agent": info["agent"],
+                "model": ref,
+                "content": content,
+                "finish": info["finish"],
+                "cost": info["cost"],
+                "tokens": info["tokens"],
+            }
+        messages.append(native)
+    return {
+        "info": {
+            "id": old["id"],
+            "projectID": old["projectID"],
+            "title": old["title"],
+            "agent": next(
+                (m.get("agent", "build") for m in reversed(messages) if m.get("agent")), "build"
+            ),
+            "model": ref,
+            "location": {"directory": old["directory"]},
+            "cost": 0,
+            "tokens": {"input": 0, "output": 0, "reasoning": 0, "cache": {"read": 0, "write": 0}},
+            "time": old["time"],
+        },
+        "messages": messages,
+    }
+
+
+def _to_legacy(bundle: dict[str, Any]) -> dict[str, Any]:
+    """Validate the v2 portable content projection and reuse the mature reader."""
+    from session_migrate.formats import opencode
+
+    info = bundle["info"]
+    _validate_native(bundle)
+    if not isinstance(info.get("location"), dict):
+        raise SessionMigrateError("OpenCode v2 session is missing location")
+    opencode._validate_tokens(info.get("tokens"), "v2 session")
+    if not opencode._is_finite_number(info.get("cost")):
+        raise SessionMigrateError("OpenCode v2 session has invalid cost")
+    model = info.get("model") or {"id": "unknown", "providerID": "unknown"}
+    messages = bundle.get("messages")
+    if not isinstance(messages, list) or len(messages) > opencode.MAX_NATIVE_MESSAGES:
+        raise SessionMigrateError("OpenCode v2 session has invalid messages")
+    output: list[dict[str, Any]] = []
+    ids: set[str] = set()
+    latest_user = "msg_import_root"
+    part_index = 0
+
+    def part(data: dict[str, Any], message_id: str) -> dict[str, Any]:
+        nonlocal part_index
+        part_index += 1
+        if part_index > opencode.MAX_NATIVE_PARTS:
+            raise SessionMigrateError("OpenCode v2 session contains too much content")
+        return {
+            **data,
+            "id": f"prt_v2_projection_{part_index}",
+            "sessionID": info["id"],
+            "messageID": message_id,
+        }
+
+    for message in messages:
+        if not isinstance(message, dict):
+            raise SessionMigrateError("OpenCode v2 session contains a malformed message")
+        mid = message.get("id")
+        if not isinstance(mid, str) or not mid.startswith("msg_") or mid in ids:
+            raise SessionMigrateError("OpenCode v2 session has invalid message IDs")
+        ids.add(mid)
+        clock = message.get("time")
+        if not isinstance(clock, dict):
+            raise SessionMigrateError("OpenCode v2 message is missing time")
+        opencode._iso_from_ms(clock.get("created"))
+        kind = message.get("type")
+        if kind == "model-switched":
+            model = message["model"]
+            continue
+        if kind == "compaction":
+            if message.get("status") != "completed":
+                continue
+            # A provider-private checkpoint without portable text must not retire
+            # earlier readable history when replayed in another harness.
+            if not message["summary"].strip() and not message["recent"].strip():
+                continue
+            synthetic_id = mid + "_compaction"
+            output.append(
+                {
+                    "info": {
+                        "id": synthetic_id,
+                        "sessionID": info["id"],
+                        "role": "user",
+                        "time": clock,
+                        "agent": "build",
+                        "model": {"modelID": model["id"], "providerID": model["providerID"]},
+                    },
+                    "parts": [
+                        part(
+                            {"type": "compaction", "auto": message.get("reason") == "auto"},
+                            synthetic_id,
+                        )
+                    ],
+                }
+            )
+            latest_user = synthetic_id
+            kind = "assistant"
+            message = {
+                **message,
+                "model": message.get("model") or model,
+                "agent": "build",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": message.get("summary", "")
+                        + (
+                            "\n\nRecent context:\n" + message["recent"]
+                            if message.get("recent")
+                            else ""
+                        ),
+                    }
+                ],
+                "_summary": True,
+            }
+        if kind not in {"user", "assistant"}:
+            continue
+        parts: list[dict[str, Any]] = []
+        common = {"id": mid, "sessionID": info["id"], "role": kind, "time": clock}
+        if kind == "user":
+            if not isinstance(message.get("text"), str):
+                raise SessionMigrateError("OpenCode v2 user message has invalid text")
+            parts.append(part({"type": "text", "text": message["text"]}, mid))
+            for attachment in message.get("files", []):
+                if not isinstance(attachment, dict) or not isinstance(attachment.get("data"), str):
+                    raise SessionMigrateError("OpenCode v2 file attachment is invalid")
+                try:
+                    base64.b64decode(attachment["data"], validate=True)
+                except ValueError as exc:
+                    raise SessionMigrateError("OpenCode v2 file attachment is not base64") from exc
+                parts.append(
+                    part(
+                        {
+                            "type": "file",
+                            "mime": attachment["mime"],
+                            "url": f"data:{attachment['mime']};base64,{attachment['data']}",
+                        },
+                        mid,
+                    )
+                )
+            common.update(
+                {
+                    "agent": "build",
+                    "model": {"modelID": model["id"], "providerID": model["providerID"]},
+                }
+            )
+            latest_user = mid
+        else:
+            model = message.get("model", model)
+            if not isinstance(message.get("content"), list):
+                raise SessionMigrateError("OpenCode v2 assistant message has invalid content")
+            for content in message["content"]:
+                if not isinstance(content, dict):
+                    raise SessionMigrateError("OpenCode v2 assistant content is malformed")
+                ptype = content.get("type")
+                if ptype in {"text", "reasoning"}:
+                    parts.append(
+                        part(
+                            {
+                                "type": ptype,
+                                "text": content.get("text"),
+                                **(
+                                    {"time": {"start": clock["created"], "end": clock["created"]}}
+                                    if ptype == "reasoning"
+                                    else {}
+                                ),
+                            },
+                            mid,
+                        )
+                    )
+                elif ptype == "tool":
+                    state = copy.deepcopy(content.get("state"))
+                    if not isinstance(state, dict):
+                        raise SessionMigrateError("OpenCode v2 tool state is invalid")
+                    status = state.get("status")
+                    if status == "completed":
+                        blocks = state.pop("content", None)
+                        if not isinstance(blocks, list) or not blocks:
+                            raise SessionMigrateError("OpenCode v2 completed tool needs content")
+                        state["output"] = "\n".join(
+                            b["text"] for b in blocks if b.get("type") == "text"
+                        )
+                        state["title"] = content["name"]
+                        state["metadata"] = state.get("metadata", {})
+                        attachments = [
+                            part({"type": "file", "mime": b["mime"], "url": b["uri"]}, mid)
+                            for b in blocks
+                            if b.get("type") == "file"
+                        ]
+                        if attachments:
+                            state["attachments"] = attachments
+                    elif status == "error":
+                        error = state.get("error")
+                        if not isinstance(error, dict) or not isinstance(error.get("message"), str):
+                            raise SessionMigrateError("OpenCode v2 tool error is invalid")
+                        state["error"] = error["message"]
+                    elif status == "streaming":
+                        state = {
+                            "status": "pending",
+                            "input": {"input": state["input"]},
+                            "raw": state["input"],
+                        }
+                    tool_time = content.get("time", clock)
+                    state["time"] = {
+                        "start": tool_time.get("created", clock["created"]),
+                        "end": tool_time.get("completed", clock["created"]),
+                    }
+                    parts.append(
+                        part(
+                            {
+                                "type": "tool",
+                                "callID": content.get("id"),
+                                "tool": content.get("name"),
+                                "state": state,
+                            },
+                            mid,
+                        )
+                    )
+                else:
+                    raise SessionMigrateError("OpenCode v2 has unsupported assistant content")
+            common.update(
+                {
+                    "parentID": latest_user,
+                    "modelID": model["id"],
+                    "providerID": model["providerID"],
+                    "agent": message.get("agent", "build"),
+                    "mode": message.get("agent", "build"),
+                    "path": {
+                        "cwd": info["location"]["directory"],
+                        "root": info["location"]["directory"],
+                    },
+                    "cost": message.get("cost", 0),
+                    "tokens": message.get("tokens", info["tokens"]),
+                    "finish": message.get("finish", "stop"),
+                }
+            )
+            if message.get("_summary"):
+                common["summary"] = True
+        output.append({"info": common, "parts": parts})
+    return {
+        "info": {
+            "id": info["id"],
+            "directory": info["location"].get("directory"),
+            "title": info.get("title") or "Imported session",
+            "slug": "v2-export",
+            "projectID": info.get("projectID"),
+            "version": "2.0",
+            "time": info.get("time"),
+            **({"parentID": info["parentID"]} if "parentID" in info else {}),
+        },
+        "messages": output,
+    }
+
+
+_MESSAGE_FIELDS = {
+    "user": {"text", "files", "agents", "skills"},
+    "assistant": {
+        "agent",
+        "model",
+        "content",
+        "snapshot",
+        "finish",
+        "rawFinish",
+        "providerState",
+        "cost",
+        "tokens",
+        "error",
+        "retry",
+    },
+    "compaction": {
+        "status",
+        "reason",
+        "summary",
+        "recent",
+        "model",
+        "providerState",
+        "providerContext",
+        "cost",
+        "tokens",
+        "error",
+    },
+    "agent-switched": {"agent", "previous"},
+    "model-switched": {"model", "previous"},
+    "location-switched": {"location", "projectID", "subpath", "previous"},
+    "synthetic": {"text", "description"},
+    "system": {"text", "description"},
+    "skill": {"skill", "name", "text"},
+    "shell": {"shellID", "command", "status", "exit", "output"},
+    "idle": {"outcome"},
+}
+
+
+def loss_events(bundle: dict[str, Any]) -> list[Any]:
+    """Account for provider-private state and nonportable v2 control records."""
+    from session_migrate.formats.opencode import _iso_from_ms
+    from session_migrate.model import Event, EventKind, Provenance
+
+    events = []
+    if (bundle["info"].get("model") or {}).get("variant"):
+        events.append(
+            Event(
+                kind=EventKind.OPAQUE,
+                timestamp=_iso_from_ms(bundle["info"]["time"]["created"]),
+                payload={"reason": "opencode_v2_session_model_variant"},
+                provenance=Provenance(0, "session"),
+            )
+        )
+    for name in ("metadata", "permissions", "revert", "fork"):
+        if bundle["info"].get(name):
+            events.append(
+                Event(
+                    kind=EventKind.OPAQUE,
+                    timestamp=_iso_from_ms(bundle["info"]["time"]["created"]),
+                    payload={"reason": f"opencode_v2_session_{name}"},
+                    provenance=Provenance(0, "session"),
+                )
+            )
+    for index, message in enumerate(bundle["messages"]):
+        reasons = []
+        kind = message.get("type")
+        if kind not in {"user", "assistant", "compaction"}:
+            reasons.append(f"opencode_v2_{kind}_record")
+        elif kind == "compaction" and message.get("status") != "completed":
+            reasons.append(f"opencode_v2_compaction_{message.get('status')}")
+        elif (
+            kind == "compaction"
+            and not message["summary"].strip()
+            and not message["recent"].strip()
+        ):
+            reasons.append("opencode_v2_compaction_empty_portable_summary")
+        if isinstance(message.get("model"), dict) and message["model"].get("variant"):
+            reasons.append("opencode_v2_message_model_variant")
+        for name in ("providerState", "providerContext", "metadata", "snapshot", "retry", "error"):
+            if message.get(name):
+                reasons.append(f"opencode_v2_{name}")
+        for name in ("agents", "skills"):
+            if message.get(name):
+                reasons.append(f"opencode_v2_user_{name}")
+        if kind == "user":
+            for attachment in message.get("files", []):
+                if (
+                    any(attachment.get(name) for name in ("name", "description", "mention"))
+                    or attachment.get("source", {}).get("type") == "uri"
+                ):
+                    reasons.append("opencode_v2_file_metadata")
+        allowed = _MESSAGE_FIELDS.get(str(kind), set()) | {"id", "metadata", "time", "type"}
+        if set(message) - allowed:
+            reasons.append("opencode_v2_unknown_message_fields")
+        for content in message["content"] if kind == "assistant" else []:
+            allowed_content = (
+                {"type", "text", "state", "time"}
+                if content.get("type") != "tool"
+                else {
+                    "type",
+                    "id",
+                    "name",
+                    "executed",
+                    "providerState",
+                    "providerResultState",
+                    "state",
+                    "time",
+                }
+            )
+            if set(content) - allowed_content:
+                reasons.append("opencode_v2_unknown_assistant_content_fields")
+            if content.get("type") == "tool":
+                state = content["state"]
+                if state["status"] == "error":
+                    structured = state["error"]
+                    if structured["type"] != "ToolError":
+                        reasons.append("opencode_v2_tool_error_type")
+                    for field in ("status", "response"):
+                        if field in structured:
+                            reasons.append(f"opencode_v2_tool_error_{field}")
+                for block in content["state"].get("content", []):
+                    if block.get("type") == "file" and block.get("name") is not None:
+                        reasons.append("opencode_v2_tool_file_metadata")
+            if (
+                content.get("type") == "tool"
+                and content.get("state", {}).get("status") == "error"
+                and content["state"].get("content")
+            ):
+                reasons.append("opencode_v2_error_tool_content")
+            for name in ("state", "providerState", "providerResultState"):
+                if content.get(name) and (name != "state" or content.get("type") != "tool"):
+                    reasons.append(f"opencode_v2_content_{name}")
+        for reason in reasons:
+            events.append(
+                Event(
+                    kind=EventKind.OPAQUE,
+                    timestamp=_iso_from_ms(message["time"]["created"]),
+                    payload={"reason": reason},
+                    provenance=Provenance(index, str(kind)),
+                )
+            )
+    return events
+
+
+def to_legacy(bundle: dict[str, Any]) -> dict[str, Any]:
+    try:
+        return _to_legacy(bundle)
+    except (KeyError, TypeError, ValueError, AttributeError) as exc:
+        raise SessionMigrateError(
+            "OpenCode v2 transfer has malformed required metadata/content"
+        ) from exc
+
+
+def _validate_native(bundle: dict[str, Any]) -> None:
+    """Check portable v2 invariants before projection can erase native fields."""
+    from session_migrate.formats.opencode import (
+        MAX_NATIVE_MESSAGES,
+        MAX_NATIVE_PARTS,
+        _is_finite_number,
+        _is_non_negative_int,
+        _validate_tokens,
+    )
+
+    def strings(value: dict[str, Any], required: tuple[str, ...], optional=()) -> None:
+        if any(not isinstance(value.get(k), str) for k in required) or any(
+            k in value and not isinstance(value[k], str) for k in optional
+        ):
+            raise SessionMigrateError("OpenCode v2 has invalid native string fields")
+
+    def enum(value: Any, choices: tuple[str, ...]) -> None:
+        if not isinstance(value, str) or value not in choices:
+            raise SessionMigrateError("OpenCode v2 has invalid native discriminator")
+
+    def object_fields(value: dict[str, Any], fields: tuple[str, ...]) -> None:
+        if any(k in value and not isinstance(value[k], dict) for k in fields):
+            raise SessionMigrateError("OpenCode v2 has invalid native object fields")
+
+    def time(value: Any, required: tuple[str, ...], optional=()) -> None:
+        if (
+            not isinstance(value, dict)
+            or any(not _is_non_negative_int(value.get(k)) for k in required)
+            or any(k in value and not _is_non_negative_int(value[k]) for k in optional)
+        ):
+            raise SessionMigrateError("OpenCode v2 has invalid native time")
+
+    def location_ref(value: Any) -> None:
+        if not isinstance(value, dict):
+            raise SessionMigrateError("OpenCode v2 has invalid location")
+        strings(value, ("directory",), ("workspaceID",))
+        if not value["directory"] or "\x00" in value["directory"]:
+            raise SessionMigrateError("OpenCode v2 has invalid location directory")
+        if "workspaceID" in value and not value["workspaceID"].startswith("wrk"):
+            raise SessionMigrateError("OpenCode v2 has invalid location workspace")
+
+    def mention(value: Any) -> None:
+        if (
+            not isinstance(value, dict)
+            or not isinstance(value.get("text"), str)
+            or not all(_is_finite_number(value.get(k)) for k in ("start", "end"))
+        ):
+            raise SessionMigrateError("OpenCode v2 has invalid attachment mention")
+
+    def ref(value: Any) -> None:
+        if not isinstance(value, dict) or not all(
+            isinstance(value.get(k), str) for k in ("id", "providerID")
+        ):
+            raise SessionMigrateError("OpenCode v2 has invalid model reference")
+        if "variant" in value and not isinstance(value["variant"], str):
+            raise SessionMigrateError("OpenCode v2 has invalid model variant")
+
+    def error(value: Any) -> None:
+        if not isinstance(value, dict) or not all(
+            isinstance(value.get(key), str) for key in ("type", "message")
+        ):
+            raise SessionMigrateError("OpenCode v2 has invalid structured error")
+        status = value.get("status")
+        if "status" in value and (not _is_non_negative_int(status) or not 100 <= status <= 599):
+            raise SessionMigrateError("OpenCode v2 has invalid error status")
+        response = value.get("response")
+        if "response" in value and (
+            not isinstance(response, dict) or not isinstance(response.get("body"), str)
+        ):
+            raise SessionMigrateError("OpenCode v2 has invalid error response")
+
+    info = bundle["info"]
+    strings(info, ("id", "projectID"), ("title", "agent", "parentID", "subpath"))
+    if not info["id"].startswith("ses_") or (
+        "parentID" in info and not info["parentID"].startswith("ses_")
+    ):
+        raise SessionMigrateError("OpenCode v2 has invalid session identity")
+    time(info.get("time"), ("created", "updated"), ("idle", "viewed", "archived"))
+    if info["time"]["updated"] < info["time"]["created"]:
+        raise SessionMigrateError("OpenCode v2 has invalid update time")
+    location_ref(info.get("location"))
+    object_fields(info, ("metadata", "fork", "revert"))
+    if "model" in info:
+        ref(info["model"])
+    if "outcome" in info:
+        enum(info["outcome"], ("succeeded", "failed", "interrupted"))
+    if "permissions" in info and not isinstance(info["permissions"], list):
+        raise SessionMigrateError("OpenCode v2 has invalid session permissions")
+    permissions = info.get("permissions")
+    if permissions is not None and (
+        not isinstance(permissions, list)
+        or any(
+            not isinstance(rule, dict)
+            or not isinstance(rule.get("action"), str)
+            or not isinstance(rule.get("resource"), str)
+            or rule.get("effect") not in {"allow", "deny", "ask"}
+            for rule in permissions
+        )
+    ):
+        raise SessionMigrateError("OpenCode v2 has invalid session permissions")
+    fork = info.get("fork")
+    if fork is not None:
+        boundary = fork.get("boundary") if isinstance(fork, dict) else None
+        if (
+            not isinstance(fork, dict)
+            or not isinstance(fork.get("sessionID"), str)
+            or not fork["sessionID"].startswith("ses_")
+            or not isinstance(boundary, dict)
+            or boundary.get("type") not in {"before", "through"}
+            or not isinstance(boundary.get("messageID"), str)
+            or not boundary["messageID"].startswith("msg_")
+        ):
+            raise SessionMigrateError("OpenCode v2 has invalid session fork")
+    revert = info.get("revert")
+    if revert is not None and (
+        not isinstance(revert, dict)
+        or not isinstance(revert.get("messageID"), str)
+        or not revert["messageID"].startswith("msg_")
+    ):
+        raise SessionMigrateError("OpenCode v2 has invalid session revert")
+    if revert is not None:
+        strings(revert, (), ("partID", "snapshot"))
+        if "files" in revert:
+            if not isinstance(revert["files"], list):
+                raise SessionMigrateError("OpenCode v2 has invalid reverted files")
+            for diff in revert["files"]:
+                if not isinstance(diff, dict):
+                    raise SessionMigrateError("OpenCode v2 has invalid reverted file")
+                strings(diff, ("file", "patch"))
+                enum(diff.get("status"), ("added", "modified", "deleted"))
+                if not all(_is_non_negative_int(diff.get(k)) for k in ("additions", "deletions")):
+                    raise SessionMigrateError("OpenCode v2 has invalid reverted file counts")
+    messages = bundle.get("messages")
+    if not isinstance(messages, list) or len(messages) > MAX_NATIVE_MESSAGES:
+        raise SessionMigrateError("OpenCode v2 session has invalid messages")
+    seen_ids = set()
+    native_parts = 0
+    for m in messages:
+        if not isinstance(m, dict):
+            raise SessionMigrateError("OpenCode v2 has malformed message")
+        strings(m, ("id", "type"))
+        if not m["id"].startswith("msg_") or m["id"] in seen_ids:
+            raise SessionMigrateError("OpenCode v2 has invalid message IDs")
+        seen_ids.add(m["id"])
+        object_fields(m, ("metadata",))
+        for field in ("cost", "tokens", "error"):
+            if field in m and m[field] is None:
+                raise SessionMigrateError("OpenCode v2 has null native field")
+        if m.get("cost") is not None and not _is_finite_number(m["cost"]):
+            raise SessionMigrateError("OpenCode v2 has invalid message cost")
+        if m.get("tokens") is not None:
+            _validate_tokens(m["tokens"], "v2 message")
+        if m.get("error") is not None:
+            error(m["error"])
+        kind = m.get("type")
+        if kind not in _MESSAGE_FIELDS:
+            raise SessionMigrateError("OpenCode v2 has unsupported message type")
+        clock = m.get("time")
+        time(clock, ("created",), ("completed", "streamed"))
+        if kind in {"assistant", "model-switched"} or (kind == "compaction" and "model" in m):
+            ref(m.get("model"))
+        if kind == "user":
+            if not isinstance(m.get("text"), str):
+                raise SessionMigrateError("OpenCode v2 user message has invalid text")
+            files = m.get("files", [])
+            if not isinstance(files, list):
+                raise SessionMigrateError("OpenCode v2 user has invalid file attachments")
+            for attachment in files:
+                if not isinstance(attachment, dict):
+                    raise SessionMigrateError("OpenCode v2 has invalid file attachment")
+                strings(attachment, ("data", "mime"), ("name", "description"))
+                if "mention" in attachment:
+                    mention(attachment["mention"])
+                source = attachment.get("source") if isinstance(attachment, dict) else None
+                if not isinstance(source, dict) or source.get("type") not in {"inline", "uri"}:
+                    raise SessionMigrateError("OpenCode v2 file has invalid source")
+                if source["type"] == "uri" and not isinstance(source.get("uri"), str):
+                    raise SessionMigrateError("OpenCode v2 file has invalid source URI")
+            native_parts += len(files)
+            for field in ("agents", "skills"):
+                if field not in m:
+                    continue
+                if not isinstance(m[field], list):
+                    raise SessionMigrateError("OpenCode v2 has invalid user attachments")
+                for attachment in m[field]:
+                    if not isinstance(attachment, dict):
+                        raise SessionMigrateError("OpenCode v2 has invalid user attachment")
+                    strings(attachment, ("name",) if field == "agents" else ("id", "name"))
+                    if field == "skills":
+                        strings(attachment, (), ("text",))
+                    if "mention" in attachment:
+                        mention(attachment["mention"])
+        if kind in {"system", "synthetic"}:
+            strings(m, ("text",), ("description",))
+        if kind == "skill":
+            strings(m, ("skill", "name", "text"))
+        if kind == "agent-switched":
+            strings(m, ("agent",), ("previous",))
+        if kind == "model-switched" and "previous" in m:
+            ref(m["previous"])
+        if kind == "location-switched":
+            location_ref(m.get("location"))
+            strings(m, (), ("projectID", "subpath"))
+            if "previous" in m:
+                previous = m["previous"]
+                if not isinstance(previous, dict):
+                    raise SessionMigrateError("OpenCode v2 has invalid previous location")
+                location_ref(previous.get("location"))
+                strings(previous, (), ("projectID", "subpath"))
+        if kind == "idle":
+            enum(m.get("outcome"), ("succeeded", "failed", "interrupted"))
+        if kind == "shell":
+            strings(m, ("shellID", "command"))
+            if not m["shellID"].startswith("sh_"):
+                raise SessionMigrateError("OpenCode v2 has invalid shell ID")
+            enum(m.get("status"), ("running", "exited", "timeout", "killed"))
+            if "exit" in m and not _is_finite_number(m["exit"]):
+                raise SessionMigrateError("OpenCode v2 has invalid shell exit")
+            if "output" in m:
+                output = m["output"]
+                if (
+                    not isinstance(output, dict)
+                    or not isinstance(output.get("output"), str)
+                    or not all(_is_non_negative_int(output.get(k)) for k in ("cursor", "size"))
+                    or not isinstance(output.get("truncated"), bool)
+                ):
+                    raise SessionMigrateError("OpenCode v2 has invalid shell output")
+        if kind == "assistant":
+            strings(m, (), ("rawFinish",))
+            object_fields(m, ("providerState", "snapshot", "retry"))
+            if "snapshot" in m:
+                strings(m["snapshot"], (), ("start", "end"))
+                files = m["snapshot"].get("files", [])
+                if not isinstance(files, list) or not all(isinstance(f, str) for f in files):
+                    raise SessionMigrateError("OpenCode v2 has invalid snapshot files")
+            if "retry" in m:
+                retry = m["retry"]
+                if not _is_non_negative_int(retry.get("attempt")) or retry["attempt"] == 0:
+                    raise SessionMigrateError("OpenCode v2 has invalid retry attempt")
+                time(retry, ("at",))
+                error(retry.get("error"))
+            if "finish" in m:
+                enum(
+                    m["finish"],
+                    ("stop", "length", "tool-calls", "content-filter", "error", "unknown"),
+                )
+            if not isinstance(m.get("agent"), str) or not isinstance(m.get("content"), list):
+                raise SessionMigrateError("OpenCode v2 assistant has invalid runtime metadata")
+            for c in m["content"]:
+                if not isinstance(c, dict):
+                    raise SessionMigrateError("OpenCode v2 has malformed assistant content")
+                object_fields(c, ("providerState", "providerResultState"))
+                if c.get("type") != "tool":
+                    enum(c.get("type"), ("text", "reasoning"))
+                    strings(c, ("text",))
+                    object_fields(c, ("state",))
+                    if "time" in c:
+                        time(c["time"], ("created",), ("completed",))
+                    continue
+                strings(c, ("id", "name"))
+                if "executed" in c and not isinstance(c["executed"], bool):
+                    raise SessionMigrateError("OpenCode v2 tool has invalid executed flag")
+                time(c.get("time"), ("created",), ("ran", "completed"))
+                state = c.get("state")
+                if not isinstance(state, dict):
+                    raise SessionMigrateError("OpenCode v2 tool has invalid state")
+                enum(state.get("status"), ("streaming", "running", "completed", "error"))
+                if state["status"] == "streaming":
+                    strings(state, ("input",))
+                elif not isinstance(state.get("input"), dict):
+                    raise SessionMigrateError("OpenCode v2 tool has invalid input")
+                if "metadata" in state and not isinstance(state["metadata"], dict):
+                    raise SessionMigrateError("OpenCode v2 tool has invalid metadata")
+                if state.get("status") == "running" and not isinstance(state.get("metadata"), dict):
+                    raise SessionMigrateError("OpenCode v2 running tool has invalid metadata")
+                if state.get("status") == "error":
+                    error(state.get("error"))
+                if (state["status"] == "completed" or "content" in state) and (
+                    not isinstance(state.get("content"), list) or not state["content"]
+                ):
+                    raise SessionMigrateError("OpenCode v2 tool has invalid content")
+                for block in state.get("content", []):
+                    if not isinstance(block, dict) or block.get("type") not in {"text", "file"}:
+                        raise SessionMigrateError("OpenCode v2 tool has invalid content")
+                    fields = ("text",) if block["type"] == "text" else ("uri", "mime")
+                    if not all(isinstance(block.get(k), str) for k in fields):
+                        raise SessionMigrateError("OpenCode v2 tool has invalid content fields")
+                    strings(block, (), ("name",))
+                native_parts += len(state.get("content", []))
+            native_parts += len(m["content"])
+        if kind == "compaction":
+            if m.get("status") not in {"running", "completed", "failed"}:
+                raise SessionMigrateError("OpenCode v2 compaction has invalid status")
+            if m.get("reason") not in {"auto", "manual"}:
+                raise SessionMigrateError("OpenCode v2 compaction has invalid reason")
+            if m["status"] in {"running", "completed"} and not all(
+                isinstance(m.get(k), str) for k in ("summary", "recent")
+            ):
+                raise SessionMigrateError("OpenCode v2 compaction has invalid summary")
+            if m["status"] == "failed":
+                error(m.get("error"))
+            object_fields(m, ("providerState", "providerContext"))
+            if "providerContext" in m:
+                context = m["providerContext"]
+                if context.get("version") != 1 or isinstance(context.get("version"), bool):
+                    raise SessionMigrateError("OpenCode v2 has invalid provider context version")
+                provenance = context.get("provenance")
+                if not isinstance(provenance, dict) or "messages" not in context:
+                    raise SessionMigrateError("OpenCode v2 has invalid provider context")
+                strings(
+                    provenance,
+                    ("providerID", "provider", "modelID", "route", "protocol", "endpoint"),
+                )
+        if native_parts > MAX_NATIVE_PARTS:
+            raise SessionMigrateError("OpenCode v2 session contains too much content")
+
+
+def record_count(bundle: dict[str, Any]) -> int:
+    return (
+        1
+        + len(bundle["messages"])
+        + sum(
+            len(m["content"])
+            if m["type"] == "assistant"
+            else len(m.get("files", []))
+            if m["type"] == "user"
+            else 0
+            for m in bundle["messages"]
+        )
+    )
diff --git a/src/session_migrate/inspection.py b/src/session_migrate/inspection.py
index 05040d2..2caa44a 100644
--- a/src/session_migrate/inspection.py
+++ b/src/session_migrate/inspection.py
@@ -12,6 +12,7 @@
 from session_migrate.errors import FormatDetectionError, JsonlError, SessionMigrateError
 from session_migrate.formats import (
     antigravity,
+    antigravity_desktop,
     cursor,
     devin,
     grok,
@@ -19,6 +20,7 @@
     kimi,
     mastracode,
     muse,
+    opencode,
     openhands,
     qwen,
     vibe,
@@ -123,6 +125,9 @@ def inspect_session(path: Path, *, source_format: AgentFormat | None = None) ->
     if source_format == AgentFormat.ANTIGRAVITY:
         parsed = antigravity.parse_session(path)
         return _inspect_portable_database(parsed)
+    if source_format == AgentFormat.ANTIGRAVITY_DESKTOP:
+        parsed = antigravity_desktop.parse_session(path)
+        return _inspect_portable_database(parsed)
     if source_format == AgentFormat.CURSOR:
         parsed = cursor.project_session(cursor.parse(path), source_format=AgentFormat.CURSOR)
         return _inspect_portable_database(parsed)
@@ -153,6 +158,8 @@ def inspect_session(path: Path, *, source_format: AgentFormat | None = None) ->
         detected = _detect_sqlite_path(path)
         if detected == AgentFormat.ANTIGRAVITY:
             parsed = antigravity.parse_session(path)
+        elif detected == AgentFormat.ANTIGRAVITY_DESKTOP:
+            parsed = antigravity_desktop.parse_session(path)
         elif detected == AgentFormat.CURSOR:
             parsed = cursor.project_session(cursor.parse(path), source_format=AgentFormat.CURSOR)
         elif detected == AgentFormat.HERMES:
@@ -166,8 +173,11 @@ def inspect_session(path: Path, *, source_format: AgentFormat | None = None) ->
     if source_format in {AgentFormat.OPENCODE, AgentFormat.KILO} or source_format is None:
         document = _load_json_document(path, before.size)
         if document is not None and source_format is None and _is_opencode_document(document):
-            ensure_file_unchanged(path, before)
-            _raise_opencode_kilo_ambiguity()
+            if opencode.opencode_v2.is_bundle(document):
+                source_format = AgentFormat.OPENCODE
+            else:
+                ensure_file_unchanged(path, before)
+                _raise_opencode_kilo_ambiguity()
         if document is not None and source_format in {
             AgentFormat.OPENCODE,
             AgentFormat.KILO,
@@ -506,6 +516,10 @@ def detect_path_format(path: Path) -> AgentFormat:
     before = file_snapshot(path)
     document = _load_json_document(path, before.size)
     if document is not None and _is_opencode_document(document):
+        if opencode.opencode_v2.is_bundle(document):
+            opencode.parse_session(path)
+            ensure_file_unchanged(path, before)
+            return AgentFormat.OPENCODE
         ensure_file_unchanged(path, before)
         _raise_opencode_kilo_ambiguity()
     else:
@@ -517,6 +531,7 @@ def detect_path_format(path: Path) -> AgentFormat:
 def _detect_sqlite_path(path: Path) -> AgentFormat:
     probes = (
         (AgentFormat.ANTIGRAVITY, lambda: antigravity.parse(path)),
+        (AgentFormat.ANTIGRAVITY_DESKTOP, lambda: antigravity_desktop.parse(path)),
         (AgentFormat.CURSOR, lambda: cursor.parse(path)),
         (AgentFormat.HERMES, lambda: hermes.list_sessions(path)),
         (AgentFormat.MASTRACODE, lambda: mastracode.list_sessions(path)),
@@ -579,6 +594,10 @@ def _inspect_opencode(
     info = value.get("info")
     messages = value.get("messages")
     assert isinstance(info, dict) and isinstance(messages, list)
+    if opencode.opencode_v2.is_bundle(value):
+        if source_format == AgentFormat.KILO:
+            raise FormatDetectionError("OpenCode v2 transfer requires --format opencode, not kilo")
+        return _inspect_portable_database(opencode.parse_session(path))
     record_types: Counter[str] = Counter({"session": 1})
     roles: Counter[str] = Counter()
     blocks: Counter[str] = Counter()
diff --git a/src/session_migrate/jsonl.py b/src/session_migrate/jsonl.py
index c86c932..35b8bb6 100644
--- a/src/session_migrate/jsonl.py
+++ b/src/session_migrate/jsonl.py
@@ -147,43 +147,70 @@ def encode_jsonl(records: Iterable[Mapping[str, Any]]) -> bytes:
 
 
 def write_private_atomic(path: Path, data: bytes) -> tuple[int, int]:
-    """Write mode-0600 bytes atomically without silently replacing a session."""
+    """Write bytes atomically without silently replacing an existing target."""
 
     path = Path(os.path.abspath(path.expanduser()))
+
     if os.path.lexists(path):
         raise JsonlError(f"refusing to overwrite existing target: {path}")
+
     try:
         _mkdir_private(path.parent)
+
         descriptor, temporary_name = tempfile.mkstemp(
-            prefix=f".{path.name}.", suffix=".tmp", dir=path.parent
+            prefix=f".{path.name}.",
+            suffix=".tmp",
+            dir=path.parent,
         )
+
         temporary_path = Path(temporary_name)
-        published_identity: tuple[int, int] | None = None
+
         try:
-            os.fchmod(descriptor, 0o600)
+            # Close the raw descriptor through fdopen before doing any
+            # filesystem operation on Windows.
             with os.fdopen(descriptor, "wb") as stream:
                 stream.write(data)
                 stream.flush()
                 os.fsync(stream.fileno())
-            # A hard link is an atomic create-if-absent operation. Unlike an
-            # exists() check followed by replace(), it cannot clobber a file
-            # created by another process during this write.
-            try:
-                os.link(temporary_path, path)
-            except FileExistsError as exc:
-                raise JsonlError(f"refusing to overwrite existing target: {path}") from exc
-            temporary_path.unlink()
+
+            if os.name == "nt":
+                # Windows: rename fails if the destination already exists,
+                # giving us create-if-absent semantics without hard links.
+                try:
+                    os.rename(temporary_path, path)
+                except FileExistsError as exc:
+                    raise JsonlError(f"refusing to overwrite existing target: {path}") from exc
+            else:
+                # POSIX: hard link provides atomic create-if-absent semantics.
+                try:
+                    os.link(temporary_path, path)
+                except FileExistsError as exc:
+                    raise JsonlError(f"refusing to overwrite existing target: {path}") from exc
+
+                temporary_path.unlink()
+
             target_stat = path.lstat()
             published_identity = (target_stat.st_dev, target_stat.st_ino)
-            _fsync_directory(path.parent)
+
+            # Directory fsync is useful on POSIX, but is not supported
+            # consistently on Windows.
+            if os.name != "nt":
+                _fsync_directory(path.parent)
+
             return published_identity
+
+        except JsonlError:
+            temporary_path.unlink(missing_ok=True)
+            raise
+
         except BaseException:
+            # The temporary file should already be closed here.
             temporary_path.unlink(missing_ok=True)
-            if published_identity is not None:
-                _unlink_if_same_file(path, published_identity)
             raise
+
     except JsonlError:
         raise
+
     except OSError as exc:
         raise JsonlError(f"cannot write target session {path}: {exc.strerror or exc}") from exc
 
@@ -205,6 +232,8 @@ def _mkdir_private(path: Path) -> None:
 
 
 def _fsync_directory(path: Path) -> None:
+    if os.name == "nt":
+        return
     descriptor = os.open(path, os.O_RDONLY | getattr(os, "O_DIRECTORY", 0))
     try:
         os.fsync(descriptor)
diff --git a/src/session_migrate/model.py b/src/session_migrate/model.py
index 14eead0..d9969c9 100644
--- a/src/session_migrate/model.py
+++ b/src/session_migrate/model.py
@@ -17,6 +17,7 @@ class AgentFormat(StrEnum):
     OPENCODE = "opencode"
     COPILOT = "copilot"
     ANTIGRAVITY = "antigravity"
+    ANTIGRAVITY_DESKTOP = "antigravity-desktop"
     CURSOR = "cursor"
     VIBE = "vibe"
     MUSE = "muse"
@@ -40,6 +41,7 @@ class TargetFormat(StrEnum):
     OPENCODE = "opencode"
     COPILOT = "copilot"
     ANTIGRAVITY = "antigravity"
+    ANTIGRAVITY_DESKTOP = "antigravity-desktop"
     CURSOR = "cursor"
     VIBE = "vibe"
     MUSE = "muse"
diff --git a/tests/native_corpus/route_oracle.py b/tests/native_corpus/route_oracle.py
index 923ee1f..f35b6be 100644
--- a/tests/native_corpus/route_oracle.py
+++ b/tests/native_corpus/route_oracle.py
@@ -62,6 +62,7 @@ class TargetContract:
     result_content_blocks: bool = True
     group_adjacent_messages: bool = False
     pair_tool_results_with_calls: bool = False
+    flatten_tool_result_blocks: bool = False
     opaque_style: str = "reason_prefixed"
     system_loss: str | None = "message:privileged_role"
     other_context_style: str = "typed"
@@ -134,6 +135,7 @@ class TargetObservation:
         KEEP,
         CapabilityRule(False, ("thinking",)),
         pair_tool_results_with_calls=True,
+        flatten_tool_result_blocks=True,
         other_context_style="privileged_image",
     ),
     "copilot": TargetContract(
@@ -228,6 +230,7 @@ class TargetObservation:
         KEEP,
         CapabilityRule(False, ("thinking",)),
         pair_tool_results_with_calls=True,
+        flatten_tool_result_blocks=True,
         other_context_style="privileged_image",
     ),
     "openhands": TargetContract(
@@ -532,6 +535,8 @@ def expected_loss_counters(session: Session, target: str) -> dict[str, int]:
             continue
         if event.kind == EventKind.TOOL_RESULT:
             _apply_rule(losses, contract.tool_result)
+            if contract.flatten_tool_result_blocks and _tool_result_flattening_loses_blocks(event):
+                losses["tool_result:content_block_order"] += 1
             for block in _result_blocks(event):
                 if block.get("type") == "image":
                     _apply_rule(losses, contract.tool_result_image)
@@ -1374,6 +1379,24 @@ def _context_loss_key(event: Event, contract: TargetContract) -> str:
     return f"context:{context_type}"
 
 
+def _tool_result_flattening_loses_blocks(event: Event) -> bool:
+    """One output string cannot retain text boundaries or image/text interleaving."""
+    text_count = 0
+    image_seen = False
+    for block in _result_blocks(event):
+        if block.get("type") in {"text", "input_text", "output_text"}:
+            text = block.get("text")
+            if not isinstance(text, str):
+                continue
+            text_count += 1
+            if not text or text_count > 1 or image_seen:
+                return True
+        elif block.get("type") in {"image", "input_image"}:
+            if _portable_image_digest(block.get("image_url") or block.get("url")) is not None:
+                image_seen = True
+    return False
+
+
 def _result_blocks(event: Event) -> list[Mapping[str, Any]]:
     value = event.payload.get("content_blocks")
     if not isinstance(value, list):
diff --git a/tests/native_corpus/v1/corpus.json b/tests/native_corpus/v1/corpus.json
index 08a8c64..6b56815 100644
--- a/tests/native_corpus/v1/corpus.json
+++ b/tests/native_corpus/v1/corpus.json
@@ -59,7 +59,7 @@
     },
     {
       "format": "hermes",
-      "fixture_dir": "sources/hermes/0.20.6/portable-rich",
+      "fixture_dir": "sources/hermes/0.22.2/portable-rich",
       "primary": true
     },
     {
diff --git a/tests/native_corpus/v1/sources/hermes/0.20.6/portable-rich/expected-ir.jsonl b/tests/native_corpus/v1/sources/hermes/0.20.6/portable-rich/expected-ir.jsonl
deleted file mode 100644
index 74bf17d..0000000
--- a/tests/native_corpus/v1/sources/hermes/0.20.6/portable-rich/expected-ir.jsonl
+++ /dev/null
@@ -1,12 +0,0 @@
-{"kind":"message","provenance":{"block_index":null,"record_type":"hermes.message"},"role":"user","text":"We are testing a disposable timeline helper. Remember SM_CORPUS_7319, inspect timeline.py and CORPUS_NOTE.txt with the native file tool, explain the boundary bug briefly, and do not edit files.","timestamp_category":"present"}
-{"input":{"command":"cat timeline.py && cat CORPUS_NOTE.txt"},"kind":"tool_call","provenance":{"block_index":0,"record_type":"hermes.message.tool_call"},"role":"assistant","timestamp_category":"present","tool_call_id":"call_hermes_inspect","tool_name":"terminal"}
-{"content_blocks":[{"text":"from dataclasses import dataclass\n\n\n@dataclass(frozen=True)\nclass Event:\n    start_ms: int\n    end_ms: int\n\n\ndef touches(previous: Event, current: Event) -> bool:\n    \"\"\"Return whether two closed intervals overlap or touch.\"\"\"\n    return current.start_ms < previous.end_ms\nNative corpus file marker: COPPER_4821\n\nThis file belongs to a disposable session-migrate test workspace. It contains\nno credentials, user data, or repository source.","type":"text"}],"is_error":false,"kind":"tool_result","provenance":{"block_index":null,"record_type":"hermes.message"},"role":"tool","text":"from dataclasses import dataclass\n\n\n@dataclass(frozen=True)\nclass Event:\n    start_ms: int\n    end_ms: int\n\n\ndef touches(previous: Event, current: Event) -> bool:\n    \"\"\"Return whether two closed intervals overlap or touch.\"\"\"\n    return current.start_ms < previous.end_ms\nNative corpus file marker: COPPER_4821\n\nThis file belongs to a disposable session-migrate test workspace. It contains\nno credentials, user data, or repository source.","timestamp_category":"present","tool_call_id":"call_hermes_inspect","tool_name":"terminal"}
-{"kind":"message","provenance":{"block_index":null,"record_type":"hermes.message"},"role":"assistant","text":"The boundary check uses <, so exactly touching intervals do not merge. The native file marker is COPPER_4821.","timestamp_category":"present"}
-{"kind":"message","provenance":{"block_index":null,"record_type":"hermes.message"},"role":"user","text":"[The user attached an image but it couldn't be analyzed. You can try examining it with vision_analyze using image_url: /fixture/work/corpus-card.png]\n\nInspect the attached medium and report its visible marker.","timestamp_category":"present"}
-{"kind":"message","provenance":{"block_index":null,"record_type":"hermes.message"},"role":"assistant","text":"The accepted image is a blue triangle labeled BLUE_TRIANGLE_7319.","timestamp_category":"present"}
-{"kind":"message","provenance":{"block_index":null,"record_type":"hermes.message"},"role":"user","text":"Use the native file tool to read missing-corpus-file.txt, report the failure, then continue without creating it.","timestamp_category":"present"}
-{"input":{"command":"cat missing-corpus-file.txt"},"kind":"tool_call","provenance":{"block_index":0,"record_type":"hermes.message.tool_call"},"role":"assistant","timestamp_category":"present","tool_call_id":"call_hermes_missing","tool_name":"terminal"}
-{"content_blocks":[{"text":"cat: missing-corpus-file.txt: No such file or directory","type":"text"}],"is_error":true,"kind":"tool_result","provenance":{"block_index":null,"record_type":"hermes.message"},"role":"tool","text":"cat: missing-corpus-file.txt: No such file or directory","timestamp_category":"present","tool_call_id":"call_hermes_missing","tool_name":"terminal"}
-{"kind":"message","provenance":{"block_index":null,"record_type":"hermes.message"},"role":"assistant","text":"SM_NATIVE_FAILURE_7319: missing-corpus-file.txt was absent; continuing.","timestamp_category":"present"}
-{"kind":"message","provenance":{"block_index":null,"record_type":"hermes.message"},"role":"user","text":"Without tools, recall the conversation, file, image, and document nonces that were actually available in this session.","timestamp_category":"present"}
-{"kind":"message","provenance":{"block_index":null,"record_type":"hermes.message"},"role":"assistant","text":"Recall: SM_CORPUS_7319, COPPER_4821, and BLUE_TRIANGLE_7319.","timestamp_category":"present"}
diff --git a/tests/native_corpus/v1/sources/hermes/0.22.2/portable-rich/expected-ir.jsonl b/tests/native_corpus/v1/sources/hermes/0.22.2/portable-rich/expected-ir.jsonl
new file mode 100644
index 0000000..712a017
--- /dev/null
+++ b/tests/native_corpus/v1/sources/hermes/0.22.2/portable-rich/expected-ir.jsonl
@@ -0,0 +1,12 @@
+{"kind": "message", "provenance": {"block_index": null, "record_type": "hermes.message"}, "role": "user", "text": "We are testing a disposable timeline helper. Remember SM_CORPUS_7319, inspect timeline.py and CORPUS_NOTE.txt with the native file tool, explain the boundary bug briefly, and do not edit files.", "timestamp_category": "present"}
+{"input": {"command": "cat timeline.py && cat CORPUS_NOTE.txt"}, "kind": "tool_call", "provenance": {"block_index": 0, "record_type": "hermes.message.tool_call"}, "role": "assistant", "timestamp_category": "present", "tool_call_id": "call_hermes_inspect", "tool_name": "terminal"}
+{"content_blocks": [{"text": "from dataclasses import dataclass\n\n\n@dataclass(frozen=True)\nclass Event:\n    start_ms: int\n    end_ms: int\n\n\ndef touches(previous: Event, current: Event) -> bool:\n    \"\"\"Return whether two closed intervals overlap or touch.\"\"\"\n    return current.start_ms < previous.end_ms\nNative corpus file marker: COPPER_4821\n\nThis file belongs to a disposable session-migrate test workspace. It contains\nno credentials, user data, or repository source.", "type": "text"}], "is_error": false, "kind": "tool_result", "provenance": {"block_index": null, "record_type": "hermes.message"}, "role": "tool", "text": "from dataclasses import dataclass\n\n\n@dataclass(frozen=True)\nclass Event:\n    start_ms: int\n    end_ms: int\n\n\ndef touches(previous: Event, current: Event) -> bool:\n    \"\"\"Return whether two closed intervals overlap or touch.\"\"\"\n    return current.start_ms < previous.end_ms\nNative corpus file marker: COPPER_4821\n\nThis file belongs to a disposable session-migrate test workspace. It contains\nno credentials, user data, or repository source.", "timestamp_category": "present", "tool_call_id": "call_hermes_inspect", "tool_name": "terminal"}
+{"kind": "message", "provenance": {"block_index": null, "record_type": "hermes.message"}, "role": "assistant", "text": "The boundary check uses <, so exactly touching intervals do not merge. The native file marker is COPPER_4821.", "timestamp_category": "present"}
+{"kind": "message", "provenance": {"block_index": null, "record_type": "hermes.message"}, "role": "user", "text": "[The user attached an image but it couldn't be analyzed. You can try examining it with vision_analyze using image_url: /fixture/work/corpus-card.png]\n\nInspect the attached medium and report its visible marker.", "timestamp_category": "present"}
+{"kind": "message", "provenance": {"block_index": null, "record_type": "hermes.message"}, "role": "assistant", "text": "The accepted image is a blue triangle labeled BLUE_TRIANGLE_7319.", "timestamp_category": "present"}
+{"kind": "message", "provenance": {"block_index": null, "record_type": "hermes.message"}, "role": "user", "text": "Use the native file tool to read missing-corpus-file.txt, report the failure, then continue without creating it.", "timestamp_category": "present"}
+{"input": {"command": "cat missing-corpus-file.txt"}, "kind": "tool_call", "provenance": {"block_index": 0, "record_type": "hermes.message.tool_call"}, "role": "assistant", "timestamp_category": "present", "tool_call_id": "call_hermes_missing", "tool_name": "terminal"}
+{"content_blocks": [{"text": "cat: missing-corpus-file.txt: No such file or directory", "type": "text"}], "is_error": true, "kind": "tool_result", "provenance": {"block_index": null, "record_type": "hermes.message"}, "role": "tool", "text": "cat: missing-corpus-file.txt: No such file or directory", "timestamp_category": "present", "tool_call_id": "call_hermes_missing", "tool_name": "terminal"}
+{"kind": "message", "provenance": {"block_index": null, "record_type": "hermes.message"}, "role": "assistant", "text": "SM_NATIVE_FAILURE_7319: missing-corpus-file.txt was absent; continuing.", "timestamp_category": "present"}
+{"kind": "message", "provenance": {"block_index": null, "record_type": "hermes.message"}, "role": "user", "text": "Without tools, recall the conversation, file, image, and document nonces that were actually available in this session.", "timestamp_category": "present"}
+{"kind": "message", "provenance": {"block_index": null, "record_type": "hermes.message"}, "role": "assistant", "text": "Recall: SM_CORPUS_7319, COPPER_4821, and BLUE_TRIANGLE_7319.", "timestamp_category": "present"}
diff --git a/tests/native_corpus/v1/sources/hermes/0.20.6/portable-rich/native/state.db b/tests/native_corpus/v1/sources/hermes/0.22.2/portable-rich/native/state.db
similarity index 75%
rename from tests/native_corpus/v1/sources/hermes/0.20.6/portable-rich/native/state.db
rename to tests/native_corpus/v1/sources/hermes/0.22.2/portable-rich/native/state.db
index a2bc890..0d1be88 100644
Binary files a/tests/native_corpus/v1/sources/hermes/0.20.6/portable-rich/native/state.db and b/tests/native_corpus/v1/sources/hermes/0.22.2/portable-rich/native/state.db differ
diff --git a/tests/native_corpus/v1/sources/hermes/0.20.6/portable-rich/provenance.json b/tests/native_corpus/v1/sources/hermes/0.22.2/portable-rich/provenance.json
similarity index 75%
rename from tests/native_corpus/v1/sources/hermes/0.20.6/portable-rich/provenance.json
rename to tests/native_corpus/v1/sources/hermes/0.22.2/portable-rich/provenance.json
index ef210bb..53e2767 100644
--- a/tests/native_corpus/v1/sources/hermes/0.20.6/portable-rich/provenance.json
+++ b/tests/native_corpus/v1/sources/hermes/0.22.2/portable-rich/provenance.json
@@ -1,19 +1,19 @@
 {
   "schema_version": 1,
-  "fixture_id": "hermes-0.20.6-portable-rich",
+  "fixture_id": "hermes-0.22.2-portable-rich",
   "format": "hermes",
   "case": "portable-rich",
-  "native_session_id": "20260831_195650_1783a3",
+  "native_session_id": "20261016_232030_e61bcd",
   "native_title": "repair-event-window-boundary",
   "native_cwd": "/fixture/work",
   "producer": {
     "name": "Hermes Agent",
-    "version": "0.20.6",
-    "package_or_tag": "v2026.8.27",
-    "source_commit": "5fc308a70719a83cccdbba4c0e39c23f5a8239d5",
+    "version": "0.22.2",
+    "package_or_tag": "v0.22.2",
+    "source_commit": "d923a5eb487a17c0a68801bba9ef0f56c81040a8",
     "platform": "linux-x86_64",
-    "binary_sha256": "060277e4ac1caa59ea6e0c551c7627f8fea0989a4aace9f73cdc1f09425f34c2",
-    "binary_size": 339
+    "binary_sha256": "d2c74d2575bc2cbfd9ddbb7b1d3d110cc68c1897e8dbf4882260d856b26cf104",
+    "binary_size": 341
   },
   "capture": {
     "created_by_exact_cli": true,
@@ -21,15 +21,15 @@
     "scenario_version": 1,
     "provider_kind": "loopback",
     "model_alias": "loopback/fixture-model",
-    "captured_at": "2026-08-31T23:56:50.214Z",
-    "raw_private_sha256": "b8972230461d0ee16157c76bdf396b16e4790f4665669058b53b5f1985d2917a"
+    "captured_at": "2026-10-17T02:20:47.056Z",
+    "raw_private_sha256": "67a441604dc92163835212e2de9cf61f63a2b28010eebdd4d05bc31802919d54"
   },
   "artifacts": [
     {
       "path": "native/state.db",
       "media_type": "application/vnd.sqlite3",
-      "size": 233472,
-      "sha256": "a69f874435820bbbcb7b1fcd4dbe188e326da4781dc06eaeda600f2162271bdf",
+      "size": 282624,
+      "sha256": "d58ca150d627941f2564fab7aca1ee7c445b08dfe86eb0ef7046d64ba892942a",
       "mode": "0600",
       "role": "transcript"
     }
@@ -105,7 +105,7 @@
   "sanitization": {
     "required": true,
     "sanitizer": "scripts/native-corpus/sanitize-hermes.py",
-    "sanitizer_git_sha": "f1aea85097a7a2bf163875c3c51d1e48fc7d2da1",
+    "sanitizer_git_sha": "de7f5c1549118436cb2c74f1770c73a97a2ccf11",
     "mutations": [
       {
         "selector": "message path",
@@ -117,6 +117,11 @@
         "category": "path",
         "count": 1
       },
+      {
+        "selector": "session profile_name",
+        "category": "text",
+        "count": 1
+      },
       {
         "selector": "session system_prompt",
         "category": "text",
@@ -126,18 +131,23 @@
         "selector": "session system_prompt_hash",
         "category": "text",
         "count": 1
+      },
+      {
+        "selector": "session tool_names",
+        "category": "text",
+        "count": 1
       }
     ],
     "secret_scan": "pass",
     "content_review": "pass",
-    "sanitized_artifact_set_sha256": "3383052e838f767093cbcf11ec4cdb9eef555e154e46d7f9d09c65538f3731e5",
+    "sanitized_artifact_set_sha256": "5a1f160f7bf1092b55666817fd34c2309a0af73fedba389ae24872b052643b3d",
     "reloaded_by_exact_cli": true,
-    "reloaded_version": "0.20.6",
-    "reloaded_binary_sha256": "060277e4ac1caa59ea6e0c551c7627f8fea0989a4aace9f73cdc1f09425f34c2"
+    "reloaded_version": "0.22.2",
+    "reloaded_binary_sha256": "d2c74d2575bc2cbfd9ddbb7b1d3d110cc68c1897e8dbf4882260d856b26cf104"
   },
   "expectations": {
     "ir": "expected-ir.jsonl",
-    "ir_sha256": "f5946e883a78571c32bfcd6d5bbbcdd9b9cdab6427255e0b1ba9dbda6f2f4f19",
+    "ir_sha256": "e7fc94e0ac3a95c8a58e491de47013b4467cf6b725acbd2ee42c38dc803672e2",
     "event_counts": {
       "message": 8,
       "tool_call": 2,
diff --git a/tests/test_antigravity_desktop_format.py b/tests/test_antigravity_desktop_format.py
new file mode 100644
index 0000000..8877c5e
--- /dev/null
+++ b/tests/test_antigravity_desktop_format.py
@@ -0,0 +1,440 @@
+import json
+import sqlite3
+from pathlib import Path
+
+import pytest
+
+from session_migrate.errors import SessionMigrateError
+from session_migrate.formats import antigravity, antigravity_desktop
+from session_migrate.model import AgentFormat, Event, EventKind, Provenance, Role, Session
+
+TARGET_ID = "33333333-3333-4333-8333-333333333333"
+TRAJECTORY_ID = "44444444-4444-4444-8444-444444444444"
+
+
+def portable_session(tmp_path: Path) -> Session:
+    events = (
+        Event(
+            kind=EventKind.MESSAGE,
+            role=Role.USER,
+            text="AGY_DESKTOP_USER_ALPHA",
+            timestamp="2026-08-20T12:00:00Z",
+            provenance=Provenance(0, "user"),
+        ),
+        Event(
+            kind=EventKind.MESSAGE,
+            role=Role.ASSISTANT,
+            text="AGY_DESKTOP_ASSISTANT_OMEGA",
+            timestamp="2026-08-20T12:00:01Z",
+            provenance=Provenance(1, "assistant"),
+        ),
+        Event(
+            kind=EventKind.TOOL_CALL,
+            role=Role.ASSISTANT,
+            tool_name="echo_marker",
+            tool_call_id="agy-call-1",
+            timestamp="2026-08-20T12:00:02Z",
+            payload={"input": {"text": "DESKTOP_INPUT_ALPHA", "count": 2}},
+            provenance=Provenance(2, "tool_call"),
+        ),
+        Event(
+            kind=EventKind.TOOL_RESULT,
+            role=Role.TOOL,
+            text="DESKTOP_RESULT_OMEGA",
+            tool_name="echo_marker",
+            tool_call_id="agy-call-1",
+            timestamp="2026-08-20T12:00:03Z",
+            payload={
+                "is_error": False,
+                "content_blocks": [{"type": "text", "text": "DESKTOP_RESULT_OMEGA"}],
+            },
+            provenance=Provenance(3, "tool_result"),
+        ),
+        Event(
+            kind=EventKind.THINKING,
+            role=Role.ASSISTANT,
+            text="PRIVATE_THINKING_MUST_NOT_SURVIVE",
+            provenance=Provenance(4, "thinking"),
+        ),
+    )
+    return Session(
+        source_format=AgentFormat.CLAUDE,
+        source_path=tmp_path / "source.jsonl",
+        source_sha256="0" * 64,
+        session_id="11111111-1111-4111-8111-111111111111",
+        cwd=tmp_path,
+        started_at="2026-08-20T12:00:00Z",
+        cli_version="2.1.209",
+        model="fixture-model",
+        title="Antigravity Desktop fixture",
+        events=events,
+        raw_record_count=len(events),
+    )
+
+
+def event_signature(events: tuple[Event, ...]) -> list[tuple[object, ...]]:
+    result = []
+    for event in events:
+        if event.kind == EventKind.THINKING:
+            continue
+        payload = event.payload.get("input") if event.kind == EventKind.TOOL_CALL else None
+        result.append(
+            (
+                event.kind,
+                event.role,
+                event.text,
+                event.tool_name,
+                event.tool_call_id,
+                json.dumps(payload, sort_keys=True),
+            )
+        )
+    return result
+
+
+def test_desktop_round_trip_preserves_messages_and_tools(tmp_path: Path) -> None:
+    source = portable_session(tmp_path)
+    data, dropped = antigravity_desktop.serialize(
+        source,
+        session_id=TARGET_ID,
+        trajectory_id=TRAJECTORY_ID,
+        cwd=tmp_path,
+        timestamp="2026-08-20T12:00:00Z",
+    )
+    path = tmp_path / f"{TARGET_ID}.db"
+    path.write_bytes(data)
+
+    antigravity_desktop.validate_native_bytes(data, TARGET_ID)
+    parsed = antigravity_desktop.parse(path)
+
+    assert dropped == {"thinking:private": 1}
+    assert b"PRIVATE_THINKING_MUST_NOT_SURVIVE" not in data
+    assert antigravity_desktop.native_record_count(data) == 4
+    assert event_signature(parsed.events) == event_signature(source.events)
+
+    # Verify Desktop wire differences
+    with sqlite3.connect(path) as conn:
+        meta = conn.execute(
+            "SELECT trajectory_id, cascade_id, trajectory_type, source FROM trajectory_meta"
+        ).fetchone()
+        assert meta == (TRAJECTORY_ID, TARGET_ID, 4, 1)  # Desktop source is 1, not 17!
+
+
+def test_desktop_parse_session_attributes(tmp_path: Path) -> None:
+    source = portable_session(tmp_path)
+    data, _ = antigravity_desktop.serialize(
+        source,
+        session_id=TARGET_ID,
+        trajectory_id=TRAJECTORY_ID,
+        cwd=tmp_path,
+    )
+    path = tmp_path / f"{TARGET_ID}.db"
+    path.write_bytes(data)
+
+    session = antigravity_desktop.parse_session(path)
+    assert session.source_format == AgentFormat.ANTIGRAVITY_DESKTOP
+    assert session.session_id == TARGET_ID
+    assert session.model_provider == "google"
+    assert session.cli_version == antigravity_desktop.PINNED_ANTIGRAVITY_DESKTOP_VERSION
+    assert len(session.events) == 4
+
+
+def test_desktop_installation_updates_summary_database(tmp_path: Path) -> None:
+    source = portable_session(tmp_path)
+    data, _ = antigravity_desktop.serialize(
+        source,
+        session_id=TARGET_ID,
+        trajectory_id=TRAJECTORY_ID,
+        cwd=tmp_path,
+        timestamp="2026-08-20T12:00:00Z",
+    )
+    target_home = tmp_path / "antigravity"
+
+    # Dry run check
+    installed_dry = antigravity_desktop.install_database(
+        data,
+        session_id=TARGET_ID,
+        cwd=tmp_path,
+        timestamp="2026-08-20T12:00:00Z",
+        title="Test Desktop Session",
+        target_home=target_home,
+        dry_run=True,
+    )
+    assert not installed_dry.conversation_path.exists()
+    assert not installed_dry.summaries_path.exists()
+
+    # Actual installation
+    installed = antigravity_desktop.install_database(
+        data,
+        session_id=TARGET_ID,
+        cwd=tmp_path,
+        timestamp="2026-08-20T12:00:00Z",
+        title="Test Desktop Session",
+        target_home=target_home,
+        dry_run=False,
+    )
+    assert installed.conversation_path.is_file()
+    assert installed.summaries_path.is_file()
+
+    # Verify summary columns
+    with sqlite3.connect(installed.summaries_path) as conn:
+        row = conn.execute(
+            "SELECT conversation_id, title, status, source, project_id, app_data_dir "
+            "FROM conversation_summaries WHERE conversation_id = ?",
+            (TARGET_ID,),
+        ).fetchone()
+        assert row == (
+            TARGET_ID,
+            "Test Desktop Session",
+            "CASCADE_RUN_STATUS_IDLE",
+            "",
+            "outside-of-project",
+            "antigravity",
+        )
+
+    # Re-installation collision check
+    with pytest.raises(SessionMigrateError, match="already exists"):
+        antigravity_desktop.install_database(
+            data,
+            session_id=TARGET_ID,
+            cwd=tmp_path,
+            timestamp="2026-08-20T12:00:00Z",
+            title="Duplicate",
+            target_home=target_home,
+            dry_run=False,
+        )
+
+
+def test_desktop_and_cli_databases_do_not_falsely_detect_each_other(tmp_path: Path) -> None:
+    source = portable_session(tmp_path)
+    cli_data, _ = antigravity.serialize(
+        source,
+        session_id=TARGET_ID,
+        trajectory_id=TRAJECTORY_ID,
+        cwd=tmp_path,
+    )
+    desktop_data, _ = antigravity_desktop.serialize(
+        source,
+        session_id=TARGET_ID,
+        trajectory_id=TRAJECTORY_ID,
+        cwd=tmp_path,
+    )
+
+    cli_path = tmp_path / "cli.db"
+    desktop_path = tmp_path / "desktop.db"
+    cli_path.write_bytes(cli_data)
+    desktop_path.write_bytes(desktop_data)
+
+    # CLI parser rejects desktop DB
+    with pytest.raises(SessionMigrateError, match="CLI cascade trajectory"):
+        antigravity.parse(desktop_path)
+
+    # Desktop parser rejects CLI DB
+    with pytest.raises(SessionMigrateError, match="Desktop cascade trajectory"):
+        antigravity_desktop.parse(cli_path)
+
+
+def test_desktop_handles_cleared_step(tmp_path: Path) -> None:
+    # A compacted conversation can contain step status 5 (CLEARED) with minimal payload
+    data, _ = antigravity_desktop.serialize(
+        portable_session(tmp_path),
+        session_id=TARGET_ID,
+        trajectory_id=TRAJECTORY_ID,
+        cwd=tmp_path,
+    )
+    path = tmp_path / f"{TARGET_ID}.db"
+    path.write_bytes(data)
+
+    # Inject a CLEARED step
+    with sqlite3.connect(path) as conn:
+        cleared_payload = antigravity._field_varint(
+            1, antigravity.STEP_TYPE_PLANNER_RESPONSE
+        ) + antigravity._field_varint(4, 5)
+        conn.execute(
+            "INSERT INTO steps(idx, step_type, status, has_subtrajectory, metadata, "
+            "step_payload, step_format) VALUES(?, ?, 5, 0, NULL, ?, 0)",
+            (4, antigravity.STEP_TYPE_PLANNER_RESPONSE, cleared_payload),
+        )
+
+    parsed = antigravity_desktop.parse(path)
+    assert any(
+        event.kind == EventKind.OPAQUE and event.payload.get("reason") == "antigravity_cleared_step"
+        for event in parsed.events
+    )
+
+
+def test_format_detection_identifies_desktop(tmp_path: Path) -> None:
+    from session_migrate.inspection import detect_path_format
+
+    data, _ = antigravity_desktop.serialize(
+        portable_session(tmp_path),
+        session_id=TARGET_ID,
+        trajectory_id=TRAJECTORY_ID,
+        cwd=tmp_path,
+    )
+    path = tmp_path / f"{TARGET_ID}.db"
+    path.write_bytes(data)
+
+    detected = detect_path_format(path)
+    assert detected == AgentFormat.ANTIGRAVITY_DESKTOP
+
+
+def test_conversion_pipeline_cli_to_desktop_and_back(tmp_path: Path) -> None:
+    from session_migrate.conversion import (
+        ConversionOptions,
+        convert_session,
+        install_antigravity_desktop_artifact,
+        load_session,
+    )
+    from session_migrate.model import TargetFormat
+
+    # 1. Start with a CLI session
+    cli_data, _ = antigravity.serialize(
+        portable_session(tmp_path),
+        session_id=TARGET_ID,
+        trajectory_id=TRAJECTORY_ID,
+        cwd=tmp_path,
+        timestamp="2026-08-20T12:00:00Z",
+    )
+    cli_path = tmp_path / f"{TARGET_ID}.db"
+    cli_path.write_bytes(cli_data)
+    loaded_cli = load_session(cli_path)
+    assert loaded_cli.source_format == AgentFormat.ANTIGRAVITY
+
+    # 2. Convert CLI -> Desktop
+    desktop_id = "55555555-5555-4555-8555-555555555555"
+    artifact = convert_session(
+        loaded_cli,
+        ConversionOptions(
+            target_format=TargetFormat.ANTIGRAVITY_DESKTOP,
+            session_id=desktop_id,
+            cwd=tmp_path,
+        ),
+    )
+    assert artifact.target_format == TargetFormat.ANTIGRAVITY_DESKTOP
+    desktop_home = tmp_path / "dest_desktop"
+    native_path, manifest_path = install_antigravity_desktop_artifact(
+        artifact,
+        target_home=desktop_home,
+    )
+    assert native_path.is_file()
+    assert manifest_path.is_file()
+
+    # 3. Load Desktop -> Convert back to CLI
+    loaded_desktop = load_session(native_path)
+    assert loaded_desktop.source_format == AgentFormat.ANTIGRAVITY_DESKTOP
+    assert loaded_desktop.session_id == desktop_id
+
+    cli_dest_id = "66666666-6666-4666-8666-666666666666"
+    cli_artifact = convert_session(
+        loaded_desktop,
+        ConversionOptions(
+            target_format=TargetFormat.ANTIGRAVITY,
+            session_id=cli_dest_id,
+            cwd=tmp_path,
+        ),
+    )
+    assert cli_artifact.target_format == TargetFormat.ANTIGRAVITY
+    assert cli_artifact.native_record_count == artifact.native_record_count
+
+
+def test_default_language_server_path_platform_matrix(tmp_path: Path) -> None:
+    # 1. Environment override
+    custom_bin = tmp_path / "custom_server"
+    resolved = antigravity_desktop.default_language_server_path(
+        platform="darwin",
+        environ={"SESSION_MIGRATE_ANTIGRAVITY_DESKTOP_BIN": str(custom_bin)},
+    )
+    assert resolved == custom_bin
+
+    # 2. Darwin default
+    resolved_mac = antigravity_desktop.default_language_server_path(
+        platform="darwin",
+        environ={},
+    )
+    assert resolved_mac == antigravity_desktop.DEFAULT_MACOS_LANGUAGE_SERVER_PATH
+
+    # 3. Linux default
+    resolved_linux = antigravity_desktop.default_language_server_path(
+        platform="linux",
+        environ={},
+    )
+    assert resolved_linux == antigravity_desktop.DEFAULT_LINUX_LANGUAGE_SERVER_PATH
+
+    # 4. Windows default with LOCALAPPDATA
+    resolved_win = antigravity_desktop.default_language_server_path(
+        platform="win32",
+        environ={"LOCALAPPDATA": "C:\\Users\\tester\\AppData\\Local"},
+    )
+    assert "language_server.exe" in str(resolved_win)
+
+
+def test_electron_user_data_dir_platform_matrix(tmp_path: Path) -> None:
+    fake_home = tmp_path / "fakehome"
+
+    # Darwin
+    mac_dir = antigravity_desktop.electron_user_data_dir(
+        platform="darwin",
+        home=fake_home,
+    )
+    assert mac_dir == fake_home / "Library" / "Application Support" / "Antigravity"
+
+    # Windows with APPDATA
+    win_dir = antigravity_desktop.electron_user_data_dir(
+        platform="win32",
+        environ={"APPDATA": "C:\\Users\\tester\\AppData\\Roaming"},
+        home=fake_home,
+    )
+    assert win_dir == Path("C:\\Users\\tester\\AppData\\Roaming") / "Antigravity"
+
+    # Windows fallback
+    win_fallback = antigravity_desktop.electron_user_data_dir(
+        platform="win32",
+        environ={},
+        home=fake_home,
+    )
+    assert win_fallback == fake_home / "AppData" / "Roaming" / "Antigravity"
+
+    # Linux with XDG_CONFIG_HOME
+    linux_xdg = antigravity_desktop.electron_user_data_dir(
+        platform="linux",
+        environ={"XDG_CONFIG_HOME": "/tmp/custom_config"},
+        home=fake_home,
+    )
+    assert linux_xdg == Path("/tmp/custom_config/Antigravity")
+
+    # Linux default fallback
+    linux_fallback = antigravity_desktop.electron_user_data_dir(
+        platform="linux",
+        environ={},
+        home=fake_home,
+    )
+    assert linux_fallback == fake_home / ".config" / "Antigravity"
+
+
+def test_verify_pinned_desktop_platform_guards(tmp_path: Path) -> None:
+    fake_bin = tmp_path / "language_server"
+    fake_bin.write_bytes(b"x" * antigravity_desktop.PINNED_ANTIGRAVITY_DESKTOP_MACOS_ARM64_SIZE)
+
+    # Size mismatch on Linux because fake_bin has macOS size
+    with pytest.raises(SessionMigrateError, match="binary size mismatch on linux"):
+        antigravity_desktop.verify_pinned_desktop(
+            fake_bin,
+            platform="linux",
+            environ={},
+        )
+
+    # Unsupported platform raises clear message
+    with pytest.raises(SessionMigrateError, match="not supported on freebsd"):
+        antigravity_desktop.verify_pinned_desktop(
+            fake_bin,
+            platform="freebsd",
+            environ={},
+        )
+
+    # With SESSION_MIGRATE_UNVALIDATED_DESKTOP_BIN=1, it should accept the path
+    bypassed = antigravity_desktop.verify_pinned_desktop(
+        fake_bin,
+        platform="linux",
+        environ={"SESSION_MIGRATE_UNVALIDATED_DESKTOP_BIN": "1"},
+    )
+    assert bypassed == fake_bin.resolve()
diff --git a/tests/test_antigravity_desktop_native.py b/tests/test_antigravity_desktop_native.py
new file mode 100644
index 0000000..5df9cb9
--- /dev/null
+++ b/tests/test_antigravity_desktop_native.py
@@ -0,0 +1,190 @@
+import json
+import os
+import ssl
+import subprocess
+import time
+import urllib.request
+from pathlib import Path
+
+import pytest
+
+from session_migrate.formats import antigravity_desktop
+from session_migrate.model import AgentFormat, Event, EventKind, Provenance, Role, Session
+
+TARGET_ID = "88888888-9999-4aaa-8bbb-cccccccccccc"
+TRAJECTORY_ID = "dddddddd-eeee-4fff-8000-111111111111"
+
+
+def exact_desktop_binary() -> Path:
+    import sys
+
+    if sys.platform != "darwin":
+        pytest.skip(
+            "Antigravity Desktop native language server test is currently pinned and verified "
+            "for macOS; Linux and Windows binary verification is pending"
+        )
+    binary = antigravity_desktop.default_language_server_path()
+    if not binary.is_file():
+        pytest.skip("Antigravity Desktop language_server is not installed on this machine")
+    try:
+        return antigravity_desktop.verify_pinned_desktop(binary)
+    except Exception as exc:
+        pytest.skip(f"Antigravity Desktop binary verification failed: {exc}")
+
+
+def test_native_desktop_language_server_loads_adapter_database(tmp_path: Path) -> None:
+    tmp_path = tmp_path.resolve()
+    binary = exact_desktop_binary()
+
+    # Create a portable test session
+    events = (
+        Event(
+            kind=EventKind.MESSAGE,
+            role=Role.USER,
+            text="Hello Antigravity Desktop from session-migrate",
+            timestamp="2026-09-28T12:00:00Z",
+            provenance=Provenance(0, "user"),
+        ),
+        Event(
+            kind=EventKind.MESSAGE,
+            role=Role.ASSISTANT,
+            text="Hello! Native desktop language server validation passed.",
+            timestamp="2026-09-28T12:00:01Z",
+            provenance=Provenance(1, "assistant"),
+        ),
+    )
+    session = Session(
+        source_format=AgentFormat.ANTIGRAVITY_DESKTOP,
+        source_path=tmp_path / "source.db",
+        source_sha256="0" * 64,
+        session_id=TARGET_ID,
+        cwd=tmp_path,
+        started_at="2026-09-28T12:00:00Z",
+        cli_version=antigravity_desktop.PINNED_ANTIGRAVITY_DESKTOP_VERSION,
+        model="gemini-2.5-pro",
+        title="Native Integration Test",
+        events=events,
+        raw_record_count=len(events),
+    )
+
+    data, _ = antigravity_desktop.serialize(
+        session,
+        session_id=TARGET_ID,
+        trajectory_id=TRAJECTORY_ID,
+        cwd=tmp_path,
+        timestamp="2026-09-28T12:00:00Z",
+    )
+
+    gemini_dir = tmp_path / ".gemini"
+    app_state = gemini_dir / "antigravity"
+    antigravity_desktop.install_database(
+        data,
+        session_id=TARGET_ID,
+        cwd=tmp_path,
+        timestamp="2026-09-28T12:00:00Z",
+        title="Native Integration Test",
+        target_home=app_state,
+        dry_run=False,
+    )
+
+    csrf_token = "01234567-89ab-cdef-0123-456789abcdef"
+
+    # Spawn language_server in the isolated directory
+    cmd = [
+        str(binary),
+        "--standalone",
+        "--override_ide_name",
+        "antigravity",
+        "--subclient_type",
+        "hub",
+        "--override_ide_version",
+        "2.18.1",
+        "--override_user_agent_name",
+        "antigravity",
+        "--https_server_port",
+        "0",
+        "--csrf_token",
+        csrf_token,
+        "-gemini_dir",
+        str(gemini_dir),
+        "-app_data_dir",
+        "antigravity",
+    ]
+    env = dict(os.environ)
+    env["HOME"] = str(tmp_path)
+
+    proc = subprocess.Popen(
+        cmd,
+        cwd=str(app_state),
+        env=env,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+    )
+    assert proc.stdin is not None
+    proc.stdin.close()
+
+    port = None
+    try:
+        import re
+
+        for _ in range(50):
+            line = proc.stdout.readline()
+            if not line:
+                break
+            m = re.search(r"listening on \w+ port at (\d+) for HTTP", line, re.I)
+            if m:
+                port = int(m.group(1))
+                break
+
+        assert port is not None, "Failed to capture language_server port"
+
+        # Query Connect-RPC GetCascadeTrajectorySteps
+        url = f"https://127.0.0.1:{port}/exa.language_server_pb.LanguageServerService/GetCascadeTrajectorySteps"
+        ctx = ssl.create_default_context()
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+
+        req_body = json.dumps({"cascadeId": TARGET_ID}).encode()
+        req = urllib.request.Request(
+            url,
+            data=req_body,
+            headers={
+                "Content-Type": "application/json",
+                "X-Codeium-Csrf-Token": csrf_token,
+            },
+            method="POST",
+        )
+
+        res = None
+        for _attempt in range(30):
+            try:
+                with urllib.request.urlopen(req, context=ctx, timeout=5) as resp:
+                    if resp.status == 200:
+                        data = json.loads(resp.read().decode())
+                        s = data.get("steps", [])
+                        if len(s) == 2 and "userInput" in s[0] and "plannerResponse" in s[1]:
+                            res = data
+                            break
+            except (urllib.error.HTTPError, urllib.error.URLError):
+                pass
+            time.sleep(0.2)
+
+        assert res is not None, "Failed to get response from language server"
+        assert "steps" in res
+        steps = res["steps"]
+        assert len(steps) == 2
+        # Step 0 is user input
+        assert steps[0].get("type") == "CORTEX_STEP_TYPE_USER_INPUT"
+        assert steps[0].get("status") == "CORTEX_STEP_STATUS_DONE"
+        # Step 1 is planner response
+        assert steps[1].get("type") == "CORTEX_STEP_TYPE_PLANNER_RESPONSE"
+        assert steps[1].get("status") == "CORTEX_STEP_STATUS_DONE"
+
+    finally:
+        proc.terminate()
+        try:
+            proc.wait(timeout=3)
+        except subprocess.TimeoutExpired:
+            proc.kill()
diff --git a/tests/test_antigravity_format.py b/tests/test_antigravity_format.py
index d7cf217..7e9538d 100644
--- a/tests/test_antigravity_format.py
+++ b/tests/test_antigravity_format.py
@@ -315,8 +315,9 @@ def test_install_is_private_transactional_and_collision_safe(
         title="Installed fixture",
         target_home=target_home,
     )
-    assert stat.S_IMODE(installed.conversation_path.stat().st_mode) == 0o600
-    assert stat.S_IMODE(installed.summaries_path.stat().st_mode) == 0o600
+    expected_mode = 0o666 if os.name == "nt" else 0o600
+    assert stat.S_IMODE(installed.conversation_path.stat().st_mode) == expected_mode
+    assert stat.S_IMODE(installed.summaries_path.stat().st_mode) == expected_mode
     parsed = antigravity.parse(installed.conversation_path)
     assert parsed.session_id == TARGET_ID
     assert parsed.title == "Installed fixture"
diff --git a/tests/test_catalog.py b/tests/test_catalog.py
index 03d019d..f5df452 100644
--- a/tests/test_catalog.py
+++ b/tests/test_catalog.py
@@ -621,6 +621,74 @@ def test_opencode_inventory_is_complete_virtual_private_and_incremental(
         assert b"forbidden OpenCode transcript marker" not in raw_catalog
 
 
+@pytest.mark.parametrize("legacy", [False, True])
+def test_opencode_v2_inventory_supports_coexisting_schemas_and_nullable_title(
+    tmp_path: Path, legacy: bool
+) -> None:
+    home = tmp_path / "opencode-data"
+    home.mkdir()
+    if legacy:
+        connection = _opencode_database(home)
+        _insert_opencode_session(connection, OPENCODE_ID, "Legacy duplicate title")
+        _insert_opencode_session(connection, OPENCODE_ARCHIVED_ID, "Legacy only title")
+    else:
+        connection = sqlite3.connect(home / "opencode.db")
+    connection.executescript(
+        """
+        CREATE TABLE session_v2 (
+            id TEXT PRIMARY KEY, directory TEXT NOT NULL, title TEXT,
+            version TEXT NOT NULL, time_created INTEGER NOT NULL,
+            time_updated INTEGER NOT NULL, parent_id TEXT, time_archived INTEGER
+        );
+        CREATE TABLE session_message (id TEXT PRIMARY KEY, session_id TEXT, data TEXT);
+        """
+    )
+    connection.executemany(
+        "INSERT INTO session_v2 VALUES (?, '/synthetic/v2-work', ?, '2.0.22', ?, ?, ?, NULL)",
+        [
+            (OPENCODE_ID, "V2 authoritative title", 1_787_050_800_000, 1_787_054_400_000, None),
+            (OPENCODE_CHILD_ID, None, 1_787_050_800_000, 1_787_054_400_000, OPENCODE_ID),
+        ],
+    )
+    connection.execute(
+        "INSERT INTO session_message VALUES ('msg_private', ?, 'private v2 body marker')",
+        (OPENCODE_ID,),
+    )
+    connection.commit()
+    connection.close()
+    with _catalog(tmp_path) as catalog:
+        result = catalog.refresh(opencode_roots=(home,), include_auto=False)
+        assert result.root_errors == 0
+        assert result.files_seen == 2 + int(legacy)
+        assert result.statuses == {"candidate": 2 + int(legacy)}
+        assert catalog.list_sessions(query="Legacy duplicate") == []
+        entry = catalog.list_sessions(query="V2 authoritative", include_paths=True)[0]
+        assert entry.session_id == OPENCODE_ID
+        assert entry.cli_version == "2.0.22"
+        assert entry.cwd == "/synthetic/v2-work"
+        assert catalog.session_source_for_transfer(entry.catalog_id).session_id == OPENCODE_ID
+        untitled = catalog.list_sessions(query=OPENCODE_CHILD_ID)[0]
+        assert untitled.kind == "subagent"
+        assert catalog.refresh(include_auto=False).unchanged == 2 + int(legacy)
+        assert catalog.list_sessions(query="private v2 body") == []
+    assert (
+        b"private v2 body marker" not in (tmp_path / "private-state/catalog.sqlite3").read_bytes()
+    )
+
+
+def test_opencode_inventory_rejects_incomplete_v2_schema(tmp_path: Path) -> None:
+    home = tmp_path / "opencode-data"
+    connection = _opencode_database(home)
+    _insert_opencode_session(connection, OPENCODE_ID, "Valid legacy title")
+    connection.execute("CREATE TABLE session_v2 (id TEXT PRIMARY KEY)")
+    connection.commit()
+    connection.close()
+    with _catalog(tmp_path) as catalog:
+        result = catalog.refresh(opencode_roots=(home,), include_auto=False)
+        assert result.root_errors == 1
+        assert catalog.roots()[0].last_error == "opencode_schema_unsupported"
+
+
 def test_opencode_inventory_failures_retain_rows_and_reject_database_symlink(
     tmp_path: Path,
 ) -> None:
@@ -1349,3 +1417,96 @@ def changed(*_args: object, **_kwargs: object) -> None:
         assert catalog.list_sessions(include_missing=True, limit=10)
         assert all(entry.status != "missing" for entry in catalog.list_sessions(limit=10))
         assert catalog.roots()[0].id == root.id
+
+
+HERMES_ID = "20261016_120000_cafe01"
+
+
+def _hermes_store(home: Path) -> None:
+    """Create a schema-31 Hermes store holding one session with two messages."""
+
+    home.mkdir(parents=True, exist_ok=True)
+    database = sqlite3.connect(home / "state.db")
+    database.executescript(
+        """
+        CREATE TABLE schema_version (version INTEGER NOT NULL);
+        CREATE TABLE sessions (
+            id TEXT PRIMARY KEY, source TEXT, model TEXT, model_config TEXT,
+            parent_session_id TEXT, started_at REAL, ended_at REAL, end_reason TEXT,
+            message_count INTEGER, tool_call_count INTEGER, cwd TEXT,
+            billing_provider TEXT, title TEXT, title_source TEXT,
+            last_activity_at REAL, archived INTEGER, hidden INTEGER
+        );
+        CREATE TABLE messages (
+            id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT, role TEXT, content TEXT,
+            tool_call_id TEXT, tool_calls TEXT, tool_name TEXT, timestamp REAL,
+            finish_reason TEXT, reasoning TEXT, reasoning_content TEXT,
+            reasoning_details TEXT, observed INTEGER, _compressed_summary INTEGER,
+            active INTEGER, compacted INTEGER, api_content TEXT, display_kind TEXT,
+            display_metadata TEXT
+        );
+        """
+    )
+    database.execute("INSERT INTO schema_version VALUES (31)")
+    database.execute(
+        """
+        INSERT INTO sessions(id, source, started_at, message_count, cwd, title,
+                             last_activity_at, archived, hidden)
+        VALUES (?, 'cli', ?, 2, ?, 'Windows identity fixture', ?, 0, 0)
+        """,
+        (HERMES_ID, 1_792_200_000.0, str(home), 1_792_200_001.0),
+    )
+    for index, (role, content) in enumerate((("user", "alpha"), ("assistant", "beta"))):
+        database.execute(
+            "INSERT INTO messages(session_id, role, content, timestamp, active, compacted)"
+            " VALUES (?, ?, ?, ?, 1, 0)",
+            (HERMES_ID, role, content, 1_792_200_000.0 + index),
+        )
+    database.commit()
+    database.close()
+
+
+def test_hermes_catalog_accepts_unsigned_windows_stat_identity(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Windows reports ``st_dev`` as an unsigned 64-bit serial SQLite cannot bind.
+
+    The catalog previously raised ``OverflowError`` mid-scan, marking every
+    SQLite-backed root ``scan_failed``.  Identity is folded into the signed range
+    for storage and for refresh comparison, so a Windows root indexes and its
+    second refresh still reports the row as unchanged.
+    """
+
+    home = tmp_path / "hermes-home"
+    _hermes_store(home)
+    real_snapshot = catalog_module._sqlite_session_snapshot
+
+    def windows_snapshot(path: Path, format_name: str) -> catalog_module._VirtualSnapshot:
+        snapshot = real_snapshot(path, format_name)
+        return catalog_module._VirtualSnapshot(
+            snapshot.device | (1 << 63),
+            snapshot.inode,
+            snapshot.size,
+            snapshot.modified_ns,
+            snapshot.fingerprint,
+        )
+
+    monkeypatch.setattr(catalog_module, "_sqlite_session_snapshot", windows_snapshot)
+    unsigned_device = windows_snapshot(home / "state.db", "hermes").device
+    assert unsigned_device > (1 << 63) - 1
+    with _catalog(tmp_path) as catalog:
+        first = catalog.refresh(hermes_roots=(home,), include_auto=False)
+        assert first.root_errors == 0
+        assert first.statuses == {"candidate": 1}
+        entries = catalog.list_sessions(limit=10)
+        assert [entry.session_id for entry in entries] == [HERMES_ID]
+        assert entries[0].records == 2
+        assert entries[0].title == "Windows identity fixture"
+        stored_device = catalog._connection.execute(
+            "SELECT device FROM sessions WHERE format = 'hermes'"
+        ).fetchone()[0]
+        assert -(1 << 63) <= stored_device <= (1 << 63) - 1
+        assert stored_device & ((1 << 64) - 1) == unsigned_device
+
+        second = catalog.refresh(hermes_roots=(home,), include_auto=False)
+        assert second.unchanged == 1
diff --git a/tests/test_central_database_catalog.py b/tests/test_central_database_catalog.py
index 84921f5..3d04c7b 100644
--- a/tests/test_central_database_catalog.py
+++ b/tests/test_central_database_catalog.py
@@ -46,7 +46,7 @@ def _hermes_store(home: Path) -> Path:
                 active INTEGER DEFAULT 1, compacted INTEGER DEFAULT 0,
                 api_content TEXT, display_kind TEXT, display_metadata TEXT
             );
-            INSERT INTO schema_version VALUES (26);
+            INSERT INTO schema_version VALUES (31);
             """
         )
         for offset, (session_id, title) in enumerate(
diff --git a/tests/test_cli.py b/tests/test_cli.py
index 53852a2..9178b3e 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -12,7 +12,7 @@
 
 
 def test_parser_exposes_version() -> None:
-    assert __version__ == "0.11.0"
+    assert __version__ == "0.12.1"
     assert build_parser().prog == "session-migrate"
 
 
diff --git a/tests/test_conversion.py b/tests/test_conversion.py
index 03c81b6..b028ad9 100644
--- a/tests/test_conversion.py
+++ b/tests/test_conversion.py
@@ -276,6 +276,122 @@ def test_claude_compaction_logical_back_edge_terminates_cycle(tmp_path: Path) ->
     ]
 
 
+def test_claude_compaction_summary_inside_the_chain_terminates_the_loop(tmp_path: Path) -> None:
+    """The compact summary can sit several hops below the boundary.
+
+    Reproduced from a real 73 MB session with two compactions, one of them a
+    direct child of its boundary and the other four hops below it: attachments
+    the CLI interleaves (environment snapshots) sit between the two.  The
+    declaration is unchanged, and ``preservedMessages`` also names ids from the
+    summarized branch that are no longer on the active path.  Demanding that the
+    summary be the boundary's direct child, and that every declared id be walked,
+    refused the session as an "ancestry cycle" even though its graph is intact.
+    """
+
+    cwd = str(tmp_path)
+    summary = claude_record("user", "summary", "att-a", "summary text", cwd=cwd)
+    summary["isCompactSummary"] = True
+    path = write_jsonl(
+        tmp_path / "claude-compaction-nested-summary.jsonl",
+        [
+            {
+                "type": "system",
+                "subtype": "compact_boundary",
+                "uuid": "boundary",
+                "parentUuid": None,
+                "logicalParentUuid": "tail",
+                "sessionId": "11111111-1111-4111-8111-111111111111",
+                "timestamp": "2026-08-17T12:00:01Z",
+                "cwd": cwd,
+                "version": "2.1.300",
+                "compactMetadata": {
+                    "preservedSegment": {
+                        "anchorUuid": "summary",
+                        "headUuid": "summarized",
+                        "tailUuid": "tail",
+                    },
+                    "preservedMessages": {
+                        "uuids": ["summarized", "tail"],
+                        "allUuids": ["summarized", "tail"],
+                    },
+                },
+            },
+            {
+                "type": "attachment",
+                "uuid": "att-a",
+                "parentUuid": "boundary",
+                "isSidechain": False,
+                "sessionId": "11111111-1111-4111-8111-111111111111",
+                "timestamp": "2026-08-17T12:00:02Z",
+                "cwd": cwd,
+                "attachment": {"type": "environment", "snapshot": {"workingDirectory": cwd}},
+            },
+            summary,
+            claude_record("user", "tail", "summary", "tail text", cwd=cwd),
+            claude_record("assistant", "leaf", "tail", "leaf text", cwd=cwd),
+            # The declared head stays on the summarized branch the walk never enters.
+            claude_record("assistant", "summarized", None, "old turn", cwd=cwd),
+            {"type": "last-prompt", "leafUuid": "leaf"},
+        ],
+    )
+
+    session = claude.parse(path)
+
+    # The walk stops at the boundary instead of refusing, and the surviving
+    # timeline keeps the summary, the preserved tail, and the new turns.
+    assert session.event_counts() == {"compaction": 2, "message": 2, "opaque": 2}
+    assert [event.text for event in session.events if event.text] == [
+        "summary text",
+        "tail text",
+        "leaf text",
+    ]
+
+
+def test_claude_compaction_back_edge_without_a_closed_declaration_is_refused(
+    tmp_path: Path,
+) -> None:
+    """A boundary whose declaration does not close over the walk is still fatal."""
+
+    cwd = str(tmp_path)
+    summary = claude_record("user", "summary", "boundary", "summary text", cwd=cwd)
+    summary["isCompactSummary"] = True
+    path = write_jsonl(
+        tmp_path / "claude-compaction-unclosed.jsonl",
+        [
+            {
+                "type": "system",
+                "subtype": "compact_boundary",
+                "uuid": "boundary",
+                "parentUuid": None,
+                "logicalParentUuid": "tail",
+                "sessionId": "11111111-1111-4111-8111-111111111111",
+                "timestamp": "2026-08-17T12:00:01Z",
+                "cwd": cwd,
+                "version": "2.1.300",
+                "compactMetadata": {
+                    "preservedSegment": {
+                        "anchorUuid": "summary",
+                        "headUuid": "tail",
+                        "tailUuid": "elsewhere",
+                    },
+                    "preservedMessages": {
+                        "uuids": ["tail", "elsewhere"],
+                        "allUuids": ["tail", "elsewhere"],
+                    },
+                },
+            },
+            summary,
+            claude_record("assistant", "mid", "summary", "mid text", cwd=cwd),
+            claude_record("user", "tail", "mid", "tail text", cwd=cwd),
+            claude_record("assistant", "leaf", "tail", "leaf text", cwd=cwd),
+            {"type": "last-prompt", "leafUuid": "leaf"},
+        ],
+    )
+
+    with pytest.raises(SessionMigrateError, match="ancestry cycle"):
+        claude.parse(path)
+
+
 def test_claude_to_codex_preserves_messages_and_tools(tmp_path: Path) -> None:
     cwd = str(tmp_path)
     source_path = write_jsonl(
diff --git a/tests/test_hermes_corpus_source.py b/tests/test_hermes_corpus_source.py
index 7797a23..68de45c 100644
--- a/tests/test_hermes_corpus_source.py
+++ b/tests/test_hermes_corpus_source.py
@@ -20,9 +20,9 @@
 from session_migrate.model import EventKind
 
 ROOT = Path(__file__).resolve().parents[1]
-FIXTURE = ROOT / "tests/native_corpus/v1/sources/hermes/0.20.6/portable-rich"
+FIXTURE = ROOT / "tests/native_corpus/v1/sources/hermes/0.22.2/portable-rich"
 SCRIPT = ROOT / "scripts/native-corpus/sanitize-hermes.py"
-SESSION_ID = "20260831_195650_1783a3"
+SESSION_ID = "20261016_232030_e61bcd"
 FOLLOWUP = "HERMES_CORPUS_COLD_RELOAD_FOLLOWUP_7319"
 REPLY = "HERMES_CORPUS_COLD_RELOAD_REPLY_7319"
 
@@ -235,7 +235,7 @@ def do_POST(self) -> None:  # noqa: N802
 def test_hermes_fixture_cold_reloads_and_continues_in_exact_client(tmp_path: Path) -> None:
     source_value = os.environ.get("SESSION_MIGRATE_HERMES_SOURCE")
     if not source_value:
-        pytest.skip("set SESSION_MIGRATE_HERMES_SOURCE to exact v2026.8.27 source")
+        pytest.skip("set SESSION_MIGRATE_HERMES_SOURCE to exact v2026.9.24 source")
     source = Path(source_value).resolve()
     binary = Path(
         os.environ.get("SESSION_MIGRATE_HERMES_BIN", str(source / ".venv/bin/hermes"))
@@ -277,7 +277,7 @@ def test_hermes_fixture_cold_reloads_and_continues_in_exact_client(tmp_path: Pat
                     "    default_model: fixture-model",
                     "    models: [fixture-model]",
                     "    discover_models: false",
-                    "    context_length: 32768",
+                    "    context_length: 131072",
                     "display:",
                     "  interface: cli",
                     "  resume_display: minimal",
diff --git a/tests/test_hermes_format.py b/tests/test_hermes_format.py
index 655ad03..ebb4188 100644
--- a/tests/test_hermes_format.py
+++ b/tests/test_hermes_format.py
@@ -1,6 +1,7 @@
 import json
 import os
 import sqlite3
+import subprocess
 from dataclasses import asdict, replace
 from pathlib import Path
 
@@ -100,7 +101,7 @@ def _portable_session(tmp_path: Path) -> Session:
     )
 
 
-def _create_store(path: Path, *, schema_version: int = 26) -> sqlite3.Connection:
+def _create_store(path: Path, *, schema_version: int = 31) -> sqlite3.Connection:
     path.parent.mkdir(parents=True, exist_ok=True)
     db = sqlite3.connect(path)
     db.executescript(
@@ -312,7 +313,15 @@ def test_hermes_root_and_state_database_resolution(tmp_path: Path) -> None:
     assert hermes.state_database_path(environ={"HERMES_HOME": str(configured)}) == (
         configured / "state.db"
     )
-    assert hermes.hermes_home(user_home, environ={}) == user_home / ".hermes"
+    # The platform default follows the CLI: %LOCALAPPDATA%\hermes on Windows,
+    # ~/.hermes elsewhere (see test_hermes_home_matches_the_native_cli_platform_default).
+    assert hermes.hermes_home(user_home, environ={}, platform="linux") == user_home / ".hermes"
+    assert (
+        hermes.hermes_home(
+            user_home, environ={"LOCALAPPDATA": str(tmp_path / "local-app-data")}, platform="win32"
+        )
+        == tmp_path / "local-app-data" / "hermes"
+    )
 
 
 def test_hermes_bundle_round_trip_tools_media_compaction_and_private_omissions(
@@ -562,6 +571,175 @@ def test_hermes_snapshot_includes_uncheckpointed_wal_commit(tmp_path: Path) -> N
         )
 
 
+def test_hermes_bundle_title_helpers_report_and_clear_only_the_title(tmp_path: Path) -> None:
+    session = _portable_session(tmp_path)
+    data, _ = hermes.serialize(
+        session,
+        session_id=NATIVE_ID,
+        cwd=tmp_path,
+        timestamp="2026-08-30T12:34:56Z",
+        title=session.title,
+    )
+    assert hermes.bundle_title(data) == session.title
+
+    adjusted = hermes.without_title(data)
+    parsed = hermes.validate_native_bytes(adjusted, NATIVE_ID)
+    original = hermes.validate_native_bytes(data, NATIVE_ID)
+    assert parsed.title is None
+    assert hermes.bundle_title(adjusted) is None
+    # Only the title changes: the envelope keeps every other field and message.
+    assert parsed.session_id == original.session_id
+    assert parsed.cwd == original.cwd
+    assert parsed.started_at == original.started_at
+    assert parsed.model == original.model
+    assert parsed.messages == original.messages
+    before, after = json.loads(data), json.loads(adjusted)
+    before["session"].pop("title")
+    after["session"].pop("title")
+    assert before == after
+
+
+def test_hermes_title_taken_matches_only_a_stored_non_null_title(tmp_path: Path) -> None:
+    store = tmp_path / "state.db"
+    db = _create_store(store)
+    _insert_session(db, NATIVE_ID, title="Título já usado")
+    db.execute(
+        """INSERT INTO sessions(id,source,started_at,message_count,title,archived,hidden)
+           VALUES (?, 'cli', ?, 0, NULL, 0, 0)""",
+        (SECOND_ID, 1_788_093_296.0),
+    )
+    db.commit()
+    db.close()
+
+    assert hermes.title_taken(store, "Título já usado") is True
+    assert hermes.title_taken(store, "outro título") is False
+    assert hermes.title_taken(store, None) is False
+    assert hermes.title_taken(store, "") is False
+    # A store that does not exist yet cannot hold a title, and an unreadable one
+    # leaves the decision to the import transaction.
+    assert hermes.title_taken(tmp_path / "missing.db", "Título já usado") is False
+
+
+def test_hermes_install_helper_moves_the_bundle_as_utf8_bytes(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """The bundle must cross the process boundary as bytes, never as locale text.
+
+    Encoding it as text uses the *caller's* codec while the store interpreter
+    always decodes UTF-8, so a Windows console whose code page is not UTF-8
+    replaced every non-ASCII character with U+FFFD inside the target store.  The
+    helper reads ``sys.stdin.buffer`` and the caller decodes stdout/stderr
+    explicitly for the same reason.
+    """
+
+    home = tmp_path / "hermes-home"
+    home.mkdir()
+    database = home / "state.db"
+    store = _create_store(database)
+    store.commit()
+    store.close()
+
+    payload = "Instalação — ação".encode()
+    captured: dict[str, object] = {}
+
+    def fake_run(command: list[str], **kwargs: object) -> object:
+        captured["command"] = command
+        captured["kwargs"] = kwargs
+        return subprocess.CompletedProcess(
+            command, 0, stdout=b'{"ok":true,"imported":1,"skipped":0,"imported_ids":[]}', stderr=b""
+        )
+
+    monkeypatch.setattr(hermes.subprocess, "run", fake_run)
+    hermes._run_helper(
+        ["python", "-I", "-X", "utf8", "-c"],
+        "import os,sys; ",
+        "import json,sys; value=json.loads(sys.stdin.buffer.read())",
+        database=database,
+        payload=payload,
+        environment={"HERMES_HOME": str(home)},
+    )
+
+    kwargs = captured["kwargs"]
+    assert isinstance(kwargs, dict)
+    assert kwargs.get("input") == payload
+    assert isinstance(kwargs.get("input"), bytes)
+    assert kwargs.get("text") is None
+    assert "stdin" not in kwargs
+    command = captured["command"]
+    assert isinstance(command, list)
+    assert "sys.stdin.buffer.read()" in command[-2]
+    assert str(database) == command[-1]
+
+
+def test_hermes_home_matches_the_native_cli_platform_default(tmp_path: Path) -> None:
+    """A bare ``~/.hermes`` is wrong on Windows, where the CLI writes %LOCALAPPDATA%."""
+
+    assert hermes.hermes_home(home=tmp_path, environ={}, platform="linux") == tmp_path / ".hermes"
+    assert (
+        hermes.hermes_home(
+            home=tmp_path, environ={"LOCALAPPDATA": r"C:\fixture\AppData\Local"}, platform="win32"
+        )
+        == Path(r"C:\fixture\AppData\Local") / "hermes"
+    )
+    assert hermes.hermes_home(home=tmp_path, environ={}, platform="win32") == (
+        tmp_path / "AppData" / "Local" / "hermes"
+    )
+    # HERMES_HOME wins everywhere, and a blank value counts as unset.
+    custom = tmp_path / "custom-home"
+    assert (
+        hermes.hermes_home(home=tmp_path, environ={"HERMES_HOME": str(custom)}, platform="win32")
+        == custom
+    )
+    assert (
+        hermes.hermes_home(home=tmp_path, environ={"HERMES_HOME": "   "}, platform="win32")
+        == tmp_path / "AppData" / "Local" / "hermes"
+    )
+    assert (
+        hermes.state_database_path(
+            environ={"LOCALAPPDATA": r"C:\fixture\AppData\Local"}, platform="win32"
+        )
+        == Path(r"C:\fixture\AppData\Local") / "hermes" / "state.db"
+    )
+    assert hermes.state_database_path(root=tmp_path / "explicit", platform="win32") == (
+        tmp_path / "explicit" / "state.db"
+    )
+
+
+def test_hermes_import_budget_covers_a_bundle_the_store_caps_by_default() -> None:
+    """A bundle the store's 5 MiB per-session cap rejects raises the budget instead.
+
+    Hermes caps one session at 5 MiB on import while its own web import accepts
+    25 MiB, so a session carrying pasted screenshots is refused although nothing
+    about it is invalid.  Size the bundle the way the store does, request the
+    smallest budget that fits, and never pass the vendor's own ceiling.
+    """
+
+    assert hermes.import_budget_bytes(0) == hermes.PINNED_HERMES_IMPORT_SESSION_BYTES
+    assert hermes.import_budget_bytes(1024) == hermes.PINNED_HERMES_IMPORT_SESSION_BYTES
+    assert hermes.import_budget_bytes(6 * 1024 * 1024) == 6 * 1024 * 1024
+    assert (
+        hermes.import_budget_bytes(900 * 1024 * 1024) == hermes.PINNED_HERMES_IMPORT_CEILING_BYTES
+    )
+
+    # `timings` is derived on export and never counts against the content budget.
+    session = {
+        "id": "20260830_123456_abcdef",
+        "messages": [{"content": "á"}],
+        "timings": [{"x": "y" * 4096}],
+    }
+    sized = hermes.measured_session_bytes(session)
+    assert sized == len(
+        json.dumps(
+            {"id": "20260830_123456_abcdef", "messages": [{"content": "á"}]},
+            ensure_ascii=False,
+            separators=(",", ":"),
+        ).encode("utf-8")
+    )
+    assert sized < len(
+        json.dumps(session, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
+    )
+
+
 def test_hermes_rejects_symlink_and_unsupported_schema(tmp_path: Path) -> None:
     path = _native_store(tmp_path / "native")
     link = tmp_path / "linked.db"
@@ -573,5 +751,5 @@ def test_hermes_rejects_symlink_and_unsupported_schema(tmp_path: Path) -> None:
     db = _create_store(old, schema_version=25)
     db.commit()
     db.close()
-    with pytest.raises(JsonlError, match="expected 26"):
+    with pytest.raises(JsonlError, match="expected 31"):
         hermes.list_sessions(old)
diff --git a/tests/test_hermes_native.py b/tests/test_hermes_native.py
index ffe31de..71f4355 100644
--- a/tests/test_hermes_native.py
+++ b/tests/test_hermes_native.py
@@ -1,4 +1,4 @@
-"""Opt-in pinned-source native trajectory for Hermes Agent 0.20.6."""
+"""Opt-in pinned-source native trajectory for Hermes Agent 0.22.2."""
 
 import json
 import os
@@ -17,6 +17,10 @@
 SESSION_ID = "20260830_123456_111111"
 FOLLOWUP = "HERMES_NATIVE_RESUME_FOLLOWUP_ZETA"
 REPLY = "HERMES_NATIVE_RESUME_REPLY_OMEGA"
+# Non-ASCII text travels through the bundle as bytes; a locale-encoded pipe used to
+# replace it with U+FFFD, so every trajectory asserts it survives verbatim.
+TITLE = "Hermes native resume fixture — ação"
+ACCENTED = "ação concluída — sem perdas"
 
 
 class Provider(ThreadingHTTPServer):
@@ -95,14 +99,14 @@ def _source(tmp_path: Path) -> Session:
         started_at="2026-08-30T12:34:56Z",
         cli_version="2.1.209",
         model="fixture-model",
-        title="Hermes native resume fixture",
+        title=TITLE,
         events=(
             Event(
                 EventKind.MESSAGE,
                 Provenance(0, "user"),
                 role=Role.USER,
                 timestamp="2026-08-30T12:34:56Z",
-                text="HERMES_IMPORTED_USER_ALPHA",
+                text=f"HERMES_IMPORTED_USER_ALPHA {ACCENTED}",
             ),
             Event(
                 EventKind.TOOL_CALL,
@@ -159,13 +163,34 @@ def _environment(home: Path, source: Path) -> dict[str, str]:
     for key in ("LANG", "LC_ALL", "LC_CTYPE", "TMPDIR"):
         if os.environ.get(key):
             environment[key] = os.environ[key]
+    # Windows needs its own essentials to load a child process at all, and the
+    # CLI resolves its home through USERPROFILE rather than HOME.
+    for key in (
+        "USERPROFILE",
+        "HOMEDRIVE",
+        "HOMEPATH",
+        "APPDATA",
+        "LOCALAPPDATA",
+        "SYSTEMROOT",
+        "SYSTEMDRIVE",
+        "WINDIR",
+        "PATHEXT",
+        "COMSPEC",
+        "TEMP",
+        "TMP",
+        "NUMBER_OF_PROCESSORS",
+    ):
+        if os.environ.get(key):
+            environment[key] = os.environ[key]
+    if not environment.get("USERPROFILE"):
+        environment["USERPROFILE"] = str(home)
     return environment
 
 
-def test_hermes_0206_import_resume_replay_append_and_compaction(tmp_path: Path) -> None:
+def test_hermes_0222_import_resume_replay_append_and_compaction(tmp_path: Path) -> None:
     source_value = os.environ.get("SESSION_MIGRATE_HERMES_SOURCE")
     if not source_value:
-        pytest.skip("set SESSION_MIGRATE_HERMES_SOURCE to the exact v2026.8.27 source checkout")
+        pytest.skip("set SESSION_MIGRATE_HERMES_SOURCE to the exact v2026.9.24 source checkout")
     source = Path(source_value).resolve()
     binary_value = os.environ.get("SESSION_MIGRATE_HERMES_BIN")
     binary = Path(binary_value).resolve() if binary_value else source / ".venv/bin/hermes"
@@ -205,7 +230,7 @@ def test_hermes_0206_import_resume_replay_append_and_compaction(tmp_path: Path)
                     "    default_model: fixture-model",
                     "    models: [fixture-model]",
                     "    discover_models: false",
-                    "    context_length: 32768",
+                    "    context_length: 131072",
                     "display:",
                     "  interface: cli",
                     "  resume_display: minimal",
@@ -234,7 +259,7 @@ def test_hermes_0206_import_resume_replay_append_and_compaction(tmp_path: Path)
         )
         assert installed.path == home / "state.db"
         before = hermes.parse_session(installed.path, SESSION_ID)
-        assert before.title == "Hermes native resume fixture"
+        assert before.title == TITLE
         assert before.cwd == work
         assert before.event_counts() == {
             "compaction": 1,
@@ -315,9 +340,19 @@ def test_hermes_0206_import_resume_replay_append_and_compaction(tmp_path: Path)
         assert resumed.returncode == 0, (resumed.stdout, resumed.stderr)
         assert REPLY in resumed.stdout
         assert provider.requests
-        request_text = json.dumps(provider.requests[-1], ensure_ascii=False)
+        # Hermes 0.22.2 names a session that closes without a title, so the
+        # request logged last is the title-generation call; the imported
+        # history replays in the chat request that precedes it.
+        chat_requests = [
+            request
+            for request in provider.requests
+            if not request["messages"][0]["content"].startswith("You name chat sessions")
+        ]
+        assert chat_requests
+        request_text = json.dumps(chat_requests[-1], ensure_ascii=False)
         for marker in (
             "HERMES_IMPORTED_USER_ALPHA",
+            ACCENTED,
             "call_hermes_native",
             "HERMES_IMPORTED_TOOL_GAMMA",
             "HERMES_IMPORTED_SUMMARY_DELTA",
diff --git a/tests/test_opencode_v2.py b/tests/test_opencode_v2.py
new file mode 100644
index 0000000..e5cb2f1
--- /dev/null
+++ b/tests/test_opencode_v2.py
@@ -0,0 +1,704 @@
+"""Portable v2 transfers, without native database writes or real providers."""
+
+import json
+from pathlib import Path
+
+import pytest
+
+from session_migrate import conversion
+from session_migrate.conversion import ConversionOptions, convert_session, load_session
+from session_migrate.errors import SessionMigrateError
+from session_migrate.formats import opencode
+from session_migrate.model import AgentFormat, Event, EventKind, Provenance, Role, TargetFormat
+
+FIXTURES = Path(__file__).parent / "fixtures"
+
+
+def artifact(tmp_path: Path, release: str = "2.0.23"):
+    session = load_session(FIXTURES / "codex-0.144.4/basic.jsonl", AgentFormat.CODEX)
+    return convert_session(
+        session,
+        ConversionOptions(
+            target_format=TargetFormat.OPENCODE,
+            target_cli_version=release,
+            cwd=tmp_path,
+            model_provider="fixture",
+            model="test",
+        ),
+    )
+
+
+def test_streamed_tool_source_retains_partial_input_through_portable_target(tmp_path):
+    partial = '{"command":"UNIQUE_PARTIAL_INPUT'
+    value = json.loads(artifact(tmp_path).native_bytes)
+    tool = next(
+        c
+        for m in value["messages"]
+        if m["type"] == "assistant"
+        for c in m["content"]
+        if c["type"] == "tool"
+    )
+    tool["state"] = {"status": "streaming", "input": partial}
+    source_path = tmp_path / "streaming-source.json"
+    source_path.write_text(json.dumps(value))
+    source = opencode.parse_session(source_path)
+    call = next(e for e in source.events if e.kind == EventKind.TOOL_CALL)
+    assert call.payload["input"] == {"input": partial}
+    target = convert_session(
+        source,
+        ConversionOptions(
+            target_format=TargetFormat.OPENCODE,
+            target_cli_version="2.0.23",
+            cwd=tmp_path,
+            model_provider="fixture",
+            model="test",
+        ),
+    )
+    exported = json.loads(target.native_bytes)
+    archived = next(
+        c
+        for m in exported["messages"]
+        if m["type"] == "assistant"
+        for c in m["content"]
+        if c["type"] == "tool"
+    )
+    assert archived["id"] == tool["id"]
+    assert archived["state"]["input"] == {"input": partial}
+    assert archived["state"]["status"] == "error"
+    assert archived["state"]["error"]["type"] == "ImportedIncompleteTool"
+    assert target.dropped["tool_call:v2_incomplete_archived"] == 1
+
+
+@pytest.mark.parametrize(
+    ("release", "validated", "warning_expected"),
+    [
+        ("1.17.20", "1.17.20", False),
+        ("2.0.22", "2.0.23", False),
+        ("2.0.23", "2.0.23", False),
+        ("opencode v2.0.23", "2.0.23", False),
+        ("2.0.24", "2.0.23", True),
+        ("2.0.23-gateway.custom", "2.0.23", True),
+    ],
+)
+def test_target_version_warning_matches_selected_schema(
+    tmp_path, release, validated, warning_expected
+):
+    session = load_session(FIXTURES / "codex-0.144.4/basic.jsonl", AgentFormat.CODEX)
+    target = convert_session(
+        session,
+        ConversionOptions(
+            target_format=TargetFormat.OPENCODE,
+            target_cli_version=release,
+            cwd=tmp_path,
+            model_provider="fixture",
+            model="test",
+        ),
+    )
+    warnings = [w for w in target.warnings if w["code"] == "unvalidated_target_version"]
+    assert bool(warnings) is warning_expected
+    if warning_expected:
+        assert warnings[0]["validated"] == validated
+        assert warnings[0]["observed"] == release
+        assert "selected OpenCode 2.0 transfer schema" in warnings[0]["message"]
+        assert "remains pinned" not in warnings[0]["message"]
+    native = json.loads(target.native_bytes)
+    assert ("location" in native["info"]) is opencode.is_v2(release)
+
+
+def test_v2_flat_schema_portable_roundtrip(tmp_path):
+    target = artifact(tmp_path)
+    value = json.loads(target.native_bytes)
+    assert value["info"]["location"] == {"directory": str(tmp_path)}
+    assert value["info"]["model"] == {"id": "test", "providerID": "fixture"}
+    assert all("info" not in m and "parts" not in m for m in value["messages"])
+    opencode.validate_native_bytes(target.native_bytes, target.session_id)
+    path = tmp_path / "bundle.json"
+    path.write_bytes(target.native_bytes)
+    parsed = opencode.parse_import(path)
+    source = load_session(FIXTURES / "codex-0.144.4/basic.jsonl", AgentFormat.CODEX)
+    assert [e.text for e in parsed.events if e.kind == EventKind.MESSAGE] == [
+        e.text for e in source.events if e.kind == EventKind.MESSAGE
+    ]
+    assert [e.tool_call_id for e in parsed.events if e.kind == EventKind.TOOL_CALL] == [
+        e.tool_call_id for e in source.events if e.kind == EventKind.TOOL_CALL
+    ]
+
+
+def test_freeform_tool_input_is_wrapped_without_losing_call_or_result(tmp_path):
+    from dataclasses import replace
+
+    session = load_session(FIXTURES / "codex-0.144.4/basic.jsonl", AgentFormat.CODEX)
+    original = next(e for e in session.events if e.kind == EventKind.TOOL_CALL)
+    freeform = "*** Begin Patch\n+Unicode: é λ\n*** End Patch\n"
+    session = replace(
+        session,
+        events=tuple(
+            replace(e, payload={"input": freeform}) if e is original else e for e in session.events
+        ),
+    )
+    target = convert_session(
+        session,
+        ConversionOptions(
+            target_format=TargetFormat.OPENCODE,
+            target_cli_version="2.0.23",
+            cwd=tmp_path,
+            model_provider="fixture",
+            model="test",
+        ),
+    )
+    native = json.loads(target.native_bytes)
+    tool = next(
+        item
+        for message in native["messages"]
+        if message["type"] == "assistant"
+        for item in message["content"]
+        if item["type"] == "tool" and item["id"] == original.tool_call_id
+    )
+    assert tool["state"]["input"] == {"input": freeform}
+    assert tool["state"]["status"] == "completed"
+    result = next(e for e in session.events if e.kind == EventKind.TOOL_RESULT)
+    assert [item for item in tool["state"]["content"] if item["type"] == "text"] == [
+        {"type": "text", "text": result.text}
+    ]
+    assert target.dropped["tool_call:non_object_input"] == 1
+
+
+def test_cli_help_explains_opencode_schema_selection(capsys):
+    from session_migrate.cli import build_parser
+
+    with pytest.raises(SystemExit) as exc:
+        build_parser().parse_args(["convert", "--help"])
+    assert exc.value.code == 0
+    help_text = " ".join(capsys.readouterr().out.split())
+    assert "selects legacy or 2.0 transfer schema for OpenCode" in help_text
+    assert "metadata version only; the writer schema remains pinned" not in help_text
+
+
+def test_v2_tools_images_compaction_and_incomplete_call(tmp_path):
+    from dataclasses import replace
+
+    base = load_session(FIXTURES / "codex-0.144.4/basic.jsonl", AgentFormat.CODEX)
+    image = "data:image/png;base64,aGVsbG8="
+    events = (
+        Event(
+            kind=EventKind.MESSAGE, role=Role.USER, text="look", provenance=Provenance(1, "user")
+        ),
+        Event(
+            kind=EventKind.CONTEXT,
+            role=Role.USER,
+            payload={"block_type": "image", "image_url": image},
+            provenance=Provenance(1, "user"),
+        ),
+        Event(
+            kind=EventKind.TOOL_CALL,
+            role=Role.ASSISTANT,
+            tool_call_id="call_one",
+            tool_name="read",
+            payload={"input": {"path": "a"}},
+            provenance=Provenance(2, "assistant"),
+        ),
+        Event(
+            kind=EventKind.TOOL_RESULT,
+            role=Role.TOOL,
+            tool_call_id="call_one",
+            text="result",
+            payload={
+                "content_blocks": [
+                    {"type": "text", "text": "result"},
+                    {"type": "image", "image_url": image},
+                ]
+            },
+            provenance=Provenance(3, "tool"),
+        ),
+        Event(
+            kind=EventKind.COMPACTION,
+            text="portable summary",
+            provenance=Provenance(4, "compaction"),
+        ),
+        Event(
+            kind=EventKind.TOOL_CALL,
+            role=Role.ASSISTANT,
+            tool_call_id="unfinished",
+            tool_name="shell",
+            payload={"input": {"cmd": "echo x"}},
+            provenance=Provenance(5, "assistant"),
+        ),
+    )
+    data, losses = opencode.serialize(
+        replace(base, events=events), session_id="ses_fixture", cwd=tmp_path, cli_version="2.0.23"
+    )
+    opencode.validate_native_bytes(data, "ses_fixture")
+    value = json.loads(data)
+    assert value["messages"][0]["files"][0]["data"] == "aGVsbG8="
+    completed = value["messages"][1]["content"][0]
+    assert completed["id"] == "call_one"
+    assert completed["state"]["content"][1]["uri"] == image
+    assert value["messages"][2]["type"] == "compaction"
+    assert value["messages"][2]["summary"] == "portable summary"
+    assert value["messages"][3]["content"][0]["state"]["status"] == "error"
+    assert losses["tool_call:v2_incomplete_archived"] == 1
+    path = tmp_path / "rich.json"
+    path.write_bytes(data)
+    parsed = opencode.parse_import(path)
+    assert any(
+        e.kind == EventKind.COMPACTION and e.text == "portable summary" for e in parsed.events
+    )
+    assert any(
+        e.kind == EventKind.TOOL_RESULT and e.tool_call_id == "call_one" and e.text == "result"
+        for e in parsed.events
+    )
+    assert any(
+        e.kind == EventKind.CONTEXT and e.payload["image_url"] == image for e in parsed.events
+    )
+
+
+@pytest.mark.parametrize("change", ["duplicate", "tool", "location", "tokens", "base64"])
+def test_v2_rejects_malformed_portable_content(tmp_path, change):
+    value = json.loads(artifact(tmp_path).native_bytes)
+    if change == "duplicate":
+        value["messages"].append(value["messages"][0])
+    elif change == "location":
+        value["info"]["location"] = None
+    elif change == "tokens":
+        value["info"]["tokens"] = {}
+    elif change == "base64":
+        value["messages"][0]["files"] = [{"data": "!!!", "mime": "image/png"}]
+    else:
+        value["messages"][1]["content"] = [
+            {"type": "tool", "state": {"status": "completed", "input": {}, "content": []}}
+        ]
+    with pytest.raises(SessionMigrateError):
+        opencode.validate_native_bytes(json.dumps(value).encode(), value["info"]["id"])
+
+
+def test_v2_private_provider_state_accounted(tmp_path):
+    value = json.loads(artifact(tmp_path).native_bytes)
+    assistant = next(m for m in value["messages"] if m["type"] == "assistant")
+    assistant["providerState"] = {"encrypted": "private"}
+    path = tmp_path / "state.json"
+    path.write_text(json.dumps(value))
+    parsed = opencode.parse_import(path)
+    assert ("opencode_v2_providerState", 1) in parsed.losses
+    assert all("private" not in (e.text or "") for e in parsed.events)
+
+
+@pytest.mark.parametrize(
+    "value, expected",
+    [
+        ("2.0.23", True),
+        ("2.0.22", True),
+        ("opencode v2.0.23", True),
+        ("2.0.23-gateway.3648f00e", True),
+        ("2.1.0", False),
+        ("3.0.0", False),
+        ("9.9.9", False),
+        ("1.17.20", True),
+    ],
+)
+def test_version_schema_gate(value, expected):
+    assert opencode.supported_version(value) is expected
+
+
+def test_v2_cli_commands_and_conflict_not_success(tmp_path, monkeypatch):
+    import subprocess
+
+    monkeypatch.setattr(conversion, "_opencode_version", lambda *args: "2.0.23")
+    calls = []
+
+    def run(command, environ):
+        calls.append(command)
+        return subprocess.CompletedProcess(command, 0, "Session already exists\n", "")
+
+    monkeypatch.setattr(conversion, "_run_opencode", run)
+    with pytest.raises(SessionMigrateError, match="refused"):
+        conversion._invoke_opencode_import(
+            Path("opencode"), tmp_path / "bundle.json", {}, cwd=tmp_path
+        )
+    assert calls[0][1:3] == ["session", "import"]
+    assert calls[0][-3:] == ["--directory", str(tmp_path), "--standalone"]
+
+
+def test_native_v2_isolated_import_export_dry_run_and_collision(tmp_path):
+    """Opt-in actual native CLI integration; only synthetic fixture data."""
+    import os
+    from dataclasses import replace
+
+    native = os.environ.get("SESSION_MIGRATE_TEST_OPENCODE_V2")
+    if not native:
+        pytest.skip("set SESSION_MIGRATE_TEST_OPENCODE_V2 to a real v2 binary")
+    env = {
+        "PATH": os.environ.get("PATH", ""),
+        "HOME": str(tmp_path / "home"),
+        "TMPDIR": str(tmp_path),
+        "OPENCODE_DISABLE_AUTOUPDATE": "true",
+        "OPENCODE_CONFIG_CONTENT": '{"disabled_providers":["opencode"]}',
+    }
+    for key, name in [
+        ("XDG_CONFIG_HOME", "config"),
+        ("XDG_DATA_HOME", "data"),
+        ("XDG_CACHE_HOME", "cache"),
+        ("XDG_STATE_HOME", "state"),
+    ]:
+        env[key] = str(tmp_path / name)
+    for value in [env["HOME"], *(env[k] for k in env if k.startswith("XDG_"))]:
+        Path(value).mkdir()
+    release = conversion._opencode_version(Path(native), env)
+    assert release in {"2.0.22", "2.0.23"}
+    target = artifact(tmp_path, release)
+    # Include a native completed compaction and linked tool output from the Codex fixture.
+    value = json.loads(target.native_bytes)
+    image = "data:image/png;base64,aGVsbG8="
+    user = next(m for m in value["messages"] if m["type"] == "user")
+    user["files"] = [{"data": "aGVsbG8=", "mime": "image/png", "source": {"type": "inline"}}]
+    tool = next(
+        c
+        for m in value["messages"]
+        if m["type"] == "assistant"
+        for c in m["content"]
+        if c["type"] == "tool"
+    )
+    tool["state"]["content"].append({"type": "file", "uri": image, "mime": "image/png"})
+    value["messages"].append(
+        {
+            "id": "msg_native_compaction",
+            "type": "compaction",
+            "time": {"created": value["info"]["time"]["updated"]},
+            "status": "completed",
+            "reason": "auto",
+            "summary": "Retain forty one.",
+            "recent": "Latest request.",
+        }
+    )
+    target = replace(target, native_bytes=(json.dumps(value) + "\n").encode())
+    manifest = tmp_path / "manifest.json"
+    cli = Path(native)
+    conversion.install_opencode_artifact(
+        target, manifest_path=manifest, target_cli=cli, environ=env, dry_run=True
+    )
+    assert not manifest.exists()
+    conversion.install_opencode_artifact(
+        target, manifest_path=manifest, target_cli=cli, environ=env
+    )
+    assert manifest.exists()
+    exported = conversion.load_opencode_session(target.session_id, source_cli=cli, environ=env)
+    assert exported.cli_version == release
+    assert any(e.kind == EventKind.COMPACTION and "forty one" in e.text for e in exported.events)
+    assert any(e.kind == EventKind.TOOL_RESULT for e in exported.events)
+    assert any(
+        e.kind == EventKind.CONTEXT and e.payload.get("image_url") == image for e in exported.events
+    )
+    # Native global conflict is also protected when the project-filtered preflight misses it.
+    other = tmp_path / "other-manifest.json"
+    with pytest.raises(SessionMigrateError, match="overwrite|refused"):
+        conversion.install_opencode_artifact(
+            target, manifest_path=other, target_cli=cli, environ=env
+        )
+    assert not other.exists()
+    from session_migrate.catalog import Catalog
+
+    with Catalog(tmp_path / "catalog.sqlite3") as catalog:
+        result = catalog.refresh(
+            opencode_roots=(Path(env["XDG_DATA_HOME"]) / "opencode",), include_auto=False
+        )
+        assert result.root_errors == 0
+        entries = catalog.list_sessions(agent_format=AgentFormat.OPENCODE, include_paths=True)
+        assert [entry.session_id for entry in entries] == [target.session_id]
+        assert entries[0].cli_version == release
+        assert entries[0].cwd == str(tmp_path)
+
+
+def test_v2_content_free_inspection(tmp_path):
+    from session_migrate.inspection import inspect_session
+
+    path = tmp_path / "inspection.json"
+    path.write_bytes(artifact(tmp_path).native_bytes)
+    result = inspect_session(path, source_format=AgentFormat.OPENCODE)
+    assert result.cwd == str(tmp_path)
+    assert result.tool_calls > 0 and result.tool_results > 0
+    assert result.roles.get("user", 0) > 0
+    assert result.records > 0
+
+
+def test_v2_autodetection_uses_flat_schema_while_legacy_remains_ambiguous(tmp_path):
+    from session_migrate.errors import FormatDetectionError
+    from session_migrate.inspection import detect_path_format, inspect_session
+
+    path = tmp_path / "auto.json"
+    path.write_bytes(artifact(tmp_path).native_bytes)
+    assert detect_path_format(path) == AgentFormat.OPENCODE
+    assert inspect_session(path).format == AgentFormat.OPENCODE.value
+    assert load_session(path).source_format == AgentFormat.OPENCODE
+    session = load_session(FIXTURES / "codex-0.144.4/basic.jsonl", AgentFormat.CODEX)
+    legacy = convert_session(session, ConversionOptions(TargetFormat.OPENCODE))
+    path.write_bytes(legacy.native_bytes)
+    with pytest.raises(FormatDetectionError, match="no reliable producer marker"):
+        detect_path_format(path)
+
+
+@pytest.mark.parametrize("whitespace", ["", "   ", "\n\t"])
+def test_private_only_compaction_preserves_readable_history(tmp_path, whitespace):
+    value = json.loads(artifact(tmp_path).native_bytes)
+    value["messages"] = [m for m in value["messages"] if m["type"] != "compaction"]
+    value["messages"].append(
+        {
+            "id": "msg_private_compaction",
+            "type": "compaction",
+            "time": {"created": value["info"]["time"]["updated"]},
+            "status": "completed",
+            "reason": "auto",
+            "summary": whitespace,
+            "recent": whitespace,
+            "providerContext": {
+                "version": 1,
+                "provenance": {
+                    "providerID": "fixture",
+                    "provider": "fixture",
+                    "modelID": "test",
+                    "route": "fixture",
+                    "protocol": "fixture",
+                    "endpoint": "fixture-digest",
+                },
+                "messages": [],
+            },
+            "providerState": {"encrypted": "private"},
+        }
+    )
+    path = tmp_path / "private-compaction.json"
+    path.write_text(json.dumps(value))
+    source = opencode.parse_session(path)
+    assert not any(e.kind == EventKind.COMPACTION for e in source.events)
+    assert any(e.kind == EventKind.MESSAGE and e.role == Role.USER for e in source.events)
+    target = convert_session(
+        source,
+        ConversionOptions(
+            target_format=TargetFormat.OPENCODE, target_cli_version="2.0.23", cwd=tmp_path
+        ),
+    )
+    native = json.loads(target.native_bytes)
+    assert not any(m["type"] == "compaction" for m in native["messages"])
+    assert target.dropped["opaque:opencode_v2_compaction_empty_portable_summary"] == 1
+    assert target.dropped["opaque:opencode_v2_providerContext"] == 1
+    assert target.dropped["opaque:opencode_v2_providerState"] == 1
+    assert b'"encrypted"' not in target.native_bytes
+
+
+def test_v2_reasoning_variant_loss_is_explicit(tmp_path):
+    value = json.loads(artifact(tmp_path).native_bytes)
+    value["info"]["model"]["variant"] = "high"
+    assistant = next(m for m in value["messages"] if m["type"] == "assistant")
+    assistant["model"]["variant"] = "max"
+    path = tmp_path / "variants.json"
+    path.write_text(json.dumps(value))
+    parsed = opencode.parse_import(path)
+    assert ("opencode_v2_session_model_variant", 1) in parsed.losses
+    assert ("opencode_v2_message_model_variant", 1) in parsed.losses
+
+
+@pytest.mark.parametrize("text", [None, 3, {}, []])
+def test_v2_invalid_user_text_fails_closed(tmp_path, text):
+    value = json.loads(artifact(tmp_path).native_bytes)
+    user = next(m for m in value["messages"] if m["type"] == "user")
+    user["text"] = text
+    with pytest.raises(SessionMigrateError, match="user message has invalid text"):
+        opencode.validate_native_bytes(json.dumps(value).encode(), value["info"]["id"])
+
+
+def test_v2_unknown_message_type_fails_closed(tmp_path):
+    value = json.loads(artifact(tmp_path).native_bytes)
+    value["messages"][0]["type"] = "future-user"
+    with pytest.raises(SessionMigrateError, match="unsupported message type"):
+        opencode.validate_native_bytes(json.dumps(value).encode(), value["info"]["id"])
+
+
+@pytest.mark.parametrize("extra_content", [None, 3, "unknown", [{"type": "future-part"}]])
+def test_unknown_user_extension_is_accounted_without_crashing(tmp_path, extra_content):
+    value = json.loads(artifact(tmp_path).native_bytes)
+    user = next(m for m in value["messages"] if m["type"] == "user")
+    user["content"] = extra_content
+    path = tmp_path / "extension.json"
+    path.write_text(json.dumps(value))
+    parsed = opencode.parse_import(path)
+    assert ("opencode_v2_unknown_message_fields", 1) in parsed.losses
+    assert any(e.kind == EventKind.MESSAGE and e.role == Role.USER for e in parsed.events)
+
+
+def test_file_metadata_omission_is_explicit(tmp_path):
+    value = json.loads(artifact(tmp_path).native_bytes)
+    user = next(m for m in value["messages"] if m["type"] == "user")
+    user["files"] = [
+        {
+            "data": "aGVsbG8=",
+            "mime": "image/png",
+            "source": {"type": "uri", "uri": "file:///private/image.png"},
+            "name": "image.png",
+        }
+    ]
+    path = tmp_path / "file-metadata.json"
+    path.write_text(json.dumps(value))
+    parsed = opencode.parse_import(path)
+    assert ("opencode_v2_file_metadata", 1) in parsed.losses
+    assert any(e.kind == EventKind.CONTEXT for e in parsed.events)
+
+
+@pytest.mark.parametrize("named_files", [1, 2])
+def test_tool_file_metadata_loss_is_counted_per_block_through_conversion(tmp_path, named_files):
+    value = json.loads(artifact(tmp_path).native_bytes)
+    tool = next(
+        content
+        for message in value["messages"]
+        if message["type"] == "assistant"
+        for content in message["content"]
+        if content["type"] == "tool"
+    )
+    uri = "data:image/png;base64,aGVsbG8="
+    file_block = {"type": "file", "uri": uri, "mime": "image/png"}
+    tool["state"]["content"].extend(
+        {**file_block, "name": f"synthetic-filename-{index}.png"} for index in range(named_files)
+    )
+    tool["state"]["content"].append(file_block)
+    expected_uris = [block["uri"] for block in tool["state"]["content"] if block["type"] == "file"]
+    path = tmp_path / "tool-file-metadata.json"
+    path.write_text(json.dumps(value))
+    source = opencode.parse_session(path)
+    target = convert_session(
+        source,
+        ConversionOptions(TargetFormat.OPENCODE, target_cli_version="2.0.23", cwd=tmp_path),
+    )
+    assert target.dropped["opaque:opencode_v2_tool_file_metadata"] == named_files
+    target_tool = next(
+        content
+        for message in json.loads(target.native_bytes)["messages"]
+        if message["type"] == "assistant"
+        for content in message["content"]
+        if content["type"] == "tool" and content["id"] == tool["id"]
+    )
+    files = [block for block in target_tool["state"]["content"] if block["type"] == "file"]
+    assert [block["uri"] for block in files] == expected_uris
+    assert b"synthetic-filename" not in target.native_bytes
+
+
+def test_kilo_metadata_override_keeps_legacy_schema(tmp_path):
+    session = load_session(FIXTURES / "codex-0.144.4/basic.jsonl", AgentFormat.CODEX)
+    target = convert_session(
+        session,
+        ConversionOptions(TargetFormat.KILO, target_cli_version="2.0.23", cwd=tmp_path),
+    )
+    value = json.loads(target.native_bytes)
+    assert value["info"]["version"] == "2.0.23"
+    assert "directory" in value["info"] and "location" not in value["info"]
+    assert all("info" in message and "parts" in message for message in value["messages"])
+
+
+def test_kilo_rejects_opencode_v2_schema(tmp_path):
+    from session_migrate.formats import kilo
+    from session_migrate.inspection import inspect_session
+
+    target = artifact(tmp_path)
+    with pytest.raises(SessionMigrateError, match="legacy nested"):
+        kilo.validate_native_bytes(target.native_bytes, target.session_id)
+    path = tmp_path / "opencode-v2.json"
+    path.write_bytes(target.native_bytes)
+    with pytest.raises(SessionMigrateError, match="legacy nested"):
+        kilo.parse_session(path)
+    with pytest.raises(SessionMigrateError, match="requires --format opencode"):
+        inspect_session(path, source_format=AgentFormat.KILO)
+
+
+@pytest.mark.parametrize("field, malformed", [("cost", "invalid"), ("tokens", {}), ("model", {})])
+def test_v2_compaction_validates_native_metadata_before_projection(tmp_path, field, malformed):
+    value = json.loads(artifact(tmp_path).native_bytes)
+    compaction = next(message for message in value["messages"] if message["type"] == "compaction")
+    compaction[field] = malformed
+    with pytest.raises(SessionMigrateError):
+        opencode.validate_native_bytes(json.dumps(value).encode(), value["info"]["id"])
+
+
+def test_v2_running_tool_requires_native_metadata(tmp_path):
+    value = json.loads(artifact(tmp_path).native_bytes)
+    tool = next(
+        content
+        for message in value["messages"]
+        if message["type"] == "assistant"
+        for content in message["content"]
+        if content["type"] == "tool"
+    )
+    tool["state"] = {"status": "running", "input": {}}
+    with pytest.raises(SessionMigrateError, match="running tool has invalid metadata"):
+        opencode.validate_native_bytes(json.dumps(value).encode(), value["info"]["id"])
+
+
+@pytest.mark.parametrize(
+    "field, malformed",
+    [
+        ("permissions", 42),
+        ("permissions", [{"permission": "read", "pattern": "*", "action": "allow"}]),
+        ("metadata", []),
+        ("fork", 42),
+        ("outcome", "not-outcome"),
+        ("location", {"directory": 42}),
+    ],
+)
+def test_v2_native_session_metadata_cannot_disappear_before_validation(tmp_path, field, malformed):
+    value = json.loads(artifact(tmp_path).native_bytes)
+    value["info"][field] = malformed
+    with pytest.raises(SessionMigrateError):
+        opencode.validate_native_bytes(json.dumps(value).encode(), value["info"]["id"])
+
+
+def test_v2_tool_error_requires_structured_type(tmp_path):
+    value = json.loads(artifact(tmp_path).native_bytes)
+    tool = next(
+        content
+        for message in value["messages"]
+        if message["type"] == "assistant"
+        for content in message["content"]
+        if content["type"] == "tool"
+    )
+    tool["state"] = {"status": "error", "input": {}, "error": {"message": "missing type"}}
+    with pytest.raises(SessionMigrateError, match="invalid structured error"):
+        opencode.validate_native_bytes(json.dumps(value).encode(), value["info"]["id"])
+
+
+def test_router_mirrored_model_lands_on_the_target_provider(tmp_path):
+    """A model mirrored by a router under `oc/` must resolve to OpenCode itself.
+
+    Routers keep their own provider id while serving OpenCode's catalogue under an `oc/`
+    prefix.  OpenCode resolves its next turn from the reference the last message carries,
+    so a session imported with the router's provider id sends free-tier traffic through
+    the router and is refused.
+    """
+
+    session = load_session(FIXTURES / "codex-0.144.4/basic.jsonl", AgentFormat.CODEX)
+    converted = convert_session(
+        session,
+        ConversionOptions(
+            target_format=TargetFormat.OPENCODE,
+            target_cli_version="2.0.23",
+            cwd=tmp_path,
+            model_provider="9router",
+            model="oc/deepseek-v4.1-flash-free",
+        ),
+    )
+    value = json.loads(converted.native_bytes)
+    refs = [value["info"]["model"]] + [m["model"] for m in value["messages"] if "model" in m]
+    assert refs
+    assert {r["providerID"] for r in refs} == {"opencode"}
+    assert {r["id"] for r in refs} == {"deepseek-v4.1-flash-free"}
+
+
+def test_model_reference_without_the_target_namespace_is_untouched(tmp_path):
+    session = load_session(FIXTURES / "codex-0.144.4/basic.jsonl", AgentFormat.CODEX)
+    converted = convert_session(
+        session,
+        ConversionOptions(
+            target_format=TargetFormat.OPENCODE,
+            target_cli_version="2.0.23",
+            cwd=tmp_path,
+            model_provider="fixture",
+            model="test",
+        ),
+    )
+    value = json.loads(converted.native_bytes)
+    refs = [value["info"]["model"]] + [m["model"] for m in value["messages"] if "model" in m]
+    assert {r["providerID"] for r in refs} == {"fixture"}
+    assert {r["id"] for r in refs} == {"test"}
diff --git a/tests/test_opencode_v2_native.py b/tests/test_opencode_v2_native.py
new file mode 100644
index 0000000..2a68d5b
--- /dev/null
+++ b/tests/test_opencode_v2_native.py
@@ -0,0 +1,119 @@
+"""Pinned v2 native import/export, cold reopen and localhost-only continuation."""
+
+import json
+import os
+import subprocess
+from dataclasses import replace
+from pathlib import Path
+
+import pytest
+from offline_provider import offline_provider
+
+from session_migrate.conversion import ConversionOptions, convert_session, install_opencode_artifact
+from session_migrate.formats import codex
+from session_migrate.model import EventKind, TargetFormat
+
+
+@pytest.mark.parametrize("compaction", [False, True])
+def test_pinned_v2_native_reopens_and_continues_same_session(tmp_path, compaction):
+    binary = os.environ.get("SESSION_MIGRATE_TEST_OPENCODE_V2")
+    if not binary:
+        pytest.skip("set SESSION_MIGRATE_TEST_OPENCODE_V2 to a stock 2.0.22 or 2.0.23 executable")
+    env = {"PATH": "/usr/bin:/bin", "LANG": "C.UTF-8", "OPENCODE_DISABLE_AUTOUPDATE": "true"}
+    for key in [
+        "HOME",
+        "XDG_CONFIG_HOME",
+        "XDG_DATA_HOME",
+        "XDG_CACHE_HOME",
+        "XDG_STATE_HOME",
+        "TMPDIR",
+    ]:
+        folder = tmp_path / key.lower()
+        folder.mkdir()
+        env[key] = str(folder)
+    project = tmp_path / "project"
+    project.mkdir()
+
+    def run(arguments):
+        result = subprocess.run(
+            [binary, *arguments], cwd=project, env=env, capture_output=True, text=True, timeout=90
+        )
+        assert result.returncode == 0, result.stderr
+        return result.stdout
+
+    release = run(["--version"]).strip().removeprefix("opencode v")
+    assert release in {"2.0.22", "2.0.23"}
+    source = codex.parse(Path(__file__).parent / "fixtures/codex-0.144.4/basic.jsonl")
+    if not compaction:
+        source = replace(
+            source, events=tuple(e for e in source.events if e.kind != EventKind.COMPACTION)
+        )
+    with offline_provider("PINNED-V2-CONTINUED-BETA-2048") as provider:
+        config = project / "opencode.json"
+        config.write_text(
+            json.dumps(
+                {
+                    "warming": False,
+                    "disabled_providers": ["opencode"],
+                    "providers": {
+                        "fixture": {
+                            "package": "@opencode/ai/providers/openai-compatible",
+                            "settings": {
+                                "apiKey": "fake-only",
+                                "baseURL": f"http://127.0.0.1:{provider.server_port}/v1",
+                            },
+                            "models": {"test": {"limit": {"context": 64000, "output": 4096}}},
+                        }
+                    },
+                }
+            )
+        )
+        env["OPENCODE_CONFIG"] = str(config)
+        artifact = convert_session(
+            source,
+            ConversionOptions(
+                target_format=TargetFormat.OPENCODE,
+                target_cli_version=release,
+                cwd=project,
+                model_provider="fixture",
+                model="test",
+            ),
+        )
+        install_opencode_artifact(
+            artifact, manifest_path=tmp_path / "manifest.json", target_cli=Path(binary), environ=env
+        )
+        before = json.loads(run(["session", "export", artifact.session_id, "--standalone"]))
+        # Every invocation is a new process: continuation and final export cold-reopen storage.
+        run(
+            [
+                "run",
+                "--session",
+                artifact.session_id,
+                "--model",
+                "fixture/test",
+                "--standalone",
+                "--format",
+                "json",
+                "pinned native continuation probe",
+            ]
+        )
+        after = json.loads(run(["session", "export", artifact.session_id, "--standalone"]))
+        assert after["info"]["id"] == before["info"]["id"] == artifact.session_id
+        assert len(after["messages"]) > len(before["messages"])
+        assert any(
+            c.get("text") == provider.reply
+            for m in after["messages"]
+            if m["type"] == "assistant"
+            for c in m["content"]
+            if c["type"] == "text"
+        )
+        assert provider.requests
+        for path, body in provider.requests:
+            assert path.endswith("/chat/completions")
+            assert "BETA-2048" in json.dumps(body)
+            assert "pinned native continuation probe" in json.dumps(body)
+            if not compaction:
+                assert any(
+                    m.get("role") == "tool" and "/work" in json.dumps(m) for m in body["messages"]
+                )
+                assert "call_fixture_1" in json.dumps(body)
diff --git a/tests/test_opencode_v2_review.py b/tests/test_opencode_v2_review.py
new file mode 100644
index 0000000..49328b6
--- /dev/null
+++ b/tests/test_opencode_v2_review.py
@@ -0,0 +1,622 @@
+"""Regression coverage for native v2 content and validation before projection."""
+
+# From TheViniAlmeida's PR #17 review-fix commit 2e3671d; see docs/opencode-v2.md.
+
+import json
+import os
+import subprocess
+from dataclasses import replace
+from pathlib import Path
+
+import pytest
+
+from session_migrate.conversion import ConversionOptions, convert_session, load_session
+from session_migrate.errors import SessionMigrateError
+from session_migrate.formats import opencode
+from session_migrate.model import AgentFormat, EventKind, TargetFormat
+
+FIXTURES = Path(__file__).parent / "fixtures"
+IMAGE_A = "data:image/png;base64,iVBORw0KGgo="
+IMAGE_B = "data:image/jpeg;base64,/9j/2Q=="
+
+
+def source_bundle(tmp_path):
+    source = load_session(FIXTURES / "codex-0.144.4/basic.jsonl", AgentFormat.CODEX)
+    return json.loads(convert_session(source, options(tmp_path)).native_bytes)
+
+
+def options(tmp_path, release="2.0.23"):
+    return ConversionOptions(
+        TargetFormat.OPENCODE,
+        target_cli_version=release,
+        cwd=tmp_path,
+        model_provider="fixture",
+        model="test",
+    )
+
+
+def tool(bundle):
+    return next(
+        c
+        for m in bundle["messages"]
+        if m["type"] == "assistant"
+        for c in m["content"]
+        if c["type"] == "tool"
+    )
+
+
+def rewrite(bundle, tmp_path, release="2.0.23"):
+    path = tmp_path / "source-v2.json"
+    path.write_text(json.dumps(bundle))
+    source = opencode.parse_session(path)
+    artifact = convert_session(source, options(tmp_path, release))
+    return json.loads(artifact.native_bytes), artifact.dropped, source
+
+
+def mixed_blocks():
+    # The basic fixture has no tool image; use independent synthetic images.
+    return [
+        {"type": "text", "text": "First image: copper"},
+        {"type": "file", "uri": IMAGE_A, "mime": "image/png"},
+        {"type": "text", "text": "Second image: blue"},
+        {"type": "file", "uri": IMAGE_B, "mime": "image/jpeg"},
+    ]
+
+
+def test_preserve_tool_block_order(tmp_path):
+    bundle = source_bundle(tmp_path)
+    blocks = mixed_blocks()
+    tool(bundle)["state"]["content"] = blocks
+    rewritten, losses, _ = rewrite(bundle, tmp_path)
+    assert tool(rewritten)["state"]["content"] == blocks, {
+        "actual": tool(rewritten)["state"]["content"],
+        "losses": losses,
+    }
+
+
+def test_structured_error_preserved_or_counted(tmp_path):
+    bundle = source_bundle(tmp_path)
+    error = {
+        "type": "ConflictError",
+        "message": "same error text",
+        "status": 409,
+        "response": {"body": "specific diagnostic"},
+    }
+    tool(bundle)["state"] = {"status": "error", "input": {"command": "true"}, "error": error}
+    rewritten, losses, _ = rewrite(bundle, tmp_path)
+    assert tool(rewritten)["state"]["error"] == error or any("error" in k for k in losses), {
+        "actual": tool(rewritten)["state"]["error"],
+        "losses": losses,
+    }
+
+
+@pytest.mark.parametrize("mutation", ["missing-system-text", "array-title"])
+def test_malformed_native_fields_rejected_before_projection(tmp_path, mutation):
+    bundle = source_bundle(tmp_path)
+    if mutation == "array-title":
+        bundle["info"]["title"] = []
+    else:
+        bundle["messages"].append(
+            {
+                "id": "msg_invalid_control",
+                "type": "system",
+                "time": {"created": bundle["info"]["time"]["updated"]},
+            }
+        )
+    with pytest.raises(SessionMigrateError):
+        opencode.validate_native_bytes(json.dumps(bundle).encode(), bundle["info"]["id"])
+
+
+@pytest.mark.parametrize("release", ["2.0.22", "2.0.23"])
+@pytest.mark.parametrize(
+    "blocks",
+    [mixed_blocks(), [{"type": "text", "text": ""}, *mixed_blocks(), {"type": "text", "text": ""}]],
+)
+def test_tool_blocks_preserve_segmentation_and_portable_payload(tmp_path, release, blocks):
+    bundle = source_bundle(tmp_path)
+    tool(bundle)["state"]["content"] = blocks
+    rewritten, losses, source = rewrite(bundle, tmp_path, release)
+    result = next(e for e in source.events if e.kind == EventKind.TOOL_RESULT)
+    expected = [
+        {"type": "text", "text": b["text"]}
+        if b["type"] == "text"
+        else {"type": "image", "image_url": b["uri"]}
+        for b in blocks
+    ]
+    # Payload is compare=False: compare it explicitly instead of Event equality.
+    assert result.payload["content_blocks"] == expected
+    assert tool(rewritten)["state"]["content"] == blocks
+    assert losses == {}
+
+
+@pytest.mark.parametrize("target", [TargetFormat.CLAUDE, TargetFormat.CODEX, TargetFormat.PI])
+def test_v2_tool_order_survives_capable_targets(tmp_path, target):
+    from session_migrate.formats import claude, codex, pi
+
+    bundle = source_bundle(tmp_path)
+    tool(bundle)["state"]["content"] = mixed_blocks()
+    _, _, source = rewrite(bundle, tmp_path)
+    migrated = convert_session(
+        source, ConversionOptions(target, cwd=tmp_path, model_provider="fixture", model="test")
+    )
+    path = tmp_path / "target.jsonl"
+    path.write_bytes(migrated.native_bytes)
+    parser = {
+        TargetFormat.CLAUDE: claude.parse,
+        TargetFormat.CODEX: codex.parse,
+        TargetFormat.PI: pi.parse_session,
+    }[target]
+    parsed = parser(path)
+    results = [e for e in parsed.events if e.kind == EventKind.TOOL_RESULT]
+    expected = [
+        {"type": "text", "text": "First image: copper"},
+        {"type": "image", "image_url": IMAGE_A},
+        {"type": "text", "text": "Second image: blue"},
+        {"type": "image", "image_url": IMAGE_B},
+    ]
+    assert results[0].payload["content_blocks"] == expected
+
+
+@pytest.mark.parametrize("target", [TargetFormat.OPENCODE, TargetFormat.KILO])
+def test_legacy_order_degradation_is_counted(tmp_path, target):
+    bundle = source_bundle(tmp_path)
+    tool(bundle)["state"]["content"] = mixed_blocks()
+    _, _, source = rewrite(bundle, tmp_path)
+    migrated = convert_session(
+        source,
+        ConversionOptions(
+            target,
+            target_cli_version="1.17.20" if target == TargetFormat.OPENCODE else "7.5.0",
+            cwd=tmp_path,
+        ),
+    )
+    value = json.loads(migrated.native_bytes)
+    state = next(p["state"] for m in value["messages"] for p in m["parts"] if p["type"] == "tool")
+    assert state["output"] == "First image: copper\nSecond image: blue"
+    assert [a["url"] for a in state["attachments"]] == [IMAGE_A, IMAGE_B]
+    assert migrated.dropped["tool_result:content_block_order"] == 1
+
+
+def test_tool_error_fields_have_individual_safe_provenance_and_manifest_losses(tmp_path):
+    bundle = source_bundle(tmp_path)
+    tool(bundle)["state"] = {
+        "status": "error",
+        "input": {},
+        "error": {
+            "type": "ConflictError",
+            "message": "same error text",
+            "status": 409,
+            "response": {"body": "SYNTHETIC_DIAGNOSTIC_NOT_PORTABLE"},
+        },
+    }
+    rewritten, losses, source = rewrite(bundle, tmp_path)
+    expected = {
+        "opencode_v2_tool_error_type",
+        "opencode_v2_tool_error_status",
+        "opencode_v2_tool_error_response",
+    }
+    omitted = [e for e in source.events if e.kind == EventKind.OPAQUE]
+    assert {e.payload["reason"] for e in omitted} == expected
+    source_index = next(
+        i
+        for i, m in enumerate(bundle["messages"])
+        if m["type"] == "assistant" and any(c["type"] == "tool" for c in m["content"])
+    )
+    assert all(e.provenance.record_index == source_index for e in omitted)
+    assert losses == {f"opaque:{reason}": 1 for reason in expected}
+    assert all("SYNTHETIC_DIAGNOSTIC" not in str(e.payload) for e in source.events)
+    assert all("SYNTHETIC_DIAGNOSTIC" not in (e.text or "") for e in source.events)
+    assert tool(rewritten)["state"]["error"] == {"type": "ToolError", "message": "same error text"}
+    artifact = convert_session(source, options(tmp_path))
+    manifest = artifact.manifest(output_path=tmp_path / "target.json")
+    assert manifest["dropped_events"] == losses
+    assert "SYNTHETIC_DIAGNOSTIC" not in json.dumps(manifest)
+
+
+CONTROLS = [
+    ("system", {"text": "fixture update", "description": "fixture summary"}, ("text",)),
+    ("synthetic", {"text": "fixture", "description": "fixture"}, ("text",)),
+    (
+        "skill",
+        {"skill": "fixture", "name": "fixture", "text": "fixture"},
+        ("skill", "name", "text"),
+    ),
+    ("agent-switched", {"agent": "build", "previous": "plan"}, ("agent",)),
+    (
+        "model-switched",
+        {
+            "model": {"id": "test", "providerID": "fixture"},
+            "previous": {"id": "previous", "providerID": "fixture"},
+        },
+        ("model",),
+    ),
+    (
+        "location-switched",
+        {
+            "location": {"directory": "/fixture"},
+            "previous": {"location": {"directory": "/previous"}},
+        },
+        ("location",),
+    ),
+    (
+        "shell",
+        {
+            "shellID": "sh_fixture",
+            "command": "fixture",
+            "status": "exited",
+            "exit": 0,
+            "output": {"output": "fixture", "cursor": 7, "size": 7, "truncated": False},
+        },
+        ("shellID", "command", "status"),
+    ),
+    ("idle", {"outcome": "succeeded"}, ("outcome",)),
+    (
+        "compaction",
+        {"status": "running", "reason": "auto", "summary": "", "recent": ""},
+        ("status", "reason", "summary", "recent"),
+    ),
+    (
+        "compaction",
+        {
+            "status": "failed",
+            "reason": "manual",
+            "error": {"type": "FixtureError", "message": "fake"},
+        },
+        ("status", "reason", "error"),
+    ),
+]
+REQUIRED_CONTROLS = [
+    (kind, fields, required) for kind, fields, keys in CONTROLS for required in keys
+]
+
+
+def append_control(bundle, kind, fields):
+    control = {
+        "id": "msg_fixture_control",
+        "type": kind,
+        "time": {"created": bundle["info"]["time"]["updated"]},
+        **fields,
+    }
+    bundle["messages"].append(control)
+    return control
+
+
+@pytest.mark.parametrize("kind,fields,required", REQUIRED_CONTROLS)
+@pytest.mark.parametrize("malformed", ["missing", None, []])
+def test_all_control_required_fields_validated_before_projection(
+    tmp_path, kind, fields, required, malformed
+):
+    bundle = source_bundle(tmp_path)
+    control = append_control(bundle, kind, fields)
+    if malformed == "missing":
+        control.pop(required)
+    else:
+        control[required] = malformed
+    data = json.dumps(bundle).encode()
+    path = tmp_path / "malformed.json"
+    path.write_bytes(data)
+    with pytest.raises(SessionMigrateError):
+        opencode.validate_native_bytes(data, bundle["info"]["id"])
+    with pytest.raises(SessionMigrateError):
+        opencode.parse_session(path)
+
+
+@pytest.mark.parametrize("kind,fields,required", CONTROLS)
+def test_valid_control_variants_are_accepted_and_omissions_counted(
+    tmp_path, kind, fields, required
+):
+    bundle = source_bundle(tmp_path)
+    append_control(bundle, kind, fields)
+    _, losses, source = rewrite(bundle, tmp_path)
+    reason = (
+        f"opencode_v2_compaction_{fields['status']}"
+        if kind == "compaction"
+        else f"opencode_v2_{kind}_record"
+    )
+    assert losses[f"opaque:{reason}"] == 1
+    assert not any(
+        e.text == fields.get("text") for e in source.events if e.kind == EventKind.MESSAGE
+    )
+
+
+@pytest.mark.parametrize(
+    "field",
+    [
+        "title",
+        "parentID",
+        "agent",
+        "model",
+        "outcome",
+        "subpath",
+        "metadata",
+        "permissions",
+        "fork",
+        "revert",
+    ],
+)
+def test_native_optional_session_fields_accept_absence_but_reject_null(tmp_path, field):
+    bundle = source_bundle(tmp_path)
+    bundle["info"].pop(field, None)
+    opencode.validate_native_bytes(json.dumps(bundle).encode(), bundle["info"]["id"])
+    bundle["info"][field] = None
+    with pytest.raises(SessionMigrateError):
+        opencode.validate_native_bytes(json.dumps(bundle).encode(), bundle["info"]["id"])
+
+
+@pytest.mark.parametrize("field", ["id", "projectID", "cost", "tokens", "time", "location"])
+def test_native_required_session_fields_cannot_be_defaulted(tmp_path, field):
+    bundle = source_bundle(tmp_path)
+    bundle["info"].pop(field)
+    with pytest.raises(SessionMigrateError):
+        opencode.validate_native_bytes(json.dumps(bundle).encode(), "ses_fixture")
+
+
+@pytest.mark.parametrize(
+    "mutation",
+    [
+        "null-description",
+        "bad-previous-model",
+        "bad-previous-location",
+        "bad-shell-output",
+        "bad-clock",
+        "duplicate-control-id",
+        "bad-model-variant",
+    ],
+)
+def test_dropped_control_nested_metadata_is_validated(tmp_path, mutation):
+    bundle = source_bundle(tmp_path)
+    if mutation == "null-description":
+        append_control(bundle, "system", {"text": "fixture", "description": None})
+    elif mutation == "bad-previous-model":
+        append_control(
+            bundle,
+            "model-switched",
+            {"model": {"id": "test", "providerID": "fixture"}, "previous": {"id": "fake"}},
+        )
+    elif mutation == "bad-previous-location":
+        append_control(
+            bundle,
+            "location-switched",
+            {"location": {"directory": "/fixture"}, "previous": {"location": {"directory": []}}},
+        )
+    elif mutation == "bad-shell-output":
+        append_control(
+            bundle,
+            "shell",
+            {
+                "shellID": "sh_fixture",
+                "command": "fixture",
+                "status": "exited",
+                "output": {"output": "fixture"},
+            },
+        )
+    elif mutation == "bad-model-variant":
+        append_control(
+            bundle,
+            "model-switched",
+            {"model": {"id": "test", "providerID": "fixture", "variant": None}},
+        )
+    else:
+        control = append_control(bundle, "idle", {"outcome": "succeeded"})
+        if mutation == "bad-clock":
+            control["time"]["completed"] = None
+        else:
+            bundle["messages"].append(control)
+    with pytest.raises(SessionMigrateError):
+        opencode.validate_native_bytes(json.dumps(bundle).encode(), bundle["info"]["id"])
+
+
+@pytest.mark.parametrize("mutation", ["missing-system-text", "array-title"])
+def test_dry_run_rejects_invalid_native_source_without_target_side_effects(
+    tmp_path, mutation, capsys
+):
+    from session_migrate.cli import main
+
+    bundle = source_bundle(tmp_path)
+    if mutation == "array-title":
+        bundle["info"]["title"] = []
+    else:
+        append_control(bundle, "system", {})
+    path = tmp_path / "invalid-source.json"
+    path.write_text(json.dumps(bundle))
+    target = tmp_path / "output"
+    assert (
+        main(
+            [
+                "import",
+                str(path),
+                "--format",
+                "opencode",
+                "--to",
+                "opencode",
+                "--target-cli-version",
+                "2.0.23",
+                "--home",
+                str(target),
+                "--dry-run",
+            ]
+        )
+        != 0
+    )
+    captured = capsys.readouterr()
+    assert "invalid" in captured.err or "malformed" in captured.err
+    assert not target.exists()
+
+
+def test_native_safety_limits_cover_content_erased_by_projection(tmp_path, monkeypatch):
+    bundle = source_bundle(tmp_path)
+    # Text-only native tool blocks collapse to one legacy part: count before that collapse.
+    tool(bundle)["state"]["content"] = [{"type": "text", "text": "fixture"}] * 30
+    monkeypatch.setattr(opencode, "MAX_NATIVE_PARTS", 20)
+    with pytest.raises(SessionMigrateError, match="too much content"):
+        opencode.validate_native_bytes(json.dumps(bundle).encode(), bundle["info"]["id"])
+    monkeypatch.setattr(opencode, "MAX_NATIVE_PARTS", 1000)
+    monkeypatch.setattr(opencode, "MAX_NATIVE_MESSAGES", len(bundle["messages"]))
+    append_control(bundle, "system", {"text": "fixture"})
+    with pytest.raises(SessionMigrateError, match="invalid messages"):
+        opencode.validate_native_bytes(json.dumps(bundle).encode(), bundle["info"]["id"])
+
+
+def test_legacy_input_cannot_forge_native_content_carrier(tmp_path):
+    bundle = source_bundle(tmp_path)
+    _, _, source = rewrite(bundle, tmp_path)
+    artifact = convert_session(source, options(tmp_path, "1.17.20"))
+    legacy = json.loads(artifact.native_bytes)
+    state = next(p["state"] for m in legacy["messages"] for p in m["parts"] if p["type"] == "tool")
+    state["content"] = mixed_blocks()
+    state["content_blocks"] = [{"type": "text", "text": "FORGED_NATIVE_CARRIER"}]
+    path = tmp_path / "legacy.json"
+    path.write_text(json.dumps(legacy))
+    parsed = opencode.parse_session(path)
+    assert "FORGED_NATIVE_CARRIER" not in str([e.payload for e in parsed.events])
+
+
+@pytest.mark.parametrize("target", [TargetFormat.OPENCODE, TargetFormat.KILO])
+@pytest.mark.parametrize(
+    "blocks,expected",
+    [
+        ([{"type": "text", "text": "caption"}], 0),
+        ([{"type": "text", "text": "caption"}, {"type": "image", "image_url": IMAGE_A}], 0),
+        ([{"type": "image", "image_url": IMAGE_A}], 0),
+        ([{"type": "text", "text": "A"}, {"type": "text", "text": "B"}], 1),
+        ([{"type": "image", "image_url": IMAGE_A}, {"type": "text", "text": "caption"}], 1),
+        ([{"type": "text", "text": ""}, {"type": "image", "image_url": IMAGE_A}], 1),
+    ],
+)
+def test_legacy_loss_oracle_counts_only_lost_segmentation_or_order(
+    tmp_path, target, blocks, expected
+):
+    from native_corpus.route_oracle import expected_loss_counters
+
+    source = load_session(FIXTURES / "codex-0.144.4/basic.jsonl", AgentFormat.CODEX)
+    result = next(e for e in source.events if e.kind == EventKind.TOOL_RESULT)
+    modified = replace(
+        result,
+        text="\n".join(b["text"] for b in blocks if b["type"] == "text") or None,
+        payload={"content_blocks": blocks},
+    )
+    source = replace(source, events=tuple(modified if e is result else e for e in source.events))
+    artifact = convert_session(source, ConversionOptions(target, cwd=tmp_path))
+    oracle = expected_loss_counters(source, target.value)
+    assert oracle.get("tool_result:content_block_order", 0) == expected
+    assert artifact.dropped == oracle
+
+
+@pytest.mark.parametrize(
+    "case",
+    ["mixed", "structured-error", "missing-system-text", "array-title", "private-checkpoint"],
+)
+def test_stock_v2_accepts_and_cold_exports_review_sources_and_fixed_targets(tmp_path, case):
+    binary = os.environ.get("SESSION_MIGRATE_TEST_OPENCODE_V2")
+    if not binary:
+        pytest.skip("set SESSION_MIGRATE_TEST_OPENCODE_V2 to stock 2.0.22 or 2.0.23")
+    env = {
+        "PATH": "/usr/bin:/bin",
+        "LANG": "C.UTF-8",
+        "OPENCODE_DISABLE_AUTOUPDATE": "true",
+        "OPENCODE_CONFIG_CONTENT": '{"warming":false,"disabled_providers":["opencode"]}',
+    }
+    for key in (
+        "HOME",
+        "XDG_CONFIG_HOME",
+        "XDG_DATA_HOME",
+        "XDG_CACHE_HOME",
+        "XDG_STATE_HOME",
+        "TMPDIR",
+    ):
+        directory = tmp_path / key.lower()
+        directory.mkdir()
+        env[key] = str(directory)
+
+    def run(*args):
+        result = subprocess.run(
+            [binary, *args], cwd=tmp_path, env=env, capture_output=True, text=True, timeout=90
+        )
+        assert result.returncode == 0, result.stderr
+        return result.stdout
+
+    assert run("--version").strip().removeprefix("opencode v") in {"2.0.22", "2.0.23"}
+    bundle = source_bundle(tmp_path)
+    if case == "mixed":
+        tool(bundle)["state"]["content"] = mixed_blocks()
+    elif case == "structured-error":
+        tool(bundle)["state"] = {
+            "status": "error",
+            "input": {},
+            "error": {
+                "type": "ConflictError",
+                "message": "same error text",
+                "status": 409,
+                "response": {"body": "specific synthetic diagnostic"},
+            },
+        }
+    elif case == "array-title":
+        bundle["info"]["title"] = []
+    elif case == "private-checkpoint":
+        bundle["messages"] = [m for m in bundle["messages"] if m["type"] != "compaction"]
+        append_control(
+            bundle,
+            "compaction",
+            {
+                "status": "completed",
+                "reason": "auto",
+                "summary": "",
+                "recent": "",
+                "providerState": {"encrypted": "SYNTHETIC_PRIVATE_CHECKPOINT"},
+                "providerContext": {
+                    "version": 1,
+                    "provenance": {
+                        "providerID": "fixture",
+                        "provider": "fixture",
+                        "modelID": "test",
+                        "route": "fixture",
+                        "protocol": "fixture",
+                        "endpoint": "fixture-digest",
+                    },
+                    "messages": [],
+                },
+            },
+        )
+    else:
+        append_control(bundle, "system", {})
+    path = tmp_path / "stock-source.json"
+    path.write_text(json.dumps(bundle))
+    if case in {"missing-system-text", "array-title"}:
+        rejected = subprocess.run(
+            [binary, "session", "import", str(path), "--directory", str(tmp_path), "--standalone"],
+            cwd=tmp_path,
+            env=env,
+            capture_output=True,
+            text=True,
+            timeout=90,
+        )
+        assert rejected.returncode != 0
+        assert "SchemaError" in rejected.stderr
+        return
+    run("session", "import", str(path), "--directory", str(tmp_path), "--standalone")
+    accepted = json.loads(run("session", "export", bundle["info"]["id"], "--standalone"))
+    assert tool(accepted)["state"] == tool(bundle)["state"]
+    path.write_text(json.dumps(accepted))
+    source = opencode.parse_session(path)
+    migrated = convert_session(source, options(tmp_path))
+    path.write_bytes(migrated.native_bytes)
+    run("session", "import", str(path), "--directory", str(tmp_path), "--standalone")
+    exported = json.loads(run("session", "export", migrated.session_id, "--standalone"))
+    if case == "mixed":
+        assert tool(exported)["state"]["content"] == mixed_blocks()
+        # Stock may add its default model variant on import; this existing
+        # metadata omission is independent of the ordered tool result.
+        expected_losses = (
+            {"opaque:opencode_v2_session_model_variant": 1}
+            if accepted["info"].get("model", {}).get("variant")
+            else {}
+        )
+        assert migrated.dropped == expected_losses
+    elif case == "structured-error":
+        assert tool(exported)["state"]["error"]["message"] == "same error text"
+        assert migrated.dropped["opaque:opencode_v2_tool_error_response"] == 1
+    else:
+        assert not any(m["type"] == "compaction" for m in exported["messages"])
+        for reason in ("providerContext", "providerState", "compaction_empty_portable_summary"):
+            assert migrated.dropped[f"opaque:opencode_v2_{reason}"] == 1
+        assert "SYNTHETIC_PRIVATE_CHECKPOINT" not in migrated.native_bytes.decode()
diff --git a/tests/test_route_matrix.py b/tests/test_route_matrix.py
index f8b0ab3..d898563 100644
--- a/tests/test_route_matrix.py
+++ b/tests/test_route_matrix.py
@@ -53,6 +53,19 @@ def source_sessions(tmp_path: Path) -> dict[str, Session]:
             FIXTURES / "copilot-source-1.0.70" / "copilot-source-native-events.jsonl"
         ),
     }
+    v2_source = tmp_path / "v2-source.json"
+    v2_artifact = convert_session(
+        sessions["claude"],
+        ConversionOptions(
+            target_format=TargetFormat.OPENCODE,
+            target_cli_version="2.0.23",
+            cwd=tmp_path,
+            model_provider="fixture",
+            model="test",
+        ),
+    )
+    v2_source.write_bytes(v2_artifact.native_bytes)
+    sessions["opencode-v2"] = opencode.parse_session(v2_source)
     antigravity_id = "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb"
     antigravity_bytes, _ = antigravity.serialize(
         sessions["claude"],
@@ -334,6 +347,7 @@ def hermes_bundle_signature(data: bytes, session_id: str) -> list[Any]:
         "pi",
         "omp",
         "opencode",
+        "opencode-v2",
         "copilot",
         "antigravity",
         "cursor",
@@ -357,6 +371,7 @@ def hermes_bundle_signature(data: bytes, session_id: str) -> list[Any]:
         TargetFormat.PI,
         TargetFormat.OMP,
         TargetFormat.OPENCODE,
+        "opencode-v2",
         TargetFormat.COPILOT,
         TargetFormat.ANTIGRAVITY,
         TargetFormat.CURSOR,
@@ -376,10 +391,16 @@ def test_every_supported_source_to_target_route_preserves_portable_timeline(
     source_name: str, target: TargetFormat, tmp_path: Path
 ) -> None:
     source = source_sessions(tmp_path)[source_name]
+    v2_target = target == "opencode-v2"
+    if v2_target:
+        target = TargetFormat.OPENCODE
     artifact = convert_session(
         source,
         ConversionOptions(
             target_format=target,
+            target_cli_version="2.0.23" if v2_target else None,
+            model_provider="fixture",
+            model="test",
             session_id=TARGET_UUID,
             cwd=tmp_path,
         ),
diff --git a/tests/test_target_integration.py b/tests/test_target_integration.py
index 251d599..f24956a 100644
--- a/tests/test_target_integration.py
+++ b/tests/test_target_integration.py
@@ -1,4 +1,5 @@
 import json
+import sqlite3
 import subprocess
 from dataclasses import replace
 from pathlib import Path
@@ -33,6 +34,7 @@
     copilot,
     cursor,
     grok,
+    hermes,
     kilo,
     omp,
     opencode,
@@ -132,6 +134,7 @@ def test_source_and_target_enums_are_deliberately_separate() -> None:
         AgentFormat.OPENCODE,
         AgentFormat.COPILOT,
         AgentFormat.ANTIGRAVITY,
+        AgentFormat.ANTIGRAVITY_DESKTOP,
         AgentFormat.CURSOR,
         AgentFormat.VIBE,
         AgentFormat.MUSE,
@@ -152,6 +155,7 @@ def test_source_and_target_enums_are_deliberately_separate() -> None:
         TargetFormat.OPENCODE,
         TargetFormat.COPILOT,
         TargetFormat.ANTIGRAVITY,
+        TargetFormat.ANTIGRAVITY_DESKTOP,
         TargetFormat.CURSOR,
         TargetFormat.VIBE,
         TargetFormat.MUSE,
@@ -219,6 +223,63 @@ def test_cli_parser_accepts_every_target_and_expands_target_cli(
     assert imported.target_cli == tmp_path / ".opencode/bin/opencode"
 
 
+def hermes_artifact(tmp_path: Path, *, title: str | None) -> conversion.ConversionArtifact:
+    return convert_session(
+        replace(source_session(), title=title),
+        ConversionOptions(
+            target_format=TargetFormat.HERMES,
+            session_id=TARGET_UUID,
+            cwd=tmp_path,
+        ),
+    )
+
+
+def test_hermes_duplicate_target_title_is_omitted_counted_and_never_refused(
+    tmp_path: Path,
+) -> None:
+    """A title already present in the target store must not refuse the migration.
+
+    Hermes enforces a partial unique index over non-null session titles, so a
+    second session cannot reuse one, while its own importer treats the title as
+    cosmetic.  The migrator installs without it and counts the omission.
+    """
+
+    title = "Investigar timeout do Postgres"
+    artifact = hermes_artifact(tmp_path, title=title)
+    assert hermes.bundle_title(artifact.native_bytes) == title
+
+    home = tmp_path / "hermes-home"
+    home.mkdir(parents=True, exist_ok=True)
+    database = sqlite3.connect(home / "state.db")
+    database.execute("CREATE TABLE sessions (id TEXT PRIMARY KEY, title TEXT)")
+    database.execute("INSERT INTO sessions VALUES (?, ?)", (artifact.session_id, title))
+    database.commit()
+    database.close()
+
+    resolved = conversion._resolve_hermes_title_conflict(artifact, target_home=home)
+    assert resolved is not artifact
+    assert resolved.dropped == {**artifact.dropped, "title:duplicate_in_target": 1}
+    assert resolved.warnings[:-1] == artifact.warnings
+    assert resolved.warnings[-1]["code"] == "target_title_omitted"
+    assert resolved.warnings[-1]["title"] == title
+    assert hermes.bundle_title(resolved.native_bytes) is None
+    hermes.validate_native_bytes(resolved.native_bytes, artifact.session_id)
+    resolved_manifest = resolved.manifest(output_path=tmp_path)
+    original_manifest = artifact.manifest(output_path=tmp_path)
+    assert resolved_manifest["target"]["sha256"] != original_manifest["target"]["sha256"]
+    assert resolved_manifest["target"]["records"] == original_manifest["target"]["records"]
+    assert resolved_manifest["dropped_events"] == {
+        **original_manifest["dropped_events"],
+        "title:duplicate_in_target": 1,
+    }
+
+    # A free title, or a session with no title, keeps the bundle as generated.
+    empty_home = tmp_path / "empty-home"
+    assert conversion._resolve_hermes_title_conflict(artifact, target_home=empty_home) is artifact
+    untitled = hermes_artifact(tmp_path / "untitled", title=None)
+    assert conversion._resolve_hermes_title_conflict(untitled, target_home=home) is untitled
+
+
 @pytest.mark.parametrize(
     "target",
     [
@@ -793,6 +854,7 @@ def test_opencode_empty_official_session_list_means_no_collisions(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     completed = subprocess.CompletedProcess(args=[], returncode=0, stdout="", stderr="")
+    monkeypatch.setattr(conversion, "_opencode_version", lambda cli, env: "1.17.20")
     monkeypatch.setattr(conversion, "_run_opencode", lambda command, env: completed)
 
     assert conversion._opencode_session_ids(Path("/synthetic/opencode"), {}) == set()
@@ -907,6 +969,7 @@ def install(
         return target_cli or Path("opencode")
 
     monkeypatch.setattr(cli_module, "install_opencode_artifact", install)
+    monkeypatch.setattr(cli_module, "detect_opencode_version", lambda cli: "1.17.20")
     monkeypatch.setenv("XDG_STATE_HOME", str(state))
 
     status = main(
diff --git a/uv.lock b/uv.lock
index 5aeddb8..649ff20 100644
--- a/uv.lock
+++ b/uv.lock
@@ -65,32 +65,32 @@ wheels = [
 
 [[package]]
 name = "ruff"
-version = "0.16.3"
+version = "0.16.10"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/61/b3/3213589383f8f1b3938781bd1278713f6d18621a14992b3e81fefb8a5ef9/ruff-0.16.3.tar.gz", hash = "sha256:e76d33a347661a84b5be6d043d0347fdc745dfdcf825a8f4fed64b5e26eebdf2", size = 4891904, upload-time = "2026-08-13T15:17:13.381Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c4/49/23802c45f093eb14bde54b141d2b2f058edfa63a06db7beed047308cc08f/ruff-0.16.10.tar.gz", hash = "sha256:eff4728c4eaae93f0955cd264d24b2ab348e74bf59986ccf282ba6dc16b3b017", size = 4958724, upload-time = "2026-10-01T18:03:21.697Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/bf/96/493770daebd68c0a67f1549fdf519f53be51fc435186c0585bcc272fd76c/ruff-0.16.3-py3-none-linux_armv6l.whl", hash = "sha256:0c5710e247a58a4521e66e124ba9a74655b414f61ba3a2e9e3811e11098f48f7", size = 10902799, upload-time = "2026-08-13T15:16:27.382Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/e6/2becf3942fddc29a29b8df47691d456fb1085391a694f74d84513251418c/ruff-0.16.3-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:fe155130631a2471fd2e14a7a664a4dfbd7194b8229c3d7b2a40b21178639081", size = 11135539, upload-time = "2026-08-13T15:16:30.87Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/1e/4b8b72f0d006dbf19326aa99f9ca0ee2ff374187c4d301cf529a51aa06fe/ruff-0.16.3-py3-none-macosx_11_0_arm64.whl", hash = "sha256:e2ed719e14aa64d895c2ee922594a90a43c861a93f0575a95ff8c47cdbd13eb9", size = 10475095, upload-time = "2026-08-13T15:16:33.259Z" },
-    { url = "https://files.pythonhosted.org/packages/92/32/2201fa49ba1f6c101ee321e83f051ac7a4b8d07b0ef6b4d3f2772b302275/ruff-0.16.3-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9e0b1da805eb043654645d74d5de1e5ce2edc686e40790d2b86f56d71cc06a84", size = 10668771, upload-time = "2026-08-13T15:16:35.65Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/66/4afc5c8363bd04d45effce1b7c8713ca037d7a6740b7451a2403a6e3a972/ruff-0.16.3-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a37bdea0bbe21780f590bf437d6412c8c4e1b6cd010f91a65c2c40c5e5f5f870", size = 10699568, upload-time = "2026-08-13T15:16:38.195Z" },
-    { url = "https://files.pythonhosted.org/packages/53/fd/c67d246bf36bf1698551c56de39e95cd07f70e64433e0098e6267d77061b/ruff-0.16.3-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:09571e6d1288ed9be475207a3ac04ada404f1cd898104be0f6ab8d7df438575b", size = 11499365, upload-time = "2026-08-13T15:16:40.623Z" },
-    { url = "https://files.pythonhosted.org/packages/67/0b/00ecbceb99a263af7b12f6f05ac3c92bc47b905e91adc3f207a836e3bc01/ruff-0.16.3-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2c18c5a101eb540010638cc1ff3c84944d3adb3df62b8d98ca8f22ba484d3413", size = 12311728, upload-time = "2026-08-13T15:16:43.564Z" },
-    { url = "https://files.pythonhosted.org/packages/54/b2/b7b3bb54f4d3f7db504e476ad4ab8de530dceebe2c061384b2757ee419e8/ruff-0.16.3-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8457c44f15033c85ddbb77b15d451df9e24e4bd03b628396dd3610cedc3b8f82", size = 11699896, upload-time = "2026-08-13T15:16:46.209Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/30/4c468429ac195addc5ee1b717b6ab1b66632786737ca3b2ed3443fb0c26a/ruff-0.16.3-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:294b95c4ae0cda9388525c2047778aa758d6b8d4bb876fd4e9eaa3ebc92343eb", size = 11058736, upload-time = "2026-08-13T15:16:48.823Z" },
-    { url = "https://files.pythonhosted.org/packages/43/67/7a113cdaddf24b64d7f75b1242a99d04c82fcef4f6921fdbb832beaffb5f/ruff-0.16.3-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:3d0c7c40c87c2a820509c31ba007968da6e1306468c067b2d82fbfdbcd0e8474", size = 11586911, upload-time = "2026-08-13T15:16:51.913Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/c1/2e66f24c0f3ead25a5e660111778685e505e5da353c82802bf49f0cbe7b9/ruff-0.16.3-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:9f738c0fdfa8eed0b2ce7fb27ee7258208a92a68d7949e62aa15164bc7b389da", size = 10954265, upload-time = "2026-08-13T15:16:54.763Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/ba/4cee23bf52cba9a058d3726de623624daf50ef9638868edd86f4126157f6/ruff-0.16.3-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:fb785f0be25abe69d320415cd4f833b59e17ba7613d9ba6a958023b6bceb0a50", size = 10709886, upload-time = "2026-08-13T15:16:57.339Z" },
-    { url = "https://files.pythonhosted.org/packages/82/df/7da7194fa5d9dc0a285f7e6fa5a4722e7c63faac0b45b614ded9314363a1/ruff-0.16.3-py3-none-musllinux_1_2_i686.whl", hash = "sha256:c5536e3acfbf9563085aa2be7b13c629c3077e902afc5b941ac44024dbb9f506", size = 11210392, upload-time = "2026-08-13T15:17:00.171Z" },
-    { url = "https://files.pythonhosted.org/packages/35/85/7795f6e817af050e7517bf3e7aa9b061cce70ef33d280aad902c956c1ecf/ruff-0.16.3-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:a2d85c02f9b8e165d85e6779184d38c4132de12603dab59c51c28e22584f9e4d", size = 11626910, upload-time = "2026-08-13T15:17:03.299Z" },
-    { url = "https://files.pythonhosted.org/packages/78/9b/475b927cf27a5cbbda3c7bafb69ed6ff77e1d7923d5d85f17c2749d7ae32/ruff-0.16.3-py3-none-win32.whl", hash = "sha256:388cdf2166642bd9b13d52b5932d3170f34f8abed7e8d9a855f1d84b83645a0a", size = 10931415, upload-time = "2026-08-13T15:17:05.726Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/99/e2a2bfc4fbf0a1e8a916bc9ebe6fe6c58cc34c28e0ffc6ce281d572d1c2e/ruff-0.16.3-py3-none-win_amd64.whl", hash = "sha256:e80a7d69ca2a6d1c4d352ec91458cdca6e56c83cdbcabd93e4abe1e53591d948", size = 11445993, upload-time = "2026-08-13T15:17:08.353Z" },
-    { url = "https://files.pythonhosted.org/packages/69/3e/4132e539aed78c148854d4997a2685b0ed4dc4e87110b59ce528564e184e/ruff-0.16.3-py3-none-win_arm64.whl", hash = "sha256:b8ca152da82c1acc1fa8d5874b15951935f0eef46f10e6954c83859011b6178a", size = 11399302, upload-time = "2026-08-13T15:17:10.908Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/21/ebce22e1d90cdb2cd691026b9c6e9bec6499f0b396089481755b5d49efff/ruff-0.16.10-py3-none-linux_armv6l.whl", hash = "sha256:488b0fe3f3574210e5cf80d9f59b9e3ab17a127a8155de3f307b392589cfb511", size = 10095557, upload-time = "2026-10-01T18:02:36.072Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/98/a54de85876a8b2612bfa0d84c7b9abfb39c6a3354aee7800b09c1649b9e3/ruff-0.16.10-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:e748ff95c934c4e978783b8e687bc174e7bd84e8ad24e3243e1ecfcda5e0282d", size = 10340577, upload-time = "2026-10-01T18:02:39.258Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/16/1a5a4a2657effe4806110f2b907313802f1367fcdbb29e8122766e407fab/ruff-0.16.10-py3-none-macosx_11_0_arm64.whl", hash = "sha256:3031a4a2e8e7b8a46f70be45f198c35a11ece509a94b80334d8d397a33c67550", size = 9774282, upload-time = "2026-10-01T18:02:41.79Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/fb/470085af734da396e68cd80fb0a3e7c109a459716ae59588c0f6fab8a17d/ruff-0.16.10-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:494401c86df4c4c25f69b9419605d944467ee98c42fb6ad405ef4fa40b8fb67d", size = 9920895, upload-time = "2026-10-01T18:02:44.458Z" },
+    { url = "https://files.pythonhosted.org/packages/57/de/f10cffe4f88a37ea6615ec460f01bf76f0bc1477737a35d9ee61a630a78b/ruff-0.16.10-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d203abc0ff2b773ee33d00ab8df0bb67046fbc7c07b119332f08b9b345cf8221", size = 9902707, upload-time = "2026-10-01T18:02:47.041Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/44/3fdcedf83ae60ef837dd239170e480dce606a9142cfa2db911afdf855fd9/ruff-0.16.10-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bd83d1235a5258d318477bc5b576303974cbdef5df0c01a1bff14efcc23bd12a", size = 10619287, upload-time = "2026-10-01T18:02:49.485Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/62/02e76a5574002153618eafbb70e159468addc72a5d2c488e65cbb4639d2d/ruff-0.16.10-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bc2610fb269fa56dd8a68669ae470fa6272902668c0fc2ebc3aa112b2633d5b8", size = 11339942, upload-time = "2026-10-01T18:02:52.008Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/c4/cde27d47ad8d4126c587e608c67c46e7feac11763f606d261a1bc8a489e6/ruff-0.16.10-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3e70175e29cc94c26ea296c80e470180b744b7419026898e58f520c6ab32578e", size = 10934316, upload-time = "2026-10-01T18:02:54.811Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/03/17234145f302a645a123e8c3bb2411ecf4669fbc350de3b0d803230a1729/ruff-0.16.10-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f33f43a864a8483eebd160e713336c8bab02c934feaff0a33cf5ccb41546d09a", size = 10387968, upload-time = "2026-10-01T18:02:57.497Z" },
+    { url = "https://files.pythonhosted.org/packages/71/29/2493af60240ee7644b38a4b821f5f9c3b5a4fa3178770fe1d0c685217395/ruff-0.16.10-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:1dfc6f0088149fb6a362c1c446bcbb3fd2157b3852fe2fa68409276eab9ad9b3", size = 10537906, upload-time = "2026-10-01T18:03:00.006Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/9a/f56b28f3b143bb9e518c34fb89ab191b626bca8b70dbf8af0d2e2d473572/ruff-0.16.10-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:6553498afc35f580f036030795810b9e6bcea31604b0fd9e8d352795473042e3", size = 10012938, upload-time = "2026-10-01T18:03:03.006Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/c4/fca37362848ea4d4d80712df13632e645e7c7cfb1bdedf140699ac7a090b/ruff-0.16.10-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:a3b8471dea115d37f123882be852bed13403746d3a76c11de4a19ec5f9ff5a03", size = 9897945, upload-time = "2026-10-01T18:03:05.818Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/c7/e0bc57664d6e0c61fd22f620af260fe9662d7e1ddb320ea7f160e76ef165/ruff-0.16.10-py3-none-musllinux_1_2_i686.whl", hash = "sha256:92e59a70bcbd9d3a5483656da906ec28edfdacfce00afd99edb8b4e9d15644be", size = 10333134, upload-time = "2026-10-01T18:03:08.25Z" },
+    { url = "https://files.pythonhosted.org/packages/21/aa/5c9f3b68737c0e4a33a1db5dfab44f7b786d96ca91a7233112ddab1e6dc2/ruff-0.16.10-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:7ae7375f803b5520dc9f546bed7e3a0acb70b91812e9bb4b19927de22f25b77d", size = 10741702, upload-time = "2026-10-01T18:03:10.775Z" },
+    { url = "https://files.pythonhosted.org/packages/78/fa/0f9c2020dc316c53d983be011720b8157cc052b97e3f4dfa7db6d0f880a6/ruff-0.16.10-py3-none-win32.whl", hash = "sha256:2a12e01cb9156c10c466f63b46eaae5ecea28dfbd21b5836353ae498e7d1349a", size = 10139176, upload-time = "2026-10-01T18:03:13.267Z" },
+    { url = "https://files.pythonhosted.org/packages/99/29/cfb0df9448d4d4ad48c2de029ada9ebd71baa6da983a6c77ee6c6cd0fe82/ruff-0.16.10-py3-none-win_amd64.whl", hash = "sha256:97f2015c92aa97105b0eab19eb5d224884399281cfc5da86a92db4ab5e7fb2ca", size = 10584734, upload-time = "2026-10-01T18:03:16.006Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/05/c16957eb287c3fc062e032619a25868d93d408a844b725bcf514f7a378ff/ruff-0.16.10-py3-none-win_arm64.whl", hash = "sha256:25a65fe998c4e6861ec079ada5826a2fc605e6cbccbe9dcd7fac1f54e791621b", size = 10366440, upload-time = "2026-10-01T18:03:19.04Z" },
 ]
 
 [[package]]
 name = "session-migrate"
-version = "0.11.0"
+version = "0.12.1"
 source = { editable = "." }
 
 [package.dev-dependencies]