Draft: two-way teleport with native CLI sessions

apps/mobile/src/features/threads/ThreadComposer.tsx

@@ -1,11 +1,13 @@
-import type {
-  EnvironmentId,
-  MessageId,
-  ModelSelection,
-  OrchestrationThreadShell,
-  ProviderInteractionMode,
-  RuntimeMode,
-  ServerConfig as T3ServerConfig,
+import {
+  isTeleportedOut,
+  teleportSendDisabledReason,
+  type EnvironmentId,
+  type MessageId,
+  type ModelSelection,
+  type OrchestrationThreadShell,
+  type ProviderInteractionMode,
+  type RuntimeMode,
+  type ServerConfig as T3ServerConfig,
 } from "@t3tools/contracts";
 import {
   detectComposerTrigger,
@@ -290,10 +292,13 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer
 
   const [previewImageUri, setPreviewImageUri] = useState<string | null>(null);
   const hasContent = props.draftMessage.trim().length > 0 || props.draftAttachments.length > 0;
+  const teleportedOut = isTeleportedOut(props.selectedThread.teleport);
+  const teleportSendBlockReason = teleportSendDisabledReason(props.selectedThread.teleport);
   // Opening and presentation count as active so the composer stays expanded
   // while focus moves between its native editor and the settings picker.
   const isExpanded = isFocused || settingsSheetPresentation.isActive;
-  const canSend = hasContent;
+  const canSend = hasContent && !teleportedOut;
+  const placeholder = teleportSendBlockReason ?? props.placeholder;
 
   // Notify the parent from the derived value, not focus events: the parent
   // sizes the feed inset from this, and blur-during-sheet would otherwise
@@ -537,6 +542,9 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer
   const { onChangeDraftMessage, onUpdateInteractionMode, draftMessage, onSendMessage } = props;
 
   const handleSend = useCallback(async () => {
+    if (isTeleportedOut(props.selectedThread.teleport)) {
+      return;
+    }
     const threadKey = scopedThreadKey(props.environmentId, props.selectedThread.id);
     if (inFlightThreadIdsRef.current.has(threadKey)) return;
     inFlightThreadIdsRef.current.add(threadKey);
@@ -560,6 +568,7 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer
     props.environmentLabel,
     props.selectedThread.id,
     props.selectedThread.title,
+    props.selectedThread.teleport,
   ]);
   const handleCommandSelect = useCallback(
     (item: ComposerCommandItem) => {
@@ -788,7 +797,7 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer
               onChangeText={props.onChangeDraftMessage}
               onSelectionChange={handleSelectionChange}
               onPasteImages={(uris) => void props.onNativePasteImages(uris)}
-              placeholder={props.placeholder}
+              placeholder={placeholder}
               onFocus={handleFocus}
               onBlur={handleBlur}
               onSubmit={handleSend}

apps/mobile/src/state/use-thread-composer-state.ts

@@ -3,6 +3,7 @@ import { useCallback, useEffect, useMemo } from "react";
 
 import {
   CommandId,
+  isTeleportedOut,
   MessageId,
   type EnvironmentId,
   type ModelSelection,
@@ -137,6 +138,9 @@ export function useThreadComposerState() {
     const threadKey = scopedThreadKey(selectedThreadShell.environmentId, selectedThreadShell.id);
     const draft = getComposerDraftSnapshot(threadKey);
     const thread = selectedThreadDetail ?? selectedThreadShell;
+    if (isTeleportedOut(thread.teleport)) {
+      return null;
+    }
     const text = draft.text.trim();
     const attachments = draft.attachments;
     if (text.length === 0 && attachments.length === 0) {

apps/server/src/auth/RpcAuthorization.ts

@@ -124,6 +124,9 @@ export const RPC_REQUIRED_SCOPES = {
   [WS_METHODS.subscribeServerLifecycle]: AuthOrchestrationReadScope,
   [WS_METHODS.subscribeAuthAccess]: AuthAccessReadScope,
   [WS_METHODS.subscribeBackgroundPolicy]: AuthOrchestrationReadScope,
+  [WS_METHODS.teleportListSessions]: AuthOrchestrationReadScope,
+  [WS_METHODS.teleportImportSessions]: AuthOrchestrationOperateScope,
+  [WS_METHODS.teleportExportSession]: AuthOrchestrationOperateScope,
 } as const satisfies Readonly<Record<WsRpcMethod, AuthEnvironmentScope>>;
 
 export function requiredScopeForRpcMethod(method: string): AuthEnvironmentScope {

apps/server/src/environment/ServerEnvironment.test.ts

@@ -92,6 +92,7 @@ it.layer(NodeServices.layer)("ServerEnvironmentLive", (it) => {
       expect(second.capabilities.connectionProbe).toBe(true);
       expect(second.capabilities.pullRequests).toBe(true);
       expect(second.capabilities.threadTitleRegeneration).toBe(true);
+      expect(second.capabilities.teleport).toBe(true);
       expect(second.capabilities.agentActivityPublishing).toBe(false);
     }),
   );

apps/server/src/environment/ServerEnvironment.ts

@@ -152,6 +152,7 @@ export const make = Effect.gen(function* () {
       threadPinning: true,
       threadPinReorder: true,
       threadTitleRegeneration: true,
+      teleport: true,
       ...(serverSelfUpdate === null ? {} : { serverSelfUpdate }),
       ...(serverSelfUpdate === "boot-service" ? { serverSelfUpdateProgress: true } : {}),
     },

apps/server/src/orchestration/Layers/OrchestrationEngine.test.ts

@@ -1379,4 +1379,269 @@ describe("OrchestrationEngine", () => {
 
     await system.dispose();
   });
+
+  it("commits unarchive, T3 ownership, and history replacement together", async () => {
+    const system = await createOrchestrationSystem();
+    const { engine } = system;
+    const createdAt = now();
+    const projectId = asProjectId("project-teleport-import");
+    const threadId = ThreadId.make("thread-teleport-import");
+
+    await system.run(
+      engine.dispatch({
+        type: "project.create",
+        commandId: CommandId.make("cmd-teleport-import-project"),
+        projectId,
+        title: "Teleport Import",
+        workspaceRoot: "/tmp/project-teleport-import",
+        defaultModelSelection: {
+          instanceId: ProviderInstanceId.make("codex"),
+          model: "gpt-5-codex",
+        },
+        createdAt,
+      }),
+    );
+    await system.run(
+      engine.dispatch({
+        type: "thread.create",
+        commandId: CommandId.make("cmd-teleport-import-thread"),
+        threadId,
+        projectId,
+        title: "Old title",
+        modelSelection: {
+          instanceId: ProviderInstanceId.make("codex"),
+          model: "gpt-5-codex",
+        },
+        interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
+        runtimeMode: "full-access",
+        branch: null,
+        worktreePath: null,
+        createdAt,
+      }),
+    );
+    await system.run(
+      engine.dispatch({
+        type: "thread.teleport.set",
+        commandId: CommandId.make("cmd-teleport-import-native"),
+        threadId,
+        teleport: {
+          presence: "native",
+          provider: "codex",
+          externalSessionId: "session-import",
+          nativePath: "/tmp/session.jsonl",
+          lastSyncedAt: createdAt,
+        },
+        createdAt,
+      }),
+    );
+    await system.run(
+      engine.dispatch({
+        type: "thread.history.replace",
+        commandId: CommandId.make("cmd-teleport-import-old-history"),
+        threadId,
+        messages: [
+          {
+            id: asMessageId("old-1"),
+            role: "user",
+            text: "old",
+            turnId: null,
+            streaming: false,
+            createdAt,
+            updatedAt: createdAt,
+          },
+        ],
+        createdAt,
+      }),
+    );
+    await system.run(
+      engine.dispatch({
+        type: "thread.archive",
+        commandId: CommandId.make("cmd-teleport-import-archive"),
+        threadId,
+      }),
+    );
+    await system.run(
+      engine.dispatch({
+        type: "thread.teleport.import",
+        commandId: CommandId.make("cmd-teleport-import-commit"),
+        threadId,
+        teleport: {
+          presence: "t3",
+          provider: "codex",
+          externalSessionId: "session-import",
+          nativePath: "/tmp/session.jsonl",
+          lastSyncedAt: createdAt,
+        },
+        messages: [
+          {
+            id: asMessageId("imported-1"),
+            role: "user",
+            text: "imported",
+            turnId: null,
+            streaming: false,
+            createdAt,
+            updatedAt: createdAt,
+          },
+        ],
+        createdAt,
+      }),
+    );
+
+    const readModel = await system.readModel();
+    const thread = readModel.threads.find((candidate) => candidate.id === threadId);
+    expect(thread?.archivedAt).toBeNull();
+    expect(thread?.teleport?.presence).toBe("t3");
+    expect(thread?.messages.map((message) => message.text)).toEqual(["imported"]);
+
+    await system.run(
+      engine.dispatch({
+        type: "thread.teleport.import",
+        commandId: CommandId.make("cmd-teleport-import-retry"),
+        threadId,
+        teleport: {
+          presence: "t3",
+          provider: "codex",
+          externalSessionId: "session-import",
+          nativePath: "/tmp/session.jsonl",
+          lastSyncedAt: createdAt,
+        },
+        messages: [
+          {
+            id: asMessageId("imported-1"),
+            role: "user",
+            text: "imported",
+            turnId: null,
+            streaming: false,
+            createdAt,
+            updatedAt: createdAt,
+          },
+        ],
+        createdAt,
+      }),
+    );
+    const retried = await system.readModel();
+    const retriedThread = retried.threads.find((candidate) => candidate.id === threadId);
+    expect(retriedThread?.teleport?.presence).toBe("t3");
+    expect(retriedThread?.messages.map((message) => message.text)).toEqual(["imported"]);
+
+    await system.dispose();
+  });
+
+  it("rejects turn start against importing presence and recovers to native", async () => {
+    const system = await createOrchestrationSystem();
+    const { engine } = system;
+    const createdAt = now();
+    const projectId = asProjectId("project-teleport-importing");
+    const threadId = ThreadId.make("thread-teleport-importing");
+
+    await system.run(
+      engine.dispatch({
+        type: "project.create",
+        commandId: CommandId.make("cmd-importing-project"),
+        projectId,
+        title: "Importing",
+        workspaceRoot: "/tmp/project-teleport-importing",
+        defaultModelSelection: {
+          instanceId: ProviderInstanceId.make("codex"),
+          model: "gpt-5-codex",
+        },
+        createdAt,
+      }),
+    );
+    await system.run(
+      engine.dispatch({
+        type: "thread.create",
+        commandId: CommandId.make("cmd-importing-thread"),
+        threadId,
+        projectId,
+        title: "Thread",
+        modelSelection: {
+          instanceId: ProviderInstanceId.make("codex"),
+          model: "gpt-5-codex",
+        },
+        interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
+        runtimeMode: "full-access",
+        branch: null,
+        worktreePath: null,
+        createdAt,
+      }),
+    );
+    await system.run(
+      engine.dispatch({
+        type: "thread.teleport.set",
+        commandId: CommandId.make("cmd-importing-fence"),
+        threadId,
+        teleport: {
+          presence: "importing",
+          provider: "codex",
+          externalSessionId: "session-importing",
+          nativePath: "/tmp/session.jsonl",
+          lastSyncedAt: createdAt,
+          restorePresence: "native",
+        },
+        createdAt,
+      }),
+    );
+
+    await expect(
+      system.run(
+        engine.dispatch({
+          type: "thread.turn.start",
+          commandId: CommandId.make("cmd-importing-turn"),
+          threadId,
+          message: {
+            messageId: asMessageId("msg-importing"),
+            role: "user",
+            text: "hello",
+            attachments: [],
+          },
+          interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
+          runtimeMode: "full-access",
+          createdAt,
+        }),
+      ),
+    ).rejects.toThrow("being imported");
+
+    await system.run(
+      engine.dispatch({
+        type: "thread.teleport.set",
+        commandId: CommandId.make("cmd-importing-recover"),
+        threadId,
+        teleport: {
+          presence: "native",
+          provider: "codex",
+          externalSessionId: "session-importing",
+          nativePath: "/tmp/session.jsonl",
+          lastSyncedAt: createdAt,
+        },
+        createdAt,
+      }),
+    );
+
+    const recovered = await system.readModel();
+    const thread = recovered.threads.find((candidate) => candidate.id === threadId);
+    expect(thread?.teleport?.presence).toBe("native");
+    expect(thread?.teleport?.restorePresence).toBeUndefined();
+
+    await expect(
+      system.run(
+        engine.dispatch({
+          type: "thread.turn.start",
+          commandId: CommandId.make("cmd-importing-turn-after-recover"),
+          threadId,
+          message: {
+            messageId: asMessageId("msg-importing-after"),
+            role: "user",
+            text: "hello",
+            attachments: [],
+          },
+          interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
+          runtimeMode: "full-access",
+          createdAt,
+        }),
+      ),
+    ).rejects.toThrow("native CLI");
+
+    await system.dispose();
+  });
 });