Draft: two-way teleport with native CLI sessions

[baanish]

What Changed

Local mirror of closed upstream pingdotgg/t3code#7136: two-way import/export of native Codex and Claude CLI sessions, plus native-revision watch and fork recovery.

TeleportProvider remains codex | claudeAgent only. Grok/OpenCode native teleport formats are not in this PR.

This revision addresses Codex and Kilo review on the mirror:

• Fall back to an exclusive-open lock probe when lsof cannot be spawned.
• Load archived threads by id so in-place import can unarchive the canonical native thread. Turn start is rejected on archived threads in the decider (not by hiding those rows from by-id reads).
• Walk each Claude projectsRoot once per home instead of once per worktree.
• Fail export with unknown-instance instead of writing into the default CLI home.
• Ignore a previous thread's native-conflict result after navigation.
• Restore the provider-directory binding if in-place import reverts.
• Prefer the newer shell/detail teleport snapshot by lastSyncedAt.
• Pass nativePath through command-palette import refs.
• Do not persist a teleport-pending: path into the provider directory when interrupted export never wrote a file.

Adversarial-review ship-blockers (this pass):

1. Failed/interrupted first-time in-place import no longer looks successful. Internal-only thread.teleport.clear emits thread.teleported with teleport: null. Crash recovery clears leftover importing when there is no prior native identity, instead of flipping to t3 with the uncommitted nativeRevision. Prior native teleport still restores (native → importing → native).
2. WS thread.turn.start with bootstrap.createThread skips requireNativeRevisionForTurn so a missing id can create+dispatch. Existing-thread turn.start, including prepareWorktree-only bootstrap, still checks. Service fail-closed for a missing thread is unchanged.
3. HTTP /api/orchestration/dispatch runs the same native-revision gate as WS, then cleans up failed uploaded attachments on dispatch error. Bugbot (valid): the HTTP path never runs thread.create, and the decider ignores bootstrap, so a bootstrap.createThread payload on an already-imported thread used to skip the gate. HTTP now looks up the thread and still requires the native revision when that id exists. The skip remains only for a missing thread.
4. Chat composer keeps the native/importing teleport lock while messages load. Loading is an additional send disable, not a replacement; isTeleportSendDisabledReason still wins so prompt/stash cannot mutate. Attachment-upload blocking is also additional, not a replacement for the teleport lock.

Related high-confidence holes:

5. Explicit nativePath in-place matching is path-stable: two files with the same session id do not rewrite each other's threads. Instance-id matching is unchanged.
6. Failed-import directory revert restores identity fields, not a pre-stop status: "running" / starting binding or a teleport-pending: native path.

Must-fix pass (mergeability):

7. Equal lastSyncedAt now prefers the shell teleport snapshot (>=, not >). A same-timestamp ownership flip (t3 → importing, native → t3) no longer keeps stale cached detail.
8. Migration 044 backfills teleport_json only when provider_name is already a valid TeleportProvider (codex | claudeAgent). Leftover opencode / grok runtime rows are skipped; no invented mapping.
9. Restored OpenCodeAdapter.ts / .test.ts to origin/main. The abort-gate / unconfirmed-abort residue is not Codex/Claude teleport.

Atomicity pass (6/10 → ~9/10):

10. beginImporting is inside the same uninterruptible revert region as stop / directory / commit. Interrupt or defect during or immediately after the fence still reverts presence: "importing".
11. First-time in-place import with no prior directory row deletes that row on revert. A prior binding still restores identity fields only (no running / teleport-pending:).
12. Startup recovery deletes a leftover new-thread import (restorePresence: "t3", empty or fence-only history, still importing). In-place imports of existing threads are cleared or restored, not deleted.
13. Startup recovery finalizes a provider-directory payload that lagged behind a committed T3 import (orchestration.presence === "t3" while directory is importing, missing, or pending). Failures are logged and skipped.
14. Unix lock probe is fail-closed when lsof cannot be spawned and the target file exists (TeleportLockProbeError). Missing file (ENOENT) stays unlocked so first export create can proceed. Windows exclusive-open is unchanged.
15. Windows native replace restores from .teleport-bak if the replacement rename fails; a failed restore now fails the operation instead of swallowing a lost original. Unix replace remains POSIX rename. Tests cover both paths and verify-does-not-clobber.
16. withInFlight is documented as process-local. It is not a cluster or cross-process lock.

Merged latest origin/main (a3a8cbd60) into this branch (e64e31ac8426cb0edf743a144fc8879f47e6a84b). Bugbot HTTP gate follow-up is 93d32f2d3. Current HEAD is ca3e9b78c. CI must be green on this exact SHA.

Conflict resolutions in this merge (all simple / keep-both; no complicated intent conflicts):

• Auth session client-connection stays 041. Main took 042 (linked PR) and 043 (unsettledAt); teleport projection is 044.
• Projection thread rows, snapshot queries, and environment capabilities keep both linkedPullRequest / threadPullRequestLinking and teleport.
• ChatComposer: HEIC prepareImageForAttachment from main, plus HEAD's in-flight abort when send becomes disabled (teleport lock still first).

Earlier main merge notes still apply:

• WebSocket turn dispatch still verifies native revision, then stamps client origin.
• HTTP /api/orchestration/dispatch uses the same gate, then cleanupFailedUploadedAttachments on tapError.
• ChatView send-disabled order: teleport → "Sending feedback" → "Messages loading" → native-conflict. Teleport lock is never replaced by loading.
• ProviderCommandReactor interrupt recovery remains main fix(server): recover from provider interrupt failures pingdotgg/t3code#7412 (interruptTurn fail → stopSession → mark stopped with lastError). OpenCode zombie Stop is not restored.
• Orchestration events keep teleport payloads and optional client origin.
• Engine tests cover origin stamping and teleport import atomicity.

Still not 10/10 (cannot be without new stores):

• No cross-store transaction (orchestration + provider directory + native file).
• withInFlight is a process-local mutex, not a cluster lock.
• A CLI can still write the native file during an admitted T3 turn after the revision check.
• TELEPORT_IMPORT_BATCH_SEMANTICS stays per-session.

Not changing in this pass:

• Mobile teleport-in UI. Mobile already blocks send while teleported out; reverse import stays on web/desktop.
• Symlink cycle walks / uncapped post-stat read.
• Export verify using T3 parser vs CLI serde.
• Parser O(n²) Claude rewind / 20MB newline fuzz corpus.

Why

Successful in-place import must be one orchestration transition (thread.teleport.import). Failed or interrupted import must revert presence: "importing" and stay retryable — including first-time directory-bound threads that never had a teleport document. After import, SHA-256 native revision watch blocks turns when the CLI file diverged or went missing; Fork native changes copies that transcript into a new T3 thread. The revision gate must apply on every thread.turn.start ingress (WS and HTTP) except bootstrap.createThread on a thread that does not exist yet.

Equal-timestamp shell/detail merges must not hide a live ownership flip. Projection backfill must not write schema-invalid teleport_json.provider values. This PR should not carry stacked OpenCode abort-gate adapter diffs.

Live interrupt after the import fence, first-time directory upserts, new-thread crash husks, and a directory that never finalized after a successful T3 commit must not strand importing until process restart. Unix hosts without lsof must not fail-open on an existing native file.

Stacked sibling remains PR #9 (cursor/teleport-opencode-1e23). This mirror targets main.

UI Changes

Media copied from closed upstream pingdotgg/t3code#7136. Import lives on the new-thread / sessions view. Export lives in the chat header. Composer send is disabled while the thread is in the native CLI.

New UI

Hover

Composer disabled after Teleport Out

Native-revision conflict banner

After import, SHA-256 native revision watch shows this banner when the CLI file diverges. Send is blocked until the user forks.

Recordings

7136 linked these as clickable posters. The raw .mp4 files have no public download URL from this environment.

Codex

Claude

Checklist

• This PR is small and focused
• I explained what changed and why
• I included before/after screenshots for any UI changes
• I included a video for animation/interaction changes

  

Summary by CodeRabbit

• New Features

  • Added Teleport support for discovering, importing, and exporting native CLI sessions.
  • Added support for Codex and Claude session formats.
  • Added native revision checks and the ability to fork diverged sessions.
  • Added Teleport controls, import flows, status indicators, and conflict banners.
  • Added environment capability detection and command palette access to session imports.

• Bug Fixes

  • Prevented sending and editing while threads are importing, native-controlled, or conflicted.
  • Improved interruption recovery and session state restoration.
  • Preserved thread metadata across history replacement and archived-thread loading.

[kilo-code-bot]

[WARNING]: Import batch is no longer all-or-nothing for load/unlock failures

Previously an upfront loop loaded + requireParsedSessionUnlocked-checked every session before any thread was committed, so a session that failed to load (missing file, unsupported provider, parse error) or was locked by a running native CLI aborted the whole batch before anything changed. That upfront validation loop was removed in 5798b445, and load + unlock now run inside the per-ref commit loop, right before each session is committed via engine.dispatch + directory.upsert.

If session N fails to load/unlock after sessions 1..N-1 were already committed, the request returns the load error while the earlier sessions were genuinely imported. The client sees a failed batch but partial state now exists, and a blind retry then hits the in-place / identity-conflict path for the already-imported sessions.

The commit message documents the deliberate "load and commit each batch session sequentially" refactor (for identity handling), but the load/unlock phase does not depend on per-ref commit context, so the upfront all-or-nothing validation could be restored while keeping the sequential commit. Worth a maintainer decision on whether partial commit is acceptable for these environmental failures.

---

Reply with @kilocode-bot fix it to have Kilo Code address this issue.

[cursor]

Agentic security review of the latest head found one medium issue: teleport.listSessions accepts a free-form cwd and treats / (or $HOME) as a containing root, so a read-scoped paired client can enumerate native CLI session titles and paths outside any T3 project. Import already binds cwd to a project workspace; list should do the same.

  

_{Sent by Cursor Security Agent: Security Reviewer}