feat(history): delete a played song with d + [y]/[n] confirm

Add a keyboard shortcut to remove a row from the played-songs history,
in both the landing browser and the in-playback `p` overlay. Press `d`
to arm, then a centered [y]/[n] modal confirms before deleting from the
SQLite history DB.

The confirmation is a `pending_delete` state flag on HistoryPanelState
rather than a blocking prompt, so the playback overlay keeps ticking the
visualizer, audio, and media-key events underneath. Routing sends `y`
to confirm and any other key to cancel, so a stray keypress can never
delete. Reuses the existing Storage::delete_by_replay_target.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: program247365

src/play_loop.rs

@@ -107,6 +107,7 @@ fn browse_history_session(
         selected: 0,
         sort_field: HistorySortField::TimePlayed,
         descending: true,
+        pending_delete: false,
     };
     refresh_history_panel(&mut panel, &storage)?;
 
@@ -148,6 +149,25 @@ fn browse_history_session(
                             refresh_history_panel(&mut panel, &storage)?;
                         }
                     }
+                    KeyCommand::HistoryDelete => {
+                        if !panel.rows.is_empty() {
+                            panel.pending_delete = true;
+                        }
+                    }
+                    KeyCommand::HistoryDeleteConfirm => {
+                        if let Some(row) = panel.rows.get(panel.selected) {
+                            let replay_target = row.replay_target.clone();
+                            storage
+                                .lock()
+                                .unwrap()
+                                .delete_by_replay_target(&replay_target)?;
+                        }
+                        panel.pending_delete = false;
+                        refresh_history_panel(&mut panel, &storage)?;
+                    }
+                    KeyCommand::HistoryDeleteCancel => {
+                        panel.pending_delete = false;
+                    }
                     KeyCommand::HistoryReplay => {
                         if let Some(row) = panel.rows.get(panel.selected) {
                             let target = row.replay_target.clone();
@@ -676,6 +696,37 @@ fn dispatch_command(
             *needs_render = true;
             Ok(None)
         }
+        KeyCommand::HistoryDelete => {
+            if let Some(panel) = state.history_panel.as_mut() {
+                if !panel.rows.is_empty() {
+                    panel.pending_delete = true;
+                    *needs_render = true;
+                }
+            }
+            Ok(None)
+        }
+        KeyCommand::HistoryDeleteConfirm => {
+            if let Some(panel) = state.history_panel.as_mut() {
+                if let Some(row) = panel.rows.get(panel.selected) {
+                    let replay_target = row.replay_target.clone();
+                    storage
+                        .lock()
+                        .unwrap()
+                        .delete_by_replay_target(&replay_target)?;
+                }
+                panel.pending_delete = false;
+                refresh_history_panel(panel, storage)?;
+                *needs_render = true;
+            }
+            Ok(None)
+        }
+        KeyCommand::HistoryDeleteCancel => {
+            if let Some(panel) = state.history_panel.as_mut() {
+                panel.pending_delete = false;
+                *needs_render = true;
+            }
+            Ok(None)
+        }
         KeyCommand::None => Ok(None),
     }
 }
@@ -813,10 +864,19 @@ pub(crate) enum KeyCommand {
     HistoryReverse,
     HistoryReplay,
     HistoryToggleFavorite,
+    HistoryDelete,
+    HistoryDeleteConfirm,
+    HistoryDeleteCancel,
 }
 
 fn handle_key_event(key: KeyEvent, state: &AppState) -> KeyCommand {
-    if state.history_panel.is_some() {
+    if let Some(panel) = &state.history_panel {
+        if panel.pending_delete {
+            return match key.code {
+                KeyCode::Char('y') | KeyCode::Char('Y') => KeyCommand::HistoryDeleteConfirm,
+                _ => KeyCommand::HistoryDeleteCancel,
+            };
+        }
         match (key.code, key.modifiers) {
             (KeyCode::Esc, _) | (KeyCode::Char('p'), _) => KeyCommand::ToggleHistory,
             (KeyCode::Char('j'), _) => KeyCommand::HistoryNext,
@@ -825,6 +885,7 @@ fn handle_key_event(key: KeyEvent, state: &AppState) -> KeyCommand {
             (KeyCode::Char('h'), _) => KeyCommand::HistorySortPrev,
             (KeyCode::Char('r'), _) => KeyCommand::HistoryReverse,
             (KeyCode::Char('s'), _) => KeyCommand::HistoryToggleFavorite,
+            (KeyCode::Char('d'), _) if !panel.rows.is_empty() => KeyCommand::HistoryDelete,
             (KeyCode::Enter, _) => KeyCommand::HistoryReplay,
             (KeyCode::Char('q'), _) | (KeyCode::Char('c'), KeyModifiers::CONTROL) => {
                 KeyCommand::Quit
@@ -853,13 +914,20 @@ fn handle_key_event(key: KeyEvent, state: &AppState) -> KeyCommand {
 }
 
 fn handle_history_browser_key_event(key: KeyEvent, panel: &HistoryPanelState) -> KeyCommand {
+    if panel.pending_delete {
+        return match key.code {
+            KeyCode::Char('y') | KeyCode::Char('Y') => KeyCommand::HistoryDeleteConfirm,
+            _ => KeyCommand::HistoryDeleteCancel,
+        };
+    }
     match (key.code, key.modifiers) {
         (KeyCode::Char('j'), _) => KeyCommand::HistoryNext,
         (KeyCode::Char('k'), _) => KeyCommand::HistoryPrev,
         (KeyCode::Char('l'), _) => KeyCommand::HistorySortNext,
         (KeyCode::Char('h'), _) => KeyCommand::HistorySortPrev,
         (KeyCode::Char('r'), _) => KeyCommand::HistoryReverse,
         (KeyCode::Char('s'), _) if !panel.rows.is_empty() => KeyCommand::HistoryToggleFavorite,
+        (KeyCode::Char('d'), _) if !panel.rows.is_empty() => KeyCommand::HistoryDelete,
         (KeyCode::Enter, _) if !panel.rows.is_empty() => KeyCommand::HistoryReplay,
         (KeyCode::Char('q'), _) | (KeyCode::Char('c'), KeyModifiers::CONTROL) => KeyCommand::Quit,
         _ => KeyCommand::None,
@@ -877,6 +945,7 @@ fn toggle_history_panel(state: &mut AppState, storage: &SharedStorage) -> Result
         selected: 0,
         sort_field: HistorySortField::TimePlayed,
         descending: true,
+        pending_delete: false,
     };
     refresh_history_panel(&mut panel, storage)?;
     state.history_panel = Some(panel);
@@ -1767,6 +1836,7 @@ mod tests {
             selected: 0,
             sort_field: HistorySortField::TimePlayed,
             descending: true,
+            pending_delete: false,
         });
 
         assert_eq!(
@@ -1825,6 +1895,7 @@ mod tests {
             selected: 0,
             sort_field: HistorySortField::TimePlayed,
             descending: true,
+            pending_delete: false,
         };
 
         assert_eq!(
@@ -1850,6 +1921,7 @@ mod tests {
             selected: 0,
             sort_field: HistorySortField::TimePlayed,
             descending: true,
+            pending_delete: false,
         };
 
         assert_eq!(
@@ -1860,4 +1932,82 @@ mod tests {
             KeyCommand::None
         );
     }
+
+    fn panel_with_one_row(pending_delete: bool) -> HistoryPanelState {
+        HistoryPanelState {
+            rows: vec![HistoryRow {
+                track_key: "a".into(),
+                replay_target: "a".into(),
+                title: "A".into(),
+                platform: "Local".into(),
+                is_favorite: false,
+                play_count: 1,
+                total_play_seconds: 10,
+                first_played_at: 0,
+                last_played_at: 0,
+                last_played_computer: String::new(),
+            }],
+            selected: 0,
+            sort_field: HistorySortField::TimePlayed,
+            descending: true,
+            pending_delete,
+        }
+    }
+
+    #[test]
+    fn history_browser_arms_delete_with_d() {
+        let panel = panel_with_one_row(false);
+        assert_eq!(
+            handle_history_browser_key_event(
+                KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE),
+                &panel
+            ),
+            KeyCommand::HistoryDelete
+        );
+    }
+
+    #[test]
+    fn history_browser_ignores_delete_when_empty() {
+        let panel = HistoryPanelState {
+            rows: Vec::new(),
+            selected: 0,
+            sort_field: HistorySortField::TimePlayed,
+            descending: true,
+            pending_delete: false,
+        };
+        assert_eq!(
+            handle_history_browser_key_event(
+                KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE),
+                &panel
+            ),
+            KeyCommand::None
+        );
+    }
+
+    #[test]
+    fn pending_delete_routes_y_to_confirm_and_other_to_cancel() {
+        let panel = panel_with_one_row(true);
+        assert_eq!(
+            handle_history_browser_key_event(
+                KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE),
+                &panel
+            ),
+            KeyCommand::HistoryDeleteConfirm
+        );
+        // Any non-`y` key cancels — including keys that normally do something.
+        assert_eq!(
+            handle_history_browser_key_event(
+                KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE),
+                &panel
+            ),
+            KeyCommand::HistoryDeleteCancel
+        );
+        assert_eq!(
+            handle_history_browser_key_event(
+                KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE),
+                &panel
+            ),
+            KeyCommand::HistoryDeleteCancel
+        );
+    }
 }

src/tui.rs

@@ -75,6 +75,8 @@ pub struct HistoryPanelState {
     pub selected: usize,
     pub sort_field: HistorySortField,
     pub descending: bool,
+    /// When true, the selected row is awaiting a delete confirmation ([y]/[n]).
+    pub pending_delete: bool,
 }
 
 #[derive(Clone)]
@@ -1231,9 +1233,9 @@ fn draw_history_table(
         if panel.descending { "↓" } else { "↑" }
     );
     let controls = if area == frame.area() {
-        "  •  j/k move  h/l sort  r reverse  s star  enter replay  q quit"
+        "  •  j/k move  h/l sort  r reverse  s star  d delete  enter replay  q quit"
     } else {
-        "  •  j/k move  h/l sort  r reverse  s star  enter replay  p/esc close"
+        "  •  j/k move  h/l sort  r reverse  s star  d delete  enter replay  p/esc close"
     };
     let header = vec![Line::from(vec![
         Span::styled(
@@ -1322,6 +1324,68 @@ fn draw_history_table(
         )])]),
         chunks[2],
     );
+
+    if panel.pending_delete {
+        if let Some(row) = panel.rows.get(panel.selected) {
+            draw_delete_confirm(frame, area, &row.title);
+        }
+    }
+}
+
+/// Renders the delete-confirmation modal centered over the history panel. The
+/// caller arms this via `HistoryPanelState::pending_delete`; `y` confirms and
+/// any other key cancels (handled in the key router, not here).
+fn draw_delete_confirm(frame: &mut ratatui::Frame, area: ratatui::layout::Rect, title: &str) {
+    let modal = centered_area(area, 60, 9);
+    frame.render_widget(Clear, modal);
+    let truncated = truncate_str(title, 54);
+    let lines = vec![
+        Line::from(vec![Span::styled(
+            "Remove this track from your history?",
+            Style::default()
+                .fg(Color::Rgb(255, 180, 80))
+                .add_modifier(Modifier::BOLD),
+        )]),
+        Line::from(""),
+        Line::from(vec![Span::styled(
+            truncated,
+            Style::default()
+                .fg(Color::Rgb(230, 230, 240))
+                .add_modifier(Modifier::BOLD),
+        )]),
+        Line::from(""),
+        Line::from(vec![
+            Span::styled(
+                "[y]",
+                Style::default()
+                    .fg(Color::Rgb(255, 120, 100))
+                    .add_modifier(Modifier::BOLD),
+            ),
+            Span::styled(" delete    ", Style::default().fg(Color::Rgb(150, 150, 170))),
+            Span::styled(
+                "[n]",
+                Style::default()
+                    .fg(Color::Rgb(120, 200, 140))
+                    .add_modifier(Modifier::BOLD),
+            ),
+            Span::styled(" keep", Style::default().fg(Color::Rgb(150, 150, 170))),
+        ]),
+    ];
+    let block = Block::default()
+        .borders(Borders::ALL)
+        .title(" confirm delete ")
+        .style(Style::default().fg(Color::Rgb(170, 90, 90)));
+    frame.render_widget(Paragraph::new(lines).block(block), modal);
+}
+
+/// Truncates a string to `max` characters, appending an ellipsis when cut.
+fn truncate_str(s: &str, max: usize) -> String {
+    if s.chars().count() <= max {
+        s.to_string()
+    } else {
+        let kept: String = s.chars().take(max.saturating_sub(1)).collect();
+        format!("{kept}…")
+    }
 }
 
 fn centered_rect(
@@ -1429,6 +1493,7 @@ mod tests {
             selected: 0,
             sort_field: HistorySortField::TimePlayed,
             descending: true,
+            pending_delete: false,
         };
         let warning = sample_warning();
         terminal