Address review: clear a stale default host, repaint on window team change, cover the construction-time constraint

- The host-selector resync applied `Some` and swallowed `None`, so a window
  moving to a team that configures no default host kept the previous team's
  slug in both the selector and the run config. `clear_default_host` mirrors
  `set_default_host`, and the view model's host is now cleared too.
- The Warp Agent settings page only repainted on `TeamsChanged`;
  `window_team_uids` is not `Tracked`, so a window team change would not
  repaint the attribution toggle once a team switcher lands.
- Added a test that resolves a scope inside a view's own build closure,
  asserting the `ViewContext` shape works there and a self-handle resolves
  nothing. Every other test resolves post-construction, where the difference
  is invisible.

Author: warp-agent-staging[bot]

app/src/settings_view/warp_agent_page.rs

@@ -622,7 +622,13 @@ impl WarpAgentPageView {
 
         let workspace = UserWorkspaces::handle(ctx);
         ctx.subscribe_to_model(&workspace, |me, _workspace, event, ctx| {
-            if let UserWorkspacesEvent::TeamsChanged = event {
+            // A window moving between teams changes what this page renders (the agent
+            // attribution toggle resolves its policy from the window's team), and
+            // `window_team_uids` is not `Tracked`, so autotracking will not repaint it.
+            if matches!(
+                event,
+                UserWorkspacesEvent::TeamsChanged | UserWorkspacesEvent::WindowTeamChanged { .. }
+            ) {
                 me.sync_custom_endpoint_buttons(ctx);
                 ctx.notify();
             }

app/src/terminal/input.rs

@@ -2412,17 +2412,21 @@ impl Input {
             if !affects_this_window {
                 return;
             }
+            // `None` has to be applied, not skipped: it means the window's team configures no
+            // self-hosted default, and leaving the previous value in place would keep the
+            // selector and the run config pointed at another team's worker.
             let effective_host = effective_default_host(ctx);
-            if let Some(slug) = &effective_host {
-                view_for_ws.update(ctx, |selector, ctx| {
-                    selector.set_default_host(slug.clone(), ctx);
-                });
-            }
-            if let Some(slug) = effective_host {
-                vm_for_ws.update(ctx, |model, _ctx| {
-                    model.set_worker_host(Some(slug));
-                });
+            match effective_host.clone() {
+                Some(slug) => view_for_ws.update(ctx, |selector, ctx| {
+                    selector.set_default_host(slug, ctx);
+                }),
+                None => view_for_ws.update(ctx, |selector, ctx| {
+                    selector.clear_default_host(ctx);
+                }),
             }
+            vm_for_ws.update(ctx, |model, _ctx| {
+                model.set_worker_host(effective_host);
+            });
         });
         view
     }

app/src/terminal/view/ambient_agent/host_selector.rs

@@ -208,6 +208,31 @@ impl HostSelector {
         self.refresh_menu(ctx);
     }
 
+    /// Drops the default host, e.g. because the window moved to a team that configures none.
+    ///
+    /// The inverse of [`Self::set_default_host`] and it defers to a saved user selection the
+    /// same way. Without it, a selection that came only from the previous team's default would
+    /// survive the move and keep pointing at that team's self-hosted worker.
+    pub fn clear_default_host(&mut self, ctx: &mut ViewContext<Self>) {
+        if self.default_host.is_none() {
+            return;
+        }
+        self.default_host = None;
+
+        let has_saved_selection = CloudAgentSettings::as_ref(ctx)
+            .last_selected_host
+            .value()
+            .is_some();
+        if !has_saved_selection {
+            self.selected = Host::Warp;
+            let label = self.selected.display_name().to_string();
+            self.button.update(ctx, |button, ctx| {
+                button.set_label(label, ctx);
+            });
+        }
+        self.refresh_menu(ctx);
+    }
+
     /// Programmatically opens the host selector popover. No-op if already open.
     pub fn open_menu(&mut self, ctx: &mut ViewContext<Self>) {
         self.set_menu_visibility(true, ctx);

app/src/workspaces/user_workspaces.rs

@@ -216,8 +216,9 @@ impl TeamScope for TeamContextForOperation {
 
 #[cfg(test)]
 impl TeamContextForOperation {
-    // Nothing constructs a test context yet; remove this `#[allow(dead_code)]` once a Group 1
-    // migration PR has a real call site.
+    // Currently unused: tests that need an operation scope mint a real one from a test window
+    // through `team_context_for_operation`, which exercises the production path as well. Kept
+    // for a test that needs a scope with no window to mint it from.
     #[allow(dead_code)]
     pub(crate) fn new_for_test(team_uid: ServerId) -> Self {
         Self {
@@ -2030,10 +2031,8 @@ impl UserWorkspaces {
     ///
     /// **Not a team-neutral read**, despite reading workspace settings: see
     /// [`Self::teamless_workspace_settings`] for why. Sole remaining caller is
-    /// `ai::orchestration::resolve_default_host_slug`, which feeds the plan card, the
-    /// confirmation card, the TUI orchestration block and the handoff pipeline. That chain
-    /// still needs both a windowless accessor the TUI can reach and a pinned scope for the
-    /// handoff's chosen destination, so it moves as one follow-up rather than piecemeal.
+    /// `ai::orchestration::resolve_default_host_slug`, whose consumers have to migrate as one
+    /// unit and are blocked on decisions this getter cannot make.
     /// Do not add callers: windowed code uses [`Self::default_host_slug_for_scope`], and a
     /// windowless availability check uses [`Self::any_team_has_default_host_slug`].
     pub fn unscoped_default_host_slug(&self) -> Option<&str> {

app/src/workspaces/user_workspaces_tests.rs

@@ -1056,6 +1056,86 @@ fn create_test_window(app: &mut App) -> (WindowId, ViewHandle<TeamContextTestVie
     app.add_window(WindowStyle::NotStealFocus, |_| TeamContextTestView)
 }
 
+/// Records what a view can resolve about its own team *during its own construction*, which is
+/// where the cloud-mode host selector's first read happens.
+struct ConstructionTimeScopeProbe {
+    host_slug_from_view_context: Option<String>,
+    team_uid_from_own_handle: Option<ServerId>,
+}
+
+impl ConstructionTimeScopeProbe {
+    fn new(ctx: &mut ViewContext<Self>) -> Self {
+        let user_workspaces = UserWorkspaces::as_ref(ctx);
+        let scope = user_workspaces.team_context_for_operation(ctx);
+        Self {
+            host_slug_from_view_context: user_workspaces
+                .default_host_slug_for_scope(&scope)
+                .map(str::to_string),
+            team_uid_from_own_handle: user_workspaces
+                .team_context(&ctx.handle(), ctx)
+                .and_then(|context| context.team_uid()),
+        }
+    }
+}
+
+impl Entity for ConstructionTimeScopeProbe {
+    type Event = ();
+}
+
+impl View for ConstructionTimeScopeProbe {
+    fn ui_name() -> &'static str {
+        "ConstructionTimeScopeProbe"
+    }
+
+    fn render(&self, _: &AppContext) -> Box<dyn Element> {
+        Empty::new().finish()
+    }
+}
+
+impl TypedActionView for ConstructionTimeScopeProbe {
+    type Action = ();
+}
+
+/// A view is not in `view_to_window` until its build closure returns, so during its own
+/// construction it can resolve its team through its `ViewContext` but *not* through a handle to
+/// itself. Both halves are asserted: the shape the host selector uses works, and the shape it
+/// would be tempting to refactor to silently resolves nothing. Every other test here resolves
+/// post-construction, where the difference is invisible.
+#[test]
+fn test_a_view_can_only_resolve_its_own_team_through_its_view_context_while_constructing() {
+    let mut team = team_for_test();
+    team.settings.default_host_slug = Some("team-host".to_string());
+    let workspace = workspace_for_test(&team);
+
+    App::test((), |mut app| async move {
+        initialize_window_team_test_app(&mut app, vec![workspace]);
+
+        let (window_id, view) = create_test_window(&mut app);
+        UserWorkspaces::handle(&app).update(&mut app, |user_workspaces, ctx| {
+            user_workspaces.set_team_for_window(window_id, team.uid, ctx);
+        });
+
+        let probe = view.update(&mut app, |_, ctx| {
+            ctx.add_typed_action_view(ConstructionTimeScopeProbe::new)
+        });
+
+        app.read(|ctx| {
+            let probe = probe.as_ref(ctx);
+            assert_eq!(
+                probe.host_slug_from_view_context.as_deref(),
+                Some("team-host"),
+                "a view under construction still resolves its window's team through its \
+                 ViewContext, whose window id is a plain field"
+            );
+            assert_eq!(
+                probe.team_uid_from_own_handle, None,
+                "a handle to a view still being constructed resolves no window, so reading the \
+                 host through one would silently drop the team's configured host"
+            );
+        });
+    })
+}
+
 fn two_teams() -> (Team, Team) {
     let team_a = team_for_test();
     let mut team_b = team_for_test();