Show the active team in the TUI statusline, with a tri-state

Adds a Team statusline item showing the window's active team, rendered only
when the user is on more than one. The condition reuses can_switch_teams --
the predicate gating the GUI's title-bar team pill -- rather than a fresh
team-count check, so the two front-ends cannot disagree about who counts as
multi-team. Clicking it opens the same switcher /team surfaces.

The item is hidden from /statusline entirely below two teams. With one team
it renders nothing, so offering a checkbox would offer one that lies. Above
two teams it is listed, checked by default, and an explicit uncheck is
permanent across any number of team-count changes.

`enabled` cannot express that, since absence from it already means "off".
Hence show_active_team: Option<bool>, None meaning undecided-so-shown, with
is_enabled absorbing the branch. Two properties fall out rather than being
arranged: an older saved config has no such field, so serde gives None, so
it shows, needing no back-fill; and normalized() cannot sweep the item into
enabled because it is never in enabled.

The cost is that one item's checkbox reads a different field from the other
fifteen. That asymmetry is real -- this is the only item defaulting to on
whose availability depends on the user's teams -- and is better visible than
hidden behind machinery implying the others work the same way.

Two things the tests caught:
- Hiding the row dropped Team from the saved order, so normalized() then
  re-appended it at the end; opening /statusline as a one-team user would
  have permanently moved the item to the bottom of the catalog. Its position
  is now restored from the config the picker opened with.
- The picker never records a decision it was not offered, so a one-team user
  cannot silently opt out by opening /statusline once.

Resyncs on TeamsChanged and on WindowTeamChanged filtered to this window,
matching every other live-valued statusline item.

CHANGELOG-TUI: The Warp Agent CLI statusline now shows your active team when you belong to more than one.

Author: warp-agent-staging[bot]

app/src/settings/ai.rs

@@ -689,6 +689,9 @@ pub enum TuiStatuslineItem {
     /// Vim mode indicator (NOR/INS/VIS/V-L/REP); hidden when vim mode is disabled.
     VimModeIndicator,
     Model,
+    /// The window's active team. Only rendered for users on more than one team, matching the
+    /// GUI's team-switcher pill.
+    Team,
     WorkingDirectory,
     GitBranch,
     GitBranchStatus,
@@ -706,10 +709,11 @@ pub enum TuiStatuslineItem {
 }
 
 impl TuiStatuslineItem {
-    pub const ALL: [Self; 15] = [
+    pub const ALL: [Self; 16] = [
         Self::AutoApprove,
         Self::VimModeIndicator,
         Self::Model,
+        Self::Team,
         Self::WorkingDirectory,
         Self::GitBranch,
         Self::GitBranchStatus,
@@ -729,6 +733,7 @@ impl TuiStatuslineItem {
             Self::AutoApprove => "Auto-approve indicator",
             Self::VimModeIndicator => "Vim mode indicator",
             Self::Model => "Model",
+            Self::Team => "Team",
             Self::WorkingDirectory => "Working directory",
             Self::GitBranch => "Git branch",
             Self::GitBranchStatus => "Git branch status",
@@ -759,6 +764,18 @@ impl TuiStatuslineItem {
 pub struct TuiStatuslineConfig {
     pub order: Vec<TuiStatuslineItem>,
     pub enabled: Vec<TuiStatuslineItem>,
+    /// Whether to show the active team, as a tri-state that `enabled` cannot express.
+    ///
+    /// `enabled` conflates "never decided" with "explicitly off", which is fine for the items
+    /// that are simply on or off but not for this one: it defaults to shown, and only appears
+    /// in `/statusline` at all when the user is on more than one team, so an absent entry has
+    /// to keep meaning "has not been asked yet" rather than "turned off".
+    ///
+    /// `None` is that undecided state and is treated as shown. Keeping it out of `enabled`
+    /// rather than adding a third list is what makes an older saved config correct for free:
+    /// it has no such field, serde gives `None`, and `None` already means shown.
+    #[serde(default)]
+    pub show_active_team: Option<bool>,
 }
 
 impl Default for TuiStatuslineConfig {
@@ -773,6 +790,7 @@ impl Default for TuiStatuslineConfig {
                 TuiStatuslineItem::GitBranch,
                 TuiStatuslineItem::GitDiffStatus,
             ],
+            show_active_team: None,
         }
     }
 }
@@ -798,11 +816,27 @@ impl TuiStatuslineConfig {
             enabled.insert(0, TuiStatuslineItem::VimModeIndicator);
         }
 
-        Self { order, enabled }
+        Self {
+            order,
+            enabled,
+            show_active_team: self.show_active_team,
+        }
     }
 
     pub fn is_enabled(&self, item: TuiStatuslineItem) -> bool {
-        self.enabled.contains(&item)
+        match item {
+            // Deliberately reads a different field from the other items. The asymmetry is real
+            // -- this is the only item whose default is on and whose availability depends on
+            // the user's teams -- so it is better shown here than hidden behind machinery that
+            // implies the other fifteen work the same way. See `show_active_team`.
+            TuiStatuslineItem::Team => self.show_active_team.unwrap_or(true),
+            _ => self.enabled.contains(&item),
+        }
+    }
+
+    /// Records an explicit `/statusline` decision about the active-team item.
+    pub fn set_show_active_team(&mut self, show: bool) {
+        self.show_active_team = Some(show);
     }
 }
 

app/src/settings/ai_tests.rs

@@ -89,6 +89,7 @@ fn tui_statusline_normalization_preserves_custom_order_and_appends_missing_items
             TuiStatuslineItem::Model,
             TuiStatuslineItem::ContextWindowUsage,
         ],
+        show_active_team: None,
     }
     .normalized();
 
@@ -99,6 +100,7 @@ fn tui_statusline_normalization_preserves_custom_order_and_appends_missing_items
             TuiStatuslineItem::Model,
             TuiStatuslineItem::AutoApprove,
             TuiStatuslineItem::VimModeIndicator,
+            TuiStatuslineItem::Team,
             TuiStatuslineItem::WorkingDirectory,
             TuiStatuslineItem::GitBranchStatus,
             TuiStatuslineItem::GitDiffStatus,
@@ -122,6 +124,72 @@ fn tui_statusline_normalization_preserves_custom_order_and_appends_missing_items
     );
 }
 
+/// A config saved before the team item existed has no opinion about it, which is the undecided
+/// state, which shows. That needs no back-fill: it falls out of the field being absent.
+#[test]
+fn tui_statusline_an_older_config_shows_the_team_item_without_being_migrated() {
+    let config = TuiStatuslineConfig {
+        order: vec![TuiStatuslineItem::Model, TuiStatuslineItem::GitBranch],
+        enabled: vec![TuiStatuslineItem::Model],
+        show_active_team: None,
+    }
+    .normalized();
+
+    assert!(config.order.contains(&TuiStatuslineItem::Team));
+    assert!(config.is_enabled(TuiStatuslineItem::Team));
+    assert!(
+        !config.enabled.contains(&TuiStatuslineItem::Team),
+        "normalization must not sweep the team item into `enabled`"
+    );
+    assert!(
+        config.enabled.contains(&TuiStatuslineItem::Model),
+        "the rest of an existing config's enabled set is the user's choice and must not change"
+    );
+}
+
+/// The team item's state is a tri-state kept out of `enabled`, so `enabled` — and therefore
+/// `tui_statusline_default_matches_figma` — is untouched by it.
+#[test]
+fn tui_statusline_team_item_defaults_to_shown_without_entering_the_enabled_list() {
+    let config = TuiStatuslineConfig::default();
+
+    assert!(config.order.contains(&TuiStatuslineItem::Team));
+    assert_eq!(config.show_active_team, None);
+    assert!(
+        config.is_enabled(TuiStatuslineItem::Team),
+        "undecided means shown"
+    );
+    assert!(
+        !config.enabled.contains(&TuiStatuslineItem::Team),
+        "the team item must never enter `enabled`, or normalization would start managing it"
+    );
+}
+
+#[test]
+fn tui_statusline_team_item_honours_an_explicit_decision() {
+    let mut config = TuiStatuslineConfig::default();
+
+    config.set_show_active_team(false);
+    assert!(!config.is_enabled(TuiStatuslineItem::Team));
+
+    config.set_show_active_team(true);
+    assert!(config.is_enabled(TuiStatuslineItem::Team));
+}
+
+/// An explicit "off" is permanent. It has to survive normalization, since that is what runs on
+/// every read and is the path that would otherwise quietly resurrect the item.
+#[test]
+fn tui_statusline_normalization_preserves_an_explicit_team_decision() {
+    let mut config = TuiStatuslineConfig::default();
+    config.set_show_active_team(false);
+
+    let normalized = config.normalized();
+
+    assert_eq!(normalized.show_active_team, Some(false));
+    assert!(!normalized.is_enabled(TuiStatuslineItem::Team));
+    assert!(!normalized.enabled.contains(&TuiStatuslineItem::Team));
+}
+
 #[test]
 fn tui_statusline_normalization_preserves_explicitly_disabled_vim_indicator() {
     let mut config = TuiStatuslineConfig::default();

crates/warp_tui/src/statusline_config_view.rs

@@ -6,7 +6,9 @@ use warp::settings::{TuiStatuslineConfig, TuiStatuslineItem};
 use warp::tui_export::{
     AskUserQuestionAction, AskUserQuestionItem, AskUserQuestionOption, AskUserQuestionSession,
     AskUserQuestionType, OptionRow, OptionSnapshot, OptionSourceStatus, QuestionDraft,
+    UserWorkspaces,
 };
+use warpui::SingletonEntity as _;
 use warpui_core::elements::tui::{
     Modifier, TuiChildView, TuiContainer, TuiElement, TuiFlex, TuiText,
 };
@@ -95,6 +97,25 @@ pub(crate) enum TuiStatuslineConfigEvent {
 pub(crate) struct TuiStatuslineConfigView {
     session: AskUserQuestionSession,
     selector: ViewHandle<TuiOptionSelector>,
+    /// Whether the active-team row is offered at all. It is not, below two teams: with one
+    /// team the item renders nothing, so a checkbox for it would be a checkbox that lies.
+    team_item_listed: bool,
+    /// The stored tri-state as it was when the picker opened, so that closing the picker
+    /// without ever having been offered the row cannot silently record "off".
+    restored_show_active_team: Option<bool>,
+    /// The catalog order the picker opened with. When the active-team row is not offered it is
+    /// absent from the rows, and therefore from the saved order, so its position has to be
+    /// restored from here — otherwise `normalized()` re-appends it at the end and hiding the
+    /// row silently reorders the catalog.
+    restored_order: Vec<TuiStatuslineItem>,
+}
+
+/// Index of the active-team item within [`TuiStatuslineItem::ALL`], which is what the option
+/// rows are keyed by.
+fn team_option_index() -> Option<usize> {
+    TuiStatuslineItem::ALL
+        .iter()
+        .position(|item| *item == TuiStatuslineItem::Team)
 }
 
 // The next stacked change mounts the picker and consumes these lifecycle helpers.
@@ -103,15 +124,21 @@ impl TuiStatuslineConfigView {
     pub(crate) fn new(config: TuiStatuslineConfig, ctx: &mut ViewContext<Self>) -> Self {
         let config = config.normalized();
         let question = statusline_question();
-        let selected_option_indices = config
+        let team_item_listed = UserWorkspaces::as_ref(ctx).can_switch_teams();
+        let mut selected_option_indices = config
             .enabled
             .iter()
             .filter_map(|item| {
                 TuiStatuslineItem::ALL
                     .iter()
                     .position(|candidate| candidate == item)
             })
-            .collect();
+            .collect::<HashSet<_>>();
+        // The team item's checked state lives in its own tri-state rather than in `enabled`,
+        // so it has to be folded into the selection by hand.
+        if team_item_listed && config.is_enabled(TuiStatuslineItem::Team) {
+            selected_option_indices.extend(team_option_index());
+        }
         let drafts = HashMap::from([(
             STATUSLINE_QUESTION_ID.to_owned(),
             QuestionDraft {
@@ -124,6 +151,9 @@ impl TuiStatuslineConfigView {
         let mut view = Self {
             session,
             selector: selector.clone(),
+            team_item_listed,
+            restored_show_active_team: config.show_active_team,
+            restored_order: config.order.clone(),
         };
         view.show_options(&config.order, ctx);
         ctx.subscribe_to_view(&selector, |view, _, event, ctx| {
@@ -138,8 +168,10 @@ impl TuiStatuslineConfigView {
     }
 
     fn show_options(&mut self, order: &[TuiStatuslineItem], ctx: &mut ViewContext<Self>) {
+        let team_item_listed = self.team_item_listed;
         let rows = order
             .iter()
+            .filter(|item| team_item_listed || **item != TuiStatuslineItem::Team)
             .filter_map(|item| {
                 TuiStatuslineItem::ALL
                     .iter()
@@ -222,31 +254,56 @@ impl TuiStatuslineConfigView {
     }
 
     fn current_config(&self, ctx: &AppContext) -> TuiStatuslineConfig {
-        let order = self
+        let mut order = self
             .selector
             .as_ref(ctx)
             .ordered_row_ids()
             .into_iter()
             .filter_map(|id| id.parse::<usize>().ok())
             .filter_map(|index| TuiStatuslineItem::ALL.get(index).copied())
             .collect::<Vec<_>>();
+        if !self.team_item_listed {
+            let position = self
+                .restored_order
+                .iter()
+                .position(|item| *item == TuiStatuslineItem::Team)
+                .unwrap_or(order.len())
+                .min(order.len());
+            order.insert(position, TuiStatuslineItem::Team);
+        }
         let enabled_indices = self
             .session
             .draft_for_question(0)
             .map(|draft| &draft.selected_option_indices);
+        let is_checked = |item: &TuiStatuslineItem| {
+            TuiStatuslineItem::ALL
+                .iter()
+                .position(|candidate| candidate == item)
+                .is_some_and(|index| {
+                    enabled_indices.is_some_and(|indices| indices.contains(&index))
+                })
+        };
         let enabled = order
             .iter()
             .copied()
-            .filter(|item| {
-                TuiStatuslineItem::ALL
-                    .iter()
-                    .position(|candidate| candidate == item)
-                    .is_some_and(|index| {
-                        enabled_indices.is_some_and(|indices| indices.contains(&index))
-                    })
-            })
+            // The team item is never in `enabled`; its state is the tri-state below.
+            .filter(|item| *item != TuiStatuslineItem::Team)
+            .filter(is_checked)
             .collect();
-        TuiStatuslineConfig { order, enabled }.normalized()
+        // Only record a decision about the team item when the row was actually offered.
+        // Otherwise a user below two teams would silently have "off" written for them by
+        // opening the picker at all, and would then find it off once they joined a second team.
+        let show_active_team = if self.team_item_listed {
+            Some(is_checked(&TuiStatuslineItem::Team))
+        } else {
+            self.restored_show_active_team
+        };
+        TuiStatuslineConfig {
+            order,
+            enabled,
+            show_active_team,
+        }
+        .normalized()
     }
 
     fn render_footer(&self, app: &AppContext) -> Box<dyn TuiElement> {

crates/warp_tui/src/statusline_config_view_tests.rs

@@ -2,17 +2,24 @@ use std::cell::RefCell;
 use std::rc::Rc;
 
 use warp::settings::{TuiStatuslineConfig, TuiStatuslineItem};
-use warp::tui_export::Appearance;
+use warp::tui_export::{Appearance, register_tui_input_mode_test_settings};
 use warpui::platform::WindowStyle;
 use warpui::{AddWindowOptions, App};
 use warpui_core::TypedActionView as _;
 
 use super::{TuiStatuslineConfigAction, TuiStatuslineConfigEvent, TuiStatuslineConfigView};
 
+/// The picker asks `UserWorkspaces` whether to offer the active-team row, so the singleton has
+/// to exist. This registers it with no teams, which is the case where the row is not offered.
+fn register_workspaces(app: &mut App) {
+    app.update(register_tui_input_mode_test_settings);
+}
+
 #[test]
 fn default_picker_preserves_figma_selection_and_full_catalog_order() {
     App::test((), |mut app| async move {
         app.add_singleton_model(|_| Appearance::mock());
+        register_workspaces(&mut app);
         let view = app.update(|ctx| {
             ctx.add_tui_window(
                 AddWindowOptions {
@@ -35,6 +42,7 @@ fn default_picker_preserves_figma_selection_and_full_catalog_order() {
 fn toggle_and_reorder_are_reflected_in_saved_config() {
     App::test((), |mut app| async move {
         app.add_singleton_model(|_| Appearance::mock());
+        register_workspaces(&mut app);
         let view = app.update(|ctx| {
             ctx.add_tui_window(
                 AddWindowOptions {
@@ -81,6 +89,7 @@ fn toggle_and_reorder_are_reflected_in_saved_config() {
                 TuiStatuslineItem::VimModeIndicator,
                 TuiStatuslineItem::AutoApprove,
                 TuiStatuslineItem::Model,
+                TuiStatuslineItem::Team,
                 TuiStatuslineItem::WorkingDirectory,
                 TuiStatuslineItem::GitBranch,
                 TuiStatuslineItem::GitBranchStatus,