diff --git a/CHANGELOG.md b/CHANGELOG.md
index 37414d3..a8f93a3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,9 @@ adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+### Changed
+- Bare `qr go` / `qr g` now opens a lightweight live-filter picker for cached projects while `qr go <project>` keeps the existing direct lookup behavior.
+
 ## [0.1.0] - 2026-07-02
 
 ### Added
diff --git a/Cargo.lock b/Cargo.lock
index d5a706c..e84206d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1330,6 +1330,7 @@ dependencies = [
  "shlex 2.0.1",
  "tempfile",
  "toml",
+ "unicode-width",
  "walkdir",
 ]
 
diff --git a/Cargo.toml b/Cargo.toml
index 9e97f0c..5e1838d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -30,6 +30,7 @@ serde_json = "1.0.145"
 shellexpand = "3.1.1"
 shlex = "2.0.1"
 toml = "0.9.8"
+unicode-width = "0.2.2"
 walkdir = "2.5.0"
 
 # OS keychain for API-key storage, via per-platform native backends. All are
diff --git a/README.md b/README.md
index 91e817e..38335af 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@ QuickRunner (`qr`) is a fast Rust CLI for common developer shell workflows: jump
 
 ## Features
 
-- `qr go <project>` / `qr g`: fuzzy project lookup backed by a cached scanner (interactive picker on multiple matches)
+- `qr go <project>` / `qr g <project>`: fuzzy project lookup backed by a cached scanner; bare `qr go` / `qr g` opens a live filter picker
 - `qr run [--watch|--log|--output] <script>` / `qr r`: script runner with watch, log, and passthrough modes
 - `qr alias add|list|remove` / `qr a`: shell alias management
 - `qr stats` / `qr s`: aggregated command stats from a local SQLite database
@@ -23,7 +23,7 @@ qr init                  # config + shell wrapper + initial scan
 exec $SHELL              # reload so the `qr go` wrapper takes effect
 ```
 
-`qr init` appends a wrapper function to your shell rc file so `qr go` can change the parent shell's directory — a child process can't do that on its own. The wrapper calls `qr go --print-path` and runs the `cd` in your shell.
+`qr init` appends a wrapper function to your shell rc file so `qr go` can change the parent shell's directory — a child process can't do that on its own. The wrapper calls `qr go --print-path` and runs the `cd` in your shell; bare `qr g` now opens the live filter and still prints only the selected path for that wrapper.
 
 ## Config
 
diff --git a/src/ai/client.rs b/src/ai/client.rs
index 0dbe1d0..d98c8ba 100644
--- a/src/ai/client.rs
+++ b/src/ai/client.rs
@@ -458,6 +458,9 @@ mod tests {
 
     #[test]
     fn clear_test_env_removes_cross_endpoint_fallback_opt_in() {
+        // Must hold the shared env lock: mutating process env without it races
+        // other lib tests that read/write env vars (and poisons the lock on panic).
+        let _guard = test_env_lock().lock().unwrap();
         unsafe {
             std::env::set_var(ALLOW_CROSS_ENDPOINT_FALLBACK_ENV, "true");
         }
diff --git a/src/commands/go.rs b/src/commands/go.rs
index b18abad..bb3341a 100644
--- a/src/commands/go.rs
+++ b/src/commands/go.rs
@@ -13,6 +13,42 @@ pub struct GoResult {
     pub interactive_ms: u128,
 }
 
+pub fn execute_live(config: &AppConfig) -> Result<GoResult> {
+    if !std::io::stdin().is_terminal() || !std::io::stderr().is_terminal() {
+        return Err(anyhow!("project name required"));
+    }
+
+    let cache = load_or_scan_projects(config)?;
+    let labels = cache
+        .projects
+        .iter()
+        .map(live_project_choice_label)
+        .collect::<Vec<_>>();
+    let picker_start = std::time::Instant::now();
+    let selected = project_at_picker_index(&cache.projects, picker::pick_live_index(&labels)?)?;
+
+    Ok(GoResult {
+        path: selected.path,
+        interactive_ms: picker_start.elapsed().as_millis(),
+    })
+}
+
+fn project_at_picker_index(
+    projects: &[ProjectEntry],
+    index: Option<usize>,
+) -> Result<ProjectEntry> {
+    if projects.is_empty() {
+        return Err(anyhow!("No projects found. Run `qr scan` to refresh."));
+    }
+    let Some(index) = index else {
+        return Err(anyhow!("Selection cancelled"));
+    };
+    projects
+        .get(index)
+        .cloned()
+        .ok_or_else(|| anyhow!("Selection cancelled"))
+}
+
 pub fn execute(config: &AppConfig, query: &str) -> Result<GoResult> {
     let cache = load_or_scan_projects(config)?;
     let matches = rank_matches(&cache.projects, query);
@@ -55,6 +91,14 @@ fn project_choice_label(entry: &ProjectEntry) -> String {
     )
 }
 
+fn live_project_choice_label(entry: &ProjectEntry) -> String {
+    format!(
+        "{}\t{}",
+        terminal::escape_untrusted(&entry.name),
+        terminal::escape_untrusted(&entry.path)
+    )
+}
+
 fn multiple_match_names(entries: &[ProjectEntry]) -> String {
     entries
         .iter()
@@ -212,6 +256,20 @@ mod tests {
         );
     }
 
+    #[test]
+    fn live_project_choice_label_keeps_parenthesized_paths_unambiguous() {
+        let entry = ProjectEntry {
+            name: "demo".into(),
+            path: r"C:\Program Files (x86)\demo".into(),
+            source: "git".into(),
+        };
+
+        assert_eq!(
+            live_project_choice_label(&entry),
+            "demo\tC:\\Program Files (x86)\\demo"
+        );
+    }
+
     #[test]
     fn multiple_match_names_escape_terminal_controls() {
         let entries = vec![
@@ -228,4 +286,23 @@ mod tests {
         ];
         assert_eq!(multiple_match_names(&entries), "one\\u{1b}[2J, two\\u{7}");
     }
+
+    #[test]
+    fn project_at_selected_live_index_returns_matching_project() {
+        let projects = sample_projects();
+
+        let selected = project_at_picker_index(&projects, Some(1)).unwrap();
+
+        assert_eq!(selected.name, "orion-api");
+    }
+
+    #[test]
+    fn project_at_selected_live_index_reports_empty_project_cache() {
+        let error = project_at_picker_index(&[], None).unwrap_err();
+
+        assert!(
+            error.to_string().contains("No projects found"),
+            "unexpected error: {error:#}"
+        );
+    }
 }
diff --git a/src/config.rs b/src/config.rs
index 6f4e66b..41dbd82 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -775,6 +775,8 @@ db_path = "/tmp/file.db"
 
     #[test]
     fn migrate_legacy_config_rewrites_stats_db_path_under_legacy_dir() {
+        let _guard = test_env_lock().lock().unwrap();
+        clear_test_env();
         let root = tempfile::tempdir().unwrap();
         let legacy = root.path().join("legacy");
         let new_dir = root.path().join("new");
@@ -813,6 +815,8 @@ db_path = "{}"
 
     #[test]
     fn migrate_legacy_agent_defaults_rewrites_shipped_defaults() {
+        let _guard = test_env_lock().lock().unwrap();
+        clear_test_env();
         let dir = tempfile::tempdir().unwrap();
         let path = dir.path().join("config.toml");
         fs::write(
@@ -854,6 +858,8 @@ claude = "claude --dangerously-skip-permissions -p"
 
     #[test]
     fn migrate_legacy_agent_defaults_preserves_custom_agent_commands() {
+        let _guard = test_env_lock().lock().unwrap();
+        clear_test_env();
         let dir = tempfile::tempdir().unwrap();
         let path = dir.path().join("config.toml");
         let custom_codex = "codex exec --model gpt-5";
@@ -936,6 +942,8 @@ db_path = "{}"
 
     #[test]
     fn migrate_legacy_config_preserves_custom_stats_db_filename() {
+        let _guard = test_env_lock().lock().unwrap();
+        clear_test_env();
         let root = tempfile::tempdir().unwrap();
         let legacy = root.path().join("legacy");
         let new_dir = root.path().join("new");
diff --git a/src/main.rs b/src/main.rs
index 9c92a07..22e4fbf 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -175,10 +175,11 @@ fn run_with_config(command: Commands) -> Result<ExitCode> {
     let execution = match command {
         Commands::Go(args) => {
             let query = args.project.join("-");
-            if query.is_empty() {
-                anyhow::bail!("project name required");
-            }
-            let result = commands::go::execute(&config, &query)?;
+            let result = if query.is_empty() {
+                commands::go::execute_live(&config)?
+            } else {
+                commands::go::execute(&config, &query)?
+            };
             interactive_ms = result.interactive_ms;
             print_go_result(&result, args.print_path)?;
             Ok(ExitCode::SUCCESS)
diff --git a/src/picker.rs b/src/picker.rs
index 2f3e46f..8208d78 100644
--- a/src/picker.rs
+++ b/src/picker.rs
@@ -3,10 +3,16 @@ use std::io::{self, Write};
 use anyhow::Result;
 use crossterm::{
     cursor,
-    event::{self, Event, KeyCode},
+    event::{self, Event, KeyCode, KeyEventKind, KeyModifiers},
     execute,
     terminal::{self, ClearType},
 };
+use unicode_width::UnicodeWidthStr;
+
+const ANSI_RESET: &str = "\x1b[0m";
+const ANSI_BOLD: &str = "\x1b[1m";
+const ANSI_DIM: &str = "\x1b[2m";
+const ANSI_CYAN: &str = "\x1b[36m";
 
 /// Restores the terminal (cursor + cooked mode) on every exit path — including
 /// early `?` errors and panics — so a crash mid-pick can never leave the user's
@@ -32,6 +38,115 @@ impl Drop for RawModeGuard {
     }
 }
 
+#[derive(Debug)]
+struct LiveFilterState {
+    options: Vec<String>,
+    query: String,
+    matches: Vec<usize>,
+    selected_offset: Option<usize>,
+}
+
+impl LiveFilterState {
+    fn new(options: Vec<String>) -> Self {
+        let mut state = Self {
+            options,
+            query: String::new(),
+            matches: Vec::new(),
+            selected_offset: None,
+        };
+        state.refresh_matches();
+        state
+    }
+
+    fn query(&self) -> &str {
+        &self.query
+    }
+
+    fn matches(&self) -> &[usize] {
+        &self.matches
+    }
+
+    fn selected_index(&self) -> Option<usize> {
+        self.selected_offset.map(|offset| self.matches[offset])
+    }
+
+    fn insert_char(&mut self, value: char) {
+        self.query.push(value);
+        self.refresh_matches();
+    }
+
+    fn backspace(&mut self) {
+        self.query.pop();
+        self.refresh_matches();
+    }
+
+    fn move_down(&mut self) {
+        if let Some(offset) = self.selected_offset {
+            if offset + 1 < self.matches.len() {
+                self.selected_offset = Some(offset + 1);
+            }
+        }
+    }
+
+    fn move_up(&mut self) {
+        if let Some(offset) = self.selected_offset {
+            if offset > 0 {
+                self.selected_offset = Some(offset - 1);
+            }
+        }
+    }
+
+    fn visible_matches(&self, per_page: usize) -> &[usize] {
+        if per_page == 0 || self.matches.is_empty() {
+            return &[];
+        }
+        let start = self.visible_start(per_page);
+        let end = self.matches.len().min(start + per_page);
+        &self.matches[start..end]
+    }
+
+    fn visible_selected_offset(&self, per_page: usize) -> Option<usize> {
+        let selected = self.selected_offset?;
+        Some(selected - self.visible_start(per_page))
+    }
+
+    fn visible_start(&self, per_page: usize) -> usize {
+        let Some(selected) = self.selected_offset else {
+            return 0;
+        };
+        if per_page == 0 || selected < per_page {
+            0
+        } else {
+            selected + 1 - per_page
+        }
+    }
+
+    fn option(&self, index: usize) -> &str {
+        &self.options[index]
+    }
+
+    fn refresh_matches(&mut self) {
+        let query = self.query.to_ascii_lowercase();
+        self.matches = self
+            .options
+            .iter()
+            .enumerate()
+            .filter_map(|(index, option)| {
+                if query.is_empty() || option.to_ascii_lowercase().contains(&query) {
+                    Some(index)
+                } else {
+                    None
+                }
+            })
+            .collect();
+        self.selected_offset = if self.matches.is_empty() {
+            None
+        } else {
+            Some(0)
+        };
+    }
+}
+
 pub fn pick_index(options: &[String]) -> Result<Option<usize>> {
     if options.is_empty() {
         return Ok(None);
@@ -49,7 +164,10 @@ pub fn pick_index(options: &[String]) -> Result<Option<usize>> {
     loop {
         render_page(options, page, per_page, None)?;
         if let Event::Key(key) = event::read()? {
-            match key.code {
+            let Some(code) = numbered_picker_key_code(key) else {
+                continue;
+            };
+            match code {
                 KeyCode::Char('q') | KeyCode::Esc => return Ok(None),
                 KeyCode::Char(c) if c.is_ascii_digit() && c != '0' => {
                     let index = c.to_digit(10).unwrap() as usize - 1;
@@ -71,6 +189,67 @@ pub fn pick_index(options: &[String]) -> Result<Option<usize>> {
     }
 }
 
+fn numbered_picker_key_code(key: crossterm::event::KeyEvent) -> Option<KeyCode> {
+    should_handle_key_event(key.kind).then_some(key.code)
+}
+
+fn should_handle_key_event(kind: KeyEventKind) -> bool {
+    kind != KeyEventKind::Release
+}
+
+pub fn pick_live_index(options: &[String]) -> Result<Option<usize>> {
+    if options.is_empty() {
+        return Ok(None);
+    }
+
+    // Like the numbered picker, the live picker renders on stderr so stdout can
+    // stay reserved for `--print-path` and the installed shell wrapper's `cd`.
+    let _guard = RawModeGuard::enter()?;
+    let mut state = LiveFilterState::new(options.to_vec());
+    let per_page = 7usize;
+    let mut rendered_lines = 0usize;
+
+    let loop_result: Result<Option<usize>> = (|| {
+        loop {
+            rendered_lines = render_live_filter(&state, per_page, rendered_lines)?;
+            if let Event::Key(key) = event::read()? {
+                if !should_handle_key_event(key.kind) {
+                    continue;
+                }
+                match key.code {
+                    KeyCode::Enter => return Ok(state.selected_index()),
+                    KeyCode::Esc => return Ok(None),
+                    KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => {
+                        return Ok(None);
+                    }
+                    KeyCode::Char(value) if !key.modifiers.contains(KeyModifiers::CONTROL) => {
+                        state.insert_char(value);
+                    }
+                    KeyCode::Backspace => state.backspace(),
+                    KeyCode::Down => state.move_down(),
+                    KeyCode::Up => state.move_up(),
+                    _ => {}
+                }
+            }
+        }
+    })();
+
+    complete_live_filter(loop_result, || clear_live_filter(rendered_lines))
+}
+
+fn complete_live_filter<T>(result: Result<T>, cleanup: impl FnOnce() -> Result<()>) -> Result<T> {
+    match result {
+        Ok(value) => {
+            cleanup()?;
+            Ok(value)
+        }
+        Err(error) => {
+            let _ = cleanup();
+            Err(error)
+        }
+    }
+}
+
 fn render_page(
     options: &[String],
     page: usize,
@@ -107,3 +286,352 @@ fn render_page(
     stderr.flush()?;
     Ok(())
 }
+
+fn render_live_filter(
+    state: &LiveFilterState,
+    per_page: usize,
+    previous_lines: usize,
+) -> Result<usize> {
+    let mut stderr = io::stderr();
+    if previous_lines > 0 {
+        execute!(
+            stderr,
+            cursor::MoveUp(previous_lines as u16),
+            terminal::Clear(ClearType::FromCursorDown)
+        )?;
+    }
+
+    let lines = live_filter_lines(state, per_page, terminal_width());
+    for line in &lines {
+        write!(stderr, "{line}\r\n")?;
+    }
+    stderr.flush()?;
+    Ok(lines.len())
+}
+
+fn clear_live_filter(previous_lines: usize) -> Result<()> {
+    if previous_lines == 0 {
+        return Ok(());
+    }
+
+    let mut stderr = io::stderr();
+    execute!(
+        stderr,
+        cursor::MoveUp(previous_lines as u16),
+        terminal::Clear(ClearType::FromCursorDown)
+    )?;
+    stderr.flush()?;
+    Ok(())
+}
+
+fn live_filter_lines(state: &LiveFilterState, per_page: usize, width: usize) -> Vec<String> {
+    let mut lines = Vec::new();
+    let query = if state.query().is_empty() {
+        format!("{ANSI_DIM}type…{ANSI_RESET}")
+    } else {
+        format!("{ANSI_BOLD}{}{ANSI_RESET}", state.query())
+    };
+    lines.push(truncate_ansi(
+        &format!("{ANSI_CYAN}find{ANSI_RESET} project {query}"),
+        width,
+    ));
+
+    if state.matches().is_empty() {
+        lines.push(truncate_ansi(
+            &format!("  {ANSI_DIM}no matches · backspace to widen · esc cancels{ANSI_RESET}"),
+            width,
+        ));
+        return lines;
+    }
+
+    for (offset, index) in state.visible_matches(per_page).iter().enumerate() {
+        let selected = state.visible_selected_offset(per_page) == Some(offset);
+        let marker = if selected {
+            format!("{ANSI_CYAN}❯{ANSI_RESET}")
+        } else {
+            " ".to_string()
+        };
+        let (name, path) = split_live_label(state.option(*index));
+        lines.push(truncate_ansi(
+            &format!("{marker} {ANSI_BOLD}{name}{ANSI_RESET} {ANSI_DIM}{path}{ANSI_RESET}"),
+            width,
+        ));
+    }
+
+    let visible = state.visible_matches(per_page).len();
+    let total = state.matches().len();
+    let count = if total > visible {
+        format!("{visible}/{total} matches")
+    } else if total == 1 {
+        "1 match".to_string()
+    } else {
+        format!("{total} matches")
+    };
+    lines.push(truncate_ansi(
+        &format!("  {ANSI_DIM}{count} · type to filter · ↑/↓ move · enter selects · esc cancels{ANSI_RESET}"),
+        width,
+    ));
+    lines
+}
+
+fn split_live_label(label: &str) -> (&str, &str) {
+    if let Some((name, path)) = label.split_once('\t') {
+        return (name, path);
+    }
+    if let Some((name, path)) = label.rsplit_once(" (") {
+        if let Some(path) = path.strip_suffix(')') {
+            return (name, path);
+        }
+    }
+    (label, "")
+}
+
+fn terminal_width() -> usize {
+    terminal::size()
+        .map(|(width, _)| normalized_terminal_width(width))
+        .unwrap_or(100)
+}
+
+fn normalized_terminal_width(width: u16) -> usize {
+    usize::from(width).max(1)
+}
+
+fn truncate_ansi(input: &str, max_width: usize) -> String {
+    if max_width == 0 || visible_width(input) <= max_width {
+        return input.to_string();
+    }
+
+    let target = max_width.saturating_sub(1);
+    let mut output = String::new();
+    let mut visible_text = String::new();
+    let mut chars = input.chars().peekable();
+    while let Some(ch) = chars.next() {
+        if ch == '\x1b' {
+            output.push(ch);
+            for next in chars.by_ref() {
+                output.push(next);
+                if next == 'm' {
+                    break;
+                }
+            }
+            continue;
+        }
+
+        let mut candidate = visible_text.clone();
+        candidate.push(ch);
+        if candidate.width() > target {
+            break;
+        }
+        output.push(ch);
+        visible_text = candidate;
+    }
+
+    output.push('…');
+    output.push_str(ANSI_RESET);
+    output
+}
+
+fn visible_width(input: &str) -> usize {
+    let mut visible = String::new();
+    let mut chars = input.chars().peekable();
+    while let Some(ch) = chars.next() {
+        if ch == '\x1b' {
+            for next in chars.by_ref() {
+                if next == 'm' {
+                    break;
+                }
+            }
+        } else {
+            visible.push(ch);
+        }
+    }
+    visible.width()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn labels(values: &[&str]) -> Vec<String> {
+        values.iter().map(|value| (*value).to_string()).collect()
+    }
+
+    fn strip_ansi_codes(input: &str) -> String {
+        let mut output = String::new();
+        let mut chars = input.chars().peekable();
+        while let Some(ch) = chars.next() {
+            if ch == '\x1b' {
+                for next in chars.by_ref() {
+                    if next == 'm' {
+                        break;
+                    }
+                }
+            } else {
+                output.push(ch);
+            }
+        }
+        output
+    }
+
+    #[test]
+    fn live_filter_starts_with_every_option_available() {
+        let state = LiveFilterState::new(labels(&["quick-runner", "orion-api", "docs"]));
+
+        assert_eq!(state.matches(), &[0, 1, 2]);
+        assert_eq!(state.selected_index(), Some(0));
+    }
+
+    #[test]
+    fn live_filter_keeps_labels_containing_the_typed_query() {
+        let mut state = LiveFilterState::new(labels(&["quick-runner", "orion-api", "docs"]));
+
+        state.insert_char('i');
+        state.insert_char('o');
+
+        assert_eq!(state.matches(), &[1]);
+        assert_eq!(state.selected_index(), Some(1));
+    }
+
+    #[test]
+    fn live_filter_clamps_selection_to_first_remaining_match() {
+        let mut state = LiveFilterState::new(labels(&["alpha", "beta", "gamma", "alphabet"]));
+        state.move_down();
+        state.move_down();
+
+        state.insert_char('a');
+        state.insert_char('l');
+        state.insert_char('p');
+
+        assert_eq!(state.matches(), &[0, 3]);
+        assert_eq!(state.selected_index(), Some(0));
+    }
+
+    #[test]
+    fn live_filter_backspace_restores_broader_matches() {
+        let mut state = LiveFilterState::new(labels(&["alpha", "alpine", "beta", "alloy"]));
+        state.insert_char('a');
+        state.insert_char('l');
+        state.insert_char('p');
+        assert_eq!(state.matches(), &[0, 1]);
+
+        state.backspace();
+
+        assert_eq!(state.matches(), &[0, 1, 3]);
+        assert_eq!(state.selected_index(), Some(0));
+    }
+
+    #[test]
+    fn live_filter_visible_matches_follow_selection() {
+        let mut state = LiveFilterState::new(labels(&[
+            "project-00",
+            "project-01",
+            "project-02",
+            "project-03",
+            "project-04",
+            "project-05",
+            "project-06",
+            "project-07",
+            "project-08",
+            "project-09",
+            "project-10",
+        ]));
+        for _ in 0..10 {
+            state.move_down();
+        }
+
+        assert_eq!(state.selected_index(), Some(10));
+        assert_eq!(state.visible_matches(9), &[2, 3, 4, 5, 6, 7, 8, 9, 10]);
+    }
+
+    #[test]
+    fn live_picker_ignores_key_release_events() {
+        assert!(should_handle_key_event(KeyEventKind::Press));
+        assert!(should_handle_key_event(KeyEventKind::Repeat));
+        assert!(!should_handle_key_event(KeyEventKind::Release));
+    }
+
+    #[test]
+    fn numbered_picker_ignores_key_release_events() {
+        let release = crossterm::event::KeyEvent::new_with_kind(
+            KeyCode::Char('1'),
+            KeyModifiers::empty(),
+            KeyEventKind::Release,
+        );
+        let press = crossterm::event::KeyEvent::new_with_kind(
+            KeyCode::Char('1'),
+            KeyModifiers::empty(),
+            KeyEventKind::Press,
+        );
+
+        assert_eq!(numbered_picker_key_code(release), None);
+        assert_eq!(numbered_picker_key_code(press), Some(KeyCode::Char('1')));
+    }
+
+    #[test]
+    fn live_filter_render_is_compact_and_styled() {
+        let state = LiveFilterState::new(labels(&[
+            "quick-runner\t/Users/aanishbhirud/Development/quick-runner",
+            "orion-api\t/Users/aanishbhirud/Development/orion-api",
+        ]));
+
+        let lines = live_filter_lines(&state, 7, 72);
+
+        assert_eq!(lines.len(), 4);
+        assert!(lines[0].contains("\u{1b}[36mfind\u{1b}[0m"));
+        assert!(lines[1].contains("❯"));
+        assert!(lines[1].contains("\u{1b}[1mquick-runner\u{1b}[0m"));
+        assert!(
+            lines[1].contains("\u{1b}[2m/Users/aanishbhirud/Development/quick-runner\u{1b}[0m")
+        );
+        assert!(lines[3].contains("type to filter"));
+    }
+
+    #[test]
+    fn live_filter_render_truncates_long_rows_to_terminal_width() {
+        let state = LiveFilterState::new(labels(&[
+            "very-long-project-name\t/Users/aanishbhirud/Development/some/deep/path/that/would/wrap",
+        ]));
+
+        let lines = live_filter_lines(&state, 7, 48);
+
+        assert!(visible_width(&lines[1]) <= 48);
+        assert!(lines[1].contains('…'));
+    }
+
+    #[test]
+    fn terminal_width_is_not_inflated_on_narrow_terminals() {
+        assert_eq!(normalized_terminal_width(20), 20);
+    }
+
+    #[test]
+    fn live_filter_cleanup_runs_when_the_picker_loop_errors() {
+        let cleaned = std::cell::Cell::new(false);
+        let loop_result: Result<()> = Err(anyhow::anyhow!("read failed"));
+
+        let result = complete_live_filter(loop_result, || {
+            cleaned.set(true);
+            Ok(())
+        });
+
+        assert!(cleaned.get());
+        assert_eq!(result.unwrap_err().to_string(), "read failed");
+    }
+
+    #[test]
+    fn live_filter_truncation_counts_unicode_terminal_cells() {
+        let output = truncate_ansi("界界界", 4);
+        let visible = strip_ansi_codes(&output);
+
+        assert!(unicode_width::UnicodeWidthStr::width(visible.as_str()) <= 4);
+        assert!(output.contains('…'));
+    }
+
+    #[test]
+    fn live_filter_truncation_counts_emoji_presentation_sequences() {
+        let output = truncate_ansi("#\u{fe0f}#\u{fe0f}#\u{fe0f}", 4);
+        let visible = strip_ansi_codes(&output);
+
+        assert!(unicode_width::UnicodeWidthStr::width(visible.as_str()) <= 4);
+        assert!(output.contains('…'));
+    }
+}
diff --git a/src/project_profile.rs b/src/project_profile.rs
index dbc9c1d..1510a97 100644
--- a/src/project_profile.rs
+++ b/src/project_profile.rs
@@ -396,9 +396,8 @@ fn qualify_script_command(
     match package_manager.unwrap_or("npm") {
         "pnpm" => Some(format!("pnpm {script_name}")),
         "yarn" => Some(format!("yarn {script_name}")),
-        _ => Some(format!("npm run {script_name}"))
-            .filter(|_| script_name != "test")
-            .or_else(|| Some("npm test".into())),
+        _ if script_name == "test" => Some("npm test".into()),
+        _ => Some(format!("npm run {script_name}")),
     }
 }