diff --git a/README.md b/README.md
index 4f2227d..b74d4b4 100644
--- a/README.md
+++ b/README.md
@@ -316,7 +316,17 @@ live as you type — `Enter` keeps the filter, `Esc` clears it.
 `s` marks the selected row; `v` (or `V`) enters **visual mode**, where
 movement marks or unmarks everything you sweep over, vim-style. The sweep
 is anchored where you entered it, so moving back reverses it. `Esc` (or
-any non-movement key) leaves visual mode.
+any non-movement key) leaves visual mode. Both panes have marks and visual
+mode.
+
+In the queue this feeds a vim-style **register**: `y` yanks the selection
+into it, `d` deletes the marked rows *into* it, and `c`/`C` fill it with
+whatever they clear — so an accidental clear is recoverable. `p` pastes it
+after the cursor and `P` before it, which makes `d` then `P` an exact undo
+and `d` … `p` a move. The register is per client, in memory, one slot, and
+holds paths — so a paste re-resolves (a yanked album expands to its
+tracks). Note `p` no longer inserts the library selection: that flow is now
+`y` on the left, then `p` on the right.
 
 - `w` saves the selection (a library subtree, or in the queue pane the
   queue) as a new folder under `/crabidy/<name>` of **link** files —
diff --git a/cbd-tui/src/app/mod.rs b/cbd-tui/src/app/mod.rs
index b2f6b5e..342f6e0 100644
--- a/cbd-tui/src/app/mod.rs
+++ b/cbd-tui/src/app/mod.rs
@@ -720,7 +720,8 @@ impl App {
             .constraints([Constraint::Percentage(70), Constraint::Min(10)].as_ref())
             .split(main[1]);
 
-        self.queue.render(f, right_side[0], queue_focused);
+        self.queue
+            .render(f, right_side[0], queue_focused, self.register.len());
         self.now_playing.render(f, right_side[1]);
 
         // The node-creation/rename input: one line inside the bottom of the
diff --git a/cbd-tui/src/app/queue.rs b/cbd-tui/src/app/queue.rs
index 1730a9c..e310d49 100644
--- a/cbd-tui/src/app/queue.rs
+++ b/cbd-tui/src/app/queue.rs
@@ -212,7 +212,10 @@ impl Queue {
         self.update_selection();
     }
 
-    pub fn render(&mut self, f: &mut Frame, area: Rect, focused: bool) {
+    /// Draws the pane. `register_len` is the number of entries `p`/`P` would
+    /// paste; a non-zero count is shown in the title so a paste is never
+    /// blind.
+    pub fn render(&mut self, f: &mut Frame, area: Rect, focused: bool, register_len: usize) {
         let selected = self.list_state.selected();
         // Render only the visible rows; `view` is the rendered index the
         // selection bar keys off, `real` the queue position (which drives
@@ -280,9 +283,10 @@ impl Queue {
                         // Visual (paint-select) mode: movement toggles marks.
                         "Queue — VISUAL".to_string()
                     } else {
-                        match self.filter.query() {
-                            Some(query) => format!("Queue — /{query}▏"),
-                            None => "Queue".to_string(),
+                        match (self.filter.query(), register_len) {
+                            (Some(query), _) => format!("Queue — /{query}▏"),
+                            (None, 0) => "Queue".to_string(),
+                            (None, n) => format!("Queue — register: {n}"),
                         }
                     }),
             )
@@ -369,7 +373,7 @@ mod tests {
         let backend = TestBackend::new(40, 8);
         let mut terminal = Terminal::new(backend).expect("test terminal");
         terminal
-            .draw(|f| queue.render(f, f.area(), true))
+            .draw(|f| queue.render(f, f.area(), true, 0))
             .expect("draw");
         let buffer = terminal.backend().buffer().clone();
         (0..buffer.area.height)
@@ -455,7 +459,7 @@ mod tests {
         let backend = TestBackend::new(40, 8);
         let mut terminal = Terminal::new(backend).expect("test terminal");
         terminal
-            .draw(|f| queue.render(f, f.area(), true))
+            .draw(|f| queue.render(f, f.area(), true, 0))
             .expect("draw");
         let buffer = terminal.backend().buffer().clone();
         for y in 0..buffer.area.height {
diff --git a/cbd-web/src/app.rs b/cbd-web/src/app.rs
index 0bad675..034eded 100644
--- a/cbd-web/src/app.rs
+++ b/cbd-web/src/app.rs
@@ -16,7 +16,7 @@ use crate::keymap::{self, Action};
 use crate::rpc::Rpc;
 use crate::state::{
     format_seconds, is_cacheable, track_label, CaptureBoard, Dialog, Focus, LibraryPane,
-    NamePurpose, QueueCursor, UiItemKind,
+    NamePurpose, QueueCursor, Register, UiItemKind,
 };
 
 const VOLUME_STEP: f32 = 0.1;
@@ -119,6 +119,9 @@ struct Store {
     queue_cursor: RwSignal<QueueCursor>,
     focus: RwSignal<Focus>,
     dialog: RwSignal<Option<Dialog>>,
+    /// What `y`/`d`/`c`/`C` set aside and `p`/`P` paste back
+    /// (architecture/queue-register.md). Per client, one slot, in memory.
+    register: RwSignal<Register>,
     toast: RwSignal<Option<String>>,
     /// The transport; local because the wasm client is not `Send`.
     rpc: StoredValue<Option<Rpc>, LocalStorage>,
@@ -150,6 +153,7 @@ impl Store {
             queue_cursor: RwSignal::new(QueueCursor::default()),
             focus: RwSignal::new(Focus::Library),
             dialog: RwSignal::new(None),
+            register: RwSignal::new(Register::default()),
             toast: RwSignal::new(None),
             rpc: StoredValue::new_local(None),
             cache: StoredValue::new_local(HashMap::new()),
@@ -191,9 +195,11 @@ impl Store {
             StreamUpdate::Queue(queue) => {
                 self.queue_pos.set(queue.current_position);
                 self.resolving.set(queue.resolving);
+                // Marks follow their own track across the snapshot rather
+                // than their index (architecture/queue-register.md D5).
+                let paths: Vec<String> = queue.tracks.iter().map(|t| t.path.clone()).collect();
                 self.queue.set(queue.tracks);
-                let len = self.queue.with_untracked(Vec::len);
-                self.queue_cursor.update(|c| c.clamp(len));
+                self.queue_cursor.update(|c| c.reconcile(paths));
             }
             StreamUpdate::Mods(mods) => self.mods.set(mods),
             StreamUpdate::QueueTrack(queue_track) => {
@@ -286,7 +292,98 @@ impl Store {
     }
 
     /// Executes one keymap action — the web twin of the TUI dispatch.
+    /// Move the library cursor, painting the swept range when visual mode is
+    /// active — the web mirror of the TUI's `library_move`.
+    fn library_move(&self, mv: impl FnOnce(&mut LibraryPane)) {
+        self.library.update(|pane| {
+            let old = pane.selected;
+            mv(pane);
+            pane.paint_between(old, pane.selected);
+        });
+    }
+
+    /// Move the queue cursor, painting the swept range when visual mode is
+    /// active — the web mirror of the TUI's `queue_move`.
+    fn queue_move(&self, mv: impl FnOnce(&mut QueueCursor, usize)) {
+        let len = self.queue.with_untracked(Vec::len);
+        self.queue_cursor.update(|cursor| {
+            let old = cursor.selected;
+            mv(cursor, len);
+            let new = cursor.selected;
+            cursor.paint_between(old, new);
+        });
+    }
+
+    /// Put the tracks at `positions` in the register. Returns whether
+    /// anything was stored, so callers can decide about clearing marks.
+    fn yank_positions(&self, positions: &[usize]) -> bool {
+        let (paths, labels) = self.queue.with_untracked(|queue| {
+            let mut paths = Vec::new();
+            let mut labels = Vec::new();
+            for pos in positions {
+                if let Some(track) = queue.get(*pos) {
+                    paths.push(track.path.clone());
+                    labels.push(track_label(track));
+                }
+            }
+            (paths, labels)
+        });
+        if paths.is_empty() {
+            return false;
+        }
+        self.register.update(|r| r.set(paths, labels));
+        true
+    }
+
+    /// `p`/`P`: insert the register at the cursor. An empty register is a
+    /// no-op, and the register survives so it can be pasted again.
+    fn paste(&self, before: bool) {
+        let paths = self.register.with_untracked(|r| r.paths().to_vec());
+        if paths.is_empty() {
+            return;
+        }
+        let position = self
+            .queue_cursor
+            .with_untracked(|c| c.paste_position(before));
+        self.queue_op(async move |mut rpc: Rpc| rpc.insert_tracks(position, paths).await);
+    }
+
+    /// Whether `action` keeps a pane in visual mode. Everything else leaves
+    /// it before running, exactly as in the TUI.
+    fn keeps_visual(action: Action) -> bool {
+        matches!(
+            action,
+            Action::LibraryFirst
+                | Action::LibraryLast
+                | Action::LibraryNext
+                | Action::LibraryPrev
+                | Action::LibraryJumpDown
+                | Action::LibraryJumpUp
+                | Action::LibraryVisualMode
+                | Action::QueueFirst
+                | Action::QueueLast
+                | Action::QueueNext
+                | Action::QueuePrev
+                | Action::QueueJumpDown
+                | Action::QueueJumpUp
+                | Action::QueueSelectCurrent
+                | Action::QueueVisualMode
+        )
+    }
+
     fn dispatch(&self, action: Action) {
+        if !Self::keeps_visual(action) {
+            if self.library.with_untracked(LibraryPane::is_visual) {
+                self.library.update(LibraryPane::exit_visual);
+            }
+            if self.queue_cursor.with_untracked(QueueCursor::is_visual) {
+                self.queue_cursor.update(QueueCursor::exit_visual);
+            }
+        }
+        self.dispatch_inner(action)
+    }
+
+    fn dispatch_inner(&self, action: Action) {
         match action {
             Action::OpenHelp => self.dialog.set(Some(Dialog::Help)),
             Action::CloseHelp => self.dialog.set(None),
@@ -309,12 +406,12 @@ impl Store {
             Action::ToggleMute => self.call(async |mut rpc: Rpc| rpc.toggle_mute().await),
             Action::ToggleShuffle => self.call(async |mut rpc: Rpc| rpc.toggle_shuffle().await),
             Action::ToggleRepeat => self.call(async |mut rpc: Rpc| rpc.toggle_repeat().await),
-            Action::LibraryNext => self.library.update(|p| p.select_by(1)),
-            Action::LibraryPrev => self.library.update(|p| p.select_by(-1)),
-            Action::LibraryFirst => self.library.update(LibraryPane::select_first),
-            Action::LibraryLast => self.library.update(LibraryPane::select_last),
-            Action::LibraryJumpDown => self.library.update(|p| p.select_by(JUMP)),
-            Action::LibraryJumpUp => self.library.update(|p| p.select_by(-JUMP)),
+            Action::LibraryNext => self.library_move(|p| p.select_by(1)),
+            Action::LibraryPrev => self.library_move(|p| p.select_by(-1)),
+            Action::LibraryFirst => self.library_move(LibraryPane::select_first),
+            Action::LibraryLast => self.library_move(LibraryPane::select_last),
+            Action::LibraryJumpDown => self.library_move(|p| p.select_by(JUMP)),
+            Action::LibraryJumpUp => self.library_move(|p| p.select_by(-JUMP)),
             Action::LibraryAscend => {
                 if let Some(parent) = self.library.with_untracked(|p| p.parent.clone()) {
                     self.open_library_node(parent);
@@ -355,17 +452,6 @@ impl Store {
                     self.queue_op(async |mut rpc: Rpc| rpc.queue_tracks(paths).await);
                 }
             }
-            Action::QueueInsertHere => {
-                let position = self.queue_cursor.with_untracked(|c| c.selected as u32);
-                if let Some(paths) = self
-                    .library
-                    .with_untracked(LibraryPane::queueable_selection)
-                {
-                    self.queue_op(async move |mut rpc: Rpc| {
-                        rpc.insert_tracks(position, paths).await
-                    });
-                }
-            }
             Action::LibraryCreateNode => {
                 let creatable = self
                     .library
@@ -425,33 +511,17 @@ impl Store {
                     }));
                 }
             }
-            Action::QueueNext => {
-                let len = self.queue.with_untracked(Vec::len);
-                self.queue_cursor.update(|c| c.select_by(1, len));
-            }
-            Action::QueuePrev => {
-                let len = self.queue.with_untracked(Vec::len);
-                self.queue_cursor.update(|c| c.select_by(-1, len));
-            }
-            Action::QueueFirst => self.queue_cursor.update(|c| c.selected = 0),
+            Action::QueueNext => self.queue_move(|c, len| c.select_by(1, len)),
+            Action::QueuePrev => self.queue_move(|c, len| c.select_by(-1, len)),
+            Action::QueueFirst => self.queue_move(|c, _| c.selected = 0),
             Action::QueueLast => {
-                let len = self.queue.with_untracked(Vec::len);
-                self.queue_cursor
-                    .update(|c| c.selected = len.saturating_sub(1));
-            }
-            Action::QueueJumpDown => {
-                let len = self.queue.with_untracked(Vec::len);
-                self.queue_cursor.update(|c| c.select_by(JUMP, len));
-            }
-            Action::QueueJumpUp => {
-                let len = self.queue.with_untracked(Vec::len);
-                self.queue_cursor.update(|c| c.select_by(-JUMP, len));
+                self.queue_move(|c, len| c.selected = len.saturating_sub(1));
             }
+            Action::QueueJumpDown => self.queue_move(|c, len| c.select_by(JUMP, len)),
+            Action::QueueJumpUp => self.queue_move(|c, len| c.select_by(-JUMP, len)),
             Action::QueueSelectCurrent => {
                 let current = self.queue_pos.get_untracked() as usize;
-                let len = self.queue.with_untracked(Vec::len);
-                self.queue_cursor
-                    .update(|c| c.selected = current.min(len.saturating_sub(1)));
+                self.queue_move(|c, len| c.selected = current.min(len.saturating_sub(1)));
             }
             Action::QueuePlaySelected => {
                 let position = self.queue_cursor.with_untracked(|c| c.selected as u32);
@@ -460,15 +530,52 @@ impl Store {
                 }
             }
             Action::QueueRemoveTrack => {
-                let position = self.queue_cursor.with_untracked(|c| c.selected as u32);
-                if self.queue.with_untracked(|q| !q.is_empty()) {
-                    self.call(async move |mut rpc: Rpc| rpc.remove_tracks(vec![position]).await);
+                let positions = self
+                    .queue_cursor
+                    .with_untracked(QueueCursor::action_positions);
+                if positions.is_empty() {
+                    return;
+                }
+                // Hand them to the register first, so `p`/`P` brings them back.
+                self.yank_positions(&positions);
+                self.queue_cursor.update(QueueCursor::remove_marks);
+                let wire: Vec<u32> = positions.iter().map(|p| *p as u32).collect();
+                self.call(async move |mut rpc: Rpc| rpc.remove_tracks(wire).await);
+            }
+            Action::QueueToggleMark => self.queue_cursor.update(QueueCursor::toggle_mark),
+            Action::QueueVisualMode => self.queue_cursor.update(QueueCursor::toggle_visual),
+            Action::QueueYank => {
+                let positions = self
+                    .queue_cursor
+                    .with_untracked(QueueCursor::action_positions);
+                if self.yank_positions(&positions) {
+                    self.queue_cursor.update(QueueCursor::remove_marks);
+                }
+            }
+            Action::QueuePaste => self.paste(false),
+            Action::QueuePasteBefore => self.paste(true),
+            Action::LibraryVisualMode => self.library.update(LibraryPane::toggle_visual),
+            Action::LibraryYank => {
+                if let Some((paths, labels)) =
+                    self.library.with_untracked(LibraryPane::yank_selection)
+                {
+                    self.register.update(|r| r.set(paths, labels));
+                    self.library.update(LibraryPane::remove_marks);
                 }
             }
             Action::QueueClearKeepCurrent => {
+                let current = self.queue_pos.get_untracked() as usize;
+                let keep: Vec<usize> = (0..self.queue.with_untracked(Vec::len))
+                    .filter(|pos| *pos != current)
+                    .collect();
+                self.yank_positions(&keep);
                 self.call(async |mut rpc: Rpc| rpc.clear_queue(true).await)
             }
-            Action::QueueClearAll => self.call(async |mut rpc: Rpc| rpc.clear_queue(false).await),
+            Action::QueueClearAll => {
+                let all: Vec<usize> = (0..self.queue.with_untracked(Vec::len)).collect();
+                self.yank_positions(&all);
+                self.call(async |mut rpc: Rpc| rpc.clear_queue(false).await)
+            }
             Action::QueueSaveAs => {
                 if self.queue.with_untracked(|q| !q.is_empty()) {
                     self.dialog.set(Some(Dialog::Name {
@@ -935,14 +1042,19 @@ fn QueueView(store: Store) -> impl IntoView {
                 <span class="path">
                     "queue"
                     {move || store.resolving.get().then_some(" (loading…)")}
+                    {move || {
+                        // A paste is blind unless the register is visible.
+                        let reg = store.register.get();
+                        (!reg.is_empty()).then(|| format!(" — register: {}", reg.len()))
+                    }}
                 </span>
                 <span class="spacer"></span>
                 <button
                     class="ghost"
-                    title="insert library selection after selected (p)"
-                    on:click=move |_| store.dispatch(Action::QueueInsertHere)
+                    title="paste the register after selected (p)"
+                    on:click=move |_| store.dispatch(Action::QueuePaste)
                 >
-                    "insert"
+                    "paste"
                 </button>
                 <button
                     class="ghost"
@@ -969,7 +1081,9 @@ fn QueueView(store: Store) -> impl IntoView {
             <ul class="list">
                 {move || {
                     let current = store.queue_pos.get() as usize;
-                    let cursor = store.queue_cursor.get().selected;
+                    let queue_state = store.queue_cursor.get();
+                    let cursor = queue_state.selected;
+                    let marks = queue_state.marks.clone();
                     store
                         .queue
                         .get()
@@ -977,9 +1091,11 @@ fn QueueView(store: Store) -> impl IntoView {
                         .enumerate()
                         .map(|(index, track)| {
                             let label = track_label(track);
+                            let marked = marks.get(index).copied().unwrap_or(false);
                             view! {
                                 <li
                                     class:selected=index == cursor
+                                    class:marked=marked
                                     class:current=index == current
                                     class:skipped=track.is_skipped
                                     on:click=move |_| {
diff --git a/cbd-web/src/keymap.rs b/cbd-web/src/keymap.rs
index 1420d32..91ee932 100644
--- a/cbd-web/src/keymap.rs
+++ b/cbd-web/src/keymap.rs
@@ -30,6 +30,8 @@ pub enum Action {
     LibraryAscend,
     LibraryDive,
     LibraryToggleMark,
+    LibraryVisualMode,
+    LibraryYank,
     LibraryCaptureNode,
     LibraryDownloadNode,
     LibraryCreateNode,
@@ -46,7 +48,11 @@ pub enum Action {
     QueueJumpUp,
     QueueSelectCurrent,
     QueuePlaySelected,
-    QueueInsertHere,
+    QueueToggleMark,
+    QueueVisualMode,
+    QueueYank,
+    QueuePaste,
+    QueuePasteBefore,
     QueueRemoveTrack,
     QueueClearKeepCurrent,
     QueueClearAll,
@@ -148,6 +154,16 @@ pub const HELP: &[HelpEntry] = &[
         key: "s",
         description: "Mark/unmark selection",
     },
+    HelpEntry {
+        scope: "Library",
+        key: "v / V",
+        description: "Visual mode: movement toggles marks",
+    },
+    HelpEntry {
+        scope: "Library",
+        key: "y",
+        description: "Yank selection into the register",
+    },
     HelpEntry {
         scope: "Library",
         key: "w",
@@ -215,8 +231,23 @@ pub const HELP: &[HelpEntry] = &[
     },
     HelpEntry {
         scope: "Queue",
-        key: "p",
-        description: "Insert library selection after this track",
+        key: "s",
+        description: "Mark/unmark selection",
+    },
+    HelpEntry {
+        scope: "Queue",
+        key: "v / V",
+        description: "Visual mode: movement toggles marks",
+    },
+    HelpEntry {
+        scope: "Queue",
+        key: "y",
+        description: "Yank selection into the register",
+    },
+    HelpEntry {
+        scope: "Queue",
+        key: "p / P",
+        description: "Paste the register after / before this track",
     },
     HelpEntry {
         scope: "Queue",
@@ -293,6 +324,8 @@ pub fn lookup(focus: Focus, help_open: bool, key: &str, ctrl: bool) -> Option<Ac
             "h" | "ArrowLeft" => Some(Action::LibraryAscend),
             "l" | "ArrowRight" => Some(Action::LibraryDive),
             "s" => Some(Action::LibraryToggleMark),
+            "v" | "V" => Some(Action::LibraryVisualMode),
+            "y" => Some(Action::LibraryYank),
             "w" => Some(Action::LibraryCaptureNode),
             "W" => Some(Action::LibraryDownloadNode),
             "%" => Some(Action::LibraryCreateNode),
@@ -310,7 +343,11 @@ pub fn lookup(focus: Focus, help_open: bool, key: &str, ctrl: bool) -> Option<Ac
             "G" => Some(Action::QueueLast),
             "o" => Some(Action::QueueSelectCurrent),
             "Enter" => Some(Action::QueuePlaySelected),
-            "p" => Some(Action::QueueInsertHere),
+            "s" => Some(Action::QueueToggleMark),
+            "v" | "V" => Some(Action::QueueVisualMode),
+            "y" => Some(Action::QueueYank),
+            "p" => Some(Action::QueuePaste),
+            "P" => Some(Action::QueuePasteBefore),
             "d" => Some(Action::QueueRemoveTrack),
             "c" => Some(Action::QueueClearKeepCurrent),
             "C" => Some(Action::QueueClearAll),
diff --git a/cbd-web/src/state.rs b/cbd-web/src/state.rs
index 0a80ce2..6e60d18 100644
--- a/cbd-web/src/state.rs
+++ b/cbd-web/src/state.rs
@@ -104,6 +104,10 @@ pub struct LibraryPane {
     pub is_creatable: bool,
     pub items: Vec<UiItem>,
     pub selected: usize,
+    /// Visual (paint-select) mode: `Some(anchor)` while active. Movement
+    /// toggles the marks of the range between the anchor and the cursor, so
+    /// moving back reverses — the TUI's rule, same code shape.
+    pub visual: Option<usize>,
     positions: HashMap<String, usize>,
 }
 
@@ -193,6 +197,66 @@ impl LibraryPane {
         }
     }
 
+    /// Toggle the mark of one row, honoring the queueable gate.
+    fn toggle_mark_at(&mut self, index: usize) {
+        if let Some(item) = self.items.get_mut(index) {
+            if item.is_queable {
+                item.marked = !item.marked;
+            }
+        }
+    }
+
+    /// Enter or leave visual mode. Entering anchors at the cursor and marks
+    /// it; leaving keeps the marks.
+    pub fn toggle_visual(&mut self) {
+        if self.visual.is_some() {
+            self.visual = None;
+        } else {
+            self.visual = Some(self.selected);
+            self.toggle_mark();
+        }
+    }
+
+    pub fn exit_visual(&mut self) {
+        self.visual = None;
+    }
+
+    pub fn is_visual(&self) -> bool {
+        self.visual.is_some()
+    }
+
+    /// Paint a visual-mode sweep: toggle every row whose membership in the
+    /// anchored range changed, so moving back over a row reverses it.
+    pub fn paint_between(&mut self, from: usize, to: usize) {
+        let Some(anchor) = self.visual else {
+            return;
+        };
+        let (old_lo, old_hi) = (anchor.min(from), anchor.max(from));
+        let (new_lo, new_hi) = (anchor.min(to), anchor.max(to));
+        for index in old_lo.min(new_lo)..=old_hi.max(new_hi) {
+            let in_old = (old_lo..=old_hi).contains(&index);
+            let in_new = (new_lo..=new_hi).contains(&index);
+            if in_old != in_new {
+                self.toggle_mark_at(index);
+            }
+        }
+    }
+
+    /// What `y` puts in the register: the marked rows, or the queueable
+    /// cursor row — paths with labels for display.
+    pub fn yank_selection(&self) -> Option<(Vec<String>, Vec<String>)> {
+        if self.items.iter().any(|i| i.marked) {
+            let marked = self.items.iter().filter(|i| i.marked);
+            return Some((
+                marked.clone().map(|i| i.path.clone()).collect(),
+                marked.map(|i| i.title.clone()).collect(),
+            ));
+        }
+        let item = self.selected_item()?;
+        item.is_queable
+            .then(|| (vec![item.path.clone()], vec![item.title.clone()]))
+    }
+
     pub fn remove_marks(&mut self) {
         for item in &mut self.items {
             item.marked = false;
@@ -242,9 +306,20 @@ impl LibraryPane {
 /// The queue pane cursor. The queue itself (tracks, current position,
 /// play state) lives in signals fed by the update stream; this only
 /// tracks the selection.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+// No longer `Copy`: it owns the mark flags and the paths they were taken
+// against (architecture/queue-register.md).
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct QueueCursor {
     pub selected: usize,
+    /// Marks, one flag per queue position. The queue is server-pushed and has
+    /// no client-owned list, so these sit beside the snapshot and are carried
+    /// across updates by [`carry_marks`].
+    pub marks: Vec<bool>,
+    /// The track paths `marks` was taken against, so the next snapshot can be
+    /// matched against it.
+    paths: Vec<String>,
+    /// Visual (paint-select) mode anchor, as in the library.
+    pub visual: Option<usize>,
 }
 
 impl QueueCursor {
@@ -258,6 +333,156 @@ impl QueueCursor {
     pub fn clamp(&mut self, len: usize) {
         self.selected = self.selected.min(len.saturating_sub(1));
     }
+
+    /// Apply a fresh queue snapshot: marks follow their own track rather than
+    /// their old index, so a mark cannot silently retarget when playback
+    /// advances or another client edits the queue.
+    pub fn reconcile(&mut self, new_paths: Vec<String>) {
+        self.marks = carry_marks(&self.paths, &self.marks, &new_paths);
+        self.paths = new_paths;
+        self.clamp(self.marks.len());
+    }
+
+    pub fn has_marks(&self) -> bool {
+        self.marks.iter().any(|m| *m)
+    }
+
+    /// The positions an action applies to: every marked row, or the cursor
+    /// row when nothing is marked.
+    pub fn action_positions(&self) -> Vec<usize> {
+        if self.has_marks() {
+            return self
+                .marks
+                .iter()
+                .enumerate()
+                .filter(|(_, marked)| **marked)
+                .map(|(pos, _)| pos)
+                .collect();
+        }
+        if self.marks.is_empty() {
+            return Vec::new();
+        }
+        vec![self.selected]
+    }
+
+    fn toggle_mark_at(&mut self, index: usize) {
+        if let Some(mark) = self.marks.get_mut(index) {
+            *mark = !*mark;
+        }
+    }
+
+    /// Every queue row may be marked — unlike the library there is no
+    /// queueable gate to apply.
+    pub fn toggle_mark(&mut self) {
+        self.toggle_mark_at(self.selected);
+    }
+
+    pub fn remove_marks(&mut self) {
+        for mark in &mut self.marks {
+            *mark = false;
+        }
+    }
+
+    pub fn toggle_visual(&mut self) {
+        if self.visual.is_some() {
+            self.visual = None;
+        } else {
+            self.visual = Some(self.selected);
+            self.toggle_mark();
+        }
+    }
+
+    pub fn exit_visual(&mut self) {
+        self.visual = None;
+    }
+
+    pub fn is_visual(&self) -> bool {
+        self.visual.is_some()
+    }
+
+    /// The library's paint rule, over positions instead of view rows.
+    pub fn paint_between(&mut self, from: usize, to: usize) {
+        let Some(anchor) = self.visual else {
+            return;
+        };
+        let (old_lo, old_hi) = (anchor.min(from), anchor.max(from));
+        let (new_lo, new_hi) = (anchor.min(to), anchor.max(to));
+        for index in old_lo.min(new_lo)..=old_hi.max(new_hi) {
+            let in_old = (old_lo..=old_hi).contains(&index);
+            let in_new = (new_lo..=new_hi).contains(&index);
+            if in_old != in_new {
+                self.toggle_mark_at(index);
+            }
+        }
+    }
+
+    /// The insert position for a paste: after the cursor for `p`, at the
+    /// cursor for `P`. An empty queue pastes at the front.
+    pub fn paste_position(&self, before: bool) -> u32 {
+        if self.marks.is_empty() {
+            return 0;
+        }
+        let pos = if before {
+            self.selected
+        } else {
+            self.selected + 1
+        };
+        pos as u32
+    }
+}
+
+/// What `y`, `d`, `c`, and `C` set aside and `p`/`P` paste back — one unnamed
+/// in-memory slot of library paths, with labels for display only. Overwritten
+/// by each write; paste re-resolves the paths, so a yanked node expands at
+/// paste time.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct Register {
+    paths: Vec<String>,
+    labels: Vec<String>,
+}
+
+impl Register {
+    pub fn set(&mut self, paths: Vec<String>, labels: Vec<String>) {
+        self.paths = paths;
+        self.labels = labels;
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.paths.is_empty()
+    }
+
+    pub fn len(&self) -> usize {
+        self.paths.len()
+    }
+
+    pub fn paths(&self) -> &[String] {
+        &self.paths
+    }
+
+    pub fn labels(&self) -> &[String] {
+        &self.labels
+    }
+}
+
+/// Carry queue marks across a server snapshot by a greedy in-order match on
+/// track path — the same rule the TUI applies (`cbd-tui/src/app/list.rs`).
+///
+/// A mark follows its track through appends, removals, and playback
+/// advancing; a mark whose track is gone is dropped; duplicate paths pair up
+/// in order. Nothing in common means no marks rather than a guess.
+pub fn carry_marks(old_paths: &[String], old_marked: &[bool], new_paths: &[String]) -> Vec<bool> {
+    let mut carried = vec![false; new_paths.len()];
+    let mut old_idx = 0;
+    for (new_idx, path) in new_paths.iter().enumerate() {
+        while old_idx < old_paths.len() && &old_paths[old_idx] != path {
+            old_idx += 1;
+        }
+        if old_idx < old_paths.len() {
+            carried[new_idx] = old_marked.get(old_idx).copied().unwrap_or(false);
+            old_idx += 1;
+        }
+    }
+    carried
 }
 
 /// How long a finished capture's line lingers, in milliseconds —
@@ -526,4 +751,150 @@ mod tests {
         assert_eq!(format_seconds(3600), "1:00:00");
         assert_eq!(format_seconds(3661), "1:01:01");
     }
+
+    fn v(items: &[&str]) -> Vec<String> {
+        items.iter().map(|s| s.to_string()).collect()
+    }
+
+    /// The same reconciliation cases the TUI pins, so the two clients cannot
+    /// drift (quality/queue-register.md G18).
+    #[test]
+    fn marks_follow_their_track_across_a_snapshot() {
+        // Unchanged.
+        assert_eq!(
+            carry_marks(&v(&["/a", "/b"]), &[false, true], &v(&["/a", "/b"])),
+            vec![false, true]
+        );
+        // Append leaves earlier marks alone.
+        assert_eq!(
+            carry_marks(&v(&["/a", "/b"]), &[false, true], &v(&["/a", "/b", "/c"])),
+            vec![false, true, false]
+        );
+        // A removal before the mark shifts it down.
+        assert_eq!(
+            carry_marks(
+                &v(&["/a", "/b", "/c"]),
+                &[false, false, true],
+                &v(&["/b", "/c"])
+            ),
+            vec![false, true]
+        );
+        // The marked track itself is gone.
+        assert_eq!(
+            carry_marks(&v(&["/a", "/b"]), &[false, true], &v(&["/a"])),
+            vec![false]
+        );
+        // Nothing in common: no marks rather than a guess.
+        assert_eq!(
+            carry_marks(&v(&["/a"]), &[true], &v(&["/x", "/y"])),
+            vec![false, false]
+        );
+        // Duplicates pair up in order.
+        assert_eq!(
+            carry_marks(&v(&["/a", "/a"]), &[false, true], &v(&["/a", "/a"])),
+            vec![false, true]
+        );
+        // A short mark vector must not panic.
+        assert_eq!(
+            carry_marks(&v(&["/a", "/b"]), &[true], &v(&["/a", "/b"])),
+            vec![true, false]
+        );
+    }
+
+    #[test]
+    fn reconcile_carries_marks_and_clamps_the_cursor() {
+        let mut cursor = QueueCursor::default();
+        cursor.reconcile(v(&["/a", "/b", "/c"]));
+        cursor.selected = 2;
+        cursor.toggle_mark();
+        assert_eq!(cursor.action_positions(), vec![2]);
+        // Playback drops the head: the mark follows /c to position 1.
+        cursor.reconcile(v(&["/b", "/c"]));
+        assert_eq!(cursor.action_positions(), vec![1]);
+        assert!(cursor.selected < 2, "cursor clamped into the shorter queue");
+    }
+
+    /// Every queue row is markable — no queueable gate here (G12).
+    #[test]
+    fn the_cursor_row_is_the_default_target() {
+        let mut cursor = QueueCursor::default();
+        cursor.reconcile(v(&["/a", "/b"]));
+        cursor.selected = 1;
+        assert_eq!(cursor.action_positions(), vec![1]);
+        assert!(!cursor.has_marks());
+    }
+
+    #[test]
+    fn an_empty_queue_has_nothing_to_act_on() {
+        let cursor = QueueCursor::default();
+        assert!(cursor.action_positions().is_empty());
+        assert_eq!(cursor.paste_position(false), 0);
+        assert_eq!(cursor.paste_position(true), 0);
+    }
+
+    /// `p` after the cursor, `P` at it (G8).
+    #[test]
+    fn paste_positions_straddle_the_cursor() {
+        let mut cursor = QueueCursor::default();
+        cursor.reconcile(v(&["/a", "/b", "/c"]));
+        cursor.selected = 1;
+        assert_eq!(cursor.paste_position(false), 2);
+        assert_eq!(cursor.paste_position(true), 1);
+    }
+
+    #[test]
+    fn queue_visual_mode_paints_and_reverses() {
+        let mut cursor = QueueCursor::default();
+        cursor.reconcile(v(&["/a", "/b", "/c"]));
+        cursor.toggle_visual();
+        assert!(cursor.is_visual());
+        // Sweep down to 2.
+        for to in 1..=2 {
+            let from = cursor.selected;
+            cursor.selected = to;
+            cursor.paint_between(from, to);
+        }
+        assert_eq!(cursor.action_positions(), vec![0, 1, 2]);
+        // Sweep back up: the row turned around on is released.
+        let from = cursor.selected;
+        cursor.selected = 1;
+        cursor.paint_between(from, 1);
+        assert_eq!(cursor.action_positions(), vec![0, 1]);
+        cursor.exit_visual();
+        assert!(!cursor.is_visual());
+        assert_eq!(cursor.action_positions(), vec![0, 1], "marks survive");
+    }
+
+    #[test]
+    fn library_visual_mode_paints_under_the_queueable_gate() {
+        let mut pane = LibraryPane::default();
+        pane.update(&node("/a", 2, 0));
+        pane.toggle_visual();
+        assert!(pane.is_visual());
+        let from = pane.selected;
+        pane.selected = 1;
+        pane.paint_between(from, 1);
+        let marked: Vec<&str> = pane
+            .items
+            .iter()
+            .filter(|i| i.marked)
+            .map(|i| i.path.as_str())
+            .collect();
+        assert_eq!(marked.len(), 2, "both queueable rows painted: {marked:?}");
+    }
+
+    #[test]
+    fn a_register_write_overwrites_and_survives_reads() {
+        let mut reg = Register::default();
+        assert!(reg.is_empty());
+        reg.set(v(&["/a"]), v(&["A"]));
+        reg.set(v(&["/b", "/c"]), v(&["B", "C"]));
+        assert_eq!(reg.len(), 2);
+        assert_eq!(reg.paths(), ["/b", "/c"]);
+        assert_eq!(reg.labels(), ["B", "C"]);
+        // Reading does not consume.
+        assert_eq!(reg.paths(), ["/b", "/c"]);
+        reg.set(Vec::new(), Vec::new());
+        assert!(reg.is_empty());
+    }
 }
diff --git a/docs/src/clients/tui.md b/docs/src/clients/tui.md
index ec6e388..8c3ca35 100644
--- a/docs/src/clients/tui.md
+++ b/docs/src/clients/tui.md
@@ -48,12 +48,12 @@ it, and while it is open every other key is inert.
 - `s` toggles a **mark** on the selected item. Marks live on the full
   item list (they survive filtering) so a marked-but-hidden row still
   counts when you queue or save.
-- `v` (or `V`) enters **visual mode** in the library: movement then marks
-  or unmarks the rows you sweep over, like vim's visual selection. The
-  selection is anchored where you entered it, so moving back over a row
-  reverses it. `Esc` leaves visual mode (keeping the marks and any `/`
-  filter), and so does any non-movement action. The pane title shows
-  `— VISUAL` while it is on.
+- `v` (or `V`) enters **visual mode**: movement then marks or unmarks the
+  rows you sweep over, like vim's visual selection. The selection is
+  anchored where you entered it, so moving back over a row reverses it.
+  `Esc` leaves visual mode (keeping the marks and any `/` filter), and so
+  does any non-movement action. The pane title shows `— VISUAL` while it is
+  on. Both panes have it.
 - `w` **saves** the selection — a library subtree, or in the queue pane
   the whole queue — as a new folder of link files under
   `/crabidy/<name>`; playback replays it from the source provider.
@@ -74,6 +74,39 @@ confirmation — it removes only the metadata toml, never the shared
 store audio, which other saves may reference.
 ```
 
+## The register: `y`, `d`, and `p`/`P`
+
+The queue has marks and visual mode too, and they feed a **register** — one
+in-memory slot, like vim's unnamed register:
+
+- `y` **yanks** the selection into the register without changing anything.
+  It works in both panes: in the library it yanks the paths you have marked
+  (or the row under the cursor), in the queue the marked tracks.
+- `d` in the queue **deletes** every marked row (or the cursor row) in one
+  go — and puts them in the register first.
+- `c` and `C` also fill the register with what they clear, so emptying the
+  queue by accident is recoverable.
+- `p` **pastes** the register after the cursor, `P` before it. The register
+  survives, so you can paste again.
+
+That gives you the two vim moves: `d` then `P` puts the tracks back exactly
+where they were, and `d` … `p` moves them somewhere else. The queue title
+shows `register: n` while something is in it, so a paste is never blind.
+
+```admonish note
+`p` used to insert the **library** selection at the cursor. It now pastes
+the register, so that flow is `y` in the library, then `p` in the queue.
+`a`, `L`, and `Enter` still queue the library selection directly.
+```
+
+```admonish warning
+The register lives in **your client**, in memory, one slot deep: another
+client cannot undo your delete, a restart forgets it, and each write
+overwrites the last. It holds *paths*, so a paste re-resolves them — a
+yanked album node expands to its tracks at paste time, and a path that no
+longer resolves (a search term you deleted meanwhile) does not come back.
+```
+
 ## The `/` live filter
 
 Pressing `/` opens a search input that filters the focused pane's items
@@ -139,6 +172,7 @@ pane).
 | Library | `l`               | Enter selected folder                     |
 | Library | `s`               | Mark / unmark selection                   |
 | Library | `v` / `V`         | Visual mode: movement toggles marks       |
+| Library | `y`               | Yank selection into the register          |
 | Library | `Enter`           | Replace queue with selection              |
 | Library | `a`               | Append selection to queue                 |
 | Library | `L`               | Queue selection after current track       |
@@ -152,12 +186,15 @@ pane).
 | Queue   | `g` / `G`         | Select first / last track                 |
 | Queue   | `Ctrl-d`          | Jump 15 tracks down                       |
 | Queue   | `Ctrl-u`          | Jump 15 tracks up                         |
+| Queue   | `s`               | Mark / unmark selection                   |
+| Queue   | `v` / `V`         | Visual mode: movement toggles marks       |
+| Queue   | `y`               | Yank selection into the register          |
 | Queue   | `o`               | Select the playing track                  |
 | Queue   | `Enter`           | Play selected track                       |
-| Queue   | `p`               | Insert library selection after this track |
-| Queue   | `d`               | Remove selected track                     |
-| Queue   | `c`               | Clear queue except current track          |
-| Queue   | `C`               | Clear entire queue                        |
+| Queue   | `p` / `P`         | Paste the register after / before         |
+| Queue   | `d`               | Remove selection (into the register)      |
+| Queue   | `c`               | Clear queue except current (to register)  |
+| Queue   | `C`               | Clear entire queue (to register)          |
 | Queue   | `w`               | Save queue under a name                   |
 | Queue   | `W`               | Capture the queue into /crabidy (audio)   |
 | Queue   | `/`               | Filter this view                          |
diff --git a/docs/src/clients/web.md b/docs/src/clients/web.md
index 19e3add..59e073d 100644
--- a/docs/src/clients/web.md
+++ b/docs/src/clients/web.md
@@ -9,8 +9,13 @@ terminal required, so phones, tablets, and guests can drive the server.
 
 Every TUI binding has a clickable equivalent, and the familiar keyboard
 bindings (`j`/`k`/`h`/`l`, `Tab`, `%`, `e`, `d`, `w`, `W`, playback and
-queue keys, `?` for help) also work on desktop browsers. The `/` live
-filter is TUI-only for now.
+queue keys, `?` for help) also work on desktop browsers. That includes
+marks (`s`), visual mode (`v`/`V`) in both panes, and the register — `y`
+yanks, `d`/`c`/`C` fill it as they remove, and `p`/`P` paste it after or
+before the cursor (see [the TUI's register
+section](./tui.md#the-register-y-d-and-pp), which behaves identically here;
+the queue toolbar shows how many entries are waiting). The `/` live filter
+is TUI-only for now.
 
 ## How it is served
 
diff --git a/docs/src/queue.md b/docs/src/queue.md
index cdd9d6a..518e394 100644
--- a/docs/src/queue.md
+++ b/docs/src/queue.md
@@ -132,6 +132,28 @@ pass at most. Without that bound, an all-skipped queue with repeat on would
 cycle forever and hammer the provider; instead the search gives up after one
 pass and the player stops.
 
+## Editing the queue from a client
+
+Queue edits are ordinary RPCs — `Insert`, `Remove`, `Clear`, `SetCurrent` —
+and both clients drive them the same way: mark rows with `s`, sweep them
+with visual mode (`v`/`V`), then `d` to remove or `y` to yank. Removed and
+yanked tracks land in a client-side **register** that `p`/`P` paste back,
+which is the closest thing to an undo the queue has. It is per client and
+in memory; the server keeps no edit history. See [the terminal
+client](./clients/tui.md#the-register-y-d-and-pp) for the keys and the
+limits.
+
+Two consequences worth knowing:
+
+- `Remove` takes **positions**, so a client must send positions from the
+  queue state it is currently showing. Both clients carry their marks across
+  each pushed queue snapshot by matching track paths, so a mark follows its
+  own track when playback advances or another client edits the queue —
+  rather than silently pointing at whatever now sits at that index.
+- `Insert` takes **paths**, so a paste re-resolves them. Pasting a yanked
+  node expands it to tracks at paste time, and a path that no longer
+  resolves simply does not come back.
+
 ## Persistence
 
 The live queue survives a server restart. It is mirrored to the reserved
diff --git a/plan/queue-register.md b/plan/queue-register.md
index 9bb7667..8da4181 100644
--- a/plan/queue-register.md
+++ b/plan/queue-register.md
@@ -10,85 +10,88 @@ path list (G25).
 
 ## A — Shared mark and visual behaviour (`cbd-tui`)
 
-- [ ] **A1 — Fill in `MarkedPane`** in `app/list.rs`: `toggle_visual`,
+- [x] **A1 — Fill in `MarkedPane`** in `app/list.rs`: `toggle_visual`,
   `toggle_mark`, `toggle_mark_view`, `paint_between`, `selection` — moved
   verbatim in behaviour from `library.rs`, with the `markable` gate taken
   from the implementor. *Verifies:* G11, G12, G16.
-- [ ] **A2 — `impl MarkedPane for Library`**, deleting the now-duplicated
+- [x] **A2 — `impl MarkedPane for Library`**, deleting the now-duplicated
   inherent methods and keeping `get_selected` as a thin wrapper over
   `selection` so existing call sites are untouched. `markable` =
   `is_queable`. *Verifies:* the existing library visual-mode suite passes
   unchanged (G11, G12).
-- [ ] **A3 — `carry_marks`** in `app/list.rs`: greedy in-order path match,
+- [x] **A3 — `carry_marks`** in `app/list.rs`: greedy in-order path match,
   drop marks whose track is gone, all-false when nothing matches, tolerant
   of a short `old_marked`. *Verifies:* the ten `carry_marks_tests` (G2, G3).
-- [ ] **A4 — Commit A.** Existing 91 tests plus the `carry_marks` suite
-  green; clippy and fmt clean. No behaviour change yet.
+- [x] **A4 — Commit A.** *Merged into commit B:* group A alone leaves
+  `carry_marks` and `Register` unwired, and committing dead code for the next
+  commit to use is worse than one larger commit. The extraction is still
+  proven behaviour-preserving — the library's whole visual-mode suite passes
+  untouched.
 
 ## B — Queue marks and the register (`cbd-tui`)
 
-- [ ] **B1 — `impl MarkedPane for Queue`** with `markable` = always, and a
+- [x] **B1 — `impl MarkedPane for Queue`** with `markable` = always, and a
   `visual: Option<usize>` field on `Queue`. *Verifies:* G12.
-- [ ] **B2 — `update_queue` carries marks** through `carry_marks` instead of
+- [x] **B2 — `update_queue` carries marks** through `carry_marks` instead of
   rebuilding them as `false`: keep the previous path list and mark flags,
   reconcile, apply. *Verifies:* G1, G2.
-- [ ] **B3 — `Register::set`** (replace the `todo!()`) and an `App.register`
+- [x] **B3 — `Register::set`** (replace the `todo!()`) and an `App.register`
   field. *Verifies:* the register suite (G6, G10).
-- [ ] **B4 — `y` in both panes.** New `Action::LibraryYank` and
+- [x] **B4 — `y` in both panes.** New `Action::LibraryYank` and
   `Action::QueueYank`; each takes `selection()`, writes the register, and
   clears the marks it consumed. *Verifies:* G5, G14, G15.
-- [ ] **B5 — `d` in the queue deletes every marked row** (cursor row when
+- [x] **B5 — `d` in the queue deletes every marked row** (cursor row when
   none), writing them to the register first, in one `RemoveTracks` call with
   positions from the current list. Replaces the `FIXME`. *Verifies:* G1,
   G13, G14, G15.
-- [ ] **B6 — `c`/`C` fill the register** with the tracks they drop (`C`
+- [x] **B6 — `c`/`C` fill the register** with the tracks they drop (`C`
   everything, `c` everything but the current track). *Verifies:* G4.
-- [ ] **B7 — `p`/`P` paste the register.** `Action::QueuePaste` /
+- [x] **B7 — `p`/`P` paste the register.** `Action::QueuePaste` /
   `QueuePasteBefore` send `InsertTracks(register.paths(), pos)` with `pos` =
   cursor + 1 for `p`, cursor for `P`; a no-op on an empty register; the
   register survives. `QueueInsertHere`'s old cross-pane behaviour is gone.
   *Verifies:* G7, G8, G9.
-- [ ] **B8 — Queue visual mode in dispatch.** A `queue_move` wrapper
+- [x] **B8 — Queue visual mode in dispatch.** A `queue_move` wrapper
   mirroring `library_move`, and the visual auto-leave guard generalized to
   whichever pane is in visual mode with its own movement whitelist.
   *Verifies:* G11.
-- [ ] **B9 — Bindings + help.** Queue scope gains `s`, `v`, `V`, `y`, `P`;
+- [x] **B9 — Bindings + help.** Queue scope gains `s`, `v`, `V`, `y`, `P`;
   library gains `y`; `p`'s description changes. The help modal derives from
   `BINDINGS`, so it follows. *Verifies:* G19, G20.
-- [ ] **B10 — Status feedback.** The pane title shows `— VISUAL` in the
+- [x] **B10 — Status feedback.** The pane title shows `— VISUAL` in the
   queue as in the library, and a non-empty register is visible somewhere
   (title or now-playing line) so paste is not blind. *Verifies:* G22 in
   spirit; keeps G9's no-op explicable.
-- [ ] **B11 — Dispatch tests** for the gates named above. *Verifies:* G1,
+- [x] **B11 — Dispatch tests** for the gates named above. *Verifies:* G1,
   G4, G5, G7–G9, G13–G15.
-- [ ] **B12 — Commit B** with the whole `cbd-tui` suite, clippy `-D
+- [x] **B12 — Commit B** with the whole `cbd-tui` suite, clippy `-D
   warnings`, and fmt clean (G24, G26).
 
 ## C — `cbd-web` parity and docs
 
-- [ ] **C1 — `Register` + `carry_marks` in `cbd-web/src/state.rs`**, same
+- [x] **C1 — `Register` + `carry_marks` in `cbd-web/src/state.rs`**, same
   shape and same test cases as the TUI's. *Verifies:* G17, G18.
-- [ ] **C2 — Library visual mode** (the piece deferred when `v`/`V` landed
+- [x] **C2 — Library visual mode** (the piece deferred when `v`/`V` landed
   in the TUI): `visual: Option<usize>` on `LibraryPane`, the same anchored
   paint, `Action::LibraryVisualMode` on `v`/`V`, auto-leave on non-movement.
   *Verifies:* G17.
-- [ ] **C3 — Queue marks beside the signal.** The web queue owns no list, so
+- [x] **C3 — Queue marks beside the signal.** The web queue owns no list, so
   hold `marks: Vec<bool>` plus the path list they were taken against, and
   reconcile on each `Queue` update. *Verifies:* G18.
-- [ ] **C4 — Queue actions:** `QueueToggleMark`, `QueueVisualMode`,
+- [x] **C4 — Queue actions:** `QueueToggleMark`, `QueueVisualMode`,
   `QueueYank`, `QueuePaste`, `QueuePasteBefore`, plus `d`/`c`/`C` writing the
   register — same semantics as the TUI. *Verifies:* G17.
-- [ ] **C5 — Keymap + `HELP` table** rows for all of the above, keeping the
+- [x] **C5 — Keymap + `HELP` table** rows for all of the above, keeping the
   lockstep test green; clickable equivalents where the web client has them.
   *Verifies:* G19.
-- [ ] **C6 — Verify the web half properly:** clippy for native **and**
+- [x] **C6 — Verify the web half properly:** clippy for native **and**
   `wasm32-unknown-unknown`, `cargo test -p cbd-web`, and a trunk bundle
   build. *Verifies:* G26.
-- [ ] **C7 — Docs.** `docs/src/clients/tui.md` (key table + a register
+- [x] **C7 — Docs.** `docs/src/clients/tui.md` (key table + a register
   section), `docs/src/clients/web.md`, `docs/src/queue.md` (what the register
   is and is not), and the README usage section. State plainly that `p`
   changed meaning. *Verifies:* G21, G22, G23.
-- [ ] **C8 — `plan/summary.md`** entry, then commit C.
+- [x] **C8 — `plan/summary.md`** entry, then commit C.
 
 ## Deferred (recorded, not dropped)
 
diff --git a/plan/summary.md b/plan/summary.md
index 3fe942c..84fabb8 100644
--- a/plan/summary.md
+++ b/plan/summary.md
@@ -1279,3 +1279,66 @@ provider-less and the `fs,opus` binaries under isolated XDG dirs: startup
 logs the feature list, writes a default config listing only built-ins, and
 warns once per unavailable name. Not exercised: `nix build` (not run here)
 and playback of an Opus file in an `opus`-less build (no audio device).
+
+## queue register (2026-07-26)
+
+Marks and visual mode for the queue pane, paired with a vim-style register:
+`y` yanks, `d`/`c`/`C` fill it as they remove, `p`/`P` paste it back after
+or before the cursor. Both clients, in one change. Ran the full dev-flow:
+`architecture/queue-register.md` (D1–D10), `quality/queue-register.md`
+(G1–G26), `plan/queue-register.md`.
+
+**No server work at all** — that was the feasibility finding that made this
+cheap: `Remove` already accepted many positions and `Insert` already took a
+path list, so the register reduces to a `Vec<String>` and the whole feature
+is two clients.
+
+**Design decisions taken in discussion with the user** (all four of my
+recommendations were accepted):
+
+- **Only `y`/`d`/`c`/`C` write the register.** The user's first proposal had
+  a library selection fill it implicitly, which keeps `p` backward
+  compatible — I argued against it because `s` in the library would then
+  silently clobber a clipboard you were about to paste, and the one thing
+  that makes vim registers safe is that only explicit yank/delete write
+  them. The cost lands on one flow only (browse→insert-here is now `y` then
+  `p`); `a`/`L`/`Enter` are untouched.
+- **`p` after the cursor, `P` before**, because after a delete the cursor
+  sits on the successor, so paste-after lands one slot late — `P` is the
+  exact restore.
+- **`c`/`C` fill the register**, the destructive ops most worth undoing.
+- **One unnamed slot**, with `Register` shaped so named registers stay
+  additive.
+
+**The one hard problem** was that queue marks are positional while the queue
+is server-pushed and rebuilt on every change (append, playback advancing,
+each streaming-resolve chunk). Naive index remapping silently retargets a
+mark, so `d` would delete the wrong tracks. `carry_marks()` carries marks
+across a snapshot by a greedy in-order match on track path; irreconcilable
+snapshots clear rather than guess, and positions handed to `Remove` are
+always read off the newest list. Ten test cases pin it in the TUI and the
+same cases again in the web client, so the two cannot drift.
+
+**Structure:** the library's mark/visual code moved into a `MarkedPane`
+trait in `cbd-tui/src/app/list.rs` (beside the existing `StatefulList`),
+which both panes implement — the library keeps `is_queable` as its mark
+gate, the queue allows every row. The web client has no owned queue list
+(just a cursor), so its marks live on `QueueCursor` beside the server
+signal; same rule, different home, as the architecture doc says.
+
+**Deviations from the plan:** commits A and B were merged — group A leaves
+`carry_marks`/`Register` unwired, and committing dead code so the next
+commit can use it is worse than one larger commit. Also removed
+`Library::queue_insert` (orphaned once `p` stopped pulling from the library)
+and rebalanced the help modal's columns: it was already overflowing at 46
+rows in a single column and the seven new bindings made it worse. It still
+truncates below ~43 rows, now pinned by a test rather than hidden —
+scrolling remains the real fix and is still an open question in the
+help-modal design.
+
+Verified: cbd-tui 117 tests (was 91), cbd-web 20 (was 12), clippy clean for
+cbd-tui and for cbd-web on **both** native and wasm32 (`mod app` only
+compiles for wasm, so native clippy alone proves nothing), the trunk bundle
+builds, and the book builds. Not exercised: live keypresses in a terminal
+and in a browser — the pure state machines are unit-tested and both render
+paths compile.