Polish TUI: throttle markdown, surface cache and tier costs, preserve draft

Author: alexylon

CHANGELOG.md

@@ -6,10 +6,22 @@ All notable changes to Sofos are documented in this file.
 
 ### Added
 
+- **The cache numbers now appear in the status line.** When either cache-read or cache-creation tokens are non-zero, the status row shows `cache: 1234r 56w` alongside the input/output totals so users can see their prompt-cache hit rate without quitting to view the session summary.
+- **The input box title line shows a `… +N more` hint when the draft overflows the visible area.** A long paste or multi-line draft that exceeds the input box height previously had no on-screen indication that more content existed below the visible window; the cap is now surfaced as part of the title.
 - **`Ctrl+W` and `Ctrl+K` are now bound in the input box.** `Ctrl+W` deletes the word behind the cursor (the readline / bash / zsh / fish binding) and `Ctrl+K` deletes from the cursor to the end of the line. `Ctrl+U` (delete to start of line) is unchanged.
 
 ### Fixed
 
+- **Long assistant turns render fluidly again.** The streaming markdown renderer used to re-render the whole accumulated buffer on every new line — quadratic in the length of the reply, which on a 50 KB stream was noticeably laggy. Replies under 16 KB stream per line as before; longer replies batch the work into 1 KB chunks so the total cost stays linear.
+- **Editing past a slash-popup dismissal stays dismissed.** Pressing Esc on `/clear` and then backspacing one character (or adding a typo fix) used to immediately re-open the popup; the dismissal now sticks while the textarea is still in the same `/command` edit family and only clears when the user switches to an unrelated command.
+- **A live draft is preserved while scrolling through input history.** Alt+Up used to discard whatever you had typed when stepping into older prompts; sofos now snapshots the draft on the first Alt+Up and restores it when Alt+Down walks past the newest entry.
+- **The session summary now surfaces the premium-tier crossover.** Crossing the GPT-5.5 / GPT-5.4 input-token threshold doubles the rate for every later turn in the session; the cost summary now prints a dimmed `(premium tier: peak input X exceeded Y threshold)` line below the estimated cost so users can see why the bill is what it is.
+- **A fully-cached session prints a summary instead of nothing.** The early-return that suppressed the post-session table when both fresh-input and output were zero ignored cache reads — a short prompt that re-hit cache used to look like zero usage. Sessions with any cache-read activity now print the usual summary.
+- **A late settlement of Anthropic cache usage in the streaming response is no longer hidden.** The renderer used to surface `cache: 0r 0w` for these turns; the trailing `message_delta` event now refreshes both totals when it carries them so the status row matches the cost summary.
+- **CommonMark `~~~` fences are recognised in streaming commits.** A partial `~~~` fence at a newline boundary used to allow a premature commit on the unclosed code block, which then needed the same fence type to close it; sofos now treats `~~~` like ```` ``` ```` for the commit-safety check.
+- **`Ctrl+C` after `WorkerBusy` is reliably routed to the in-flight job.** The worker used to clear the interrupt flag before announcing it was busy, so a Ctrl+C that landed in the tiny race window slipped through to the shutdown path. Sofos now sends `WorkerBusy` first and clears the flag second, eliminating the race.
+- **A panicking worker no longer prints a zeroed session summary.** The shutdown path now carries an explicit `panicked` flag so the goodbye line is preceded by a "Session ended unexpectedly" warning instead of pretending the run finished cleanly with no usage at all.
+
 - **`Ctrl+C` while the slash-command popup is open dismisses the popup.** It used to fall through to the outer handler and quit the session, which surprised users who only wanted to bail out of the suggestion list. Ctrl+C with the popup closed still requests shutdown.
 - **The cursor shape now follows the active mode after `/safe` and `/normal`.** Toggling safe mode mid-session previously updated the status line but left the cursor in its old shape; the cursor now switches to the safe-mode underscore on `/safe` and back to the default block on `/normal`, matching the startup behaviour.
 - **A panic anywhere inside the TUI now restores the terminal before the backtrace prints.** A process-wide panic hook disables raw mode, disables bracketed paste, pops the keyboard enhancement flags, and shows the cursor through a real-tty handle that bypasses the output-capture pipe — so even a panic that strikes before the local Drop chain runs leaves the user with a usable shell.

src/repl/mod.rs

@@ -297,6 +297,8 @@ impl Repl {
             reasoning,
             input_tokens: self.session_state.total_input_tokens,
             output_tokens: self.session_state.total_output_tokens,
+            cache_read_tokens: self.session_state.total_cache_read_tokens,
+            cache_creation_tokens: self.session_state.total_cache_creation_tokens,
         }
     }
 
@@ -347,6 +349,7 @@ impl Repl {
             cache_read_tokens: self.session_state.total_cache_read_tokens,
             cache_creation_tokens: self.session_state.total_cache_creation_tokens,
             peak_single_turn_input_tokens: self.session_state.peak_single_turn_input_tokens,
+            panicked: false,
         }
     }
 

src/repl/tui/app.rs

@@ -68,6 +68,11 @@ pub struct App {
     /// `Alt+Up` / `Alt+Down` history navigation. Capped at
     /// [`INPUT_HISTORY_CAP`]; the oldest entries are dropped once full.
     pub input_history: VecDeque<String>,
+    /// Live draft saved when the user first presses Alt+Up to enter
+    /// history. Restored when `history_next` walks past the newest
+    /// entry, so a typed-but-unsent draft isn't silently erased when
+    /// the user wanted to scroll through prior prompts.
+    pub history_draft: Option<String>,
     /// Current position in the history ring while navigating.
     /// `None` means the textarea holds the user's live draft (not a
     /// historical entry).
@@ -206,6 +211,7 @@ impl App {
             confirmation: None,
             pasted_images: Vec::new(),
             input_history: VecDeque::new(),
+            history_draft: None,
             history_cursor: None,
             slash_popup: SlashPopup::new(),
         }
@@ -249,14 +255,19 @@ impl App {
 
     /// Move one step backward (older) through input history and load the
     /// resulting entry into the textarea. No-op when the history is
-    /// empty. When currently showing the live draft, snapshot... no — we
-    /// deliberately don't snapshot the live draft; going forward past the
-    /// newest entry restores an empty textarea, matching reedline's
-    /// default behaviour.
+    /// empty. Snapshots the in-progress draft on the first press so a
+    /// later `history_next` past the newest entry can put it back.
     pub fn history_prev(&mut self) {
         if self.input_history.is_empty() {
             return;
         }
+        // First step into history captures the live draft so we can
+        // restore it on the way out. Subsequent steps don't overwrite
+        // it — moving between two history entries doesn't change the
+        // original draft.
+        if self.history_cursor.is_none() {
+            self.history_draft = Some(self.input_text());
+        }
         let next = match self.history_cursor {
             None => self.input_history.len() - 1,
             Some(0) => 0,
@@ -267,15 +278,20 @@ impl App {
     }
 
     /// Move one step forward (newer) through input history. When stepping
-    /// past the newest entry, clears the textarea back to the live-draft
-    /// state (`history_cursor = None`).
+    /// past the newest entry, restores the live draft captured by
+    /// `history_prev`, falling back to an empty textarea when no draft
+    /// was saved.
     pub fn history_next(&mut self) {
         let Some(cursor) = self.history_cursor else {
             return;
         };
         if cursor + 1 >= self.input_history.len() {
             self.history_cursor = None;
+            let draft = self.history_draft.take().unwrap_or_default();
             self.clear_input();
+            if !draft.is_empty() {
+                self.textarea.insert_str(draft);
+            }
             return;
         }
         let next = cursor + 1;
@@ -497,6 +513,8 @@ mod tests {
             reasoning: String::new(),
             input_tokens: 0,
             output_tokens: 0,
+            cache_read_tokens: 0,
+            cache_creation_tokens: 0,
         });
         assert!(a.is_safe_mode());
         a.status.as_mut().unwrap().mode = Mode::Normal;
@@ -740,6 +758,8 @@ mod tests {
             reasoning: "thinking: 10000 tok".into(),
             input_tokens: 123,
             output_tokens: 456,
+            cache_read_tokens: 0,
+            cache_creation_tokens: 0,
         });
         let s = a.status.as_ref().unwrap();
         assert_eq!(s.mode.label(), "safe");

src/repl/tui/event.rs

@@ -19,6 +19,11 @@ pub struct ExitSummary {
     /// pricing cliffs (e.g. gpt-5.4/5.5 at 272K) so the displayed
     /// session cost reflects the rate the provider actually billed.
     pub peak_single_turn_input_tokens: u32,
+    /// True when the worker exits because it panicked rather than via
+    /// the normal shutdown path. Lets the UI prefix the goodbye line
+    /// with a "Session ended unexpectedly" notice instead of pretending
+    /// the run finished cleanly with zeroed totals.
+    pub panicked: bool,
 }
 
 /// Tool access mode shown in the status line.
@@ -48,6 +53,12 @@ pub struct StatusSnapshot {
     pub reasoning: String,
     pub input_tokens: u32,
     pub output_tokens: u32,
+    /// Cumulative cache-read tokens for the session — exposed in the
+    /// status line so users can see their prompt-cache hit rate
+    /// without quitting to view the session summary.
+    pub cache_read_tokens: u32,
+    /// Cumulative cache-creation tokens billed at the premium rate.
+    pub cache_creation_tokens: u32,
 }
 
 /// Which standard stream a captured line came from.

src/repl/tui/mod.rs

@@ -342,6 +342,15 @@ pub fn run(mut repl: Repl) -> Result<()> {
     colored::control::unset_override();
 
     if let Some(summary) = app.exit_summary.take() {
+        if summary.panicked {
+            // The worker exited via panic rather than the normal
+            // shutdown path. The counts in `summary` are zeroed
+            // placeholders from `ShutdownSender::send_now`, so the
+            // session-summary table would be misleading; surface the
+            // explicit notice and skip straight to the goodbye line.
+            println!();
+            UI::print_warning("Session ended unexpectedly. See backtrace above for details.");
+        }
         let summary_printed = UI::display_session_summary(
             &summary.model,
             summary.input_tokens,

src/repl/tui/slash_popup.rs

@@ -103,13 +103,16 @@ impl SlashPopup {
     /// Show the popup whenever the first line still looks like a partially
     /// typed slash command; hide it otherwise.
     pub fn sync(&mut self, input: &str) {
-        // Honour a prior `dismiss` until the input changes.
-        if self
-            .dismissed_for
-            .as_deref()
-            .is_some_and(|prev| prev == input)
-        {
-            return;
+        // Honour a prior `dismiss` while the user is editing within the
+        // same slash-command "family" — either the current input still
+        // begins with the dismissed text (kept typing) or the dismissed
+        // text begins with the current input (backspaced). Switching
+        // to an unrelated command (e.g. dismiss `/clear`, then type
+        // `/list`) breaks both prefix tests and re-opens the popup.
+        if let Some(prev) = self.dismissed_for.as_deref() {
+            if prev == input || input.starts_with(prev) || prev.starts_with(input) {
+                return;
+            }
         }
         self.dismissed_for = None;
 
@@ -324,8 +327,21 @@ mod tests {
         popup.sync("/c");
         assert!(!popup.is_visible());
 
-        // Typing another character clears the dismissal.
+        // Typing more inside the same prefix family keeps the dismissal
+        // — the user is still editing the same slash-command attempt,
+        // and a small typo fix shouldn't reopen the suggestion list.
         popup.sync("/cl");
+        assert!(!popup.is_visible());
+
+        // Backspacing into a shared prefix likewise keeps the dismissal.
+        popup.sync("/");
+        assert!(!popup.is_visible());
+
+        // Switching to a clearly different slash-command attempt
+        // re-opens the popup: neither input is a prefix of the
+        // dismissed text (`/r` is a real prefix in the catalog —
+        // `/resume`).
+        popup.sync("/r");
         assert!(popup.is_visible());
     }
 }

src/repl/tui/ui.rs

@@ -171,14 +171,30 @@ fn draw_input(frame: &mut Frame, area: Rect, app: &App) {
 
     let safe = app.is_safe_mode();
     let prompt_glyph = if safe { " : " } else { " > " };
-    let title = Line::from(vec![Span::styled(
+    let content_width = area.width.saturating_sub(2);
+
+    let mut textarea = app.textarea.clone();
+    let measure = textarea.measure(content_width);
+    let overflow_rows = measure.content_rows.saturating_sub(MAX_INPUT_CONTENT_ROWS);
+
+    let mut title_spans = vec![Span::styled(
         prompt_glyph,
         Style::default()
             .fg(if safe { Color::Yellow } else { TITLE_FG })
             .add_modifier(Modifier::BOLD),
-    )]);
+    )];
+    if overflow_rows > 0 {
+        // Long paste / long draft: the textarea is showing only the
+        // first `MAX_INPUT_CONTENT_ROWS` rows. Surface the cap in the
+        // title line so the user knows their input continues below the
+        // visible window.
+        title_spans.push(Span::styled(
+            format!(" … +{} more ", overflow_rows),
+            Style::default().fg(Color::DarkGray),
+        ));
+    }
+    let title = Line::from(title_spans);
 
-    let mut textarea = app.textarea.clone();
     textarea.set_block(
         Block::default()
             .borders(Borders::ALL)
@@ -301,15 +317,25 @@ fn draw_hint(frame: &mut Frame, area: Rect, app: &App) {
 fn draw_status(frame: &mut Frame, area: Rect, app: &App) {
     // Fall back to the model name we already know if the worker hasn't
     // pushed a full snapshot yet (e.g. very first frame).
-    let (model, mode, reasoning, in_tok, out_tok) = match &app.status {
+    let (model, mode, reasoning, in_tok, out_tok, cache_read, cache_create) = match &app.status {
         Some(s) => (
             s.model.as_str(),
             s.mode,
             s.reasoning.as_str(),
             s.input_tokens,
             s.output_tokens,
+            s.cache_read_tokens,
+            s.cache_creation_tokens,
+        ),
+        None => (
+            app.model_label.as_str(),
+            Mode::Normal,
+            "",
+            0u32,
+            0u32,
+            0u32,
+            0u32,
         ),
-        None => (app.model_label.as_str(), Mode::Normal, "", 0u32, 0u32),
     };
 
     let mode_style = match mode {
@@ -342,6 +368,18 @@ fn draw_status(frame: &mut Frame, area: Rect, app: &App) {
         ));
     }
 
+    // Surface the cache numbers when either side has a non-zero
+    // total. The cache-read percentage is the cheapest cost lever
+    // the user has and they otherwise can't see it without
+    // dropping out of the session.
+    if cache_read > 0 || cache_create > 0 {
+        spans.push(Span::styled(SEP, Style::default().fg(Color::DarkGray)));
+        spans.push(Span::styled(
+            format!("cache: {}r {}w", cache_read, cache_create),
+            Style::default().fg(MODEL_FG),
+        ));
+    }
+
     frame.render_widget(Paragraph::new(Line::from(spans)), area);
 }
 

src/repl/tui/worker.rs

@@ -75,13 +75,18 @@ impl<'a> ShutdownSender<'a> {
         if self.sent {
             return;
         }
+        // Reaching `send_now` without an installed summary means the
+        // worker is panicking on the way out — set `panicked: true`
+        // so the UI can prefix the goodbye line instead of pretending
+        // a fully zeroed normal exit.
         let summary = self.summary.take().unwrap_or(ExitSummary {
             model: String::new(),
             input_tokens: 0,
             output_tokens: 0,
             cache_read_tokens: 0,
             cache_creation_tokens: 0,
             peak_single_turn_input_tokens: 0,
+            panicked: true,
         });
         let _ = self.ui_tx.send(UiEvent::WorkerShutdown(summary));
         self.sent = true;
@@ -107,8 +112,15 @@ fn run(
         match job {
             Job::Shutdown => break,
             Job::Message { text, images } => {
-                interrupt.store(false, Ordering::SeqCst);
+                // Notify the UI we're busy BEFORE clearing the
+                // interrupt flag. Otherwise a Ctrl+C that lands in
+                // the window between the two falls through to
+                // `request_shutdown` (the bare-press handler in
+                // `input.rs`) instead of interrupting the upcoming
+                // turn — `app.busy()` is still false because
+                // `WorkerBusy` hasn't been delivered yet.
                 let _ = ui_tx.send(UiEvent::WorkerBusy("processing".into()));
+                interrupt.store(false, Ordering::SeqCst);
                 if let Err(e) = repl.process_message(&text, images) {
                     if !matches!(e, crate::error::SofosError::Interrupted) {
                         if e.is_blocked() {

src/ui/cost.rs

@@ -38,7 +38,13 @@ impl UI {
         total_cache_creation_tokens: u32,
         peak_single_turn_input_tokens: u32,
     ) -> bool {
-        if total_input_tokens == 0 && total_output_tokens == 0 {
+        // A fully-cached session has `total_input_tokens == 0` and
+        // `total_output_tokens == 0` because the new-input field
+        // doesn't include cache reads. Without the cache-read clause
+        // a session that only re-hit cache would print no summary at
+        // all, which looks like a bug to users running short
+        // exploratory prompts.
+        if total_input_tokens == 0 && total_output_tokens == 0 && total_cache_read_tokens == 0 {
             return false;
         }
 
@@ -102,6 +108,26 @@ impl UI {
             format!("${:.4}", estimated_cost).bright_yellow().bold()
         );
 
+        // Surface the per-prompt cliff when premium pricing kicked in
+        // — users otherwise have no way to tell that crossing the
+        // GPT-5.5 / GPT-5.4 input-token threshold doubled the rate
+        // for every later turn in this session.
+        let info = crate::api::model_info::lookup(model);
+        if let Some(tier) = info.premium_tier {
+            if peak_single_turn_input_tokens > tier.input_threshold {
+                println!(
+                    "{:<20} {}",
+                    "".bright_white(),
+                    format!(
+                        "(premium tier: peak input {} exceeded {} threshold)",
+                        Self::format_number(peak_single_turn_input_tokens),
+                        Self::format_number(tier.input_threshold)
+                    )
+                    .dimmed()
+                );
+            }
+        }
+
         println!("{}", "─".repeat(50).bright_cyan());
         println!();
         true