refactor(client): migrate the three banners onto the InfoBar stack (UI/UX v3 P6b) (#93)

Nexterm shipped three top-of-screen banners — update notice, offline and
server error — as three `Option` fields on `ClientState`, three vertex
builders totalling 232 structurally identical lines, and three copies of the
stacking arithmetic, with the error banner re-deriving its own offset by
testing the other two. They are now three kinds of one surface.

The three fields are removed rather than wrapped, so the compiler enumerated
every call site: the update poller and the connect loop queue through
`push_info_bar`, a successful connect clears the offline slot, and
`ServerToClient::Error` replaces the error slot instead of overwriting a
field. `bar_rects` from P6a is the only function that computes a bar's `y`,
and `stack_order` the only one that decides which bar is on top — a source
gate over `ui_verts.rs` fails if a second stacking expression comes back.

Three user-visible changes come with the consolidation:

- The stack draws below the tab bar instead of over it. Chrome hiding chrome
  is the worse of the two costs — the tab bar is how the user navigates, and
  hiding it while an error is up is exactly when they need it (D2).
- At most two bars are drawn. The stack overlays terminal rows that are
  neither reflowed nor scrolled, so it must not grow without bound; the
  count suffix for the rest needs a new string and lands in P6c (D-cap).
- `Enter` opens the release page only while the update bar is on top, so an
  error above it now takes priority (D4). `Esc` still clears the error bar
  before the update bar, because it walks the same order the stack is drawn
  in, and the offline bar is skipped rather than dismissed — its content is
  "still not connected", and it no longer advertises an `[Esc]` that did
  nothing.

Accessibility is unchanged on purpose: the update bar keeps its `Role::Alert`
node and the tree hash now reads the stack (excluding the offline bar's
elapsed seconds, as before). Giving every kind a node — which is what finally
makes a failed shell launch announceable — is P6c, kept separate so that fix
is reviewable without this migration around it.

Generated with [Claude Code](https://claude.ai/code)
via [Happy](https://happy.engineering)

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Happy <yesreply@happy.engineering>

Author: 3 people

CHANGELOG.md

@@ -39,6 +39,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   name table as TOML, so a scheme is reachable from both the moment it exists.
 
 ### Changed
+- The three top-of-screen banners — update notice, offline, server error — are
+  now one **InfoBar stack**. They were three state fields, three vertex
+  builders and three copies of the stacking arithmetic, with the error banner
+  re-deriving its own offset by testing the other two; they are now three kinds
+  of one surface, laid out by the single `bar_rects` function. Three visible
+  changes come with it: the stack draws **below the tab bar** instead of over
+  it, at most **two bars** are drawn at once (a third is queued but not drawn
+  until P6c gives it a count suffix), and `Enter` opens the release page only
+  while the update bar is the top one — an error bar above it now takes
+  priority. `Esc` still clears the error bar before the update bar, and the
+  offline bar still clears itself on connect and offers no `[Esc]` hint
+  (UI/UX v3 P6b).
 - The chrome surface ramp now picks its direction with the same predicate the
   text correction uses (WCAG relative luminance against the readability
   watershed) instead of BT.709 on undecoded sRGB channels, and is capped so no

docs/plans/ui-ux-modernization-v3.md

@@ -708,7 +708,14 @@ gated behind a spike.
       buttons and the footer's `↗` / `↺` links move too; see the design spec's
       §8
 - [x] P5 contrast everywhere + high-contrast scheme (P5a–P5d, 2026-08-29)
-- [ ] P6 InfoBar + consent reclassification
+- [ ] P6 InfoBar consolidation (consent reclassification dropped, spec §4)
+  - [x] P6a InfoBar model + pure layout — shipped via #92 (2026-08-29)
+  - [x] P6b migrate the three banners onto the stack — the three `Option`
+    fields and the three builders are gone; the stack draws below the tab bar,
+    capped at two bars, and `Enter` acts on the top bar only (2026-08-29)
+  - [ ] P6c AccessKit nodes ×kind + tree hash + `infobar-more-count` ×8 locales
+    — the phase's most valuable change: the error bar is still unannounced
+  - [ ] P6d entrance/exit motion + auto-dismissal for the info severity
 - [x] P7 base `notitle` custom title bar — shipped early via #46 (2026-07-30)
 - [x] P7 spike: Windows 11 snap layouts — answered in production via #49 (2026-07-31)
 - [x] P7 default-on decision — `notitle` default on Windows/Linux via #50 (2026-07-31)

nexterm-client-gpu/CLAUDE.md

@@ -17,9 +17,10 @@ Guidance for working inside the GPU client crate. The repo-wide rules — langua
   - `settings_<tab>.rs` — one module per migrated category, each exposing `<tab>_widget_descs` (semantics), `build_<tab>_widgets` (semantics + geometry) and `apply_<tab>_action` (the single state transition the mouse, keyboard and AccessKit paths all call). All nine categories are migrated: Theme, Window, Font, Startup, Blocks, Security, Profiles, Ssh and Keybindings. The three list-shaped tabs (Profiles, Ssh, Keybindings) window their entry list via `layout::list_window`, and reserve index 0 for the entry list itself (which entry is selected lives in `selected_host_index` / `selected_key_index`, because that outlives focus moving to the fields); their delete-confirmation dialogs stay hand-written, because a modal over the panel is not a settings row.
   - **Focus** is one field: `SettingsPanel.focused_widget_index` (a `WidgetId.index` for the current category), replacing the seven `<tab>_field_focus` counters. What an index means is defined by that category's descriptor builder — its `row` constants where it has them, otherwise the order descriptors are pushed. Every category change goes through `SettingsPanel::set_category`, which resets the index, the scroll offset and any in-flight field edit; do not assign `panel.category` directly. Keyboard ↑/↓ walk the descriptors via `widgets/navigation.rs` (`focus_next` / `focus_prev`), skipping anything that is not a focus stop — `!enabled`, `Label`, and `Swatch` (a swatch duplicates the cycler row above it, so nine extra stops would buy nothing). A new category therefore gains keyboard navigation by describing its controls, with no navigation code of its own. Ssh and Keybindings are the exception and keep bespoke arrow arms, because index 0 addresses their entry list as a whole rather than a described widget.
 - `settings/hover.rs` — `HoverDwell`, the pointer-dwell timer that gates tooltips (500 ms).
+- `renderer/overlay/infobar.rs` — the InfoBar stack (UI/UX v3 P6): every non-blocking status message — update notice, offline, server error — as one `InfoBarKind` queued on `ClientState.info_bars`, one slot per kind. `bar_rects` is the only function that computes a bar's `y`, and `stack_order` the only one that decides which bar is on top; a new message type is an enum arm, not a fourth builder, and it must not gain stacking arithmetic of its own. Drawn by `ui_verts::build_info_bar_verts` below the tab bar, capped at two visible bars.
 - `palette.rs` — Command palette (`Ctrl+Shift+P`). Fuzzy search via `SkimMatcherV2`. Sprint 5-7 / Phase 3-3 covers all 25 actions in `execute_action` (Quit, ClosePane, NewWindow, QuickSelect, SetBroadcastOn/Off, …) and persists usage history at `~/.local/state/nexterm/palette_history.json` (atomic write, mode 0600). The pure `rank_actions` function orders by history when the query is empty (last_used desc → use_count desc) and combines fuzzy score with a `history_bonus` (use_count×10 capped at 100, +100 within 1 day, +50 within 1 week) when a query is present. `record_use` records the selection.
 - `host_manager.rs` — SSH host manager UI. `load_history()` / `save_history()` persist connection frequency to `host_history.json`. The `PasswordModal` struct handles the password prompt for `auth_type="password"` hosts.
-- `update_checker.rs` — Polls the GitHub Releases API five seconds after startup. Disabled by `auto_check_update = false`. Results land in `ClientState.update_banner`; `Esc` dismisses, `Enter` opens the release page.
+- `update_checker.rs` — Polls the GitHub Releases API five seconds after startup. Disabled by `auto_check_update = false`. Results are queued onto `ClientState.info_bars` as `InfoBarKind::UpdateAvailable`; `Esc` dismisses, `Enter` opens the release page while it is the top bar.
 - `platform.rs` — Platform-specific utilities. `apply_backdrop` applies the configured `window.backdrop` material: Windows via `DwmSetWindowAttribute(DWMWA_SYSTEMBACKDROP_TYPE)` (Windows 11 build 22621+; a no-op below that), macOS via `window-vibrancy`, Linux not at all. The value mapping, `dwm_backdrop_value`, is a plain `const fn` compiled on every platform so it is testable without Windows. `open_releases_url` opens the release page in the default browser.
 - `renderer/background_pass.rs` — Background image rendering (Sprint 5-7 / Phase 3-1). When `WindowConfig.background_image` is set, the image is loaded at startup and each frame draws clear → background image → cell backgrounds → text. NDC + UV computation for each fit mode (cover/contain/stretch/center/tile) lives in the pure function `compute_background_quad`, with 11 unit tests. Images larger than 4096×4096 are downscaled with Lanczos3. Tile mode falls back to stretch when the tile count exceeds 256 (defensive). Reuses the existing `image_pipeline` (used for Sixel/Kitty) instead of introducing a separate one. Supported formats: PNG / JPEG (whichever features are enabled in the workspace `image` crate).
 - `animations/` — UI animation foundation. `mod.rs` holds `AnimationManager` and the spring physics (`SpringState`) for the tab accent and per-pane dim; `easing.rs` the time-based helpers (`ease_out_cubic`, `compute_progress`); `curve.rs` the nine Fluent 2 cubic-bezier curves and eight duration steps, transcribed from `microsoft/fluentui` `packages/tokens` (do not re-derive them by eye); `timed.rs` the `Timed { start, duration_ms, curve }` value type; `surface.rs` the `SurfaceMotion` open/close pair shared by every overlay surface (UI/UX v3 P3b). Springs are for motion interrupted by a new target; `Timed` is for transitions with a known start, end and duration. A zero duration — what `AnimationsConfig::scaled_duration_ms` returns when `enabled = false` or `intensity = "off"` — makes a `Timed` finished on creation, which is the whole reduced-motion path. `ClientState::has_active_animation` is the one place that decides whether the event loop requests another frame; a surface that gains a `Timed` adds a clause there or it will simply never animate.

nexterm-client-gpu/src/accessibility.rs

@@ -29,6 +29,7 @@ use accesskit::{
 use crate::host_manager::HostManager;
 use crate::macro_picker::MacroPicker;
 use crate::palette::CommandPalette;
+use crate::renderer::overlay::infobar::InfoBarKind;
 use crate::settings_panel::SettingsPanel;
 use crate::state::{
     AlertEntry, AlertKind, ClientState, CloseWindowDialog, ContextMenu, QuickSelectState,
@@ -849,8 +850,13 @@ pub fn build_tree_from_state(state: &ClientState) -> TreeUpdate {
         focus = overlay_focus;
     }
 
-    // ===== Non-modal: update banner =====
-    if let Some(version) = &state.update_banner {
+    // ===== Non-modal: update bar (UI/UX v3 P6) =====
+    // Still only the update kind: giving every `InfoBarKind` a node — which is
+    // what finally makes the server error announceable — is P6c.
+    if let Some(version) = state.info_bars.iter().find_map(|bar| match &bar.kind {
+        InfoBarKind::UpdateAvailable { version } => Some(version),
+        _ => None,
+    }) {
         nodes.push(build_update_banner_node(version));
         root_children.push(UPDATE_BANNER_ID);
     }
@@ -2270,14 +2276,20 @@ pub fn compute_tree_state_hash(state: &ClientState) -> u64 {
         }
     }
 
-    // === update_banner (non-modal) ===
-    state.update_banner.hash(&mut h);
-
-    // === offline_banner (non-modal, Sprint 5-14 / v1.7.8 — P2-1) ===
-    // We only care whether the banner is visible (the elapsed-seconds count
-    // updates every frame and would otherwise force a tree rebuild every
-    // throttle tick — accessibility consumers do not need that granularity).
-    state.offline_banner_since.is_some().hash(&mut h);
+    // === InfoBar stack (non-modal, UI/UX v3 P6) ===
+    // Slot plus message, so adding, removing or rewording a bar rebuilds the
+    // tree. The offline bar contributes only its presence: its elapsed-seconds
+    // count updates every frame and would otherwise force a rebuild every
+    // throttle tick — accessibility consumers do not need that granularity.
+    state.info_bars.len().hash(&mut h);
+    for bar in &state.info_bars {
+        bar.kind.slot().hash(&mut h);
+        match &bar.kind {
+            InfoBarKind::UpdateAvailable { version } => version.hash(&mut h),
+            InfoBarKind::ServerError { message } => message.hash(&mut h),
+            InfoBarKind::Offline { .. } => {}
+        }
+    }
 
     // === SR alerts (Sprint 5-11-5) ===
     // Reflect length + each seq + kind. `kind` becomes hashable via `as u8`.
@@ -2878,7 +2890,12 @@ mod tests {
     fn update_banner_coexists_with_palette() {
         let mut state = ClientState::new(80, 24, 1000);
         state.palette.is_open = true;
-        state.update_banner = Some("v1.6.0".to_string());
+        state.push_info_bar(
+            InfoBarKind::UpdateAvailable {
+                version: "v1.6.0".to_string(),
+            },
+            std::time::Instant::now(),
+        );
 
         let update = build_tree_from_state(&state);
 
@@ -3030,7 +3047,12 @@ mod tests {
         let h_none = compute_tree_state_hash(&state_none);
 
         let mut state_banner = ClientState::new(80, 24, 1000);
-        state_banner.update_banner = Some("v1.6.0".to_string());
+        state_banner.push_info_bar(
+            InfoBarKind::UpdateAvailable {
+                version: "v1.6.0".to_string(),
+            },
+            std::time::Instant::now(),
+        );
         let h_banner = compute_tree_state_hash(&state_banner);
 
         assert_ne!(

nexterm-client-gpu/src/renderer/event_handler/lifecycle.rs

@@ -22,6 +22,7 @@ use crate::animations::duration::GENTLE;
 use crate::connection::{Connection, ConnectionExt};
 use crate::glyph_atlas::{GlyphAtlas, GlyphKey};
 use crate::renderer::WgpuState;
+use crate::renderer::overlay::infobar::{InfoBarKind, InfoBarSlot};
 
 impl EventHandler {
     /// `ApplicationHandler::new_events` implementation.
@@ -309,8 +310,8 @@ impl EventHandler {
                 }
                 self.connect_failure_count = 0;
                 self.connect_failure_started_at = None;
-                // P2-1: clear the offline banner if it was visible.
-                self.app.state.offline_banner_since = None;
+                // P2-1: clear the offline bar if it was visible.
+                self.app.state.remove_info_bar(InfoBarSlot::Offline);
                 true
             }
             Err(e) => {
@@ -340,13 +341,15 @@ impl EventHandler {
                 }
 
                 // P2-1: once the offline streak has lasted past the threshold,
-                // raise the visible "Connecting…" banner. The renderer reads
-                // `offline_banner_since` and formats the elapsed seconds.
-                if self.app.state.offline_banner_since.is_none()
+                // raise the visible "Connecting…" bar. The bar carries `since`
+                // and the renderer formats the elapsed seconds from it.
+                if !self.app.state.has_info_bar(InfoBarSlot::Offline)
                     && let Some(started) = self.connect_failure_started_at
                     && started.elapsed() >= Self::OFFLINE_BANNER_THRESHOLD
                 {
-                    self.app.state.offline_banner_since = Some(started);
+                    self.app
+                        .state
+                        .push_info_bar(InfoBarKind::Offline { since: started }, Instant::now());
                     if let Some(w) = &self.window {
                         w.request_redraw();
                     }
@@ -660,12 +663,14 @@ impl EventHandler {
             self.app.state.prefix_pending_until = None;
         }
 
-        // Poll for notifications from the update checker and show the banner.
+        // Poll for notifications from the update checker and raise the bar.
         if self.update_rx.has_changed().unwrap_or(false)
-            && let Some(ver) = self.update_rx.borrow_and_update().clone()
-            && self.app.state.update_banner.is_none()
+            && let Some(version) = self.update_rx.borrow_and_update().clone()
+            && !self.app.state.has_info_bar(InfoBarSlot::Update)
         {
-            self.app.state.update_banner = Some(ver);
+            self.app
+                .state
+                .push_info_bar(InfoBarKind::UpdateAvailable { version }, Instant::now());
             had_messages = true;
         }
 

nexterm-client-gpu/src/renderer/input_handler/mod.rs

@@ -24,6 +24,7 @@ use crate::key_map::{
     config_key_matches, config_key_matches_token, format_key_event, physical_to_proto_key,
     proto_modifiers, winit_code_to_char,
 };
+use crate::renderer::overlay::infobar;
 use crate::vertex_util::grid_to_text;
 
 use super::EventHandler;
@@ -1069,26 +1070,33 @@ impl EventHandler {
             return true;
         }
 
-        // When the server-error banner is visible: Esc closes it (Sprint 5-12 Phase 1).
-        // Processed before update_banner so the overlapping banner clears first.
-        if self.app.state.error_banner.is_some()
-            && let WKeyCode::Escape = code
-        {
-            self.app.state.error_banner = None;
-            return true;
-        }
-
-        // While the update-notification banner is visible: Esc closes it, Enter opens the browser
-        if self.app.state.update_banner.is_some() {
+        // InfoBar stack (UI/UX v3 P6). `Esc` dismisses the loudest bar that can
+        // be dismissed at all — which keeps the previous ordering, where the
+        // error banner cleared before the update one, without either handler
+        // having to know the other exists. The offline bar is skipped rather
+        // than dismissed: it reports a condition that is still true.
+        if !self.app.state.info_bars.is_empty() {
+            let order = infobar::stack_order(self.app.state.info_bars.make_contiguous());
             match code {
                 WKeyCode::Escape => {
-                    self.app.state.update_banner = None;
-                    return true;
+                    if let Some(&index) = order
+                        .iter()
+                        .find(|&&index| self.app.state.info_bars[index].kind.is_dismissible())
+                    {
+                        self.app.state.info_bars.remove(index);
+                        return true;
+                    }
                 }
+                // D4: only the top bar carries an activation, so `Enter` does
+                // nothing while an error sits above the update notice.
                 WKeyCode::Enter => {
-                    crate::platform::open_releases_url();
-                    self.app.state.update_banner = None;
-                    return true;
+                    if let Some(&top) = order.first()
+                        && self.app.state.info_bars[top].kind.has_activation()
+                    {
+                        crate::platform::open_releases_url();
+                        self.app.state.info_bars.remove(top);
+                        return true;
+                    }
                 }
                 _ => {}
             }