git-coco 0.39.0 → 0.40.1

package/dist/index.js

@@ -78,7 +78,7 @@ var readline__namespace = /*#__PURE__*/_interopNamespaceDefault(readline);
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.39.0";
+const BUILD_VERSION = "0.40.1";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -2152,11 +2152,21 @@ function formatAuthenticationError(error, logger) {
     logger.verbose(`\nOriginal error: ${error.message}`, { color: 'gray' });
 }
 /**
- * Formats a generic error
+ * Formats a generic error.
+ *
+ * The error message prints unconditionally (was previously gated behind
+ * `--verbose`, which left users staring at a "Failed to execute command"
+ * line with no actionable detail when something crashed). The full stack
+ * trace stays under `logger.verbose` so plain output stays focused on the
+ * one-line cause; users running into something they can't diagnose can opt
+ * in with `--verbose` for the trace.
  */
 function formatGenericError(error, logger) {
     logger.log('\nFailed to execute command', { color: 'yellow' });
-    logger.verbose(`\nError: "${error.message}"`, { color: 'red' });
+    logger.log(`\nError: ${error.message}`, { color: 'red' });
+    if (error.stack) {
+        logger.verbose(`\n${error.stack}`, { color: 'gray' });
+    }
 }
 function commandExecutor(handler) {
     return async (argv) => {
@@ -14905,6 +14915,35 @@ function getLogInkWorkflowActions() {
             kind: 'normal',
             requiresConfirmation: false,
         },
+        // Status surface group-level batch ops (#791 follow-up). Triggered
+        // by Enter when the cursor is on a status group header
+        // (Staged / Unstaged / Untracked). Empty `key` keeps them
+        // palette-discoverable without registering a global hotkey — the
+        // Enter-on-header path in inkInput is the canonical trigger.
+        {
+            id: 'unstage-all-staged',
+            key: '',
+            label: 'Unstage all staged files',
+            description: 'Unstage every file currently in the staged group.',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
+        {
+            id: 'stage-all-unstaged',
+            key: '',
+            label: 'Stage all unstaged files',
+            description: 'Stage every modified-but-not-staged file.',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
+        {
+            id: 'stage-all-untracked',
+            key: '',
+            label: 'Stage all untracked files',
+            description: 'Add every untracked file to the index after confirmation.',
+            kind: 'destructive',
+            requiresConfirmation: true,
+        },
         {
             id: 'delete-branch',
             key: 'D',
@@ -15922,6 +15961,88 @@ function extractDiffHunk(input) {
     return { patchText };
 }
 
+/**
+ * Hardcoded per-entity action lists surfaced inside the right-hand
+ * inspector panel. The inspector used to repeat the repo / branch /
+ * status content the top header and left sidebar already show; we drop
+ * that trailer in favor of an actionable cheat-sheet so the user knows
+ * exactly which keystrokes apply to whatever they have under the cursor.
+ *
+ * Why hardcoded instead of introspecting `LOG_INK_KEY_BINDINGS`:
+ *   - Most per-entity actions live in `inkInput.ts` as direct keystroke
+ *     handlers (e.g. `c` cherry-pick, `R` revert) rather than as
+ *     globally-registered bindings, so the registry would be a partial
+ *     view at best.
+ *   - The bindings registry's `contexts` model (normal / search / focus
+ *     name) does not cleanly map to inspector entity types like "branch"
+ *     or "tag". Filtering it would mean replicating the same per-view
+ *     scoping logic the input dispatcher already encodes.
+ *   - New per-entity actions are added infrequently — the maintenance
+ *     cost of mirroring them here is low and keeps this file the single
+ *     source of truth for "what shows in the inspector".
+ *
+ * If you wire up a new per-entity keystroke in `inkInput.ts` — for
+ * example a "create branch from this commit" or "create tag from this
+ * commit" action — add the matching row to the relevant array below so
+ * it shows up in the inspector automatically.
+ */
+const HISTORY_COMMIT_ACTIONS = [
+    { key: 'enter', label: 'Open diff' },
+    { key: 'c', label: 'Cherry-pick' },
+    { key: 'R', label: 'Revert', destructive: true },
+    { key: 'Z', label: 'Reset to commit', destructive: true },
+    { key: 'i', label: 'Interactive rebase', destructive: true },
+    { key: 'y', label: 'Yank hash' },
+    { key: 'Y', label: 'Yank short hash' },
+    { key: 'O', label: 'Open in browser' },
+];
+const BRANCH_ACTIONS = [
+    { key: 'enter', label: 'Checkout' },
+    { key: '+', label: 'New branch' },
+    { key: 'R', label: 'Rename' },
+    { key: 'u', label: 'Set upstream' },
+    { key: 'D', label: 'Delete', destructive: true },
+    { key: 'P', label: 'Push current' },
+    { key: 'F', label: 'Fetch all' },
+    { key: 'y', label: 'Yank name' },
+];
+const TAG_ACTIONS = [
+    { key: '+', label: 'New tag' },
+    { key: 'P', label: 'Push tag' },
+    { key: 'T', label: 'Delete', destructive: true },
+    { key: 'R', label: 'Delete remote', destructive: true },
+    { key: 'y', label: 'Yank name' },
+];
+const STASH_ACTIONS = [
+    { key: 'enter', label: 'Open diff' },
+    { key: 'a', label: 'Apply' },
+    { key: 'p', label: 'Pop' },
+    { key: 'X', label: 'Drop', destructive: true },
+    { key: 'y', label: 'Yank ref' },
+];
+const WORKTREE_ACTIONS = [
+    { key: 'W', label: 'Remove', destructive: true },
+    { key: 'y', label: 'Yank path' },
+];
+function getInspectorActions(context) {
+    switch (context) {
+        case 'history-commit':
+            return HISTORY_COMMIT_ACTIONS;
+        case 'branch':
+            return BRANCH_ACTIONS;
+        case 'tag':
+            return TAG_ACTIONS;
+        case 'stash':
+            return STASH_ACTIONS;
+        case 'worktree':
+            return WORKTREE_ACTIONS;
+        default: {
+            const exhaustive = context;
+            throw new Error(`Unhandled inspector action context: ${String(exhaustive)}`);
+        }
+    }
+}
+
 /**
  * Sort modes for the promoted views (P4.2).
  *
@@ -16128,6 +16249,7 @@ function withPushedView(state, value) {
         diffSource: value === 'diff' ? state.diffSource : undefined,
         stashDiffRef: value === 'diff' ? state.stashDiffRef : undefined,
         pendingCommitFocused: value === 'history' ? state.pendingCommitFocused : false,
+        statusGroupHeaderFocused: value === 'status' ? state.statusGroupHeaderFocused : false,
         pendingKey: undefined,
     };
 }
@@ -16150,6 +16272,7 @@ function withPoppedView(state) {
         diffSource: next === 'diff' ? state.diffSource : undefined,
         stashDiffRef: next === 'diff' ? state.stashDiffRef : undefined,
         pendingCommitFocused: next === 'history' ? state.pendingCommitFocused : false,
+        statusGroupHeaderFocused: next === 'status' ? state.statusGroupHeaderFocused : false,
         pendingKey: undefined,
     };
 }
@@ -16167,6 +16290,7 @@ function withReplacedView(state, value) {
         diffSource: value === 'diff' ? state.diffSource : undefined,
         stashDiffRef: value === 'diff' ? state.stashDiffRef : undefined,
         pendingCommitFocused: value === 'history' ? state.pendingCommitFocused : false,
+        statusGroupHeaderFocused: value === 'status' ? state.statusGroupHeaderFocused : false,
         pendingKey: undefined,
     };
 }
@@ -16298,9 +16422,12 @@ function createLogInkState(rows, options = {}) {
         focus: 'commits',
         sidebarTab: 'status',
         userSidebarTab: 'status',
+        sidebarHeaderFocused: false,
+        statusGroupHeaderFocused: false,
         statusFilterMask: { ...DEFAULT_LOG_INK_STATUS_FILTER_MASK },
         diffViewMode: 'unified',
         inspectorTab: 'inspector',
+        inspectorActionIndex: 0,
     };
 }
 function getSelectedInkCommit(state) {
@@ -16341,12 +16468,21 @@ function applyLogInkAction(state, action) {
             return {
                 ...state,
                 focus: cycleValue(FOCUS_ORDER, state.focus, 1),
+                // Reset header focus when leaving the sidebar so the next
+                // re-entry starts on items rather than mid-flag.
+                sidebarHeaderFocused: false,
+                // Same idea for the status group header — Tab cycling away
+                // from 'commits' should always land back on a real file when
+                // the user returns.
+                statusGroupHeaderFocused: false,
                 pendingKey: undefined,
             };
         case 'focusPrevious':
             return {
                 ...state,
                 focus: cycleValue(FOCUS_ORDER, state.focus, -1),
+                sidebarHeaderFocused: false,
+                statusGroupHeaderFocused: false,
                 pendingKey: undefined,
             };
         case 'move':
@@ -16411,6 +16547,9 @@ function applyLogInkAction(state, action) {
                 selectedWorktreeFileIndex: clampIndex$1(state.selectedWorktreeFileIndex + action.delta, action.fileCount),
                 selectedWorktreeHunkIndex: 0,
                 worktreeDiffOffset: 0,
+                // Cursor moved to a real file row — drop header focus so the
+                // file Enter handler (open diff) is what fires next.
+                statusGroupHeaderFocused: false,
             };
         }
         case 'moveBranch':
@@ -16429,10 +16568,40 @@ function applyLogInkAction(state, action) {
                 selectedBranchIndex: 0,
                 pendingKey: undefined,
             };
+        case 'setSidebarHeaderFocused':
+            return {
+                ...state,
+                sidebarHeaderFocused: action.value,
+                pendingKey: undefined,
+            };
+        case 'setStatusGroupHeaderFocused':
+            return {
+                ...state,
+                statusGroupHeaderFocused: action.value,
+                pendingKey: undefined,
+            };
+        case 'jumpToStatusGroup':
+            // Used by ←/→ on the status surface to land on the first file of
+            // the previous / next non-empty group. Clears header focus so the
+            // user is on a real file after the jump (matches the
+            // sidebar pattern where ←/→ between tabs lands on items, not on
+            // the next tab's header).
+            return {
+                ...state,
+                selectedWorktreeFileIndex: Math.max(0, action.targetIndex),
+                selectedWorktreeHunkIndex: 0,
+                worktreeDiffOffset: 0,
+                statusGroupHeaderFocused: false,
+                pendingKey: undefined,
+            };
         case 'setInspectorTab':
             return {
                 ...state,
                 inspectorTab: action.value,
+                // Reset the action cursor so a fresh tab visit always starts
+                // on the first action, regardless of where the user left off
+                // in a previous entity context.
+                inspectorActionIndex: 0,
                 pendingKey: undefined,
             };
         case 'cycleInspectorTab': {
@@ -16444,9 +16613,22 @@ function applyLogInkAction(state, action) {
             return {
                 ...state,
                 inspectorTab: next,
+                inspectorActionIndex: 0,
                 pendingKey: undefined,
             };
         }
+        case 'moveInspectorAction':
+            return {
+                ...state,
+                inspectorActionIndex: clampIndex$1(state.inspectorActionIndex + action.delta, action.actionCount),
+                pendingKey: undefined,
+            };
+        case 'resetInspectorActionIndex':
+            return {
+                ...state,
+                inspectorActionIndex: 0,
+                pendingKey: undefined,
+            };
         case 'moveTag':
             return {
                 ...state,
@@ -16516,6 +16698,10 @@ function applyLogInkAction(state, action) {
                 ...state,
                 statusFilterMask: allOff ? { ...DEFAULT_LOG_INK_STATUS_FILTER_MASK } : next,
                 selectedWorktreeFileIndex: 0,
+                // Group composition changed — header focus would be ambiguous
+                // (cursor lands on file 0 which may belong to a different
+                // group now). Reset to clear the indicator.
+                statusGroupHeaderFocused: false,
                 pendingKey: undefined,
             };
         }
@@ -16686,6 +16872,13 @@ function applyLogInkAction(state, action) {
             return {
                 ...state,
                 focus: action.value,
+                // Reset sidebar header focus when leaving the sidebar so a
+                // re-entry starts on items rather than mid-flag.
+                sidebarHeaderFocused: action.value === 'sidebar' ? state.sidebarHeaderFocused : false,
+                // The status group header lives in the 'commits' focus on
+                // the status view — clear when focus moves away so a
+                // re-entry starts on a real file.
+                statusGroupHeaderFocused: action.value === 'commits' ? state.statusGroupHeaderFocused : false,
                 pendingKey: undefined,
             };
         case 'setPendingKey':
@@ -16887,6 +17080,82 @@ function action(actionValue) {
         action: actionValue,
     };
 }
+/**
+ * Resolve which inspector action context applies for the current
+ * state. Today only history commits expose actions in the inspector
+ * (the renderer hard-coded `'history-commit'`); future PRs can fan
+ * this out to branch / tag / stash / worktree contexts as the
+ * inspector gains entity-aware sections. Returns `undefined` when no
+ * actions section should be shown (so the cursor model stays a
+ * no-op).
+ */
+function resolveInspectorActionContext(state) {
+    if (state.activeView === 'history' && !state.pendingCommitFocused) {
+        return 'history-commit';
+    }
+    return undefined;
+}
+function getInspectorActionsForState(state) {
+    const ctx = resolveInspectorActionContext(state);
+    return ctx ? getInspectorActions(ctx) : [];
+}
+/**
+ * Synthesize the events that fire when the user presses Enter on a
+ * cursored inspector action (#791 follow-up). Mirrors
+ * `getLogInkPaletteExecuteEvents` — each action's `key` field
+ * routes to the same dispatch the corresponding keystroke would
+ * trigger from the history view's commit cursor. Per-key dispatch
+ * (rather than recursively re-running the keystroke through
+ * `getLogInkInputEvents`) avoids the gating problem: most history
+ * keystroke handlers require `state.focus === 'commits'`, but the
+ * inspector executor fires from `state.focus === 'detail'`.
+ */
+function getInspectorActionExecuteEvents(inspectorAction, state) {
+    const commit = state.filteredCommits[state.selectedIndex];
+    const requireCommit = (fn) => {
+        if (!commit) {
+            return [action({ type: 'setStatus', value: 'No commit selected' })];
+        }
+        return fn(commit.hash, state.selectedIndex);
+    };
+    switch (inspectorAction.key) {
+        case 'enter':
+            return requireCommit((sha, commitIndex) => [
+                action({ type: 'navigateOpenDiffForCommit', sha, commitIndex }),
+            ]);
+        case 'c':
+            return requireCommit(() => [
+                action({ type: 'setPendingConfirmation', value: 'cherry-pick-commit' }),
+            ]);
+        case 'R':
+            return requireCommit(() => [
+                action({ type: 'setPendingConfirmation', value: 'revert-commit' }),
+            ]);
+        case 'Z':
+            return requireCommit(() => [
+                action({
+                    type: 'openInputPrompt',
+                    kind: 'reset-mode',
+                    label: 'Reset mode (soft / mixed / hard)',
+                }),
+            ]);
+        case 'i':
+            return requireCommit(() => [
+                action({ type: 'setPendingConfirmation', value: 'interactive-rebase' }),
+            ]);
+        case 'y':
+            return requireCommit(() => [{ type: 'yankFromActiveView' }]);
+        case 'Y':
+            return requireCommit(() => [{ type: 'yankFromActiveView', short: true }]);
+        case 'O':
+            return [{ type: 'runWorkflowAction', id: 'open-pr' }];
+        default:
+            return [action({
+                    type: 'setStatus',
+                    value: `Action ${inspectorAction.key} not yet wired`,
+                })];
+    }
+}
 /**
  * Build the events needed to apply the hunk under the diff cursor. The
  * runtime workflow handler expects payload format `<target>\n<patch>`
@@ -17698,11 +17967,74 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
     if (key.rightArrow && state.focus === 'sidebar') {
         return [action({ type: 'nextSidebarTab' })];
     }
+    // ←/→ on the inspector switch between the [Inspector] / [Actions]
+    // tabs, mirroring the sidebar's left/right tab semantics. `[` and
+    // `]` still work as keyboard alternatives, but the visible hint in
+    // the inspector chrome shows ←/→ because the bracketed `[/]`
+    // notation reads as "press the / key" — which is the global filter
+    // trigger and was making users think the binding was busted.
+    if (key.leftArrow && state.focus === 'detail') {
+        return [action({ type: 'setInspectorTab', value: 'inspector' })];
+    }
+    if (key.rightArrow && state.focus === 'detail') {
+        return [action({ type: 'setInspectorTab', value: 'actions' })];
+    }
+    // ←/→ on the status surface jump between the staged / unstaged /
+    // untracked groups — the horizontal axis is "between groups", the
+    // vertical axis (↑/↓ below) is "within the active group's files".
+    // Lands on the first file of the target group (clears header
+    // focus) so the user is always on a real file after a jump,
+    // mirroring the sidebar's tab-switch landing behavior.
+    if ((key.leftArrow || key.rightArrow) &&
+        state.activeView === 'status' &&
+        state.focus === 'commits' &&
+        context.statusGroups &&
+        context.statusGroups.length > 1) {
+        const groups = context.statusGroups;
+        const currentIndex = groups.findIndex((group) => state.selectedWorktreeFileIndex >= group.startIndex &&
+            state.selectedWorktreeFileIndex < group.startIndex + group.count);
+        const fallback = currentIndex >= 0 ? currentIndex : 0;
+        const delta = key.leftArrow ? -1 : 1;
+        const nextIndex = Math.max(0, Math.min(groups.length - 1, fallback + delta));
+        if (nextIndex !== fallback) {
+            return [action({ type: 'jumpToStatusGroup', targetIndex: groups[nextIndex].startIndex })];
+        }
+        return [];
+    }
     if (key.upArrow || inputValue === 'k') {
+        // Inspector Actions tab: ↑/↓ moves the cursor through the
+        // executable action list. Wins over moveDetailFile so a
+        // history-commit explore with both file list AND actions visible
+        // navigates the actions when the user has [/]-toggled to the
+        // actions tab. (#791 follow-up)
+        if (state.focus === 'detail' && state.inspectorTab === 'actions' && context.inspectorActionCount) {
+            return [action({
+                    type: 'moveInspectorAction',
+                    delta: -1,
+                    actionCount: context.inspectorActionCount,
+                })];
+        }
         if (state.focus === 'detail' && context.detailFileCount) {
             return [action({ type: 'moveDetailFile', delta: -1, fileCount: context.detailFileCount })];
         }
         if (state.activeView === 'status' && context.worktreeFileCount) {
+            // Already on the group header — ↑ is a no-op (use ←/→ to switch
+            // groups). Mirrors the sidebar's "header is the top of the
+            // hierarchy" behavior.
+            if (state.statusGroupHeaderFocused) {
+                return [];
+            }
+            // Cursor at the first file of its group → promote to the group
+            // header rather than crossing the boundary into the previous
+            // group's last file. Keeps the cursor inside its current
+            // container; ←/→ is the explicit way to move between groups.
+            if (context.statusGroups && context.statusGroups.length > 0) {
+                const currentGroup = context.statusGroups.find((group) => state.selectedWorktreeFileIndex >= group.startIndex &&
+                    state.selectedWorktreeFileIndex < group.startIndex + group.count);
+                if (currentGroup && state.selectedWorktreeFileIndex === currentGroup.startIndex) {
+                    return [action({ type: 'setStatusGroupHeaderFocused', value: true })];
+                }
+            }
             return [action({
                     type: 'moveWorktreeFile',
                     delta: -1,
@@ -17727,6 +18059,30 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
                     previewLineCount: context.previewLineCount,
                 })];
         }
+        // Sidebar header focus: ↑ at item index 0 promotes the cursor
+        // onto the active tab's header. Pressing ↑ again is a no-op
+        // (use ←/→ to switch between tab headers, Enter to drill in).
+        // Only triggers when the sidebar is focused on a content tab —
+        // dedicated promoted views (`g b` etc.) keep the legacy clamp
+        // behavior because they have no header to escape to.
+        if (state.focus === 'sidebar' && !state.sidebarHeaderFocused) {
+            if (state.sidebarTab === 'branches' && state.selectedBranchIndex === 0 && (context.branchCount ?? 0) > 0) {
+                return [action({ type: 'setSidebarHeaderFocused', value: true })];
+            }
+            if (state.sidebarTab === 'tags' && state.selectedTagIndex === 0 && (context.tagCount ?? 0) > 0) {
+                return [action({ type: 'setSidebarHeaderFocused', value: true })];
+            }
+            if (state.sidebarTab === 'stashes' && state.selectedStashIndex === 0 && (context.stashCount ?? 0) > 0) {
+                return [action({ type: 'setSidebarHeaderFocused', value: true })];
+            }
+            if (state.sidebarTab === 'worktrees' && state.selectedWorktreeListIndex === 0 && (context.worktreeListCount ?? 0) > 0) {
+                return [action({ type: 'setSidebarHeaderFocused', value: true })];
+            }
+        }
+        // Already on the header — ↑ is a no-op (←/→ switches tabs).
+        if (state.focus === 'sidebar' && state.sidebarHeaderFocused) {
+            return [];
+        }
         if (isBranchActionTarget(state) && context.branchCount) {
             return [action({ type: 'moveBranch', delta: -1, count: context.branchCount })];
         }
@@ -17761,10 +18117,23 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         if (state.activeView === 'history' && state.pendingCommitFocused) {
             return [action({ type: 'unfocusPendingCommit' })];
         }
+        if (state.focus === 'detail' && state.inspectorTab === 'actions' && context.inspectorActionCount) {
+            return [action({
+                    type: 'moveInspectorAction',
+                    delta: 1,
+                    actionCount: context.inspectorActionCount,
+                })];
+        }
         if (state.focus === 'detail' && context.detailFileCount) {
             return [action({ type: 'moveDetailFile', delta: 1, fileCount: context.detailFileCount })];
         }
         if (state.activeView === 'status' && context.worktreeFileCount) {
+            // Header focused → ↓ re-enters the group at the cursored file
+            // (which is already the group's first file by construction).
+            // Just clear the flag.
+            if (state.statusGroupHeaderFocused) {
+                return [action({ type: 'setStatusGroupHeaderFocused', value: false })];
+            }
             return [action({
                     type: 'moveWorktreeFile',
                     delta: 1,
@@ -17785,6 +18154,13 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
                     previewLineCount: context.previewLineCount,
                 })];
         }
+        // Sidebar header focused: ↓ re-enters the list at index 0.
+        // Clears the header flag and snaps the per-entity selection to 0
+        // (mirrors the existing default selection behavior on first
+        // sidebar focus).
+        if (state.focus === 'sidebar' && state.sidebarHeaderFocused) {
+            return [action({ type: 'setSidebarHeaderFocused', value: false })];
+        }
         if (isBranchActionTarget(state) && context.branchCount) {
             return [action({ type: 'moveBranch', delta: 1, count: context.branchCount })];
         }
@@ -17878,6 +18254,21 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
             ];
         }
     }
+    // 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
+    // actions tab. Routes through `getInspectorActionExecuteEvents` so
+    // the per-action dispatch table stays the single source of truth
+    // for what each action does. (#791 follow-up)
+    if (key.return &&
+        state.focus === 'detail' &&
+        state.inspectorTab === 'actions') {
+        const actions = getInspectorActionsForState(state);
+        const cursored = actions[state.inspectorActionIndex];
+        if (cursored) {
+            return getInspectorActionExecuteEvents(cursored, state);
+        }
+    }
     // From the inspector / commit-diff detail panel, Enter opens (or refocuses)
     // the diff view scoped to the currently-selected commit and file. Lets the
     // user drive the explore flow entirely from the right panel: j/k picks a
@@ -17916,7 +18307,15 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         const sidebarItemCount = getSidebarItemCount(state.sidebarTab, context);
         const hasInSidebarPrimaryAction = (state.sidebarTab === 'branches' || state.sidebarTab === 'stashes') &&
             sidebarTabHasSelectableItems(state.sidebarTab, sidebarItemCount);
-        if (!hasInSidebarPrimaryAction) {
+        // Three cases drill into the dedicated view:
+        //   1. The cursor is on the tab header (user pressed ↑ at the
+        //      top of the list to escape the items — Enter explicitly
+        //      jumps to the dedicated view).
+        //   2. The tab has no in-sidebar primary action defined (status,
+        //      tags, worktrees — drilling in is the canonical path).
+        //   3. The tab has zero items (the dedicated view's empty state
+        //      tells the user what to do next).
+        if (state.sidebarHeaderFocused || !hasInSidebarPrimaryAction) {
             const tabToView = {
                 status: 'status',
                 branches: 'branches',
@@ -17936,6 +18335,24 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         // Fall through — per-entity Enter handler below claims the keystroke.
     }
     if (key.return && state.activeView === 'status' && state.focus === 'commits' && context.worktreeFileCount) {
+        // Group header focused → fire the group's batch workflow action.
+        // Routed through the workflow runner so the runtime owns the
+        // git invocation + status messaging consistently with the
+        // single-file `space` toggle. The `payload` carries the group's
+        // state ('staged' / 'unstaged' / 'untracked') so the runtime can
+        // resolve which files to act on without re-deriving group state.
+        if (state.statusGroupHeaderFocused && context.statusGroups) {
+            const currentGroup = context.statusGroups.find((group) => state.selectedWorktreeFileIndex >= group.startIndex &&
+                state.selectedWorktreeFileIndex < group.startIndex + group.count);
+            if (currentGroup) {
+                const workflowId = currentGroup.state === 'staged'
+                    ? 'unstage-all-staged'
+                    : currentGroup.state === 'unstaged'
+                        ? 'stage-all-unstaged'
+                        : 'stage-all-untracked';
+                return [{ type: 'runWorkflowAction', id: workflowId, payload: currentGroup.state }];
+            }
+        }
         return [action({
                 type: 'navigateOpenDiffForWorktreeFile',
                 fileIndex: state.selectedWorktreeFileIndex,
@@ -20678,6 +21095,35 @@ function parseStashDiffFiles(lines) {
     }
     return files;
 }
+/**
+ * Resolve which stash file *contains* a given line offset — the user's
+ * cursor scrolls through a concatenated multi-file patch, and this is
+ * what powers the "File N/M: <path>" panel header, the inline header
+ * highlighting (#791 follow-up), and the cherry-pick / open-in-editor
+ * dispatchers' "what file is the cursor on" lookup.
+ *
+ * Returns `undefined` when the file list is empty *or* the offset
+ * lands before the very first file's `diff --git` header (e.g. when
+ * `--stat` summary lines lead the patch). Callers fall through to a
+ * "no file selected" state in that case.
+ */
+function findStashFileForOffset(files, offset) {
+    if (files.length === 0)
+        return undefined;
+    let current;
+    for (const file of files) {
+        if (file.startLine <= offset) {
+            current = file;
+        }
+        else {
+            break;
+        }
+    }
+    // First file is the canonical fallback — even if the offset lands
+    // before its header (rare), we want the cursor to be "in" something
+    // so the user's actions have a target.
+    return current ?? files[0];
+}
 const DIFF_GIT_HEADER = /^diff --git (?:"a\/((?:\\.|[^"\\])+)"|a\/(\S+)) (?:"b\/((?:\\.|[^"\\])+)"|b\/(\S+))$/;
 function parseDiffGitHeader(line) {
     const match = line.match(DIFF_GIT_HEADER);
@@ -20732,6 +21178,25 @@ function revertFile(git, file) {
     }
     return runAction$3(() => git.raw(['restore', '--', file.path]), `Reverted ${file.path}`);
 }
+/**
+ * Group-level batch ops triggered by Enter on a status group header
+ * (staged / unstaged / untracked). Pass the files belonging to that
+ * group; the helpers run a single `git add` / `git restore --staged`
+ * with all paths in one invocation rather than looping per-file —
+ * faster + atomic from the user's point of view.
+ */
+function stageAllFiles(git, files) {
+    if (files.length === 0) {
+        return Promise.resolve({ ok: false, message: 'No files to stage' });
+    }
+    return runAction$3(() => git.raw(['add', '--', ...files.map((file) => file.path)]), `Staged ${files.length} ${files.length === 1 ? 'file' : 'files'}`);
+}
+function unstageAllFiles(git, files) {
+    if (files.length === 0) {
+        return Promise.resolve({ ok: false, message: 'No files to unstage' });
+    }
+    return runAction$3(() => git.raw(['restore', '--staged', '--', ...files.map((file) => file.path)]), `Unstaged ${files.length} ${files.length === 1 ? 'file' : 'files'}`);
+}
 
 function fileState(indexStatus, worktreeStatus) {
     if (indexStatus === '?' && worktreeStatus === '?') {
@@ -20775,6 +21240,22 @@ function applyStatusFilterMask(files, mask) {
     }
     return files.filter((file) => mask[file.state]);
 }
+const WORKTREE_GROUP_ORDER = ['staged', 'unstaged', 'untracked'];
+function groupWorktreeFiles(files) {
+    const groups = [];
+    let cursor = 0;
+    for (const groupState of WORKTREE_GROUP_ORDER) {
+        const groupFiles = files.filter((file) => file.state === groupState);
+        if (groupFiles.length > 0) {
+            groups.push({ state: groupState, files: groupFiles, startIndex: cursor });
+            cursor += groupFiles.length;
+        }
+    }
+    return groups;
+}
+function flattenWorktreeGroups(groups) {
+    return groups.flatMap((group) => group.files);
+}
 
 function hunkHeader(hunk) {
     return `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`;
@@ -23124,88 +23605,6 @@ function formatPullRequestStateLine(pr) {
     return parts.join(' · ');
 }
 
-/**
- * Hardcoded per-entity action lists surfaced inside the right-hand
- * inspector panel. The inspector used to repeat the repo / branch /
- * status content the top header and left sidebar already show; we drop
- * that trailer in favor of an actionable cheat-sheet so the user knows
- * exactly which keystrokes apply to whatever they have under the cursor.
- *
- * Why hardcoded instead of introspecting `LOG_INK_KEY_BINDINGS`:
- *   - Most per-entity actions live in `inkInput.ts` as direct keystroke
- *     handlers (e.g. `c` cherry-pick, `R` revert) rather than as
- *     globally-registered bindings, so the registry would be a partial
- *     view at best.
- *   - The bindings registry's `contexts` model (normal / search / focus
- *     name) does not cleanly map to inspector entity types like "branch"
- *     or "tag". Filtering it would mean replicating the same per-view
- *     scoping logic the input dispatcher already encodes.
- *   - New per-entity actions are added infrequently — the maintenance
- *     cost of mirroring them here is low and keeps this file the single
- *     source of truth for "what shows in the inspector".
- *
- * If you wire up a new per-entity keystroke in `inkInput.ts` — for
- * example a "create branch from this commit" or "create tag from this
- * commit" action — add the matching row to the relevant array below so
- * it shows up in the inspector automatically.
- */
-const HISTORY_COMMIT_ACTIONS = [
-    { key: 'enter', label: 'Open diff' },
-    { key: 'c', label: 'Cherry-pick' },
-    { key: 'R', label: 'Revert', destructive: true },
-    { key: 'Z', label: 'Reset to commit', destructive: true },
-    { key: 'i', label: 'Interactive rebase', destructive: true },
-    { key: 'y', label: 'Yank hash' },
-    { key: 'Y', label: 'Yank short hash' },
-    { key: 'O', label: 'Open in browser' },
-];
-const BRANCH_ACTIONS = [
-    { key: 'enter', label: 'Checkout' },
-    { key: '+', label: 'New branch' },
-    { key: 'R', label: 'Rename' },
-    { key: 'u', label: 'Set upstream' },
-    { key: 'D', label: 'Delete', destructive: true },
-    { key: 'P', label: 'Push current' },
-    { key: 'F', label: 'Fetch all' },
-    { key: 'y', label: 'Yank name' },
-];
-const TAG_ACTIONS = [
-    { key: '+', label: 'New tag' },
-    { key: 'P', label: 'Push tag' },
-    { key: 'T', label: 'Delete', destructive: true },
-    { key: 'R', label: 'Delete remote', destructive: true },
-    { key: 'y', label: 'Yank name' },
-];
-const STASH_ACTIONS = [
-    { key: 'enter', label: 'Open diff' },
-    { key: 'a', label: 'Apply' },
-    { key: 'p', label: 'Pop' },
-    { key: 'X', label: 'Drop', destructive: true },
-    { key: 'y', label: 'Yank ref' },
-];
-const WORKTREE_ACTIONS = [
-    { key: 'W', label: 'Remove', destructive: true },
-    { key: 'y', label: 'Yank path' },
-];
-function getInspectorActions(context) {
-    switch (context) {
-        case 'history-commit':
-            return HISTORY_COMMIT_ACTIONS;
-        case 'branch':
-            return BRANCH_ACTIONS;
-        case 'tag':
-            return TAG_ACTIONS;
-        case 'stash':
-            return STASH_ACTIONS;
-        case 'worktree':
-            return WORKTREE_ACTIONS;
-        default: {
-            const exhaustive = context;
-            throw new Error(`Unhandled inspector action context: ${String(exhaustive)}`);
-        }
-    }
-}
-
 function sectionLines(title, diff) {
     const lines = diff.split('\n').map((line) => line.trimEnd());
     return [
@@ -23761,7 +24160,16 @@ function LogInkApp(deps) {
     // count, selected-file resolution, and the rendered list all key off
     // it so toggles never desync the cursor from the rendered rows.
     const visibleWorktreeFiles = React.useMemo(() => applyStatusFilterMask(context.worktree?.files || [], state.statusFilterMask), [context.worktree?.files, state.statusFilterMask]);
-    const selectedWorktreeFile = visibleWorktreeFiles[state.selectedWorktreeFileIndex];
+    // Sectioned view of the visible files (#791 follow-up). Drives the
+    // status surface's three-tier cursor model: ←/→ jumps between
+    // groups, ↑ at index 0 promotes to the group header, Enter on the
+    // header fires the group's batch action. The renderer also consumes
+    // this so the visible file list stays in canonical group order
+    // regardless of whatever order `git status --porcelain` happens to
+    // emit.
+    const visibleWorktreeGroups = React.useMemo(() => groupWorktreeFiles(visibleWorktreeFiles), [visibleWorktreeFiles]);
+    const visibleWorktreeFilesGrouped = React.useMemo(() => flattenWorktreeGroups(visibleWorktreeGroups), [visibleWorktreeGroups]);
+    const selectedWorktreeFile = visibleWorktreeFilesGrouped[state.selectedWorktreeFileIndex];
     const dispatch = React.useCallback((action) => {
         setState((current) => applyLogInkAction(current, action));
     }, []);
@@ -24620,6 +25028,26 @@ function LogInkApp(deps) {
                     return { ok: false, message: 'Comment body required' };
                 return commentPullRequest(body);
             },
+            // Status surface group-level batch ops (#791 follow-up). The
+            // input handler dispatches these when the user presses Enter on a
+            // group header. We re-derive the file list from the live
+            // `context.worktree?.files` rather than trusting a snapshot —
+            // the worktree may have changed since the keystroke fired (rare,
+            // but the cost of re-filtering is negligible compared to the cost
+            // of a stale add). The mask is honored too so a user who's
+            // hidden a category never has it touched by accident.
+            'stage-all-unstaged': async () => {
+                const files = applyStatusFilterMask(context.worktree?.files || [], state.statusFilterMask).filter((file) => file.state === 'unstaged');
+                return stageAllFiles(git, files);
+            },
+            'unstage-all-staged': async () => {
+                const files = applyStatusFilterMask(context.worktree?.files || [], state.statusFilterMask).filter((file) => file.state === 'staged');
+                return unstageAllFiles(git, files);
+            },
+            'stage-all-untracked': async () => {
+                const files = applyStatusFilterMask(context.worktree?.files || [], state.statusFilterMask).filter((file) => file.state === 'untracked');
+                return stageAllFiles(git, files);
+            },
         };
         const handler = handlers[id];
         if (!handler) {
@@ -24645,7 +25073,7 @@ function LogInkApp(deps) {
         }
     }, [context, dispatch, git, refreshContext, state.branchSort, state.filter, state.selectedBranchIndex,
         state.selectedStashIndex, state.selectedTagIndex, state.selectedWorktreeListIndex, state.stashDiffRef,
-        state.tagSort]);
+        state.statusFilterMask, state.tagSort]);
     // Resolve the active view's "yank target" (commit hash / branch /
     // tag / stash ref / file path) against the live filtered+sorted list,
     // copy it to the system clipboard, and surface the result on the
@@ -24700,7 +25128,7 @@ function LogInkApp(deps) {
             // Read from the mask-filtered list (#776) so the cursor and the
             // yanked path always match what's on screen — yanking a hidden
             // row is always a desync bug.
-            const path = visibleWorktreeFiles[state.selectedWorktreeFileIndex]?.path;
+            const path = visibleWorktreeFilesGrouped[state.selectedWorktreeFileIndex]?.path;
             if (path) {
                 value = path;
                 label = `path ${path}`;
@@ -24708,7 +25136,7 @@ function LogInkApp(deps) {
         }
         else if (view === 'diff') {
             if (state.diffSource === 'worktree') {
-                const path = visibleWorktreeFiles[state.selectedWorktreeFileIndex]?.path;
+                const path = visibleWorktreeFilesGrouped[state.selectedWorktreeFileIndex]?.path;
                 if (path) {
                     value = path;
                     label = `path ${path}`;
@@ -24718,17 +25146,8 @@ function LogInkApp(deps) {
                 // Walk back to the most recent file header at or before the
                 // current preview offset — same logic the input-context block
                 // uses to expose stashDiffSelectedPath.
-                const files = parseStashDiffFiles(stashDiffLines);
-                if (files.length > 0) {
-                    let current = files[0];
-                    for (const file of files) {
-                        if (file.startLine <= state.diffPreviewOffset) {
-                            current = file;
-                        }
-                        else {
-                            break;
-                        }
-                    }
+                const current = findStashFileForOffset(parseStashDiffFiles(stashDiffLines), state.diffPreviewOffset);
+                if (current) {
                     value = current.path;
                     label = `path ${current.path}`;
                 }
@@ -24782,7 +25201,7 @@ function LogInkApp(deps) {
         state.selectedTagIndex,
         state.selectedWorktreeFileIndex,
         state.tagSort,
-        visibleWorktreeFiles,
+        visibleWorktreeFilesGrouped,
     ]);
     React.useEffect(() => {
         let active = true;
@@ -25022,28 +25441,14 @@ function LogInkApp(deps) {
             ? parseStashDiffFiles(stashDiffLines)
             : [];
         const stashDiffFileOffsets = stashDiffFiles.map((file) => file.startLine);
-        const stashDiffSelectedPath = (() => {
-            if (state.diffSource !== 'stash' || stashDiffFiles.length === 0)
-                return undefined;
-            const offset = state.diffPreviewOffset;
-            // Walk backwards to the most recent file header at or before the
-            // current cursor offset.
-            let current = stashDiffFiles[0];
-            for (const file of stashDiffFiles) {
-                if (file.startLine <= offset) {
-                    current = file;
-                }
-                else {
-                    break;
-                }
-            }
-            return current.path;
-        })();
+        const stashDiffSelectedPath = state.diffSource === 'stash'
+            ? findStashFileForOffset(stashDiffFiles, state.diffPreviewOffset)?.path
+            : undefined;
         getLogInkInputEvents(state, inputValue, key, {
             detailFileCount: detail?.files.length,
             previewLineCount: diffPreviewLineCount,
             worktreeDiffLineCount: worktreeDiff?.lines.length,
-            worktreeFileCount: visibleWorktreeFiles.length,
+            worktreeFileCount: visibleWorktreeFilesGrouped.length,
             worktreeHunkOffsets: worktreeDiff?.hunkOffsets,
             commitDiffHunkOffsets,
             branchCount: branchVisibleCount,
@@ -25053,7 +25458,13 @@ function LogInkApp(deps) {
             stashDiffFileOffsets: stashDiffFileOffsets.length ? stashDiffFileOffsets : undefined,
             stashDiffSelectedPath,
             worktreeListCount: worktreeVisibleCount,
-            worktreeSelectedPath: visibleWorktreeFiles[state.selectedWorktreeFileIndex]?.path,
+            worktreeSelectedPath: visibleWorktreeFilesGrouped[state.selectedWorktreeFileIndex]?.path,
+            statusGroups: visibleWorktreeGroups.map((group) => ({
+                state: group.state,
+                count: group.files.length,
+                startIndex: group.startIndex,
+            })),
+            inspectorActionCount: getInspectorActionsForState(state).length,
             commitDiffSelectedPath: state.diffSource === 'commit'
                 ? selectedDetailFile?.path
                 : undefined,
@@ -25199,6 +25610,11 @@ function renderSidebar(h, components, state, context, contextStatus, width, body
     // Accordion layout — every tab's title is visible on its own line, but
     // only the active tab expands its content underneath. Switching tabs
     // (1-5 / [/]) collapses the previous and expands the next.
+    // When sidebar focus has been promoted to the tab header (#806
+    // follow-up), the active tab's title row gets selection styling
+    // and the items below it render without their cursor highlight
+    // (which now lives on the header).
+    const headerFocused = focused && state.sidebarHeaderFocused;
     const tabBlocks = tabs.flatMap((tab, tabIndex) => {
         const isActive = tab === state.sidebarTab;
         const count = sidebarTabCount(tab, context);
@@ -25206,6 +25622,7 @@ function renderSidebar(h, components, state, context, contextStatus, width, body
             ? `${sidebarTabLabel(tab)} (${count})`
             : sidebarTabLabel(tab);
         const headerText = isActive ? `[${labelWithCount}]` : labelWithCount;
+        const headerSelected = isActive && headerFocused;
         const blocks = [];
         if (tabIndex > 0) {
             blocks.push(h(Text, { key: `tab-spacer-${tab}` }, ''));
@@ -25214,6 +25631,12 @@ function renderSidebar(h, components, state, context, contextStatus, width, body
             key: `tab-header-${tab}`,
             bold: isActive,
             dimColor: !isActive,
+            // Selection styling on the header itself when the cursor has
+            // been promoted off the items list. inverse swaps fg/bg so the
+            // highlight reads as "this is the cursor target" identically
+            // to how items render when focused.
+            backgroundColor: headerSelected && !theme.noColor ? theme.colors.selection : undefined,
+            inverse: headerSelected,
         }, headerText));
         if (isActive) {
             blocks.push(...renderActiveSidebarContent(h, Text, tab, state, context, contextStatus, width, bodyRows, theme));
@@ -25251,7 +25674,11 @@ function renderActiveSidebarContent(h, Text, tab, state, context, contextStatus,
     // ↑/↓ 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;
+    // Items render with the cursor highlight only when the sidebar is
+    // focused on this tab AND the cursor is on items (not promoted to
+    // the tab header). The header-focused branch up in `renderSidebar`
+    // owns the highlight in that case.
+    const focused = state.focus === 'sidebar' && state.sidebarTab === tab && !state.sidebarHeaderFocused;
     if (tab === 'branches') {
         if (isLogInkContextKeyLoading(contextStatus, 'branches')) {
             return [h(Text, { key: 'tab-branches-loading', dimColor: true }, '  Loading branches…')];
@@ -25551,6 +25978,16 @@ function renderPendingCommitRow(h, Text, worktree, selected, theme) {
         backgroundColor: selected && !theme.noColor ? theme.colors.selection : undefined,
     }, truncate$1(label, 140));
 }
+function buildStatusSurfaceRows(groups) {
+    const rows = [];
+    for (const group of groups) {
+        rows.push({ kind: 'header', group });
+        group.files.forEach((file, offset) => {
+            rows.push({ kind: 'file', group, file, flatIndex: group.startIndex + offset });
+        });
+    }
+    return rows;
+}
 function renderStatusSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
@@ -25560,26 +25997,64 @@ function renderStatusSurface(h, components, state, context, contextStatus, bodyR
     // uses for j/k navigation. `visibleFiles` may be a strict subset of
     // worktree.files when the user has narrowed via 1/2/3.
     const visibleFiles = applyStatusFilterMask(worktree?.files || [], state.statusFilterMask);
+    // Group + canonical-sort. The runtime + input handler agree on this
+    // order so a `selectedWorktreeFileIndex` of N always points to the
+    // same file across all three (renderer / input / workflow handlers).
+    const visibleGroups = groupWorktreeFiles(visibleFiles);
+    const surfaceRows = buildStatusSurfaceRows(visibleGroups);
     const listRows = Math.max(4, bodyRows - 5);
     const selectedIndex = state.selectedWorktreeFileIndex;
+    const headerFocused = state.statusGroupHeaderFocused;
+    // Resolve the cursor's row index in the flat (header-and-file) row
+    // list. Used to window the visible slice around the cursor.
+    const cursorRowIndex = (() => {
+        if (!surfaceRows.length)
+            return 0;
+        const currentGroup = visibleGroups.find((group) => selectedIndex >= group.startIndex && selectedIndex < group.startIndex + group.files.length);
+        if (!currentGroup)
+            return 0;
+        if (headerFocused) {
+            const idx = surfaceRows.findIndex((row) => row.kind === 'header' && row.group === currentGroup);
+            return idx >= 0 ? idx : 0;
+        }
+        const idx = surfaceRows.findIndex((row) => row.kind === 'file' && row.flatIndex === selectedIndex);
+        return idx >= 0 ? idx : 0;
+    })();
     const cleanHint = formatLogInkStatusEmpty({ hasChanges: Boolean(worktree?.files.length) });
-    const startIndex = Math.max(0, selectedIndex - Math.floor(listRows / 2));
+    const windowStart = Math.max(0, Math.min(Math.max(0, surfaceRows.length - listRows), cursorRowIndex - Math.floor(listRows / 2)));
     const isLoading = isLogInkContextKeyLoading(contextStatus, 'worktree');
-    const fileRows = isLoading || !visibleFiles.length
+    const renderedRows = isLoading || !surfaceRows.length
         ? []
-        : visibleFiles.slice(startIndex).slice(0, listRows).map((file, offset) => {
-            const index = startIndex + offset;
-            const isSelected = index === selectedIndex;
+        : surfaceRows.slice(windowStart, windowStart + listRows).map((row, offset) => {
+            const rowIndex = windowStart + offset;
+            if (row.kind === 'header') {
+                const groupContainsCursor = selectedIndex >= row.group.startIndex &&
+                    selectedIndex < row.group.startIndex + row.group.files.length;
+                const headerSelected = focused && headerFocused && groupContainsCursor;
+                const arrow = theme.ascii ? '>' : '▾';
+                const groupLabel = capitalizeGroupName(row.group.state);
+                const text = `  ${arrow} ${groupLabel} (${row.group.files.length})`;
+                return h(Text, {
+                    key: `status-group-${row.group.state}-${rowIndex}`,
+                    bold: true,
+                    dimColor: !headerSelected && rowIndex > cursorRowIndex,
+                    backgroundColor: headerSelected && !theme.noColor ? theme.colors.selection : undefined,
+                    inverse: headerSelected,
+                }, truncate$1(text, 140));
+            }
+            const isSelected = !headerFocused && row.flatIndex === selectedIndex;
             const cursorPart = `${isSelected ? '>' : ' '} `;
-            const dotColor = getStageStatusDotColor(file.state, theme);
+            const dotColor = getStageStatusDotColor(row.file.state, theme);
             const useDot = dotColor !== undefined;
             const dotCells = useDot ? cellWidth(STAGE_STATUS_DOT) + 1 : 0;
-            const tail = `${file.indexStatus}${file.worktreeStatus} ${file.state.padEnd(9)} ${file.path}`;
-            const tailTrunc = truncate$1(tail, Math.max(0, 140 - cellWidth(cursorPart) - dotCells));
+            const tail = `${row.file.indexStatus}${row.file.worktreeStatus} ${row.file.path}`;
+            const tailTrunc = truncate$1(tail, Math.max(0, 140 - cellWidth(cursorPart) - dotCells - 2));
             return h(Text, {
-                key: `status-row-${index}`,
-                dimColor: offset > 0,
-            }, cursorPart, ...(useDot ? [h(Text, { color: dotColor }, STAGE_STATUS_DOT), ' '] : []), tailTrunc);
+                key: `status-file-${row.flatIndex}-${rowIndex}`,
+                dimColor: !isSelected && rowIndex > cursorRowIndex,
+                backgroundColor: isSelected && focused && !theme.noColor ? theme.colors.selection : undefined,
+                inverse: isSelected && focused,
+            }, `  ${cursorPart}`, ...(useDot ? [h(Text, { color: dotColor }, STAGE_STATUS_DOT), ' '] : []), tailTrunc);
         });
     // When the mask narrows the list to nothing but the underlying repo
     // is non-clean, surface why the panel looks empty so the user can
@@ -25609,11 +26084,14 @@ function renderStatusSurface(h, components, state, context, contextStatus, bodyR
     // never touch the filter.
     ...(isStatusFilterMaskActive(state.statusFilterMask)
         ? [h(Text, { key: 'status-mask-indicator', dimColor: true }, `filter: ${formatStatusFilterMask(state.statusFilterMask)}  (1/2/3 to toggle)`)]
-        : []), ...fileRows, ...fallbackLines.map((line, index) => h(Text, {
+        : []), ...renderedRows, ...fallbackLines.map((line, index) => h(Text, {
         key: `status-surface-fallback-${index}`,
         dimColor: index > 0,
     }, truncate$1(line, 140))));
 }
+function capitalizeGroupName(value) {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}
 function isStatusFilterMaskActive(mask) {
     return !mask.staged || !mask.unstaged || !mask.untracked;
 }
@@ -26063,20 +26541,7 @@ function renderDiffSurface(h, components, state, context, contextStatus, worktre
         const visibleLines = lines.slice(state.diffPreviewOffset, state.diffPreviewOffset + visibleRows);
         const stashFiles = parseStashDiffFiles(lines);
         const fileCount = stashFiles.length;
-        const currentFile = (() => {
-            if (fileCount === 0)
-                return undefined;
-            let current = stashFiles[0];
-            for (const file of stashFiles) {
-                if (file.startLine <= state.diffPreviewOffset) {
-                    current = file;
-                }
-                else {
-                    break;
-                }
-            }
-            return current;
-        })();
+        const currentFile = findStashFileForOffset(stashFiles, state.diffPreviewOffset);
         const currentFileIndex = currentFile
             ? Math.max(0, stashFiles.findIndex((file) => file.startLine === currentFile.startLine))
             : -1;
@@ -26103,14 +26568,41 @@ function renderDiffSurface(h, components, state, context, contextStatus, worktre
         const headerLines = splitRequestedButTooNarrow
             ? [...baseHeaderLines.slice(0, -1), 'Terminal too narrow for side-by-side; showing unified.', '']
             : baseHeaderLines;
+        // File header anchor map: absolute line index → owning stash file.
+        // Lets the body-render pass restyle each `diff --git` row in O(1)
+        // and decide which one is the *active* file (the one currently
+        // containing `diffPreviewOffset`). The active header gets the
+        // selection background to mark "the file the cursor is inside."
+        const stashFileByStartLine = new Map(stashFiles.map((file) => [file.startLine, file]));
+        const activeStartLine = currentFile?.startLine;
         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)));
+                : visibleLines.map((line, index) => {
+                    const absoluteIndex = state.diffPreviewOffset + index;
+                    const headerFile = stashFileByStartLine.get(absoluteIndex);
+                    if (headerFile) {
+                        // Replace the verbose `diff --git a/<path> b/<path>` text
+                        // with a compact `▾ <path>` marker — the path itself is
+                        // the meaningful identifier, not the a/b duplication. The
+                        // active file's header gets selection styling so the user
+                        // sees at a glance which file the cursor is inside.
+                        const isActive = absoluteIndex === activeStartLine;
+                        const arrow = theme.ascii ? '> ' : '▾ ';
+                        return h(Text, {
+                            key: `stash-diff-line-${absoluteIndex}`,
+                            bold: true,
+                            color: theme.noColor ? undefined : theme.colors.accent,
+                            backgroundColor: isActive && focused && !theme.noColor ? theme.colors.selection : undefined,
+                            inverse: isActive && focused,
+                        }, truncate$1(`${arrow}${headerFile.path}`, width - 4));
+                    }
+                    return h(Text, {
+                        key: `stash-diff-line-${absoluteIndex}`,
+                        ...diffLineProps(line, theme),
+                    }, truncate$1(line, width - 4));
+                });
         return h(Box, {
             borderColor: focusBorderColor(theme, focused),
             borderStyle: theme.borderStyle,
@@ -26293,7 +26785,10 @@ function renderHistoryInspector(h, components, state, context, _contextStatus, d
         }, h(Text, { bold: true }, panelTitle('Inspector', focused)), ...fallbackLines.map((line, index) => h(Text, {
             key: `detail-${index}`,
             dimColor: index > 1,
-        }, truncate$1(line, width - 4))), ...renderInspectorActionsSection(h, Text, 'history-commit', width, theme));
+        }, truncate$1(line, width - 4))), ...renderInspectorActionsSection(h, Text, 'history-commit', width, theme, {
+            cursorIndex: state.inspectorActionIndex,
+            cursorActive: focused && state.inspectorTab === 'actions',
+        }));
     }
     const statLine = `${detail.stats.filesChanged} files  +${detail.stats.insertions}/-${detail.stats.deletions}`;
     // P5.1 — link the commit hash and each ref out to GitHub when we know
@@ -26330,22 +26825,39 @@ function renderHistoryInspector(h, components, state, context, _contextStatus, d
         h(Text, { key: 'detail-spacer-3' }, ''),
         h(Text, { key: 'detail-files-title' }, 'Changed files:'),
     ];
+    // Single-cursor invariant: the file list owns the cursor when the
+    // inspector tab is active; the actions list owns it when the actions
+    // tab is active. Pass `focused` only for the matching tab so users
+    // never see two simultaneous selection highlights inside the panel.
+    const fileListFocused = focused && state.inspectorTab === 'inspector';
     const fileListMaxRows = Math.max(4, Math.min(detail.files.length, 10));
-    const fileListNodes = renderCommitFileList(h, Text, detail.files, state.selectedFileIndex, focused, fileListMaxRows, width, theme);
-    // Tabbed mode (#806 follow-up — short terminals): render only the
-    // active inspector tab with a `[Inspector] Actions` header so the
-    // user knows what they're seeing and how to switch (`[/]` while
-    // focus is on the inspector). Tall terminals stack both sections
-    // as before.
+    const fileListNodes = renderCommitFileList(h, Text, detail.files, state.selectedFileIndex, fileListFocused, fileListMaxRows, width, theme);
+    // Tab indicator. Renders in BOTH tabbed (short-terminal) mode and
+    // tall-stacked mode so the user can always see which tab the cursor
+    // owns and learn the `[/]` toggle. Without this on tall terminals,
+    // the actions list looked like a static cheat-sheet — there was no
+    // visible signal that the cursor could move into it.
+    //
+    // Spacing between tab labels comes from the labels' own padding
+    // (the active label is bracketed `[Inspector]` while the inactive
+    // one is space-padded ` Inspector `, so adjacency reads cleanly).
+    // Earlier revisions stuck a raw `' '` between the Text children to
+    // pad them visually — that crashes Ink at first paint with
+    // "Text string ' ' must be rendered inside <Text> component"
+    // because Box only accepts component children, never bare strings.
+    const activeTab = state.inspectorTab;
+    const tabHeader = h(Box, { key: 'inspector-tabs', flexDirection: 'row' }, h(Text, {
+        bold: activeTab === 'inspector',
+        dimColor: activeTab !== 'inspector',
+    }, activeTab === 'inspector' ? '[Inspector]' : ' Inspector '), h(Text, {
+        bold: activeTab === 'actions',
+        dimColor: activeTab !== 'actions',
+    }, activeTab === 'actions' ? '[Actions]' : ' Actions '), ...(focused
+        ? [h(Text, { key: 'inspector-tabs-hint', dimColor: true }, '  · ←/→ switch')]
+        : []));
+    // Tabbed mode (short terminals): render only the active tab's
+    // content under the tab header.
     if (tabbed) {
-        const activeTab = state.inspectorTab;
-        const tabHeader = h(Box, { key: 'inspector-tabs', flexDirection: 'row' }, h(Text, {
-            bold: activeTab === 'inspector',
-            dimColor: activeTab !== 'inspector',
-        }, activeTab === 'inspector' ? '[Inspector]' : ' Inspector '), ' ', h(Text, {
-            bold: activeTab === 'actions',
-            dimColor: activeTab !== 'actions',
-        }, activeTab === 'actions' ? '[Actions]' : ' Actions '));
         return h(Box, {
             borderColor: focusBorderColor(theme, focused),
             borderStyle: theme.borderStyle,
@@ -26354,15 +26866,24 @@ function renderHistoryInspector(h, components, state, context, _contextStatus, d
             paddingX: 1,
         }, h(Text, { bold: true }, panelTitle('Inspector', focused)), tabHeader, h(Text, { key: 'inspector-tabs-spacer' }, ''), ...(activeTab === 'inspector'
             ? [...headerNodes, ...fileListNodes]
-            : renderInspectorActionsSection(h, Text, 'history-commit', width, theme)));
-    }
+            : renderInspectorActionsSection(h, Text, 'history-commit', width, theme, {
+                cursorIndex: state.inspectorActionIndex,
+                cursorActive: focused,
+            })));
+    }
+    // Tall mode: stack both sections so the user can read everything at
+    // once, but show the tab header so the active section (and the
+    // `[/]` switch affordance) is visible.
     return h(Box, {
         borderColor: focusBorderColor(theme, focused),
         borderStyle: theme.borderStyle,
         flexDirection: 'column',
         width,
         paddingX: 1,
-    }, h(Text, { bold: true }, panelTitle('Inspector', focused)), ...headerNodes, ...fileListNodes, ...renderInspectorActionsSection(h, Text, 'history-commit', width, theme));
+    }, h(Text, { bold: true }, panelTitle('Inspector', focused)), tabHeader, h(Text, { key: 'inspector-tabs-spacer' }, ''), ...headerNodes, ...fileListNodes, ...renderInspectorActionsSection(h, Text, 'history-commit', width, theme, {
+        cursorIndex: state.inspectorActionIndex,
+        cursorActive: focused && state.inspectorTab === 'actions',
+    }));
 }
 /**
  * Render the trailing "Actions:" section that surfaces which keystrokes
@@ -26375,7 +26896,7 @@ function renderHistoryInspector(h, components, state, context, _contextStatus, d
  * minimum from `getLogInkLayout`) so an overflowing label never wraps and
  * collides with the next row.
  */
-function renderInspectorActionsSection(h, Text, context, width, theme) {
+function renderInspectorActionsSection(h, Text, context, width, theme, options = {}) {
     const actions = getInspectorActions(context);
     if (!actions.length)
         return [];
@@ -26386,10 +26907,13 @@ function renderInspectorActionsSection(h, Text, context, width, theme) {
     const GAP = '  ';
     const DESTRUCTIVE_SUFFIX = '  [!]';
     const labelBudget = Math.max(4, width - 4 /* border + padX */ - KEY_COLUMN - GAP.length - DESTRUCTIVE_SUFFIX.length);
+    const cursorIndex = options.cursorIndex ?? 0;
+    const cursorActive = options.cursorActive ?? false;
     const nodes = [
         h(Text, { key: 'actions-spacer' }, ''),
-        h(Text, { key: 'actions-title' }, 'Actions:'),
+        h(Text, { key: 'actions-title' }, cursorActive ? '[Actions]' : 'Actions:'),
         ...actions.map((action, index) => {
+            const isSelected = cursorActive && index === cursorIndex;
             const keyCell = action.key.padEnd(KEY_COLUMN);
             const label = truncate$1(action.label, labelBudget);
             const children = [
@@ -26407,7 +26931,11 @@ function renderInspectorActionsSection(h, Text, context, width, theme) {
                     dimColor: false,
                 }, DESTRUCTIVE_SUFFIX));
             }
-            return h(Text, { key: `actions-${index}` }, ...children);
+            return h(Text, {
+                key: `actions-${index}`,
+                backgroundColor: isSelected && !theme.noColor ? theme.colors.selection : undefined,
+                inverse: isSelected,
+            }, ...children);
         }),
     ];
     return nodes;