Feat: begin sample explorer overhaul

.github/workflows/build-cross.yml

@@ -10,7 +10,7 @@ env:
 jobs:
   build:
     runs-on: ubuntu-latest
-    timeout-minutes: 45
+    timeout-minutes: 60
 
     steps:
       - uses: actions/checkout@v4

.github/workflows/build-linux.yml

@@ -30,7 +30,7 @@ env:
 jobs:
   build:
     runs-on: ubuntu-latest
-    timeout-minutes: 30
+    timeout-minutes: 60
 
     steps:
       - uses: actions/checkout@v4

.github/workflows/build-macos.yml

@@ -42,7 +42,7 @@ jobs:
         include: ${{ fromJSON(inputs.matrix) }}
 
     runs-on: ${{ matrix.os }}
-    timeout-minutes: 30
+    timeout-minutes: 60
 
     steps:
       - uses: actions/checkout@v4

.github/workflows/build-plugins-linux.yml

@@ -10,7 +10,7 @@ env:
 jobs:
   build:
     runs-on: ubuntu-latest
-    timeout-minutes: 30
+    timeout-minutes: 60
 
     steps:
       - uses: actions/checkout@v4

.github/workflows/build-plugins-macos.yml

@@ -24,7 +24,7 @@ jobs:
         include: ${{ fromJSON(inputs.matrix) }}
 
     runs-on: ${{ matrix.os }}
-    timeout-minutes: 30
+    timeout-minutes: 60
 
     steps:
       - uses: actions/checkout@v4

.github/workflows/build-plugins-rpi.yml

@@ -10,7 +10,7 @@ env:
 jobs:
   build:
     runs-on: ubuntu-latest
-    timeout-minutes: 45
+    timeout-minutes: 60
 
     steps:
       - uses: actions/checkout@v4

.github/workflows/build-plugins-windows.yml

@@ -10,7 +10,7 @@ env:
 jobs:
   build:
     runs-on: windows-latest
-    timeout-minutes: 30
+    timeout-minutes: 60
 
     defaults:
       run:

.github/workflows/build-windows.yml

@@ -30,7 +30,7 @@ env:
 jobs:
   build:
     runs-on: windows-latest
-    timeout-minutes: 30
+    timeout-minutes: 60
 
     steps:
       - uses: actions/checkout@v4

crates/forth/src/vm.rs

@@ -112,7 +112,7 @@ impl Forth {
         let vars_snapshot = self.vars.load_full();
         let mut var_writes: HashMap<String, Value> = HashMap::new();
 
-        cmd.set_global(self.global_params.lock().clone());
+        cmd.set_global(std::mem::take(&mut *self.global_params.lock()));
 
         self.execute_ops(
             ops,
@@ -459,7 +459,7 @@ impl Forth {
                     if b.as_float().map_or(true, |v| v == 0.0) {
                         return Err("division by zero".into());
                     }
-                    stack.push(lift_binary(a, b, |x, y| x / y)?);
+                    stack.push(lift_binary(&a, &b, |x, y| x / y)?);
                 }
                 Op::Mod => {
                     let b = pop(stack)?;
@@ -467,47 +467,47 @@ impl Forth {
                     if b.as_float().map_or(true, |v| v == 0.0) {
                         return Err("modulo by zero".into());
                     }
-                    let result = lift_binary(a, b, |x, y| (x as i64 % y as i64) as f64)?;
+                    let result = lift_binary(&a, &b, |x, y| (x as i64 % y as i64) as f64)?;
                     stack.push(result);
                 }
                 Op::Neg => {
                     let v = pop(stack)?;
-                    stack.push(lift_unary(v, |x| -x)?);
+                    stack.push(lift_unary(&v, |x| -x)?);
                 }
                 Op::Abs => {
                     let v = pop(stack)?;
-                    stack.push(lift_unary(v, |x| x.abs())?);
+                    stack.push(lift_unary(&v, |x| x.abs())?);
                 }
                 Op::Floor => {
                     let v = pop(stack)?;
-                    stack.push(lift_unary(v, |x| x.floor())?);
+                    stack.push(lift_unary(&v, |x| x.floor())?);
                 }
                 Op::Ceil => {
                     let v = pop(stack)?;
-                    stack.push(lift_unary(v, |x| x.ceil())?);
+                    stack.push(lift_unary(&v, |x| x.ceil())?);
                 }
                 Op::Round => {
                     let v = pop(stack)?;
-                    stack.push(lift_unary(v, |x| x.round())?);
+                    stack.push(lift_unary(&v, |x| x.round())?);
                 }
                 Op::Min => binary_op(stack, |a, b| a.min(b))?,
                 Op::Max => binary_op(stack, |a, b| a.max(b))?,
                 Op::Pow => binary_op(stack, |a, b| a.powf(b))?,
                 Op::Sqrt => {
                     let v = pop(stack)?;
-                    stack.push(lift_unary(v, |x| x.sqrt())?);
+                    stack.push(lift_unary(&v, |x| x.sqrt())?);
                 }
                 Op::Sin => {
                     let v = pop(stack)?;
-                    stack.push(lift_unary(v, |x| x.sin())?);
+                    stack.push(lift_unary(&v, |x| x.sin())?);
                 }
                 Op::Cos => {
                     let v = pop(stack)?;
-                    stack.push(lift_unary(v, |x| x.cos())?);
+                    stack.push(lift_unary(&v, |x| x.cos())?);
                 }
                 Op::Log => {
                     let v = pop(stack)?;
-                    stack.push(lift_unary(v, |x| x.ln())?);
+                    stack.push(lift_unary(&v, |x| x.ln())?);
                 }
 
                 Op::Eq => cmp_op(stack, |a, b| (a - b).abs() < f64::EPSILON)?,
@@ -1055,7 +1055,7 @@ impl Forth {
                     let key = read_key(&var_writes_cell, vars_snapshot);
                     let values = std::mem::take(stack);
                     for val in values {
-                        let result = lift_unary_int(val, |degree| {
+                        let result = lift_unary_int(&val, |degree| {
                             let octave_offset = degree.div_euclid(len);
                             let idx = degree.rem_euclid(len) as usize;
                             key + octave_offset * 12 + pattern[idx]
@@ -1155,7 +1155,7 @@ impl Forth {
                 Op::Oct => {
                     let shift = pop(stack)?;
                     let note = pop(stack)?;
-                    let result = lift_binary(note, shift, |n, s| n + s * 12.0)?;
+                    let result = lift_binary(&note, &shift, |n, s| n + s * 12.0)?;
                     stack.push(result);
                 }
 
@@ -1921,65 +1921,65 @@ fn float_to_value(result: f64) -> Value {
     }
 }
 
-fn lift_unary<F>(val: Value, f: F) -> Result<Value, String>
+fn lift_unary<F>(val: &Value, f: F) -> Result<Value, String>
 where
     F: Fn(f64) -> f64 + Copy,
 {
     match val {
         Value::ArpList(items) => {
-            let mapped: Result<Vec<_>, _> = items.iter().map(|x| lift_unary(x.clone(), f)).collect();
+            let mapped: Result<Vec<_>, _> = items.iter().map(|x| lift_unary(x, f)).collect();
             Ok(Value::ArpList(Arc::from(mapped?)))
         }
         Value::CycleList(items) => {
-            let mapped: Result<Vec<_>, _> = items.iter().map(|x| lift_unary(x.clone(), f)).collect();
+            let mapped: Result<Vec<_>, _> = items.iter().map(|x| lift_unary(x, f)).collect();
             Ok(Value::CycleList(Arc::from(mapped?)))
         }
         v => Ok(float_to_value(f(v.as_float()?))),
     }
 }
 
-fn lift_unary_int<F>(val: Value, f: F) -> Result<Value, String>
+fn lift_unary_int<F>(val: &Value, f: F) -> Result<Value, String>
 where
     F: Fn(i64) -> i64 + Copy,
 {
     match val {
         Value::ArpList(items) => {
             let mapped: Result<Vec<_>, _> =
-                items.iter().map(|x| lift_unary_int(x.clone(), f)).collect();
+                items.iter().map(|x| lift_unary_int(x, f)).collect();
             Ok(Value::ArpList(Arc::from(mapped?)))
         }
         Value::CycleList(items) => {
             let mapped: Result<Vec<_>, _> =
-                items.iter().map(|x| lift_unary_int(x.clone(), f)).collect();
+                items.iter().map(|x| lift_unary_int(x, f)).collect();
             Ok(Value::CycleList(Arc::from(mapped?)))
         }
         v => Ok(Value::Int(f(v.as_int()?), None)),
     }
 }
 
-fn lift_binary<F>(a: Value, b: Value, f: F) -> Result<Value, String>
+fn lift_binary<F>(a: &Value, b: &Value, f: F) -> Result<Value, String>
 where
     F: Fn(f64, f64) -> f64 + Copy,
 {
     match (a, b) {
         (Value::ArpList(items), b) => {
             let mapped: Result<Vec<_>, _> =
-                items.iter().map(|x| lift_binary(x.clone(), b.clone(), f)).collect();
+                items.iter().map(|x| lift_binary(x, b, f)).collect();
             Ok(Value::ArpList(Arc::from(mapped?)))
         }
         (a, Value::ArpList(items)) => {
             let mapped: Result<Vec<_>, _> =
-                items.iter().map(|x| lift_binary(a.clone(), x.clone(), f)).collect();
+                items.iter().map(|x| lift_binary(a, x, f)).collect();
             Ok(Value::ArpList(Arc::from(mapped?)))
         }
         (Value::CycleList(items), b) => {
             let mapped: Result<Vec<_>, _> =
-                items.iter().map(|x| lift_binary(x.clone(), b.clone(), f)).collect();
+                items.iter().map(|x| lift_binary(x, b, f)).collect();
             Ok(Value::CycleList(Arc::from(mapped?)))
         }
         (a, Value::CycleList(items)) => {
             let mapped: Result<Vec<_>, _> =
-                items.iter().map(|x| lift_binary(a.clone(), x.clone(), f)).collect();
+                items.iter().map(|x| lift_binary(a, x, f)).collect();
             Ok(Value::CycleList(Arc::from(mapped?)))
         }
         (a, b) => Ok(float_to_value(f(a.as_float()?, b.as_float()?))),
@@ -1992,7 +1992,7 @@ where
 {
     let b = pop(stack)?;
     let a = pop(stack)?;
-    stack.push(lift_binary(a, b, f)?);
+    stack.push(lift_binary(&a, &b, f)?);
     Ok(())
 }
 

crates/project/src/project.rs

@@ -170,6 +170,17 @@ impl LaunchQuantization {
         }
     }
 
+    pub fn short_label(&self) -> &'static str {
+        match self {
+            Self::Immediate => "Imm",
+            Self::Beat => "Bt",
+            Self::Bar => "1B",
+            Self::Bars2 => "2B",
+            Self::Bars4 => "4B",
+            Self::Bars8 => "8B",
+        }
+    }
+
     /// Cycle to the next longer quantization, clamped at `Bars8`.
     pub fn next(&self) -> Self {
         match self {
@@ -212,6 +223,13 @@ impl SyncMode {
         }
     }
 
+    pub fn short_label(&self) -> &'static str {
+        match self {
+            Self::Reset => "Rst",
+            Self::PhaseLock => "Plk",
+        }
+    }
+
     /// Toggle between Reset and PhaseLock.
     pub fn toggle(&self) -> Self {
         match self {

crates/ratatui/src/editor.rs

@@ -1,6 +1,7 @@
 //! Script editor widget with completion, search, and sample finder popups.
 
 use std::cell::Cell;
+use std::sync::Arc;
 
 use crate::theme;
 use ratatui::{
@@ -25,7 +26,7 @@ pub struct CompletionCandidate {
 }
 
 struct CompletionState {
-    candidates: Vec<CompletionCandidate>,
+    candidates: Arc<[CompletionCandidate]>,
     matches: Vec<usize>,
     cursor: usize,
     prefix: String,
@@ -37,7 +38,7 @@ struct CompletionState {
 impl CompletionState {
     fn new() -> Self {
         Self {
-            candidates: Vec::new(),
+            candidates: Arc::from([]),
             matches: Vec::new(),
             cursor: 0,
             prefix: String::new(),
@@ -171,7 +172,7 @@ impl Editor {
         self.scroll_offset.set(0);
     }
 
-    pub fn set_candidates(&mut self, candidates: Vec<CompletionCandidate>) {
+    pub fn set_candidates(&mut self, candidates: Arc<[CompletionCandidate]>) {
         self.completion.candidates = candidates;
     }
 

crates/ratatui/src/file_browser.rs

@@ -14,11 +14,14 @@ pub struct FileBrowserModal<'a> {
     title: &'a str,
     input: &'a str,
     entries: &'a [(String, bool, bool)],
+    audio_counts: &'a [Option<usize>],
     selected: usize,
     scroll_offset: usize,
     border_color: Option<Color>,
     width: u16,
     height: u16,
+    hints: Option<Line<'a>>,
+    color_path: bool,
 }
 
 impl<'a> FileBrowserModal<'a> {
@@ -27,11 +30,14 @@ impl<'a> FileBrowserModal<'a> {
             title,
             input,
             entries,
+            audio_counts: &[],
             selected: 0,
             scroll_offset: 0,
             border_color: None,
             width: 60,
             height: 16,
+            hints: None,
+            color_path: false,
         }
     }
 
@@ -60,6 +66,21 @@ impl<'a> FileBrowserModal<'a> {
         self
     }
 
+    pub fn hints(mut self, hints: Line<'a>) -> Self {
+        self.hints = Some(hints);
+        self
+    }
+
+    pub fn audio_counts(mut self, counts: &'a [Option<usize>]) -> Self {
+        self.audio_counts = counts;
+        self
+    }
+
+    pub fn color_path(mut self) -> Self {
+        self.color_path = true;
+        self
+    }
+
     pub fn render_centered(self, frame: &mut Frame, term: Rect) -> Rect {
         let colors = theme::get();
         let border_color = self.border_color.unwrap_or(colors.ui.text_primary);
@@ -70,37 +91,61 @@ impl<'a> FileBrowserModal<'a> {
             .border_color(border_color)
             .render_centered(frame, term);
 
-        let rows = Layout::vertical([Constraint::Length(1), Constraint::Min(1)]).split(inner);
+        let has_hints = self.hints.is_some();
+        let constraints = if has_hints {
+            vec![
+                Constraint::Length(1),
+                Constraint::Min(1),
+                Constraint::Length(1),
+            ]
+        } else {
+            vec![Constraint::Length(1), Constraint::Min(1)]
+        };
+        let rows = Layout::vertical(constraints).split(inner);
 
         // Input line
-        frame.render_widget(
+        let input_spans = if self.color_path {
-            Paragraph::new(Line::from(vec![
+            let (path_part, filter_part) = match self.input.rfind('/') {
+                Some(pos) => (&self.input[..=pos], &self.input[pos + 1..]),
+                None => ("", self.input),
+            };
+            vec![
+                Span::raw("> "),
+                Span::styled(path_part.to_string(), Style::new().fg(colors.browser.directory)),
+                Span::styled(filter_part.to_string(), Style::new().fg(colors.input.text)),
+                Span::styled("█", Style::new().fg(colors.input.cursor)),
+            ]
+        } else {
+            vec![
                 Span::raw("> "),
                 Span::styled(self.input, Style::new().fg(colors.input.text)),
                 Span::styled("█", Style::new().fg(colors.input.cursor)),
-            ])),
+            ]
-            rows[0],
+        };
+        frame.render_widget(Paragraph::new(Line::from(input_spans)), rows[0]);
+
+        // Hints bar
+        if let Some(hints) = self.hints {
+            let hint_row = rows[2];
+            frame.render_widget(
+                Paragraph::new(hints).alignment(ratatui::layout::Alignment::Right),
+                hint_row,
             );
+        }
 
         // Entries list
         let visible_height = rows[1].height as usize;
         let visible_entries = self
             .entries
             .iter()
+            .enumerate()
             .skip(self.scroll_offset)
             .take(visible_height);
 
         let lines: Vec<Line> = visible_entries
-            .enumerate()
+            .map(|(abs_idx, (name, is_dir, is_cagire))| {
-            .map(|(i, (name, is_dir, is_cagire))| {
-                let abs_idx = i + self.scroll_offset;
                 let is_selected = abs_idx == self.selected;
                 let prefix = if is_selected { "> " } else { "  " };
-                let display = if *is_dir {
-                    format!("{prefix}{name}/")
-                } else {
-                    format!("{prefix}{name}")
-                };
                 let color = if is_selected {
                     colors.browser.selected
                 } else if *is_dir {
@@ -110,7 +155,21 @@ impl<'a> FileBrowserModal<'a> {
                 } else {
                     colors.browser.file
                 };
-                Line::from(Span::styled(display, Style::new().fg(color)))
+                let display = if *is_dir {
+                    format!("{prefix}{name}/")
+                } else {
+                    format!("{prefix}{name}")
+                };
+                let mut spans = vec![Span::styled(display, Style::new().fg(color))];
+                if *is_dir && name != ".." {
+                    if let Some(Some(count)) = self.audio_counts.get(abs_idx) {
+                        spans.push(Span::styled(
+                            format!("  ({count})"),
+                            Style::new().fg(colors.browser.file),
+                        ));
+                    }
+                }
+                Line::from(spans)
             })
             .collect();
 

crates/ratatui/src/sample_browser.rs

@@ -23,6 +23,7 @@ pub struct TreeLine {
     pub label: String,
     pub folder: String,
     pub index: usize,
+    pub child_count: usize,
 }
 
 /// Tree-view browser for navigating sample folders.
@@ -163,15 +164,43 @@ impl<'a> SampleBrowser<'a> {
                 Style::new().fg(icon_color)
             };
 
+            let prefix_width = indent.len() + 2; // indent + icon
+            let suffix = match entry.kind {
+                TreeLineKind::File => format!(" {}", entry.index),
+                TreeLineKind::Root { expanded: false }
+                | TreeLineKind::Folder { expanded: false }
+                    if entry.child_count > 0 =>
+                {
+                    format!("  ({})", entry.child_count)
+                }
+                _ => String::new(),
+            };
+            let max_label = (area.width as usize)
+                .saturating_sub(prefix_width)
+                .saturating_sub(suffix.len());
+            let label: std::borrow::Cow<str> = if entry.label.len() > max_label && max_label > 1 {
+                let truncated: String = entry.label.chars().take(max_label - 1).collect();
+                format!("{}\u{2026}", truncated).into()
+            } else {
+                (&entry.label).into()
+            };
+
             let mut spans = vec![
                 Span::raw(indent),
                 Span::styled(icon, icon_style),
-                Span::styled(&entry.label, label_style),
+                Span::styled(label, label_style),
             ];
 
-            if matches!(entry.kind, TreeLineKind::File) {
+            match entry.kind {
+                TreeLineKind::File => {
                     let idx_style = Style::new().fg(colors.browser.empty_text);
-                spans.push(Span::styled(format!(" {}", entry.index), idx_style));
+                    spans.push(Span::styled(suffix, idx_style));
+                }
+                _ if !suffix.is_empty() => {
+                    let dim_style = Style::new().fg(colors.browser.empty_text);
+                    spans.push(Span::styled(suffix, dim_style));
+                }
+                _ => {}
             }
 
             lines.push(Line::from(spans));

docs/getting-started/banks_patterns.md

@@ -31,7 +31,7 @@ Each pattern is an independent sequence of steps with its own properties:
 | Sync Mode | Reset or Phase-Lock on re-trigger | `Reset` |
 | Follow Up | What happens when the pattern finishes an iteration | `Loop` |
 
-Press `e` in the patterns view to edit these settings. After editing properties, you will have to hit the `c` key to _commit_ these changes. More about that later!
+Press `e` in the patterns view to edit these settings. After editing properties, you will have to hit the `c` key to _launch_ these changes. More about that later!
 
 ### Follow Up
 
@@ -46,12 +46,12 @@ The follow-up action determines what happens when a pattern reaches the end of i
 Access the patterns view with `F2` (or `Ctrl+Up` from the sequencer). The view shows all banks and patterns in a grid. Indicators show pattern state:
 
 - `>` Currently playing
-- `+` Staged to play
+- `+` Armed to play
-- `-` Staged to stop
+- `-` Armed to stop
 - `M` Muted
 - `S` Soloed
 
-It is quite essential for you to understand the stage / commit system in order to use patterns. Please read the next section carefully!
+It is quite essential for you to understand the arm / launch system in order to use patterns. Please read the next section carefully!
 
 ### Keybindings
 
@@ -59,13 +59,13 @@ It is quite essential for you to understand the stage / commit system in order t
 |-----|--------|
 | `Arrows` | Navigate banks and patterns |
 | `Enter` | Select and return to sequencer |
-| `p` | Stage pattern to play/stop |
+| `p` | Arm pattern to play/stop |
-| `c` | Commit staged changes |
+| `c` | Launch armed changes |
-| `m` / `x` | Stage mute / solo toggle |
+| `m` / `x` | Arm mute / solo toggle |
 | `e` | Edit pattern properties |
 | `r` | Rename bank or pattern |
 | `Ctrl+c` / `Ctrl+v` | Copy / Paste |
 | `Delete` | Reset to empty pattern |
-| `Esc` | Cancel staged changes |
+| `Esc` | Cancel armed changes |
 
 

docs/getting-started/staging.md

@@ -1,35 +1,35 @@
-# Stage / Commit
+# Arm / Launch
 
-In Cagire, changes to playback happen in two steps. First you **stage**: you mark what you want to happen. Then you **commit**: you apply all staged changes at once. Nothing changes until you commit. It is simpler than it sounds.
+In Cagire, changes to playback happen in two steps. First you **arm**: you mark what you want to happen. Then you **launch**: you apply all armed changes at once. Nothing changes until you launch. It is simpler than it sounds.
 
-Say you want patterns `04` and `05` to start playing together. You stage both (`p` on each), then commit (`c`). Both start at the same time. Want to stop them later? Stage them again, commit again. That's it.
+Say you want patterns `04` and `05` to start playing together. You arm both (`p` on each), then launch (`c`). Both start at the same time. Want to stop them later? Arm them again, launch again. That's it.
 
 This two-step process exists for good reasons:
 
-- **Multiple changes at once**: queue several patterns to start/stop, commit them together.
+- **Multiple changes at once**: queue several patterns to start/stop, launch them together.
 - **Clean timing**: all changes land on beat or bar boundaries, never mid-step.
 - **Safe preparation**: set up the next section while the current one keeps playing.
 
-## Push changes, then apply
+## Arm changes, then launch
 
-Staging is an essential feature to understand to be effective when doing live performances:
+Arming is an essential feature to understand to be effective when doing live performances:
 
 1. Open the **Patterns** view (`F2` or `Ctrl+Up` from sequencer)
 2. Navigate to a pattern you wish to change/play
-3. Press `p` to stage it. The pending change is going to be displayed:
+3. Press `p` to arm it. The pending change is going to be displayed:
-   - `+` (staged to play)
+   - `+` (armed to play)
-   - `-` (staged to stop)
+   - `-` (armed to stop)
-   - `m` (staged to mute)
+   - `m` (armed to mute)
-   - `s` (staged to solo)
+   - `s` (armed to solo)
    - etc.
 4. Repeat for other patterns you want to change
-5. Press `c` to commit all changes
+5. Press `c` to launch all changes
 6. Or press `Esc` to cancel
 
-You can also stage mute/solo changes:
+You can also arm mute/solo changes:
 
-- Press `m` to stage a mute toggle
+- Press `m` to arm a mute toggle
-- Press `x` to stage a solo toggle
+- Press `x` to arm a solo toggle
 - Press `Shift+m` to clear all mutes
 - Press `Shift+x` to clear all solos
 
@@ -41,16 +41,18 @@ It might wait for the next beat/bar boundary.
 | Indicator | Meaning |
 |-----------|---------|
 | `>` | Currently playing |
-| `+` | Staged to play |
+| `+` | Armed to play |
-| `-` | Staged to stop |
+| `-` | Armed to stop |
 | `M` | Muted |
 | `S` | Soloed |
 
-A pattern can show combined indicators, e.g. `>` (playing) and `-` (staged to stop), or `>M` (playing and muted).
+A pattern can show combined indicators, e.g. `>` (playing) and `-` (armed to stop), or `>M` (playing and muted).
+
+Armed patterns blink to make pending changes impossible to miss.
 
 ## Quantization
 
-Committed changes don't execute immediately. They wait for a quantization boundary:
+Launched changes don't execute immediately. They wait for a quantization boundary:
 
 | Setting | Behavior |
 |---------|----------|

src/app/dispatch.rs

@@ -215,7 +215,7 @@ impl App {
                     },
                 );
                 self.ui
-                    .set_status(format!("{} props staged", bp_label(bank, pattern)));
+                    .set_status(format!("{} props armed", bp_label(bank, pattern)));
             }
 
             // Page navigation

src/app/mod.rs

@@ -29,7 +29,7 @@ use crate::state::{
     ProjectState, ScriptEditorState, UiState,
 };
 
-static COMPLETION_CANDIDATES: LazyLock<Vec<CompletionCandidate>> = LazyLock::new(|| {
+static COMPLETION_CANDIDATES: LazyLock<Arc<[CompletionCandidate]>> = LazyLock::new(|| {
     model::WORDS
         .iter()
         .map(|w| CompletionCandidate {

src/app/scripting.rs

@@ -1,5 +1,7 @@
 //! Forth script compilation, evaluation, and editor ↔ step synchronization.
 
+use std::sync::Arc;
+
 use crossbeam_channel::Sender;
 
 use crate::engine::LinkState;
@@ -55,7 +57,7 @@ impl App {
                 script.lines().map(String::from).collect()
             };
             self.editor_ctx.editor.set_content(lines);
-            self.editor_ctx.editor.set_candidates(COMPLETION_CANDIDATES.clone());
+            self.editor_ctx.editor.set_candidates(Arc::clone(&COMPLETION_CANDIDATES));
             self.editor_ctx
                 .editor
                 .set_completion_enabled(self.ui.show_completion);
@@ -87,7 +89,7 @@ impl App {
             prelude.lines().map(String::from).collect()
         };
         self.editor_ctx.editor.set_content(lines);
-        self.editor_ctx.editor.set_candidates(COMPLETION_CANDIDATES.clone());
+        self.editor_ctx.editor.set_candidates(Arc::clone(&COMPLETION_CANDIDATES));
         self.editor_ctx
             .editor
             .set_completion_enabled(self.ui.show_completion);
@@ -190,7 +192,7 @@ impl App {
             script.lines().map(String::from).collect()
         };
         self.script_editor.editor.set_content(lines);
-        self.script_editor.editor.set_candidates(COMPLETION_CANDIDATES.clone());
+        self.script_editor.editor.set_candidates(Arc::clone(&COMPLETION_CANDIDATES));
         self.script_editor
             .editor
             .set_completion_enabled(self.ui.show_completion);

src/app/staging.rs

@@ -24,7 +24,7 @@ impl App {
         if let Some(idx) = existing {
             self.playback.staged_changes.remove(idx);
             self.ui
-                .set_status(format!("{} unstaged", bp_label(bank, pattern)));
+                .set_status(format!("{} disarmed", bp_label(bank, pattern)));
         } else if is_playing {
             self.playback.staged_changes.push(StagedChange {
                 change: PatternChange::Stop { bank, pattern },
@@ -32,7 +32,7 @@ impl App {
                 sync_mode: pattern_data.sync_mode,
             });
             self.ui
-                .set_status(format!("{} staged to stop", bp_label(bank, pattern)));
+                .set_status(format!("{} armed to stop", bp_label(bank, pattern)));
         } else {
             self.playback.staged_changes.push(StagedChange {
                 change: PatternChange::Start { bank, pattern },
@@ -40,7 +40,7 @@ impl App {
                 sync_mode: pattern_data.sync_mode,
             });
             self.ui
-                .set_status(format!("{} staged to play", bp_label(bank, pattern)));
+                .set_status(format!("{} armed to play", bp_label(bank, pattern)));
         }
     }
 
@@ -52,7 +52,7 @@ impl App {
         let prop_count = self.playback.staged_prop_changes.len();
 
         if pattern_count == 0 && mute_count == 0 && prop_count == 0 {
-            self.ui.set_status("No changes to commit".to_string());
+            self.ui.set_status("No changes to launch".to_string());
             return false;
         }
 
@@ -90,7 +90,7 @@ impl App {
         }
 
         let total = pattern_count + mute_count + prop_count;
-        let status = format!("Committed {total} changes");
+        let status = format!("Launched {total} changes");
         self.ui.set_status(status);
 
         mute_changed
@@ -110,7 +110,7 @@ impl App {
         self.playback.staged_prop_changes.clear();
 
         let total = pattern_count + mute_count + prop_count;
-        let status = format!("Cleared {total} staged changes");
+        let status = format!("Cleared {total} armed changes");
         self.ui.set_status(status);
     }
 }

src/engine/audio.rs

@@ -413,10 +413,16 @@ pub fn build_stream(
                 },
                 {
                     let device_lost = Arc::clone(&device_lost);
-                    move |err| {
+                    move |err: cpal::StreamError| {
                         eprintln!("input stream error: {err}");
+                        match err {
+                            cpal::StreamError::DeviceNotAvailable
+                            | cpal::StreamError::StreamInvalidated => {
                                 device_lost.store(true, Ordering::Release);
                             }
+                            _ => {}
+                        }
+                    }
                 },
                 None,
             )
@@ -528,9 +534,15 @@ pub fn build_stream(
                     let _ = fft_producer.try_push(mono);
                 }
             },
-            move |err| {
+            move |err: cpal::StreamError| {
                 let _ = error_tx.try_send(format!("stream error: {err}"));
+                match err {
+                    cpal::StreamError::DeviceNotAvailable
+                    | cpal::StreamError::StreamInvalidated => {
                         device_lost.store(true, Ordering::Release);
+                    }
+                    _ => {}
+                }
             },
             None,
         )

src/engine/sequencer.rs

@@ -555,7 +555,7 @@ pub struct SequencerState {
     pattern_cache: PatternCache,
     pending_updates: HashMap<(usize, usize), PatternSnapshot>,
     runs_counter: RunsCounter,
-    step_traces: StepTracesMap,
+    step_traces: Arc<StepTracesMap>,
     event_count: usize,
     script_engine: ScriptEngine,
     variables: Variables,
@@ -593,7 +593,7 @@ impl SequencerState {
             pattern_cache: PatternCache::new(),
             pending_updates: HashMap::new(),
             runs_counter: RunsCounter::new(),
-            step_traces: HashMap::new(),
+            step_traces: Arc::new(HashMap::new()),
             event_count: 0,
             script_engine,
             variables,
@@ -713,7 +713,7 @@ impl SequencerState {
                     self.audio_state.active_patterns.clear();
                     self.audio_state.pending_starts.clear();
                     self.audio_state.pending_stops.clear();
-                    self.step_traces.clear();
+                    self.step_traces = Arc::new(HashMap::new());
                     self.runs_counter.counts.clear();
                     self.audio_state.flush_midi_notes = true;
                 }
@@ -731,7 +731,7 @@ impl SequencerState {
                     self.speed_overrides.clear();
                     self.script_engine.clear_global_params();
                     self.runs_counter.counts.clear();
-                    self.step_traces.clear();
+                    self.step_traces = Arc::new(HashMap::new());
                     self.audio_state.flush_midi_notes = true;
                 }
                 SeqCommand::ResetScriptState => {
@@ -811,7 +811,7 @@ impl SequencerState {
     fn tick_paused(&mut self) -> TickOutput {
         for pending in self.audio_state.pending_stops.drain(..) {
             self.audio_state.active_patterns.remove(&pending.id);
-            self.step_traces.retain(|&(bank, pattern, _), _| {
+            Arc::make_mut(&mut self.step_traces).retain(|&(bank, pattern, _), _| {
                 bank != pending.id.bank || pattern != pending.id.pattern
             });
             let key = (pending.id.bank, pending.id.pattern);
@@ -894,7 +894,7 @@ impl SequencerState {
         for pending in &self.audio_state.pending_stops {
             if check_quantization_boundary(pending.quantization, beat, prev_beat, quantum) {
                 self.audio_state.active_patterns.remove(&pending.id);
-                self.step_traces.retain(|&(bank, pattern, _), _| {
+                Arc::make_mut(&mut self.step_traces).retain(|&(bank, pattern, _), _| {
                     bank != pending.id.bank || pattern != pending.id.pattern
                 });
                 // Flush pending update so cache stays current for future launches
@@ -1015,7 +1015,7 @@ impl SequencerState {
                                     .script_engine
                                     .evaluate_with_trace(script, &ctx, &mut trace)
                                 {
-                                    self.step_traces.insert(
+                                    Arc::make_mut(&mut self.step_traces).insert(
                                         (active.bank, active.pattern, source_idx),
                                         std::mem::take(&mut trace),
                                     );
@@ -1229,7 +1229,7 @@ impl SequencerState {
                     last_step_beat: a.last_step_beat,
                 })
                 .collect(),
-            step_traces: Arc::new(self.step_traces.clone()),
+            step_traces: Arc::clone(&self.step_traces),
             event_count: self.event_count,
             tempo: self.last_tempo,
             beat: self.last_beat,

src/input/engine_page.rs

@@ -267,7 +267,8 @@ pub(super) fn handle_engine_page(ctx: &mut InputContext, key: KeyEvent) -> Input
         }
         KeyCode::Char('A') if ctx.app.audio.section == EngineSection::Samples => {
             use crate::state::file_browser::FileBrowserState;
-            let state = FileBrowserState::new_load(String::new());
+            let mut state = FileBrowserState::new_load(String::new());
+            state.compute_audio_counts();
             ctx.dispatch(AppCommand::OpenModal(Modal::AddSamplePath(Box::new(state))));
         }
         KeyCode::Char('D') => {

src/input/main_page.rs

@@ -79,9 +79,6 @@ pub(super) fn handle_main_page(ctx: &mut InputContext, key: KeyEvent, ctrl: bool
             let current = format!("{:.1}", ctx.link.tempo());
             ctx.dispatch(AppCommand::OpenModal(Modal::SetTempo(current)));
         }
-        KeyCode::Char(':') => {
-            ctx.dispatch(AppCommand::OpenModal(Modal::JumpToStep(String::new())));
-        }
         KeyCode::Char('<') | KeyCode::Char(',') => ctx.dispatch(AppCommand::LengthDecrease),
         KeyCode::Char('>') | KeyCode::Char('.') => ctx.dispatch(AppCommand::LengthIncrease),
         KeyCode::Char('[') => ctx.dispatch(AppCommand::SpeedDecrease),

src/input/mod.rs

@@ -179,6 +179,19 @@ fn handle_normal_input(ctx: &mut InputContext, key: KeyEvent) -> InputResult {
         return InputResult::Continue;
     }
 
+    if key.code == KeyCode::Char(':') {
+        let in_search = ctx.app.ui.dict_search_active || ctx.app.ui.help_search_active;
+        let in_script = ctx.app.page == Page::Script && ctx.app.script_editor.focused;
+        if !in_search && !in_script {
+            ctx.dispatch(AppCommand::OpenModal(Modal::CommandPalette {
+                input: String::new(),
+                cursor: 0,
+                scroll: 0,
+            }));
+            return InputResult::Continue;
+        }
+    }
+
     match ctx.app.page {
         Page::Main => main_page::handle_main_page(ctx, key, ctrl),
         Page::Patterns => patterns_page::handle_patterns_page(ctx, key),

src/input/modal.rs

@@ -10,6 +10,49 @@ use crate::state::{
 };
 
 pub(super) fn handle_modal_input(ctx: &mut InputContext, key: KeyEvent) -> InputResult {
+    // Handle CommandPalette before the main match to avoid borrow conflicts
+    // (Enter needs &App for palette_entries while the match borrows &mut modal)
+    if let Modal::CommandPalette { input, cursor, scroll } = &mut ctx.app.ui.modal {
+        match key.code {
+            KeyCode::Esc => ctx.dispatch(AppCommand::CloseModal),
+            KeyCode::Char(c) => {
+                input.push(c);
+                *cursor = 0;
+                *scroll = 0;
+            }
+            KeyCode::Backspace => {
+                input.pop();
+                *cursor = 0;
+                *scroll = 0;
+            }
+            KeyCode::Up if key.modifiers.contains(KeyModifiers::CONTROL) => {
+                *cursor = cursor.saturating_sub(5);
+            }
+            KeyCode::Down if key.modifiers.contains(KeyModifiers::CONTROL) => {
+                *cursor += 5;
+            }
+            KeyCode::Up => {
+                *cursor = cursor.saturating_sub(1);
+            }
+            KeyCode::Down => {
+                *cursor += 1;
+            }
+            KeyCode::PageUp => {
+                *cursor = cursor.saturating_sub(10);
+            }
+            KeyCode::PageDown => {
+                *cursor += 10;
+            }
+            KeyCode::Enter => {
+                let query = input.clone();
+                let cursor_val = *cursor;
+                handle_palette_enter(ctx, &query, cursor_val);
+            }
+            _ => {}
+        }
+        return InputResult::Continue;
+    }
+
     match &mut ctx.app.ui.modal {
         Modal::Confirm { action, selected } => {
             let confirmed = *selected;
@@ -179,22 +222,6 @@ pub(super) fn handle_modal_input(ctx: &mut InputContext, key: KeyEvent) -> Input
             KeyCode::Char(c) => input.push(c),
             _ => {}
         },
-        Modal::JumpToStep(input) => match key.code {
-            KeyCode::Enter => {
-                if let Ok(step) = input.parse::<usize>() {
-                    if step > 0 {
-                        ctx.dispatch(AppCommand::GoToStep(step - 1));
-                    }
-                }
-                ctx.dispatch(AppCommand::CloseModal);
-            }
-            KeyCode::Esc => ctx.dispatch(AppCommand::CloseModal),
-            KeyCode::Backspace => {
-                input.pop();
-            }
-            KeyCode::Char(c) if c.is_ascii_digit() => input.push(c),
-            _ => {}
-        },
         Modal::SetTempo(input) => match key.code {
             KeyCode::Enter => {
                 if let Ok(tempo) = input.parse::<f64>() {
@@ -222,8 +249,12 @@ pub(super) fn handle_modal_input(ctx: &mut InputContext, key: KeyEvent) -> Input
                         Some(state.current_dir().join(&entry.name))
                     } else if entry.is_dir {
                         state.enter_selected();
+                        state.compute_audio_counts();
                         None
                     } else {
+                        ctx.dispatch(AppCommand::SetStatus(
+                            "Select a directory, not a file".into(),
+                        ));
                         None
                     }
                 } else {
@@ -261,15 +292,16 @@ pub(super) fn handle_modal_input(ctx: &mut InputContext, key: KeyEvent) -> Input
                 }
             }
             KeyCode::Esc => ctx.dispatch(AppCommand::CloseModal),
-            KeyCode::Tab => state.autocomplete(),
+            KeyCode::Tab => { state.autocomplete(); state.compute_audio_counts(); }
-            KeyCode::Left => state.go_up(),
+            KeyCode::Left => { state.go_up(); state.compute_audio_counts(); }
-            KeyCode::Right => state.enter_selected(),
+            KeyCode::Right => { state.enter_selected(); state.compute_audio_counts(); }
-            KeyCode::Up => state.select_prev(14),
+            KeyCode::Up => state.select_prev(16),
-            KeyCode::Down => state.select_next(14),
+            KeyCode::Down => state.select_next(16),
-            KeyCode::Backspace => state.backspace(),
+            KeyCode::Backspace => { state.backspace(); state.compute_audio_counts(); }
             KeyCode::Char(c) => {
                 state.input.push(c);
                 state.refresh_entries();
+                state.compute_audio_counts();
             }
             _ => {}
         },
@@ -514,7 +546,7 @@ pub(super) fn handle_modal_input(ctx: &mut InputContext, key: KeyEvent) -> Input
             }
         }
         Modal::KeybindingsHelp { scroll } => {
-            let bindings_count = crate::views::keybindings::bindings_for(ctx.app.page, ctx.app.plugin_mode).len();
+            let bindings_count = crate::model::palette::bindings_for(ctx.app.page, ctx.app.plugin_mode).len();
             match key.code {
                 KeyCode::Esc | KeyCode::Char('?') => ctx.dispatch(AppCommand::CloseModal),
                 KeyCode::Up | KeyCode::Char('k') => {
@@ -636,6 +668,7 @@ pub(super) fn handle_modal_input(ctx: &mut InputContext, key: KeyEvent) -> Input
                 _ => ctx.dispatch(AppCommand::CloseModal),
             }
         }
+        Modal::CommandPalette { .. } => unreachable!(),
         Modal::None => unreachable!(),
     }
     InputResult::Continue
@@ -670,6 +703,97 @@ fn execute_confirm(ctx: &mut InputContext, action: &ConfirmAction) -> InputResul
     InputResult::Continue
 }
 
+fn handle_palette_enter(ctx: &mut InputContext, query: &str, cursor: usize) {
+    let page = ctx.app.page;
+    let plugin_mode = ctx.app.plugin_mode;
+
+    // Numeric input on Main page → jump to step
+    if page == crate::page::Page::Main
+        && !query.is_empty()
+        && query.chars().all(|c| c.is_ascii_digit())
+    {
+        if let Ok(step) = query.parse::<usize>() {
+            if step > 0 {
+                ctx.dispatch(AppCommand::GoToStep(step - 1));
+            }
+        }
+        ctx.dispatch(AppCommand::CloseModal);
+        return;
+    }
+
+    let entries = crate::model::palette::palette_entries(query, plugin_mode, ctx.app);
+    if let Some(entry) = entries.get(cursor) {
+        ctx.dispatch(AppCommand::CloseModal);
+        execute_palette_entry(ctx, entry);
+    } else {
+        ctx.dispatch(AppCommand::CloseModal);
+    }
+}
+
+fn execute_palette_entry(
+    ctx: &mut InputContext,
+    entry: &crate::model::palette::CommandEntry,
+) {
+    use crate::model::palette::PaletteAction;
+    use std::sync::atomic::Ordering;
+
+    match &entry.action {
+        Some(PaletteAction::Resolve(f)) => {
+            if let Some(cmd) = f(ctx.app) {
+                ctx.dispatch(cmd);
+            }
+        }
+        Some(PaletteAction::Save) => super::open_save(ctx),
+        Some(PaletteAction::Load) => super::open_load(ctx),
+        Some(PaletteAction::TogglePlaying) => {
+            ctx.dispatch(AppCommand::TogglePlaying);
+            ctx.playing
+                .store(ctx.app.playback.playing, Ordering::Relaxed);
+        }
+        Some(PaletteAction::MuteToggle) => {
+            let (bank, pattern) = (ctx.app.editor_ctx.bank, ctx.app.editor_ctx.pattern);
+            ctx.app.playback.toggle_mute(bank, pattern);
+            ctx.app.send_mute_state(ctx.seq_cmd_tx);
+        }
+        Some(PaletteAction::SoloToggle) => {
+            let (bank, pattern) = (ctx.app.editor_ctx.bank, ctx.app.editor_ctx.pattern);
+            ctx.app.playback.toggle_solo(bank, pattern);
+            ctx.app.send_mute_state(ctx.seq_cmd_tx);
+        }
+        Some(PaletteAction::ClearMutes) => {
+            ctx.dispatch(AppCommand::ClearMutes);
+            ctx.app.send_mute_state(ctx.seq_cmd_tx);
+        }
+        Some(PaletteAction::ClearSolos) => {
+            ctx.dispatch(AppCommand::ClearSolos);
+            ctx.app.send_mute_state(ctx.seq_cmd_tx);
+        }
+        Some(PaletteAction::Hush) => {
+            let _ = ctx
+                .audio_tx
+                .load()
+                .send(crate::engine::AudioCommand::Hush);
+        }
+        Some(PaletteAction::Panic) => {
+            let _ = ctx
+                .audio_tx
+                .load()
+                .send(crate::engine::AudioCommand::Panic);
+            let _ = ctx.seq_cmd_tx.send(SeqCommand::StopAll);
+        }
+        Some(PaletteAction::TestTone) => {
+            let _ = ctx
+                .audio_tx
+                .load()
+                .send(crate::engine::AudioCommand::Evaluate {
+                    cmd: "/sound/sine/dur/0.5/decay/0.2".into(),
+                    time: None,
+                });
+        }
+        None => {}
+    }
+}
+
 fn rename_command(target: &RenameTarget, name: Option<String>) -> AppCommand {
     match target {
         RenameTarget::Bank { bank } => AppCommand::RenameBank { bank: *bank, name },

src/input/mouse.rs

@@ -211,6 +211,21 @@ fn handle_scroll(ctx: &mut InputContext, col: u16, row: u16, term: Rect, up: boo
         return;
     }
 
+    // Scroll over side panel area
+    if ctx.app.panel.visible && ctx.app.panel.side.is_some() {
+        let (_main_area, side_area) = panel_split(body);
+        if contains(side_area, col, row) {
+            if let Some(crate::state::SidePanel::SampleBrowser(state)) = &mut ctx.app.panel.side {
+                if up {
+                    state.move_up();
+                } else {
+                    state.move_down();
+                }
+            }
+            return;
+        }
+    }
+
     match ctx.app.page {
         Page::Main => {
             if up {
@@ -356,25 +371,60 @@ fn handle_footer_click(ctx: &mut InputContext, col: u16, row: u16, footer: Rect)
 
 // --- Body ---
 
-fn handle_body_click(ctx: &mut InputContext, col: u16, row: u16, body: Rect, kind: ClickKind) {
+fn panel_split(body: Rect) -> (Rect, Rect) {
-    // Account for side panel splitting
-    let page_area = if ctx.app.panel.visible && ctx.app.panel.side.is_some() {
     if body.width >= 120 {
         let panel_width = body.width * 35 / 100;
-            let [main, _side] =
+        let [main, side] =
             Layout::horizontal([Constraint::Fill(1), Constraint::Length(panel_width)])
                 .areas(body);
-            main
+        (main, side)
     } else {
         let panel_height = body.height * 40 / 100;
-            let [main, _side] =
+        let [main, side] =
             Layout::vertical([Constraint::Fill(1), Constraint::Length(panel_height)])
                 .areas(body);
-            main
+        (main, side)
     }
+}
+
+fn handle_body_click(ctx: &mut InputContext, col: u16, row: u16, body: Rect, kind: ClickKind) {
+    use crate::state::PanelFocus;
+
+    if ctx.app.panel.visible && ctx.app.panel.side.is_some() {
+        let (main_area, side_area) = panel_split(body);
+
+        if contains(side_area, col, row) {
+            ctx.app.panel.focus = PanelFocus::Side;
+            return;
+        }
+
+        // Click on main area: defocus panel
+        if contains(main_area, col, row) {
+            if kind == ClickKind::Double {
+                ctx.dispatch(AppCommand::ClosePanel);
             } else {
-        body
+                ctx.app.panel.focus = PanelFocus::Main;
-    };
+            }
+        }
+
+        // Fall through to page-specific handler with main_area
+        if !contains(main_area, col, row) {
+            return;
+        }
+
+        match ctx.app.page {
+            Page::Main => handle_main_click(ctx, col, row, main_area, kind),
+            Page::Patterns => handle_patterns_click(ctx, col, row, main_area, kind),
+            Page::Help => handle_help_click(ctx, col, row, main_area),
+            Page::Dict => handle_dict_click(ctx, col, row, main_area),
+            Page::Options => handle_options_click(ctx, col, row, main_area),
+            Page::Engine => handle_engine_click(ctx, col, row, main_area, kind),
+            Page::Script => handle_script_click(ctx, col, row, main_area),
+        }
+        return;
+    }
+
+    let page_area = body;
 
     if !contains(page_area, col, row) {
         return;
@@ -983,10 +1033,12 @@ fn handle_modal_click(ctx: &mut InputContext, col: u16, row: u16, term: Rect) {
                 Modal::PatternProps { .. } => (50, 18),
                 Modal::EuclideanDistribution { .. } => (50, 11),
                 Modal::Onboarding { .. } => (57, 20),
-                Modal::FileBrowser(_) | Modal::AddSamplePath(_) => (60, 18),
+                Modal::FileBrowser(_) => (60, 18),
+                Modal::AddSamplePath(_) => (70, 20),
                 Modal::Rename { .. } => (40, 5),
                 Modal::SetPattern { .. } | Modal::SetScript { .. } => (45, 5),
-                Modal::SetTempo(_) | Modal::JumpToStep(_) => (30, 5),
+                Modal::SetTempo(_) => (30, 5),
+                Modal::CommandPalette { .. } => (55, 20),
                 _ => return,
             };
             let modal_area = centered_rect(term, w, h);

src/input/panel.rs

@@ -41,7 +41,7 @@ pub(super) fn handle_panel_input(ctx: &mut InputContext, key: KeyEvent) -> Input
             }
             KeyCode::Down => {
                 for _ in 0..10 {
-                    state.move_down(30);
+                    state.move_down();
                 }
             }
             _ => {}
@@ -49,7 +49,7 @@ pub(super) fn handle_panel_input(ctx: &mut InputContext, key: KeyEvent) -> Input
     } else {
         match key.code {
             KeyCode::Up | KeyCode::Char('k') => state.move_up(),
-            KeyCode::Down | KeyCode::Char('j') => state.move_down(30),
+            KeyCode::Down | KeyCode::Char('j') => state.move_down(),
             KeyCode::PageUp => {
                 for _ in 0..20 {
                     state.move_up();
@@ -57,7 +57,7 @@ pub(super) fn handle_panel_input(ctx: &mut InputContext, key: KeyEvent) -> Input
             }
             KeyCode::PageDown => {
                 for _ in 0..20 {
-                    state.move_down(30);
+                    state.move_down();
                 }
             }
             KeyCode::Enter | KeyCode::Right => {
@@ -71,6 +71,10 @@ pub(super) fn handle_panel_input(ctx: &mut InputContext, key: KeyEvent) -> Input
                                 .audio_tx
                                 .load()
                                 .send(AudioCommand::Evaluate { cmd, time: None });
+                            ctx.dispatch(AppCommand::SetStatus(format!(
+                                "\u{25B8} {}/{}",
+                                folder, entry.label
+                            )));
                         }
                         _ => state.toggle_expand(),
                     }

src/main.rs

@@ -355,10 +355,16 @@ fn main() -> io::Result<()> {
         let elapsed = last_frame.elapsed();
         last_frame = Instant::now();
 
+        let has_armed = app.playback.has_armed();
+        if has_armed {
+            let rate = std::f32::consts::TAU; // 1 Hz full cycle
+            app.ui.pulse_phase = (app.ui.pulse_phase + elapsed.as_secs_f32() * rate) % std::f32::consts::TAU;
+        }
         let effects_active = app.ui.effects.borrow().is_running()
             || app.ui.modal_fx.borrow().is_some()
             || app.ui.title_fx.borrow().is_some()
-            || app.ui.nav_fx.borrow().is_some();
+            || app.ui.nav_fx.borrow().is_some()
+            || has_armed;
         let cursor_pulse = app.page == page::Page::Main && !app.ui.performance_mode && !app.playback.playing;
         let audio_cooldown = !app.playback.playing && last_stop_time.elapsed() < Duration::from_secs(1);
         if app.playback.playing || had_event || app.ui.show_title || effects_active || app.ui.show_minimap() || cursor_pulse || audio_cooldown {

src/model/mod.rs

@@ -2,6 +2,7 @@ pub mod categories;
 pub mod demos;
 pub mod docs;
 pub mod onboarding;
+pub mod palette;
 mod script;
 
 pub use cagire_forth::{

src/model/onboarding.rs

@@ -30,12 +30,12 @@ pub fn for_page(page: Page) -> &'static [(&'static str, &'static [(&'static str,
         ],
         Page::Patterns => &[
             (
-                "Organize your project into banks and patterns. The left column lists 32 banks, the right shows patterns in the selected bank. The bottom strip previews steps and pattern properties. Stage patterns to play or stop, then commit to apply all changes at once.",
+                "Organize your project into banks and patterns. The left column lists 32 banks, the right shows patterns in the selected bank. The bottom strip previews steps and pattern properties. Arm patterns to play or stop, then launch to apply all changes at once.",
                 &[
                     ("Arrows", "navigate"),
                     ("Enter", "open in sequencer"),
-                    ("Space", "stage play/stop"),
+                    ("p", "arm play/stop"),
-                    ("c", "commit changes"),
+                    ("c", "launch changes"),
                     ("r", "rename"),
                     ("e", "properties"),
                     ("?", "all keys"),
@@ -44,8 +44,8 @@ pub fn for_page(page: Page) -> &'static [(&'static str, &'static [(&'static str,
             (
                 "Mute and solo patterns to control the mix. Use euclidean distribution to generate rhythmic patterns from a single step. Select multiple patterns with Shift for bulk operations.",
                 &[
-                    ("m", "stage mute"),
+                    ("m", "arm mute"),
-                    ("s", "stage solo"),
+                    ("s", "arm solo"),
                     ("E", "euclidean"),
                     ("Shift+↑↓", "select range"),
                     ("y", "copy"),

src/state/file_browser.rs

@@ -27,6 +27,7 @@ pub struct FileBrowserState {
     pub entries: Vec<DirEntry>,
     pub selected: usize,
     pub scroll_offset: usize,
+    pub audio_counts: Vec<Option<usize>>,
 }
 
 impl FileBrowserState {
@@ -37,6 +38,7 @@ impl FileBrowserState {
             entries: Vec::new(),
             selected: 0,
             scroll_offset: 0,
+            audio_counts: Vec::new(),
         };
         state.refresh_entries();
         state
@@ -49,6 +51,7 @@ impl FileBrowserState {
             entries: Vec::new(),
             selected: 0,
             scroll_offset: 0,
+            audio_counts: Vec::new(),
         };
         state.refresh_entries();
         state
@@ -119,10 +122,27 @@ impl FileBrowserState {
         });
 
         self.entries = entries;
+        self.audio_counts = Vec::new();
         self.selected = 0;
         self.scroll_offset = 0;
     }
 
+    pub fn compute_audio_counts(&mut self) {
+        let dir = self.current_dir();
+        self.audio_counts = self
+            .entries
+            .iter()
+            .map(|entry| {
+                if !entry.is_dir || entry.name == ".." {
+                    return None;
+                }
+                let path = dir.join(&entry.name);
+                let count = count_audio_files(&path);
+                if count > 0 { Some(count) } else { None }
+            })
+            .collect();
+    }
+
     pub fn autocomplete(&mut self) {
         let real_entries: Vec<&DirEntry> =
             self.entries.iter().filter(|e| e.name != "..").collect();
@@ -249,6 +269,23 @@ fn ensure_parent_dirs(path: &Path) {
     }
 }
 
+fn count_audio_files(path: &Path) -> usize {
+    let Ok(read_dir) = fs::read_dir(path) else {
+        return 0;
+    };
+    read_dir
+        .flatten()
+        .filter(|e| {
+            let name = e.file_name();
+            let name = name.to_string_lossy();
+            matches!(
+                name.rsplit('.').next().map(|ext| ext.to_lowercase()).as_deref(),
+                Some("wav" | "flac" | "ogg" | "aiff" | "aif" | "mp3")
+            )
+        })
+        .count()
+}
+
 fn longest_common_prefix(entries: &[&DirEntry]) -> String {
     if entries.is_empty() {
         return String::new();

src/state/modal.rs

@@ -74,7 +74,6 @@ pub enum Modal {
         input: String,
     },
     SetTempo(String),
-    JumpToStep(String),
     AddSamplePath(Box<FileBrowserState>),
     Editor,
     PatternProps {
@@ -102,4 +101,9 @@ pub enum Modal {
         rotation: String,
     },
     Onboarding { page: usize },
+    CommandPalette {
+        input: String,
+        cursor: usize,
+        scroll: usize,
+    },
 }

src/state/playback.rs

@@ -130,6 +130,34 @@ impl PlaybackState {
         self.soloed.contains(&(bank, pattern))
     }
 
+    pub fn has_armed(&self) -> bool {
+        !self.staged_changes.is_empty()
+            || !self.staged_mute_changes.is_empty()
+            || !self.staged_prop_changes.is_empty()
+    }
+
+    pub fn armed_summary(&self) -> Option<String> {
+        let play = self.staged_changes.iter().filter(|c| matches!(c.change, PatternChange::Start { .. })).count();
+        let stop = self.staged_changes.iter().filter(|c| matches!(c.change, PatternChange::Stop { .. })).count();
+        let mute = self.staged_mute_changes.iter().filter(|c| matches!(c, StagedMuteChange::ToggleMute { .. })).count();
+        let solo = self.staged_mute_changes.iter().filter(|c| matches!(c, StagedMuteChange::ToggleSolo { .. })).count();
+        let props = self.staged_prop_changes.len();
+
+        let parts: Vec<String> = [
+            (play, "play"),
+            (stop, "stop"),
+            (mute, "mute"),
+            (solo, "solo"),
+            (props, "props"),
+        ]
+        .into_iter()
+        .filter(|(n, _)| *n > 0)
+        .map(|(n, label)| format!("{n} {label}"))
+        .collect();
+
+        if parts.is_empty() { None } else { Some(parts.join(", ")) }
+    }
+
     pub fn is_effectively_muted(&self, bank: usize, pattern: usize) -> bool {
         if self.muted.contains(&(bank, pattern)) {
             return true;

src/state/sample_browser.rs

@@ -1,3 +1,4 @@
+use std::cell::Cell;
 use std::fs;
 use std::path::{Path, PathBuf};
 
@@ -62,12 +63,19 @@ impl SampleNode {
             SampleNode::Folder { expanded, .. } => TreeLineKind::Folder { expanded: *expanded },
             SampleNode::File { .. } => TreeLineKind::File,
         };
+        let child_count = match self {
+            SampleNode::Root { children, .. } | SampleNode::Folder { children, .. } => {
+                children.iter().filter(|c| matches!(c, SampleNode::File { .. })).count()
+            }
+            SampleNode::File { .. } => 0,
+        };
         out.push(TreeLine {
             depth,
             kind,
             label: self.label().to_string(),
             folder: parent_folder.to_string(),
             index: file_index,
+            child_count,
         });
         if self.expanded() {
             let folder_name = self.label();
@@ -321,6 +329,7 @@ impl SampleTree {
                 expanded,
             } if name == target_name => {
                 let show_children = !collapsed && *expanded;
+                let file_count = children.iter().filter(|c| matches!(c, SampleNode::File { .. })).count();
                 out.push(TreeLine {
                     depth: 0,
                     kind: TreeLineKind::Folder {
@@ -329,6 +338,7 @@ impl SampleTree {
                     label: name.clone(),
                     folder: String::new(),
                     index: 0,
+                    child_count: file_count,
                 });
                 if show_children {
                     let mut idx = 0;
@@ -340,6 +350,7 @@ impl SampleTree {
                                 label: fname.clone(),
                                 folder: name.clone(),
                                 index: idx,
+                                child_count: 0,
                             });
                             idx += 1;
                         }
@@ -362,6 +373,7 @@ pub struct SampleBrowserState {
     pub scroll_offset: usize,
     pub search_query: String,
     pub search_active: bool,
+    pub visible_height: Cell<usize>,
     filter: Option<Vec<String>>,
 }
 
@@ -373,6 +385,7 @@ impl SampleBrowserState {
             scroll_offset: 0,
             search_query: String::new(),
             search_active: false,
+            visible_height: Cell::new(20),
             filter: None,
         }
     }
@@ -427,6 +440,10 @@ impl SampleBrowserState {
         if self.scroll_offset > self.cursor {
             self.scroll_offset = self.cursor;
         }
+        let vh = self.visible_height.get();
+        if vh > 0 && self.cursor >= self.scroll_offset + vh {
+            self.scroll_offset = self.cursor - vh + 1;
+        }
     }
 
     pub fn move_up(&mut self) {
@@ -438,15 +455,16 @@ impl SampleBrowserState {
         }
     }
 
-    pub fn move_down(&mut self, visible_height: usize) {
+    pub fn move_down(&mut self) {
         let count = self.visible_count();
         if count == 0 {
             return;
         }
         if self.cursor + 1 < count {
             self.cursor += 1;
-            if self.cursor >= self.scroll_offset + visible_height {
+            let vh = self.visible_height.get();
-                self.scroll_offset = self.cursor - visible_height + 1;
+            if vh > 0 && self.cursor >= self.scroll_offset + vh {
+                self.scroll_offset = self.cursor - vh + 1;
             }
         }
     }

src/state/ui.rs

@@ -86,6 +86,7 @@ pub struct UiState {
     pub demo_index: usize,
     pub nav_indicator_until: Option<Instant>,
     pub nav_fx: RefCell<Option<Effect>>,
+    pub pulse_phase: f32,
     pub last_click: Option<(Instant, u16, u16)>,
 }
 
@@ -142,6 +143,7 @@ impl Default for UiState {
             demo_index: 0,
             nav_indicator_until: None,
             nav_fx: RefCell::new(None),
+            pulse_phase: 0.0,
             last_click: None,
         }
     }

src/views/keybindings.rs

@@ -1,144 +0,0 @@
-use crate::page::Page;
-
-pub fn bindings_for(page: Page, plugin_mode: bool) -> Vec<(&'static str, &'static str, &'static str)> {
-    let mut bindings = vec![
-        ("F1–F7", "Go to view", "Dict/Patterns/Options/Help/Sequencer/Engine/Script"),
-        ("Ctrl+←→↑↓", "Navigate", "Switch between adjacent views"),
-    ];
-    if !plugin_mode {
-        bindings.push(("q", "Quit", "Quit application"));
-    }
-    bindings.extend([
-        ("s", "Save", "Save project"),
-        ("l", "Load", "Load project"),
-        ("?", "Keybindings", "Show this help"),
-        ("F12", "Restart", "Full restart from step 0"),
-    ]);
-
-    // Page-specific bindings
-    match page {
-        Page::Main => {
-            if !plugin_mode {
-                bindings.push(("Space", "Play/Stop", "Toggle playback"));
-            }
-            bindings.push(("Alt+↑↓", "Pattern", "Previous/next pattern"));
-            bindings.push(("Alt+←→", "Bank", "Previous/next bank"));
-            bindings.push(("←→↑↓", "Navigate", "Move cursor between steps"));
-            bindings.push(("Shift+←→↑↓", "Select", "Extend selection"));
-            bindings.push(("Esc", "Clear", "Clear selection"));
-            bindings.push(("Enter", "Edit", "Open step editor"));
-            bindings.push(("t", "Toggle", "Toggle selected steps"));
-            bindings.push(("p", "Prelude", "Edit prelude script"));
-            bindings.push(("Tab", "Samples", "Toggle sample browser"));
-            bindings.push(("Ctrl+C", "Copy", "Copy selected steps"));
-            bindings.push(("Ctrl+V", "Paste", "Paste steps"));
-            bindings.push(("Ctrl+B", "Link", "Paste as linked steps"));
-            bindings.push(("Ctrl+D", "Duplicate", "Duplicate selection"));
-            bindings.push(("Ctrl+H", "Harden", "Convert links to copies"));
-            bindings.push(("Del", "Delete", "Delete step(s)"));
-            bindings.push(("< >", "Length", "Decrease/increase pattern length"));
-            bindings.push(("[ ]", "Speed", "Decrease/increase pattern speed"));
-            if !plugin_mode {
-                bindings.push(("+ -", "Tempo", "Increase/decrease tempo"));
-                bindings.push(("T", "Set tempo", "Open tempo input"));
-            }
-            bindings.push(("L", "Set length", "Open length input"));
-            bindings.push(("S", "Set speed", "Open speed input"));
-            bindings.push(("f", "Fill", "Toggle fill mode (hold)"));
-            bindings.push(("r", "Rename", "Rename current step"));
-            bindings.push(("Ctrl+R", "Run", "Run step script immediately"));
-            bindings.push((":", "Jump", "Jump to step number"));
-            bindings.push(("e", "Euclidean", "Distribute linked steps using Euclidean rhythm"));
-            bindings.push(("m", "Mute", "Stage mute for current pattern"));
-            bindings.push(("x", "Solo", "Stage solo for current pattern"));
-            bindings.push(("M", "Clear mutes", "Clear all mutes"));
-            bindings.push(("X", "Clear solos", "Clear all solos"));
-            bindings.push(("d", "Eval prelude", "Re-evaluate prelude without editing"));
-            bindings.push(("g", "Share", "Export pattern to clipboard"));
-            bindings.push(("G", "Import", "Import pattern from clipboard"));
-        }
-        Page::Patterns => {
-            bindings.push(("←→↑↓", "Navigate", "Move between banks/patterns"));
-            bindings.push(("Shift+↑↓", "Select", "Extend selection"));
-            bindings.push(("Alt+↑↓", "Shift", "Move patterns up/down"));
-            bindings.push(("Enter", "Select", "Select pattern for editing"));
-            if !plugin_mode {
-                bindings.push(("Space", "Play", "Toggle pattern playback"));
-            }
-            bindings.push(("Esc", "Back", "Clear staged or go back"));
-            bindings.push(("c", "Commit", "Commit staged changes"));
-            bindings.push(("p", "Stage play", "Stage pattern play toggle"));
-            bindings.push(("r", "Rename", "Rename bank/pattern"));
-            bindings.push(("d", "Describe", "Add description to pattern"));
-            bindings.push(("e", "Properties", "Edit pattern properties"));
-            bindings.push(("m", "Mute", "Stage mute for pattern"));
-            bindings.push(("x", "Solo", "Stage solo for pattern"));
-            bindings.push(("M", "Clear mutes", "Clear all mutes"));
-            bindings.push(("X", "Clear solos", "Clear all solos"));
-            bindings.push(("g", "Share", "Export bank or pattern to clipboard"));
-            bindings.push(("G", "Import", "Import bank or pattern from clipboard"));
-            bindings.push(("Ctrl+C", "Copy", "Copy bank/pattern"));
-            bindings.push(("Ctrl+V", "Paste", "Paste bank/pattern"));
-            bindings.push(("Del", "Reset", "Reset bank/pattern"));
-            bindings.push(("Ctrl+Z", "Undo", "Undo last action"));
-            bindings.push(("Ctrl+Shift+Z", "Redo", "Redo last action"));
-        }
-        Page::Engine => {
-            bindings.push(("Tab", "Section", "Next section"));
-            bindings.push(("Shift+Tab", "Section", "Previous section"));
-            bindings.push(("←→", "Switch", "Switch device type or adjust setting"));
-            bindings.push(("↑↓", "Navigate", "Navigate list items"));
-            bindings.push(("PgUp/Dn", "Page", "Page through device list"));
-            bindings.push(("Enter", "Select", "Select device"));
-            if !plugin_mode {
-                bindings.push(("R", "Restart", "Restart audio engine"));
-            }
-            bindings.push(("A", "Add path", "Add sample path"));
-            bindings.push(("D", "Refresh/Del", "Refresh devices or delete path"));
-            bindings.push(("h", "Hush", "Stop all sounds gracefully"));
-            bindings.push(("p", "Panic", "Stop all sounds immediately"));
-            bindings.push(("r", "Reset", "Reset peak voice counter"));
-            if !plugin_mode {
-                bindings.push(("t", "Test", "Play test tone"));
-            }
-        }
-        Page::Options => {
-            bindings.push(("Tab", "Next", "Move to next option"));
-            bindings.push(("Shift+Tab", "Previous", "Move to previous option"));
-            bindings.push(("↑↓", "Navigate", "Navigate options"));
-            bindings.push(("←→", "Toggle", "Toggle or adjust option"));
-            if !plugin_mode {
-                bindings.push(("Space", "Play/Stop", "Toggle playback"));
-            }
-        }
-        Page::Help => {
-            bindings.push(("↑↓ j/k", "Scroll", "Scroll content"));
-            bindings.push(("Tab", "Topic", "Next topic"));
-            bindings.push(("Shift+Tab", "Topic", "Previous topic"));
-            bindings.push(("PgUp/Dn", "Page", "Page scroll"));
-            bindings.push(("n", "Next code", "Jump to next code block"));
-            bindings.push(("p", "Prev code", "Jump to previous code block"));
-            bindings.push(("Enter", "Run code", "Execute focused code block"));
-            bindings.push(("/", "Search", "Activate search"));
-            bindings.push(("Esc", "Clear", "Clear search / deselect block"));
-        }
-        Page::Dict => {
-            bindings.push(("Tab", "Focus", "Toggle category/words focus"));
-            bindings.push(("↑↓ j/k", "Navigate", "Navigate items"));
-            bindings.push(("PgUp/Dn", "Page", "Page scroll"));
-            bindings.push(("/", "Search", "Activate search"));
-            bindings.push(("Ctrl+F", "Search", "Activate search"));
-            bindings.push(("Esc", "Clear", "Clear search"));
-        }
-        Page::Script => {
-            bindings.push(("Enter", "Focus", "Focus editor for typing"));
-            bindings.push(("Esc", "Unfocus", "Unfocus editor to use page keybindings"));
-            bindings.push(("Ctrl+E", "Evaluate", "Compile and check for errors (focused)"));
-            bindings.push(("S", "Set Speed", "Set script speed via text input (unfocused)"));
-            bindings.push(("L", "Set Length", "Set script length via text input (unfocused)"));
-            bindings.push(("Ctrl+S", "Stack", "Toggle stack preview (focused)"));
-        }
-    }
-
-    bindings
-}

src/views/mod.rs

@@ -2,7 +2,6 @@ pub mod dict_view;
 pub mod engine_view;
 pub mod help_view;
 pub mod highlight;
-pub mod keybindings;
 pub mod main_view;
 pub mod options_view;
 pub mod patterns_view;

src/views/patterns_view.rs

@@ -1,7 +1,7 @@
 use ratatui::layout::{Alignment, Constraint, Layout, Rect};
 use ratatui::style::{Color, Modifier, Style};
 use ratatui::text::{Line, Span};
-use ratatui::widgets::{Block, BorderType, Borders, Paragraph};
+use ratatui::widgets::{Block, Borders, Paragraph};
 use ratatui::Frame;
 
 use crate::app::App;
@@ -13,6 +13,20 @@ use crate::widgets::{render_scroll_indicators, IndicatorAlign};
 
 const MIN_ROW_HEIGHT: u16 = 1;
 
+fn pulse_value(phase: f32) -> f32 {
+    phase.sin() * 0.5 + 0.5
+}
+
+fn pulse_color(from: Color, to: Color, t: f32) -> Color {
+    match (from, to) {
+        (Color::Rgb(r1, g1, b1), Color::Rgb(r2, g2, b2)) => {
+            let l = |a: u8, b: u8| (a as f32 + (b as f32 - a as f32) * t) as u8;
+            Color::Rgb(l(r1, r2), l(g1, g2), l(b1, b2))
+        }
+        _ => from,
+    }
+}
+
 /// Replaces the background color of spans beyond `filled_cols` with `unfilled_bg`.
 fn apply_progress_bg(spans: Vec<Span<'_>>, filled_cols: usize, unfilled_bg: Color) -> Vec<Span<'_>> {
     let mut result = Vec::with_capacity(spans.len() + 1);
@@ -54,7 +68,32 @@ pub fn render(frame: &mut Frame, app: &App, snapshot: &SequencerSnapshot, area:
         Layout::horizontal([Constraint::Fill(1), Constraint::Length(22)]).areas(bottom_area);
 
     render_banks(frame, app, snapshot, banks_area);
-    render_patterns(frame, app, snapshot, patterns_area);
+
+    let armed_summary = app.playback.armed_summary();
+    let (patterns_main, launch_bar_area) = if armed_summary.is_some() {
+        let [main, bar] =
+            Layout::vertical([Constraint::Fill(1), Constraint::Length(1)]).areas(patterns_area);
+        (main, Some(bar))
+    } else {
+        (patterns_area, None)
+    };
+
+    render_patterns(frame, app, snapshot, patterns_main);
+
+    if let (Some(bar_area), Some(summary)) = (launch_bar_area, armed_summary) {
+        let pulse = pulse_value(app.ui.pulse_phase);
+        let pulsed_fg = pulse_color(theme.list.staged_play_fg, theme.list.staged_play_bg, pulse * 0.6);
+        let text = format!("\u{25b6} {summary} \u{2014} c to launch");
+        let bar = Paragraph::new(text)
+            .alignment(Alignment::Center)
+            .style(
+                Style::new()
+                    .fg(pulsed_fg)
+                    .bg(theme.list.staged_play_bg)
+                    .add_modifier(Modifier::BOLD),
+            );
+        frame.render_widget(bar, bar_area);
+    }
 
     let bank = app.patterns_nav.bank_cursor;
     let pattern_idx = app.patterns_nav.pattern_cursor;
@@ -82,6 +121,7 @@ pub fn render(frame: &mut Frame, app: &App, snapshot: &SequencerSnapshot, area:
 
 fn render_banks(frame: &mut Frame, app: &App, snapshot: &SequencerSnapshot, area: Rect) {
     let theme = theme::get();
+    let pulse = pulse_value(app.ui.pulse_phase);
     let is_focused = matches!(app.patterns_nav.column, PatternsColumn::Banks);
 
     let border_color = if is_focused { theme.ui.header } else { theme.ui.border };
@@ -215,6 +255,12 @@ fn render_banks(frame: &mut Frame, app: &App, snapshot: &SequencerSnapshot, area
         } else {
             style
         };
+        let style = if (is_staged || has_staged_mute_solo) && !is_cursor && !is_in_range {
+            let pulsed = pulse_color(fg, bg, pulse * 0.6);
+            style.fg(pulsed)
+        } else {
+            style
+        };
 
         let bg_block = Block::default().style(Style::new().bg(bg));
         frame.render_widget(bg_block, row_area);
@@ -247,6 +293,7 @@ fn render_banks(frame: &mut Frame, app: &App, snapshot: &SequencerSnapshot, area
 
 fn render_patterns(frame: &mut Frame, app: &App, snapshot: &SequencerSnapshot, area: Rect) {
     use crate::model::PatternSpeed;
+    let pulse = pulse_value(app.ui.pulse_phase);
 
     let theme = theme::get();
     let is_focused = matches!(app.patterns_nav.column, PatternsColumn::Patterns);
@@ -312,8 +359,7 @@ fn render_patterns(frame: &mut Frame, app: &App, snapshot: &SequencerSnapshot, a
 
     let cursor = app.patterns_nav.pattern_cursor;
     let available = inner.height as usize;
-    // Cursor row takes 2 lines (main + detail); account for 1 extra
+    let max_visible = available.max(1);
-    let max_visible = available.saturating_sub(1).max(1);
 
     let scroll_offset = if MAX_PATTERNS <= max_visible {
         0
@@ -328,8 +374,6 @@ fn render_patterns(frame: &mut Frame, app: &App, snapshot: &SequencerSnapshot, a
     let mut y = inner.y;
     for visible_idx in 0..visible_count {
         let idx = scroll_offset + visible_idx;
-        let is_expanded = idx == cursor;
-        let row_h = if is_expanded { 2u16 } else { 1u16 };
         if y >= inner.y + inner.height {
             break;
         }
@@ -338,7 +382,7 @@ fn render_patterns(frame: &mut Frame, app: &App, snapshot: &SequencerSnapshot, a
             x: inner.x,
             y,
             width: inner.width,
-            height: row_h.min(inner.y + inner.height - y),
+            height: 1u16.min(inner.y + inner.height - y),
         };
 
         let is_cursor = is_focused && idx == app.patterns_nav.pattern_cursor;
@@ -424,21 +468,9 @@ fn render_patterns(frame: &mut Frame, app: &App, snapshot: &SequencerSnapshot, a
         let base_style = Style::new().bg(bg).fg(fg);
         let bold_style = base_style.add_modifier(Modifier::BOLD);
 
-        let content_area = if is_expanded {
-            let border_color = if is_focused { theme.selection.cursor } else { theme.ui.unfocused };
-            let block = Block::default()
-                .borders(Borders::LEFT | Borders::RIGHT)
-                .border_type(BorderType::QuadrantOutside)
-                .border_style(Style::new().fg(border_color).bg(bg))
-                .style(Style::new().bg(bg));
-            let content = block.inner(row_area);
-            frame.render_widget(block, row_area);
-            content
-        } else {
         let bg_block = Block::default().style(Style::new().bg(bg));
         frame.render_widget(bg_block, row_area);
-            row_area
+        let content_area = row_area;
-        };
 
         let text_area = Rect {
             x: content_area.x,
@@ -454,6 +486,14 @@ fn render_patterns(frame: &mut Frame, app: &App, snapshot: &SequencerSnapshot, a
         };
         let dim_style = base_style.remove_modifier(Modifier::BOLD);
 
+        let is_armed = is_staged_play || is_staged_stop || has_staged_mute || has_staged_solo || has_staged_props;
+        let (name_style, dim_style) = if is_armed && !is_cursor && !is_in_range {
+            let pulsed = pulse_color(fg, bg, pulse * 0.6);
+            (name_style.fg(pulsed), dim_style.fg(pulsed))
+        } else {
+            (name_style, dim_style)
+        };
+
         let mut spans = vec![Span::styled(format!("{}{:02}", prefix, idx + 1), name_style)];
         if !name.is_empty() {
             spans.push(Span::styled(format!(" {name}"), name_style));
@@ -466,16 +506,38 @@ fn render_patterns(frame: &mut Frame, app: &App, snapshot: &SequencerSnapshot, a
             String::new()
         };
         let props_indicator = if has_staged_props { "~" } else { "" };
-        let right_info = if content_count > 0 {
+        let quant_sync = if is_selected {
-            format!("{props_indicator}{content_count}/{length}{speed_str}")
+            format!(
+                "{}:{} ",
+                pattern.quantization.short_label(),
+                pattern.sync_mode.short_label()
+            )
         } else {
-            format!("{props_indicator}  {length}{speed_str}")
+            String::new()
+        };
+        let right_info = if content_count > 0 {
+            format!("{quant_sync}{props_indicator}{content_count}/{length}{speed_str}")
+        } else {
+            format!("{quant_sync}{props_indicator}  {length}{speed_str}")
         };
         let left_width: usize = spans.iter().map(|s| s.content.chars().count()).sum();
         let right_width = right_info.chars().count();
-        let padding = (text_area.width as usize).saturating_sub(left_width + right_width + 1);
+        let gap = (text_area.width as usize).saturating_sub(left_width + right_width + 1);
 
-        spans.push(Span::styled(" ".repeat(padding), dim_style));
+        if let Some(desc) = pattern.description.as_deref().filter(|d| !d.is_empty() && gap > 4) {
+            let budget = gap - 2;
+            let char_count = desc.chars().count();
+            if char_count <= budget {
+                spans.push(Span::styled(format!(" {desc}"), dim_style));
+                spans.push(Span::styled(" ".repeat(gap - char_count - 1), dim_style));
+            } else {
+                let truncated: String = desc.chars().take(budget - 1).collect();
+                spans.push(Span::styled(format!(" {truncated}\u{2026}"), dim_style));
+                spans.push(Span::styled(" ", dim_style));
+            }
+        } else {
+            spans.push(Span::styled(" ".repeat(gap), dim_style));
+        }
         spans.push(Span::styled(right_info, dim_style));
 
         let spans = if is_playing && !is_cursor && !is_in_range {
@@ -488,52 +550,6 @@ fn render_patterns(frame: &mut Frame, app: &App, snapshot: &SequencerSnapshot, a
 
         frame.render_widget(Paragraph::new(Line::from(spans)), text_area);
 
-        if is_expanded && content_area.height >= 2 {
-            let detail_area = Rect {
-                x: content_area.x,
-                y: content_area.y + 1,
-                width: content_area.width,
-                height: 1,
-            };
-
-            let right_label = format!(
-                "{} · {}",
-                pattern.quantization.label(),
-                pattern.sync_mode.label()
-            );
-            let w = detail_area.width as usize;
-            let label = if let Some(desc) = &pattern.description {
-                let right_len = right_label.chars().count();
-                let max_desc = w.saturating_sub(right_len + 1);
-                let truncated: String = desc.chars().take(max_desc).collect();
-                let pad = w.saturating_sub(truncated.chars().count() + right_len);
-                format!("{truncated}{}{right_label}", " ".repeat(pad))
-            } else {
-                format!("{right_label:>w$}")
-            };
-            let padded_label = label;
-
-            let filled_width = if is_playing {
-                let ratio = snapshot.get_smooth_progress(bank, idx, length, speed.multiplier()).unwrap_or(0.0);
-                (ratio * detail_area.width as f64).min(detail_area.width as f64) as usize
-            } else {
-                0
-            };
-
-            let dim_fg = theme.ui.text_muted;
-            let progress_bg = theme.list.playing_bg;
-            let byte_offset = padded_label
-                .char_indices()
-                .nth(filled_width)
-                .map_or(padded_label.len(), |(i, _)| i);
-            let (left, right) = padded_label.split_at(byte_offset);
-            let detail_spans = vec![
-                Span::styled(left.to_string(), Style::new().bg(progress_bg).fg(dim_fg)),
-                Span::styled(right.to_string(), Style::new().bg(theme.ui.bg).fg(dim_fg)),
-            ];
-            frame.render_widget(Paragraph::new(Line::from(detail_spans)), detail_area);
-        }
-
         y += row_area.height;
     }
 

src/views/render.rs

@@ -299,6 +299,13 @@ fn render_side_panel(frame: &mut Frame, app: &App, area: Rect) {
             let [tree_area, preview_area] =
                 Layout::vertical([Constraint::Fill(1), Constraint::Length(6)]).areas(area);
 
+            // Compute visible height: tree_area minus borders (2), minus search bar (1) if shown
+            let mut vh = tree_area.height.saturating_sub(2) as usize;
+            if state.search_active || !state.search_query.is_empty() {
+                vh = vh.saturating_sub(1);
+            }
+            state.visible_height.set(vh);
+
             let entries = state.entries();
             SampleBrowser::new(&entries, state.cursor)
                 .scroll_offset(state.scroll_offset)
@@ -542,6 +549,13 @@ fn render_footer(frame: &mut Frame, app: &App, snapshot: &SequencerSnapshot, are
         ])
     } else {
         let bindings: Vec<(&str, &str)> = match app.page {
+            Page::Main if app.panel.visible && app.panel.focus == PanelFocus::Side => vec![
+                ("↑↓", "Navigate"),
+                ("→", "Expand/Play"),
+                ("←", "Collapse"),
+                ("/", "Search"),
+                ("Tab", "Close"),
+            ],
             Page::Main => vec![
                 ("Space", "Play"),
                 ("Enter", "Edit"),
@@ -552,7 +566,7 @@ fn render_footer(frame: &mut Frame, app: &App, snapshot: &SequencerSnapshot, are
             Page::Patterns => vec![
                 ("Enter", "Select"),
                 ("Space", "Play"),
-                ("c", "Commit"),
+                ("c", "Launch"),
                 ("r", "Rename"),
                 ("?", "Keys"),
             ],
@@ -707,15 +721,6 @@ fn render_modal(
                 .border_color(theme.modal.confirm)
                 .render_centered(frame, term)
         }
-        Modal::JumpToStep(input) => {
-            let pattern_len = app.current_edit_pattern().length;
-            let title = format!("Jump to Step (1-{})", pattern_len);
-            TextInputModal::new(&title, input)
-                .hint("Enter step number")
-                .width(30)
-                .border_color(theme.modal.confirm)
-                .render_centered(frame, term)
-        }
         Modal::SetTempo(input) => TextInputModal::new("Set Tempo (20-300 BPM)", input)
             .hint("Enter BPM")
             .width(30)
@@ -728,12 +733,21 @@ fn render_modal(
                 .iter()
                 .map(|e| (e.name.clone(), e.is_dir, e.is_cagire()))
                 .collect();
-            FileBrowserModal::new("Add Sample Path", &state.input, &entries)
+            let hints = hint_line(&[
+                ("\u{2190}", "parent"),
+                ("\u{2192}", "enter"),
+                ("Enter", "add"),
+                ("Esc", "cancel"),
+            ]);
+            FileBrowserModal::new("Browse Samples", &state.input, &entries)
                 .selected(state.selected)
                 .scroll_offset(state.scroll_offset)
                 .border_color(theme.modal.rename)
-                .width(60)
+                .audio_counts(&state.audio_counts)
-                .height(18)
+                .hints(hints)
+                .color_path()
+                .width(70)
+                .height(20)
                 .render_centered(frame, term)
         }
         Modal::Editor => {
@@ -883,6 +897,9 @@ fn render_modal(
 
             inner
         }
+        Modal::CommandPalette { input, cursor, scroll } => {
+            render_command_palette(frame, app, input, *cursor, *scroll, term)
+        }
         Modal::KeybindingsHelp { scroll } => render_modal_keybindings(frame, app, *scroll, term),
         Modal::EuclideanDistribution {
             source_step,
@@ -1086,6 +1103,247 @@ fn render_modal_editor(
     inner
 }
 
+fn render_command_palette(
+    frame: &mut Frame,
+    app: &App,
+    query: &str,
+    cursor: usize,
+    scroll: usize,
+    term: Rect,
+) -> Rect {
+    use crate::model::palette::{palette_entries, CommandEntry};
+
+    let theme = theme::get();
+    let entries = palette_entries(query, app.plugin_mode, app);
+
+    // On Main page, numeric input prepends a synthetic "Jump to Step" entry
+    let jump_step: Option<usize> = if app.page == Page::Main
+        && !query.is_empty()
+        && query.chars().all(|c| c.is_ascii_digit())
+    {
+        query.parse().ok()
+    } else {
+        None
+    };
+
+    // Build display rows: each is either a separator header or a command entry
+    struct DisplayRow<'a> {
+        entry: Option<&'a CommandEntry>,
+        separator: Option<&'static str>,
+        is_jump: bool,
+        jump_label: String,
+    }
+
+    let mut rows: Vec<DisplayRow> = Vec::new();
+
+    if let Some(n) = jump_step {
+        rows.push(DisplayRow {
+            entry: None,
+            separator: None,
+            is_jump: true,
+            jump_label: format!("Jump to Step {n}"),
+        });
+    }
+
+    if query.is_empty() {
+        // Grouped by category with separators
+        let mut last_category = "";
+        for e in &entries {
+            if e.category != last_category {
+                rows.push(DisplayRow {
+                    entry: None,
+                    separator: Some(e.category),
+                    is_jump: false,
+                    jump_label: String::new(),
+                });
+                last_category = e.category;
+            }
+            rows.push(DisplayRow {
+                entry: Some(e),
+                separator: None,
+                is_jump: false,
+                jump_label: String::new(),
+            });
+        }
+    } else {
+        for e in &entries {
+            rows.push(DisplayRow {
+                entry: Some(e),
+                separator: None,
+                is_jump: false,
+                jump_label: String::new(),
+            });
+        }
+    }
+
+    // Count selectable items (non-separator)
+    let selectable_count = rows.iter().filter(|r| r.separator.is_none()).count();
+    let cursor = cursor.min(selectable_count.saturating_sub(1));
+
+    let width: u16 = 55;
+    let max_height = (term.height as usize * 60 / 100).max(8);
+    let content_height = rows.len() + 4; // input + gap + hint + border padding
+    let height = content_height.min(max_height) as u16;
+
+    let inner = ModalFrame::new(": Command Palette")
+        .width(width)
+        .height(height)
+        .border_color(theme.modal.confirm)
+        .render_centered(frame, term);
+
+    let mut y = inner.y;
+    let content_width = inner.width;
+
+    // Input line
+    let input_line = Line::from(vec![
+        Span::styled("> ", Style::default().fg(theme.modal.confirm)),
+        Span::styled(query, Style::default().fg(theme.ui.text_primary)),
+        Span::styled("\u{2588}", Style::default().fg(theme.modal.confirm)),
+    ]);
+    frame.render_widget(
+        Paragraph::new(input_line),
+        Rect::new(inner.x, y, content_width, 1),
+    );
+    y += 1;
+
+    // Visible area for entries
+    let visible_height = inner.height.saturating_sub(2) as usize; // minus input line and hint line
+
+    // Auto-scroll
+    let scroll = {
+        let mut s = scroll;
+        // Map cursor (selectable index) to row index for scrolling
+        let mut selectable_idx = 0;
+        let mut cursor_row = 0;
+        for (i, row) in rows.iter().enumerate() {
+            if row.separator.is_some() {
+                continue;
+            }
+            if selectable_idx == cursor {
+                cursor_row = i;
+                break;
+            }
+            selectable_idx += 1;
+        }
+        if cursor_row >= s + visible_height {
+            s = cursor_row + 1 - visible_height;
+        }
+        if cursor_row < s {
+            s = cursor_row;
+        }
+        s
+    };
+
+    // Render visible rows
+    let mut selectable_idx = rows.iter().take(scroll).filter(|r| r.separator.is_none()).count();
+    for row in rows.iter().skip(scroll).take(visible_height) {
+        if y >= inner.y + inner.height - 1 {
+            break;
+        }
+
+        if let Some(cat) = row.separator {
+            // Category header
+            let pad = content_width.saturating_sub(cat.len() as u16 + 4) / 2;
+            let sep_left = "\u{2500}".repeat(pad as usize);
+            let sep_right =
+                "\u{2500}".repeat(content_width.saturating_sub(pad + cat.len() as u16 + 4) as usize);
+            let line = Line::from(vec![
+                Span::styled(
+                    format!("{sep_left} "),
+                    Style::default().fg(theme.ui.text_muted),
+                ),
+                Span::styled(cat, Style::default().fg(theme.ui.text_dim)),
+                Span::styled(
+                    format!(" {sep_right}"),
+                    Style::default().fg(theme.ui.text_muted),
+                ),
+            ]);
+            frame.render_widget(Paragraph::new(line), Rect::new(inner.x, y, content_width, 1));
+            y += 1;
+            continue;
+        }
+
+        let is_selected = selectable_idx == cursor;
+        let (bg, fg) = if is_selected {
+            (theme.selection.cursor_bg, theme.selection.cursor_fg)
+        } else if selectable_idx.is_multiple_of(2) {
+            (theme.table.row_even, theme.ui.text_primary)
+        } else {
+            (theme.table.row_odd, theme.ui.text_primary)
+        };
+
+        let (name, keybinding) = if row.is_jump {
+            (row.jump_label.as_str(), "")
+        } else if let Some(e) = row.entry {
+            (e.name, e.keybinding)
+        } else {
+            selectable_idx += 1;
+            y += 1;
+            continue;
+        };
+
+        let key_len = keybinding.len() as u16;
+        let name_width = content_width.saturating_sub(key_len + 2);
+        let truncated_name: String = name.chars().take(name_width as usize).collect();
+        let padding = name_width.saturating_sub(truncated_name.len() as u16);
+
+        let key_fg = if is_selected {
+            theme.selection.cursor_fg
+        } else {
+            theme.ui.text_dim
+        };
+
+        let line = Line::from(vec![
+            Span::styled(format!(" {truncated_name}"), Style::default().bg(bg).fg(fg)),
+            Span::styled(
+                " ".repeat(padding as usize),
+                Style::default().bg(bg),
+            ),
+            Span::styled(
+                format!("{keybinding} "),
+                Style::default().bg(bg).fg(key_fg),
+            ),
+        ]);
+        frame.render_widget(Paragraph::new(line), Rect::new(inner.x, y, content_width, 1));
+
+        selectable_idx += 1;
+        y += 1;
+    }
+
+    // Empty state
+    if selectable_count == 0 {
+        let msg = "No matching commands";
+        let empty_y = inner.y + inner.height / 2;
+        if empty_y < inner.y + inner.height - 1 {
+            frame.render_widget(
+                Paragraph::new(msg)
+                    .style(Style::default().fg(theme.ui.text_muted))
+                    .alignment(Alignment::Center),
+                Rect::new(inner.x, empty_y, content_width, 1),
+            );
+        }
+    }
+
+    // Hint bar
+    let hint_area = Rect::new(inner.x, inner.y + inner.height - 1, inner.width, 1);
+    let hints = if jump_step.is_some() && cursor == 0 {
+        hint_line(&[
+            ("\u{2191}\u{2193}", "navigate"),
+            ("Enter", "jump to step"),
+            ("Esc", "close"),
+        ])
+    } else {
+        hint_line(&[
+            ("\u{2191}\u{2193}", "navigate"),
+            ("Enter", "run"),
+            ("Esc", "close"),
+        ])
+    };
+    frame.render_widget(Paragraph::new(hints), hint_area);
+
+    inner
+}
+
 fn render_modal_keybindings(frame: &mut Frame, app: &App, scroll: usize, term: Rect) -> Rect {
     let theme = theme::get();
     let width = (term.width * 80 / 100).clamp(60, 100);
@@ -1098,7 +1356,7 @@ fn render_modal_keybindings(frame: &mut Frame, app: &App, scroll: usize, term: R
         .border_color(theme.modal.editor)
         .render_centered(frame, term);
 
-    let bindings = super::keybindings::bindings_for(app.page, app.plugin_mode);
+    let bindings = crate::model::palette::bindings_for(app.page, app.plugin_mode);
     let visible_rows = inner.height.saturating_sub(2) as usize;
 
     let rows: Vec<Row> = bindings

website/src/pages/index.astro

@@ -87,8 +87,8 @@ const DL = 'https://dlcagire.raphaelforment.fr';
         <tr>
             <td>Windows (x86_64)</td>
             <td><a href={`${DL}/cagire-windows-x86_64.zip`}>zip</a></td>
-            <td><a href={`${DL}/cagire-windows-x86_64-desktop.zip`}>zip</a> · <a href={`${DL}/cagire-msi.zip`}>.msi</a></td>
+            <td><a href={`${DL}/cagire-desktop-windows-x86_64.zip`}>zip</a> · <s>.msi</s></td>
-            <td><s>CLAP</s> · <s>VST3</s></td>
+            <td><a href={`${DL}/plugins-windows-x86_64-clap.zip`}>CLAP</a> · <a href={`${DL}/plugins-windows-x86_64-vst3.zip`}>VST3</a></td>
         </tr>
     </table>
     <p class="note">Source code and issue tracker on <a href="https://github.com/Bubobubobubobubo/cagire">GitHub</a>. You can also compile the software yourself from source!</p>