git-coco 0.38.0 → 0.40.0

package/dist/index.esm.mjs

@@ -53,7 +53,7 @@ import { pathToFileURL } from 'url';
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.38.0";
+const BUILD_VERSION = "0.40.0";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -14747,84 +14747,6 @@ function formatInkRefLabels(refs) {
     return refs.length ? ` ${refs.map((ref) => `[${ref}]`).join(' ')}` : '';
 }
 
-function countLabel(count, singular, plural = `${singular}s`) {
-    return `${count} ${count === 1 ? singular : plural}`;
-}
-function getLogInkWorkflowSections(context) {
-    const currentBranch = context.branches?.currentBranch || context.provider?.currentBranch || '<detached>';
-    const dirty = context.branches?.dirty ? 'dirty worktree' : 'clean worktree';
-    const loading = context.contextLoading;
-    const currentPullRequest = context.provider?.currentPullRequest || context.pullRequest?.currentPullRequest;
-    const repository = context.provider?.repository;
-    const repoName = repository?.owner && repository.name
-        ? `${repository.owner}/${repository.name}`
-        : repository?.message || 'local repository';
-    const operation = context.operation;
-    const worktree = context.worktree;
-    return [
-        {
-            title: 'Branch',
-            lines: [
-                `Current: ${currentBranch}`,
-                `State: ${dirty}`,
-                loading && !context.branches
-                    ? 'Branch data loading'
-                    : context.branches
-                        ? `${countLabel(context.branches.localBranches.length, 'local branch', 'local branches')} | ${countLabel(context.branches.remoteBranches.length, 'remote branch', 'remote branches')}`
-                        : 'Branch data unavailable',
-            ],
-        },
-        {
-            title: 'Provider / PR',
-            lines: [
-                `Repository: ${repoName}`,
-                loading && !context.provider && !context.pullRequest
-                    ? 'Provider and pull request data loading'
-                    : currentPullRequest
-                        ? `PR #${currentPullRequest.number} ${currentPullRequest.state}${currentPullRequest.isDraft ? ' draft' : ''}`
-                        : 'No pull request detected for current branch',
-                context.provider?.authenticated === false ? 'Provider auth: offline' : 'Provider auth: available',
-            ],
-        },
-        {
-            title: 'Status',
-            lines: loading && !worktree
-                ? ['Status data loading']
-                : worktree
-                    ? [
-                        `${countLabel(worktree.stagedCount, 'staged file')}`,
-                        `${countLabel(worktree.unstagedCount, 'unstaged file')}`,
-                        `${countLabel(worktree.untrackedCount, 'untracked file')}`,
-                    ]
-                    : ['Status data unavailable'],
-        },
-        {
-            title: 'Tags / Stashes / Worktrees',
-            lines: [
-                loading && !context.tags ? 'Tags loading' : context.tags ? countLabel(context.tags.tags.length, 'tag') : 'Tags unavailable',
-                loading && !context.stashes ? 'Stashes loading' : context.stashes ? countLabel(context.stashes.stashes.length, 'stash', 'stashes') : 'Stashes unavailable',
-                context.worktreeList
-                    ? countLabel(context.worktreeList.worktrees.length, 'worktree')
-                    : loading
-                        ? 'Worktrees loading'
-                        : 'Worktrees unavailable',
-            ],
-        },
-        {
-            title: 'Operation / AI',
-            lines: [
-                loading && !operation
-                    ? 'Operation data loading'
-                    : operation?.operation
-                        ? `${operation.operation} in progress with ${countLabel(operation.conflictedFiles.length, 'conflict')}`
-                        : 'No merge, rebase, cherry-pick, or revert in progress',
-                context.selectedCommit
-                    ? `AI actions target ${context.selectedCommit.shortHash}; estimates shown before execution`
-                    : 'AI actions require a selected commit',
-            ],
-        },
-    ];
-}
 function getLogInkWorkflowActions() {
     return [
         {
@@ -14958,6 +14880,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',
@@ -15068,6 +15019,38 @@ function getLogInkWorkflowActions() {
             kind: 'destructive',
             requiresConfirmation: true,
         },
+        {
+            // Per-view-only: scoped to the history view in inkInput (key `B`).
+            // The prompt itself is the affirmative gate — the user has to
+            // type a branch name before anything happens — so this skips the
+            // y-confirm path. Empty key keeps it palette-discoverable; the
+            // palette path can't synthesize a branch name and surfaces a
+            // hint instead.
+            //
+            // Distinct from `create-branch` (palette / `+` on branches view),
+            // which uses `git switch -c` and switches onto the new branch.
+            // This workflow uses `git branch <name> <sha>` and stays put —
+            // GitKraken's "create branch here" semantic.
+            id: 'create-branch-here',
+            key: '',
+            label: 'Create branch from commit',
+            description: 'Create a branch pointed at the cursored commit (does not switch).',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
+        {
+            // Per-view-only: scoped to the history view in inkInput via the
+            // `gT` chord (bare `T` is taken by delete-tag on the tags view).
+            // Same prompt-as-confirmation pattern as create-branch-here.
+            // Lightweight tag — annotated tags remain available through the
+            // existing `+` flow on the tags view.
+            id: 'create-tag-here',
+            key: '',
+            label: 'Create tag at commit',
+            description: 'Create a lightweight tag at the cursored commit.',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
         {
             // Per-view-only: scoped to the history view in inkInput. `i`
             // (lowercase) is used instead of `I` so the existing `I`
@@ -15080,6 +15063,38 @@ function getLogInkWorkflowActions() {
             kind: 'destructive',
             requiresConfirmation: true,
         },
+        {
+            // Per-view-only: scoped to the history view in inkInput (key `B`).
+            // The prompt itself is the affirmative gate — the user has to
+            // type a branch name before anything happens — so this skips the
+            // y-confirm path. Empty key keeps it palette-discoverable; the
+            // palette path can't synthesize a branch name and surfaces a
+            // hint instead.
+            //
+            // Distinct from `create-branch` (palette / `+` on branches view),
+            // which uses `git switch -c` and switches onto the new branch.
+            // This workflow uses `git branch <name> <sha>` and stays put —
+            // GitKraken's "create branch here" semantic.
+            id: 'create-branch-here',
+            key: '',
+            label: 'Create branch from commit',
+            description: 'Create a branch pointed at the cursored commit (does not switch).',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
+        {
+            // Per-view-only: scoped to the history view in inkInput via the
+            // `gT` chord (bare `T` is taken by delete-tag on the tags view).
+            // Same prompt-as-confirmation pattern as create-branch-here.
+            // Lightweight tag — annotated tags remain available through the
+            // existing `+` flow on the tags view.
+            id: 'create-tag-here',
+            key: '',
+            label: 'Create tag at commit',
+            description: 'Create a lightweight tag at the cursored commit.',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
         {
             id: 'ai-commit-summary',
             key: 'I',
@@ -15614,9 +15629,12 @@ function getLogInkFooterHints(options) {
         // History view default hints. Mutating ops (`c` cherry-pick, `R`
         // revert, `Z` reset, `i` interactive-rebase) all route through a
         // y-confirm or mode prompt — none fire silently from the keystroke.
-        // Grouped into a compact `c/R/Z/i mutate` chip so the footer stays
-        // scannable; full descriptions live in `?` help and the palette.
-        contextual: ['↑/↓ move', 'enter diff', 'c/R/Z/i mutate', 'y/Y yank', '/ search', 'gg/G top/bottom'],
+        // `B` create-branch-here and `gT` create-tag-here use a prompt as
+        // the affirmative gate (typing the name is the confirmation).
+        // 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'],
         global: NORMAL_GLOBAL_HINTS,
     };
 }
@@ -15908,6 +15926,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).
  *
@@ -15927,23 +16027,31 @@ function cycleBranchSort(mode) {
     return BRANCH_SORT_MODES[(index + 1) % BRANCH_SORT_MODES.length];
 }
 function sortBranches(branches, mode) {
-    const copy = branches.slice();
+    // Pin the current branch at index 0 regardless of sort mode (#806
+    // follow-up). Lands the user's cursor on the active branch by
+    // default and keeps the most-relevant row glued to the top of the
+    // list as they cycle sorts.
+    const current = branches.find((entry) => entry.current);
+    const rest = branches.filter((entry) => !entry.current);
+    const sortedRest = rest.slice();
     switch (mode) {
         case 'name':
-            return copy.sort((a, b) => a.shortName.localeCompare(b.shortName));
+            sortedRest.sort((a, b) => a.shortName.localeCompare(b.shortName));
+            break;
         case 'recent':
             // ISO-shaped dates compare byte-for-byte; descending so the freshest
             // branch sits at the top.
-            return copy.sort((a, b) => (b.date || '').localeCompare(a.date || '') ||
+            sortedRest.sort((a, b) => (b.date || '').localeCompare(a.date || '') ||
                 a.shortName.localeCompare(b.shortName));
+            break;
         case 'ahead':
             // ahead-first; ties broken by behind, then by name. Keeps "this branch
             // has unmerged work" in the user's first scroll.
-            return copy.sort((a, b) => b.ahead - a.ahead || b.behind - a.behind ||
+            sortedRest.sort((a, b) => b.ahead - a.ahead || b.behind - a.behind ||
                 a.shortName.localeCompare(b.shortName));
-        default:
-            return copy;
+            break;
     }
+    return current ? [current, ...sortedRest] : sortedRest;
 }
 const TAG_SORT_MODES = ['recent', 'name'];
 const DEFAULT_TAG_SORT_MODE = 'recent';
@@ -16106,6 +16214,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,
     };
 }
@@ -16128,6 +16237,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,
     };
 }
@@ -16145,6 +16255,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,
     };
 }
@@ -16276,8 +16387,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) {
@@ -16318,12 +16433,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':
@@ -16335,6 +16459,28 @@ function applyLogInkAction(state, action) {
                 pendingCommitFocused: false,
                 pendingKey: undefined,
             };
+        case 'selectCommitByHash': {
+            // Locates a commit by its full or short hash within the active
+            // filtered list and snaps the cursor to it. Used by the
+            // branch/tag auto-jump effect (#806 follow-up): cursoring a
+            // branch in the sidebar tracks the history view to that
+            // branch's tip without the user manually scrolling. No-op when
+            // the hash isn't in the loaded list (the runtime surfaces a
+            // status hint in that case).
+            const target = action.hash;
+            const index = state.filteredCommits.findIndex((commit) => commit.hash === target || commit.shortHash === target);
+            if (index < 0) {
+                return state;
+            }
+            return {
+                ...state,
+                selectedIndex: index,
+                selectedFileIndex: 0,
+                diffPreviewOffset: 0,
+                pendingCommitFocused: false,
+                pendingKey: undefined,
+            };
+        }
         case 'focusPendingCommit':
             return {
                 ...state,
@@ -16366,6 +16512,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':
@@ -16374,6 +16523,77 @@ function applyLogInkAction(state, action) {
                 selectedBranchIndex: clampIndex$1(state.selectedBranchIndex + action.delta, action.count),
                 pendingKey: undefined,
             };
+        case 'resetBranchSelection':
+            // Snap the branches sidebar / view cursor back to position 0.
+            // Used after a successful checkout (#806 follow-up): combined
+            // with the "current branch pinned at top" rule from #809, this
+            // lands the user's cursor on the just-checked-out branch.
+            return {
+                ...state,
+                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': {
+            // Two-tab toggle — `delta` is symmetrical so direction does not
+            // matter, but we keep the action shape consistent with the
+            // sidebar's `nextSidebarTab` / `previousSidebarTab` so callers
+            // can mirror the sidebar pattern verbatim.
+            const next = state.inspectorTab === 'inspector' ? 'actions' : 'inspector';
+            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,
@@ -16443,6 +16663,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,
             };
         }
@@ -16613,6 +16837,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':
@@ -16814,6 +17045,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>`
@@ -17459,6 +17766,30 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
             action({ type: 'setStatus', value: 'gH applies a hunk in commit-diff or stash-diff view' }),
         ];
     }
+    // `gT` chord: create a lightweight tag at the cursored commit on the
+    // history view. Bare `T` is taken (delete-tag on the tags view) so we
+    // use the chord. Mirrors `gH` exactly — uppercase letter after the
+    // `g` chord prefix, distinct from the lowercase `gt` chord which
+    // jumps to the tags view. The prompt is the affirmative gate.
+    if (state.pendingKey === 'g' && inputValue === 'T') {
+        if (state.activeView === 'history' &&
+            state.focus === 'commits' &&
+            state.filteredCommits.length > 0 &&
+            !state.pendingCommitFocused) {
+            return [
+                action({ type: 'setPendingKey', value: undefined }),
+                action({
+                    type: 'openInputPrompt',
+                    kind: 'create-tag-here',
+                    label: 'New tag name (at cursored commit)',
+                }),
+            ];
+        }
+        return [
+            action({ type: 'setPendingKey', value: undefined }),
+            action({ type: 'setStatus', value: 'gT creates a tag at the cursored commit on the history view' }),
+        ];
+    }
     if (inputValue === 'g') {
         if (state.pendingKey === 'g') {
             return [
@@ -17540,6 +17871,13 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
                     hunkOffsets: context.commitDiffHunkOffsets,
                 })];
         }
+        // Inspector focused: cycle the inspector tab. The renderer only
+        // honors the tab field on short terminals (where the inspector
+        // collapses into a tabbed layout), but we let the user pre-set
+        // their preference on tall terminals too.
+        if (state.focus === 'detail') {
+            return [action({ type: 'cycleInspectorTab', delta: -1 })];
+        }
         return [action({ type: 'previousSidebarTab' })];
     }
     if (inputValue === ']') {
@@ -17564,6 +17902,9 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
                     hunkOffsets: context.commitDiffHunkOffsets,
                 })];
         }
+        if (state.focus === 'detail') {
+            return [action({ type: 'cycleInspectorTab', delta: 1 })];
+        }
         return [action({ type: 'nextSidebarTab' })];
     }
     // Status surface intercepts 1/2/3 before the sidebar-tab numeric
@@ -17591,11 +17932,62 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
     if (key.rightArrow && state.focus === 'sidebar') {
         return [action({ type: 'nextSidebarTab' })];
     }
+    // ←/→ 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,
@@ -17620,6 +18012,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 })];
         }
@@ -17654,10 +18070,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,
@@ -17678,6 +18107,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 })];
         }
@@ -17771,6 +18207,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
@@ -17809,7 +18260,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',
@@ -17829,6 +18288,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,
@@ -18063,6 +18540,22 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         !state.pendingCommitFocused) {
         return [action({ type: 'setPendingConfirmation', value: 'interactive-rebase' })];
     }
+    // `B` opens a create-branch prompt rooted at the cursored commit
+    // (`git branch <name> <sha>` — does NOT switch to the new branch).
+    // The prompt itself is the affirmative gate, so no separate y-confirm.
+    // Bare uppercase `B` since the lowercase `b` is used by the `gb`
+    // chord prefix and we want a single keystroke for this common op.
+    if (inputValue === 'B' &&
+        state.activeView === 'history' &&
+        state.focus === 'commits' &&
+        state.filteredCommits.length > 0 &&
+        !state.pendingCommitFocused) {
+        return [action({
+                type: 'openInputPrompt',
+                kind: 'create-branch-here',
+                label: 'New branch name (at cursored commit)',
+            })];
+    }
     // `y` / `Y` yank the contextually relevant identifier from the active
     // view to the system clipboard:
     //   history    → cursored commit hash (Y for short hash)
@@ -18689,10 +19182,25 @@ const LOG_INK_MIN_COLUMNS = 80;
 const LOG_INK_MIN_ROWS = 24;
 const LOG_INK_DEFAULT_COLUMNS = 120;
 const LOG_INK_DEFAULT_ROWS = 40;
+/**
+ * Terminal-row threshold below which the inspector switches to a
+ * tabbed layout (commit-detail vs actions). Picked empirically: at
+ * 28 rows the inspector's full stack (~30 rows when fully populated)
+ * starts clipping the actions section; below that, the tabbed mode
+ * gives both views their own air.
+ */
+const INSPECTOR_TABBED_BELOW_ROWS = 28;
 function getLogInkLayout(input) {
     const columns = input.columns || LOG_INK_DEFAULT_COLUMNS;
     const rows = input.rows || LOG_INK_DEFAULT_ROWS;
-    const detailWidth = Math.max(30, Math.min(56, Math.floor(columns * 0.34)));
+    // Inspector width — at rest 20-32 cells (~22% of width), focused
+    // 36-60 cells (~40% of width). Narrow rest state keeps the commit
+    // graph dominant; focus expansion gives the inspector room for long
+    // commit bodies / file lists / action labels. Mirrors the sidebar
+    // pattern (sidebarFocused above): instant transition per render.
+    const detailWidth = input.inspectorFocused
+        ? Math.max(36, Math.min(60, Math.floor(columns * 0.40)))
+        : Math.max(20, Math.min(32, Math.floor(columns * 0.22)));
     // Sidebar at rest: 22-34 cells (~24% of width). Focused: 32-50 cells
     // (~36% of width). The transition is instant per render — focus tab to
     // expand, focus away to collapse.
@@ -18707,6 +19215,7 @@ function getLogInkLayout(input) {
         rows,
         sidebarWidth,
         tooSmall: columns < LOG_INK_MIN_COLUMNS || rows < LOG_INK_MIN_ROWS,
+        inspectorTabbed: rows < INSPECTOR_TABBED_BELOW_ROWS,
     };
 }
 
@@ -20202,6 +20711,63 @@ function resetToCommit(git, commit, mode) {
             : result.details,
     }));
 }
+/**
+ * Create a new local branch pointed at <commit>, without switching to it.
+ *
+ * This is the "create branch from cursored commit" history action — the
+ * user types the new branch name into an input prompt and we run
+ * `git branch <name> <sha>` (NOT `git switch -c`, which is what
+ * `branchActions.createBranch` does for the create-branch-at-HEAD flow).
+ * The split exists because GitKraken-style "create branch here" is
+ * specifically about marking a historical commit, not about switching
+ * onto a new working branch.
+ *
+ * Note for the inspector follow-up: workflow surfacing is driven by the
+ * registry in `inkWorkflows.ts`, not a hardcoded action list — adding
+ * `create-branch-here` there is enough for the inspector / palette to
+ * pick this up.
+ */
+function createBranchFromCommit(git, name, commit) {
+    const trimmedName = name.trim();
+    if (!commit) {
+        return Promise.resolve({
+            ok: false,
+            message: 'No commit selected.',
+        });
+    }
+    if (!trimmedName) {
+        return Promise.resolve({
+            ok: false,
+            message: 'Branch name required.',
+        });
+    }
+    return guardNoInProgressOperation(git).then((blocked) => (blocked || runAction$5(() => git.raw(['branch', trimmedName, commit.hash]), `Created branch ${trimmedName} at ${commit.shortHash}`)));
+}
+/**
+ * Create a lightweight tag pointed at <commit>.
+ *
+ * Mirrors `createBranchFromCommit` for the tag side: the user types a
+ * tag name into an input prompt and we run `git tag <name> <sha>`
+ * (lightweight, no `-a`/`-m`). Annotated tags remain available through
+ * the existing `+` flow on the tags view; this is the per-commit
+ * shortcut.
+ */
+function createTagAtCommit(git, name, commit) {
+    const trimmedName = name.trim();
+    if (!commit) {
+        return Promise.resolve({
+            ok: false,
+            message: 'No commit selected.',
+        });
+    }
+    if (!trimmedName) {
+        return Promise.resolve({
+            ok: false,
+            message: 'Tag name required.',
+        });
+    }
+    return guardNoInProgressOperation(git).then((blocked) => (blocked || runAction$5(() => git.raw(['tag', trimmedName, commit.hash]), `Created tag ${trimmedName} at ${commit.shortHash}`)));
+}
 function startInteractiveRebase(git, commit) {
     if (!commit) {
         return Promise.resolve({
@@ -20482,6 +21048,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);
@@ -20536,6 +21131,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 === '?') {
@@ -20579,6 +21193,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} @@`;
@@ -23483,7 +24113,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));
     }, []);
@@ -23727,6 +24366,80 @@ function LogInkApp(deps) {
             active = false;
         };
     }, [git, selected?.hash]);
+    // #806 follow-up — auto-jump the history view to whichever branch /
+    // tag the user is currently cursoring in the sidebar (or the
+    // dedicated branches / tags view). Debounced so cursor-scrolling
+    // through a long branch list doesn't dispatch on every keystroke.
+    // No-op when the cursored ref's tip isn't in the loaded commit
+    // window (under compact mode the cursored branch's tip may not be
+    // fetched yet); a status hint surfaces in that case so the user
+    // knows to toggle full graph or load older commits.
+    React.useEffect(() => {
+        const onBranchTab = state.activeView === 'branches' ||
+            (state.focus === 'sidebar' && state.sidebarTab === 'branches');
+        const onTagTab = state.activeView === 'tags' ||
+            (state.focus === 'sidebar' && state.sidebarTab === 'tags');
+        if (!onBranchTab && !onTagTab)
+            return;
+        let cancelled = false;
+        const timer = setTimeout(() => {
+            if (cancelled)
+                return;
+            let targetHash;
+            let targetLabel;
+            if (onBranchTab) {
+                const all = sortBranches(context.branches?.localBranches || [], state.branchSort);
+                const visible = state.filter
+                    ? all.filter((b) => matchesPromotedFilter([b.shortName, b.upstream || ''], state.filter))
+                    : all;
+                const branch = visible[Math.min(state.selectedBranchIndex, Math.max(0, visible.length - 1))];
+                if (branch) {
+                    targetHash = branch.hash;
+                    targetLabel = `branch ${branch.shortName}`;
+                }
+            }
+            else if (onTagTab) {
+                const all = sortTags(context.tags?.tags || [], state.tagSort);
+                const visible = state.filter
+                    ? all.filter((t) => matchesPromotedFilter([t.name, t.subject], state.filter))
+                    : all;
+                const tag = visible[Math.min(state.selectedTagIndex, Math.max(0, visible.length - 1))];
+                if (tag) {
+                    targetHash = tag.hash;
+                    targetLabel = `tag ${tag.name}`;
+                }
+            }
+            if (!targetHash)
+                return;
+            const loaded = state.filteredCommits.some((commit) => commit.hash === targetHash || commit.shortHash === targetHash);
+            if (loaded) {
+                dispatch({ type: 'selectCommitByHash', hash: targetHash });
+                // Confirmation status message so the user gets feedback even
+                // when the dedicated branches / tags view is occupying the
+                // main panel and the history cursor moves invisibly behind it.
+                dispatch({
+                    type: 'setStatus',
+                    value: `Synced history to ${targetLabel} tip`,
+                });
+            }
+            else {
+                dispatch({
+                    type: 'setStatus',
+                    value: `${targetLabel} tip not in loaded window — press \\ for full graph or Ctrl+L to load more`,
+                });
+            }
+        }, 150);
+        return () => {
+            cancelled = true;
+            clearTimeout(timer);
+        };
+    }, [
+        dispatch, context.branches, context.tags,
+        state.activeView, state.focus, state.sidebarTab,
+        state.selectedBranchIndex, state.selectedTagIndex,
+        state.branchSort, state.tagSort, state.filter,
+        state.filteredCommits,
+    ]);
     React.useEffect(() => {
         let active = true;
         async function loadWorktreeDiff() {
@@ -24102,6 +24815,30 @@ function LogInkApp(deps) {
                     message: commit.message,
                 });
             },
+            'create-branch-here': async () => {
+                const commit = getSelectedInkCommit(state);
+                const name = payload?.trim();
+                if (!commit)
+                    return { ok: false, message: 'No commit selected' };
+                if (!name)
+                    return { ok: false, message: 'Branch name required' };
+                return createBranchFromCommit(git, name, {
+                    hash: commit.hash,
+                    shortHash: commit.shortHash,
+                });
+            },
+            'create-tag-here': async () => {
+                const commit = getSelectedInkCommit(state);
+                const name = payload?.trim();
+                if (!commit)
+                    return { ok: false, message: 'No commit selected' };
+                if (!name)
+                    return { ok: false, message: 'Tag name required' };
+                return createTagAtCommit(git, name, {
+                    hash: commit.hash,
+                    shortHash: commit.shortHash,
+                });
+            },
             'checkout-file-from-commit': async () => {
                 // payload is "<sha> <path>" so we pass both through a single
                 // string field on the action.
@@ -24154,6 +24891,17 @@ function LogInkApp(deps) {
                 if (!repo || repo.provider !== 'github' || !repo.owner || !repo.name) {
                     return { ok: false, message: 'No GitHub remote detected for this repo' };
                 }
+                // History view: prefer the cursored commit's URL so `O` from
+                // a commit context lands the user on the commit page rather
+                // than the repo root or the current PR. The user-visible
+                // intent of `O` is "open whatever I'm cursoring on the web";
+                // a commit is what the cursor is on in the history view.
+                if (state.activeView === 'history') {
+                    const commit = getSelectedInkCommit(state);
+                    if (commit) {
+                        return openProviderUrl(repo, { type: 'commit', commit: commit.hash });
+                    }
+                }
                 const pr = context.provider?.currentPullRequest || context.pullRequest?.currentPullRequest;
                 if (pr) {
                     return openProviderUrl(repo, { type: 'pull-request', number: pr.number });
@@ -24233,6 +24981,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) {
@@ -24241,12 +25009,24 @@ function LogInkApp(deps) {
         }
         const result = await handler();
         dispatch({ type: 'setStatus', value: result?.message || 'Workflow action complete' });
-        // Silent refresh so the deleted item disappears from the list without
-        // flickering the surfaces through a 'loading' phase.
-        await refreshContext({ silent: true });
+        // Checkout-branch is the one workflow where we want a *visible*
+        // refresh so the user sees the branches sidebar repaint with the
+        // new current branch (per #806 follow-up). Snap the cursor to
+        // position 0 first so when the refresh completes and the new
+        // current branch lands at the top (per #809's pin-current rule),
+        // the cursor is already there waiting.
+        if (id === 'checkout-branch' && result?.ok) {
+            dispatch({ type: 'resetBranchSelection' });
+            await refreshContext();
+        }
+        else {
+            // Silent refresh so the deleted item disappears from the list
+            // without flickering the surfaces through a 'loading' phase.
+            await refreshContext({ silent: true });
+        }
     }, [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
@@ -24301,7 +25081,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}`;
@@ -24309,7 +25089,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}`;
@@ -24319,17 +25099,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}`;
                 }
@@ -24383,7 +25154,7 @@ function LogInkApp(deps) {
         state.selectedTagIndex,
         state.selectedWorktreeFileIndex,
         state.tagSort,
-        visibleWorktreeFiles,
+        visibleWorktreeFilesGrouped,
     ]);
     React.useEffect(() => {
         let active = true;
@@ -24623,28 +25394,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,
@@ -24654,7 +25411,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,
@@ -24725,6 +25488,7 @@ function LogInkApp(deps) {
         columns: windowSize.columns || process.stdout.columns || LOG_INK_DEFAULT_COLUMNS,
         rows: windowSize.rows || process.stdout.rows || LOG_INK_DEFAULT_ROWS,
         sidebarFocused: state.focus === 'sidebar',
+        inspectorFocused: state.focus === 'detail',
     });
     if (layout.tooSmall) {
         return h(Box, {
@@ -24739,7 +25503,7 @@ function LogInkApp(deps) {
     if (showOnboarding) {
         return renderOnboardingOverlay(h, { Box, Text }, layout.rows, layout.columns, theme, appLabel);
     }
-    return h(Box, { flexDirection: 'column', height: layout.rows }, renderHeader(h, { Box, Text }, state, context, contextStatus, layout.columns, theme, appLabel), h(Box, { flexDirection: 'row', height: layout.bodyRows }, renderSidebar(h, { Box, Text }, state, context, contextStatus, layout.sidebarWidth, theme), renderMainPanel(h, { Box, Text }, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, layout.bodyRows, layout.mainPanelWidth, theme, hasMoreCommits, loadingMoreCommits), renderDetailPanel(h, { Box, Text }, state, context, contextStatus, detail, detailLoading, filePreview, filePreviewLoading, layout.detailWidth, theme)), renderFooter(h, { Box, Text }, state, 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, 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;
@@ -24792,13 +25556,18 @@ function renderHeader(h, components, state, context, contextStatus, columns, the
         ? h(Text, { bold: true, color: theme.colors.accent }, `${prLabel}${titleSuffix}`)
         : undefined, h(Text, { bold: true, color: modeColor }, `  ${mode}`), search ? h(Text, { dimColor: true }, `  ${truncate$1(search, 36)}`) : undefined);
 }
-function renderSidebar(h, components, state, context, contextStatus, width, theme) {
+function renderSidebar(h, components, state, context, contextStatus, width, bodyRows, theme) {
     const { Box, Text } = components;
     const focused = state.focus === 'sidebar';
     const tabs = getLogInkSidebarTabs();
     // 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);
@@ -24806,6 +25575,7 @@ function renderSidebar(h, components, state, context, contextStatus, width, them
             ? `${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}` }, ''));
@@ -24814,9 +25584,15 @@ function renderSidebar(h, components, state, context, contextStatus, width, them
             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, theme));
+            blocks.push(...renderActiveSidebarContent(h, Text, tab, state, context, contextStatus, width, bodyRows, theme));
         }
         return blocks;
     });
@@ -24835,7 +25611,15 @@ function renderSidebar(h, components, state, context, contextStatus, width, them
  * surface; every other tab falls through to `sidebarLines` for its
  * string-based summary.
  */
-function renderActiveSidebarContent(h, Text, tab, state, context, contextStatus, width, theme) {
+function renderActiveSidebarContent(h, Text, tab, state, context, contextStatus, width, bodyRows, theme) {
+    // Available rows for the active tab's list. The sidebar chrome
+    // takes ~10 rows (panel title + spacer + 5 tab headers + 4 inter-tab
+    // spacers); the branches tab eats 3 more for its summary header
+    // (Current / Worktree / spacer). Floor of 8 keeps short terminals
+    // usable; tall terminals (40+ rows) get noticeably more items.
+    const sidebarChrome = 10;
+    const branchHeaderRows = tab === 'branches' ? 3 : 0;
+    const visibleListCount = Math.max(8, bodyRows - sidebarChrome - branchHeaderRows);
     if (tab === 'status') {
         return renderActiveStatusTabContent(h, Text, context, contextStatus, width, theme);
     }
@@ -24843,7 +25627,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…')];
@@ -24860,7 +25648,7 @@ function renderActiveSidebarContent(h, Text, tab, state, context, contextStatus,
         ];
         return [
             ...headerRows,
-            ...renderSelectableSidebarRows(h, Text, sortedBranches, state.selectedBranchIndex, focused, width, theme, (branch) => `${branchRowMarker(branch, { ascii: theme.ascii })} ${branch.shortName}`, 'tab-branches'),
+            ...renderSelectableSidebarRows(h, Text, sortedBranches, state.selectedBranchIndex, focused, width, theme, (branch) => `${branchRowMarker(branch, { ascii: theme.ascii })} ${branch.shortName}`, 'tab-branches', visibleListCount),
         ];
     }
     if (tab === 'tags') {
@@ -24871,7 +25659,7 @@ function renderActiveSidebarContent(h, Text, tab, state, context, contextStatus,
         if (tags.length === 0) {
             return [h(Text, { key: 'tab-tags-empty', dimColor: true }, '  No tags found')];
         }
-        return renderSelectableSidebarRows(h, Text, tags, state.selectedTagIndex, focused, width, theme, (tag) => `${truncate$1(tag.name, 16)} ${tag.subject}`, 'tab-tags');
+        return renderSelectableSidebarRows(h, Text, tags, state.selectedTagIndex, focused, width, theme, (tag) => `${truncate$1(tag.name, 16)} ${tag.subject}`, 'tab-tags', visibleListCount);
     }
     if (tab === 'stashes') {
         if (isLogInkContextKeyLoading(contextStatus, 'stashes')) {
@@ -24881,7 +25669,7 @@ function renderActiveSidebarContent(h, Text, tab, state, context, contextStatus,
         if (stashes.length === 0) {
             return [h(Text, { key: 'tab-stashes-empty', dimColor: true }, '  No stashes found')];
         }
-        return renderSelectableSidebarRows(h, Text, stashes, state.selectedStashIndex, focused, width, theme, (stash, index) => `@{${index}} ${stash.message || '(no message)'}`, 'tab-stashes');
+        return renderSelectableSidebarRows(h, Text, stashes, state.selectedStashIndex, focused, width, theme, (stash, index) => `@{${index}} ${stash.message || '(no message)'}`, 'tab-stashes', visibleListCount);
     }
     // worktrees
     if (isLogInkContextKeyLoading(contextStatus, 'worktreeList')) {
@@ -24895,7 +25683,7 @@ function renderActiveSidebarContent(h, Text, tab, state, context, contextStatus,
         const marker = worktree.current ? '*' : ' ';
         const wstate = worktree.dirty ? 'dirty' : 'clean';
         return `${marker} ${worktree.branch || worktree.path} ${wstate}`;
-    }, 'tab-worktrees');
+    }, 'tab-worktrees', visibleListCount);
 }
 /**
  * Render a sliding-window list of selectable sidebar rows. The cursor
@@ -24904,10 +25692,10 @@ function renderActiveSidebarContent(h, Text, tab, state, context, contextStatus,
  * Sliding window keeps the cursor in view as the user navigates a long
  * list; truncation hints surface the count of hidden rows.
  */
-function renderSelectableSidebarRows(h, Text, items, selectedIndex, focused, width, theme, toRowText, keyPrefix) {
+function renderSelectableSidebarRows(h, Text, items, selectedIndex, focused, width, theme, toRowText, keyPrefix, visibleCount) {
     if (items.length === 0)
         return [];
-    const window = getSidebarVisibleWindow(items.length, selectedIndex);
+    const window = getSidebarVisibleWindow(items.length, selectedIndex, visibleCount);
     const elements = [];
     if (window.truncatedAbove > 0) {
         elements.push(h(Text, {
@@ -25143,6 +25931,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';
@@ -25152,26 +25950,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
@@ -25201,11 +26037,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;
 }
@@ -25655,20 +26494,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;
@@ -25695,14 +26521,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,
@@ -25808,7 +26661,7 @@ function renderDiffSurface(h, components, state, context, contextStatus, worktre
         }, truncate$1(line, 140)))
         : []));
 }
-function renderDetailPanel(h, components, state, context, contextStatus, detail, loading, filePreview, filePreviewLoading, width, theme) {
+function renderDetailPanel(h, components, state, context, contextStatus, detail, loading, filePreview, filePreviewLoading, width, tabbed, theme) {
     const focused = state.focus === 'detail';
     if (state.showHelp) {
         return renderHelpPanel(h, components, state, width, theme, focused);
@@ -25865,16 +26718,11 @@ function renderDetailPanel(h, components, state, context, contextStatus, detail,
     if (state.activeView === 'stash') {
         return renderStashPreviewPanel(h, components, state, context, contextStatus, width, theme, focused);
     }
-    return renderHistoryInspector(h, components, state, context, contextStatus, detail, loading, filePreview, filePreviewLoading, width, theme, focused);
+    return renderHistoryInspector(h, components, state, context, contextStatus, detail, loading, filePreview, filePreviewLoading, width, tabbed, theme, focused);
 }
-function renderHistoryInspector(h, components, state, context, contextStatus, detail, loading, _filePreview, _filePreviewLoading, width, theme, focused) {
+function renderHistoryInspector(h, components, state, context, _contextStatus, detail, loading, _filePreview, _filePreviewLoading, width, tabbed, theme, focused) {
     const { Box, Text } = components;
     const selected = getSelectedInkCommit(state);
-    const workflowSections = getLogInkWorkflowSections({
-        ...context,
-        contextLoading: isLogInkContextLoading(contextStatus),
-        selectedCommit: selected,
-    });
     if (!detail) {
         const fallbackLines = [
             selected?.message || 'No commit selected.',
@@ -25890,7 +26738,10 @@ function renderHistoryInspector(h, components, state, context, contextStatus, de
         }, h(Text, { bold: true }, panelTitle('Inspector', focused)), ...fallbackLines.map((line, index) => h(Text, {
             key: `detail-${index}`,
             dimColor: index > 1,
-        }, truncate$1(line, width - 4))));
+        }, 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
@@ -25901,18 +26752,26 @@ function renderHistoryInspector(h, components, state, context, contextStatus, de
     const refNodes = detail.refs.length
         ? renderInspectorRefs(h, Text, detail.refs, repository)
         : null;
+    // Inspector reorder (PR — drop duplicative Workflows trailer):
+    //  1. Commit message (the headline of what you're looking at)
+    //  2. Metadata (hash / author / date / refs / stats)
+    //  3. Body preview (up to 8 lines now that the trailer is gone)
+    //  4. Changed files list (cursored entry highlights)
+    //  5. Actions cheat-sheet (per-entity keystrokes; destructive marked)
+    // The Workflows: trailer that used to repeat the repo / branch /
+    // status from the top header and left sidebar is intentionally gone.
     const headerNodes = [
         h(Text, { key: 'detail-msg' }, truncate$1(detail.message, width - 4)),
         h(Text, { key: 'detail-spacer-1' }, ''),
         h(Text, { key: 'detail-commit', dimColor: true }, 'Commit: ', commitLink),
         h(Text, { key: 'detail-author', dimColor: true }, truncate$1(`Author: ${detail.author}`, width - 4)),
-        h(Text, { key: 'detail-date', dimColor: true }, truncate$1(`Date: ${detail.date}`, width - 4)),
+        h(Text, { key: 'detail-date', dimColor: true }, truncate$1(`Date:   ${detail.date}`, width - 4)),
         refNodes
-            ? h(Text, { key: 'detail-refs', dimColor: true }, 'Refs: ', ...refNodes)
-            : h(Text, { key: 'detail-refs', dimColor: true }, 'Refs: none'),
-        h(Text, { key: 'detail-stat', dimColor: true }, truncate$1(statLine, width - 4)),
+            ? h(Text, { key: 'detail-refs', dimColor: true }, 'Refs:   ', ...refNodes)
+            : h(Text, { key: 'detail-refs', dimColor: true }, 'Refs:   none'),
+        h(Text, { key: 'detail-stat', dimColor: true }, truncate$1(`Stats:  ${statLine}`, width - 4)),
         h(Text, { key: 'detail-spacer-2' }, ''),
-        ...(detail.body ? detail.body.split('\n').slice(0, 6) : ['No commit body.']).map((line, index) => h(Text, {
+        ...(detail.body ? detail.body.split('\n').slice(0, 8) : ['No commit body.']).map((line, index) => h(Text, {
             key: `detail-body-${index}`,
             dimColor: true,
         }, truncate$1(line, width - 4))),
@@ -25921,24 +26780,98 @@ function renderHistoryInspector(h, components, state, context, contextStatus, de
     ];
     const fileListMaxRows = Math.max(4, Math.min(detail.files.length, 10));
     const fileListNodes = renderCommitFileList(h, Text, detail.files, state.selectedFileIndex, focused, fileListMaxRows, width, theme);
-    const trailerLines = [
-        '',
-        'Workflows:',
-        ...workflowSections.flatMap((section) => [
-            section.title,
-            ...section.lines.slice(0, 3).map((line) => `  ${line}`),
-        ]).slice(0, 12),
-    ];
+    // 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.
+    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,
+            flexDirection: 'column',
+            width,
+            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, {
+                cursorIndex: state.inspectorActionIndex,
+                cursorActive: focused,
+            })));
+    }
     return h(Box, {
         borderColor: focusBorderColor(theme, focused),
         borderStyle: theme.borderStyle,
         flexDirection: 'column',
         width,
         paddingX: 1,
-    }, h(Text, { bold: true }, panelTitle('Inspector', focused)), ...headerNodes, ...fileListNodes, ...trailerLines.map((line, index) => h(Text, {
-        key: `detail-trailer-${index}`,
-        dimColor: index > 0,
-    }, truncate$1(line, width - 4))));
+    }, h(Text, { bold: true }, panelTitle('Inspector', focused)), ...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
+ * apply to whatever the inspector is focused on. Keys are colored with
+ * `theme.colors.accent` so they pop as the actionable element. Destructive
+ * actions get the danger color plus a `[!]` marker so they don't blend
+ * into the cherry-pick / yank rows.
+ *
+ * Truncates labels when the inspector is narrow (down to the 26-cell
+ * minimum from `getLogInkLayout`) so an overflowing label never wraps and
+ * collides with the next row.
+ */
+function renderInspectorActionsSection(h, Text, context, width, theme, options = {}) {
+    const actions = getInspectorActions(context);
+    if (!actions.length)
+        return [];
+    // Width budget for each row: subtract padding + " " gutter, the key
+    // column (left-padded to 5 cells so labels align), the "  " gap
+    // between key and label, and the optional "  [!]" suffix (5 cells).
+    const KEY_COLUMN = 5;
+    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' }, 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 = [
+                h(Text, {
+                    key: `actions-${index}-key`,
+                    color: action.destructive ? theme.colors.danger : theme.colors.accent,
+                }, keyCell),
+                GAP,
+                label,
+            ];
+            if (action.destructive) {
+                children.push(h(Text, {
+                    key: `actions-${index}-mark`,
+                    color: theme.colors.danger,
+                    dimColor: false,
+                }, DESTRUCTIVE_SUFFIX));
+            }
+            return h(Text, {
+                key: `actions-${index}`,
+                backgroundColor: isSelected && !theme.noColor ? theme.colors.selection : undefined,
+                inverse: isSelected,
+            }, ...children);
+        }),
+    ];
+    return nodes;
 }
 /**
  * Build a commit URL for the repo when GitHub provider info is available.
@@ -26512,7 +27445,7 @@ async function startCocoUiFromLogArgv(logArgv, options = {}) {
     const git = options.git || getRepo();
     const rows = options.rows || (await getLogRows(git, logArgv));
     await startInkInteractiveLog(git, rows, {}, {
-        appLabel: 'coco ui',
+        appLabel: 'coco',
         idleTips: config.logTui?.idleTips,
         initialView: 'history',
         logArgv,
@@ -26525,7 +27458,7 @@ async function startCocoUi(argv) {
     const logArgv = createLogArgvFromUiArgv(argv);
     const rows = await getLogRows(git, logArgv);
     await startInkInteractiveLog(git, rows, {}, {
-        appLabel: 'coco ui',
+        appLabel: 'coco',
         idleTips: config.logTui?.idleTips,
         initialView: argv.view || 'history',
         logArgv,