warpdotdev
diff --git a/‎app/src/search/slash_command_menu/static_commands/commands.rs‎
Lines changed: 14 additions & 0 deletions b/‎app/src/search/slash_command_menu/static_commands/commands.rs‎
Lines changed: 14 additions & 0 deletions
diff --git a/‎app/src/search/slash_command_menu/static_commands/mod.rs‎
Lines changed: 1 addition & 0 deletions b/‎app/src/search/slash_command_menu/static_commands/mod.rs‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎app/src/terminal/input/slash_commands/mod.rs‎
Lines changed: 1 addition & 0 deletions b/‎app/src/terminal/input/slash_commands/mod.rs‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎app/src/tui_export.rs‎
Lines changed: 2 additions & 1 deletion b/‎app/src/tui_export.rs‎
Lines changed: 2 additions & 1 deletion
diff --git a/‎app/src/tui_test_support.rs‎
Lines changed: 17 additions & 0 deletions b/‎app/src/tui_test_support.rs‎
Lines changed: 17 additions & 0 deletions
diff --git a/‎app/src/workspaces/user_workspaces.rs‎
Lines changed: 14 additions & 0 deletions b/‎app/src/workspaces/user_workspaces.rs‎
Lines changed: 14 additions & 0 deletions
diff --git a/‎app/src/workspaces/user_workspaces_tests.rs‎
Lines changed: 109 additions & 0 deletions b/‎app/src/workspaces/user_workspaces_tests.rs‎
Lines changed: 109 additions & 0 deletions
diff --git a/‎crates/warp_tui/src/handoff/tests.rs‎
Lines changed: 1 addition & 1 deletion b/‎crates/warp_tui/src/handoff/tests.rs‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎crates/warp_tui/src/inline_menu.rs‎
Lines changed: 52 additions & 1 deletion b/‎crates/warp_tui/src/inline_menu.rs‎
Lines changed: 52 additions & 1 deletion
diff --git a/‎crates/warp_tui/src/input/view.rs‎
Lines changed: 4 additions & 0 deletions b/‎crates/warp_tui/src/input/view.rs‎
Lines changed: 4 additions & 0 deletions
@@ -560,6 +560,19 @@ pub static MODEL: LazyLock<StaticCommand> = LazyLock::new(|| StaticCommand {
     argument: None,
 });
 
+/// TUI-only: the GUI switches teams from the title-bar pill, which opens a new window for the
+/// chosen team rather than re-scoping the current one. The TUI has a single window, so it
+/// switches in place instead.
+pub const TEAM: StaticCommand = StaticCommand {
+    name: "/team",
+    description: "Switch the active team",
+    kind: SlashCommandKind::Team,
+    supported_surfaces: SlashCommandSurfaces::TuiOnly,
+    availability: Availability::ALWAYS,
+    auto_enter_ai_mode: false,
+    argument: None,
+};
+
 pub static HOST: LazyLock<StaticCommand> = LazyLock::new(|| StaticCommand {
     name: "/host",
     description: "Switch the cloud agent execution host",
@@ -994,6 +1007,7 @@ fn all_commands_for_all_surfaces() -> Vec<StaticCommand> {
         EXPORT_TO_CLIPBOARD,
         COPY_DEBUGGING_ID,
         MODEL.clone(),
+        TEAM,
         STATUS,
         VIEW_LOGS,
         VOICE,
 
@@ -94,6 +94,7 @@ pub enum SlashCommandKind {
     New,
     Clear,
     Model,
+    Team,
     Host,
     Harness,
     Environment,
 
@@ -1301,6 +1301,7 @@ impl Input {
             | SlashCommandKind::Exit
             | SlashCommandKind::Logout
             | SlashCommandKind::Clear
+            | SlashCommandKind::Team
             | SlashCommandKind::Status => {
                 debug_assert!(
                     false,
 
@@ -183,7 +183,7 @@ pub use crate::search::slash_command_menu::static_commands::{
     SlashCommandKind, SlashCommandSurfaces,
 };
 pub use crate::search::slash_command_menu::{SlashCommandId, StaticCommand};
-pub use crate::server::ids::SyncId;
+pub use crate::server::ids::{ServerId, SyncId};
 pub use crate::server::server_api::ServerApiProvider;
 #[cfg(feature = "voice_input")]
 pub use crate::server::server_api::TranscribeError;
@@ -265,6 +265,7 @@ pub use crate::tui_test_support::{
     blocklist_ai_history_model_with_queries, forkable_tui_conversation_for_test,
     queue_tui_permission_action, register_tui_input_mode_test_settings,
     register_tui_session_view_test_singletons, set_tui_default_team_admin_for_test,
+    set_tui_workspace_teams_for_test,
 };
 pub use crate::user_config::{WarpConfig, WarpConfigUpdateEvent};
 pub use crate::util::image::{
 
@@ -38,6 +38,7 @@ use crate::code_review::git_repo_model::GitRepoModels;
 use crate::network::NetworkStatus;
 use crate::persistence::PersistenceWriter;
 use crate::server::experiments::ServerExperiments;
+use crate::server::ids::ServerId;
 use crate::server::server_api::ServerApiProvider;
 use crate::server::sync_queue::SyncQueue;
 #[cfg(feature = "voice_input")]
@@ -288,6 +289,22 @@ pub fn set_tui_default_team_admin_for_test(ctx: &mut AppContext) {
     });
 }
 
+pub fn set_tui_workspace_teams_for_test(teams: Vec<(ServerId, String)>, ctx: &mut AppContext) {
+    let teams = teams
+        .into_iter()
+        .map(|(uid, name)| Team::from_local_cache(uid, name, None, None, None))
+        .collect();
+    let workspace = Workspace::from_local_cache(
+        "workspace_uid123456789".to_owned().into(),
+        "test workspace".to_owned(),
+        Some(teams),
+    );
+    let workspace_uid = workspace.uid;
+    UserWorkspaces::handle(ctx).update(ctx, |workspaces, ctx| {
+        workspaces.update_workspaces(vec![workspace], ctx);
+        workspaces.set_current_workspace_uid(workspace_uid, ctx);
+    });
+}
 /// Queues an action as the active confirmation request for a TUI view test.
 pub fn queue_tui_permission_action(
     action_model: &mut BlocklistAIActionModel,
 
@@ -413,6 +413,20 @@ impl UserWorkspaces {
         self.window_team_uids.get(&window_id).copied().flatten()
     }
 
+    pub fn switch_window_to_team(
+        &mut self,
+        window_id: WindowId,
+        team_uid: ServerId,
+        ctx: &mut ModelContext<Self>,
+    ) {
+        if self.team_uid_for_window(window_id) == Some(team_uid) {
+            return;
+        }
+        self.window_team_uids.insert(window_id, Some(team_uid));
+        ctx.emit(UserWorkspacesEvent::WindowTeamChanged { window_id });
+        ctx.notify();
+    }
+
     /// Returns `true` when the user belongs to more than one team in the current
     /// workspace, meaning the team-switcher pill and dropdown should be shown.
     /// Single-team and no-workspace users return `false` so their UI is unchanged.
 
@@ -1,3 +1,5 @@
+use std::cell::Cell;
+use std::rc::Rc;
 use std::time::Duration;
 
 use mockall::Sequence;
@@ -1152,6 +1154,113 @@ fn test_window_team_reconciliation_moves_rendering_but_not_a_captured_context()
     })
 }
 
+fn team_named(uid: i64, name: &str) -> Team {
+    let mut team = team_for_test();
+    team.uid = uid.into();
+    team.name = name.to_owned();
+    team
+}
+
+/// Two teams in workspace order, so a test can tell the default apart from a chosen team.
+fn platform_and_security() -> (Team, Team, Workspace) {
+    let platform = team_named(123, "Platform");
+    let security = team_named(456, "Security");
+    let mut workspace = workspace_for_test(&platform);
+    workspace.teams.push(security.clone());
+    (platform, security, workspace)
+}
+
+#[test]
+fn switching_a_window_to_a_team_overwrites_and_announces_it() {
+    let (platform, security, workspace) = platform_and_security();
+
+    App::test((), |mut app| async move {
+        initialize_window_team_test_app(&mut app, vec![workspace]);
+
+        let window_id = WindowId::new();
+        let changes = Rc::new(Cell::new(0));
+        let changes_for_subscription = changes.clone();
+        app.update(|ctx| {
+            ctx.subscribe_to_model(&UserWorkspaces::handle(ctx), move |_, event, _| {
+                if matches!(event, UserWorkspacesEvent::WindowTeamChanged { .. }) {
+                    changes_for_subscription.set(changes_for_subscription.get() + 1);
+                }
+            });
+        });
+
+        UserWorkspaces::handle(&app).update(&mut app, |user_workspaces, ctx| {
+            user_workspaces.register_window(window_id, Some(platform.uid), ctx);
+        });
+        let changes_after_register = changes.get();
+
+        UserWorkspaces::handle(&app).update(&mut app, |user_workspaces, ctx| {
+            user_workspaces.switch_window_to_team(window_id, security.uid, ctx);
+        });
+
+        app.read(|ctx| {
+            assert_eq!(
+                UserWorkspaces::as_ref(ctx).team_uid_for_window(window_id),
+                Some(security.uid),
+                "switching must overwrite, unlike the insert-only registration paths"
+            );
+        });
+        assert_eq!(
+            changes.get(),
+            changes_after_register + 1,
+            "the switch must announce itself so scoped consumers resync"
+        );
+    })
+}
+
+#[test]
+fn switching_a_window_to_its_current_team_announces_nothing() {
+    let team = team_for_test();
+    let workspace = workspace_for_test(&team);
+
+    App::test((), |mut app| async move {
+        initialize_window_team_test_app(&mut app, vec![workspace]);
+
+        let window_id = WindowId::new();
+        UserWorkspaces::handle(&app).update(&mut app, |user_workspaces, ctx| {
+            user_workspaces.register_window(window_id, Some(team.uid), ctx);
+        });
+
+        let changes = Rc::new(Cell::new(0));
+        let changes_for_subscription = changes.clone();
+        app.update(|ctx| {
+            ctx.subscribe_to_model(&UserWorkspaces::handle(ctx), move |_, event, _| {
+                if matches!(event, UserWorkspacesEvent::WindowTeamChanged { .. }) {
+                    changes_for_subscription.set(changes_for_subscription.get() + 1);
+                }
+            });
+        });
+
+        UserWorkspaces::handle(&app).update(&mut app, |user_workspaces, ctx| {
+            user_workspaces.switch_window_to_team(window_id, team.uid, ctx);
+        });
+
+        assert_eq!(changes.get(), 0);
+    })
+}
+
+/// The switcher's own visibility rule, which the TUI indicator reuses rather than
+/// reimplementing so the two front-ends cannot disagree about who counts as multi-team.
+#[test]
+fn can_switch_teams_only_with_more_than_one_team() {
+    let (_, _, two_team_workspace) = platform_and_security();
+    let one_team_workspace = workspace_for_test(&team_for_test());
+
+    App::test((), |mut app| async move {
+        initialize_window_team_test_app(&mut app, vec![one_team_workspace]);
+        app.read(|ctx| assert!(!UserWorkspaces::as_ref(ctx).can_switch_teams()));
+
+        UserWorkspaces::handle(&app).update(&mut app, |user_workspaces, ctx| {
+            user_workspaces.update_workspaces(vec![two_team_workspace], ctx);
+        });
+        app.read(|ctx| assert!(UserWorkspaces::as_ref(ctx).can_switch_teams()));
+    })
+}
+
 #[test]
 fn test_team_contexts_represent_a_registered_teamless_window() {
     App::test((), |mut app| async move {
 
@@ -38,7 +38,7 @@ fn fixture(app: &mut App) -> Fixture {
                 window_style: WindowStyle::NotStealFocus,
                 ..Default::default()
             },
-            |_| RootTuiView::new(),
+            RootTuiView::new,
         )
     });
     let sessions = app.add_singleton_model(|_| TuiSessions::new_for_test());
 
@@ -5,7 +5,7 @@ use std::rc::Rc;
 
 use string_offset::CharOffset;
 use warp::tui_export::{
-    AcceptSlashCommandOrSavedPrompt, AgentConversationEntryId, LLMId, TuiMcpAction,
+    AcceptSlashCommandOrSavedPrompt, AgentConversationEntryId, LLMId, ServerId, TuiMcpAction,
     TuiUpArrowHistoryItemKind,
 };
 use warp_search_core::inline_menu::{InlineMenuResultsUpdate, InlineMenuSelection};
@@ -27,6 +27,7 @@ use crate::model_menu::TuiModelMenuModel;
 use crate::prompt_and_command_history_menu::TuiPromptAndCommandHistoryMenuModel;
 use crate::skills_menu::TuiSkillMenuModel;
 use crate::slash_commands::TuiSlashCommandModel;
+use crate::team_menu::TuiTeamMenuModel;
 use crate::tui_builder::TuiUiBuilder;
 use crate::tui_column_layout::{
     TuiTwoColumnConstraints, TuiTwoColumnLayout, format_tui_first_column, tui_two_column_layout,
@@ -403,6 +404,7 @@ pub(crate) enum TuiInlineMenuAccepted {
     SlashCommand(AcceptSlashCommandOrSavedPrompt),
     Conversation(AgentConversationEntryId),
     Model(LLMId),
+    Team(ServerId),
     Mcp(TuiMcpAction),
     McpInstall(TuiMcpInstallFlowAction),
     PromptAndCommandHistory {
@@ -877,6 +879,55 @@ impl TuiInlineMenuHandle for ModelHandle<TuiModelMenuModel> {
     }
 }
 
+impl TuiInlineMenuHandle for ModelHandle<TuiTeamMenuModel> {
+    fn mode(&self) -> TuiInputSuggestionsMode {
+        TuiInputSuggestionsMode::TeamSelector
+    }
+    fn is_open(&self, ctx: &AppContext) -> bool {
+        self.as_ref(ctx).is_open(ctx)
+    }
+    fn open(&self, ctx: &mut AppContext) {
+        self.update(ctx, |model, ctx| model.open(ctx));
+    }
+    fn input_highlight_range(&self, _ctx: &AppContext) -> Option<Range<CharOffset>> {
+        None
+    }
+
+    fn input_argument_hint_text(&self, _ctx: &AppContext) -> Option<&'static str> {
+        None
+    }
+
+    fn select_previous(&self, ctx: &mut AppContext) {
+        self.update(ctx, |model, ctx| model.select_previous(ctx));
+    }
+
+    fn select_next(&self, ctx: &mut AppContext) {
+        self.update(ctx, |model, ctx| model.select_next(ctx));
+    }
+
+    fn accept(&self, ctx: &mut AppContext) -> Option<TuiInlineMenuAccepted> {
+        self.as_ref(ctx)
+            .accept_selected(ctx)
+            .map(TuiInlineMenuAccepted::Team)
+    }
+
+    fn dismiss(&self, ctx: &mut AppContext) {
+        self.update(ctx, |model, ctx| model.dismiss(ctx));
+    }
+
+    fn snapshot(&self, ctx: &AppContext) -> Option<TuiInlineMenuSnapshot> {
+        self.as_ref(ctx).snapshot(ctx)
+    }
+
+    fn select_by_snapshot_index(&self, index: usize, ctx: &mut AppContext) -> bool {
+        self.update(ctx, |model, ctx| model.select_at_snapshot_index(index, ctx))
+    }
+
+    fn scroll_by_delta(&self, delta: isize, ctx: &mut AppContext) {
+        self.update(ctx, |model, ctx| model.scroll_by_delta(delta, ctx));
+    }
+}
+
 impl TuiInlineMenuHandle for ModelHandle<TuiSkillMenuModel> {
     fn mode(&self) -> TuiInputSuggestionsMode {
         TuiInputSuggestionsMode::SkillMenu
 
@@ -165,6 +165,7 @@ pub enum TuiInputViewEvent {
     AcceptedConversation(warp::tui_export::AgentConversationEntryId),
     /// The user selected a model menu item.
     AcceptedModel(LLMId),
+    AcceptedTeam(warp::tui_export::ServerId),
     /// The user selected an action from the MCP menu.
     AcceptedMcp(TuiMcpAction),
     /// The user advanced the explicit MCP installation flow.
@@ -1366,6 +1367,9 @@ impl TuiInputView {
             TuiInlineMenuAccepted::Model(id) => {
                 ctx.emit(TuiInputViewEvent::AcceptedModel(id));
             }
+            TuiInlineMenuAccepted::Team(team_uid) => {
+                ctx.emit(TuiInputViewEvent::AcceptedTeam(team_uid));
+            }
             TuiInlineMenuAccepted::Mcp(action) => {
                 ctx.emit(TuiInputViewEvent::AcceptedMcp(action));
             }
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ fn fixture(app: &mut App) -> Fixture {`
`38`	`38`	`window_style: WindowStyle::NotStealFocus,`
`39`	`39`	`..Default::default()`
`40`	`40`	`},`
`41`		`- \|_\| RootTuiView::new(),`
	`41`	`+ RootTuiView::new,`
`42`	`42`	`)`
`43`	`43`	`});`
`44`	`44`	`let sessions = app.add_singleton_model(\|_\| TuiSessions::new_for_test());`