From 416db90795a523def961d4d84668e30006beaa53 Mon Sep 17 00:00:00 2001
From: Julius Marminge <51714798+juliusmarminge@users.noreply.github.com>
Date: Wed, 7 Oct 2026 00:16:32 -0700
Subject: [PATCH 1/4] =?UTF-8?q?feat(web,mobile):=20Continue=20on=E2=80=A6?=
 =?UTF-8?q?=20a=20linked=20environment?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Moving a thread to a linked environment was reachable only through the
t3_thread_handoff MCP tool. Users now pick "Continue on…" from the web
sidebar and chat-header thread menus, the command palette, and mobile's
long-press and thread header menus. Targets are read from
threadHandoff.options when the menu opens.

The thread shows the move's state above the composer: waiting for the
turn to end (with Keep it here), under way, moved (with Open on <machine>),
or failed. While the thread is departing or departed, the composer is
closed on both clients.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 apps/mobile/src/Stack.tsx                     |  11 ++
 apps/mobile/src/features/home/HomeScreen.tsx  |   3 +
 .../features/threads/ThreadDetailScreen.tsx   |  18 ++-
 .../features/threads/ThreadGitControls.tsx    |  14 ++
 .../features/threads/ThreadHandoffCard.tsx    |  94 ++++++++++++
 .../features/threads/ThreadHandoffSheet.tsx   | 145 ++++++++++++++++++
 .../src/features/threads/ThreadHeader.tsx     |  10 +-
 .../threads/ThreadNavigationSidebar.tsx       |   3 +
 .../features/threads/ThreadRouteScreen.tsx    |  11 ++
 .../features/threads/thread-list-v2-items.tsx |  19 ++-
 .../src/state/thread-list-environments.ts     |   4 +
 apps/mobile/src/state/threadHandoff.ts        |   5 +
 apps/web/src/components/ChatView.tsx          |  32 ++--
 apps/web/src/components/CommandPalette.tsx    |  44 ++++++
 apps/web/src/components/Sidebar.tsx           |  20 +++
 .../components/chat/ThreadHandoffBanner.tsx   | 100 ++++++++++++
 .../components/threadActionMenu.logic.test.ts |  42 +++++
 .../src/components/threadActionMenu.logic.ts  |  26 ++++
 apps/web/src/components/threadHandoffMenu.ts  |  79 ++++++++++
 .../web/src/hooks/useThreadActionMenu.test.ts |   5 +
 apps/web/src/hooks/useThreadActionMenu.ts     |  20 +++
 apps/web/src/state/threadHandoff.ts           |   5 +
 docs/user/remote-access.md                    |   4 +-
 packages/client-runtime/src/state/models.ts   |   3 +
 .../src/state/peerLinks.test.ts               |  28 +++-
 .../client-runtime/src/state/peerLinks.ts     |  61 +++++++-
 vite.config.ts                                |   1 +
 27 files changed, 789 insertions(+), 18 deletions(-)
 create mode 100644 apps/mobile/src/features/threads/ThreadHandoffCard.tsx
 create mode 100644 apps/mobile/src/features/threads/ThreadHandoffSheet.tsx
 create mode 100644 apps/mobile/src/state/threadHandoff.ts
 create mode 100644 apps/web/src/components/chat/ThreadHandoffBanner.tsx
 create mode 100644 apps/web/src/components/threadHandoffMenu.ts
 create mode 100644 apps/web/src/state/threadHandoff.ts

diff --git a/apps/mobile/src/Stack.tsx b/apps/mobile/src/Stack.tsx
index 00645ddc091a..8ac49aba7a99 100644
--- a/apps/mobile/src/Stack.tsx
+++ b/apps/mobile/src/Stack.tsx
@@ -68,6 +68,7 @@ import { GitCommitSheet } from "./features/threads/git/GitCommitSheet";
 import { GitConfirmSheet } from "./features/threads/git/GitConfirmSheet";
 import { GitOverviewSheet } from "./features/threads/git/GitOverviewSheet";
 import { ThreadAgentsSheet } from "./features/threads/ThreadAgentsSheet";
+import { ThreadHandoffSheet } from "./features/threads/ThreadHandoffSheet";
 import { ThreadQueueSheet } from "./features/threads/ThreadQueueControl";
 import { ThreadRouteScreen } from "./features/threads/ThreadRouteScreen";
 import { McpAppFullscreenScreen } from "./features/threads/McpAppFullscreenScreen";
@@ -550,6 +551,7 @@ const WORKSPACE_OVERLAY_ROUTES = new Set([
   "SettingsLegal",
   "SettingsSheet",
   "ThreadAgents",
+  "ThreadHandoff",
   "ThreadQueue",
   "ThreadReviewComment",
   "ThreadDevicePreview",
@@ -862,6 +864,15 @@ const RootStackConfig = createWorkspaceStackNavigator({
         sheetGrabberVisible: true,
       },
     }),
+    ThreadHandoff: createNativeStackScreen({
+      screen: ThreadHandoffSheet,
+      options: {
+        ...FORM_SHEET_PRESENTATION_OPTIONS,
+        headerShown: false,
+        sheetAllowedDetents: [0.5, 0.9],
+        sheetGrabberVisible: true,
+      },
+    }),
     GitOverview: createNativeStackScreen({
       screen: GitOverviewSheet,
       linking: `${THREAD_LINKING_PREFIX}/git`,
diff --git a/apps/mobile/src/features/home/HomeScreen.tsx b/apps/mobile/src/features/home/HomeScreen.tsx
index a6f098a05ea4..f1c93b20d8ea 100644
--- a/apps/mobile/src/features/home/HomeScreen.tsx
+++ b/apps/mobile/src/features/home/HomeScreen.tsx
@@ -528,6 +528,7 @@ export function HomeScreen(props: HomeScreenProps) {
     pinReorderEnvironmentIds,
     activeReorderEnvironmentIds,
     titleRegenerationEnvironmentIds,
+    handoffEnvironmentIds,
   } = listEnvironments;
   const resolveProviderInstance = useThreadRowProviderInstanceResolver(providersByEnvironmentId);
   const pendingOrder = usePendingThreadOrder(nowMinute, snoozeWakeTick);
@@ -774,6 +775,7 @@ export function HomeScreen(props: HomeScreenProps) {
           onRenameThread={handleRenameThread}
           onRegenerateThreadTitle={handleRegenerateThreadTitle}
           titleRegenerationSupported={titleRegenerationEnvironmentIds.has(thread.environmentId)}
+          handoffSupported={handoffEnvironmentIds.has(thread.environmentId)}
           settlementSupported={settlementEnvironmentIds.has(thread.environmentId)}
           onSettleThread={handleSettleThread}
           snoozeSupported={snoozeEnvironmentIds.has(thread.environmentId)}
@@ -837,6 +839,7 @@ export function HomeScreen(props: HomeScreenProps) {
       snoozeEnvironmentIds,
       threadSearchMatchByKey,
       titleRegenerationEnvironmentIds,
+      handoffEnvironmentIds,
       toggleSettledShelf,
       toggleSnoozedShelf,
       toggleWorkingShelf,
diff --git a/apps/mobile/src/features/threads/ThreadDetailScreen.tsx b/apps/mobile/src/features/threads/ThreadDetailScreen.tsx
index 6bc5084e0d53..52d4efea3379 100644
--- a/apps/mobile/src/features/threads/ThreadDetailScreen.tsx
+++ b/apps/mobile/src/features/threads/ThreadDetailScreen.tsx
@@ -2,6 +2,7 @@ import * as Dialog from "../../components/ui/Dialog";
 import { useAtomValue } from "@effect/atom-react";
 import { useChildThreadInputs, useThreadReportedModelSelection } from "../../state/entities";
 import { UsageLimitRecoveryCard } from "./UsageLimitRecoveryCard";
+import { ThreadHandoffCard, threadHandoffClosesComposer } from "./ThreadHandoffCard";
 import { useNavigation } from "@react-navigation/native";
 import type { WorktreeSetupCardProps } from "./worktree-setup-card";
 import type { ComposerTextPaste } from "../../native/T3ComposerEditor.types";
@@ -562,7 +563,9 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread
     useState<RuntimeRequestId | null>(null);
   const activeUserInputRequestId = props.activePendingUserInput?.requestId ?? null;
   const composerSlotHidden =
-    activeUserInputRequestId !== null || props.creationState?.kind === "failed";
+    activeUserInputRequestId !== null ||
+    props.creationState?.kind === "failed" ||
+    threadHandoffClosesComposer(props.selectedThread);
   const [usageLimitsPanel, setUsageLimitsPanel] = useState<{
     readonly key: string;
     readonly threadKey: string;
@@ -1215,6 +1218,16 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread
                       />
                     </Animated.View>
                   ) : null}
+                  <View
+                    // With the composer closed, the card pads the home indicator itself.
+                    style={
+                      threadHandoffClosesComposer(props.selectedThread)
+                        ? { paddingBottom: composerBottomInset }
+                        : undefined
+                    }
+                  >
+                    <ThreadHandoffCard thread={props.selectedThread} />
+                  </View>
                   <UsageLimitRecoveryCard
                     key={props.selectedThread.latestRun?.runId}
                     thread={props.selectedThread}
@@ -1310,7 +1323,8 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread
 
                 {/*
                  * Hidden (not unmounted) while a user-input request owns the composer slot, so
-                 * composer drafts and editor state survive.
+                 * composer drafts and editor state survive. A thread that moved away continues on
+                 * the other environment, so its card owns the slot too.
                  */}
                 <View style={composerSlotHidden ? { display: "none" } : undefined}>
                   {isProviderSubagent ? (
diff --git a/apps/mobile/src/features/threads/ThreadGitControls.tsx b/apps/mobile/src/features/threads/ThreadGitControls.tsx
index ac0fd16b1be7..bd811aae68ff 100644
--- a/apps/mobile/src/features/threads/ThreadGitControls.tsx
+++ b/apps/mobile/src/features/threads/ThreadGitControls.tsx
@@ -91,6 +91,8 @@ export type ThreadGitMenuProps = {
   readonly onOpenFilesInspector?: () => void;
   readonly onOpenGitInspector?: () => void;
   readonly onMergeBack?: () => void;
+  /** Present only when the thread can move to a linked environment. */
+  readonly onContinueOn?: () => void;
   readonly onPull: () => Promise<void>;
   readonly onRunAction: (input: GitActionRequestInput) => Promise<GitRunStackedActionResult | null>;
 };
@@ -392,6 +394,17 @@ function useThreadGitHeaderActionItems(props: ThreadGitControlsProps): ThreadGit
                   },
                 ]
               : []),
+            ...(props.onContinueOn
+              ? [
+                  {
+                    description: "Move this thread and its work to a linked environment",
+                    icon: { name: "arrow.up.right", type: "sfSymbol" as const },
+                    label: "Continue on…",
+                    onPress: props.onContinueOn,
+                    type: "action" as const,
+                  },
+                ]
+              : []),
             {
               description: "Commit, files, branches",
               icon: { name: "ellipsis", type: "sfSymbol" },
@@ -422,6 +435,7 @@ function useThreadGitHeaderActionItems(props: ThreadGitControlsProps): ThreadGit
       props.canOpenTerminal,
       props.canOperateTerminal,
       props.gitStatus,
+      props.onContinueOn,
       props.onMergeBack,
       props.onOpenNewTerminal,
       props.onOpenTerminal,
diff --git a/apps/mobile/src/features/threads/ThreadHandoffCard.tsx b/apps/mobile/src/features/threads/ThreadHandoffCard.tsx
new file mode 100644
index 000000000000..bcd05e4b1e6b
--- /dev/null
+++ b/apps/mobile/src/features/threads/ThreadHandoffCard.tsx
@@ -0,0 +1,94 @@
+import { threadHandoffNotice } from "@t3tools/client-runtime/state/peerLinks";
+import { squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";
+import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell";
+import { useNavigation } from "@react-navigation/native";
+import { useState } from "react";
+import { View } from "react-native";
+
+import { AppText as Text } from "../../components/ui/AppText";
+import { cn } from "../../lib/cn";
+import { useEnvironments } from "../../state/environments";
+import { threadHandoffEnvironment } from "../../state/threadHandoff";
+import { useAtomCommand } from "../../state/use-atom-command";
+import { RequestActionButton } from "./RequestActionButton";
+
+/** Whether the composer is closed because the thread is moving or has moved away. */
+export function threadHandoffClosesComposer(
+  thread: Pick<EnvironmentThreadShell, "handoff">,
+): boolean {
+  return thread.handoff?.state === "departing" || thread.handoff?.state === "departed";
+}
+
+/**
+ * A thread's move to a linked environment: waiting for its turn to end (with
+ * Keep it here), under way, moved (with a link there when this app is
+ * connected to it), or failed.
+ */
+export function ThreadHandoffCard({ thread }: { thread: EnvironmentThreadShell }) {
+  const navigation = useNavigation();
+  const cancel = useAtomCommand(threadHandoffEnvironment.cancel, {
+    label: "cancel thread move",
+    reportFailure: false,
+  });
+  const [cancelling, setCancelling] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const { presentationById } = useEnvironments();
+  const handoff = thread.handoff;
+  const notice = threadHandoffNotice(handoff);
+  if (handoff === null || notice === null) return null;
+
+  const keepHere = async () => {
+    setCancelling(true);
+    setError(null);
+    const result = await cancel({
+      environmentId: thread.environmentId,
+      input: { threadId: thread.id },
+    });
+    setCancelling(false);
+    if (result._tag === "Failure") setError(String(squashAtomCommandFailure(result)));
+  };
+
+  return (
+    <View className="mx-3 mb-2 gap-2 rounded-xl border border-border-subtle bg-screen p-3">
+      <Text
+        className={cn(
+          "text-sm font-t3-bold",
+          notice.tone === "error" ? "text-danger-foreground" : "text-foreground",
+        )}
+      >
+        {notice.title}
+      </Text>
+      {notice.detail !== null ? (
+        <Text className="text-sm text-foreground-secondary">{notice.detail}</Text>
+      ) : null}
+      {handoff.state === "pending" ? (
+        <View className="flex-row">
+          <RequestActionButton
+            label={cancelling ? "Cancelling…" : "Keep it here"}
+            tone="secondary"
+            disabled={cancelling}
+            onPress={() => void keepHere()}
+          />
+        </View>
+      ) : handoff.state === "departed" && presentationById.has(handoff.environmentId) ? (
+        <View className="flex-row">
+          <RequestActionButton
+            label={`Open on ${handoff.label}`}
+            tone="secondary"
+            onPress={() =>
+              navigation.navigate("Thread", {
+                environmentId: handoff.environmentId,
+                threadId: handoff.threadId,
+              })
+            }
+          />
+        </View>
+      ) : null}
+      {error !== null ? (
+        <Text accessibilityRole="alert" className="text-sm text-danger-foreground">
+          {error}
+        </Text>
+      ) : null}
+    </View>
+  );
+}
diff --git a/apps/mobile/src/features/threads/ThreadHandoffSheet.tsx b/apps/mobile/src/features/threads/ThreadHandoffSheet.tsx
new file mode 100644
index 000000000000..71a329b37ed8
--- /dev/null
+++ b/apps/mobile/src/features/threads/ThreadHandoffSheet.tsx
@@ -0,0 +1,145 @@
+import { squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";
+import type { EnvironmentId, ThreadId } from "@t3tools/contracts";
+import { useNavigation, type StaticScreenProps } from "@react-navigation/native";
+import * as Haptics from "expo-haptics";
+import { useState } from "react";
+import { Platform, Pressable, ScrollView, View } from "react-native";
+import { Screen, ScreenStack, ScreenStackHeaderConfig } from "react-native-screens";
+import { useSafeAreaInsets } from "react-native-safe-area-context";
+
+import { AndroidSheetHeader } from "../../components/ui/AndroidScreenHeader";
+import { AppText as Text } from "../../components/ui/AppText";
+import { useUniwindTheme } from "../../lib/useUniwindTheme";
+import { nativeHeaderScrollEdgeEffects } from "../../native/StackHeader";
+import { useEnvironmentQuery } from "../../state/query";
+import { threadHandoffEnvironment } from "../../state/threadHandoff";
+import { useAtomCommand } from "../../state/use-atom-command";
+
+const HEADER_SCROLL_EDGE_EFFECTS = nativeHeaderScrollEdgeEffects(Platform.OS, Platform.Version);
+
+type HandoffTarget = { readonly environmentId: EnvironmentId; readonly threadId: ThreadId };
+
+/**
+ * "Continue on…": the linked environments this thread can move to. Picking
+ * one starts the move and closes the sheet; the thread's card shows how it goes.
+ */
+export function ThreadHandoffSheet({ route }: StaticScreenProps<HandoffTarget>) {
+  const target = route.params;
+  const navigation = useNavigation();
+  const insets = useSafeAreaInsets();
+  const theme = useUniwindTheme();
+  const options = useEnvironmentQuery(
+    threadHandoffEnvironment.options({
+      environmentId: target.environmentId,
+      input: { threadId: target.threadId },
+    }),
+  );
+  const start = useAtomCommand(threadHandoffEnvironment.start, {
+    label: "move thread",
+    reportFailure: false,
+  });
+  const [starting, setStarting] = useState<EnvironmentId | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  const choose = async (environmentId: EnvironmentId) => {
+    void Haptics.selectionAsync();
+    setStarting(environmentId);
+    setError(null);
+    const result = await start({
+      environmentId: target.environmentId,
+      input: { threadId: target.threadId, environmentId },
+    });
+    setStarting(null);
+    if (result._tag === "Failure") {
+      setError(String(squashAtomCommandFailure(result)));
+      return;
+    }
+    navigation.goBack();
+  };
+
+  const targets = options.data?.options ?? [];
+  const content = (
+    <ScrollView
+      className="flex-1"
+      contentInsetAdjustmentBehavior={Platform.OS === "ios" ? "automatic" : "never"}
+      contentContainerClassName="px-5 pb-6"
+      contentContainerStyle={{ paddingBottom: Math.max(insets.bottom, 16) + 8 }}
+    >
+      <Text className="pb-2 pt-3 text-sm text-foreground-muted">
+        Moves the conversation, unpushed commits, and uncommitted changes. This thread becomes
+        read-only here.
+      </Text>
+      {options.error ? (
+        <Text className="pt-4 text-sm text-danger-foreground">{options.error}</Text>
+      ) : options.data === null ? (
+        <Text className="pt-4 text-sm text-foreground-muted">Asking linked environments…</Text>
+      ) : targets.length === 0 ? (
+        <Text className="pt-4 text-sm text-foreground-muted">
+          No linked environments. Link one from a desktop or with `t3 environment link`.
+        </Text>
+      ) : (
+        targets.map((option) => (
+          <Pressable
+            key={option.environmentId}
+            accessibilityRole="button"
+            accessibilityState={{ disabled: option.reason !== null || starting !== null }}
+            disabled={option.reason !== null || starting !== null}
+            onPress={() => void choose(option.environmentId)}
+            className="border-b border-border py-3.5 active:opacity-70 disabled:opacity-50"
+          >
+            <Text className="text-base font-t3-bold text-foreground">
+              {starting === option.environmentId ? `Moving to ${option.label}…` : option.label}
+            </Text>
+            {option.reason !== null ? (
+              <Text className="text-xs text-foreground-muted">{option.reason}</Text>
+            ) : null}
+          </Pressable>
+        ))
+      )}
+      {error !== null ? (
+        <Text accessibilityRole="alert" className="pt-3 text-sm text-danger-foreground">
+          {error}
+        </Text>
+      ) : null}
+    </ScrollView>
+  );
+
+  if (Platform.OS === "ios") {
+    // A plain formSheet screen never renders a stack header, so it comes from
+    // a nested native stack inside the sheet (same shape as the agents sheet).
+    return (
+      <View collapsable={false} className="flex-1 bg-sheet">
+        <ScreenStack style={{ flex: 1 }}>
+          <Screen
+            activityState={2}
+            enabled
+            isNativeStack
+            screenId="thread-handoff-sheet-native"
+            scrollEdgeEffects={HEADER_SCROLL_EDGE_EFFECTS}
+            style={{ backgroundColor: theme["--color-sheet"], flex: 1 }}
+          >
+            {content}
+            <ScreenStackHeaderConfig
+              backgroundColor="rgba(0,0,0,0)"
+              color={theme["--color-foreground"]}
+              hideBackButton
+              hideShadow={false}
+              title="Continue on…"
+              titleColor={theme["--color-foreground"]}
+              titleFontSize={18}
+              titleFontWeight="800"
+              translucent
+            />
+          </Screen>
+        </ScreenStack>
+      </View>
+    );
+  }
+
+  return (
+    <View collapsable={false} className="flex-1 bg-sheet">
+      <AndroidSheetHeader title="Continue on…" onBack={() => navigation.goBack()} />
+      {content}
+    </View>
+  );
+}
diff --git a/apps/mobile/src/features/threads/ThreadHeader.tsx b/apps/mobile/src/features/threads/ThreadHeader.tsx
index c2888b92ab8a..7a79c1964b94 100644
--- a/apps/mobile/src/features/threads/ThreadHeader.tsx
+++ b/apps/mobile/src/features/threads/ThreadHeader.tsx
@@ -20,7 +20,7 @@ export function ThreadHeader(
 ) {
   const returnToList = useWorkspaceListNavigation("threads");
   const { layout, panes, toggleAuxiliaryPane } = useAdaptiveWorkspaceLayout();
-  const { onOpenTerminal, onMergeBack } = props.gitControls;
+  const { onOpenTerminal, onMergeBack, onContinueOn } = props.gitControls;
   const native = useThreadHeaderOptions(props);
   const androidHeaderActions = useMemo<ReadonlyArray<AppBarAction>>(() => {
     const actions: AppBarAction[] = [];
@@ -59,6 +59,13 @@ export function ThreadHeader(
         onPress: onMergeBack,
       });
     }
+    if (onContinueOn) {
+      actions.push({
+        accessibilityLabel: "Continue on another environment",
+        icon: "arrow.up.right",
+        onPress: onContinueOn,
+      });
+    }
     return actions;
   }, [
     props.inspectorMode,
@@ -66,6 +73,7 @@ export function ThreadHeader(
     props.onOpenFilesInspector,
     onOpenTerminal,
     onMergeBack,
+    onContinueOn,
     props.onOpenGitInspector,
     toggleAuxiliaryPane,
     props.onReturnToThread,
diff --git a/apps/mobile/src/features/threads/ThreadNavigationSidebar.tsx b/apps/mobile/src/features/threads/ThreadNavigationSidebar.tsx
index 66be152db074..1abe5415f9cb 100644
--- a/apps/mobile/src/features/threads/ThreadNavigationSidebar.tsx
+++ b/apps/mobile/src/features/threads/ThreadNavigationSidebar.tsx
@@ -303,6 +303,7 @@ function ThreadNavigationSidebarPane(
     pinReorderEnvironmentIds,
     activeReorderEnvironmentIds,
     titleRegenerationEnvironmentIds,
+    handoffEnvironmentIds,
   } = listEnvironments;
   const resolveProviderInstance = useThreadRowProviderInstanceResolver(providersByEnvironmentId);
   const pendingOrder = usePendingThreadOrder(nowMinute, snoozeWakeTick);
@@ -689,6 +690,7 @@ function ThreadNavigationSidebarPane(
               onRenameThread={renameThread}
               onRegenerateThreadTitle={regenerateThreadTitle}
               titleRegenerationSupported={titleRegenerationEnvironmentIds.has(thread.environmentId)}
+              handoffSupported={handoffEnvironmentIds.has(thread.environmentId)}
               settlementSupported={settlementEnvironmentIds.has(thread.environmentId)}
               onSettleThread={settleThread}
               snoozeSupported={snoozeEnvironmentIds.has(thread.environmentId)}
@@ -784,6 +786,7 @@ function ThreadNavigationSidebarPane(
       providersByEnvironmentId,
       threadSearchMatchByKey,
       titleRegenerationEnvironmentIds,
+      handoffEnvironmentIds,
       settleThread,
       settlementEnvironmentIds,
       showMoreSettled,
diff --git a/apps/mobile/src/features/threads/ThreadRouteScreen.tsx b/apps/mobile/src/features/threads/ThreadRouteScreen.tsx
index 28964c2965df..b0b06833abb0 100644
--- a/apps/mobile/src/features/threads/ThreadRouteScreen.tsx
+++ b/apps/mobile/src/features/threads/ThreadRouteScreen.tsx
@@ -801,6 +801,17 @@ function ThreadRouteContent(
       mergeBackTargetThreadId !== null && mergeBackRun !== null
         ? () => void handleMergeBack()
         : undefined,
+    onContinueOn:
+      selectedThread !== null &&
+      selectedThread !== undefined &&
+      routeEnvironmentRuntime?.serverConfig?.environment.capabilities.peerLinks === true &&
+      (selectedThread.handoff === null || selectedThread.handoff.state === "failed")
+        ? () =>
+            navigation.navigate("ThreadHandoff", {
+              environmentId: selectedThread.environmentId,
+              threadId: selectedThread.id,
+            })
+        : undefined,
     currentBranch: selectedThread?.branch ?? null,
     gitStatus: gitStatus.data,
     gitOperationLabel: gitState.gitOperationLabel,
diff --git a/apps/mobile/src/features/threads/thread-list-v2-items.tsx b/apps/mobile/src/features/threads/thread-list-v2-items.tsx
index dc4e6353be15..c78e5c4f2238 100644
--- a/apps/mobile/src/features/threads/thread-list-v2-items.tsx
+++ b/apps/mobile/src/features/threads/thread-list-v2-items.tsx
@@ -21,6 +21,7 @@ import type { EnvironmentThreadSearchMatch } from "@t3tools/client-runtime/state
 import { AuthOrchestrationOperateScope, type EnvironmentMachineKind } from "@t3tools/contracts";
 import { canSnooze, resolveSnoozePresets } from "@t3tools/client-runtime/state/thread-settled";
 import type { MenuAction } from "@react-native-menu/menu";
+import { useNavigation } from "@react-navigation/native";
 import { memo, useCallback, useEffect, useMemo, useState, type ComponentProps } from "react";
 import { Pressable, useWindowDimensions, View } from "react-native";
 import type { SwipeableMethods } from "react-native-gesture-handler/ReanimatedSwipeable";
@@ -502,6 +503,7 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: {
   readonly pinningSupported: boolean;
   readonly autoSettleOptOutSupported: boolean;
   readonly titleRegenerationSupported: boolean;
+  readonly handoffSupported?: boolean;
   readonly reorderSupported?: boolean;
   readonly onMoveThread?: (
     thread: EnvironmentThreadShell,
@@ -535,6 +537,7 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: {
     onSetThreadAutoSettle,
     onMoveThread,
   } = props;
+  const navigation = useNavigation();
   const snoozedRow = props.snoozed === true;
   const pinnedRow = props.pinned === true;
   const dormant = useSwipeRowDormant(props.activationKey);
@@ -705,6 +708,10 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: {
         : [],
     [props.autoSettleOptOutSupported, thread.autoSettleDisabledAt],
   );
+  // The targets are read in the sheet it opens; a native menu is built ahead of time.
+  const canContinueOn =
+    props.handoffSupported === true &&
+    (thread.handoff === null || thread.handoff.state === "failed");
   const titleMenuItems = useMemo<MenuAction[]>(
     () => [
       { id: "rename", title: "Rename", image: "square.and.pencil" },
@@ -712,8 +719,11 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: {
         supported: props.titleRegenerationSupported,
         isRegenerating: thread.titleRegeneration != null,
       }),
+      ...(canContinueOn
+        ? [{ id: "continue-on", title: "Continue on…", image: "arrow.up.right" }]
+        : []),
     ],
-    [props.titleRegenerationSupported, thread.titleRegeneration],
+    [canContinueOn, props.titleRegenerationSupported, thread.titleRegeneration],
   );
   const snoozableCardMenuActions = useMemo<MenuAction[]>(
     () => [
@@ -787,6 +797,12 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: {
       if (nativeEvent.event === "archive") handleArchive();
       if (nativeEvent.event === "rename") handleRename();
       if (nativeEvent.event === "regenerate-title") handleRegenerateTitle();
+      if (nativeEvent.event === "continue-on") {
+        navigation.navigate("ThreadHandoff", {
+          environmentId: thread.environmentId,
+          threadId: thread.id,
+        });
+      }
       if (nativeEvent.event === "copy-thread-id") {
         copyTextWithHaptic(thread.id, { target: "thread-id" });
       }
@@ -811,6 +827,7 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: {
     },
     [
       onNewThreadOnBranch,
+      navigation,
       thread,
       handleArchive,
       handleDelete,
diff --git a/apps/mobile/src/state/thread-list-environments.ts b/apps/mobile/src/state/thread-list-environments.ts
index f1aab3756f5a..5374b1930baf 100644
--- a/apps/mobile/src/state/thread-list-environments.ts
+++ b/apps/mobile/src/state/thread-list-environments.ts
@@ -20,6 +20,7 @@ const capabilityKeys = [
   "threadPinReorder",
   "threadActiveReorder",
   "threadTitleRegeneration",
+  "peerLinks",
 ] as const;
 
 function selectEnvironment(config: ServerConfig) {
@@ -69,6 +70,7 @@ function collectEnvironments(environments: ReadonlyMap<EnvironmentId, ListEnviro
   const pinReorderEnvironmentIds = new Set<EnvironmentId>();
   const activeReorderEnvironmentIds = new Set<EnvironmentId>();
   const titleRegenerationEnvironmentIds = new Set<EnvironmentId>();
+  const handoffEnvironmentIds = new Set<EnvironmentId>();
   for (const [id, { providers, machineKind, capabilities }] of environments) {
     providersByEnvironmentId.set(id, providers);
     machineByEnvironmentId.set(id, machineKind);
@@ -79,6 +81,7 @@ function collectEnvironments(environments: ReadonlyMap<EnvironmentId, ListEnviro
     if (capabilities.threadPinReorder === true) pinReorderEnvironmentIds.add(id);
     if (capabilities.threadActiveReorder === true) activeReorderEnvironmentIds.add(id);
     if (capabilities.threadTitleRegeneration === true) titleRegenerationEnvironmentIds.add(id);
+    if (capabilities.peerLinks === true) handoffEnvironmentIds.add(id);
   }
   return {
     providersByEnvironmentId,
@@ -90,6 +93,7 @@ function collectEnvironments(environments: ReadonlyMap<EnvironmentId, ListEnviro
     pinReorderEnvironmentIds,
     activeReorderEnvironmentIds,
     titleRegenerationEnvironmentIds,
+    handoffEnvironmentIds,
   };
 }
 
diff --git a/apps/mobile/src/state/threadHandoff.ts b/apps/mobile/src/state/threadHandoff.ts
new file mode 100644
index 000000000000..be386fbdf6f3
--- /dev/null
+++ b/apps/mobile/src/state/threadHandoff.ts
@@ -0,0 +1,5 @@
+import { createThreadHandoffEnvironmentAtoms } from "@t3tools/client-runtime/state/peerLinks";
+
+import { connectionAtomRuntime } from "../connection/runtime";
+
+export const threadHandoffEnvironment = createThreadHandoffEnvironmentAtoms(connectionAtomRuntime);
diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
index d813d59323e3..f919b7d87a06 100644
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -248,6 +248,10 @@ import {
 } from "../previewMiniPlayerStore";
 import { threadPullRequestPanelTarget } from "./pullRequest/pullRequestDetail.logic";
 import { RightPanelTabs } from "./RightPanelTabs";
+import {
+  threadHandoffSendBlockReason,
+  useThreadHandoffBannerItem,
+} from "./chat/ThreadHandoffBanner";
 import { LinkPullRequestDialogHost } from "./pullRequest/LinkPullRequestDialog";
 import { useDeviceState } from "~/state/device";
 import { BranchToolbar, type BranchToolbarHandle } from "./BranchToolbar";
@@ -5268,6 +5272,7 @@ export default function ChatView(props: ChatViewProps) {
       onAction={acknowledgeActiveThreadWokeStable}
     />
   ) : null;
+  const threadHandoffBannerItem = useThreadHandoffBannerItem(activeThreadShell);
   const activeThreadHasCompactableConversation = serverVisibleTurnItems.some(
     ({ item }) =>
       item.type === "user_message" &&
@@ -5381,10 +5386,13 @@ export default function ChatView(props: ChatViewProps) {
       goalBannerItem,
       backgroundWorkBannerItem,
     ].filter((item) => item !== null);
+    const handoffItems = threadHandoffBannerItem === null ? [] : [threadHandoffBannerItem];
+    // The user asked for this one, so it leads the notice tier instead of trailing it.
     const usageLimitsItems = usageLimitsBanner === null ? [] : [usageLimitsBanner];
     const projectCloneItems = projectCloneBannerItem === null ? [] : [projectCloneBannerItem];
     if (!localCheckoutBranchMismatch || !showBranchMismatchBanner || !activeBranchMismatchKey) {
       return [
+        ...handoffItems,
         ...feedbackBannerItems,
         ...limitRecoveryItems,
         ...usageLimitsItems,
@@ -5394,6 +5402,7 @@ export default function ChatView(props: ChatViewProps) {
       ];
     }
     return [
+      ...handoffItems,
       ...feedbackBannerItems,
       ...limitRecoveryItems,
       ...usageLimitsItems,
@@ -8224,17 +8233,18 @@ export default function ChatView(props: ChatViewProps) {
                               sendDisabledReason={
                                 !canOperateThread
                                   ? "This connection cannot change threads."
-                                  : isEnvironmentChanging
-                                    ? "Preparing machine"
-                                    : isRevertingCheckpoint
-                                      ? "Rewinding conversation"
-                                      : feedbackUploading
-                                        ? "Sending feedback"
-                                        : threadDetailLoading
-                                          ? "Messages loading"
-                                          : worktreeSetupBlocksSend
-                                            ? "Preparing worktree"
-                                            : projectCloneSendBlockReason
+                                  : (threadHandoffSendBlockReason(activeThreadShell) ??
+                                    (isEnvironmentChanging
+                                      ? "Preparing machine"
+                                      : isRevertingCheckpoint
+                                        ? "Rewinding conversation"
+                                        : feedbackUploading
+                                          ? "Sending feedback"
+                                          : threadDetailLoading
+                                            ? "Messages loading"
+                                            : worktreeSetupBlocksSend
+                                              ? "Preparing worktree"
+                                              : projectCloneSendBlockReason))
                               }
                               isPreparingWorktree={isPreparingWorktree && !sendQueuesBehindSetup}
                               queuedRunsControl={queuedRunsControl}
diff --git a/apps/web/src/components/CommandPalette.tsx b/apps/web/src/components/CommandPalette.tsx
index 7ac6a5bd36c5..f62363214d23 100644
--- a/apps/web/src/components/CommandPalette.tsx
+++ b/apps/web/src/components/CommandPalette.tsx
@@ -26,6 +26,7 @@ import {
 } from "@t3tools/client-runtime/operations/projects";
 import { sourceControlClients } from "@t3tools/client-runtime/source-control-clients";
 import { connectionStatusText } from "@t3tools/client-runtime/connection";
+import { threadRuntimeCanArchive } from "@t3tools/client-runtime/state/models";
 import { threadSearchMatchKey } from "@t3tools/client-runtime/state/thread-search";
 import { resolveThreadReferenceCopyTarget } from "@t3tools/shared/threadReference";
 import {
@@ -70,6 +71,7 @@ import {
   LinkIcon,
   MessageSquareIcon,
   MonitorIcon,
+  MonitorUpIcon,
   MoonIcon,
   PaletteIcon,
   RotateCcwIcon,
@@ -137,6 +139,7 @@ import {
 import { useProjects, useServerConfigs, useThreadShells, waitForProject } from "../state/entities";
 import { useThreadSearch } from "../state/queries";
 import { resolveThreadActionProjectRef, startNewThreadFromContext } from "../lib/chatThreadActions";
+import { readThreadHandoffTargets, startThreadHandoff } from "./threadHandoffMenu";
 import {
   appendBrowsePathSegment,
   ensureBrowseDirectoryPath,
@@ -1761,6 +1764,47 @@ function OpenCommandPaletteDialog(props: {
     }
   }
 
+  if (
+    activeThread !== null &&
+    activeThreadServerConfig?.environment.capabilities.peerLinks === true &&
+    (activeThread.handoff == null || activeThread.handoff.state === "failed")
+  ) {
+    const thread = activeThread;
+    actionItems.push({
+      kind: "action",
+      value: "action:continue-on",
+      searchTerms: ["continue on", "move", "hand off", "handoff", "environment", "machine"],
+      title: "Continue on…",
+      description: "Move this thread and its work to a linked environment",
+      disabled: !threadRuntimeCanArchive(thread.runtime),
+      icon: <MonitorUpIcon className={ITEM_ICON_CLASS} />,
+      keepOpen: true,
+      run: async () => {
+        const targets = await readThreadHandoffTargets(thread.environmentId, thread.id);
+        pushPaletteView({
+          addonIcon: <MonitorUpIcon className={ADDON_ICON_CLASS} />,
+          groups: [
+            {
+              value: "handoff-targets",
+              label: targets.length === 0 ? "No linked environments answered" : "Continue on",
+              items: targets.map((target) => ({
+                kind: "action" as const,
+                value: `action:continue-on:${target.environmentId}`,
+                searchTerms: [target.label],
+                title: target.label,
+                ...(target.reason === null ? {} : { description: target.reason }),
+                disabled: target.reason !== null,
+                icon: <MonitorIcon className={ITEM_ICON_CLASS} />,
+                run: () =>
+                  startThreadHandoff(thread.environmentId, thread.id, target.environmentId),
+              })),
+            },
+          ],
+        });
+      },
+    });
+  }
+
   if (activeThread !== null) {
     const thread = activeThread;
     actionItems.push({
diff --git a/apps/web/src/components/Sidebar.tsx b/apps/web/src/components/Sidebar.tsx
index bd6a50d4dc17..08bda00b25fe 100644
--- a/apps/web/src/components/Sidebar.tsx
+++ b/apps/web/src/components/Sidebar.tsx
@@ -187,6 +187,11 @@ import {
   buildThreadActionMenuItems,
   threadActionRequiresOperate,
 } from "./threadActionMenu.logic";
+import {
+  readThreadHandoffSupported,
+  readThreadHandoffTargets,
+  startThreadHandoff,
+} from "./threadHandoffMenu";
 import {
   animateSidebarLayoutChanges,
   applySidebarThreadDrop,
@@ -4224,6 +4229,12 @@ export default function Sidebar() {
                 projectRef.projectId === thread.projectId,
             ),
           ) ?? null;
+        // Only an environment that can move threads makes the menu wait for targets.
+        const handoffTargets =
+          readThreadHandoffSupported(thread.environmentId) &&
+          (thread.handoff == null || thread.handoff.state === "failed")
+            ? await readThreadHandoffTargets(thread.environmentId, thread.id)
+            : [];
         const clicked = await settlePromise(() =>
           api.contextMenu.show(
             buildThreadActionMenuItems({
@@ -4253,12 +4264,21 @@ export default function Sidebar() {
                 titleRegeneration: supportsTitleRegeneration,
               },
               snoozePresets,
+              handoffTargets,
             }),
             position,
           ),
         );
         if (clicked._tag === "Failure" || clicked.value === null) return;
         if (threadActionRequiresOperate(clicked.value) && !checkThreadOperations([thread])) return;
+        if (clicked.value?.startsWith("continue-on:")) {
+          await startThreadHandoff(
+            thread.environmentId,
+            thread.id,
+            clicked.value.slice("continue-on:".length),
+          );
+          return;
+        }
         if (clicked.value?.startsWith("snooze:")) {
           const preset =
             clicked.value === "snooze:custom"
diff --git a/apps/web/src/components/chat/ThreadHandoffBanner.tsx b/apps/web/src/components/chat/ThreadHandoffBanner.tsx
new file mode 100644
index 000000000000..39ac771d4d5e
--- /dev/null
+++ b/apps/web/src/components/chat/ThreadHandoffBanner.tsx
@@ -0,0 +1,100 @@
+import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell";
+import { threadHandoffNotice } from "@t3tools/client-runtime/state/peerLinks";
+import {
+  isAtomCommandInterrupted,
+  squashAtomCommandFailure,
+} from "@t3tools/client-runtime/state/runtime";
+import { scopeThreadRef } from "@t3tools/client-runtime/environment";
+import { useNavigate } from "@tanstack/react-router";
+import { ArrowUpRightIcon, MonitorUpIcon, TriangleAlertIcon } from "lucide-react";
+import { useMemo, useState } from "react";
+
+import { useEnvironmentIds } from "~/state/environments";
+import { threadHandoffEnvironment } from "~/state/threadHandoff";
+import { useAtomCommand } from "~/state/use-atom-command";
+import { buildThreadRouteParams } from "../../threadRoutes";
+import { Button } from "../ui/button";
+import { stackedThreadToast, toastManager } from "../ui/toast";
+import type { ComposerBannerStackItem } from "./ComposerBannerStack";
+
+/** Why the composer is closed while a thread moves away, or null when it is open. */
+export function threadHandoffSendBlockReason(
+  shell: Pick<EnvironmentThreadShell, "handoff"> | null | undefined,
+): string | null {
+  const handoff = shell?.handoff;
+  if (handoff?.state === "departing") return `Moving to ${handoff.label}`;
+  if (handoff?.state === "departed") return `Continues on ${handoff.label}`;
+  return null;
+}
+
+/**
+ * The banner for a thread's move to a linked environment: waiting (with
+ * Cancel), under way, moved (with a link to it there when this client is
+ * connected to that environment), or failed.
+ */
+export function useThreadHandoffBannerItem(
+  shell: Pick<EnvironmentThreadShell, "environmentId" | "id" | "handoff"> | null | undefined,
+): ComposerBannerStackItem | null {
+  const navigate = useNavigate();
+  const cancel = useAtomCommand(threadHandoffEnvironment.cancel, { label: "cancel thread move" });
+  const [cancelling, setCancelling] = useState(false);
+  const handoff = shell?.handoff ?? null;
+  const environmentIds = useEnvironmentIds();
+  const canOpenThere =
+    handoff?.state === "departed" && environmentIds.includes(handoff.environmentId);
+  return useMemo(() => {
+    const notice = threadHandoffNotice(handoff);
+    if (shell == null || handoff === null || notice === null) return null;
+    const actions =
+      handoff.state === "pending" ? (
+        <Button
+          size="xs"
+          variant="ghost"
+          disabled={cancelling}
+          onClick={() => {
+            setCancelling(true);
+            void cancel({ environmentId: shell.environmentId, input: { threadId: shell.id } }).then(
+              (result) => {
+                setCancelling(false);
+                if (result._tag === "Failure" && !isAtomCommandInterrupted(result)) {
+                  toastManager.add(
+                    stackedThreadToast({
+                      type: "error",
+                      title: "Could not cancel the move",
+                      description: String(squashAtomCommandFailure(result)),
+                    }),
+                  );
+                }
+              },
+            );
+          }}
+        >
+          {cancelling ? "Cancelling…" : "Keep it here"}
+        </Button>
+      ) : handoff.state === "departed" && canOpenThere ? (
+        <Button
+          size="xs"
+          variant="ghost"
+          onClick={() =>
+            void navigate({
+              to: "/$environmentId/$threadId",
+              params: buildThreadRouteParams(
+                scopeThreadRef(handoff.environmentId, handoff.threadId),
+              ),
+            })
+          }
+        >
+          Open on {handoff.label}
+          <ArrowUpRightIcon />
+        </Button>
+      ) : undefined;
+    return {
+      id: `thread-handoff:${shell.id}:${handoff.handoffId}:${handoff.state}`,
+      variant: notice.tone,
+      icon: notice.tone === "error" ? <TriangleAlertIcon /> : <MonitorUpIcon />,
+      title: notice.title,
+      ...(notice.detail === null ? {} : { description: notice.detail }),
+      ...(actions === undefined ? {} : { actions }),
+    };
+  }, [canOpenThere, cancel, cancelling, handoff, navigate, shell]);
+}
diff --git a/apps/web/src/components/threadActionMenu.logic.test.ts b/apps/web/src/components/threadActionMenu.logic.test.ts
index a51f0906460a..83f20bc06b0a 100644
--- a/apps/web/src/components/threadActionMenu.logic.test.ts
+++ b/apps/web/src/components/threadActionMenu.logic.test.ts
@@ -91,6 +91,48 @@ describe("buildThreadActionMenuItems", () => {
     expect(allowed.every((item) => !item.disabled)).toBe(true);
   });
 
+  it("offers each linked environment, disabled with its reason when it cannot take the thread", () => {
+    const items = buildThreadActionMenuItems({
+      ...baseState,
+      handoffTargets: [
+        { environmentId: "environment-box", label: "Box", reason: null },
+        {
+          environmentId: "environment-vps",
+          label: "VPS",
+          reason: "No project with this repository",
+        },
+      ],
+    });
+    const continueOn = items.find((item) => item.id === "continue-on");
+    expect(continueOn?.children).toEqual([
+      { id: "continue-on:environment-box", label: "Box", disabled: false },
+      {
+        id: "continue-on:environment-vps",
+        label: "VPS (No project with this repository)",
+        disabled: true,
+      },
+    ]);
+    // Without targets there is nothing to offer, and a running thread cannot move.
+    expect(buildThreadActionMenuItems(baseState).some((item) => item.id === "continue-on")).toBe(
+      false,
+    );
+    expect(
+      buildThreadActionMenuItems({
+        ...baseState,
+        isRunning: true,
+        handoffTargets: [{ environmentId: "environment-box", label: "Box", reason: null }],
+      }).find((item) => item.id === "continue-on")?.disabled,
+    ).toBe(true);
+    // A connection that cannot change threads cannot move one either.
+    expect(
+      buildThreadActionMenuItems({
+        ...baseState,
+        canOperate: false,
+        handoffTargets: [{ environmentId: "environment-box", label: "Box", reason: null }],
+      }).find((item) => item.id === "continue-on")?.disabled,
+    ).toBe(true);
+  });
+
   it("hides lifecycle items when the environment lacks the capabilities", () => {
     expect(
       ids({
diff --git a/apps/web/src/components/threadActionMenu.logic.ts b/apps/web/src/components/threadActionMenu.logic.ts
index cca7bcf20ed2..039de5ae41d7 100644
--- a/apps/web/src/components/threadActionMenu.logic.ts
+++ b/apps/web/src/components/threadActionMenu.logic.ts
@@ -22,6 +22,8 @@ export type ThreadActionMenuId =
   | "copy-path"
   | "copy-branch"
   | "copy-thread-id"
+  | "continue-on"
+  | `continue-on:${string}`
   | "archive"
   | "delete";
 
@@ -86,6 +88,15 @@ export interface ThreadActionMenuState {
     readonly titleRegeneration: boolean;
   };
   readonly snoozePresets: ReadonlyArray<SnoozePreset>;
+  /**
+   * Linked environments the thread can move to, read when the menu opens;
+   * empty or absent hides "Continue on…". `reason` disables one with a hint.
+   */
+  readonly handoffTargets?: ReadonlyArray<{
+    readonly environmentId: string;
+    readonly label: string;
+    readonly reason: string | null;
+  }>;
 }
 
 /** Local navigation, read markers, and copying remain available to read-only clients. */
@@ -147,6 +158,21 @@ export function buildThreadActionMenuItems(
               },
         ]
       : []),
+    ...(state.handoffTargets !== undefined && state.handoffTargets.length > 0
+      ? [
+          {
+            id: "continue-on" as const,
+            label: "Continue on…",
+            icon: "folder-tree",
+            disabled: state.isRunning,
+            children: state.handoffTargets.map((target) => ({
+              id: `continue-on:${target.environmentId}` as const,
+              label: target.reason === null ? target.label : `${target.label} (${target.reason})`,
+              disabled: target.reason !== null,
+            })),
+          },
+        ]
+      : []),
     { id: "rename", label: "Rename thread", icon: "pencil", separatorBefore: true },
     ...(state.supports.titleRegeneration
       ? [
diff --git a/apps/web/src/components/threadHandoffMenu.ts b/apps/web/src/components/threadHandoffMenu.ts
new file mode 100644
index 000000000000..dce8a0066fea
--- /dev/null
+++ b/apps/web/src/components/threadHandoffMenu.ts
@@ -0,0 +1,79 @@
+import type { EnvironmentId, ThreadId } from "@t3tools/contracts";
+import {
+  runAtomCommand,
+  squashAtomCommandFailure,
+  isAtomCommandInterrupted,
+} from "@t3tools/client-runtime/state/runtime";
+import * as Effect from "effect/Effect";
+import { AtomRegistry } from "effect/reactivity";
+
+import { appAtomRegistry } from "../rpc/atomRegistry";
+import { environmentServerConfigsAtom } from "../state/server";
+import { threadHandoffEnvironment } from "../state/threadHandoff";
+import { stackedThreadToast, toastManager } from "./ui/toast";
+
+/** How long a menu waits for the move targets before opening without them. */
+const TARGETS_TIMEOUT_MS = 1_500;
+
+/** Whether this environment can move threads, so its menus should ask where to. */
+export function readThreadHandoffSupported(environmentId: EnvironmentId): boolean {
+  return (
+    appAtomRegistry.get(environmentServerConfigsAtom).get(environmentId)?.environment.capabilities
+      .peerLinks === true
+  );
+}
+
+/**
+ * Where a thread can move, read as its menu opens. Empty when the environment
+ * cannot move threads, or does not answer in time; the menu then shows no
+ * "Continue on…".
+ */
+export async function readThreadHandoffTargets(
+  environmentId: EnvironmentId,
+  threadId: ThreadId,
+): Promise<
+  ReadonlyArray<{
+    readonly environmentId: string;
+    readonly label: string;
+    readonly reason: string | null;
+  }>
+> {
+  if (!readThreadHandoffSupported(environmentId)) return [];
+  const result = await Effect.runPromise(
+    AtomRegistry.getResult(
+      appAtomRegistry,
+      threadHandoffEnvironment.options({ environmentId, input: { threadId } }),
+      { suspendOnWaiting: true },
+    ).pipe(
+      Effect.timeoutOption(TARGETS_TIMEOUT_MS),
+      Effect.map((found) => (found._tag === "Some" ? found.value.options : [])),
+      Effect.orElseSucceed(() => []),
+    ),
+  );
+  return result.map((option) => ({
+    environmentId: option.environmentId,
+    label: option.label,
+    reason: option.reason,
+  }));
+}
+
+/** Starts the move a "Continue on…" choice asked for; the thread's banner shows how it goes. */
+export async function startThreadHandoff(
+  environmentId: EnvironmentId,
+  threadId: ThreadId,
+  targetEnvironmentId: string,
+): Promise<void> {
+  const result = await runAtomCommand(appAtomRegistry, threadHandoffEnvironment.start, {
+    environmentId,
+    input: { threadId, environmentId: targetEnvironmentId as EnvironmentId },
+  });
+  if (result._tag === "Failure" && !isAtomCommandInterrupted(result)) {
+    toastManager.add(
+      stackedThreadToast({
+        type: "error",
+        title: "Could not move the thread",
+        description: String(squashAtomCommandFailure(result)),
+      }),
+    );
+  }
+}
diff --git a/apps/web/src/hooks/useThreadActionMenu.test.ts b/apps/web/src/hooks/useThreadActionMenu.test.ts
index 4b8054c986fa..4e2cdb51d63a 100644
--- a/apps/web/src/hooks/useThreadActionMenu.test.ts
+++ b/apps/web/src/hooks/useThreadActionMenu.test.ts
@@ -35,6 +35,11 @@ function recordEffect(action: string) {
 }
 
 vi.mock("../components/CustomSnoozeDialog", () => ({ requestCustomSnooze: vi.fn() }));
+vi.mock("../components/threadHandoffMenu", () => ({
+  readThreadHandoffSupported: () => false,
+  readThreadHandoffTargets: async () => [],
+  startThreadHandoff: async () => recordEffect("continue-on"),
+}));
 vi.mock("react", () => ({
   useCallback: (callback: unknown) => callback,
   useMemo: (factory: () => unknown) => factory(),
diff --git a/apps/web/src/hooks/useThreadActionMenu.ts b/apps/web/src/hooks/useThreadActionMenu.ts
index 08ed2b24e4cf..3555469f288d 100644
--- a/apps/web/src/hooks/useThreadActionMenu.ts
+++ b/apps/web/src/hooks/useThreadActionMenu.ts
@@ -20,6 +20,11 @@ import {
   threadActionRequiresOperate,
   type ThreadActionMenuId,
 } from "../components/threadActionMenu.logic";
+import {
+  readThreadHandoffSupported,
+  readThreadHandoffTargets,
+  startThreadHandoff,
+} from "../components/threadHandoffMenu";
 import { stackedThreadToast, toastManager } from "../components/ui/toast";
 import { threadEnvironment } from "../state/threads";
 import { useOrchestrationCommand } from "../state/use-orchestration-command";
@@ -128,6 +133,12 @@ export function useThreadActionMenu(input: {
       };
       const isRegeneratingTitle = thread.titleRegeneration != null;
       const snoozePresets = resolveSnoozePresets(now, timestampFormat);
+      // Only an environment that can move threads makes the menu wait for targets.
+      const handoffTargets =
+        readThreadHandoffSupported(threadRef.environmentId) &&
+        (thread.handoff == null || thread.handoff.state === "failed")
+          ? await readThreadHandoffTargets(threadRef.environmentId, threadRef.threadId)
+          : [];
       const items = buildThreadActionMenuItems({
         canOperate: readEnvironmentScope(threadRef.environmentId, AuthOrchestrationOperateScope),
         branch: thread.branch ?? null,
@@ -141,6 +152,7 @@ export function useThreadActionMenu(input: {
         isRunning: !threadRuntimeCanArchive(thread.runtime),
         supports,
         snoozePresets,
+        handoffTargets,
       });
       const clicked = await settlePromise(() => api.contextMenu.show(items, position));
       if (clicked._tag === "Failure" || clicked.value === null) return;
@@ -155,6 +167,14 @@ export function useThreadActionMenu(input: {
         );
         return;
       }
+      if (action.startsWith("continue-on:")) {
+        await startThreadHandoff(
+          threadRef.environmentId,
+          threadRef.threadId,
+          action.slice("continue-on:".length),
+        );
+        return;
+      }
       if (action.startsWith("snooze:")) {
         const preset =
           action === "snooze:custom"
diff --git a/apps/web/src/state/threadHandoff.ts b/apps/web/src/state/threadHandoff.ts
new file mode 100644
index 000000000000..be386fbdf6f3
--- /dev/null
+++ b/apps/web/src/state/threadHandoff.ts
@@ -0,0 +1,5 @@
+import { createThreadHandoffEnvironmentAtoms } from "@t3tools/client-runtime/state/peerLinks";
+
+import { connectionAtomRuntime } from "../connection/runtime";
+
+export const threadHandoffEnvironment = createThreadHandoffEnvironmentAtoms(connectionAtomRuntime);
diff --git a/docs/user/remote-access.md b/docs/user/remote-access.md
index 75747a7e0f48..c6e83c69fabc 100644
--- a/docs/user/remote-access.md
+++ b/docs/user/remote-access.md
@@ -275,7 +275,9 @@ and the access, then approve.
 ### Continue a thread on another machine
 
 A thread can move to a linked machine with its conversation and its code:
-commits you have not pushed, uncommitted edits and new files. It continues
+commits you have not pushed, uncommitted edits and new files. Choose
+**Continue on…** from the thread's menu or the command palette, or from the
+thread's long-press or header menu on mobile, then pick the machine. It continues
 there in a new worktree of the project with the same repository, and the copy
 here becomes read-only with a link to it. Ignored files such as `.env` stay
 behind, and a move larger than 50 MB asks you to push the branch first.
diff --git a/packages/client-runtime/src/state/models.ts b/packages/client-runtime/src/state/models.ts
index 47d5ec49bc5f..4349c2d13ff8 100644
--- a/packages/client-runtime/src/state/models.ts
+++ b/packages/client-runtime/src/state/models.ts
@@ -99,6 +99,8 @@ export interface EnvironmentThreadShell {
   readonly linkOrigin: OrchestrationV2ThreadShell["linkOrigin"] | null;
   /** The thread in a linked environment that delegated this one, if one did. */
   readonly delegatedFrom: OrchestrationV2ThreadShell["delegatedFrom"] | null;
+  /** A move to a linked environment: waiting, under way, done, or failed. */
+  readonly handoff: NonNullable<OrchestrationV2ThreadShell["handoff"]> | null;
   readonly activeProviderThreadId: OrchestrationV2ThreadShell["activeProviderThreadId"];
   readonly latestRun: ThreadRunSummary | null;
   readonly runtime: ThreadRuntimeSummary | null;
@@ -240,6 +242,7 @@ export function presentThreadShell(
     forkedFrom: thread.forkedFrom,
     linkOrigin: thread.linkOrigin ?? null,
     delegatedFrom: thread.delegatedFrom ?? null,
+    handoff: thread.handoff ?? null,
     activeProviderThreadId: thread.activeProviderThreadId,
     latestRun,
     runtime: shellRuntime(thread),
diff --git a/packages/client-runtime/src/state/peerLinks.test.ts b/packages/client-runtime/src/state/peerLinks.test.ts
index 4a02b2a618d2..9457f7eb0ada 100644
--- a/packages/client-runtime/src/state/peerLinks.test.ts
+++ b/packages/client-runtime/src/state/peerLinks.test.ts
@@ -2,7 +2,7 @@ import { EnvironmentId, type PeerLinkSummary } from "@t3tools/contracts";
 import { describe, expect, it } from "@effect/vitest";
 import * as DateTime from "effect/DateTime";
 
-import { peerLinkHealth } from "./peerLinks.ts";
+import { peerLinkHealth, threadHandoffNotice } from "./peerLinks.ts";
 
 const now = DateTime.makeUnsafe("2026-10-06T12:00:00.000Z");
 const link = (overrides: Partial<PeerLinkSummary>): PeerLinkSummary => ({
@@ -46,3 +46,29 @@ describe("peerLinkHealth", () => {
     });
   });
 });
+
+describe("threadHandoffNotice", () => {
+  const base = {
+    handoffId: "h",
+    environmentId: EnvironmentId.make("environment-box"),
+    label: "Box",
+  };
+  it("tells the user a waiting move can still be cancelled", () => {
+    expect(threadHandoffNotice({ ...base, state: "pending" })?.detail).toBe(
+      "Send a message to keep it here instead.",
+    );
+  });
+  it("marks the copy left behind as read-only, and a failure with its reason", () => {
+    expect(
+      threadHandoffNotice({ ...base, state: "departed", threadId: "thread:x" as never }),
+    ).toMatchObject({ title: "This thread continues on Box", detail: "This copy is read-only." });
+    expect(
+      threadHandoffNotice({ ...base, state: "failed", lastError: "Push the branch." }),
+    ).toEqual({
+      tone: "error",
+      title: "Could not move to Box",
+      detail: "Push the branch.",
+    });
+    expect(threadHandoffNotice(null)).toBeNull();
+  });
+});
diff --git a/packages/client-runtime/src/state/peerLinks.ts b/packages/client-runtime/src/state/peerLinks.ts
index 2dbaf0d9893e..417744d65fd1 100644
--- a/packages/client-runtime/src/state/peerLinks.ts
+++ b/packages/client-runtime/src/state/peerLinks.ts
@@ -1,4 +1,8 @@
-import { type PeerLinkSummary, WS_METHODS } from "@t3tools/contracts";
+import {
+  type OrchestrationV2ThreadShell,
+  type PeerLinkSummary,
+  WS_METHODS,
+} from "@t3tools/contracts";
 import * as DateTime from "effect/DateTime";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
@@ -34,6 +38,61 @@ export function createPeerLinkEnvironmentAtoms<R, E>(
   };
 }
 
+/** Moving threads to linked environments, as one environment's server does it. */
+export function createThreadHandoffEnvironmentAtoms<R, E>(
+  runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>,
+) {
+  return {
+    options: createEnvironmentRpcQueryAtomFamily(runtime, {
+      label: "environment-data:thread-handoff:options",
+      tag: WS_METHODS.threadHandoffOptions,
+      // Each read probes every linked environment for a matching project.
+      staleTimeMs: 15_000,
+    }),
+    start: createEnvironmentRpcCommand(runtime, {
+      label: "environment-data:thread-handoff:start",
+      tag: WS_METHODS.threadHandoffStart,
+    }),
+    cancel: createEnvironmentRpcCommand(runtime, {
+      label: "environment-data:thread-handoff:cancel",
+      tag: WS_METHODS.threadHandoffCancel,
+    }),
+  };
+}
+
+/** What a thread's banner says about its move, or nothing when there is none to show. */
+export function threadHandoffNotice(
+  handoff: NonNullable<OrchestrationV2ThreadShell["handoff"]> | null | undefined,
+): {
+  readonly tone: "info" | "warning" | "error";
+  readonly title: string;
+  readonly detail: string | null;
+} | null {
+  if (handoff === null || handoff === undefined) return null;
+  switch (handoff.state) {
+    case "pending":
+      return {
+        tone: "info",
+        title: `Moving to ${handoff.label} when this turn ends`,
+        detail: "Send a message to keep it here instead.",
+      };
+    case "departing":
+      return { tone: "info", title: `Moving to ${handoff.label}…`, detail: null };
+    case "departed":
+      return {
+        tone: "info",
+        title: `This thread continues on ${handoff.label}`,
+        detail: "This copy is read-only.",
+      };
+    case "failed":
+      return {
+        tone: "error",
+        title: `Could not move to ${handoff.label}`,
+        detail: handoff.lastError,
+      };
+  }
+}
+
 /** Links expire after 30 days and cannot be renewed yet, so warn this long before. */
 const EXPIRY_WARNING_DAYS = 5;
 
diff --git a/vite.config.ts b/vite.config.ts
index 812e5d504fc7..da30d903c12d 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -389,6 +389,7 @@ export default defineConfig({
           "apps/mobile/src/features/threads/NewTaskContextPickerScreens.tsx",
           "apps/mobile/src/features/threads/ThreadQueueControl.tsx",
           "apps/mobile/src/features/threads/ThreadAgentsSheet.tsx",
+          "apps/mobile/src/features/threads/ThreadHandoffSheet.tsx",
           "apps/mobile/src/features/review/ReviewCommentCard.tsx",
           "apps/mobile/src/features/threads/ThreadSettingsSheet.tsx",
           "apps/mobile/src/features/threads/git/GitOverviewSheet.tsx",

From 4476b7f99e93c665f20ce1c99fbdd64a426fd976 Mon Sep 17 00:00:00 2001
From: Julius Marminge <51714798+juliusmarminge@users.noreply.github.com>
Date: Fri, 16 Oct 2026 10:11:19 -0700
Subject: [PATCH 2/4] fix(web): handoff menus, sends and banners respect the
 move's state

"Open on <machine>" showed for a destination this client knew about but
was not connected to; it now needs a connected environment.

The thread menus waited for move targets and then showed the menu even
if the user had since closed it, opened another, or switched threads.
Each open now takes a token, and a stale one is dropped before showing.

Preview annotations and app messages reached onSend and sendAppMessage
directly, past the closed send button, so they could clear the composer
for a thread that is moving away. Both now check the handoff first.

The handoff notice sat ahead of the system notices, so on a priority tie
it hid an update or reconnect notice in the collapsed stack.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 apps/web/src/components/ChatView.tsx          |  10 +-
 apps/web/src/components/Sidebar.tsx           |   4 +
 .../components/chat/ThreadHandoffBanner.tsx   | 114 +++++++++---------
 .../web/src/hooks/useThreadActionMenu.test.ts |  45 ++++++-
 apps/web/src/hooks/useThreadActionMenu.ts     |  14 +++
 5 files changed, 123 insertions(+), 64 deletions(-)

diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
index f919b7d87a06..48b1f94b50b2 100644
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -3368,6 +3368,8 @@ export default function ChatView(props: ChatViewProps) {
     if (!isServerThread || activeThreadId === null) {
       throw new Error("Messages from apps need a started thread.");
     }
+    const handoffBlockReason = threadHandoffSendBlockReason(activeThreadShell);
+    if (handoffBlockReason !== null) throw new Error(handoffBlockReason);
     const result = await startThreadTurn({
       environmentId,
       input: {
@@ -5387,27 +5389,27 @@ export default function ChatView(props: ChatViewProps) {
       backgroundWorkBannerItem,
     ].filter((item) => item !== null);
     const handoffItems = threadHandoffBannerItem === null ? [] : [threadHandoffBannerItem];
-    // The user asked for this one, so it leads the notice tier instead of trailing it.
     const usageLimitsItems = usageLimitsBanner === null ? [] : [usageLimitsBanner];
     const projectCloneItems = projectCloneBannerItem === null ? [] : [projectCloneBannerItem];
     if (!localCheckoutBranchMismatch || !showBranchMismatchBanner || !activeBranchMismatchKey) {
       return [
-        ...handoffItems,
         ...feedbackBannerItems,
         ...limitRecoveryItems,
         ...usageLimitsItems,
         ...projectCloneItems,
         ...systemComposerBannerItems,
+        // After the system notices, so a reconnect or update notice wins a priority tie.
+        ...handoffItems,
         ...backgroundWorkItems,
       ];
     }
     return [
-      ...handoffItems,
       ...feedbackBannerItems,
       ...limitRecoveryItems,
       ...usageLimitsItems,
       ...projectCloneItems,
       ...systemComposerBannerItems,
+      ...handoffItems,
       ...backgroundWorkItems,
       {
         id: `branch-mismatch:${activeBranchMismatchKey}`,
@@ -6006,6 +6008,8 @@ export default function ChatView(props: ChatViewProps) {
     if (
       !readEnvironmentScope(environmentId, AuthOrchestrationOperateScope) ||
       !activeThread ||
+      // The send button is closed for this too, but annotations reach onSend directly.
+      threadHandoffSendBlockReason(activeThreadShell) !== null ||
       (isSendBusy && !sendQueuesBehindSetup) ||
       isConnecting ||
       isRevertingCheckpoint ||
diff --git a/apps/web/src/components/Sidebar.tsx b/apps/web/src/components/Sidebar.tsx
index 08bda00b25fe..d8d55fdc4d53 100644
--- a/apps/web/src/components/Sidebar.tsx
+++ b/apps/web/src/components/Sidebar.tsx
@@ -4186,8 +4186,11 @@ export default function Sidebar() {
     },
   );
 
+  // Waiting for move targets can outlast the right-click that asked for them.
+  const latestThreadContextMenuRef = useRef(0);
   const handleThreadContextMenu = useStableCallback(
     (threadRef: ScopedThreadRef, position: { x: number; y: number }) => {
+      const open = ++latestThreadContextMenuRef.current;
       void (async () => {
         const api = readLocalApi();
         if (!api) return;
@@ -4235,6 +4238,7 @@ export default function Sidebar() {
           (thread.handoff == null || thread.handoff.state === "failed")
             ? await readThreadHandoffTargets(thread.environmentId, thread.id)
             : [];
+        if (open !== latestThreadContextMenuRef.current) return;
         const clicked = await settlePromise(() =>
           api.contextMenu.show(
             buildThreadActionMenuItems({
diff --git a/apps/web/src/components/chat/ThreadHandoffBanner.tsx b/apps/web/src/components/chat/ThreadHandoffBanner.tsx
index 39ac771d4d5e..74111583e92e 100644
--- a/apps/web/src/components/chat/ThreadHandoffBanner.tsx
+++ b/apps/web/src/components/chat/ThreadHandoffBanner.tsx
@@ -7,9 +7,9 @@ import {
 import { scopeThreadRef } from "@t3tools/client-runtime/environment";
 import { useNavigate } from "@tanstack/react-router";
 import { ArrowUpRightIcon, MonitorUpIcon, TriangleAlertIcon } from "lucide-react";
-import { useMemo, useState } from "react";
+import { useState } from "react";
 
-import { useEnvironmentIds } from "~/state/environments";
+import { useConnectedEnvironmentIds } from "~/state/environments";
 import { threadHandoffEnvironment } from "~/state/threadHandoff";
 import { useAtomCommand } from "~/state/use-atom-command";
 import { buildThreadRouteParams } from "../../threadRoutes";
@@ -39,62 +39,58 @@ export function useThreadHandoffBannerItem(
   const cancel = useAtomCommand(threadHandoffEnvironment.cancel, { label: "cancel thread move" });
   const [cancelling, setCancelling] = useState(false);
   const handoff = shell?.handoff ?? null;
-  const environmentIds = useEnvironmentIds();
+  const connectedEnvironmentIds = useConnectedEnvironmentIds();
   const canOpenThere =
-    handoff?.state === "departed" && environmentIds.includes(handoff.environmentId);
-  return useMemo(() => {
-    const notice = threadHandoffNotice(handoff);
-    if (shell == null || handoff === null || notice === null) return null;
-    const actions =
-      handoff.state === "pending" ? (
-        <Button
-          size="xs"
-          variant="ghost"
-          disabled={cancelling}
-          onClick={() => {
-            setCancelling(true);
-            void cancel({ environmentId: shell.environmentId, input: { threadId: shell.id } }).then(
-              (result) => {
-                setCancelling(false);
-                if (result._tag === "Failure" && !isAtomCommandInterrupted(result)) {
-                  toastManager.add(
-                    stackedThreadToast({
-                      type: "error",
-                      title: "Could not cancel the move",
-                      description: String(squashAtomCommandFailure(result)),
-                    }),
-                  );
-                }
-              },
-            );
-          }}
-        >
-          {cancelling ? "Cancelling…" : "Keep it here"}
-        </Button>
-      ) : handoff.state === "departed" && canOpenThere ? (
-        <Button
-          size="xs"
-          variant="ghost"
-          onClick={() =>
-            void navigate({
-              to: "/$environmentId/$threadId",
-              params: buildThreadRouteParams(
-                scopeThreadRef(handoff.environmentId, handoff.threadId),
-              ),
-            })
-          }
-        >
-          Open on {handoff.label}
-          <ArrowUpRightIcon />
-        </Button>
-      ) : undefined;
-    return {
-      id: `thread-handoff:${shell.id}:${handoff.handoffId}:${handoff.state}`,
-      variant: notice.tone,
-      icon: notice.tone === "error" ? <TriangleAlertIcon /> : <MonitorUpIcon />,
-      title: notice.title,
-      ...(notice.detail === null ? {} : { description: notice.detail }),
-      ...(actions === undefined ? {} : { actions }),
-    };
-  }, [canOpenThere, cancel, cancelling, handoff, navigate, shell]);
+    handoff?.state === "departed" && connectedEnvironmentIds.includes(handoff.environmentId);
+  const notice = threadHandoffNotice(handoff);
+  if (shell == null || handoff === null || notice === null) return null;
+  const actions =
+    handoff.state === "pending" ? (
+      <Button
+        size="xs"
+        variant="ghost"
+        disabled={cancelling}
+        onClick={() => {
+          setCancelling(true);
+          void cancel({ environmentId: shell.environmentId, input: { threadId: shell.id } }).then(
+            (result) => {
+              setCancelling(false);
+              if (result._tag === "Failure" && !isAtomCommandInterrupted(result)) {
+                toastManager.add(
+                  stackedThreadToast({
+                    type: "error",
+                    title: "Could not cancel the move",
+                    description: String(squashAtomCommandFailure(result)),
+                  }),
+                );
+              }
+            },
+          );
+        }}
+      >
+        {cancelling ? "Cancelling…" : "Keep it here"}
+      </Button>
+    ) : handoff.state === "departed" && canOpenThere ? (
+      <Button
+        size="xs"
+        variant="ghost"
+        onClick={() =>
+          void navigate({
+            to: "/$environmentId/$threadId",
+            params: buildThreadRouteParams(scopeThreadRef(handoff.environmentId, handoff.threadId)),
+          })
+        }
+      >
+        Open on {handoff.label}
+        <ArrowUpRightIcon />
+      </Button>
+    ) : undefined;
+  return {
+    id: `thread-handoff:${shell.id}:${handoff.handoffId}:${handoff.state}`,
+    variant: notice.tone,
+    icon: notice.tone === "error" ? <TriangleAlertIcon /> : <MonitorUpIcon />,
+    title: notice.title,
+    ...(notice.detail === null ? {} : { description: notice.detail }),
+    ...(actions === undefined ? {} : { actions }),
+  };
 }
diff --git a/apps/web/src/hooks/useThreadActionMenu.test.ts b/apps/web/src/hooks/useThreadActionMenu.test.ts
index 4e2cdb51d63a..4844e979fd3a 100644
--- a/apps/web/src/hooks/useThreadActionMenu.test.ts
+++ b/apps/web/src/hooks/useThreadActionMenu.test.ts
@@ -21,6 +21,9 @@ const state = vi.hoisted(() => ({
   granted: new Set<string>(),
   effects: [] as string[],
   completed: deferred<void>(),
+  handoffTargets: null as Promise<
+    ReadonlyArray<{ environmentId: string; label: string; reason: string | null }>
+  > | null,
   show: vi.fn<
     (
       items: ReadonlyArray<ContextMenuItem<ThreadActionMenuId>>,
@@ -36,13 +39,15 @@ function recordEffect(action: string) {
 
 vi.mock("../components/CustomSnoozeDialog", () => ({ requestCustomSnooze: vi.fn() }));
 vi.mock("../components/threadHandoffMenu", () => ({
-  readThreadHandoffSupported: () => false,
-  readThreadHandoffTargets: async () => [],
+  readThreadHandoffSupported: () => state.handoffTargets !== null,
+  readThreadHandoffTargets: () => state.handoffTargets ?? Promise.resolve([]),
   startThreadHandoff: async () => recordEffect("continue-on"),
 }));
 vi.mock("react", () => ({
   useCallback: (callback: unknown) => callback,
+  useEffect: () => {},
   useMemo: (factory: () => unknown) => factory(),
+  useRef: (current: unknown) => ({ current }),
 }));
 vi.mock("@tanstack/react-router", () => ({
   useRouter: () => ({ navigate: async () => recordEffect("project-settings") }),
@@ -167,9 +172,45 @@ beforeEach(() => {
   state.granted = new Set(["primary"]);
   state.effects = [];
   state.completed = deferred<void>();
+  state.handoffTargets = null;
   state.show.mockReset().mockResolvedValue(null);
 });
 
+describe("thread menu while move targets load", () => {
+  const targets = [{ environmentId: "box", label: "Box", reason: null }];
+
+  it("shows the menu once the targets arrive", async () => {
+    state.handoffTargets = Promise.resolve(targets);
+    createMenu().openMenu(position);
+    await vi.waitFor(() => expect(state.show).toHaveBeenCalledTimes(1));
+    expect(state.show.mock.calls[0]![0].some((item) => item.id === "continue-on")).toBe(true);
+  });
+
+  it("drops an open the user closed or replaced before the targets arrived", async () => {
+    const first = deferred<typeof targets>();
+    state.handoffTargets = first.promise;
+    const menu = createMenu();
+    menu.openMenu(position);
+    menu.closeMenu();
+    first.resolve(targets);
+    await first.promise;
+    await Promise.resolve();
+    expect(state.show).not.toHaveBeenCalled();
+
+    const stale = deferred<typeof targets>();
+    state.handoffTargets = stale.promise;
+    menu.openMenu(position);
+    state.handoffTargets = Promise.resolve(targets);
+    menu.openMenu({ x: 30, y: 40 });
+    stale.resolve(targets);
+    await vi.waitFor(() => expect(state.show).toHaveBeenCalledTimes(1));
+    await stale.promise;
+    await Promise.resolve();
+    expect(state.show).toHaveBeenCalledTimes(1);
+    expect(state.show.mock.calls[0]![1]).toEqual({ x: 30, y: 40 });
+  });
+});
+
 describe("thread menu permissions", () => {
   it("disables mutations for a denied secondary environment", () => {
     createMenu().openMenu(position);
diff --git a/apps/web/src/hooks/useThreadActionMenu.ts b/apps/web/src/hooks/useThreadActionMenu.ts
index 3555469f288d..aa40bbb9c3b2 100644
--- a/apps/web/src/hooks/useThreadActionMenu.ts
+++ b/apps/web/src/hooks/useThreadActionMenu.ts
@@ -13,6 +13,7 @@ import {
   type ThreadId,
 } from "@t3tools/contracts";
 import { useRouter } from "@tanstack/react-router";
+import { useEffect, useRef } from "react";
 
 import { resolveSnoozePresets } from "../components/Sidebar.snooze";
 import {
@@ -116,8 +117,19 @@ export function useThreadActionMenu(input: {
     onError: (error) => failureToast("Failed to copy thread ID", error),
   });
 
+  // Waiting for move targets can outlast the open that asked for them: a newer
+  // open, a close, or a switch to another thread each make the pending one stale.
+  const latestOpenRef = useRef(0);
+  useEffect(() => {
+    if (threadRef === null) return;
+    return () => {
+      latestOpenRef.current += 1;
+    };
+  }, [threadRef]);
+
   const openMenu = (position: { x: number; y: number }) => {
     if (threadRef === null) return;
+    const open = ++latestOpenRef.current;
     void (async () => {
       const api = readLocalApi();
       if (!api) return;
@@ -139,6 +151,7 @@ export function useThreadActionMenu(input: {
         (thread.handoff == null || thread.handoff.state === "failed")
           ? await readThreadHandoffTargets(threadRef.environmentId, threadRef.threadId)
           : [];
+      if (open !== latestOpenRef.current) return;
       const items = buildThreadActionMenuItems({
         canOperate: readEnvironmentScope(threadRef.environmentId, AuthOrchestrationOperateScope),
         branch: thread.branch ?? null,
@@ -340,6 +353,7 @@ export function useThreadActionMenu(input: {
   };
 
   const closeMenu = () => {
+    latestOpenRef.current += 1;
     void readLocalApi()?.contextMenu.close();
   };
 

From acd5fd0603fe8b22b37faf96fa57e8b09cf0f75b Mon Sep 17 00:00:00 2001
From: Julius Marminge <51714798+juliusmarminge@users.noreply.github.com>
Date: Fri, 16 Oct 2026 10:23:23 -0700
Subject: [PATCH 3/4] fix(mobile): offer a thread's move only when it can work
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

"Open on <machine>" showed for any destination in the catalog; it now
needs that environment to be connected.

The thread header offered "Continue on…" to a connection that cannot
change threads, and both it and the row menu offered it while a turn was
live or queued, which the server refuses. Both now check that first.

A message waiting in this device's outbox would be refused once its
thread starts moving, losing it. The sheet now says so and holds the
move until that message is sent or discarded.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../features/threads/ThreadHandoffCard.tsx    |  3 ++-
 .../features/threads/ThreadHandoffSheet.tsx   | 19 +++++++++++++++++--
 .../features/threads/ThreadRouteScreen.tsx    |  6 +++++-
 .../features/threads/thread-list-v2-items.tsx | 11 +++++++----
 4 files changed, 31 insertions(+), 8 deletions(-)

diff --git a/apps/mobile/src/features/threads/ThreadHandoffCard.tsx b/apps/mobile/src/features/threads/ThreadHandoffCard.tsx
index bcd05e4b1e6b..6eb1c0537383 100644
--- a/apps/mobile/src/features/threads/ThreadHandoffCard.tsx
+++ b/apps/mobile/src/features/threads/ThreadHandoffCard.tsx
@@ -70,7 +70,8 @@ export function ThreadHandoffCard({ thread }: { thread: EnvironmentThreadShell }
             onPress={() => void keepHere()}
           />
         </View>
-      ) : handoff.state === "departed" && presentationById.has(handoff.environmentId) ? (
+      ) : handoff.state === "departed" &&
+        presentationById.get(handoff.environmentId)?.connection.phase === "connected" ? (
         <View className="flex-row">
           <RequestActionButton
             label={`Open on ${handoff.label}`}
diff --git a/apps/mobile/src/features/threads/ThreadHandoffSheet.tsx b/apps/mobile/src/features/threads/ThreadHandoffSheet.tsx
index 71a329b37ed8..523b94fed1cc 100644
--- a/apps/mobile/src/features/threads/ThreadHandoffSheet.tsx
+++ b/apps/mobile/src/features/threads/ThreadHandoffSheet.tsx
@@ -9,11 +9,13 @@ import { useSafeAreaInsets } from "react-native-safe-area-context";
 
 import { AndroidSheetHeader } from "../../components/ui/AndroidScreenHeader";
 import { AppText as Text } from "../../components/ui/AppText";
+import { scopedThreadKey } from "../../lib/scopedEntities";
 import { useUniwindTheme } from "../../lib/useUniwindTheme";
 import { nativeHeaderScrollEdgeEffects } from "../../native/StackHeader";
 import { useEnvironmentQuery } from "../../state/query";
 import { threadHandoffEnvironment } from "../../state/threadHandoff";
 import { useAtomCommand } from "../../state/use-atom-command";
+import { useQueuedThreadKeys } from "../../state/use-thread-outbox";
 
 const HEADER_SCROLL_EDGE_EFFECTS = nativeHeaderScrollEdgeEffects(Platform.OS, Platform.Version);
 
@@ -40,8 +42,14 @@ export function ThreadHandoffSheet({ route }: StaticScreenProps<HandoffTarget>)
   });
   const [starting, setStarting] = useState<EnvironmentId | null>(null);
   const [error, setError] = useState<string | null>(null);
+  // A message waiting in the outbox exists only on this device. Once the thread
+  // starts moving, the server refuses it, so it would be lost.
+  const outboxWaiting = useQueuedThreadKeys().has(
+    scopedThreadKey(target.environmentId, target.threadId),
+  );
 
   const choose = async (environmentId: EnvironmentId) => {
+    if (outboxWaiting) return;
     void Haptics.selectionAsync();
     setStarting(environmentId);
     setError(null);
@@ -69,6 +77,11 @@ export function ThreadHandoffSheet({ route }: StaticScreenProps<HandoffTarget>)
         Moves the conversation, unpushed commits, and uncommitted changes. This thread becomes
         read-only here.
       </Text>
+      {outboxWaiting ? (
+        <Text accessibilityRole="alert" className="pt-2 text-sm text-danger-foreground">
+          A message is still waiting to send from this device. Send or discard it first.
+        </Text>
+      ) : null}
       {options.error ? (
         <Text className="pt-4 text-sm text-danger-foreground">{options.error}</Text>
       ) : options.data === null ? (
@@ -82,8 +95,10 @@ export function ThreadHandoffSheet({ route }: StaticScreenProps<HandoffTarget>)
           <Pressable
             key={option.environmentId}
             accessibilityRole="button"
-            accessibilityState={{ disabled: option.reason !== null || starting !== null }}
-            disabled={option.reason !== null || starting !== null}
+            accessibilityState={{
+              disabled: option.reason !== null || starting !== null || outboxWaiting,
+            }}
+            disabled={option.reason !== null || starting !== null || outboxWaiting}
             onPress={() => void choose(option.environmentId)}
             className="border-b border-border py-3.5 active:opacity-70 disabled:opacity-50"
           >
diff --git a/apps/mobile/src/features/threads/ThreadRouteScreen.tsx b/apps/mobile/src/features/threads/ThreadRouteScreen.tsx
index b0b06833abb0..5c9f753fbdc9 100644
--- a/apps/mobile/src/features/threads/ThreadRouteScreen.tsx
+++ b/apps/mobile/src/features/threads/ThreadRouteScreen.tsx
@@ -73,6 +73,7 @@ import { useSelectedThreadGitState } from "../../state/use-selected-thread-git-s
 import { useSelectedThreadRequests } from "../../state/use-selected-thread-requests";
 import { useSelectedThreadWorktree } from "../../state/use-selected-thread-worktree";
 import { useThreadComposerState } from "../../state/use-thread-composer-state";
+import { threadRuntimeIsActive } from "@t3tools/client-runtime/state/models";
 import { resolveMergeBackTargetThreadId } from "@t3tools/client-runtime/state/thread-relationships";
 import { resolveLatestMergeBackRun } from "@t3tools/client-runtime/state/thread-workflows";
 import { threadEnvironment } from "../../state/threads";
@@ -804,8 +805,11 @@ function ThreadRouteContent(
     onContinueOn:
       selectedThread !== null &&
       selectedThread !== undefined &&
+      canOperateThread &&
       routeEnvironmentRuntime?.serverConfig?.environment.capabilities.peerLinks === true &&
-      (selectedThread.handoff === null || selectedThread.handoff.state === "failed")
+      (selectedThread.handoff === null || selectedThread.handoff.state === "failed") &&
+      // The server refuses to move a thread while any of its turns is live or queued.
+      !threadRuntimeIsActive(selectedThread.runtime)
         ? () =>
             navigation.navigate("ThreadHandoff", {
               environmentId: selectedThread.environmentId,
diff --git a/apps/mobile/src/features/threads/thread-list-v2-items.tsx b/apps/mobile/src/features/threads/thread-list-v2-items.tsx
index c78e5c4f2238..8c4927b7a214 100644
--- a/apps/mobile/src/features/threads/thread-list-v2-items.tsx
+++ b/apps/mobile/src/features/threads/thread-list-v2-items.tsx
@@ -13,9 +13,10 @@ import { CustomSnoozeSheet } from "./CustomSnoozeSheet";
 import { appAtomRegistry } from "../../state/atom-registry";
 import { threadArrangementOpenAtom } from "../../state/thread-order";
 import type { ThreadMoveDestination } from "./threadOrder";
-import type {
-  EnvironmentProject,
-  EnvironmentThreadShell,
+import {
+  threadRuntimeIsActive,
+  type EnvironmentProject,
+  type EnvironmentThreadShell,
 } from "@t3tools/client-runtime/state/shell";
 import type { EnvironmentThreadSearchMatch } from "@t3tools/client-runtime/state/thread-search";
 import { AuthOrchestrationOperateScope, type EnvironmentMachineKind } from "@t3tools/contracts";
@@ -709,9 +710,11 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: {
     [props.autoSettleOptOutSupported, thread.autoSettleDisabledAt],
   );
   // The targets are read in the sheet it opens; a native menu is built ahead of time.
+  // The server refuses to move a thread while any of its turns is live or queued.
   const canContinueOn =
     props.handoffSupported === true &&
-    (thread.handoff === null || thread.handoff.state === "failed");
+    (thread.handoff === null || thread.handoff.state === "failed") &&
+    !threadRuntimeIsActive(thread.runtime);
   const titleMenuItems = useMemo<MenuAction[]>(
     () => [
       { id: "rename", title: "Rename", image: "square.and.pencil" },

From debdafdeb902f9c339f14d277bcbb210a5525e2d Mon Sep 17 00:00:00 2001
From: Julius Marminge <51714798+juliusmarminge@users.noreply.github.com>
Date: Fri, 16 Oct 2026 12:39:24 -0700
Subject: [PATCH 4/4] =?UTF-8?q?fix(web,mobile):=20Continue=20on=E2=80=A6?=
 =?UTF-8?q?=20needs=20operate=20access,=20and=20the=20mobile=20fallback=20?=
 =?UTF-8?q?menu=20offers=20it?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The command palette offered Continue on… on a read-only connection; it now needs
operate access, like the thread menus. On mobile layouts without native header glass
the header falls back to a menu that did not list the action.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../mobile/src/features/threads/ThreadGitControls.tsx | 11 +++++++++++
 apps/web/src/components/CommandPalette.tsx            |  4 +++-
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/apps/mobile/src/features/threads/ThreadGitControls.tsx b/apps/mobile/src/features/threads/ThreadGitControls.tsx
index bd811aae68ff..3a122834413f 100644
--- a/apps/mobile/src/features/threads/ThreadGitControls.tsx
+++ b/apps/mobile/src/features/threads/ThreadGitControls.tsx
@@ -601,6 +601,17 @@ function threadGitMenuDefinition(
         subtitle: "Turn diffs and worktree changes",
         onPress: model.openReview,
       },
+      ...(props.onContinueOn
+        ? [
+            {
+              id: "git-continue-on",
+              title: "Continue on…",
+              icon: "arrow.up.right",
+              subtitle: "Move this thread and its work to a linked environment",
+              onPress: props.onContinueOn,
+            },
+          ]
+        : []),
       {
         id: "git-more",
         title: "More",
diff --git a/apps/web/src/components/CommandPalette.tsx b/apps/web/src/components/CommandPalette.tsx
index f62363214d23..8d97d44e77ab 100644
--- a/apps/web/src/components/CommandPalette.tsx
+++ b/apps/web/src/components/CommandPalette.tsx
@@ -1776,7 +1776,9 @@ function OpenCommandPaletteDialog(props: {
       searchTerms: ["continue on", "move", "hand off", "handoff", "environment", "machine"],
       title: "Continue on…",
       description: "Move this thread and its work to a linked environment",
-      disabled: !threadRuntimeCanArchive(thread.runtime),
+      disabled:
+        !threadRuntimeCanArchive(thread.runtime) ||
+        !readEnvironmentScope(thread.environmentId, AuthOrchestrationOperateScope),
       icon: <MonitorUpIcon className={ITEM_ICON_CLASS} />,
       keepOpen: true,
       run: async () => {