git-coco 0.35.0 → 0.36.0

package/dist/index.esm.mjs

@@ -37,9 +37,11 @@ import '@langchain/core/utils/env';
 import '@langchain/core/utils/async_caller';
 import { encoding_for_model } from 'tiktoken';
 import { spawn, exec, execFile } from 'child_process';
+import { spawnSync } from 'node:child_process';
 import * as fs$1 from 'node:fs';
 import * as os$1 from 'node:os';
 import * as path$1 from 'node:path';
+import * as crypto from 'node:crypto';
 import * as readline from 'readline';
 import readline__default from 'readline';
 import { promisify } from 'util';
@@ -50,7 +52,7 @@ import { pathToFileURL } from 'url';
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.35.0";
+const BUILD_VERSION = "0.36.0";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -13890,13 +13892,18 @@ function applyCommitComposeAction(state, action) {
                 loading: action.value,
             };
         case 'setDraft':
+            // No `message` here — the loader → filled fields are the confirmation
+            // that the AI generated something. A lingering "AI draft ready for
+            // editing" line in the panel reads as stale state. The runtime still
+            // posts the same string to the footer status line for transient
+            // feedback.
             return {
                 ...state,
                 ...splitCommitDraft(action.value),
                 field: 'summary',
                 editing: true,
                 loading: false,
-                message: 'AI draft ready for editing',
+                message: undefined,
                 details: undefined,
             };
         case 'setResult':
@@ -14528,6 +14535,85 @@ function getLogInkWorkflowActions() {
             kind: 'normal',
             requiresConfirmation: false,
         },
+        {
+            // Per-view-only: scoped to the history view in inkInput so `c`
+            // doesn't fire elsewhere. Empty key keeps it palette-discoverable
+            // without registering a global hotkey.
+            id: 'cherry-pick-commit',
+            key: '',
+            label: 'Cherry-pick commit',
+            description: 'Apply the selected commit on top of the current branch (after confirmation).',
+            kind: 'destructive',
+            requiresConfirmation: true,
+        },
+        {
+            // Per-view-only: scoped to the commit-diff explore in inkInput.
+            // Routed through the y-confirm path because `git checkout <sha> --
+            // <path>` overwrites the worktree file unconditionally and we
+            // want the user to acknowledge that before discarding any local
+            // edits to the path.
+            id: 'checkout-file-from-commit',
+            key: '',
+            label: 'Cherry-pick file from commit',
+            description: 'Materialize the selected file from this commit into the working tree (after confirmation).',
+            kind: 'destructive',
+            requiresConfirmation: true,
+        },
+        {
+            // Per-view-only: scoped to the stash-diff explorer in inkInput.
+            // Same overwrite rationale as `checkout-file-from-commit` — the
+            // y-confirm path is the dirty-tree warning.
+            id: 'checkout-file-from-stash',
+            key: '',
+            label: 'Cherry-pick file from stash',
+            description: 'Materialize the selected file from this stash into the working tree (after confirmation).',
+            kind: 'destructive',
+            requiresConfirmation: true,
+        },
+        {
+            id: 'open-pr',
+            key: 'O',
+            label: 'Open PR / repo',
+            description: 'Open the current branch\'s pull request in the browser, or the repo page if there\'s no PR.',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
+        {
+            id: 'fetch-remotes',
+            key: 'F',
+            label: 'Fetch all remotes',
+            description: 'Run `git fetch --all --prune` and silently refresh context.',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
+        {
+            id: 'pull-current-branch',
+            key: 'U',
+            label: 'Pull current branch',
+            description: 'Run `git pull --ff-only` against the current branch.',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
+        {
+            id: 'push-current-branch',
+            key: 'P',
+            label: 'Push current branch',
+            description: 'Run `git push` for the current branch.',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
+        {
+            // Per-view-only — the inkInput handler scopes this to the tags
+            // surface so we don't expose `R` as a remote-delete from elsewhere.
+            // The empty `key` keeps the workflow palette-discoverable but does
+            // not register a global hotkey.
+            id: 'delete-remote-tag',
+            key: '',
+            label: 'Delete remote tag',
+            description: 'Push :tag to origin to delete the selected tag remotely after confirmation.',
+            kind: 'destructive',
+            requiresConfirmation: true,
+        },
         {
             id: 'stage-file',
             key: 'space',
@@ -14775,6 +14861,13 @@ const LOG_INK_KEY_BINDINGS = [
         description: 'Push the stash view (gz; gs is reserved for status).',
         contexts: ['normal'],
     },
+    {
+        id: 'navigateWorktrees',
+        keys: ['gw'],
+        label: 'worktrees',
+        description: 'Push the linked worktrees view.',
+        contexts: ['normal'],
+    },
     {
         id: 'navigateBack',
         keys: ['<', 'esc'],
@@ -14895,6 +14988,7 @@ const GLOBAL_BINDING_IDS = [
     'navigateBranches',
     'navigateTags',
     'navigateStash',
+    'navigateWorktrees',
     'navigateBack',
 ];
 const NORMAL_GLOBAL_HINTS = ['g jump', '< back', '? help', ': cmds', 'q quit'];
@@ -14973,37 +15067,57 @@ function getLogInkFooterHints(options) {
         };
     }
     if (options.activeView === 'diff') {
+        if (options.diffSource === 'stash') {
+            return {
+                contextual: ['j/k lines', '[/] file', 'c cherry-pick', 'o edit', 'esc back'],
+                global: NORMAL_GLOBAL_HINTS,
+            };
+        }
+        if (options.diffSource === 'commit') {
+            // Commit-diff explore: read-only diff, but `c` cherry-picks the
+            // cursored file from the commit into the worktree.
+            return {
+                contextual: ['j/k hunks', '[/] file', 'c cherry-pick', 'esc back'],
+                global: NORMAL_GLOBAL_HINTS,
+            };
+        }
         return {
-            contextual: ['j/k hunks', 'space stage', 'z revert', 'e/c compose', 'esc files'],
+            contextual: ['j/k hunks', 'space stage', 'z revert', 'o edit', 'e/c compose', 'esc files'],
             global: NORMAL_GLOBAL_HINTS,
         };
     }
     if (options.activeView === 'compose') {
         return {
-            contextual: ['e edit', 'tab field', 'c commit', 'I AI draft', 'esc back'],
+            contextual: ['e edit', 'c commit', 'I AI draft', 'gs hunks', 'esc back'],
             global: NORMAL_GLOBAL_HINTS,
         };
     }
     if (options.activeView === 'branches') {
         return {
-            contextual: ['↑/↓ branches', 's sort', 'D delete', 'X checkout', 'enter diff'],
+            contextual: ['↑/↓ branches', 'enter checkout', '+ new', 'D delete', 's sort'],
             global: NORMAL_GLOBAL_HINTS,
         };
     }
     if (options.activeView === 'tags') {
         return {
-            contextual: ['↑/↓ tags', 's sort', 'T create', 'X push', 'esc back'],
+            contextual: ['↑/↓ tags', '+ new', 'P push', 'T delete', 's sort'],
             global: NORMAL_GLOBAL_HINTS,
         };
     }
     if (options.activeView === 'stash') {
         return {
-            contextual: ['↑/↓ stashes', 'A apply', 'D drop', 'esc back'],
+            contextual: ['↑/↓ stashes', 'enter diff', 'a apply', 'p pop', 'X drop'],
+            global: NORMAL_GLOBAL_HINTS,
+        };
+    }
+    if (options.activeView === 'worktrees') {
+        return {
+            contextual: ['↑/↓ worktrees', 'W remove', 'esc back'],
             global: NORMAL_GLOBAL_HINTS,
         };
     }
     return {
-        contextual: ['↑/↓ move', '/ search', 'gg/G top/bottom', 'n/N next'],
+        contextual: ['↑/↓ move', 'enter diff', 'c cherry-pick', '/ search', 'gg/G top/bottom'],
         global: NORMAL_GLOBAL_HINTS,
     };
 }
@@ -15266,10 +15380,12 @@ function getLogInkPaletteExecuteEvents(command, state) {
         if (command.requiresConfirmation) {
             return [action({ type: 'setPendingConfirmation', value: command.id })];
         }
-        return [
-            action({ type: 'setWorkflowAction', value: command.id }),
-            action({ type: 'setStatus', value: `${command.label} selected` }),
-        ];
+        // Non-confirm workflows are dispatched directly through the runtime
+        // workflow runner — same path the keyboard takes. Previously this
+        // emitted `setWorkflowAction` only, which set state but never fired
+        // the action because nothing in the runtime consumes
+        // `workflowActionId`.
+        return [{ type: 'runWorkflowAction', id: command.id }];
     }
     // Binding-derived commands. Map each LogInkCommandId to the same events
     // the keystroke would emit. Order matches the keymap registry.
@@ -15331,6 +15447,8 @@ function getLogInkPaletteExecuteEvents(command, state) {
             return [action({ type: 'pushView', value: 'tags' })];
         case 'navigateStash':
             return [action({ type: 'pushView', value: 'stash' })];
+        case 'navigateWorktrees':
+            return [action({ type: 'pushView', value: 'worktrees' })];
         case 'navigateBack':
             return [action({ type: 'popView' })];
         case 'openSelected': {
@@ -15429,6 +15547,39 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         }
         return [{ type: 'exit' }];
     }
+    // Input prompt is the most modal — when active, every keystroke routes
+    // into the prompt until Enter (submit) or Esc (cancel). Sits above the
+    // filter/confirmation/compose handlers so a prompt opened from inside
+    // any of those still captures focus cleanly.
+    if (state.inputPrompt) {
+        if (key.escape) {
+            return [
+                action({ type: 'closeInputPrompt' }),
+                action({ type: 'setStatus', value: 'cancelled' }),
+            ];
+        }
+        if (key.return) {
+            const value = state.inputPrompt.value.trim();
+            if (!value) {
+                return [action({ type: 'setStatus', value: 'enter a value or press esc to cancel' })];
+            }
+            const id = state.inputPrompt.kind;
+            return [
+                { type: 'runWorkflowAction', id, payload: value },
+                action({ type: 'closeInputPrompt' }),
+            ];
+        }
+        if (key.backspace || key.delete) {
+            return [action({ type: 'backspaceInputPrompt' })];
+        }
+        if (key.ctrl && inputValue === 'u') {
+            return [action({ type: 'clearInputPromptText' })];
+        }
+        if (inputValue && !key.ctrl && !key.meta) {
+            return [action({ type: 'appendInputPrompt', value: inputValue })];
+        }
+        return [];
+    }
     if (state.commitCompose.editing) {
         if (key.escape) {
             return [action({ type: 'commitCompose', action: { type: 'setEditing', value: false } })];
@@ -15497,7 +15648,7 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
             // selected item and run the right action function.
             if (workflowAction) {
                 return [
-                    { type: 'runWorkflowAction', id: workflowAction.id },
+                    { type: 'runWorkflowAction', id: workflowAction.id, payload: state.pendingConfirmationPayload },
                     action({ type: 'setPendingConfirmation', value: undefined }),
                 ];
             }
@@ -15647,6 +15798,12 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
             action({ type: 'setStatus', value: 'jumped to stash' }),
         ];
     }
+    if (state.pendingKey === 'g' && inputValue === 'w') {
+        return [
+            action({ type: 'pushView', value: 'worktrees' }),
+            action({ type: 'setStatus', value: 'jumped to worktrees' }),
+        ];
+    }
     if (inputValue === 'g') {
         if (state.pendingKey === 'g') {
             return [
@@ -15698,6 +15855,13 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
                     hunkOffsets: context.worktreeHunkOffsets,
                 })];
         }
+        if (state.activeView === 'diff' && state.diffSource === 'stash' && context.stashDiffFileOffsets?.length) {
+            return [action({
+                    type: 'jumpCommitDiffHunk',
+                    delta: -1,
+                    hunkOffsets: context.stashDiffFileOffsets,
+                })];
+        }
         if (state.activeView === 'diff' && context.commitDiffHunkOffsets?.length) {
             return [action({
                     type: 'jumpCommitDiffHunk',
@@ -15715,6 +15879,13 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
                     hunkOffsets: context.worktreeHunkOffsets,
                 })];
         }
+        if (state.activeView === 'diff' && state.diffSource === 'stash' && context.stashDiffFileOffsets?.length) {
+            return [action({
+                    type: 'jumpCommitDiffHunk',
+                    delta: 1,
+                    hunkOffsets: context.stashDiffFileOffsets,
+                })];
+        }
         if (state.activeView === 'diff' && context.commitDiffHunkOffsets?.length) {
             return [action({
                     type: 'jumpCommitDiffHunk',
@@ -15768,6 +15939,9 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         if (state.activeView === 'stash' && context.stashCount) {
             return [action({ type: 'moveStash', delta: -1, count: context.stashCount })];
         }
+        if (state.activeView === 'worktrees' && context.worktreeListCount) {
+            return [action({ type: 'moveWorktreeListEntry', delta: -1, count: context.worktreeListCount })];
+        }
         if (state.activeView === 'history' &&
             state.focus === 'commits' &&
             state.selectedIndex === 0 &&
@@ -15818,6 +15992,9 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         if (state.activeView === 'stash' && context.stashCount) {
             return [action({ type: 'moveStash', delta: 1, count: context.stashCount })];
         }
+        if (state.activeView === 'worktrees' && context.worktreeListCount) {
+            return [action({ type: 'moveWorktreeListEntry', delta: 1, count: context.worktreeListCount })];
+        }
         return [
             action(state.focus === 'sidebar'
                 ? { type: 'nextSidebarTab' }
@@ -15918,12 +16095,183 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
                 })];
         }
     }
-    if (key.return && state.activeView === 'status' && context.worktreeFileCount) {
+    // Enter on a sidebar tab drills into the corresponding promoted view
+    // (status / branches / tags / stash). Sits above the per-view Enter
+    // handlers so a sidebar-focused Enter never fires checkout-branch /
+    // navigateOpenDiffForCommit / etc. against the (hidden) selection in
+    // the active tab.
+    //
+    // The Enter also moves focus out of the sidebar into the newly opened
+    // list — otherwise ↑/↓ keep cycling sidebar tabs instead of navigating
+    // inside the just-opened view, which made the drill-in feel half-done.
+    if (key.return && state.focus === 'sidebar') {
+        const tabToView = {
+            status: 'status',
+            branches: 'branches',
+            tags: 'tags',
+            stashes: 'stash',
+            worktrees: 'worktrees',
+        };
+        const target = tabToView[state.sidebarTab];
+        if (target) {
+            return [
+                action({ type: 'pushView', value: target }),
+                action({ type: 'setFocus', value: 'commits' }),
+            ];
+        }
+        return [action({ type: 'setStatus', value: 'no detail view for this tab' })];
+    }
+    if (key.return && state.activeView === 'status' && state.focus === 'commits' && context.worktreeFileCount) {
         return [action({
                 type: 'navigateOpenDiffForWorktreeFile',
                 fileIndex: state.selectedWorktreeFileIndex,
             })];
     }
+    // Enter on a branch row checks the branch out. Non-destructive workflow
+    // action — no confirmation prompt.
+    if (key.return && state.activeView === 'branches' && state.focus === 'commits' && context.branchCount) {
+        return [{ type: 'runWorkflowAction', id: 'checkout-branch' }];
+    }
+    // `+` opens a create-branch / create-tag prompt depending on context.
+    // Works from either the matching promoted view (active branches /
+    // tags surface) or from the sidebar when the corresponding tab is
+    // active — saves a drill-in for "I just want to make a new branch".
+    const wantsCreateBranch = inputValue === '+' && (state.activeView === 'branches' ||
+        (state.focus === 'sidebar' && state.sidebarTab === 'branches'));
+    const wantsCreateTag = inputValue === '+' && (state.activeView === 'tags' ||
+        (state.focus === 'sidebar' && state.sidebarTab === 'tags'));
+    if (wantsCreateBranch) {
+        return [action({
+                type: 'openInputPrompt',
+                kind: 'create-branch',
+                label: 'New branch name',
+            })];
+    }
+    if (wantsCreateTag) {
+        return [action({
+                type: 'openInputPrompt',
+                kind: 'create-tag',
+                label: 'New tag name',
+            })];
+    }
+    // Per-view stash actions: `a` apply (keep the stash), `p` pop (apply
+    // then drop). Drop is the existing destructive `X` workflow which
+    // routes through the y-confirm path. Scoped to the stash view so the
+    // letters stay free elsewhere.
+    if (inputValue === 'a' && state.activeView === 'stash' && context.stashCount) {
+        return [{ type: 'runWorkflowAction', id: 'apply-stash' }];
+    }
+    if (inputValue === 'p' && state.activeView === 'stash' && context.stashCount) {
+        return [{ type: 'runWorkflowAction', id: 'pop-stash' }];
+    }
+    // Per-view tag action: `P` pushes the selected tag to origin. Letter
+    // is scoped to the tags surface so it doesn't collide with `p` for
+    // pop-stash. Note: this also takes precedence over the global
+    // push-current-branch workflow's `P` key.
+    if (inputValue === 'P' && state.activeView === 'tags' && context.tagCount) {
+        return [{ type: 'runWorkflowAction', id: 'push-tag' }];
+    }
+    // Per-view branches actions: `R` renames the selected branch, `u`
+    // sets its upstream. Both open the input prompt so the user can type
+    // the new value. Pre-fills are handled by the prompt's `initial`.
+    if (inputValue === 'R' && state.activeView === 'branches' && context.branchCount) {
+        return [action({
+                type: 'openInputPrompt',
+                kind: 'rename-branch',
+                label: 'Rename branch to',
+            })];
+    }
+    if (inputValue === 'u' && state.activeView === 'branches' && context.branchCount) {
+        return [action({
+                type: 'openInputPrompt',
+                kind: 'set-upstream',
+                label: 'Upstream ref (e.g. origin/main)',
+            })];
+    }
+    // Per-view tag action: `R` deletes the tag from the remote (after
+    // confirmation). Scoped per-view so this letter is free elsewhere
+    // (especially the `R` rename binding on the branches view).
+    if (inputValue === 'R' && state.activeView === 'tags' && context.tagCount) {
+        return [action({ type: 'setPendingConfirmation', value: 'delete-remote-tag' })];
+    }
+    // Global stash hotkey: `S` opens a stash-message prompt and
+    // `createStash` runs once submitted. Available everywhere there's
+    // not a more modal handler in front of it.
+    if (inputValue === 'S') {
+        return [action({
+                type: 'openInputPrompt',
+                kind: 'create-stash',
+                label: 'Stash message',
+            })];
+    }
+    // `o` opens the file under the cursor in $EDITOR. Available on the
+    // status surface (worktree files), the worktree diff (the file being
+    // diffed), and the stash diff (the file the cursor sits in inside
+    // the patch). The runtime suspends Ink, spawns the editor sync, then
+    // re-renders.
+    if (inputValue === 'o' && state.activeView === 'status' && context.worktreeFileCount && context.worktreeSelectedPath) {
+        return [{ type: 'openFileInEditor', path: context.worktreeSelectedPath }];
+    }
+    if (inputValue === 'o' && state.activeView === 'diff' && state.diffSource === 'worktree' && context.worktreeSelectedPath) {
+        return [{ type: 'openFileInEditor', path: context.worktreeSelectedPath }];
+    }
+    if (inputValue === 'o' && state.activeView === 'diff' && state.diffSource === 'stash' && context.stashDiffSelectedPath) {
+        return [{ type: 'openFileInEditor', path: context.stashDiffSelectedPath }];
+    }
+    // `c` on a stash diff cherry-picks the file under the cursor —
+    // materializes that single path from the stash into the working tree
+    // (`git checkout <stashRef> -- <path>`). Routed through the y-confirm
+    // path because the checkout overwrites the worktree file
+    // unconditionally; the prompt is the user's chance to abort if they
+    // have unsaved edits at that path.
+    if (inputValue === 'c' &&
+        state.activeView === 'diff' &&
+        state.diffSource === 'stash' &&
+        context.stashDiffSelectedPath &&
+        state.stashDiffRef) {
+        return [action({
+                type: 'setPendingConfirmation',
+                value: 'checkout-file-from-stash',
+                payload: context.stashDiffSelectedPath,
+            })];
+    }
+    // `c` on a commit-diff explore cherry-picks the cursored file from
+    // that historical commit — `git checkout <sha> -- <path>`. Same
+    // confirmation rationale as the stash variant. The payload encodes
+    // both the sha and the path so the runtime handler doesn't have to
+    // re-resolve either.
+    if (inputValue === 'c' &&
+        state.activeView === 'diff' &&
+        state.diffSource === 'commit' &&
+        context.commitDiffSelectedPath &&
+        context.commitDiffSelectedSha) {
+        return [action({
+                type: 'setPendingConfirmation',
+                value: 'checkout-file-from-commit',
+                payload: `${context.commitDiffSelectedSha} ${context.commitDiffSelectedPath}`,
+            })];
+    }
+    // `c` on the history view cherry-picks the full selected commit on
+    // top of the current branch. Routed through the y-confirm flow since
+    // it can produce conflicts and is a real working-tree mutation.
+    if (inputValue === 'c' &&
+        state.activeView === 'history' &&
+        state.focus === 'commits' &&
+        state.filteredCommits.length > 0 &&
+        !state.pendingCommitFocused) {
+        return [action({ type: 'setPendingConfirmation', value: 'cherry-pick-commit' })];
+    }
+    // Enter on a stash row pushes the diff view scoped to that stash.
+    // The runtime loads `git stash show -p <ref>` once the view is
+    // active. The stash ref is passed via the action so we don't need a
+    // context lookup here.
+    if (key.return && state.activeView === 'stash' && state.focus === 'commits' && context.stashCount && context.stashSelectedRef) {
+        return [action({
+                type: 'navigateOpenDiffForStash',
+                ref: context.stashSelectedRef,
+                stashIndex: state.selectedStashIndex,
+            })];
+    }
     if (inputValue === ' ' && state.activeView === 'status' && context.worktreeFileCount) {
         return [{ type: 'toggleSelectedFileStage' }];
     }
@@ -15959,10 +16307,10 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         return [action({ type: 'setPendingConfirmation', value: workflowAction.id })];
     }
     if (workflowAction) {
-        return [
-            action({ type: 'setWorkflowAction', value: workflowAction.id }),
-            action({ type: 'setStatus', value: `${workflowAction.label} selected` }),
-        ];
+        // Non-destructive workflow — fire it directly via the runtime
+        // handler. The handler surfaces success/failure on the status line
+        // and silently refreshes context so the list updates.
+        return [{ type: 'runWorkflowAction', id: workflowAction.id }];
     }
     return [];
 }
@@ -15978,7 +16326,7 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
  * fall back to "already seen" so we never block startup.
  */
 const MARKER_BASENAME = 'onboarding.seen';
-function resolveCacheDir() {
+function resolveCacheDir$1() {
     const xdg = process.env.XDG_CACHE_HOME;
     if (xdg && xdg.trim().length > 0) {
         return path$1.join(xdg, 'coco');
@@ -15986,7 +16334,7 @@ function resolveCacheDir() {
     return path$1.join(os$1.homedir(), '.cache', 'coco');
 }
 function getOnboardingMarkerPath() {
-    return path$1.join(resolveCacheDir(), MARKER_BASENAME);
+    return path$1.join(resolveCacheDir$1(), MARKER_BASENAME);
 }
 function hasSeenOnboarding() {
     try {
@@ -16010,6 +16358,65 @@ function markOnboardingSeen() {
     }
 }
 
+/**
+ * Persist which sidebar tab the user last had active, keyed per repo so
+ * switching projects doesn't reset every other repo's preference. The
+ * cache lives next to the onboarding marker (XDG-friendly) and is
+ * best-effort: read/write failures fall back to the default sidebar
+ * tab on next start.
+ *
+ * Repos are keyed by a short hash of their absolute path — no PII in
+ * the cache filename, and re-creating a repo at the same path keeps
+ * the same preference.
+ */
+const VALID_TABS = [
+    'status',
+    'branches',
+    'tags',
+    'stashes',
+    'worktrees',
+];
+function resolveCacheDir() {
+    const xdg = process.env.XDG_CACHE_HOME;
+    if (xdg && xdg.trim().length > 0) {
+        return path$1.join(xdg, 'coco');
+    }
+    return path$1.join(os$1.homedir(), '.cache', 'coco');
+}
+function repoKey(repoPath) {
+    // sha1 is used here as a non-security cache-key derivation — we just
+    // need a deterministic short identifier for the marker filename so
+    // re-creating a repo at the same path keeps the same preference.
+    // No PII or auth context is hashed; no collision-resistance against
+    // an adversary is required. DevSkim DS126858 doesn't apply.
+    // DevSkim: ignore DS126858
+    return crypto.createHash('sha1').update(repoPath).digest('hex').slice(0, 16);
+}
+function getSidebarTabMarkerPath(repoPath) {
+    return path$1.join(resolveCacheDir(), `sidebar-tab.${repoKey(repoPath)}`);
+}
+function getSavedSidebarTab(repoPath) {
+    try {
+        const raw = fs$1.readFileSync(getSidebarTabMarkerPath(repoPath), 'utf8').trim();
+        return VALID_TABS.includes(raw)
+            ? raw
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function saveSidebarTab(repoPath, tab) {
+    const marker = getSidebarTabMarkerPath(repoPath);
+    try {
+        fs$1.mkdirSync(path$1.dirname(marker), { recursive: true });
+        fs$1.writeFileSync(marker, tab);
+    }
+    catch {
+        // Best-effort persistence; swallow.
+    }
+}
+
 /**
  * Promoted-view selection rectification on filter changes (P4.5).
  *
@@ -16263,7 +16670,12 @@ 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)));
-    const sidebarWidth = Math.max(22, Math.min(34, Math.floor(columns * 0.24)));
+    // 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.
+    const sidebarWidth = input.sidebarFocused
+        ? Math.max(32, Math.min(50, Math.floor(columns * 0.36)))
+        : Math.max(22, Math.min(34, Math.floor(columns * 0.24)));
     return {
         bodyRows: Math.max(8, rows - 5),
         columns,
@@ -17003,9 +17415,19 @@ function withPushedView(state, value) {
         ...state,
         activeView: value,
         viewStack,
+        // The compose + status views' right detail panels already show
+        // worktree info, so keeping the left sidebar on the Status tab
+        // duplicates that information. Auto-switch to Branches when entering
+        // either view; the user can swap back with [/] if they want.
+        //
+        // We update only the rendered `sidebarTab` here, never
+        // `userSidebarTab`, so this auto-switch is invisible to per-repo
+        // persistence and pop-view restores the previous tab.
+        sidebarTab: value === 'compose' || value === 'status' ? 'branches' : state.sidebarTab,
         worktreeDiffOffset: value === 'diff' ? state.worktreeDiffOffset : 0,
         selectedWorktreeHunkIndex: value === 'diff' ? state.selectedWorktreeHunkIndex : 0,
         diffSource: value === 'diff' ? state.diffSource : undefined,
+        stashDiffRef: value === 'diff' ? state.stashDiffRef : undefined,
         pendingCommitFocused: value === 'history' ? state.pendingCommitFocused : false,
         pendingKey: undefined,
     };
@@ -17020,9 +17442,14 @@ function withPoppedView(state) {
         ...state,
         activeView: next,
         viewStack,
+        // Restore the user's last explicit tab choice so popping out of
+        // compose / status (which auto-switch the sidebar to Branches)
+        // returns the user to whatever they actually had open before.
+        sidebarTab: state.userSidebarTab,
         worktreeDiffOffset: next === 'diff' ? state.worktreeDiffOffset : 0,
         selectedWorktreeHunkIndex: next === 'diff' ? state.selectedWorktreeHunkIndex : 0,
         diffSource: next === 'diff' ? state.diffSource : undefined,
+        stashDiffRef: next === 'diff' ? state.stashDiffRef : undefined,
         pendingCommitFocused: next === 'history' ? state.pendingCommitFocused : false,
         pendingKey: undefined,
     };
@@ -17039,6 +17466,7 @@ function withReplacedView(state, value) {
         worktreeDiffOffset: value === 'diff' ? state.worktreeDiffOffset : 0,
         selectedWorktreeHunkIndex: value === 'diff' ? state.selectedWorktreeHunkIndex : 0,
         diffSource: value === 'diff' ? state.diffSource : undefined,
+        stashDiffRef: value === 'diff' ? state.stashDiffRef : undefined,
         pendingCommitFocused: value === 'history' ? state.pendingCommitFocused : false,
         pendingKey: undefined,
     };
@@ -17131,6 +17559,7 @@ function createLogInkState(rows, options = {}) {
         selectedBranchIndex: 0,
         selectedTagIndex: 0,
         selectedStashIndex: 0,
+        selectedWorktreeListIndex: 0,
         branchSort: DEFAULT_BRANCH_SORT_MODE,
         tagSort: DEFAULT_TAG_SORT_MODE,
         paletteFilter: '',
@@ -17146,10 +17575,12 @@ function createLogInkState(rows, options = {}) {
         showCommandPalette: false,
         workflowActionId: undefined,
         pendingConfirmationId: undefined,
+        pendingConfirmationPayload: undefined,
         pendingMutationConfirmation: undefined,
         pendingKey: undefined,
         focus: 'commits',
         sidebarTab: 'status',
+        userSidebarTab: 'status',
     };
 }
 function getSelectedInkCommit(state) {
@@ -17256,6 +17687,12 @@ function applyLogInkAction(state, action) {
                 selectedStashIndex: clampIndex$1(state.selectedStashIndex + action.delta, action.count),
                 pendingKey: undefined,
             };
+        case 'moveWorktreeListEntry':
+            return {
+                ...state,
+                selectedWorktreeListIndex: clampIndex$1(state.selectedWorktreeListIndex + action.delta, action.count),
+                pendingKey: undefined,
+            };
         case 'cycleBranchSort':
             return {
                 ...state,
@@ -17272,6 +17709,30 @@ function applyLogInkAction(state, action) {
                 selectedTagIndex: 0,
                 pendingKey: undefined,
             };
+        case 'openInputPrompt':
+            return {
+                ...state,
+                inputPrompt: {
+                    kind: action.kind,
+                    label: action.label,
+                    value: action.initial || '',
+                },
+                pendingKey: undefined,
+            };
+        case 'appendInputPrompt':
+            return state.inputPrompt
+                ? { ...state, inputPrompt: { ...state.inputPrompt, value: `${state.inputPrompt.value}${action.value}` } }
+                : state;
+        case 'backspaceInputPrompt':
+            return state.inputPrompt
+                ? { ...state, inputPrompt: { ...state.inputPrompt, value: state.inputPrompt.value.slice(0, -1) } }
+                : state;
+        case 'clearInputPromptText':
+            return state.inputPrompt
+                ? { ...state, inputPrompt: { ...state.inputPrompt, value: '' } }
+                : state;
+        case 'closeInputPrompt':
+            return { ...state, inputPrompt: undefined, pendingKey: undefined };
         case 'moveToBottom':
             return {
                 ...state,
@@ -17290,12 +17751,15 @@ function applyLogInkAction(state, action) {
                 pendingCommitFocused: false,
                 pendingKey: undefined,
             };
-        case 'nextSidebarTab':
+        case 'nextSidebarTab': {
+            const next = cycleValue(SIDEBAR_TABS, state.sidebarTab, 1);
             return {
                 ...state,
-                sidebarTab: cycleValue(SIDEBAR_TABS, state.sidebarTab, 1),
+                sidebarTab: next,
+                userSidebarTab: next,
                 pendingKey: undefined,
             };
+        }
         case 'page':
             return {
                 ...state,
@@ -17329,12 +17793,15 @@ function applyLogInkAction(state, action) {
                 diffPreviewOffset: nextHunkOffset(state.diffPreviewOffset, action.hunkOffsets, action.delta),
                 pendingKey: undefined,
             };
-        case 'previousSidebarTab':
+        case 'previousSidebarTab': {
+            const previous = cycleValue(SIDEBAR_TABS, state.sidebarTab, -1);
             return {
                 ...state,
-                sidebarTab: cycleValue(SIDEBAR_TABS, state.sidebarTab, -1),
+                sidebarTab: previous,
+                userSidebarTab: previous,
                 pendingKey: undefined,
             };
+        }
         case 'setFilter':
             return withFilter$1(state, action.value, action.promotedSelections);
         case 'setActiveView':
@@ -17382,6 +17849,21 @@ function applyLogInkAction(state, action) {
                 diffSource: 'worktree',
             };
         }
+        case 'navigateOpenDiffForStash': {
+            const next = withPushedView(state, 'diff');
+            return {
+                ...next,
+                diffSource: 'stash',
+                stashDiffRef: action.ref,
+                selectedStashIndex: Math.max(0, action.stashIndex ?? state.selectedStashIndex),
+                // Reset the diff scroll offset so the stash patch always opens
+                // at the top, mirroring `navigateOpenDiffForCommit`. Without
+                // this, opening a stash inherits whatever offset the previous
+                // diff had, landing the user mid-patch.
+                diffPreviewOffset: 0,
+                worktreeDiffOffset: 0,
+            };
+        }
         case 'navigateOpenComposeForFile': {
             const next = withPushedView(state, 'status');
             return {
@@ -17406,9 +17888,22 @@ function applyLogInkAction(state, action) {
             return {
                 ...state,
                 sidebarTab: action.value,
+                userSidebarTab: action.value,
                 focus: 'sidebar',
                 pendingKey: undefined,
             };
+        case 'restoreSidebarTab':
+            // Mount-time restore from per-repo persistence (#21). Updates the
+            // tab + the user-choice mirror without forcing focus into the
+            // sidebar — that's the focus-steal regression flagged in the PR
+            // review. Users land on commits as usual; their saved tab is
+            // visible in the sidebar but doesn't grab the cursor.
+            return {
+                ...state,
+                sidebarTab: action.value,
+                userSidebarTab: action.value,
+                pendingKey: undefined,
+            };
         case 'setStatus':
             return {
                 ...state,
@@ -17420,6 +17915,7 @@ function applyLogInkAction(state, action) {
                 ...state,
                 workflowActionId: action.value,
                 pendingConfirmationId: undefined,
+                pendingConfirmationPayload: undefined,
                 pendingMutationConfirmation: undefined,
                 pendingKey: undefined,
             };
@@ -17427,6 +17923,7 @@ function applyLogInkAction(state, action) {
             return {
                 ...state,
                 pendingConfirmationId: action.value,
+                pendingConfirmationPayload: action.value ? action.payload : undefined,
                 workflowActionId: action.value ? undefined : state.workflowActionId,
                 pendingMutationConfirmation: action.value ? undefined : state.pendingMutationConfirmation,
                 pendingKey: undefined,
@@ -17436,6 +17933,7 @@ function applyLogInkAction(state, action) {
                 ...state,
                 pendingMutationConfirmation: action.value,
                 pendingConfirmationId: action.value ? undefined : state.pendingConfirmationId,
+                pendingConfirmationPayload: action.value ? undefined : state.pendingConfirmationPayload,
                 workflowActionId: action.value ? undefined : state.workflowActionId,
                 pendingKey: undefined,
             };
@@ -18257,6 +18755,36 @@ function cherryPickCommit(git, commit) {
     }
     return guardNoInProgressOperation(git).then((blocked) => (blocked || runAction$5(() => git.raw(['cherry-pick', commit.hash]), `Cherry-picked ${commit.shortHash}`)));
 }
+/**
+ * Materialize a single file's contents from a historical commit into the
+ * working tree, leaving every other path untouched. Equivalent to
+ * `git checkout <sha> -- <path>` for additions/modifications. When the
+ * path no longer exists at <sha> (i.e. the commit deleted that file),
+ * mirror the deletion in the worktree via `git rm --force`.
+ *
+ * Important: this overwrites the file in the working tree. The caller
+ * is responsible for confirming with the user when the working tree
+ * already has uncommitted changes to that path.
+ */
+async function checkoutFileFromCommit(git, sha, path) {
+    return checkoutOrDeleteFromRef(git, sha, path, sha.slice(0, 7));
+}
+async function checkoutOrDeleteFromRef(git, ref, path, label) {
+    const exists = await pathExistsAtRef(git, ref, path);
+    if (exists) {
+        return runAction$5(() => git.raw(['checkout', ref, '--', path]), `Checked out ${path} from ${label}`);
+    }
+    return runAction$5(() => git.raw(['rm', '--force', '--quiet', '--', path]), `Removed ${path} (mirrors deletion from ${label})`);
+}
+async function pathExistsAtRef(git, ref, path) {
+    try {
+        await git.raw(['cat-file', '-e', `${ref}:${path}`]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function revertCommit(git, commit) {
     if (!commit) {
         return Promise.resolve({
@@ -18406,6 +18934,20 @@ function popStash(git, stash) {
 function dropStash(git, stash) {
     return runAction$4(() => git.raw(['stash', 'drop', stash.ref]), `Dropped ${stash.ref}`);
 }
+/**
+ * Materialize a single file's contents from a stash into the working
+ * tree, leaving the rest of the stash untouched. Equivalent to
+ * `git checkout <stashRef> -- <path>` for additions/modifications. When
+ * the path doesn't exist at <stashRef> — i.e. the stash recorded a
+ * deletion — mirror that deletion in the worktree.
+ *
+ * Important: this overwrites the file in the working tree. The caller
+ * is responsible for confirming with the user when the working tree
+ * already has uncommitted changes to that path.
+ */
+function checkoutFileFromStash(git, stashRef, path) {
+    return checkoutOrDeleteFromRef(git, stashRef, path, stashRef);
+}
 
 function parseStashSubject(subject) {
     const match = subject.match(/^(?:WIP on|On) ([^:]+):\s*(.*)$/);
@@ -18458,6 +19000,68 @@ async function getStashDiffSummary(git, stashRef) {
         .map((line) => line.trimEnd())
         .filter(Boolean);
 }
+/**
+ * Full unified-patch diff for a stash. Used by the diff surface when
+ * `state.diffSource === 'stash'` to render the stash's changes inline.
+ *
+ * Empty stashes (e.g. created by `git stash --keep-index` against an
+ * already-clean tree) return [] rather than throwing — surfaces fall
+ * back to a "no diff to display" message.
+ */
+async function getStashDiff(git, stashRef) {
+    return (await git.raw(['stash', 'show', '-p', stashRef]))
+        .split('\n')
+        .map((line) => line.replace(/\r$/, ''));
+}
+/**
+ * Slice a unified-patch into per-file sections. Each entry records the
+ * file path and the offset of its `diff --git` header within `lines`.
+ * Used by the stash explorer to build a per-file cursor + cherry-pick
+ * the file at the cursor.
+ *
+ * Renames / moves return the destination path (the `b/` side); the
+ * action surface treats that as the path to materialize from the stash.
+ *
+ * Path quoting: git wraps paths containing spaces or special characters
+ * in double-quotes (`diff --git "a/path with spaces" "b/path with spaces"`).
+ * The parser handles both the unquoted and quoted forms; without that,
+ * stash-file navigation and cherry-pick silently broke for any file
+ * whose path contained a space.
+ */
+function parseStashDiffFiles(lines) {
+    const files = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        const parsed = parseDiffGitHeader(line);
+        if (parsed) {
+            files.push({ path: parsed.bPath || parsed.aPath, startLine: i });
+        }
+    }
+    return files;
+}
+const DIFF_GIT_HEADER = /^diff --git (?:"a\/((?:\\.|[^"\\])+)"|a\/(\S+)) (?:"b\/((?:\\.|[^"\\])+)"|b\/(\S+))$/;
+function parseDiffGitHeader(line) {
+    const match = line.match(DIFF_GIT_HEADER);
+    if (!match)
+        return undefined;
+    const aPath = unescapeGitQuoted(match[1]) || match[2];
+    const bPath = unescapeGitQuoted(match[3]) || match[4];
+    if (!aPath || !bPath)
+        return undefined;
+    return { aPath, bPath };
+}
+function unescapeGitQuoted(value) {
+    if (value === undefined)
+        return undefined;
+    // Git's diff header quoting escapes `"`, `\`, and the usual
+    // C-style sequences. Reverse the most common ones so callers get the
+    // raw on-disk path.
+    return value
+        .replace(/\\\\/g, '\\')
+        .replace(/\\"/g, '"')
+        .replace(/\\t/g, '\t')
+        .replace(/\\n/g, '\n');
+}
 
 async function runAction$3(action, successMessage) {
     try {
@@ -21062,10 +21666,6 @@ function LogInkApp(deps) {
     const h = React.createElement;
     const { exit } = useApp();
     const windowSize = useWindowSize();
-    const layout = getLogInkLayout({
-        columns: windowSize.columns || process.stdout.columns || LOG_INK_DEFAULT_COLUMNS,
-        rows: windowSize.rows || process.stdout.rows || LOG_INK_DEFAULT_ROWS,
-    });
     // Bumping this on SIGCONT forces the existing tree to repaint so users
     // land on a drawn screen after `fg` instead of an empty alt buffer.
     const [, setResumeTick] = React.useState(0);
@@ -21093,6 +21693,13 @@ function LogInkApp(deps) {
     const [worktreeDiffLoading, setWorktreeDiffLoading] = React.useState(false);
     const [worktreeHunks, setWorktreeHunks] = React.useState(undefined);
     const [worktreeHunksLoading, setWorktreeHunksLoading] = React.useState(false);
+    // Stash diff explorer (Enter on a stash row): the runtime fetches
+    // `git stash show -p <ref>` lazily once the diff view becomes active
+    // with diffSource='stash'. Lines are stored as a flat string[] —
+    // renderDiffSurface paints each line through diffLineProps so +/-
+    // colors match the commit-diff path.
+    const [stashDiffLines, setStashDiffLines] = React.useState(undefined);
+    const [stashDiffLoading, setStashDiffLoading] = React.useState(false);
     const [hasMoreCommits, setHasMoreCommits] = React.useState(() => (Boolean(logArgv?.interactive && !logArgv.limit) &&
         getCommitRows(rows).length >= LOG_INTERACTIVE_DEFAULT_LIMIT));
     const [loadingMoreCommits, setLoadingMoreCommits] = React.useState(false);
@@ -21137,6 +21744,36 @@ function LogInkApp(deps) {
     const dispatch = React.useCallback((action) => {
         setState((current) => applyLogInkAction(current, action));
     }, []);
+    // Auto-dismiss status messages after a short window so transient
+    // confirmations ("Pulled current branch", "Edited foo.ts") don't
+    // linger forever. Each new message resets the timer; clearing the
+    // message via setStatus(undefined) cancels it. Doesn't fire while a
+    // modal (input prompt, confirmation, palette) is open — those flows
+    // use the status line as live feedback for the open task.
+    React.useEffect(() => {
+        if (!state.statusMessage)
+            return;
+        if (state.inputPrompt || state.pendingConfirmationId || state.pendingMutationConfirmation || state.showCommandPalette) {
+            return;
+        }
+        // The `setTimeout` callback is a literal arrow function (not a
+        // string), and the delay is a hard-coded constant, so the
+        // eval-injection vector behind DevSkim DS172411 doesn't apply here.
+        // DevSkim: ignore DS172411
+        const handle = setTimeout(() => {
+            if (mountedRef.current) {
+                dispatch({ type: 'setStatus', value: undefined });
+            }
+        }, 4000);
+        return () => clearTimeout(handle);
+    }, [
+        dispatch,
+        state.inputPrompt,
+        state.pendingConfirmationId,
+        state.pendingMutationConfirmation,
+        state.showCommandPalette,
+        state.statusMessage,
+    ]);
     const refreshContext = React.useCallback(async (options = {}) => {
         // Loud refresh (manual `r`): flip everything to 'loading' so the user
         // sees the surfaces clear, then settle to 'ready' on completion.
@@ -21216,6 +21853,61 @@ function LogInkApp(deps) {
             watcher?.close();
         };
     }, [git, refreshContext, refreshWorktreeContext]);
+    // Per-repo sidebar tab persistence (#21). Resolve the repo root, look
+    // up the cached tab, and dispatch `restoreSidebarTab` once on mount so
+    // the user lands on whichever tab they were last on for this project.
+    // `restoreSidebarTab` (vs `setSidebarTab`) intentionally does not pull
+    // focus into the sidebar — the user lands on commits, the saved tab
+    // is just visible in the gutter.
+    //
+    // The save effect listens to `userSidebarTab` (the user's explicit
+    // choice mirror), not `sidebarTab`. That way the auto-switch to
+    // Branches when entering compose / status doesn't overwrite the saved
+    // preference.
+    const repoRootRef = React.useRef(undefined);
+    React.useEffect(() => {
+        let cancelled = false;
+        void (async () => {
+            try {
+                const repoRoot = (await git.revparse(['--show-toplevel'])).trim();
+                if (cancelled || !repoRoot)
+                    return;
+                repoRootRef.current = repoRoot;
+                const saved = getSavedSidebarTab(repoRoot);
+                if (saved && saved !== state.userSidebarTab) {
+                    dispatch({ type: 'restoreSidebarTab', value: saved });
+                }
+            }
+            catch {
+                // Not in a worktree, or revparse failed; nothing to restore.
+            }
+        })();
+        return () => { cancelled = true; };
+    }, [git, dispatch]);
+    React.useEffect(() => {
+        const repoRoot = repoRootRef.current;
+        if (!repoRoot)
+            return;
+        saveSidebarTab(repoRoot, state.userSidebarTab);
+    }, [state.userSidebarTab]);
+    // P-stash-explorer: load `git stash show -p <ref>` once the diff view
+    // becomes active with diffSource='stash'. Best-effort — empty stashes
+    // or read errors fall through to a "no diff" hint at the render site.
+    React.useEffect(() => {
+        if (state.activeView !== 'diff' || state.diffSource !== 'stash' || !state.stashDiffRef) {
+            return;
+        }
+        let active = true;
+        setStashDiffLoading(true);
+        void (async () => {
+            const lines = await safe(getStashDiff(git, state.stashDiffRef));
+            if (active) {
+                setStashDiffLines(lines || []);
+                setStashDiffLoading(false);
+            }
+        })();
+        return () => { active = false; };
+    }, [git, state.activeView, state.diffSource, state.stashDiffRef]);
     React.useEffect(() => {
         let active = true;
         async function loadWorktreeHunks() {
@@ -21426,13 +22118,96 @@ function LogInkApp(deps) {
         });
         dispatch({ type: 'setStatus', value: result.message });
     }, [dispatch]);
+    // Open a file in $EDITOR (or $VISUAL) by suspending Ink's hold on the
+    // terminal, spawning the editor synchronously inheriting stdio, then
+    // restoring the alt screen + raw mode and forcing a re-render. The
+    // dance mirrors the SIGTSTP / SIGCONT path in inkTerminalLifecycle.
+    // Falls back to vi when neither env var is set; surfaces a status
+    // message on missing-binary / non-zero exit so the user isn't left
+    // wondering.
+    const openInEditor = React.useCallback((path) => {
+        if (!path)
+            return;
+        const editorEnv = process.env.VISUAL || process.env.EDITOR || 'vi';
+        // $VISUAL / $EDITOR commonly include flags (`code -w`, `vim -f`,
+        // `emacs -nw`). Tokenize on whitespace so the leading word is the
+        // executable and the rest are passed as arguments — passing the
+        // full string to spawnSync as the executable would fail with
+        // ENOENT for any of those configurations.
+        const editorArgs = editorEnv.trim().split(/\s+/).filter(Boolean);
+        const editor = editorArgs[0] || 'vi';
+        const editorPrefixArgs = editorArgs.slice(1);
+        const out = process.stdout;
+        const stdin = process.stdin;
+        const ENTER_ALT = '\x1b[?1049h';
+        const EXIT_ALT = '\x1b[?1049l';
+        const SHOW_CURSOR = '\x1b[?25h';
+        const HIDE_CURSOR = '\x1b[?25l';
+        try {
+            // Drop into the primary buffer + cooked mode so the editor
+            // doesn't inherit our raw-mode keystrokes.
+            stdin.setRawMode?.(false);
+            out.write(`${SHOW_CURSOR}${EXIT_ALT}`);
+            const result = spawnSync(editor, [...editorPrefixArgs, path], { stdio: 'inherit' });
+            if (result.error) {
+                dispatch({ type: 'setStatus', value: `Failed to launch ${editor}: ${result.error.message}` });
+            }
+            else if (result.signal) {
+                // Editor was killed by a signal (e.g. ^C, SIGTERM). status is
+                // null in this case, so the old `status !== 0` check would
+                // mistakenly fall through to the success branch.
+                dispatch({ type: 'setStatus', value: `${editor} interrupted by ${result.signal}` });
+            }
+            else if (typeof result.status === 'number' && result.status !== 0) {
+                dispatch({ type: 'setStatus', value: `${editor} exited with status ${result.status}` });
+            }
+            else {
+                dispatch({ type: 'setStatus', value: `Edited ${path}` });
+            }
+        }
+        finally {
+            // Re-enter the alt screen + raw mode + hidden cursor; nudge React
+            // so the freshly-restored screen actually paints.
+            out.write(`${ENTER_ALT}${HIDE_CURSOR}`);
+            stdin.setRawMode?.(true);
+            resumeRef?.current?.();
+        }
+        // Worktree status may have changed (e.g. user saved an edit) — silent
+        // refresh so the file row reflects the new staged/unstaged state.
+        void refreshWorktreeContext({ silent: true });
+    }, [dispatch, refreshWorktreeContext, resumeRef]);
     // Resolve the destructive-action target from the live filtered+sorted
     // list the user is looking at, run the action against it, surface the
     // result on the status line, and silently refresh so the deleted item
     // disappears. Called from the y-confirm path for delete-branch / delete-
     // tag / drop-stash / remove-worktree / abort-operation.
-    const runWorkflowAction = React.useCallback(async (id) => {
+    const runWorkflowAction = React.useCallback(async (id, payload) => {
         const handlers = {
+            'create-branch': async () => {
+                const name = payload?.trim();
+                if (!name)
+                    return { ok: false, message: 'Branch name required' };
+                const startPoint = context.branches?.currentBranch || 'HEAD';
+                return createBranch(git, name, startPoint);
+            },
+            'create-tag': async () => {
+                const name = payload?.trim();
+                if (!name)
+                    return { ok: false, message: 'Tag name required' };
+                return createLightweightTag(git, name, 'HEAD');
+            },
+            'checkout-branch': async () => {
+                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, visible.length - 1)];
+                if (!branch)
+                    return { ok: false, message: 'No branch selected' };
+                if (branch.current)
+                    return { ok: true, message: `Already on ${branch.shortName}` };
+                return checkoutBranch(git, branch);
+            },
             'delete-branch': async () => {
                 const all = sortBranches(context.branches?.localBranches || [], state.branchSort);
                 const visible = state.filter
@@ -21453,6 +22228,16 @@ function LogInkApp(deps) {
                     return { ok: false, message: 'No tag selected' };
                 return deleteLocalTag(git, tag.name);
             },
+            'push-tag': async () => {
+                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, visible.length - 1)];
+                if (!tag)
+                    return { ok: false, message: 'No tag selected' };
+                return pushTag(git, tag.name);
+            },
             'drop-stash': async () => {
                 const all = context.stashes?.stashes || [];
                 const visible = state.filter
@@ -21463,14 +22248,82 @@ function LogInkApp(deps) {
                     return { ok: false, message: 'No stash selected' };
                 return dropStash(git, stash);
             },
+            'apply-stash': async () => {
+                const all = context.stashes?.stashes || [];
+                const visible = state.filter
+                    ? all.filter((s) => matchesPromotedFilter([s.ref, s.message], state.filter))
+                    : all;
+                const stash = visible[Math.min(state.selectedStashIndex, visible.length - 1)];
+                if (!stash)
+                    return { ok: false, message: 'No stash selected' };
+                return applyStash(git, stash);
+            },
+            'pop-stash': async () => {
+                const all = context.stashes?.stashes || [];
+                const visible = state.filter
+                    ? all.filter((s) => matchesPromotedFilter([s.ref, s.message], state.filter))
+                    : all;
+                const stash = visible[Math.min(state.selectedStashIndex, visible.length - 1)];
+                if (!stash)
+                    return { ok: false, message: 'No stash selected' };
+                return popStash(git, stash);
+            },
+            'checkout-file-from-stash': async () => {
+                const path = payload?.trim();
+                const ref = state.stashDiffRef;
+                if (!path)
+                    return { ok: false, message: 'No stash file under cursor' };
+                if (!ref)
+                    return { ok: false, message: 'No stash ref active' };
+                return checkoutFileFromStash(git, ref, path);
+            },
+            'cherry-pick-commit': async () => {
+                const commit = getSelectedInkCommit(state);
+                if (!commit)
+                    return { ok: false, message: 'No commit selected' };
+                return cherryPickCommit(git, {
+                    hash: commit.hash,
+                    shortHash: commit.shortHash,
+                    message: commit.message,
+                });
+            },
+            'checkout-file-from-commit': async () => {
+                // payload is "<sha> <path>" so we pass both through a single
+                // string field on the action.
+                const trimmed = payload?.trim();
+                if (!trimmed)
+                    return { ok: false, message: 'No commit file under cursor' };
+                const spaceIndex = trimmed.indexOf(' ');
+                if (spaceIndex < 0)
+                    return { ok: false, message: 'Malformed commit file payload' };
+                const sha = trimmed.slice(0, spaceIndex);
+                const path = trimmed.slice(spaceIndex + 1);
+                if (!sha || !path)
+                    return { ok: false, message: 'No commit file under cursor' };
+                return checkoutFileFromCommit(git, sha, path);
+            },
             'remove-worktree': async () => {
                 const all = context.worktreeList?.worktrees || [];
-                // No dedicated cursor for the worktrees tab yet — operate on the
-                // first non-current worktree as a safe default.
-                const target = all.find((w) => !w.current);
-                if (!target)
-                    return { ok: false, message: 'No removable worktree' };
-                return removeWorktree(git, target);
+                // Resolve the target from the visible (filtered) list so a
+                // hidden filtered-out worktree can never be the action target.
+                // Falls back to the cursor against the unfiltered list when the
+                // action is invoked from the palette without ever visiting the
+                // worktrees view.
+                const visible = state.filter
+                    ? all.filter((w) => matchesPromotedFilter([w.path, w.branch || ''], state.filter))
+                    : all;
+                const cursorTarget = visible.length
+                    ? visible[Math.min(state.selectedWorktreeListIndex, visible.length - 1)]
+                    : all[Math.min(state.selectedWorktreeListIndex, Math.max(0, all.length - 1))];
+                if (!cursorTarget)
+                    return { ok: false, message: 'No worktree selected' };
+                if (cursorTarget.current) {
+                    return {
+                        ok: false,
+                        message: 'Cannot remove the current worktree — switch to another worktree first.',
+                    };
+                }
+                return removeWorktree(git, cursorTarget);
             },
             'abort-operation': async () => {
                 const operation = context.operation?.operation;
@@ -21479,6 +22332,64 @@ function LogInkApp(deps) {
                 }
                 return abortOperation(git, operation);
             },
+            'open-pr': async () => {
+                const repo = context.provider?.repository;
+                if (!repo || repo.provider !== 'github' || !repo.owner || !repo.name) {
+                    return { ok: false, message: 'No GitHub remote detected for this repo' };
+                }
+                const pr = context.provider?.currentPullRequest || context.pullRequest?.currentPullRequest;
+                if (pr) {
+                    return openProviderUrl(repo, { type: 'pull-request', number: pr.number });
+                }
+                // No PR — fall back to opening the repo page so the user can
+                // create one or browse from there.
+                return openProviderUrl(repo, { type: 'repo' });
+            },
+            'fetch-remotes': async () => fetchRemotes(git),
+            'pull-current-branch': async () => pullCurrentBranch(git),
+            'push-current-branch': async () => pushCurrentBranch(git),
+            'rename-branch': async () => {
+                const newName = payload?.trim();
+                if (!newName)
+                    return { ok: false, message: 'New branch name required' };
+                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, visible.length - 1)];
+                if (!branch)
+                    return { ok: false, message: 'No branch selected' };
+                return renameBranch(git, branch.shortName, newName);
+            },
+            'set-upstream': async () => {
+                const upstream = payload?.trim();
+                if (!upstream)
+                    return { ok: false, message: 'Upstream ref required' };
+                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, visible.length - 1)];
+                if (!branch)
+                    return { ok: false, message: 'No branch selected' };
+                return setUpstream(git, branch.shortName, upstream);
+            },
+            'delete-remote-tag': async () => {
+                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, visible.length - 1)];
+                if (!tag)
+                    return { ok: false, message: 'No tag selected' };
+                return deleteRemoteTag(git, tag.name);
+            },
+            'create-stash': async () => {
+                const message = payload?.trim();
+                if (!message)
+                    return { ok: false, message: 'Stash message required' };
+                return createStash(git, message);
+            },
         };
         const handler = handlers[id];
         if (!handler) {
@@ -21491,7 +22402,8 @@ function LogInkApp(deps) {
         // 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.tagSort]);
+        state.selectedStashIndex, state.selectedTagIndex, state.selectedWorktreeListIndex, state.stashDiffRef,
+        state.tagSort]);
     React.useEffect(() => {
         let active = true;
         async function loadPreview() {
@@ -21597,14 +22509,53 @@ function LogInkApp(deps) {
                 .filter((tag) => matchesPromotedFilter([tag.name, tag.subject], state.filter))
                 .length
             : context.tags?.tags.length;
-        const stashVisibleCount = state.filter
+        const visibleStashes = state.filter
             ? (context.stashes?.stashes || [])
                 .filter((stash) => matchesPromotedFilter([stash.ref, stash.message], state.filter))
+            : (context.stashes?.stashes || []);
+        const stashVisibleCount = visibleStashes.length;
+        const stashSelectedRef = visibleStashes[Math.min(state.selectedStashIndex, Math.max(0, visibleStashes.length - 1))]?.ref;
+        // The worktrees promoted view is filterable; mirror the branches /
+        // tags / stash pattern and feed the filtered count into the input
+        // dispatcher so ↑/↓ stay synchronized with the visible rows.
+        const worktreeVisibleCount = state.filter
+            ? (context.worktreeList?.worktrees || [])
+                .filter((w) => matchesPromotedFilter([w.path, w.branch || ''], state.filter))
                 .length
-            : context.stashes?.stashes.length;
+            : context.worktreeList?.worktrees.length;
+        // When the diff view is showing a stash patch, swap the previewLineCount
+        // to the stash diff length so the existing pageDetailPreview path
+        // (j/k, PgUp/PgDn) scrolls through it without a parallel pipeline.
+        const diffPreviewLineCount = state.diffSource === 'stash'
+            ? stashDiffLines?.length
+            : filePreview?.hunks.length;
+        // Parse the active stash diff into per-file sections so `]`/`[` can
+        // jump between files and `c` knows which path the cursor is on for
+        // a file-level cherry-pick.
+        const stashDiffFiles = state.diffSource === 'stash' && stashDiffLines
+            ? 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;
+        })();
         getLogInkInputEvents(state, inputValue, key, {
             detailFileCount: detail?.files.length,
-            previewLineCount: filePreview?.hunks.length,
+            previewLineCount: diffPreviewLineCount,
             worktreeDiffLineCount: worktreeDiff?.lines.length,
             worktreeFileCount: context.worktree?.files.length,
             worktreeHunkOffsets: worktreeDiff?.hunkOffsets,
@@ -21612,6 +22563,17 @@ function LogInkApp(deps) {
             branchCount: branchVisibleCount,
             tagCount: tagVisibleCount,
             stashCount: stashVisibleCount,
+            stashSelectedRef,
+            stashDiffFileOffsets: stashDiffFileOffsets.length ? stashDiffFileOffsets : undefined,
+            stashDiffSelectedPath,
+            worktreeListCount: worktreeVisibleCount,
+            worktreeSelectedPath: context.worktree?.files[state.selectedWorktreeFileIndex]?.path,
+            commitDiffSelectedPath: state.diffSource === 'commit'
+                ? selectedDetailFile?.path
+                : undefined,
+            commitDiffSelectedSha: state.diffSource === 'commit'
+                ? selected?.hash
+                : undefined,
             worktreeDirty,
         }).forEach((event) => {
             if (event.type === 'exit') {
@@ -21639,7 +22601,10 @@ function LogInkApp(deps) {
                 void runAiCommitDraft();
             }
             else if (event.type === 'runWorkflowAction') {
-                void runWorkflowAction(event.id);
+                void runWorkflowAction(event.id, event.payload);
+            }
+            else if (event.type === 'openFileInEditor') {
+                openInEditor(event.path);
             }
             else {
                 // P4.5: enrich filter-mutating actions with a precomputed
@@ -21653,6 +22618,13 @@ function LogInkApp(deps) {
             }
         });
     });
+    // Layout depends on focus (sidebar grows when focused), so it's
+    // computed here — after state is in scope but before the render path.
+    const layout = getLogInkLayout({
+        columns: windowSize.columns || process.stdout.columns || LOG_INK_DEFAULT_COLUMNS,
+        rows: windowSize.rows || process.stdout.rows || LOG_INK_DEFAULT_ROWS,
+        sidebarFocused: state.focus === 'sidebar',
+    });
     if (layout.tooSmall) {
         return h(Box, {
             flexDirection: 'column',
@@ -21666,7 +22638,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, layout.bodyRows, layout.mainPanelWidth, theme, hasMoreCommits, loadingMoreCommits), renderDetailPanel(h, { Box, Text }, state, context, contextStatus, detail, detailLoading, filePreview, filePreviewLoading, layout.detailWidth, theme)), renderFooter(h, { Box, Text }, state, theme, idleTip));
+    return h(Box, { flexDirection: 'column', height: layout.rows }, renderHeader(h, { Box, Text }, state, context, contextStatus, layout.columns, theme, appLabel), h(Box, { flexDirection: 'row', height: layout.bodyRows }, renderSidebar(h, { Box, Text }, state, context, contextStatus, layout.sidebarWidth, theme), renderMainPanel(h, { Box, Text }, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, layout.bodyRows, layout.mainPanelWidth, theme, hasMoreCommits, loadingMoreCommits), renderDetailPanel(h, { Box, Text }, state, context, contextStatus, detail, detailLoading, filePreview, filePreviewLoading, layout.detailWidth, theme)), renderFooter(h, { Box, Text }, state, theme, idleTip));
 }
 function renderHeader(h, components, state, context, contextStatus, columns, theme, appLabel) {
     const { Box, Text } = components;
@@ -21722,28 +22694,96 @@ function renderHeader(h, components, state, context, contextStatus, columns, the
 function renderSidebar(h, components, state, context, contextStatus, width, theme) {
     const { Box, Text } = components;
     const focused = state.focus === 'sidebar';
-    const lines = sidebarLines(context, contextStatus, state.sidebarTab, width - 4, state, theme);
     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.
+    const tabBlocks = tabs.flatMap((tab, tabIndex) => {
+        const isActive = tab === state.sidebarTab;
+        const count = sidebarTabCount(tab, context);
+        const labelWithCount = count !== undefined
+            ? `${sidebarTabLabel(tab)} (${count})`
+            : sidebarTabLabel(tab);
+        const headerText = isActive ? `[${labelWithCount}]` : labelWithCount;
+        const blocks = [];
+        if (tabIndex > 0) {
+            blocks.push(h(Text, { key: `tab-spacer-${tab}` }, ''));
+        }
+        blocks.push(h(Text, {
+            key: `tab-header-${tab}`,
+            bold: isActive,
+            dimColor: !isActive,
+        }, headerText));
+        if (isActive) {
+            blocks.push(...renderActiveSidebarContent(h, Text, tab, state, context, contextStatus, width, theme));
+        }
+        return blocks;
+    });
     return h(Box, {
         borderColor: focusBorderColor(theme, focused),
         borderStyle: theme.borderStyle,
         flexDirection: 'column',
         width,
         paddingX: 1,
-    }, h(Text, { bold: true }, panelTitle('Repository', focused)), h(Text, { dimColor: true }, tabs.map((tab) => {
-        const count = sidebarTabCount(tab, context);
-        const labelWithCount = count !== undefined
-            ? `${sidebarTabLabel(tab)} (${count})`
-            : sidebarTabLabel(tab);
-        return tab === state.sidebarTab ? `[${labelWithCount}]` : labelWithCount;
-    }).join(' ')), h(Text, undefined, ''), ...lines.map((line, index) => h(Text, { key: `sidebar-${index}` }, truncate$1(line, width - 4))));
+    }, h(Text, { bold: true }, panelTitle('Repository', focused)), h(Text, undefined, ''), ...tabBlocks);
+}
+/**
+ * Render the indented body of the active sidebar tab. The status tab
+ * colours its summary counts (warning / danger / muted) and per-file
+ * rows so they read as the same severity scale used in the main status
+ * surface; every other tab falls through to `sidebarLines` for its
+ * string-based summary.
+ */
+function renderActiveSidebarContent(h, Text, tab, state, context, contextStatus, width, theme) {
+    if (tab === 'status') {
+        return renderActiveStatusTabContent(h, Text, context, contextStatus, width, theme);
+    }
+    const lines = sidebarLines(context, contextStatus, tab, width - 6, state, theme);
+    return lines.map((line, index) => h(Text, {
+        key: `tab-content-${tab}-${index}`,
+        dimColor: !line.trim(),
+    }, truncate$1(`  ${line}`, width - 4)));
+}
+function renderActiveStatusTabContent(h, Text, context, contextStatus, width, theme) {
+    if (isLogInkContextKeyLoading(contextStatus, 'worktree')) {
+        return [h(Text, { key: 'tab-status-loading', dimColor: true }, '  Loading status…')];
+    }
+    const worktree = context.worktree;
+    if (!worktree) {
+        return [h(Text, { key: 'tab-status-empty', dimColor: true }, '  Status unavailable')];
+    }
+    const colorOf = (state) => {
+        if (theme.noColor)
+            return undefined;
+        if (state === 'staged')
+            return theme.colors.warning;
+        if (state === 'unstaged')
+            return theme.colors.danger;
+        return theme.colors.muted;
+    };
+    const summaryRow = (count, label, key, kind) => h(Text, { key }, '  ', h(Text, { color: colorOf(kind), bold: count > 0 }, `${count} ${label}`));
+    const fileRows = worktree.files.slice(0, 12).map((file, index) => {
+        const codes = `${file.indexStatus}${file.worktreeStatus}`;
+        return h(Text, {
+            key: `tab-status-file-${index}`,
+            color: colorOf(file.state),
+        }, truncate$1(`  ${codes} ${file.path}`, width - 4));
+    });
+    return [
+        summaryRow(worktree.stagedCount, 'staged', 'tab-status-staged', 'staged'),
+        summaryRow(worktree.unstagedCount, 'unstaged', 'tab-status-unstaged', 'unstaged'),
+        summaryRow(worktree.untrackedCount, 'untracked', 'tab-status-untracked', 'untracked'),
+        ...(fileRows.length
+            ? [h(Text, { key: 'tab-status-spacer' }, ''), ...fileRows]
+            : []),
+    ];
 }
-function renderMainPanel(h, components, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits) {
+function renderMainPanel(h, components, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits) {
     if (state.activeView === 'status') {
         return renderStatusSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
     }
     if (state.activeView === 'diff') {
-        return renderDiffSurface(h, components, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, bodyRows, width, theme);
+        return renderDiffSurface(h, components, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, bodyRows, width, theme);
     }
     if (state.activeView === 'compose') {
         return renderComposeSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
@@ -21757,6 +22797,9 @@ function renderMainPanel(h, components, state, context, contextStatus, worktreeD
     if (state.activeView === 'stash') {
         return renderStashSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
     }
+    if (state.activeView === 'worktrees') {
+        return renderWorktreesSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+    }
     return renderHistoryPanel(h, components, state, context, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits);
 }
 function renderHistoryPanel(h, components, state, context, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits) {
@@ -21966,15 +23009,25 @@ function renderComposeSurface(h, components, state, context, contextStatus, body
             key: `compose-body-${index}`,
             dimColor: line === '<empty>',
         }, `  ${line}${bodyCursor && isLast ? bodyCursor : ''}`);
-    }), h(Text, undefined, ''), ...(compose.loading
-        ? [h(Text, {
+    }), 
+    // Loading indicator + post-action message belong inline with the draft
+    // (they describe what just happened to the fields above). The state-
+    // line ("Editing — Enter switches summary↔body…" / "Press e to edit
+    // …") is footer-style guidance and now sits at the very bottom of the
+    // pane so it doesn't visually separate the body from any
+    // result/details.
+    ...(compose.loading
+        ? [
+            h(Text, undefined, ''),
+            h(Text, {
                 key: 'compose-loading',
                 bold: true,
                 color: theme.noColor ? undefined : theme.colors.accent,
             }, theme.ascii
                 ? '[...] Generating AI commit draft (this can take a moment)'
-                : '⏳ Generating AI commit draft… (this can take a moment)')]
-        : [h(Text, { dimColor: true }, stateLine)]), ...(compose.message ? [h(Text, { key: 'compose-msg' }, truncate$1(compose.message, 140))] : []), ...(compose.details || []).map((line, index) => h(Text, {
+                : '⏳ Generating AI commit draft… (this can take a moment)'),
+        ]
+        : []), ...(compose.message ? [h(Text, undefined, ''), h(Text, { key: 'compose-msg' }, truncate$1(compose.message, 140))] : []), ...(compose.details || []).map((line, index) => h(Text, {
         key: `compose-detail-${index}`,
         dimColor: true,
     }, truncate$1(`  ${line}`, 140))), ...(!hasStagedFiles && noStagedHint
@@ -21982,7 +23035,7 @@ function renderComposeSurface(h, components, state, context, contextStatus, body
             h(Text, { key: 'compose-no-staged-spacer' }, ''),
             h(Text, { key: 'compose-no-staged', dimColor: true }, truncate$1(noStagedHint, 140)),
         ]
-        : []));
+        : []), h(Box, { flexGrow: 1 }), h(Text, { key: 'compose-stateline', dimColor: true }, truncate$1(stateLine, width - 4)));
 }
 function matchesPromotedFilter(haystacks, filter) {
     if (!filter.trim()) {
@@ -22136,6 +23189,48 @@ function renderStashSurface(h, components, state, context, contextStatus, bodyRo
         width,
     }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Stash', focused)), h(Text, { dimColor: true }, headerRight)), ...renderPromotedFilterAffordance(h, Text, state, theme), ...lines);
 }
+function renderWorktreesSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+    const { Box, Text } = components;
+    const focused = state.focus === 'commits';
+    const loading = isLogInkContextKeyLoading(contextStatus, 'worktreeList');
+    const allWorktrees = context.worktreeList?.worktrees || [];
+    const worktrees = state.filter
+        ? allWorktrees.filter((entry) => matchesPromotedFilter([entry.path, entry.branch || '', entry.head || ''], state.filter))
+        : allWorktrees;
+    const selected = Math.max(0, Math.min(state.selectedWorktreeListIndex, Math.max(0, worktrees.length - 1)));
+    const listRows = Math.max(4, bodyRows - 4);
+    const startIndex = Math.max(0, selected - Math.floor(listRows / 2));
+    const visible = worktrees.slice(startIndex, startIndex + listRows);
+    const filterLabel = state.filter ? ` | filter: ${state.filter}` : '';
+    const headerRight = loading
+        ? 'loading worktrees'
+        : `${worktrees.length}/${allWorktrees.length} worktrees${filterLabel}`;
+    const lines = loading
+        ? [h(Text, { key: 'worktrees-loading', dimColor: true }, formatLogInkLoading({ resource: 'worktrees' }))]
+        : worktrees.length === 0
+            ? [h(Text, { key: 'worktrees-empty', dimColor: true }, 'No linked worktrees.')]
+            : visible.map((entry, offset) => {
+                const index = startIndex + offset;
+                const isSelected = index === selected;
+                const cursor = isSelected ? '>' : ' ';
+                const marker = entry.current ? '*' : ' ';
+                const branchLabel = entry.branch ? entry.branch : entry.head || '<detached>';
+                const stateLabel = entry.dirty ? 'dirty' : 'clean';
+                return h(Text, {
+                    key: `worktree-${index}`,
+                    bold: isSelected,
+                    dimColor: !isSelected && !entry.current,
+                }, truncate$1(`${cursor} ${marker} ${branchLabel.padEnd(28)} ${stateLabel.padEnd(6)} ${entry.path}`, width - 4));
+            });
+    return h(Box, {
+        borderColor: focusBorderColor(theme, focused),
+        borderStyle: theme.borderStyle,
+        flexDirection: 'column',
+        flexShrink: 0,
+        paddingX: 1,
+        width,
+    }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Worktrees', focused)), h(Text, { dimColor: true }, headerRight)), ...renderPromotedFilterAffordance(h, Text, state, theme), ...lines);
+}
 /**
  * Filter input cursor for the promoted views (branches/tags/stash).
  * History already shows the same `filter: foo_` affordance in its header
@@ -22154,12 +23249,67 @@ function renderPromotedFilterAffordance(h, Text, state, theme) {
         h(Text, { key: 'promoted-filter-input', color: accent }, `filter: ${state.filter}_`),
     ];
 }
-function renderDiffSurface(h, components, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, bodyRows, width, theme) {
+function renderDiffSurface(h, components, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, bodyRows, width, theme) {
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const worktree = context.worktree;
     const worktreeFile = worktree?.files[state.selectedWorktreeFileIndex];
     const visibleRows = Math.max(4, bodyRows - 4);
+    // Stash diff branch: when the user opened the diff via Enter on a stash
+    // row, render the stash patch text directly. The patch is parsed into
+    // per-file sections so `]` / `[` jumps between files and `c`
+    // cherry-picks the file at the cursor.
+    if (state.diffSource === 'stash') {
+        const lines = stashDiffLines || [];
+        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 currentFileIndex = currentFile
+            ? Math.max(0, stashFiles.findIndex((file) => file.startLine === currentFile.startLine))
+            : -1;
+        const headerLines = stashDiffLoading
+            ? [`Loading diff for ${state.stashDiffRef || 'stash'}...`]
+            : lines.length
+                ? [
+                    `Stash: ${state.stashDiffRef || ''}`,
+                    fileCount > 0 && currentFile
+                        ? `File ${currentFileIndex + 1}/${fileCount}: ${currentFile.path}`
+                        : 'No files in this stash.',
+                    `Lines ${Math.min(state.diffPreviewOffset + 1, lines.length)}-${Math.min(state.diffPreviewOffset + visibleLines.length, lines.length)}/${lines.length}`,
+                    '',
+                ]
+                : ['No diff to display for this stash.'];
+        return h(Box, {
+            borderColor: focusBorderColor(theme, focused),
+            borderStyle: theme.borderStyle,
+            flexDirection: 'column',
+            flexShrink: 0,
+            paddingX: 1,
+            width,
+        }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Stash diff', focused)), h(Text, { dimColor: true }, state.stashDiffRef || 'no stash')), ...headerLines.map((line, index) => h(Text, {
+            key: `stash-diff-header-${index}`,
+            dimColor: index > 0,
+        }, truncate$1(line, width - 4))), ...(stashDiffLoading || !lines.length
+            ? []
+            : visibleLines.map((line, index) => h(Text, {
+                key: `stash-diff-line-${state.diffPreviewOffset + index}`,
+                ...diffLineProps(line, theme),
+            }, truncate$1(line, width - 4)))));
+    }
     // diffSource disambiguates: 'commit' was set when the user opened the
     // diff via history → Enter (read-only commit-diff explore), 'worktree'
     // was set when they came from status → Enter (stage / hunk / revert).
@@ -22253,6 +23403,9 @@ function renderDetailPanel(h, components, state, context, contextStatus, detail,
     if (state.showCommandPalette) {
         return renderCommandPalette(h, components, state, width, theme, focused);
     }
+    if (state.inputPrompt) {
+        return renderInputPromptPanel(h, components, state, width, theme, focused);
+    }
     if (state.pendingConfirmationId || state.pendingMutationConfirmation) {
         return renderConfirmationPanel(h, components, state, width, theme, focused);
     }
@@ -22652,16 +23805,40 @@ function renderCommitPanel(h, components, state, context, contextStatus, width,
     }, h(Text, { bold: true }, panelTitle('Commit', focused)), ...headerLines.map((line, index) => h(Text, {
         key: `commit-header-${index}`,
         dimColor: index < 2 || line.startsWith('  ') || line === '<empty>',
-    }, truncate$1(line, width - 4))), loading
-        ? h(Text, {
-            key: 'commit-loading',
-            bold: true,
-            color: theme.noColor ? undefined : theme.colors.accent,
-        }, truncate$1(theme.ascii ? '[...] Generating AI draft' : '⏳ Generating AI draft…', width - 4))
-        : h(Text, { key: 'commit-state', dimColor: true }, truncate$1(stateLine, width - 4)), ...trailerLines.map((line, index) => h(Text, {
+    }, truncate$1(line, width - 4))), 
+    // Loading indicator + commit result/details stay inline with the body
+    // (they describe what just happened to the fields above). The action
+    // hint ("e edit | c commit | I AI draft") moves to the bottom of the
+    // pane to read as footer guidance, matching the compose surface.
+    ...(loading
+        ? [h(Text, {
+                key: 'commit-loading',
+                bold: true,
+                color: theme.noColor ? undefined : theme.colors.accent,
+            }, truncate$1(theme.ascii ? '[...] Generating AI draft' : '⏳ Generating AI draft…', width - 4))]
+        : []), ...trailerLines.map((line, index) => h(Text, {
         key: `commit-trailer-${index}`,
         dimColor: line.startsWith('  '),
-    }, truncate$1(line, width - 4))));
+    }, truncate$1(line, width - 4))), h(Box, { flexGrow: 1 }), loading
+        ? null
+        : h(Text, { key: 'commit-state', dimColor: true }, truncate$1(stateLine, width - 4)));
+}
+function renderInputPromptPanel(h, components, state, width, theme, focused) {
+    const { Box, Text } = components;
+    const prompt = state.inputPrompt;
+    if (!prompt) {
+        return h(Box, { width });
+    }
+    return h(Box, {
+        borderColor: focusBorderColor(theme, focused),
+        borderStyle: theme.borderStyle,
+        flexDirection: 'column',
+        width,
+        paddingX: 1,
+    }, h(Text, { bold: true }, panelTitle('Prompt', focused)), h(Text, { dimColor: true }, truncate$1(prompt.label, width - 4)), h(Text, undefined, ''), h(Text, {
+        bold: true,
+        color: theme.noColor ? undefined : theme.colors.accent,
+    }, truncate$1(`${prompt.value}_`, width - 4)), h(Text, undefined, ''), h(Text, { dimColor: true }, 'Enter to submit · Esc to cancel · Ctrl+u to clear'));
 }
 function renderConfirmationPanel(h, components, state, width, theme, focused) {
     const { Box, Text } = components;
@@ -22839,6 +24016,7 @@ function renderFooter(h, components, state, theme, idleTip) {
     const { Box, Text } = components;
     const hints = getLogInkFooterHints({
         activeView: state.activeView,
+        diffSource: state.diffSource,
         filterMode: state.filterMode,
         focus: state.focus,
         pendingKey: state.pendingKey,