git-coco 0.45.0 → 0.47.0

package/dist/index.esm.mjs

@@ -54,7 +54,7 @@ import { pathToFileURL } from 'url';
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.45.0";
+const BUILD_VERSION = "0.47.0";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -14521,7 +14521,7 @@ const builder$3 = (yargs) => {
     return yargs.options(options$3).usage(getCommandUsageHeader(command$3));
 };
 
-const FIELD_SEPARATOR$2 = '\x1f';
+const FIELD_SEPARATOR$3 = '\x1f';
 // `%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.
@@ -14574,13 +14574,13 @@ function parseLogOutput(output) {
         .map((line) => line.trimEnd())
         .filter(Boolean)
         .map((line) => {
-        if (!line.includes(FIELD_SEPARATOR$2)) {
+        if (!line.includes(FIELD_SEPARATOR$3)) {
             return {
                 type: 'graph',
                 graph: line,
             };
         }
-        const [graph, shortHash, hash, parentsStr, date, author, refs, message] = line.split(FIELD_SEPARATOR$2);
+        const [graph, shortHash, hash, parentsStr, date, author, refs, message] = line.split(FIELD_SEPARATOR$3);
         return {
             type: 'commit',
             graph: graph.trimEnd(),
@@ -14655,7 +14655,7 @@ function parseNameStatus(output, numstat = []) {
 function parseCommitDetail(metadata, files, numstatOutput = '') {
     const [hash, shortHash, parentsStr, date, author, refs, message, body = ''] = metadata
         .trimEnd()
-        .split(FIELD_SEPARATOR$2);
+        .split(FIELD_SEPARATOR$3);
     const numstat = parseNumstat(numstatOutput);
     return {
         shortHash,
@@ -14795,14 +14795,14 @@ async function getCommitFilePreview(git, commit, file, limit = 40) {
     };
 }
 
-const FIELD_SEPARATOR$1 = '\x1f';
+const FIELD_SEPARATOR$2 = '\x1f';
 function parseBranchRefs(output) {
     return output
         .split('\n')
         .map((line) => line.trimEnd())
         .filter(Boolean)
         .map((line) => {
-        const [refName, shortName, hash, upstream, head, date, subject] = line.split(FIELD_SEPARATOR$1);
+        const [refName, shortName, hash, upstream, head, date, subject] = line.split(FIELD_SEPARATOR$2);
         if (!refName || !shortName) {
             return undefined;
         }
@@ -14842,7 +14842,7 @@ async function getBranchOverview(git) {
     const [branchOutput, statusOutput, currentBranchOutput] = await Promise.all([
         git.raw([
             'for-each-ref',
-            `--format=%(refname)${FIELD_SEPARATOR$1}%(refname:short)${FIELD_SEPARATOR$1}%(objectname:short)${FIELD_SEPARATOR$1}%(upstream:short)${FIELD_SEPARATOR$1}%(HEAD)${FIELD_SEPARATOR$1}%(committerdate:short)${FIELD_SEPARATOR$1}%(contents:subject)`,
+            `--format=%(refname)${FIELD_SEPARATOR$2}%(refname:short)${FIELD_SEPARATOR$2}%(objectname:short)${FIELD_SEPARATOR$2}%(upstream:short)${FIELD_SEPARATOR$2}%(HEAD)${FIELD_SEPARATOR$2}%(committerdate:short)${FIELD_SEPARATOR$2}%(contents:subject)`,
             'refs/heads',
             'refs/remotes',
         ]),
@@ -15392,10 +15392,12 @@ async function runCommitDraftWorkflow(input = {}) {
 }
 
 const LOG_INK_CONTEXT_KEYS = [
+    'bisect',
     'branches',
     'operation',
     'provider',
     'pullRequest',
+    'reflog',
     'stashes',
     'tags',
     'worktree',
@@ -16115,6 +16117,45 @@ function getLogInkWorkflowActions() {
             kind: 'normal',
             requiresConfirmation: false,
         },
+        {
+            // #784 — bisect workflow actions. All four are scoped per-view in
+            // inkInput (active only when activeView === 'bisect') so the
+            // single-letter keys stay free elsewhere. Empty `key` keeps them
+            // palette-discoverable. Reset is the only destructive one — it
+            // throws away the bisect state — so it routes through y-confirm;
+            // good / bad / skip are recoverable via `git bisect log` and run
+            // immediately.
+            id: 'bisect-good',
+            key: '',
+            label: 'Bisect: mark good',
+            description: 'Mark the current bisect candidate as good and advance to the next one.',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
+        {
+            id: 'bisect-bad',
+            key: '',
+            label: 'Bisect: mark bad',
+            description: 'Mark the current bisect candidate as bad and advance to the next one.',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
+        {
+            id: 'bisect-skip',
+            key: '',
+            label: 'Bisect: skip candidate',
+            description: 'Skip the current bisect candidate (e.g. it does not build) and advance.',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
+        {
+            id: 'bisect-reset',
+            key: '',
+            label: 'Bisect: reset',
+            description: 'End the bisect session and restore HEAD. Discards in-progress bisect state.',
+            kind: 'destructive',
+            requiresConfirmation: true,
+        },
         {
             id: 'ai-commit-summary',
             key: 'I',
@@ -16351,6 +16392,27 @@ const LOG_INK_KEY_BINDINGS = [
         description: 'Push the conflict resolution helper view (available during merge/rebase/cherry-pick/revert).',
         contexts: ['normal'],
     },
+    {
+        id: 'navigateReflog',
+        keys: ['gr'],
+        label: 'reflog',
+        description: 'Push the reflog browser view — chronological recovery log.',
+        contexts: ['normal'],
+    },
+    {
+        id: 'navigateBisect',
+        keys: ['gB'],
+        label: 'bisect',
+        description: 'Push the bisect workflow view (#784). Capital B disambiguates from gb (branches). Available whenever a bisect is in progress; surfaces the current candidate and the good / bad / skip / reset action keys.',
+        contexts: ['normal'],
+    },
+    {
+        id: 'markForCompare',
+        keys: ['m'],
+        label: 'mark compare',
+        description: 'Mark the cursored ref (branch / tag / commit) as the base for a compare-two-refs diff (#779). Press again on the same ref to clear; with a base set, Enter on another ref opens the compare diff.',
+        contexts: ['commits'],
+    },
     {
         id: 'navigateBack',
         keys: ['<', 'esc'],
@@ -16481,6 +16543,8 @@ const GLOBAL_BINDING_IDS = [
     'navigateWorktrees',
     'navigatePullRequest',
     'navigateConflicts',
+    'navigateReflog',
+    'navigateBisect',
     'navigateBack',
 ];
 const NORMAL_GLOBAL_HINTS = ['g jump', '< back', '? help', ': cmds', 'q quit'];
@@ -16608,6 +16672,15 @@ function getLogInkFooterHints(options) {
                 global: NORMAL_GLOBAL_HINTS,
             };
         }
+        if (options.diffSource === 'compare') {
+            // Compare-two-refs (#779): read-only diff with no per-file
+            // cherry-pick or hunk apply (those don't make sense across
+            // arbitrary refs). Just scroll + back out.
+            return {
+                contextual: ['j/k lines', splitToggleHint, 'esc back'],
+                global: NORMAL_GLOBAL_HINTS,
+            };
+        }
         return {
             contextual: ['j/k hunks', 'space stage', 'z revert', 'o edit', 'e/c compose', 'y yank'],
             global: NORMAL_GLOBAL_HINTS,
@@ -16620,14 +16693,26 @@ function getLogInkFooterHints(options) {
         };
     }
     if (options.activeView === 'branches') {
+        if (options.compareBaseSet) {
+            return {
+                contextual: ['↑/↓ branches', 'enter compare', 'm clear', 'esc back'],
+                global: NORMAL_GLOBAL_HINTS,
+            };
+        }
         return {
-            contextual: ['↑/↓ branches', 'enter checkout', '+ new', 'D delete', 's sort', 'y yank'],
+            contextual: ['↑/↓ branches', 'enter checkout', '+ new', 'D delete', 'm compare', 's sort', 'y yank'],
             global: NORMAL_GLOBAL_HINTS,
         };
     }
     if (options.activeView === 'tags') {
+        if (options.compareBaseSet) {
+            return {
+                contextual: ['↑/↓ tags', 'enter compare', 'm clear', 'esc back'],
+                global: NORMAL_GLOBAL_HINTS,
+            };
+        }
         return {
-            contextual: ['↑/↓ tags', '+ new', 'P push', 'T delete', 's sort', 'y yank'],
+            contextual: ['↑/↓ tags', '+ new', 'P push', 'T delete', 'm compare', 's sort', 'y yank'],
             global: NORMAL_GLOBAL_HINTS,
         };
     }
@@ -16659,6 +16744,28 @@ function getLogInkFooterHints(options) {
             global: NORMAL_GLOBAL_HINTS,
         };
     }
+    if (options.activeView === 'reflog') {
+        return {
+            contextual: ['↑/↓ entries', 'enter inspect', 'esc back'],
+            global: NORMAL_GLOBAL_HINTS,
+        };
+    }
+    if (options.activeView === 'bisect') {
+        return {
+            contextual: ['g good', 'b bad', 's skip', 'x reset', 'esc back'],
+            global: NORMAL_GLOBAL_HINTS,
+        };
+    }
+    if (options.compareBaseSet) {
+        // History view with a compare base set — Enter is overridden to
+        // open the compare diff; show the override + the bail-out key.
+        // Mutate / new chips are dropped so the footer doesn't compete
+        // with the active workflow.
+        return {
+            contextual: ['↑/↓ move', 'enter compare', 'm clear', 'esc back'],
+            global: NORMAL_GLOBAL_HINTS,
+        };
+    }
     return {
         // History view default hints. Mutating ops (`c` cherry-pick, `R`
         // revert, `Z` reset, `i` interactive-rebase) all route through a
@@ -16668,7 +16775,7 @@ function getLogInkFooterHints(options) {
         // Grouped into compact `c/R/Z/i mutate` and `B/gT new` chips so
         // the footer stays scannable; full descriptions live in `?` help
         // and the palette.
-        contextual: ['↑/↓ move', 'enter diff', 'c/R/Z/i mutate', 'B/gT new', 'y/Y yank', '/ search', 'gg/G top/bottom'],
+        contextual: ['↑/↓ move', 'enter diff', 'c/R/Z/i mutate', 'B/gT new', 'm compare', 'y/Y yank', '/ search'],
         global: NORMAL_GLOBAL_HINTS,
     };
 }
@@ -17247,6 +17354,7 @@ function withPushedView(state, value) {
         selectedWorktreeHunkIndex: value === 'diff' ? state.selectedWorktreeHunkIndex : 0,
         diffSource: value === 'diff' ? state.diffSource : undefined,
         stashDiffRef: value === 'diff' ? state.stashDiffRef : undefined,
+        compareHead: value === 'diff' ? state.compareHead : undefined,
         pendingCommitFocused: value === 'history' ? state.pendingCommitFocused : false,
         statusGroupHeaderFocused: value === 'status' ? state.statusGroupHeaderFocused : false,
         pendingKey: undefined,
@@ -17258,6 +17366,13 @@ function withPoppedView(state) {
     }
     const viewStack = state.viewStack.slice(0, -1);
     const next = topOfStack(viewStack);
+    // #779 — compareBase is "cleared when the diff view is popped." We
+    // detect that case by checking if the *previous* top was 'diff'.
+    // The compare workflow ends when the user backs out of the compare
+    // diff; on the next mark they re-set the base. Other view pops
+    // preserve compareBase so the user can move between branches / tags /
+    // history while hunting for a head ref.
+    const wasOnDiff = state.activeView === 'diff';
     return {
         ...state,
         activeView: next,
@@ -17270,6 +17385,8 @@ function withPoppedView(state) {
         selectedWorktreeHunkIndex: next === 'diff' ? state.selectedWorktreeHunkIndex : 0,
         diffSource: next === 'diff' ? state.diffSource : undefined,
         stashDiffRef: next === 'diff' ? state.stashDiffRef : undefined,
+        compareBase: wasOnDiff ? undefined : state.compareBase,
+        compareHead: next === 'diff' ? state.compareHead : undefined,
         pendingCommitFocused: next === 'history' ? state.pendingCommitFocused : false,
         statusGroupHeaderFocused: next === 'status' ? state.statusGroupHeaderFocused : false,
         pendingKey: undefined,
@@ -17288,6 +17405,7 @@ function withReplacedView(state, value) {
         selectedWorktreeHunkIndex: value === 'diff' ? state.selectedWorktreeHunkIndex : 0,
         diffSource: value === 'diff' ? state.diffSource : undefined,
         stashDiffRef: value === 'diff' ? state.stashDiffRef : undefined,
+        compareHead: value === 'diff' ? state.compareHead : undefined,
         pendingCommitFocused: value === 'history' ? state.pendingCommitFocused : false,
         statusGroupHeaderFocused: value === 'status' ? state.statusGroupHeaderFocused : false,
         pendingKey: undefined,
@@ -17308,6 +17426,11 @@ function withFilter$1(state, filter, promotedSelections) {
         (filterChanged ? 0 : state.selectedTagIndex);
     const stashIndex = promotedSelections?.stashIndex ??
         (filterChanged ? 0 : state.selectedStashIndex);
+    // Reflog (#781) snaps to 0 on filter change rather than rectifying.
+    // The list is chronological and the user is unlikely to be tracking
+    // a specific entry through filter changes — the simpler reset
+    // matches the "find recovery target by typing" interaction.
+    const reflogIndex = filterChanged ? 0 : state.selectedReflogIndex;
     return {
         ...state,
         filter,
@@ -17317,6 +17440,7 @@ function withFilter$1(state, filter, promotedSelections) {
         selectedBranchIndex: branchIndex,
         selectedTagIndex: tagIndex,
         selectedStashIndex: stashIndex,
+        selectedReflogIndex: reflogIndex,
         diffPreviewOffset: 0,
         pendingKey: undefined,
     };
@@ -17406,6 +17530,7 @@ function createLogInkState(rows, options = {}) {
         selectedStashIndex: 0,
         selectedWorktreeListIndex: 0,
         selectedConflictFileIndex: 0,
+        selectedReflogIndex: 0,
         branchSort: DEFAULT_BRANCH_SORT_MODE,
         tagSort: DEFAULT_TAG_SORT_MODE,
         paletteFilter: '',
@@ -17653,6 +17778,12 @@ function applyLogInkAction(state, action) {
                 selectedStashIndex: clampIndex$1(state.selectedStashIndex + action.delta, action.count),
                 pendingKey: undefined,
             };
+        case 'moveReflog':
+            return {
+                ...state,
+                selectedReflogIndex: clampIndex$1(state.selectedReflogIndex + action.delta, action.count),
+                pendingKey: undefined,
+            };
         case 'moveWorktreeListEntry':
             return {
                 ...state,
@@ -17877,6 +18008,31 @@ function applyLogInkAction(state, action) {
                 worktreeDiffOffset: 0,
             };
         }
+        case 'navigateOpenDiffForCompare': {
+            const next = withPushedView(state, 'diff');
+            return {
+                ...next,
+                diffSource: 'compare',
+                compareBase: action.base,
+                compareHead: action.head,
+                // Reset scroll offset so the compare patch always opens at
+                // the top — same reasoning as the stash branch above.
+                diffPreviewOffset: 0,
+                worktreeDiffOffset: 0,
+            };
+        }
+        case 'setCompareBase':
+            return {
+                ...state,
+                compareBase: action.value,
+                pendingKey: undefined,
+            };
+        case 'clearCompareBase':
+            return {
+                ...state,
+                compareBase: undefined,
+                pendingKey: undefined,
+            };
         case 'navigateOpenComposeForFile': {
             const next = withPushedView(state, 'status');
             return {
@@ -18232,10 +18388,66 @@ function isStashActionTarget(state) {
     return (state.activeView === 'stash' && state.focus === 'commits') ||
         (state.focus === 'sidebar' && state.sidebarTab === 'stashes');
 }
+/**
+ * Reflog has no sidebar tab — only the dedicated promoted view (#781).
+ * The condition stays as a single helper anyway so navigation handlers
+ * can read it the same way they do for the other promoted views.
+ */
+function isReflogActionTarget(state) {
+    return state.activeView === 'reflog' && state.focus === 'commits';
+}
 function isWorktreeActionTarget(state) {
     return (state.activeView === 'worktrees' && state.focus === 'commits') ||
         (state.focus === 'sidebar' && state.sidebarTab === 'worktrees');
 }
+/**
+ * Compare-flow target views (#779). The `m` mark + Enter-as-compare
+ * overrides only fire on rows that represent a single ref the user
+ * could pass to `git diff <ref>..<ref>` — branches, tags, and history
+ * commits. The reflog view is intentionally excluded because reflog
+ * entries are *moves* of HEAD, not refs a user typically diffs against.
+ */
+function isCompareFlowTarget(state) {
+    if (state.focus !== 'commits')
+        return false;
+    return state.activeView === 'branches' ||
+        state.activeView === 'tags' ||
+        state.activeView === 'history';
+}
+/**
+ * Resolve the cursored ref for the compare flow (#779). Pulls the
+ * concrete ref + label off context for branches / tags, and reads the
+ * commit row from state for history. Returns undefined when no usable
+ * ref is under the cursor (e.g., the views are empty, or the focus is
+ * on the synthetic "(+) new commit" row).
+ */
+function getCursoredCompareRef(state, context) {
+    if (state.activeView === 'branches' && context.branchSelectedShortName) {
+        return {
+            kind: 'branch',
+            ref: context.branchSelectedShortName,
+            label: context.branchSelectedShortName,
+        };
+    }
+    if (state.activeView === 'tags' && context.tagSelectedName) {
+        return {
+            kind: 'tag',
+            ref: context.tagSelectedName,
+            label: context.tagSelectedName,
+        };
+    }
+    if (state.activeView === 'history' && !state.pendingCommitFocused) {
+        const commit = state.filteredCommits[state.selectedIndex];
+        if (commit) {
+            return {
+                kind: 'commit',
+                ref: commit.hash,
+                label: `${commit.shortHash} ${commit.message}`.trim(),
+            };
+        }
+    }
+    return undefined;
+}
 /**
  * Item count for the active sidebar tab — used by the generic
  * sidebar-Enter handler to decide whether to defer to the per-entity
@@ -18335,6 +18547,20 @@ function getLogInkPaletteExecuteEvents(command, state) {
             return [action({ type: 'pushView', value: 'pull-request' })];
         case 'navigateConflicts':
             return [action({ type: 'pushView', value: 'conflicts' })];
+        case 'navigateReflog':
+            return [action({ type: 'pushView', value: 'reflog' })];
+        case 'navigateBisect':
+            return [action({ type: 'pushView', value: 'bisect' })];
+        case 'markForCompare':
+            // Palette context can't reach the cursored ref (filtered branch /
+            // tag lists live in runtime state, not the reducer). Surface a
+            // hint and let the user press `m` directly on the row. The
+            // inline keypress handler further down in this file does the
+            // actual work and has access to the necessary context.
+            return [action({
+                    type: 'setStatus',
+                    value: 'open branches / tags / history and press m on the cursored ref',
+                })];
         case 'navigateBack':
             return [action({ type: 'popView' })];
         case 'openSelected': {
@@ -18812,6 +19038,25 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
             action({ type: 'setStatus', value: 'jumped to conflicts' }),
         ];
     }
+    // `gr` chord: jump to the reflog browser (#781). Recovery view —
+    // chronological list of reflog entries with Enter to drill into the
+    // commit-diff for the entry's hash. Loaded lazily by the runtime.
+    if (state.pendingKey === 'g' && inputValue === 'r') {
+        return [
+            action({ type: 'pushView', value: 'reflog' }),
+            action({ type: 'setStatus', value: 'jumped to reflog' }),
+        ];
+    }
+    // `gB` chord: jump to the bisect workflow view (#784). Capital B
+    // disambiguates from `gb` (branches). Always navigates — even when
+    // bisect is inactive — so the user can see the empty-state hint and
+    // know how to start one. The view's surface tells them the next step.
+    if (state.pendingKey === 'g' && inputValue === 'B') {
+        return [
+            action({ type: 'pushView', value: 'bisect' }),
+            action({ type: 'setStatus', value: 'jumped to bisect' }),
+        ];
+    }
     // `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
@@ -18851,6 +19096,29 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
             action({ type: 'setStatus', value: 'gT creates a tag at the cursored commit on the history view' }),
         ];
     }
+    // #784 — bisect view action keys. Scoped to `state.activeView ===
+    // 'bisect' && state.focus === 'commits'` so the single-letter keys
+    // stay free everywhere else. `g` and `b` collide with the global
+    // chord prefix and the `gb` continuation respectively — placed
+    // BEFORE the bare-`g` chord trigger below so a `g` keystroke on
+    // the bisect view marks good rather than entering chord mode. The
+    // user's path back out of bisect is `<` / `esc`, never a chord;
+    // the in-bisect view itself can't navigate elsewhere via `g`-prefix
+    // chords until the user exits with `esc` first.
+    if (state.activeView === 'bisect' && state.focus === 'commits') {
+        if (inputValue === 'g' && state.pendingKey !== 'g') {
+            return [{ type: 'runWorkflowAction', id: 'bisect-good' }];
+        }
+        if (inputValue === 'b' && state.pendingKey !== 'g') {
+            return [{ type: 'runWorkflowAction', id: 'bisect-bad' }];
+        }
+        if (inputValue === 's') {
+            return [{ type: 'runWorkflowAction', id: 'bisect-skip' }];
+        }
+        if (inputValue === 'x') {
+            return [action({ type: 'setPendingConfirmation', value: 'bisect-reset' })];
+        }
+    }
     if (inputValue === 'g') {
         if (state.pendingKey === 'g') {
             return [
@@ -19118,6 +19386,9 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         if (isStashActionTarget(state) && context.stashCount) {
             return [action({ type: 'moveStash', delta: -1, count: context.stashCount })];
         }
+        if (isReflogActionTarget(state) && context.reflogCount) {
+            return [action({ type: 'moveReflog', delta: -1, count: context.reflogCount })];
+        }
         if (isWorktreeActionTarget(state) && context.worktreeListCount) {
             return [action({ type: 'moveWorktreeListEntry', delta: -1, count: context.worktreeListCount })];
         }
@@ -19199,6 +19470,9 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         if (isStashActionTarget(state) && context.stashCount) {
             return [action({ type: 'moveStash', delta: 1, count: context.stashCount })];
         }
+        if (isReflogActionTarget(state) && context.reflogCount) {
+            return [action({ type: 'moveReflog', delta: 1, count: context.reflogCount })];
+        }
         if (isWorktreeActionTarget(state) && context.worktreeListCount) {
             return [action({ type: 'moveWorktreeListEntry', delta: 1, count: context.worktreeListCount })];
         }
@@ -19270,6 +19544,30 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
             action({ type: 'setStatus', value: 'staging worktree changes' }),
         ];
     }
+    // Compare-flow Enter override (#779). When `compareBase` is set and
+    // the user presses Enter on a branch / tag / history commit row, we
+    // open the compare diff (base..head) instead of the row's normal
+    // action (checkout / drill-in / diff). Scoped to compare-flow
+    // targets so non-flow views keep their Enter intact. Runs BEFORE
+    // the per-row Enter handlers below so the override wins, including
+    // before the history-row drill-in.
+    if (key.return && state.compareBase && isCompareFlowTarget(state)) {
+        const head = getCursoredCompareRef(state, context);
+        if (!head) {
+            return [action({ type: 'setStatus', value: 'No ref under cursor — move to a branch / tag / commit row first' })];
+        }
+        if (head.ref === state.compareBase.ref && head.kind === state.compareBase.kind) {
+            return [action({ type: 'setStatus', value: 'Compare base and head are the same ref — pick a different one' })];
+        }
+        return [
+            action({
+                type: 'navigateOpenDiffForCompare',
+                base: state.compareBase,
+                head,
+            }),
+            action({ type: 'setStatus', value: `Comparing ${state.compareBase.label} → ${head.label}` }),
+        ];
+    }
     if (key.return &&
         state.activeView === 'history' &&
         state.focus === 'commits' &&
@@ -19286,6 +19584,28 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
             ];
         }
     }
+    // Enter on a reflog row drills into the diff for that entry's hash
+    // (#781). Reuses `navigateOpenDiffForCommit`, which finds the commit
+    // by hash in `state.filteredCommits` first and falls back to
+    // `commitIndex` only when the hash isn't present. Reflog hashes that
+    // exist in the loaded history (the common case) drill in cleanly;
+    // dangling-commit hashes fall back to the index. The `commitIndex`
+    // we pass is best-effort — index in `state.commits` if found, else
+    // `state.selectedIndex` so the cursor stays sane on the diff view.
+    if (key.return &&
+        isReflogActionTarget(state) &&
+        context.reflogSelectedHash) {
+        const sha = context.reflogSelectedHash;
+        const fallbackIndex = state.commits.findIndex((commit) => commit.hash === sha);
+        return [
+            action({
+                type: 'navigateOpenDiffForCommit',
+                sha,
+                commitIndex: fallbackIndex >= 0 ? fallbackIndex : state.selectedIndex,
+            }),
+            action({ type: 'setStatus', value: `viewing diff for ${sha.slice(0, 7)}` }),
+        ];
+    }
     // Inspector Actions tab: Enter on the cursored action fires its
     // associated event (cherry-pick / revert / yank / etc.). Wins over
     // the file-list Enter below when the user has [/]-toggled to the
@@ -19465,6 +19785,27 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
     if (inputValue === 'R' && isTagActionTarget(state) && context.tagCount) {
         return [action({ type: 'setPendingConfirmation', value: 'delete-remote-tag' })];
     }
+    // `m` marks (or un-marks) the cursored ref as the compare base
+    // (#779). Scoped to compare-flow targets so it doesn't collide with
+    // the `m` PR-merge handler further down. The toggle behavior — `m`
+    // again on the same ref clears the base — gives the user a way to
+    // bail out without remembering a separate cancel key.
+    if (inputValue === 'm' && isCompareFlowTarget(state)) {
+        const ref = getCursoredCompareRef(state, context);
+        if (!ref) {
+            return [action({ type: 'setStatus', value: 'No ref under cursor — move to a branch / tag / commit row first' })];
+        }
+        if (state.compareBase && state.compareBase.ref === ref.ref && state.compareBase.kind === ref.kind) {
+            return [
+                action({ type: 'clearCompareBase' }),
+                action({ type: 'setStatus', value: `Cleared compare base ${ref.label}` }),
+            ];
+        }
+        return [
+            action({ type: 'setCompareBase', value: ref }),
+            action({ type: 'setStatus', value: `Compare base: ${ref.label} — press enter on another ref to diff` }),
+        ];
+    }
     // Per-view worktree action: `D` removes the worktree AND deletes
     // the branch it was tracking (#838). Scoped to the worktrees
     // surface so it intercepts BEFORE the global workflow-by-key
@@ -20843,6 +21184,12 @@ function formatLogInkStatusEmpty({ hasChanges }) {
     }
     return 'Worktree clean. Press gh for history, gb for branches, gz for stash.';
 }
+function formatLogInkReflogEmpty({ filter }) {
+    if (filter.trim()) {
+        return `No reflog entries match filter '${filter}'. Press ctrl+u to clear.`;
+    }
+    return 'No reflog entries. Activity in this repo will appear here over time.';
+}
 function formatLogInkComposeEmpty({ hasStaged }) {
     if (hasStaged) {
         return undefined;
@@ -22472,14 +22819,14 @@ function deleteRemoteTag(git, tagName) {
     return runAction$2(() => git.raw(['push', 'origin', `:${tagName}`]), `Deleted remote tag ${tagName}`);
 }
 
-const FIELD_SEPARATOR = '\x1f';
+const FIELD_SEPARATOR$1 = '\x1f';
 function parseTagRefs(output) {
     return output
         .split('\n')
         .map((line) => line.trimEnd())
         .filter(Boolean)
         .map((line) => {
-        const [name, hash, date, subject] = line.split(FIELD_SEPARATOR);
+        const [name, hash, date, subject] = line.split(FIELD_SEPARATOR$1);
         return {
             name,
             hash,
@@ -22491,7 +22838,7 @@ function parseTagRefs(output) {
 async function getTagOverview(git) {
     const output = await git.raw([
         'for-each-ref',
-        `--format=%(refname:short)${FIELD_SEPARATOR}%(objectname:short)${FIELD_SEPARATOR}%(creatordate:short)${FIELD_SEPARATOR}%(subject)`,
+        `--format=%(refname:short)${FIELD_SEPARATOR$1}%(objectname:short)${FIELD_SEPARATOR$1}%(creatordate:short)${FIELD_SEPARATOR$1}%(subject)`,
         '--sort=-creatordate',
         'refs/tags',
     ]);
@@ -24750,6 +25097,231 @@ function formatPullRequestStateLine(pr) {
     return parts.join(' · ');
 }
 
+const EMPTY_STATUS = {
+    active: false,
+    currentSha: '',
+    log: [],
+};
+async function bisectIsActive(git) {
+    try {
+        const path = (await git.revparse(['--git-path', 'BISECT_LOG'])).trim();
+        return path.length > 0 && existsSync(path);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Parse the output of `git bisect log` into structured entries. Each
+ * entry corresponds to one user decision (start / good / bad / skip)
+ * or the "# bad: [<sha>] <subject>" comment lines git emits for
+ * traceability. Comment lines without a recognized prefix are dropped
+ * — they're informational headers ("# status: ..."), not actions
+ * the user took.
+ */
+function parseBisectLog(output) {
+    const entries = [];
+    for (const rawLine of output.split('\n')) {
+        const line = rawLine.trimEnd();
+        if (!line)
+            continue;
+        // Comment rows: "# good: [sha] subject" / "# bad: [sha] subject" /
+        // "# first bad commit: ..." / "# status: ...". The first two carry
+        // the most user-relevant info (which commits were marked) so we
+        // promote them to typed entries; the rest fall through as raw
+        // lines tagged 'unknown' so the renderer can dim them or hide
+        // entirely.
+        if (line.startsWith('#')) {
+            const commentMatch = line.match(/^#\s+(good|bad|skip):\s+\[([^\]]+)\]\s*(.*)$/);
+            if (commentMatch) {
+                entries.push({
+                    kind: commentMatch[1],
+                    sha: commentMatch[2],
+                    subject: commentMatch[3] || undefined,
+                    raw: line,
+                });
+                continue;
+            }
+            entries.push({ kind: 'unknown', raw: line });
+            continue;
+        }
+        // Command rows: "git bisect start", "git bisect good <sha>",
+        // "git bisect bad <sha>", "git bisect skip <sha>".
+        const commandMatch = line.match(/^git\s+bisect\s+(start|good|bad|skip)\s*(.*)$/);
+        if (commandMatch) {
+            const sha = commandMatch[2]?.trim().split(/\s+/)[0] || undefined;
+            entries.push({
+                kind: commandMatch[1],
+                sha: sha || undefined,
+                raw: line,
+            });
+            continue;
+        }
+        entries.push({ kind: 'unknown', raw: line });
+    }
+    return entries;
+}
+/**
+ * Load the live bisect status. Best-effort — when bisect isn't
+ * active the empty-status sentinel returns immediately so callers
+ * don't pay for a `git bisect log` round-trip on every refresh.
+ */
+async function getBisectStatus(git) {
+    if (!(await bisectIsActive(git))) {
+        return EMPTY_STATUS;
+    }
+    let log = [];
+    try {
+        const output = await git.raw(['bisect', 'log']);
+        log = parseBisectLog(output);
+    }
+    catch {
+        // bisect log can fail on a freshly-started bisect with no decisions.
+        // Treat the absence of a parseable log as "active but empty" rather
+        // than non-active, so the surface still routes to the bisect view
+        // and the user can see the badge.
+        log = [];
+    }
+    let currentSha = '';
+    try {
+        currentSha = (await git.revparse(['HEAD'])).trim();
+    }
+    catch {
+        currentSha = '';
+    }
+    return { active: true, currentSha, log };
+}
+
+/**
+ * Thin wrappers around `git bisect <verb>` for the TUI's in-bisect
+ * action keys (#784). Each returns the raw stdout so the surface can
+ * surface git's own "Bisecting: N revisions left to test after this
+ * (roughly K steps)" hint as a status message — that wording is the
+ * single most useful piece of feedback git emits during bisect, and
+ * mirroring it keeps the TUI's status line authoritative.
+ *
+ * No try/catch here — git itself returns non-zero on user errors
+ * (already-bisecting, no good ref, etc.) and `simple-git` surfaces
+ * those as rejections. The runtime catches them and routes to the
+ * status line.
+ */
+async function bisectGood(git, ref) {
+    const args = ['bisect', 'good'];
+    return git.raw(args);
+}
+async function bisectBad(git, ref) {
+    const args = ['bisect', 'bad'];
+    return git.raw(args);
+}
+async function bisectSkip(git, ref) {
+    const args = ['bisect', 'skip'];
+    return git.raw(args);
+}
+async function bisectReset(git) {
+    return git.raw(['bisect', 'reset']);
+}
+/**
+ * Pull the user-facing remaining-revisions hint out of `git bisect`
+ * stdout. Looks for the canonical line:
+ *
+ *   `Bisecting: N revisions left to test after this (roughly K steps)`
+ *
+ * Returns undefined when the line isn't present (e.g. the run
+ * finished and git emitted a "<sha> is the first bad commit" line
+ * instead). Callers fall back to an empty status update in that case.
+ */
+function extractBisectRemainingHint(stdout) {
+    for (const line of stdout.split('\n').reverse()) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('Bisecting:'))
+            return trimmed;
+        if (trimmed.includes('is the first bad commit'))
+            return trimmed;
+    }
+    return undefined;
+}
+
+/**
+ * Compare two refs (branches / tags / commits) and return the unified
+ * patch as line-split string output (#779).
+ *
+ * Mirrors the stash-diff loader's contract — emits `string[]` so the
+ * existing diff surface can render the lines through its standard
+ * +/-/@@ coloring path. Two-dot syntax (`base..head`) gives the
+ * "what changed on head, relative to base" view that's natural for
+ * branch reviews and pre-merge sanity checks.
+ *
+ * Defensive about input — both refs are passed as-is to git, so the
+ * caller is responsible for providing a git-resolvable form
+ * (branch shortName, tag name, or commit hash). On any git error
+ * (unknown ref, etc.) the runtime's `safe()` wrapper at the call
+ * site catches the throw and the surface falls back to a "no diff"
+ * hint.
+ */
+async function getCompareDiff(git, base, head) {
+    return (await git.raw(['diff', `${base}..${head}`]))
+        .split('\n')
+        .map((line) => line.replace(/\r$/, ''));
+}
+
+const FIELD_SEPARATOR = '\x1f';
+/**
+ * Default fetch limit. 200 entries is enough to span weeks of normal
+ * activity for an active repo while keeping the load fast — `git reflog`
+ * is local-only so even 1000+ entries is sub-second, but 200 keeps the
+ * rendered list bounded for terminals.
+ */
+const DEFAULT_REFLOG_LIMIT = 200;
+function parseReflogOverview(output) {
+    return output
+        .split('\n')
+        .map((line) => line.trimEnd())
+        .filter(Boolean)
+        .map((line) => {
+        const [selector, hash, relativeDate, subject] = line.split(FIELD_SEPARATOR);
+        return {
+            selector: selector || '',
+            hash: hash || '',
+            relativeDate: relativeDate || '',
+            subject: subject || '',
+        };
+    });
+}
+async function getReflogOverview(git, limit = DEFAULT_REFLOG_LIMIT) {
+    const output = await git.raw([
+        'reflog',
+        `--max-count=${limit}`,
+        `--pretty=format:%gd${FIELD_SEPARATOR}%h${FIELD_SEPARATOR}%cr${FIELD_SEPARATOR}%gs`,
+    ]);
+    return {
+        entries: parseReflogOverview(output),
+    };
+}
+/**
+ * Pull the action prefix off a reflog subject. Reflog subjects follow
+ * a `<verb>[ qualifier]: <message>` pattern emitted by git itself —
+ * "commit: ...", "commit (amend): ...", "checkout: moving from main
+ * to feature", "merge feature: ...", "reset: moving to HEAD~1", etc.
+ *
+ * For display we want the verb (and any parenthetical qualifier) on
+ * its own so the view can render a fixed-width `action` column and
+ * keep the rest of the message left-aligned.
+ *
+ * Defensive: if the subject has no colon, the whole string is treated
+ * as the action and the message is empty. This keeps the renderer
+ * from crashing on a malformed entry.
+ */
+function splitReflogSubject(subject) {
+    const colonIndex = subject.indexOf(':');
+    if (colonIndex === -1) {
+        return { action: subject.trim(), message: '' };
+    }
+    return {
+        action: subject.slice(0, colonIndex).trim(),
+        message: subject.slice(colonIndex + 1).trim(),
+    };
+}
+
 function sectionLines(title, diff) {
     const lines = diff.split('\n').map((line) => line.trimEnd());
     return [
@@ -24862,7 +25434,7 @@ async function safe(promise) {
     }
 }
 async function loadLogInkContext(git) {
-    const [branches, pullRequest, tags, worktree, stashes, worktreeList, operation, provider] = await Promise.all([
+    const [branches, pullRequest, tags, worktree, stashes, worktreeList, operation, provider, reflog, bisect] = await Promise.all([
         safe(getBranchOverview(git)),
         safe(getPullRequestOverview(git)),
         safe(getTagOverview(git)),
@@ -24871,12 +25443,16 @@ async function loadLogInkContext(git) {
         safe(getWorktreeListOverview(git)),
         safe(getGitOperationOverview(git)),
         safe(getProviderOverview(git)),
+        safe(getReflogOverview(git)),
+        safe(getBisectStatus(git)),
     ]);
     return {
+        bisect,
         branches,
         operation,
         provider,
         pullRequest,
+        reflog,
         stashes,
         tags,
         worktree,
@@ -24902,6 +25478,14 @@ function loadLogInkContextEntries(git) {
             key: 'tags',
             load: () => safe(getTagOverview(git)),
         },
+        {
+            key: 'reflog',
+            load: () => safe(getReflogOverview(git)),
+        },
+        {
+            key: 'bisect',
+            load: () => safe(getBisectStatus(git)),
+        },
         {
             key: 'worktree',
             load: () => safe(getWorktreeOverview(git)),
@@ -25290,6 +25874,10 @@ function LogInkApp(deps) {
     // colors match the commit-diff path.
     const [stashDiffLines, setStashDiffLines] = React.useState(undefined);
     const [stashDiffLoading, setStashDiffLoading] = React.useState(false);
+    // #779 — compare-two-refs diff state. Loaded lazily when the diff
+    // view becomes active with `diffSource === 'compare'`.
+    const [compareDiffLines, setCompareDiffLines] = React.useState(undefined);
+    const [compareDiffLoading, setCompareDiffLoading] = React.useState(false);
     const [hasMoreCommits, setHasMoreCommits] = React.useState(() => (Boolean(logArgv?.interactive && !logArgv.limit) &&
         getCommitRows(rows).length >= LOG_INTERACTIVE_DEFAULT_LIMIT));
     const [loadingMoreCommits, setLoadingMoreCommits] = React.useState(false);
@@ -25384,6 +25972,12 @@ function LogInkApp(deps) {
             return all;
         return all.filter((entry) => matchesPromotedFilter([entry.path, entry.branch || ''], state.filter));
     }, [context.worktreeList?.worktrees, state.filter]);
+    const filteredReflogList = React.useMemo(() => {
+        const all = context.reflog?.entries || [];
+        if (!state.filter)
+            return all;
+        return all.filter((entry) => matchesPromotedFilter([entry.selector, entry.hash, entry.relativeDate, entry.subject], state.filter));
+    }, [context.reflog?.entries, state.filter]);
     const dispatch = React.useCallback((action) => {
         setState((current) => applyLogInkAction(current, action));
     }, []);
@@ -25594,6 +26188,70 @@ function LogInkApp(deps) {
         })();
         return () => { active = false; };
     }, [git, state.activeView, state.diffSource, state.stashDiffRef]);
+    // #879 (item 2) — load commit detail for the active bisect's
+    // current candidate so the bisect surface can show "what changed
+    // here" alongside the decision keys. Mirrors the history-detail
+    // loader's shape but keyed on `bisect.currentSha` and only fires
+    // when the bisect view is active. Best-effort: any failure leaves
+    // the surface in its non-detail mode (decision log only) — never
+    // crash the workstation because git couldn't resolve a sha.
+    const [bisectCandidateDetail, setBisectCandidateDetail] = React.useState(undefined);
+    const [bisectCandidateLoading, setBisectCandidateLoading] = React.useState(false);
+    const bisectCandidateSha = state.activeView === 'bisect' && context.bisect?.active
+        ? context.bisect.currentSha
+        : '';
+    React.useEffect(() => {
+        if (!bisectCandidateSha) {
+            setBisectCandidateDetail(undefined);
+            setBisectCandidateLoading(false);
+            return;
+        }
+        let active = true;
+        setBisectCandidateLoading(true);
+        void (async () => {
+            const next = await safe(getCommitDetail(git, bisectCandidateSha));
+            if (active) {
+                setBisectCandidateDetail(next);
+                setBisectCandidateLoading(false);
+            }
+        })();
+        return () => { active = false; };
+    }, [git, bisectCandidateSha]);
+    // #779 — load `git diff <base>..<head>` once the diff view becomes
+    // active with diffSource='compare'. Mirrors the stash loader's
+    // shape; the surface renders the lines via the same +/-/@@ coloring
+    // path. On unknown ref / git error, `safe()` swallows and the
+    // surface falls back to a "no diff" hint.
+    const compareBaseRef = state.compareBase?.ref;
+    const compareHeadRef = state.compareHead?.ref;
+    React.useEffect(() => {
+        if (state.activeView !== 'diff' ||
+            state.diffSource !== 'compare' ||
+            !compareBaseRef ||
+            !compareHeadRef) {
+            return;
+        }
+        let active = true;
+        setCompareDiffLoading(true);
+        void (async () => {
+            const lines = await safe(getCompareDiff(git, compareBaseRef, compareHeadRef));
+            if (active) {
+                setCompareDiffLines(lines || []);
+                setCompareDiffLoading(false);
+            }
+        })();
+        return () => { active = false; };
+    }, [git, state.activeView, state.diffSource, compareBaseRef, compareHeadRef]);
+    // Reset compare-diff state whenever the diff view exits. Without
+    // this, opening a new compare immediately after closing one would
+    // briefly show the previous comparison's lines while the new
+    // loader runs.
+    React.useEffect(() => {
+        if (state.diffSource !== 'compare') {
+            setCompareDiffLines(undefined);
+            setCompareDiffLoading(false);
+        }
+    }, [state.diffSource]);
     React.useEffect(() => {
         let active = true;
         async function loadWorktreeHunks() {
@@ -26104,6 +26762,50 @@ function LogInkApp(deps) {
                     return { ok: false, message: 'No stash selected' };
                 return popStash(git, stash);
             },
+            'bisect-good': async () => {
+                if (!context.bisect?.active)
+                    return { ok: false, message: 'No bisect in progress' };
+                try {
+                    const stdout = await bisectGood(git);
+                    return { ok: true, message: extractBisectRemainingHint(stdout) || 'Marked good' };
+                }
+                catch (error) {
+                    return { ok: false, message: `Bisect good failed: ${error.message}` };
+                }
+            },
+            'bisect-bad': async () => {
+                if (!context.bisect?.active)
+                    return { ok: false, message: 'No bisect in progress' };
+                try {
+                    const stdout = await bisectBad(git);
+                    return { ok: true, message: extractBisectRemainingHint(stdout) || 'Marked bad' };
+                }
+                catch (error) {
+                    return { ok: false, message: `Bisect bad failed: ${error.message}` };
+                }
+            },
+            'bisect-skip': async () => {
+                if (!context.bisect?.active)
+                    return { ok: false, message: 'No bisect in progress' };
+                try {
+                    const stdout = await bisectSkip(git);
+                    return { ok: true, message: extractBisectRemainingHint(stdout) || 'Skipped' };
+                }
+                catch (error) {
+                    return { ok: false, message: `Bisect skip failed: ${error.message}` };
+                }
+            },
+            'bisect-reset': async () => {
+                if (!context.bisect?.active)
+                    return { ok: false, message: 'No bisect in progress' };
+                try {
+                    await bisectReset(git);
+                    return { ok: true, message: 'Bisect reset' };
+                }
+                catch (error) {
+                    return { ok: false, message: `Bisect reset failed: ${error.message}` };
+                }
+            },
             'checkout-file-from-stash': async () => {
                 const path = payload?.trim();
                 const ref = state.stashDiffRef;
@@ -26776,9 +27478,13 @@ function LogInkApp(deps) {
         // perf pass) — reading them here is O(1) instead of O(branches +
         // tags + stashes + worktrees) per keystroke.
         const branchVisibleCount = filteredBranchList.length;
+        const branchSelectedShortName = filteredBranchList[Math.min(state.selectedBranchIndex, Math.max(0, filteredBranchList.length - 1))]?.shortName;
         const tagVisibleCount = filteredTagList.length;
+        const tagSelectedName = filteredTagList[Math.min(state.selectedTagIndex, Math.max(0, filteredTagList.length - 1))]?.name;
         const stashVisibleCount = filteredStashList.length;
         const stashSelectedRef = filteredStashList[Math.min(state.selectedStashIndex, Math.max(0, filteredStashList.length - 1))]?.ref;
+        const reflogVisibleCount = filteredReflogList.length;
+        const reflogSelectedHash = filteredReflogList[Math.min(state.selectedReflogIndex, Math.max(0, filteredReflogList.length - 1))]?.hash;
         const worktreeVisibleCount = filteredWorktreeList.length;
         // When the diff view is showing a stash patch, swap the previewLineCount
         // to the stash diff length so the existing pageDetailPreview path
@@ -26803,8 +27509,12 @@ function LogInkApp(deps) {
             worktreeHunkOffsets: worktreeDiff?.hunkOffsets,
             commitDiffHunkOffsets,
             branchCount: branchVisibleCount,
+            branchSelectedShortName,
             tagCount: tagVisibleCount,
+            tagSelectedName,
             stashCount: stashVisibleCount,
+            reflogCount: reflogVisibleCount,
+            reflogSelectedHash,
             stashSelectedRef,
             stashDiffFileOffsets: stashDiffFileOffsets.length ? stashDiffFileOffsets : undefined,
             stashDiffSelectedPath,
@@ -26910,12 +27620,15 @@ 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, layout.bodyRows, 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, layout.inspectorTabbed, theme)), renderFooter(h, { Box, Text }, state, context, 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, layout.bodyRows, theme), renderMainPanel(h, { Box, Text }, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, bisectCandidateDetail, bisectCandidateLoading, layout.bodyRows, layout.mainPanelWidth, theme, hasMoreCommits, loadingMoreCommits), renderDetailPanel(h, { Box, Text }, state, context, contextStatus, detail, detailLoading, filePreview, filePreviewLoading, layout.detailWidth, layout.inspectorTabbed, theme)), renderFooter(h, { Box, Text }, state, context, theme, idleTip));
 }
 function renderHeader(h, components, state, context, contextStatus, columns, theme, appLabel) {
     const { Box, Text } = components;
     const branch = context.branches?.currentBranch || context.provider?.currentBranch || '<detached>';
-    const dirty = context.branches?.dirty ? 'dirty' : 'clean';
+    // #784 — surface bisect-in-progress in the title bar so users entering
+    // the TUI mid-bisect see it immediately, before they navigate to gB.
+    const dirtyBase = context.branches?.dirty ? 'dirty' : 'clean';
+    const dirty = context.bisect?.active ? `${dirtyBase} · BISECTING` : dirtyBase;
     const repo = context.provider?.repository.owner && context.provider.repository.name
         ? `${context.provider.repository.owner}/${context.provider.repository.name}`
         : 'local repository';
@@ -27170,12 +27883,12 @@ function renderActiveStatusTabContent(h, Text, context, contextStatus, width, th
             : []),
     ];
 }
-function renderMainPanel(h, components, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits) {
+function renderMainPanel(h, components, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, bisectCandidateDetail, bisectCandidateLoading, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits) {
     if (state.activeView === 'status') {
         return renderStatusSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
     }
     if (state.activeView === 'diff') {
-        return renderDiffSurface(h, components, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, bodyRows, width, theme);
+        return renderDiffSurface(h, components, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, bodyRows, width, theme);
     }
     if (state.activeView === 'compose') {
         return renderComposeSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
@@ -27186,6 +27899,12 @@ function renderMainPanel(h, components, state, context, contextStatus, worktreeD
     if (state.activeView === 'tags') {
         return renderTagsSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
     }
+    if (state.activeView === 'reflog') {
+        return renderReflogSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+    }
+    if (state.activeView === 'bisect') {
+        return renderBisectSurface(h, components, state, context, contextStatus, bisectCandidateDetail, bisectCandidateLoading, bodyRows, width, theme);
+    }
     if (state.activeView === 'stash') {
         return renderStashSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
     }
@@ -27813,6 +28532,211 @@ function renderTagsSurface(h, components, state, context, contextStatus, bodyRow
         width,
     }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Tags', focused)), h(Text, { dimColor: true }, headerRight)), ...renderPromotedFilterAffordance(h, Text, state, theme), ...lines);
 }
+/**
+ * Promoted reflog browser (#781). Mirrors `renderTagsSurface` visually
+ * — same header / filter affordance / footer hint conventions — but
+ * lays out four columns per row: relative date, action prefix, short
+ * hash, and message. Filtering matches against all four (so typing
+ * "checkout" narrows to checkout entries, "abc" narrows to a hash).
+ *
+ * Per-row layout uses fixed column widths derived from the visible
+ * window so short-action rows don't leave a wide gutter and long
+ * actions don't push the message off-screen. The cap mirrors the
+ * tags surface's name-column treatment.
+ */
+function renderReflogSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+    const { Box, Text } = components;
+    const focused = state.focus === 'commits';
+    const loading = isLogInkContextKeyLoading(contextStatus, 'reflog');
+    const allEntries = context.reflog?.entries || [];
+    const entries = state.filter
+        ? allEntries.filter((entry) => matchesPromotedFilter([entry.selector, entry.hash, entry.relativeDate, entry.subject], state.filter))
+        : allEntries;
+    const selected = Math.max(0, Math.min(state.selectedReflogIndex, Math.max(0, entries.length - 1)));
+    const listRows = Math.max(4, bodyRows - 4);
+    const startIndex = Math.max(0, selected - Math.floor(listRows / 2));
+    const visible = entries.slice(startIndex, startIndex + listRows);
+    const filterLabel = state.filter ? ` | filter: ${state.filter}` : '';
+    const headerRight = loading
+        ? 'loading reflog'
+        : `${entries.length}/${allEntries.length} entries${filterLabel}`;
+    const emptyLabel = formatLogInkReflogEmpty({ filter: state.filter });
+    const loadingLabel = formatLogInkLoading({ resource: 'reflog' });
+    // Column widths derived from the visible window. The hash column is
+    // fixed (short SHA is always 7 chars) and the date column caps so
+    // "X minutes ago" / "Y hours ago" stays readable without dominating
+    // the row. Action column scales to the longest visible action so
+    // commit / checkout / merge align cleanly.
+    const splitVisible = visible.map((entry) => ({
+        entry,
+        parts: splitReflogSubject(entry.subject),
+    }));
+    const dateColWidth = splitVisible.length === 0
+        ? 16
+        : Math.min(20, Math.max(6, ...splitVisible.map(({ entry }) => entry.relativeDate.length)));
+    const actionColWidth = splitVisible.length === 0
+        ? 12
+        : Math.min(24, Math.max(6, ...splitVisible.map(({ parts }) => parts.action.length)));
+    const hashColWidth = 8;
+    const lines = loading
+        ? [h(Text, { key: 'reflog-loading', dimColor: true }, loadingLabel)]
+        : entries.length === 0
+            ? [h(Text, { key: 'reflog-empty', dimColor: true }, emptyLabel)]
+            : splitVisible.map(({ entry, parts }, offset) => {
+                const index = startIndex + offset;
+                const isSelected = index === selected;
+                const cursor = isSelected ? '>' : ' ';
+                const datePadded = truncate$1(entry.relativeDate, dateColWidth).padEnd(dateColWidth);
+                const actionPadded = truncate$1(parts.action, actionColWidth).padEnd(actionColWidth);
+                const hashPadded = truncate$1(entry.hash, hashColWidth).padEnd(hashColWidth);
+                const message = parts.message || entry.subject;
+                const lineText = truncate$1(`${cursor} ${datePadded} ${actionPadded} ${hashPadded} ${message}`, Math.max(20, width - 4));
+                return h(Text, {
+                    key: `reflog-${index}`,
+                    bold: isSelected,
+                    dimColor: !isSelected,
+                }, lineText);
+            });
+    return h(Box, {
+        borderColor: focusBorderColor(theme, focused),
+        borderStyle: theme.borderStyle,
+        flexDirection: 'column',
+        flexShrink: 0,
+        paddingX: 1,
+        width,
+    }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Reflog', focused)), h(Text, { dimColor: true }, headerRight)), ...renderPromotedFilterAffordance(h, Text, state, theme), ...lines);
+}
+/**
+ * Bisect workflow surface (#784). Shows the current candidate commit
+ * (HEAD), a parsed view of recent decisions from `git bisect log`, and
+ * the four action keys (g good, b bad, s skip, x reset).
+ *
+ * When bisect is inactive, the surface renders an empty-state hint
+ * pointing the user at the CLI to start one. The view stays
+ * navigable so the user can read the documentation before starting
+ * — they can't break anything from here.
+ */
+function renderBisectSurface(h, components, state, context, contextStatus, candidateDetail, candidateLoading, bodyRows, width, theme) {
+    const { Box, Text } = components;
+    const focused = state.focus === 'commits';
+    const loading = isLogInkContextKeyLoading(contextStatus, 'bisect');
+    const bisect = context.bisect;
+    const accent = theme.noColor ? undefined : theme.colors.accent;
+    const lines = [];
+    if (loading) {
+        lines.push(h(Text, { key: 'bisect-loading', dimColor: true }, truncate$1('· Loading bisect status…', width - 4)));
+    }
+    else if (!bisect?.active) {
+        // Empty-state explainer (#879). Teaches the bisect workflow in
+        // ~30 seconds: what it is, how it works, how to start one (CLI
+        // entry remains the supported on-ramp until the in-TUI start
+        // child item lands), and a tip about picking the good anchor.
+        // Bisect is a rarely-used feature even for experienced users —
+        // shipping it with terse copy assumes muscle memory the median
+        // user doesn't have.
+        const empty = [
+            { key: 'title', text: 'Bisect — find the commit that introduced a bug.', opts: { bold: true } },
+            { key: 'spacer-1', text: '' },
+            { key: 'how-h', text: 'How it works', opts: { bold: true } },
+            { key: 'how-1', text: '  Binary search through history. You mark commits as "good" (bug' },
+            { key: 'how-2', text: '  not present) or "bad" (bug present); git narrows the range until' },
+            { key: 'how-3', text: '  it identifies the first bad commit.' },
+            { key: 'spacer-2', text: '' },
+            { key: 'start-h', text: 'How to start', opts: { bold: true } },
+            { key: 'start-1', text: '  From your shell:' },
+            { key: 'start-2', text: '    git bisect start <bad-ref> <good-ref>', opts: { accent: true } },
+            { key: 'start-3', text: '  Then come back here — coco picks up the active bisect and gives' },
+            { key: 'start-4', text: '  you single-keystroke controls:' },
+            { key: 'start-5', text: '    g  mark good      s  skip (e.g. doesn\'t build)', opts: { accent: true } },
+            { key: 'start-6', text: '    b  mark bad       x  reset / cancel', opts: { accent: true } },
+            { key: 'spacer-3', text: '' },
+            { key: 'tip-h', text: 'Tip', opts: { bold: true } },
+            { key: 'tip-1', text: '  Pick a recent release tag as your "good" anchor if you don\'t' },
+            { key: 'tip-2', text: '  remember when the bug appeared. Tags are visible from the tags' },
+            { key: 'tip-3', text: '  view (g t).' },
+        ];
+        for (const row of empty) {
+            lines.push(h(Text, {
+                key: `bisect-empty-${row.key}`,
+                bold: row.opts?.bold,
+                dimColor: row.opts?.dim,
+                color: row.opts?.accent ? accent : undefined,
+            }, truncate$1(row.text, width - 4)));
+        }
+    }
+    else {
+        // Active bisect. Three-section body: current candidate (sha +
+        // commit summary so the user can judge the diff at a glance),
+        // recent decisions, action hints. Action keys live in the footer.
+        const headerSha = bisect.currentSha ? bisect.currentSha.slice(0, 8) : '<unknown>';
+        lines.push(h(Text, { key: 'bisect-active-title', bold: true }, truncate$1(`Bisecting · current candidate ${headerSha}`, width - 4)));
+        // #879 (item 2) — render commit detail for the current candidate.
+        // Lets the user judge "does this look like it would cause the bug?"
+        // before they run their tests, instead of dropping to shell to
+        // git show. Loading is brief (one git show invocation) and the
+        // surface falls back to just the sha header when the detail
+        // hasn't arrived yet (or git rejected the lookup).
+        if (candidateLoading) {
+            lines.push(h(Text, { key: 'bisect-candidate-loading', dimColor: true }, truncate$1('  loading commit detail…', width - 4)));
+        }
+        else if (candidateDetail) {
+            const { author, date, message, body, stats, files } = candidateDetail;
+            lines.push(h(Text, { key: 'bisect-candidate-subject' }, truncate$1(`  ${message}`, width - 4)));
+            lines.push(h(Text, { key: 'bisect-candidate-author', dimColor: true }, truncate$1(`  ${author} · ${date}`, width - 4)));
+            // Body line — first non-empty line of the commit body, truncated.
+            // Skip the noisy preamble (subject + blank line) by taking the
+            // first paragraph after the title; body===subject is common for
+            // single-line commits and we filter that out.
+            const firstBodyLine = (body || '')
+                .split('\n')
+                .map((line) => line.trim())
+                .find((line) => line.length > 0 && line !== message);
+            if (firstBodyLine) {
+                lines.push(h(Text, { key: 'bisect-candidate-body', dimColor: true }, truncate$1(`  ${firstBodyLine}`, width - 4)));
+            }
+            // Stats summary: total file count + +/- numbers, then a few
+            // file names so the user sees scope at a glance. Cap the
+            // file-name list at 3 entries to keep the section bounded.
+            lines.push(h(Text, { key: 'bisect-candidate-stats' }, truncate$1(`  ${stats.filesChanged} file${stats.filesChanged === 1 ? '' : 's'} · +${stats.insertions} / -${stats.deletions}`, width - 4)));
+            const sampleFiles = files.slice(0, 3).map((file) => file.path);
+            if (sampleFiles.length > 0) {
+                const overflow = files.length > sampleFiles.length ? ` (+${files.length - sampleFiles.length} more)` : '';
+                lines.push(h(Text, { key: 'bisect-candidate-files', dimColor: true }, truncate$1(`    ${sampleFiles.join(', ')}${overflow}`, width - 4)));
+            }
+        }
+        // Spacer separates the candidate section from decisions.
+        lines.push(h(Text, { key: 'bisect-active-spacer' }, ''));
+        const decisions = bisect.log.filter((entry) => entry.kind === 'good' || entry.kind === 'bad' || entry.kind === 'skip');
+        if (decisions.length === 0) {
+            lines.push(h(Text, { key: 'bisect-no-decisions', dimColor: true }, truncate$1('No decisions logged yet — press g (good) or b (bad) to record one.', width - 4)));
+        }
+        else {
+            lines.push(h(Text, { key: 'bisect-decisions-header', bold: true }, truncate$1(`Decisions (${decisions.length}):`, width - 4)));
+            const recent = decisions.slice(-Math.max(4, bodyRows - 8));
+            for (const entry of recent) {
+                const kindLabel = entry.kind.toUpperCase().padEnd(5);
+                const sha = (entry.sha || '<unknown>').padEnd(8);
+                const subject = entry.subject || '';
+                const text = `  ${kindLabel} ${sha} ${subject}`;
+                lines.push(h(Text, {
+                    key: `bisect-entry-${entry.raw}`,
+                    dimColor: entry.kind === 'skip',
+                    bold: entry.kind === 'bad',
+                }, truncate$1(text, width - 4)));
+            }
+        }
+        lines.push(h(Text, { key: 'bisect-action-spacer' }, ''));
+        lines.push(h(Text, { key: 'bisect-action-hint', dimColor: true }, truncate$1('Actions: g good · b bad · s skip · x reset', width - 4)));
+    }
+    return h(Box, {
+        borderColor: focusBorderColor(theme, focused),
+        borderStyle: theme.borderStyle,
+        flexDirection: 'column',
+        flexShrink: 0,
+        paddingX: 1,
+        width,
+    }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Bisect', focused)), h(Text, { dimColor: true }, bisect?.active ? 'BISECTING' : 'inactive')), ...lines);
+}
 function renderStashSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
@@ -28018,7 +28942,7 @@ function renderPromotedFilterAffordance(h, Text, state, theme) {
         h(Text, { key: 'promoted-filter-input', color: accent }, `filter: ${state.filter}_`),
     ];
 }
-function renderDiffSurface(h, components, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, bodyRows, width, theme) {
+function renderDiffSurface(h, components, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, bodyRows, width, theme) {
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const worktree = context.worktree;
@@ -28109,6 +29033,50 @@ function renderDiffSurface(h, components, state, context, contextStatus, worktre
             dimColor: index > 0,
         }, truncate$1(line, width - 4))), ...stashBodyNodes);
     }
+    // Compare-two-refs branch (#779). Mirrors the stash diff above but
+    // sourced from `git diff <base>..<head>`. No per-file cherry-pick or
+    // hunk apply — comparing arbitrary refs doesn't have a sensible
+    // mutate-from-here flow, so the surface is read-only navigation.
+    if (state.diffSource === 'compare') {
+        const lines = compareDiffLines || [];
+        const splitActive = isSplitDiffViable(state, width);
+        const splitRequestedButTooNarrow = state.diffViewMode === 'split' && !splitActive;
+        const visibleLines = lines.slice(state.diffPreviewOffset, state.diffPreviewOffset + visibleRows);
+        const baseLabel = state.compareBase?.label || state.compareBase?.ref || '<base>';
+        const headLabel = state.compareHead?.label || state.compareHead?.ref || '<head>';
+        const compareTitle = `${baseLabel} → ${headLabel}`;
+        const baseHeaderLines = compareDiffLoading
+            ? [`Loading diff for ${compareTitle}...`]
+            : lines.length && (lines.length > 1 || lines[0])
+                ? [
+                    compareTitle,
+                    `Lines ${Math.min(state.diffPreviewOffset + 1, lines.length)}-${Math.min(state.diffPreviewOffset + visibleLines.length, lines.length)}/${lines.length}`,
+                    '',
+                ]
+                : ['No diff to display — refs may resolve to the same tree.'];
+        const headerLines = splitRequestedButTooNarrow
+            ? [...baseHeaderLines.slice(0, -1), 'Terminal too narrow for side-by-side; showing unified.', '']
+            : baseHeaderLines;
+        const compareBodyNodes = compareDiffLoading || !lines.length || (lines.length === 1 && !lines[0])
+            ? []
+            : splitActive
+                ? renderSplitDiffBody(h, components, visibleLines, state.diffPreviewOffset, width, theme, 'compare-diff-split')
+                : visibleLines.map((line, index) => h(Text, {
+                    key: `compare-diff-line-${state.diffPreviewOffset + index}`,
+                    ...diffLineProps(line, theme),
+                }, truncate$1(line, width - 4)));
+        return h(Box, {
+            borderColor: focusBorderColor(theme, focused),
+            borderStyle: theme.borderStyle,
+            flexDirection: 'column',
+            flexShrink: 0,
+            paddingX: 1,
+            width,
+        }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle(splitActive ? 'Compare (split)' : 'Compare', focused)), h(Text, { dimColor: true }, truncate$1(compareTitle, Math.max(20, Math.floor(width / 2))))), ...headerLines.map((line, index) => h(Text, {
+            key: `compare-diff-header-${index}`,
+            dimColor: index > 0,
+        }, truncate$1(line, width - 4))), ...compareBodyNodes);
+    }
     // diffSource disambiguates: 'commit' was set when the user opened the
     // diff via history → Enter (read-only commit-diff explore), 'worktree'
     // was set when they came from status → Enter (stage / hunk / revert).
@@ -28967,6 +29935,7 @@ function renderFooter(h, components, state, context, theme, idleTip) {
         showHelp: state.showHelp,
         sidebarTab: state.sidebarTab,
         sidebarItemCount,
+        compareBaseSet: Boolean(state.compareBase),
     });
     // Real status messages always win; idle tips only fill the slot when it
     // would otherwise be empty.