git-coco 0.59.0 → 0.60.0

package/dist/index.esm.mjs

@@ -61,7 +61,7 @@ import { pathToFileURL } from 'url';
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.59.0";
+const BUILD_VERSION = "0.60.0";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -18903,9 +18903,17 @@ async function getStashOverview(git) {
     //   %gd  — stash reflog selector (stash@{N})
     //   %H   — stash commit hash
     //   %P   — space-separated parent hashes (first = base, see StashEntry.baseHash)
-    //   %ci  — committer date, ISO format
+    //   %cI  — committer date, strict ISO 8601
     //   %gs  — reflog subject ("WIP on main: <subject>")
-    const stashes = parseStashList(await git.raw(['stash', 'list', '--date=iso', '--format=%gd%x1f%H%x1f%P%x1f%ci%x1f%gs']));
+    //
+    // NOTE: we deliberately do NOT pass `--date=iso`. That flag rewrites the
+    // `%gd` selector from the index form (`stash@{0}`) into a timestamp
+    // (`stash@{2026-06-03 17:29:23 -0400}`), which is noisy in the list, eats
+    // row width, and — critically — breaks `renameStash`, which parses the
+    // `stash@{N}` index out of the ref. `%cI` gives a strict-ISO date that's
+    // independent of `--date`, so we get both a clean index ref and a
+    // parseable date.
+    const stashes = parseStashList(await git.raw(['stash', 'list', '--format=%gd%x1f%H%x1f%P%x1f%cI%x1f%gs']));
     return {
         stashes: await Promise.all(stashes.map(async (stash) => ({
             ...stash,
@@ -20574,7 +20582,7 @@ function applyCommitComposeAction(state, action) {
                     loading: false,
                     streamingPreview: undefined,
                     pendingAiDraft: action.value,
-                    message: 'AI draft ready. Press R to replace your text, or Esc to keep what you have.',
+                    message: 'AI draft ready. Press Enter (or R) to replace your text, or Esc to keep what you have.',
                     details: undefined,
                 };
             }
@@ -20623,7 +20631,7 @@ function applyCommitComposeAction(state, action) {
                 loading: false,
                 streamingPreview: undefined,
                 pendingAiDraft: action.value,
-                message: 'AI draft ready. Press R to replace your text, or Esc to keep what you have.',
+                message: 'AI draft ready. Press Enter (or R) to replace your text, or Esc to keep what you have.',
                 details: undefined,
             };
         case 'acceptPendingAiDraft':
@@ -22179,6 +22187,25 @@ function getLogInkWorkflowActions() {
             kind: 'destructive',
             requiresConfirmation: true,
         },
+        {
+            // Palette-only create variants (empty `key`): no global hotkey to
+            // collide with `S` / `gZ`, reachable from `:`. Both stash a quick
+            // WIP entry with the requested scope.
+            id: 'stash-staged',
+            key: '',
+            label: 'Stash staged only',
+            description: 'Stash just the staged (index) changes — `git stash push --staged`.',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
+        {
+            id: 'stash-keep-index',
+            key: '',
+            label: 'Stash keeping index',
+            description: 'Stash everything but leave the index intact for an immediate commit — `git stash push --keep-index`.',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
         {
             id: 'remove-worktree',
             key: 'W',
@@ -22690,6 +22717,13 @@ const LOG_INK_KEY_BINDINGS = [
         description: 'Push the stash view (gz; gs is reserved for status).',
         contexts: ['normal'],
     },
+    {
+        id: 'createStash',
+        keys: ['gZ'],
+        label: 'stash changes',
+        description: 'Stash all changes (tracked + untracked) with an optional message — works from any view, including status/diff/compose. Empty message creates a quick WIP stash.',
+        contexts: ['normal'],
+    },
     {
         id: 'navigateWorktrees',
         keys: ['gw'],
@@ -22962,6 +22996,20 @@ const LOG_INK_KEY_BINDINGS = [
         description: 'Add the cursored file or folder to .gitignore (pick a pattern).',
         contexts: ['status'],
     },
+    {
+        id: 'stageAll',
+        keys: ['A'],
+        label: 'stage all',
+        description: 'Stage every change in the worktree (git add -A).',
+        contexts: ['status', 'compose'],
+    },
+    {
+        id: 'stagePathspec',
+        keys: ['+'],
+        label: 'stage paths',
+        description: 'Stage files matching a typed pathspec (. / src/ / *.ts / a list).',
+        contexts: ['status', 'compose'],
+    },
     {
         id: 'viewChangelog',
         keys: ['L'],
@@ -23035,6 +23083,19 @@ const GLOBAL_BINDING_IDS = [
     'navigateBack',
 ];
 const NORMAL_GLOBAL_HINTS = ['g jump', '< back', '? help', ': cmds', 'q quit'];
+/**
+ * Narrow single-pane footer budget (#1135). On terminals below the
+ * single-pane breakpoint the pane switcher (`tab: …`, ~29 cells) plus
+ * the snap-back / peek affordance already claim most of an 80-cell row,
+ * so the per-view hint tail and the global cluster are trimmed to what
+ * fits without clipping — the switcher is the orientation anchor and
+ * must stay whole. The dropped bindings remain one `?` (help) away.
+ *
+ *   - keep only the first view hint (the most actionable for the view)
+ *   - shrink the global cluster to the two recovery essentials
+ */
+const SINGLE_PANE_GLOBAL_HINTS = ['? help', 'q quit'];
+const SINGLE_PANE_VIEW_HINT_LIMIT = 1;
 /**
  * Per-binding category mapping. Used to subdivide the help overlay's
  * Global and view sections into named clusters so users don't face a
@@ -23055,6 +23116,9 @@ const BINDING_CATEGORY_BY_ID = {
     openProjectConfig: 'view',
     openGlobalConfig: 'view',
     gitignoreFile: 'mutate',
+    stageAll: 'mutate',
+    stagePathspec: 'mutate',
+    createStash: 'mutate',
     quit: 'essentials',
     refresh: 'essentials',
     navigateBack: 'essentials',
@@ -23206,18 +23270,20 @@ function formatLogInkBreadcrumb(viewStack) {
     if (viewStack.length === 1 && viewStack[0] === 'history') {
         return '';
     }
-    // Trailing back-hint (P2.5) reminds the user how to walk back when
-    // they're nested deeper than the root view.
-    return `${viewStack.join(' › ')}   ← <`;
+    // Pure location breadcrumb — no trailing back-hint. The footer's
+    // global `< back` hint already names the walk-back key, so repeating
+    // `← <` on every nested view was redundant header chrome (TUI audit).
+    return viewStack.join(' › ');
 }
 /**
  * Render the nested-repo navigation stack (#931) as a breadcrumb suitable
  * for the chrome header. Returns an empty string for a root-only stack
  * so the header stays compact when nothing has been pushed.
  *
- * The trailing `← esc` reminds the user that Esc is the way out — same
- * shape as the view breadcrumb's `← <` so the two read consistently.
- * The repo breadcrumb shows in addition to the view breadcrumb when
+ * The trailing `← esc` reminds the user that Esc (not `<`) pops the
+ * repo stack — a distinct key from the footer's global `< back`, so
+ * unlike the view breadcrumb (pure location) the repo crumb keeps its
+ * hint. The repo breadcrumb shows in addition to the view breadcrumb when
  * both stacks are non-trivial; the chrome layer is responsible for
  * laying them out side by side.
  *
@@ -23260,7 +23326,53 @@ function combineLogInkBreadcrumbSegments(repoCrumb, viewCrumb) {
     }
     return '';
 }
+/**
+ * Single-pane pane switcher hint, e.g. `tab: [sidebar] main inspector`.
+ * The active pane (derived from focus: sidebar → sidebar, detail →
+ * inspector, otherwise main) is bracketed so the user can see which of
+ * the three panes Tab will move them away from. Surfaced only on narrow
+ * terminals where the other two panes aren't on screen.
+ */
+function singlePaneSwitcherHint(focus) {
+    const active = focus === 'sidebar' ? 'sidebar' : focus === 'detail' ? 'inspector' : 'main';
+    const label = (pane) => (pane === active ? `[${pane}]` : pane);
+    return `tab: ${label('sidebar')} ${label('main')} ${label('inspector')}`;
+}
 function getLogInkFooterHints(options) {
+    const hints = computeLogInkFooterHints(options);
+    // While peeking the sidebar (#1135 v2) the footer shows the snap-back
+    // affordance instead of the switcher — the user is mid-glance, not
+    // navigating, so `v`/Esc returning to main is the relevant action. The
+    // view-hint tail + globals are trimmed to fit the narrow row (see
+    // SINGLE_PANE_GLOBAL_HINTS).
+    if (options.peeking) {
+        return {
+            contextual: ['v/esc → main', ...hints.contextual.slice(0, SINGLE_PANE_VIEW_HINT_LIMIT)],
+            global: SINGLE_PANE_GLOBAL_HINTS,
+        };
+    }
+    // On narrow terminals only one pane is on screen, so prepend a Tab
+    // pane switcher for orientation. The caller (footer) only sets
+    // `singlePane` in the plain per-pane states — while an overlay or
+    // filter owns the screen the visible pane is forced (or input is
+    // captured) and Tab does something else, so the switcher is
+    // suppressed there to avoid showing a pane that isn't active. From the
+    // main / inspector pane we also surface `v peek` so the momentary
+    // sidebar glance is discoverable. The full per-view hint cluster +
+    // global cluster don't fit alongside the switcher at the 80-col floor,
+    // so both are trimmed (the dropped keys stay reachable via `?`).
+    if (options.singlePane) {
+        const lead = options.focus === 'sidebar'
+            ? [singlePaneSwitcherHint(options.focus)]
+            : [singlePaneSwitcherHint(options.focus), 'v peek'];
+        return {
+            contextual: [...lead, ...hints.contextual.slice(0, SINGLE_PANE_VIEW_HINT_LIMIT)],
+            global: SINGLE_PANE_GLOBAL_HINTS,
+        };
+    }
+    return hints;
+}
+function computeLogInkFooterHints(options) {
     if (options.pendingKey) {
         const continuations = getLogInkChordContinuations(options.pendingKey);
         if (continuations.length > 0) {
@@ -23377,7 +23489,7 @@ function getLogInkFooterHints(options) {
     }
     if (options.activeView === 'status') {
         return {
-            contextual: ['↑/↓ files', 'enter diff', 'space stage', 'z revert', 'i ignore', 'e/c compose', 'y yank'],
+            contextual: ['↑/↓ files', 'enter hunks', 'space stage', 'A stage all', 'z revert', 'e/c compose'],
             global: NORMAL_GLOBAL_HINTS,
         };
     }
@@ -23389,16 +23501,19 @@ function getLogInkFooterHints(options) {
         const splitToggleHint = options.diffViewMode === 'split' ? 'd unified' : 'd split';
         if (options.diffSource === 'stash') {
             return {
-                contextual: ['j/k lines', '[/] file', 'c cherry-pick', 'H apply hunk', 'o edit', splitToggleHint, 'y yank', 'esc back'],
+                contextual: ['j/k lines', '[/] file', 'c cherry-pick', 'H apply hunk', splitToggleHint, '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, and `H`
-            // (or `gH` for index) applies just the cursored hunk.
+            // (or `gH` for index) applies just the cursored hunk. `j/k`
+            // line-scroll the diff body; `[`/`]` jump between hunks — the
+            // footer labels match the actual handlers (commit diff has no
+            // per-file `[/]` jump; that's the stash diff).
             return {
-                contextual: ['j/k hunks', '[/] file', 'c cherry-pick', 'H apply hunk', splitToggleHint, 'y/Y yank', 'esc back'],
+                contextual: ['j/k lines', '[/] hunk', 'c cherry-pick', 'H apply hunk', splitToggleHint, 'esc back'],
                 global: NORMAL_GLOBAL_HINTS,
             };
         }
@@ -23411,14 +23526,17 @@ function getLogInkFooterHints(options) {
                 global: NORMAL_GLOBAL_HINTS,
             };
         }
+        // Worktree (staging) diff. The hunk is the unit of action: ↑/↓ walk
+        // hunks, space stages/unstages the selected one, a stages the whole
+        // file, z discards the hunk.
         return {
-            contextual: ['j/k hunks', 'space stage', 'z revert', 'o edit', 'e/c compose', 'y yank'],
+            contextual: ['↑/↓ hunk', 'space stage', 'a stage file', 'z discard', 'o edit', 'esc back'],
             global: NORMAL_GLOBAL_HINTS,
         };
     }
     if (options.activeView === 'compose') {
         return {
-            contextual: ['e edit', 'E $EDITOR', 'c commit', 'S split', 'I AI draft', 'gs hunks', 'esc back'],
+            contextual: ['e edit', 'c commit', 'A stage all', '+ stage…', 'S split', 'I AI draft', 'esc back'],
             global: NORMAL_GLOBAL_HINTS,
         };
     }
@@ -23448,7 +23566,7 @@ function getLogInkFooterHints(options) {
     }
     if (options.activeView === 'stash') {
         return {
-            contextual: ['↑/↓ stashes', 'enter diff', 'a apply', 'p pop', 'X drop', 'y yank'],
+            contextual: ['↑/↓ stashes', 'enter diff', 'a/A apply', 'p pop', 'R rename', 'b branch', 'X drop · u undo'],
             global: NORMAL_GLOBAL_HINTS,
         };
     }
@@ -24839,7 +24957,7 @@ function topOfStack(stack) {
 }
 function withPushedView(state, value) {
     if (topOfStack(state.viewStack) === value) {
-        return { ...state, pendingKey: undefined };
+        return { ...state, peekReturnFocus: undefined, pendingKey: undefined };
     }
     const viewStack = [...state.viewStack, value];
     return {
@@ -24862,12 +24980,15 @@ function withPushedView(state, value) {
         compareHead: value === 'diff' ? state.compareHead : undefined,
         pendingCommitFocused: value === 'history' ? state.pendingCommitFocused : false,
         statusGroupHeaderFocused: value === 'status' ? state.statusGroupHeaderFocused : false,
+        // Changing the view is a deliberate destination — cancel any pending
+        // peek return so the user isn't snapped back afterward.
+        peekReturnFocus: undefined,
         pendingKey: undefined,
     };
 }
 function withPoppedView(state) {
     if (state.viewStack.length <= 1) {
-        return { ...state, pendingKey: undefined };
+        return { ...state, peekReturnFocus: undefined, pendingKey: undefined };
     }
     const viewStack = state.viewStack.slice(0, -1);
     const next = topOfStack(viewStack);
@@ -24894,6 +25015,8 @@ function withPoppedView(state) {
         compareHead: next === 'diff' ? state.compareHead : undefined,
         pendingCommitFocused: next === 'history' ? state.pendingCommitFocused : false,
         statusGroupHeaderFocused: next === 'status' ? state.statusGroupHeaderFocused : false,
+        // Backing out is a deliberate navigation — cancel any peek return.
+        peekReturnFocus: undefined,
         pendingKey: undefined,
     };
 }
@@ -25006,7 +25129,7 @@ function withPoppedRepoFrame(state) {
 }
 function withReplacedView(state, value) {
     if (topOfStack(state.viewStack) === value) {
-        return { ...state, pendingKey: undefined };
+        return { ...state, peekReturnFocus: undefined, pendingKey: undefined };
     }
     const viewStack = [...state.viewStack.slice(0, -1), value];
     return {
@@ -25020,6 +25143,9 @@ function withReplacedView(state, value) {
         compareHead: value === 'diff' ? state.compareHead : undefined,
         pendingCommitFocused: value === 'history' ? state.pendingCommitFocused : false,
         statusGroupHeaderFocused: value === 'status' ? state.statusGroupHeaderFocused : false,
+        // Changing the view is a deliberate destination — cancel any pending
+        // peek return so the user isn't snapped back afterward.
+        peekReturnFocus: undefined,
         pendingKey: undefined,
     };
 }
@@ -25253,6 +25379,9 @@ function applyLogInkAction(state, action) {
                 // from 'commits' should always land back on a real file when
                 // the user returns.
                 statusGroupHeaderFocused: false,
+                // Explicit focus cycle cancels a pending peek return — the
+                // user has taken manual control of the focus.
+                peekReturnFocus: undefined,
                 pendingKey: undefined,
             };
         case 'focusPrevious':
@@ -25261,6 +25390,7 @@ function applyLogInkAction(state, action) {
                 focus: cycleValue(FOCUS_ORDER, state.focus, -1),
                 sidebarHeaderFocused: false,
                 statusGroupHeaderFocused: false,
+                peekReturnFocus: undefined,
                 pendingKey: undefined,
             };
         case 'move':
@@ -25758,8 +25888,35 @@ function applyLogInkAction(state, action) {
                 // the status view — clear when focus moves away so a
                 // re-entry starts on a real file.
                 statusGroupHeaderFocused: action.value === 'commits' ? state.statusGroupHeaderFocused : false,
+                // An explicit focus set cancels a pending peek return.
+                peekReturnFocus: undefined,
+                pendingKey: undefined,
+            };
+        case 'togglePeek': {
+            // Peek = "focus the sidebar with a return ticket." Closing returns
+            // to the stashed focus; opening (only from a non-sidebar pane)
+            // stashes the current focus and jumps to the sidebar. The render
+            // layer needs no special case — `focus: 'sidebar'` already drives
+            // the single-pane layout to show the sidebar full-width.
+            if (state.peekReturnFocus !== undefined) {
+                return {
+                    ...state,
+                    focus: state.peekReturnFocus,
+                    peekReturnFocus: undefined,
+                    sidebarHeaderFocused: false,
+                    pendingKey: undefined,
+                };
+            }
+            if (state.focus === 'sidebar') {
+                return state;
+            }
+            return {
+                ...state,
+                focus: 'sidebar',
+                peekReturnFocus: state.focus,
                 pendingKey: undefined,
             };
+        }
         case 'setPendingKey':
             return {
                 ...state,
@@ -26626,6 +26783,12 @@ function getLogInkPaletteExecuteEvents(command, state) {
             return [action({ type: 'toggleGraph' })];
         case 'navigateHome':
             return [action({ type: 'navigateHome' })];
+        case 'createStash':
+            return [action({
+                    type: 'openInputPrompt',
+                    kind: 'create-stash',
+                    label: 'Stash message (empty = WIP)',
+                })];
         case 'navigateStatus':
             return [action({ type: 'pushView', value: 'status' })];
         case 'navigateDiff':
@@ -26731,6 +26894,14 @@ function getLogInkPaletteExecuteEvents(command, state) {
             // Runtime resolves the cursored worktree file and opens the picker
             // (no-ops with a warning when there's no file under the cursor).
             return [{ type: 'openGitignorePicker' }];
+        case 'stageAll':
+            return [{ type: 'runWorkflowAction', id: 'stage-all' }];
+        case 'stagePathspec':
+            return [action({
+                    type: 'openInputPrompt',
+                    kind: 'stage-pathspec',
+                    label: 'Stage pathspec (e.g. `.`, `src/`, `*.ts`, or a space-separated list)',
+                })];
         case 'workflowDeleteBranch':
         case 'workflowDeleteTag':
         case 'workflowDropStash':
@@ -26821,6 +26992,15 @@ function submitInputPrompt(state) {
     if (!state.inputPrompt)
         return [];
     const value = state.inputPrompt.value.trim();
+    // create-stash allows an EMPTY value → quick WIP stash (git supplies its
+    // own "WIP on <branch>" subject). Handled before the generic empty guard
+    // so an empty stash prompt commits a WIP stash instead of bouncing.
+    if (state.inputPrompt.kind === 'create-stash') {
+        return [
+            { type: 'runWorkflowAction', id: 'create-stash', payload: value },
+            action({ type: 'closeInputPrompt' }),
+        ];
+    }
     if (!value) {
         return [action({ type: 'setStatus', value: 'enter a value or press esc to cancel', kind: 'warning' })];
     }
@@ -26830,6 +27010,12 @@ function submitInputPrompt(state) {
             action({ type: 'closeInputPrompt' }),
         ];
     }
+    if (state.inputPrompt.kind === 'stage-pathspec') {
+        return [
+            { type: 'runWorkflowAction', id: 'stage-pathspec', payload: value },
+            action({ type: 'closeInputPrompt' }),
+        ];
+    }
     if (state.inputPrompt.kind === 'reset-mode') {
         const mode = value.toLowerCase();
         if (mode !== 'soft' && mode !== 'mixed' && mode !== 'hard') {
@@ -27056,7 +27242,9 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
     // draft was pending should see the original `R` / Esc semantics of
     // wherever they are now.
     if (state.activeView === 'compose' && state.commitCompose.pendingAiDraft) {
-        if (inputValue === 'R' && !key.ctrl && !key.meta) {
+        // `R` or `Enter` accept the swap (the AI draft becomes the new
+        // content); `Enter` is the natural "yes, use it" confirmation.
+        if ((inputValue === 'R' && !key.ctrl && !key.meta) || key.return) {
             return [action({ type: 'commitCompose', action: { type: 'acceptPendingAiDraft' } })];
         }
         if (key.escape) {
@@ -27442,6 +27630,15 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         }
         return events;
     }
+    // #1135 v2 — while peeking the sidebar, Esc or the peek key (`v`)
+    // snaps back to the pane the user came from. Placed before the
+    // generic Esc → popView so a peek glance returns to main rather than
+    // walking the view stack. Every other key falls through to normal
+    // handling (focus is on the sidebar during a peek), so ←/→ and ↑/↓
+    // browse the sidebar and keep the peek open until an explicit exit.
+    if (state.peekReturnFocus !== undefined && (key.escape || inputValue === 'v')) {
+        return [action({ type: 'togglePeek' })];
+    }
     if (key.escape && state.viewStack.length > 1) {
         return [action({ type: 'popView' })];
     }
@@ -27508,6 +27705,17 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
             action({ type: 'setStatus', value: 'jumped to stash' }),
         ];
     }
+    // `gZ` chord: stash all changes from ANY view — including status / diff /
+    // compose, where bare `S` is claimed by the commit-split flow. Mnemonic
+    // pair with `gz` (jump to the stash *view*). Opens the same message
+    // prompt; an empty message creates a quick WIP stash.
+    if (state.pendingKey === 'g' && inputValue === 'Z') {
+        return [action({
+                type: 'openInputPrompt',
+                kind: 'create-stash',
+                label: 'Stash message (empty = WIP)',
+            })];
+    }
     if (state.pendingKey === 'g' && inputValue === 'w') {
         return [
             action({ type: 'pushView', value: 'worktrees' }),
@@ -27871,6 +28079,13 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
     if (key.tab) {
         return [action({ type: key.shift ? 'focusPrevious' : 'focusNext' })];
     }
+    // #1135 v2 — `v` peeks the sidebar from the main / inspector pane on
+    // narrow (single-pane) terminals: a momentary glance that snaps back
+    // with `v` / Esc (handled above once peeking). No-op in the three-pane
+    // layout (every pane is already on screen) and from the sidebar itself.
+    if (inputValue === 'v' && context.singlePane && state.focus !== 'sidebar') {
+        return [action({ type: 'togglePeek' })];
+    }
     // ←/→ on the sidebar switch tabs (Status ↔ Branches ↔ Tags ↔
     // Stashes ↔ Worktrees) — the horizontal axis is "between tabs", the
     // vertical axis (↑/↓ below) is "within the active tab's items".
@@ -27956,10 +28171,17 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
                     fileCount: context.worktreeFileCount,
                 })];
         }
-        // Diff view: j/k scrolls the visible diff one line. Hunk navigation
-        // moved to ]/[ so single-hunk files (longer than the preview pane)
-        // can scroll bidirectionally instead of getting pinned to a hunk
-        // anchor.
+        // Worktree (staging) diff: ↑/↓ move between hunks — the hunk is the
+        // unit you stage, so the cursor walks hunks (auto-scrolling to the
+        // selected one). Single-hunk files fall through to line-scroll so a
+        // long lone hunk stays readable; `[`/`]` remain hunk-jump aliases.
+        if (state.activeView === 'diff' && (context.worktreeHunkOffsets?.length ?? 0) > 1) {
+            return [action({
+                    type: 'jumpWorktreeHunk',
+                    delta: -1,
+                    hunkOffsets: context.worktreeHunkOffsets,
+                })];
+        }
         if (state.activeView === 'diff' && context.worktreeDiffLineCount) {
             return [action({
                     type: 'pageWorktreeDiff',
@@ -28074,6 +28296,15 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
                     fileCount: context.worktreeFileCount,
                 })];
         }
+        // Worktree (staging) diff: ↓ walks to the next hunk (see the ↑
+        // handler). Multi-hunk only; single-hunk files line-scroll.
+        if (state.activeView === 'diff' && (context.worktreeHunkOffsets?.length ?? 0) > 1) {
+            return [action({
+                    type: 'jumpWorktreeHunk',
+                    delta: 1,
+                    hunkOffsets: context.worktreeHunkOffsets,
+                })];
+        }
         if (state.activeView === 'diff' && context.worktreeDiffLineCount) {
             return [action({
                     type: 'pageWorktreeDiff',
@@ -28480,6 +28711,25 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
     if (inputValue === 'p' && isStashActionTarget(state) && context.stashCount) {
         return [{ type: 'runWorkflowAction', id: 'pop-stash' }];
     }
+    // `A` applies restoring the staged/unstaged split (`git stash apply
+    // --index`) — distinct from `a` (plain apply).
+    if (inputValue === 'A' && isStashActionTarget(state) && context.stashCount) {
+        return [{ type: 'runWorkflowAction', id: 'apply-stash-index' }];
+    }
+    // `b` turns the cursored stash into a new branch (`git stash branch`).
+    if (inputValue === 'b' && isStashActionTarget(state) && context.stashCount) {
+        return [action({ type: 'openInputPrompt', kind: 'stash-branch', label: 'New branch from stash' })];
+    }
+    // `R` renames the cursored stash (store-under-new-message + drop old).
+    if (inputValue === 'R' && isStashActionTarget(state) && context.stashCount) {
+        return [action({ type: 'openInputPrompt', kind: 'rename-stash', label: 'Rename stash' })];
+    }
+    // `u` undoes the last drop. Gated on the view, NOT the count, so it
+    // still works right after you drop your only stash (the list is empty
+    // but the dropped commit is recoverable by hash).
+    if (inputValue === 'u' && isStashActionTarget(state)) {
+        return [{ type: 'runWorkflowAction', id: 'undo-drop-stash' }];
+    }
     // Per-view tag action: `P` pushes the selected tag to origin. Letter
     // is scoped to the tags target so it doesn't collide with `p` for
     // pop-stash. Note: this also takes precedence over the global
@@ -28708,7 +28958,7 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         return [action({
                 type: 'openInputPrompt',
                 kind: 'create-stash',
-                label: 'Stash message',
+                label: 'Stash message (empty = WIP)',
             })];
     }
     // `o` opens the file under the cursor in $EDITOR. Available on the
@@ -28977,9 +29227,35 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
     if (inputValue === ' ' && state.activeView === 'status' && context.worktreeFileCount) {
         return [{ type: 'toggleSelectedFileStage' }];
     }
+    // `A` — stage everything (git add -A); `+` — stage by typed pathspec.
+    // Both available from the status AND compose views so you can stage
+    // without leaving the message editor.
+    if (inputValue === 'A' && (state.activeView === 'status' || state.activeView === 'compose')) {
+        return [{ type: 'runWorkflowAction', id: 'stage-all' }];
+    }
+    if (inputValue === '+' && (state.activeView === 'status' || state.activeView === 'compose')) {
+        return [action({
+                type: 'openInputPrompt',
+                kind: 'stage-pathspec',
+                label: 'Stage pathspec (e.g. `.`, `src/`, `*.ts`, or a space-separated list)',
+            })];
+    }
     if (inputValue === ' ' && state.activeView === 'diff' && context.worktreeHunkOffsets?.length) {
         return [{ type: 'toggleSelectedHunkStage' }];
     }
+    // Worktree diff with no hunks (a new/untracked file) — `space` stages
+    // the whole file, since there's nothing to partial-stage.
+    if (inputValue === ' ' &&
+        state.activeView === 'diff' &&
+        state.diffSource === 'worktree' &&
+        !context.worktreeHunkOffsets?.length) {
+        return [{ type: 'toggleSelectedFileStage' }];
+    }
+    // `a` stages/unstages the WHOLE current file from the staging diff —
+    // an escape hatch out of hunk-by-hunk back to all-or-nothing.
+    if (inputValue === 'a' && state.activeView === 'diff' && state.diffSource === 'worktree') {
+        return [{ type: 'toggleSelectedFileStage' }];
+    }
     if (inputValue === 'z' && state.activeView === 'status' && context.worktreeFileCount) {
         return [action({ type: 'setPendingMutationConfirmation', value: 'revert-file' })];
     }
@@ -29754,21 +30030,22 @@ const INSPECTOR_TABBED_BELOW_ROWS = 28;
  *   wide   >= 160 — plenty of room; keep absolute dates
  *   normal >= 120 — relative dates save 8-ish cells without hiding info
  *   tight  >= 100 — drop date entirely; subject + refs are the priority
- *   rail   <  100 — even with side panels collapsed the row is tight;
- *                   stack to two lines and rail the side panels at rest
+ *   rail   <  100 — history rows stack to two lines; the UI also drops
+ *                   to single-pane mode (see `LAYOUT_SINGLE_PANE_BELOW`)
  */
 const LAYOUT_TIGHT_BELOW = 120;
 const LAYOUT_NORMAL_BELOW = 160;
 const LAYOUT_RAIL_BELOW = 100;
 /**
- * Fixed cell width for a railed side panel. Just wide enough for a
- * 1-cell icon + a 2-3 digit count after subtracting border (2) and
- * padding (2). Going narrower clips the count; going wider defeats
- * the purpose of railing in the first place.
+ * Width below which the three-panel layout can't tile without starving
+ * every pane, so the UI shows exactly one full-width pane (the focused
+ * one) and Tab cycles which pane is visible. Coincides with the `rail`
+ * density breakpoint — single-pane mode replaces the old 8-cell icon
+ * rails that used to render at this width.
  */
-const LAYOUT_RAIL_PANEL_WIDTH = 8;
+const LAYOUT_SINGLE_PANE_BELOW = LAYOUT_RAIL_BELOW;
 const SIDEBAR_AT_REST_BY_TIER = {
-    rail: { min: 22, max: 28, fraction: 0.24 }, // unused — rail collapses to LAYOUT_RAIL_PANEL_WIDTH
+    rail: { min: 22, max: 28, fraction: 0.24 }, // unused at rest — single-pane mode overrides the width
     tight: { min: 22, max: 28, fraction: 0.24 },
     normal: { min: 22, max: 30, fraction: 0.22 },
     wide: { min: 28, max: 32, fraction: 0.20 },
@@ -29787,14 +30064,25 @@ function getLogInkLayout(input) {
             : columns >= LAYOUT_RAIL_BELOW
                 ? 'tight'
                 : 'rail';
-    // Rail collapse: only happens at the narrowest tier, and only for
-    // the panel that does NOT currently hold focus AND is not being
-    // commandeered by the help overlay. Focus always wins — pressing
-    // tab to the sidebar pops it back open even on an 80-cell terminal
-    // so the user can actually use it. The help overlay also wins for
-    // the inspector since that's where its descriptions render.
-    const sidebarRailed = density === 'rail' && !input.sidebarFocused;
-    const inspectorRailed = density === 'rail' && !input.inspectorFocused && !input.helpOverlayActive;
+    // Below the single-pane breakpoint the three-panel layout can't tile
+    // without starving every pane, so we show exactly one full-width pane
+    // — the focused one — and Tab cycles which pane is visible. This
+    // replaces the retired 8-cell icon rails (an 8-cell stub showed a tab
+    // glyph + count and nothing actionable).
+    const singlePane = columns < LAYOUT_SINGLE_PANE_BELOW;
+    // Which pane shows in single-pane mode. Defaults to the focused pane
+    // (focus and visibility coalesce, so the existing Tab focus cycle
+    // drives it). An active overlay can force a specific pane via
+    // `forcedPane` so its surface isn't hidden behind whatever pane focus
+    // points at.
+    const focusPane = input.sidebarFocused
+        ? 'sidebar'
+        : input.inspectorFocused
+            ? 'inspector'
+            : 'main';
+    const visiblePane = singlePane
+        ? input.forcedPane ?? focusPane
+        : focusPane;
     // Inspector width — at rest 20-32 cells (~22% of width), focused
     // 36-60 cells (~40% of width). Narrow rest state keeps the commit
     // graph dominant; focus expansion gives the inspector room for long
@@ -29806,42 +30094,48 @@ function getLogInkLayout(input) {
     // "Move focus...". Capped at 100 cells so a wide terminal doesn't
     // waste an absurd amount of horizontal space on the cheat sheet.
     //
-    // Rail collapse wins over the at-rest range but loses to focus and
-    // to the help overlay — both of those represent deliberate user
-    // intent to read the panel.
+    // (In single-pane mode these three-panel widths are recomputed below
+    // so the visible pane gets the full terminal.)
     const detailWidth = input.helpOverlayActive
         ? Math.max(60, Math.min(100, Math.floor(columns * 0.50)))
         : input.inspectorFocused
             ? Math.max(36, Math.min(60, Math.floor(columns * 0.40)))
-            : inspectorRailed
-                ? LAYOUT_RAIL_PANEL_WIDTH
-                : Math.max(20, Math.min(32, Math.floor(columns * 0.22)));
+            : Math.max(20, Math.min(32, Math.floor(columns * 0.22)));
     // Sidebar at rest is tier-aware (see `SIDEBAR_AT_REST_BY_TIER`):
     // tight stays compact (22-28), normal shrinks slightly (22-30),
     // wide grows naturally (28-48) so the side panel doesn't get pinned
     // at an arbitrary cap on big terminals while the main panel hogs
     // 80% of the width. Focused: 32-50 cells (~36% of width),
     // regardless of tier — deliberate user intent to read the sidebar
-    // deserves the extra width. Rail mode (narrow terminal, unfocused)
-    // collapses to a fixed 8-cell strip with tab glyphs only.
+    // deserves the extra width.
     const sidebarWidth = input.sidebarFocused
         ? Math.max(32, Math.min(50, Math.floor(columns * 0.36)))
-        : sidebarRailed
-            ? LAYOUT_RAIL_PANEL_WIDTH
-            : calcSidebarAtRestWidth(columns, density);
+        : calcSidebarAtRestWidth(columns, density);
+    // Single-pane mode: exactly one pane renders, full-width; the other
+    // two are hidden (width 0), not railed. Above the breakpoint the
+    // three panels tile flush across the terminal.
+    const paneWidths = singlePane
+        ? {
+            sidebarWidth: visiblePane === 'sidebar' ? columns : 0,
+            mainPanelWidth: visiblePane === 'main' ? columns : 0,
+            detailWidth: visiblePane === 'inspector' ? columns : 0,
+        }
+        : {
+            sidebarWidth,
+            mainPanelWidth: Math.max(20, columns - sidebarWidth - detailWidth),
+            detailWidth,
+        };
     return {
         bodyRows: Math.max(8, rows - 5),
         columns,
-        detailWidth,
-        mainPanelWidth: Math.max(20, columns - sidebarWidth - detailWidth),
         rows,
-        sidebarWidth,
         tooSmall: columns < LOG_INK_MIN_COLUMNS || rows < LOG_INK_MIN_ROWS,
         inspectorTabbed: rows < INSPECTOR_TABBED_BELOW_ROWS,
         density,
-        sidebarRailed,
-        inspectorRailed,
+        singlePane,
+        visiblePane,
         historyRowMode: density === 'rail' ? 'stacked' : 'single',
+        ...paneWidths,
     };
 }
 
@@ -30890,6 +31184,45 @@ async function highlightDiffCode(filePath, lines) {
     return result;
 }
 
+/**
+ * Humanize raw AI-provider / LangChain error strings into a short,
+ * actionable line for the compose surface.
+ *
+ * The underlying errors are verbose and developer-facing — e.g.
+ * `executeChain: Chain execution failed: 429 You exceeded your current
+ * quota …`. We classify the common failure modes (rate limit, auth,
+ * network, context length) into a concise message that tells the user
+ * what happened and what to do, and fall back to the original (trimmed)
+ * text for anything we don't recognize. Pure + tested.
+ */
+function humanizeAiError(raw) {
+    const message = (raw || '').trim();
+    if (!message)
+        return 'AI request failed.';
+    const lower = message.toLowerCase();
+    // Rate limit / quota — the 429 in the screenshot.
+    if (/\b429\b/.test(message) || /rate.?limit|too many requests|exceeded your current quota|quota/i.test(lower)) {
+        return 'Rate limited by your AI provider (429) — too many requests or quota exceeded. Wait a moment, then press I to retry.';
+    }
+    // Auth / API key problems.
+    if (/\b401\b|\b403\b/.test(message) || /unauthor|forbidden|invalid api key|incorrect api key|no api key|authentication/i.test(lower)) {
+        return 'AI provider rejected the request — check your API key (run `coco init`, or press gK to edit the global config).';
+    }
+    // Context window overflow.
+    if (/context length|maximum context|too many tokens|reduce the length|context_length_exceeded/i.test(lower)) {
+        return 'The staged diff is too large for the model’s context window — stage fewer changes (or split the commit) and retry with I.';
+    }
+    // Network / connectivity.
+    if (/etimedout|econnreset|enotfound|econnrefused|network error|fetch failed|socket hang up|timeout/i.test(lower)) {
+        return 'Network error reaching the AI provider — check your connection, then press I to retry.';
+    }
+    // Unknown: strip the noisy `executeChain: Chain execution failed:`
+    // prefix if present so the meaningful part leads, and keep it to one
+    // line so it doesn't blow out the panel.
+    const stripped = message.replace(/^.*?chain execution failed:\s*/i, '').trim() || message;
+    return stripped.split('\n')[0];
+}
+
 async function runAction$4(action, successMessage) {
     try {
         await action();
@@ -30933,15 +31266,104 @@ async function runAction$3(action, successMessage) {
         };
     }
 }
-function createStash(git, message) {
+function createStash(git, message, options = {}) {
     const trimmedMessage = message.trim();
-    if (!trimmedMessage) {
-        return Promise.resolve({
-            ok: false,
-            message: 'Stash cancelled: empty message.',
-        });
+    const args = ['stash', 'push'];
+    // `--staged` is index-only, so untracked / `--keep-index` don't apply;
+    // every other mode includes untracked (`-u`). `--keep-index` leaves the
+    // index populated for an immediate follow-up commit.
+    if (options.stagedOnly) {
+        args.push('--staged');
+    }
+    else {
+        args.push('-u');
+        if (options.keepIndex)
+            args.push('--keep-index');
+    }
+    if (trimmedMessage)
+        args.push('-m', trimmedMessage);
+    const paths = options.pathspec?.trim();
+    if (paths)
+        args.push('--', ...paths.split(/\s+/));
+    const what = options.stagedOnly
+        ? 'staged changes'
+        : paths
+            ? `“${paths}”`
+            : options.keepIndex
+                ? 'changes (index kept)'
+                : '';
+    const success = trimmedMessage
+        ? `Created stash: ${trimmedMessage}`
+        : what
+            ? `Stashed ${what}`
+            : 'Created WIP stash';
+    return runAction$3(() => git.raw(args), success);
+}
+/**
+ * Apply a stash while restoring the original staged/unstaged split via
+ * `--index`. Faithfully reinstates what was staged at stash time; git
+ * errors (surfaced to the user) if the index can no longer be replayed,
+ * in which case plain `applyStash` is the fallback.
+ */
+function applyStashKeepIndex(git, stash) {
+    return runAction$3(() => git.raw(['stash', 'apply', '--index', stash.ref]), `Applied ${stash.ref} (index restored)`);
+}
+/**
+ * Create a new branch from a stash's base commit, apply the stash onto
+ * it, and drop the stash on success — `git stash branch`. The canonical
+ * recovery when a stash no longer applies cleanly onto the current
+ * branch (the branch starts at the exact commit the stash was made on).
+ */
+function stashBranch(git, stash, branchName) {
+    const trimmed = branchName.trim();
+    if (!trimmed) {
+        return Promise.resolve({ ok: false, message: 'Cancelled: empty branch name.' });
+    }
+    return runAction$3(() => git.raw(['stash', 'branch', trimmed, stash.ref]), `Created branch ${trimmed} from ${stash.ref}`);
+}
+/**
+ * Rename a stash. Git has no native rename, so: drop the original entry,
+ * then re-store the SAME commit under the new message.
+ *
+ * Order matters — and it's the OPPOSITE of what you'd guess. `git stash
+ * store` SILENTLY NO-OPS when the commit is already referenced in the
+ * stash reflog (verified empirically), so storing first does nothing and
+ * a follow-up drop removes the wrong entry. Dropping first removes the
+ * reflog reference (the commit object survives), so the subsequent
+ * `store` actually re-adds it — landing at `stash@{0}` with the new
+ * message. The commit is captured by hash beforehand, so the drop→store
+ * window can't lose it.
+ */
+function renameStash(git, stash, newMessage) {
+    const trimmed = newMessage.trim();
+    if (!trimmed) {
+        return Promise.resolve({ ok: false, message: 'Rename cancelled: empty message.' });
+    }
+    if (!stash.hash) {
+        return Promise.resolve({ ok: false, message: 'Cannot rename: stash commit hash unavailable.' });
+    }
+    // Preserve git's `On <branch>: <subject>` convention so the renamed
+    // stash keeps its origin-branch context. The list + inspector parse the
+    // branch out of that prefix (`parseStashSubject`); a bare message would
+    // render `on <unknown>`. Falls back to the bare message when the branch
+    // is unknown so we never store a misleading `On <unknown>:`.
+    const branch = stash.branch && stash.branch !== '<unknown>' ? stash.branch : '';
+    const storedMessage = branch ? `On ${branch}: ${trimmed}` : trimmed;
+    return runAction$3(async () => {
+        await git.raw(['stash', 'drop', stash.ref]);
+        await git.raw(['stash', 'store', '-m', storedMessage, stash.hash]);
+    }, `Renamed ${stash.ref} → ${trimmed}`);
+}
+/**
+ * Re-store a previously dropped stash by its commit hash — the undo for
+ * a `dropStash`. The dropped stash's commit stays in the object database
+ * until git gc, so storing it back recreates the entry (at `stash@{0}`).
+ */
+function restoreStash(git, hash, message) {
+    if (!hash) {
+        return Promise.resolve({ ok: false, message: 'Nothing to restore.' });
     }
-    return runAction$3(() => git.raw(['stash', 'push', '-u', '-m', trimmedMessage]), `Created stash: ${trimmedMessage}`);
+    return runAction$3(() => git.raw(['stash', 'store', '-m', message || 'restored stash', hash]), 'Restored dropped stash');
 }
 function applyStash(git, stash) {
     return runAction$3(() => git.raw(['stash', 'apply', stash.ref]), `Applied ${stash.ref}`);
@@ -31814,6 +32236,28 @@ function unstageAllFiles(git, files) {
     }
     return runAction(() => git.raw(['restore', '--staged', '--', ...files.map((file) => file.path)]), `Unstaged ${files.length} ${files.length === 1 ? 'file' : 'files'}`);
 }
+/**
+ * Stage everything in the worktree — modifications, new files, and
+ * deletions — in one shot (`git add -A`). The `A` hotkey + the `:`
+ * palette's "stage all" both route here.
+ */
+function stageAll(git) {
+    return runAction(() => git.raw(['add', '-A']), 'Staged all changes');
+}
+/**
+ * Stage files matching one or more git pathspecs (`git add -- <spec…>`).
+ * Powers the typed "stage…" prompt (`+`): the user types a path, a
+ * directory, a glob like `*.ts`, or a space-separated list, and git's
+ * own pathspec matching does the rest. Args are passed directly (no
+ * shell), so the globs are interpreted by git, not the shell.
+ */
+function stagePathspec(git, pathspec) {
+    const specs = pathspec.trim().split(/\s+/).filter(Boolean);
+    if (specs.length === 0) {
+        return Promise.resolve({ ok: false, message: 'Enter a pathspec to stage (e.g. . or src/ or *.ts).' });
+    }
+    return runAction(() => git.raw(['add', '--', ...specs]), `Staged ${specs.join(' ')}`);
+}
 
 function hunkHeader(hunk) {
     return `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`;
@@ -32390,7 +32834,7 @@ function buildLoadedHashSet(commits) {
  * 5a.7 of #890. Two-row layout introduced post-0.54.2; per-kind
  * colors + glyphs added in the same pass.
  */
-function renderFooter$1(h, components, state, context, theme, idleTip, spinnerFrame = 0) {
+function renderFooter$1(h, components, state, context, theme, idleTip, spinnerFrame = 0, singlePane = false) {
     const { Box, Text } = components;
     // Sidebar item count drives the per-tab footer hints — when items are
     // present the footer surfaces in-sidebar ops (checkout / apply / pop /
@@ -32404,6 +32848,23 @@ function renderFooter$1(h, components, state, context, theme, idleTip, spinnerFr
             default: return undefined;
         }
     })();
+    // The single-pane pane switcher only makes sense in the plain
+    // per-pane states. While an overlay or filter owns the screen the
+    // visible pane is forced (split-plan → main; help / palette / theme /
+    // gitignore / input prompt / confirmation / chord → inspector) or
+    // input is captured, and Tab does something else — so the switcher
+    // would point at a pane that isn't on screen. Suppress it then. Mirror
+    // of the runtime's `forcedPane` derivation in `app.ts`.
+    const overlayForcesPane = Boolean(state.splitPlan ||
+        state.showHelp ||
+        state.showCommandPalette ||
+        state.showThemePicker ||
+        state.gitignorePicker ||
+        state.inputPrompt ||
+        state.pendingConfirmationId ||
+        state.pendingMutationConfirmation ||
+        state.pendingKey ||
+        state.filterMode);
     const hints = getLogInkFooterHints({
         activeView: state.activeView,
         diffSource: state.diffSource,
@@ -32417,6 +32878,12 @@ function renderFooter$1(h, components, state, context, theme, idleTip, spinnerFr
         sidebarItemCount,
         compareBaseSet: Boolean(state.compareBase),
         splitPlanStatus: state.splitPlan?.status,
+        singlePane: singlePane && !overlayForcesPane,
+        // Peeking (#1135 v2) is a single-pane glance with focus on the
+        // sidebar; the footer shows `v/esc → main` instead of the switcher.
+        // Suppressed under an overlay (which owns the footer) just like the
+        // switcher.
+        peeking: Boolean(state.peekReturnFocus) && singlePane && !overlayForcesPane,
     });
     // Real status messages always win; idle tips only fill the slot when it
     // would otherwise be empty.
@@ -32912,7 +33379,10 @@ function sidebarTabCount(tab, context) {
  * Header chip builder. Turns the workstation's title-bar state into an
  * ordered list of small visually-distinct chips:
  *
- *   coco · gfargo/coco · ⎇ main · ✓ clean · ⊘ no PR · [NORMAL]
+ *   coco · gfargo/coco · ⎇ main · ✓ clean · [NORMAL]
+ *
+ * The PR chip is appended only when a pull request exists (#1133); there
+ * is no "no PR" placeholder chip.
  *
  * Pre-refactor the title bar concatenated every segment into a single
  * Text span, which made the eye read the whole thing as one run of
@@ -33008,10 +33478,11 @@ function buildHeaderChips(input) {
             bold: true,
         });
     }
-    // PR state. When present, the chip uses the PR-state glyph + a short
-    // label ("PR #1234 OPEN" / "PR #1234 DRAFT"). When absent, a muted
-    // "no PR" chip so users know the system DID look (vs. the bar just
-    // being blank).
+    // PR state. Shown only when a PR actually exists — the chip uses the
+    // PR-state glyph + a short label ("PR #1234 OPEN" / "PR #1234 DRAFT").
+    // The old always-on "no PR" chip spent a permanent header segment to
+    // report a negative default state on every screen; dropping it keeps
+    // the state cluster about what *is* true (TUI audit).
     if (input.pullRequest) {
         const prGlyph = getPullRequestStateGlyph({ ...input.pullRequest, isDraft: Boolean(input.pullRequest.isDraft) }, theme);
         const stateLabel = input.pullRequest.isDraft
@@ -33028,15 +33499,6 @@ function buildHeaderChips(input) {
             bold: false,
         });
     }
-    else {
-        chips.push({
-            id: 'pr',
-            label: theme.ascii ? '- no PR' : '⊘ no PR',
-            color: theme.colors.muted,
-            dim: true,
-            bold: false,
-        });
-    }
     // View breadcrumb. Rendered only when there's content (`coco ui`
     // root view → no breadcrumb chip; pushed into a sub-view → chip
     // appears). Comes AFTER PR so the "state" group (app/repo/branch/
@@ -33107,7 +33569,10 @@ function measureHeaderChipsWidth(chips) {
  * Title-bar renderer. Surfaces the workstation's identity + navigation
  * state as a row of small visually-distinct chips:
  *
- *   coco · gfargo/coco · ⎇ main · ✓ clean · ⊘ no PR · [NORMAL]
+ *   coco · gfargo/coco · ⎇ main · ✓ clean · [NORMAL]
+ *
+ * The PR chip is appended only when a pull request exists (e.g.
+ * `· ⊠ PR #1234 OPEN`); there's no "no PR" placeholder chip.
  *
  * Per-chip color/glyph treatment lets the user scan in chunks ("what
  * app, what repo, what branch, how clean, what PR state, what mode")
@@ -33547,70 +34012,10 @@ function renderActiveSidebarContent(h, Text, tab, state, context, contextStatus,
         return `${marker} ${worktree.branch || worktree.path} ${wstate}`;
     }, 'tab-worktrees', visibleListCount);
 }
-/**
- * Single-letter glyph for a sidebar tab in rail mode. Letters always
- * carry the meaning so this stays useful under ASCII; the rail is too
- * narrow to fit the full tab label. Pairs with `sidebarTabCount` for
- * the trailing count.
- */
-function sidebarTabRailGlyph(tab) {
-    switch (tab) {
-        case 'status':
-            return 'S';
-        case 'branches':
-            return 'B';
-        case 'tags':
-            return 'T';
-        case 'stashes':
-            return '$';
-        case 'worktrees':
-            return 'W';
-        default:
-            return '·';
-    }
-}
-/**
- * Rail-mode sidebar — shown on terminals < 100 columns when the
- * sidebar does not hold focus. Five vertically stacked tab glyphs
- * with optional counts; the active tab is bracketed. Pressing Tab to
- * focus the sidebar pops it back to the full accordion (the layout
- * un-rails it on focus, this renderer is never called in that case).
- */
-function renderSidebarRail$1(h, components, state, context, width, theme, focused, tabs) {
-    const { Box, Text } = components;
-    return h(Box, {
-        borderColor: focusBorderColor(theme, focused),
-        borderStyle: theme.borderStyle,
-        flexDirection: 'column',
-        width,
-        paddingX: 1,
-    }, h(Text, { bold: true, dimColor: !focused }, 'Repo'), h(Text, { dimColor: true }, '────'), ...tabs.map((tab) => {
-        const isActive = tab === state.sidebarTab;
-        const glyph = sidebarTabRailGlyph(tab);
-        const count = sidebarTabCount(tab, context);
-        // Count fits in 2 cells (rail content area is ~4 cells); 99+
-        // collapses to `+` so we never overflow.
-        const countText = count === undefined
-            ? ''
-            : count > 99
-                ? '+'
-                : String(count);
-        const body = isActive ? `[${glyph}]` : ` ${glyph} `;
-        const text = countText ? `${body}${countText}` : body;
-        return h(Text, {
-            key: `rail-${tab}`,
-            bold: isActive,
-            dimColor: !isActive,
-        }, text);
-    }));
-}
-function renderSidebar$1(h, components, state, context, contextStatus, width, bodyRows, theme, railed = false) {
+function renderSidebar$1(h, components, state, context, contextStatus, width, bodyRows, theme) {
     const { Box, Text } = components;
     const focused = state.focus === 'sidebar';
     const tabs = getLogInkSidebarTabs();
-    if (railed) {
-        return renderSidebarRail$1(h, components, state, context, width, theme, focused, tabs);
-    }
     // 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.
@@ -33669,7 +34074,8 @@ function renderSidebar$1(h, components, state, context, contextStatus, width, bo
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.1
  * of #890. No behavior change.
  */
-function renderBisectSurface(h, components, state, context, contextStatus, candidateDetail, candidateLoading, bodyRows, width, theme) {
+function renderBisectSurface(ctx, candidateDetail, candidateLoading) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const loading = isLogInkContextKeyLoading(contextStatus, 'bisect');
@@ -33993,7 +34399,8 @@ function formatLogInkGitHubNoRemote({ resource, }) {
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.2
  * of #890. No behavior change.
  */
-function renderBranchesSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+function renderBranchesSurface(ctx) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const branches = context.branches;
@@ -34139,7 +34546,8 @@ function formatCacheAge(generatedAt, now) {
     const day = Math.floor(hr / 24);
     return `${day}d ago`;
 }
-function renderChangelogSurface(h, components, state, _context, _contextStatus, bodyRows, width, theme) {
+function renderChangelogSurface(ctx) {
+    const { h, components, state, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const view = state.changelogView;
@@ -34331,7 +34739,8 @@ function renderStreamingPreviewLines(h, components, preview, width, theme) {
         }, `${prefix}${line}`);
     });
 }
-function renderComposeSurface(h, components, state, context, contextStatus, bodyRows, width, theme, spinnerFrame = 0) {
+function renderComposeSurface(ctx, spinnerFrame = 0) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const compose = state.commitCompose;
     const focused = state.focus === 'commits';
@@ -34444,7 +34853,8 @@ function renderComposeSurface(h, components, state, context, contextStatus, body
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.3
  * of #890. No behavior change.
  */
-function renderConflictsSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+function renderConflictsSurface(ctx) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const loading = isLogInkContextKeyLoading(contextStatus, 'operation');
@@ -34913,6 +35323,50 @@ function renderDiffLine(h, Text, line, theme, syntaxSpans, maxCells, key) {
     return h(Text, { key }, h(Text, { key: `${key}-m`, color: markerColor }, marker), ...children);
 }
 
+/** The hunk index owning `absLine`, or -1 for pre-hunk header/label rows. */
+function hunkIndexForLine(absLine, hunkOffsets) {
+    let index = -1;
+    for (let k = 0; k < hunkOffsets.length; k++) {
+        if (hunkOffsets[k] <= absLine)
+            index = k;
+        else
+            break;
+    }
+    return index;
+}
+function renderWorktreeDiffBody(h, components, params) {
+    const { Box, Text } = components;
+    const { lines, offset, visibleRows, width, theme, syntaxSpans, hunkOffsets, hunks, selectedIndex, keyPrefix } = params;
+    const headerSet = new Set(hunkOffsets);
+    const accent = theme.noColor ? undefined : theme.colors.accent;
+    const added = theme.noColor ? undefined : theme.colors.gitAdded;
+    const codeWidth = Math.max(8, width - 5); // 2 chrome + 1 gutter + slack
+    const visible = lines.slice(offset, offset + visibleRows);
+    return visible.map((line, i) => {
+        const abs = offset + i;
+        const key = `${keyPrefix}-${abs}`;
+        const hunkIndex = hunkIndexForLine(abs, hunkOffsets);
+        const hunk = hunkIndex >= 0 ? hunks[hunkIndex] : undefined;
+        const isSelected = hunkIndex >= 0 && hunkIndex === selectedIndex;
+        const isStaged = hunk?.state === 'staged';
+        const bar = isSelected ? '▎' : ' ';
+        // `@@` header row — badge + (dim) hunk position, emphasized when selected.
+        if (headerSet.has(abs)) {
+            const badge = theme.ascii ? (isStaged ? '[x] ' : '[ ] ') : (isStaged ? '● ' : '○ ');
+            const badgeColor = theme.noColor ? undefined : isStaged ? added : theme.colors.muted;
+            return h(Box, { key, flexDirection: 'row' }, h(Text, { color: accent }, bar), h(Text, { color: badgeColor, bold: isSelected }, badge), h(Text, { bold: isSelected, color: isSelected ? accent : (theme.noColor ? undefined : theme.colors.muted) }, truncateCells(line, codeWidth)));
+        }
+        // Body / context / pre-hunk lines.
+        // A staged hunk that ISN'T selected renders dim ("done", out of
+        // focus); the selected hunk and unstaged hunks keep full diff +
+        // syntax coloring via renderDiffLine so the focus stays vivid.
+        const content = isStaged && !isSelected && hunkIndex >= 0
+            ? h(Text, { key: `${key}-c`, dimColor: true }, truncateCells(line, codeWidth))
+            : renderDiffLine(h, Text, line, theme, syntaxSpans, codeWidth, `${key}-c`);
+        return h(Box, { key, flexDirection: 'row' }, h(Text, { color: accent }, bar), content);
+    });
+}
+
 /**
  * Diff surface — the unified or side-by-side diff view. Four sources
  * route through here, disambiguated by `state.diffSource`:
@@ -34935,7 +35389,9 @@ function renderDiffLine(h, Text, line, theme, syntaxSpans, maxCells, key) {
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.4
  * of #890. No behavior change.
  */
-function renderDiffSurface(h, components, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, bodyRows, width, theme, syntaxSpans) {
+function renderDiffSurface(ctx, diff) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
+    const { worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, syntaxSpans, } = diff;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const worktree = context.worktree;
@@ -35106,7 +35562,8 @@ function renderDiffSurface(h, components, state, context, contextStatus, worktre
             ? [`Loading diff for ${selectedDetailFile?.path || 'selected file'}...`]
             : previewHunks.length
                 ? [
-                    `Selected file: ${selectedDetailFile?.path || ''}`,
+                    // File path is already shown in the panel title bar (right) —
+                    // no redundant "Selected file:" line here.
                     currentHunkLabel,
                     `Lines ${Math.min(state.diffPreviewOffset + 1, previewHunks.length || 1)}-${Math.min(state.diffPreviewOffset + visiblePreviewHunks.length, previewHunks.length)}/${previewHunks.length}`,
                     '',
@@ -35134,19 +35591,31 @@ function renderDiffSurface(h, components, state, context, contextStatus, worktre
     }
     const diffLines = worktreeDiff?.lines || [];
     const selectedHunk = worktreeHunks?.hunks[state.selectedWorktreeHunkIndex];
+    const totalHunks = worktreeHunks?.hunks.length ?? 0;
+    const stagedHunks = worktreeHunks?.hunks.filter((hunk) => hunk.state === 'staged').length ?? 0;
     const visibleDiffLines = diffLines.slice(state.worktreeDiffOffset, state.worktreeDiffOffset + visibleRows);
+    // Hunk-position line: badge + selected hunk's state + a staged/total
+    // progress count, so the user always sees how far through staging they
+    // are. Untracked/new files have no hunks — point them at whole-file
+    // staging instead of a dead-end "no hunks" message.
+    const hunkHeaderLine = worktreeHunksLoading
+        ? 'Hunks loading…'
+        : worktreeDiff?.untracked
+            ? (theme.ascii ? 'New file — press space to stage it whole.' : '✚ New file — press space to stage it whole.')
+            : totalHunks
+                ? `Hunk ${state.selectedWorktreeHunkIndex + 1}/${totalHunks} · ${selectedHunk?.state === 'staged'
+                    ? (theme.ascii ? '[x] staged' : '● staged')
+                    : (theme.ascii ? '[ ] unstaged' : '○ unstaged')} · ${stagedHunks}/${totalHunks} staged`
+                : 'No stageable hunks for this file.';
     const headerLines = isLogInkContextKeyLoading(contextStatus, 'worktree')
         ? ['Loading file context...']
         : worktreeDiffLoading
             ? [`Loading diff for ${worktreeFile?.path || 'selected file'}...`]
             : worktreeFile
                 ? [
-                    `Selected file: ${worktreeFile.path}`,
-                    worktreeHunksLoading
-                        ? 'Hunks loading...'
-                        : worktreeHunks?.hunks.length
-                            ? `Hunk ${state.selectedWorktreeHunkIndex + 1}/${worktreeHunks.hunks.length} ${selectedHunk?.state || ''}`
-                            : 'No stageable hunks for this file.',
+                    // File path is already shown in the panel title bar (right) —
+                    // no redundant "Selected file:" line here.
+                    hunkHeaderLine,
                     `Lines ${Math.min(state.worktreeDiffOffset + 1, diffLines.length || 1)}-${Math.min(state.worktreeDiffOffset + visibleDiffLines.length, diffLines.length)}/${diffLines.length}`,
                     '',
                 ]
@@ -35161,11 +35630,26 @@ function renderDiffSurface(h, components, state, context, contextStatus, worktre
         flexShrink: 0,
         paddingX: 1,
         width,
-    }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Diff', focused)), h(Text, { dimColor: true }, worktreeFile ? worktreeFile.path : 'no file')), ...headerLines.map((line, index) => h(Text, {
+    }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Diff', focused)), 
+    // Use the path of the file actually being diffed (the grouped/visible
+    // selection feeds the loaded diff) — `worktreeFile` indexes the raw,
+    // ungrouped file list and can name a different file than the diff body.
+    h(Text, { dimColor: true }, worktreeDiff?.filePath || worktreeFile?.path || 'no file')), ...headerLines.map((line, index) => h(Text, {
         key: `diff-surface-header-${index}`,
         dimColor: index > 0,
     }, truncateCells(line, 140))), ...(showDiffLines
-        ? visibleDiffLines.map((line, index) => renderDiffLine(h, Text, line, theme, syntaxSpans, 140, `diff-surface-line-${state.worktreeDiffOffset + index}`))
+        ? renderWorktreeDiffBody(h, components, {
+            lines: diffLines,
+            offset: state.worktreeDiffOffset,
+            visibleRows,
+            width,
+            theme,
+            syntaxSpans,
+            hunkOffsets: worktreeDiff?.hunkOffsets || [],
+            hunks: worktreeHunks?.hunks || [],
+            selectedIndex: state.selectedWorktreeHunkIndex,
+            keyPrefix: 'diff-surface-line',
+        })
         : []));
 }
 
@@ -36349,7 +36833,8 @@ function renderRemoteOpLoader(h, components, state, width, bodyRows, theme, focu
         height: innerHeight,
     }, h(Text, { color: accent, bold: true }, `${spinner}  ${op.label}`), h(Text, undefined, ''), h(Text, { color: accent }, track), h(Text, undefined, ''), h(Text, { dimColor: true }, 'Talking to the remote — history refreshes automatically.')));
 }
-function renderHistoryPanel(h, components, state, context, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits, density, rowMode, dateBucketingEnabled = false, now = getRenderNow(), spinnerFrame = 0) {
+function renderHistoryPanel(ctx, hasMoreCommits, loadingMoreCommits, density, rowMode, dateBucketingEnabled = false, now = getRenderNow(), spinnerFrame = 0) {
+    const { h, components, state, context, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     // Remote op in flight (fetch / pull / push) → swap the commit list
@@ -37051,7 +37536,8 @@ function matchesIssueFilter(issue, filter) {
         ...(issue.assignees || []),
     ], filter);
 }
-function renderIssuesTriageSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+function renderIssuesTriageSurface(ctx) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const overview = context.issueList;
@@ -37333,7 +37819,8 @@ function formatPullRequestStateLine(pr) {
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.2
  * of #890. No behavior change.
  */
-function renderPullRequestSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+function renderPullRequestSurface(ctx) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const loading = isLogInkContextKeyLoading(contextStatus, 'pullRequest');
@@ -37506,7 +37993,8 @@ function matchesPullRequestFilter(pr, filter) {
         ...(pr.assignees || []),
     ], filter);
 }
-function renderPullRequestTriageSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+function renderPullRequestTriageSurface(ctx) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const overview = context.pullRequestList;
@@ -37622,7 +38110,8 @@ function renderPullRequestTriageSurface(h, components, state, context, contextSt
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.1
  * of #890. No behavior change.
  */
-function renderReflogSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+function renderReflogSurface(ctx) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const loading = isLogInkContextKeyLoading(contextStatus, 'reflog');
@@ -37693,7 +38182,8 @@ function renderReflogSurface(h, components, state, context, contextStatus, bodyR
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.1
  * of #890. No behavior change.
  */
-function renderStashSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+function renderStashSurface(ctx) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const loading = isLogInkContextKeyLoading(contextStatus, 'stashes');
@@ -37711,6 +38201,11 @@ function renderStashSurface(h, components, state, context, contextStatus, bodyRo
         : `${stashes.length}/${allStashes.length} stashes${filterLabel}`;
     const emptyLabel = formatLogInkStashEmpty({ filter: state.filter });
     const loadingLabel = formatLogInkLoading({ resource: 'stashes' });
+    const now = getRenderNow();
+    // Available width for a row: box width minus the 2-cell horizontal
+    // padding. Truncate to it (with a small floor) instead of a magic 140
+    // so the richer meta degrades gracefully on narrow terminals.
+    const rowWidth = Math.max(20, width - 2);
     const lines = loading
         ? [h(Text, { key: 'stash-loading', dimColor: true }, loadingLabel)]
         : stashes.length === 0
@@ -37719,11 +38214,25 @@ function renderStashSurface(h, components, state, context, contextStatus, bodyRo
                 const index = startIndex + offset;
                 const isSelected = index === selected;
                 const cursor = isSelected ? '>' : ' ';
+                // Surface the metadata the StashEntry already carries — origin
+                // branch, file count, and relative age — between the ref and the
+                // message, so the list answers "which stash is this?" without an
+                // Enter→diff round trip.
+                const age = formatCompactRelativeDate(stash.date, now);
+                const fileCount = stash.files.length;
+                const meta = [
+                    stash.branch ? `on ${stash.branch}` : '',
+                    fileCount > 0 ? `${fileCount} file${fileCount === 1 ? '' : 's'}` : '',
+                    age,
+                ].filter(Boolean).join(' · ');
+                const rowText = meta
+                    ? `${cursor} ${stash.ref.padEnd(11)} ${meta}  ${stash.message}`
+                    : `${cursor} ${stash.ref.padEnd(11)} ${stash.message}`;
                 return h(Text, {
                     key: `stash-${index}`,
                     bold: isSelected,
                     dimColor: !isSelected,
-                }, truncateCells(`${cursor} ${stash.ref.padEnd(12)} ${stash.message}`, 140));
+                }, truncateCells(rowText, rowWidth));
             });
     const stashHasMoreAbove = startIndex > 0 && stashes.length > 0;
     const stashHasMoreBelow = startIndex + listRows < stashes.length;
@@ -37783,7 +38292,8 @@ function formatStatusFilterMask(mask) {
         active.push('untracked');
     return active.join(' + ') || 'none';
 }
-function renderStatusSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+function renderStatusSurface(ctx) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const worktree = context.worktree;
@@ -37930,7 +38440,8 @@ function flagColor(flag, theme) {
         return theme.colors.danger;
     return undefined;
 }
-function renderSubmodulesSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+function renderSubmodulesSurface(ctx) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const loading = isLogInkContextKeyLoading(contextStatus, 'submodules');
@@ -38069,7 +38580,8 @@ function formatHyperlink(text, url, env = process.env) {
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.2
  * of #890. No behavior change.
  */
-function renderTagsSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+function renderTagsSurface(ctx) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const loading = isLogInkContextKeyLoading(contextStatus, 'tags');
@@ -38151,7 +38663,8 @@ function renderTagsSurface(h, components, state, context, contextStatus, bodyRow
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.1
  * of #890. No behavior change.
  */
-function renderWorktreesSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+function renderWorktreesSurface(ctx) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const loading = isLogInkContextKeyLoading(contextStatus, 'worktreeList');
@@ -38215,7 +38728,12 @@ function renderWorktreesSurface(h, components, state, context, contextStatus, bo
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.7
  * of #890. No behavior change.
  */
-function renderMainPanel(h, components, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, bisectCandidateDetail, bisectCandidateLoading, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits, spinnerFrame, density, rowMode, dateBucketingEnabled, syntaxSpans) {
+function renderMainPanel(surface, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, bisectCandidateDetail, bisectCandidateLoading, hasMoreCommits, loadingMoreCommits, spinnerFrame, density, rowMode, dateBucketingEnabled, syntaxSpans) {
+    // The universal render values now arrive bundled (#1136); only the
+    // few raw values the dispatcher itself touches (split-plan overlay,
+    // activeView switch) are destructured here. Surfaces receive `surface`
+    // directly plus their own slices.
+    const { h, components, state, bodyRows, width, theme } = surface;
     // Split-plan overlay (#907 polish): renders in the MAIN panel (not
     // detail) when active, because the content — multiple commit groups
     // with file lists, rationale, hunks — needs the full center width
@@ -38227,51 +38745,66 @@ function renderMainPanel(h, components, state, context, contextStatus, worktreeD
         return renderSplitPlanOverlay(h, components, state, width, bodyRows, theme, true, spinnerFrame);
     }
     if (state.activeView === 'status') {
-        return renderStatusSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+        return renderStatusSurface(surface);
     }
     if (state.activeView === 'diff') {
-        return renderDiffSurface(h, components, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, bodyRows, width, theme, syntaxSpans);
+        const diffData = {
+            worktreeDiff,
+            worktreeDiffLoading,
+            worktreeHunks,
+            worktreeHunksLoading,
+            filePreview,
+            filePreviewLoading,
+            commitDiffHunkOffsets,
+            selectedDetailFile,
+            stashDiffLines,
+            stashDiffLoading,
+            compareDiffLines,
+            compareDiffLoading,
+            syntaxSpans,
+        };
+        return renderDiffSurface(surface, diffData);
     }
     if (state.activeView === 'compose') {
-        return renderComposeSurface(h, components, state, context, contextStatus, bodyRows, width, theme, spinnerFrame);
+        return renderComposeSurface(surface, spinnerFrame);
     }
     if (state.activeView === 'branches') {
-        return renderBranchesSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+        return renderBranchesSurface(surface);
     }
     if (state.activeView === 'tags') {
-        return renderTagsSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+        return renderTagsSurface(surface);
     }
     if (state.activeView === 'reflog') {
-        return renderReflogSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+        return renderReflogSurface(surface);
     }
     if (state.activeView === 'bisect') {
-        return renderBisectSurface(h, components, state, context, contextStatus, bisectCandidateDetail, bisectCandidateLoading, bodyRows, width, theme);
+        return renderBisectSurface(surface, bisectCandidateDetail, bisectCandidateLoading);
     }
     if (state.activeView === 'stash') {
-        return renderStashSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+        return renderStashSurface(surface);
     }
     if (state.activeView === 'worktrees') {
-        return renderWorktreesSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+        return renderWorktreesSurface(surface);
     }
     if (state.activeView === 'submodules') {
-        return renderSubmodulesSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+        return renderSubmodulesSurface(surface);
     }
     if (state.activeView === 'pull-request') {
-        return renderPullRequestSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+        return renderPullRequestSurface(surface);
     }
     if (state.activeView === 'pull-request-triage') {
-        return renderPullRequestTriageSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+        return renderPullRequestTriageSurface(surface);
     }
     if (state.activeView === 'issues') {
-        return renderIssuesTriageSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+        return renderIssuesTriageSurface(surface);
     }
     if (state.activeView === 'conflicts') {
-        return renderConflictsSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+        return renderConflictsSurface(surface);
     }
     if (state.activeView === 'changelog') {
-        return renderChangelogSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+        return renderChangelogSurface(surface);
     }
-    return renderHistoryPanel(h, components, state, context, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits, density, rowMode, dateBucketingEnabled, undefined, spinnerFrame);
+    return renderHistoryPanel(surface, hasMoreCommits, loadingMoreCommits, density, rowMode, dateBucketingEnabled, undefined, spinnerFrame);
 }
 
 /**
@@ -39144,21 +39677,16 @@ function renderCommitPanel(h, components, state, context, contextStatus, width,
     const bodyVisualLines = bodyHasContent
         ? compose.body.split('\n').flatMap((line) => wrapCells(line, bodyTextWidth)).slice(0, 12)
         : ['<empty>'];
-    const summaryWrapped = wrapCells(`${compose.summary || '<empty>'}${summaryCursor}`, bodyTextWidth);
-    const summaryFirst = `${compose.field === 'summary' && compose.editing ? '>' : ' '} Summary: ${summaryWrapped[0] || ''}`;
-    const summaryRest = summaryWrapped.slice(1).map((line) => `           ${line}`);
-    const headerLines = [
-        statusLine,
-        '',
-        summaryFirst,
-        ...summaryRest,
-        `${compose.field === 'body' && compose.editing ? '>' : ' '} Body:`,
-        ...bodyVisualLines.map((line, index) => {
-            const isLast = index === bodyVisualLines.length - 1;
-            return `  ${line}${bodyCursor && isLast ? bodyCursor : ''}`;
-        }),
-        '',
-    ];
+    const hasSummary = Boolean(compose.summary);
+    const summaryMarker = compose.field === 'summary' && compose.editing ? '>' : ' ';
+    const bodyMarker = compose.field === 'body' && compose.editing ? '>' : ' ';
+    // The generated subject is the thing the user is looking for — render
+    // it bold + accent so it pops out of the inspector instead of blending
+    // into the dim label/body text. The `Summary:` label stays dim.
+    const summaryLabel = `${summaryMarker} Summary: `;
+    const summaryColor = hasSummary && !theme.noColor ? theme.colors.accent : undefined;
+    const summaryValueWidth = Math.max(4, width - 4 - cellWidth(summaryLabel));
+    const summaryWrapped = wrapCells(`${compose.summary || '<empty>'}${summaryCursor}`, summaryValueWidth);
     const trailerLines = [
         ...(compose.message ? ['', compose.message] : []),
         ...(compose.details || []).map((line) => `  ${line}`),
@@ -39172,10 +39700,26 @@ function renderCommitPanel(h, components, state, context, contextStatus, width,
         flexDirection: 'column',
         width,
         paddingX: 1,
-    }, h(Text, { bold: true }, panelTitle('Commit', focused)), ...headerLines.map((line, index) => h(Text, {
-        key: `commit-header-${index}`,
-        dimColor: index < 2 || line.startsWith('  ') || line === '<empty>',
-    }, truncateCells(line, width - 4))), 
+    }, h(Text, { bold: true }, panelTitle('Commit', focused)), h(Text, { key: 'commit-status', dimColor: true }, truncateCells(statusLine, width - 4)), h(Text, { key: 'commit-spacer-1' }, ''), 
+    // Summary: dim label + the subject value emphasized so it's easy to spot.
+    h(Text, { key: 'commit-summary' }, h(Text, { dimColor: true }, summaryLabel), h(Text, {
+        bold: hasSummary,
+        color: summaryColor,
+        dimColor: !hasSummary,
+    }, summaryWrapped[0] || '<empty>')), ...summaryWrapped.slice(1).map((line, index) => h(Text, {
+        key: `commit-summary-rest-${index}`,
+        bold: true,
+        color: summaryColor,
+    }, truncateCells(`${' '.repeat(cellWidth(summaryLabel))}${line}`, width - 4))), h(Text, {
+        key: 'commit-body-label',
+        dimColor: !(compose.field === 'body' && compose.editing),
+    }, truncateCells(`${bodyMarker} Body:`, width - 4)), ...bodyVisualLines.map((line, index) => {
+        const isLast = index === bodyVisualLines.length - 1;
+        return h(Text, {
+            key: `commit-body-${index}`,
+            dimColor: true,
+        }, truncateCells(`  ${line}${bodyCursor && isLast ? bodyCursor : ''}`, width - 4));
+    }), h(Text, { key: 'commit-spacer-2' }, ''), 
     // 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
@@ -39266,41 +39810,11 @@ function renderPullRequestTriagePreviewPanel(h, components, state, context, cont
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.7
  * of #890. No behavior change.
  */
-/**
- * Rail-mode inspector — shown on terminals < 100 columns when the
- * detail panel does not hold focus. The full inspector (commit body,
- * file list, actions) does not survive truncation to ~4 content cells
- * so we collapse to a stack with the panel label and the selected
- * commit's shortHash. Focus pops the panel back to its expanded
- * widths via the layout, so this renderer is only reached at rest.
- *
- * Help / overlay states are still handled by their own renderers
- * above; this short-circuit only kicks in for the regular "view the
- * commit" cases.
- */
-function renderInspectorRail(h, components, state, detail, width, theme, focused) {
-    const { Box, Text } = components;
-    // Prefer the loaded detail's hash (canonical) but fall back to the
-    // selected list row's shortHash so the rail isn't blank on the
-    // first render before getCommitDetail resolves.
-    const selectedRow = getSelectedInkCommit(state);
-    const hashText = detail?.hash.slice(0, 4)
-        ?? selectedRow?.shortHash.slice(0, 4)
-        ?? '····';
-    return h(Box, {
-        borderColor: focusBorderColor(theme, focused),
-        borderStyle: theme.borderStyle,
-        flexDirection: 'column',
-        width,
-        paddingX: 1,
-    }, h(Text, { bold: true, dimColor: !focused }, panelTitle('Insp', focused)), h(Text, { dimColor: true }, '────'), h(Text, { color: theme.noColor ? undefined : theme.colors.accent }, hashText));
-}
-function renderDetailPanel(h, components, state, context, contextStatus, detail, loading, filePreview, filePreviewLoading, width, tabbed, theme, railed = false, bodyRows = 0) {
+function renderDetailPanel(h, components, state, context, contextStatus, detail, loading, filePreview, filePreviewLoading, width, tabbed, theme, bodyRows = 0) {
     const focused = state.focus === 'detail';
     // Overlays (help / palette / input / confirmation / chord) take
-    // precedence over rail because they always claim the panel's width
-    // via the help-overlay layout branch — and railing those would
-    // defeat their whole purpose (the user is reading them).
+    // precedence over every per-view surface because they claim the
+    // panel's full width via the help-overlay layout branch.
     if (state.showHelp) {
         return renderHelpPanel(h, components, state, width, theme, focused, bodyRows);
     }
@@ -39332,15 +39846,6 @@ function renderDetailPanel(h, components, state, context, contextStatus, detail,
     if (state.pendingKey && !state.splitPlan) {
         return renderChordOverlay(h, components, state, width, theme, focused);
     }
-    // Rail mode applies only after every overlay above has had its say
-    // — those would all be unreadable at 4 cells of content. The layout
-    // also clears `railed` whenever the inspector takes focus, so we
-    // can safely short-circuit the per-view dispatch here without
-    // worrying about hiding the panel from a user who's actively
-    // reading it.
-    if (railed) {
-        return renderInspectorRail(h, components, state, detail, width, theme, focused);
-    }
     // The synthetic "(+) new commit" row routes the inspector through the
     // worktree summary so the user sees what's staged / unstaged at a glance
     // — same surface as the compose view's right panel.
@@ -39390,6 +39895,43 @@ function renderDetailPanel(h, components, state, context, contextStatus, detail,
     return renderHistoryInspector(h, components, state, context, contextStatus, detail, loading, filePreview, filePreviewLoading, width, tabbed, theme, focused);
 }
 
+/**
+ * Runtime React Context for the workstation (#1136).
+ *
+ * The render layer currently drills `state` / `dispatch` / `theme` /
+ * `layout` / `context` through every `render*Surface` signature, so
+ * adding a feature repeatedly means threading one more value through
+ * `app → mainPanel → render<View>Surface`. This Context is the single
+ * place those five values live; surfaces read what they need from it
+ * instead of receiving 10–15 positional props.
+ *
+ * Why a factory (`getLogInkRuntimeContext(React)`) instead of a plain
+ * module-level `React.createContext(...)`: the workstation never
+ * statically imports React. `ink` + `react` are ESM-only and loaded via
+ * dynamicImport at boot (see `inkRuntime.ts`), so the rest of the
+ * codebase compiles without bundling them. The Context object must be
+ * built from that same runtime React instance — the one that renders
+ * the tree and the one a consumer's `useContext` reads from have to be
+ * identical. There is exactly one React instance per process, so we
+ * lazily create the Context on first use and cache it; `LogInkApp`'s
+ * provider and (in later PRs) the surface consumers all share the one
+ * identity.
+ */
+let cachedContext = null;
+/**
+ * Lazily create (and thereafter return) the process-wide
+ * `LogInkRuntimeContext`, bound to the runtime React instance. Pass the
+ * same `React` the tree is rendered with — `LogInkApp` uses `deps.React`;
+ * tests use the statically-imported `react`.
+ */
+function getLogInkRuntimeContext(React) {
+    if (!cachedContext) {
+        cachedContext = React.createContext(null);
+        cachedContext.displayName = 'LogInkRuntimeContext';
+    }
+    return cachedContext;
+}
+
 /**
  * Resolve + scaffold the coco config files the workstation can open in
  * `$EDITOR` (the `gk` / `gK` chords and their command-palette entries).
@@ -39873,6 +40415,10 @@ function LogInkApp(deps) {
     const loadingMoreCommitsRef = React.useRef(false);
     const loadMoreRequestRef = React.useRef(0);
     const mountedRef = React.useRef(true);
+    // Last dropped stash {hash, message}, captured before `drop-stash` runs
+    // so `undo-drop-stash` can re-store it. The dropped commit survives in
+    // the object DB until gc, so the hash is enough to bring it back.
+    const lastDroppedStashRef = React.useRef(null);
     // P4.3 — idle tip rotation. tickIndex 0 ⇒ no tip; the hook bumps it after
     // a grace window of empty statusMessage and then on a steady cadence, so
     // the footer surfaces a different hint every interval until the user does
@@ -41116,11 +41662,15 @@ function LogInkApp(deps) {
                 dispatch({ type: 'setStatus', value: 'AI draft ready for editing', kind: 'success' });
                 return;
             }
+            // Humanize provider errors (rate limit / auth / context / network)
+            // into a short actionable line; success-but-no-draft keeps its
+            // message as-is.
+            const composeMessage = result.ok ? result.message : humanizeAiError(result.message);
             dispatch({
                 type: 'commitCompose',
-                action: { type: 'setResult', message: result.message, details: result.details },
+                action: { type: 'setResult', message: composeMessage, details: result.details },
             });
-            dispatch({ type: 'setStatus', value: result.message });
+            dispatch({ type: 'setStatus', value: composeMessage, kind: result.ok ? undefined : 'error' });
         }
         catch (error) {
             // Audit finding #3: defensive recovery for unexpected throws
@@ -42091,8 +42641,20 @@ function LogInkApp(deps) {
                 const stash = visible[Math.min(state.selectedStashIndex, visible.length - 1)];
                 if (!stash)
                     return { ok: false, message: 'No stash selected' };
+                // Remember the dropped commit so `u` can undo it.
+                if (stash.hash)
+                    lastDroppedStashRef.current = { hash: stash.hash, message: stash.message };
                 return dropStash(git, stash);
             },
+            'undo-drop-stash': async () => {
+                const dropped = lastDroppedStashRef.current;
+                if (!dropped)
+                    return { ok: false, message: 'Nothing to undo — no stash dropped this session' };
+                const result = await restoreStash(git, dropped.hash, dropped.message);
+                if (result.ok)
+                    lastDroppedStashRef.current = null;
+                return result;
+            },
             'apply-stash': async () => {
                 const all = context.stashes?.stashes || [];
                 const visible = state.filter
@@ -42103,6 +42665,16 @@ function LogInkApp(deps) {
                     return { ok: false, message: 'No stash selected' };
                 return applyStash(git, stash);
             },
+            'apply-stash-index': 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 applyStashKeepIndex(git, stash);
+            },
             'pop-stash': async () => {
                 const all = context.stashes?.stashes || [];
                 const visible = state.filter
@@ -42113,6 +42685,26 @@ function LogInkApp(deps) {
                     return { ok: false, message: 'No stash selected' };
                 return popStash(git, stash);
             },
+            'rename-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 renameStash(git, stash, payload ?? '');
+            },
+            'stash-branch': 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 stashBranch(git, stash, payload ?? '');
+            },
             'bisect-good': async () => {
                 if (!context.bisect?.active)
                     return { ok: false, message: 'No bisect in progress' };
@@ -42523,11 +43115,12 @@ function LogInkApp(deps) {
                 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);
+                // Empty is allowed — createStash turns it into a quick WIP stash
+                // (git's own `WIP on <branch>` subject). Naming is optional.
+                return createStash(git, payload ?? '');
             },
+            'stash-staged': async () => createStash(git, payload ?? '', { stagedOnly: true }),
+            'stash-keep-index': async () => createStash(git, payload ?? '', { keepIndex: true }),
             // #783 — full PR action panel handlers. Each wraps the matching
             // pullRequestActions verb. Strategy / body arrives via `payload`
             // — input prompts validate before they reach here, but the
@@ -42775,6 +43368,8 @@ function LogInkApp(deps) {
                 const files = applyStatusFilterMask(context.worktree?.files || [], state.statusFilterMask).filter((file) => file.state === 'untracked');
                 return stageAllFiles(git, files);
             },
+            'stage-all': async () => stageAll(git),
+            'stage-pathspec': async () => stagePathspec(git, payload || ''),
         };
         const handler = handlers[id];
         if (!handler) {
@@ -42805,6 +43400,16 @@ function LogInkApp(deps) {
                 'checkout-branch',
                 'continue-operation',
                 'pull-current-branch',
+                // Fetch / pull / push bring in new commits and move
+                // remote-tracking refs (origin/main, ahead/behind) — refresh the
+                // graph so they appear instead of staying pinned to the pre-sync
+                // state. (A successful push advances the local origin/<branch>
+                // ref, so the chip should hop to the pushed commit.)
+                'fetch-remotes',
+                'fetch-selected-branch',
+                'pull-selected-branch',
+                'push-current-branch',
+                'push-selected-branch',
                 'cherry-pick-commit',
                 'revert-commit',
                 'reset-hard-to-commit',
@@ -42859,6 +43464,11 @@ function LogInkApp(deps) {
             if (result?.ok && id === 'add-to-gitignore') {
                 await refreshWorktreeContext();
             }
+            // Stage-all / stage-pathspec change staged/unstaged counts — refresh
+            // the worktree so the status list + compose summary reflect it.
+            if (result?.ok && (id === 'stage-all' || id === 'stage-pathspec')) {
+                await refreshWorktreeContext();
+            }
             if (result?.ok && id === 'drop-stash') {
                 // Explicit worktree refresh in case the dropped stash carried
                 // untracked-file state that's now collected.
@@ -43442,6 +44052,11 @@ function LogInkApp(deps) {
             ? findStashFileForOffset(stashDiffFiles, state.diffPreviewOffset)?.path
             : undefined;
         getLogInkInputEvents(state, inputValue, key, {
+            // Narrow terminals show one pane at a time (#1135) — gates the `v`
+            // peek key. Derived the same way the layout does, since `layout`
+            // is computed later in the render path (not in this callback).
+            singlePane: (windowSize.columns || process.stdout.columns || LOG_INK_DEFAULT_COLUMNS) <
+                LAYOUT_SINGLE_PANE_BELOW,
             detailFileCount: detail?.files.length,
             previewLineCount: diffPreviewLineCount,
             worktreeDiffLineCount: worktreeDiff?.lines.length,
@@ -43566,7 +44181,14 @@ function LogInkApp(deps) {
                 exit();
             }
             else if (event.type === 'refreshContext') {
+                // The user-initiated refresh (`r`) refreshes BOTH the metadata
+                // context (branches/tags/worktree) AND the commit rows. Without
+                // the row re-fetch the history graph stays pinned to whatever
+                // commits existed at boot — new commits (made in another
+                // terminal, or remote commits brought in by a fetch) never
+                // appear until relaunch, which reads as "the history is stuck."
                 void refreshContext();
+                void refreshHistoryRows();
             }
             else if (event.type === 'toggleSelectedFileStage') {
                 void toggleSelectedFileStage();
@@ -43665,6 +44287,24 @@ function LogInkApp(deps) {
             }
         });
     });
+    // In single-pane mode (narrow terminals) only one pane renders, so an
+    // active overlay must pull its own pane into view rather than stay
+    // hidden behind whatever pane focus points at. The split-plan overlay
+    // lives in the main panel; every other overlay (help / palette / theme
+    // / gitignore / input prompt / confirmation / chord) renders in the
+    // inspector. Ignored above the single-pane breakpoint (all panes show).
+    const forcedPane = state.splitPlan
+        ? 'main'
+        : state.showHelp ||
+            state.showCommandPalette ||
+            state.showThemePicker ||
+            state.gitignorePicker ||
+            state.inputPrompt ||
+            state.pendingConfirmationId ||
+            state.pendingMutationConfirmation ||
+            state.pendingKey
+            ? 'inspector'
+            : undefined;
     // 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({
@@ -43673,7 +44313,22 @@ function LogInkApp(deps) {
         sidebarFocused: state.focus === 'sidebar',
         inspectorFocused: state.focus === 'detail',
         helpOverlayActive: state.showHelp,
+        forcedPane,
     });
+    // Runtime Context provider (#1136). Bundles the five most-drilled
+    // values so surfaces can read them from context instead of receiving
+    // them as positional props. No consumers yet — this PR only installs
+    // the provider at the root; the surface families migrate in later PRs.
+    // A Context.Provider renders its children transparently (no host
+    // output), so wrapping the tree is behavior-preserving.
+    const RuntimeContext = getLogInkRuntimeContext(React);
+    const runtimeContextValue = {
+        state,
+        dispatch,
+        theme,
+        layout,
+        context,
+    };
     if (layout.tooSmall) {
         return h(Box, {
             flexDirection: 'column',
@@ -43687,7 +44342,35 @@ 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$1(h, { Box, Text }, state, context, contextStatus, layout.columns, theme, appLabel), h(Box, { flexDirection: 'row', height: layout.bodyRows }, renderSidebar$1(h, { Box, Text }, state, context, contextStatus, layout.sidebarWidth, layout.bodyRows, theme, layout.sidebarRailed), renderMainPanel(h, { Box, Text }, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, bisectCandidateDetail, bisectCandidateLoading, layout.bodyRows, layout.mainPanelWidth, theme, hasMoreCommits, loadingMoreCommits, spinnerFrame, layout.density, layout.historyRowMode, Boolean(dateBucketingEnabled), diffSyntaxSpans), renderDetailPanel(h, { Box, Text }, state, context, contextStatus, detail, detailLoading, filePreview, filePreviewLoading, layout.detailWidth, layout.inspectorTabbed, theme, layout.inspectorRailed, layout.bodyRows)), renderFooter$1(h, { Box, Text }, state, context, theme, idleTip, spinnerFrame));
+    // Panel renderers are thunks so single-pane mode can build only the
+    // visible pane — the main-panel render in particular is expensive, so
+    // we don't want to invoke the two hidden ones just to drop them.
+    const sidebarPanel = () => renderSidebar$1(h, { Box, Text }, state, context, contextStatus, layout.sidebarWidth, layout.bodyRows, theme);
+    const mainSurface = {
+        h,
+        components: { Box, Text },
+        state,
+        context,
+        contextStatus,
+        bodyRows: layout.bodyRows,
+        width: layout.mainPanelWidth,
+        theme,
+    };
+    const mainPanel = () => renderMainPanel(mainSurface, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, bisectCandidateDetail, bisectCandidateLoading, hasMoreCommits, loadingMoreCommits, spinnerFrame, layout.density, layout.historyRowMode, Boolean(dateBucketingEnabled), diffSyntaxSpans);
+    const detailPanel = () => renderDetailPanel(h, { Box, Text }, state, context, contextStatus, detail, detailLoading, filePreview, filePreviewLoading, layout.detailWidth, layout.inspectorTabbed, theme, layout.bodyRows);
+    // Single-pane mode (narrow terminals): exactly one full-width pane,
+    // chosen by `layout.visiblePane`; Tab cycles which one. Above the
+    // breakpoint all three tile side by side as before.
+    const bodyPanels = layout.singlePane
+        ? [
+            layout.visiblePane === 'sidebar'
+                ? sidebarPanel()
+                : layout.visiblePane === 'inspector'
+                    ? detailPanel()
+                    : mainPanel(),
+        ]
+        : [sidebarPanel(), mainPanel(), detailPanel()];
+    return h(RuntimeContext.Provider, { value: runtimeContextValue }, h(Box, { flexDirection: 'column', height: layout.rows }, renderHeader$1(h, { Box, Text }, state, context, contextStatus, layout.columns, theme, appLabel), h(Box, { flexDirection: 'row', height: layout.bodyRows }, ...bodyPanels), renderFooter$1(h, { Box, Text }, state, context, theme, idleTip, spinnerFrame, layout.singlePane)));
 }
 
 /**
@@ -45807,6 +46490,54 @@ async function getWorkspacePullRequestCounts(repoPaths, options = {}) {
     return { authenticated: true, counts };
 }
 
+/**
+ * Clone a remote repository into a local path — the runtime side of the
+ * workspace surface's `c` (clone) flow.
+ *
+ * `deriveRepoName` is pure (and tested) so the UI can pre-fill the
+ * destination as `<cwd>/<name>` the moment a URL is typed; `cloneRepo`
+ * does the filesystem-touching work and reports a friendly result.
+ */
+/**
+ * Infer the repository folder name from a clone URL or SSH spec:
+ *   git@github.com:gfargo/coco.git  → coco
+ *   https://github.com/gfargo/coco  → coco
+ *   https://example.com/a/b/c.git/  → c
+ * Falls back to `repo` when nothing usable can be parsed.
+ */
+function deriveRepoName(url) {
+    const trimmed = url.trim().replace(/\/+$/, '').replace(/\.git$/i, '');
+    if (!trimmed)
+        return 'repo';
+    // Split on both `/` and `:` so `host:owner/name` SSH specs work.
+    const segment = trimmed.split(/[/:]/).filter(Boolean).pop() || '';
+    return segment || 'repo';
+}
+/**
+ * Clone `url` into `targetPath`. Refuses to clobber an existing path so
+ * a typo never overwrites a directory. Network / auth failures surface
+ * git's own message (trimmed to one line).
+ */
+async function cloneRepo(url, targetPath) {
+    const remote = url.trim();
+    const dest = targetPath.trim();
+    if (!remote)
+        return { ok: false, message: 'Enter a remote URL to clone.' };
+    if (!dest)
+        return { ok: false, message: 'Enter a destination path.' };
+    if (fs.existsSync(dest)) {
+        return { ok: false, message: `${dest} already exists — choose another path.` };
+    }
+    try {
+        await simpleGit().clone(remote, dest);
+        return { ok: true, message: `Cloned into ${dest}` };
+    }
+    catch (error) {
+        const raw = error instanceof Error ? error.message : String(error);
+        return { ok: false, message: `Clone failed: ${raw.split('\n')[0]}` };
+    }
+}
+
 function resolveStoreDir(subdir) {
     const xdg = process.env.XDG_CACHE_HOME;
     const root = xdg && xdg.trim().length > 0 ? xdg : path$1.join(os$1.homedir(), '.cache');
@@ -46049,6 +46780,7 @@ function createWorkspaceState(init) {
         showThemePicker: false,
         themePickerFilter: '',
         themePickerIndex: 0,
+        helpScrollOffset: 0,
         knownRepoPaths: init.knownRepoPaths ?? [],
         pullRequestFetching: [],
     };
@@ -46214,10 +46946,17 @@ function applyWorkspaceAction(state, action) {
             return { ...state, status: action.status };
         }
         case 'toggle-help': {
-            return { ...state, showHelp: !state.showHelp, showOnboarding: false };
+            // Always reopen at the top — picking up the last scroll position
+            // is more surprising than predictable for a reference overlay.
+            return { ...state, showHelp: !state.showHelp, helpScrollOffset: 0, showOnboarding: false };
         }
         case 'close-help': {
-            return { ...state, showHelp: false };
+            return { ...state, showHelp: false, helpScrollOffset: 0 };
+        }
+        case 'scroll-help': {
+            // Floor-clamp at 0 only; the renderer ceiling-clamps against the
+            // real content height so `j` past the end sticks at the last row.
+            return { ...state, helpScrollOffset: Math.max(0, state.helpScrollOffset + action.delta) };
         }
         case 'toggle-theme-picker': {
             return {
@@ -46547,6 +47286,7 @@ function buildWorkspaceListWindow(state, options = { rows: 20 }) {
     const all = buildWorkspaceListRows(state, {
         width: options.width,
         spinnerTick: options.spinnerTick,
+        now: options.now,
     });
     const visibleCount = Math.max(1, options.rows);
     if (all.length <= visibleCount) {
@@ -46670,10 +47410,11 @@ function buildWorkspaceHeaderChips(state, options = { focusLabel: 'List' }) {
 // The contextual slot drops bindings users can find via the help
 // overlay (arrow keys, tab); the global slot is the safety net so
 // `? help` and `q quit` never disappear.
-const LIST_CONTEXTUAL = ['s sort', '/ filter', 'r/R refresh', 'a add', 'd remove'];
+const LIST_CONTEXTUAL = ['s sort', '/ filter', 'r/R refresh', 'a add', 'c clone', 'd remove'];
 const SIDEBAR_CONTEXTUAL = ['↑/↓ cycle tab', 'enter open'];
 const FILTER_CONTEXTUAL = ['type to filter', 'enter apply', 'esc cancel'];
 const ADD_REPO_CONTEXTUAL = ['type path', 'tab to complete', 'enter to add', 'esc to cancel'];
+const CLONE_REPO_CONTEXTUAL = ['enter URL', 'enter → destination', 'enter to clone', 'esc to cancel'];
 const CONFIRM_DELETE_CONTEXTUAL = ['y confirm', 'any other key cancels'];
 const GLOBAL_HINTS = ['? help', 'q quit'];
 function contextualHintsFor(focus) {
@@ -46684,6 +47425,8 @@ function contextualHintsFor(focus) {
             return FILTER_CONTEXTUAL;
         case 'add-repo':
             return ADD_REPO_CONTEXTUAL;
+        case 'clone-repo':
+            return CLONE_REPO_CONTEXTUAL;
         case 'confirm-delete':
             return CONFIRM_DELETE_CONTEXTUAL;
         case 'list':
@@ -46698,6 +47441,7 @@ function buildWorkspaceFooter(state) {
     // is open and showing them would be misleading.
     const isModal = state.focus === 'filter' ||
         state.focus === 'add-repo' ||
+        state.focus === 'clone-repo' ||
         state.focus === 'confirm-delete';
     const global = isModal ? [] : GLOBAL_HINTS;
     const allHints = [...contextual, ...global];
@@ -46759,6 +47503,7 @@ function buildWorkspaceHelpSections() {
                 { glyph: '⟳', keys: 'r', description: 'Refresh all repos (discovery + PR counts)' },
                 { glyph: '⟲', keys: 'R', description: 'Refresh just the cursored repo (faster)' },
                 { glyph: '＋', keys: 'a', description: 'Add a repo via path prompt (tab-completes)' },
+                { glyph: '⬇', keys: 'c', description: 'Clone a remote repo (defaults into the launch directory)' },
                 { glyph: '✕', keys: 'd', description: 'Remove the cursored repo from the known-repos store' },
             ],
         },
@@ -46776,7 +47521,7 @@ function buildWorkspaceOnboarding(state) {
             : undefined,
         populatedHint: empty
             ? undefined
-            : 'Press `enter` to open a repo · `?` for the full keymap · `a` to add a repo by path.',
+            : 'Press `enter` to open a repo · `a` to add by path · `c` to clone · `?` for the full keymap.',
     };
 }
 
@@ -47072,6 +47817,7 @@ function renderListBody(deps, width, height) {
         width,
         rows: listRows,
         spinnerTick: deps.spinnerTick,
+        now: deps.now,
     });
     const visibleRepos = selectVisibleRepos(state);
     const filterChip = state.filter
@@ -47107,7 +47853,7 @@ function renderListBody(deps, width, height) {
 function renderHelpRow(deps, row, glyphWidth, keysWidth, key) {
     const { React, ink, theme } = deps;
     const { Box, Text } = ink;
-    return React.createElement(Box, { key, flexDirection: 'row' }, React.createElement(Box, { width: glyphWidth, flexShrink: 0 }, React.createElement(Text, { color: theme.noColor ? undefined : theme.colors.accent, bold: true }, ` ${row.glyph ?? ' '} `)), React.createElement(Box, { width: keysWidth, flexShrink: 0 }, React.createElement(Text, { color: theme.noColor ? undefined : theme.colors.success, bold: true }, row.keys)), React.createElement(Text, null, row.description));
+    return React.createElement(Box, { key, flexShrink: 0, flexDirection: 'row' }, React.createElement(Box, { width: glyphWidth, flexShrink: 0 }, React.createElement(Text, { color: theme.noColor ? undefined : theme.colors.accent, bold: true }, ` ${row.glyph ?? ' '} `)), React.createElement(Box, { width: keysWidth, flexShrink: 0 }, React.createElement(Text, { color: theme.noColor ? undefined : theme.colors.success, bold: true }, row.keys)), React.createElement(Text, null, row.description));
 }
 function renderHelpOverlay(deps) {
     if (!deps.state.showHelp) {
@@ -47120,34 +47866,68 @@ function renderHelpOverlay(deps) {
     // Columns: glyph cell (4 cells) · keys (padded to longest) · description.
     const glyphWidth = 4;
     const keysWidth = Math.max(14, allRows.reduce((acc, row) => Math.max(acc, row.keys.length), 0) + 4);
-    const children = [];
-    // Title bar — accent-tinged, matches the chip-style header on the
-    // main surface so the help reads as the same app, just a different
-    // panel.
-    children.push(React.createElement(Box, { key: 'title', flexDirection: 'row', justifyContent: 'space-between' }, React.createElement(Box, { key: 'title-left', flexDirection: 'row' }, React.createElement(Text, { bold: true, color: theme.noColor ? undefined : theme.colors.accent }, ' ?  coco workspace'), React.createElement(Text, { dimColor: true }, '  keymap · '), React.createElement(Text, { dimColor: true }, `${allRows.length} bindings`)), React.createElement(Text, { dimColor: true }, 'esc / ? to close ')));
-    children.push(React.createElement(Text, { key: 'title-sep', dimColor: true }, ''));
-    // Sections — each gets a title in accent, optional subtitle dim,
-    // then its rows, then a blank line.
+    // Body lines — every scrollable row below the pinned title. Built as
+    // a flat list (section title → optional subtitle → rows → inter-section
+    // spacer) so we can window it against the available height. Each entry
+    // is `flexShrink: 0` so Ink never crushes rows on top of each other
+    // when the keymap is taller than the panel (which used to collapse the
+    // title and the first category onto the same line).
+    const body = [];
     sections.forEach((section, sIndex) => {
-        children.push(React.createElement(Text, {
+        body.push(React.createElement(Text, {
             key: `section-${sIndex}-title`,
             bold: true,
             color: theme.noColor ? undefined : theme.colors.muted,
         }, section.title.toUpperCase()));
         if (section.subtitle) {
-            children.push(React.createElement(Text, { key: `section-${sIndex}-subtitle`, dimColor: true }, ` ${section.subtitle}`));
+            body.push(React.createElement(Text, { key: `section-${sIndex}-subtitle`, dimColor: true }, ` ${section.subtitle}`));
         }
         section.rows.forEach((row, rIndex) => {
-            children.push(renderHelpRow(deps, row, glyphWidth, keysWidth, `row-${sIndex}-${rIndex}`));
+            body.push(renderHelpRow(deps, row, glyphWidth, keysWidth, `row-${sIndex}-${rIndex}`));
         });
         if (sIndex < sections.length - 1) {
-            children.push(React.createElement(Text, { key: `section-${sIndex}-spacer` }, ''));
+            body.push(React.createElement(Text, { key: `section-${sIndex}-spacer` }, ''));
         }
     });
+    // Vertical budget: the overlay shares the column with the header
+    // (3 rows) and footer (FOOTER_HEIGHT). Its own chrome eats the border
+    // (2), the pinned title (1) and the title/body separator (1). Whatever
+    // is left is the window we slide the body through.
+    const HEADER_ROWS = 3;
+    const overlayChromeRows = 4;
+    const visibleRows = Math.max(4, deps.rows - HEADER_ROWS - FOOTER_HEIGHT - overlayChromeRows);
+    // Ceiling-clamp the offset here (the reducer only floors at 0) so
+    // scrolling past the end sticks at the last row instead of revealing
+    // blank space.
+    const maxOffset = Math.max(0, body.length - visibleRows);
+    const offset = Math.min(deps.state.helpScrollOffset, maxOffset);
+    const children = [];
+    // Title bar — accent-tinged, matches the chip-style header on the
+    // main surface so the help reads as the same app, just a different
+    // panel. Pinned above the scrolling body.
+    children.push(React.createElement(Box, { key: 'title', flexShrink: 0, flexDirection: 'row', justifyContent: 'space-between' }, React.createElement(Box, { key: 'title-left', flexDirection: 'row' }, React.createElement(Text, { bold: true, color: theme.noColor ? undefined : theme.colors.accent }, ' ?  coco workspace'), React.createElement(Text, { dimColor: true }, '  keymap · '), React.createElement(Text, { dimColor: true }, `${allRows.length} bindings`)), React.createElement(Text, { dimColor: true }, 'esc / ? to close ')));
+    children.push(React.createElement(Text, { key: 'title-sep', dimColor: true }, ''));
+    // "more above" / "more below" hints each consume a window row so they
+    // don't push body content off-screen. Mirrors the `coco ui` overlay.
+    let windowSize = visibleRows;
+    const hasMoreAbove = offset > 0;
+    if (hasMoreAbove) {
+        windowSize -= 1;
+        children.push(React.createElement(Text, { key: 'more-above', dimColor: true }, ' ↑ more above (j/k or ↑/↓ to scroll)'));
+    }
+    const hasMoreBelow = offset + windowSize < body.length;
+    if (hasMoreBelow) {
+        windowSize -= 1;
+    }
+    children.push(...body.slice(offset, offset + windowSize));
+    if (hasMoreBelow) {
+        children.push(React.createElement(Text, { key: 'more-below', dimColor: true }, ' ↓ more below (j/k or ↑/↓ to scroll)'));
+    }
     return React.createElement(Box, {
         borderColor: focusBorderColor(theme, true),
         borderStyle: theme.borderStyle,
         flexDirection: 'column',
+        flexShrink: 0,
         paddingX: 1,
     }, ...children);
 }
@@ -47198,6 +47978,29 @@ function renderAddRepoPrompt(deps) {
         ? React.createElement(Text, { color: toneColor('dim', theme) }, completionLine)
         : null);
 }
+function renderCloneRepoPrompt(deps) {
+    if (deps.state.focus !== 'clone-repo') {
+        return null;
+    }
+    const { React, ink, theme, cloneUrl, cloneTarget, cloneField, cloneCompletion, cloning } = deps;
+    const { Box, Text } = ink;
+    const urlActive = cloneField === 'url' && !cloning;
+    const targetActive = cloneField === 'target' && !cloning;
+    const completionLine = cloneCompletion.completions.slice(0, 8).join('  ');
+    const hint = cloning
+        ? 'Cloning… this can take a moment for large repos.'
+        : cloneField === 'url'
+            ? 'Paste a remote URL (https or git@…), then enter for the destination.'
+            : 'Edit the destination · tab to complete · enter to clone · esc to cancel';
+    return React.createElement(Box, {
+        borderColor: focusBorderColor(theme, true),
+        borderStyle: theme.borderStyle,
+        flexDirection: 'column',
+        paddingX: 1,
+    }, React.createElement(Text, { bold: true }, 'Clone a repository'), React.createElement(Text, { color: urlActive ? undefined : toneColor('dim', theme) }, `  URL:  ${cloneUrl}${urlActive ? '_' : ''}`), React.createElement(Text, { color: targetActive ? undefined : toneColor('dim', theme) }, `  Into: ${cloneTarget}${targetActive ? '_' : ''}`), React.createElement(Text, { dimColor: true }, hint), completionLine && targetActive
+        ? React.createElement(Text, { color: toneColor('dim', theme) }, completionLine)
+        : null);
+}
 const FOOTER_HEIGHT = 4; // 2 borders + hint row + status row
 function renderFooter(deps) {
     const { React, ink, state, theme } = deps;
@@ -47239,8 +48042,10 @@ function computeBodyHeight(deps) {
     const FOOTER_ROWS = FOOTER_HEIGHT;
     const onboardingRows = buildWorkspaceOnboarding(deps.state).show ? 5 : 0;
     const addRepoRows = deps.state.focus === 'add-repo' ? 5 : 0;
+    // Clone modal is one row taller (URL + Into + hint + completion).
+    const cloneRows = deps.state.focus === 'clone-repo' ? 6 : 0;
     const confirmRows = deps.state.focus === 'confirm-delete' ? 5 : 0;
-    const reserved = HEADER_ROWS + FOOTER_ROWS + onboardingRows + addRepoRows + confirmRows;
+    const reserved = HEADER_ROWS + FOOTER_ROWS + onboardingRows + addRepoRows + cloneRows + confirmRows;
     return Math.max(8, deps.rows - reserved);
 }
 function renderWorkspaceApp(deps) {
@@ -47262,7 +48067,7 @@ function renderWorkspaceApp(deps) {
         return React.createElement(Box, { flexDirection: 'column', height: rootHeight }, renderHeader(deps), renderThemePickerOverlay(React.createElement, { Box: ink.Box, Text: ink.Text }, deps.state.themePickerFilter, deps.state.themePickerIndex, bodyWidth, deps.theme, true), renderFooter(deps));
     }
     const bodyHeight = computeBodyHeight(deps);
-    return React.createElement(Box, { flexDirection: 'column', height: rootHeight }, renderHeader(deps), React.createElement(Box, { flexDirection: 'row', height: bodyHeight }, renderSidebar(deps, bodyHeight), renderListBody(deps, bodyWidth - sidebarWidthFor(deps) - 2, bodyHeight)), renderOnboardingBanner(deps), renderAddRepoPrompt(deps), renderConfirmDelete(deps), renderFooter(deps));
+    return React.createElement(Box, { flexDirection: 'column', height: rootHeight }, renderHeader(deps), React.createElement(Box, { flexDirection: 'row', height: bodyHeight }, renderSidebar(deps, bodyHeight), renderListBody(deps, bodyWidth - sidebarWidthFor(deps) - 2, bodyHeight)), renderOnboardingBanner(deps), renderAddRepoPrompt(deps), renderCloneRepoPrompt(deps), renderConfirmDelete(deps), renderFooter(deps));
 }
 
 /**
@@ -47299,6 +48104,21 @@ function resolveWorkspaceInput(input, key, state) {
         if (key.escape || input === '?' || input === 'q') {
             return { kind: 'action', action: { type: 'close-help' } };
         }
+        // The keymap is taller than the panel on short terminals — let
+        // j/k/↑/↓ and ctrl+d/u scroll the windowed body. Mirrors the
+        // `coco ui` help overlay.
+        if (key.downArrow || input === 'j') {
+            return { kind: 'action', action: { type: 'scroll-help', delta: 1 } };
+        }
+        if (key.upArrow || input === 'k') {
+            return { kind: 'action', action: { type: 'scroll-help', delta: -1 } };
+        }
+        if (key.ctrl && input === 'd') {
+            return { kind: 'action', action: { type: 'scroll-help', delta: 10 } };
+        }
+        if (key.ctrl && input === 'u') {
+            return { kind: 'action', action: { type: 'scroll-help', delta: -10 } };
+        }
         return { kind: 'noop' };
     }
     // Theme picker is modal (like `coco ui`'s gC): type to filter, ↑/↓ to
@@ -47349,6 +48169,14 @@ function resolveWorkspaceInput(input, key, state) {
         // can drive the path-completion prompt.
         return { kind: 'noop' };
     }
+    if (state.focus === 'clone-repo') {
+        if (key.escape) {
+            return { kind: 'action', action: { type: 'set-focus', focus: 'list' } };
+        }
+        // Enter/Tab/printable keys drive the URL + destination prompt in the
+        // runtime (it owns the two-field state + path completion).
+        return { kind: 'noop' };
+    }
     // Confirm-delete is modal: only `y` confirms, anything else cancels.
     if (state.focus === 'confirm-delete') {
         if (input === 'y' || input === 'Y') {
@@ -47443,6 +48271,9 @@ function resolveWorkspaceInput(input, key, state) {
     if (input === 'a') {
         return { kind: 'add-repo' };
     }
+    if (input === 'c') {
+        return { kind: 'clone-repo' };
+    }
     if (input === 'd') {
         return { kind: 'request-delete' };
     }
@@ -47997,6 +48828,19 @@ function WorkspaceInkApp(props) {
     const [filterDraft, setFilterDraft] = React.useState('');
     const [addRepoDraft, setAddRepoDraft] = React.useState('~/');
     const [addRepoCompletion, setAddRepoCompletion] = React.useState(() => completePath('~/'));
+    // Clone-repo modal (`c`). Two fields: the remote URL and the
+    // destination path. `cloneField` tracks which is active; `cloneTarget`
+    // auto-derives `<cwd>/<repo-name>` from the URL until the user edits it
+    // (`cloneTargetEdited`). `cloning` blocks input + shows a spinner while
+    // `git clone` runs. The boot cwd is captured once at mount so it stays
+    // the directory the workspace launched in even after drill-in.
+    const bootCwdRef = React.useRef(process.cwd());
+    const [cloneUrl, setCloneUrl] = React.useState('');
+    const [cloneTarget, setCloneTarget] = React.useState('');
+    const [cloneField, setCloneField] = React.useState('url');
+    const [cloneTargetEdited, setCloneTargetEdited] = React.useState(false);
+    const [cloneCompletion, setCloneCompletion] = React.useState(() => completePath('~/'));
+    const [cloning, setCloning] = React.useState(false);
     // Tick counter for the per-row PR-fetch spinner. Bumped on a
     // setInterval that only runs while at least one row is mid-fetch
     // (see effect below) so idle workspaces don't burn CPU on animation
@@ -48046,6 +48890,18 @@ function WorkspaceInkApp(props) {
     addRepoDraftRef.current = addRepoDraft;
     const addRepoCompletionRef = React.useRef(addRepoCompletion);
     addRepoCompletionRef.current = addRepoCompletion;
+    const cloneUrlRef = React.useRef(cloneUrl);
+    cloneUrlRef.current = cloneUrl;
+    const cloneTargetRef = React.useRef(cloneTarget);
+    cloneTargetRef.current = cloneTarget;
+    const cloneFieldRef = React.useRef(cloneField);
+    cloneFieldRef.current = cloneField;
+    const cloneTargetEditedRef = React.useRef(cloneTargetEdited);
+    cloneTargetEditedRef.current = cloneTargetEdited;
+    const cloneCompletionRef = React.useRef(cloneCompletion);
+    cloneCompletionRef.current = cloneCompletion;
+    const cloningRef = React.useRef(cloning);
+    cloningRef.current = cloning;
     // Background discovery + PR-count refresh on mount.
     React.useEffect(() => {
         let cancelled = false;
@@ -48278,6 +49134,60 @@ function WorkspaceInkApp(props) {
             });
         }
     }, [addRepoDraft, dispatch, props]);
+    // Default destination for a clone URL: `<bootCwd>/<repo-name>`.
+    const cloneTargetFor = React.useCallback((url) => {
+        return path$1.join(bootCwdRef.current, deriveRepoName(url));
+    }, []);
+    const openClone = React.useCallback(() => {
+        setCloneUrl('');
+        setCloneTarget('');
+        setCloneField('url');
+        setCloneTargetEdited(false);
+        setCloneCompletion(completePath(`${bootCwdRef.current}/`));
+        dispatch({ type: 'set-focus', focus: 'clone-repo' });
+    }, [dispatch]);
+    const commitClone = React.useCallback(async () => {
+        const url = cloneUrlRef.current.trim();
+        const target = expandHomePrefix(cloneTargetRef.current.trim().replace(/\/+$/, ''));
+        if (!url) {
+            dispatch({ type: 'set-status', status: 'Enter a remote URL.' });
+            return;
+        }
+        if (!target) {
+            dispatch({ type: 'set-status', status: 'Enter a destination path.' });
+            return;
+        }
+        setCloning(true);
+        dispatch({ type: 'set-status', status: `Cloning ${deriveRepoName(url)}…` });
+        const result = await cloneRepo(url, target);
+        if (unmountedRef.current)
+            return;
+        setCloning(false);
+        if (!result.ok) {
+            // Keep the modal open so the user can fix the URL / path and retry.
+            dispatch({ type: 'set-status', status: result.message });
+            return;
+        }
+        const updated = appendKnownRepo(target);
+        dispatch({ type: 'replace-known-repos', paths: updated });
+        dispatch({ type: 'set-focus', focus: 'list' });
+        dispatch({ type: 'set-status', status: result.message });
+        dispatch({ type: 'set-loading', loading: true });
+        try {
+            const merged = mergeKnownRepos(props.knownRepos, readKnownRepos());
+            const overview = await props.loadOverview(props.roots, merged);
+            writeCachedWorkspace(props.roots, overview);
+            dispatch({ type: 'replace-overview', overview });
+            dispatch({ type: 'anchor-cursor-by-path', path: target });
+        }
+        catch (err) {
+            dispatch({ type: 'set-loading', loading: false });
+            dispatch({
+                type: 'set-status',
+                status: err instanceof Error ? err.message : 'Refresh failed.',
+            });
+        }
+    }, [dispatch, props]);
     // Callback refs so the stable input handler can reach the latest
     // closure without taking them in deps.
     const commitAddRepoRef = React.useRef(commitAddRepo);
@@ -48290,6 +49200,10 @@ function WorkspaceInkApp(props) {
     refreshRowRef.current = refreshRow;
     const openAddRepoRef = React.useRef(openAddRepo);
     openAddRepoRef.current = openAddRepo;
+    const openCloneRef = React.useRef(openClone);
+    openCloneRef.current = openClone;
+    const commitCloneRef = React.useRef(commitClone);
+    commitCloneRef.current = commitClone;
     const requestDeleteRef = React.useRef(requestDelete);
     requestDeleteRef.current = requestDelete;
     const confirmDeleteRef = React.useRef(confirmDelete);
@@ -48372,6 +49286,73 @@ function WorkspaceInkApp(props) {
             }
             return;
         }
+        if (state.focus === 'clone-repo') {
+            // While the clone is running, swallow everything except Esc
+            // (which is a no-op here — the clone is already in flight).
+            if (cloningRef.current)
+                return;
+            if (key.escape) {
+                dispatch({ type: 'set-focus', focus: 'list' });
+                return;
+            }
+            const field = cloneFieldRef.current;
+            const url = cloneUrlRef.current;
+            const target = cloneTargetRef.current;
+            const targetEdited = cloneTargetEditedRef.current;
+            if (key.return) {
+                if (field === 'url') {
+                    if (!url.trim()) {
+                        dispatch({ type: 'set-status', status: 'Enter a remote URL.' });
+                        return;
+                    }
+                    // Advance to the (pre-filled, editable) destination field.
+                    const derived = targetEdited ? target : cloneTargetFor(url);
+                    setCloneTarget(derived);
+                    setCloneCompletion(completePath(derived));
+                    setCloneField('target');
+                    return;
+                }
+                void commitCloneRef.current();
+                return;
+            }
+            if (key.tab && field === 'target') {
+                const next = applyTabCompletion(target, cloneCompletionRef.current);
+                setCloneTarget(next);
+                setCloneTargetEdited(true);
+                setCloneCompletion(completePath(next));
+                return;
+            }
+            if (key.backspace || key.delete) {
+                if (field === 'url') {
+                    const next = url.slice(0, -1);
+                    setCloneUrl(next);
+                    if (!targetEdited)
+                        setCloneTarget(next ? cloneTargetFor(next) : '');
+                }
+                else {
+                    const next = target.slice(0, -1);
+                    setCloneTarget(next);
+                    setCloneTargetEdited(true);
+                    setCloneCompletion(completePath(next || '~/'));
+                }
+                return;
+            }
+            if (rawInput && !key.ctrl && !key.meta) {
+                if (field === 'url') {
+                    const next = url + rawInput;
+                    setCloneUrl(next);
+                    if (!targetEdited)
+                        setCloneTarget(cloneTargetFor(next));
+                }
+                else {
+                    const next = target + rawInput;
+                    setCloneTarget(next);
+                    setCloneTargetEdited(true);
+                    setCloneCompletion(completePath(next));
+                }
+            }
+            return;
+        }
         // Ctrl+C → quit, since we disabled Ink's built-in ctrl+c exit.
         // Handled here (rather than in the pure resolver) because the
         // resolver doesn't have a notion of "raw key with ctrl flag" for
@@ -48412,6 +49393,9 @@ function WorkspaceInkApp(props) {
             case 'add-repo':
                 openAddRepoRef.current();
                 break;
+            case 'clone-repo':
+                openCloneRef.current();
+                break;
             case 'request-delete':
                 requestDeleteRef.current();
                 break;
@@ -48461,6 +49445,11 @@ function WorkspaceInkApp(props) {
         filterDraft,
         addRepoDraft,
         addRepoCompletion,
+        cloneUrl,
+        cloneTarget,
+        cloneField,
+        cloneCompletion,
+        cloning,
         columns,
         rows,
         spinnerTick,