Agent: add purposeful motion across chat, composer, menus and settings

apps/maple-agent/CLAUDE.md

@@ -118,6 +118,19 @@ popup before a nested one). The popup handles the rest:
 A text field inside a menu that goes away calls `Popup::refocus`, so the
 menu keeps the keyboard. Menu keys live in the keymap's `Menu` context.
 
+## Motion
+
+Animate through `ui/motion.rs` only; [motion](docs/motion.md) holds the
+tokens and rules. Motion never delays input, retargets from the value on
+screen, closes menus and dialogs at once, and settles immediately under
+reduced motion. Streaming text, typing, and keyboard navigation do not
+animate. Rows inside `gpui::list` time their entrance from view state, not
+element state, so they never replay when scrolled back into view. Never put
+opacity on an ancestor of a cached view: its replayed paint keeps the
+opacity of its first frame. Paint a cover over it instead, as `swap_in`
+does, unless its bounds or content mask change on every frame of the fade
+and again at rest, as in the sidebar collapse.
+
 ## Accessibility
 
 GPUI only reports elements with both an id and a role, and it builds the tree

apps/maple-agent/app/src/desktop.rs

@@ -2383,6 +2383,20 @@ impl Render for MapleApp {
             cx.refresh_windows();
         }
         let titlebar = self.titlebar.clone();
+        // The screen fades in when it changes kind; the first screen and a
+        // screen that only re-renders draw at once.
+        let screen_kind = if self.updater.restart_path().is_some() {
+            "restart"
+        } else {
+            match &self.screen {
+                Screen::Restoring => "restoring",
+                Screen::StoreGate(_) => "store-gate",
+                Screen::Login(_) => "login",
+                Screen::Chat(_) => "chat",
+                Screen::Settings(_) => "settings",
+                Screen::PlanGate(_) => "plan-gate",
+            }
+        };
         let root = div()
             .relative()
             .size_full()
@@ -2397,7 +2411,7 @@ impl Render for MapleApp {
             // on transcript/composer via `typography::chat_reading`.
             .text_sm()
             .child(titlebar)
-            .child(
+            .child(ui::motion::swap_in(
                 div()
                     .flex_1()
                     .min_h_0()
@@ -2442,7 +2456,10 @@ impl Render for MapleApp {
                             Screen::PlanGate(gate) => gate.clone().into_any_element(),
                         }
                     }),
-            );
+                "maple-screen",
+                screen_kind,
+                gpui::rgb(ui::theme::bg_app()),
+            ));
         #[cfg(target_os = "linux")]
         let root = root.children(self.restart_confirmation.clone());
         root
@@ -5323,6 +5340,79 @@ mod tests {
         assert!(return_to_window(true, cx));
     }
 
+    /// Settings and back brings the chat's sidebar back with its task rows.
+    /// The screen fade covers the whole window, so a regression there would
+    /// show as a sidebar whose rows never return.
+    #[gpui::test]
+    fn settings_and_back_keeps_the_sidebar_task_rows(cx: &mut gpui::TestAppContext) {
+        struct Host(Entity<MapleApp>);
+        impl Render for Host {
+            fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
+                div().size_full().child(self.0.clone())
+            }
+        }
+        let settings = crate::settings::SETTINGS_IO_LOCK.lock();
+        let app = project_shell_locked(cx, &settings);
+        let chat = app.read_with(cx, |app, _| app.local_chat.clone().expect("local chat"));
+        chat.update(cx, |chat, cx| {
+            chat.seed_sessions_for_test(
+                vec![maple_agent::agent::AgentSessionSummary {
+                    web_enabled: true,
+                    permission_mode: Default::default(),
+                    state: maple_agent::agent::AgentTaskState::Active,
+                    acp: false,
+                    id: "s1".into(),
+                    title: "First task".into(),
+                    project_root: "/same/project".into(),
+                    created_ms: 0,
+                    updated_ms: 0,
+                    message_count: 1,
+                    model: None,
+                }],
+                cx,
+            )
+        });
+        let (_, cx) = cx.add_window_view(|_, _| Host(app.clone()));
+        cx.simulate_resize(size(px(1100.), px(850.)));
+        cx.run_until_parked();
+        assert!(
+            cx.debug_bounds("session-s1").is_some(),
+            "the task row shows"
+        );
+
+        app.update(cx, |app, cx| app.show_settings(Section::General, cx));
+        cx.run_until_parked();
+        assert!(
+            cx.debug_bounds("session-s1").is_none(),
+            "Settings replaces the chat"
+        );
+        let snapshot = app.read_with(cx, |app, cx| match &app.screen {
+            Screen::Settings(screen) => screen.read(cx).settings_snapshot(),
+            _ => panic!("expected Settings"),
+        });
+        let start = std::time::Instant::now();
+        ui::motion::set_test_now(Some(start));
+        app.update(cx, |app, cx| app.close_settings(snapshot, cx));
+        cx.run_until_parked();
+        // Let the screen fade and anything the sidebar eases settle.
+        for step in 1..=4 {
+            ui::motion::set_test_now(Some(start + ui::motion::PANEL * step));
+            cx.update(|window, cx| {
+                window.simulate_next_frame(cx);
+            });
+            cx.run_until_parked();
+        }
+        // A cached view replays its last paint without recording debug
+        // bounds, so draw every view afresh before looking for the row.
+        cx.update(|_, cx| cx.refresh_windows());
+        cx.run_until_parked();
+        assert!(
+            cx.debug_bounds("session-s1").is_some(),
+            "the task row is back after Settings"
+        );
+        ui::motion::set_test_now(None);
+    }
+
     #[gpui::test]
     fn a_free_guest_gets_its_account_id_in_the_gate(cx: &mut gpui::TestAppContext) {
         let settings = crate::settings::SETTINGS_IO_LOCK.lock();