mode_indicator.patch

diff --git a/src/utils/agent_chat/mode_indicator.rs b/src/utils/agent_chat/mode_indicator.rs
new file mode 100644
index 0000000..e8f1a2d
--- /dev/null
+++ b/src/utils/agent_chat/mode_indicator.rs
@@ -0,0 +1,202 @@
+//! Mode indicator and contextual help for chat interface
+//!
+//! Provides visual feedback about current input mode and available actions.
+//! Implements progressive disclosure - help text changes based on context.
+
+use super::Colors;
+use crossterm::terminal;
+use std::io::{self, Write};
+
+/// Current input mode for display purposes
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DisplayMode {
+    /// Normal input mode - user is typing queries
+    Input,
+    /// Task selection mode - navigating todo list
+    TaskSelection,
+}
+
+/// Render the mode indicator status line
+/// This appears on the right side of the input prompt
+///
+/// # Arguments
+/// * `mode` - Current input mode (Input or TaskSelection)
+/// * `suggestions_visible` - Whether suggestion dropdown is currently shown
+///
+/// # Returns
+/// Formatted string with ANSI color codes for mode indicator and help text
+pub fn render_mode_indicator(mode: DisplayMode, suggestions_visible: bool) -> String {
+    let (cols, _) = terminal::size().unwrap_or((80, 24));
+
+    // Compact version for narrow terminals
+    if cols < 80 {
+        let compact_tag = match mode {
+            DisplayMode::Input => {
+                if suggestions_visible {
+                    "[IN↕]" // Arrows indicate suggestions active
+                } else {
+                    "[IN]"
+                }
+            }
+            DisplayMode::TaskSelection => "[TK]",
+        };
+        return format!("{}{}{}", Colors::DIM, compact_tag, Colors::RESET);
+    }
+
+    // Full version with contextual help for wider terminals
+    let (mode_tag, help_text) = match mode {
+        DisplayMode::Input => {
+            if suggestions_visible {
+                // Suggestions active - show suggestion navigation help
+                ("[INPUT]", "↑↓ select │ Tab accept │ Esc cancel")
+            } else {
+                // Normal input - show general commands
+                ("[INPUT]", "Ctrl+T tasks │ Ctrl+L clear │ Ctrl+C exit")
+            }
+        }
+        DisplayMode::TaskSelection => {
+            // Task mode - show task-specific commands
+            ("[TASKS]", "↑↓ navigate │ Enter toggle │ Esc exit")
+        }
+    };
+
+    format!(
+        "{}{}{}  {}│{} {}",
+        Colors::DIM,
+        mode_tag,
+        Colors::RESET,
+        Colors::DIM,
+        Colors::RESET,
+        help_text
+    )
+}
+
+/// Update the mode indicator in place (right-aligned)
+/// Call this after any mode change or when redrawing input
+///
+/// # Arguments
+/// * `mode` - Current input mode
+/// * `suggestions_visible` - Whether suggestions are shown
+///
+/// # Example
+/// ```no_run
+/// update_mode_indicator_inline(DisplayMode::Input, false)?;
+/// ```
+pub fn update_mode_indicator_inline(
+    mode: DisplayMode,
+    suggestions_visible: bool,
+) -> io::Result<()> {
+    let indicator = render_mode_indicator(mode, suggestions_visible);
+    let (cols, _) = terminal::size().unwrap_or((80, 24));
+
+    // Calculate position: right-align with 2-char margin
+    let indicator_len = strip_ansi_codes(&indicator).chars().count();
+    let padding = cols.saturating_sub(indicator_len as u16 + 2);
+
+    // Save cursor position, move to right side, print, restore cursor
+    print!("\x1B[s"); // Save cursor
+    print!("\x1B[{}G", padding); // Move to column
+    print!("{}", indicator);
+    print!("\x1B[u"); // Restore cursor
+
+    io::stdout().flush()
+}
+
+/// Strip ANSI color codes for accurate length calculation
+/// Required because colored text is longer than it appears on screen
+///
+/// # Arguments
+/// * `text` - String potentially containing ANSI escape codes
+///
+/// # Returns
+/// String with all ANSI codes removed
+fn strip_ansi_codes(text: &str) -> String {
+    let mut result = String::new();
+    let mut in_escape = false;
+
+    for ch in text.chars() {
+        if ch == '\x1B' {
+            in_escape = true;
+        } else if in_escape && (ch == 'm' || ch == 'K') {
+            in_escape = false;
+        } else if !in_escape {
+            result.push(ch);
+        }
+    }
+
+    result
+}
+
+/// Render input box with mode indicator in header
+/// Use this for the full bordered input box
+///
+/// # Arguments
+/// * `mode` - Current input mode
+/// * `suggestions_visible` - Whether suggestions are shown
+///
+/// # Returns
+/// Result indicating success/failure of terminal I/O
+pub fn render_input_box_with_mode(
+    mode: DisplayMode,
+    suggestions_visible: bool,
+) -> io::Result<()> {
+    let (cols, _) = terminal::size().unwrap_or((80, 24));
+    let indicator = render_mode_indicator(mode, suggestions_visible);
+    let indicator_len = strip_ansi_codes(&indicator).chars().count();
+
+    // Calculate border width
+    let border_width = cols.saturating_sub(10) as usize;
+    let title_space = border_width.saturating_sub(indicator_len + 10); // "─ Input " = 8 chars
+
+    // Top border with mode indicator embedded
+    print!(
+        "{}┌─ Input {}",
+        Colors::GREEN,
+        "─".repeat(title_space)
+    );
+
+    // Position indicator on right side of border
+    print!("\x1B[{}G", cols.saturating_sub(indicator_len as u16 + 3));
+    print!("{}  {}┐{}", indicator, Colors::GREEN, Colors::RESET);
+
+    // Move to start of next line for input field
+    print!("\n{}│{} > ", Colors::GREEN, Colors::RESET);
+
+    io::stdout().flush()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_strip_ansi_codes() {
+        let colored = "\x1B[32m[INPUT]\x1B[0m Ctrl+C exit";
+        let stripped = strip_ansi_codes(colored);
+        assert_eq!(stripped, "[INPUT] Ctrl+C exit");
+    }
+
+    #[test]
+    fn test_strip_ansi_codes_complex() {
+        let complex = "\x1B[2m[INPUT]\x1B[0m  \x1B[2m│\x1B[0m Help text";
+        let stripped = strip_ansi_codes(complex);
+        assert_eq!(stripped, "[INPUT]  │ Help text");
+    }
+
+    #[test]
+    fn test_mode_indicator_lengths() {
+        let input_mode = render_mode_indicator(DisplayMode::Input, false);
+        let task_mode = render_mode_indicator(DisplayMode::TaskSelection, false);
+
+        // Ensure both fit in reasonable terminal width
+        assert!(strip_ansi_codes(&input_mode).len() < 70);
+        assert!(strip_ansi_codes(&task_mode).len() < 70);
+    }
+
+    #[test]
+    fn test_suggestions_change_help_text() {
+        let no_suggestions = render_mode_indicator(DisplayMode::Input, false);
+        let with_suggestions = render_mode_indicator(DisplayMode::Input, true);
+
+        assert!(no_suggestions.contains("Ctrl+T"));
+        assert!(with_suggestions.contains("↑↓ select"));
+        assert_ne!(no_suggestions, with_suggestions);
+    }
+}
diff --git a/src/utils/agent_chat/mod.rs b/src/utils/agent_chat/mod.rs
index a1b2c3d..e8f1a2d 100644
--- a/src/utils/agent_chat/mod.rs
+++ b/src/utils/agent_chat/mod.rs
@@ -13,6 +13,7 @@ pub mod fuzzy_matcher;
 pub mod input_handler;
 pub mod responsive_layout;
 pub mod streaming_output;
+pub mod mode_indicator;
 pub mod suggestions;
 pub mod system_status_bar;
 pub mod task_state;
@@ -32,6 +33,7 @@ pub use input_handler::{
 };
 pub use responsive_layout::{ComponentArea, TerminalRenderer};
 pub use streaming_output::{ContextTracker, MultilineInput};
+pub use mode_indicator::{render_mode_indicator, update_mode_indicator_inline, DisplayMode};
 pub use suggestions::RealtimeSuggestion;
 pub use system_status_bar::SystemStatusBarManager;
 pub use task_state::{InputMode, TaskState, TodoItem, TodoPriority};
diff --git a/src/utils/agent_chat/task_state.rs b/src/utils/agent_chat/task_state.rs
index a1b2c3d..e8f1a2d 100644
--- a/src/utils/agent_chat/task_state.rs
+++ b/src/utils/agent_chat/task_state.rs
@@ -14,6 +14,22 @@ pub enum InputMode {
     TaskSelection,
 }

+impl std::fmt::Display for InputMode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            InputMode::InputField => write!(f, "Input"),
+            InputMode::TaskSelection => write!(f, "Tasks"),
+        }
+    }
+}
+
+impl From<InputMode> for crate::utils::agent_chat::mode_indicator::DisplayMode {
+    fn from(mode: InputMode) -> Self {
+        match mode {
+            InputMode::InputField => crate::utils::agent_chat::mode_indicator::DisplayMode::Input,
+            InputMode::TaskSelection => crate::utils::agent_chat::mode_indicator::DisplayMode::TaskSelection,
+        }
+    }
+}

 /// Priority levels for TODO items
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
diff --git a/src/utils/agent_chat/chat_application.rs b/src/utils/agent_chat/chat_application.rs
index a1b2c3d..e8f1a2d 100644
--- a/src/utils/agent_chat/chat_application.rs
+++ b/src/utils/agent_chat/chat_application.rs
@@ -12,6 +12,7 @@ use crate::services::mcp_service::{McpServerConfig, McpService, McpTool};
 use anyhow::{anyhow, Context, Result};
 use crossterm::event::{self, Event, KeyCode, KeyEvent, KeyModifiers};
 use crossterm::terminal;
+use super::mode_indicator::{update_mode_indicator_inline, DisplayMode};
 use log::{debug, error, warn};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -427,9 +428,16 @@ async fn get_enhanced_input_with_status(
     input_state.update_mcp_tools_cache(mcp_tools_cache.to_vec());

     // Clean input prompt - Claude Code style
-    print!("> ");
+    print!("> ");
+
+    // Show mode indicator (right-aligned)
+    let mode: DisplayMode = task_state.input_mode.into();
+    if let Err(e) = update_mode_indicator_inline(mode, false) {
+        debug!("Failed to render mode indicator: {}", e);
+    }
+
     io::stdout()
-        .flush()
+        .flush()
         .map_err(|e| anyhow!("Failed to flush stdout: {}", e))?;

     // Enable raw mode for character-by-character input (unless in test/fallback mode)
@@ -536,26 +544,38 @@ async fn get_enhanced_input_with_status(
             InputChar::CtrlT => {
                 // Toggle between input field and task selection
                 task_state.toggle_input_mode();
+
+                // Get new mode for indicator
+                let new_mode: DisplayMode = task_state.input_mode.into();

                 match task_state.input_mode {
                     InputMode::TaskSelection => {
+                        // Clear and show task list
                         clear_suggestions_display();
-                        task_state.current_reasoning =
-                            "Task selection mode active. Use ↑↓ to navigate, Enter to toggle."
-                                .to_string();
-                    }
-                    InputMode::InputField => {
-                        task_state.current_reasoning =
-                            "Input mode active. Type your command or query.".to_string();
+                        print!("\x1B[2J\x1B[1;1H");
+                        show_enhanced_status_bar(task_state);
+                        show_task_details_below_input(task_state);
+
+                        // Show mode indicator
+                        if let Err(e) = update_mode_indicator_inline(new_mode, false) {
+                            debug!("Failed to update mode indicator: {}", e);
+                        }
                     }
+                    InputMode::InputField => {
+                        // Return to input mode
+                        print!("\x1B[2J\x1B[1;1H");
+                        show_enhanced_status_bar(task_state);
+                        print!("> {}", input_state.input);
+
+                        // Update mode indicator
+                        if let Err(e) = update_mode_indicator_inline(new_mode, !input_state.suggestions.is_empty()) {
+                            debug!("Failed to update mode indicator: {}", e);
+                        }
+                    }
                 }

-                // Refresh display
-                print!("\x1B[2J\x1B[1;1H");
-                show_enhanced_status_bar(task_state);
-
-                if task_state.input_mode == InputMode::InputField {
+                // Final positioning
+                if task_state.input_mode == InputMode::InputField {
                     println!(
                         "{}┌─ Input ──────────────────────────────────────────────┐{}",
                         Colors::GREEN,
@@ -574,7 +594,13 @@ async fn get_enhanced_input_with_status(
             InputChar::Escape => {
                 if task_state.input_mode == InputMode::TaskSelection {
                     // Cancel task selection and return to input mode
-                    task_state.input_mode = InputMode::InputField;
+                    task_state.input_mode = InputMode::InputField;
+                    let new_mode: DisplayMode = task_state.input_mode.into();
+
                     task_state.current_reasoning =
                         "Cancelled task selection. Returned to input mode.".to_string();

@@ -592,6 +618,11 @@ async fn get_enhanced_input_with_status(
                         Colors::RESET,
                         input_state.input
                     );
+
+                    // Update mode indicator
+                    if let Err(e) = update_mode_indicator_inline(new_mode, !input_state.suggestions.is_empty()) {
+                        debug!("Failed to update mode indicator: {}", e);
+                    }
+
                     io::stdout()
                         .flush()
                         .map_err(|e| anyhow!("Failed to flush stdout: {}", e))?;
@@ -608,11 +639,19 @@ async fn get_enhanced_input_with_status(
                         input_state.suggestions_suppressed = true;
                         input_state.sug_win_start = 0;

-                        clear_suggestions_display();
+                        clear_suggestions_display();
+
+                        // Update indicator (suggestions now hidden)
+                        let mode: DisplayMode = task_state.input_mode.into();
+                        if let Err(e) = update_mode_indicator_inline(mode, false) {
+                            debug!("Failed to update mode indicator: {}", e);
+                        }
+
                         redraw_input_line(&input_state.input)?;
                     } else {
                         // No suggestions visible - clear input as before
-                        input_state.clear();
+                        input_state.clear();
+
                         clear_suggestions_display();
                         redraw_input_line(&input_state.input)?;
                     }
@@ -627,12 +666,25 @@ async fn get_enhanced_input_with_status(
             InputChar::Arrow(arrow_key) => match task_state.input_mode {
                 InputMode::InputField => {
                     handle_arrow_key(&mut input_state, arrow_key).await?;
+
+                    // Update indicator if suggestions visibility changed
+                    let mode: DisplayMode = task_state.input_mode.into();
+                    if let Err(e) = update_mode_indicator_inline(mode, !input_state.suggestions.is_empty()) {
+                        debug!("Failed to update mode indicator: {}", e);
+                    }
                 }
                 InputMode::TaskSelection => match arrow_key {
                     ArrowKey::Up => {
                         task_state.navigate_todo_up();
                         if let Some(selected_task) = task_state.get_selected_task_details() {
                             task_state.current_reasoning = selected_task.reasoning.clone();
+                        }
+
+                        // Redraw with mode indicator
+                        let mode: DisplayMode = task_state.input_mode.into();
+                        if let Err(e) = update_mode_indicator_inline(mode, false) {
+                            debug!("Failed to update mode indicator: {}", e);
                         }
                         print!("\x1B[2J\x1B[1;1H");
                         show_enhanced_status_bar(task_state);
@@ -653,10 +705,19 @@ async fn get_enhanced_input_with_status(
             },
             InputChar::Regular(ch) => {
                 if task_state.input_mode == InputMode::InputField {
-                    handle_regular_character(&mut input_state, ch, suggestion_tx).await?;
+                    handle_regular_character(&mut input_state, ch, suggestion_tx).await?;
+
+                    // Update indicator based on suggestions
+                    let mode: DisplayMode = task_state.input_mode.into();
+                    if let Err(e) = update_mode_indicator_inline(mode, !input_state.suggestions.is_empty()) {
+                        debug!("Failed to update mode indicator: {}", e);
+                    }

                     // Update reasoning based on input
-                    if input_state.input.len() > 0 {
+                    if !input_state.input.is_empty() {
                         task_state.current_reasoning =
                             format!("User typing: '{}'", input_state.input);
                     }