From 902da833536fbec4e8e74c0e861dbffa2a8ce290 Mon Sep 17 00:00:00 2001
From: raeedz <raeedz@gmail.com>
Date: Wed, 1 Jul 2026 16:50:29 -0700
Subject: [PATCH 1/9] Add syntax colors for variables, properties, and
 functions

Editor theme, tokens, and commit diff highlighter previously
rendered all identifiers in near-white text; now variables/properties
get a soft light-blue and functions/calls get a warm gold, shared
via new --syntax-* CSS tokens.
---
 src/design/cm6-theme.ts    | 21 ++++++++++++++-------
 src/design/tokens.css      | 13 +++++++++++++
 src/git/diff-highlight.tsx | 14 ++++++++++----
 3 files changed, 37 insertions(+), 11 deletions(-)

diff --git a/src/design/cm6-theme.ts b/src/design/cm6-theme.ts
index ee41d7d..ec05f18 100644
--- a/src/design/cm6-theme.ts
+++ b/src/design/cm6-theme.ts
@@ -40,6 +40,10 @@ const COLORS = {
   stateWarning:   "var(--state-warning)",
   stateError:     "var(--state-error)",
   stateInfoMuted: "color-mix(in oklch, var(--surface-1), var(--state-info) 18%)",
+
+  syntaxVariable: "var(--syntax-variable)",
+  syntaxProperty: "var(--syntax-property)",
+  syntaxFunction: "var(--syntax-function)",
 };
 
 export const cm6Theme = EditorView.theme(
@@ -134,15 +138,18 @@ export const cm6Highlight = HighlightStyle.define([
   { tag: t.paren, color: COLORS.textSecondary },
   { tag: t.separator, color: COLORS.textTertiary },
 
-  // Identifiers — primary text, no special color
-  { tag: t.variableName, color: COLORS.textPrimary },
-  { tag: t.propertyName, color: COLORS.textPrimary },
+  // Identifiers — soft light-blue. Lezer tags bare variables and
+  // function calls alike as `variableName`, so this is what gives the
+  // bulk of the code color instead of a wall of near-white text.
+  { tag: t.variableName, color: COLORS.syntaxVariable },
+  { tag: t.definition(t.variableName), color: COLORS.syntaxVariable },
+  { tag: t.propertyName, color: COLORS.syntaxProperty },
   { tag: t.attributeName, color: COLORS.stateInfo },
 
-  // Functions — medium weight, primary color
-  { tag: t.function(t.variableName), color: COLORS.textPrimary, fontWeight: "500" },
-  { tag: t.function(t.propertyName), color: COLORS.textPrimary, fontWeight: "500" },
-  { tag: t.macroName, color: COLORS.textPrimary, fontWeight: "500" },
+  // Functions — warm gold, medium weight
+  { tag: t.function(t.variableName), color: COLORS.syntaxFunction, fontWeight: "500" },
+  { tag: t.function(t.propertyName), color: COLORS.syntaxFunction, fontWeight: "500" },
+  { tag: t.macroName, color: COLORS.syntaxFunction, fontWeight: "500" },
 
   // Keywords — info blue, distinct from accent
   { tag: t.keyword, color: COLORS.stateInfo, fontWeight: "500" },
diff --git a/src/design/tokens.css b/src/design/tokens.css
index 8caf752..09ea32b 100644
--- a/src/design/tokens.css
+++ b/src/design/tokens.css
@@ -109,6 +109,19 @@
   --diff-change-bg:  oklch(32% 0.13  85 / 0.40);
   --diff-change-fg:  oklch(86% 0.18  85);
 
+  /* Syntax palette — shared by the editor theme (cm6-theme.ts) and the
+     diff highlighter (diff-highlight.tsx), which mirror each other.
+     Identifiers — variables, function calls, and properties — are the
+     bulk of any code diff, and Lezer tags them all as plain
+     `variableName`/`propertyName`. Left uncolored they fall back to
+     near-white --text-primary, so a diff reads as a wall of white.
+     A soft light-blue for identifiers and a warm gold for functions
+     give code real color while staying calm against the cool-dark
+     surface. */
+  --syntax-variable: oklch(83% 0.055 245);
+  --syntax-property: oklch(83% 0.055 245);
+  --syntax-function: oklch(87% 0.11  92);
+
   /* Modal backdrop */
   --backdrop: oklch(0% 0 0 / 0.55);
 
diff --git a/src/git/diff-highlight.tsx b/src/git/diff-highlight.tsx
index 0ffde29..d720834 100644
--- a/src/git/diff-highlight.tsx
+++ b/src/git/diff-highlight.tsx
@@ -65,12 +65,18 @@ const HL = tagHighlighter([
   { tag: t.className, class: "color:var(--accent)" },
   { tag: t.namespace, class: "color:var(--accent)" },
 
-  { tag: t.function(t.variableName), class: "font-weight:500" },
-  { tag: t.function(t.propertyName), class: "font-weight:500" },
-  { tag: t.macroName, class: "font-weight:500" },
+  // Identifiers. Lezer tags bare variables AND function calls alike as
+  // `variableName`, so this rule is what colors the bulk of the code —
+  // without it everything here falls back to near-white --text-primary.
+  { tag: t.variableName, class: "color:var(--syntax-variable)" },
+  { tag: t.definition(t.variableName), class: "color:var(--syntax-variable)" },
+
+  { tag: t.function(t.variableName), class: "color:var(--syntax-function);font-weight:500" },
+  { tag: t.function(t.propertyName), class: "color:var(--syntax-function);font-weight:500" },
+  { tag: t.macroName, class: "color:var(--syntax-function);font-weight:500" },
 
   { tag: t.attributeName, class: "color:var(--state-info)" },
-  { tag: t.propertyName, class: "color:var(--text-primary)" },
+  { tag: t.propertyName, class: "color:var(--syntax-property)" },
 
   { tag: t.tagName, class: "color:var(--state-error)" },
   { tag: t.angleBracket, class: "color:var(--text-tertiary)" },

From cc672fda1459e2897b6da9c52788786897499268 Mon Sep 17 00:00:00 2001
From: raeedz <raeedz@gmail.com>
Date: Thu, 2 Jul 2026 21:04:29 -0700
Subject: [PATCH 2/9] Add alt-screen scroll glue for selections via content
 matching

Replace the wheel-count-based `term_native_selection_scrolled` command
with `detect_scroll_shift`, which diffs consecutive grid snapshots by
row text to measure the actual scroll offset and re-glues the active
selection accordingly. This tracks apps (vim, less, htop) that scroll
more than one row per wheel notch, where the old heuristic drifted.
---
 src-tauri/src/lib.rs                          |   2 -
 src-tauri/src/warp_term.rs                    | 237 ++++++++++++++++--
 src/terminal/BlockTerminal.tsx                |  24 +-
 .../src/elements/selectable_area.rs           |  12 +
 4 files changed, 241 insertions(+), 34 deletions(-)

diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index bc2d9c2..eb6c253 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -300,8 +300,6 @@ pub fn run() {
             #[cfg(target_os = "macos")]
             warp_term::term_native_selection_text,
             #[cfg(target_os = "macos")]
-            warp_term::term_native_selection_scrolled,
-            #[cfg(target_os = "macos")]
             warp_term::term_native_set_viewport,
             #[cfg(target_os = "macos")]
             warp_term::term_native_link_at,
diff --git a/src-tauri/src/warp_term.rs b/src-tauri/src/warp_term.rs
index f531058..398e943 100644
--- a/src-tauri/src/warp_term.rs
+++ b/src-tauri/src/warp_term.rs
@@ -871,6 +871,87 @@ fn is_zsh_eol_marker(row: &RowSnapshot) -> bool {
     seen
 }
 
+/// Concatenated glyph text of a row with trailing blanks trimmed — the identity
+/// we match on when measuring how far an alt-screen app scrolled. We compare
+/// TEXT (not the full styled spans) so a pager re-coloring a line (e.g. moving
+/// its highlighted current line, or a cursor landing on it) doesn't defeat the
+/// match.
+fn row_text(row: &RowSnapshot) -> String {
+    let mut s = String::new();
+    for sp in &row.spans {
+        s.push_str(&sp.text);
+    }
+    s.trim_end().to_string()
+}
+
+/// Measure how many rows an alt-screen app scrolled between two consecutive grid
+/// snapshots, by content matching. Returns `k` such that the new grid shows, at
+/// row `i`, what the old grid had at row `i + k`:
+///   - `k > 0` → content moved UP by k rows (scrolled toward newer / down)
+///   - `k < 0` → content moved DOWN by k rows (scrolled toward older / up)
+///   - `0`     → no clear scroll (partial repaint, spinner tick, cursor blink,
+///                a page swap, or genuinely nothing moved)
+///
+/// This is the source of truth for gluing a selection to alt-screen text, and it
+/// replaces the old "assume the app scrolls one row per wheel notch" guess —
+/// which drifts on any app that scrolls several rows per notch (vim's default,
+/// most pagers). Because it reads the app's ACTUAL response it's correct
+/// regardless of the app's wheel-to-rows ratio.
+///
+/// Deliberately conservative: it reports a non-zero shift only when a clear
+/// majority of the NON-BLANK rows line up at exactly one offset AND that offset
+/// explains more rows than staying put (k = 0). A one-line spinner update or a
+/// single streamed character leaves k = 0 unbeaten, so a completed selection is
+/// never nudged by a non-scroll repaint — the exact "jumpy / stuck selection"
+/// artifact a naive always-shift approach produces.
+fn detect_scroll_shift(old: &[RowSnapshot], new: &[RowSnapshot]) -> i32 {
+    let n = old.len().min(new.len());
+    if n < 4 {
+        return 0; // too little signal to be confident
+    }
+    let o: Vec<String> = old.iter().take(n).map(row_text).collect();
+    let e: Vec<String> = new.iter().take(n).map(row_text).collect();
+
+    // Count indices where new[i] equals old[i + k], ignoring blank rows (a blank
+    // line matches every other blank line and would inflate every offset).
+    let score = |k: i32| -> usize {
+        let mut c = 0usize;
+        for i in 0..n {
+            let j = i as i32 + k;
+            if j < 0 || j as usize >= n {
+                continue;
+            }
+            if !e[i].is_empty() && e[i] == o[j as usize] {
+                c += 1;
+            }
+        }
+        c
+    };
+
+    let base = score(0); // non-blank rows still in place
+    let mut best_k = 0i32;
+    let mut best = base;
+    let range = (n as i32) - 1;
+    for k in -range..=range {
+        if k == 0 {
+            continue;
+        }
+        let s = score(k);
+        if s > best {
+            best = s;
+            best_k = k;
+        }
+    }
+
+    // Require the winning offset to be genuinely dominant: it must line up a solid
+    // block of rows and clearly beat the in-place score, else treat it as noise.
+    if best_k != 0 && best >= 3 && best > base + 1 {
+        best_k
+    } else {
+        0
+    }
+}
+
 /// How many leading rows of the live grid to render: trims trailing blank rows
 /// (keeping through the cursor row) so an idle / just-finished shell screen sits
 /// compactly above the input instead of padding the transcript with blanks.
@@ -1580,7 +1661,26 @@ pub fn attach(app: &tauri::AppHandle) {
         // Route the frame to whichever pane mirrors this pty (main or side).
         if let Some(p) = pane_for_pty(pty_id) {
             let mut g = p.grid.lock().unwrap_or_else(|e| e.into_inner());
+            // Alt-screen scroll-glue: an alt-screen app (git log / less / man /
+            // vim / htop) repaints its grid in place when it scrolls, so a
+            // completed selection anchored to fixed grid coordinates would slide
+            // off the text it was started on. Measure how far the grid ACTUALLY
+            // scrolled (content match — robust to the app's rows-per-wheel-notch,
+            // which the old React-side line-count guess got wrong) and shift the
+            // selection to track it. Gated to when something is actually selected
+            // AND the app owns the screen: the normal shell/inline-agent
+            // transcript glues for free (its SelectableArea lives inside the
+            // ClippedScrollable, whose scroll translation already moves the
+            // selection with the content), so we must NOT double-shift it here.
+            let detect = frame.alt_screen && p.sel.has_selection();
+            let old_rows = if detect { g.rows.clone() } else { Vec::new() };
             g.apply_frame(frame);
+            if detect {
+                let k = detect_scroll_shift(&old_rows, &g.rows);
+                if k != 0 {
+                    p.sel.shift_relative_y(-(k as f32) * LINE_PX);
+                }
+            }
         }
         let _ = app_for_sink.run_on_main_thread(|| {
             warpui::platform::poke_embedded_redraw();
@@ -1980,24 +2080,6 @@ pub fn term_native_mouse(
     }
 }
 
-/// Tauri command: the alt-screen agent's content scrolled by `delta_lines`
-/// (the same signed line count just sent through `term_native_wheel`;
-/// positive = toward newer/down). The app repaints its grid in place, so a
-/// selection anchored to grid coordinates would highlight whatever text
-/// scrolled under it. Shift the stored selection bounds by the distance the
-/// content moved (scrolling up by N lines moves the text DOWN N rows →
-/// +N·LINE_PX) so the highlight stays glued to the text it was started on,
-/// Warp-style. Best-effort: assumes the app scrolls one row per wheel line
-/// (true for claude/codex and every pager we route here).
-#[tauri::command]
-pub fn term_native_selection_scrolled(pane_key: String, delta_lines: i32) {
-    let p = pane(&pane_key);
-    p.sel.shift_relative_y(-(delta_lines as f32) * LINE_PX);
-    if let Some(app) = APP_HANDLE.get() {
-        let _ = app.run_on_main_thread(|| warpui::platform::poke_embedded_redraw());
-    }
-}
-
 /// Tauri command: the latest selected transcript text (cached by the
 /// `SelectableArea` selection handler), or `None` if nothing is selected. React
 /// reads this on Cmd+C in the shell and writes it to the clipboard via the
@@ -2054,6 +2136,125 @@ pub fn term_native_set_viewport(pane_key: String, top: f64, height: f64) {
     }
 }
 
+#[cfg(test)]
+mod scroll_shift_tests {
+    use super::*;
+
+    fn plain_span(text: &str) -> Span {
+        Span {
+            text: text.to_string(),
+            fg: "var(--text-primary)".into(),
+            bg: "var(--surface-0)".into(),
+            bold: false,
+            italic: false,
+            underline: false,
+            inverse: false,
+            dim: false,
+            strikeout: false,
+            link: None,
+        }
+    }
+    fn rows(lines: &[&str]) -> Vec<RowSnapshot> {
+        lines
+            .iter()
+            .map(|l| RowSnapshot {
+                spans: vec![plain_span(l)],
+            })
+            .collect()
+    }
+
+    #[test]
+    fn scroll_down_shifts_content_up() {
+        // Ten distinct rows; the app scrolls DOWN by 3 (content moves up 3, three
+        // fresh rows appear at the bottom). new[i] == old[i+3] for the retained
+        // rows, so the measured shift is +3.
+        let old = rows(&[
+            "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9",
+        ]);
+        let new = rows(&[
+            "r3", "r4", "r5", "r6", "r7", "r8", "r9", "n7", "n8", "n9",
+        ]);
+        assert_eq!(detect_scroll_shift(&old, &new), 3);
+    }
+
+    #[test]
+    fn scroll_up_shifts_content_down() {
+        // The app scrolls UP by 2 (content moves down 2, two older rows appear at
+        // the top). new[i] == old[i-2] → measured shift is -2.
+        let old = rows(&[
+            "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9",
+        ]);
+        let new = rows(&[
+            "p0", "p1", "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
+        ]);
+        assert_eq!(detect_scroll_shift(&old, &new), -2);
+    }
+
+    #[test]
+    fn identical_grids_report_no_scroll() {
+        let g = rows(&["a", "b", "c", "d", "e", "f", "g", "h"]);
+        assert_eq!(detect_scroll_shift(&g, &g), 0);
+    }
+
+    #[test]
+    fn spinner_tick_reports_no_scroll() {
+        // Only one row changes (a spinner glyph / streamed char). Staying put
+        // explains far more rows than any shift, so no shift is reported — this
+        // is what keeps a completed selection from jumping on a non-scroll frame.
+        let old = rows(&["a", "b", "c", "d", "e", "f", "g", "loading |"]);
+        let new = rows(&["a", "b", "c", "d", "e", "f", "g", "loading /"]);
+        assert_eq!(detect_scroll_shift(&old, &new), 0);
+    }
+
+    #[test]
+    fn full_page_swap_reports_no_scroll() {
+        // A page jump replaces every row with unrelated content — no offset lines
+        // anything up, so we conservatively report no scroll rather than guess.
+        let old = rows(&["a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7"]);
+        let new = rows(&["z0", "z1", "z2", "z3", "z4", "z5", "z6", "z7"]);
+        assert_eq!(detect_scroll_shift(&old, &new), 0);
+    }
+
+    #[test]
+    fn blank_rows_do_not_inflate_a_false_shift() {
+        // A grid that is mostly blank with a couple of content rows must not
+        // report a shift just because the blank rows "match" at every offset.
+        let old = rows(&["", "", "hello", "world", "", "", "", ""]);
+        let new = rows(&["", "", "hello", "world", "", "", "", ""]);
+        assert_eq!(detect_scroll_shift(&old, &new), 0);
+    }
+
+    #[test]
+    fn ignores_color_only_changes() {
+        // A pager re-coloring its current line (same text, different style) is not
+        // a scroll. row_text compares glyphs only, so this stays at 0.
+        let old = vec![
+            RowSnapshot { spans: vec![plain_span("line one")] },
+            RowSnapshot { spans: vec![plain_span("line two")] },
+            RowSnapshot { spans: vec![plain_span("line three")] },
+            RowSnapshot { spans: vec![plain_span("line four")] },
+            RowSnapshot { spans: vec![plain_span("line five")] },
+        ];
+        let mut recolored = plain_span("line three");
+        recolored.inverse = true;
+        let new = vec![
+            RowSnapshot { spans: vec![plain_span("line one")] },
+            RowSnapshot { spans: vec![plain_span("line two")] },
+            RowSnapshot { spans: vec![recolored] },
+            RowSnapshot { spans: vec![plain_span("line four")] },
+            RowSnapshot { spans: vec![plain_span("line five")] },
+        ];
+        assert_eq!(detect_scroll_shift(&old, &new), 0);
+    }
+
+    #[test]
+    fn tiny_grids_bail_out() {
+        let old = rows(&["a", "b", "c"]);
+        let new = rows(&["b", "c", "d"]);
+        assert_eq!(detect_scroll_shift(&old, &new), 0);
+    }
+}
+
 #[cfg(test)]
 mod link_tests {
     use super::*;
diff --git a/src/terminal/BlockTerminal.tsx b/src/terminal/BlockTerminal.tsx
index 81eee20..c0b2aa3 100644
--- a/src/terminal/BlockTerminal.tsx
+++ b/src/terminal/BlockTerminal.tsx
@@ -963,12 +963,10 @@ export function BlockTerminal({
       invoke("term_native_wheel", { id: ptyId, deltaLines: lines, col, row }).catch(
         () => {},
       );
-      // Keep any native selection glued to its text: the app repaints its grid
-      // in place when it scrolls, so shift the stored selection anchors by the
-      // distance the content moved. No-op when nothing is selected.
-      invoke("term_native_selection_scrolled", { paneKey, deltaLines: lines }).catch(
-        () => {},
-      );
+      // Any native selection stays glued to its text without our help: the Rust
+      // frame sink measures how far the app actually scrolled (content match)
+      // and shifts the selection anchors to match. We used to guess the distance
+      // here from `lines`, which drifted whenever the app scrolled ≠1 row/notch.
       // Drain a fast flick across subsequent frames (momentum) rather than one
       // big jump — smooth deceleration.
       if (Math.abs(accumPx) >= LINE_PX) raf = requestAnimationFrame(flush);
@@ -1103,11 +1101,12 @@ export function BlockTerminal({
       if (delta === 0) return; // back inside the safe zone — stop the loop
       if (altScreen) {
         // Alt-screen AGENT (claude/codex on the alt screen): the app owns its
-        // scroll-back, so page it with the same wheel encoding the wheel
-        // bridge uses, then shift the native selection anchors by the distance
-        // the content moved (term_native_selection_scrolled) so the highlight
-        // stays glued to the text it was started on instead of whatever
-        // scrolled under it. Whole lines only; the px remainder carries.
+        // scroll-back, so page it with the same wheel encoding the wheel bridge
+        // uses. The selection stays glued on its own — the Rust frame sink
+        // measures how far the app actually scrolled (content match) and shifts
+        // the anchors to match, so the highlight tracks the text it was started
+        // on instead of whatever scrolled under it. Whole lines only; the px
+        // remainder carries.
         wheelAccumPx += delta;
         const lines = Math.trunc(wheelAccumPx / DRAG_LINE_PX);
         if (lines !== 0) {
@@ -1117,9 +1116,6 @@ export function BlockTerminal({
           invoke("term_native_wheel", { id: ptyId, deltaLines: lines, col, row }).catch(
             () => {},
           );
-          invoke("term_native_selection_scrolled", { paneKey, deltaLines: lines }).catch(
-            () => {},
-          );
         }
       } else {
         invoke("term_native_scroll", { paneKey, deltaPx: delta }).catch(() => {});
diff --git a/vendor/crates/warpui_core/src/elements/selectable_area.rs b/vendor/crates/warpui_core/src/elements/selectable_area.rs
index 003ab31..7d8fc6f 100644
--- a/vendor/crates/warpui_core/src/elements/selectable_area.rs
+++ b/vendor/crates/warpui_core/src/elements/selectable_area.rs
@@ -200,6 +200,18 @@ impl SelectionHandle {
             .is_selecting
     }
 
+    /// Whether a selection currently exists (a head anchor has been set) —
+    /// whether or not it is still being actively dragged. Used by the terminal
+    /// to skip the alt-screen scroll-glue bookkeeping entirely when there is
+    /// nothing selected.
+    pub fn has_selection(&self) -> bool {
+        self.selection
+            .lock()
+            .expect("Should not be poisoned.")
+            .head
+            .is_some()
+    }
+
     pub fn clear(&self) {
         self.selection
             .lock()

From e49c06f375056560d33d726d136ca37b5a47158e Mon Sep 17 00:00:00 2001
From: raeedz <raeedz@gmail.com>
Date: Fri, 3 Jul 2026 21:39:54 -0700
Subject: [PATCH 3/9] Add fix-this-hunk workflow to diff view

Lets users attach change requests to individual diff hunks and send them as one composed prompt to the worktree's agent terminal.
---
 src/git/AllChangesView.tsx |   4 +
 src/git/DiffFix.test.ts    |  45 +++
 src/git/DiffFix.tsx        | 552 +++++++++++++++++++++++++++++++++++++
 src/git/DiffView.tsx       | 218 +++++++++++++--
 4 files changed, 802 insertions(+), 17 deletions(-)
 create mode 100644 src/git/DiffFix.test.ts
 create mode 100644 src/git/DiffFix.tsx

diff --git a/src/git/AllChangesView.tsx b/src/git/AllChangesView.tsx
index 534723a..cafdbd0 100644
--- a/src/git/AllChangesView.tsx
+++ b/src/git/AllChangesView.tsx
@@ -4,6 +4,7 @@ import { CaretDown } from "@phosphor-icons/react";
 import { git } from "@/lib/git";
 import { DiffBody } from "./DiffView";
 import { DiffAskOverlay, reconstructDiffContext } from "./DiffAsk";
+import { DiffFixBar, DiffFixProvider } from "./DiffFix";
 import { parseUnifiedDiff, type DiffLine } from "./diff-parse";
 
 /**
@@ -76,6 +77,7 @@ export function AllChangesView({ projectPath }: { projectPath: string }) {
   }, [sections]);
 
   return (
+    <DiffFixProvider cwd={projectPath}>
     <motion.div
       initial={{ opacity: 0, y: 4 }}
       animate={{ opacity: 1, y: 0 }}
@@ -180,7 +182,9 @@ export function AllChangesView({ projectPath }: { projectPath: string }) {
           }}
         />
       )}
+      <DiffFixBar />
     </motion.div>
+    </DiffFixProvider>
   );
 }
 
diff --git a/src/git/DiffFix.test.ts b/src/git/DiffFix.test.ts
new file mode 100644
index 0000000..841499d
--- /dev/null
+++ b/src/git/DiffFix.test.ts
@@ -0,0 +1,45 @@
+import { describe, expect, it } from "bun:test";
+import { composeFixPrompt, type HunkRef } from "./DiffFix";
+
+const hunk = (over: Partial<HunkRef>): HunkRef => ({
+  id: "src/foo.ts#0",
+  file: "src/foo.ts",
+  label: "",
+  snippet: "@@ -1,2 +1,2 @@\n-old\n+new",
+  ...over,
+});
+
+describe("composeFixPrompt", () => {
+  it("pairs each request with its diff snippet inside a fenced block", () => {
+    const prompt = composeFixPrompt([
+      { ref: hunk({ label: "fn handleClick" }), text: "rename to onSelect" },
+    ]);
+    expect(prompt).toContain("### Change 1 — src/foo.ts (in fn handleClick)");
+    expect(prompt).toContain("```diff\n@@ -1,2 +1,2 @@\n-old\n+new\n```");
+    expect(prompt).toContain("Requested: rename to onSelect");
+    expect(prompt).toContain("Make these edits now.");
+  });
+
+  it("omits the scope suffix when the hunk has no label", () => {
+    const prompt = composeFixPrompt([{ ref: hunk({}), text: "handle null" }]);
+    expect(prompt).toContain("### Change 1 — src/foo.ts\n");
+    expect(prompt).not.toContain("(in ");
+  });
+
+  it("numbers multiple changes in order", () => {
+    const prompt = composeFixPrompt([
+      { ref: hunk({ id: "a#0", file: "a.ts" }), text: "first" },
+      { ref: hunk({ id: "b#0", file: "b.ts" }), text: "second" },
+    ]);
+    expect(prompt).toContain("### Change 1 — a.ts");
+    expect(prompt).toContain("### Change 2 — b.ts");
+    expect(prompt.indexOf("Change 1")).toBeLessThan(prompt.indexOf("Change 2"));
+  });
+
+  it("trims surrounding whitespace from the user's request", () => {
+    const prompt = composeFixPrompt([
+      { ref: hunk({}), text: "  spaced out  \n" },
+    ]);
+    expect(prompt).toContain("Requested: spaced out");
+  });
+});
diff --git a/src/git/DiffFix.tsx b/src/git/DiffFix.tsx
new file mode 100644
index 0000000..b5fdd50
--- /dev/null
+++ b/src/git/DiffFix.tsx
@@ -0,0 +1,552 @@
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  type ReactNode,
+} from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { AnimatePresence, motion } from "motion/react";
+import { MagicWand, Minus, NotePencil, Plus, X } from "@phosphor-icons/react";
+import { useAppDispatch, useAppState } from "@/state/AppState";
+import { useToast } from "@/primitives/Toast";
+import type { AppState, TerminalTab, Worktree } from "@/state/types";
+
+/**
+ * "Fix this hunk" — a review-and-delegate layer over the working diff.
+ *
+ * Each edited block in a working-tree diff (a contiguous run of `+`/`-`
+ * lines) grows a `+` button in the left gutter; clicking it opens an
+ * inline box under that block where the user types what they want
+ * changed about that part of the code. Comments accumulate across blocks
+ * and files, and a floating "Fix" bar composes them into one prompt —
+ * each request paired with the exact diff snippet it refers to — and
+ * pastes it straight into the worktree's agent terminal, which then goes
+ * and implements them.
+ *
+ * The plumbing is a React context: `DiffFixProvider` owns the comment
+ * state and the target worktree's cwd; `DiffBody` reads the context to
+ * decide whether to render `+` buttons at all (so historical commit
+ * diffs, which mount without a provider, stay read-only); `DiffFixBar`
+ * reads it to build and send the prompt.
+ */
+
+/** A single hunk the user can attach a change request to. */
+export interface HunkRef {
+  /** Stable within one diff render: `${file}#${ordinal}`. */
+  id: string;
+  file: string;
+  /** Enclosing scope git tacked onto the `@@` header, if any. */
+  label: string;
+  /** The hunk rebuilt as a unified-diff snippet, handed to the agent. */
+  snippet: string;
+}
+
+interface DiffFixApi {
+  isOpen: (id: string) => boolean;
+  hasText: (id: string) => boolean;
+  /** Open a box for this hunk (idempotent — keeps existing text). */
+  openBox: (ref: HunkRef) => void;
+  /** Close a box and drop its text. */
+  closeBox: (id: string) => void;
+  getText: (id: string) => string;
+  setText: (id: string, text: string) => void;
+  /** Open boxes with non-empty text, in file+hunk order. */
+  entries: () => Array<{ ref: HunkRef; text: string }>;
+  /** Count of non-empty comments — drives the Fix bar. */
+  count: number;
+  clear: () => void;
+  /** Worktree checkout dir this diff belongs to. */
+  cwd: string;
+}
+
+const DiffFixContext = createContext<DiffFixApi | null>(null);
+
+/** Diff-fix API for the enclosing view, or null when there is no
+ *  provider (e.g. a historical commit diff — read-only, no `+`). */
+export function useDiffFix(): DiffFixApi | null {
+  return useContext(DiffFixContext);
+}
+
+export function DiffFixProvider({
+  cwd,
+  children,
+}: {
+  cwd: string;
+  children: ReactNode;
+}) {
+  // `open` maps hunk id → its ref (so we can rebuild the prompt without
+  // re-deriving snippets); `text` maps hunk id → the user's request.
+  const [open, setOpen] = useState<Record<string, HunkRef>>({});
+  const [text, setText] = useState<Record<string, string>>({});
+
+  const api = useMemo<DiffFixApi>(() => {
+    const orderKey = (ref: HunkRef) => {
+      const hash = ref.id.lastIndexOf("#");
+      const ord = hash >= 0 ? Number(ref.id.slice(hash + 1)) : 0;
+      return [ref.file, Number.isFinite(ord) ? ord : 0] as const;
+    };
+    const activeRefs = Object.values(open).filter(
+      (ref) => (text[ref.id]?.trim().length ?? 0) > 0,
+    );
+    return {
+      isOpen: (id) => id in open,
+      hasText: (id) => id in open && (text[id]?.trim().length ?? 0) > 0,
+      openBox: (ref) =>
+        setOpen((o) => (o[ref.id] ? o : { ...o, [ref.id]: ref })),
+      closeBox: (id) => {
+        setOpen((o) => {
+          if (!(id in o)) return o;
+          const { [id]: _drop, ...rest } = o;
+          return rest;
+        });
+        setText((t) => {
+          if (!(id in t)) return t;
+          const { [id]: _drop, ...rest } = t;
+          return rest;
+        });
+      },
+      getText: (id) => text[id] ?? "",
+      setText: (id, value) => setText((s) => ({ ...s, [id]: value })),
+      entries: () =>
+        activeRefs
+          .slice()
+          .sort((a, b) => {
+            const [fa, oa] = orderKey(a);
+            const [fb, ob] = orderKey(b);
+            return fa === fb ? oa - ob : fa < fb ? -1 : 1;
+          })
+          .map((ref) => ({ ref, text: text[ref.id] ?? "" })),
+      count: activeRefs.length,
+      clear: () => {
+        setOpen({});
+        setText({});
+      },
+      cwd,
+    };
+  }, [open, text, cwd]);
+
+  return (
+    <DiffFixContext.Provider value={api}>{children}</DiffFixContext.Provider>
+  );
+}
+
+/* ------------------------------------------------------------------
+   `+` button — sits in the left gutter beside each change block.
+   ------------------------------------------------------------------ */
+
+export function HunkAddButton({
+  hunkRef,
+  fix,
+}: {
+  hunkRef: HunkRef;
+  fix: DiffFixApi;
+}) {
+  const active = fix.isOpen(hunkRef.id);
+  const commented = fix.hasText(hunkRef.id);
+  const lit = active || commented;
+  const [hover, setHover] = useState(false);
+  return (
+    <button
+      type="button"
+      title={active ? "Discard this suggestion" : "Suggest a change to this block"}
+      aria-label={
+        active ? "Discard this suggestion" : "Suggest a change to this block"
+      }
+      onClick={(e) => {
+        e.stopPropagation();
+        // Toggle: `+` opens the suggestion box, `−` dismisses it.
+        if (active) fix.closeBox(hunkRef.id);
+        else fix.openBox(hunkRef);
+      }}
+      onMouseEnter={() => setHover(true)}
+      onMouseLeave={() => setHover(false)}
+      style={{
+        display: "inline-flex",
+        alignItems: "center",
+        justifyContent: "center",
+        width: 17,
+        height: 17,
+        flexShrink: 0,
+        borderRadius: "var(--radius-sm)",
+        border: `1px solid ${
+          lit || hover ? "var(--accent-bright)" : "var(--border-strong)"
+        }`,
+        backgroundColor:
+          lit || hover
+            ? "var(--surface-accent-tinted)"
+            : "var(--surface-2)",
+        color: lit || hover ? "var(--accent-bright)" : "var(--text-secondary)",
+        cursor: "pointer",
+        boxShadow: "var(--shadow-xs, 0 1px 1px rgba(0,0,0,0.15))",
+        transition:
+          "background-color var(--motion-fast) var(--ease-out-quart), " +
+          "color var(--motion-fast) var(--ease-out-quart), " +
+          "border-color var(--motion-fast) var(--ease-out-quart)",
+      }}
+    >
+      {active ? <Minus size={13} weight="bold" /> : <Plus size={13} weight="bold" />}
+    </button>
+  );
+}
+
+/* ------------------------------------------------------------------
+   Inline comment box — rendered in its own row under the hunk.
+   ------------------------------------------------------------------ */
+
+export function HunkCommentBox({
+  hunkRef,
+  fix,
+}: {
+  hunkRef: HunkRef;
+  fix: DiffFixApi;
+}) {
+  const ref = useRef<HTMLTextAreaElement>(null);
+  const value = fix.getText(hunkRef.id);
+
+  // Focus on mount; auto-grow to fit content.
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    el.focus();
+    el.setSelectionRange(el.value.length, el.value.length);
+  }, []);
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    el.style.height = "auto";
+    el.style.height = `${Math.min(el.scrollHeight, 160)}px`;
+  }, [value]);
+
+  return (
+    <motion.div
+      initial={{ opacity: 0, y: -4 }}
+      animate={{ opacity: 1, y: 0 }}
+      transition={{ duration: 0.14, ease: [0.25, 1, 0.5, 1] }}
+      style={{
+        position: "relative",
+        width: "min(100%, 300px)",
+        minHeight: 96,
+        borderRadius: "var(--radius-md)",
+        border:
+          "1px solid color-mix(in oklch, var(--border-strong), var(--accent) 20%)",
+        backgroundColor: "var(--surface-accent-soft)",
+        padding: "var(--space-2)",
+      }}
+    >
+      <NotePencil
+        aria-hidden
+        size={14}
+        weight="bold"
+        style={{
+          position: "absolute",
+          top: "calc(var(--space-2) + 2px)",
+          left: "var(--space-2)",
+          color: "color-mix(in oklch, var(--text-tertiary), var(--accent) 45%)",
+          pointerEvents: "none",
+        }}
+      />
+      <textarea
+        ref={ref}
+        value={value}
+        onChange={(e) => fix.setText(hunkRef.id, e.target.value)}
+        onKeyDown={(e) => {
+          // Esc discards the box without letting the diff's global Esc
+          // (which closes the whole view) fire.
+          if (e.key === "Escape") {
+            e.preventDefault();
+            e.stopPropagation();
+            fix.closeBox(hunkRef.id);
+          }
+          e.stopPropagation();
+        }}
+        placeholder="Suggest a change"
+        rows={1}
+        spellCheck={false}
+        style={{
+          width: "100%",
+          minHeight: 76,
+          resize: "none",
+          border: "none",
+          outline: "none",
+          background: "transparent",
+          color: "var(--text-primary)",
+          fontFamily: "var(--font-sans)",
+          fontSize: "var(--text-xs)",
+          lineHeight: 1.5,
+          padding: 0,
+          paddingLeft: 22,
+          paddingRight: 18,
+        }}
+      />
+      <button
+        type="button"
+        title="Discard this request"
+        aria-label="Discard this request"
+        onClick={(e) => {
+          e.stopPropagation();
+          fix.closeBox(hunkRef.id);
+        }}
+        style={{
+          position: "absolute",
+          top: "var(--space-1)",
+          right: "var(--space-1)",
+          display: "inline-flex",
+          alignItems: "center",
+          justifyContent: "center",
+          width: 18,
+          height: 18,
+          flexShrink: 0,
+          borderRadius: "var(--radius-sm)",
+          border: "none",
+          background: "transparent",
+          color: "var(--text-tertiary)",
+          cursor: "pointer",
+        }}
+        onMouseEnter={(e) => {
+          e.currentTarget.style.color = "var(--text-primary)";
+          e.currentTarget.style.backgroundColor = "var(--surface-2)";
+        }}
+        onMouseLeave={(e) => {
+          e.currentTarget.style.color = "var(--text-tertiary)";
+          e.currentTarget.style.backgroundColor = "transparent";
+        }}
+      >
+        <X size={13} weight="bold" />
+      </button>
+    </motion.div>
+  );
+}
+
+/* ------------------------------------------------------------------
+   Floating "Fix" bar + prompt composition + PTY handoff.
+   ------------------------------------------------------------------ */
+
+interface AgentTarget {
+  worktree: Worktree;
+  ptyId: string;
+  /** Present when the target is a main-column terminal tab we can focus. */
+  tabId?: string;
+  /**
+   * True when we detected an agent CLI (Claude Code, Codex, …) in the
+   * chosen terminal. False means the terminal is just a bare shell — the
+   * prompt would land at a `$` prompt and do nothing, so the Fix bar
+   * refuses and tells the user to start their agent.
+   */
+  hasAgent: boolean;
+}
+
+/**
+ * Resolve the terminal PTY to hand the prompt to for the worktree whose
+ * checkout is `cwd`. Prefers a terminal with an agent actually running
+ * in it (active tab first, then any tab); failing that it still returns
+ * a bare-shell terminal so the caller can surface a "no agent" error
+ * rather than silently dropping the prompt into a shell. Last resort is
+ * the secondary panel terminal, judged by the worktree's detected CLI.
+ */
+function resolveAgentTarget(state: AppState, cwd: string): AgentTarget | null {
+  const worktree = Object.values(state.worktrees).find((w) => w.path === cwd);
+  if (!worktree) return null;
+
+  const termTabs = worktree.tabIds
+    .map((id) => state.tabs[id])
+    .filter((t): t is TerminalTab => !!t && t.kind === "terminal");
+
+  // An agent is "running" in a terminal when a CLI was detected in it.
+  const activeId = worktree.activeTabId;
+  const agentTab =
+    termTabs.find((t) => t.id === activeId && t.detectedCli != null) ??
+    termTabs.find((t) => t.detectedCli != null);
+  if (agentTab)
+    return {
+      worktree,
+      ptyId: agentTab.ptyId,
+      tabId: agentTab.id,
+      hasAgent: true,
+    };
+
+  // A terminal is open but it's a plain shell — return it flagged so the
+  // caller can tell the user no agent is running.
+  const active = activeId ? state.tabs[activeId] : null;
+  const shellTab =
+    (active && active.kind === "terminal" ? active : null) ??
+    termTabs[0] ??
+    null;
+  if (shellTab)
+    return {
+      worktree,
+      ptyId: shellTab.ptyId,
+      tabId: shellTab.id,
+      hasAgent: false,
+    };
+
+  // Secondary panel: no per-tab CLI detection, so lean on the worktree's
+  // detected agent CLI as the best available signal.
+  const secondary =
+    worktree.secondaryActiveTerminalId ?? worktree.secondaryPtyId;
+  return secondary
+    ? { worktree, ptyId: secondary, hasAgent: worktree.agentCli != null }
+    : null;
+}
+
+/** Turn the collected comments into one prompt for the agent. */
+export function composeFixPrompt(
+  entries: Array<{ ref: HunkRef; text: string }>,
+): string {
+  const header =
+    "I'm reviewing the current diff and want you to make the changes below. " +
+    "Each item points at a specific block of the diff (shown as a unified-diff snippet) and says " +
+    "what I want changed there. Implement all of them directly in the code, keeping " +
+    "each edit scoped to what's described. Don't ask for confirmation between items — " +
+    "just make the changes.";
+  const blocks = entries.map((e, i) => {
+    const loc = e.ref.label ? `${e.ref.file} (in ${e.ref.label})` : e.ref.file;
+    return (
+      `### Change ${i + 1} — ${loc}\n` +
+      "```diff\n" +
+      e.ref.snippet +
+      "\n```\n" +
+      `Requested: ${e.text.trim()}`
+    );
+  });
+  return [header, ...blocks, "Make these edits now."].join("\n\n");
+}
+
+const encoder = new TextEncoder();
+const PASTE_START = encoder.encode("\x1b[200~");
+const PASTE_END = encoder.encode("\x1b[201~");
+
+/**
+ * Deliver a multi-line prompt to a TUI agent (Claude Code, Codex, …)
+ * the way a real paste arrives: wrapped in bracketed-paste markers so
+ * embedded newlines land as literal newlines in the agent's input
+ * buffer rather than submitting each line. A trailing carriage return,
+ * sent as its own event, submits.
+ */
+async function sendToAgent(ptyId: string, prompt: string): Promise<void> {
+  const payload = encoder.encode(prompt);
+  const framed = new Uint8Array(
+    PASTE_START.length + payload.length + PASTE_END.length,
+  );
+  framed.set(PASTE_START, 0);
+  framed.set(payload, PASTE_START.length);
+  framed.set(PASTE_END, PASTE_START.length + payload.length);
+  await invoke("term_input", { id: ptyId, data: Array.from(framed) });
+  await invoke("term_input", { id: ptyId, data: [0x0d] });
+}
+
+export function DiffFixBar() {
+  const fix = useDiffFix();
+  const state = useAppState();
+  const dispatch = useAppDispatch();
+  const toast = useToast();
+  const [sending, setSending] = useState(false);
+  const [hover, setHover] = useState(false);
+
+  if (!fix) return null;
+  const count = fix.count;
+
+  const send = async () => {
+    const entries = fix.entries();
+    if (entries.length === 0 || sending) return;
+    const target = resolveAgentTarget(state, fix.cwd);
+    if (!target) {
+      toast.show({
+        message:
+          "No terminal open for this worktree — open your agent and press Fix again.",
+      });
+      return;
+    }
+    if (!target.hasAgent) {
+      toast.show({
+        message:
+          "No agent is running in this worktree — start Claude Code or Codex in the terminal, then press Fix again.",
+      });
+      return;
+    }
+    setSending(true);
+    try {
+      await sendToAgent(target.ptyId, composeFixPrompt(entries));
+      // Bring the agent terminal to the front so the user watches it work.
+      if (target.tabId)
+        dispatch({
+          type: "select-tab",
+          worktreeId: target.worktree.id,
+          id: target.tabId,
+        });
+      toast.show({
+        message: `Sent ${entries.length} change${
+          entries.length === 1 ? "" : "s"
+        } to the agent.`,
+      });
+      fix.clear();
+    } catch (e) {
+      toast.show({ message: `Couldn't reach the agent: ${e}` });
+    } finally {
+      setSending(false);
+    }
+  };
+
+  return (
+    <AnimatePresence>
+      {count > 0 && (
+        <motion.div
+          initial={{ opacity: 0, y: 10 }}
+          animate={{ opacity: 1, y: 0 }}
+          exit={{ opacity: 0, y: 10 }}
+          transition={{ duration: 0.16, ease: [0.25, 1, 0.5, 1] }}
+          style={{
+            position: "absolute",
+            left: 0,
+            right: 0,
+            bottom: 0,
+            display: "flex",
+            justifyContent: "center",
+            padding: "var(--space-3)",
+            pointerEvents: "none",
+            zIndex: 6,
+          }}
+        >
+          <button
+            type="button"
+            onClick={() => void send()}
+            onMouseEnter={() => setHover(true)}
+            onMouseLeave={() => setHover(false)}
+            disabled={sending}
+            style={{
+              pointerEvents: "auto",
+              display: "inline-flex",
+              alignItems: "center",
+              gap: "var(--space-2)",
+              height: 34,
+              padding: "0 var(--space-4)",
+              borderRadius: "var(--radius-pill)",
+              border:
+                "1px solid color-mix(in oklch, var(--surface-3), var(--accent) 55%)",
+              backgroundColor: hover
+                ? "color-mix(in oklch, var(--surface-2), var(--accent) 20%)"
+                : "color-mix(in oklch, var(--surface-2), var(--accent) 12%)",
+              color: "color-mix(in oklch, var(--text-primary), var(--accent) 35%)",
+              fontFamily: "var(--font-sans)",
+              fontSize: "var(--text-xs)",
+              fontWeight: "var(--weight-semibold)",
+              letterSpacing: "var(--tracking-tight)",
+              boxShadow: "var(--shadow-popover)",
+              cursor: sending ? "default" : "pointer",
+              opacity: sending ? 0.7 : 1,
+              transition:
+                "background-color var(--motion-fast) var(--ease-out-quart)",
+            }}
+          >
+            <MagicWand size={14} weight="fill" />
+            {sending
+              ? "Sending…"
+              : `Fix ${count} change${count === 1 ? "" : "s"}`}
+          </button>
+        </motion.div>
+      )}
+    </AnimatePresence>
+  );
+}
diff --git a/src/git/DiffView.tsx b/src/git/DiffView.tsx
index 9243ab8..74f752e 100644
--- a/src/git/DiffView.tsx
+++ b/src/git/DiffView.tsx
@@ -1,8 +1,24 @@
 import { motion } from "motion/react";
-import { useEffect, useMemo, useRef, useState, type ReactNode } from "react";
+import {
+  Fragment,
+  memo,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  type ReactNode,
+} from "react";
 import { git } from "@/lib/git";
 import { useDiffLineRenderers } from "./diff-highlight";
 import { DiffAskOverlay, reconstructDiffContext } from "./DiffAsk";
+import {
+  DiffFixBar,
+  DiffFixProvider,
+  HunkAddButton,
+  HunkCommentBox,
+  useDiffFix,
+  type HunkRef,
+} from "./DiffFix";
 import { parseUnifiedDiff, type DiffLine } from "./diff-parse";
 
 export { parseUnifiedDiff, type DiffLine };
@@ -121,6 +137,7 @@ export function DiffView({ projectPath, filePath, staged, onClose }: Props) {
     : "";
 
   return (
+    <DiffFixProvider cwd={projectPath}>
     <motion.div
       initial={{ opacity: 0, y: 4 }}
       animate={{ opacity: 1, y: 0 }}
@@ -283,8 +300,10 @@ export function DiffView({ projectPath, filePath, staged, onClose }: Props) {
             resolve={() => ({ path: filePath, diff: diffContext })}
           />
         )}
+        <DiffFixBar />
       </div>
     </motion.div>
+    </DiffFixProvider>
   );
 }
 
@@ -372,6 +391,72 @@ function hunkLabel(text: string): string {
   return m ? m[1].trim() : "";
 }
 
+/** Cap the diff snippet we attach per block so a giant edit doesn't
+ *  balloon the prompt handed to the agent. */
+const MAX_HUNK_SNIPPET_LINES = 80;
+
+interface BlockLayout {
+  /** Change-block ordinal each visible row belongs to (-1 if the row is
+   *  not part of an edited block — context, hunk header, plumbing). */
+  blockOf: number[];
+  /** Metadata per block: id, enclosing scope, and its diff snippet. */
+  blocks: HunkRef[];
+  /** First visible-row index of each block — where the `+` button sits. */
+  firstRow: number[];
+  /** Last visible-row index of each block — where the comment box lands. */
+  lastRow: number[];
+}
+
+/**
+ * Walk the rendered rows once and group the *edited* lines into change
+ * blocks: a block is a maximal run of consecutive `+`/`-` lines. A
+ * context line, a hunk boundary, or a plumbing header ends the run. Each
+ * block gets the `+` button on its first line and, when opened, the
+ * comment box directly under its last line — so a request targets the
+ * exact contiguous edit the user is pointing at, not the whole hunk.
+ *
+ * The snippet handed to the agent is that block's changed lines under
+ * the enclosing `@@` header (so line numbers/scope are anchored).
+ */
+function computeBlockLayout(visible: DiffLine[], file: string): BlockLayout {
+  const blockOf = new Array<number>(visible.length).fill(-1);
+  const blocks: HunkRef[] = [];
+  const firstRow: number[] = [];
+  const lastRow: number[] = [];
+  const snippetLines: string[][] = [];
+  let hunkHeader = "";
+  let label = "";
+  let cur = -1; // open block, or -1 between blocks
+  visible.forEach((l, i) => {
+    if (l.kind === "hunk") {
+      hunkHeader = l.text;
+      label = hunkLabel(l.text);
+      cur = -1;
+      return;
+    }
+    if (l.kind === "add" || l.kind === "remove") {
+      if (cur < 0) {
+        cur = blocks.length;
+        blocks.push({ id: `${file}#${cur}`, file, label, snippet: "" });
+        firstRow[cur] = i;
+        snippetLines.push(hunkHeader ? [hunkHeader] : []);
+      }
+      blockOf[i] = cur;
+      lastRow[cur] = i;
+      const prefix = l.kind === "add" ? "+" : "-";
+      if (snippetLines[cur].length < MAX_HUNK_SNIPPET_LINES)
+        snippetLines[cur].push(prefix + l.text);
+    } else {
+      // context / surviving header — closes the current block.
+      cur = -1;
+    }
+  });
+  blocks.forEach((b, k) => {
+    b.snippet = snippetLines[k].join("\n");
+  });
+  return { blockOf, blocks, firstRow, lastRow };
+}
+
 export function DiffBody({
   lines,
   filePath,
@@ -383,6 +468,17 @@ export function DiffBody({
   // indices line up with what we actually render.
   const visible = useMemo(() => visibleDiffLines(lines), [lines]);
   const rendered = useDiffLineRenderers(visible, filePath);
+  // Present only inside a working-diff view; null for historical commit
+  // diffs, which keeps them read-only (no `+`, no boxes).
+  const fix = useDiffFix();
+  const layout = useMemo(
+    () => computeBlockLayout(visible, filePath ?? ""),
+    [visible, filePath],
+  );
+  // The `+` gutter only exists in a working-diff view; commit diffs mount
+  // without a provider, so `fix` is null and no extra column is added.
+  const hasFix = !!fix;
+  const cols = hasFix ? 4 : 3;
   return (
     <table
       style={{
@@ -392,21 +488,77 @@ export function DiffBody({
       }}
     >
       <colgroup>
-        {/* One line-number gutter, one sigil, then the code. */}
-        <col style={{ width: 52 }} />
-        <col style={{ width: 22 }} />
+        {/* Optional `+` gutter, line-number gutter, sigil, then the code. */}
+        {hasFix && <col style={{ width: 20 }} />}
+        <col style={{ width: 28 }} />
+        <col style={{ width: 14 }} />
         <col />
       </colgroup>
       <tbody>
-        {visible.map((l, i) => (
-          <DiffRow key={i} line={l} body={rendered[i]} />
-        ))}
+        {visible.map((l, i) => {
+          const ord = layout.blockOf[i];
+          // The button sits on the first changed line of each block; only
+          // that row carries `fix`, so the rest keep stable props and skip
+          // re-render while the user types in a box.
+          const blockRef =
+            ord >= 0 && layout.firstRow[ord] === i
+              ? layout.blocks[ord]
+              : undefined;
+          const showBox =
+            hasFix &&
+            ord >= 0 &&
+            layout.lastRow[ord] === i &&
+            fix.isOpen(layout.blocks[ord].id);
+          return (
+            <Fragment key={i}>
+              <DiffRow
+                line={l}
+                body={rendered[i]}
+                gutter={hasFix}
+                colSpanAll={cols}
+                blockRef={blockRef}
+                fix={blockRef ? fix ?? undefined : undefined}
+              />
+              {showBox && fix && (
+                <tr>
+                  <td
+                    colSpan={cols}
+                    style={{
+                      padding: "var(--space-2) var(--space-3)",
+                      backgroundColor: "var(--surface-1)",
+                      borderBottom: "var(--border-1)",
+                    }}
+                  >
+                    <HunkCommentBox hunkRef={layout.blocks[ord]} fix={fix} />
+                  </td>
+                </tr>
+              )}
+            </Fragment>
+          );
+        })}
       </tbody>
     </table>
   );
 }
 
-function DiffRow({ line, body }: { line: DiffLine; body: ReactNode }) {
+const DiffRow = memo(function DiffRow({
+  line,
+  body,
+  gutter,
+  colSpanAll,
+  blockRef,
+  fix,
+}: {
+  line: DiffLine;
+  body: ReactNode;
+  /** Whether the leading `+`-button gutter column is present. */
+  gutter: boolean;
+  /** colSpan for full-width rows (hunk/header) — 4 with gutter, else 3. */
+  colSpanAll: number;
+  /** Set only on the first line of a change block — renders the button. */
+  blockRef?: HunkRef;
+  fix?: ReturnType<typeof useDiffFix>;
+}) {
   // Hunk markers become a single full-width separator rule — the visual
   // "the diff skips here" cue, with the enclosing-scope label if git gave
   // one. No raw `@@ -a,b +c,d @@` noise, no per-side numbers to decode.
@@ -415,9 +567,9 @@ function DiffRow({ line, body }: { line: DiffLine; body: ReactNode }) {
     return (
       <tr>
         <td
-          colSpan={3}
+          colSpan={colSpanAll}
           style={{
-            padding: "var(--space-1) var(--space-3)",
+            padding: "var(--space-1) var(--space-2)",
             borderTop: "var(--border-1)",
             borderBottom: "var(--border-1)",
             backgroundColor: "var(--surface-1)",
@@ -442,9 +594,9 @@ function DiffRow({ line, body }: { line: DiffLine; body: ReactNode }) {
     return (
       <tr>
         <td
-          colSpan={3}
+          colSpan={colSpanAll}
           style={{
-            padding: "var(--space-1) var(--space-3)",
+            padding: "var(--space-1) var(--space-2)",
             backgroundColor: "var(--surface-1)",
             color: "var(--text-tertiary)",
             fontSize: "var(--text-2xs)",
@@ -475,7 +627,9 @@ function DiffRow({ line, body }: { line: DiffLine; body: ReactNode }) {
   // Single gutter: the line's position in the file it belongs to —
   // removed lines carry their old number, everything else the new one.
   const lineNo = isRemove ? line.oldLine : line.newLine;
-  // A colored left edge reinforces add/remove without a second column.
+  // A colored left edge reinforces add/remove without a second column. It
+  // rides the leftmost cell — the `+` gutter when present, otherwise the
+  // line-number column — so the strip always hugs the far left of the row.
   const edge = isAdd
     ? "2px solid var(--diff-add-fg)"
     : isRemove
@@ -484,15 +638,45 @@ function DiffRow({ line, body }: { line: DiffLine; body: ReactNode }) {
 
   return (
     <tr style={{ backgroundColor: bg }}>
+      {gutter && (
+        <td
+          style={{
+            padding: 0,
+            position: "relative",
+            verticalAlign: "top",
+            borderLeft: edge,
+          }}
+        >
+          {fix && blockRef && (
+            // Absolutely positioned so the 18px button never stretches the
+            // first line of the block taller than the lines below it.
+            <div
+              style={{
+                position: "absolute",
+                inset: 0,
+                display: "flex",
+                alignItems: "flex-start",
+                justifyContent: "center",
+                paddingTop: 1,
+                pointerEvents: "none",
+              }}
+            >
+              <span style={{ pointerEvents: "auto" }}>
+                <HunkAddButton hunkRef={blockRef} fix={fix} />
+              </span>
+            </div>
+          )}
+        </td>
+      )}
       <td
         style={{
-          padding: "0 var(--space-2)",
+          padding: "0 var(--space-1)",
           textAlign: "right",
           color: "var(--text-tertiary)",
           userSelect: "none",
           fontSize: "var(--text-2xs)",
           verticalAlign: "top",
-          borderLeft: edge,
+          borderLeft: gutter ? undefined : edge,
         }}
         className="tabular"
       >
@@ -500,7 +684,7 @@ function DiffRow({ line, body }: { line: DiffLine; body: ReactNode }) {
       </td>
       <td
         style={{
-          padding: "0 var(--space-1)",
+          padding: 0,
           color: sigilColor,
           userSelect: "none",
           textAlign: "center",
@@ -522,7 +706,7 @@ function DiffRow({ line, body }: { line: DiffLine; body: ReactNode }) {
       </td>
     </tr>
   );
-}
+});
 
 function Empty({ label }: { label: string }) {
   return (

From 43391f83e6d8ded7e31723cc522e0c449a4e8f28 Mon Sep 17 00:00:00 2001
From: raeedz <raeedz@gmail.com>
Date: Fri, 3 Jul 2026 21:45:04 -0700
Subject: [PATCH 4/9] Slim down tab bars to single-line labels
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Drop the tab subtitle/summary line and shrink tab heights
  (36→30px strip, 32→26px MainColumn tabs, 28→24px RightPanel tabs).
---
 src/design/tokens.css    |  2 +-
 src/shell/MainColumn.tsx | 53 +++-------------------------------------
 src/shell/RightPanel.tsx |  2 +-
 3 files changed, 6 insertions(+), 51 deletions(-)

diff --git a/src/design/tokens.css b/src/design/tokens.css
index 09ea32b..af1730e 100644
--- a/src/design/tokens.css
+++ b/src/design/tokens.css
@@ -228,7 +228,7 @@
   --right-width:      372px;   /* files / changes / checks / memory + secondary terminal */
 
   --rail-width:         48px;
-  --tab-height:         36px;   /* 2-line tab (title + summary) at a fixed height; shared by sidebar + right-panel top bars */
+  --tab-height:         30px;   /* single-line tab at a fixed height; shared by sidebar + right-panel top bars */
   --pane-header-height: 28px;
   --filter-bar-height:  32px;
   --section-header-height: 24px;
diff --git a/src/shell/MainColumn.tsx b/src/shell/MainColumn.tsx
index bbf204f..d617fb7 100644
--- a/src/shell/MainColumn.tsx
+++ b/src/shell/MainColumn.tsx
@@ -362,13 +362,10 @@ function TabButton({
         display: "inline-flex",
         alignItems: "center",
         gap: 8,
-        // Fixed at 32 — leaves 4px breathing inside the 36px strip,
-        // and is tall enough to host the two-line label stack
-        // (title 12px / summary 10px = ~23px content) without ever
-        // growing further when the summary line appears. The tab no
-        // longer "stretches" on agent start; the second line just
-        // fills the space we already reserved.
-        height: 32,
+        // Single-line tab — sized to sit inside the 30px strip with a
+        // little breathing room. The live summary that used to ride a
+        // second line under the title is gone, so the tab stays short.
+        height: 26,
         minWidth: 120,
         maxWidth: 240,
         padding: "0 var(--space-2) 0 10px",
@@ -513,7 +510,6 @@ function TabLabelStack({ tab }: { tab: Tab }) {
   // appears/disappears within the same physical slot rather than
   // doubling the strip height the way it used to.
   const title = tabLabel(tab);
-  const summary = tabSummary(tab);
   return (
     <div
       style={{
@@ -538,51 +534,10 @@ function TabLabelStack({ tab }: { tab: Tab }) {
       >
         {title}
       </span>
-      {summary && (
-        <span
-          style={{
-            fontSize: 10,
-            color: "var(--text-tertiary)",
-            overflow: "hidden",
-            textOverflow: "ellipsis",
-            whiteSpace: "nowrap",
-          }}
-        >
-          {summary}
-        </span>
-      )}
     </div>
   );
 }
 
-/**
- * The live one-line summary that sits below the title inside the
- * tab. We trust `tab.summary` (set by BlockTerminal via the
- * helper-agent layer or the activeCommand fallback) for terminal
- * tabs, and fall back to the file path for file-backed tabs so the
- * line still carries information. CSS handles the visual ellipsis.
- */
-function tabSummary(tab: Tab): string {
-  // Hard cap at 80 chars defensively — the agent's activity-summary
-  // helper occasionally emits a runaway sentence, and tab labels are
-  // bounded by `maxWidth` anyway but we want predictable layout cost
-  // (CSS `text-overflow: ellipsis` is O(n) on text length when
-  // computing the truncation point).
-  const trim = (s: string | undefined | null): string => {
-    if (!s) return "";
-    const cleaned = s.replace(/\s+/g, " ").trim();
-    if (cleaned === "ready" || cleaned === "Untitled") return "";
-    return cleaned.length > 80 ? cleaned.slice(0, 80) : cleaned;
-  };
-  if (tab.kind === "terminal") return trim(tab.summary);
-  if (tab.kind === "diff" || tab.kind === "markdown") {
-    return trim(tab.filePath);
-  }
-  if (tab.kind === "all-changes") return "";
-  return trim(tab.summary);
-}
-
-
 /** Bare label for a tab — bare names only (no path, no subtitle).
  *  Terminal tabs only surface the CLI badge ("claude" / "codex" /
  *  "gemini") while the agent is actively running. Once it exits the
diff --git a/src/shell/RightPanel.tsx b/src/shell/RightPanel.tsx
index 492b066..973c4be 100644
--- a/src/shell/RightPanel.tsx
+++ b/src/shell/RightPanel.tsx
@@ -252,7 +252,7 @@ function PanelTab({
       onMouseLeave={() => setHover(false)}
       style={{
         position: "relative",
-        height: 28,
+        height: 24,
         padding: "0 var(--space-2)",
         backgroundColor: "transparent",
         color: active ? "var(--text-primary)" : "var(--text-secondary)",

From 66282fdde657809d76547ee76745e1e13a615bcb Mon Sep 17 00:00:00 2001
From: raeedz <raeedz@gmail.com>
Date: Sat, 4 Jul 2026 13:54:40 -0700
Subject: [PATCH 5/9] The `git diff` returned no output already (already
 answered by earlier truncated diff shown in the prompt), so I have enough
 context. Providing the commit message based on the diff I already saw.

Add 3-pane main-column split support to warp_term

Extend PANES from 2 to 3 slots (main, side, main2) so a main-column
split renders both halves natively, and clip wide alt-screen grids
to their pane's width so full-width TUIs stop bleeding into
neighboring React panels.
---
 src-tauri/src/warp_term.rs          | 200 ++++++++----
 src/git/DiffFix.tsx                 |   6 +-
 src/hooks/useVisibleTerminalSet.ts  |  18 +-
 src/lib/pointerDrag.tsx             | 149 +++++++++
 src/shell/MainColumn.tsx            | 486 ++++++++++++++++++++++++----
 src/shell/RightPanel.tsx            |  20 +-
 src/shell/Sidebar.tsx               | 190 ++++++-----
 src/state/reducer.test.ts           | 146 +++++++++
 src/state/reducer.ts                |  84 ++++-
 src/state/types.ts                  |  21 ++
 src/terminal/BlockTerminal.tsx      |  19 +-
 src/terminal/WarpSurfaceTracker.tsx |  88 ++++-
 12 files changed, 1181 insertions(+), 246 deletions(-)
 create mode 100644 src/lib/pointerDrag.tsx

diff --git a/src-tauri/src/warp_term.rs b/src-tauri/src/warp_term.rs
index 398e943..dd615c7 100644
--- a/src-tauri/src/warp_term.rs
+++ b/src-tauri/src/warp_term.rs
@@ -371,16 +371,22 @@ impl Pane {
     }
 }
 
-/// The panes: index 0 = main column, 1 = right-panel side terminal. Created
-/// lazily before attach so the sinks and the view share the same `Pane`s.
-static PANES: OnceLock<[Pane; 2]> = OnceLock::new();
-fn panes() -> &'static [Pane; 2] {
-    PANES.get_or_init(|| [Pane::new(), Pane::new()])
+/// The panes: index 0 = main column (or the LEFT half of a main-column
+/// split), 1 = right-panel side terminal, 2 = the RIGHT half of a
+/// main-column split. Created lazily before attach so the sinks and the
+/// view share the same `Pane`s.
+static PANES: OnceLock<[Pane; 3]> = OnceLock::new();
+fn panes() -> &'static [Pane; 3] {
+    PANES.get_or_init(|| [Pane::new(), Pane::new(), Pane::new()])
 }
-/// Resolve a React pane key to its `Pane`. Anything but "side" is the main pane
-/// (so a missing/legacy key maps safely to main).
+/// Resolve a React pane key to its `Pane`. Anything but "side" / "main2" is
+/// the main pane (so a missing/legacy key maps safely to main).
 fn pane(key: &str) -> &'static Pane {
-    &panes()[if key == "side" { 1 } else { 0 }]
+    &panes()[match key {
+        "side" => 1,
+        "main2" => 2,
+        _ => 0,
+    }]
 }
 /// The pane currently mirroring `pty_id`, if any (frame/block sink routing).
 fn pane_for_pty(pty_id: &str) -> Option<&'static Pane> {
@@ -1278,6 +1284,34 @@ fn build_pane_column(p: &'static Pane, mono: FamilyId) -> Box<dyn Element> {
             },
             grid,
         );
+        // Clip a wide alt grid to the pane. The narrow side pane pins a wide
+        // PTY (PAN_MIN_COLS) for shell layout, and an alt-screen TUI paints
+        // rows at that full grid width — ConstrainedBox only bounds layout,
+        // it doesn't clip painting — so without this the rows draw straight
+        // past the pane's right edge, over the neighbouring React panels
+        // ("terminal pokes out the side"). Same horizontal ClippedScrollable
+        // as the shell transcript below, gated on real overflow.
+        let grid_px = g.n_cols as f32 * CELL_ADVANCE;
+        let h_overflow = pane_w > 1.0 && grid_px > pane_w + 2.0;
+        let clipped: Box<dyn Element> = if h_overflow {
+            let max_hscroll = (grid_px - pane_w).max(0.0);
+            let hx = p.hscroll.scroll_start().as_f32().clamp(0.0, max_hscroll);
+            p.hscroll.scroll_to(Pixels::new(hx));
+            let bounded = ConstrainedBox::new(Box::new(selectable)).with_width(grid_px);
+            Box::new(
+                ClippedScrollable::horizontal(
+                    p.hscroll.clone(),
+                    Box::new(bounded),
+                    ScrollbarWidth::None,
+                    Fill::None,
+                    Fill::None,
+                    Fill::None,
+                )
+                .with_overlayed_scrollbar(),
+            )
+        } else {
+            Box::new(selectable)
+        };
         // Bound the full grid to the pane's height at its surface offset.
         // `pin_region`'s ConstrainedBox gives this MainAxisSize::Max grid a FINITE
         // height; nesting it raw under the side pane's column instead left it in
@@ -1286,9 +1320,9 @@ fn build_pane_column(p: &'static Pane, mono: FamilyId) -> Box<dyn Element> {
         // (rect not reported yet — only the topmost pane, briefly) returns the raw
         // grid, which the Stack bounds.
         if pane_h > 1.0 {
-            pin_region(Box::new(selectable), surface_offset_y, pane_h)
+            pin_region(clipped, surface_offset_y, pane_h)
         } else {
-            Box::new(selectable)
+            clipped
         }
     } else {
         // Shell transcript AND inline agents (claude/codex): closed blocks
@@ -1564,62 +1598,82 @@ impl View for TerminalRootView {
     }
 
     fn render(&self, _: &AppContext) -> Box<dyn Element> {
-        let ps = panes();
-        let main = &ps[0];
-        let side = &ps[1];
-
-        let main_col = build_pane_column(main, self.mono);
-        let side_on = side.active();
-        let column: Box<dyn Element> = if side_on {
-            // Both panes placed (the right-panel split is open). The surface
-            // covers the combined bounding box; lay the panes side-by-side by
-            // width (they share the AppShell row's top + height), with the gap
-            // between them (the React divider) left black.
-            //
-            // NOTE: the MAIN pane keeps its rect even when it's showing a
-            // non-terminal tab (editor/diff) — see `term_native_detach` /
-            // `term_surface_set_rect`, which detach the pty + clear the grid but
-            // DON'T zero the rect. So `main.rect()` is the real main-column box
-            // here, the gap stays ~0 (not `side.x`), and the combined surface
-            // size is unchanged from the both-terminals layout. That's what keeps
-            // the side terminal in place: the surface never resizes on a main
-            // tab switch, it just paints the main column empty/black behind the
-            // opaque editor DOM. (A detached main renders an empty grid, hidden.)
-            let (mx, my, mw, mh) = main.rect();
-            let (sx, sy, sw, sh) = side.rect();
-            let gap = (sx - (mx + mw)).max(0.0);
-            // Combined surface height. BOTH columns must be height-bounded to it:
-            // each pane's column is a MainAxisSize::Max flex (it fills the surface,
-            // with a lower pane's content pushed down by surface_offset_y), and a
-            // Max flex PANICS under an unbounded/infinite max constraint — which
-            // is what a width-only ConstrainedBox left the side column with, so a
-            // claude/alt-screen full grid in the side pane aborted the app
-            // (flex/mod.rs "can't be rendered in an infinite max constraint").
-            let ch = ((my + mh).max(sy + sh) - my.min(sy)).max(1.0);
-            let side_col = build_pane_column(side, self.mono);
+        // Every placed pane (non-trivial rect), laid out left-to-right by
+        // reported x: main (or the split's left half), the split's right
+        // half (main2), and the right-panel side terminal — any subset of
+        // which can be present. The surface covers the combined bounding
+        // box; the gaps between panes (React dividers) stay black.
+        //
+        // NOTE: the MAIN pane keeps its rect even when it's showing a
+        // non-terminal tab (editor/diff) — see `term_native_detach` /
+        // `term_surface_set_rect`, which detach the pty + clear the grid but
+        // DON'T zero the rect. So `main.rect()` is the real main-column box
+        // here and the combined surface size is unchanged when a main tab
+        // switch lands on an editor. That's what keeps the other terminals
+        // in place: the surface never resizes on a main tab switch, it just
+        // paints the main column empty/black behind the opaque editor DOM.
+        // (A detached main renders an empty grid, hidden.)
+        let mut placed: Vec<&'static Pane> =
+            panes().iter().filter(|p| p.active()).collect();
+        placed.sort_by(|a, b| {
+            a.rect()
+                .0
+                .partial_cmp(&b.rect().0)
+                .unwrap_or(std::cmp::Ordering::Equal)
+        });
+
+        let column: Box<dyn Element> = if placed.len() <= 1 {
+            // Single (or no) placed pane — degenerate to the plain column,
+            // exactly the pre-split single-pane layout. `pane("main")` keeps
+            // the startup path (no rect reported yet) painting the main grid.
+            let p = placed.first().copied().unwrap_or(pane("main"));
+            build_pane_column(p, self.mono)
+        } else {
+            // Combined surface height. EVERY column must be height-bounded to
+            // it: each pane's column is a MainAxisSize::Max flex (it fills the
+            // surface, with a lower pane's content pushed down by
+            // surface_offset_y), and a Max flex PANICS under an unbounded/
+            // infinite max constraint — which is what a width-only
+            // ConstrainedBox left the side column with, so a claude/alt-screen
+            // full grid in the side pane aborted the app (flex/mod.rs "can't
+            // be rendered in an infinite max constraint").
+            let mut top = f32::MAX;
+            let mut bot = 0.0f32;
+            for p in &placed {
+                let (_, y, _, h) = p.rect();
+                top = top.min(y);
+                bot = bot.max(y + h);
+            }
+            let ch = (bot - top).max(1.0);
             let mut kids: Vec<Box<dyn Element>> = Vec::new();
-            kids.push(Box::new(
-                ConstrainedBox::new(main_col)
-                    .with_width(mw.max(1.0))
-                    .with_height(ch),
-            ));
-            if gap > 0.5 {
+            for (i, p) in placed.iter().enumerate() {
+                let (x, _, w, _) = p.rect();
+                // Clamp each column so it can't overlap the next pane — a
+                // stale retained main rect (e.g. full-width from before a
+                // split opened) must not push its neighbours off the surface.
+                let w = match placed.get(i + 1) {
+                    Some(n) => w.min((n.rect().0 - x).max(1.0)),
+                    None => w,
+                };
                 kids.push(Box::new(
-                    ConstrainedBox::new(Rect::new().finish()).with_width(gap),
+                    ConstrainedBox::new(build_pane_column(p, self.mono))
+                        .with_width(w.max(1.0))
+                        .with_height(ch),
                 ));
+                if let Some(n) = placed.get(i + 1) {
+                    let gap = n.rect().0 - (x + w);
+                    if gap > 0.5 {
+                        kids.push(Box::new(
+                            ConstrainedBox::new(Rect::new().finish()).with_width(gap),
+                        ));
+                    }
+                }
             }
-            kids.push(Box::new(
-                ConstrainedBox::new(side_col)
-                    .with_width(sw.max(1.0))
-                    .with_height(ch),
-            ));
             Flex::row()
                 .with_main_axis_size(MainAxisSize::Max)
                 .with_cross_axis_alignment(CrossAxisAlignment::Stretch)
                 .with_children(kids)
                 .finish()
-        } else {
-            main_col
         };
 
         Stack::new()
@@ -1875,8 +1929,11 @@ pub fn term_surface_set_rect(pane_key: String, x: f64, y: f64, width: f64, heigh
     // is what stops the right-panel side terminal from blanking / shrinking: the
     // shared GPU surface is fragile to resize, and a zeroed main both collapsed
     // the box AND broke the side's side-by-side gap math. The side pane is NOT
-    // retained — collapsing the right panel SHOULD shrink the surface.
-    let is_main = pane_key != "side";
+    // retained — collapsing the right panel SHOULD shrink the surface. Neither
+    // is main2 (the split's right half): closing the split zero-reports it,
+    // and retaining would leave a stale column painting over the re-widened
+    // main pane.
+    let is_main = pane_key != "side" && pane_key != "main2";
     if is_main && zero {
         // Drop the stale report; keep the prior rect.
     } else if let Ok(mut r) = p.rect.lock() {
@@ -1901,13 +1958,21 @@ pub fn term_native_attach(
     let p = pane(&pane_key);
     // Stop mirroring this pane's previous pty, then mirror the new one.
     let prev = p.pty_id();
-    if !prev.is_empty() && prev != id {
-        crate::term::clear_native_pty(&prev);
-    }
     if let Ok(mut g) = p.pty.lock() {
         g.clear();
         g.push_str(&id);
     }
+    // Unregister the previous pty ONLY if no other pane mirrors it now.
+    // When two terminals swap halves (main ⇄ main2) the two attach calls
+    // land back-to-back, and the second pane's "previous" pty is exactly
+    // the one the first pane just claimed — clearing it unconditionally
+    // froze that pane (frames stopped reaching the sink).
+    if !prev.is_empty()
+        && prev != id
+        && panes().iter().all(|q| q.pty_id() != prev)
+    {
+        crate::term::clear_native_pty(&prev);
+    }
     crate::term::set_native_pty(&id);
     {
         let mut g = p.grid.lock().unwrap_or_else(|e| e.into_inner());
@@ -1958,13 +2023,16 @@ pub fn term_native_attach(
 pub fn term_native_detach(pane_key: String) {
     let p = pane(&pane_key);
     let prev = p.pty_id();
-    if !prev.is_empty() {
-        crate::term::clear_native_pty(&prev);
-    }
     if let Ok(mut g) = p.pty.lock() {
         g.clear();
     }
-    if pane_key == "side" {
+    // Same other-pane guard as `term_native_attach`: during a half-swap the
+    // pty this pane is letting go of may have just been claimed by another
+    // pane — don't yank its frames.
+    if !prev.is_empty() && panes().iter().all(|q| q.pty_id() != prev) {
+        crate::term::clear_native_pty(&prev);
+    }
+    if pane_key == "side" || pane_key == "main2" {
         if let Ok(mut r) = p.rect.lock() {
             *r = (0.0, 0.0, 0.0, 0.0);
         }
diff --git a/src/git/DiffFix.tsx b/src/git/DiffFix.tsx
index b5fdd50..e470519 100644
--- a/src/git/DiffFix.tsx
+++ b/src/git/DiffFix.tsx
@@ -231,8 +231,8 @@ export function HunkCommentBox({
         minHeight: 96,
         borderRadius: "var(--radius-md)",
         border:
-          "1px solid color-mix(in oklch, var(--border-strong), var(--accent) 20%)",
-        backgroundColor: "var(--surface-accent-soft)",
+          "1px solid color-mix(in oklch, var(--border-strong), var(--accent) 60%)",
+        backgroundColor: "var(--surface-2)",
         padding: "var(--space-2)",
       }}
     >
@@ -244,7 +244,7 @@ export function HunkCommentBox({
           position: "absolute",
           top: "calc(var(--space-2) + 2px)",
           left: "var(--space-2)",
-          color: "color-mix(in oklch, var(--text-tertiary), var(--accent) 45%)",
+          color: "var(--accent)",
           pointerEvents: "none",
         }}
       />
diff --git a/src/hooks/useVisibleTerminalSet.ts b/src/hooks/useVisibleTerminalSet.ts
index 8d61d04..bab81f8 100644
--- a/src/hooks/useVisibleTerminalSet.ts
+++ b/src/hooks/useVisibleTerminalSet.ts
@@ -48,12 +48,22 @@ export function useVisibleTerminalSet() {
         ids.push(tab.ptyId);
       }
     }
-    // Secondary terminal counts only when the right-panel secondary
-    // section is expanded AND showing the Terminal subtab. Other
-    // states (Setup, Run, collapsed) don't actually render a
+    // The split pane's tab renders alongside the active tab, so its
+    // PTY is just as on-screen as the active one.
+    if (worktree.splitTabId) {
+      const tab = state.tabs[worktree.splitTabId];
+      if (tab && tab.kind === "terminal") {
+        ids.push(tab.ptyId);
+      }
+    }
+    // Secondary terminal counts only when the right panel itself is
+    // shown AND the secondary section is expanded AND showing the
+    // Terminal subtab. Other states (panel collapsed to 0 width,
+    // Setup, Run, section collapsed) don't actually render a
     // BlockTerminal, so the PTY would be wasting full-cadence
     // emits on a non-visible surface.
     if (
+      !state.rightPanelCollapsed &&
       !worktree.secondaryCollapsed &&
       worktree.secondaryTab === "terminal" &&
       worktree.secondaryActiveTerminalId
@@ -61,7 +71,7 @@ export function useVisibleTerminalSet() {
       ids.push(worktree.secondaryActiveTerminalId);
     }
     return ids;
-  }, [worktree, state.tabs]);
+  }, [worktree, state.tabs, state.rightPanelCollapsed]);
 
   const lastSentRef = useRef<string>("");
 
diff --git a/src/lib/pointerDrag.tsx b/src/lib/pointerDrag.tsx
new file mode 100644
index 0000000..0d3e0a0
--- /dev/null
+++ b/src/lib/pointerDrag.tsx
@@ -0,0 +1,149 @@
+import { createPortal } from "react-dom";
+
+/**
+ * Pointer-tracked drag-and-drop for INTERNAL chrome interactions (tab →
+ * split drop, sidebar worktree reorder).
+ *
+ * Deliberately NOT HTML5 drag-and-drop: the Tauri window keeps native
+ * drag-drop interception enabled (`dragDropEnabled` default) because the
+ * terminal and file tree consume real file drops via `onDragDropEvent` —
+ * and with that interception on, WKWebView delivers DOM `dragover` but
+ * swallows the DOM `drop`/`dragend`, so an HTML5 drop target highlights
+ * and then never fires. WebKit additionally refuses to start element
+ * drags from `<button>`s (the sidebar rows). Tracking mousemove/mouseup
+ * ourselves sidesteps the whole native drag session.
+ *
+ * Call from a mousedown handler. Nothing happens until the pointer
+ * travels past a small threshold — a plain click never triggers
+ * `onStart`. Once dragging:
+ *
+ *   - text selection + cursor are locked for the duration
+ *   - `onMove` fires per mousemove (use for ghost position + hit-tests)
+ *   - mouseup fires `onDrop(x, y)` then `onEnd`; Escape cancels with
+ *     `onEnd` only
+ *   - the click event generated by the ending mouseup is swallowed
+ *     (capture-phase, one-shot) so the drop doesn't ALSO activate
+ *     whatever the drag started on
+ */
+/** True while any pointer drag is past its threshold. Unlike a native
+ *  drag session, pointer tracking doesn't suppress mouseenter/hover on
+ *  the elements swept over — hover-intent UI (worktree hover cards,
+ *  tab tooltips) checks this to stay closed mid-drag. */
+let dragActive = false;
+export function pointerDragActive(): boolean {
+  return dragActive;
+}
+
+export function beginPointerDrag(
+  down: { button: number; clientX: number; clientY: number },
+  h: {
+    onStart?: (x: number, y: number) => void;
+    onMove?: (x: number, y: number) => void;
+    onDrop?: (x: number, y: number) => void;
+    /** Always fires last, drag or plain click. */
+    onEnd?: () => void;
+  },
+): void {
+  if (down.button !== 0) return;
+  const THRESHOLD_PX = 5;
+  const sx = down.clientX;
+  const sy = down.clientY;
+  let started = false;
+
+  const onMove = (e: MouseEvent) => {
+    if (!started) {
+      if (
+        Math.abs(e.clientX - sx) + Math.abs(e.clientY - sy) <
+        THRESHOLD_PX
+      ) {
+        return;
+      }
+      started = true;
+      dragActive = true;
+      document.body.style.userSelect = "none";
+      document.body.style.cursor = "grabbing";
+      h.onStart?.(e.clientX, e.clientY);
+    }
+    h.onMove?.(e.clientX, e.clientY);
+  };
+
+  const finish = (drop: MouseEvent | null) => {
+    window.removeEventListener("mousemove", onMove, true);
+    window.removeEventListener("mouseup", onUp, true);
+    window.removeEventListener("keydown", onKey, true);
+    if (started) {
+      dragActive = false;
+      document.body.style.userSelect = "";
+      document.body.style.cursor = "";
+      // Swallow the click this mouseup is about to generate — without
+      // this, dropping a tab onto the view ALSO "clicks" the tab (or
+      // row) the drag started from.
+      const swallow = (ce: MouseEvent) => {
+        ce.stopPropagation();
+        ce.preventDefault();
+      };
+      window.addEventListener("click", swallow, { capture: true, once: true });
+      setTimeout(
+        () => window.removeEventListener("click", swallow, true),
+        0,
+      );
+      if (drop) h.onDrop?.(drop.clientX, drop.clientY);
+    }
+    h.onEnd?.();
+  };
+
+  const onUp = (e: MouseEvent) => finish(e);
+  const onKey = (e: KeyboardEvent) => {
+    if (e.key === "Escape") finish(null);
+  };
+
+  // Capture phase: terminal panes / editors can't stopPropagation the
+  // drag out from under us.
+  window.addEventListener("mousemove", onMove, true);
+  window.addEventListener("mouseup", onUp, true);
+  window.addEventListener("keydown", onKey, true);
+}
+
+/**
+ * Floating label that trails the pointer during a pointer drag. Offset
+ * from the cursor so `document.elementFromPoint(x, y)` hit-tests (used
+ * by drop targets) never land on the ghost itself; `pointerEvents:
+ * none` guards the same for the offset region.
+ */
+export function DragGhost({
+  x,
+  y,
+  label,
+}: {
+  x: number;
+  y: number;
+  label: string;
+}) {
+  return createPortal(
+    <div
+      aria-hidden
+      style={{
+        position: "fixed",
+        left: x + 14,
+        top: y + 10,
+        zIndex: 2000,
+        pointerEvents: "none",
+        padding: "3px 10px",
+        borderRadius: "var(--radius-sm)",
+        backgroundColor: "var(--surface-3)",
+        border: "1px solid var(--border-strong)",
+        color: "var(--text-primary)",
+        fontSize: "var(--text-xs)",
+        fontFamily: "var(--font-sans)",
+        boxShadow: "0 4px 12px oklch(0% 0 0 / 0.4)",
+        maxWidth: 240,
+        overflow: "hidden",
+        textOverflow: "ellipsis",
+        whiteSpace: "nowrap",
+      }}
+    >
+      {label}
+    </div>,
+    document.body,
+  );
+}
diff --git a/src/shell/MainColumn.tsx b/src/shell/MainColumn.tsx
index d617fb7..0c23040 100644
--- a/src/shell/MainColumn.tsx
+++ b/src/shell/MainColumn.tsx
@@ -19,7 +19,7 @@ import { projectSettings } from "@/state/types";
 import { collectWorktreePtyIds, worktreeArchive } from "@/lib/worktrees";
 import { forgetPtys } from "@/terminal/sessionMemory";
 import { useToast } from "@/primitives/Toast";
-import { FolderDashedIcon } from "@phosphor-icons/react";
+import { ArrowsOutSimpleIcon, FolderDashedIcon } from "@phosphor-icons/react";
 import { ErrorBoundary } from "./ErrorBoundary";
 import { BlockTerminal } from "@/terminal/BlockTerminal";
 import { WarpSurfaceTracker } from "@/terminal/WarpSurfaceTracker";
@@ -29,6 +29,11 @@ import { CommitDetailView } from "@/git/CommitDetailView";
 import { Editor } from "@/editor/Editor";
 import { MarkdownView } from "@/editor/MarkdownView";
 import { fs } from "@/lib/fs";
+import {
+  beginPointerDrag,
+  DragGhost,
+  pointerDragActive,
+} from "@/lib/pointerDrag";
 import { RepositorySettingsView } from "./RepositorySettingsView";
 
 /**
@@ -46,6 +51,18 @@ export function MainColumn() {
   // file has unsaved edits, we hold the tab in this state and render
   // the modal. Clean tabs close immediately and never set this.
   const [pendingClose, setPendingClose] = useState<Tab | null>(null);
+  // Tab id currently being dragged out of the strip (HTML5 drag). While
+  // set, TabContent renders the split drop overlay. Cleared on dragend.
+  const [draggingTabId, setDraggingTabId] = useState<string | null>(null);
+
+  // Second pane of the 50/50 split, resolved defensively: the reducer
+  // enforces splitTabId ≠ activeTabId and clears it on close, but stale
+  // persisted state must degrade to "no split", not a broken layout.
+  const splitTab =
+    (worktree?.splitTabId &&
+      worktree.splitTabId !== activeTab?.id &&
+      tabs.find((t) => t.id === worktree.splitTabId)) ||
+    null;
 
   if (!project || !worktree) {
     return (
@@ -117,13 +134,17 @@ export function MainColumn() {
       <TabStrip
         tabs={tabs}
         activeTabId={activeTab?.id ?? null}
+        splitTabId={splitTab?.id ?? null}
         worktreeId={worktree.id}
         onCloseTab={requestCloseTab}
+        onTabDragChange={setDraggingTabId}
       />
       <TabContent
         worktree={worktree}
         tab={activeTab}
+        splitTab={splitTab}
         cwd={worktree.path}
+        draggingTabId={draggingTabId}
       />
       <CloseTabConfirmDialog
         tab={pendingClose}
@@ -179,13 +200,18 @@ export function MainColumn() {
 function TabStrip({
   tabs,
   activeTabId,
+  splitTabId,
   worktreeId,
   onCloseTab,
+  onTabDragChange,
 }: {
   tabs: Tab[];
   activeTabId: string | null;
+  splitTabId: string | null;
   worktreeId: string;
   onCloseTab: (tab: Tab) => void;
+  /** Fires with the tab id on dragstart, null on dragend. */
+  onTabDragChange: (id: string | null) => void;
 }) {
   const dispatch = useAppDispatch();
 
@@ -242,8 +268,10 @@ function TabStrip({
             key={tab.id}
             tab={tab}
             active={tab.id === activeTabId}
+            inSplit={tab.id === splitTabId}
             worktreeId={worktreeId}
             onCloseTab={onCloseTab}
+            onTabDragChange={onTabDragChange}
           />
         ))}
         <button
@@ -317,13 +345,20 @@ function TabStrip({
 function TabButton({
   tab,
   active,
+  inSplit,
   worktreeId,
   onCloseTab,
+  onTabDragChange,
 }: {
   tab: Tab;
   active: boolean;
+  /** True when this tab occupies the split (right) pane — tinted like
+   *  the active tab but without the accent underline, so the strip
+   *  shows both on-screen tabs at a glance. */
+  inSplit: boolean;
   worktreeId: string;
   onCloseTab: (tab: Tab) => void;
+  onTabDragChange: (id: string | null) => void;
 }) {
   const dispatch = useAppDispatch();
   // Hover tooltip exposes the tab's full live summary — the same
@@ -334,12 +369,49 @@ function TabButton({
     useTooltipAnchor<HTMLDivElement>();
   const tooltipLabel = fullTabSummary(tab);
 
+  // Pointer-tracked drag out of the strip (NOT HTML5 drag-and-drop —
+  // see lib/pointerDrag.tsx for why that can't work in this webview).
+  // The ghost position doubles as the "is dragging" flag.
+  const [ghost, setGhost] = useState<{ x: number; y: number } | null>(null);
+
+  const onTabMouseDown = (e: React.MouseEvent) => {
+    // Not from the close button — that's a click affordance, and a
+    // drag from it would close-or-split ambiguously.
+    if ((e.target as HTMLElement).closest("button")) return;
+    beginPointerDrag(e, {
+      onStart: (x, y) => {
+        cancelShow();
+        onTabDragChange(tab.id);
+        setGhost({ x, y });
+      },
+      onMove: (x, y) => setGhost({ x, y }),
+      onDrop: (x, y) => {
+        const zone = document.querySelector("[data-tab-drop-zone]");
+        const r = zone?.getBoundingClientRect();
+        if (!r || x < r.left || x > r.right || y < r.top || y > r.bottom) {
+          return;
+        }
+        dispatch({
+          type: "split-tab",
+          worktreeId,
+          id: tab.id,
+          side: x < r.left + r.width / 2 ? "left" : "right",
+        });
+      },
+      onEnd: () => {
+        onTabDragChange(null);
+        setGhost(null);
+      },
+    });
+  };
+
   return (
     <>
     <motion.div
       ref={ref}
       role="tab"
       aria-selected={active}
+      onMouseDown={onTabMouseDown}
       // `layout="position"` (not `layout`) — we want neighbours to
       // slide when a tab is opened, closed, or reordered, but we
       // *don't* want motion to animate the tab's own width when its
@@ -355,7 +427,10 @@ function TabButton({
         cancelShow();
         dispatch({ type: "select-tab", worktreeId, id: tab.id });
       }}
-      onMouseEnter={beginShow}
+      onMouseEnter={() => {
+        // No tooltips on tabs swept over mid-drag.
+        if (!pointerDragActive()) beginShow();
+      }}
       onMouseLeave={cancelShow}
       style={{
         position: "relative",
@@ -370,8 +445,10 @@ function TabButton({
         maxWidth: 240,
         padding: "0 var(--space-2) 0 10px",
         cursor: "pointer",
-        backgroundColor: active ? "var(--surface-2)" : "transparent",
-        color: active ? "var(--text-primary)" : "var(--text-secondary)",
+        backgroundColor:
+          active || inSplit ? "var(--surface-2)" : "transparent",
+        color:
+          active || inSplit ? "var(--text-primary)" : "var(--text-secondary)",
         borderTopLeftRadius: 6,
         borderTopRightRadius: 6,
         transition:
@@ -443,6 +520,7 @@ function TabButton({
         />
       )}
     </AnimatePresence>
+    {ghost && <DragGhost x={ghost.x} y={ghost.y} label={tabLabel(tab)} />}
     </>
   );
 }
@@ -648,20 +726,64 @@ function isTabDirty(tab: Tab): boolean {
    Tab content router
    ------------------------------------------------------------------ */
 
+/** Width of the black seam between the two split halves. */
+const SPLIT_DIVIDER_W = 1;
+
+/**
+ * Geometry of one content pane. `full` (no split) is the whole content
+ * area; `left`/`right` are the two halves of the 50/50 split with a
+ * SPLIT_DIVIDER_W seam between them. Shared by the half containers AND
+ * the terminal keepalive slots so a terminal's DOM slot, its
+ * WarpSurfaceTracker rect, and its non-terminal siblings always agree
+ * on the same box.
+ */
+function paneBox(side: "full" | "left" | "right"): React.CSSProperties {
+  if (side === "left") {
+    return {
+      position: "absolute",
+      top: 0,
+      bottom: 0,
+      left: 0,
+      width: `calc(50% - ${SPLIT_DIVIDER_W}px)`,
+    };
+  }
+  if (side === "right") {
+    return { position: "absolute", top: 0, bottom: 0, left: "50%", right: 0 };
+  }
+  return { position: "absolute", inset: 0 };
+}
+
 function TabContent({
   worktree,
   tab,
+  splitTab,
   cwd,
+  draggingTabId,
 }: {
   worktree: Worktree;
   tab: Tab | null;
+  /** Occupant of the split (right) pane, or null when unsplit. */
+  splitTab: Tab | null;
   // `cwd` is the WORKTREE path, not the project root. Git commands
   // (`git_diff`, `git_diff_all`) must run inside the active worktree
   // — running them at the project root would silently report the
   // wrong directory's diff (which can be empty even when the
   // worktree has changes).
   cwd: string;
+  /** Tab id mid-drag from the strip; renders the split drop overlay. */
+  draggingTabId: string | null;
 }) {
+  const split = !!splitTab;
+  // TEMP DEBUG — remove before commit (live-state mirror for the render
+  // investigation; a module-level interval at the bottom of this file
+  // posts it to a local diagnostics listener).
+  (window as unknown as Record<string, unknown>).__paneState = {
+    wt: worktree.id,
+    splitTabIdRaw: worktree.splitTabId ?? null,
+    activeTabId: worktree.activeTabId ?? null,
+    active: tab ? { id: tab.id, kind: tab.kind } : null,
+    split: splitTab ? { id: splitTab.id, kind: splitTab.kind } : null,
+  };
   // Terminal-kind tabs go through the always-mounted keepalive
   // layer; non-terminal kinds (diff, markdown, all-changes,
   // project-settings) mount on demand. The keepalive layer is
@@ -678,71 +800,254 @@ function TabContent({
   // already-mounted terminals — no re-listen, no re-term_start,
   // no React commit cascade for the BlockTerminal subtree.
   return (
-    <div style={{ minHeight: 0, minWidth: 0, position: "relative", overflow: "hidden" }}>
-      {/* Reports this pane's rect to the native warpui terminal surface so it
-          composites over exactly the terminal region. */}
-      <WarpSurfaceTracker visible={!!tab && tab.kind === "terminal"} />
+    <div
+      data-tab-drop-zone
+      style={{ minHeight: 0, minWidth: 0, position: "relative", overflow: "hidden" }}
+    >
       <ErrorBoundary>
         <TerminalKeepaliveLayer
           activeTerminalTabId={
             tab && tab.kind === "terminal" ? tab.id : null
           }
+          splitTerminalTabId={
+            splitTab && splitTab.kind === "terminal" ? splitTab.id : null
+          }
+          split={split}
           activeWorktree={worktree}
         />
-        {!tab && (
-          <div
-            style={{
-              position: "absolute",
-              inset: 0,
-              display: "grid",
-              placeItems: "center",
-              color: "var(--text-tertiary)",
-              fontSize: "var(--text-xs)",
-              backgroundColor: "var(--surface-2)",
-            }}
-          >
-            No tab open. Press <Kbd>+</Kbd> to start a terminal.
-          </div>
+        <HalfPane side={split ? "left" : "full"} tab={tab} cwd={cwd} />
+        {splitTab && (
+          <>
+            <div
+              aria-hidden
+              style={{
+                position: "absolute",
+                top: 0,
+                bottom: 0,
+                left: `calc(50% - ${SPLIT_DIVIDER_W}px)`,
+                width: SPLIT_DIVIDER_W,
+                backgroundColor: "var(--border-default)",
+                zIndex: 2,
+              }}
+            />
+            <HalfPane side="right" tab={splitTab} cwd={cwd} />
+            <ExpandPaneButton side="left" worktreeId={worktree.id} />
+            <ExpandPaneButton side="right" worktreeId={worktree.id} />
+          </>
         )}
-        {tab && tab.kind !== "terminal" && (
+        {draggingTabId && <TabDropOverlay />}
+      </ErrorBoundary>
+    </div>
+  );
+}
+
+/**
+ * One content pane (the whole area, or one half of the split). Hosts
+ * the pane's WarpSurfaceTracker (native terminal rect reporting) and
+ * the non-terminal tab views. Terminal tabs render NOTHING here — they
+ * live in the keepalive layer underneath, which positions the matching
+ * slot over this same paneBox — so the container is pointer-transparent
+ * to let clicks fall through to the terminal.
+ */
+function HalfPane({
+  side,
+  tab,
+  cwd,
+}: {
+  side: "full" | "left" | "right";
+  tab: Tab | null;
+  cwd: string;
+}) {
+  const isTerminal = !!tab && tab.kind === "terminal";
+  return (
+    <div style={{ ...paneBox(side), pointerEvents: "none", zIndex: 1 }}>
+      {/* Reports this pane's rect to the native warpui terminal surface
+          so it composites over exactly the terminal region. The main
+          pane (full/left) keeps reporting its box even when hidden so
+          the retained Rust-side rect tracks split-layout changes that
+          happen while a non-terminal tab is showing; the right half
+          zeroes instead (its pane should vanish when not a terminal). */}
+      <WarpSurfaceTracker
+        visible={isTerminal}
+        paneKey={side === "right" ? "main2" : "main"}
+        reportWhenHidden={side !== "right"}
+      />
+      {!tab && (
+        <div
+          style={{
+            position: "absolute",
+            inset: 0,
+            display: "grid",
+            placeItems: "center",
+            color: "var(--text-tertiary)",
+            fontSize: "var(--text-xs)",
+            backgroundColor: "var(--surface-2)",
+            pointerEvents: "auto",
+          }}
+        >
+          No tab open. Press <Kbd>+</Kbd> to start a terminal.
+        </div>
+      )}
+      {tab && tab.kind !== "terminal" && (
+        <div
+          style={{
+            position: "absolute",
+            inset: 0,
+            display: "flex",
+            flexDirection: "column",
+            backgroundColor: "var(--surface-2)",
+            minHeight: 0,
+            pointerEvents: "auto",
+          }}
+        >
+          {tab.kind === "diff" ? (
+            <DiffTabContent
+              key={tab.id}
+              tabId={tab.id}
+              cwd={cwd}
+              filePath={tab.filePath}
+              staged={tab.staged}
+            />
+          ) : tab.kind === "all-changes" ? (
+            <AllChangesView key={tab.id} projectPath={cwd} />
+          ) : tab.kind === "commit" ? (
+            <CommitDetailView
+              key={tab.id}
+              cwd={cwd}
+              hash={tab.hash}
+              worktreeId={tab.worktreeId}
+            />
+          ) : tab.kind === "project-settings" ? (
+            <RepositorySettingsView
+              key={tab.id}
+              projectId={tab.projectId}
+            />
+          ) : (
+            <MarkdownTabContent key={tab.id} tab={tab} />
+          )}
+        </div>
+      )}
+    </div>
+  );
+}
+
+/**
+ * Floating "make this half full screen again" affordance, one per half
+ * while split. Collapses the split keeping this half's tab as the
+ * active full-width tab.
+ */
+function ExpandPaneButton({
+  side,
+  worktreeId,
+}: {
+  side: "left" | "right";
+  worktreeId: string;
+}) {
+  const dispatch = useAppDispatch();
+  return (
+    <button
+      type="button"
+      title={`Expand ${side} pane · full screen`}
+      onClick={() => dispatch({ type: "unsplit", worktreeId, keep: side })}
+      style={{
+        position: "absolute",
+        top: 6,
+        ...(side === "left"
+          ? { right: `calc(50% + ${SPLIT_DIVIDER_W + 6}px)` }
+          : { right: 6 }),
+        zIndex: 6,
+        width: 24,
+        height: 24,
+        display: "inline-flex",
+        alignItems: "center",
+        justifyContent: "center",
+        color: "var(--text-tertiary)",
+        backgroundColor: "var(--surface-2)",
+        border: "var(--border-1)",
+        borderRadius: "var(--radius-sm)",
+        opacity: 0.75,
+        transition:
+          "opacity var(--motion-instant) var(--ease-out-quart)," +
+          "color var(--motion-instant) var(--ease-out-quart)",
+      }}
+      onMouseOver={(e) => {
+        e.currentTarget.style.opacity = "1";
+        e.currentTarget.style.color = "var(--text-primary)";
+      }}
+      onMouseOut={(e) => {
+        e.currentTarget.style.opacity = "0.75";
+        e.currentTarget.style.color = "var(--text-tertiary)";
+      }}
+    >
+      <ArrowsOutSimpleIcon size={13} />
+    </button>
+  );
+}
+
+/**
+ * Purely visual drop hint, mounted only while a tab is being pointer-
+ * dragged from the strip. Tracks the cursor via window mousemove and
+ * highlights whichever half of the content area it's over. The actual
+ * drop is dispatched by the drag source (TabButton) on mouseup, hit-
+ * testing against the `data-tab-drop-zone` root — this layer stays
+ * `pointerEvents: none` so it can never eat the interaction.
+ */
+function TabDropOverlay() {
+  const ref = useRef<HTMLDivElement>(null);
+  const [hoverSide, setHoverSide] = useState<"left" | "right" | null>(null);
+
+  useEffect(() => {
+    const onMove = (e: MouseEvent) => {
+      const r = ref.current?.getBoundingClientRect();
+      if (!r) return;
+      const inside =
+        e.clientX >= r.left &&
+        e.clientX <= r.right &&
+        e.clientY >= r.top &&
+        e.clientY <= r.bottom;
+      const side = !inside
+        ? null
+        : e.clientX < r.left + r.width / 2
+          ? "left"
+          : "right";
+      setHoverSide((cur) => (cur === side ? cur : side));
+    };
+    // Capture phase, same as beginPointerDrag's tracker, so panes that
+    // stopPropagation mousemove can't hide the hint.
+    window.addEventListener("mousemove", onMove, true);
+    return () => window.removeEventListener("mousemove", onMove, true);
+  }, []);
+
+  return (
+    <div
+      ref={ref}
+      style={{ position: "absolute", inset: 0, zIndex: 40, pointerEvents: "none" }}
+    >
+      {hoverSide && (
+        <div
+          aria-hidden
+          style={{
+            position: "absolute",
+            top: 4,
+            bottom: 4,
+            ...(hoverSide === "left"
+              ? { left: 4, right: "calc(50% + 2px)" }
+              : { left: "calc(50% + 2px)", right: 4 }),
+            borderRadius: "var(--radius-md)",
+            border: "1px solid var(--accent)",
+            overflow: "hidden",
+          }}
+        >
           <div
             style={{
               position: "absolute",
               inset: 0,
-              display: "flex",
-              flexDirection: "column",
-              backgroundColor: "var(--surface-2)",
-              minHeight: 0,
+              backgroundColor: "var(--accent)",
+              opacity: 0.12,
             }}
-          >
-            {tab.kind === "diff" ? (
-              <DiffTabContent
-                key={tab.id}
-                tabId={tab.id}
-                cwd={cwd}
-                filePath={tab.filePath}
-                staged={tab.staged}
-              />
-            ) : tab.kind === "all-changes" ? (
-              <AllChangesView key={tab.id} projectPath={cwd} />
-            ) : tab.kind === "commit" ? (
-              <CommitDetailView
-                key={tab.id}
-                cwd={cwd}
-                hash={tab.hash}
-                worktreeId={tab.worktreeId}
-              />
-            ) : tab.kind === "project-settings" ? (
-              <RepositorySettingsView
-                key={tab.id}
-                projectId={tab.projectId}
-              />
-            ) : (
-              <MarkdownTabContent key={tab.id} tab={tab} />
-            )}
-          </div>
-        )}
-      </ErrorBoundary>
+          />
+        </div>
+      )}
     </div>
   );
 }
@@ -770,9 +1075,17 @@ const KEEPALIVE_WORKTREES = 3;
 
 function TerminalKeepaliveLayer({
   activeTerminalTabId,
+  splitTerminalTabId,
+  split,
   activeWorktree,
 }: {
   activeTerminalTabId: string | null;
+  /** Terminal tab occupying the split (right) pane, if any. */
+  splitTerminalTabId: string | null;
+  /** True while the 50/50 split is open (regardless of tab kinds) —
+      the active terminal then renders into the LEFT half instead of
+      the full content box. */
+  split: boolean;
   activeWorktree: Worktree;
 }) {
   const state = useAppState();
@@ -809,7 +1122,19 @@ function TerminalKeepaliveLayer({
   return (
     <>
       {terminalSlots.map(({ tab, worktree }) => {
-        const visible = tab.id === activeTerminalTabId;
+        // Where this terminal renders: the full content box, one half
+        // of the split, or nowhere (kept alive but hidden). Placement
+        // shares paneBox() with the HalfPane containers so the slot,
+        // its tracker rect, and any sibling non-terminal half line up.
+        const placement: "full" | "left" | "right" | null =
+          tab.id === activeTerminalTabId
+            ? split
+              ? "left"
+              : "full"
+            : tab.id === splitTerminalTabId
+              ? "right"
+              : null;
+        const visible = placement !== null;
         return (
           <div
             key={tab.id}
@@ -834,8 +1159,7 @@ function TerminalKeepaliveLayer({
             // useTerminalSession — which gates React state updates,
             // not GPU work.
             style={{
-              position: "absolute",
-              inset: 0,
+              ...paneBox(placement ?? "full"),
               display: "flex",
               flexDirection: "column",
               minHeight: 0,
@@ -852,6 +1176,7 @@ function TerminalKeepaliveLayer({
               worktree={worktree}
               tab={tab}
               isVisible={visible}
+              paneKey={placement === "right" ? "main2" : "main"}
             />
           </div>
         );
@@ -864,10 +1189,14 @@ function TerminalTabContent({
   worktree,
   tab,
   isVisible,
+  paneKey,
 }: {
   worktree: Worktree;
   tab: TerminalTab;
   isVisible: boolean;
+  /** Native pane this slot drives: "main" (full / left half) or
+   *  "main2" (the split's right half). */
+  paneKey: "main" | "main2";
 }) {
   const dispatch = useAppDispatch();
   const { settings } = useAppState();
@@ -883,6 +1212,7 @@ function TerminalTabContent({
       // Main-column terminals drive the native warpui surface; right-panel
       // agent terminals do not (single surface until multi-pane, M6).
       nativeSurface
+      paneKey={paneKey}
       // Re-seed agent state on remount so an in-flight claude/codex
       // session doesn't briefly drop back to shell mode (which paints
       // PromptInput under the agent's own UI) when the user navigates
@@ -1491,3 +1821,41 @@ function MissingWorktreeView({
   );
 }
 
+
+
+// TEMP DEBUG — remove before commit. Posts a 2s heartbeat of the pane
+// layout (state mirror + drop-zone children boxes + visibility) to a
+// local diagnostics listener so pane-rendering failures can be caught
+// in the exact moment they happen.
+{
+  const g = window as unknown as { __paneDump?: number; __paneState?: unknown };
+  if (g.__paneDump) window.clearInterval(g.__paneDump);
+  g.__paneDump = window.setInterval(() => {
+    const z = document.querySelector("[data-tab-drop-zone]");
+    const kids = z
+      ? Array.from(z.children).map((c) => {
+          const e = c as HTMLElement;
+          const r = e.getBoundingClientRect();
+          const cs = getComputedStyle(e);
+          return {
+            rect: { x: r.x, y: r.y, w: r.width, h: r.height },
+            vis: cs.visibility,
+            z: cs.zIndex,
+            kidCount: e.children.length,
+            text: (e.textContent ?? "").slice(0, 40),
+          };
+        })
+      : null;
+    const zr = z?.getBoundingClientRect();
+    fetch("http://localhost:8787/dump", {
+      method: "POST",
+      body: JSON.stringify({
+        t: new Date().toISOString(),
+        win: { w: window.innerWidth, h: window.innerHeight },
+        zone: zr ? { x: zr.x, y: zr.y, w: zr.width, h: zr.height } : null,
+        state: g.__paneState ?? null,
+        kids,
+      }),
+    }).catch(() => {});
+  }, 2000);
+}
diff --git a/src/shell/RightPanel.tsx b/src/shell/RightPanel.tsx
index 973c4be..6efb9d0 100644
--- a/src/shell/RightPanel.tsx
+++ b/src/shell/RightPanel.tsx
@@ -44,6 +44,7 @@ import { forgetPtys } from "@/terminal/sessionMemory";
  */
 export function RightPanel() {
   const worktree = useActiveWorktree();
+  const { rightPanelCollapsed } = useAppState();
   if (!worktree) return null;
   const splitPct = Math.min(80, Math.max(20, worktree.rightSplitPct));
   const collapsed = worktree.secondaryCollapsed === true;
@@ -62,7 +63,16 @@ export function RightPanel() {
       }}
     >
       <UpperPanel worktree={worktree} />
-      <SecondaryPanel worktree={worktree} collapsed={collapsed} />
+      <SecondaryPanel
+        worktree={worktree}
+        collapsed={collapsed}
+        // The whole right panel collapsing to 0 width must hide the native
+        // side terminal explicitly: the panel's min-content DOM overflows
+        // the 0-width column (layout-wise — overflow:hidden only clips
+        // paint), so a merely-clipped tracker would still measure a real
+        // box hanging off the window's right edge.
+        panelHidden={rightPanelCollapsed}
+      />
     </div>
   );
 }
@@ -1625,9 +1635,13 @@ function ChecksView() {
 function SecondaryPanel({
   worktree,
   collapsed,
+  panelHidden,
 }: {
   worktree: Worktree;
   collapsed: boolean;
+  /** True while the whole right panel is collapsed to 0 width — the
+   *  native side pane must report hidden (zero rect + pty detach). */
+  panelHidden: boolean;
 }) {
   const dispatch = useAppDispatch();
   return (
@@ -1734,7 +1748,9 @@ function SecondaryPanel({
       >
         <WarpSurfaceTracker
           paneKey="side"
-          visible={!collapsed && worktree.secondaryTab === "terminal"}
+          visible={
+            !collapsed && !panelHidden && worktree.secondaryTab === "terminal"
+          }
         />
         <AnimatePresence initial={false}>
           {!collapsed && (
diff --git a/src/shell/Sidebar.tsx b/src/shell/Sidebar.tsx
index 1a86589..8bce25f 100644
--- a/src/shell/Sidebar.tsx
+++ b/src/shell/Sidebar.tsx
@@ -5,7 +5,6 @@ import {
   useRef,
   useState,
   type CSSProperties,
-  type DragEvent,
   type MouseEvent,
   type ReactNode,
 } from "react";
@@ -60,6 +59,11 @@ import {
   worktreeRestore,
 } from "@/lib/worktrees";
 import { forgetPtys } from "@/terminal/sessionMemory";
+import {
+  beginPointerDrag,
+  DragGhost,
+  pointerDragActive,
+} from "@/lib/pointerDrag";
 import { useToast } from "@/primitives/Toast";
 import { useTrackAgentActivity } from "@/state/agentActivityStore";
 
@@ -273,69 +277,59 @@ function ProjectGroup({
     null,
   );
 
-  // Drag-reorder plumbing. The MIME type carries this project's id, so
-  // rows in OTHER repo groups never accept the drag — worktrees can
-  // only be rearranged within their own repository. Handlers are
-  // useCallback-stable so they don't defeat WorktreeRow's memo.
-  const dragMime = `application/x-goonware-worktree-${project.id}`.toLowerCase();
+  // Pointer-tracked drag-reorder plumbing (NOT HTML5 drag-and-drop —
+  // see lib/pointerDrag.tsx for why that can't work in this webview).
+  // The drop target is resolved by hit-testing the cursor against the
+  // rows' `data-wt-row` markers, and only ids belonging to THIS repo
+  // group are accepted — worktrees can only be rearranged within their
+  // own repository. Handlers are ref-backed and useCallback-stable so
+  // they don't defeat WorktreeRow's memo.
   const dragIdRef = useRef<string | null>(null);
   const [dropTarget, setDropTarget] = useState<{
     id: string;
     edge: "above" | "below";
   } | null>(null);
+  const dropTargetRef = useRef(dropTarget);
+  dropTargetRef.current = dropTarget;
+  const rowIdsRef = useRef<Set<string>>(new Set());
+  rowIdsRef.current = new Set(worktrees.map((w) => w.id));
 
-  const onRowDragStart = useCallback(
-    (e: DragEvent, id: string) => {
-      dragIdRef.current = id;
-      e.dataTransfer.effectAllowed = "move";
-      e.dataTransfer.setData(dragMime, id);
-    },
-    [dragMime],
-  );
-
-  const rowEdge = (e: DragEvent): "above" | "below" => {
-    const r = e.currentTarget.getBoundingClientRect();
-    return e.clientY < r.top + r.height / 2 ? "above" : "below";
-  };
-
-  const onRowDragOver = useCallback(
-    (e: DragEvent, id: string) => {
-      if (!e.dataTransfer.types.includes(dragMime)) return;
-      // Hovering the row being dragged: dropping there is a no-op, so
-      // don't preventDefault (no drop affordance) or draw a line that
-      // implies a move.
-      if (id === dragIdRef.current) {
-        setDropTarget(null);
-        return;
-      }
-      e.preventDefault();
-      e.dataTransfer.dropEffect = "move";
-      const edge = rowEdge(e);
-      setDropTarget((cur) =>
-        cur?.id === id && cur.edge === edge ? cur : { id, edge },
-      );
-    },
-    [dragMime],
-  );
+  const onRowDragStart = useCallback((id: string) => {
+    dragIdRef.current = id;
+  }, []);
 
-  const onRowDrop = useCallback(
-    (e: DragEvent, id: string) => {
-      if (!e.dataTransfer.types.includes(dragMime)) return;
-      e.preventDefault();
-      const dragged = dragIdRef.current ?? e.dataTransfer.getData(dragMime);
-      if (dragged && dragged !== id) {
-        dispatch({
-          type: "reorder-worktree",
-          id: dragged,
-          targetId: id,
-          edge: rowEdge(e),
-        });
-      }
-      dragIdRef.current = null;
+  const onRowDragMove = useCallback((x: number, y: number) => {
+    // The DragGhost is offset from the cursor and pointer-transparent,
+    // so elementFromPoint lands on the real row under the pointer.
+    const li = document
+      .elementFromPoint(x, y)
+      ?.closest<HTMLElement>("[data-wt-row]");
+    const id = li?.dataset.wtRow ?? null;
+    // Hovering the row being dragged (or a row of another repo, or
+    // empty space): no line — dropping there is a no-op.
+    if (!id || id === dragIdRef.current || !rowIdsRef.current.has(id)) {
       setDropTarget(null);
-    },
-    [dragMime, dispatch],
-  );
+      return;
+    }
+    const r = li!.getBoundingClientRect();
+    const edge = y < r.top + r.height / 2 ? "above" : "below";
+    setDropTarget((cur) =>
+      cur?.id === id && cur.edge === edge ? cur : { id, edge },
+    );
+  }, []);
+
+  const onRowDrop = useCallback(() => {
+    const dragged = dragIdRef.current;
+    const target = dropTargetRef.current;
+    if (dragged && target && dragged !== target.id) {
+      dispatch({
+        type: "reorder-worktree",
+        id: dragged,
+        targetId: target.id,
+        edge: target.edge,
+      });
+    }
+  }, [dispatch]);
 
   const onRowDragEnd = useCallback(() => {
     dragIdRef.current = null;
@@ -506,17 +500,7 @@ function ProjectGroup({
         )}
       </div>
 
-      <ul
-        style={{ listStyle: "none", margin: 0, padding: 0 }}
-        // Clear the drop line when the drag exits the row list (over
-        // the project header, History, outside the sidebar…) instead
-        // of leaving it stuck on the last row hovered.
-        onDragLeave={(e) => {
-          if (!e.currentTarget.contains(e.relatedTarget as Node | null)) {
-            setDropTarget(null);
-          }
-        }}
-      >
+      <ul style={{ listStyle: "none", margin: 0, padding: 0 }}>
         {worktrees.map((w) => (
           // `isRunning` is derived INSIDE WorktreeRow via the
           // singleton `agentActivityStore` (Claude transcript-mtime
@@ -537,7 +521,7 @@ function ProjectGroup({
             archiveBehavior={state.settings.archiveBehavior}
             deleteBranchOnArchive={state.settings.deleteBranchOnArchive}
             onRowDragStart={onRowDragStart}
-            onRowDragOver={onRowDragOver}
+            onRowDragMove={onRowDragMove}
             onRowDrop={onRowDrop}
             onRowDragEnd={onRowDragEnd}
             dropEdge={dropTarget?.id === w.id ? dropTarget.edge : null}
@@ -818,7 +802,7 @@ const WorktreeRow = memo(function WorktreeRowImpl({
   archiveBehavior,
   deleteBranchOnArchive,
   onRowDragStart,
-  onRowDragOver,
+  onRowDragMove,
   onRowDrop,
   onRowDragEnd,
   dropEdge,
@@ -836,11 +820,11 @@ const WorktreeRow = memo(function WorktreeRowImpl({
   archiveBehavior: "ask" | "stash" | "force";
   /** Per-Git-settings tab. Drilled in for the same memo reasons. */
   deleteBranchOnArchive: boolean;
-  /** Drag-reorder hooks from the owning ProjectGroup — stable
+  /** Pointer drag-reorder hooks from the owning ProjectGroup — stable
       (useCallback) so they don't defeat the memo above. */
-  onRowDragStart: (e: DragEvent, id: string) => void;
-  onRowDragOver: (e: DragEvent, id: string) => void;
-  onRowDrop: (e: DragEvent, id: string) => void;
+  onRowDragStart: (id: string) => void;
+  onRowDragMove: (x: number, y: number) => void;
+  onRowDrop: () => void;
   onRowDragEnd: () => void;
   /** Where the in-flight drag would land relative to this row — drawn
       as a 2px accent line. Null when this row isn't the drop target. */
@@ -855,6 +839,11 @@ const WorktreeRow = memo(function WorktreeRowImpl({
   // rerender (the others stay memoized).
   const isRunning = useTrackAgentActivity(worktree.id, worktree.path);
   const dispatch = useAppDispatch();
+  // Cursor position of an in-flight reorder drag (null = not dragging).
+  // Doubles as the mount flag for the floating DragGhost label.
+  const [dragGhost, setDragGhost] = useState<{ x: number; y: number } | null>(
+    null,
+  );
   // Subscribed to state so the archive handler can look up the
   // worktree's terminal-tab pty_ids and feed them to `forgetPtys`.
   // The earlier memo discipline (drill `archiveBehavior` /
@@ -1080,23 +1069,15 @@ const WorktreeRow = memo(function WorktreeRowImpl({
   return (
     <li
       ref={rowRef}
-      // The icon-picker dialog renders inline inside this li (it does
-      // not portal) — a draggable ancestor turns its text-selection
-      // drags into row drags in WebKit, so suspend dragging while the
-      // dialog is open.
-      draggable={!pickerOpen}
-      onDragStart={(e) => {
-        // A drag kills hover intent — never pop the hover card mid-drag.
-        cancelTimers();
-        setCardAnchor(null);
-        setHovering(false);
-        onRowDragStart(e, worktree.id);
-      }}
-      onDragOver={(e) => onRowDragOver(e, worktree.id)}
-      onDrop={(e) => onRowDrop(e, worktree.id)}
-      onDragEnd={onRowDragEnd}
+      // Drop-target marker for the pointer drag's elementFromPoint
+      // hit-test (see ProjectGroup.onRowDragMove).
+      data-wt-row={worktree.id}
       style={{ position: "relative" }}
       onMouseEnter={() => {
+        // Rows swept over during a reorder drag must not light up or
+        // arm the hover card — pointer drags don't suppress mouseenter
+        // the way a native drag session did.
+        if (pointerDragActive()) return;
         setHovering(true);
         openCard();
       }}
@@ -1121,11 +1102,44 @@ const WorktreeRow = memo(function WorktreeRowImpl({
           }}
         />
       )}
+      {dragGhost && (
+        <DragGhost x={dragGhost.x} y={dragGhost.y} label={worktree.name} />
+      )}
       <button
         type="button"
         onClick={onSelect}
         onDoubleClick={onDoubleClick}
         onContextMenu={onContextMenu}
+        // Pointer-tracked reorder drag. A plain click never crosses the
+        // movement threshold, so select/double-click keep working; once
+        // the threshold IS crossed, beginPointerDrag swallows the
+        // trailing click so a drop doesn't also activate this row.
+        onMouseDown={(e) => {
+          if (pickerOpen) return;
+          // Only arm from the row surface itself, not the inline action
+          // buttons that appear on hover (archive, settings, …).
+          if ((e.target as HTMLElement).closest("button") !== e.currentTarget)
+            return;
+          beginPointerDrag(e, {
+            onStart: (x, y) => {
+              // A drag kills hover intent — never pop the card mid-drag.
+              cancelTimers();
+              setCardAnchor(null);
+              setHovering(false);
+              onRowDragStart(worktree.id);
+              setDragGhost({ x, y });
+            },
+            onMove: (x, y) => {
+              setDragGhost({ x, y });
+              onRowDragMove(x, y);
+            },
+            onDrop: () => onRowDrop(),
+            onEnd: () => {
+              onRowDragEnd();
+              setDragGhost(null);
+            },
+          });
+        }}
         style={rowStyle}
         // Active rows lock to `activeBg` — hover does NOT override.
         // Without this guard the row visibly flickers when the user
diff --git a/src/state/reducer.test.ts b/src/state/reducer.test.ts
index 2841b61..a3e504e 100644
--- a/src/state/reducer.test.ts
+++ b/src/state/reducer.test.ts
@@ -248,3 +248,149 @@ describe("reorder-worktree", () => {
     expect(order(out, "p2")).toEqual(["x", "y"]);
   });
 });
+
+describe("split panes", () => {
+  /** Worktree with three commit tabs t1 (active), t2, t3. */
+  const seeded = (): AppState => {
+    let s = seed([worktree("w1", "p1")]);
+    s = open(s, commitTab("t1", "w1", "aaa111"));
+    s = open(s, commitTab("t2", "w1", "bbb222"));
+    s = open(s, commitTab("t3", "w1", "ccc333"));
+    return reducer(s, { type: "select-tab", worktreeId: "w1", id: "t1" });
+  };
+
+  test("dropping a non-active tab on the right splits", () => {
+    const s = reducer(seeded(), {
+      type: "split-tab",
+      worktreeId: "w1",
+      id: "t2",
+      side: "right",
+    });
+    expect(s.worktrees.w1.activeTabId).toBe("t1");
+    expect(s.worktrees.w1.splitTabId).toBe("t2");
+  });
+
+  test("dropping the ACTIVE tab on the right backfills the left half", () => {
+    const s = reducer(seeded(), {
+      type: "split-tab",
+      worktreeId: "w1",
+      id: "t1",
+      side: "right",
+    });
+    expect(s.worktrees.w1.splitTabId).toBe("t1");
+    expect(s.worktrees.w1.activeTabId).toBe("t3");
+  });
+
+  test("a single-tab worktree cannot split with itself", () => {
+    let s = seed([worktree("w1", "p1")]);
+    s = open(s, commitTab("t1", "w1", "aaa111"));
+    const out = reducer(s, {
+      type: "split-tab",
+      worktreeId: "w1",
+      id: "t1",
+      side: "right",
+    });
+    expect(out).toBe(s);
+  });
+
+  test("dropping a tab on the left of an unsplit view splits (old active → right)", () => {
+    const s = reducer(seeded(), {
+      type: "split-tab",
+      worktreeId: "w1",
+      id: "t2",
+      side: "left",
+    });
+    expect(s.worktrees.w1.activeTabId).toBe("t2");
+    expect(s.worktrees.w1.splitTabId).toBe("t1");
+  });
+
+  test("dropping the split tab on the left swaps halves", () => {
+    let s = reducer(seeded(), {
+      type: "split-tab",
+      worktreeId: "w1",
+      id: "t2",
+      side: "right",
+    });
+    s = reducer(s, {
+      type: "split-tab",
+      worktreeId: "w1",
+      id: "t2",
+      side: "left",
+    });
+    expect(s.worktrees.w1.activeTabId).toBe("t2");
+    expect(s.worktrees.w1.splitTabId).toBe("t1");
+  });
+
+  test("selecting the split tab in the strip swaps instead of duplicating", () => {
+    let s = reducer(seeded(), {
+      type: "split-tab",
+      worktreeId: "w1",
+      id: "t2",
+      side: "right",
+    });
+    s = reducer(s, { type: "select-tab", worktreeId: "w1", id: "t2" });
+    expect(s.worktrees.w1.activeTabId).toBe("t2");
+    expect(s.worktrees.w1.splitTabId).toBe("t1");
+  });
+
+  test("re-opening (dedup path) the split tab's target also swaps", () => {
+    let s = reducer(seeded(), {
+      type: "split-tab",
+      worktreeId: "w1",
+      id: "t2",
+      side: "right",
+    });
+    s = open(s, commitTab("t9", "w1", "bbb222")); // dedups onto t2
+    expect(s.worktrees.w1.activeTabId).toBe("t2");
+    expect(s.worktrees.w1.splitTabId).toBe("t1");
+  });
+
+  test("unsplit keeping the left half", () => {
+    let s = reducer(seeded(), {
+      type: "split-tab",
+      worktreeId: "w1",
+      id: "t2",
+      side: "right",
+    });
+    s = reducer(s, { type: "unsplit", worktreeId: "w1", keep: "left" });
+    expect(s.worktrees.w1.activeTabId).toBe("t1");
+    expect(s.worktrees.w1.splitTabId).toBeNull();
+  });
+
+  test("unsplit keeping the right half", () => {
+    let s = reducer(seeded(), {
+      type: "split-tab",
+      worktreeId: "w1",
+      id: "t2",
+      side: "right",
+    });
+    s = reducer(s, { type: "unsplit", worktreeId: "w1", keep: "right" });
+    expect(s.worktrees.w1.activeTabId).toBe("t2");
+    expect(s.worktrees.w1.splitTabId).toBeNull();
+  });
+
+  test("closing the split tab clears the split", () => {
+    let s = reducer(seeded(), {
+      type: "split-tab",
+      worktreeId: "w1",
+      id: "t2",
+      side: "right",
+    });
+    s = reducer(s, { type: "close-tab", id: "t2" });
+    expect(s.worktrees.w1.activeTabId).toBe("t1");
+    expect(s.worktrees.w1.splitTabId).toBeNull();
+    expect(s.worktrees.w1.tabIds).toEqual(["t1", "t3"]);
+  });
+
+  test("closing the active tab promotes the split tab", () => {
+    let s = reducer(seeded(), {
+      type: "split-tab",
+      worktreeId: "w1",
+      id: "t2",
+      side: "right",
+    });
+    s = reducer(s, { type: "close-tab", id: "t1" });
+    expect(s.worktrees.w1.activeTabId).toBe("t2");
+    expect(s.worktrees.w1.splitTabId).toBeNull();
+  });
+});
diff --git a/src/state/reducer.ts b/src/state/reducer.ts
index 5438250..5f82313 100644
--- a/src/state/reducer.ts
+++ b/src/state/reducer.ts
@@ -433,7 +433,16 @@ export function reducer(state: AppState, action: AppAction): AppState {
               action.activate !== false
                 ? {
                     ...state.worktrees,
-                    [w.id]: { ...w, activeTabId: existing.id },
+                    [w.id]: {
+                      ...w,
+                      activeTabId: existing.id,
+                      // Focusing the tab that occupies the split pane
+                      // swaps halves — same rule as `select-tab`.
+                      splitTabId:
+                        w.splitTabId === existing.id
+                          ? w.activeTabId
+                          : w.splitTabId ?? null,
+                    },
                   }
                 : state.worktrees,
           };
@@ -458,24 +467,85 @@ export function reducer(state: AppState, action: AppAction): AppState {
       const w = state.worktrees[t.worktreeId];
       if (!w) return state;
       const tabIds = w.tabIds.filter((id) => id !== action.id);
-      const activeTabId =
-        w.activeTabId === action.id
-          ? tabIds[tabIds.length - 1] ?? null
-          : w.activeTabId;
+      let splitTabId = w.splitTabId === action.id ? null : w.splitTabId ?? null;
+      let activeTabId = w.activeTabId;
+      if (w.activeTabId === action.id) {
+        // Closing the active (left) tab of a split promotes the split
+        // tab to active rather than jumping to an arbitrary neighbour.
+        if (splitTabId) {
+          activeTabId = splitTabId;
+          splitTabId = null;
+        } else {
+          activeTabId = tabIds[tabIds.length - 1] ?? null;
+        }
+      }
+      if (splitTabId === activeTabId) splitTabId = null;
       const { [action.id]: _removed, ...tabs } = state.tabs;
       return {
         ...state,
         tabs,
         worktrees: {
           ...state.worktrees,
-          [w.id]: { ...w, tabIds, activeTabId },
+          [w.id]: { ...w, tabIds, activeTabId, splitTabId },
         },
       };
     }
 
     case "select-tab": {
-      return updateWorktree(state, action.worktreeId, () => ({
+      return updateWorktree(state, action.worktreeId, (w) => ({
         activeTabId: action.id,
+        // Selecting the tab that lives in the split pane swaps the two
+        // halves (both stay visible) instead of rendering one tab twice.
+        splitTabId:
+          w.splitTabId === action.id ? w.activeTabId : w.splitTabId ?? null,
+      }));
+    }
+
+    case "split-tab": {
+      const w = state.worktrees[action.worktreeId];
+      if (!w) return state;
+      const t = state.tabs[action.id];
+      if (!t || t.worktreeId !== w.id || !w.tabIds.includes(action.id))
+        return state;
+      const oldActive = w.activeTabId;
+      const oldSplit = w.splitTabId ?? null;
+      if (action.side === "right") {
+        // Dragged tab becomes the split pane. If it was the active tab
+        // the left half needs a different occupant: the previous split
+        // tab if there was one, otherwise the nearest other tab. A
+        // single-tab worktree can't split with itself — no-op.
+        let activeTabId = oldActive;
+        if (action.id === oldActive) {
+          const fallback =
+            oldSplit ?? w.tabIds.filter((id) => id !== action.id).pop() ?? null;
+          if (!fallback) return state;
+          activeTabId = fallback;
+        }
+        return updateWorktree(state, w.id, () => ({
+          activeTabId,
+          splitTabId: action.id,
+        }));
+      }
+      // side === "left": dragged tab becomes the active tab. Keep the
+      // split (swap if the dragged tab WAS the split tab); when unsplit,
+      // the previous active tab moves to the right half so the drop
+      // always produces/keeps a split.
+      if (action.id === oldActive && oldSplit) return state;
+      const splitTabId =
+        action.id === oldSplit ? oldActive : oldSplit ?? oldActive;
+      if (!splitTabId || splitTabId === action.id) return state;
+      return updateWorktree(state, w.id, () => ({
+        activeTabId: action.id,
+        splitTabId,
+      }));
+    }
+
+    case "unsplit": {
+      const w = state.worktrees[action.worktreeId];
+      if (!w || !w.splitTabId) return state;
+      return updateWorktree(state, w.id, () => ({
+        activeTabId: action.keep === "right" ? w.splitTabId : w.activeTabId,
+        splitTabId: null,
       }));
     }
 
diff --git a/src/state/types.ts b/src/state/types.ts
index 9ffd705..1a7dfcc 100644
--- a/src/state/types.ts
+++ b/src/state/types.ts
@@ -212,6 +212,14 @@ export interface Worktree {
   /** Tabs (terminal / diff / markdown) in the main column for this worktree. */
   tabIds: TabId[];
   activeTabId: TabId | null;
+  /**
+   * Second pane of the 50/50 main-column split. Null/undefined = no
+   * split (the active tab fills the column). Set by dropping a tab
+   * from the strip onto the right half of the content area. Invariant
+   * (reducer-enforced): never equal to `activeTabId` — the same tab
+   * can't render in both halves.
+   */
+  splitTabId?: TabId | null;
 
   /** Right-panel selected tab and split position. */
   rightPanel: RightPanelTab;
@@ -615,6 +623,19 @@ export type AppAction =
   | { type: "open-tab"; tab: Tab; activate?: boolean }
   | { type: "close-tab"; id: TabId }
   | { type: "select-tab"; worktreeId: WorktreeId; id: TabId }
+  /** Drop a tab onto one half of the content area. `side: "right"`
+      puts it in the split pane (creating the split); `side: "left"`
+      makes it the active tab. Either way the reducer preserves the
+      activeTabId ≠ splitTabId invariant (swapping when needed). */
+  | {
+      type: "split-tab";
+      worktreeId: WorktreeId;
+      id: TabId;
+      side: "left" | "right";
+    }
+  /** Collapse the split back to one full-width pane. `keep` names the
+      half whose tab stays visible (as the active tab). */
+  | { type: "unsplit"; worktreeId: WorktreeId; keep: "left" | "right" }
   | { type: "update-tab"; id: TabId; patch: Partial<Tab> }
   | { type: "set-tab-summary"; id: TabId; summary: string }
 
diff --git a/src/terminal/BlockTerminal.tsx b/src/terminal/BlockTerminal.tsx
index c0b2aa3..18ae77b 100644
--- a/src/terminal/BlockTerminal.tsx
+++ b/src/terminal/BlockTerminal.tsx
@@ -89,10 +89,11 @@ interface Props {
    * unset so they don't hijack the single native surface (multi-pane is M6).
    */
   nativeSurface?: boolean;
-  /** Which native pane this terminal drives: "main" (main column) or "side"
-   *  (right-panel). Threaded into every native command so the two panes' grids
+  /** Which native pane this terminal drives: "main" (main column / left half
+   *  of a split), "main2" (right half of a main-column split) or "side"
+   *  (right-panel). Threaded into every native command so the panes' grids
    *  / scroll / selection stay independent on the one embedded surface. */
-  paneKey?: "main" | "side";
+  paneKey?: "main" | "side" | "main2";
   /** Command to spawn (e.g. "zsh", "claude", "codex"). */
   command: string;
   args?: string[];
@@ -1518,9 +1519,15 @@ export function BlockTerminal({
       // does it (a horizontal ClippedScrollable, gated on grid-wider-than-pane,
       // fed by `term_native_hscroll` — see warp_term.rs). Either way the PTY must
       // believe it's wide, so size it the same on both paths.
-      const cols = allowHorizontalScroll
-        ? Math.max(fitCols, PAN_MIN_COLS)
-        : fitCols;
+      // The wide-PTY pin is a SHELL affordance (`ls` in columns + pan).
+      // A foregrounded agent (claude/codex) re-wraps its whole TUI on
+      // SIGWINCH, so pinning it wide just paints lines past the narrow
+      // pane that then have to be clipped/panned — size agents to the
+      // real pane width so their text wraps to the space it actually has.
+      const cols =
+        allowHorizontalScroll && !agentMode && !foregroundIsAgent
+          ? Math.max(fitCols, PAN_MIN_COLS)
+          : fitCols;
       return { rows, cols };
     };
 
diff --git a/src/terminal/WarpSurfaceTracker.tsx b/src/terminal/WarpSurfaceTracker.tsx
index 4826b86..a279f28 100644
--- a/src/terminal/WarpSurfaceTracker.tsx
+++ b/src/terminal/WarpSurfaceTracker.tsx
@@ -19,11 +19,24 @@ import { invoke } from "@tauri-apps/api/core";
 export function WarpSurfaceTracker({
   visible,
   paneKey = "main",
+  reportWhenHidden = false,
 }: {
   visible: boolean;
-  /** Which native pane this tracker reports for: "main" (main column) or "side"
-   *  (right panel). The surface covers the combined box of both. */
-  paneKey?: "main" | "side";
+  /** Which native pane this tracker reports for: "main" (main column, or the
+   *  left half of a main-column split), "main2" (the split's right half) or
+   *  "side" (right panel). The surface covers the combined box of all placed
+   *  panes. */
+  paneKey?: "main" | "side" | "main2";
+  /**
+   * Keep reporting the real measured rect even while `visible` is false
+   * (instead of the zero rect that hides the pane). Used by the MAIN pane in
+   * split layouts: its box must stay accurate when a non-terminal tab is
+   * showing, or the Rust side's retained rect goes stale (e.g. full-width
+   * from before the split opened) and paints over the neighbouring pane.
+   * The pty is still detached while hidden, so the pane renders black behind
+   * the opaque non-terminal DOM.
+   */
+  reportWhenHidden?: boolean;
 }) {
   const ref = useRef<HTMLDivElement>(null);
 
@@ -36,37 +49,90 @@ export function WarpSurfaceTracker({
     }
   }, [visible, paneKey]);
 
+  // Unmount cleanup: zero the rect + detach so a pane whose tracker leaves
+  // the tree (the split's right half after an unsplit) doesn't keep a stale
+  // rect that would leave a dead column composited over the re-widened main
+  // pane. The main pane ignores zero-rect reports Rust-side (deliberate
+  // retention), so this is a no-op for it.
+  useEffect(() => {
+    return () => {
+      invoke("term_surface_set_rect", {
+        paneKey,
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 0,
+      }).catch(() => {});
+      invoke("term_native_detach", { paneKey }).catch(() => {});
+    };
+  }, [paneKey]);
+
   useEffect(() => {
     const el = ref.current;
     if (!el) return;
 
     let raf = 0;
-    const report = () => {
-      const r = visible ? el.getBoundingClientRect() : null;
+    // Last rect actually sent, so the poll below can re-check cheaply
+    // without spamming IPC. Seeded to a sentinel so the first report
+    // always sends.
+    let sent = "";
+    const report = (force = false) => {
+      const r = visible || reportWhenHidden ? el.getBoundingClientRect() : null;
       // CSS px relative to the webview's top-left (== window content top-left);
       // Rust converts to a bottom-left screen frame for the child window.
-      const rect = r
-        ? { x: r.left, y: r.top, width: r.width, height: r.height }
-        : { x: 0, y: 0, width: 0, height: 0 };
+      //
+      // Clamp to the window box. The native surface composites BELOW the
+      // webview, so any part of a measured rect outside the window is
+      // meaningless — but reported as-is it walks the embedded child window
+      // (which macOS does NOT clip to its parent) out past the app's edge.
+      // The concrete case: collapsing the right panel to 0 width leaves the
+      // panel's min-content-sized DOM overflowing off the window's right
+      // edge (overflow:hidden clips paint, not layout), and this tracker
+      // would report that off-window box as a real pane — the side terminal
+      // then "shoots out" beyond the window. An off-window or fully-clipped
+      // rect clamps to zero, which hides the pane.
+      let rect = { x: 0, y: 0, width: 0, height: 0 };
+      if (r) {
+        const left = Math.max(r.left, 0);
+        const top = Math.max(r.top, 0);
+        const right = Math.min(r.right, window.innerWidth);
+        const bottom = Math.min(r.bottom, window.innerHeight);
+        if (right - left > 1 && bottom - top > 1) {
+          rect = { x: left, y: top, width: right - left, height: bottom - top };
+        }
+      }
+      const key = `${rect.x},${rect.y},${rect.width},${rect.height}`;
+      if (!force && key === sent) return;
+      sent = key;
       // No-op on non-macOS (command absent) — swallow.
       invoke("term_surface_set_rect", { paneKey, ...rect }).catch(() => {});
     };
     const schedule = () => {
       cancelAnimationFrame(raf);
-      raf = requestAnimationFrame(report);
+      raf = requestAnimationFrame(() => report());
     };
 
-    schedule();
+    report(true);
     const ro = new ResizeObserver(schedule);
     ro.observe(el);
     window.addEventListener("resize", schedule);
+    // Self-healing backstop: the RO + single-rAF chain above can drop a
+    // report (WKWebView pauses rAF while the window is occluded, and a
+    // layout flip like split↔full racing a heavy commit has been seen
+    // to leave the native rect stale — terminal stuck at half width,
+    // the rest of the hole showing the black host window). Re-checking
+    // on a slow interval costs one getBoundingClientRect and sends
+    // nothing while the rect is unchanged, but guarantees the native
+    // surface converges to the real DOM box within ~300ms.
+    const poll = window.setInterval(() => report(), 300);
 
     return () => {
       cancelAnimationFrame(raf);
       ro.disconnect();
       window.removeEventListener("resize", schedule);
+      window.clearInterval(poll);
     };
-  }, [visible, paneKey]);
+  }, [visible, paneKey, reportWhenHidden]);
 
   return (
     <div

From 0eae0a5358409f968dba9f391ec461f81eac1bea Mon Sep 17 00:00:00 2001
From: raeedz <raeedz@gmail.com>
Date: Sat, 4 Jul 2026 14:05:27 -0700
Subject: [PATCH 6/9] Add customizable "New worktree" dialog (name, color,
 icon)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace ⌘N's auto-created landmark-named worktree with a dialog for
choosing the name, sidebar color, and icon before creation.
---
 src/hooks/useKeyboardShortcuts.ts  |  43 +--
 src/shell/AppShell.tsx             |   2 +
 src/shell/CreateWorktreeDialog.tsx | 430 +++++++++++++++++++++++++++++
 src/shell/IconPickerDialog.tsx     |   6 +-
 src/shell/Sidebar.tsx              |  34 +--
 src/state/reducer.ts               |   5 +
 src/state/types.ts                 |   4 +
 7 files changed, 455 insertions(+), 69 deletions(-)
 create mode 100644 src/shell/CreateWorktreeDialog.tsx

diff --git a/src/hooks/useKeyboardShortcuts.ts b/src/hooks/useKeyboardShortcuts.ts
index e5dfe49..2906935 100644
--- a/src/hooks/useKeyboardShortcuts.ts
+++ b/src/hooks/useKeyboardShortcuts.ts
@@ -6,13 +6,7 @@ import {
   useAppState,
 } from "@/state/AppState";
 import { openProjectDialog } from "@/lib/projectDialog";
-import {
-  nextAutoBranch,
-  primaryTerminalTab,
-  worktreeCreate,
-} from "@/lib/worktrees";
 import { forgetPtys } from "@/terminal/sessionMemory";
-import { applyBranchPrefix, projectSettings } from "@/state/types";
 
 /**
  * Match a digit press regardless of modifier-induced char shifting.
@@ -172,38 +166,15 @@ export function useKeyboardShortcuts() {
         return;
       }
 
-      // ⌘N — auto-create a new worktree in the active project. No
-      // prompt: the branch is named via the random landmark pool.
+      // ⌘N — open the "New worktree" dialog for the active project.
+      // The dialog suggests a landmark name and lets the user rename
+      // it / pick a color and icon before creation.
       if (cmd && !shift && !e.altKey && e.key.toLowerCase() === "n" && project) {
         e.preventDefault();
-        const base = nextAutoBranch(project.id, state);
-        const branch = applyBranchPrefix(
-          base,
-          state.settings.branchPrefixMode,
-          state.settings.githubUsername,
-          state.settings.customBranchPrefix,
-        );
-        const proj = project;
-        const cfg = projectSettings(proj);
-        void (async () => {
-          try {
-            const w = await worktreeCreate(
-              proj.id,
-              proj.path,
-              branch,
-              base,
-              {
-                baseRef: cfg.baseBranch,
-                filesToCopy: cfg.filesToCopy,
-                setupScript: cfg.setupScript,
-              },
-            );
-            dispatch({ type: "add-worktree", worktree: w });
-            dispatch({ type: "open-tab", tab: primaryTerminalTab(w) });
-          } catch (err) {
-            window.alert(`Worktree creation failed: ${err}`);
-          }
-        })();
+        dispatch({
+          type: "set-create-worktree-open",
+          projectId: project.id,
+        });
         return;
       }
 
diff --git a/src/shell/AppShell.tsx b/src/shell/AppShell.tsx
index 82dc126..a92bec7 100644
--- a/src/shell/AppShell.tsx
+++ b/src/shell/AppShell.tsx
@@ -4,6 +4,7 @@ import { Sidebar } from "./Sidebar";
 import { MainColumn } from "./MainColumn";
 import { RightPanel } from "./RightPanel";
 import { CreatePRDialog } from "./CreatePRDialog";
+import { CreateWorktreeDialog } from "./CreateWorktreeDialog";
 import { SettingsView } from "./SettingsView";
 import { UpdaterToast } from "./UpdaterToast";
 import { SearchOverlay } from "@/palette/SearchOverlay";
@@ -242,6 +243,7 @@ export function AppShell() {
 
       <SearchOverlay />
       <CreatePRDialog />
+      <CreateWorktreeDialog />
       <SettingsView />
       <UpdaterToast />
     </div>
diff --git a/src/shell/CreateWorktreeDialog.tsx b/src/shell/CreateWorktreeDialog.tsx
new file mode 100644
index 0000000..f6ae97f
--- /dev/null
+++ b/src/shell/CreateWorktreeDialog.tsx
@@ -0,0 +1,430 @@
+import {
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  type CSSProperties,
+} from "react";
+import { motion, AnimatePresence } from "motion/react";
+import { useAppDispatch, useAppState } from "@/state/AppState";
+import {
+  applyBranchPrefix,
+  projectSettings,
+  TAG_IDS,
+  type Project,
+  type TagId,
+} from "@/state/types";
+import {
+  nextAutoBranch,
+  primaryTerminalTab,
+  worktreeCreate,
+} from "@/lib/worktrees";
+import { PICKER_ICONS } from "@/design/picker-icons";
+import { ColorSwatch, IconCell, SearchGlyph } from "@/shell/IconPickerDialog";
+import { useToast } from "@/primitives/Toast";
+
+/**
+ * "New worktree" dialog — opened by ⌘N and the sidebar + button via
+ * `state.createWorktreeProjectId`. Lets the user name the worktree
+ * (instead of the auto-assigned landmark name) and pick its sidebar
+ * color + icon before it's created. Enter creates, ESC cancels, and
+ * leaving the name untouched keeps the suggested landmark name.
+ */
+export function CreateWorktreeDialog() {
+  const state = useAppState();
+  const projectId = state.createWorktreeProjectId;
+  const project = projectId ? state.projects[projectId] : null;
+
+  return (
+    <AnimatePresence>
+      {project && (
+        // Keyed by project so reopening always mounts a fresh panel
+        // with a new name suggestion and cleared color/icon drafts.
+        <DialogPanel key={project.id} project={project} />
+      )}
+    </AnimatePresence>
+  );
+}
+
+/** Reduce free-typed input to a git-legal branch component. */
+function sanitizeBranchBase(raw: string): string {
+  return raw
+    .trim()
+    .toLowerCase()
+    .replace(/\s+/g, "-")
+    .replace(/[^a-z0-9._-]+/g, "-")
+    .replace(/\.+/g, ".")
+    .replace(/-{2,}/g, "-")
+    .replace(/^[-.]+|[-.]+$/g, "");
+}
+
+function DialogPanel({ project }: { project: Project }) {
+  const state = useAppState();
+  const dispatch = useAppDispatch();
+  const toast = useToast();
+
+  // Suggested landmark name, fixed for the lifetime of this open.
+  const [suggestion] = useState(() => nextAutoBranch(project.id, state));
+  const [draftName, setDraftName] = useState(suggestion);
+  const [color, setColor] = useState<TagId | undefined>(undefined);
+  const [iconName, setIconName] = useState<string | undefined>(undefined);
+  const [query, setQuery] = useState("");
+  const [busy, setBusy] = useState(false);
+
+  const nameRef = useRef<HTMLInputElement>(null);
+  const backdropMouseDownRef = useRef(false);
+  const busyRef = useRef(false);
+
+  const close = () => {
+    if (busyRef.current) return;
+    dispatch({ type: "set-create-worktree-open", projectId: null });
+  };
+  const closeRef = useRef(close);
+  useEffect(() => {
+    closeRef.current = close;
+  });
+
+  useEffect(() => {
+    // Pre-select the suggestion so typing immediately replaces it —
+    // accepting the auto-name costs nothing, renaming costs no clicks.
+    const t = window.setTimeout(() => {
+      nameRef.current?.focus();
+      nameRef.current?.select();
+    }, 80);
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === "Escape") closeRef.current();
+    };
+    window.addEventListener("keydown", onKey);
+    return () => {
+      window.clearTimeout(t);
+      window.removeEventListener("keydown", onKey);
+    };
+  }, []);
+
+  const base = sanitizeBranchBase(draftName) || suggestion;
+  const branch = applyBranchPrefix(
+    base,
+    state.settings.branchPrefixMode,
+    state.settings.githubUsername,
+    state.settings.customBranchPrefix,
+  );
+
+  const filtered = useMemo(() => {
+    const q = query.trim().toLowerCase();
+    if (!q) return PICKER_ICONS;
+    return PICKER_ICONS.filter(
+      (p) =>
+        p.name.toLowerCase().includes(q) || p.label.toLowerCase().includes(q),
+    );
+  }, [query]);
+
+  const create = async () => {
+    if (busyRef.current) return;
+    busyRef.current = true;
+    setBusy(true);
+    const label = draftName.trim() || suggestion;
+    const cfg = projectSettings(project);
+    try {
+      const w = await worktreeCreate(project.id, project.path, branch, label, {
+        baseRef: cfg.baseBranch,
+        filesToCopy: cfg.filesToCopy,
+        setupScript: cfg.setupScript,
+      });
+      dispatch({ type: "add-worktree", worktree: w });
+      if (color || iconName) {
+        dispatch({
+          type: "update-worktree",
+          id: w.id,
+          patch: { color, iconName },
+        });
+      }
+      dispatch({ type: "open-tab", tab: primaryTerminalTab(w) });
+      busyRef.current = false;
+      dispatch({ type: "set-create-worktree-open", projectId: null });
+    } catch (err) {
+      busyRef.current = false;
+      setBusy(false);
+      toast.show({ message: `Worktree creation failed: ${err}` });
+    }
+  };
+
+  const sectionLabel: CSSProperties = {
+    fontSize: "var(--text-xs)",
+    textTransform: "uppercase",
+    letterSpacing: "var(--tracking-caps)",
+    color: "var(--text-tertiary)",
+    fontWeight: "var(--weight-semibold)",
+  };
+
+  return (
+    <motion.div
+      key="create-worktree-backdrop"
+      initial={{ opacity: 0 }}
+      animate={{ opacity: 1 }}
+      exit={{ opacity: 0 }}
+      transition={{ duration: 0.16 }}
+      onMouseDown={(e) => {
+        if (e.target === e.currentTarget) backdropMouseDownRef.current = true;
+      }}
+      onMouseUp={(e) => {
+        if (backdropMouseDownRef.current && e.target === e.currentTarget) {
+          close();
+        }
+        backdropMouseDownRef.current = false;
+      }}
+      style={{
+        position: "fixed",
+        inset: 0,
+        backgroundColor: "var(--backdrop)",
+        zIndex: 10_000,
+        display: "grid",
+        placeItems: "start center",
+        paddingTop: "min(15vh, 140px)",
+      }}
+    >
+      <motion.div
+        key="create-worktree-panel"
+        initial={{ opacity: 0, scale: 0.985, y: 4 }}
+        animate={{ opacity: 1, scale: 1, y: 0 }}
+        exit={{ opacity: 0, y: -4 }}
+        transition={{ duration: 0.22, ease: [0.16, 1, 0.3, 1] }}
+        onMouseDown={(e) => e.stopPropagation()}
+        onMouseUp={(e) => e.stopPropagation()}
+        onClick={(e) => e.stopPropagation()}
+        style={{
+          width: "min(640px, 92vw)",
+          maxHeight: "78vh",
+          display: "grid",
+          gridTemplateRows: "auto auto auto 1fr auto",
+          backgroundColor: "var(--surface-2)",
+          border: "var(--border-1)",
+          borderRadius: "var(--radius-lg)",
+          boxShadow:
+            "0 24px 60px -16px rgba(0,0,0,0.65), 0 4px 10px rgba(0,0,0,0.4)",
+          overflow: "hidden",
+        }}
+      >
+        <header
+          style={{
+            padding: "var(--space-3) var(--space-4) var(--space-3)",
+            display: "grid",
+            gap: 6,
+          }}
+        >
+          <span style={sectionLabel}>
+            New worktree · {project.name}
+          </span>
+          <input
+            ref={nameRef}
+            type="text"
+            value={draftName}
+            spellCheck={false}
+            onChange={(e) => setDraftName(e.target.value)}
+            onKeyDown={(e) => {
+              if (e.key === "Enter") {
+                e.preventDefault();
+                void create();
+              }
+            }}
+            placeholder={suggestion}
+            style={{
+              width: "100%",
+              height: 40,
+              padding: "0 12px",
+              backgroundColor: "var(--surface-1)",
+              border: "var(--border-1)",
+              borderRadius: "var(--radius-sm)",
+              color: "var(--text-primary)",
+              fontFamily: "var(--font-sans)",
+              fontSize: "var(--text-lg)",
+              fontWeight: "var(--weight-semibold)",
+              outline: "none",
+            }}
+          />
+          <span
+            style={{
+              fontSize: "var(--text-xs)",
+              fontFamily: "var(--font-mono)",
+              color: "var(--text-tertiary)",
+            }}
+          >
+            branch: {branch}
+          </span>
+        </header>
+
+        <section
+          style={{
+            padding: "var(--space-3) var(--space-4)",
+            borderTop: "var(--border-1)",
+            display: "grid",
+            gap: 6,
+          }}
+        >
+          <span style={sectionLabel}>Color</span>
+          <div
+            role="radiogroup"
+            aria-label="Tag color"
+            style={{ display: "flex", gap: 6, flexWrap: "wrap" }}
+          >
+            {TAG_IDS.map((id) => (
+              <ColorSwatch
+                key={id}
+                id={id}
+                active={id === (color ?? "default")}
+                onClick={() => setColor(id === "default" ? undefined : id)}
+              />
+            ))}
+          </div>
+        </section>
+
+        <section
+          style={{
+            padding: "var(--space-3) var(--space-4) var(--space-2)",
+            borderTop: "var(--border-1)",
+            display: "grid",
+            gap: 8,
+          }}
+        >
+          <span style={sectionLabel}>Icon</span>
+          <div
+            style={{
+              display: "flex",
+              alignItems: "center",
+              gap: 10,
+              height: 36,
+              padding: "0 12px",
+              backgroundColor: "var(--surface-1)",
+              border: "var(--border-1)",
+              borderRadius: "var(--radius-sm)",
+            }}
+          >
+            <SearchGlyph />
+            <input
+              type="text"
+              value={query}
+              onChange={(e) => setQuery(e.target.value)}
+              placeholder="Search icons"
+              style={{
+                flex: 1,
+                minWidth: 0,
+                background: "transparent",
+                border: "none",
+                outline: "none",
+                color: "var(--text-primary)",
+                fontFamily: "var(--font-sans)",
+                fontSize: "var(--text-md)",
+              }}
+            />
+            {query && (
+              <button
+                type="button"
+                onClick={() => setQuery("")}
+                title="Clear search"
+                style={{
+                  width: 20,
+                  height: 20,
+                  display: "inline-flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  backgroundColor: "transparent",
+                  color: "var(--text-tertiary)",
+                  borderRadius: "var(--radius-xs)",
+                  cursor: "pointer",
+                }}
+              >
+                ×
+              </button>
+            )}
+          </div>
+        </section>
+
+        <div
+          style={{
+            overflow: "auto",
+            padding: "0 var(--space-4) var(--space-3)",
+            minHeight: 0,
+            // Cap the grid so the footer stays visible without the
+            // panel growing to the viewport max on every open.
+            maxHeight: 220,
+          }}
+        >
+          <div
+            style={{
+              display: "grid",
+              gridTemplateColumns: "repeat(auto-fill, minmax(56px, 1fr))",
+              gap: 6,
+            }}
+          >
+            {filtered.map((icon) => (
+              <IconCell
+                key={icon.name}
+                icon={icon}
+                active={icon.name === iconName}
+                onClick={() =>
+                  setIconName(icon.name === iconName ? undefined : icon.name)
+                }
+              />
+            ))}
+            {filtered.length === 0 && (
+              <span
+                style={{
+                  gridColumn: "1 / -1",
+                  padding: "var(--space-4)",
+                  textAlign: "center",
+                  color: "var(--text-tertiary)",
+                  fontSize: "var(--text-xs)",
+                }}
+              >
+                No icons match "{query}"
+              </span>
+            )}
+          </div>
+        </div>
+
+        <div
+          style={{
+            display: "flex",
+            justifyContent: "flex-end",
+            gap: 8,
+            padding: "var(--space-3)",
+            borderTop: "var(--border-1)",
+          }}
+        >
+          <button
+            type="button"
+            onClick={close}
+            disabled={busy}
+            style={{
+              height: 28,
+              padding: "0 var(--space-3)",
+              borderRadius: "var(--radius-sm)",
+              color: "var(--text-secondary)",
+              backgroundColor: "var(--surface-3)",
+              fontSize: "var(--text-sm)",
+              opacity: busy ? 0.5 : 1,
+            }}
+          >
+            Cancel
+          </button>
+          <button
+            type="button"
+            onClick={() => void create()}
+            disabled={busy || !base}
+            style={{
+              height: 28,
+              padding: "0 var(--space-3)",
+              borderRadius: "var(--radius-sm)",
+              color: "var(--text-primary)",
+              backgroundColor: "var(--accent-press)",
+              fontSize: "var(--text-sm)",
+              fontWeight: "var(--weight-medium)",
+              opacity: busy || !base ? 0.5 : 1,
+            }}
+          >
+            {busy ? "Creating…" : "Create worktree"}
+          </button>
+        </div>
+      </motion.div>
+    </motion.div>
+  );
+}
diff --git a/src/shell/IconPickerDialog.tsx b/src/shell/IconPickerDialog.tsx
index 7b46c70..7920688 100644
--- a/src/shell/IconPickerDialog.tsx
+++ b/src/shell/IconPickerDialog.tsx
@@ -408,7 +408,7 @@ export function IconPickerDialog({
   );
 }
 
-function IconCell({
+export function IconCell({
   icon,
   active,
   onClick,
@@ -456,7 +456,7 @@ function IconCell({
   );
 }
 
-function ColorSwatch({
+export function ColorSwatch({
   id,
   active,
   onClick,
@@ -517,7 +517,7 @@ function ColorSwatch({
   );
 }
 
-function SearchGlyph() {
+export function SearchGlyph() {
   return (
     <svg
       width="14"
diff --git a/src/shell/Sidebar.tsx b/src/shell/Sidebar.tsx
index 8bce25f..1d13128 100644
--- a/src/shell/Sidebar.tsx
+++ b/src/shell/Sidebar.tsx
@@ -42,7 +42,6 @@ import {
   useProjectWorktrees,
 } from "@/state/AppState";
 import {
-  applyBranchPrefix,
   projectSettings,
   type ArchiveRecord,
   type Project,
@@ -52,10 +51,8 @@ import {
 import { openProjectDialog } from "@/lib/projectDialog";
 import {
   collectWorktreePtyIds,
-  nextAutoBranch,
   worktreeArchive,
   primaryTerminalTab,
-  worktreeCreate,
   worktreeRestore,
 } from "@/lib/worktrees";
 import { forgetPtys } from "@/terminal/sessionMemory";
@@ -270,7 +267,6 @@ function ProjectGroup({
   activeWorktreeId: string | null;
 }) {
   const dispatch = useAppDispatch();
-  const toast = useToast();
   const [hovering, setHovering] = useState(false);
   const [pickerOpen, setPickerOpen] = useState(false);
   const [menuAnchor, setMenuAnchor] = useState<{ x: number; y: number } | null>(
@@ -337,32 +333,10 @@ function ProjectGroup({
   }, []);
 
   const state = useAppState();
-  const onCreate = async () => {
-    const base = nextAutoBranch(project.id, state);
-    const branch = applyBranchPrefix(
-      base,
-      state.settings.branchPrefixMode,
-      state.settings.githubUsername,
-      state.settings.customBranchPrefix,
-    );
-    const cfg = projectSettings(project);
-    try {
-      const w = await worktreeCreate(
-        project.id,
-        project.path,
-        branch,
-        base,
-        {
-          baseRef: cfg.baseBranch,
-          filesToCopy: cfg.filesToCopy,
-          setupScript: cfg.setupScript,
-        },
-      );
-      dispatch({ type: "add-worktree", worktree: w });
-      dispatch({ type: "open-tab", tab: primaryTerminalTab(w) });
-    } catch (err) {
-      toast.show({ message: `Worktree creation failed: ${err}` });
-    }
+  // Opens the "New worktree" dialog (name / color / icon) instead of
+  // creating directly — the dialog owns the worktreeCreate call.
+  const onCreate = () => {
+    dispatch({ type: "set-create-worktree-open", projectId: project.id });
   };
 
   const onOpenSettings = () => {
diff --git a/src/state/reducer.ts b/src/state/reducer.ts
index 5f82313..175c97c 100644
--- a/src/state/reducer.ts
+++ b/src/state/reducer.ts
@@ -36,6 +36,7 @@ export const INITIAL_STATE: AppState = {
   settingsOpen: false,
   settingsSection: { kind: "general" },
   prDialogOpen: null,
+  createWorktreeProjectId: null,
   settings: DEFAULT_SETTINGS,
   markdownView: "rich",
 };
@@ -176,6 +177,10 @@ export function reducer(state: AppState, action: AppAction): AppState {
         iconName: action.iconName,
       }));
 
+    case "set-create-worktree-open":
+      if (state.createWorktreeProjectId === action.projectId) return state;
+      return { ...state, createWorktreeProjectId: action.projectId };
+
     /* Worktrees --------------------------------------------------- */
 
     case "add-worktree": {
diff --git a/src/state/types.ts b/src/state/types.ts
index 1a7dfcc..65820f8 100644
--- a/src/state/types.ts
+++ b/src/state/types.ts
@@ -560,6 +560,9 @@ export interface AppState {
      */
     mode: "manual" | "auto";
   } | null;
+  /** Project the "New worktree" dialog is creating into; null = closed.
+      Transient — stripped by persistence like the other dialog flags. */
+  createWorktreeProjectId: ProjectId | null;
 
   settings: Settings;
   markdownView: "rich" | "source";
@@ -594,6 +597,7 @@ export type AppAction =
       worktreeId: WorktreeId;
       iconName: string | undefined;
     }
+  | { type: "set-create-worktree-open"; projectId: ProjectId | null }
 
   // Worktrees
   | { type: "add-worktree"; worktree: Worktree }

From 540eb9587dcd1771cd5e6a7accdef4975da564a1 Mon Sep 17 00:00:00 2001
From: raeedz <raeedz@gmail.com>
Date: Sat, 4 Jul 2026 14:10:43 -0700
Subject: [PATCH 7/9] Add spacing below the "Fix N changes" bar

Lift the floating fix bar off the panel's bottom edge using --space-4.
---
 src/git/DiffFix.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/git/DiffFix.tsx b/src/git/DiffFix.tsx
index e470519..56ac3de 100644
--- a/src/git/DiffFix.tsx
+++ b/src/git/DiffFix.tsx
@@ -501,7 +501,7 @@ export function DiffFixBar() {
             position: "absolute",
             left: 0,
             right: 0,
-            bottom: 0,
+            bottom: "var(--space-4)",
             display: "flex",
             justifyContent: "center",
             padding: "var(--space-3)",

From 52e6372c1031c5c2f7210997ee03da8ccee4e0a1 Mon Sep 17 00:00:00 2001
From: raeedz <raeedz@gmail.com>
Date: Sun, 5 Jul 2026 22:37:44 -0700
Subject: [PATCH 8/9] PR tab: add pr_list, pr_diff, pr_checkout,
 pr_checkout_return commands

Registers gh CLI-backed PR listing/diff/checkout in the backend, with
tagged auto-stash/restore around checkout so uncommitted work is
never lost.
---
 src-tauri/src/lib.rs       |   5 +
 src-tauri/src/pr.rs        | 364 +++++++++++++++++
 src/git/PrDiffView.tsx     | 197 ++++++++++
 src/git/PrsView.tsx        | 772 +++++++++++++++++++++++++++++++++++++
 src/git/conflictAgent.ts   |  76 ++++
 src/lib/pr.ts              |  68 ++++
 src/shell/MainColumn.tsx   |  14 +
 src/shell/RightPanel.tsx   |  15 +
 src/shell/WindowChrome.tsx |  94 +----
 src/state/reducer.ts       |   2 +
 src/state/types.ts         |  44 ++-
 11 files changed, 1577 insertions(+), 74 deletions(-)
 create mode 100644 src/git/PrDiffView.tsx
 create mode 100644 src/git/PrsView.tsx
 create mode 100644 src/git/conflictAgent.ts
 create mode 100644 src/lib/pr.ts

diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index eb6c253..5d64dd7 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -247,6 +247,11 @@ pub fn run() {
             pr::pr_merge,
             pr::merge_base_into_branch,
             pr::gh_username,
+            // PRs tab (list / review / checkout / return)
+            pr::pr_list,
+            pr::pr_diff,
+            pr::pr_checkout,
+            pr::pr_checkout_return,
             // Connections (Task #10)
             connections::connections_scan,
             // Search (Task #15)
diff --git a/src-tauri/src/pr.rs b/src-tauri/src/pr.rs
index 4d93978..792bdae 100644
--- a/src-tauri/src/pr.rs
+++ b/src-tauri/src/pr.rs
@@ -30,6 +30,39 @@ pub struct PrStatus {
     pub mergeable: Option<String>,
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PrListItem {
+    pub number: u64,
+    pub title: String,
+    pub url: String,
+    pub head_ref_name: String,
+    pub base_ref_name: String,
+    pub author: String,
+    pub additions: u64,
+    pub deletions: u64,
+    pub changed_files: u64,
+    /// One of MERGEABLE, CONFLICTING, UNKNOWN.
+    pub mergeable: String,
+    pub is_draft: bool,
+    pub updated_at: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PrCheckoutResult {
+    pub original_branch: String,
+    pub stashed: bool,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PrReturnResult {
+    /// False when a stash was expected but the tagged stash was gone —
+    /// the branch switch happened, but nothing was restored.
+    pub stash_restored: bool,
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ConflictResult {
@@ -576,6 +609,237 @@ pub async fn pr_status(cwd: String, branch: String) -> Result<PrStatus, String>
     })
 }
 
+/// List every open PR on the repo via `gh pr list`. Drives the right
+/// panel's PRs tab. Author is flattened to the login string; draft PRs
+/// are included (the tab renders a Draft chip rather than hiding them).
+#[tauri::command]
+pub async fn pr_list(cwd: String) -> Result<Vec<PrListItem>, String> {
+    if !Path::new(&cwd).exists() {
+        return Err(format!("cwd does not exist: {cwd}"));
+    }
+    let out = Command::new("gh")
+        .args([
+            "pr",
+            "list",
+            "--state",
+            "open",
+            "--limit",
+            "50",
+            "--json",
+            "number,title,url,headRefName,baseRefName,author,additions,deletions,changedFiles,mergeable,isDraft,updatedAt",
+        ])
+        .current_dir(&cwd)
+        .output()
+        .await
+        .map_err(|e| format!("spawn gh: {e}. Is GitHub CLI installed? `brew install gh`"))?;
+    if !out.status.success() {
+        return Err(format!(
+            "gh pr list failed: {}",
+            String::from_utf8_lossy(&out.stderr).trim()
+        ));
+    }
+    #[derive(Deserialize)]
+    struct AuthorJson {
+        login: String,
+    }
+    #[derive(Deserialize)]
+    #[serde(rename_all = "camelCase")]
+    struct RowJson {
+        number: u64,
+        title: String,
+        url: String,
+        head_ref_name: String,
+        base_ref_name: String,
+        author: Option<AuthorJson>,
+        additions: u64,
+        deletions: u64,
+        changed_files: u64,
+        mergeable: String,
+        is_draft: bool,
+        updated_at: String,
+    }
+    let rows: Vec<RowJson> = serde_json::from_slice(&out.stdout)
+        .map_err(|e| format!("parse gh json: {e}"))?;
+    Ok(rows
+        .into_iter()
+        .map(|r| PrListItem {
+            number: r.number,
+            title: r.title,
+            url: r.url,
+            head_ref_name: r.head_ref_name,
+            base_ref_name: r.base_ref_name,
+            author: r.author.map(|a| a.login).unwrap_or_default(),
+            additions: r.additions,
+            deletions: r.deletions,
+            changed_files: r.changed_files,
+            mergeable: r.mergeable,
+            is_draft: r.is_draft,
+            updated_at: r.updated_at,
+        })
+        .collect())
+}
+
+/// Unified diff of a PR (`gh pr diff <number>`) — lets the PRs tab
+/// show the full review diff without checking the branch out.
+#[tauri::command]
+pub async fn pr_diff(cwd: String, number: u64) -> Result<String, String> {
+    if !Path::new(&cwd).exists() {
+        return Err(format!("cwd does not exist: {cwd}"));
+    }
+    let num = number.to_string();
+    let out = Command::new("gh")
+        .args(["pr", "diff", &num])
+        .current_dir(&cwd)
+        .output()
+        .await
+        .map_err(|e| format!("spawn gh: {e}. Is GitHub CLI installed? `brew install gh`"))?;
+    if !out.status.success() {
+        return Err(format!(
+            "gh pr diff failed: {}",
+            String::from_utf8_lossy(&out.stderr).trim()
+        ));
+    }
+    Ok(String::from_utf8_lossy(&out.stdout).into_owned())
+}
+
+/// Message marker on the auto-stash created by `pr_checkout`, suffixed
+/// with the branch it was taken from so `pr_checkout_return` can find
+/// exactly this stash even if the user made others in between.
+const PR_STASH_MARKER: &str = "goonware-pr-checkout";
+
+/// Find the stash ref (e.g. `stash@{1}`) whose message carries our
+/// marker for `branch`. Newest match wins.
+async fn find_pr_stash(cwd: &str, branch: &str) -> Option<String> {
+    let raw = run_git(cwd, &["stash", "list", "--format=%gd\u{1f}%gs"])
+        .await
+        .ok()?;
+    let needle = format!("{PR_STASH_MARKER}:{branch}");
+    for line in raw.lines() {
+        let Some((gd, gs)) = line.split_once('\u{1f}') else {
+            continue;
+        };
+        // %gs renders as "On <branch>: <message>" — compare the message
+        // exactly, so returning to `feat` can never pop a stash tagged
+        // for `feature` (or any user stash that merely mentions the
+        // marker). Branch names can't contain spaces, so the first
+        // ": " is always git's own separator.
+        let msg = gs.split_once(": ").map_or(gs, |(_, m)| m);
+        if msg == needle {
+            return Some(gd.to_string());
+        }
+    }
+    None
+}
+
+/// Turn the worktree into a review environment for a PR: stash any
+/// uncommitted work (tagged so we can restore it later), then
+/// `gh pr checkout <number>`. Returns what the caller needs to offer a
+/// "go back" button — the original branch and whether a stash was made.
+///
+/// If the checkout itself fails the stash is popped back immediately so
+/// the user's work never silently disappears into the stash list.
+#[tauri::command]
+pub async fn pr_checkout(cwd: String, number: u64) -> Result<PrCheckoutResult, String> {
+    if !Path::new(&cwd).exists() {
+        return Err(format!("cwd does not exist: {cwd}"));
+    }
+    let original_branch = run_git_checked(&cwd, &["symbolic-ref", "--short", "HEAD"])
+        .await
+        .map_err(|_| "could not determine current branch (detached HEAD?)".to_string())?
+        .trim()
+        .to_string();
+    if original_branch.is_empty() {
+        return Err("could not determine current branch (detached HEAD?)".into());
+    }
+
+    let porcelain = run_git_checked(&cwd, &["status", "--porcelain"]).await?;
+    let dirty = porcelain.lines().any(|l| !l.trim().is_empty());
+    let mut stashed = false;
+    if dirty {
+        let msg = format!("{PR_STASH_MARKER}:{original_branch}");
+        run_git_checked(&cwd, &["stash", "push", "-u", "-m", &msg]).await?;
+        stashed = true;
+    }
+
+    let num = number.to_string();
+    let out = Command::new("gh")
+        .args(["pr", "checkout", &num])
+        .current_dir(&cwd)
+        .output()
+        .await
+        .map_err(|e| format!("spawn gh: {e}. Is GitHub CLI installed? `brew install gh`"))?;
+    if !out.status.success() {
+        let mut msg = format!(
+            "gh pr checkout failed: {}",
+            String::from_utf8_lossy(&out.stderr).trim()
+        );
+        // Roll the stash back so a failed checkout is a clean no-op.
+        // gh isn't atomic — it can die after already switching branches
+        // — so make sure the pop lands on the original branch, and say
+        // so when the stash couldn't be restored rather than dropping
+        // the pop error on the floor.
+        if stashed {
+            let head = run_git_checked(&cwd, &["symbolic-ref", "--short", "HEAD"])
+                .await
+                .map(|s| s.trim().to_string())
+                .unwrap_or_default();
+            let on_original = head == original_branch
+                || run_git_checked(&cwd, &["checkout", &original_branch])
+                    .await
+                    .is_ok();
+            let popped = match find_pr_stash(&cwd, &original_branch).await {
+                Some(stash_ref) if on_original => {
+                    run_git_checked(&cwd, &["stash", "pop", &stash_ref])
+                        .await
+                        .is_ok()
+                }
+                _ => false,
+            };
+            if !popped {
+                msg.push_str(
+                    " — your uncommitted work is still saved in the stash list (`git stash list`)",
+                );
+            }
+        }
+        return Err(msg);
+    }
+    Ok(PrCheckoutResult {
+        original_branch,
+        stashed,
+    })
+}
+
+/// Undo `pr_checkout`: switch back to the original branch and pop the
+/// tagged stash if one was made. Fails loudly if the PR branch has
+/// uncommitted edits (git refuses the checkout) — the user decides
+/// whether to commit or discard those, we never do it for them.
+///
+/// `stash_restored` is false when `stashed` was set but the tagged
+/// stash no longer exists (e.g. the user popped it by hand) — the
+/// caller must not claim the work was restored.
+#[tauri::command]
+pub async fn pr_checkout_return(
+    cwd: String,
+    branch: String,
+    stashed: bool,
+) -> Result<PrReturnResult, String> {
+    if !Path::new(&cwd).exists() {
+        return Err(format!("cwd does not exist: {cwd}"));
+    }
+    if branch.is_empty() {
+        return Err("no branch to return to".into());
+    }
+    run_git_checked(&cwd, &["checkout", &branch]).await?;
+    let mut stash_restored = false;
+    if stashed {
+        if let Some(stash_ref) = find_pr_stash(&cwd, &branch).await {
+            run_git_checked(&cwd, &["stash", "pop", &stash_ref]).await?;
+            stash_restored = true;
+        }
+    }
+    Ok(PrReturnResult { stash_restored })
+}
+
 /// Merge a PR via `gh pr merge` — server-side merge using the user's
 /// existing GitHub auth. Defaults to `--merge` (merge commit). Pass
 /// `"squash"` or `"rebase"` to override. Branch is deleted on remote
@@ -1208,4 +1472,104 @@ mod tests {
             .expect_err("missing cwd should error");
         assert!(!err.is_empty());
     }
+
+    // ---- pr_checkout_return stash round-trip -----------------------------
+
+    #[tokio::test]
+    async fn checkout_return_restores_branch_and_pops_tagged_stash() {
+        // Simulate the state pr_checkout leaves behind: work stashed
+        // with the marker message on `feature/mine`, HEAD moved to a
+        // "PR branch". Return must land back on the original branch
+        // with the stashed file restored — and leave an unrelated,
+        // newer stash untouched.
+        let (clone, _bare) = build_repo_with_bare_remote("feature/mine");
+        let cwd = clone.path().to_str().unwrap();
+
+        std::fs::write(clone.path().join("wip.txt"), "my wip\n").unwrap();
+        run_sync(
+            clone.path(),
+            &[
+                "stash",
+                "push",
+                "-u",
+                "-m",
+                &format!("{PR_STASH_MARKER}:feature/mine"),
+            ],
+        );
+        run_sync(clone.path(), &["checkout", "-b", "pr-branch"]);
+
+        // A second, unrelated stash made "later" (stash@{0}) must survive.
+        std::fs::write(clone.path().join("other.txt"), "other\n").unwrap();
+        run_sync(clone.path(), &["stash", "push", "-u", "-m", "user stash"]);
+
+        let result = pr_checkout_return(cwd.to_string(), "feature/mine".to_string(), true)
+            .await
+            .expect("return succeeds");
+        assert!(result.stash_restored, "tagged stash should be reported restored");
+
+        let branch = run_sync(clone.path(), &["symbolic-ref", "--short", "HEAD"]);
+        assert_eq!(branch.trim(), "feature/mine");
+        assert!(
+            clone.path().join("wip.txt").exists(),
+            "stashed wip should be restored"
+        );
+        let stashes = run_sync(clone.path(), &["stash", "list"]);
+        assert!(
+            stashes.contains("user stash"),
+            "unrelated stash must survive: {stashes}"
+        );
+        assert!(
+            !stashes.contains(PR_STASH_MARKER),
+            "tagged stash should be consumed: {stashes}"
+        );
+    }
+
+    #[tokio::test]
+    async fn checkout_return_without_stash_just_switches_branch() {
+        let (clone, _bare) = build_repo_with_bare_remote("feature/clean");
+        let cwd = clone.path().to_str().unwrap();
+        run_sync(clone.path(), &["checkout", "-b", "pr-branch"]);
+
+        let result = pr_checkout_return(cwd.to_string(), "feature/clean".to_string(), false)
+            .await
+            .expect("return succeeds");
+        assert!(!result.stash_restored, "no stash existed to restore");
+
+        let branch = run_sync(clone.path(), &["symbolic-ref", "--short", "HEAD"]);
+        assert_eq!(branch.trim(), "feature/clean");
+    }
+
+    #[tokio::test]
+    async fn checkout_return_ignores_stash_tagged_for_prefixed_branch() {
+        // Marker matching is exact: a stash tagged for `feature/mine-2`
+        // must not be popped when returning to `feature/mine`.
+        let (clone, _bare) = build_repo_with_bare_remote("feature/mine");
+        let cwd = clone.path().to_str().unwrap();
+
+        std::fs::write(clone.path().join("wip.txt"), "other branch wip\n").unwrap();
+        run_sync(
+            clone.path(),
+            &[
+                "stash",
+                "push",
+                "-u",
+                "-m",
+                &format!("{PR_STASH_MARKER}:feature/mine-2"),
+            ],
+        );
+        run_sync(clone.path(), &["checkout", "-b", "pr-branch"]);
+
+        let result = pr_checkout_return(cwd.to_string(), "feature/mine".to_string(), true)
+            .await
+            .expect("return succeeds");
+        assert!(
+            !result.stash_restored,
+            "stash tagged for a prefixed branch name must not match"
+        );
+        let stashes = run_sync(clone.path(), &["stash", "list"]);
+        assert!(
+            stashes.contains("feature/mine-2"),
+            "the other branch's stash must survive: {stashes}"
+        );
+    }
 }
diff --git a/src/git/PrDiffView.tsx b/src/git/PrDiffView.tsx
new file mode 100644
index 0000000..29bd7b2
--- /dev/null
+++ b/src/git/PrDiffView.tsx
@@ -0,0 +1,197 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import { motion } from "motion/react";
+import { pr } from "@/lib/pr";
+import { FileBlock, sliceByFile, type FileSection } from "./AllChangesView";
+
+/**
+ * Full diff of an open PR, one collapsible section per file — the
+ * main-column body of a `pr-diff` tab. Fetches `gh pr diff <number>`
+ * live (no checkout needed) and reuses the AllChangesView slicing +
+ * FileBlock renderer so tinting, line numbers, and sticky file headers
+ * match the working-tree diff views exactly. Listens to
+ * `goonware-git-refresh` so a push to the PR branch (e.g. after
+ * resolving conflicts in a checked-out session) re-pulls the diff.
+ */
+export function PrDiffView({
+  projectPath,
+  number,
+  title,
+}: {
+  projectPath: string;
+  number: number;
+  title: string;
+}) {
+  const [raw, setRaw] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const inFlight = useRef(false);
+  const rerun = useRef(false);
+
+  useEffect(() => {
+    let cancelled = false;
+    // git-refresh fires for every git operation in the worktree, so:
+    // keep showing the current diff while the refetch runs (no blank
+    // flash), skip identical payloads (setRaw keeps the old identity
+    // so sliceByFile doesn't re-parse), and coalesce events that land
+    // mid-fetch into one trailing refetch instead of piling up gh
+    // subprocesses.
+    const refresh = () => {
+      if (inFlight.current) {
+        rerun.current = true;
+        return;
+      }
+      inFlight.current = true;
+      pr.diff(projectPath, number)
+        .then((d) => {
+          if (cancelled) return;
+          setRaw((prev) => (prev === d ? prev : d));
+          setError(null);
+        })
+        .catch((e) => {
+          if (!cancelled) setError(String(e));
+        })
+        .finally(() => {
+          inFlight.current = false;
+          if (rerun.current && !cancelled) {
+            rerun.current = false;
+            refresh();
+          }
+        });
+    };
+    refresh();
+    const onRefresh = (e: Event) => {
+      const detail = (e as CustomEvent<{ cwd?: string }>).detail;
+      if (!detail?.cwd || detail.cwd === projectPath) refresh();
+    };
+    window.addEventListener("goonware-git-refresh", onRefresh);
+    return () => {
+      cancelled = true;
+      window.removeEventListener("goonware-git-refresh", onRefresh);
+    };
+  }, [projectPath, number]);
+
+  const sections = useMemo<FileSection[]>(
+    () => (raw ? sliceByFile(raw) : []),
+    [raw],
+  );
+
+  const totals = useMemo(() => {
+    let add = 0;
+    let rem = 0;
+    for (const s of sections) {
+      for (const l of s.lines) {
+        if (l.kind === "add") add++;
+        else if (l.kind === "remove") rem++;
+      }
+    }
+    return { add, rem, files: sections.length };
+  }, [sections]);
+
+  return (
+    <motion.div
+      initial={{ opacity: 0, y: 4 }}
+      animate={{ opacity: 1, y: 0 }}
+      transition={{ duration: 0.14, ease: [0.25, 1, 0.5, 1] }}
+      style={{
+        position: "absolute",
+        inset: 0,
+        display: "flex",
+        flexDirection: "column",
+        backgroundColor: "var(--surface-0)",
+        overflow: "hidden",
+      }}
+    >
+      <div
+        style={{
+          height: 36,
+          flexShrink: 0,
+          display: "flex",
+          alignItems: "center",
+          gap: "var(--space-3)",
+          padding: "0 var(--space-3)",
+          backgroundColor: "var(--surface-1)",
+          borderBottom: "var(--border-1)",
+          userSelect: "none",
+        }}
+      >
+        <span
+          style={{
+            fontFamily: "var(--font-mono)",
+            fontSize: "var(--text-2xs)",
+            fontWeight: "var(--weight-semibold)",
+            color: "var(--text-secondary)",
+            flexShrink: 0,
+          }}
+        >
+          #{number}
+        </span>
+        <span
+          style={{
+            fontFamily: "var(--font-sans)",
+            fontSize: "var(--text-xs)",
+            color: "var(--text-primary)",
+            overflow: "hidden",
+            textOverflow: "ellipsis",
+            whiteSpace: "nowrap",
+            minWidth: 0,
+          }}
+          title={title}
+        >
+          {title}
+        </span>
+        <span style={{ flex: 1 }} />
+        <span
+          className="tabular"
+          style={{
+            fontFamily: "var(--font-mono)",
+            fontSize: "var(--text-2xs)",
+            color: "var(--text-tertiary)",
+            flexShrink: 0,
+          }}
+        >
+          {totals.files} file{totals.files === 1 ? "" : "s"} ·{" "}
+          <span style={{ color: "var(--diff-add-fg)" }}>+{totals.add}</span>{" "}
+          <span style={{ color: "var(--diff-remove-fg)" }}>−{totals.rem}</span>
+        </span>
+      </div>
+
+      <div
+        style={{
+          flex: 1,
+          minHeight: 0,
+          overflow: "auto",
+          backgroundColor: "var(--surface-0)",
+        }}
+        className="allow-select"
+      >
+        {raw === null && !error && <Empty label="loading PR diff…" />}
+        {raw === null && error && <Empty label={`error: ${error}`} />}
+        {raw !== null && sections.length === 0 && (
+          <Empty label="no changes in this PR" />
+        )}
+        {raw !== null && sections.length > 0 && (
+          <div style={{ display: "flex", flexDirection: "column" }}>
+            {sections.map((s) => (
+              <FileBlock key={s.path} section={s} />
+            ))}
+          </div>
+        )}
+      </div>
+    </motion.div>
+  );
+}
+
+function Empty({ label }: { label: string }) {
+  return (
+    <div
+      style={{
+        padding: "var(--space-6) var(--space-4)",
+        textAlign: "center",
+        color: "var(--text-tertiary)",
+        fontSize: "var(--text-xs)",
+        fontFamily: "var(--font-sans)",
+      }}
+    >
+      {label}
+    </div>
+  );
+}
diff --git a/src/git/PrsView.tsx b/src/git/PrsView.tsx
new file mode 100644
index 0000000..ef9b014
--- /dev/null
+++ b/src/git/PrsView.tsx
@@ -0,0 +1,772 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { ArrowSquareOut, ArrowsLeftRight, GitMerge } from "@phosphor-icons/react";
+import { IconRefresh } from "@/design/icons";
+import {
+  AnimatePresence,
+  Tooltip,
+  useTooltipAnchor,
+} from "@/primitives/Tooltip";
+import { useAppDispatch, useAppState } from "@/state/AppState";
+import { type Tab, type Worktree } from "@/state/types";
+import { pr, type PrListItem } from "@/lib/pr";
+import { system } from "@/lib/fs";
+import { mergeBaseAndHandOff } from "./conflictAgent";
+import { useToast } from "@/primitives/Toast";
+
+const PR_LIST_POLL_MS = 30_000;
+
+type Busy =
+  | { kind: "checkout" | "merge"; number: number }
+  | { kind: "return" }
+  | { kind: "conflicts" }
+  | null;
+
+/**
+ * Right-panel PRs tab: every open PR on the repo, live from `gh pr
+ * list`. A row click opens the PR's full diff in the main column; the
+ * hover actions check the PR out into this worktree (stashing whatever
+ * was in progress), merge it server-side, or open it on GitHub.
+ *
+ * Checking a PR out flips the worktree into a review session — the
+ * banner at the top names the PR, offers "Resolve conflicts" when
+ * GitHub reports the PR conflicting, and a Return button that restores
+ * the original branch plus the stashed work. The session record lives
+ * on the worktree (persisted), so the way back survives restarts.
+ */
+export function PrsView({
+  worktree,
+  isVisible,
+}: {
+  worktree: Worktree;
+  isVisible: boolean;
+}) {
+  const dispatch = useAppDispatch();
+  const state = useAppState();
+  const toast = useToast();
+  const [prs, setPrs] = useState<PrListItem[] | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [busy, setBusy] = useState<Busy>(null);
+  const path = worktree.path;
+  const session = worktree.prSession ?? null;
+
+  // One in-flight fetch at a time; stale responses for a previous
+  // worktree path are dropped rather than painted.
+  const pathRef = useRef(path);
+  pathRef.current = path;
+  const refresh = useCallback(async () => {
+    try {
+      const rows = await pr.list(path);
+      if (pathRef.current !== path) return;
+      setPrs(rows);
+      setError(null);
+    } catch (e) {
+      if (pathRef.current !== path) return;
+      setError(String(e));
+    }
+  }, [path]);
+
+  // Fetch when the pane is actually showing (it stays mounted behind
+  // display:none like the other right-panel panes) — gh shells out a
+  // network call per poll, so hidden panes stay quiet.
+  useEffect(() => {
+    if (!isVisible || worktree.missing) return;
+    void refresh();
+    const t = window.setInterval(() => {
+      if (document.visibilityState === "hidden") return;
+      void refresh();
+    }, PR_LIST_POLL_MS);
+    const onGitRefresh = (e: Event) => {
+      const detail = (e as CustomEvent<{ cwd?: string }>).detail;
+      if (!detail?.cwd || detail.cwd === path) void refresh();
+    };
+    window.addEventListener("goonware-git-refresh", onGitRefresh);
+    return () => {
+      window.clearInterval(t);
+      window.removeEventListener("goonware-git-refresh", onGitRefresh);
+    };
+  }, [isVisible, worktree.missing, path, refresh]);
+
+  const notifyGitRefresh = () => {
+    window.dispatchEvent(
+      new CustomEvent("goonware-git-refresh", { detail: { cwd: path } }),
+    );
+  };
+
+  const openDiff = (item: PrListItem) => {
+    const tab: Tab = {
+      id: `t_pr_${item.number}_${Date.now().toString(36)}`,
+      worktreeId: worktree.id,
+      kind: "pr-diff",
+      number: item.number,
+      title: item.title,
+      summary: `PR #${item.number} · ${item.headRefName}`,
+      summaryUpdatedAt: Date.now(),
+    };
+    // The reducer dedupes on (kind, number) — re-clicking a row focuses
+    // the existing tab instead of stacking copies.
+    dispatch({ type: "open-tab", tab });
+  };
+
+  const checkout = async (item: PrListItem) => {
+    if (busy) return;
+    if (session) {
+      toast.show({
+        message:
+          session.number === item.number
+            ? `PR #${item.number} is already checked out here.`
+            : `Return to ${session.originalBranch} before checking out another PR.`,
+      });
+      return;
+    }
+    setBusy({ kind: "checkout", number: item.number });
+    try {
+      const result = await pr.checkout(path, item.number);
+      dispatch({
+        type: "update-worktree",
+        id: worktree.id,
+        patch: {
+          prSession: {
+            number: item.number,
+            branch: item.headRefName,
+            title: item.title,
+            originalBranch: result.originalBranch,
+            baseBranch: item.baseRefName,
+            stashed: result.stashed,
+          },
+        },
+      });
+      notifyGitRefresh();
+      // Reviewing means reading the changes — put the PR's diff on
+      // screen in the same gesture instead of hiding it behind a
+      // toast action the user has to catch before it fades.
+      openDiff(item);
+      toast.show({
+        message: `Checked out PR #${item.number} (${item.headRefName})${
+          result.stashed ? " — your changes are stashed" : ""
+        }.`,
+      });
+    } catch (e) {
+      toast.show({ message: `Checkout failed: ${e}` });
+    } finally {
+      setBusy(null);
+    }
+  };
+
+  // Switch back to the session's original branch, pop the tagged
+  // stash, and clear the session record. Shared by the Return button
+  // and the merged-the-reviewed-PR path in merge().
+  const endSession = async (s: NonNullable<Worktree["prSession"]>) => {
+    const result = await pr.checkoutReturn(path, s.originalBranch, s.stashed);
+    dispatch({
+      type: "update-worktree",
+      id: worktree.id,
+      patch: { prSession: null },
+    });
+    return result;
+  };
+
+  const returnToBranch = async () => {
+    if (!session || busy) return;
+    setBusy({ kind: "return" });
+    try {
+      const result = await endSession(session);
+      notifyGitRefresh();
+      toast.show({
+        message:
+          session.stashed && !result.stashRestored
+            ? `Back on ${session.originalBranch} — heads-up: the tagged stash was gone, nothing was restored.`
+            : `Back on ${session.originalBranch}${
+                session.stashed ? " — stashed changes restored" : ""
+              }.`,
+      });
+    } catch (e) {
+      toast.show({ message: `Return failed: ${e}` });
+    } finally {
+      setBusy(null);
+    }
+  };
+
+  const merge = async (item: PrListItem) => {
+    if (busy) return;
+    setBusy({ kind: "merge", number: item.number });
+    try {
+      await pr.merge(path, item.number, "merge");
+      // If we merged the PR we were reviewing, the session's branch is
+      // gone on the remote — send the user home in the same gesture.
+      // A failed return must be visible: the session stays so the
+      // Return button can retry, and the toast says what went wrong.
+      let suffix = "";
+      if (session && session.number === item.number) {
+        try {
+          await endSession(session);
+          suffix = ` — back on ${session.originalBranch}`;
+        } catch (e) {
+          suffix = `, but returning to ${session.originalBranch} failed: ${e}`;
+        }
+      }
+      // The goonware-git-refresh event re-runs this pane's own list
+      // fetch (listener above), so no explicit refresh() on top of it.
+      notifyGitRefresh();
+      toast.show({ message: `Merged PR #${item.number}${suffix}.` });
+    } catch (e) {
+      toast.show({ message: `Merge failed: ${e}` });
+    } finally {
+      setBusy(null);
+    }
+  };
+
+  const openExternal = (item: PrListItem) => {
+    void system.open(item.url).catch(() => undefined);
+  };
+
+  const sessionItem = session
+    ? prs?.find((p) => p.number === session.number)
+    : undefined;
+
+  // Pull origin/<base> into the checked-out PR branch, then hand any
+  // conflicted files to the worktree's agent — shared flow with the
+  // chrome's Resolve-conflicts button (see conflictAgent.ts).
+  const resolveConflicts = async () => {
+    if (!session || busy) return;
+    // The base captured at checkout is authoritative; the list row is
+    // only a fallback for sessions persisted before baseBranch existed.
+    // Never guess a branch name — merging the wrong base makes a mess
+    // the agent would then push.
+    const base = session.baseBranch ?? sessionItem?.baseRefName;
+    if (!base) {
+      toast.show({
+        message:
+          "Can't determine the PR's base branch — refresh the PR list and try again.",
+      });
+      return;
+    }
+    setBusy({ kind: "conflicts" });
+    try {
+      const result = await mergeBaseAndHandOff({
+        path,
+        base,
+        branchLabel: `PR #${session.number}'s branch`,
+        worktree,
+        tabs: state.tabs,
+        project: state.projects[worktree.projectId],
+      });
+      notifyGitRefresh();
+      if (result.kind === "clean") {
+        toast.show({
+          message: result.alreadyUpToDate
+            ? "PR branch is already up to date with its base."
+            : "Merged base into the PR branch — no conflicts. Push to update the PR.",
+        });
+      } else {
+        const files = `${result.files} file${result.files === 1 ? "" : "s"}`;
+        toast.show({
+          message:
+            result.kind === "sent"
+              ? `Conflicts in ${files} — sent to agent.`
+              : `Conflicts in ${files}. Open your agent terminal and ask it to resolve.`,
+        });
+      }
+    } catch (e) {
+      toast.show({ message: `Resolve failed: ${e}` });
+    } finally {
+      setBusy(null);
+    }
+  };
+
+  return (
+    <div
+      style={{
+        position: "absolute",
+        inset: 0,
+        display: "flex",
+        flexDirection: "column",
+        minHeight: 0,
+        backgroundColor: "var(--surface-1)",
+      }}
+    >
+      <div
+        style={{
+          display: "flex",
+          alignItems: "center",
+          gap: "var(--space-2)",
+          height: 30,
+          flexShrink: 0,
+          padding: "0 var(--space-3)",
+          borderBottom: "var(--border-1)",
+          userSelect: "none",
+        }}
+      >
+        <span
+          style={{
+            fontFamily: "var(--font-sans)",
+            fontSize: "var(--text-2xs)",
+            fontWeight: "var(--weight-semibold)",
+            color: "var(--text-secondary)",
+            textTransform: "uppercase",
+            letterSpacing: "var(--tracking-caps)",
+          }}
+        >
+          open pull requests
+        </span>
+        {prs && prs.length > 0 && (
+          <span
+            className="tabular"
+            style={{
+              fontFamily: "var(--font-mono)",
+              fontSize: "var(--text-2xs)",
+              color: "var(--text-tertiary)",
+            }}
+          >
+            {prs.length}
+          </span>
+        )}
+        <span style={{ flex: 1 }} />
+        <button
+          type="button"
+          onClick={() => void refresh()}
+          title="Refresh PR list"
+          aria-label="Refresh PR list"
+          style={{
+            display: "inline-flex",
+            alignItems: "center",
+            justifyContent: "center",
+            width: 22,
+            height: 22,
+            borderRadius: "var(--radius-xs)",
+            backgroundColor: "transparent",
+            color: "var(--text-tertiary)",
+            cursor: "pointer",
+          }}
+        >
+          <IconRefresh size={12} />
+        </button>
+      </div>
+
+      {session && (
+        <SessionBanner
+          session={session}
+          conflicting={sessionItem?.mergeable === "CONFLICTING"}
+          busy={busy}
+          onReturn={() => void returnToBranch()}
+          onResolve={() => void resolveConflicts()}
+        />
+      )}
+
+      <div style={{ flex: 1, minHeight: 0, overflow: "auto" }}>
+        {prs === null && !error && <Empty label="loading PRs…" />}
+        {error && <Empty label={`error: ${error}`} />}
+        {!error && prs !== null && prs.length === 0 && (
+          <Empty label="no open PRs" />
+        )}
+        {!error &&
+          prs?.map((item) => (
+            <PrRow
+              key={item.number}
+              item={item}
+              checkedOut={session?.number === item.number}
+              busy={busy}
+              onOpen={() => openDiff(item)}
+              onCheckout={() => void checkout(item)}
+              onMerge={() => void merge(item)}
+              onOpenExternal={() => openExternal(item)}
+            />
+          ))}
+      </div>
+    </div>
+  );
+}
+
+/* ------------------------------------------------------------------
+   Session banner — "you are reviewing PR #N" + the way back.
+   ------------------------------------------------------------------ */
+
+function SessionBanner({
+  session,
+  conflicting,
+  busy,
+  onReturn,
+  onResolve,
+}: {
+  session: NonNullable<Worktree["prSession"]>;
+  conflicting: boolean;
+  busy: Busy;
+  onReturn: () => void;
+  onResolve: () => void;
+}) {
+  const returning = busy?.kind === "return";
+  const resolving = busy?.kind === "conflicts";
+  return (
+    <div
+      style={{
+        flexShrink: 0,
+        display: "flex",
+        flexDirection: "column",
+        gap: "var(--space-2)",
+        padding: "var(--space-3)",
+        borderBottom: "var(--border-1)",
+        backgroundColor: "var(--surface-2)",
+      }}
+    >
+      <div
+        style={{
+          fontFamily: "var(--font-sans)",
+          fontSize: "var(--text-xs)",
+          color: "var(--text-primary)",
+          overflow: "hidden",
+          textOverflow: "ellipsis",
+          whiteSpace: "nowrap",
+        }}
+        title={session.title}
+      >
+        Reviewing{" "}
+        <span style={{ fontWeight: "var(--weight-semibold)" }}>
+          PR #{session.number}
+        </span>{" "}
+        — {session.title}
+      </div>
+      <div
+        style={{
+          fontFamily: "var(--font-mono)",
+          fontSize: "var(--text-2xs)",
+          color: "var(--text-tertiary)",
+        }}
+      >
+        on {session.branch}
+        {session.stashed && " · your changes are stashed"}
+      </div>
+      <div style={{ display: "flex", gap: "var(--space-2)" }}>
+        <BannerButton
+          label={
+            returning
+              ? "Returning…"
+              : `Back to ${session.originalBranch}`
+          }
+          primary
+          disabled={busy !== null}
+          onClick={onReturn}
+        />
+        {/* Always reachable — GitHub's mergeable flag lags pushes and
+            the session PR may not even be in the polled list, so the
+            user must be able to sync/resolve regardless. */}
+        <BannerButton
+          label={
+            resolving
+              ? "Resolving…"
+              : conflicting
+                ? "Resolve conflicts"
+                : "Sync with base"
+          }
+          disabled={busy !== null}
+          onClick={onResolve}
+        />
+      </div>
+    </div>
+  );
+}
+
+function BannerButton({
+  label,
+  primary,
+  disabled,
+  onClick,
+}: {
+  label: string;
+  primary?: boolean;
+  disabled: boolean;
+  onClick: () => void;
+}) {
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      disabled={disabled}
+      style={{
+        height: 24,
+        padding: "0 var(--space-3)",
+        borderRadius: "var(--radius-sm)",
+        backgroundColor: primary ? "var(--accent-press)" : "var(--surface-3)",
+        color: primary ? "#fff" : "var(--text-primary)",
+        fontSize: "var(--text-xs)",
+        fontWeight: "var(--weight-medium)",
+        cursor: disabled ? "default" : "pointer",
+        opacity: disabled ? 0.6 : 1,
+        overflow: "hidden",
+        textOverflow: "ellipsis",
+        whiteSpace: "nowrap",
+      }}
+    >
+      {label}
+    </button>
+  );
+}
+
+/* ------------------------------------------------------------------
+   One PR row — click opens the diff; hover actions do the rest.
+   ------------------------------------------------------------------ */
+
+function PrRow({
+  item,
+  checkedOut,
+  busy,
+  onOpen,
+  onCheckout,
+  onMerge,
+  onOpenExternal,
+}: {
+  item: PrListItem;
+  checkedOut: boolean;
+  busy: Busy;
+  onOpen: () => void;
+  onCheckout: () => void;
+  onMerge: () => void;
+  onOpenExternal: () => void;
+}) {
+  const [hover, setHover] = useState(false);
+  const conflicting = item.mergeable === "CONFLICTING";
+  // Any in-flight operation (including numberless ones like Return)
+  // disables every row's git-mutating actions — checkout/merge racing
+  // a checkout/pop in the same worktree corrupts the restore.
+  const anyBusy = busy !== null;
+  const rowBusy = anyBusy && "number" in busy && busy.number === item.number;
+  return (
+    <div
+      onMouseEnter={() => setHover(true)}
+      onMouseLeave={() => setHover(false)}
+      onClick={onOpen}
+      role="button"
+      tabIndex={0}
+      onKeyDown={(e) => {
+        if (e.key === "Enter") onOpen();
+      }}
+      style={{
+        display: "flex",
+        flexDirection: "column",
+        gap: 3,
+        padding: "var(--space-2) var(--space-3)",
+        borderBottom: "var(--border-1)",
+        backgroundColor: hover ? "var(--surface-2)" : "transparent",
+        cursor: "pointer",
+        transition: "background-color var(--motion-fast) var(--ease-out-quart)",
+      }}
+    >
+      <div style={{ display: "flex", alignItems: "center", gap: "var(--space-2)", minWidth: 0 }}>
+        <span
+          className="tabular"
+          style={{
+            fontFamily: "var(--font-mono)",
+            fontSize: "var(--text-2xs)",
+            color: "var(--text-tertiary)",
+            flexShrink: 0,
+          }}
+        >
+          #{item.number}
+        </span>
+        <span
+          style={{
+            fontFamily: "var(--font-sans)",
+            fontSize: "var(--text-xs)",
+            color: "var(--text-primary)",
+            overflow: "hidden",
+            textOverflow: "ellipsis",
+            whiteSpace: "nowrap",
+            minWidth: 0,
+            flex: 1,
+          }}
+          title={item.title}
+        >
+          {item.title}
+        </span>
+        {checkedOut && <Chip label="checked out" tone="accent" />}
+        {item.isDraft && <Chip label="draft" tone="muted" />}
+        {conflicting && <Chip label="conflicts" tone="warning" />}
+      </div>
+      <div
+        style={{
+          display: "flex",
+          alignItems: "center",
+          gap: "var(--space-2)",
+          minWidth: 0,
+          height: 18,
+        }}
+      >
+        <span
+          style={{
+            fontFamily: "var(--font-mono)",
+            fontSize: "var(--text-2xs)",
+            color: "var(--text-tertiary)",
+            overflow: "hidden",
+            textOverflow: "ellipsis",
+            whiteSpace: "nowrap",
+            minWidth: 0,
+            flex: 1,
+          }}
+          title={`${item.headRefName} → ${item.baseRefName}`}
+        >
+          {item.author && `${item.author} · `}
+          {item.headRefName} → {item.baseRefName}
+          {" · "}
+          <span style={{ color: "var(--diff-add-fg)" }}>+{item.additions}</span>{" "}
+          <span style={{ color: "var(--diff-remove-fg)" }}>
+            −{item.deletions}
+          </span>
+        </span>
+        {(hover || rowBusy) && (
+          <span
+            style={{ display: "inline-flex", alignItems: "center", gap: 3, flexShrink: 0 }}
+            onClick={(e) => e.stopPropagation()}
+          >
+            <RowAction
+              tip={
+                checkedOut
+                  ? "Already checked out"
+                  : "Check this PR out into the worktree (stashes current work)"
+              }
+              disabled={anyBusy || checkedOut}
+              onClick={onCheckout}
+            >
+              <ArrowsLeftRight size={13} />
+            </RowAction>
+            <RowAction tip="Open on GitHub" disabled={false} onClick={onOpenExternal}>
+              <ArrowSquareOut size={13} />
+            </RowAction>
+            <RowAction
+              tip={
+                item.isDraft
+                  ? "Draft PR — mark it ready for review first"
+                  : conflicting
+                    ? "Has conflicts — check out and resolve first"
+                    : "Merge this PR into its base branch"
+              }
+              disabled={anyBusy || conflicting || item.isDraft}
+              onClick={onMerge}
+              label={rowBusy && busy?.kind === "merge" ? "Merging…" : "Merge"}
+            >
+              <GitMerge size={12} weight="bold" />
+            </RowAction>
+          </span>
+        )}
+      </div>
+    </div>
+  );
+}
+
+/**
+ * One hover action on a PR row. The tip renders through the shared
+ * Tooltip primitive (not the native `title`) so it appears fast and
+ * matches the sidebar/tab-strip tips. Disabled state is aria-disabled
+ * with a guarded click rather than the `disabled` attribute — a truly
+ * disabled button swallows mouse events, and the tip is most useful
+ * exactly when the action is unavailable ("draft — mark ready first").
+ *
+ * With `label` the action renders as a prominent filled pill (the
+ * Merge button) instead of a bare 20px icon.
+ */
+function RowAction({
+  tip,
+  label,
+  disabled,
+  onClick,
+  children,
+}: {
+  tip: string;
+  label?: string;
+  disabled: boolean;
+  onClick: () => void;
+  children: React.ReactNode;
+}) {
+  const { ref, anchor, beginShow, cancelShow } =
+    useTooltipAnchor<HTMLButtonElement>();
+  const prominent = label !== undefined;
+  return (
+    <>
+      <button
+        ref={ref}
+        type="button"
+        aria-label={tip}
+        aria-disabled={disabled}
+        onMouseEnter={beginShow}
+        onMouseLeave={cancelShow}
+        onClick={() => {
+          cancelShow();
+          if (!disabled) onClick();
+        }}
+        style={{
+          display: "inline-flex",
+          alignItems: "center",
+          justifyContent: "center",
+          gap: 4,
+          height: 20,
+          width: prominent ? undefined : 20,
+          padding: prominent ? "0 var(--space-2)" : 0,
+          borderRadius: "var(--radius-xs)",
+          backgroundColor: prominent ? "var(--state-success-bg)" : "transparent",
+          border: prominent ? "1px solid var(--state-success)" : "none",
+          color: prominent
+            ? "var(--state-success-bright)"
+            : "var(--text-secondary)",
+          fontFamily: "var(--font-sans)",
+          fontSize: "var(--text-2xs)",
+          fontWeight: "var(--weight-semibold)",
+          whiteSpace: "nowrap",
+          cursor: disabled ? "default" : "pointer",
+          opacity: disabled ? 0.4 : 1,
+        }}
+      >
+        {children}
+        {label}
+      </button>
+      <AnimatePresence>
+        {anchor && <Tooltip label={tip} anchor={anchor} placement="above" />}
+      </AnimatePresence>
+    </>
+  );
+}
+
+function Chip({
+  label,
+  tone,
+}: {
+  label: string;
+  tone: "accent" | "muted" | "warning";
+}) {
+  const color =
+    tone === "warning"
+      ? "var(--state-warning)"
+      : tone === "accent"
+        ? "var(--accent-press)"
+        : "var(--text-tertiary)";
+  return (
+    <span
+      style={{
+        flexShrink: 0,
+        padding: "1px 6px",
+        borderRadius: "var(--radius-pill)",
+        border: `1px solid ${color}`,
+        color,
+        fontFamily: "var(--font-sans)",
+        fontSize: "var(--text-2xs)",
+        lineHeight: 1.4,
+        whiteSpace: "nowrap",
+      }}
+    >
+      {label}
+    </span>
+  );
+}
+
+function Empty({ label }: { label: string }) {
+  return (
+    <div
+      style={{
+        padding: "var(--space-6) var(--space-4)",
+        textAlign: "center",
+        color: "var(--text-tertiary)",
+        fontSize: "var(--text-xs)",
+        fontFamily: "var(--font-sans)",
+      }}
+    >
+      {label}
+    </div>
+  );
+}
+
diff --git a/src/git/conflictAgent.ts b/src/git/conflictAgent.ts
new file mode 100644
index 0000000..83b12fc
--- /dev/null
+++ b/src/git/conflictAgent.ts
@@ -0,0 +1,76 @@
+import { pr } from "@/lib/pr";
+import { termInput } from "@/lib/tauri/term";
+import { projectSettings, type Project, type Tab, type Worktree } from "@/state/types";
+
+/**
+ * Shared "merge the base branch in, then hand any conflicts to the
+ * worktree's agent" flow. Used by both WindowChrome's Resolve-conflicts
+ * button (for the worktree's own PR) and the PRs tab's session banner
+ * (for a checked-out PR) — one prompt, one PTY-selection policy.
+ */
+
+function isTerminal(t: Tab): t is Extract<Tab, { kind: "terminal" }> {
+  return t.kind === "terminal";
+}
+
+/** Prefer the active main-column terminal, then any terminal tab,
+ *  then the secondary panel's terminal. */
+export function findAgentPty(
+  worktree: Worktree,
+  tabs: Record<string, Tab>,
+): string | null {
+  const activeTab = worktree.activeTabId ? tabs[worktree.activeTabId] : null;
+  if (activeTab && isTerminal(activeTab)) return activeTab.ptyId;
+  for (const id of worktree.tabIds) {
+    const t = tabs[id];
+    if (t && isTerminal(t)) return t.ptyId;
+  }
+  return worktree.secondaryActiveTerminalId ?? worktree.secondaryPtyId ?? null;
+}
+
+export type ConflictHandoff =
+  | { kind: "clean"; alreadyUpToDate: boolean }
+  | { kind: "sent"; files: number }
+  | { kind: "no-agent"; files: number };
+
+/**
+ * Pull origin/`base` into the checked-out branch. When that leaves
+ * conflicts in the working tree, inject a resolution prompt into the
+ * worktree's agent terminal (user watches it work in real time, which
+ * beats a one-shot helper run for a multi-file edit). The caller turns
+ * the returned outcome into its own toasts.
+ */
+export async function mergeBaseAndHandOff(opts: {
+  path: string;
+  /** Base branch to merge in (e.g. the PR's `baseRefName`). */
+  base: string;
+  /** Spliced into the prompt: "pulling <base> into <branchLabel>". */
+  branchLabel: string;
+  worktree: Worktree;
+  tabs: Record<string, Tab>;
+  project: Project | null | undefined;
+}): Promise<ConflictHandoff> {
+  const result = await pr.mergeBaseIntoBranch(opts.path, opts.base);
+  if (!result.conflicts) {
+    return { kind: "clean", alreadyUpToDate: result.alreadyUpToDate };
+  }
+  const fileList = result.files.slice(0, 24).join(", ");
+  const cfg = projectSettings(opts.project);
+  const extras = [cfg.prefs.general, cfg.prefs.resolveConflicts]
+    .map((s) => s.trim())
+    .filter(Boolean)
+    .join("\n\n");
+  const prompt =
+    `Merge conflicts after pulling ${opts.base} into ${opts.branchLabel}. ` +
+    `Files: ${fileList}. ` +
+    `Read each conflicted file, resolve the <<<<<<<, =======, >>>>>>> markers ` +
+    `keeping the correct intent, then run \`git add <files>\`, \`git commit --no-edit\`, ` +
+    `and \`git push\`. Don't ask for confirmation between files — just resolve them all.` +
+    (extras ? `\n\n${extras}` : "");
+  const ptyId = findAgentPty(opts.worktree, opts.tabs);
+  if (!ptyId) return { kind: "no-agent", files: result.files.length };
+  await termInput(ptyId, new TextEncoder().encode(prompt + "\n")).catch(
+    () => undefined,
+  );
+  return { kind: "sent", files: result.files.length };
+}
diff --git a/src/lib/pr.ts b/src/lib/pr.ts
new file mode 100644
index 0000000..aab3420
--- /dev/null
+++ b/src/lib/pr.ts
@@ -0,0 +1,68 @@
+import { invoke } from "@tauri-apps/api/core";
+
+/**
+ * Frontend wrapper around the Rust-side PR commands (gh CLI under the
+ * hood). See src-tauri/src/pr.rs.
+ */
+
+export interface PrListItem {
+  number: number;
+  title: string;
+  url: string;
+  headRefName: string;
+  baseRefName: string;
+  author: string;
+  additions: number;
+  deletions: number;
+  changedFiles: number;
+  /** One of MERGEABLE, CONFLICTING, UNKNOWN. */
+  mergeable: string;
+  isDraft: boolean;
+  updatedAt: string;
+}
+
+export interface PrCheckoutResult {
+  originalBranch: string;
+  stashed: boolean;
+}
+
+export interface PrReturnResult {
+  /**
+   * False when a stash was expected but the tagged stash was gone —
+   * the branch switch happened, but nothing was restored.
+   */
+  stashRestored: boolean;
+}
+
+export interface ConflictResult {
+  conflicts: boolean;
+  files: string[];
+  alreadyUpToDate: boolean;
+}
+
+export const pr = {
+  /** Every open PR on the repo, newest first (gh's default order). */
+  list: (cwd: string) => invoke<PrListItem[]>("pr_list", { cwd }),
+  /** Full unified diff of a PR without checking it out. */
+  diff: (cwd: string, number: number) =>
+    invoke<string>("pr_diff", { cwd, number }),
+  /**
+   * Stash uncommitted work (tagged for restore) and check the PR's
+   * branch out into this worktree. The returned record is what the
+   * "go back" button needs — persist it on the worktree.
+   */
+  checkout: (cwd: string, number: number) =>
+    invoke<PrCheckoutResult>("pr_checkout", { cwd, number }),
+  /** Switch back to `branch` and pop the tagged stash if one was made. */
+  checkoutReturn: (cwd: string, branch: string, stashed: boolean) =>
+    invoke<PrReturnResult>("pr_checkout_return", { cwd, branch, stashed }),
+  /** Server-side merge via gh; deletes the remote branch on success. */
+  merge: (cwd: string, number: number, method: "merge" | "squash" | "rebase") =>
+    invoke<void>("pr_merge", { cwd, number, method }),
+  /**
+   * Pull origin/<base> into the checked-out branch. Conflicted files
+   * are left in the working tree with markers for resolution.
+   */
+  mergeBaseIntoBranch: (cwd: string, base: string) =>
+    invoke<ConflictResult>("merge_base_into_branch", { cwd, base }),
+};
diff --git a/src/shell/MainColumn.tsx b/src/shell/MainColumn.tsx
index 0c23040..114ceab 100644
--- a/src/shell/MainColumn.tsx
+++ b/src/shell/MainColumn.tsx
@@ -25,6 +25,7 @@ import { BlockTerminal } from "@/terminal/BlockTerminal";
 import { WarpSurfaceTracker } from "@/terminal/WarpSurfaceTracker";
 import { DiffView } from "@/git/DiffView";
 import { AllChangesView } from "@/git/AllChangesView";
+import { PrDiffView } from "@/git/PrDiffView";
 import { CommitDetailView } from "@/git/CommitDetailView";
 import { Editor } from "@/editor/Editor";
 import { MarkdownView } from "@/editor/MarkdownView";
@@ -565,6 +566,9 @@ function fullTabSummary(tab: Tab): string | null {
   if (tab.kind === "all-changes") {
     return trim(tab.title) || "All changes";
   }
+  if (tab.kind === "pr-diff") {
+    return trim(tab.title) || `PR #${tab.number}`;
+  }
   if (tab.kind === "commit") {
     return trim(tab.title) || trim(tab.hash) || "Commit";
   }
@@ -647,6 +651,9 @@ function tabLabel(tab: Tab): string {
   if (tab.kind === "all-changes") {
     return tab.title || "Changes";
   }
+  if (tab.kind === "pr-diff") {
+    return tab.title || `PR #${tab.number}`;
+  }
   if (tab.kind === "commit") {
     // Subject line on top; the short sha rides the summary line below.
     return tab.title || tab.hash.slice(0, 7);
@@ -910,6 +917,13 @@ function HalfPane({
             />
           ) : tab.kind === "all-changes" ? (
             <AllChangesView key={tab.id} projectPath={cwd} />
+          ) : tab.kind === "pr-diff" ? (
+            <PrDiffView
+              key={tab.id}
+              projectPath={cwd}
+              number={tab.number}
+              title={tab.title}
+            />
           ) : tab.kind === "commit" ? (
             <CommitDetailView
               key={tab.id}
diff --git a/src/shell/RightPanel.tsx b/src/shell/RightPanel.tsx
index 6efb9d0..7535e39 100644
--- a/src/shell/RightPanel.tsx
+++ b/src/shell/RightPanel.tsx
@@ -25,6 +25,7 @@ import { fs } from "@/lib/fs";
 import { git, type StatusEntry } from "@/lib/git";
 import { FileTree } from "@/files/FileTree";
 import { HistoryView } from "@/git/HistoryView";
+import { PrsView } from "@/git/PrsView";
 import { paneSlotStyle } from "./paneSlotLayout";
 import { BlockTerminal } from "@/terminal/BlockTerminal";
 import { WarpSurfaceTracker } from "@/terminal/WarpSurfaceTracker";
@@ -132,6 +133,12 @@ function UpperPanel({ worktree }: { worktree: Worktree }) {
           active={worktree.rightPanel === "changes"}
           badge={worktree.changeCount > 0 ? worktree.changeCount : undefined}
         />
+        <PanelTab
+          worktreeId={worktree.id}
+          label="PRs"
+          tab="prs"
+          active={worktree.rightPanel === "prs"}
+        />
         <PanelTab
           worktreeId={worktree.id}
           label="Skills"
@@ -177,6 +184,14 @@ function UpperPanel({ worktree }: { worktree: Worktree }) {
             refresh={status.refresh}
           />
         </PaneSlot>
+        <PaneSlot active={worktree.rightPanel === "prs"}>
+          <PrsView
+            worktree={worktree}
+            // Gates the gh-CLI polling — hidden panes stay quiet, same
+            // deal as BrowserPane's isVisible below.
+            isVisible={worktree.rightPanel === "prs"}
+          />
+        </PaneSlot>
         <PaneSlot active={worktree.rightPanel === "skills"}>
           <SkillsView worktree={worktree} />
         </PaneSlot>
diff --git a/src/shell/WindowChrome.tsx b/src/shell/WindowChrome.tsx
index b1a4957..ca098eb 100644
--- a/src/shell/WindowChrome.tsx
+++ b/src/shell/WindowChrome.tsx
@@ -1,7 +1,6 @@
 import {
   useCallback,
   useEffect,
-  useMemo,
   useRef,
   useState,
   type ComponentType,
@@ -24,8 +23,9 @@ import {
   useAppState,
 } from "@/state/AppState";
 import { useToast } from "@/primitives/Toast";
-import { projectSettings, type Tab, type Worktree } from "@/state/types";
+import { projectSettings, type Worktree } from "@/state/types";
 import { collectWorktreePtyIds, worktreeArchive } from "@/lib/worktrees";
+import { mergeBaseAndHandOff } from "@/git/conflictAgent";
 import { forgetPtys } from "@/terminal/sessionMemory";
 
 const TRAFFIC_LIGHT_GUTTER = 78;
@@ -49,12 +49,6 @@ interface PrStatus {
   mergeable: string | null;
 }
 
-interface ConflictResult {
-  conflicts: boolean;
-  files: string[];
-  alreadyUpToDate: boolean;
-}
-
 /**
  * Thin window-chrome strip pinned to the very top of the app. Houses
  * the search summoner (centered) and the per-branch action button on
@@ -214,26 +208,6 @@ function BranchActionButton({ worktree }: { worktree: Worktree | null }) {
     void archiveAfterMerge();
   }, [archiveOnMerge, worktree, pr?.state, archiveAfterMerge]);
 
-  // Find a terminal-tab PTY to inject a prompt into when delegating
-  // conflict resolution to the agent. Falls back to the secondary
-  // panel's active terminal if no main-column terminal is open.
-  const targetPtyId = useMemo(() => {
-    if (!worktree) return null;
-    const activeTab = worktree.activeTabId
-      ? state.tabs[worktree.activeTabId]
-      : null;
-    if (activeTab && isTerminal(activeTab)) return activeTab.ptyId;
-    for (const id of worktree.tabIds) {
-      const t = state.tabs[id];
-      if (t && isTerminal(t)) return t.ptyId;
-    }
-    return (
-      worktree.secondaryActiveTerminalId ??
-      worktree.secondaryPtyId ??
-      null
-    );
-  }, [worktree, state.tabs]);
-
   const merge = useCallback(async () => {
     if (!worktree || !pr?.number) return;
     setBusy(true);
@@ -265,11 +239,17 @@ function BranchActionButton({ worktree }: { worktree: Worktree | null }) {
     if (!worktree) return;
     setBusy(true);
     try {
-      const result = await invoke<ConflictResult>(
-        "merge_base_into_branch",
-        { cwd: path, base: "main" },
-      );
-      if (!result.conflicts) {
+      // Shared with the PRs tab's session banner — one prompt, one
+      // PTY-selection policy (see conflictAgent.ts).
+      const result = await mergeBaseAndHandOff({
+        path,
+        base: "main",
+        branchLabel: "this branch",
+        worktree,
+        tabs: state.tabs,
+        project: state.projects[worktree.projectId],
+      });
+      if (result.kind === "clean") {
         window.dispatchEvent(
           new CustomEvent("goonware-git-refresh", { detail: { cwd: path } }),
         );
@@ -281,43 +261,20 @@ function BranchActionButton({ worktree }: { worktree: Worktree | null }) {
         await refresh();
         return;
       }
-      // Conflicts present in working tree. Hand off to the worktree's
-      // agent via PTY injection — user sees the agent work in real
-      // time, which beats a one-shot helperRun for a multi-file edit.
-      const fileList = result.files.slice(0, 24).join(", ");
-      const project = state.projects[worktree.projectId];
-      const cfg = projectSettings(project);
-      const extras = [cfg.prefs.general, cfg.prefs.resolveConflicts]
-        .map((s) => s.trim())
-        .filter(Boolean)
-        .join("\n\n");
-      const prompt =
-        `Merge conflicts after pulling main into this branch. ` +
-        `Files: ${fileList}. ` +
-        `Read each conflicted file, resolve the <<<<<<<, =======, >>>>>>> markers ` +
-        `keeping the correct intent, then run \`git add <files>\`, \`git commit --no-edit\`, ` +
-        `and \`git push\`. Don't ask for confirmation between files — just resolve them all.` +
-        (extras ? `\n\n${extras}` : "");
-      if (targetPtyId) {
-        const bytes = stringToUtf8Bytes(prompt + "\n");
-        await invoke("term_input", { id: targetPtyId, data: bytes }).catch(
-          () => undefined,
-        );
-        toast.show({
-          message: `Conflicts in ${result.files.length} file${result.files.length === 1 ? "" : "s"} — sent to agent.`,
-        });
-      } else {
-        toast.show({
-          message: `Conflicts in ${result.files.length} file${result.files.length === 1 ? "" : "s"}. Open your agent terminal and ask it to resolve.`,
-        });
-      }
+      const files = `${result.files} file${result.files === 1 ? "" : "s"}`;
+      toast.show({
+        message:
+          result.kind === "sent"
+            ? `Conflicts in ${files} — sent to agent.`
+            : `Conflicts in ${files}. Open your agent terminal and ask it to resolve.`,
+      });
       await refresh();
     } catch (e) {
       toast.show({ message: `Resolve failed: ${e}` });
     } finally {
       setBusy(false);
     }
-  }, [worktree, path, targetPtyId, refresh, toast]);
+  }, [worktree, path, state.projects, state.tabs, refresh, toast]);
 
   const openCreatePR = (m: "manual" | "auto") => {
     if (!worktree) return;
@@ -657,15 +614,6 @@ function intentText(intent: ButtonIntent): string {
   return "color-mix(in oklch, var(--text-primary), var(--accent) 35%)";
 }
 
-function isTerminal(t: Tab): t is Extract<Tab, { kind: "terminal" }> {
-  return t.kind === "terminal";
-}
-
-function stringToUtf8Bytes(s: string): number[] {
-  const enc = new TextEncoder();
-  return Array.from(enc.encode(s));
-}
-
 /**
  * Centered search summoner. Pill-shaped tall input styled after the
  * search modal — prominent leading magnifier, dark surface that pops
diff --git a/src/state/reducer.ts b/src/state/reducer.ts
index 175c97c..6ab6e42 100644
--- a/src/state/reducer.ts
+++ b/src/state/reducer.ts
@@ -691,6 +691,8 @@ function sameTabTarget(a: Tab, b: Tab): boolean {
       return a.kind === "project-settings" && a.projectId === b.projectId;
     case "all-changes":
       return true;
+    case "pr-diff":
+      return a.kind === "pr-diff" && a.number === b.number;
     case "commit":
       return a.kind === "commit" && a.hash === b.hash;
   }
diff --git a/src/state/types.ts b/src/state/types.ts
index 65820f8..2203e1a 100644
--- a/src/state/types.ts
+++ b/src/state/types.ts
@@ -191,9 +191,37 @@ export function projectSettings(project: Project | null | undefined): ProjectSet
    target, and a secondary terminal in the right panel.
    ------------------------------------------------------------------ */
 
-export type RightPanelTab = "files" | "changes" | "skills" | "browser";
+export type RightPanelTab = "files" | "changes" | "prs" | "skills" | "browser";
 export type SecondaryTab = "setup" | "run" | "terminal";
 
+/**
+ * A "reviewing a PR" session on a worktree. Set when the user checks
+ * a PR out from the PRs tab: their uncommitted work is stashed (tagged
+ * so nothing else can pop it by accident) and the PR's head branch is
+ * checked out in place. Cleared by the Return flow, which restores the
+ * original branch and pops the stash. Persisted with the worktree so
+ * the "go back" affordance survives restarts.
+ */
+export interface PrSession {
+  /** PR number checked out into the worktree. */
+  number: number;
+  /** PR head branch currently checked out. */
+  branch: string;
+  /** PR title, for the banner label. */
+  title: string;
+  /** Branch to return to when the session ends. */
+  originalBranch: string;
+  /**
+   * PR base branch (merge target), captured at checkout so conflict
+   * resolution never has to guess it from the (possibly truncated or
+   * still-loading) PR list. Optional only for sessions persisted
+   * before the field existed.
+   */
+  baseBranch?: string;
+  /** True when pre-checkout dirty state was stashed (and must pop back). */
+  stashed: boolean;
+}
+
 export interface Worktree {
   id: WorktreeId;
   projectId: ProjectId;
@@ -243,6 +271,8 @@ export interface Worktree {
   color?: TagId;
   /** User-picked HugeIcons component name (overrides project's choice). */
   iconName?: string;
+  /** Active PR-review session, if the worktree is checked out to a PR. */
+  prSession?: PrSession | null;
   /**
    * True when the backing directory on disk has gone missing between
    * launches (e.g. the user deleted it manually). Transient — set by a
@@ -330,6 +360,17 @@ export interface AllChangesTab extends TabBase {
   kind: "all-changes";
 }
 
+/**
+ * Tab variant rendering an open PR's full diff (via `gh pr diff`) in
+ * the main column. Opened by clicking a row in the PRs panel. Only the
+ * number is stored — the view fetches the diff live, so new pushes to
+ * the PR fold in on the next refresh.
+ */
+export interface PrDiffTab extends TabBase {
+  kind: "pr-diff";
+  number: number;
+}
+
 /**
  * Tab variant showing one commit from the history graph: metadata
  * (author, sha, parents, refs, message) plus the full diff the commit
@@ -347,6 +388,7 @@ export type Tab =
   | MarkdownTab
   | ProjectSettingsTab
   | AllChangesTab
+  | PrDiffTab
   | CommitTab;
 
 /**

From 6e5e4d42aaa4f3bad3295f237f1e8fb89d1cdcdc Mon Sep 17 00:00:00 2001
From: raeedz <raeedz@gmail.com>
Date: Sun, 5 Jul 2026 23:13:26 -0700
Subject: [PATCH 9/9] Add PR review-state system, replace pr_diff with
 soft-reset flow

Introduces pr_review_enter/pr_review_restore to stage a PR's diff via
merge-base soft-reset so it renders in the normal changes UI, and adds
a self-review guard preventing pr_checkout from clobbering the
worktree's own branch.
---
 src-tauri/src/lib.rs     |   3 +-
 src-tauri/src/pr.rs      | 349 ++++++++++++++++++++++++++++++++++++---
 src/git/PrDiffView.tsx   | 197 ----------------------
 src/git/PrsView.tsx      | 142 ++++++++++++----
 src/lib/pr.ts            |  56 +++++--
 src/shell/MainColumn.tsx |  14 --
 src/state/reducer.ts     |   2 -
 src/state/types.ts       |  20 +--
 8 files changed, 483 insertions(+), 300 deletions(-)
 delete mode 100644 src/git/PrDiffView.tsx

diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 5d64dd7..00e3a93 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -249,9 +249,10 @@ pub fn run() {
             pr::gh_username,
             // PRs tab (list / review / checkout / return)
             pr::pr_list,
-            pr::pr_diff,
             pr::pr_checkout,
             pr::pr_checkout_return,
+            pr::pr_review_enter,
+            pr::pr_review_restore,
             // Connections (Task #10)
             connections::connections_scan,
             // Search (Task #15)
diff --git a/src-tauri/src/pr.rs b/src-tauri/src/pr.rs
index 792bdae..dd0e710 100644
--- a/src-tauri/src/pr.rs
+++ b/src-tauri/src/pr.rs
@@ -53,6 +53,10 @@ pub struct PrListItem {
 pub struct PrCheckoutResult {
     pub original_branch: String,
     pub stashed: bool,
+    /// Branch head at checkout time — what `pr_checkout_return` needs
+    /// to undo the review-state soft reset. None when review state
+    /// could not be established (the branch is checked out normally).
+    pub head_sha: Option<String>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -679,27 +683,106 @@ pub async fn pr_list(cwd: String) -> Result<Vec<PrListItem>, String> {
         .collect())
 }
 
-/// Unified diff of a PR (`gh pr diff <number>`) — lets the PRs tab
-/// show the full review diff without checking the branch out.
+/// Put the checked-out PR branch into "review state": HEAD soft-reset
+/// to the merge-base with `base`, so the PR's entire diff shows up as
+/// staged changes and flows through the app's normal changes UI (the
+/// Changes tab, the all-changes view, per-file diffs) instead of a
+/// bespoke PR-diff surface. Returns the branch head sha needed to undo
+/// this later.
+///
+/// Best-effort by design: any failure past resolving HEAD leaves the
+/// branch checked out normally and still returns the sha — the
+/// checkout already succeeded, and the caller must be able to offer
+/// the way back regardless.
+async fn enter_review_state(cwd: &str, base: &str) -> Option<String> {
+    let head_sha = run_git_checked(cwd, &["rev-parse", "HEAD"])
+        .await
+        .ok()?
+        .trim()
+        .to_string();
+    if head_sha.is_empty() || base.is_empty() {
+        return if head_sha.is_empty() { None } else { Some(head_sha) };
+    }
+    // origin/<base> may be stale or absent locally; refresh best-effort.
+    // Non-interactive and timeboxed — a fetch that wants credentials or
+    // a dead network must degrade to "merge-base against the local ref",
+    // never hang the checkout.
+    let mut fetch = Command::new("git");
+    fetch
+        .args(["fetch", "origin", base])
+        .current_dir(cwd)
+        .stdin(std::process::Stdio::null());
+    for (k, v) in NON_INTERACTIVE_GIT_ENV {
+        fetch.env(k, v);
+    }
+    let _ = tokio::time::timeout(std::time::Duration::from_secs(20), fetch.output()).await;
+    let origin_base = format!("origin/{base}");
+    let merge_base = match run_git_checked(cwd, &["merge-base", &origin_base, "HEAD"]).await {
+        Ok(s) => s.trim().to_string(),
+        Err(_) => match run_git_checked(cwd, &["merge-base", base, "HEAD"]).await {
+            Ok(s) => s.trim().to_string(),
+            Err(_) => return Some(head_sha),
+        },
+    };
+    if !merge_base.is_empty() && merge_base != head_sha {
+        let _ = run_git_checked(cwd, &["reset", "--soft", &merge_base]).await;
+    }
+    Some(head_sha)
+}
+
+/// Undo `enter_review_state`: move the branch ref forward to the
+/// recorded head. Soft, so any review edits stay in the index/worktree
+/// as diffs against the real head — lossless. Only acts when HEAD is
+/// an ancestor of `head_sha` (the soft reset is still in effect); if
+/// the user or an agent committed on top, resetting would drop those
+/// commits from the branch, so we leave everything alone and report
+/// false.
+async fn restore_review_state(cwd: &str, head_sha: &str) -> Result<bool, String> {
+    let head = run_git_checked(cwd, &["rev-parse", "HEAD"])
+        .await?
+        .trim()
+        .to_string();
+    if head == head_sha {
+        return Ok(false);
+    }
+    let ancestor = Command::new("git")
+        .args(["merge-base", "--is-ancestor", "HEAD", head_sha])
+        .current_dir(cwd)
+        .output()
+        .await
+        .map_err(|e| format!("spawn git: {e}"))?
+        .status
+        .success();
+    if !ancestor {
+        return Ok(false);
+    }
+    run_git_checked(cwd, &["reset", "--soft", head_sha]).await?;
+    Ok(true)
+}
+
+/// Re-establish review state on an already-checked-out PR branch —
+/// used after a clean base merge so the (now conflict-free) PR diff
+/// shows as staged changes again. Returns the new head sha to persist.
 #[tauri::command]
-pub async fn pr_diff(cwd: String, number: u64) -> Result<String, String> {
+pub async fn pr_review_enter(cwd: String, base: String) -> Result<Option<String>, String> {
     if !Path::new(&cwd).exists() {
         return Err(format!("cwd does not exist: {cwd}"));
     }
-    let num = number.to_string();
-    let out = Command::new("gh")
-        .args(["pr", "diff", &num])
-        .current_dir(&cwd)
-        .output()
-        .await
-        .map_err(|e| format!("spawn gh: {e}. Is GitHub CLI installed? `brew install gh`"))?;
-    if !out.status.success() {
-        return Err(format!(
-            "gh pr diff failed: {}",
-            String::from_utf8_lossy(&out.stderr).trim()
-        ));
+    Ok(enter_review_state(&cwd, &base).await)
+}
+
+/// Leave review state (branch ref back on the real head) without
+/// switching branches — the step before any operation that needs the
+/// branch in its true shape, e.g. merging the base in.
+#[tauri::command]
+pub async fn pr_review_restore(cwd: String, head_sha: String) -> Result<bool, String> {
+    if !Path::new(&cwd).exists() {
+        return Err(format!("cwd does not exist: {cwd}"));
     }
-    Ok(String::from_utf8_lossy(&out.stdout).into_owned())
+    if head_sha.is_empty() {
+        return Ok(false);
+    }
+    restore_review_state(&cwd, &head_sha).await
 }
 
 /// Message marker on the auto-stash created by `pr_checkout`, suffixed
@@ -732,14 +815,22 @@ async fn find_pr_stash(cwd: &str, branch: &str) -> Option<String> {
 }
 
 /// Turn the worktree into a review environment for a PR: stash any
-/// uncommitted work (tagged so we can restore it later), then
-/// `gh pr checkout <number>`. Returns what the caller needs to offer a
-/// "go back" button — the original branch and whether a stash was made.
+/// uncommitted work (tagged so we can restore it later), `gh pr
+/// checkout <number>`, then soft-reset to the merge-base with `base`
+/// so the PR's whole diff appears as staged changes in the normal
+/// changes UI. Returns what the caller needs to offer a "go back"
+/// button — the original branch, whether a stash was made, and the PR
+/// branch's real head sha.
 ///
 /// If the checkout itself fails the stash is popped back immediately so
 /// the user's work never silently disappears into the stash list.
 #[tauri::command]
-pub async fn pr_checkout(cwd: String, number: u64) -> Result<PrCheckoutResult, String> {
+pub async fn pr_checkout(
+    cwd: String,
+    number: u64,
+    base: String,
+    head: String,
+) -> Result<PrCheckoutResult, String> {
     if !Path::new(&cwd).exists() {
         return Err(format!("cwd does not exist: {cwd}"));
     }
@@ -752,6 +843,29 @@ pub async fn pr_checkout(cwd: String, number: u64) -> Result<PrCheckoutResult, S
         return Err("could not determine current branch (detached HEAD?)".into());
     }
 
+    // Reviewing the PR that IS this worktree's branch would stash the
+    // user's own work-in-progress and soft-reset their working branch
+    // in place — and when the worktree hosts a running dev build, that
+    // rewrites the app's own sources mid-flight. There is nothing to
+    // check out; refuse up front.
+    if !head.is_empty() && head == original_branch {
+        return Err(format!(
+            "PR #{number}'s branch (`{head}`) is what this worktree is already on — \
+             this worktree IS that PR. Review it from a different branch or worktree."
+        ));
+    }
+
+    // A tagged stash for this branch means an earlier review session
+    // never finished (e.g. the app died mid-checkout). Stacking a
+    // second stash under the same tag would make the eventual pop
+    // ambiguous — refuse and point at the recovery path instead.
+    if find_pr_stash(&cwd, &original_branch).await.is_some() {
+        return Err(format!(
+            "A previous PR review left stashed work on `{original_branch}` \
+             (see `git stash list`). Pop or drop that stash, then retry."
+        ));
+    }
+
     let porcelain = run_git_checked(&cwd, &["status", "--porcelain"]).await?;
     let dirty = porcelain.lines().any(|l| !l.trim().is_empty());
     let mut stashed = false;
@@ -803,16 +917,23 @@ pub async fn pr_checkout(cwd: String, number: u64) -> Result<PrCheckoutResult, S
         }
         return Err(msg);
     }
+    // Best-effort past this point — the checkout succeeded, so the
+    // session record (and its way back) must reach the caller even if
+    // review state couldn't be established.
+    let head_sha = enter_review_state(&cwd, &base).await;
     Ok(PrCheckoutResult {
         original_branch,
         stashed,
+        head_sha,
     })
 }
 
-/// Undo `pr_checkout`: switch back to the original branch and pop the
-/// tagged stash if one was made. Fails loudly if the PR branch has
-/// uncommitted edits (git refuses the checkout) — the user decides
-/// whether to commit or discard those, we never do it for them.
+/// Undo `pr_checkout`: put the PR branch back on its real head (the
+/// review-state soft reset would otherwise carry the whole PR diff
+/// onto the original branch as staged changes), switch back, and pop
+/// the tagged stash if one was made. Fails loudly if the PR branch has
+/// review edits (git refuses the checkout) — the user decides whether
+/// to commit or discard those, we never do it for them.
 ///
 /// `stash_restored` is false when `stashed` was set but the tagged
 /// stash no longer exists (e.g. the user popped it by hand) — the
@@ -822,6 +943,7 @@ pub async fn pr_checkout_return(
     cwd: String,
     branch: String,
     stashed: bool,
+    head_sha: Option<String>,
 ) -> Result<PrReturnResult, String> {
     if !Path::new(&cwd).exists() {
         return Err(format!("cwd does not exist: {cwd}"));
@@ -829,6 +951,11 @@ pub async fn pr_checkout_return(
     if branch.is_empty() {
         return Err("no branch to return to".into());
     }
+    // A failed restore must abort the return: checking out with the
+    // PR's diff still staged would splat it onto the original branch.
+    if let Some(sha) = head_sha.as_deref().filter(|s| !s.is_empty()) {
+        restore_review_state(&cwd, sha).await?;
+    }
     run_git_checked(&cwd, &["checkout", &branch]).await?;
     let mut stash_restored = false;
     if stashed {
@@ -1502,7 +1629,7 @@ mod tests {
         std::fs::write(clone.path().join("other.txt"), "other\n").unwrap();
         run_sync(clone.path(), &["stash", "push", "-u", "-m", "user stash"]);
 
-        let result = pr_checkout_return(cwd.to_string(), "feature/mine".to_string(), true)
+        let result = pr_checkout_return(cwd.to_string(), "feature/mine".to_string(), true, None)
             .await
             .expect("return succeeds");
         assert!(result.stash_restored, "tagged stash should be reported restored");
@@ -1530,7 +1657,7 @@ mod tests {
         let cwd = clone.path().to_str().unwrap();
         run_sync(clone.path(), &["checkout", "-b", "pr-branch"]);
 
-        let result = pr_checkout_return(cwd.to_string(), "feature/clean".to_string(), false)
+        let result = pr_checkout_return(cwd.to_string(), "feature/clean".to_string(), false, None)
             .await
             .expect("return succeeds");
         assert!(!result.stash_restored, "no stash existed to restore");
@@ -1559,7 +1686,7 @@ mod tests {
         );
         run_sync(clone.path(), &["checkout", "-b", "pr-branch"]);
 
-        let result = pr_checkout_return(cwd.to_string(), "feature/mine".to_string(), true)
+        let result = pr_checkout_return(cwd.to_string(), "feature/mine".to_string(), true, None)
             .await
             .expect("return succeeds");
         assert!(
@@ -1572,4 +1699,172 @@ mod tests {
             "the other branch's stash must survive: {stashes}"
         );
     }
+
+    // ---- pr_checkout guards ----------------------------------------------
+
+    #[tokio::test]
+    async fn checkout_refuses_the_worktrees_own_branch() {
+        // Reviewing the PR whose head IS the current branch would stash
+        // the user's WIP and soft-reset their own working branch —
+        // refuse before touching anything.
+        let (clone, _bare) = build_repo_with_bare_remote("feature/mine");
+        let cwd = clone.path().to_str().unwrap();
+        std::fs::write(clone.path().join("wip.txt"), "wip\n").unwrap();
+
+        let err = pr_checkout(
+            cwd.to_string(),
+            7,
+            "main".to_string(),
+            "feature/mine".to_string(),
+        )
+        .await
+        .expect_err("same-branch checkout must refuse");
+        assert!(err.contains("already on"), "unexpected error: {err}");
+
+        // Nothing was stashed or moved.
+        assert!(clone.path().join("wip.txt").exists());
+        let stashes = run_sync(clone.path(), &["stash", "list"]);
+        assert!(stashes.trim().is_empty(), "no stash expected: {stashes}");
+    }
+
+    #[tokio::test]
+    async fn checkout_refuses_when_a_tagged_stash_already_exists() {
+        // A leftover tagged stash means a previous session never
+        // finished — a second checkout must not stack another stash
+        // under the same tag.
+        let (clone, _bare) = build_repo_with_bare_remote("feature/mine");
+        let cwd = clone.path().to_str().unwrap();
+        std::fs::write(clone.path().join("old-wip.txt"), "stranded\n").unwrap();
+        run_sync(
+            clone.path(),
+            &[
+                "stash",
+                "push",
+                "-u",
+                "-m",
+                &format!("{PR_STASH_MARKER}:feature/mine"),
+            ],
+        );
+
+        let err = pr_checkout(
+            cwd.to_string(),
+            7,
+            "main".to_string(),
+            "someone-elses-branch".to_string(),
+        )
+        .await
+        .expect_err("existing tagged stash must refuse");
+        assert!(err.contains("stash"), "unexpected error: {err}");
+
+        // The stranded stash is untouched — exactly one, same tag.
+        let stashes = run_sync(clone.path(), &["stash", "list"]);
+        assert_eq!(
+            stashes.matches(PR_STASH_MARKER).count(),
+            1,
+            "stash list changed: {stashes}"
+        );
+    }
+
+    // ---- review state (soft reset to merge-base) --------------------------
+
+    /// Repo with main pushed to a bare remote plus a two-commit
+    /// "PR branch" checked out. Returns (clone, bare, pr_head_sha).
+    fn build_pr_branch_repo() -> (TempDir, TempDir, String) {
+        let (clone, bare) = build_repo_on_main("main");
+        run_sync(clone.path(), &["checkout", "-b", "pr-branch"]);
+        std::fs::write(clone.path().join("a.txt"), "one\n").unwrap();
+        run_sync(clone.path(), &["add", "a.txt"]);
+        run_sync(clone.path(), &["commit", "-m", "pr commit 1"]);
+        std::fs::write(clone.path().join("b.txt"), "two\n").unwrap();
+        run_sync(clone.path(), &["add", "b.txt"]);
+        run_sync(clone.path(), &["commit", "-m", "pr commit 2"]);
+        let head = run_sync(clone.path(), &["rev-parse", "HEAD"]).trim().to_string();
+        (clone, bare, head)
+    }
+
+    #[tokio::test]
+    async fn enter_review_state_stages_pr_diff_and_restore_undoes_it() {
+        let (clone, _bare, pr_head) = build_pr_branch_repo();
+        let cwd = clone.path().to_str().unwrap();
+
+        let returned = enter_review_state(cwd, "main").await;
+        assert_eq!(returned.as_deref(), Some(pr_head.as_str()));
+
+        // HEAD sits on the merge-base; the PR's files are staged.
+        let mb = run_sync(clone.path(), &["merge-base", "origin/main", &pr_head]);
+        let head_now = run_sync(clone.path(), &["rev-parse", "HEAD"]);
+        assert_eq!(head_now.trim(), mb.trim());
+        let staged = run_sync(clone.path(), &["diff", "--cached", "--name-only"]);
+        assert!(staged.contains("a.txt") && staged.contains("b.txt"),
+            "PR files should show as staged: {staged}");
+
+        // Restore: branch ref back on the real head, tree clean.
+        let did = restore_review_state(cwd, &pr_head).await.expect("restore");
+        assert!(did, "restore should have acted");
+        let head_after = run_sync(clone.path(), &["rev-parse", "HEAD"]);
+        assert_eq!(head_after.trim(), pr_head);
+        let porcelain = run_sync(clone.path(), &["status", "--porcelain"]);
+        assert!(porcelain.trim().is_empty(), "expected clean tree: {porcelain}");
+    }
+
+    #[tokio::test]
+    async fn restore_review_state_refuses_when_commits_were_made_on_top() {
+        let (clone, _bare, pr_head) = build_pr_branch_repo();
+        let cwd = clone.path().to_str().unwrap();
+        enter_review_state(cwd, "main").await.expect("enter");
+
+        // Simulate a takeover: commit the staged review diff as one
+        // new commit. HEAD is no longer an ancestor of the PR head.
+        run_sync(clone.path(), &["commit", "-m", "review takeover"]);
+        let new_head = run_sync(clone.path(), &["rev-parse", "HEAD"]).trim().to_string();
+
+        let did = restore_review_state(cwd, &pr_head).await.expect("restore call");
+        assert!(!did, "must not reset past user commits");
+        let head_after = run_sync(clone.path(), &["rev-parse", "HEAD"]);
+        assert_eq!(head_after.trim(), new_head, "takeover commit must survive");
+    }
+
+    #[tokio::test]
+    async fn checkout_return_with_head_sha_restores_branch_before_switching() {
+        let (clone, _bare, pr_head) = build_pr_branch_repo();
+        let cwd = clone.path().to_str().unwrap();
+        enter_review_state(cwd, "main").await.expect("enter");
+
+        let result = pr_checkout_return(
+            cwd.to_string(),
+            "main".to_string(),
+            false,
+            Some(pr_head.clone()),
+        )
+        .await
+        .expect("return succeeds");
+        assert!(!result.stash_restored);
+
+        // Back on main with a clean tree — the PR diff did NOT come along.
+        let branch = run_sync(clone.path(), &["symbolic-ref", "--short", "HEAD"]);
+        assert_eq!(branch.trim(), "main");
+        let porcelain = run_sync(clone.path(), &["status", "--porcelain"]);
+        assert!(porcelain.trim().is_empty(), "expected clean tree: {porcelain}");
+        // And the PR branch still points at its real head.
+        let pr_ref = run_sync(clone.path(), &["rev-parse", "pr-branch"]);
+        assert_eq!(pr_ref.trim(), pr_head);
+    }
+
+    #[tokio::test]
+    async fn review_edits_survive_restore_as_uncommitted_changes() {
+        let (clone, _bare, pr_head) = build_pr_branch_repo();
+        let cwd = clone.path().to_str().unwrap();
+        enter_review_state(cwd, "main").await.expect("enter");
+
+        // Edit a PR file during review.
+        std::fs::write(clone.path().join("a.txt"), "one edited\n").unwrap();
+
+        let did = restore_review_state(cwd, &pr_head).await.expect("restore");
+        assert!(did);
+        // The edit remains, now as a plain uncommitted diff vs the head.
+        let porcelain = run_sync(clone.path(), &["status", "--porcelain"]);
+        assert!(porcelain.contains("a.txt"), "edit must survive: {porcelain}");
+        let content = std::fs::read_to_string(clone.path().join("a.txt")).unwrap();
+        assert_eq!(content, "one edited\n");
+    }
 }
diff --git a/src/git/PrDiffView.tsx b/src/git/PrDiffView.tsx
deleted file mode 100644
index 29bd7b2..0000000
--- a/src/git/PrDiffView.tsx
+++ /dev/null
@@ -1,197 +0,0 @@
-import { useEffect, useMemo, useRef, useState } from "react";
-import { motion } from "motion/react";
-import { pr } from "@/lib/pr";
-import { FileBlock, sliceByFile, type FileSection } from "./AllChangesView";
-
-/**
- * Full diff of an open PR, one collapsible section per file — the
- * main-column body of a `pr-diff` tab. Fetches `gh pr diff <number>`
- * live (no checkout needed) and reuses the AllChangesView slicing +
- * FileBlock renderer so tinting, line numbers, and sticky file headers
- * match the working-tree diff views exactly. Listens to
- * `goonware-git-refresh` so a push to the PR branch (e.g. after
- * resolving conflicts in a checked-out session) re-pulls the diff.
- */
-export function PrDiffView({
-  projectPath,
-  number,
-  title,
-}: {
-  projectPath: string;
-  number: number;
-  title: string;
-}) {
-  const [raw, setRaw] = useState<string | null>(null);
-  const [error, setError] = useState<string | null>(null);
-  const inFlight = useRef(false);
-  const rerun = useRef(false);
-
-  useEffect(() => {
-    let cancelled = false;
-    // git-refresh fires for every git operation in the worktree, so:
-    // keep showing the current diff while the refetch runs (no blank
-    // flash), skip identical payloads (setRaw keeps the old identity
-    // so sliceByFile doesn't re-parse), and coalesce events that land
-    // mid-fetch into one trailing refetch instead of piling up gh
-    // subprocesses.
-    const refresh = () => {
-      if (inFlight.current) {
-        rerun.current = true;
-        return;
-      }
-      inFlight.current = true;
-      pr.diff(projectPath, number)
-        .then((d) => {
-          if (cancelled) return;
-          setRaw((prev) => (prev === d ? prev : d));
-          setError(null);
-        })
-        .catch((e) => {
-          if (!cancelled) setError(String(e));
-        })
-        .finally(() => {
-          inFlight.current = false;
-          if (rerun.current && !cancelled) {
-            rerun.current = false;
-            refresh();
-          }
-        });
-    };
-    refresh();
-    const onRefresh = (e: Event) => {
-      const detail = (e as CustomEvent<{ cwd?: string }>).detail;
-      if (!detail?.cwd || detail.cwd === projectPath) refresh();
-    };
-    window.addEventListener("goonware-git-refresh", onRefresh);
-    return () => {
-      cancelled = true;
-      window.removeEventListener("goonware-git-refresh", onRefresh);
-    };
-  }, [projectPath, number]);
-
-  const sections = useMemo<FileSection[]>(
-    () => (raw ? sliceByFile(raw) : []),
-    [raw],
-  );
-
-  const totals = useMemo(() => {
-    let add = 0;
-    let rem = 0;
-    for (const s of sections) {
-      for (const l of s.lines) {
-        if (l.kind === "add") add++;
-        else if (l.kind === "remove") rem++;
-      }
-    }
-    return { add, rem, files: sections.length };
-  }, [sections]);
-
-  return (
-    <motion.div
-      initial={{ opacity: 0, y: 4 }}
-      animate={{ opacity: 1, y: 0 }}
-      transition={{ duration: 0.14, ease: [0.25, 1, 0.5, 1] }}
-      style={{
-        position: "absolute",
-        inset: 0,
-        display: "flex",
-        flexDirection: "column",
-        backgroundColor: "var(--surface-0)",
-        overflow: "hidden",
-      }}
-    >
-      <div
-        style={{
-          height: 36,
-          flexShrink: 0,
-          display: "flex",
-          alignItems: "center",
-          gap: "var(--space-3)",
-          padding: "0 var(--space-3)",
-          backgroundColor: "var(--surface-1)",
-          borderBottom: "var(--border-1)",
-          userSelect: "none",
-        }}
-      >
-        <span
-          style={{
-            fontFamily: "var(--font-mono)",
-            fontSize: "var(--text-2xs)",
-            fontWeight: "var(--weight-semibold)",
-            color: "var(--text-secondary)",
-            flexShrink: 0,
-          }}
-        >
-          #{number}
-        </span>
-        <span
-          style={{
-            fontFamily: "var(--font-sans)",
-            fontSize: "var(--text-xs)",
-            color: "var(--text-primary)",
-            overflow: "hidden",
-            textOverflow: "ellipsis",
-            whiteSpace: "nowrap",
-            minWidth: 0,
-          }}
-          title={title}
-        >
-          {title}
-        </span>
-        <span style={{ flex: 1 }} />
-        <span
-          className="tabular"
-          style={{
-            fontFamily: "var(--font-mono)",
-            fontSize: "var(--text-2xs)",
-            color: "var(--text-tertiary)",
-            flexShrink: 0,
-          }}
-        >
-          {totals.files} file{totals.files === 1 ? "" : "s"} ·{" "}
-          <span style={{ color: "var(--diff-add-fg)" }}>+{totals.add}</span>{" "}
-          <span style={{ color: "var(--diff-remove-fg)" }}>−{totals.rem}</span>
-        </span>
-      </div>
-
-      <div
-        style={{
-          flex: 1,
-          minHeight: 0,
-          overflow: "auto",
-          backgroundColor: "var(--surface-0)",
-        }}
-        className="allow-select"
-      >
-        {raw === null && !error && <Empty label="loading PR diff…" />}
-        {raw === null && error && <Empty label={`error: ${error}`} />}
-        {raw !== null && sections.length === 0 && (
-          <Empty label="no changes in this PR" />
-        )}
-        {raw !== null && sections.length > 0 && (
-          <div style={{ display: "flex", flexDirection: "column" }}>
-            {sections.map((s) => (
-              <FileBlock key={s.path} section={s} />
-            ))}
-          </div>
-        )}
-      </div>
-    </motion.div>
-  );
-}
-
-function Empty({ label }: { label: string }) {
-  return (
-    <div
-      style={{
-        padding: "var(--space-6) var(--space-4)",
-        textAlign: "center",
-        color: "var(--text-tertiary)",
-        fontSize: "var(--text-xs)",
-        fontFamily: "var(--font-sans)",
-      }}
-    >
-      {label}
-    </div>
-  );
-}
diff --git a/src/git/PrsView.tsx b/src/git/PrsView.tsx
index ef9b014..c668e09 100644
--- a/src/git/PrsView.tsx
+++ b/src/git/PrsView.tsx
@@ -7,8 +7,9 @@ import {
   useTooltipAnchor,
 } from "@/primitives/Tooltip";
 import { useAppDispatch, useAppState } from "@/state/AppState";
-import { type Tab, type Worktree } from "@/state/types";
+import { type Worktree } from "@/state/types";
 import { pr, type PrListItem } from "@/lib/pr";
+import { git } from "@/lib/git";
 import { system } from "@/lib/fs";
 import { mergeBaseAndHandOff } from "./conflictAgent";
 import { useToast } from "@/primitives/Toast";
@@ -23,15 +24,18 @@ type Busy =
 
 /**
  * Right-panel PRs tab: every open PR on the repo, live from `gh pr
- * list`. A row click opens the PR's full diff in the main column; the
- * hover actions check the PR out into this worktree (stashing whatever
- * was in progress), merge it server-side, or open it on GitHub.
+ * list`. A row click checks the PR out into this worktree (stashing
+ * whatever was in progress) and soft-resets to the merge-base with the
+ * PR's base, so the whole PR reads as *staged changes* in the app's
+ * normal review surfaces — the Changes tab lists the files, the
+ * all-changes view is the total diff. No bespoke PR-diff tab.
  *
  * Checking a PR out flips the worktree into a review session — the
  * banner at the top names the PR, offers "Resolve conflicts" when
  * GitHub reports the PR conflicting, and a Return button that restores
- * the original branch plus the stashed work. The session record lives
- * on the worktree (persisted), so the way back survives restarts.
+ * the branch head, the original branch, and the stashed work. The
+ * session record lives on the worktree (persisted), so the way back
+ * survives restarts.
  */
 export function PrsView({
   worktree,
@@ -92,35 +96,61 @@ export function PrsView({
     );
   };
 
-  const openDiff = (item: PrListItem) => {
-    const tab: Tab = {
-      id: `t_pr_${item.number}_${Date.now().toString(36)}`,
+  // Put the review on screen using the app's normal surfaces: the
+  // right panel's Changes tab (the PR's files, staged) and the main
+  // column's all-changes tab (the total diff). The reducer dedupes
+  // all-changes per worktree, so repeat calls focus the existing tab.
+  const openChangesUi = () => {
+    dispatch({
+      type: "set-right-panel",
       worktreeId: worktree.id,
-      kind: "pr-diff",
-      number: item.number,
-      title: item.title,
-      summary: `PR #${item.number} · ${item.headRefName}`,
-      summaryUpdatedAt: Date.now(),
-    };
-    // The reducer dedupes on (kind, number) — re-clicking a row focuses
-    // the existing tab instead of stacking copies.
-    dispatch({ type: "open-tab", tab });
+      panel: "changes",
+    });
+    dispatch({
+      type: "open-tab",
+      tab: {
+        id: `t_changes_${Date.now().toString(36)}`,
+        worktreeId: worktree.id,
+        kind: "all-changes",
+        title: "Changes",
+        summary: "",
+        summaryUpdatedAt: Date.now(),
+      },
+    });
   };
 
   const checkout = async (item: PrListItem) => {
     if (busy) return;
     if (session) {
+      if (session.number === item.number) {
+        // Already reviewing this PR — just bring the review back up.
+        openChangesUi();
+        return;
+      }
       toast.show({
-        message:
-          session.number === item.number
-            ? `PR #${item.number} is already checked out here.`
-            : `Return to ${session.originalBranch} before checking out another PR.`,
+        message: `Return to ${session.originalBranch} before checking out another PR.`,
+      });
+      return;
+    }
+    // This worktree's own PR: its changes ARE the worktree. Checking
+    // it out would stash the user's WIP and soft-reset their working
+    // branch in place (the backend refuses too — this is the friendly
+    // early exit). Just show the changes that are already here.
+    if (item.headRefName === worktree.branch) {
+      openChangesUi();
+      toast.show({
+        message: `PR #${item.number} is this worktree's own branch — its changes are already here.`,
       });
       return;
     }
     setBusy({ kind: "checkout", number: item.number });
     try {
-      const result = await pr.checkout(path, item.number);
+      const result = await pr.checkout(
+        path,
+        item.number,
+        item.baseRefName,
+        item.headRefName,
+      );
       dispatch({
         type: "update-worktree",
         id: worktree.id,
@@ -131,18 +161,18 @@ export function PrsView({
             title: item.title,
             originalBranch: result.originalBranch,
             baseBranch: item.baseRefName,
+            headSha: result.headSha ?? undefined,
             stashed: result.stashed,
           },
         },
       });
       notifyGitRefresh();
-      // Reviewing means reading the changes — put the PR's diff on
-      // screen in the same gesture instead of hiding it behind a
-      // toast action the user has to catch before it fades.
-      openDiff(item);
+      // Reviewing means reading the changes — land on the staged-diff
+      // review (Changes tab + total diff) in the same gesture.
+      openChangesUi();
       toast.show({
-        message: `Checked out PR #${item.number} (${item.headRefName})${
-          result.stashed ? " — your changes are stashed" : ""
+        message: `Reviewing PR #${item.number} (${item.headRefName}) — its diff is staged in Changes${
+          result.stashed ? "; your work is stashed" : ""
         }.`,
       });
     } catch (e) {
@@ -156,7 +186,12 @@ export function PrsView({
   // stash, and clear the session record. Shared by the Return button
   // and the merged-the-reviewed-PR path in merge().
   const endSession = async (s: NonNullable<Worktree["prSession"]>) => {
-    const result = await pr.checkoutReturn(path, s.originalBranch, s.stashed);
+    const result = await pr.checkoutReturn(
+      path,
+      s.originalBranch,
+      s.stashed,
+      s.headSha ?? null,
+    );
     dispatch({
       type: "update-worktree",
       id: worktree.id,
@@ -242,6 +277,12 @@ export function PrsView({
     }
     setBusy({ kind: "conflicts" });
     try {
+      // The branch is soft-reset to its merge-base while under review
+      // (that's what makes the diff read as staged changes) — a merge
+      // can't run in that state, so restore the real head first.
+      if (session.headSha) {
+        await pr.reviewRestore(path, session.headSha);
+      }
       const result = await mergeBaseAndHandOff({
         path,
         base,
@@ -250,14 +291,36 @@ export function PrsView({
         tabs: state.tabs,
         project: state.projects[worktree.projectId],
       });
-      notifyGitRefresh();
       if (result.kind === "clean") {
+        // Push the merge commit so the PR actually updates on GitHub,
+        // then drop back into review state (staged diff) with the new
+        // head recorded on the session.
+        let pushNote = "";
+        if (!result.alreadyUpToDate) {
+          try {
+            await git.push(path, "origin", session.branch);
+          } catch (e) {
+            pushNote = ` Push failed — the merge commit is still local: ${e}`;
+          }
+        }
+        const newHead = await pr.reviewEnter(path, base).catch(() => null);
+        dispatch({
+          type: "update-worktree",
+          id: worktree.id,
+          patch: {
+            prSession: { ...session, headSha: newHead ?? session.headSha },
+          },
+        });
+        notifyGitRefresh();
         toast.show({
           message: result.alreadyUpToDate
             ? "PR branch is already up to date with its base."
-            : "Merged base into the PR branch — no conflicts. Push to update the PR.",
+            : `Merged ${base} into the PR branch — no conflicts.${
+                pushNote || " Pushed to update the PR."
+              }`,
         });
       } else {
+        notifyGitRefresh();
         const files = `${result.files} file${result.files === 1 ? "" : "s"}`;
         toast.show({
           message:
@@ -364,8 +427,9 @@ export function PrsView({
               key={item.number}
               item={item}
               checkedOut={session?.number === item.number}
+              isOwn={item.headRefName === worktree.branch}
               busy={busy}
-              onOpen={() => openDiff(item)}
+              onOpen={() => void checkout(item)}
               onCheckout={() => void checkout(item)}
               onMerge={() => void merge(item)}
               onOpenExternal={() => openExternal(item)}
@@ -507,6 +571,7 @@ function BannerButton({
 function PrRow({
   item,
   checkedOut,
+  isOwn,
   busy,
   onOpen,
   onCheckout,
@@ -515,6 +580,8 @@ function PrRow({
 }: {
   item: PrListItem;
   checkedOut: boolean;
+  /** True when the PR's head is the branch this worktree is on. */
+  isOwn: boolean;
   busy: Busy;
   onOpen: () => void;
   onCheckout: () => void;
@@ -577,6 +644,7 @@ function PrRow({
           {item.title}
         </span>
         {checkedOut && <Chip label="checked out" tone="accent" />}
+        {isOwn && !checkedOut && <Chip label="this worktree" tone="accent" />}
         {item.isDraft && <Chip label="draft" tone="muted" />}
         {conflicting && <Chip label="conflicts" tone="warning" />}
       </div>
@@ -618,10 +686,12 @@ function PrRow({
             <RowAction
               tip={
                 checkedOut
-                  ? "Already checked out"
-                  : "Check this PR out into the worktree (stashes current work)"
+                  ? "Checked out — open its review in Changes"
+                  : isOwn
+                    ? "This worktree's own PR — its changes are already here"
+                    : "Review: check out and stage the PR's diff in Changes (stashes current work)"
               }
-              disabled={anyBusy || checkedOut}
+              disabled={anyBusy}
               onClick={onCheckout}
             >
               <ArrowsLeftRight size={13} />
diff --git a/src/lib/pr.ts b/src/lib/pr.ts
index aab3420..c0e4a25 100644
--- a/src/lib/pr.ts
+++ b/src/lib/pr.ts
@@ -24,6 +24,13 @@ export interface PrListItem {
 export interface PrCheckoutResult {
   originalBranch: string;
   stashed: boolean;
+  /**
+   * The PR branch's real head sha (the review flow soft-resets the
+   * branch to its merge-base so the diff reads as staged changes;
+   * this is what Return resets back to). Null when review state
+   * couldn't be established.
+   */
+  headSha: string | null;
 }
 
 export interface PrReturnResult {
@@ -43,19 +50,46 @@ export interface ConflictResult {
 export const pr = {
   /** Every open PR on the repo, newest first (gh's default order). */
   list: (cwd: string) => invoke<PrListItem[]>("pr_list", { cwd }),
-  /** Full unified diff of a PR without checking it out. */
-  diff: (cwd: string, number: number) =>
-    invoke<string>("pr_diff", { cwd, number }),
   /**
-   * Stash uncommitted work (tagged for restore) and check the PR's
-   * branch out into this worktree. The returned record is what the
-   * "go back" button needs — persist it on the worktree.
+   * Stash uncommitted work (tagged for restore), check the PR's branch
+   * out into this worktree, and soft-reset to the merge-base with
+   * `base` so the PR's whole diff shows as staged changes in the
+   * normal changes UI. `head` is the PR's head branch — the backend
+   * refuses when it's the branch already checked out here (reviewing
+   * your own worktree's PR would rewrite the branch in place). The
+   * returned record is what the "go back" button needs — persist it
+   * on the worktree.
+   */
+  checkout: (cwd: string, number: number, base: string, head: string) =>
+    invoke<PrCheckoutResult>("pr_checkout", { cwd, number, base, head }),
+  /**
+   * Put the PR branch back on its real head, switch back to `branch`,
+   * and pop the tagged stash if one was made.
+   */
+  checkoutReturn: (
+    cwd: string,
+    branch: string,
+    stashed: boolean,
+    headSha: string | null,
+  ) =>
+    invoke<PrReturnResult>("pr_checkout_return", {
+      cwd,
+      branch,
+      stashed,
+      headSha,
+    }),
+  /**
+   * Re-establish review state (staged PR diff) on the checked-out
+   * branch — used after a clean base merge. Returns the new head sha.
+   */
+  reviewEnter: (cwd: string, base: string) =>
+    invoke<string | null>("pr_review_enter", { cwd, base }),
+  /**
+   * Leave review state (branch ref back on its real head) without
+   * switching branches. No-op when commits were made on top.
    */
-  checkout: (cwd: string, number: number) =>
-    invoke<PrCheckoutResult>("pr_checkout", { cwd, number }),
-  /** Switch back to `branch` and pop the tagged stash if one was made. */
-  checkoutReturn: (cwd: string, branch: string, stashed: boolean) =>
-    invoke<PrReturnResult>("pr_checkout_return", { cwd, branch, stashed }),
+  reviewRestore: (cwd: string, headSha: string) =>
+    invoke<boolean>("pr_review_restore", { cwd, headSha }),
   /** Server-side merge via gh; deletes the remote branch on success. */
   merge: (cwd: string, number: number, method: "merge" | "squash" | "rebase") =>
     invoke<void>("pr_merge", { cwd, number, method }),
diff --git a/src/shell/MainColumn.tsx b/src/shell/MainColumn.tsx
index 114ceab..0c23040 100644
--- a/src/shell/MainColumn.tsx
+++ b/src/shell/MainColumn.tsx
@@ -25,7 +25,6 @@ import { BlockTerminal } from "@/terminal/BlockTerminal";
 import { WarpSurfaceTracker } from "@/terminal/WarpSurfaceTracker";
 import { DiffView } from "@/git/DiffView";
 import { AllChangesView } from "@/git/AllChangesView";
-import { PrDiffView } from "@/git/PrDiffView";
 import { CommitDetailView } from "@/git/CommitDetailView";
 import { Editor } from "@/editor/Editor";
 import { MarkdownView } from "@/editor/MarkdownView";
@@ -566,9 +565,6 @@ function fullTabSummary(tab: Tab): string | null {
   if (tab.kind === "all-changes") {
     return trim(tab.title) || "All changes";
   }
-  if (tab.kind === "pr-diff") {
-    return trim(tab.title) || `PR #${tab.number}`;
-  }
   if (tab.kind === "commit") {
     return trim(tab.title) || trim(tab.hash) || "Commit";
   }
@@ -651,9 +647,6 @@ function tabLabel(tab: Tab): string {
   if (tab.kind === "all-changes") {
     return tab.title || "Changes";
   }
-  if (tab.kind === "pr-diff") {
-    return tab.title || `PR #${tab.number}`;
-  }
   if (tab.kind === "commit") {
     // Subject line on top; the short sha rides the summary line below.
     return tab.title || tab.hash.slice(0, 7);
@@ -917,13 +910,6 @@ function HalfPane({
             />
           ) : tab.kind === "all-changes" ? (
             <AllChangesView key={tab.id} projectPath={cwd} />
-          ) : tab.kind === "pr-diff" ? (
-            <PrDiffView
-              key={tab.id}
-              projectPath={cwd}
-              number={tab.number}
-              title={tab.title}
-            />
           ) : tab.kind === "commit" ? (
             <CommitDetailView
               key={tab.id}
diff --git a/src/state/reducer.ts b/src/state/reducer.ts
index 6ab6e42..175c97c 100644
--- a/src/state/reducer.ts
+++ b/src/state/reducer.ts
@@ -691,8 +691,6 @@ function sameTabTarget(a: Tab, b: Tab): boolean {
       return a.kind === "project-settings" && a.projectId === b.projectId;
     case "all-changes":
       return true;
-    case "pr-diff":
-      return a.kind === "pr-diff" && a.number === b.number;
     case "commit":
       return a.kind === "commit" && a.hash === b.hash;
   }
diff --git a/src/state/types.ts b/src/state/types.ts
index 2203e1a..b85b0fa 100644
--- a/src/state/types.ts
+++ b/src/state/types.ts
@@ -218,6 +218,14 @@ export interface PrSession {
    * before the field existed.
    */
   baseBranch?: string;
+  /**
+   * The PR branch's real head sha, recorded at checkout. The branch is
+   * soft-reset to its merge-base with the PR's base so the whole diff
+   * reads as staged changes in the normal changes UI; this sha is what
+   * the Return flow resets back to. Absent when review state couldn't
+   * be established (or for sessions persisted before the field).
+   */
+  headSha?: string;
   /** True when pre-checkout dirty state was stashed (and must pop back). */
   stashed: boolean;
 }
@@ -360,17 +368,6 @@ export interface AllChangesTab extends TabBase {
   kind: "all-changes";
 }
 
-/**
- * Tab variant rendering an open PR's full diff (via `gh pr diff`) in
- * the main column. Opened by clicking a row in the PRs panel. Only the
- * number is stored — the view fetches the diff live, so new pushes to
- * the PR fold in on the next refresh.
- */
-export interface PrDiffTab extends TabBase {
-  kind: "pr-diff";
-  number: number;
-}
-
 /**
  * Tab variant showing one commit from the history graph: metadata
  * (author, sha, parents, refs, message) plus the full diff the commit
@@ -388,7 +385,6 @@ export type Tab =
   | MarkdownTab
   | ProjectSettingsTab
   | AllChangesTab
-  | PrDiffTab
   | CommitTab;
 
 /**