add support for cross-window tab drag

Removes WorkspaceAction::HandoffPendingTransfer, ReverseHandoff, and
FinalizeDropTab. The cross-window drag flow no longer routes through
WorkspaceAction; it is now coordinated through the upcoming
CrossWindowTabDrag singleton model.

hide window when dragging to target

fix unstable drop zone

render exact copy of tab

rendering consistency checkin

ghost state checkpoint

Fix crashes

Update view.rs

fix edge case issues around persistence and detachment

fix typo

integration: add tests for cross-window tab drag

Adds four end-to-end integration tests behind the new
drag_tabs_to_windows feature on the integration crate:
- test_reorder_tabs_with_drag
- test_detach_tab_to_new_window_with_drag
- test_attach_tab_to_other_window_and_continue_drag
- test_single_tab_handoff_continues_drag

Wires them into both the manual integration runner and the nextest
ui_tests! suite, and adds the matching feature passthrough in
crates/integration/Cargo.toml.

app_state: skip persistence during cross-window tab drag

While a cross-window tab drag is active, the dragged tab's pane group
is in flight between the source and preview windows. Both can briefly
claim the same terminal_panes.uuid, which trips SQLite's UNIQUE
constraint when persistence runs mid-drag.

Skip persistence entirely while CrossWindowTabDrag is active; the next
mouse-up or non-drag change will trigger a save. Also switches the
existing per-window workspace lookup to WorkspaceRegistry, mirroring
root_view, and uses the renamed is_tab_drag_preview() helper.

root_view: simplify after cross-window tab drag refactor

Removes the bespoke DetachTabImmediateArg / TabTransferInfo plumbing
and the root_view:detach_tab_immediate global action, both of which
existed only to support the old cross-window drag flow. Their
responsibilities now live in CrossWindowTabDrag and the workspace
view.

Updates create_transferred_window to take the TransferredTab and
window placement directly and return just the new WindowId, and
switches workspace_for_window to look up workspaces through
WorkspaceRegistry instead of scanning views_of_type::<Workspace>.

workspace view: integrate cross-window tab drag

Wires the workspace view into the new CrossWindowTabDrag singleton:
- Drives the drag state machine from on_drag/on_drop on tabs and the
  tab bar.
- Exposes helpers (tab_bar_rects_for_window, TransferredTab,
  TAB_BAR_POSITION_ID) that the singleton uses to coordinate hit
  testing and view-tree transfers between windows.
- Renames is_drag_preview_workspace to is_tab_drag_preview to match
  the new state model.
- Adjusts vertical-tab drag behavior so that when DragTabsToWindows is
  enabled, vertical tabs can be dragged horizontally out of the panel
  to detach into a new window. When the flag is off the existing
  vertical-only constraint is preserved.

workspace: add CrossWindowTabDrag singleton model

Adds a new singleton model that owns all cross-window tab drag state
across the application. The model tracks the drag lifecycle through
three phases — Floating, InsertedInTarget, and Transitioning — and
exposes on_drag/on_drop entry points that workspace views call to drive
the state machine.

Two drag sources are supported:
- SingleTabWindow: the source window itself acts as the floating
  preview.
- MultiTabWindow: a dedicated preview window is created for the tab.

Registers the singleton in workspace::init() so it is available
app-wide. The workspace view integration that actually exercises the
new APIs is added in a follow-up commit.

warpui: track window front-to-back ordering and add window bounds helper

Adds a WindowOrderingState to WindowManager so callers can find which
window is topmost at a given screen position, which is needed when
deciding where a dragged tab should land. Adds a matching
ordered_window_ids() API for both the production and integration-test
window managers.

Also adds AppContext::set_and_cache_window_bounds for callers that need
to move a window and update the cache atomically, and tweaks the macOS
window close path so force-terminated windows close immediately while
normal closes still go through performClose:.

Add tab dragging product and tech specs

Includes the original drag-tabs-to-windows PRODUCT.md and TECH.md, plus
follow-up TECH specs for fix-drag-drop, fix-dragging-out,
pane-uuid-collision-on-handoff, and put-back-plus-new-window-overlap.

Co-Authored-By: Oz <oz-agent@warp.dev>

Author: peicodes

app/src/app_state.rs

@@ -21,7 +21,8 @@ use crate::tab::SelectedTabColor;
 use crate::terminal::ShellLaunchData;
 use crate::themes::theme::AnsiColorIdentifier;
 use crate::workspace::view::left_panel::ToolPanelView;
-use crate::workspace::Workspace;
+use crate::workspace::WorkspaceRegistry;
+use warpui::SingletonEntity as _;
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct AppState {
@@ -353,13 +354,14 @@ pub fn get_app_state(app: &AppContext) -> AppState {
             }
         }
 
-        if let Some(first_workspace) = app
-            .views_of_type::<Workspace>(window_id)
-            .as_ref()
-            .and_then(|workspaces| workspaces.first())
-        {
-            let ws = first_workspace.as_ref(app);
-            if ws.is_drag_preview_workspace() {
+        if let Some(workspace) = WorkspaceRegistry::as_ref(app).get(window_id, app) {
+            let ws = workspace.as_ref(app);
+            // Transient drag-preview windows are not real user-visible
+            // workspaces; skip them so they never end up in the persisted
+            // session. (Persistence is also short-circuited entirely while a
+            // cross-window drag is active; see `save_app` in
+            // `workspace/global_actions.rs`.)
+            if ws.is_tab_drag_preview() {
                 continue;
             }
             let snapshot = ws.snapshot(

app/src/root_view.rs

@@ -74,7 +74,7 @@ use crate::{
     auth::auth_override_warning_modal::{AuthOverrideWarningModal, AuthOverrideWarningModalEvent},
     auth::auth_view_modal::{AuthView, AuthViewVariant},
     server::server_api::ServerApi,
-    workspace::{view::OnboardingTutorial, PaneViewLocator, Workspace},
+    workspace::{view::OnboardingTutorial, PaneViewLocator, Workspace, WorkspaceRegistry},
 };
 use crate::{features::FeatureFlag, ChannelState};
 use crate::{send_telemetry_from_app_ctx, GlobalResourceHandles, GlobalResourceHandlesProvider};
@@ -112,8 +112,7 @@ use warpui::{id, AddWindowOptions, DisplayId, SingletonEntity};
 use warpui::{
     platform::{WindowBounds, WindowStyle},
     presenter::ChildView,
-    AppContext, Element, Entity, EntityId, TypedActionView, View, ViewContext, ViewHandle,
-    WindowId,
+    AppContext, Element, Entity, TypedActionView, View, ViewContext, ViewHandle, WindowId,
 };
 use warpui::{FocusContext, NextNewWindowsHasThisWindowsBoundsUponClose};
 
@@ -241,29 +240,6 @@ pub struct CreateEnvironmentArg {
     pub repos: Vec<String>,
 }
 
-/// Arguments for the immediate tab detach action dispatched during drag.
-/// This contains minimal info needed to identify which tab to detach.
-pub struct DetachTabImmediateArg {
-    /// Index of the tab to detach
-    pub tab_index: usize,
-    /// Pre-calculated window position for the new window (in screen coordinates).
-    /// This is calculated to position the window so the mouse is in the tab bar region.
-    pub window_position: Option<Vector2F>,
-    /// Source window ID - the window containing the tab to detach.
-    /// We need this because the active window might be the preview window.
-    pub source_window_id: WindowId,
-}
-
-/// Pre-gathered information for creating a transferred window.
-/// This is used when the caller already has access to the workspace (e.g., from within a view method)
-/// and cannot rely on workspace lookup (which fails during view updates).
-pub struct TabTransferInfo {
-    pub transferred_tab: crate::workspace::view::TransferredTab,
-    pub window_size: Vector2F,
-    pub window_position: Vector2F,
-    pub source_window_id: WindowId,
-}
-
 impl CreateEnvironmentArg {
     /// Formats the `/create-environment` slash command invocation.
     pub fn to_query(&self) -> String {
@@ -310,9 +286,6 @@ pub fn init(app: &mut AppContext) {
     );
     app.add_global_action("root_view:open_launch_config", open_launch_config);
     app.add_global_action("root_view:send_feedback", send_feedback);
-    app.add_global_action("root_view:detach_tab_immediate", |arg, ctx| {
-        let _ = detach_tab_with_transfer(arg, ctx);
-    });
     app.add_global_action(
         "root_view:toggle_quake_mode_window",
         toggle_quake_mode_window,
@@ -540,17 +513,7 @@ fn maybe_register_global_window_shortcuts(
 /// Find the root [`Workspace`] view for the active window.
 fn active_workspace(ctx: &mut AppContext) -> Option<ViewHandle<Workspace>> {
     let window_id = ctx.windows().active_window()?;
-    ctx.views_of_type::<Workspace>(window_id)
-        .and_then(|views| views.first().cloned())
-}
-
-/// Find the root [`Workspace`] view for a specific window.
-pub fn workspace_for_window(
-    window_id: WindowId,
-    ctx: &mut AppContext,
-) -> Option<ViewHandle<Workspace>> {
-    ctx.views_of_type::<Workspace>(window_id)
-        .and_then(|views| views.first().cloned())
+    WorkspaceRegistry::as_ref(ctx).get(window_id, ctx)
 }
 
 fn open_launch_config(arg: &OpenLaunchConfigArg, ctx: &mut AppContext) {
@@ -621,73 +584,29 @@ fn send_feedback(_: &(), ctx: &mut AppContext) {
     }
 }
 
-/// Handler for tab detachment using the transferable views framework.
-/// Instead of extracting and recreating views, this transfers the PaneGroup view tree directly.
-/// Returns the new window ID if successful.
-pub fn detach_tab_with_transfer(
-    arg: &DetachTabImmediateArg,
-    ctx: &mut AppContext,
-) -> Option<WindowId> {
-    let Some(source_workspace) = workspace_for_window(arg.source_window_id, ctx) else {
-        log::warn!(
-            "No workspace found for source window {:?}",
-            arg.source_window_id
-        );
-        return None;
-    };
-
-    let transferred_tab = source_workspace.read(ctx, |workspace, ctx| {
-        workspace.get_tab_transfer_info(arg.tab_index, ctx)
-    })?;
-
-    let window_size = ctx
-        .windows()
-        .platform_window(arg.source_window_id)
-        .map(|window| window.as_ctx().size())
-        .unwrap_or(*FALLBACK_WINDOW_SIZE);
-
-    let window_position = arg.window_position.unwrap_or_default();
-
-    let info = TabTransferInfo {
-        transferred_tab,
-        window_size,
-        window_position,
-        source_window_id: arg.source_window_id,
-    };
-
-    let (new_window_id, _transferred_view_ids) = create_transferred_window(info, false, ctx);
-
-    source_workspace.update(ctx, |workspace, ctx| {
-        workspace.remove_tab_without_undo(arg.tab_index, ctx);
-    });
-
-    Some(new_window_id)
-}
-
 /// Creates a new window with the transferred pane group.
-/// This function takes pre-gathered TabTransferInfo, allowing it to be called
-/// from within a view method where workspace lookup would fail.
 ///
-/// If `for_drag` is true, the window is created without stealing focus (for drag preview).
+/// If `is_tab_drag_preview` is true, the window is created without stealing
+/// focus so it can follow the cursor during a tab drag.
 ///
-/// Returns the new window ID and the list of transferred view entity IDs.
-/// The transferred view IDs are needed by `tab_drag::on_tab_drag` to track which
-/// views must follow the tab during subsequent handoff/reverse-handoff cycles.
+/// Returns the new window ID.
 pub fn create_transferred_window(
-    info: TabTransferInfo,
-    for_drag: bool,
+    transferred_tab: crate::workspace::view::TransferredTab,
+    source_window_id: WindowId,
+    window_size: Vector2F,
+    window_position: Vector2F,
+    is_tab_drag_preview: bool,
     ctx: &mut AppContext,
-) -> (WindowId, Vec<EntityId>) {
+) -> WindowId {
     let global_resource_handles = GlobalResourceHandlesProvider::handle(ctx)
         .as_ref(ctx)
         .get()
         .clone();
     let window_settings = WindowSettings::handle(ctx).as_ref(ctx);
 
-    let window_bounds =
-        WindowBounds::ExactPosition(RectF::new(info.window_position, info.window_size));
+    let window_bounds = WindowBounds::ExactPosition(RectF::new(window_position, window_size));
 
-    let window_style = if for_drag {
+    let window_style = if is_tab_drag_preview {
         WindowStyle::PositionedNoFocus
     } else {
         WindowStyle::Normal
@@ -707,35 +626,34 @@ pub fn create_transferred_window(
             let mut view = RootView::new(
                 global_resource_handles.clone(),
                 NewWorkspaceSource::TransferredTab {
-                    tab_color: info.transferred_tab.color,
-                    custom_title: info.transferred_tab.custom_title.clone(),
-                    left_panel_open: info.transferred_tab.left_panel_open,
-                    vertical_tabs_panel_open: info.transferred_tab.vertical_tabs_panel_open,
-                    right_panel_open: info.transferred_tab.right_panel_open,
-                    is_right_panel_maximized: info.transferred_tab.is_right_panel_maximized,
-                    for_drag_preview: for_drag,
+                    tab_color: transferred_tab.color,
+                    custom_title: transferred_tab.custom_title.clone(),
+                    left_panel_open: transferred_tab.left_panel_open,
+                    vertical_tabs_panel_open: transferred_tab.vertical_tabs_panel_open,
+                    right_panel_open: transferred_tab.right_panel_open,
+                    is_right_panel_maximized: transferred_tab.is_right_panel_maximized,
+                    is_tab_drag_preview,
                 },
                 ctx,
             );
-            if !for_drag {
+            if !is_tab_drag_preview {
                 view.focus(ctx);
             }
             view
         },
     );
 
-    let pane_group_id = info.transferred_tab.pane_group.id();
-    let transferred_view_ids =
-        ctx.transfer_view_tree_to_window(pane_group_id, info.source_window_id, new_window_id);
+    let pane_group_id = transferred_tab.pane_group.id();
+    ctx.transfer_view_tree_to_window(pane_group_id, source_window_id, new_window_id);
 
-    if let Some(new_workspace) = workspace_for_window(new_window_id, ctx) {
+    if let Some(new_workspace) = WorkspaceRegistry::as_ref(ctx).get(new_window_id, ctx) {
         new_workspace.update(ctx, |workspace, ctx| {
-            workspace.adopt_transferred_pane_group(info.transferred_tab.pane_group.clone(), ctx);
+            workspace.adopt_transferred_pane_group(transferred_tab.pane_group.clone(), ctx);
         });
     } else {
         log::warn!("Failed to find workspace in newly created window {new_window_id:?}");
     }
-    (new_window_id, transferred_view_ids)
+    new_window_id
 }
 
 #[cfg(feature = "crash_reporting")]
@@ -1606,7 +1524,7 @@ pub enum NewWorkspaceSource {
         /// Whether the right panel was maximized in the source tab
         is_right_panel_maximized: bool,
         /// Whether this transferred tab window is currently being used as a drag preview.
-        for_drag_preview: bool,
+        is_tab_drag_preview: bool,
     },
 }
 

app/src/tab.rs

@@ -601,6 +601,16 @@ pub struct TabComponent<'a> {
     tooltip_git_branch: Option<String>,
     is_drag_target: bool,
     background_opacity: u8,
+    /// Set to `true` when this `TabComponent` is being rendered inside the
+    /// floating chip overlay used during a cross-window tab drag. In that
+    /// mode `build()` skips the outer `SavePosition`, `Draggable`, and
+    /// `DropTarget` wrappers so the chip:
+    ///   * does not write to `tab_position_id(tab_index)` in the target
+    ///     window's position cache (which would corrupt
+    ///     `tab_insertion_index_for_cursor` and cause the empty-slot
+    ///     flicker), and
+    ///   * does not act as its own draggable / drop target.
+    for_drag_ghost: bool,
 }
 
 /// Structure that holds TabComponent styles.
@@ -755,9 +765,17 @@ impl<'a> TabComponent<'a> {
             tooltip_git_branch,
             is_drag_target,
             background_opacity,
+            for_drag_ghost: false,
         }
     }
 
+    /// Marks this tab as being rendered inside the floating chip used by the
+    /// cross-window tab drag overlay. See [`TabComponent::for_drag_ghost`].
+    pub fn for_drag_ghost(mut self) -> Self {
+        self.for_drag_ghost = true;
+        self
+    }
+
     /// Returns the agent indicator for the focused session's active conversation,
     /// or `None` if there is no non-empty, non-passive conversation to display.
     /// When a shell command is long-running the status is overridden to
@@ -1442,6 +1460,13 @@ impl<'a> TabComponent<'a> {
                         .into_solid_bias_top_color(),
                 )
                 .finish()
+        } else if self.for_drag_ghost {
+            // The chip overlay is a purely visual snapshot of the source tab.
+            // It must not act as a drop target — both because that's not
+            // semantically meaningful for an element that follows the cursor,
+            // and because the inner `DropTarget`'s position is unrelated to
+            // any real tab in the target window.
+            tab.finish()
         } else {
             DropTarget::new(
                 tab.finish(),
@@ -1472,6 +1497,8 @@ impl UiComponent for TabComponent<'_> {
         let is_any_tab_dragging = self.tab_bar.is_any_tab_dragging;
         let draggable_state = self.tab.draggable_state.clone();
         let mouse_close_state = self.tab.close_mouse_state.clone();
+        // Capture before `self` is moved into the Hoverable closure below.
+        let for_drag_ghost = self.for_drag_ghost;
 
         // Extract values before moving self into closure
         let tooltip_text = self.tooltip_message.clone();
@@ -1656,22 +1683,32 @@ impl UiComponent for TabComponent<'_> {
                 .finish()
         };
 
-        let draggable = Draggable::new(draggable_state, constrained_tab)
-            .on_drag_start(|ctx, _, _| ctx.dispatch_typed_action(WorkspaceAction::StartTabDrag))
-            .on_drag(move |ctx, _, rect, _| {
-                ctx.dispatch_typed_action(WorkspaceAction::DragTab {
-                    tab_index,
-                    tab_position: rect,
-                });
-            })
-            .on_drop(|ctx, _, _, _| ctx.dispatch_typed_action(WorkspaceAction::DropTab));
-        let draggable = if FeatureFlag::DragTabsToWindows.is_enabled() {
-            draggable
+        // Skip the `Draggable` and `SavePosition` wrappers when rendering
+        // the tab inside the cross-window drag chip overlay. Wrapping the
+        // chip in another `Draggable` would interfere with the in-flight
+        // drag, and writing a `SavePosition` keyed by `tab_position_id(0)`
+        // would clobber the target window's real tab 0 entry in the
+        // position cache, breaking `tab_insertion_index_for_cursor`.
+        let full_tab: Box<dyn Element> = if for_drag_ghost {
+            constrained_tab
         } else {
-            draggable.with_drag_axis(DragAxis::HorizontalOnly)
+            let draggable = Draggable::new(draggable_state, constrained_tab)
+                .on_drag_start(|ctx, _, _| ctx.dispatch_typed_action(WorkspaceAction::StartTabDrag))
+                .on_drag(move |ctx, _, rect, _| {
+                    ctx.dispatch_typed_action(WorkspaceAction::DragTab {
+                        tab_index,
+                        tab_position: rect,
+                    });
+                })
+                .on_drop(|ctx, _, _, _| ctx.dispatch_typed_action(WorkspaceAction::DropTab));
+            let draggable = if FeatureFlag::DragTabsToWindows.is_enabled() {
+                draggable
+            } else {
+                draggable.with_drag_axis(DragAxis::HorizontalOnly)
+            };
+            let tab_with_drag: Box<dyn Element> = draggable.finish();
+            SavePosition::new(tab_with_drag, &tab_position_id(tab_index)).finish()
         };
-        let tab_with_drag: Box<dyn Element> = draggable.finish();
-        let full_tab = SavePosition::new(tab_with_drag, &tab_position_id(tab_index)).finish();
 
         if FeatureFlag::NewTabStyling.is_enabled() {
             Shrinkable::new(1.0, full_tab)

app/src/workspace/action.rs

@@ -240,16 +240,7 @@ pub enum WorkspaceAction {
         tab_index: usize,
         tab_position: RectF,
     },
-    HandoffPendingTransfer {
-        target_window_id: WindowId,
-        insertion_index: usize,
-    },
-    ReverseHandoff {
-        target_window_id: WindowId,
-        target_insertion_index: usize,
-    },
     DropTab,
-    FinalizeDropTab,
     /// Toggles the left panel. In Code Mode V1 this toggles Warp Drive.
     /// In Code Mode V2 this toggles the left panel which contains both the project explorer and
     /// Warp Drive. This happens as explicit action from the user.
@@ -820,10 +811,7 @@ impl WorkspaceAction {
             | CreateTeamAIPrompt
             | OpenInExplorer { .. }
             | DragTab { .. }
-            | HandoffPendingTransfer { .. }
-            | ReverseHandoff { .. }
             | StartTabDrag
-            | FinalizeDropTab
             | ToggleLeftPanel
             | ToggleWarpDrive
             | OpenWarpDrive