git-coco 0.37.0 → 0.38.0

package/dist/index.js

@@ -43,6 +43,7 @@ var path$1 = require('node:path');
 var crypto = require('node:crypto');
 var readline = require('readline');
 var util$1 = require('util');
+var crypto$1 = require('crypto');
 var url = require('url');
 
 function _interopNamespaceDefault(e) {
@@ -77,7 +78,7 @@ var readline__namespace = /*#__PURE__*/_interopNamespaceDefault(readline);
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.37.0";
+const BUILD_VERSION = "0.38.0";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -13539,8 +13540,11 @@ const builder$3 = (yargs) => {
 };
 
 const FIELD_SEPARATOR$2 = '\x1f';
-const LOG_FORMAT = `%x1f%h%x1f%H%x1f%ad%x1f%an%x1f%d%x1f%s`;
-const DETAIL_FORMAT = `%H%x1f%h%x1f%ad%x1f%an%x1f%d%x1f%s%x1f%b`;
+// `%P` (parent hashes, space-separated) lets the TUI distinguish
+// merge commits (parents.length > 1) from regular commits without a
+// second round-trip to git. See #791 stage 3 — merge glyph + HEAD ring.
+const LOG_FORMAT = `%x1f%h%x1f%H%x1f%P%x1f%ad%x1f%an%x1f%d%x1f%s`;
+const DETAIL_FORMAT = `%H%x1f%h%x1f%P%x1f%ad%x1f%an%x1f%d%x1f%s%x1f%b`;
 const LOG_DEFAULT_LIMIT = 30;
 const LOG_INTERACTIVE_DEFAULT_LIMIT = 300;
 function toArray(value) {
@@ -13594,12 +13598,13 @@ function parseLogOutput(output) {
                 graph: line,
             };
         }
-        const [graph, shortHash, hash, date, author, refs, message] = line.split(FIELD_SEPARATOR$2);
+        const [graph, shortHash, hash, parentsStr, date, author, refs, message] = line.split(FIELD_SEPARATOR$2);
         return {
             type: 'commit',
             graph: graph.trimEnd(),
             shortHash,
             hash,
+            parents: parentsStr ? parentsStr.trim().split(' ').filter(Boolean) : [],
             date,
             author,
             refs: cleanRefs(refs),
@@ -13666,13 +13671,14 @@ function parseNameStatus(output, numstat = []) {
     });
 }
 function parseCommitDetail(metadata, files, numstatOutput = '') {
-    const [hash, shortHash, date, author, refs, message, body = ''] = metadata
+    const [hash, shortHash, parentsStr, date, author, refs, message, body = ''] = metadata
         .trimEnd()
         .split(FIELD_SEPARATOR$2);
     const numstat = parseNumstat(numstatOutput);
     return {
         shortHash,
         hash,
+        parents: parentsStr ? parentsStr.trim().split(' ').filter(Boolean) : [],
         date,
         author,
         refs: cleanRefs(refs),
@@ -13726,6 +13732,24 @@ function buildLogArgs(argv, options = {}) {
     }
     return args;
 }
+/**
+ * Build merged `LogArgv` for the interactive TUI's `g` graph toggle.
+ *
+ * The TUI tracks a transient `fullGraph` boolean; toggling it must produce
+ * a fresh fetch with the right `view` so the renderer actually has graph
+ * topology to draw. When switching to full mode we override `view` to
+ * `'full'` (which `buildLogArgs` already maps to `--all`, dropping
+ * `--first-parent`/`--no-merges`). When switching back we honor the user's
+ * original `view` from argv, defaulting to `'compact'`.
+ *
+ * Pure helper so the effect that calls it stays trivially testable.
+ */
+function buildToggleGraphArgs(argv, fullGraph) {
+    if (fullGraph) {
+        return { ...argv, view: 'full' };
+    }
+    return { ...argv, view: argv.view ?? 'compact' };
+}
 async function getLogRows(git, argv, options = {}) {
     return parseLogOutput(await git.raw(buildLogArgs(argv, options)));
 }
@@ -13967,7 +13991,7 @@ function splitCommitDraft(draft) {
         body,
     };
 }
-function compactOutputLines$4(output) {
+function compactOutputLines$5(output) {
     return output
         .split('\n')
         .map((line) => line.trim())
@@ -13975,14 +13999,14 @@ function compactOutputLines$4(output) {
 }
 function formatManualCommitFailure(error) {
     if (error instanceof PreCommitHookError) {
-        const details = compactOutputLines$4(error.hookOutput);
+        const details = compactOutputLines$5(error.hookOutput);
         return {
             ok: false,
             message: `Commit blocked by hook: ${details[0] || 'hook failed'}`,
             details: details.slice(1, 6),
         };
     }
-    const details = compactOutputLines$4(error.message);
+    const details = compactOutputLines$5(error.message);
     return {
         ok: false,
         message: details[0] || 'Commit failed.',
@@ -14283,7 +14307,7 @@ function formatCommitWorkflowMessage(action, output) {
     }
     return 'Generated commit message.';
 }
-function compactOutputLines$3(output) {
+function compactOutputLines$4(output) {
     return output
         .split('\n')
         .map((line) => line.trim())
@@ -14291,14 +14315,14 @@ function compactOutputLines$3(output) {
 }
 function formatCommitFailure(error) {
     if (error instanceof PreCommitHookError) {
-        const details = compactOutputLines$3(error.hookOutput);
+        const details = compactOutputLines$4(error.hookOutput);
         return {
             ok: false,
             message: `Commit blocked by hook: ${details[0] || 'hook failed'}`,
             details: details.slice(1, 6),
         };
     }
-    const details = compactOutputLines$3(error.message);
+    const details = compactOutputLines$4(error.message);
     return {
         ok: false,
         message: details[0] || 'Commit action failed.',
@@ -14331,7 +14355,7 @@ async function runCommitWorkflow({ action, git = getRepo(), noVerify = false, })
     }
     catch (error) {
         if (isCommandExitError(error)) {
-            const lines = compactOutputLines$3(output || error.message);
+            const lines = compactOutputLines$4(output || error.message);
             return {
                 ok: error.code === 0,
                 message: lines[0] || error.message,
@@ -14373,7 +14397,7 @@ async function runCommitDraftWorkflow(input = {}) {
     }
     catch (error) {
         if (isCommandExitError(error)) {
-            const lines = compactOutputLines$3(error.message);
+            const lines = compactOutputLines$4(error.message);
             return {
                 ok: error.code === 0,
                 message: lines[0] || error.message,
@@ -14411,6 +14435,274 @@ function isLogInkContextKeyLoading(status, key) {
     return status[key] === 'loading';
 }
 
+/**
+ * The chars `git log --graph` emits for branch topology — `*`, `|`, `\`,
+ * `/`, `_`, ` `. ASCII-only output is bulletproof for legacy terminals
+ * but the angles read poorly when many branches overlap.
+ *
+ * `substituteGraphChars` walks the row left-to-right with one-char
+ * lookahead so it can recognize git's two-char junction patterns and
+ * emit proper box-drawing junctions (├╮ / ├╯) instead of overlapping
+ * pipes (│╲ / │╱). Anything that isn't part of a recognized pattern
+ * falls back to the legacy 1-to-1 substitution.
+ *
+ * `theme.ascii` (TERM=dumb / vt100) bypasses substitution entirely so
+ * legacy terminals get the raw `git log --graph` output. `theme.noColor`
+ * is orthogonal — Unicode chars still render, just without color.
+ *
+ * Kept ASCII-only intentionally:
+ *   - alphanumerics       (commit refs / annotations git sometimes injects)
+ *   - parens / brackets   (HEAD decoration markers, not part of the graph)
+ *   - hyphens / colons    (likewise)
+ */
+const ASCII_TO_UNICODE_MAP = {
+    '*': '●',
+    '|': '│',
+    '/': '╱',
+    '\\': '╲',
+    '_': '─',
+};
+const DEFAULT_COMMIT_GLYPH = '●';
+/**
+ * #791 stage 3 — distinct glyphs for merges and HEAD so they stand
+ * out from the run of regular commits. `◆` (filled diamond) flags a
+ * merge commit (`parents.length > 1`); `◉` (fisheye) flags HEAD
+ * regardless of parent count. Both render at the same column width as
+ * `●` so graph alignment stays intact across mixed commit types.
+ */
+const MERGE_COMMIT_GLYPH = '◆';
+const HEAD_COMMIT_GLYPH = '◉';
+/**
+ * Recognized 2-char junction patterns. The key is the bigram git emits
+ * (lane char + spacer char); the value is the box-drawing pair we render.
+ *
+ * - `|\` (fork): trunk lane gains a right-T (├) and the spacer becomes
+ *   the upper-right corner (╮) starting the new lane below.
+ * - `|/` (converge): trunk lane gains a right-T (├) and the spacer
+ *   becomes the upper-left corner (╯) absorbing the side lane from
+ *   above.
+ *
+ * `*\` and `* /` (commit-row variants) are handled the same way, but
+ * the commit glyph itself stays configurable via `commitGlyph` so
+ * stage 3 can swap in `◆` / `◉` for merges and HEAD.
+ */
+const PIPE_FORK = '├╮';
+const PIPE_CONVERGE = '├╯';
+const FORK_SPACER = '╮';
+const CONVERGE_SPACER = '╯';
+function substituteGraphChars(graph, options) {
+    if (options.ascii) {
+        return graph;
+    }
+    const commitGlyph = options.commitGlyph ?? DEFAULT_COMMIT_GLYPH;
+    let output = '';
+    let i = 0;
+    while (i < graph.length) {
+        const a = graph[i];
+        const b = i + 1 < graph.length ? graph[i + 1] : '';
+        if (a === '|' && b === '\\') {
+            output += PIPE_FORK;
+            i += 2;
+            continue;
+        }
+        if (a === '|' && b === '/') {
+            output += PIPE_CONVERGE;
+            i += 2;
+            continue;
+        }
+        if (a === '*' && b === '\\') {
+            output += commitGlyph + FORK_SPACER;
+            i += 2;
+            continue;
+        }
+        if (a === '*' && b === '/') {
+            output += commitGlyph + CONVERGE_SPACER;
+            i += 2;
+            continue;
+        }
+        if (a === '*') {
+            output += commitGlyph;
+        }
+        else {
+            output += ASCII_TO_UNICODE_MAP[a] ?? a;
+        }
+        i += 1;
+    }
+    return output;
+}
+
+/**
+ * Lane tracking + per-lane coloring for the Ink log TUI graph (#791
+ * stage 2).
+ *
+ * `git log --graph` emits topology in 2-char patterns where every even
+ * position is a lane column (`*`, `|`, ` `) and every odd position is
+ * a spacer that may carry a connector (`\`, `/`, `_`). To color graph
+ * chars by which logical lane they belong to, we walk the rows
+ * left-to-right tracking which lane id occupies each column and apply
+ * git's emission rules:
+ *
+ *   - `|\` (fork): the spacer spawns a new lane id at column +1 below.
+ *   - `|/` (converge): the spacer absorbs the lane at column +1 into
+ *     this column; the absorbed lane disappears in the next row.
+ *   - `*` is treated like `|` for lane purposes (a commit lives on a
+ *     lane and connects through the row).
+ *
+ * Lane ids are stable across rows for the same column unless one of
+ * the transition patterns above fires. Other shifts (multi-step `_`
+ * crossings, octopus merges) degrade gracefully — uncovered chars
+ * just fall back to `undefined` lane id, so they render in the muted
+ * graph color rather than a wrong lane color.
+ *
+ * The segment builder collapses adjacent characters with the same
+ * lane id into one `LaneSegment` so the renderer emits one Text span
+ * per visually-distinct color region instead of per-char.
+ */
+function createLaneTrackerState() {
+    return { columnLanes: new Map(), nextLaneId: 0 };
+}
+/**
+ * Walk a single graph row left-to-right, mutating the tracker so the
+ * next row sees the updated column → lane id map. Returns lane
+ * segments ready for the renderer. When `options.ascii` is true the
+ * tracker is left untouched and the row is emitted as a single
+ * lane-less segment so legacy terminals get raw ASCII output with no
+ * coloring.
+ */
+function renderGraphRowSegments(graph, tracker, options) {
+    if (options.ascii) {
+        return [{ text: graph, laneId: undefined }];
+    }
+    const commitGlyph = options.commitGlyph ?? DEFAULT_COMMIT_GLYPH;
+    const segments = [];
+    const push = (text, laneId) => {
+        const last = segments[segments.length - 1];
+        if (last && last.laneId === laneId) {
+            last.text += text;
+        }
+        else {
+            segments.push({ text, laneId });
+        }
+    };
+    let i = 0;
+    while (i < graph.length) {
+        const c = graph[i];
+        const next = i + 1 < graph.length ? graph[i + 1] : '';
+        const col = i >> 1;
+        const isSpacer = (i & 1) === 1;
+        if (c === ' ') {
+            push(' ', undefined);
+            i += 1;
+            continue;
+        }
+        if (!isSpacer && (c === '|' || c === '*')) {
+            if (!tracker.columnLanes.has(col)) {
+                tracker.columnLanes.set(col, tracker.nextLaneId++);
+            }
+            const laneId = tracker.columnLanes.get(col);
+            const glyph = c === '|' ? '│' : commitGlyph;
+            if (next === '\\') {
+                const newLaneId = tracker.nextLaneId++;
+                tracker.columnLanes.set(col + 1, newLaneId);
+                push(c === '|' ? '├' : commitGlyph, laneId);
+                push('╮', newLaneId);
+                i += 2;
+                continue;
+            }
+            if (next === '/') {
+                const absorbedLaneId = tracker.columnLanes.get(col + 1);
+                push(c === '|' ? '├' : commitGlyph, laneId);
+                push('╯', absorbedLaneId);
+                tracker.columnLanes.delete(col + 1);
+                i += 2;
+                continue;
+            }
+            push(glyph, laneId);
+            i += 1;
+            continue;
+        }
+        // Non-lane chars (standalone `\`, `/`, `_`, decorations) — substitute
+        // 1-to-1 and leave the lane id undefined so they render in the muted
+        // fallback color.
+        push(ASCII_TO_UNICODE_MAP[c] ?? c, undefined);
+        i += 1;
+    }
+    return segments;
+}
+/**
+ * Run the tracker over `count` rows starting from `state.rows[0]` so
+ * downstream callers can resume tracking from a specific window
+ * without re-scanning. Used by `getVisibleLogInkHistory` to keep lane
+ * ids stable across scrolling — without this, each scroll would
+ * re-color lanes from a fresh tracker.
+ */
+function advanceTrackerThrough(graphs, tracker, count) {
+    for (let i = 0; i < count && i < graphs.length; i++) {
+        renderGraphRowSegments(graphs[i], tracker, { ascii: false });
+    }
+}
+/**
+ * Theme-aware lane palette. Default uses bright ANSI named colors that
+ * render reliably on 16-color terminals; catppuccin / gruvbox lift
+ * accent hues from their respective palettes so the graph stays
+ * coherent with the surrounding chrome.
+ *
+ * Selecting 8 colors gives enough variety to distinguish lanes in
+ * practice (most repos peak at 3-4 simultaneous lanes); the modulo
+ * lookup wraps cleanly for the rare case of more.
+ */
+const DEFAULT_LANE_PALETTE = [
+    'cyan', 'magenta', 'yellow', 'green', 'blue', 'red', 'cyanBright', 'magentaBright',
+];
+const CATPPUCCIN_LANE_PALETTE = [
+    '#89b4fa', '#f5c2e7', '#f9e2af', '#a6e3a1', '#cba6f7', '#fab387', '#94e2d5', '#f5e0dc',
+];
+const GRUVBOX_LANE_PALETTE = [
+    '#83a598', '#d3869b', '#fabd2f', '#b8bb26', '#d65d0e', '#fb4934', '#8ec07c', '#fe8019',
+];
+function getLanePalette(theme) {
+    if (theme.noColor) {
+        return [];
+    }
+    const accent = theme.colors.accent;
+    if (accent === '#89b4fa') {
+        return CATPPUCCIN_LANE_PALETTE;
+    }
+    if (accent === '#83a598') {
+        return GRUVBOX_LANE_PALETTE;
+    }
+    return DEFAULT_LANE_PALETTE;
+}
+function getLaneColor(laneId, theme) {
+    if (laneId === undefined) {
+        return undefined;
+    }
+    const palette = getLanePalette(theme);
+    if (palette.length === 0) {
+        return undefined;
+    }
+    return palette[laneId % palette.length];
+}
+
+/**
+ * Pick the commit glyph based on parent count + HEAD-ness so the
+ * renderer can flag merges and the current head visually. HEAD wins
+ * over merge when both apply (HEAD on a merge commit) — the ◉ ring
+ * is the more salient signal and the user can still see the merge
+ * via the lane topology.
+ */
+function commitGlyphFor(commit) {
+    if (isHeadCommit$1(commit)) {
+        return HEAD_COMMIT_GLYPH;
+    }
+    if (commit.parents.length > 1) {
+        return MERGE_COMMIT_GLYPH;
+    }
+    return DEFAULT_COMMIT_GLYPH;
+}
+function isHeadCommit$1(commit) {
+    return commit.refs.some((ref) => ref === 'HEAD' || ref.startsWith('HEAD ->'));
+}
 function clampWindowStart(index, count, visibleCount) {
     return Math.max(0, Math.min(index - Math.floor(visibleCount / 2), Math.max(0, count - visibleCount)));
 }
@@ -14426,6 +14718,11 @@ function toCompactItems(state, visibleCount) {
         type: 'commit',
         commit,
         graph: '*',
+        // Compact mode skips lane tracking (no topology to color) but still
+        // wants the merge / HEAD glyph so the user can spot them at a
+        // glance. Lane id stays undefined so the segment renders muted —
+        // matching the legacy compact appearance, just with a richer glyph.
+        laneSegments: [{ text: commitGlyphFor(commit), laneId: undefined }],
         selected: start + offset === state.selectedIndex,
     }));
 }
@@ -14436,17 +14733,28 @@ function toFullGraphItems(state, visibleCount) {
     const selected = state.filteredCommits[state.selectedIndex];
     const selectedRowIndex = state.rows.findIndex((row) => isSelectedCommit(row, selected));
     const start = clampWindowStart(selectedRowIndex >= 0 ? selectedRowIndex : 0, state.rows.length, visibleCount);
+    // Lane tracking is order-dependent — fast-forward the tracker through
+    // every row above the visible window so lane ids stay stable as the
+    // user scrolls. Without this, scrolling would re-color lanes from a
+    // fresh tracker each time.
+    const tracker = createLaneTrackerState();
+    const allGraphs = state.rows.map((row) => (row.type === 'commit' ? row.graph || '*' : row.graph));
+    advanceTrackerThrough(allGraphs, tracker, start);
     return state.rows.slice(start, start + visibleCount).map((row) => {
         if (row.type === 'graph') {
             return {
                 type: 'graph',
                 graph: row.graph,
+                laneSegments: renderGraphRowSegments(row.graph, tracker, { ascii: false }),
             };
         }
+        const graph = row.graph || '*';
+        const commitGlyph = commitGlyphFor(row);
         return {
             type: 'commit',
             commit: row,
-            graph: row.graph || '*',
+            graph,
+            laneSegments: renderGraphRowSegments(graph, tracker, { ascii: false, commitGlyph }),
             selected: isSelectedCommit(row, selected),
         };
     });
@@ -14595,6 +14903,34 @@ function getLogInkWorkflowActions() {
             kind: 'destructive',
             requiresConfirmation: true,
         },
+        {
+            // Per-view-only: scoped to commit-diff and stash-diff explores in
+            // inkInput (key: H). The action is non-destructive in the sense
+            // that `git apply` won't lose any data — `git apply -R` undoes
+            // it cleanly — so it bypasses the y-confirm path. The patch text
+            // travels via the action's `payload` field. Empty key keeps the
+            // workflow palette-discoverable without registering a global
+            // hotkey (the palette path can't synthesize the patch text and
+            // surfaces a hint instead — actual dispatch is from H in diff
+            // view).
+            id: 'apply-hunk-worktree',
+            key: '',
+            label: 'Apply hunk to worktree',
+            description: 'Extract the hunk under the cursor and apply it to the working tree via `git apply`.',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
+        {
+            // Sibling of `apply-hunk-worktree` — same extraction path, but
+            // `git apply --cached` so the patch lands in the index without
+            // touching the worktree. Bound to the `gH` chord in inkInput.
+            id: 'apply-hunk-index',
+            key: '',
+            label: 'Apply hunk to index',
+            description: 'Extract the hunk under the cursor and apply it to the index via `git apply --cached`.',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
         {
             id: 'open-pr',
             key: 'O',
@@ -14687,6 +15023,88 @@ function getLogInkWorkflowActions() {
             kind: 'destructive',
             requiresConfirmation: true,
         },
+        // #783 — full PR action panel. All five entries are palette-only
+        // (`key: ''`) — actual dispatch is per-view scoped in inkInput so
+        // the keys stay free outside the pull-request view. Merge / close /
+        // approve / request-changes route through the y-confirm path
+        // because each is irreversible (or near-irreversible) once gh
+        // publishes it; comment is a free-form prompt with no extra
+        // confirmation since the body itself is the affirmative action.
+        {
+            id: 'merge-pr',
+            key: '',
+            label: 'Merge pull request',
+            description: 'Merge the current branch\'s pull request (prompts for merge / squash / rebase, then confirms).',
+            kind: 'destructive',
+            requiresConfirmation: true,
+        },
+        {
+            id: 'close-pr',
+            key: '',
+            label: 'Close pull request',
+            description: 'Close the current pull request without merging.',
+            kind: 'destructive',
+            requiresConfirmation: true,
+        },
+        {
+            id: 'approve-pr',
+            key: '',
+            label: 'Approve pull request',
+            description: 'Submit an approving review on the current pull request.',
+            kind: 'normal',
+            requiresConfirmation: true,
+        },
+        {
+            id: 'request-changes-pr',
+            key: '',
+            label: 'Request changes on pull request',
+            description: 'Submit a change-request review (prompts for the review body, then confirms).',
+            kind: 'normal',
+            requiresConfirmation: true,
+        },
+        {
+            id: 'comment-pr',
+            key: '',
+            label: 'Comment on pull request',
+            description: 'Add a comment to the current pull request (prompts for body).',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
+        {
+            // Per-view-only: scoped to the history view in inkInput so `R`
+            // doesn't fire elsewhere (it's also `R` for rename in branches
+            // and delete-remote-tag in tags). Empty key keeps it
+            // palette-discoverable without registering a global hotkey.
+            id: 'revert-commit',
+            key: '',
+            label: 'Revert commit',
+            description: 'Revert the cursored commit by adding an inverse commit on top of HEAD.',
+            kind: 'destructive',
+            requiresConfirmation: true,
+        },
+        {
+            // Per-view-only: scoped to the history view in inkInput. Triggers
+            // a mode prompt (soft / mixed / hard) before the reset runs so
+            // `Z` alone never silently rewrites history.
+            id: 'reset-to-commit',
+            key: '',
+            label: 'Reset to commit',
+            description: 'Move the current branch tip to the cursored commit (prompts for soft / mixed / hard).',
+            kind: 'destructive',
+            requiresConfirmation: true,
+        },
+        {
+            // Per-view-only: scoped to the history view in inkInput. `i`
+            // (lowercase) is used instead of `I` so the existing `I`
+            // ai-commit-summary workflow stays reachable on the history
+            // view — `i` matches the `git rebase -i` flag mnemonic anyway.
+            id: 'interactive-rebase',
+            key: '',
+            label: 'Interactive rebase',
+            description: 'Start an interactive rebase from the cursored commit (opens $GIT_EDITOR for the todo list).',
+            kind: 'destructive',
+            requiresConfirmation: true,
+        },
         {
             id: 'ai-commit-summary',
             key: 'I',
@@ -14708,6 +15126,15 @@ function getLogInkWorkflowActions() {
     ];
 }
 function getLogInkWorkflowActionByKey(inputValue) {
+    // Workflow actions with an empty `key` are palette-only — they
+    // exist so the command palette can surface them but should never
+    // match a raw keystroke. Without this guard, any unbound key
+    // (left/right arrow, function keys) that arrives with an empty
+    // inputValue would `find()` the first empty-key entry —
+    // `cherry-pick-commit` — and pop its confirmation dialog.
+    if (!inputValue) {
+        return undefined;
+    }
     return getLogInkWorkflowActions().find((action) => action.key === inputValue);
 }
 function getLogInkWorkflowActionById(id) {
@@ -14837,6 +15264,13 @@ const LOG_INK_KEY_BINDINGS = [
         description: 'Toggle compact and full graph display.',
         contexts: ['normal', 'commits'],
     },
+    {
+        id: 'toggleDiffViewMode',
+        keys: ['d'],
+        label: 'split/unified',
+        description: 'Toggle the diff view between unified and side-by-side split rendering. Falls back to unified on narrow terminals.',
+        contexts: ['commits'],
+    },
     {
         id: 'navigateHome',
         keys: ['gh'],
@@ -14893,6 +15327,13 @@ const LOG_INK_KEY_BINDINGS = [
         description: 'Push the linked worktrees view.',
         contexts: ['normal'],
     },
+    {
+        id: 'navigatePullRequest',
+        keys: ['gp'],
+        label: 'pull request',
+        description: 'Push the dedicated pull-request action panel for the current branch.',
+        contexts: ['normal'],
+    },
     {
         id: 'navigateBack',
         keys: ['<', 'esc'],
@@ -15021,6 +15462,7 @@ const GLOBAL_BINDING_IDS = [
     'navigateTags',
     'navigateStash',
     'navigateWorktrees',
+    'navigatePullRequest',
     'navigateBack',
 ];
 const NORMAL_GLOBAL_HINTS = ['g jump', '< back', '? help', ': cmds', 'q quit'];
@@ -15081,8 +15523,37 @@ function getLogInkFooterHints(options) {
         };
     }
     if (options.focus === 'sidebar') {
+        // Per-tab hints when the active tab has selectable items — the user
+        // can act on the cursored entity without leaving the workstation
+        // view. Status tab + empty content tabs fall back to the generic
+        // "enter open" hint that drills into the dedicated view.
+        const itemsPresent = (options.sidebarItemCount ?? 0) > 0;
+        if (itemsPresent && options.sidebarTab === 'branches') {
+            return {
+                contextual: ['↑/↓ branches', '←/→ tab', 'enter checkout', 'D delete', 'R rename', 'u upstream'],
+                global: NORMAL_GLOBAL_HINTS,
+            };
+        }
+        if (itemsPresent && options.sidebarTab === 'stashes') {
+            return {
+                contextual: ['↑/↓ stashes', '←/→ tab', 'enter diff', 'a apply', 'p pop', 'X drop'],
+                global: NORMAL_GLOBAL_HINTS,
+            };
+        }
+        if (itemsPresent && options.sidebarTab === 'tags') {
+            return {
+                contextual: ['↑/↓ tags', '←/→ tab', '+ new', 'P push', 'T delete'],
+                global: NORMAL_GLOBAL_HINTS,
+            };
+        }
+        if (itemsPresent && options.sidebarTab === 'worktrees') {
+            return {
+                contextual: ['↑/↓ worktrees', '←/→ tab', 'W remove'],
+                global: NORMAL_GLOBAL_HINTS,
+            };
+        }
         return {
-            contextual: ['[/] tab', '1-5 jump', 'tab focus'],
+            contextual: ['←/→ tab', '1-5 jump', 'enter open', 'tab focus'],
             global: NORMAL_GLOBAL_HINTS,
         };
     }
@@ -15099,17 +15570,23 @@ function getLogInkFooterHints(options) {
         };
     }
     if (options.activeView === 'diff') {
+        // Surface what `d` will switch *to* — labels the next mode rather
+        // than the current one so the hint reads as a verb. The split-mode
+        // hint is only shown for the read-only diff sources (commit/stash);
+        // the worktree diff stays unified-only for now.
+        const splitToggleHint = options.diffViewMode === 'split' ? 'd unified' : 'd split';
         if (options.diffSource === 'stash') {
             return {
-                contextual: ['j/k lines', '[/] file', 'c cherry-pick', 'o edit', 'y yank', 'esc back'],
+                contextual: ['j/k lines', '[/] file', 'c cherry-pick', 'H apply hunk', 'o edit', splitToggleHint, 'y yank', 'esc back'],
                 global: NORMAL_GLOBAL_HINTS,
             };
         }
         if (options.diffSource === 'commit') {
             // Commit-diff explore: read-only diff, but `c` cherry-picks the
-            // cursored file from the commit into the worktree.
+            // cursored file from the commit into the worktree, and `H`
+            // (or `gH` for index) applies just the cursored hunk.
             return {
-                contextual: ['j/k hunks', '[/] file', 'c cherry-pick', 'y/Y yank', 'esc back'],
+                contextual: ['j/k hunks', '[/] file', 'c cherry-pick', 'H apply hunk', splitToggleHint, 'y/Y yank', 'esc back'],
                 global: NORMAL_GLOBAL_HINTS,
             };
         }
@@ -15148,8 +15625,23 @@ function getLogInkFooterHints(options) {
             global: NORMAL_GLOBAL_HINTS,
         };
     }
+    if (options.activeView === 'pull-request') {
+        return {
+            // #783 — full PR action panel. Five mutating ops scoped to this
+            // view: m / x / a / R / c, plus O for open-in-browser (already
+            // a global). Each routes through y-confirm or an input prompt;
+            // none fire silently.
+            contextual: ['m merge', 'x close', 'a approve', 'R changes', 'c comment', 'O open', 'esc back'],
+            global: NORMAL_GLOBAL_HINTS,
+        };
+    }
     return {
-        contextual: ['↑/↓ move', 'enter diff', 'c cherry-pick', 'y/Y yank', '/ search', 'gg/G top/bottom'],
+        // History view default hints. Mutating ops (`c` cherry-pick, `R`
+        // revert, `Z` reset, `i` interactive-rebase) all route through a
+        // y-confirm or mode prompt — none fire silently from the keystroke.
+        // Grouped into a compact `c/R/Z/i mutate` chip so the footer stays
+        // scannable; full descriptions live in `?` help and the palette.
+        contextual: ['↑/↓ move', 'enter diff', 'c/R/Z/i mutate', 'y/Y yank', '/ search', 'gg/G top/bottom'],
         global: NORMAL_GLOBAL_HINTS,
     };
 }
@@ -15292,39 +15784,6 @@ function filterLogInkPaletteCommands(commands, filter, recent) {
         .map((entry) => entry.command);
 }
 
-/**
- * The chars `git log --graph` emits for branch topology — `*`, `|`, `\`,
- * `/`, `_`, ` `. ASCII-only output is bulletproof for legacy terminals
- * but the angles read poorly when many branches overlap.
- *
- * `substituteGraphChars` swaps them for box-drawing / geometric Unicode
- * equivalents when the terminal can render them; falls back to ASCII
- * under `theme.ascii` (TERM=dumb / vt100) and `theme.noColor` is
- * orthogonal — the Unicode chars are still rendered, just without color.
- *
- * Kept ASCII-only intentionally:
- *   - alphanumerics       (commit refs / annotations git sometimes injects)
- *   - parens / brackets   (HEAD decoration markers, not part of the graph)
- *   - hyphens / colons    (likewise)
- */
-const ASCII_TO_UNICODE = {
-    '*': '●',
-    '|': '│',
-    '/': '╱',
-    '\\': '╲',
-    '_': '─',
-};
-function substituteGraphChars(graph, options) {
-    if (options.ascii) {
-        return graph;
-    }
-    let output = '';
-    for (const character of graph) {
-        output += ASCII_TO_UNICODE[character] ?? character;
-    }
-    return output;
-}
-
 /**
  * OSC 8 hyperlink helpers for the Ink TUI (P5.1).
  *
@@ -15396,6 +15855,84 @@ function formatHyperlink(text, url, env = process.env) {
     return `${OSC_PREFIX}${url}${ST}${text}${OSC_PREFIX}${ST}`;
 }
 
+/**
+ * Extract a single hunk from a unified-patch diff so it can be fed to
+ * `git apply` (or `git apply --cached`) for a hunk-level cherry-pick.
+ *
+ * The TUI's diff explore views render two flavors of patch text:
+ *
+ *   - stash-diff: full `git stash show -p` output, which includes
+ *     `diff --git`, `---`, `+++`, and one or more `@@ ... @@` hunks
+ *     per file.
+ *   - commit-diff: the per-file `filePreview.hunks` array, which is
+ *     hunks-only (no `diff --git` / `---` / `+++` headers).
+ *
+ * Either way, this helper walks `lines` from `cursorOffset` backwards
+ * to find the most recent `@@` header, walks forward to the end of
+ * that hunk's body, and synthesizes a fresh `diff --git` /
+ * `---` / `+++` set using the caller-provided path. The output is a
+ * complete, self-contained patch suitable for `git apply` without
+ * having to preserve original headers from `lines`.
+ */
+const HUNK_HEADER_PREFIX = '@@';
+const DIFF_GIT_PREFIX = 'diff --git ';
+/**
+ * Find the index of the `@@` hunk header at or before `cursorOffset`.
+ * Returns -1 when the cursor sits before the first hunk in the patch
+ * (i.e. on a `diff --git` / `---` / `+++` header line) — caller treats
+ * that as "no hunk at cursor" and surfaces a status message.
+ */
+function findHunkHeaderAtOrBefore(lines, cursorOffset) {
+    const start = Math.min(cursorOffset, lines.length - 1);
+    for (let i = start; i >= 0; i -= 1) {
+        if (lines[i]?.startsWith(HUNK_HEADER_PREFIX)) {
+            return i;
+        }
+    }
+    return -1;
+}
+/**
+ * Walk forward from a hunk header to either the next `@@` header or
+ * the next `diff --git` line — that's where this hunk's body ends.
+ * The end index is exclusive (the line at `endIndex` is NOT part of
+ * this hunk).
+ */
+function findHunkBodyEnd(lines, headerIndex) {
+    for (let i = headerIndex + 1; i < lines.length; i += 1) {
+        const line = lines[i];
+        if (line?.startsWith(HUNK_HEADER_PREFIX) || line?.startsWith(DIFF_GIT_PREFIX)) {
+            return i;
+        }
+    }
+    return lines.length;
+}
+function extractDiffHunk(input) {
+    const { lines, cursorOffset, path } = input;
+    if (!lines.length || !path) {
+        return null;
+    }
+    const headerIndex = findHunkHeaderAtOrBefore(lines, cursorOffset);
+    if (headerIndex < 0) {
+        return null;
+    }
+    const bodyEnd = findHunkBodyEnd(lines, headerIndex);
+    // Header itself + at least one body line. An empty hunk body would
+    // mean the patch is malformed and `git apply` would reject it; bail
+    // out early so the caller can surface a clear status message.
+    if (bodyEnd <= headerIndex + 1) {
+        return null;
+    }
+    const hunkLines = lines.slice(headerIndex, bodyEnd);
+    const patchText = [
+        `diff --git a/${path} b/${path}`,
+        `--- a/${path}`,
+        `+++ b/${path}`,
+        ...hunkLines,
+        '',
+    ].join('\n');
+    return { patchText };
+}
+
 /**
  * Sort modes for the promoted views (P4.2).
  *
@@ -15765,6 +16302,7 @@ function createLogInkState(rows, options = {}) {
         sidebarTab: 'status',
         userSidebarTab: 'status',
         statusFilterMask: { ...DEFAULT_LOG_INK_STATUS_FILTER_MASK },
+        diffViewMode: 'unified',
     };
 }
 function getSelectedInkCommit(state) {
@@ -15902,6 +16440,7 @@ function applyLogInkAction(state, action) {
                     kind: action.kind,
                     label: action.label,
                     value: action.initial || '',
+                    multiline: action.multiline,
                 },
                 pendingKey: undefined,
             };
@@ -15934,6 +16473,27 @@ function applyLogInkAction(state, action) {
         }
         case 'setHistoryFetchArgs':
             return { ...state, historyFetchArgs: action.value, pendingKey: undefined };
+        case 'toggleDiffViewMode':
+            // Reset the scroll offsets so the new mode opens at the top — long
+            // lines wrap differently in split mode (the renderer truncates per
+            // column instead of per row), so the saved offset can land on a
+            // different visual line. Snap to the top is simpler than mapping
+            // unified offsets to split offsets.
+            return {
+                ...state,
+                diffViewMode: state.diffViewMode === 'unified' ? 'split' : 'unified',
+                diffPreviewOffset: 0,
+                worktreeDiffOffset: 0,
+                pendingKey: undefined,
+            };
+        case 'setDiffViewMode':
+            return {
+                ...state,
+                diffViewMode: action.value,
+                diffPreviewOffset: 0,
+                worktreeDiffOffset: 0,
+                pendingKey: undefined,
+            };
         case 'moveToBottom':
             return {
                 ...state,
@@ -16212,12 +16772,151 @@ function applyLogInkAction(state, action) {
     }
 }
 
+/**
+ * In-sidebar selection helpers (#791 follow-up — sidebar entity ops).
+ *
+ * The workstation sidebar's branches / tags / stashes / worktrees tabs
+ * used to be read-only previews — to act on an entity the user had to
+ * drill into the dedicated promoted view. With the per-entity ops
+ * gated to also fire on `state.focus === 'sidebar'` plus a matching
+ * `sidebarTab`, j/k navigates the visible list inside the sidebar
+ * itself, Enter performs the primary action (checkout / open diff),
+ * and the existing per-view secondary keys (a/p/X/D/R/u/+P) are now
+ * reachable without leaving the workstation view.
+ *
+ * The sidebar accordion is short — the visible window for an active
+ * tab is capped (defaults below) so a long branch list doesn't
+ * collapse the rest of the chrome. When the cursor scrolls past the
+ * visible window, this module produces a sliding window that keeps it
+ * in view; the dedicated view stays the right home for "show me all
+ * 80 branches at once."
+ */
+const DEFAULT_SIDEBAR_VISIBLE = 8;
+/**
+ * Compute the sliding window so that `selected` stays inside it while
+ * the window remains anchored at the top whenever possible (so short
+ * lists don't scroll for no reason). When the cursor moves past the
+ * window, the window slides just enough to keep the cursor in view —
+ * matching the commit history's `clampWindowStart` behaviour for
+ * familiarity.
+ */
+function getSidebarVisibleWindow(total, selected, visible = DEFAULT_SIDEBAR_VISIBLE) {
+    const size = Math.max(1, Math.min(visible, total));
+    if (total <= visible) {
+        return { start: 0, size, truncatedAbove: 0, truncatedBelow: 0 };
+    }
+    const half = Math.floor(size / 2);
+    const idealStart = selected - half;
+    const maxStart = total - size;
+    const start = Math.max(0, Math.min(idealStart, maxStart));
+    return {
+        start,
+        size,
+        truncatedAbove: start,
+        truncatedBelow: total - (start + size),
+    };
+}
+/**
+ * True when an in-sidebar action (j/k move, Enter checkout, etc.)
+ * should fire instead of the generic drill-in / tab-cycle behaviour.
+ *
+ * Status tab is excluded because its preview shows worktree files —
+ * those have their own selection model in the dedicated status view
+ * and the sidebar doesn't surface them as selectable rows.
+ */
+function sidebarTabHasSelectableItems(sidebarTab, itemCount) {
+    if (!itemCount || itemCount <= 0)
+        return false;
+    return sidebarTab === 'branches' ||
+        sidebarTab === 'tags' ||
+        sidebarTab === 'stashes' ||
+        sidebarTab === 'worktrees';
+}
+
 function action(actionValue) {
     return {
         type: 'action',
         action: actionValue,
     };
 }
+/**
+ * Build the events needed to apply the hunk under the diff cursor. The
+ * runtime workflow handler expects payload format `<target>\n<patch>`
+ * — splitting on the first newline keeps the patch body intact for
+ * targets like `worktree` and `index` (no newlines in the prefix).
+ *
+ * Returns [] when the user isn't on a commit-diff / stash-diff explore,
+ * or when no hunk can be extracted at the current cursor offset
+ * (e.g. cursor sits on a `diff --git` header before the first `@@`).
+ * Callers fall back to a contextual status message when this returns [].
+ */
+function buildApplyHunkEvents(state, context, target) {
+    if (state.activeView !== 'diff')
+        return [];
+    if (state.diffSource !== 'commit' && state.diffSource !== 'stash')
+        return [];
+    const lines = context.diffLinesForHunkApply;
+    if (!lines || lines.length === 0)
+        return [];
+    const path = state.diffSource === 'stash'
+        ? context.stashDiffSelectedPath
+        : context.commitDiffSelectedPath;
+    if (!path)
+        return [];
+    const extracted = extractDiffHunk({
+        lines,
+        cursorOffset: state.diffPreviewOffset,
+        path,
+    });
+    if (!extracted)
+        return [];
+    const id = target === 'index' ? 'apply-hunk-index' : 'apply-hunk-worktree';
+    return [{
+            type: 'runWorkflowAction',
+            id,
+            payload: `${target}\n${extracted.patchText}`,
+        }];
+}
+/**
+ * Per-entity action-target predicates. The promoted views (`branches`,
+ * `tags`, `stash`, `worktrees`) each scope a set of ops to their
+ * dedicated surface. The same ops also fire when the user has the
+ * sidebar focused on the matching tab — that's how in-sidebar
+ * selection (#791 follow-up) lets the user checkout / apply / drop
+ * without leaving the workstation view.
+ */
+function isBranchActionTarget(state) {
+    return (state.activeView === 'branches' && state.focus === 'commits') ||
+        (state.focus === 'sidebar' && state.sidebarTab === 'branches');
+}
+function isTagActionTarget(state) {
+    return (state.activeView === 'tags' && state.focus === 'commits') ||
+        (state.focus === 'sidebar' && state.sidebarTab === 'tags');
+}
+function isStashActionTarget(state) {
+    return (state.activeView === 'stash' && state.focus === 'commits') ||
+        (state.focus === 'sidebar' && state.sidebarTab === 'stashes');
+}
+function isWorktreeActionTarget(state) {
+    return (state.activeView === 'worktrees' && state.focus === 'commits') ||
+        (state.focus === 'sidebar' && state.sidebarTab === 'worktrees');
+}
+/**
+ * Item count for the active sidebar tab — used by the generic
+ * sidebar-Enter handler to decide whether to defer to the per-entity
+ * Enter (when items are present and the user is cursoring through
+ * them) or to drill into the dedicated view (when the tab is empty
+ * or has no per-entity Enter handler defined).
+ */
+function getSidebarItemCount(sidebarTab, context) {
+    switch (sidebarTab) {
+        case 'branches': return context.branchCount;
+        case 'tags': return context.tagCount;
+        case 'stashes': return context.stashCount;
+        case 'worktrees': return context.worktreeListCount;
+        default: return undefined;
+    }
+}
 /**
  * Translate a palette command into the same events its keystroke would have
  * produced. Phase 6 makes `:` a real launcher: this is the single mapping
@@ -16297,6 +16996,8 @@ function getLogInkPaletteExecuteEvents(command, state) {
             return [action({ type: 'pushView', value: 'stash' })];
         case 'navigateWorktrees':
             return [action({ type: 'pushView', value: 'worktrees' })];
+        case 'navigatePullRequest':
+            return [action({ type: 'pushView', value: 'pull-request' })];
         case 'navigateBack':
             return [action({ type: 'popView' })];
         case 'openSelected': {
@@ -16354,10 +17055,10 @@ function getLogInkPaletteExecuteEvents(command, state) {
         case 'clearSearch':
             return [action({ type: 'clearFilter' })];
         case 'cycleSort':
-            if (state.activeView === 'branches') {
+            if (isBranchActionTarget(state)) {
                 return [action({ type: 'cycleBranchSort' })];
             }
-            if (state.activeView === 'tags') {
+            if (isTagActionTarget(state)) {
                 return [action({ type: 'cycleTagSort' })];
             }
             return [action({
@@ -16394,6 +17095,77 @@ function hasUnsavedComposeDraft(state) {
     }
     return Boolean(compose.summary.trim() || compose.body.trim());
 }
+/**
+ * Submit the active input prompt — used by Enter on single-line
+ * prompts and by Ctrl+D on multi-line prompts (#806). Most prompt
+ * kinds dispatch a workflow whose id matches the kind
+ * (`create-branch`, `rename-branch`, etc.). A few are exceptions:
+ *   - `reset-mode` (#777) collects soft/mixed/hard and forwards the
+ *     mode as the payload to `reset-to-commit`.
+ *   - `pr-merge-strategy` (#783) validates the strategy and routes to
+ *     `merge-pr` via the y-confirm path.
+ *   - `pr-comment` dispatches `comment-pr` directly — the body itself
+ *     is the affirmative action.
+ *   - `pr-request-changes` routes to `request-changes-pr` via
+ *     y-confirm because the review is publicly visible.
+ * Each exception validates here so a typo doesn't surface as a
+ * "workflow not yet wired" status downstream.
+ *
+ * Empty values yield a hint instead of a no-op so the user knows what
+ * to do — the same UX whether they pressed Enter (single-line) or
+ * Ctrl+D (multi-line).
+ */
+function submitInputPrompt(state) {
+    if (!state.inputPrompt)
+        return [];
+    const value = state.inputPrompt.value.trim();
+    if (!value) {
+        return [action({ type: 'setStatus', value: 'enter a value or press esc to cancel' })];
+    }
+    if (state.inputPrompt.kind === 'reset-mode') {
+        const mode = value.toLowerCase();
+        if (mode !== 'soft' && mode !== 'mixed' && mode !== 'hard') {
+            return [action({
+                    type: 'setStatus',
+                    value: `Unknown reset mode: ${value}. Use soft, mixed, or hard.`,
+                })];
+        }
+        return [
+            { type: 'runWorkflowAction', id: 'reset-to-commit', payload: mode },
+            action({ type: 'closeInputPrompt' }),
+        ];
+    }
+    if (state.inputPrompt.kind === 'pr-merge-strategy') {
+        const strategy = value.toLowerCase();
+        if (strategy !== 'merge' && strategy !== 'squash' && strategy !== 'rebase') {
+            return [action({
+                    type: 'setStatus',
+                    value: `Unknown merge strategy: ${value}. Use merge, squash, or rebase.`,
+                })];
+        }
+        return [
+            action({ type: 'setPendingConfirmation', value: 'merge-pr', payload: strategy }),
+            action({ type: 'closeInputPrompt' }),
+        ];
+    }
+    if (state.inputPrompt.kind === 'pr-comment') {
+        return [
+            { type: 'runWorkflowAction', id: 'comment-pr', payload: value },
+            action({ type: 'closeInputPrompt' }),
+        ];
+    }
+    if (state.inputPrompt.kind === 'pr-request-changes') {
+        return [
+            action({ type: 'setPendingConfirmation', value: 'request-changes-pr', payload: value }),
+            action({ type: 'closeInputPrompt' }),
+        ];
+    }
+    const id = state.inputPrompt.kind;
+    return [
+        { type: 'runWorkflowAction', id, payload: value },
+        action({ type: 'closeInputPrompt' }),
+    ];
+}
 function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
     if (key.ctrl && inputValue === 'c') {
         if (hasUnsavedComposeDraft(state) && !state.pendingMutationConfirmation) {
@@ -16406,22 +17178,25 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
     // filter/confirmation/compose handlers so a prompt opened from inside
     // any of those still captures focus cleanly.
     if (state.inputPrompt) {
+        const isMultiline = Boolean(state.inputPrompt.multiline);
         if (key.escape) {
             return [
                 action({ type: 'closeInputPrompt' }),
                 action({ type: 'setStatus', value: 'cancelled' }),
             ];
         }
+        // Multi-line prompts (#806): Ctrl+D submits (Unix EOF convention,
+        // mirrors `git commit -m -` and HEREDOC patterns). Plain Enter
+        // inserts a newline so the user can compose review bodies / PR
+        // comments naturally without opening $EDITOR.
+        if (isMultiline && key.ctrl && inputValue === 'd') {
+            return submitInputPrompt(state);
+        }
+        if (isMultiline && key.return) {
+            return [action({ type: 'appendInputPrompt', value: '\n' })];
+        }
         if (key.return) {
-            const value = state.inputPrompt.value.trim();
-            if (!value) {
-                return [action({ type: 'setStatus', value: 'enter a value or press esc to cancel' })];
-            }
-            const id = state.inputPrompt.kind;
-            return [
-                { type: 'runWorkflowAction', id, payload: value },
-                action({ type: 'closeInputPrompt' }),
-            ];
+            return submitInputPrompt(state);
         }
         if (key.backspace || key.delete) {
             return [action({ type: 'backspaceInputPrompt' })];
@@ -16673,14 +17448,40 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
     }
     if (state.pendingKey === 'g' && inputValue === 'z') {
         return [
-            action({ type: 'pushView', value: 'stash' }),
-            action({ type: 'setStatus', value: 'jumped to stash' }),
+            action({ type: 'pushView', value: 'stash' }),
+            action({ type: 'setStatus', value: 'jumped to stash' }),
+        ];
+    }
+    if (state.pendingKey === 'g' && inputValue === 'w') {
+        return [
+            action({ type: 'pushView', value: 'worktrees' }),
+            action({ type: 'setStatus', value: 'jumped to worktrees' }),
+        ];
+    }
+    // `gp` jumps to the dedicated pull-request action panel (#783).
+    // Lowercase `p` matches the pattern of other navigation chords
+    // (gh / gs / gd / gc / gb / gt / gz / gw). The panel renders the
+    // current branch's PR via `gh pr view --json` enriched fields and
+    // exposes m / x / a / R / c action keys scoped to the view.
+    if (state.pendingKey === 'g' && inputValue === 'p') {
+        return [
+            action({ type: 'pushView', value: 'pull-request' }),
+            action({ type: 'setStatus', value: 'jumped to pull request' }),
         ];
     }
-    if (state.pendingKey === 'g' && inputValue === 'w') {
+    // `gH` chord: apply the cursored hunk to the index (`git apply
+    // --cached`). Sibling of bare `H` which targets the worktree.
+    // Discoverable via the footer hint on diff views and the help
+    // overlay; the explicit chord keeps `H` (single keystroke) for
+    // the more common worktree case.
+    if (state.pendingKey === 'g' && inputValue === 'H') {
+        const events = buildApplyHunkEvents(state, context, 'index');
+        if (events.length) {
+            return [action({ type: 'setPendingKey', value: undefined }), ...events];
+        }
         return [
-            action({ type: 'pushView', value: 'worktrees' }),
-            action({ type: 'setStatus', value: 'jumped to worktrees' }),
+            action({ type: 'setPendingKey', value: undefined }),
+            action({ type: 'setStatus', value: 'gH applies a hunk in commit-diff or stash-diff view' }),
         ];
     }
     if (inputValue === 'g') {
@@ -16692,6 +17493,22 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         }
         return [action({ type: 'setPendingKey', value: 'g' })];
     }
+    // `d` on the diff view toggles between unified and side-by-side split
+    // rendering (#785). Scoped to the diff view so the letter stays free
+    // for other surfaces. The chord branch above already claimed `gd`,
+    // so by the time we get here `pendingKey` is not `g`.
+    if (inputValue === 'd' && state.activeView === 'diff') {
+        const next = state.diffViewMode === 'unified' ? 'split' : 'unified';
+        return [
+            action({ type: 'toggleDiffViewMode' }),
+            action({
+                type: 'setStatus',
+                value: next === 'split'
+                    ? 'Switched to side-by-side diff'
+                    : 'Switched to unified diff',
+            }),
+        ];
+    }
     if (inputValue === '\\') {
         return [action({ type: 'toggleGraph' })];
     }
@@ -16714,10 +17531,10 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         return [{ type: 'refreshContext' }];
     }
     if (inputValue === 's') {
-        if (state.activeView === 'branches') {
+        if (isBranchActionTarget(state)) {
             return [action({ type: 'cycleBranchSort' })];
         }
-        if (state.activeView === 'tags') {
+        if (isTagActionTarget(state)) {
             return [action({ type: 'cycleTagSort' })];
         }
         // Falls through so other views (history/status/diff/compose/stash) still
@@ -16788,6 +17605,17 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
     if (key.tab) {
         return [action({ type: key.shift ? 'focusPrevious' : 'focusNext' })];
     }
+    // ←/→ on the sidebar switch tabs (Status ↔ Branches ↔ Tags ↔
+    // Stashes ↔ Worktrees) — the horizontal axis is "between tabs", the
+    // vertical axis (↑/↓ below) is "within the active tab's items".
+    // [/] still works as a keyboard alternative for users who prefer
+    // non-arrow keys.
+    if (key.leftArrow && state.focus === 'sidebar') {
+        return [action({ type: 'previousSidebarTab' })];
+    }
+    if (key.rightArrow && state.focus === 'sidebar') {
+        return [action({ type: 'nextSidebarTab' })];
+    }
     if (key.upArrow || inputValue === 'k') {
         if (state.focus === 'detail' && context.detailFileCount) {
             return [action({ type: 'moveDetailFile', delta: -1, fileCount: context.detailFileCount })];
@@ -16817,16 +17645,16 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
                     previewLineCount: context.previewLineCount,
                 })];
         }
-        if (state.activeView === 'branches' && context.branchCount) {
+        if (isBranchActionTarget(state) && context.branchCount) {
             return [action({ type: 'moveBranch', delta: -1, count: context.branchCount })];
         }
-        if (state.activeView === 'tags' && context.tagCount) {
+        if (isTagActionTarget(state) && context.tagCount) {
             return [action({ type: 'moveTag', delta: -1, count: context.tagCount })];
         }
-        if (state.activeView === 'stash' && context.stashCount) {
+        if (isStashActionTarget(state) && context.stashCount) {
             return [action({ type: 'moveStash', delta: -1, count: context.stashCount })];
         }
-        if (state.activeView === 'worktrees' && context.worktreeListCount) {
+        if (isWorktreeActionTarget(state) && context.worktreeListCount) {
             return [action({ type: 'moveWorktreeListEntry', delta: -1, count: context.worktreeListCount })];
         }
         if (state.activeView === 'history' &&
@@ -16836,6 +17664,11 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
             context.worktreeDirty) {
             return [action({ type: 'focusPendingCommit' })];
         }
+        // Sidebar fallback: when no entity claim above succeeds (status
+        // tab or empty content tab), ↑ falls through to cycling sidebar
+        // tabs so the user always has a way to navigate. With ←/→ above
+        // already handling tab switching, this is mostly a vim-style
+        // safety net for `k`.
         return [
             action(state.focus === 'sidebar'
                 ? { type: 'previousSidebarTab' }
@@ -16870,16 +17703,16 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
                     previewLineCount: context.previewLineCount,
                 })];
         }
-        if (state.activeView === 'branches' && context.branchCount) {
+        if (isBranchActionTarget(state) && context.branchCount) {
             return [action({ type: 'moveBranch', delta: 1, count: context.branchCount })];
         }
-        if (state.activeView === 'tags' && context.tagCount) {
+        if (isTagActionTarget(state) && context.tagCount) {
             return [action({ type: 'moveTag', delta: 1, count: context.tagCount })];
         }
-        if (state.activeView === 'stash' && context.stashCount) {
+        if (isStashActionTarget(state) && context.stashCount) {
             return [action({ type: 'moveStash', delta: 1, count: context.stashCount })];
         }
-        if (state.activeView === 'worktrees' && context.worktreeListCount) {
+        if (isWorktreeActionTarget(state) && context.worktreeListCount) {
             return [action({ type: 'moveWorktreeListEntry', delta: 1, count: context.worktreeListCount })];
         }
         return [
@@ -16983,30 +17816,42 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         }
     }
     // Enter on a sidebar tab drills into the corresponding promoted view
-    // (status / branches / tags / stash). Sits above the per-view Enter
-    // handlers so a sidebar-focused Enter never fires checkout-branch /
-    // navigateOpenDiffForCommit / etc. against the (hidden) selection in
-    // the active tab.
+    // (status / branches / tags / stash) — but only when the sidebar tab
+    // either has no per-entity Enter handler defined (status, tags,
+    // worktrees) or has zero items (so the dedicated view's empty-state
+    // tells the user what to do next).
+    //
+    // When the sidebar IS focused on a content tab WITH items, this
+    // handler defers to the per-entity Enter below (checkout-branch for
+    // branches, navigateOpenDiffForStash for stashes) so the user can
+    // act on the cursored item without leaving the workstation view —
+    // the in-sidebar selection win from #791 follow-up.
     //
-    // The Enter also moves focus out of the sidebar into the newly opened
-    // list — otherwise ↑/↓ keep cycling sidebar tabs instead of navigating
-    // inside the just-opened view, which made the drill-in feel half-done.
+    // The drill-in moves focus out of the sidebar into the newly opened
+    // list — otherwise ↑/↓ keep navigating the sidebar instead of the
+    // just-opened view, which made the drill-in feel half-done.
     if (key.return && state.focus === 'sidebar') {
-        const tabToView = {
-            status: 'status',
-            branches: 'branches',
-            tags: 'tags',
-            stashes: 'stash',
-            worktrees: 'worktrees',
-        };
-        const target = tabToView[state.sidebarTab];
-        if (target) {
-            return [
-                action({ type: 'pushView', value: target }),
-                action({ type: 'setFocus', value: 'commits' }),
-            ];
+        const sidebarItemCount = getSidebarItemCount(state.sidebarTab, context);
+        const hasInSidebarPrimaryAction = (state.sidebarTab === 'branches' || state.sidebarTab === 'stashes') &&
+            sidebarTabHasSelectableItems(state.sidebarTab, sidebarItemCount);
+        if (!hasInSidebarPrimaryAction) {
+            const tabToView = {
+                status: 'status',
+                branches: 'branches',
+                tags: 'tags',
+                stashes: 'stash',
+                worktrees: 'worktrees',
+            };
+            const target = tabToView[state.sidebarTab];
+            if (target) {
+                return [
+                    action({ type: 'pushView', value: target }),
+                    action({ type: 'setFocus', value: 'commits' }),
+                ];
+            }
+            return [action({ type: 'setStatus', value: 'no detail view for this tab' })];
         }
-        return [action({ type: 'setStatus', value: 'no detail view for this tab' })];
+        // Fall through — per-entity Enter handler below claims the keystroke.
     }
     if (key.return && state.activeView === 'status' && state.focus === 'commits' && context.worktreeFileCount) {
         return [action({
@@ -17015,8 +17860,10 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
             })];
     }
     // Enter on a branch row checks the branch out. Non-destructive workflow
-    // action — no confirmation prompt.
-    if (key.return && state.activeView === 'branches' && state.focus === 'commits' && context.branchCount) {
+    // action — no confirmation prompt. Fires from either the dedicated
+    // branches view or from the sidebar when the branches tab is focused
+    // with items.
+    if (key.return && isBranchActionTarget(state) && context.branchCount) {
         return [{ type: 'runWorkflowAction', id: 'checkout-branch' }];
     }
     // `+` opens a create-branch / create-tag prompt depending on context.
@@ -17043,32 +17890,33 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
     }
     // Per-view stash actions: `a` apply (keep the stash), `p` pop (apply
     // then drop). Drop is the existing destructive `X` workflow which
-    // routes through the y-confirm path. Scoped to the stash view so the
-    // letters stay free elsewhere.
-    if (inputValue === 'a' && state.activeView === 'stash' && context.stashCount) {
+    // routes through the y-confirm path. Scoped to the stash target so
+    // the letters stay free elsewhere — the target predicate also fires
+    // when the sidebar's stashes tab is focused with items.
+    if (inputValue === 'a' && isStashActionTarget(state) && context.stashCount) {
         return [{ type: 'runWorkflowAction', id: 'apply-stash' }];
     }
-    if (inputValue === 'p' && state.activeView === 'stash' && context.stashCount) {
+    if (inputValue === 'p' && isStashActionTarget(state) && context.stashCount) {
         return [{ type: 'runWorkflowAction', id: 'pop-stash' }];
     }
     // Per-view tag action: `P` pushes the selected tag to origin. Letter
-    // is scoped to the tags surface so it doesn't collide with `p` for
+    // is scoped to the tags target so it doesn't collide with `p` for
     // pop-stash. Note: this also takes precedence over the global
     // push-current-branch workflow's `P` key.
-    if (inputValue === 'P' && state.activeView === 'tags' && context.tagCount) {
+    if (inputValue === 'P' && isTagActionTarget(state) && context.tagCount) {
         return [{ type: 'runWorkflowAction', id: 'push-tag' }];
     }
     // Per-view branches actions: `R` renames the selected branch, `u`
     // sets its upstream. Both open the input prompt so the user can type
     // the new value. Pre-fills are handled by the prompt's `initial`.
-    if (inputValue === 'R' && state.activeView === 'branches' && context.branchCount) {
+    if (inputValue === 'R' && isBranchActionTarget(state) && context.branchCount) {
         return [action({
                 type: 'openInputPrompt',
                 kind: 'rename-branch',
                 label: 'Rename branch to',
             })];
     }
-    if (inputValue === 'u' && state.activeView === 'branches' && context.branchCount) {
+    if (inputValue === 'u' && isBranchActionTarget(state) && context.branchCount) {
         return [action({
                 type: 'openInputPrompt',
                 kind: 'set-upstream',
@@ -17076,11 +17924,48 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
             })];
     }
     // Per-view tag action: `R` deletes the tag from the remote (after
-    // confirmation). Scoped per-view so this letter is free elsewhere
-    // (especially the `R` rename binding on the branches view).
-    if (inputValue === 'R' && state.activeView === 'tags' && context.tagCount) {
+    // confirmation). Scoped per-target so this letter is free elsewhere
+    // (especially the `R` rename binding on the branches target).
+    if (inputValue === 'R' && isTagActionTarget(state) && context.tagCount) {
         return [action({ type: 'setPendingConfirmation', value: 'delete-remote-tag' })];
     }
+    // #783 — full PR action panel keys, scoped to the pull-request view.
+    // All five wrap a `gh pr <verb>` invocation; merge / request-changes /
+    // comment open prompts first, the rest route through the y-confirm
+    // path because they're irreversible (or near-irreversible).
+    if (inputValue === 'm' && state.activeView === 'pull-request') {
+        return [action({
+                type: 'openInputPrompt',
+                kind: 'pr-merge-strategy',
+                label: 'Merge strategy (merge / squash / rebase)',
+            })];
+    }
+    if (inputValue === 'x' && state.activeView === 'pull-request') {
+        return [action({ type: 'setPendingConfirmation', value: 'close-pr' })];
+    }
+    if (inputValue === 'a' && state.activeView === 'pull-request') {
+        return [action({ type: 'setPendingConfirmation', value: 'approve-pr' })];
+    }
+    if (inputValue === 'R' && state.activeView === 'pull-request') {
+        // Free-form review body — multi-line so the reviewer can structure
+        // their feedback naturally without opening $EDITOR (#806).
+        return [action({
+                type: 'openInputPrompt',
+                kind: 'pr-request-changes',
+                label: 'Request changes — review body (Enter newline · Ctrl+D submit)',
+                multiline: true,
+            })];
+    }
+    if (inputValue === 'c' && state.activeView === 'pull-request') {
+        // Free-form comment body — multi-line for the same reason as
+        // pr-request-changes.
+        return [action({
+                type: 'openInputPrompt',
+                kind: 'pr-comment',
+                label: 'Comment body (Enter newline · Ctrl+D submit)',
+                multiline: true,
+            })];
+    }
     // Global stash hotkey: `S` opens a stash-message prompt and
     // `createStash` runs once submitted. Available everywhere there's
     // not a more modal handler in front of it.
@@ -17138,6 +18023,21 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
                 payload: `${context.commitDiffSelectedSha} ${context.commitDiffSelectedPath}`,
             })];
     }
+    // `H` on a commit-diff or stash-diff explore extracts the hunk under
+    // the cursor and applies it to the working tree (`git apply`). The
+    // sibling `gH` chord targets the index (`git apply --cached`). Both
+    // bypass the y-confirm path because `git apply` is non-destructive
+    // (it'll fail loudly on conflict and `git apply -R` undoes a clean
+    // apply).
+    if (inputValue === 'H') {
+        const events = buildApplyHunkEvents(state, context, 'worktree');
+        if (events.length) {
+            return events;
+        }
+        if (state.activeView === 'diff' && (state.diffSource === 'commit' || state.diffSource === 'stash')) {
+            return [action({ type: 'setStatus', value: 'no hunk under cursor — j/k to a + or - line first' })];
+        }
+    }
     // `c` on the history view cherry-picks the full selected commit on
     // top of the current branch. Routed through the y-confirm flow since
     // it can produce conflicts and is a real working-tree mutation.
@@ -17148,6 +18048,46 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         !state.pendingCommitFocused) {
         return [action({ type: 'setPendingConfirmation', value: 'cherry-pick-commit' })];
     }
+    // `R` reverts the cursored commit by adding an inverse commit on top
+    // of HEAD. Same y-confirm gate as cherry-pick — non-rewriting but
+    // still a real mutation.
+    if (inputValue === 'R' &&
+        state.activeView === 'history' &&
+        state.focus === 'commits' &&
+        state.filteredCommits.length > 0 &&
+        !state.pendingCommitFocused) {
+        return [action({ type: 'setPendingConfirmation', value: 'revert-commit' })];
+    }
+    // `Z` resets the current branch tip to the cursored commit. Opens a
+    // mode prompt (soft / mixed / hard) instead of jumping straight to
+    // confirmation because the choice changes the destructiveness
+    // dramatically — `--hard` discards working-tree changes. The prompt
+    // submission special-cases `kind === 'reset-mode'` to forward the
+    // mode through `reset-to-commit` (see prompt-submit handler above).
+    // No `initial` value: existing prompts append to initial rather than
+    // replacing it, which would surprise the user typing the mode.
+    if (inputValue === 'Z' &&
+        state.activeView === 'history' &&
+        state.focus === 'commits' &&
+        state.filteredCommits.length > 0 &&
+        !state.pendingCommitFocused) {
+        return [action({
+                type: 'openInputPrompt',
+                kind: 'reset-mode',
+                label: 'Reset mode (soft / mixed / hard)',
+            })];
+    }
+    // `i` (lowercase) starts an interactive rebase from the cursored
+    // commit's parent. Lowercase keeps the existing global `I`
+    // ai-commit-summary workflow reachable on the history view; `i`
+    // also matches the `git rebase -i` flag mnemonic.
+    if (inputValue === 'i' &&
+        state.activeView === 'history' &&
+        state.focus === 'commits' &&
+        state.filteredCommits.length > 0 &&
+        !state.pendingCommitFocused) {
+        return [action({ type: 'setPendingConfirmation', value: 'interactive-rebase' })];
+    }
     // `y` / `Y` yank the contextually relevant identifier from the active
     // view to the system clipboard:
     //   history    → cursored commit hash (Y for short hash)
@@ -17163,13 +18103,13 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         if (state.activeView === 'history' && state.filteredCommits.length > 0) {
             return [{ type: 'yankFromActiveView', short }];
         }
-        if (state.activeView === 'branches' && context.branchCount) {
+        if (isBranchActionTarget(state) && context.branchCount) {
             return [{ type: 'yankFromActiveView' }];
         }
-        if (state.activeView === 'tags' && context.tagCount) {
+        if (isTagActionTarget(state) && context.tagCount) {
             return [{ type: 'yankFromActiveView' }];
         }
-        if (state.activeView === 'stash' && context.stashCount && context.stashSelectedRef) {
+        if (isStashActionTarget(state) && context.stashCount && context.stashSelectedRef) {
             return [{ type: 'yankFromActiveView' }];
         }
         if (state.activeView === 'status' && context.worktreeSelectedPath) {
@@ -17187,8 +18127,9 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
     // Enter on a stash row pushes the diff view scoped to that stash.
     // The runtime loads `git stash show -p <ref>` once the view is
     // active. The stash ref is passed via the action so we don't need a
-    // context lookup here.
-    if (key.return && state.activeView === 'stash' && state.focus === 'commits' && context.stashCount && context.stashSelectedRef) {
+    // context lookup here. Fires from either the dedicated stash view or
+    // from the sidebar when the stashes tab is focused with items.
+    if (key.return && isStashActionTarget(state) && context.stashCount && context.stashSelectedRef) {
         return [action({
                 type: 'navigateOpenDiffForStash',
                 ref: context.stashSelectedRef,
@@ -17249,7 +18190,7 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
  * fall back to "already seen" so we never block startup.
  */
 const MARKER_BASENAME = 'onboarding.seen';
-function resolveCacheDir$1() {
+function resolveCacheDir$2() {
     const xdg = process.env.XDG_CACHE_HOME;
     if (xdg && xdg.trim().length > 0) {
         return path__namespace$1.join(xdg, 'coco');
@@ -17257,7 +18198,7 @@ function resolveCacheDir$1() {
     return path__namespace$1.join(os__namespace$1.homedir(), '.cache', 'coco');
 }
 function getOnboardingMarkerPath() {
-    return path__namespace$1.join(resolveCacheDir$1(), MARKER_BASENAME);
+    return path__namespace$1.join(resolveCacheDir$2(), MARKER_BASENAME);
 }
 function hasSeenOnboarding() {
     try {
@@ -17281,6 +18222,52 @@ function markOnboardingSeen() {
     }
 }
 
+/**
+ * Persist the user's preferred diff view mode (unified vs side-by-side
+ * split — #785) per repo. Mirrors `inkSidebarPersistence.ts` so the
+ * cache layout, error model, and key derivation stay consistent across
+ * settings: best-effort, XDG-friendly, no PII in the cache filename.
+ */
+const VALID_MODES = ['unified', 'split'];
+function resolveCacheDir$1() {
+    const xdg = process.env.XDG_CACHE_HOME;
+    if (xdg && xdg.trim().length > 0) {
+        return path__namespace$1.join(xdg, 'coco');
+    }
+    return path__namespace$1.join(os__namespace$1.homedir(), '.cache', 'coco');
+}
+function repoKey$1(repoPath) {
+    // sha1 is used here as a non-security cache-key derivation — we just
+    // need a deterministic short identifier for the marker filename. No
+    // PII or auth context is hashed.
+    // DevSkim: ignore DS126858
+    return crypto__namespace.createHash('sha1').update(repoPath).digest('hex').slice(0, 16);
+}
+function getDiffViewModeMarkerPath(repoPath) {
+    return path__namespace$1.join(resolveCacheDir$1(), `diff-view-mode.${repoKey$1(repoPath)}`);
+}
+function getSavedDiffViewMode(repoPath) {
+    try {
+        const raw = fs__namespace$1.readFileSync(getDiffViewModeMarkerPath(repoPath), 'utf8').trim();
+        return VALID_MODES.includes(raw)
+            ? raw
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function saveDiffViewMode(repoPath, mode) {
+    const marker = getDiffViewModeMarkerPath(repoPath);
+    try {
+        fs__namespace$1.mkdirSync(path__namespace$1.dirname(marker), { recursive: true });
+        fs__namespace$1.writeFileSync(marker, mode);
+    }
+    catch {
+        // Best-effort persistence; swallow.
+    }
+}
+
 /**
  * Persist which sidebar tab the user last had active, keyed per repo so
  * switching projects doesn't reset every other repo's preference. The
@@ -17340,6 +18327,144 @@ function saveSidebarTab(repoPath, tab) {
     }
 }
 
+/**
+ * Pair-alignment helper for the side-by-side diff view (#785).
+ *
+ * Takes the unified-diff line array that the renderer already paints (one
+ * line per element, the leading character drives `+`/`-`/context coloring)
+ * and re-shapes it into two-column rows the split renderer can lay out
+ * without further parsing. Pure / synchronous so it can be exercised from
+ * tests without spinning up Ink.
+ *
+ * Algorithm:
+ *  1. Walk lines in order. `@@` headers seed a new hunk and reset the
+ *     `oldLineNo` / `newLineNo` cursors from the header range.
+ *  2. Inside a hunk, group the consecutive runs of `-` and `+` lines that
+ *     follow each other. Each run of removals + the immediately-following
+ *     run of additions forms a "change block" that pairs up element-wise:
+ *     row[i] = { left: removals[i], right: additions[i] }. When one side
+ *     is shorter, pad with `kind: 'empty'` rows so the columns stay
+ *     aligned.
+ *  3. Context lines emit as a paired row with the same text on both
+ *     sides and the synthesized line numbers from each cursor.
+ *  4. Diff metadata (`diff `, `index `, `--- `, `+++ `, etc.) emit as
+ *     `kind: 'header'` rows so the split view still has a section break.
+ *  5. A context line that interrupts a change block forces the in-flight
+ *     block to flush before the context row is emitted — pairs are never
+ *     drawn across context boundaries (matches lazygit / fugitive
+ *     behavior, and is what the issue specifies).
+ *
+ * Long lines are not wrapped here — the renderer truncates per column at
+ * paint time so this helper stays pure and trivially testable.
+ */
+const EMPTY_LEFT = { text: '', kind: 'empty' };
+const EMPTY_RIGHT = { text: '', kind: 'empty' };
+/**
+ * Parse the start line numbers out of an `@@ -A,B +C,D @@` header. Returns
+ * `[oldStart, newStart]`; either falls back to 1 when the header is
+ * malformed (which only happens with synthetic / hand-crafted patches).
+ */
+function parseHunkHeader(line) {
+    const match = /@@\s+-(\d+)(?:,\d+)?\s+\+(\d+)(?:,\d+)?\s+@@/.exec(line);
+    if (!match) {
+        return [1, 1];
+    }
+    return [Number(match[1]) || 1, Number(match[2]) || 1];
+}
+function isDiffHeader(line) {
+    return (line.startsWith('diff ') ||
+        line.startsWith('index ') ||
+        line.startsWith('--- ') ||
+        line.startsWith('+++ ') ||
+        line.startsWith('similarity ') ||
+        line.startsWith('rename ') ||
+        line.startsWith('copy ') ||
+        line.startsWith('new file ') ||
+        line.startsWith('deleted file ') ||
+        line.startsWith('old mode ') ||
+        line.startsWith('new mode ') ||
+        line.startsWith('Binary files '));
+}
+/**
+ * Flush a pending change block (removals + additions accumulated from a
+ * contiguous `-`/`+` run) into paired rows. Pads the shorter side with
+ * empty placeholders so columns stay aligned.
+ */
+function flushChangeBlock(removals, additions, rows) {
+    const max = Math.max(removals.length, additions.length);
+    for (let i = 0; i < max; i++) {
+        const left = removals[i] || EMPTY_LEFT;
+        const right = additions[i] || EMPTY_RIGHT;
+        rows.push({ left, right });
+    }
+    removals.length = 0;
+    additions.length = 0;
+}
+function buildSplitDiffRows(unifiedLines) {
+    const rows = [];
+    let oldLineNo = 0;
+    let newLineNo = 0;
+    let inHunk = false;
+    const removals = [];
+    const additions = [];
+    const flushHeader = (text) => {
+        flushChangeBlock(removals, additions, rows);
+        rows.push({
+            left: { text, kind: 'header' },
+            right: { text, kind: 'header' },
+        });
+    };
+    for (const raw of unifiedLines) {
+        if (raw.startsWith('@@')) {
+            flushChangeBlock(removals, additions, rows);
+            const [oldStart, newStart] = parseHunkHeader(raw);
+            oldLineNo = oldStart;
+            newLineNo = newStart;
+            inHunk = true;
+            rows.push({
+                left: { text: raw, kind: 'header' },
+                right: { text: raw, kind: 'header' },
+            });
+            continue;
+        }
+        if (!inHunk || isDiffHeader(raw)) {
+            flushHeader(raw);
+            continue;
+        }
+        if (raw.startsWith('-')) {
+            removals.push({
+                text: raw.slice(1),
+                lineNumber: oldLineNo,
+                kind: 'remove',
+            });
+            oldLineNo += 1;
+            continue;
+        }
+        if (raw.startsWith('+')) {
+            additions.push({
+                text: raw.slice(1),
+                lineNumber: newLineNo,
+                kind: 'add',
+            });
+            newLineNo += 1;
+            continue;
+        }
+        // Context line (or `` marker, which we
+        // treat like a context row so it lands on both sides — readers
+        // expect to see it in either column).
+        flushChangeBlock(removals, additions, rows);
+        const text = raw.startsWith(' ') ? raw.slice(1) : raw;
+        rows.push({
+            left: { text, lineNumber: oldLineNo, kind: 'context' },
+            right: { text, lineNumber: newLineNo, kind: 'context' },
+        });
+        oldLineNo += 1;
+        newLineNo += 1;
+    }
+    flushChangeBlock(removals, additions, rows);
+    return rows;
+}
+
 /**
  * Promoted-view selection rectification on filter changes (P4.5).
  *
@@ -17761,7 +18886,8 @@ function createLogInkTheme(options = {}) {
 /**
  * Format a branch's relationship to its upstream.
  * - no upstream  → "no upstream"
- * - even         → "even with <upstream>"
+ * - even         → "" (the boring default — keep the row tight; the row
+ *   marker already encodes "synced")
  * - divergent    → "↑<ahead> ↓<behind> <upstream>" (only the non-zero side
  *   is rendered so the line stays tight). ASCII mode falls back to the
  *   legacy `+N/-N` form.
@@ -17771,7 +18897,7 @@ function formatBranchDivergence(branch, options = {}) {
         return 'no upstream';
     }
     if (branch.ahead === 0 && branch.behind === 0) {
-        return `even with ${branch.upstream}`;
+        return '';
     }
     if (options.ascii) {
         return `+${branch.ahead}/-${branch.behind} ${branch.upstream}`;
@@ -17785,14 +18911,76 @@ function formatBranchDivergence(branch, options = {}) {
 }
 /**
  * Single-cell marker shown to the left of a branch name in lists.
- * `*` = current, `◌` = no upstream (detached from a remote), space otherwise.
+ *
+ * - `*` — current branch (regardless of remote state)
+ * - `◌` — no upstream
+ * - `≡` — has upstream + synced (ahead === 0 && behind === 0)
+ * - `↕` — has upstream + diverged (any non-zero ahead/behind)
+ * - ` ` — fallback / no info
+ *
+ * ASCII fallbacks (legible without box-drawing/arrow glyphs):
+ * - `?` for "no upstream", `=` for synced, `~` for diverged.
  */
 function branchRowMarker(branch, options = {}) {
     if (branch.current)
         return '*';
     if (!branch.upstream)
         return options.ascii ? '?' : '◌';
-    return ' ';
+    const ahead = branch.ahead ?? 0;
+    const behind = branch.behind ?? 0;
+    if (ahead === 0 && behind === 0) {
+        return options.ascii ? '=' : '≡';
+    }
+    return options.ascii ? '~' : '↕';
+}
+/**
+ * Compact, human-friendly relative timestamp for the branch row.
+ * Inputs:
+ * - `iso` — committer-date in `YYYY-MM-DD` form (as produced by
+ *   `for-each-ref` with `committerdate:short`).
+ * - `now` — reference instant; pass it explicitly so callers can pin it
+ *   for deterministic tests.
+ *
+ * Outputs (rounded toward the nearest unit):
+ * - `today`, `1d ago`, `2d ago` … up to 13d
+ * - `2w ago` … up to 8w
+ * - `2mo ago` … up to 12mo
+ * - `2y ago` for older
+ * - `''` for malformed inputs (caller renders nothing).
+ *
+ * "in the future" inputs (clock skew, bad data) collapse to `today`.
+ */
+function formatBranchLastTouched(iso, now) {
+    if (!iso)
+        return '';
+    // Tolerate either `YYYY-MM-DD` or `YYYY-MM-DDTHH:MM:SS…` ISO strings.
+    const match = /^(\d{4})-(\d{2})-(\d{2})/.exec(iso);
+    if (!match)
+        return '';
+    const year = Number.parseInt(match[1], 10);
+    const month = Number.parseInt(match[2], 10);
+    const day = Number.parseInt(match[3], 10);
+    if (!Number.isFinite(year) || !Number.isFinite(month) || !Number.isFinite(day))
+        return '';
+    // Compare at day granularity in UTC so a branch touched "yesterday"
+    // never reads "today" depending on the operator's timezone.
+    const branchUtc = Date.UTC(year, month - 1, day);
+    const nowUtc = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate());
+    const diffMs = nowUtc - branchUtc;
+    const oneDay = 24 * 60 * 60 * 1000;
+    const days = Math.floor(diffMs / oneDay);
+    if (days <= 0)
+        return 'today';
+    if (days < 14)
+        return `${days}d ago`;
+    const weeks = Math.floor(days / 7);
+    if (weeks < 9)
+        return `${weeks}w ago`;
+    const months = Math.floor(days / 30);
+    if (months < 12)
+        return `${months}mo ago`;
+    const years = Math.floor(days / 365);
+    return `${years}y ago`;
 }
 /**
  * Pick the glyph + color for a PR state badge.
@@ -18222,7 +19410,7 @@ function createChangelogArgv(input) {
         ...input,
     };
 }
-function compactOutputLines$2(output) {
+function compactOutputLines$3(output) {
     return output
         .split('\n')
         .map((line) => line.trim())
@@ -18246,7 +19434,7 @@ async function captureStdout(action) {
     }
 }
 function formatCapturedAiOutput(output) {
-    const lines = compactOutputLines$2(output);
+    const lines = compactOutputLines$3(output);
     const telemetry = lines.filter((line) => line.includes('[llm:summary]'));
     const content = lines.filter((line) => !line.includes('[llm]') && !line.includes('[llm:summary]'));
     const editable = content.join('\n');
@@ -18543,8 +19731,65 @@ function parsePullRequestInfo(output) {
     if (!trimmed) {
         return undefined;
     }
-    return JSON.parse(trimmed);
+    const raw = JSON.parse(trimmed);
+    const author = raw.author && typeof raw.author === 'object' && 'login' in raw.author
+        ? String(raw.author.login)
+        : undefined;
+    return {
+        number: raw.number,
+        title: raw.title,
+        url: raw.url,
+        state: raw.state,
+        isDraft: raw.isDraft,
+        headRefName: raw.headRefName,
+        baseRefName: raw.baseRefName,
+        body: typeof raw.body === 'string' ? raw.body : undefined,
+        author,
+        reviewDecision: typeof raw.reviewDecision === 'string' ? raw.reviewDecision : undefined,
+        mergeable: typeof raw.mergeable === 'string' ? raw.mergeable : undefined,
+        mergeStateStatus: typeof raw.mergeStateStatus === 'string' ? raw.mergeStateStatus : undefined,
+        statusCheckRollup: Array.isArray(raw.statusCheckRollup)
+            ? raw.statusCheckRollup.map((entry) => ({
+                name: String(entry.name || entry.context || 'check'),
+                status: typeof entry.status === 'string' ? entry.status : undefined,
+                conclusion: typeof entry.conclusion === 'string' ? entry.conclusion : undefined,
+            }))
+            : undefined,
+        reviews: Array.isArray(raw.reviews)
+            ? raw.reviews.map((entry) => {
+                const author = entry.author && typeof entry.author === 'object' && 'login' in entry.author
+                    ? String(entry.author.login)
+                    : '';
+                return {
+                    author,
+                    state: typeof entry.state === 'string' ? entry.state : '',
+                };
+            }).filter((review) => review.author)
+            : undefined,
+    };
 }
+/**
+ * `gh pr view --json` field list. Centralized so the data fetcher and
+ * any future re-fetch (e.g., refresh after a merge action) request the
+ * same shape — the parser depends on every field being present, even
+ * if optional, so they're safe to deserialize.
+ */
+const PULL_REQUEST_VIEW_JSON_FIELDS = [
+    'number',
+    'title',
+    'url',
+    'state',
+    'isDraft',
+    'headRefName',
+    'baseRefName',
+    'body',
+    'author',
+    'reviewDecision',
+    'mergeable',
+    'mergeStateStatus',
+    'statusCheckRollup',
+    'reviews',
+].join(',');
 async function getPullRequestOverview(git, runner = defaultGhRunner) {
     const [repository, currentBranchOutput] = await Promise.all([
         getGitHubRepository(git),
@@ -18576,7 +19821,7 @@ async function getPullRequestOverview(git, runner = defaultGhRunner) {
             'pr',
             'view',
             '--json',
-            'number,title,url,state,isDraft,headRefName,baseRefName',
+            PULL_REQUEST_VIEW_JSON_FIELDS,
         ]);
         return {
             available: true,
@@ -18743,7 +19988,7 @@ function providerBranchName(branch) {
     return branch.shortName;
 }
 
-function compactOutputLines$1(output) {
+function compactOutputLines$2(output) {
     return output
         .split('\n')
         .map((line) => line.trim())
@@ -18758,7 +20003,7 @@ async function runAction$5(action, successMessage) {
         };
     }
     catch (error) {
-        const lines = compactOutputLines$1(error.message);
+        const lines = compactOutputLines$2(error.message);
         return {
             ok: false,
             message: lines[0] || 'History action failed.',
@@ -18900,7 +20145,7 @@ async function compareCommits(git, from, to) {
     }
     try {
         const output = await git.raw(['diff', '--stat', '--color=never', `${from.hash}..${to.hash}`]);
-        const lines = compactOutputLines$1(output);
+        const lines = compactOutputLines$2(output);
         return {
             ok: true,
             message: `Compared ${from.shortHash}..${to.shortHash}`,
@@ -19067,6 +20312,61 @@ function createPullRequest(input, runner = defaultGhRunner) {
         };
     });
 }
+function isPullRequestMergeStrategy(value) {
+    return value === 'merge' || value === 'squash' || value === 'rebase';
+}
+function buildMergePullRequestArgs(strategy) {
+    // `--auto` and `--admin` are intentionally omitted — they're rarely
+    // what a user wants from a TUI and require explicit gh auth scopes.
+    // `--delete-branch` is opt-in via a future flag; default leaves the
+    // branch in place so the user can verify before cleanup.
+    return ['pr', 'merge', `--${strategy}`];
+}
+function mergePullRequest(strategy, runner = defaultGhRunner) {
+    return runGhAction(runner, buildMergePullRequestArgs(strategy), (output) => ({
+        ok: true,
+        message: output.trim() || `Merged pull request with ${strategy}`,
+    }));
+}
+function closePullRequest(runner = defaultGhRunner) {
+    return runGhAction(runner, ['pr', 'close'], (output) => ({
+        ok: true,
+        message: output.trim() || 'Closed pull request',
+    }));
+}
+/**
+ * `gh pr review --approve` requires the user's gh auth to have scope
+ * to write reviews — same scope that the in-browser approve button
+ * uses. The runner surfaces auth failures via the standard error path.
+ */
+function approvePullRequest(runner = defaultGhRunner) {
+    return runGhAction(runner, ['pr', 'review', '--approve'], (output) => ({
+        ok: true,
+        message: output.trim() || 'Approved pull request',
+    }));
+}
+/**
+ * Request changes — `gh pr review` requires a body with this verb so
+ * the empty-body case is rejected upstream by the input prompt.
+ */
+function requestChangesPullRequest(body, runner = defaultGhRunner) {
+    if (!body.trim()) {
+        return Promise.resolve({ ok: false, message: 'Review body required for change-request' });
+    }
+    return runGhAction(runner, ['pr', 'review', '--request-changes', '--body', body], (output) => ({
+        ok: true,
+        message: output.trim() || 'Requested changes',
+    }));
+}
+function commentPullRequest(body, runner = defaultGhRunner) {
+    if (!body.trim()) {
+        return Promise.resolve({ ok: false, message: 'Comment body required' });
+    }
+    return runGhAction(runner, ['pr', 'comment', '--body', body], (output) => ({
+        ok: true,
+        message: output.trim() || 'Comment added',
+    }));
+}
 
 async function runAction$4(action, successMessage) {
     try {
@@ -19691,7 +20991,7 @@ function applyLogTuiAction(state, action) {
     }
 }
 
-function compactOutputLines(output) {
+function compactOutputLines$1(output) {
     return output
         .split('\n')
         .map((line) => line.trim())
@@ -19706,7 +21006,7 @@ async function runAction(action, successMessage) {
         };
     }
     catch (error) {
-        const details = compactOutputLines(error.message);
+        const details = compactOutputLines$1(error.message);
         return {
             ok: false,
             message: details[0] || 'Git operation action failed.',
@@ -21355,35 +22655,303 @@ async function startInteractiveLog(git, rows, streams = {}) {
                 applyAndRender(applyLogTuiAction(state, { type: 'clearFilter' }));
             }
         };
-        input.on('keypress', onKeypress);
-        void Promise.all([
-            refreshBranches(),
-            refreshPullRequest(),
-            refreshTags(),
-            refreshWorktree(),
-            refreshStashes(),
-            refreshWorktreeList(),
-            refreshOperationOverview(),
-            refreshProviderOverview(),
-        ])
-            .then(async () => {
-            await refreshStatusHunks();
-            await render();
-        })
-            .catch(() => {
-            branches = undefined;
-            pullRequest = undefined;
-            tags = undefined;
-            worktree = undefined;
-            statusHunks = undefined;
-            stashes = undefined;
-            worktreeList = undefined;
-            operationOverview = undefined;
-            providerOverview = undefined;
-        });
-        void render();
+        input.on('keypress', onKeypress);
+        void Promise.all([
+            refreshBranches(),
+            refreshPullRequest(),
+            refreshTags(),
+            refreshWorktree(),
+            refreshStashes(),
+            refreshWorktreeList(),
+            refreshOperationOverview(),
+            refreshProviderOverview(),
+        ])
+            .then(async () => {
+            await refreshStatusHunks();
+            await render();
+        })
+            .catch(() => {
+            branches = undefined;
+            pullRequest = undefined;
+            tags = undefined;
+            worktree = undefined;
+            statusHunks = undefined;
+            stashes = undefined;
+            worktreeList = undefined;
+            operationOverview = undefined;
+            providerOverview = undefined;
+        });
+        void render();
+    });
+}
+
+function compactOutputLines(output) {
+    return output
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+async function safeUnlink(path) {
+    try {
+        await fs.promises.unlink(path);
+    }
+    catch (error) {
+        // ENOENT is fine — the temp file was never created or already
+        // cleaned up. Anything else we silently swallow because the
+        // worst-case impact is a single ~1KB file in $TMPDIR.
+        error.code;
+    }
+}
+/**
+ * Write a unified-diff patch to a temp file and feed it to
+ * `git apply` (or `git apply --cached` when target === 'index').
+ *
+ * This is the runner behind the `apply-hunk-worktree` /
+ * `apply-hunk-index` workflow actions — the input handler builds
+ * `patchText` from the cursored hunk via `extractDiffHunk` and the
+ * runtime hands it here.
+ *
+ * `--whitespace=nowarn` keeps `git apply` quiet about trailing
+ * whitespace differences (the most common false positive when the
+ * patch comes from a stash made on a different platform). Real
+ * conflicts still surface via the non-zero exit code.
+ *
+ * The patch is written to a temp file rather than piped on stdin
+ * because some `simple-git` adapters don't expose a clean stdin
+ * channel for `git.raw`; the tempfile path keeps the runner
+ * portable across environments.
+ */
+async function applyHunkPatch(git, patchText, options) {
+    if (!patchText.trim()) {
+        return {
+            ok: false,
+            message: 'No hunk under cursor to apply.',
+        };
+    }
+    const targetLabel = options.target === 'index' ? 'index' : 'worktree';
+    const tempPath = path.join(os.tmpdir(), `coco-hunk-${crypto$1.randomUUID()}.patch`);
+    try {
+        await fs.promises.writeFile(tempPath, patchText, 'utf8');
+        const args = ['apply'];
+        if (options.target === 'index') {
+            args.push('--cached');
+        }
+        args.push('--whitespace=nowarn');
+        args.push(tempPath);
+        try {
+            await git.raw(args);
+            return {
+                ok: true,
+                message: `Applied hunk to ${targetLabel}`,
+            };
+        }
+        catch (error) {
+            const lines = compactOutputLines(error.message);
+            return {
+                ok: false,
+                message: lines[0] || `Failed to apply hunk to ${targetLabel}`,
+                details: lines.slice(1, 6),
+            };
+        }
+    }
+    catch (error) {
+        return {
+            ok: false,
+            message: `Could not stage hunk for apply: ${error.message}`,
+        };
+    }
+    finally {
+        await safeUnlink(tempPath);
+    }
+}
+
+function formatStashHeaderIdentity(ref, stashes) {
+    if (!ref) {
+        return { subtitle: 'no stash', bodyLine: 'Stash:' };
+    }
+    const index = stashes?.findIndex((entry) => entry.ref === ref) ?? -1;
+    const entry = index >= 0 ? stashes[index] : undefined;
+    if (!entry) {
+        return {
+            subtitle: ref,
+            bodyLine: `Stash: ${ref}`,
+        };
+    }
+    const onBranch = entry.branch && entry.branch !== '<unknown>' ? ` on ${entry.branch}` : '';
+    const message = entry.message?.trim() || '(no message)';
+    return {
+        subtitle: `@{${index}} ${message}${onBranch}`,
+        bodyLine: `Stash: ${ref}${onBranch} — ${message}`,
+    };
+}
+
+/**
+ * Normalize gh's two parallel signals (`status` for in-flight check
+ * runs, `conclusion` for completed runs and status contexts) into a
+ * single status enum the renderer can map to a glyph + color.
+ */
+function normalizePullRequestCheckStatus(check) {
+    const status = (check.status || '').toUpperCase();
+    const conclusion = (check.conclusion || '').toUpperCase();
+    // In-flight check runs: gh emits `status: IN_PROGRESS|QUEUED` with
+    // no conclusion yet. `PENDING` covers status-context runs that are
+    // still waiting on a reporter.
+    if (!conclusion && (status === 'IN_PROGRESS' || status === 'QUEUED' || status === 'PENDING')) {
+        return 'pending';
+    }
+    switch (conclusion || status) {
+        case 'SUCCESS':
+            return 'success';
+        case 'FAILURE':
+        case 'ERROR':
+        case 'TIMED_OUT':
+        case 'ACTION_REQUIRED':
+            return 'failure';
+        case 'NEUTRAL':
+            return 'neutral';
+        case 'SKIPPED':
+        case 'CANCELLED':
+            return 'skipped';
+        default:
+            return 'pending';
+    }
+}
+/**
+ * Glyph for a normalized check status. ASCII fallbacks keep the panel
+ * usable on legacy terminals where the geometric shapes block isn't
+ * rendered.
+ */
+function pullRequestCheckGlyph(status, options = {}) {
+    if (options.ascii) {
+        switch (status) {
+            case 'success': return '+';
+            case 'failure': return 'x';
+            case 'pending': return '.';
+            case 'neutral': return '-';
+            case 'skipped': return '/';
+        }
+    }
+    switch (status) {
+        case 'success': return '✓';
+        case 'failure': return '✗';
+        case 'pending': return '◌';
+        case 'neutral': return '○';
+        case 'skipped': return '∼';
+    }
+}
+function summarizePullRequestChecks(checks) {
+    const summary = {
+        total: 0, success: 0, failure: 0, pending: 0, neutral: 0, skipped: 0,
+    };
+    if (!checks)
+        return summary;
+    for (const check of checks) {
+        summary.total += 1;
+        summary[normalizePullRequestCheckStatus(check)] += 1;
+    }
+    return summary;
+}
+/**
+ * One-line summary like `5 checks · 4 ✓ · 1 ◌` for the panel header.
+ * Hides zero-count categories so the line stays scannable.
+ */
+function formatPullRequestChecksSummary(summary, options = {}) {
+    if (summary.total === 0) {
+        return 'No status checks reported';
+    }
+    const parts = [`${summary.total} ${summary.total === 1 ? 'check' : 'checks'}`];
+    const push = (count, status) => {
+        if (count > 0)
+            parts.push(`${count} ${pullRequestCheckGlyph(status, options)}`);
+    };
+    push(summary.success, 'success');
+    push(summary.failure, 'failure');
+    push(summary.pending, 'pending');
+    push(summary.neutral, 'neutral');
+    push(summary.skipped, 'skipped');
+    return parts.join(' · ');
+}
+function buildPullRequestCheckRows(checks, options = {}) {
+    if (!checks)
+        return [];
+    return checks.map((check) => {
+        const status = normalizePullRequestCheckStatus(check);
+        return {
+            glyph: pullRequestCheckGlyph(status, options),
+            name: check.name,
+            status,
+            detail: (check.conclusion || check.status || '').toLowerCase(),
+        };
     });
 }
+function summarizePullRequestReviews(reviews, reviewDecision) {
+    const summary = {
+        total: 0, approved: 0, changesRequested: 0, commented: 0, dismissed: 0, pending: 0,
+        decisionLabel: reviewDecision || undefined,
+    };
+    if (!reviews)
+        return summary;
+    for (const review of reviews) {
+        summary.total += 1;
+        switch (review.state.toUpperCase()) {
+            case 'APPROVED':
+                summary.approved += 1;
+                break;
+            case 'CHANGES_REQUESTED':
+                summary.changesRequested += 1;
+                break;
+            case 'COMMENTED':
+                summary.commented += 1;
+                break;
+            case 'DISMISSED':
+                summary.dismissed += 1;
+                break;
+            case 'PENDING':
+                summary.pending += 1;
+                break;
+        }
+    }
+    return summary;
+}
+function formatPullRequestReviewsSummary(summary) {
+    const decision = summary.decisionLabel
+        ? summary.decisionLabel.replace(/_/g, ' ').toLowerCase()
+        : undefined;
+    if (summary.total === 0) {
+        return decision ? `No reviews · ${decision}` : 'No reviews submitted';
+    }
+    const parts = [`${summary.total} ${summary.total === 1 ? 'review' : 'reviews'}`];
+    if (summary.approved > 0)
+        parts.push(`${summary.approved} approved`);
+    if (summary.changesRequested > 0)
+        parts.push(`${summary.changesRequested} changes requested`);
+    if (summary.commented > 0)
+        parts.push(`${summary.commented} commented`);
+    if (summary.pending > 0)
+        parts.push(`${summary.pending} pending`);
+    if (summary.dismissed > 0)
+        parts.push(`${summary.dismissed} dismissed`);
+    if (decision)
+        parts.push(`decision: ${decision}`);
+    return parts.join(' · ');
+}
+/**
+ * One-line state badge for the header, e.g. `OPEN · draft` or `MERGED`.
+ * Mergeable / merge-state is appended as a secondary chip when the PR
+ * is open so the user sees `MERGEABLE` / `CONFLICTING` at a glance.
+ */
+function formatPullRequestStateLine(pr) {
+    const parts = [pr.state];
+    if (pr.isDraft)
+        parts.push('draft');
+    if (pr.state === 'OPEN' && pr.mergeable) {
+        parts.push(pr.mergeable.toLowerCase());
+    }
+    if (pr.state === 'OPEN' && pr.mergeStateStatus && pr.mergeStateStatus !== 'CLEAN') {
+        parts.push(pr.mergeStateStatus.toLowerCase());
+    }
+    return parts.join(' · ');
+}
 
 function sectionLines(title, diff) {
     const lines = diff.split('\n').map((line) => line.trimEnd());
@@ -21600,6 +23168,89 @@ function diffLineProps(line, theme) {
     }
     return {};
 }
+/**
+ * Minimum terminal width below which the split diff falls back to
+ * unified rendering (#785). Each column needs ~50 columns for code to
+ * read comfortably plus border + padding overhead, so anything narrower
+ * than ~120 columns gets the unified view regardless of the user's
+ * preference. The preference is preserved — switching back to a wide
+ * terminal restores split mode automatically.
+ */
+const MIN_SPLIT_DIFF_WIDTH = 120;
+function isSplitDiffViable(state, width) {
+    return state.diffViewMode === 'split' && width >= MIN_SPLIT_DIFF_WIDTH;
+}
+/**
+ * Style props for one side of a split-diff row, derived from the row's
+ * `kind` rather than the leading character (because the helper has
+ * already stripped the leading +/-/space). Keeps the colors aligned with
+ * `diffLineProps`.
+ */
+function splitDiffSideProps(kind, theme) {
+    if (kind === 'header') {
+        if (theme.noColor)
+            return { dimColor: true };
+        return { color: theme.colors.accent };
+    }
+    if (kind === 'empty') {
+        return { dimColor: true };
+    }
+    if (theme.noColor) {
+        return { dimColor: kind === 'context' };
+    }
+    if (kind === 'add')
+        return { color: theme.colors.gitAdded };
+    if (kind === 'remove')
+        return { color: theme.colors.gitDeleted };
+    return {};
+}
+/**
+ * Format one column of a split-diff row: an optional 4-digit line
+ * number prefix + the line text, padded/truncated to the column width.
+ * Empty rows render a faint `·` placeholder so the alignment gap is
+ * visible at a glance.
+ */
+function formatSplitDiffCell(side, columnWidth) {
+    if (side.kind === 'empty') {
+        const placeholder = ' · ';
+        return placeholder.padEnd(columnWidth);
+    }
+    if (side.kind === 'header') {
+        return truncate$1(side.text, columnWidth).padEnd(columnWidth);
+    }
+    const lineNo = side.lineNumber !== undefined ? String(side.lineNumber).padStart(4) : '    ';
+    // Strip the trailing newline that some diffs include. Keeps column
+    // widths predictable.
+    const text = side.text.replace(/\n$/, '');
+    // 4 digits + 1 space gutter = 5 chars; reserve that off the column
+    // before truncating the text.
+    const textRoom = Math.max(1, columnWidth - 5);
+    return `${lineNo} ${truncate$1(text, textRoom)}`.padEnd(columnWidth);
+}
+/**
+ * Render the split-diff body as a list of two-column rows. The caller
+ * is responsible for slicing the unified-line array to the visible
+ * window — the helper just transforms that slice into Ink nodes.
+ */
+function renderSplitDiffBody(h, components, unifiedSlice, startOffset, width, theme, keyPrefix) {
+    const { Box, Text } = components;
+    const rows = buildSplitDiffRows(unifiedSlice);
+    // Reserve 3 columns of gutter (1 left padding from the Box + 1 column
+    // separator + 1 right padding) so neither side touches the border.
+    const usable = Math.max(20, width - 4);
+    const gutter = 1;
+    const half = Math.max(10, Math.floor((usable - gutter) / 2));
+    return rows.map((row, index) => {
+        const leftProps = splitDiffSideProps(row.left.kind, theme);
+        const rightProps = splitDiffSideProps(row.right.kind, theme);
+        const leftText = formatSplitDiffCell(row.left, half);
+        const rightText = formatSplitDiffCell(row.right, half);
+        return h(Box, {
+            key: `${keyPrefix}-${startOffset + index}`,
+            flexDirection: 'row',
+        }, h(Box, { width: half, flexShrink: 0 }, h(Text, leftProps, leftText)), h(Box, { width: gutter, flexShrink: 0 }, h(Text, { dimColor: true }, ' ')), h(Box, { width: half, flexShrink: 0 }, h(Text, rightProps, rightText)));
+    });
+}
 /**
  * Pick a theme color for a single name-status code (`A`, `M`, `D`,
  * `R100`, etc.) so the inspector and commit-diff file list render with
@@ -21653,68 +23304,6 @@ function sidebarTabLabel(tab) {
             return tab;
     }
 }
-function sidebarLines(context, contextStatus, tab, width, state, theme) {
-    if (tab === 'status') {
-        const worktree = context.worktree;
-        if (isLogInkContextKeyLoading(contextStatus, 'worktree')) {
-            return ['Loading status...'];
-        }
-        if (!worktree) {
-            return ['Status unavailable'];
-        }
-        return [
-            `${worktree.stagedCount} staged`,
-            `${worktree.unstagedCount} unstaged`,
-            `${worktree.untrackedCount} untracked`,
-            '',
-            ...worktree.files.slice(0, 12).map((file) => `${file.indexStatus}${file.worktreeStatus} ${truncate$1(file.path, width - 3)}`),
-        ];
-    }
-    if (tab === 'branches') {
-        const branches = context.branches;
-        if (isLogInkContextKeyLoading(contextStatus, 'branches')) {
-            return ['Loading branches...'];
-        }
-        if (!branches) {
-            return ['Branches unavailable'];
-        }
-        const sortedBranches = sortBranches(branches.localBranches, state.branchSort);
-        return [
-            `Current: ${branches.currentBranch || '<detached>'}`,
-            branches.dirty ? 'Worktree: dirty' : 'Worktree: clean',
-            '',
-            ...sortedBranches.slice(0, 8).map((branch) => `${branchRowMarker(branch, { ascii: theme.ascii })} ${truncate$1(branch.shortName, width - 4)}`),
-            ...sortedBranches.slice(0, 4).map((branch) => `  ${truncate$1(formatBranchDivergence(branch, { ascii: theme.ascii }), width - 2)}`),
-        ];
-    }
-    if (tab === 'tags') {
-        if (isLogInkContextKeyLoading(contextStatus, 'tags')) {
-            return ['Loading tags...'];
-        }
-        const sortedTags = sortTags(context.tags?.tags || [], state.tagSort);
-        return sortedTags.length
-            ? sortedTags.slice(0, 12).map((tag) => `${truncate$1(tag.name, 16)} ${truncate$1(tag.subject, Math.max(8, width - 18))}`)
-            : ['No tags found'];
-    }
-    if (tab === 'stashes') {
-        if (isLogInkContextKeyLoading(contextStatus, 'stashes')) {
-            return ['Loading stashes...'];
-        }
-        return context.stashes?.stashes.length
-            ? context.stashes.stashes.slice(0, 12).map((stash) => `${stash.ref} ${truncate$1(stash.message, Math.max(8, width - stash.ref.length - 1))}`)
-            : ['No stashes found'];
-    }
-    if (isLogInkContextKeyLoading(contextStatus, 'worktreeList')) {
-        return ['Loading worktrees...'];
-    }
-    return context.worktreeList?.worktrees.length
-        ? context.worktreeList.worktrees.slice(0, 12).map((worktree) => {
-            const marker = worktree.current ? '*' : ' ';
-            const state = worktree.dirty ? 'dirty' : 'clean';
-            return `${marker} ${truncate$1(worktree.branch || worktree.path, Math.max(8, width - 8))} ${state}`;
-        })
-        : ['No linked worktrees'];
-}
 async function startInkInteractiveLog(git, rows, streams = {}, options = {}) {
     const input = streams.input || process.stdin;
     const output = streams.output || process.stdout;
@@ -22056,6 +23645,13 @@ function LogInkApp(deps) {
                 if (saved && saved !== state.userSidebarTab) {
                     dispatch({ type: 'restoreSidebarTab', value: saved });
                 }
+                // Diff view mode persistence (#785). Same per-repo cache pattern
+                // as the sidebar tab — restore the user's last preference if
+                // they had one. New repos / fresh installs default to unified.
+                const savedDiffMode = getSavedDiffViewMode(repoRoot);
+                if (savedDiffMode && savedDiffMode !== state.diffViewMode) {
+                    dispatch({ type: 'setDiffViewMode', value: savedDiffMode });
+                }
             }
             catch {
                 // Not in a worktree, or revparse failed; nothing to restore.
@@ -22069,6 +23665,12 @@ function LogInkApp(deps) {
             return;
         saveSidebarTab(repoRoot, state.userSidebarTab);
     }, [state.userSidebarTab]);
+    React.useEffect(() => {
+        const repoRoot = repoRootRef.current;
+        if (!repoRoot)
+            return;
+        saveDiffViewMode(repoRoot, state.diffViewMode);
+    }, [state.diffViewMode]);
     // P-stash-explorer: load `git stash show -p <ref>` once the diff view
     // becomes active with diffSource='stash'. Best-effort — empty stashes
     // or read errors fall through to a "no diff" hint at the render site.
@@ -22361,6 +23963,27 @@ function LogInkApp(deps) {
     // disappears. Called from the y-confirm path for delete-branch / delete-
     // tag / drop-stash / remove-worktree / abort-operation.
     const runWorkflowAction = React.useCallback(async (id, payload) => {
+        // Hunk-apply payload format: `<target>\n<patchText>` — the input
+        // handler synthesizes both pieces (target from the keystroke,
+        // patch text from extractDiffHunk against the live diff lines)
+        // and packs them into the single `payload` field. Splitting on
+        // the first newline keeps the patch body intact.
+        const runApplyHunk = (expectedTarget, raw) => {
+            if (!raw) {
+                return Promise.resolve({ ok: false, message: 'No hunk under cursor to apply.' });
+            }
+            const newlineIndex = raw.indexOf('\n');
+            if (newlineIndex < 0) {
+                return Promise.resolve({ ok: false, message: 'Malformed hunk-apply payload.' });
+            }
+            const target = raw.slice(0, newlineIndex) === 'index' ? 'index' : 'worktree';
+            const patchText = raw.slice(newlineIndex + 1);
+            // The input handler is the source of truth for target — but if a
+            // palette-injected payload mismatches the workflow id, prefer
+            // the workflow id so the user sees the action they asked for.
+            const effectiveTarget = expectedTarget || target;
+            return applyHunkPatch(git, patchText, { target: effectiveTarget });
+        };
         const handlers = {
             'create-branch': async () => {
                 const name = payload?.trim();
@@ -22466,6 +24089,44 @@ function LogInkApp(deps) {
                     message: commit.message,
                 });
             },
+            'revert-commit': async () => {
+                const commit = getSelectedInkCommit(state);
+                if (!commit)
+                    return { ok: false, message: 'No commit selected' };
+                return revertCommit(git, {
+                    hash: commit.hash,
+                    shortHash: commit.shortHash,
+                    message: commit.message,
+                });
+            },
+            'reset-to-commit': async () => {
+                const commit = getSelectedInkCommit(state);
+                if (!commit)
+                    return { ok: false, message: 'No commit selected' };
+                // Mode arrives via the action's `payload` field — the input
+                // handler runs the reset-mode prompt (kind: 'reset-mode') and
+                // routes the typed value here. Default to `mixed` (git's own
+                // default) when the user submitted an empty value.
+                const raw = payload?.trim().toLowerCase() || 'mixed';
+                if (!isResetMode(raw)) {
+                    return { ok: false, message: `Unknown reset mode: ${raw}. Use soft, mixed, or hard.` };
+                }
+                return resetToCommit(git, {
+                    hash: commit.hash,
+                    shortHash: commit.shortHash,
+                    message: commit.message,
+                }, raw);
+            },
+            'interactive-rebase': async () => {
+                const commit = getSelectedInkCommit(state);
+                if (!commit)
+                    return { ok: false, message: 'No commit selected' };
+                return startInteractiveRebase(git, {
+                    hash: commit.hash,
+                    shortHash: commit.shortHash,
+                    message: commit.message,
+                });
+            },
             'checkout-file-from-commit': async () => {
                 // payload is "<sha> <path>" so we pass both through a single
                 // string field on the action.
@@ -22481,6 +24142,8 @@ function LogInkApp(deps) {
                     return { ok: false, message: 'No commit file under cursor' };
                 return checkoutFileFromCommit(git, sha, path);
             },
+            'apply-hunk-worktree': async () => runApplyHunk('worktree', payload),
+            'apply-hunk-index': async () => runApplyHunk('index', payload),
             'remove-worktree': async () => {
                 const all = context.worktreeList?.worktrees || [];
                 // Resolve the target from the visible (filtered) list so a
@@ -22569,6 +24232,32 @@ function LogInkApp(deps) {
                     return { ok: false, message: 'Stash message required' };
                 return createStash(git, message);
             },
+            // #783 — full PR action panel handlers. Each wraps the matching
+            // pullRequestActions verb. Strategy / body arrives via `payload`
+            // — input prompts validate before they reach here, but the
+            // strategy guard stays as a defensive belt-and-suspenders since
+            // a future palette path could call us with a raw value.
+            'merge-pr': async () => {
+                const strategy = (payload || 'merge').toLowerCase();
+                if (!isPullRequestMergeStrategy(strategy)) {
+                    return { ok: false, message: `Unknown merge strategy: ${strategy}. Use merge, squash, or rebase.` };
+                }
+                return mergePullRequest(strategy);
+            },
+            'close-pr': async () => closePullRequest(),
+            'approve-pr': async () => approvePullRequest(),
+            'request-changes-pr': async () => {
+                const body = payload?.trim();
+                if (!body)
+                    return { ok: false, message: 'Review body required for change-request' };
+                return requestChangesPullRequest(body);
+            },
+            'comment-pr': async () => {
+                const body = payload?.trim();
+                if (!body)
+                    return { ok: false, message: 'Comment body required' };
+                return commentPullRequest(body);
+            },
         };
         const handler = handlers[id];
         if (!handler) {
@@ -22859,6 +24548,51 @@ function LogInkApp(deps) {
             });
         })();
     }, [dispatch, git, logArgv, state.historyFetchArgs]);
+    // Graph mode toggle (`g` key, #791 follow-up). The header label flips
+    // between "compact graph" and "full graph", but unless we re-fetch with
+    // the right `view`, the underlying rows still come from the user's
+    // initial argv (default `--first-parent --no-merges`) and the renderer
+    // has no topology to draw — defeating the per-lane / junction work.
+    // Mirrors the historyFetchArgs effect: skip first run, request-id ref
+    // for stale-completion guard, swap rows in place via replaceRows.
+    const toggleGraphEffectInitialized = React.useRef(false);
+    const toggleGraphRequestRef = React.useRef(0);
+    React.useEffect(() => {
+        if (!logArgv)
+            return;
+        if (!toggleGraphEffectInitialized.current) {
+            toggleGraphEffectInitialized.current = true;
+            return;
+        }
+        const requestId = toggleGraphRequestRef.current + 1;
+        toggleGraphRequestRef.current = requestId;
+        const merged = buildToggleGraphArgs(logArgv, state.fullGraph);
+        dispatch({
+            type: 'setStatus',
+            value: state.fullGraph
+                ? 'Loading full topology…'
+                : 'Loading compact history…',
+        });
+        void (async () => {
+            const nextRows = await safe(getLogRows(git, merged, { limit: LOG_INTERACTIVE_DEFAULT_LIMIT }));
+            if (!mountedRef.current || toggleGraphRequestRef.current !== requestId) {
+                return;
+            }
+            if (!nextRows) {
+                dispatch({ type: 'setStatus', value: 'Failed to refetch graph rows' });
+                return;
+            }
+            dispatch({ type: 'replaceRows', rows: nextRows });
+            const matched = getCommitRows(nextRows).length;
+            setHasMoreCommits(matched >= LOG_INTERACTIVE_DEFAULT_LIMIT);
+            dispatch({
+                type: 'setStatus',
+                value: state.fullGraph
+                    ? `Showing ${matched} commits across all branches`
+                    : `Showing ${matched} commits (compact)`,
+            });
+        })();
+    }, [dispatch, git, logArgv, state.fullGraph]);
     const commitDiffHunkOffsets = React.useMemo(() => (filePreview?.hunks
         .map((line, index) => (line.startsWith('@@') ? index : -1))
         .filter((index) => index >= 0)), [filePreview]);
@@ -22953,6 +24687,17 @@ function LogInkApp(deps) {
                 ? selected?.hash
                 : undefined,
             worktreeDirty,
+            // H / gH need the actual diff text (not just hunk offsets) to
+            // slice the cursored hunk into a `git apply` patch. Stash uses
+            // the full `git stash show -p` output; commit-diff uses the
+            // per-file `filePreview.hunks` array. Either way, extractDiffHunk
+            // walks `@@` headers and synthesizes a fresh diff --git / --- /
+            // +++ header set using the path the caller already resolved.
+            diffLinesForHunkApply: state.diffSource === 'stash'
+                ? stashDiffLines
+                : state.diffSource === 'commit'
+                    ? filePreview?.hunks
+                    : undefined,
         }).forEach((event) => {
             if (event.type === 'exit') {
                 exit();
@@ -23019,7 +24764,7 @@ function LogInkApp(deps) {
     if (showOnboarding) {
         return renderOnboardingOverlay(h, { Box, Text }, layout.rows, layout.columns, theme, appLabel);
     }
-    return h(Box, { flexDirection: 'column', height: layout.rows }, renderHeader(h, { Box, Text }, state, context, contextStatus, layout.columns, theme, appLabel), h(Box, { flexDirection: 'row', height: layout.bodyRows }, renderSidebar(h, { Box, Text }, state, context, contextStatus, layout.sidebarWidth, theme), renderMainPanel(h, { Box, Text }, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, layout.bodyRows, layout.mainPanelWidth, theme, hasMoreCommits, loadingMoreCommits), renderDetailPanel(h, { Box, Text }, state, context, contextStatus, detail, detailLoading, filePreview, filePreviewLoading, layout.detailWidth, theme)), renderFooter(h, { Box, Text }, state, theme, idleTip));
+    return h(Box, { flexDirection: 'column', height: layout.rows }, renderHeader(h, { Box, Text }, state, context, contextStatus, layout.columns, theme, appLabel), h(Box, { flexDirection: 'row', height: layout.bodyRows }, renderSidebar(h, { Box, Text }, state, context, contextStatus, layout.sidebarWidth, theme), renderMainPanel(h, { Box, Text }, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, layout.bodyRows, layout.mainPanelWidth, theme, hasMoreCommits, loadingMoreCommits), renderDetailPanel(h, { Box, Text }, state, context, contextStatus, detail, detailLoading, filePreview, filePreviewLoading, layout.detailWidth, theme)), renderFooter(h, { Box, Text }, state, context, theme, idleTip));
 }
 function renderHeader(h, components, state, context, contextStatus, columns, theme, appLabel) {
     const { Box, Text } = components;
@@ -23119,11 +24864,101 @@ function renderActiveSidebarContent(h, Text, tab, state, context, contextStatus,
     if (tab === 'status') {
         return renderActiveStatusTabContent(h, Text, context, contextStatus, width, theme);
     }
-    const lines = sidebarLines(context, contextStatus, tab, width - 6, state, theme);
-    return lines.map((line, index) => h(Text, {
-        key: `tab-content-${tab}-${index}`,
-        dimColor: !line.trim(),
-    }, truncate$1(`  ${line}`, width - 4)));
+    // Branches / tags / stashes / worktrees: render selectable rows so
+    // ↑/↓ navigates within the sidebar list and Enter / per-entity keys
+    // act on the cursored item without needing to drill into the
+    // dedicated view (#791 follow-up — in-sidebar selection).
+    const focused = state.focus === 'sidebar' && state.sidebarTab === tab;
+    if (tab === 'branches') {
+        if (isLogInkContextKeyLoading(contextStatus, 'branches')) {
+            return [h(Text, { key: 'tab-branches-loading', dimColor: true }, '  Loading branches…')];
+        }
+        const branches = context.branches;
+        if (!branches) {
+            return [h(Text, { key: 'tab-branches-empty', dimColor: true }, '  Branches unavailable')];
+        }
+        const sortedBranches = sortBranches(branches.localBranches, state.branchSort);
+        const headerRows = [
+            h(Text, { key: 'tab-branches-current', dimColor: true }, truncate$1(`  Current: ${branches.currentBranch || '<detached>'}`, width - 4)),
+            h(Text, { key: 'tab-branches-state', dimColor: true }, `  Worktree: ${branches.dirty ? 'dirty' : 'clean'}`),
+            h(Text, { key: 'tab-branches-spacer' }, ''),
+        ];
+        return [
+            ...headerRows,
+            ...renderSelectableSidebarRows(h, Text, sortedBranches, state.selectedBranchIndex, focused, width, theme, (branch) => `${branchRowMarker(branch, { ascii: theme.ascii })} ${branch.shortName}`, 'tab-branches'),
+        ];
+    }
+    if (tab === 'tags') {
+        if (isLogInkContextKeyLoading(contextStatus, 'tags')) {
+            return [h(Text, { key: 'tab-tags-loading', dimColor: true }, '  Loading tags…')];
+        }
+        const tags = sortTags(context.tags?.tags || [], state.tagSort);
+        if (tags.length === 0) {
+            return [h(Text, { key: 'tab-tags-empty', dimColor: true }, '  No tags found')];
+        }
+        return renderSelectableSidebarRows(h, Text, tags, state.selectedTagIndex, focused, width, theme, (tag) => `${truncate$1(tag.name, 16)} ${tag.subject}`, 'tab-tags');
+    }
+    if (tab === 'stashes') {
+        if (isLogInkContextKeyLoading(contextStatus, 'stashes')) {
+            return [h(Text, { key: 'tab-stashes-loading', dimColor: true }, '  Loading stashes…')];
+        }
+        const stashes = context.stashes?.stashes || [];
+        if (stashes.length === 0) {
+            return [h(Text, { key: 'tab-stashes-empty', dimColor: true }, '  No stashes found')];
+        }
+        return renderSelectableSidebarRows(h, Text, stashes, state.selectedStashIndex, focused, width, theme, (stash, index) => `@{${index}} ${stash.message || '(no message)'}`, 'tab-stashes');
+    }
+    // worktrees
+    if (isLogInkContextKeyLoading(contextStatus, 'worktreeList')) {
+        return [h(Text, { key: 'tab-worktrees-loading', dimColor: true }, '  Loading worktrees…')];
+    }
+    const worktrees = context.worktreeList?.worktrees || [];
+    if (worktrees.length === 0) {
+        return [h(Text, { key: 'tab-worktrees-empty', dimColor: true }, '  No linked worktrees')];
+    }
+    return renderSelectableSidebarRows(h, Text, worktrees, state.selectedWorktreeListIndex, focused, width, theme, (worktree) => {
+        const marker = worktree.current ? '*' : ' ';
+        const wstate = worktree.dirty ? 'dirty' : 'clean';
+        return `${marker} ${worktree.branch || worktree.path} ${wstate}`;
+    }, 'tab-worktrees');
+}
+/**
+ * Render a sliding-window list of selectable sidebar rows. The cursor
+ * highlights the row at `selectedIndex` only when `focused` is true so
+ * an unfocused sidebar doesn't compete visually with the active panel.
+ * Sliding window keeps the cursor in view as the user navigates a long
+ * list; truncation hints surface the count of hidden rows.
+ */
+function renderSelectableSidebarRows(h, Text, items, selectedIndex, focused, width, theme, toRowText, keyPrefix) {
+    if (items.length === 0)
+        return [];
+    const window = getSidebarVisibleWindow(items.length, selectedIndex);
+    const elements = [];
+    if (window.truncatedAbove > 0) {
+        elements.push(h(Text, {
+            key: `${keyPrefix}-trunc-above`,
+            dimColor: true,
+        }, truncate$1(`  … ${window.truncatedAbove} more above`, width - 4)));
+    }
+    for (let offset = 0; offset < window.size; offset += 1) {
+        const index = window.start + offset;
+        if (index >= items.length)
+            break;
+        const isSelected = focused && index === selectedIndex;
+        const text = toRowText(items[index], index);
+        elements.push(h(Text, {
+            key: `${keyPrefix}-row-${index}`,
+            backgroundColor: isSelected && !theme.noColor ? theme.colors.selection : undefined,
+            inverse: isSelected,
+        }, truncate$1(`  ${text}`, width - 4)));
+    }
+    if (window.truncatedBelow > 0) {
+        elements.push(h(Text, {
+            key: `${keyPrefix}-trunc-below`,
+            dimColor: true,
+        }, truncate$1(`  … ${window.truncatedBelow} more below`, width - 4)));
+    }
+    return elements;
 }
 function renderActiveStatusTabContent(h, Text, context, contextStatus, width, theme) {
     if (isLogInkContextKeyLoading(contextStatus, 'worktree')) {
@@ -23181,6 +25016,9 @@ function renderMainPanel(h, components, state, context, contextStatus, worktreeD
     if (state.activeView === 'worktrees') {
         return renderWorktreesSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
     }
+    if (state.activeView === 'pull-request') {
+        return renderPullRequestSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+    }
     return renderHistoryPanel(h, components, state, context, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits);
 }
 function renderHistoryPanel(h, components, state, context, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits) {
@@ -23230,15 +25068,46 @@ function renderHistoryPanel(h, components, state, context, bodyRows, width, them
         }))
         : visible.items.map((item, index) => {
             if (item.type === 'graph') {
+                if (item.laneSegments && !theme.ascii) {
+                    return h(Text, { key: `graph-${index}-${item.graph}` }, ...renderLaneSegmentSpans(h, Text, item.laneSegments, theme, visible.graphWidth, `g${index}`));
+                }
                 return h(Text, {
                     key: `graph-${index}-${item.graph}`,
                     color: theme.noColor ? undefined : theme.colors.muted,
                     dimColor: theme.noColor,
                 }, truncate$1(substituteGraphChars(item.graph.padEnd(visible.graphWidth), { ascii: theme.ascii }), 140));
             }
-            return renderCommitHistoryRow(h, Text, item.commit, item.graph, visible.graphWidth, Boolean(item.selected) && !realSelectionSuppressed, theme, index);
+            return renderCommitHistoryRow(h, Text, item.commit, item.graph, visible.graphWidth, Boolean(item.selected) && !realSelectionSuppressed, theme, index, item.laneSegments);
         }));
 }
+/**
+ * Render `LaneSegment[]` as a flat list of Text spans, one per lane
+ * (#791 stage 2). Each segment paints in its lane's palette color so
+ * the eye can follow a branch column-by-column; segments without a
+ * lane id (spaces, padding, decorations) fall back to the muted graph
+ * color so they visually recede.
+ *
+ * Final padding is appended as its own span so callers do not need to
+ * pre-pad the graph string before computing lane segments.
+ */
+function renderLaneSegmentSpans(h, Text, segments, theme, padTo, keyPrefix) {
+    const muted = theme.noColor ? undefined : theme.colors.muted;
+    const elements = [];
+    let totalLen = 0;
+    segments.forEach((seg, idx) => {
+        const laneColor = getLaneColor(seg.laneId, theme);
+        elements.push(h(Text, {
+            key: `${keyPrefix}-${idx}`,
+            color: laneColor ?? muted,
+            dimColor: theme.noColor && seg.laneId === undefined,
+        }, seg.text));
+        totalLen += seg.text.length;
+    });
+    if (padTo > totalLen) {
+        elements.push(h(Text, { key: `${keyPrefix}-pad` }, ' '.repeat(padTo - totalLen)));
+    }
+    return elements;
+}
 /**
  * Render a single commit row with each segment in its own colored span.
  * Graph chars render in `theme.colors.muted` so the topology visually
@@ -23251,8 +25120,7 @@ function renderHistoryPanel(h, components, state, context, bodyRows, width, them
  * Truncation is per-segment so the variable-length message field gets
  * the leftover budget after fixed segments are accounted for.
  */
-function renderCommitHistoryRow(h, Text, commit, graph, graphWidth, selected, theme, index) {
-    const renderedGraph = substituteGraphChars(graph.padEnd(graphWidth), { ascii: theme.ascii });
+function renderCommitHistoryRow(h, Text, commit, graph, graphWidth, selected, theme, index, laneSegments) {
     const refs = formatInkRefLabels(commit.refs);
     const totalWidth = 140;
     const fixedWidth = graphWidth + 1 + commit.shortHash.length + 1 + commit.date.length + 1;
@@ -23261,11 +25129,17 @@ function renderCommitHistoryRow(h, Text, commit, graph, graphWidth, selected, th
     const selectedBg = selected && !theme.noColor ? theme.colors.selection : undefined;
     const accent = theme.noColor ? undefined : theme.colors.accent;
     const muted = theme.noColor ? undefined : theme.colors.muted;
+    // Lane-colored graph spans when full graph mode + non-ASCII rendering
+    // is in play; otherwise fall back to the legacy single-muted span so
+    // compact mode and legacy terminals stay visually unchanged.
+    const graphChildren = laneSegments && !theme.ascii
+        ? renderLaneSegmentSpans(h, Text, laneSegments, theme, graphWidth, `c${index}`)
+        : [h(Text, { color: muted, dimColor: theme.noColor }, substituteGraphChars(graph.padEnd(graphWidth), { ascii: theme.ascii }))];
     return h(Text, {
         key: `${commit.hash}-${index}`,
         backgroundColor: selectedBg,
         inverse: selected,
-    }, h(Text, { color: muted, dimColor: theme.noColor }, renderedGraph), ' ', h(Text, { color: accent, bold: selected }, commit.shortHash), ' ', h(Text, { dimColor: true }, commit.date), ' ', h(Text, undefined, message), refs ? h(Text, { color: accent }, refs) : null);
+    }, ...graphChildren, ' ', h(Text, { color: accent, bold: selected }, commit.shortHash), ' ', h(Text, { dimColor: true }, commit.date), ' ', h(Text, undefined, message), refs ? h(Text, { color: accent }, refs) : null);
 }
 /**
  * Render the synthetic "(+) new commit" affordance shown above the real
@@ -23498,11 +25372,35 @@ function renderBranchesSurface(h, components, state, context, contextStatus, bod
                 const cursor = isSelected ? '>' : ' ';
                 const marker = branchRowMarker(branch, { ascii: theme.ascii });
                 const divergence = formatBranchDivergence(branch, { ascii: theme.ascii });
+                const lastTouched = formatBranchLastTouched(branch.date, new Date());
+                // Split the row into spans so the timestamp stays dim even on the
+                // currently-selected (bold) row. The leading marker + name keep
+                // their original column widths; the timestamp is right-padded so
+                // the divergence column stays aligned across rows.
+                const namePadded = branch.shortName.padEnd(28);
+                const timestampPadded = lastTouched.padEnd(8);
+                const lineDim = !isSelected && !branch.current;
+                const head = `${cursor} ${marker} ${namePadded} `;
+                const trailingDivergence = divergence ? ` ${divergence}` : '';
+                // Truncate the assembled line cooperatively so we never overflow
+                // the panel; the timestamp is short and the divergence is the
+                // most expendable, but the existing 140 cap is ample.
+                const fullText = `${head}${timestampPadded}${trailingDivergence}`;
+                const truncated = truncate$1(fullText, 140);
+                // If truncation chopped into the timestamp/divergence portion,
+                // fall back to a single Text to keep the visible width honest.
+                if (truncated !== fullText) {
+                    return h(Text, {
+                        key: `branch-${index}`,
+                        bold: isSelected,
+                        dimColor: lineDim,
+                    }, truncated);
+                }
                 return h(Text, {
                     key: `branch-${index}`,
                     bold: isSelected,
-                    dimColor: !isSelected && !branch.current,
-                }, truncate$1(`${cursor} ${marker} ${branch.shortName.padEnd(28)} ${divergence}`, 140));
+                    dimColor: lineDim,
+                }, head, h(Text, { dimColor: true }, timestampPadded), trailingDivergence);
             });
     return h(Box, {
         borderColor: focusBorderColor(theme, focused),
@@ -23655,6 +25553,98 @@ function renderWorktreesSurface(h, components, state, context, contextStatus, bo
         width,
     }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Worktrees', focused)), h(Text, { dimColor: true }, headerRight)), ...renderPromotedFilterAffordance(h, Text, state, theme), ...lines);
 }
+/**
+ * Pull-request action panel (#783) — renders the current branch's PR
+ * with header, checks table, reviews summary, and a body preview.
+ * Action keys (m / x / a / R / c / O) are wired in inkInput.ts and
+ * surfaced via the footer; this renderer is read-only.
+ *
+ * Three loading / fallback states matter:
+ * - Provider data still loading → "Loading pull request..."
+ * - GitHub remote present but no PR for the current branch → empty
+ *   state hint pointing the user at `C` to create one.
+ * - GitHub CLI missing / unauthenticated → unavailable hint.
+ */
+function renderPullRequestSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+    const { Box, Text } = components;
+    const focused = state.focus === 'commits';
+    const loading = isLogInkContextKeyLoading(contextStatus, 'pullRequest');
+    const pullRequestOverview = context.pullRequest;
+    // Use the dedicated `pullRequest` overview only — the `provider`
+    // shape carries a slimmer ProviderPullRequestStatus that lacks
+    // url / headRefName / body / mergeable / reviews. The dedicated
+    // overview hits `gh pr view --json` with the full enriched field
+    // list (PULL_REQUEST_VIEW_JSON_FIELDS) so the panel has everything.
+    const pr = pullRequestOverview?.currentPullRequest;
+    const muted = theme.noColor ? undefined : theme.colors.muted;
+    const accent = theme.noColor ? undefined : theme.colors.accent;
+    const containerProps = {
+        borderColor: focusBorderColor(theme, focused),
+        borderStyle: theme.borderStyle,
+        flexDirection: 'column',
+        flexShrink: 0,
+        paddingX: 1,
+        width,
+    };
+    if (loading && !pr) {
+        return h(Box, containerProps, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Pull request', focused)), h(Text, { dimColor: true }, 'loading')), h(Text, { dimColor: true }, formatLogInkLoading({ resource: 'pull request' })));
+    }
+    if (!pr) {
+        const hint = pullRequestOverview?.message
+            || 'No pull request detected for this branch. Press `C` (or `:create-pr`) to create one.';
+        return h(Box, containerProps, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Pull request', focused)), h(Text, { dimColor: true }, 'no PR')), h(Text, { dimColor: true }, truncate$1(hint, width - 4)));
+    }
+    const checks = summarizePullRequestChecks(pr.statusCheckRollup);
+    const reviews = summarizePullRequestReviews(pr.reviews, pr.reviewDecision);
+    const checkRows = buildPullRequestCheckRows(pr.statusCheckRollup, { ascii: theme.ascii });
+    const checkColor = (s) => {
+        if (theme.noColor)
+            return undefined;
+        if (s === 'success')
+            return theme.colors.success;
+        if (s === 'failure')
+            return theme.colors.danger;
+        if (s === 'pending')
+            return theme.colors.warning;
+        return theme.colors.muted;
+    };
+    // Reserve a few rows for the header/section labels; the rest go to
+    // the checks table. Body preview gets the leftover rows so the
+    // surface stays vertically balanced even on tall terminals.
+    const checkBudget = Math.max(3, Math.min(checkRows.length, Math.floor(bodyRows / 2)));
+    const visibleChecks = checkRows.slice(0, checkBudget);
+    const truncatedChecks = checkRows.length - visibleChecks.length;
+    const bodyPreviewBudget = Math.max(2, bodyRows - 8 - visibleChecks.length);
+    const bodyLines = (pr.body || '').split(/\r?\n/).filter((line) => line.trim().length > 0);
+    const visibleBodyLines = bodyLines.slice(0, bodyPreviewBudget);
+    const truncatedBodyLines = bodyLines.length - visibleBodyLines.length;
+    const headerRight = `#${pr.number} · ${pr.headRefName} → ${pr.baseRefName}`;
+    const stateLine = formatPullRequestStateLine(pr);
+    const author = pr.author ? `by @${pr.author}` : '';
+    return h(Box, containerProps, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Pull request', focused)), h(Text, { dimColor: true }, headerRight)), h(Text, undefined, truncate$1(pr.title, width - 4)), h(Text, { dimColor: true }, truncate$1(`${stateLine}${author ? ` · ${author}` : ''}`, width - 4)), h(Text, undefined, ''), 
+    // Checks section
+    h(Text, { bold: true, color: accent }, 'Checks'), h(Text, { dimColor: true }, truncate$1(`  ${formatPullRequestChecksSummary(checks, { ascii: theme.ascii })}`, width - 4)), ...visibleChecks.map((row, index) => h(Text, {
+        key: `pr-check-${index}`,
+        color: checkColor(row.status),
+    }, truncate$1(`  ${row.glyph} ${row.name.padEnd(28)} ${row.detail}`, width - 4))), ...(truncatedChecks > 0
+        ? [h(Text, { key: 'pr-checks-trunc', dimColor: true }, truncate$1(`  … ${truncatedChecks} more`, width - 4))]
+        : []), h(Text, undefined, ''), 
+    // Reviews section
+    h(Text, { bold: true, color: accent }, 'Reviews'), h(Text, { dimColor: true }, truncate$1(`  ${formatPullRequestReviewsSummary(reviews)}`, width - 4)), h(Text, undefined, ''), 
+    // Body preview
+    ...(visibleBodyLines.length > 0
+        ? [
+            h(Text, { key: 'pr-body-label', bold: true, color: accent }, 'Description'),
+            ...visibleBodyLines.map((line, index) => h(Text, {
+                key: `pr-body-${index}`,
+                color: muted,
+            }, truncate$1(`  ${line}`, width - 4))),
+            ...(truncatedBodyLines > 0
+                ? [h(Text, { key: 'pr-body-trunc', dimColor: true }, truncate$1(`  … ${truncatedBodyLines} more lines`, width - 4))]
+                : []),
+        ]
+        : []));
+}
 /**
  * Filter input cursor for the promoted views (branches/tags/stash).
  * History already shows the same `filter: foo_` affordance in its header
@@ -23685,6 +25675,8 @@ function renderDiffSurface(h, components, state, context, contextStatus, worktre
     // cherry-picks the file at the cursor.
     if (state.diffSource === 'stash') {
         const lines = stashDiffLines || [];
+        const splitActive = isSplitDiffViable(state, width);
+        const splitRequestedButTooNarrow = state.diffViewMode === 'split' && !splitActive;
         const visibleLines = lines.slice(state.diffPreviewOffset, state.diffPreviewOffset + visibleRows);
         const stashFiles = parseStashDiffFiles(lines);
         const fileCount = stashFiles.length;
@@ -23705,11 +25697,19 @@ function renderDiffSurface(h, components, state, context, contextStatus, worktre
         const currentFileIndex = currentFile
             ? Math.max(0, stashFiles.findIndex((file) => file.startLine === currentFile.startLine))
             : -1;
-        const headerLines = stashDiffLoading
-            ? [`Loading diff for ${state.stashDiffRef || 'stash'}...`]
+        // Look up the active stash entry so the panel header can show a
+        // human-identifier instead of the raw `stash@{<iso-date>}` ref.
+        // The git ref is the timestamp form (we fetch with --date=iso for
+        // stable parsing) which reads as noise in the title bar; the
+        // message + branch + index combination is what the user wrote down
+        // when they ran `git stash`. Body still shows the full ref so it
+        // stays unambiguous.
+        const stashIdentity = formatStashHeaderIdentity(state.stashDiffRef, context.stashes?.stashes);
+        const baseHeaderLines = stashDiffLoading
+            ? [`Loading diff for ${stashIdentity.subtitle}...`]
             : lines.length
                 ? [
-                    `Stash: ${state.stashDiffRef || ''}`,
+                    stashIdentity.bodyLine,
                     fileCount > 0 && currentFile
                         ? `File ${currentFileIndex + 1}/${fileCount}: ${currentFile.path}`
                         : 'No files in this stash.',
@@ -23717,6 +25717,17 @@ function renderDiffSurface(h, components, state, context, contextStatus, worktre
                     '',
                 ]
                 : ['No diff to display for this stash.'];
+        const headerLines = splitRequestedButTooNarrow
+            ? [...baseHeaderLines.slice(0, -1), 'Terminal too narrow for side-by-side; showing unified.', '']
+            : baseHeaderLines;
+        const stashBodyNodes = stashDiffLoading || !lines.length
+            ? []
+            : splitActive
+                ? renderSplitDiffBody(h, components, visibleLines, state.diffPreviewOffset, width, theme, 'stash-diff-split')
+                : visibleLines.map((line, index) => h(Text, {
+                    key: `stash-diff-line-${state.diffPreviewOffset + index}`,
+                    ...diffLineProps(line, theme),
+                }, truncate$1(line, width - 4)));
         return h(Box, {
             borderColor: focusBorderColor(theme, focused),
             borderStyle: theme.borderStyle,
@@ -23724,15 +25735,10 @@ function renderDiffSurface(h, components, state, context, contextStatus, worktre
             flexShrink: 0,
             paddingX: 1,
             width,
-        }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Stash diff', focused)), h(Text, { dimColor: true }, state.stashDiffRef || 'no stash')), ...headerLines.map((line, index) => h(Text, {
+        }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle(splitActive ? 'Stash diff (split)' : 'Stash diff', focused)), h(Text, { dimColor: true }, stashIdentity.subtitle)), ...headerLines.map((line, index) => h(Text, {
             key: `stash-diff-header-${index}`,
             dimColor: index > 0,
-        }, truncate$1(line, width - 4))), ...(stashDiffLoading || !lines.length
-            ? []
-            : visibleLines.map((line, index) => h(Text, {
-                key: `stash-diff-line-${state.diffPreviewOffset + index}`,
-                ...diffLineProps(line, theme),
-            }, truncate$1(line, width - 4)))));
+        }, truncate$1(line, width - 4))), ...stashBodyNodes);
     }
     // diffSource disambiguates: 'commit' was set when the user opened the
     // diff via history → Enter (read-only commit-diff explore), 'worktree'
@@ -23743,6 +25749,8 @@ function renderDiffSurface(h, components, state, context, contextStatus, worktre
         (state.diffSource === undefined && !worktreeFile && Boolean(selectedDetailFile));
     if (useCommitDiff) {
         const previewHunks = filePreview?.hunks || [];
+        const splitActive = isSplitDiffViable(state, width);
+        const splitRequestedButTooNarrow = state.diffViewMode === 'split' && !splitActive;
         const visiblePreviewHunks = previewHunks.slice(state.diffPreviewOffset, state.diffPreviewOffset + visibleRows);
         const hunkCount = commitDiffHunkOffsets?.length || 0;
         const currentHunkIndex = hunkCount > 0
@@ -23753,7 +25761,7 @@ function renderDiffSurface(h, components, state, context, contextStatus, worktre
         const currentHunkLabel = hunkCount > 0
             ? `Hunk ${Math.min(hunkCount - currentHunkIndex, hunkCount)}/${hunkCount}`
             : 'No hunks for this file.';
-        const headerLines = filePreviewLoading
+        const baseHeaderLines = filePreviewLoading
             ? [`Loading diff for ${selectedDetailFile?.path || 'selected file'}...`]
             : previewHunks.length
                 ? [
@@ -23763,6 +25771,17 @@ function renderDiffSurface(h, components, state, context, contextStatus, worktre
                     '',
                 ]
                 : ['No diff preview available for this file.'];
+        const headerLines = splitRequestedButTooNarrow
+            ? [...baseHeaderLines.slice(0, -1), 'Terminal too narrow for side-by-side; showing unified.', '']
+            : baseHeaderLines;
+        const commitBodyNodes = filePreviewLoading || !previewHunks.length
+            ? []
+            : splitActive
+                ? renderSplitDiffBody(h, components, visiblePreviewHunks, state.diffPreviewOffset, width, theme, 'commit-diff-split')
+                : visiblePreviewHunks.map((line, index) => h(Text, {
+                    key: `diff-surface-line-${state.diffPreviewOffset + index}`,
+                    ...diffLineProps(line, theme),
+                }, truncate$1(line, 140)));
         return h(Box, {
             borderColor: focusBorderColor(theme, focused),
             borderStyle: theme.borderStyle,
@@ -23770,15 +25789,10 @@ function renderDiffSurface(h, components, state, context, contextStatus, worktre
             flexShrink: 0,
             paddingX: 1,
             width,
-        }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Diff', focused)), h(Text, { dimColor: true }, selectedDetailFile?.path || 'no file')), ...headerLines.map((line, index) => h(Text, {
+        }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle(splitActive ? 'Diff (split)' : 'Diff', focused)), h(Text, { dimColor: true }, selectedDetailFile?.path || 'no file')), ...headerLines.map((line, index) => h(Text, {
             key: `diff-surface-header-${index}`,
             dimColor: index > 0,
-        }, truncate$1(line, 140))), ...(filePreviewLoading || !previewHunks.length
-            ? []
-            : visiblePreviewHunks.map((line, index) => h(Text, {
-                key: `diff-surface-line-${state.diffPreviewOffset + index}`,
-                ...diffLineProps(line, theme),
-            }, truncate$1(line, 140)))));
+        }, truncate$1(line, 140))), ...commitBodyNodes);
     }
     const diffLines = worktreeDiff?.lines || [];
     const selectedHunk = worktreeHunks?.hunks[state.selectedWorktreeHunkIndex];
@@ -24253,16 +26267,34 @@ function renderInputPromptPanel(h, components, state, width, theme, focused) {
     if (!prompt) {
         return h(Box, { width });
     }
+    const accent = theme.noColor ? undefined : theme.colors.accent;
+    // Multi-line prompts (#806) split on newline and render one Text
+    // row per buffer line — the cursor sits at the end of the last
+    // line via the trailing `_`. Single-line prompts collapse to the
+    // original one-row layout for muscle-memory continuity.
+    const promptLines = prompt.multiline ? prompt.value.split('\n') : [prompt.value];
+    if (promptLines.length === 0) {
+        promptLines.push('');
+    }
+    const valueRows = promptLines.map((line, index) => {
+        const isLast = index === promptLines.length - 1;
+        const display = isLast ? `${line}_` : line;
+        return h(Text, {
+            key: `prompt-line-${index}`,
+            bold: true,
+            color: accent,
+        }, truncate$1(display, width - 4));
+    });
+    const hint = prompt.multiline
+        ? 'Enter newline · Ctrl+d submit · Esc cancel · Ctrl+u clear'
+        : 'Enter submit · Esc cancel · Ctrl+u clear';
     return h(Box, {
         borderColor: focusBorderColor(theme, focused),
         borderStyle: theme.borderStyle,
         flexDirection: 'column',
         width,
         paddingX: 1,
-    }, h(Text, { bold: true }, panelTitle('Prompt', focused)), h(Text, { dimColor: true }, truncate$1(prompt.label, width - 4)), h(Text, undefined, ''), h(Text, {
-        bold: true,
-        color: theme.noColor ? undefined : theme.colors.accent,
-    }, truncate$1(`${prompt.value}_`, width - 4)), h(Text, undefined, ''), h(Text, { dimColor: true }, 'Enter to submit · Esc to cancel · Ctrl+u to clear'));
+    }, h(Text, { bold: true }, panelTitle('Prompt', focused)), h(Text, { dimColor: true }, truncate$1(prompt.label, width - 4)), h(Text, undefined, ''), ...valueRows, h(Text, undefined, ''), h(Text, { dimColor: true }, hint));
 }
 function renderConfirmationPanel(h, components, state, width, theme, focused) {
     const { Box, Text } = components;
@@ -24436,16 +26468,31 @@ function renderCommandPalette(h, components, state, width, theme, focused) {
         ? [h(Text, { key: 'palette-recent-hint', dimColor: true }, '· marks recently-used')]
         : []), ...itemLines);
 }
-function renderFooter(h, components, state, theme, idleTip) {
+function renderFooter(h, components, state, context, theme, idleTip) {
     const { Box, Text } = components;
+    // Sidebar item count drives the per-tab footer hints — when items are
+    // present the footer surfaces in-sidebar ops (checkout / apply / pop /
+    // drop), otherwise it falls back to the generic "enter open" hint.
+    const sidebarItemCount = (() => {
+        switch (state.sidebarTab) {
+            case 'branches': return context.branches?.localBranches.length;
+            case 'tags': return context.tags?.tags.length;
+            case 'stashes': return context.stashes?.stashes.length;
+            case 'worktrees': return context.worktreeList?.worktrees.length;
+            default: return undefined;
+        }
+    })();
     const hints = getLogInkFooterHints({
         activeView: state.activeView,
         diffSource: state.diffSource,
+        diffViewMode: state.diffViewMode,
         filterMode: state.filterMode,
         focus: state.focus,
         pendingKey: state.pendingKey,
         showCommandPalette: state.showCommandPalette,
         showHelp: state.showHelp,
+        sidebarTab: state.sidebarTab,
+        sidebarItemCount,
     });
     // Real status messages always win; idle tips only fill the slot when it
     // would otherwise be empty.