feat(tui): add auto-update notification system

- Add UpdateNotificationStatus enum for tracking update states
- Add update_status, update_progress, update_version fields to AppState
- Spawn background update check task on TUI startup
- Add update check result handling in EventLoop
- Render update banner above input field with status-specific messages
- Add cortex-update dependency to cortex-tui

Author: echobt

Cargo.lock

@@ -28,6 +28,7 @@ cortex-protocol = { workspace = true }
 cortex-common = { workspace = true }
 cortex-login = { workspace = true }
 cortex-agents = { workspace = true }
+cortex-update = { path = "../cortex-update" }
 
 # TUI framework
 ratatui = { workspace = true }

src/cortex-tui/Cargo.toml

@@ -15,7 +15,7 @@ mod types;
 pub use approval::{ApprovalState, PendingToolResult};
 pub use autocomplete::{AutocompleteItem, AutocompleteState};
 pub use session::{ActiveModal, SessionSummary};
-pub use state::AppState;
+pub use state::{AppState, UpdateNotificationStatus};
 pub use streaming::StreamingState;
 pub use subagent::{
     SubagentDisplayStatus, SubagentTaskDisplay, SubagentTodoItem, SubagentTodoStatus,

src/cortex-tui/src/app/mod.rs

@@ -22,6 +22,19 @@ use super::streaming::StreamingState;
 use super::subagent::SubagentTaskDisplay;
 use super::types::{AppView, FocusTarget, OperationMode};
 
+/// Status of the auto-update notification system
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum UpdateNotificationStatus {
+    /// Update check in progress
+    Checking,
+    /// A new version is available
+    Available,
+    /// Currently downloading the update
+    Downloading,
+    /// Download complete, restart required
+    RestartRequired,
+}
+
 /// Main application state
 pub struct AppState {
     pub view: AppView,
@@ -172,6 +185,12 @@ pub struct AppState {
     pub user_email: Option<String>,
     /// Organization name for welcome screen
     pub org_name: Option<String>,
+    /// Auto-update notification state
+    pub update_status: Option<UpdateNotificationStatus>,
+    /// Download progress percentage (0-100)
+    pub update_progress: Option<f32>,
+    /// New version string when available
+    pub update_version: Option<String>,
 }
 
 impl AppState {
@@ -272,6 +291,9 @@ impl AppState {
             user_name: None,
             user_email: None,
             org_name: None,
+            update_status: None,
+            update_progress: None,
+            update_version: None,
         }
     }
 

src/cortex-tui/src/app/state.rs

@@ -731,11 +731,42 @@ impl AppRunner {
             Arc::new(registry)
         };
 
+        // ====================================================================
+        // BACKGROUND TASK: Check for updates (non-blocking)
+        // ====================================================================
+        let update_check_task = tokio::spawn(async move {
+            match cortex_update::UpdateManager::new() {
+                Ok(manager) => match manager.check_update().await {
+                    Ok(Some(info)) => {
+                        tracing::info!(
+                            "Update available: {} -> {}",
+                            info.current_version,
+                            info.latest_version
+                        );
+                        Some((info.latest_version, info.asset.sha256))
+                    }
+                    Ok(None) => {
+                        tracing::debug!("No updates available");
+                        None
+                    }
+                    Err(e) => {
+                        tracing::debug!("Failed to check for updates: {}", e);
+                        None
+                    }
+                },
+                Err(e) => {
+                    tracing::debug!("Failed to create update manager: {}", e);
+                    None
+                }
+            }
+        });
+
         // Create event loop with provider manager, cortex session, and tool registry
         let mut event_loop = EventLoop::new(app_state)
             .with_provider_manager(provider_manager)
             .with_cortex_session(cortex_session)
-            .with_tool_registry(tool_registry);
+            .with_tool_registry(tool_registry)
+            .with_update_check_task(update_check_task);
 
         // Add unified executor if available
         if let Some(executor) = unified_executor {

src/cortex-tui/src/runner/app_runner/runner.rs

@@ -165,6 +165,9 @@ pub struct EventLoop {
 
     /// TUI capture manager for debugging (enabled via CORTEX_TUI_CAPTURE=1).
     pub(super) tui_capture: TuiCapture,
+
+    /// Handle for background update check task
+    pub(super) update_check_task: Option<JoinHandle<Option<(String, String)>>>,
 }
 
 impl EventLoop {
@@ -211,6 +214,7 @@ impl EventLoop {
             is_continuation: false,
             _undo_stack: Vec::new(),
             tui_capture,
+            update_check_task: None,
         }
     }
 
@@ -244,6 +248,12 @@ impl EventLoop {
         self
     }
 
+    /// Sets the update check background task.
+    pub fn with_update_check_task(mut self, task: JoinHandle<Option<(String, String)>>) -> Self {
+        self.update_check_task = Some(task);
+        self
+    }
+
     /// Runs the main event loop.
     ///
     /// This method initializes the FrameEngine to poll keyboard, mouse, and
@@ -365,6 +375,29 @@ impl EventLoop {
                         tracing::error!("Error rendering after tool event: {}", e);
                     }
                 }
+
+                // Branch 4: Background update check result
+                result = async {
+                    match self.update_check_task.as_mut() {
+                        Some(task) => task.await,
+                        None => std::future::pending().await,
+                    }
+                } => {
+                    // Remove the task handle since it's complete
+                    self.update_check_task = None;
+
+                    // Update app state with result
+                    if let Ok(Some((version, _sha256))) = result {
+                        self.app_state.update_status = Some(crate::app::UpdateNotificationStatus::Available);
+                        self.app_state.update_version = Some(version);
+                        self.app_state.toasts.info("A new version of Cortex is available!");
+                    }
+
+                    // Re-render to show update banner
+                    if let Err(e) = self.render(terminal) {
+                        tracing::error!("Error rendering after update check: {}", e);
+                    }
+                }
             }
         }
 

src/cortex-tui/src/runner/event_loop/core.rs

@@ -378,6 +378,47 @@ impl<'a> MinimalSessionView<'a> {
         }
     }
 
+    /// Renders an update notification banner above the input area.
+    fn render_update_banner(
+        &self,
+        area: Rect,
+        buf: &mut Buffer,
+        status: &crate::app::UpdateNotificationStatus,
+    ) {
+        use crate::app::UpdateNotificationStatus;
+
+        // Determine the banner text and color based on status
+        let (banner_text, color) = match status {
+            UpdateNotificationStatus::Checking => {
+                ("🔍 Checking for updates...".to_string(), self.colors.text_dim)
+            }
+            UpdateNotificationStatus::Available => {
+                let text = if let Some(ref version) = self.app_state.update_version {
+                    format!("🔄 A new version is available ({})", version)
+                } else {
+                    "🔄 A new version is available".to_string()
+                };
+                (text, self.colors.accent)
+            }
+            UpdateNotificationStatus::Downloading => {
+                let text = if let Some(progress) = self.app_state.update_progress {
+                    format!("⬇️  Downloading... {:.0}%", progress)
+                } else {
+                    "⬇️  Downloading...".to_string()
+                };
+                (text, self.colors.warning)
+            }
+            UpdateNotificationStatus::RestartRequired => (
+                "✅ You must restart to run the latest version".to_string(),
+                self.colors.success,
+            ),
+        };
+
+        // Render the banner at the provided area
+        let banner_style = Style::default().fg(color);
+        buf.set_string(area.x + 2, area.y, &banner_text, banner_style);
+    }
+
     /// Returns whether a task is currently running.
     fn is_task_running(&self) -> bool {
         self.app_state.streaming.is_streaming
@@ -571,6 +612,9 @@ impl<'a> Widget for MinimalSessionView<'a> {
         let status_height: u16 = if is_task_running { 1 } else { 0 };
         let input_height: u16 = 3;
         let hints_height: u16 = 1;
+        // Add 1 row for update banner if update is available
+        let has_update_banner = self.app_state.update_status.is_some();
+        let update_banner_height: u16 = if has_update_banner { 1 } else { 0 };
 
         // Calculate welcome card heights from render_motd constants
         let welcome_card_height = 11_u16;
@@ -584,7 +628,8 @@ impl<'a> Widget for MinimalSessionView<'a> {
         layout.gap(1);
 
         // Calculate available height for scrollable content (before input/hints)
-        let bottom_reserved = status_height + input_height + autocomplete_height + hints_height + 2; // +2 for gaps
+        let bottom_reserved =
+            status_height + update_banner_height + input_height + autocomplete_height + hints_height + 2; // +2 for gaps
         let available_height = area.height.saturating_sub(1 + bottom_reserved); // 1 for top margin
 
         // Render scrollable content area (welcome cards + messages together)
@@ -608,7 +653,14 @@ impl<'a> Widget for MinimalSessionView<'a> {
             next_y += status_height;
         }
 
-        // 6. Input area - follows status (or content if no status)
+        // 5.5. Update notification banner (above input, after status)
+        if let Some(ref status) = self.app_state.update_status {
+            let banner_area = Rect::new(area.x, next_y, area.width, update_banner_height);
+            self.render_update_banner(banner_area, buf, status);
+            next_y += update_banner_height;
+        }
+
+        // 6. Input area - follows status/banner (or content if no status)
         let input_y = next_y;
         let input_area = Rect::new(area.x, input_y, area.width, input_height);