fix(tui): P0 TUI fixes — Ctrl+C, spinner timing, buttons, welcome

P0-1: Ctrl+C double-press to exit (CC-aligned)
  - Single Ctrl+C: interrupts current operation, shows [interrupted]
  - Double Ctrl+C within 500ms: actually exits
  - Ctrl+D: same double-press behavior

P0-4: Spinner shows elapsed time and token count
  - Format: "⠋ Cogitating… (12s · 3.2k tokens)"
  - Tracks started_at and response_tokens per spinner session
  - Token count estimated from ContentDelta character length

P0-5: UI text and visual fixes
  - Permission buttons: Yes/No → Allow/Deny/Always Allow
  - Welcome message on startup: "Welcome! Type a message..."
  - Turn separators: ❯ prompt echo + ──── divider between turns
  - Blank line after assistant response for visual breathing room

Author: lingcoder

crates/tui/src/app.rs

@@ -161,6 +161,8 @@ pub struct App {
     unseen_message_count: usize,
     /// Current prompt input mode.
     pub input_mode: PromptInputMode,
+    /// Timestamp of last Ctrl+C press for double-press detection.
+    last_interrupt: Option<Instant>,
 }
 
 impl App {
@@ -171,7 +173,8 @@ impl App {
             state: AppState::Idle,
             input: InputBox::new(),
             spinner: Spinner::new(),
-            content_buffer: String::new(),
+            content_buffer: "Welcome! Type a message to start, or /help for commands.\n\n"
+                .to_string(),
             model_name: model_name.into(),
             permission_dialog: None,
             should_quit: false,
@@ -195,6 +198,7 @@ impl App {
             scroll_anchor: None,
             unseen_message_count: 0,
             input_mode: PromptInputMode::Prompt,
+            last_interrupt: None,
         }
     }
 
@@ -286,8 +290,24 @@ impl App {
         if let Some(action) = self.keybindings.resolve(key.code, key.modifiers) {
             match action {
                 Action::Quit => {
-                    self.should_quit = true;
-                    return AppAction::Quit;
+                    // CC-aligned double-press: first Ctrl+C interrupts, second exits.
+                    let now = Instant::now();
+                    if let Some(last) = self.last_interrupt
+                        && now.duration_since(last) < Duration::from_millis(500)
+                    {
+                        // Double press within 500ms → actually quit
+                        self.should_quit = true;
+                        return AppAction::Quit;
+                    }
+                    // First press → interrupt current operation
+                    self.last_interrupt = Some(now);
+                    if self.state == AppState::Processing {
+                        self.spinner.stop();
+                        self.state = AppState::Idle;
+                        let _ = writeln!(self.content_buffer, "\n[interrupted]");
+                    }
+                    // Show hint that double-press exits
+                    return AppAction::None;
                 }
                 Action::NewSession if self.state != AppState::Confirming => {
                     return AppAction::NewSession;
@@ -476,6 +496,9 @@ impl App {
                 if key.code == KeyCode::Enter && !key.modifiers.contains(KeyModifiers::SHIFT) {
                     if !self.input.is_empty() {
                         let text = self.input.submit();
+                        // Turn separator: show user prompt then divider
+                        let _ = writeln!(self.content_buffer, "❯ {text}");
+                        let _ = writeln!(self.content_buffer, "────────────────────────────────");
                         self.state = AppState::Processing;
                         self.spinner.start_with_random_verb();
                         return AppAction::Submit(text);
@@ -563,6 +586,8 @@ impl App {
                     self.content_scroll = 0; // auto-scroll on new content
                 }
                 self.content_buffer.push_str(&delta);
+                // Approximate token count for spinner display (~4 chars per token)
+                self.spinner.response_tokens += (delta.len() as u64).div_ceil(4);
             }
             Event::MessageEnd { usage, .. } => {
                 self.spinner.stop();
@@ -571,6 +596,8 @@ impl App {
                 // Accumulate token usage (displayed in status bar, not inline)
                 self.total_input_tokens += usage.input_tokens;
                 self.total_output_tokens += usage.output_tokens;
+                // Turn separator after assistant response
+                let _ = writeln!(self.content_buffer, "\n");
             }
             Event::ToolUseStart { name, .. } => {
                 self.current_tool = Some(name.clone());
@@ -1193,7 +1220,7 @@ mod tests {
         assert_eq!(app.state, AppState::Idle);
         assert!(app.input.is_empty());
         assert!(!app.spinner.is_active());
-        assert!(app.content_buffer.is_empty());
+        assert!(app.content_buffer.contains("Welcome"));
         assert_eq!(app.model_name, "gpt-4o");
         assert!(!app.should_quit);
         assert!(!app.sidebar_visible);
@@ -1233,16 +1260,30 @@ mod tests {
     }
 
     #[test]
-    fn ctrl_c_quits() {
+    fn ctrl_c_single_interrupts() {
         let mut app = App::new("test");
         let action = app.handle_event(ctrl_key('c'));
+        // Single Ctrl+C should interrupt, not quit
+        assert_eq!(action, AppAction::None);
+        assert!(!app.should_quit);
+    }
+
+    #[test]
+    fn ctrl_c_double_quits() {
+        let mut app = App::new("test");
+        // First press: interrupt
+        app.handle_event(ctrl_key('c'));
+        // Second press within 500ms: quit
+        let action = app.handle_event(ctrl_key('c'));
         assert_eq!(action, AppAction::Quit);
         assert!(app.should_quit);
     }
 
     #[test]
     fn ctrl_d_quits() {
         let mut app = App::new("test");
+        // Ctrl+D also goes through Quit action (same double-press logic)
+        app.handle_event(ctrl_key('d'));
         let action = app.handle_event(ctrl_key('d'));
         assert_eq!(action, AppAction::Quit);
     }
@@ -1266,7 +1307,7 @@ mod tests {
             index: 0,
             delta: "world".into(),
         }));
-        assert_eq!(app.content_buffer, "Hello world");
+        assert!(app.content_buffer.ends_with("Hello world"));
         assert_eq!(app.content_scroll, 0); // auto-scrolled
     }
 
@@ -1602,7 +1643,10 @@ mod tests {
         let mut app = App::new("test");
         let kb = Keybindings::defaults();
         app.set_keybindings(kb);
-        // Should not panic
+        // Single Ctrl+C should interrupt (not quit with double-press logic)
+        let action = app.handle_event(ctrl_key('c'));
+        assert_eq!(action, AppAction::None);
+        // Double press should quit
         let action = app.handle_event(ctrl_key('c'));
         assert_eq!(action, AppAction::Quit);
     }

crates/tui/src/components/dialog.rs

@@ -65,9 +65,9 @@ impl PermissionDialog {
             request_id: request_id.into(),
             selected: 0,
             options: vec![
-                ("Yes", PermissionResponse::Allow),
-                ("No", PermissionResponse::Deny),
-                ("Always allow", PermissionResponse::AlwaysAllow),
+                ("Allow", PermissionResponse::Allow),
+                ("Deny", PermissionResponse::Deny),
+                ("Always Allow", PermissionResponse::AlwaysAllow),
             ],
         }
     }

crates/tui/src/components/spinner.rs

@@ -255,6 +255,10 @@ pub struct Spinner {
     active: bool,
     /// Shimmer color (the highlight sliding across text).
     shimmer_color: Color,
+    /// When the spinner started (for elapsed time display).
+    started_at: Option<std::time::Instant>,
+    /// Cumulative response tokens during this spinner session.
+    pub response_tokens: u64,
 }
 
 impl Spinner {
@@ -268,6 +272,8 @@ impl Spinner {
             override_message: None,
             active: false,
             shimmer_color: Color::White,
+            started_at: None,
+            response_tokens: 0,
         }
     }
 
@@ -278,6 +284,8 @@ impl Spinner {
         self.active = true;
         self.frame = 0;
         self.tick = 0;
+        self.started_at = Some(std::time::Instant::now());
+        self.response_tokens = 0;
     }
 
     /// Start the spinner with a specific message (overrides verb).
@@ -286,6 +294,8 @@ impl Spinner {
         self.active = true;
         self.frame = 0;
         self.tick = 0;
+        self.started_at = Some(std::time::Instant::now());
+        self.response_tokens = 0;
     }
 
     /// Stop the spinner.
@@ -307,13 +317,36 @@ impl Spinner {
         self.active
     }
 
-    /// Current display message (verb + "…" or override message).
+    /// Current display message (verb + "…" + timing + tokens).
     #[must_use]
     pub fn message(&self) -> String {
-        if let Some(ref msg) = self.override_message {
+        let base = if let Some(ref msg) = self.override_message {
             msg.clone()
         } else {
             format!("{}…", self.verb)
+        };
+
+        // Append elapsed time and token count like CC: "Verb… (12s · 3.2k tokens)"
+        let mut suffix_parts = Vec::new();
+        if let Some(started) = self.started_at {
+            let elapsed = started.elapsed().as_secs();
+            if elapsed >= 1 {
+                suffix_parts.push(format!("{elapsed}s"));
+            }
+        }
+        if self.response_tokens > 0 {
+            let formatted = if self.response_tokens >= 1000 {
+                format!("{:.1}k", self.response_tokens as f64 / 1000.0)
+            } else {
+                self.response_tokens.to_string()
+            };
+            suffix_parts.push(format!("{formatted} tokens"));
+        }
+
+        if suffix_parts.is_empty() {
+            base
+        } else {
+            format!("{base} ({})", suffix_parts.join(" · "))
         }
     }