@pheem49/mint 1.16.0 → 1.18.0

package/crates/mint-cli/src/interactive/chat_tui/watermark.rs

@@ -0,0 +1,148 @@
+//! 3D rotating medallion watermark for the empty TUI transcript.
+use super::*;
+
+pub(super) const WATERMARK_FRAME_COUNT: u8 = 200;
+pub(super) const WATERMARK_TICK: std::time::Duration = std::time::Duration::from_millis(30);
+pub(super) const WATERMARK_HOLD: std::time::Duration = std::time::Duration::from_secs(1);
+pub(super) const WATERMARK_WIDTH: u16 = 39;
+pub(super) const WATERMARK_HEIGHT: u16 = 17;
+
+pub(super) fn watermark_animation_at(
+    elapsed: std::time::Duration,
+) -> (Option<u8>, Option<std::time::Duration>) {
+    let half_turn_frames = WATERMARK_FRAME_COUNT / 2;
+    let half_turn = WATERMARK_TICK * half_turn_frames as u32;
+    let hold_end = half_turn + WATERMARK_HOLD;
+    let full_turn_end = hold_end + half_turn;
+    // Ease each 3-second half turn into and out of its resting face.
+    let eased_frame = |step: u8| {
+        let progress = step as f32 / half_turn_frames as f32;
+        let eased = (1.0 - (progress * std::f32::consts::PI).cos()) * 0.5;
+        (eased * half_turn_frames as f32).round() as u8
+    };
+    if elapsed < half_turn {
+        let step = (elapsed.as_millis() / WATERMARK_TICK.as_millis()) as u8;
+        (
+            Some(eased_frame(step)),
+            Some(WATERMARK_TICK * (step as u32 + 1)),
+        )
+    } else if elapsed < hold_end {
+        (Some(half_turn_frames), Some(hold_end))
+    } else if elapsed < full_turn_end {
+        let step = ((elapsed - hold_end).as_millis() / WATERMARK_TICK.as_millis()) as u8;
+        (
+            Some((half_turn_frames + eased_frame(step)) % WATERMARK_FRAME_COUNT),
+            Some(hold_end + WATERMARK_TICK * (step as u32 + 1)),
+        )
+    } else {
+        (None, None)
+    }
+}
+
+pub(super) fn mint_m_watermark(frame: Option<u8>, height: usize) -> Text<'static> {
+    const WIDTH: usize = WATERMARK_WIDTH as usize;
+    const DESIGN_HEIGHT: usize = WATERMARK_HEIGHT as usize;
+    #[derive(Clone, Copy)]
+    enum Part {
+        Void,
+        Rim,
+        Band,
+        Orbit,
+        Mark,
+    }
+
+    let height = height.clamp(1, DESIGN_HEIGHT);
+    let angle = frame.unwrap_or(0) as f32 * std::f32::consts::TAU / WATERMARK_FRAME_COUNT as f32;
+    let (sin, cos) = angle.sin_cos();
+    let mut pixels = vec![vec![None::<(f32, Part)>; WIDTH]; height];
+
+    // A dotted medallion with an M on its front and a leaf on its back. The
+    // two faces and the rim share one depth buffer as they turn in 3D.
+    for y in 0..DESIGN_HEIGHT {
+        let world_y = y as f32 - 8.0;
+        let projected_y = y * height.saturating_sub(1) / (DESIGN_HEIGHT - 1);
+        for source_x in 0..WIDTH {
+            let world_x = (source_x as f32 - 19.0) / 2.0;
+            let radius = world_x.hypot(world_y);
+            if radius > 8.15 {
+                continue;
+            }
+
+            let stem = (world_x.abs() - 3.7).abs() < 0.5 && world_y.abs() <= 4.2;
+            let diagonal_y = world_y + 4.2;
+            let diagonal = (-4.2..=2.2).contains(&world_y)
+                && [-3.7 + diagonal_y * 3.7 / 6.4, 3.7 - diagonal_y * 3.7 / 6.4]
+                    .into_iter()
+                    .any(|line_x| (world_x - line_x).abs() < 0.5);
+            let front_mark = stem || diagonal;
+
+            let leaf_x = world_x * 0.8 + world_y * 0.6;
+            let leaf_y = -world_x * 0.6 + world_y * 0.8;
+            let leaf_radius = (leaf_x / 4.2).powi(2) + (leaf_y / 2.5).powi(2);
+            let back_mark =
+                (leaf_radius - 1.0).abs() < 0.22 || (leaf_y.abs() < 0.32 && leaf_x.abs() < 3.8);
+
+            for (z, mark) in [(-1.2, back_mark), (0.0, false), (1.2, front_mark)] {
+                let part = if radius > 7.25 {
+                    Part::Rim
+                } else if radius > 6.2 {
+                    Part::Band
+                } else if mark {
+                    Part::Mark
+                } else if radius > 5.75 && radius < 6.05 && (source_x + y) % 3 != 0 {
+                    Part::Orbit
+                } else {
+                    Part::Void
+                };
+                let projected_x = (19.0 + (world_x * cos + z * sin) * 2.0).round() as isize;
+                if !(0..WIDTH as isize).contains(&projected_x) {
+                    continue;
+                }
+                let depth = -world_x * sin + z * cos;
+                let cell = &mut pixels[projected_y][projected_x as usize];
+                if cell.is_none_or(|(existing_depth, _)| depth > existing_depth) {
+                    *cell = Some((depth, part));
+                }
+            }
+        }
+    }
+
+    let lines = pixels
+        .into_iter()
+        .map(|row| {
+            let spans = row
+                .into_iter()
+                .map(|pixel| match pixel {
+                    Some((_, Part::Void)) | None => Span::raw(" "),
+                    Some((depth, part)) => {
+                        let lit = frame.is_some() && depth > 0.5;
+                        let (glyph, color) = match part {
+                            Part::Mark => (
+                                "⣿",
+                                if lit {
+                                    crate::terminal_theme::ACCENT
+                                } else {
+                                    crate::terminal_theme::WATERMARK_MARK
+                                },
+                            ),
+                            Part::Rim => (
+                                "⠿",
+                                if lit {
+                                    crate::terminal_theme::BLUE
+                                } else {
+                                    crate::terminal_theme::WATERMARK_RIM
+                                },
+                            ),
+                            Part::Band => ("⠿", crate::terminal_theme::WATERMARK_BAND),
+                            Part::Orbit => ("⠂", crate::terminal_theme::WATERMARK_ORBIT),
+                            Part::Void => unreachable!(),
+                        };
+                        Span::styled(glyph, Style::default().fg(color))
+                    }
+                })
+                .collect::<Vec<_>>();
+            Line::from(spans)
+        })
+        .collect::<Vec<_>>();
+    Text::from(lines)
+}

package/crates/mint-cli/src/interactive/command_ui.rs

@@ -36,13 +36,20 @@ impl ChoiceItem {
 }
 
 pub trait CommandUi {
-    fn uses_inline_resume_picker(&self) -> bool {
-        false
-    }
     fn push_notice_str(&mut self, text: &str);
     fn push_command_output_str(&mut self, text: &str);
+    fn push_release_notes(&mut self, notes: &str) {
+        self.push_command_output(notes);
+    }
+    #[allow(dead_code)]
+    fn push_plan(&mut self, plan: &str) {
+        self.push_command_output(plan);
+    }
     fn set_status(&mut self, lines: Vec<String>);
     fn clear_status(&mut self);
+    fn open_thought_viewer(&mut self) -> Result<()> {
+        Ok(())
+    }
     fn prompt_choice(
         &mut self,
         title: &str,
@@ -91,6 +98,9 @@ pub trait CommandUi {
         initial: Option<&str>,
     ) -> Result<Option<String>>;
     fn prompt_confirm(&mut self, question: &str, default: bool) -> Result<bool>;
+    fn prompt_onboard(&mut self, _config: &mut mint_core::MintConfig) -> Result<bool> {
+        Ok(false)
+    }
     fn report_error(&mut self, error: &anyhow::Error);
     fn clear_transcript(&mut self) {}
     fn reload_transcript(&mut self, _chat_id: &str, _workspace: &std::path::Path) {}
@@ -149,6 +159,14 @@ impl CommandUi for FullScreenCommandUi<'_> {
         self.handle.push_command(text);
     }
 
+    fn push_release_notes(&mut self, notes: &str) {
+        self.handle.push_release_notes(notes);
+    }
+
+    fn push_plan(&mut self, plan: &str) {
+        self.handle.push_plan(plan);
+    }
+
     fn set_status(&mut self, lines: Vec<String>) {
         self.handle.set_status(lines);
     }
@@ -226,6 +244,10 @@ impl CommandUi for FullScreenCommandUi<'_> {
         }
     }
 
+    fn prompt_onboard(&mut self, config: &mut mint_core::MintConfig) -> Result<bool> {
+        self.terminal.run_onboard_wizard(config)
+    }
+
     fn report_error(&mut self, error: &anyhow::Error) {
         self.handle.push_notice(format!("Error: {error}"));
     }
@@ -236,6 +258,13 @@ impl CommandUi for FullScreenCommandUi<'_> {
         }
     }
 
+    fn open_thought_viewer(&mut self) -> Result<()> {
+        if let Ok(mut state) = self.state.lock() {
+            state.open_thought_modal();
+        }
+        Ok(())
+    }
+
     fn reload_transcript(&mut self, chat_id: &str, workspace: &std::path::Path) {
         if let Ok(mut state) = self.state.lock() {
             state.reload_transcript(chat_id, workspace);
@@ -253,8 +282,23 @@ impl ClassicCommandUi {
 }
 
 impl CommandUi for ClassicCommandUi {
-    fn uses_inline_resume_picker(&self) -> bool {
-        true
+    fn open_thought_viewer(&mut self) -> Result<()> {
+        if let Some(record) = crate::interactive::get_last_thought() {
+            let _ = crate::interactive::show_thought_viewer(&record.thought, &record.elapsed_str);
+        } else {
+            self.push_notice_str("No recent thought process recorded for this turn.");
+        }
+        Ok(())
+    }
+
+    fn prompt_resume_picker(
+        &mut self,
+        _sessions: Vec<mint_core::ChatSession>,
+        current_dir: &std::path::Path,
+        _current_branch: Option<String>,
+        active_chat_id: &str,
+    ) -> Result<Option<String>> {
+        crate::interactive::prompt_resume_session_picker(current_dir, active_chat_id)
     }
 
     fn push_notice_str(&mut self, text: &str) {
@@ -362,6 +406,38 @@ impl CommandUi for ClassicCommandUi {
         crate::interactive::confirm(&format!("{question} {suffix} "))
     }
 
+    fn prompt_onboard(&mut self, config: &mut mint_core::MintConfig) -> Result<bool> {
+        let mut wizard = crate::onboard::OnboardWizard::new(config.clone());
+        crossterm::terminal::enable_raw_mode()?;
+        let mut stdout = std::io::stdout();
+        let _ = crossterm::execute!(
+            stdout,
+            crossterm::terminal::EnterAlternateScreen,
+            crossterm::cursor::Hide
+        );
+        let backend = ratatui::backend::CrosstermBackend::new(stdout);
+        let mut terminal = ratatui::Terminal::new(backend)?;
+
+        let outcome = wizard.run_with_terminal(&mut terminal);
+
+        let _ = crossterm::terminal::disable_raw_mode();
+        let mut stdout = std::io::stdout();
+        let _ = crossterm::execute!(
+            stdout,
+            crossterm::terminal::LeaveAlternateScreen,
+            crossterm::cursor::Show
+        );
+
+        match outcome? {
+            crate::onboard::OnboardOutcome::SavedAndLaunch
+            | crate::onboard::OnboardOutcome::SavedAndExit => {
+                *config = wizard.take_config();
+                Ok(true)
+            }
+            crate::onboard::OnboardOutcome::Cancelled => Ok(false),
+        }
+    }
+
     fn report_error(&mut self, error: &anyhow::Error) {
         eprintln!("{ERROR}Error:{RESET} {error}");
     }
@@ -372,6 +448,8 @@ impl CommandUi for ClassicCommandUi {
 pub struct MockCommandUi {
     pub notices: Vec<String>,
     pub command_outputs: Vec<String>,
+    pub release_notes: Vec<String>,
+    pub plans: Vec<String>,
     pub status: Vec<String>,
     pub choice_answers: Vec<Option<usize>>,
     pub text_answers: Vec<Option<String>>,
@@ -394,6 +472,15 @@ impl CommandUi for MockCommandUi {
         self.command_outputs.push(text.to_string());
     }
 
+    fn push_release_notes(&mut self, notes: &str) {
+        self.release_notes.push(notes.to_string());
+    }
+
+    fn push_plan(&mut self, plan: &str) {
+        self.plans.push(plan.to_string());
+        self.command_outputs.push(plan.to_string());
+    }
+
     fn set_status(&mut self, lines: Vec<String>) {
         self.status = lines;
     }

package/crates/mint-cli/src/interactive/composer.rs

@@ -0,0 +1,186 @@
+use std::ops::Range;
+use std::path::Path;
+use unicode_width::UnicodeWidthStr;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct CollapsedPaste {
+    pub range: Range<usize>,
+    pub text: String,
+}
+
+pub(crate) fn normalize_prompt_newlines(text: &str) -> String {
+    text.replace("\r\n", "\n").replace('\r', "\n")
+}
+
+pub(crate) fn input_row_start(chars: &[char], rows: &[String], row_index: usize) -> usize {
+    let mut start = 0;
+    for row in rows.iter().take(row_index) {
+        start += row.chars().count();
+        if chars.get(start) == Some(&'\n') {
+            start += 1;
+        }
+    }
+    start
+}
+
+pub(crate) fn wrap_input_visual_into_rows(
+    input_chars: &[char],
+    row_width: usize,
+    cursor_pos: usize,
+) -> (Vec<String>, usize, usize) {
+    let row_width = row_width.max(1);
+    let mut rows: Vec<String> = Vec::new();
+    let mut row_starts = Vec::new();
+    let mut row_start = 0usize;
+    let mut visual_width = 0usize;
+
+    for (index, character) in input_chars.iter().copied().enumerate() {
+        if character == '\n' {
+            rows.push(input_chars[row_start..index].iter().collect());
+            row_starts.push(row_start);
+            row_start = index + 1;
+            visual_width = 0;
+            continue;
+        }
+
+        let character_width = UnicodeWidthStr::width(character.to_string().as_str());
+        if visual_width > 0 && visual_width + character_width > row_width {
+            rows.push(input_chars[row_start..index].iter().collect());
+            row_starts.push(row_start);
+            row_start = index;
+            visual_width = 0;
+        }
+        visual_width += character_width;
+    }
+
+    if row_start < input_chars.len() || input_chars.last() == Some(&'\n') || rows.is_empty() {
+        rows.push(input_chars[row_start..].iter().collect());
+        row_starts.push(row_start);
+    }
+
+    let cursor_pos = cursor_pos.min(input_chars.len());
+    let mut cursor_row = rows.len().saturating_sub(1);
+    for (index, start) in row_starts.iter().copied().enumerate() {
+        let end = start + rows[index].chars().count();
+        let next_starts_here = row_starts.get(index + 1) == Some(&cursor_pos);
+        if cursor_pos < end || (cursor_pos == end && !next_starts_here) {
+            cursor_row = index;
+            break;
+        }
+        if cursor_pos == start {
+            cursor_row = index;
+            break;
+        }
+    }
+    let cursor_col = cursor_pos.saturating_sub(row_starts[cursor_row]);
+    (rows, cursor_row, cursor_col)
+}
+
+/// Shared `/`, `$`, and `@` completion matcher used across Full-Screen TUI and Classic CLI.
+pub(crate) fn match_composer_suggestions(
+    chars: &[char],
+    cursor: usize,
+    current_dir: &Path,
+) -> Vec<(String, String)> {
+    let cursor = cursor.min(chars.len());
+    let before: String = chars[..cursor].iter().collect();
+    if before.starts_with('/') {
+        let prefix = before.to_lowercase();
+        let has_space = before.contains(char::is_whitespace);
+        let query = &prefix[1..];
+        let mut matches: Vec<_> = super::SLASH_COMMANDS
+            .iter()
+            .filter(|command| {
+                if !command.on_cli() || !command.token.starts_with('/') {
+                    return false;
+                }
+                let token_lower = command.token.to_lowercase();
+                if has_space {
+                    token_lower.starts_with(&prefix)
+                } else {
+                    token_lower.starts_with(&prefix)
+                        || command.description.to_lowercase().contains(query)
+                }
+            })
+            .collect();
+        if !matches.is_empty() {
+            matches.sort_by_key(|command| !command.token.to_lowercase().starts_with(&prefix));
+            return matches
+                .into_iter()
+                .map(|command| (command.token.clone(), command.description.clone()))
+                .collect();
+        }
+    }
+    if before.starts_with('$') && !before.contains(char::is_whitespace) {
+        let prefix = before[1..].to_lowercase();
+        return super::load_all_available_skills(current_dir)
+            .into_iter()
+            .filter(|skill| skill.name.to_lowercase().starts_with(&prefix))
+            .map(|skill| {
+                (
+                    format!("${}", skill.name),
+                    skill.description.unwrap_or_default(),
+                )
+            })
+            .collect();
+    }
+    let start = chars[..cursor]
+        .iter()
+        .rposition(|c| c.is_whitespace())
+        .map_or(0, |index| index + 1);
+    if chars.get(start) == Some(&'@') {
+        let query: String = chars[start..cursor].iter().collect();
+        return super::collect_mention_candidates(&query, current_dir)
+            .into_iter()
+            .map(|candidate| (candidate.label, candidate.description))
+            .collect();
+    }
+    Vec::new()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn wrap_input_visual_handles_newlines_and_thai_marks() {
+        let chars: Vec<char> = "สวัสดี\nโลก".chars().collect();
+        let (rows, row, col) = wrap_input_visual_into_rows(&chars, 20, chars.len());
+        assert_eq!(rows, vec!["สวัสดี".to_string(), "โลก".to_string()]);
+        assert_eq!(row, 1);
+        assert_eq!(col, 3);
+    }
+
+    #[test]
+    fn match_composer_suggestions_matches_slash_commands() {
+        let chars: Vec<char> = "/res".chars().collect();
+        let results = match_composer_suggestions(&chars, chars.len(), Path::new("."));
+        assert!(results.iter().any(|(token, _)| token == "/resume"));
+
+        let chars_r: Vec<char> = "/r".chars().collect();
+        let results_r = match_composer_suggestions(&chars_r, chars_r.len(), Path::new("."));
+        let resume_pos = results_r.iter().position(|(t, _)| t == "/resume");
+        let retry_pos = results_r.iter().position(|(t, _)| t == "/retry");
+        assert!(resume_pos.is_some() && retry_pos.is_some());
+        assert!(resume_pos.unwrap() < retry_pos.unwrap());
+    }
+
+    #[test]
+    fn match_composer_suggestions_matches_plan_list_order_and_subcommand() {
+        let chars_p: Vec<char> = "/p".chars().collect();
+        let results_p = match_composer_suggestions(&chars_p, chars_p.len(), Path::new("."));
+        let plan_idx = results_p.iter().position(|(t, _)| t == "/plan");
+        let plan_list_idx = results_p.iter().position(|(t, _)| t == "/plan list");
+        assert!(plan_idx.is_some());
+        assert!(plan_list_idx.is_some());
+        assert_eq!(plan_list_idx.unwrap(), plan_idx.unwrap() + 1);
+
+        let chars_plan_space: Vec<char> = "/plan ".chars().collect();
+        let results_plan =
+            match_composer_suggestions(&chars_plan_space, chars_plan_space.len(), Path::new("."));
+        assert_eq!(
+            results_plan.first().map(|(t, _)| t.as_str()),
+            Some("/plan list")
+        );
+    }
+}

package/crates/mint-cli/src/interactive/format.rs

@@ -59,7 +59,7 @@ pub fn format_workspace_with_branch(path: &Path) -> String {
 /// matching on a fixed prefix is safe — user-typed text starting with the
 /// same characters is vanishingly unlikely and, worst case, only affects
 /// display color, not the text actually sent.
-const PLACEHOLDER_PREFIXES: [&str; 2] = ["[Pasted text #", "[Image #"];
+const PLACEHOLDER_PREFIXES: [&str; 3] = ["[Pasted text #", "[Pasted Content ", "[Image #"];
 
 fn matches_placeholder_prefix(chars: &[char], i: usize) -> bool {
     PLACEHOLDER_PREFIXES.iter().any(|prefix| {
@@ -92,15 +92,90 @@ pub fn format_placeholders(s: &str) -> String {
     }
     result
 }
+
 pub fn is_thai_zero_width(c: char) -> bool {
     let cp = c as u32;
     cp == 0x0E31 || (0x0E34..=0x0E3A).contains(&cp) || (0x0E47..=0x0E4E).contains(&cp)
 }
+
+pub fn is_cjk_wide(c: char) -> bool {
+    let val = c as u32;
+    (0x4E00..=0x9FFF).contains(&val)
+        || (0x3400..=0x4DBF).contains(&val)
+        || (0x20000..=0x2A6DF).contains(&val)
+        || (0xAC00..=0xD7AF).contains(&val)
+        || (0x3040..=0x309F).contains(&val)
+        || (0x30A0..=0x30FF).contains(&val)
+}
+
 pub fn char_visual_width(c: char) -> usize {
-    if is_thai_zero_width(c) { 0 } else { 1 }
+    if is_thai_zero_width(c) {
+        0
+    } else if is_cjk_wide(c) {
+        2
+    } else {
+        unicode_width::UnicodeWidthChar::width(c).unwrap_or(1)
+    }
 }
+
 pub fn string_visual_width(s: &str) -> usize {
-    s.chars().map(char_visual_width).sum()
+    display_width(s)
+}
+
+/// Canonical terminal display width accounting for ANSI CSI sequences, Thai
+/// zero-width combining marks, and East-Asian / emoji wide glyphs.
+pub fn display_width(s: &str) -> usize {
+    let mut count = 0;
+    let mut chars = s.chars().peekable();
+    while let Some(c) = chars.next() {
+        if c == '\u{1b}' && chars.peek() == Some(&'[') {
+            chars.next();
+            for c2 in chars.by_ref() {
+                if c2.is_ascii_alphabetic() {
+                    break;
+                }
+            }
+            continue;
+        }
+        if is_thai_zero_width(c) {
+            continue;
+        }
+        if is_cjk_wide(c) {
+            count += 2;
+        } else {
+            count += unicode_width::UnicodeWidthChar::width(c).unwrap_or(0);
+        }
+    }
+    count
+}
+
+/// Canonical width-aware string clipper with `…` ellipsis used across TUI
+/// widgets (`resume_picker`, `tool_activity`, `chat_tui`, etc.).
+pub fn truncate_to_width(text: &str, max_width: usize) -> String {
+    if display_width(text) <= max_width {
+        return text.to_owned();
+    }
+    if max_width == 0 {
+        return String::new();
+    }
+    let mut result = String::new();
+    let mut width = 0usize;
+    for ch in text.chars() {
+        let ch_width = if is_thai_zero_width(ch) {
+            0
+        } else if is_cjk_wide(ch) {
+            2
+        } else {
+            unicode_width::UnicodeWidthChar::width(ch).unwrap_or(0)
+        };
+        if width + ch_width > max_width.saturating_sub(1) {
+            break;
+        }
+        result.push(ch);
+        width += ch_width;
+    }
+    result.push('…');
+    result
 }
 pub fn active_model<'a>(provider: &str, config: &'a mint_core::MintConfig) -> &'a str {
     match provider {

package/crates/mint-cli/src/interactive/input_box.rs

@@ -114,6 +114,14 @@ impl MentionKind {
 }
 
 pub fn collect_mention_candidates(query: &str, current_dir: &Path) -> Vec<MentionCandidate> {
+    collect_mention_candidates_with_recents(query, current_dir, &[])
+}
+
+pub fn collect_mention_candidates_with_recents(
+    query: &str,
+    current_dir: &Path,
+    recent_files: &[String],
+) -> Vec<MentionCandidate> {
     let prefix = query.strip_prefix('@').unwrap_or(query).to_lowercase();
     let mut candidates = Vec::new();
 
@@ -156,7 +164,43 @@ pub fn collect_mention_candidates(query: &str, current_dir: &Path) -> Vec<Mentio
         }
     }
 
-    // 3. Workspace files and folders
+    // 3. Recently modified/written session files (prioritized)
+    let mut auto_recents = Vec::new();
+    let effective_recents: &[String] = if !recent_files.is_empty() {
+        recent_files
+    } else {
+        if let Ok(changes) = mint_core::git::diff::read_workspace_git_diff(current_dir) {
+            for c in changes {
+                auto_recents.push(c.path);
+            }
+        }
+        &auto_recents
+    };
+
+    let mut seen_recents = std::collections::HashSet::new();
+    for file in effective_recents {
+        let clean = file.trim_start_matches('@').trim();
+        if clean.is_empty() {
+            continue;
+        }
+        let file_name = std::path::Path::new(clean)
+            .file_name()
+            .map(|s| s.to_string_lossy().to_string())
+            .unwrap_or_else(|| clean.to_string());
+        if file_name.to_lowercase().starts_with(&prefix)
+            || clean.to_lowercase().starts_with(&prefix)
+            || prefix.is_empty()
+        {
+            seen_recents.insert(file_name.clone());
+            candidates.push(MentionCandidate {
+                label: format!("@{file_name}"),
+                description: "Recently edited in this session".into(),
+                kind: MentionKind::File,
+            });
+        }
+    }
+
+    // 4. Workspace files and folders
     if let Ok(entries) = std::fs::read_dir(current_dir) {
         let mut file_entries = Vec::new();
         for entry in entries.flatten() {
@@ -166,6 +210,7 @@ pub fn collect_mention_candidates(query: &str, current_dir: &Path) -> Vec<Mentio
                 || name == "node_modules"
                 || name == "dist"
                 || name == "build"
+                || seen_recents.contains(&name)
             {
                 continue;
             }
@@ -1827,4 +1872,19 @@ mod tests {
             );
         }
     }
+
+    #[test]
+    fn mention_candidates_prioritize_recently_edited_files() {
+        let temp_dir = std::env::current_dir().unwrap();
+        let recents = vec![
+            "generate_harness_pdf.py".to_string(),
+            "CalculationCard.tsx".to_string(),
+        ];
+        let candidates = collect_mention_candidates_with_recents("@Calc", &temp_dir, &recents);
+        assert!(
+            candidates
+                .iter()
+                .any(|c| c.label == "@CalculationCard.tsx" && c.description.contains("Recent"))
+        );
+    }
 }