@@ -73,16 +73,15 @@ To work with the agent and the reviewer side by side, start the agent through Kl
 klaub wrap codex                 # or: klaub wrap -- claude --model <model>
 ```
 
-Klaub runs the agent in a session of its own with a reviewer window next to it. Press `Ctrl+B` then `R` to open the reviewer, `Ctrl+B` then `A` to go back to the agent (lower case works too), and `Ctrl+B` then `d` to leave the session running in the background. `klaub session attach` brings it back. `Ctrl+B` then `Q` ends the session and the agent.
+Klaub runs the agent in a session of its own with a reviewer window next to it. Press `Shift+→` to go to the reviewer and `Shift+←` to go back to the agent. `Ctrl+B` then `d` leaves the session running in the background, and `klaub session attach` brings it back. `Ctrl+B` then `Q` ends the session and the agent.
 
-### Your first review in six keys
+### Your first review in five keys
 
-1. Open the queue with `klaub review`. The riskiest change is first.
+1. Open the queue with `klaub review`. The riskiest change is first, and the code of the selected one is beside it.
 2. Press `w` to see why it has that priority.
-3. Press `Enter` to read the whole function. Press `v` to flip between the old and the new version.
-4. Press `i` for the contract and `4` for the callers and the routes that reach the change.
-5. Press `c` to comment on a line, and `r` to mark a unit as reviewed.
-6. Press `F` to finish. Klaub saves the comments and prepares one short instruction for the agent.
+3. Press `Enter` to focus the code, `v` to flip between the old and the new version and `[` and `]` to jump between the changed regions.
+4. Press `i` for the contract and `K` for the symbol panel: its signature with the types, its documentation and its priority.
+5. Press `r` to mark a unit as reviewed, and `2` or `3` to read the same change as a tree or as a list of files.
 
 Press `?` at any time for the key list.
 
@@ -265,29 +264,22 @@ Every key below can be changed in `.klaub.toml` under `[keys]` ([configuration](
 
 | Key | Mode |
 | --- | --- |
-| `1` or `F2` | Review, with the queue on the left |
-| `2` or `F3` | Review, with the structure tree on the left: modules, files and symbols |
-| `3` | Review, with the flat list of changed files on the left |
-| `F4` | Review, with the code focused (`Enter` on a list gets there too) |
-| `4`, `g` or `F5` | Impact: callers, entrypoints, callees |
-| `5` or `F6` | Comments |
-| `6`, `b` or `F8` | Context: brief and acceptance criteria |
-| `7`, `t` or `F7` | Tests |
-| `8` or `F10` | Follow-up: decide on the previous round's comments |
-| `9` | Coverage |
-| `0`, `f` or `F9` | Flow |
+| `1` or `F2` | The queue on the left, ranked by risk |
+| `2` or `F3` | The structure tree on the left: modules, files and symbols |
+| `3` | The flat list of changed files on the left |
+| `F4` | The code focused (`Enter` on a list gets there too) |
 | `Tab`, `Shift+Tab` | Next and previous mode |
 | `Esc` | Go back (from the code, to the list you came from) |
 
-The review screen is a list on the left and the code of the selected unit on the right. The queue, the tree and the file list are three ways to fill the left side, and the code follows the cursor as you move in any of them. `K` shows or hides the panel beside the code: the symbol's signature with its types, the documentation comment it carries, the comments you wrote on it and the reasons for its priority.
+The screen is a list on the left and the code of the selected unit on the right. The queue, the tree and the file list are three ways to fill the left side, and the code follows the cursor as you move in any of them. `K` shows or hides the panel beside the code: the symbol's signature with its types, the documentation comment it carries and the reasons for its priority.
 
 ### Moving and reading
 
 | Key | Action |
 | --- | --- |
 | `j`, `k` or arrows | Move |
 | `h`, `l` | Scroll sideways in code |
-| `Enter` | Open the selected unit, symbol or step |
+| `Enter` | Open the selected unit |
 | `v` | Toggle old and new |
 | `B` (hold) | Show the previous version while held, in supported terminals |
 | `[`, `]` | Previous and next changed region |
@@ -303,15 +295,11 @@ The review screen is a list on the left and the code of the selected unit on the
 
 | Key | Action |
 | --- | --- |
-| `c` | Comment on the selection (`V` selects several lines) |
 | `w` | Why this priority, and silence a false positive |
 | `r` | Mark reviewed or unmark |
 | `m`, `,` | Bookmark a unit, jump to the next bookmark |
 | `n`, `P` | Next and previous unreviewed unit |
 | `N` | Next unreviewed P0 or P1 unit |
-| `e`, `d` | In Comments: edit or delete a draft |
-| `y`, `p`, `u`, `X` | In Follow-up: resolved, partial, unresolved, regression |
-| `F` | Finish the review |
 | `R` | Take a new snapshot after the worktree changed |
 
 ### Filters and tools
@@ -326,25 +314,22 @@ The review screen is a list on the left and the code of the selected unit on the
 | `s` | Minimum reach: local, module or global |
 | `M` | Next module |
 | `x` | Clear filters |
-| `X` | Run the associated tests (asks first) |
-| `U` | Reload test reports |
-| `L` | Reload the flow diagram |
-| `p` | In Impact: pivot on a symbol. In Flow: ask the agent for a diagram |
 
 ### Around the agent
 
 These work after `klaub wrap`. Press the prefix (`Ctrl+B` by default), release it, then the key.
 
 | Key | Action |
 | --- | --- |
+| `Shift+→` | Open the reviewer, with no prefix |
+| `Shift+←` | Back to the agent, with no prefix |
 | `R` or `r` | Open the reviewer |
 | `A` or `a` | Back to the agent |
-| `I`, `C`, `T`, `B`, `L` | Open the reviewer on impact, comments, tests, brief or flow |
 | `d` | Detach and leave the session running (`klaub session attach` brings it back) |
 | `Q` | End the session and its agent, after a `y/n` confirmation |
 | `?` | Print these chords |
 
-An optional mouse mode (`[ui] mouse = true`) adds wheel scrolling and clicks on tabs, rows and code lines.
+An optional mouse mode (`[ui] mouse = true`) adds wheel scrolling and clicks on rows and code lines.
 
 ## Command reference
 
 
@@ -33,7 +33,7 @@ use klaub::adapters::storage::{
 };
 use klaub::app::{OpenOptions, Ports, ReviewSession};
 use klaub::domain::config::Config;
-use klaub::domain::ports::{Clipboard, IdGenerator};
+use klaub::domain::ports::IdGenerator;
 use klaub::domain::snapshot::SnapshotRequest;
 use klaub::tui::{App, draw, handle_key};
 use ratatui::Terminal;
@@ -105,12 +105,7 @@ fn app() -> (TempRepo, App) {
         &OpenOptions::default(),
     )
     .unwrap();
-    let app = App::new(
-        session,
-        Arc::new(TreeSitterParser::new()),
-        None,
-        None::<Arc<dyn Clipboard>>,
-    );
+    let app = App::new(session, Arc::new(TreeSitterParser::new()));
     (repo, app)
 }
 
 
@@ -31,7 +31,7 @@ Every key has a default, so an empty file (or none) is valid. The schema lives i
 | `ui.hold_to_peek` | `false` | Hold `B` (the `peek_previous` key) while reading code to see the previous version, and let go to come back. It needs a terminal that reports key releases (the kitty keyboard protocol: kitty, Ghostty, WezTerm, recent iTerm2 and foot). Where that is missing, which includes tmux, the key says so and `v` still toggles. While it is on, the terminal sends keys as escape codes except inside text fields, which keep ordinary input so compose and `AltGr` characters still type. |
 | `integration.submit_mode` | `"manual"` | The only mode. Klaub never presses `Enter` in the agent. |
 | `integration.paste_requires_confirmation` | `true` | Putting text in the agent's input always asks first. |
-| `integration.tmux_prefix` | `"C-b"` | The prefix of the session chords. Moving between the agent and the reviewer needs no prefix: `Shift+←` goes to the agent and `Shift+→` to the reviewer. The rest are `Prefix+R`, `Prefix+A`, `Prefix+I`, `Prefix+C`, `Prefix+T`, `Prefix+B`, `Prefix+L`, `Prefix+Q` and `Prefix+?`. |
+| `integration.tmux_prefix` | `"C-b"` | The prefix of the session chords. Moving between the agent and the reviewer needs no prefix: `Shift+←` goes to the agent and `Shift+→` to the reviewer. The rest are `Prefix+R`, `Prefix+A`, `Prefix+d`, `Prefix+Q` and `Prefix+?`. |
 
 ## `[keys]`
 
@@ -40,34 +40,28 @@ Moves a reader action to another single character. An action that is moved gives
 ```toml
 [keys]
 toggle_reviewed = "e"
-comment = "C"
+explain = "E"
 ```
 
 The ids are:
 
-`queue`, `structure`, `files`, `code`, `impact`, `comments`, `context`, `tests`, `followup`, `coverage`, `flow`, `next_unreviewed`, `previous_unreviewed`, `next_critical`, `toggle_reviewed`, `toggle_bookmark`, `next_bookmark`, `comment`, `explain`, `toggle_version`, `peek_previous`, `next_change`, `previous_change`, `toggle_code_scope`, `search`, `filter_high`, `filter_unreviewed`, `filter_introduced`, `filter_no_tests`, `filter_new`, `cycle_scope`, `cycle_module`, `clear_filters`, `history_back`, `history_forward`, `deeper_tree`, `shallower_tree`, `run_tests`, `reload_reports`, `reload_flow`, `refresh`, `finish`, `help`.
+`queue`, `structure`, `files`, `code`, `next_unreviewed`, `previous_unreviewed`, `next_critical`, `toggle_reviewed`, `toggle_bookmark`, `next_bookmark`, `explain`, `toggle_version`, `peek_previous`, `next_change`, `previous_change`, `toggle_code_scope`, `search`, `filter_high`, `filter_unreviewed`, `filter_introduced`, `filter_no_tests`, `filter_new`, `cycle_scope`, `cycle_module`, `clear_filters`, `history_back`, `history_forward`, `deeper_tree`, `shallower_tree`, `refresh`, `help`.
 
 The keys that only mean something inside some modes move the same way. A moved key answers to its new character in the modes it works in, and its old character stops acting there:
 
 | Id | Default | Works in |
 | --- | --- | --- |
-| `down`, `up` | `j`, `k` | every list, scrolling view and the delivery list |
+| `down`, `up` | `j`, `k` | every list and the code |
 | `scroll_left`, `scroll_right` | `h`, `l` | Code |
-| `select_lines` | `V` | Code |
 | `open_file` | `o` | Code |
 | `inspect_contract` | `i` | Code |
 | `toggle_inspector` | `K` | Code |
-| `pivot_impact` | `p` | Impact |
-| `request_flow` | `p` | Flow |
-| `edit_intent`, `add_criterion` | `i`, `a` | Context |
-| `edit_comment`, `delete_comment` | `e`, `d` | Comments |
-| `decide_resolved`, `decide_partial`, `decide_unresolved`, `decide_regression` | `y`, `p`, `u`, `X` | Follow-up |
 
 ```toml
 [keys]
 down = "z"
 up = "Z"
-decide_resolved = "Y"
+open_file = "O"
 ```
 
 A mode-specific key may take a letter that another mode uses, but not one that is live in the same mode, and not one a global action already has. The footer and the help show the keys in use.
 
@@ -18,5 +18,5 @@ pub mod tmux;
 mod process;
 mod system;
 
-pub(crate) use process::{ClipboardCopy, ProcessTestRunner};
+pub(crate) use process::ProcessTestRunner;
 pub(crate) use system::{RandomIds, SystemClock};
@@ -1,18 +1,18 @@
-//! Process-backed adapters: the test runner and the clipboard.
+//! Process-backed adapter: the test runner.
 //!
-//! Both spawn a program directly, never through a shell, so a test id or a copied comment cannot
-//! be interpreted as shell syntax. Output is capped and sanitised before it comes back, because it
+//! It spawns the program directly, never through a shell, so a test id cannot be interpreted as
+//! shell syntax. Output is capped and sanitised before it comes back, because it
 //! is later drawn on screen.
 
-use std::io::{Read, Write};
+use std::io::Read;
 use std::os::unix::process::CommandExt;
 use std::process::{Child, Command, Stdio};
 use std::sync::{Arc, Mutex};
 use std::thread::{self, JoinHandle};
 use std::time::{Duration, Instant};
 
 use crate::domain::error::{Error, Result};
-use crate::domain::ports::{CancelToken, Clipboard, TestRunOutcome, TestRunRequest, TestRunner};
+use crate::domain::ports::{CancelToken, TestRunOutcome, TestRunRequest, TestRunner};
 use crate::domain::text::sanitize_terminal_text;
 
 /// How much of a test run's output is kept. The tail is what the reader shows.
@@ -192,54 +192,6 @@ fn tail(text: &str) -> String {
     text[cut..].to_owned()
 }
 
-/// Copies text with `pbcopy` on macOS and `wl-copy` or `xclip` elsewhere. A missing program is an
-/// error the reader reports, not a panic.
-#[derive(Debug, Default)]
-pub(crate) struct ClipboardCopy;
-
-impl Clipboard for ClipboardCopy {
-    fn copy(&self, text: &str) -> Result<()> {
-        let candidates: &[(&str, &[&str])] = if cfg!(target_os = "macos") {
-            &[("pbcopy", &[])]
-        } else {
-            &[("wl-copy", &[]), ("xclip", &["-selection", "clipboard"])]
-        };
-        let mut last = None;
-        for (program, args) in candidates {
-            match pipe_to(program, args, text) {
-                Ok(()) => return Ok(()),
-                Err(error) => last = Some(error),
-            }
-        }
-        Err(last
-            .unwrap_or_else(|| Error::invalid("clipboard", "no clipboard program is available")))
-    }
-}
-
-fn pipe_to(program: &str, args: &[&str], text: &str) -> Result<()> {
-    let mut child = Command::new(program)
-        .args(args)
-        .stdin(Stdio::piped())
-        .stdout(Stdio::null())
-        .stderr(Stdio::null())
-        .spawn()
-        .map_err(|error| Error::io(program, error))?;
-    if let Some(stdin) = child.stdin.as_mut() {
-        stdin
-            .write_all(text.as_bytes())
-            .map_err(|error| Error::io(program, error))?;
-    }
-    let status = child.wait().map_err(|error| Error::io(program, error))?;
-    if status.success() {
-        Ok(())
-    } else {
-        Err(Error::invalid(
-            "clipboard",
-            format!("{program} exited with {status}"),
-        ))
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
 
@@ -26,8 +26,8 @@ pub struct SessionConfig<'a> {
 
 /// The help shown by `Prefix ?`.
 pub const HELP_TEXT: &str = "klaub  Shift+Left agent  Shift+Right review (no prefix)  Prefix+R review  \
-Prefix+A agent  Prefix+I impact  Prefix+C comments  Prefix+T tests  Prefix+B brief  Prefix+L flow  \
-Prefix+d detach  Prefix+Q quit  (Prefix is Ctrl+B unless configured; R and A also work in lower case)";
+Prefix+A agent  Prefix+d detach  Prefix+Q quit  \
+(Prefix is Ctrl+B unless configured; R and A also work in lower case)";
 
 /// Checks a tmux key name such as `C-b`, `C-Space` or `M-a`.
 pub fn validate_prefix(prefix: &str) -> Result<()> {
@@ -202,35 +202,6 @@ pub fn configuration(spec: &SessionConfig<'_>) -> Result<Vec<Vec<String>>> {
         "10000",
         HELP_TEXT,
     ]));
-    // These open the reviewer on a specific mode. The review window is selected first, then the
-    // function key is delivered to its pane, where the reader maps it to a mode.
-    for (key, function_key) in [
-        ("I", "F5"),
-        ("C", "F6"),
-        ("T", "F7"),
-        ("B", "F8"),
-        ("L", "F9"),
-    ] {
-        commands.push(command(&[
-            "bind-key",
-            "-T",
-            "prefix",
-            key,
-            "run-shell",
-            "-b",
-            "#{@klaub-focus-review}",
-        ]));
-        commands.push(command(&[
-            "bind-key",
-            "-T",
-            "prefix",
-            key,
-            "send-keys",
-            "-t",
-            "review",
-            function_key,
-        ]));
-    }
     commands.push(command(&[
         "set-hook",
         "-g",
@@ -306,13 +277,8 @@ mod tests {
                 .any(|c| c.starts_with("bind-key -T prefix Q confirm-before"))
         );
         assert!(
-            flat.iter()
-                .any(|c| c == "bind-key -T prefix I send-keys -t review F5"),
-            "Prefix+I opens the impact view"
-        );
-        assert!(
-            flat.iter()
-                .any(|c| c == "bind-key -T prefix L send-keys -t review F9")
+            !flat.iter().any(|c| c.contains("send-keys -t review")),
+            "the reader has no screens left to open by a key"
         );
         assert!(
             !flat.iter().any(|c| c.contains("unbind-key")),
 
@@ -100,6 +100,12 @@ pub struct Analysis {
 }
 
 impl Analysis {
+    /// Whether `path` is a test file by the configured patterns.
+    #[must_use]
+    pub fn is_test_file(&self, path: &crate::domain::path::RepoPath) -> bool {
+        is_test_path(&self.config, path)
+    }
+
     /// The file entry containing `unit`.
     pub fn file_of(&self, unit: &UnitId) -> Option<&FileEntry> {
         self.units.get(unit).map(|u| &self.files[u.file_index])
 
@@ -15,16 +15,15 @@ use crate::adapters::parse::TreeSitterParser;
 use crate::adapters::storage::{
     FsConfigSource, FsFileReader, FsFlowRepository, JsonReviewRepository, SqliteCache,
 };
-use crate::adapters::tmux::channel::TmuxAgentChannel;
 use crate::app::{OpenOptions, Ports, ReviewSession};
 use crate::domain::i18n::{Locale, cli as t};
 use crate::domain::ids::SessionId;
-use crate::domain::ports::{AgentChannel, Clipboard, ConfigSource};
+use crate::domain::ports::ConfigSource;
 use crate::domain::snapshot::{Scope, SnapshotRequest};
 use crate::tui::App;
 use anyhow::{Context as _, Result};
 
-use crate::adapters::{ClipboardCopy, ProcessTestRunner, RandomIds, SystemClock};
+use crate::adapters::{ProcessTestRunner, RandomIds, SystemClock};
 use crate::cli::args::{Format, ReviewArgs};
 use crate::cli::context::Context;
 use crate::cli::{env, logging, output};
@@ -93,8 +92,7 @@ pub(super) fn run(ctx: &Context, args: &ReviewArgs) -> Result<ExitCode> {
     let session = ReviewSession::open(ports, request, &config, &options)
         .with_context(|| t::cannot_open_review(locale, &target.worktree.display().to_string()))?;
 
-    let clipboard: Option<Arc<dyn Clipboard>> = Some(Arc::new(ClipboardCopy));
-    let mut app = App::new(session, parser, target.agent, clipboard);
+    let mut app = App::new(session, parser);
     if first_review_here {
         app = app.with_storage_notice();
     }
@@ -137,10 +135,9 @@ fn report_wait(session: &ReviewSession, format: Format, locale: Locale) -> Resul
     Ok(code)
 }
 
-/// Where the review happens and, inside a wrapped session, the pane the feedback can be prepared in.
+/// Where the review happens and, inside a wrapped session, the session it belongs to.
 struct ReviewTarget {
     session_id: Option<SessionId>,
-    agent: Option<Arc<dyn AgentChannel>>,
     worktree: PathBuf,
 }
 
@@ -149,7 +146,6 @@ fn resolve_target(ctx: &Context, args: &ReviewArgs) -> Result<ReviewTarget> {
         let cwd = std::env::current_dir()?;
         return Ok(ReviewTarget {
             session_id: None,
-            agent: None,
             worktree: env::find_worktree_root(&cwd).unwrap_or(cwd),
         });
     };
@@ -158,10 +154,8 @@ fn resolve_target(ctx: &Context, args: &ReviewArgs) -> Result<ReviewTarget> {
         .registry()
         .load(&id)
         .with_context(|| t::cannot_load_session(ctx.locale, id.as_str()))?;
-    let channel: Arc<dyn AgentChannel> = Arc::new(TmuxAgentChannel::new(record.clone()));
     Ok(ReviewTarget {
         session_id: Some(id),
-        agent: Some(channel),
         worktree: record.worktree,
     })
 }