git-coco 0.38.0 → 0.39.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.39.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 [
         {
@@ -15068,6 +14990,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 +15034,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 +15600,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,
     };
 }
@@ -15927,23 +15916,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';
@@ -16278,6 +16275,7 @@ function createLogInkState(rows, options = {}) {
         userSidebarTab: 'status',
         statusFilterMask: { ...DEFAULT_LOG_INK_STATUS_FILTER_MASK },
         diffViewMode: 'unified',
+        inspectorTab: 'inspector',
     };
 }
 function getSelectedInkCommit(state) {
@@ -16335,6 +16333,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,
@@ -16374,6 +16394,34 @@ 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 'setInspectorTab':
+            return {
+                ...state,
+                inspectorTab: action.value,
+                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,
+                pendingKey: undefined,
+            };
+        }
         case 'moveTag':
             return {
                 ...state,
@@ -17459,6 +17507,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 +17612,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 +17643,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
@@ -18063,6 +18145,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 +18787,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 +18820,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 +20316,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({
@@ -22928,6 +23099,88 @@ function formatPullRequestStateLine(pr) {
     return parts.join(' · ');
 }
 
+/**
+ * Hardcoded per-entity action lists surfaced inside the right-hand
+ * inspector panel. The inspector used to repeat the repo / branch /
+ * status content the top header and left sidebar already show; we drop
+ * that trailer in favor of an actionable cheat-sheet so the user knows
+ * exactly which keystrokes apply to whatever they have under the cursor.
+ *
+ * Why hardcoded instead of introspecting `LOG_INK_KEY_BINDINGS`:
+ *   - Most per-entity actions live in `inkInput.ts` as direct keystroke
+ *     handlers (e.g. `c` cherry-pick, `R` revert) rather than as
+ *     globally-registered bindings, so the registry would be a partial
+ *     view at best.
+ *   - The bindings registry's `contexts` model (normal / search / focus
+ *     name) does not cleanly map to inspector entity types like "branch"
+ *     or "tag". Filtering it would mean replicating the same per-view
+ *     scoping logic the input dispatcher already encodes.
+ *   - New per-entity actions are added infrequently — the maintenance
+ *     cost of mirroring them here is low and keeps this file the single
+ *     source of truth for "what shows in the inspector".
+ *
+ * If you wire up a new per-entity keystroke in `inkInput.ts` — for
+ * example a "create branch from this commit" or "create tag from this
+ * commit" action — add the matching row to the relevant array below so
+ * it shows up in the inspector automatically.
+ */
+const HISTORY_COMMIT_ACTIONS = [
+    { key: 'enter', label: 'Open diff' },
+    { key: 'c', label: 'Cherry-pick' },
+    { key: 'R', label: 'Revert', destructive: true },
+    { key: 'Z', label: 'Reset to commit', destructive: true },
+    { key: 'i', label: 'Interactive rebase', destructive: true },
+    { key: 'y', label: 'Yank hash' },
+    { key: 'Y', label: 'Yank short hash' },
+    { key: 'O', label: 'Open in browser' },
+];
+const BRANCH_ACTIONS = [
+    { key: 'enter', label: 'Checkout' },
+    { key: '+', label: 'New branch' },
+    { key: 'R', label: 'Rename' },
+    { key: 'u', label: 'Set upstream' },
+    { key: 'D', label: 'Delete', destructive: true },
+    { key: 'P', label: 'Push current' },
+    { key: 'F', label: 'Fetch all' },
+    { key: 'y', label: 'Yank name' },
+];
+const TAG_ACTIONS = [
+    { key: '+', label: 'New tag' },
+    { key: 'P', label: 'Push tag' },
+    { key: 'T', label: 'Delete', destructive: true },
+    { key: 'R', label: 'Delete remote', destructive: true },
+    { key: 'y', label: 'Yank name' },
+];
+const STASH_ACTIONS = [
+    { key: 'enter', label: 'Open diff' },
+    { key: 'a', label: 'Apply' },
+    { key: 'p', label: 'Pop' },
+    { key: 'X', label: 'Drop', destructive: true },
+    { key: 'y', label: 'Yank ref' },
+];
+const WORKTREE_ACTIONS = [
+    { key: 'W', label: 'Remove', destructive: true },
+    { key: 'y', label: 'Yank path' },
+];
+function getInspectorActions(context) {
+    switch (context) {
+        case 'history-commit':
+            return HISTORY_COMMIT_ACTIONS;
+        case 'branch':
+            return BRANCH_ACTIONS;
+        case 'tag':
+            return TAG_ACTIONS;
+        case 'stash':
+            return STASH_ACTIONS;
+        case 'worktree':
+            return WORKTREE_ACTIONS;
+        default: {
+            const exhaustive = context;
+            throw new Error(`Unhandled inspector action context: ${String(exhaustive)}`);
+        }
+    }
+}
+
 function sectionLines(title, diff) {
     const lines = diff.split('\n').map((line) => line.trimEnd());
     return [
@@ -23727,6 +23980,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 +24429,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 +24505,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 });
@@ -24241,9 +24603,21 @@ 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]);
@@ -24725,6 +25099,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 +25114,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,7 +25167,7 @@ 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();
@@ -24816,7 +25191,7 @@ function renderSidebar(h, components, state, context, contextStatus, width, them
             dimColor: !isActive,
         }, 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 +25210,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);
     }
@@ -24860,7 +25243,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 +25254,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 +25264,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 +25278,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 +25287,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, {
@@ -25808,7 +26191,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 +26248,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 +26268,7 @@ 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));
     }
     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 +26279,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 +26307,85 @@ 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)));
+    }
     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));
+}
+/**
+ * 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) {
+    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 nodes = [
+        h(Text, { key: 'actions-spacer' }, ''),
+        h(Text, { key: 'actions-title' }, 'Actions:'),
+        ...actions.map((action, index) => {
+            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}` }, ...children);
+        }),
+    ];
+    return nodes;
 }
 /**
  * Build a commit URL for the repo when GitHub provider info is available.
@@ -26512,7 +26959,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 +26972,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,