feat(ui): ov2 Phase B — Ctrl-N/P chat switching, /tasks slash, Alt+X for drop-interjection

Second milestone of dirge-ov2. Adds the keyboard surface for the
multi-chat model that Phase A wired into the Renderer.

## New keybinds

- **Ctrl-N**: next chat (cycles through Renderer.chats with wrap)
- **Ctrl-P**: previous chat (wraps)
- **Ctrl-X**: cycle forward to next chat (matches maki's TASKS
  keybinding; will become a proper picker overlay when subagent
  chats actually exist post-Phase E)
- **Alt-X**: drop last queued interjection (was Ctrl-X)

All chat-switch bindings no-op when only the main chat exists,
so single-session usage is unchanged.

## Ctrl-X collision

Per the user's pre-coding decision: dirge's previous Ctrl-X
binding (drop the most-recently-queued interjection) moves to
Alt-X. Ctrl-X is reclaimed for the maki-style task switcher.
Updated the inline hint that prints when the user queues a
message during an active run ("Alt+X drops" instead of "Ctrl+X
drops") and the `/help` listing.

## `/tasks` slash command

Lists the current chat windows with an arrow on the active one
and switches forward by one slot. Same effect as Ctrl-X /
Ctrl-N for users who prefer slash commands. When only the main
chat exists prints a friendly hint pointing at the `task` tool.

## Verified

- `cargo check` clean
- `cargo test chat_snapshot` still passes (Phase A foundation
  intact)
- single-chat sessions behave identically — Ctrl-N/P/X no-op,
  Alt-X works for interjection drop, /tasks shows the hint

## Next

- Phase C: per-chat UI state (response_buf, last_tool_name, etc.)
  moves into a per-chat struct in ui/mod.rs so chat switches
  preserve the streaming context
- Phase D: refactor `task` tool to spawn full agent + events
- Phase E: event router → chat buffer

Author: Yogthos

src/ui/mod.rs

@@ -1294,12 +1294,16 @@ pub async fn run_interactive(
                             )?;
                             continue;
                         }
-                        // Ctrl+X drops the most-recently-queued interjection
-                        // without affecting the running agent. No-op when the
-                        // queue is empty so it doesn't shadow other behaviors.
-                        let ctrl_x = key.code == KeyCode::Char('x')
-                            && key.modifiers.contains(KeyModifiers::CONTROL);
-                        if ctrl_x && !interjection_queue.is_empty() {
+                        // dirge-ov2 Phase B: Ctrl-X is reclaimed for
+                        // the /tasks subagent-chat picker (matches
+                        // maki's binding). The previous "drop queued
+                        // interjection" behavior moves to Alt+X. The
+                        // queued-message footer below now reads
+                        // "Alt+X drops" instead of "Ctrl+X drops" —
+                        // surfaced wherever the queue hint is shown.
+                        let alt_x = key.code == KeyCode::Char('x')
+                            && key.modifiers.contains(KeyModifiers::ALT);
+                        if alt_x && !interjection_queue.is_empty() {
                             interjection_queue.pop_back();
                             write_outside_chamber(
                                 &mut renderer,
@@ -1319,6 +1323,68 @@ pub async fn run_interactive(
                             continue;
                         }
 
+                        // dirge-ov2 Phase B: Ctrl-N cycles to the next
+                        // chat (subagent window). Wraps to first chat
+                        // after the last; no-op when only one chat
+                        // exists. Mirrors maki's NEXT_CHAT binding
+                        // (`components/keybindings.rs:136`).
+                        let ctrl_n = key.code == KeyCode::Char('n')
+                            && key.modifiers.contains(KeyModifiers::CONTROL);
+                        if ctrl_n && renderer.chat_count() > 1 {
+                            let next = (renderer.active_chat() + 1) % renderer.chat_count();
+                            renderer.switch_chat(next);
+                            renderer.render_viewport()?;
+                            renderer.draw_bottom(
+                                &input,
+                                &with_queue(StatusLine::render(session, is_running, 0, loop_label.as_deref(), context.current_prompt_name.as_deref(), perm_mode().as_deref()), interjection_queue.len()),
+                                is_running,
+                            )?;
+                            continue;
+                        }
+
+                        // dirge-ov2 Phase B: Ctrl-P cycles to the
+                        // previous chat. Mirrors maki's PREV_CHAT
+                        // binding (`components/keybindings.rs:135`).
+                        let ctrl_p = key.code == KeyCode::Char('p')
+                            && key.modifiers.contains(KeyModifiers::CONTROL);
+                        if ctrl_p && renderer.chat_count() > 1 {
+                            let count = renderer.chat_count();
+                            let prev = (renderer.active_chat() + count - 1) % count;
+                            renderer.switch_chat(prev);
+                            renderer.render_viewport()?;
+                            renderer.draw_bottom(
+                                &input,
+                                &with_queue(StatusLine::render(session, is_running, 0, loop_label.as_deref(), context.current_prompt_name.as_deref(), perm_mode().as_deref()), interjection_queue.len()),
+                                is_running,
+                            )?;
+                            continue;
+                        }
+
+                        // dirge-ov2 Phase B: Ctrl-X opens the /tasks
+                        // picker — same effect as typing `/tasks`.
+                        // No-op when only the main chat exists
+                        // (nothing to switch between). Maki's TASKS
+                        // keybinding (`components/keybindings.rs`,
+                        // `ctrl_bind!('x')`).
+                        let ctrl_x = key.code == KeyCode::Char('x')
+                            && key.modifiers.contains(KeyModifiers::CONTROL);
+                        if ctrl_x && renderer.chat_count() > 1 {
+                            // Cycle through chats via Ctrl-N once a
+                            // proper picker UI lands in Phase B+.
+                            // For now, cycle forward — gives the
+                            // user a way to land on subagent chats
+                            // via a single key press.
+                            let next = (renderer.active_chat() + 1) % renderer.chat_count();
+                            renderer.switch_chat(next);
+                            renderer.render_viewport()?;
+                            renderer.draw_bottom(
+                                &input,
+                                &with_queue(StatusLine::render(session, is_running, 0, loop_label.as_deref(), context.current_prompt_name.as_deref(), perm_mode().as_deref()), interjection_queue.len()),
+                                is_running,
+                            )?;
+                            continue;
+                        }
+
                         // Ctrl+O — expand the most-recent collapsed
                         // tool result. We re-print it as a fresh
                         // chamber below the current chat so the user
@@ -1937,7 +2003,7 @@ pub async fn run_interactive(
                                 }
                                 renderer.write_line(
                                     &format!(
-                                        "(queued; runner will stop at next safe boundary — Ctrl+X drops, Ctrl+C cancels)"
+                                        "(queued; runner will stop at next safe boundary — Alt+X drops, Ctrl+C cancels)"
                                     ),
                                     theme::dim(),
                                 )?;

src/ui/slash.rs

@@ -1145,6 +1145,33 @@ pub async fn handle_slash(
             *is_running = false;
             return Err(std::io::Error::new(std::io::ErrorKind::Interrupted, "quit").into());
         }
+        // dirge-ov2 Phase B: `/tasks` lists active chat windows and
+        // cycles to the next one. Equivalent to Ctrl-X / Ctrl-N for
+        // keyboard-shy users (or scripts that drive dirge via slash
+        // commands). When only the main chat exists, prints a hint.
+        "/tasks" => {
+            let names = renderer.chat_names();
+            if names.len() <= 1 {
+                renderer.write_line(
+                    "no subagent chats — spawn one via the `task` tool or wait for the agent to dispatch a subagent.",
+                    c_result(),
+                )?;
+            } else {
+                renderer.write_line("chat windows:", c_result())?;
+                let active = renderer.active_chat();
+                for (i, name) in names.iter().enumerate() {
+                    let marker = if i == active { "→" } else { " " };
+                    renderer.write_line(&format!("  {} [{}] {}", marker, i, name), c_result())?;
+                }
+                let next = (active + 1) % names.len();
+                renderer.switch_chat(next);
+                renderer.render_viewport()?;
+                renderer.write_line(
+                    &format!("→ switched to chat {} ({})", next, names[next]),
+                    c_result(),
+                )?;
+            }
+        }
         "/clear" => {
             session.messages.clear();
             session.total_estimated_tokens = 0;
@@ -1767,7 +1794,15 @@ pub async fn handle_slash(
             renderer.write_line("  Ctrl+R                 toggle reasoning", c_result())?;
             renderer.write_line("  Ctrl+C / Ctrl+D        interrupt/quit", c_result())?;
             renderer.write_line(
-                "  Ctrl+X                 drop last queued interjection",
+                "  Ctrl+N / Ctrl+P        next / previous chat (subagent windows)",
+                c_result(),
+            )?;
+            renderer.write_line(
+                "  Ctrl+X / /tasks        cycle through chat windows",
+                c_result(),
+            )?;
+            renderer.write_line(
+                "  Alt+X                  drop last queued interjection",
                 c_result(),
             )?;
             renderer.write_line(