git-coco 0.52.0 → 0.53.0

package/dist/index.esm.mjs

@@ -61,7 +61,7 @@ import { pathToFileURL } from 'url';
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.52.0";
+const BUILD_VERSION = "0.53.0";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -15612,6 +15612,7 @@ Structural rules:
 - Only use hunk IDs LITERALLY copied from the "Staged hunk inventory" section below. Do not invent or guess hunk IDs.
 - If the hunk inventory says "No hunk-level inventory available" then EVERY group's "hunks" array MUST be empty (use only "files"). Do not write hunk IDs like "path::hunk-1" when no hunk inventory exists — those are not valid.
 - Prefer 2-5 commits unless the changes are truly all one topic.
+- Order the groups in the sequence they would logically be built — foundational changes first, consumers after. If group B uses a symbol, function, type, or file introduced in group A, A MUST appear before B in the array. The applier commits in array order, so this order becomes the git history. Example: a "feat: add helpers" group that introduces \`formatX()\` must come before a "feat: wire helpers into renderer" group that calls \`formatX()\`, even if the staged diff is presented in the opposite order. When two groups have no dependency relationship, prefer the one closer to a "scaffold" (types, config, new files) before the one closer to a "use site" (existing files modified to consume the new code).
 
 Commit message style:
 - Write each "title" in the imperative mood ("add", not "added"), under 72 chars.
@@ -21068,6 +21069,37 @@ function getLogInkWorkflowActions() {
             kind: 'normal',
             requiresConfirmation: false,
         },
+        // Per-view variants of fetch / pull / push that act on the
+        // cursored branch instead of the current one. Empty `key` keeps
+        // them palette-discoverable without registering a global hotkey —
+        // inkInput.ts dispatches them contextually when the user presses
+        // F / U / P while the branches sidebar is focused. Outside that
+        // context, the F / U / P keys still fire the global *-current-*
+        // / fetch-remotes variants above.
+        {
+            id: 'fetch-selected-branch',
+            key: '',
+            label: 'Fetch selected branch',
+            description: 'Run `git fetch <remote> <branch>` for the cursored branch in the branches view / sidebar.',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
+        {
+            id: 'pull-selected-branch',
+            key: '',
+            label: 'Pull selected branch',
+            description: 'Pull the cursored branch in the branches view / sidebar. Falls back to a fast-forward-only refspec fetch when the branch is not currently checked out; refuses non-FF.',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
+        {
+            id: 'push-selected-branch',
+            key: '',
+            label: 'Push selected branch',
+            description: 'Run `git push <remote> <branch>` for the cursored branch in the branches view / sidebar.',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
         {
             // Per-view-only — the inkInput handler scopes this to the tags
             // surface so we don't expose `R` as a remote-delete from elsewhere.
@@ -22008,8 +22040,22 @@ function getLogInkFooterHints(options) {
         // "enter open" hint that drills into the dedicated view.
         const itemsPresent = (options.sidebarItemCount ?? 0) > 0;
         if (itemsPresent && options.sidebarTab === 'branches') {
+            // P / U / F fire the global pull-current-branch, push-current-branch,
+            // fetch-remotes workflows — already implemented, just not visible in
+            // the footer before. Surfacing them here matters because the user's
+            // attention is on a branch when the branches sidebar is focused;
+            // pull / push / fetch are the next obvious actions.
+            //
+            // Note: `U` and `P` currently operate on the CURRENT branch, not the
+            // cursored one. Task #5 will extend them to act on the cursored row;
+            // until then the labels read as "current-branch ops" by virtue of
+            // matching the workflow descriptions.
             return {
-                contextual: ['↑/↓ branches', '←/→ tab', 'enter checkout', 'D delete', 'R rename', 'u upstream'],
+                contextual: [
+                    '↑/↓ branches', '←/→ tab', 'enter checkout',
+                    'F fetch', 'U pull', 'P push',
+                    'D delete', 'R rename', 'u upstream',
+                ],
                 global: NORMAL_GLOBAL_HINTS,
             };
         }
@@ -26438,6 +26484,27 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         events.push({ type: 'createManualCommit' });
         return events;
     }
+    // Context-sensitive per-branch variants of F / U / P. When the
+    // user has the branches sidebar / view focused with at least one
+    // branch, F / U / P should act on the cursored row, not on the
+    // current branch. This intercept fires BEFORE the generic
+    // workflow-by-key lookup below so the global *-current-branch
+    // variants don't shadow the contextual ones.
+    //
+    // Outside the branches context, the generic lookup runs and the
+    // F / U / P keys hit the global `fetch-remotes` / `pull-current-branch`
+    // / `push-current-branch` workflows as before.
+    if (isBranchActionTarget(state) && context.branchCount) {
+        if (inputValue === 'F') {
+            return [{ type: 'runWorkflowAction', id: 'fetch-selected-branch' }];
+        }
+        if (inputValue === 'U') {
+            return [{ type: 'runWorkflowAction', id: 'pull-selected-branch' }];
+        }
+        if (inputValue === 'P') {
+            return [{ type: 'runWorkflowAction', id: 'push-selected-branch' }];
+        }
+    }
     const workflowAction = getLogInkWorkflowActionByKey(inputValue);
     if (workflowAction?.requiresConfirmation) {
         return [action({ type: 'setPendingConfirmation', value: workflowAction.id })];
@@ -27540,6 +27607,106 @@ function pushCurrentBranch(git) {
 function setUpstream(git, localBranch, upstreamBranch) {
     return runAction$5(() => git.raw(['branch', '--set-upstream-to', upstreamBranch, localBranch]), `Set ${localBranch} upstream to ${upstreamBranch}`);
 }
+/**
+ * Push an arbitrary local branch (need not be the current branch) to
+ * its remote. Refuses when the branch has no upstream and no remote
+ * defaulting is configured — that branch needs a `git push -u …` from
+ * the shell first.
+ *
+ * Pairs with `pushCurrentBranch` (no-arg variant); the workstation
+ * dispatcher picks one or the other based on where the cursor is.
+ */
+function pushBranch(git, branch) {
+    if (branch.type !== 'local') {
+        return Promise.resolve({
+            ok: false,
+            message: 'Only local branches can be pushed.',
+        });
+    }
+    if (!branch.upstream || !branch.remote) {
+        return Promise.resolve({
+            ok: false,
+            message: `${branch.shortName} has no upstream — checkout the branch and run \`git push -u <remote> ${branch.shortName}\` first.`,
+        });
+    }
+    return runAction$5(() => git.raw(['push', branch.remote, branch.shortName]), `Pushed ${branch.shortName} to ${branch.upstream}`);
+}
+/**
+ * Fetch the cursored branch's upstream from its remote. Side-effect
+ * free on the working tree — just updates the remote-tracking ref.
+ * Works for any branch with an upstream regardless of checkout state.
+ *
+ * Falls back to a clean error when the branch has no upstream
+ * configured (`git fetch <remote> <name>` would assume an unrelated
+ * default refspec and surprise the user).
+ */
+function fetchBranch(git, branch) {
+    if (branch.type !== 'local') {
+        return Promise.resolve({
+            ok: false,
+            message: 'Only local branches can be fetched per-branch — use F to fetch all remotes.',
+        });
+    }
+    if (!branch.upstream || !branch.remote) {
+        return Promise.resolve({
+            ok: false,
+            message: `${branch.shortName} has no upstream — nothing to fetch.`,
+        });
+    }
+    // `branch.upstream` is the short form (e.g. `origin/main`); the
+    // ref name after the remote prefix is what fetch wants as the
+    // refspec source. For a remote `origin` and upstream `origin/main`
+    // we run `git fetch origin main`.
+    const upstreamRef = branch.upstream.startsWith(`${branch.remote}/`)
+        ? branch.upstream.slice(branch.remote.length + 1)
+        : branch.upstream;
+    return runAction$5(() => git.raw(['fetch', branch.remote, upstreamRef]), `Fetched ${branch.upstream}`);
+}
+/**
+ * Pull the cursored branch. Branches into two paths based on whether
+ * the branch is currently checked out:
+ *
+ *   - **Current branch**: defer to `pullCurrentBranch` (standard
+ *     `git pull --ff-only`).
+ *   - **Non-current branch**: use the refspec form
+ *     `git fetch <remote> <branch>:<branch>` which advances the local
+ *     ref to match the remote ref ONLY if the update is fast-forward.
+ *     Returns non-zero on non-FF without touching the working tree.
+ *     Diverged branches need a checkout + `pull --rebase` from the
+ *     user; we refuse rather than try to do that for them.
+ *
+ * `currentBranchName` lets the dispatcher compare without re-querying
+ * git — it already has the value in `context.branches.currentBranch`.
+ */
+function pullBranch(git, branch, currentBranchName) {
+    if (branch.type !== 'local') {
+        return Promise.resolve({
+            ok: false,
+            message: 'Only local branches can be pulled.',
+        });
+    }
+    if (!branch.upstream || !branch.remote) {
+        return Promise.resolve({
+            ok: false,
+            message: `${branch.shortName} has no upstream — nothing to pull.`,
+        });
+    }
+    // Current branch — defer to the in-place workflow.
+    if (branch.shortName === currentBranchName) {
+        return pullCurrentBranch(git);
+    }
+    // Non-current branch — refspec-based fast-forward refusing non-FF.
+    // `branch.upstream` is `<remote>/<ref>`; strip the remote prefix to
+    // get the upstream ref name to fetch.
+    const upstreamRef = branch.upstream.startsWith(`${branch.remote}/`)
+        ? branch.upstream.slice(branch.remote.length + 1)
+        : branch.upstream;
+    return runAction$5(() => git.raw([
+        'fetch',
+        branch.remote,
+        `${upstreamRef}:${branch.shortName}`,
+    ]), `Fast-forwarded ${branch.shortName} to ${branch.upstream}`);
+}
 
 async function runAction$4(action, successMessage) {
     try {
@@ -29063,29 +29230,81 @@ function formatBranchDivergence(branch, options = {}) {
         parts.push(`↓${branch.behind}`);
     return `${parts.join(' ')} ${branch.upstream}`;
 }
-/**
- * Single-cell marker shown to the left of a branch name in lists.
- *
- * - `*` — current branch (regardless of remote state)
- * - `◌` — no upstream
- * - `≡` — has upstream + synced (ahead === 0 && behind === 0)
- * - `↕` — has upstream + diverged (any non-zero ahead/behind)
- * - ` ` — fallback / no info
- *
- * ASCII fallbacks (legible without box-drawing/arrow glyphs):
- * - `?` for "no upstream", `=` for synced, `~` for diverged.
- */
+function formatUpstreamAheadBanner(branch, options = {}) {
+    if (!branch?.upstream || branch.behind <= 0) {
+        return undefined;
+    }
+    const sep = options.ascii ? '.' : '·';
+    if (branch.ahead > 0) {
+        // Diverged — local has work too, fast-forward pull is impossible.
+        // Suggest pull --rebase as the cleaner-history default; users who
+        // prefer merge can do that themselves.
+        const symbols = options.ascii
+            ? `+${branch.ahead} -${branch.behind}`
+            : `↑${branch.ahead} ↓${branch.behind}`;
+        return `${symbols} diverged from ${branch.upstream} ${sep} F fetch ${sep} U pull --rebase`;
+    }
+    // Behind-only — fast-forward pull works.
+    const arrow = options.ascii ? 'v' : '↓';
+    const noun = branch.behind === 1 ? 'commit' : 'commits';
+    return `${arrow} ${branch.behind} ${noun} behind ${branch.upstream} ${sep} F fetch ${sep} U pull`;
+}
 function branchRowMarker(branch, options = {}) {
-    if (branch.current)
-        return '*';
-    if (!branch.upstream)
-        return options.ascii ? '?' : '◌';
+    if (branch.current) {
+        return { glyph: '*', kind: 'head' };
+    }
+    if (!branch.upstream) {
+        return { glyph: options.ascii ? '?' : '◌', kind: 'no-upstream' };
+    }
     const ahead = branch.ahead ?? 0;
     const behind = branch.behind ?? 0;
     if (ahead === 0 && behind === 0) {
-        return options.ascii ? '=' : '≡';
+        return { glyph: options.ascii ? '=' : '≡', kind: 'synced' };
+    }
+    if (ahead > 0 && behind > 0) {
+        return { glyph: options.ascii ? '~' : '⇅', kind: 'diverged' };
+    }
+    if (behind > 0) {
+        return { glyph: options.ascii ? 'v' : '↓', kind: 'behind' };
+    }
+    // ahead > 0 (the only remaining case after the guards above)
+    return { glyph: options.ascii ? '^' : '↑', kind: 'ahead' };
+}
+/**
+ * Theme-aware colour picker for a `BranchRowMarker.kind`.
+ *
+ * Reuses the existing chip / banner colour semantic so the workstation
+ * speaks one visual language across history (chips, "behind upstream"
+ * banner) and the branches list:
+ *
+ *   - `head`        → success green (matches HEAD chip)
+ *   - `behind`      → warning yellow (matches "behind upstream" banner)
+ *   - `diverged`    → warning yellow (same: action needed inbound)
+ *   - `ahead`       → info blue (you have work to push)
+ *   - `synced`      → undefined (neutral; inherit row's existing dim)
+ *   - `no-upstream` → undefined (neutral; same)
+ *
+ * Returns `undefined` under `noColor` / `ascii` for the muted cases so
+ * the row renderer skips the colour wrap entirely; the glyph alone
+ * carries the meaning.
+ */
+function getBranchRowMarkerColor(kind, theme) {
+    if (theme.noColor)
+        return undefined;
+    switch (kind) {
+        case 'head':
+            return theme.colors.success;
+        case 'behind':
+        case 'diverged':
+            return theme.colors.warning;
+        case 'ahead':
+            return theme.colors.info;
+        case 'synced':
+        case 'no-upstream':
+            return undefined;
+        default:
+            return undefined;
     }
-    return options.ascii ? '~' : '↕';
 }
 /**
  * Compact, human-friendly relative timestamp for the branch row.
@@ -29693,7 +29912,7 @@ function renderActiveSidebarContent(h, Text, tab, state, context, contextStatus,
         ];
         return [
             ...headerRows,
-            ...renderSelectableSidebarRows(h, Text, sortedBranches, state.selectedBranchIndex, focused, width, theme, (branch) => `${branchRowMarker(branch, { ascii: theme.ascii })} ${branch.shortName}`, 'tab-branches', visibleListCount),
+            ...renderSelectableSidebarRows(h, Text, sortedBranches, state.selectedBranchIndex, focused, width, theme, (branch) => `${branchRowMarker(branch, { ascii: theme.ascii }).glyph} ${branch.shortName}`, 'tab-branches', visibleListCount),
         ];
     }
     if (tab === 'tags') {
@@ -30156,21 +30375,22 @@ function renderBranchesSurface(h, components, state, context, contextStatus, bod
                 const isSelected = index === selected;
                 const cursor = isSelected ? '>' : ' ';
                 const marker = branchRowMarker(branch, { ascii: theme.ascii });
+                const markerColor = getBranchRowMarkerColor(marker.kind, theme);
                 const divergence = formatBranchDivergence(branch, { ascii: theme.ascii });
                 const lastTouched = formatBranchLastTouched(branch.date, new Date());
                 // Split the row into spans so the timestamp stays dim even on the
-                // currently-selected (bold) row. The leading marker + name keep
-                // their per-window-derived column widths; the timestamp is
-                // right-padded so the divergence column stays aligned across rows.
+                // currently-selected (bold) row, and the sync-state marker keeps
+                // its own colour even when the surrounding row text is dimmed.
                 const namePadded = truncateCells(branch.shortName, nameColWidth).padEnd(nameColWidth);
                 const timestampPadded = lastTouched.padEnd(8);
                 const lineDim = !isSelected && !branch.current;
-                const head = `${cursor} ${marker} ${namePadded} `;
+                const cursorAndPad = `${cursor} `;
+                const trailingName = ` ${namePadded} `;
                 const trailingDivergence = divergence ? ` ${divergence}` : '';
                 // Truncate the assembled line to the actual panel width so a
                 // narrow inspector / sidebar focus doesn't push branch rows
                 // onto a second visual line (#830).
-                const fullText = `${head}${timestampPadded}${trailingDivergence}`;
+                const fullText = `${cursorAndPad}${marker.glyph}${trailingName}${timestampPadded}${trailingDivergence}`;
                 const truncated = truncateCells(fullText, Math.max(20, width - 4));
                 // If truncation chopped into the timestamp/divergence portion,
                 // fall back to a single Text to keep the visible width honest.
@@ -30185,7 +30405,15 @@ function renderBranchesSurface(h, components, state, context, contextStatus, bod
                     key: `branch-${index}`,
                     bold: isSelected,
                     dimColor: lineDim,
-                }, head, h(Text, { dimColor: true }, timestampPadded), trailingDivergence);
+                }, cursorAndPad, 
+                // The marker carries the sync-state colour; an explicit
+                // `dimColor: false` on this span keeps the colour bright even
+                // when the surrounding row is dim (other branches in the list
+                // dim out under the existing `lineDim` rule). The synced /
+                // no-upstream kinds return undefined from
+                // `getBranchRowMarkerColor`, so those markers inherit the
+                // row's dim and read as quiet chrome.
+                h(Text, { color: markerColor, dimColor: markerColor ? false : undefined }, marker.glyph), trailingName, h(Text, { dimColor: true }, timestampPadded), trailingDivergence);
             });
     return h(Box, {
         borderColor: focusBorderColor(theme, focused),
@@ -32197,6 +32425,25 @@ function renderHistoryPanel(h, components, state, context, bodyRows, width, them
         paddingX: 1,
         width,
     }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Commits', focused)), h(Text, { dimColor: true }, `${title} | ${graphMode} | ${loadState}`)), 
+    // Upstream-ahead banner. Surfaces "the remote has work you don't"
+    // for the current branch — distinct from the chip work in 0.52.0
+    // which colours remote refs IN the row set. On a behind branch the
+    // upstream commits aren't reachable from local HEAD, so the chips
+    // alone can't signal "fetch / pull needed." This single line does.
+    //
+    // Two wording variants (behind-only vs diverged) live in the
+    // helper; render is identical aside from the formatted string.
+    // Warning yellow = same semantic as the remote-tracking chip kind.
+    ...((() => {
+        const currentBranchRef = context.branches?.localBranches.find((branch) => branch.current);
+        const banner = formatUpstreamAheadBanner(currentBranchRef, { ascii: theme.ascii });
+        if (!banner)
+            return [];
+        return [h(Text, {
+                key: 'upstream-ahead-banner',
+                color: theme.noColor ? undefined : theme.colors.warning,
+            }, banner)];
+    })()), 
     // Server-side filter indicator (#776). Only rendered when the user
     // has an active path:/author: prefix; clears when they Ctrl+U.
     ...(state.historyFetchArgs
@@ -36877,16 +37124,20 @@ function LogInkApp(deps) {
             return;
         }
         // Success — close the overlay, reset compose (the staged set is
-        // now empty since the plan committed everything), and pop the
-        // compose view so the user lands on whatever was beneath (usually
-        // status, sometimes history).
+        // now empty since the plan committed everything), and route the
+        // user to the history view so they see the just-landed commits
+        // with the recent-commit marker firing on each row that was
+        // created. Previous behavior popped compose to whatever was
+        // beneath (often status — which now reads "clean worktree" and
+        // gives the user no signal that anything just happened);
+        // history is the natural follow-on surface.
+        //
+        // navigateHome nukes the rest of the stack so `<` after apply
+        // doesn't walk back into the now-empty compose / status state
+        // the user just left behind.
         dispatch({ type: 'clearSplitPlan' });
         dispatch({ type: 'commitCompose', action: { type: 'reset' } });
-        // Only pop if compose is on top — the apply could have been
-        // invoked from a deeper stack and we don't want to over-pop.
-        if (state.activeView === 'compose' && state.viewStack.length > 1) {
-            dispatch({ type: 'popView' });
-        }
+        dispatch({ type: 'navigateHome' });
         // Refresh BEFORE setting the final status so we can peek at the
         // post-apply worktree state and craft a directive next-step hint
         // ("X unstaged + Y untracked remaining — press gs to stage / I
@@ -36936,7 +37187,7 @@ function LogInkApp(deps) {
         }
         const successMessage = formatSplitApplySuccess(commitHashes.length, unstaged, untracked);
         dispatch({ type: 'setStatus', value: successMessage, kind: 'success' });
-    }, [dispatch, git, refreshContext, refreshHistoryRows, refreshWorktreeContext, state.activeView, state.splitPlan, state.viewStack.length]);
+    }, [dispatch, git, refreshContext, refreshHistoryRows, refreshWorktreeContext, state.splitPlan]);
     // Esc inside the overlay — close without applying. Status line gets
     // a confirmation so the user knows the operation was abandoned.
     const cancelCommitSplit = React.useCallback(() => {
@@ -37443,6 +37694,41 @@ function LogInkApp(deps) {
             'fetch-remotes': async () => fetchRemotes(git),
             'pull-current-branch': async () => pullCurrentBranch(git),
             'push-current-branch': async () => pushCurrentBranch(git),
+            // Per-branch fetch / pull / push that operate on the cursored
+            // row in the branches sidebar. inkInput.ts dispatches these
+            // when F / U / P fire from the sidebar; the *-current-branch
+            // / fetch-remotes variants above still handle the same keys
+            // from any other context.
+            'fetch-selected-branch': async () => {
+                const all = sortBranches(context.branches?.localBranches || [], state.branchSort);
+                const visible = state.filter
+                    ? all.filter((b) => matchesPromotedFilter([b.shortName, b.upstream || ''], state.filter))
+                    : all;
+                const branch = visible[Math.min(state.selectedBranchIndex, visible.length - 1)];
+                if (!branch)
+                    return { ok: false, message: 'No branch selected' };
+                return fetchBranch(git, branch);
+            },
+            'pull-selected-branch': async () => {
+                const all = sortBranches(context.branches?.localBranches || [], state.branchSort);
+                const visible = state.filter
+                    ? all.filter((b) => matchesPromotedFilter([b.shortName, b.upstream || ''], state.filter))
+                    : all;
+                const branch = visible[Math.min(state.selectedBranchIndex, visible.length - 1)];
+                if (!branch)
+                    return { ok: false, message: 'No branch selected' };
+                return pullBranch(git, branch, context.branches?.currentBranch);
+            },
+            'push-selected-branch': async () => {
+                const all = sortBranches(context.branches?.localBranches || [], state.branchSort);
+                const visible = state.filter
+                    ? all.filter((b) => matchesPromotedFilter([b.shortName, b.upstream || ''], state.filter))
+                    : all;
+                const branch = visible[Math.min(state.selectedBranchIndex, visible.length - 1)];
+                if (!branch)
+                    return { ok: false, message: 'No branch selected' };
+                return pushBranch(git, branch);
+            },
             'rename-branch': async () => {
                 const newName = payload?.trim();
                 if (!newName)

package/dist/index.js

@@ -78,7 +78,7 @@ var readline__namespace = /*#__PURE__*/_interopNamespaceDefault(readline);
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.52.0";
+const BUILD_VERSION = "0.53.0";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -15629,6 +15629,7 @@ Structural rules:
 - Only use hunk IDs LITERALLY copied from the "Staged hunk inventory" section below. Do not invent or guess hunk IDs.
 - If the hunk inventory says "No hunk-level inventory available" then EVERY group's "hunks" array MUST be empty (use only "files"). Do not write hunk IDs like "path::hunk-1" when no hunk inventory exists — those are not valid.
 - Prefer 2-5 commits unless the changes are truly all one topic.
+- Order the groups in the sequence they would logically be built — foundational changes first, consumers after. If group B uses a symbol, function, type, or file introduced in group A, A MUST appear before B in the array. The applier commits in array order, so this order becomes the git history. Example: a "feat: add helpers" group that introduces \`formatX()\` must come before a "feat: wire helpers into renderer" group that calls \`formatX()\`, even if the staged diff is presented in the opposite order. When two groups have no dependency relationship, prefer the one closer to a "scaffold" (types, config, new files) before the one closer to a "use site" (existing files modified to consume the new code).
 
 Commit message style:
 - Write each "title" in the imperative mood ("add", not "added"), under 72 chars.
@@ -21085,6 +21086,37 @@ function getLogInkWorkflowActions() {
             kind: 'normal',
             requiresConfirmation: false,
         },
+        // Per-view variants of fetch / pull / push that act on the
+        // cursored branch instead of the current one. Empty `key` keeps
+        // them palette-discoverable without registering a global hotkey —
+        // inkInput.ts dispatches them contextually when the user presses
+        // F / U / P while the branches sidebar is focused. Outside that
+        // context, the F / U / P keys still fire the global *-current-*
+        // / fetch-remotes variants above.
+        {
+            id: 'fetch-selected-branch',
+            key: '',
+            label: 'Fetch selected branch',
+            description: 'Run `git fetch <remote> <branch>` for the cursored branch in the branches view / sidebar.',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
+        {
+            id: 'pull-selected-branch',
+            key: '',
+            label: 'Pull selected branch',
+            description: 'Pull the cursored branch in the branches view / sidebar. Falls back to a fast-forward-only refspec fetch when the branch is not currently checked out; refuses non-FF.',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
+        {
+            id: 'push-selected-branch',
+            key: '',
+            label: 'Push selected branch',
+            description: 'Run `git push <remote> <branch>` for the cursored branch in the branches view / sidebar.',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
         {
             // Per-view-only — the inkInput handler scopes this to the tags
             // surface so we don't expose `R` as a remote-delete from elsewhere.
@@ -22025,8 +22057,22 @@ function getLogInkFooterHints(options) {
         // "enter open" hint that drills into the dedicated view.
         const itemsPresent = (options.sidebarItemCount ?? 0) > 0;
         if (itemsPresent && options.sidebarTab === 'branches') {
+            // P / U / F fire the global pull-current-branch, push-current-branch,
+            // fetch-remotes workflows — already implemented, just not visible in
+            // the footer before. Surfacing them here matters because the user's
+            // attention is on a branch when the branches sidebar is focused;
+            // pull / push / fetch are the next obvious actions.
+            //
+            // Note: `U` and `P` currently operate on the CURRENT branch, not the
+            // cursored one. Task #5 will extend them to act on the cursored row;
+            // until then the labels read as "current-branch ops" by virtue of
+            // matching the workflow descriptions.
             return {
-                contextual: ['↑/↓ branches', '←/→ tab', 'enter checkout', 'D delete', 'R rename', 'u upstream'],
+                contextual: [
+                    '↑/↓ branches', '←/→ tab', 'enter checkout',
+                    'F fetch', 'U pull', 'P push',
+                    'D delete', 'R rename', 'u upstream',
+                ],
                 global: NORMAL_GLOBAL_HINTS,
             };
         }
@@ -26455,6 +26501,27 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         events.push({ type: 'createManualCommit' });
         return events;
     }
+    // Context-sensitive per-branch variants of F / U / P. When the
+    // user has the branches sidebar / view focused with at least one
+    // branch, F / U / P should act on the cursored row, not on the
+    // current branch. This intercept fires BEFORE the generic
+    // workflow-by-key lookup below so the global *-current-branch
+    // variants don't shadow the contextual ones.
+    //
+    // Outside the branches context, the generic lookup runs and the
+    // F / U / P keys hit the global `fetch-remotes` / `pull-current-branch`
+    // / `push-current-branch` workflows as before.
+    if (isBranchActionTarget(state) && context.branchCount) {
+        if (inputValue === 'F') {
+            return [{ type: 'runWorkflowAction', id: 'fetch-selected-branch' }];
+        }
+        if (inputValue === 'U') {
+            return [{ type: 'runWorkflowAction', id: 'pull-selected-branch' }];
+        }
+        if (inputValue === 'P') {
+            return [{ type: 'runWorkflowAction', id: 'push-selected-branch' }];
+        }
+    }
     const workflowAction = getLogInkWorkflowActionByKey(inputValue);
     if (workflowAction?.requiresConfirmation) {
         return [action({ type: 'setPendingConfirmation', value: workflowAction.id })];
@@ -27557,6 +27624,106 @@ function pushCurrentBranch(git) {
 function setUpstream(git, localBranch, upstreamBranch) {
     return runAction$5(() => git.raw(['branch', '--set-upstream-to', upstreamBranch, localBranch]), `Set ${localBranch} upstream to ${upstreamBranch}`);
 }
+/**
+ * Push an arbitrary local branch (need not be the current branch) to
+ * its remote. Refuses when the branch has no upstream and no remote
+ * defaulting is configured — that branch needs a `git push -u …` from
+ * the shell first.
+ *
+ * Pairs with `pushCurrentBranch` (no-arg variant); the workstation
+ * dispatcher picks one or the other based on where the cursor is.
+ */
+function pushBranch(git, branch) {
+    if (branch.type !== 'local') {
+        return Promise.resolve({
+            ok: false,
+            message: 'Only local branches can be pushed.',
+        });
+    }
+    if (!branch.upstream || !branch.remote) {
+        return Promise.resolve({
+            ok: false,
+            message: `${branch.shortName} has no upstream — checkout the branch and run \`git push -u <remote> ${branch.shortName}\` first.`,
+        });
+    }
+    return runAction$5(() => git.raw(['push', branch.remote, branch.shortName]), `Pushed ${branch.shortName} to ${branch.upstream}`);
+}
+/**
+ * Fetch the cursored branch's upstream from its remote. Side-effect
+ * free on the working tree — just updates the remote-tracking ref.
+ * Works for any branch with an upstream regardless of checkout state.
+ *
+ * Falls back to a clean error when the branch has no upstream
+ * configured (`git fetch <remote> <name>` would assume an unrelated
+ * default refspec and surprise the user).
+ */
+function fetchBranch(git, branch) {
+    if (branch.type !== 'local') {
+        return Promise.resolve({
+            ok: false,
+            message: 'Only local branches can be fetched per-branch — use F to fetch all remotes.',
+        });
+    }
+    if (!branch.upstream || !branch.remote) {
+        return Promise.resolve({
+            ok: false,
+            message: `${branch.shortName} has no upstream — nothing to fetch.`,
+        });
+    }
+    // `branch.upstream` is the short form (e.g. `origin/main`); the
+    // ref name after the remote prefix is what fetch wants as the
+    // refspec source. For a remote `origin` and upstream `origin/main`
+    // we run `git fetch origin main`.
+    const upstreamRef = branch.upstream.startsWith(`${branch.remote}/`)
+        ? branch.upstream.slice(branch.remote.length + 1)
+        : branch.upstream;
+    return runAction$5(() => git.raw(['fetch', branch.remote, upstreamRef]), `Fetched ${branch.upstream}`);
+}
+/**
+ * Pull the cursored branch. Branches into two paths based on whether
+ * the branch is currently checked out:
+ *
+ *   - **Current branch**: defer to `pullCurrentBranch` (standard
+ *     `git pull --ff-only`).
+ *   - **Non-current branch**: use the refspec form
+ *     `git fetch <remote> <branch>:<branch>` which advances the local
+ *     ref to match the remote ref ONLY if the update is fast-forward.
+ *     Returns non-zero on non-FF without touching the working tree.
+ *     Diverged branches need a checkout + `pull --rebase` from the
+ *     user; we refuse rather than try to do that for them.
+ *
+ * `currentBranchName` lets the dispatcher compare without re-querying
+ * git — it already has the value in `context.branches.currentBranch`.
+ */
+function pullBranch(git, branch, currentBranchName) {
+    if (branch.type !== 'local') {
+        return Promise.resolve({
+            ok: false,
+            message: 'Only local branches can be pulled.',
+        });
+    }
+    if (!branch.upstream || !branch.remote) {
+        return Promise.resolve({
+            ok: false,
+            message: `${branch.shortName} has no upstream — nothing to pull.`,
+        });
+    }
+    // Current branch — defer to the in-place workflow.
+    if (branch.shortName === currentBranchName) {
+        return pullCurrentBranch(git);
+    }
+    // Non-current branch — refspec-based fast-forward refusing non-FF.
+    // `branch.upstream` is `<remote>/<ref>`; strip the remote prefix to
+    // get the upstream ref name to fetch.
+    const upstreamRef = branch.upstream.startsWith(`${branch.remote}/`)
+        ? branch.upstream.slice(branch.remote.length + 1)
+        : branch.upstream;
+    return runAction$5(() => git.raw([
+        'fetch',
+        branch.remote,
+        `${upstreamRef}:${branch.shortName}`,
+    ]), `Fast-forwarded ${branch.shortName} to ${branch.upstream}`);
+}
 
 async function runAction$4(action, successMessage) {
     try {
@@ -29080,29 +29247,81 @@ function formatBranchDivergence(branch, options = {}) {
         parts.push(`↓${branch.behind}`);
     return `${parts.join(' ')} ${branch.upstream}`;
 }
-/**
- * Single-cell marker shown to the left of a branch name in lists.
- *
- * - `*` — current branch (regardless of remote state)
- * - `◌` — no upstream
- * - `≡` — has upstream + synced (ahead === 0 && behind === 0)
- * - `↕` — has upstream + diverged (any non-zero ahead/behind)
- * - ` ` — fallback / no info
- *
- * ASCII fallbacks (legible without box-drawing/arrow glyphs):
- * - `?` for "no upstream", `=` for synced, `~` for diverged.
- */
+function formatUpstreamAheadBanner(branch, options = {}) {
+    if (!branch?.upstream || branch.behind <= 0) {
+        return undefined;
+    }
+    const sep = options.ascii ? '.' : '·';
+    if (branch.ahead > 0) {
+        // Diverged — local has work too, fast-forward pull is impossible.
+        // Suggest pull --rebase as the cleaner-history default; users who
+        // prefer merge can do that themselves.
+        const symbols = options.ascii
+            ? `+${branch.ahead} -${branch.behind}`
+            : `↑${branch.ahead} ↓${branch.behind}`;
+        return `${symbols} diverged from ${branch.upstream} ${sep} F fetch ${sep} U pull --rebase`;
+    }
+    // Behind-only — fast-forward pull works.
+    const arrow = options.ascii ? 'v' : '↓';
+    const noun = branch.behind === 1 ? 'commit' : 'commits';
+    return `${arrow} ${branch.behind} ${noun} behind ${branch.upstream} ${sep} F fetch ${sep} U pull`;
+}
 function branchRowMarker(branch, options = {}) {
-    if (branch.current)
-        return '*';
-    if (!branch.upstream)
-        return options.ascii ? '?' : '◌';
+    if (branch.current) {
+        return { glyph: '*', kind: 'head' };
+    }
+    if (!branch.upstream) {
+        return { glyph: options.ascii ? '?' : '◌', kind: 'no-upstream' };
+    }
     const ahead = branch.ahead ?? 0;
     const behind = branch.behind ?? 0;
     if (ahead === 0 && behind === 0) {
-        return options.ascii ? '=' : '≡';
+        return { glyph: options.ascii ? '=' : '≡', kind: 'synced' };
+    }
+    if (ahead > 0 && behind > 0) {
+        return { glyph: options.ascii ? '~' : '⇅', kind: 'diverged' };
+    }
+    if (behind > 0) {
+        return { glyph: options.ascii ? 'v' : '↓', kind: 'behind' };
+    }
+    // ahead > 0 (the only remaining case after the guards above)
+    return { glyph: options.ascii ? '^' : '↑', kind: 'ahead' };
+}
+/**
+ * Theme-aware colour picker for a `BranchRowMarker.kind`.
+ *
+ * Reuses the existing chip / banner colour semantic so the workstation
+ * speaks one visual language across history (chips, "behind upstream"
+ * banner) and the branches list:
+ *
+ *   - `head`        → success green (matches HEAD chip)
+ *   - `behind`      → warning yellow (matches "behind upstream" banner)
+ *   - `diverged`    → warning yellow (same: action needed inbound)
+ *   - `ahead`       → info blue (you have work to push)
+ *   - `synced`      → undefined (neutral; inherit row's existing dim)
+ *   - `no-upstream` → undefined (neutral; same)
+ *
+ * Returns `undefined` under `noColor` / `ascii` for the muted cases so
+ * the row renderer skips the colour wrap entirely; the glyph alone
+ * carries the meaning.
+ */
+function getBranchRowMarkerColor(kind, theme) {
+    if (theme.noColor)
+        return undefined;
+    switch (kind) {
+        case 'head':
+            return theme.colors.success;
+        case 'behind':
+        case 'diverged':
+            return theme.colors.warning;
+        case 'ahead':
+            return theme.colors.info;
+        case 'synced':
+        case 'no-upstream':
+            return undefined;
+        default:
+            return undefined;
     }
-    return options.ascii ? '~' : '↕';
 }
 /**
  * Compact, human-friendly relative timestamp for the branch row.
@@ -29710,7 +29929,7 @@ function renderActiveSidebarContent(h, Text, tab, state, context, contextStatus,
         ];
         return [
             ...headerRows,
-            ...renderSelectableSidebarRows(h, Text, sortedBranches, state.selectedBranchIndex, focused, width, theme, (branch) => `${branchRowMarker(branch, { ascii: theme.ascii })} ${branch.shortName}`, 'tab-branches', visibleListCount),
+            ...renderSelectableSidebarRows(h, Text, sortedBranches, state.selectedBranchIndex, focused, width, theme, (branch) => `${branchRowMarker(branch, { ascii: theme.ascii }).glyph} ${branch.shortName}`, 'tab-branches', visibleListCount),
         ];
     }
     if (tab === 'tags') {
@@ -30173,21 +30392,22 @@ function renderBranchesSurface(h, components, state, context, contextStatus, bod
                 const isSelected = index === selected;
                 const cursor = isSelected ? '>' : ' ';
                 const marker = branchRowMarker(branch, { ascii: theme.ascii });
+                const markerColor = getBranchRowMarkerColor(marker.kind, theme);
                 const divergence = formatBranchDivergence(branch, { ascii: theme.ascii });
                 const lastTouched = formatBranchLastTouched(branch.date, new Date());
                 // Split the row into spans so the timestamp stays dim even on the
-                // currently-selected (bold) row. The leading marker + name keep
-                // their per-window-derived column widths; the timestamp is
-                // right-padded so the divergence column stays aligned across rows.
+                // currently-selected (bold) row, and the sync-state marker keeps
+                // its own colour even when the surrounding row text is dimmed.
                 const namePadded = truncateCells(branch.shortName, nameColWidth).padEnd(nameColWidth);
                 const timestampPadded = lastTouched.padEnd(8);
                 const lineDim = !isSelected && !branch.current;
-                const head = `${cursor} ${marker} ${namePadded} `;
+                const cursorAndPad = `${cursor} `;
+                const trailingName = ` ${namePadded} `;
                 const trailingDivergence = divergence ? ` ${divergence}` : '';
                 // Truncate the assembled line to the actual panel width so a
                 // narrow inspector / sidebar focus doesn't push branch rows
                 // onto a second visual line (#830).
-                const fullText = `${head}${timestampPadded}${trailingDivergence}`;
+                const fullText = `${cursorAndPad}${marker.glyph}${trailingName}${timestampPadded}${trailingDivergence}`;
                 const truncated = truncateCells(fullText, Math.max(20, width - 4));
                 // If truncation chopped into the timestamp/divergence portion,
                 // fall back to a single Text to keep the visible width honest.
@@ -30202,7 +30422,15 @@ function renderBranchesSurface(h, components, state, context, contextStatus, bod
                     key: `branch-${index}`,
                     bold: isSelected,
                     dimColor: lineDim,
-                }, head, h(Text, { dimColor: true }, timestampPadded), trailingDivergence);
+                }, cursorAndPad, 
+                // The marker carries the sync-state colour; an explicit
+                // `dimColor: false` on this span keeps the colour bright even
+                // when the surrounding row is dim (other branches in the list
+                // dim out under the existing `lineDim` rule). The synced /
+                // no-upstream kinds return undefined from
+                // `getBranchRowMarkerColor`, so those markers inherit the
+                // row's dim and read as quiet chrome.
+                h(Text, { color: markerColor, dimColor: markerColor ? false : undefined }, marker.glyph), trailingName, h(Text, { dimColor: true }, timestampPadded), trailingDivergence);
             });
     return h(Box, {
         borderColor: focusBorderColor(theme, focused),
@@ -32214,6 +32442,25 @@ function renderHistoryPanel(h, components, state, context, bodyRows, width, them
         paddingX: 1,
         width,
     }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Commits', focused)), h(Text, { dimColor: true }, `${title} | ${graphMode} | ${loadState}`)), 
+    // Upstream-ahead banner. Surfaces "the remote has work you don't"
+    // for the current branch — distinct from the chip work in 0.52.0
+    // which colours remote refs IN the row set. On a behind branch the
+    // upstream commits aren't reachable from local HEAD, so the chips
+    // alone can't signal "fetch / pull needed." This single line does.
+    //
+    // Two wording variants (behind-only vs diverged) live in the
+    // helper; render is identical aside from the formatted string.
+    // Warning yellow = same semantic as the remote-tracking chip kind.
+    ...((() => {
+        const currentBranchRef = context.branches?.localBranches.find((branch) => branch.current);
+        const banner = formatUpstreamAheadBanner(currentBranchRef, { ascii: theme.ascii });
+        if (!banner)
+            return [];
+        return [h(Text, {
+                key: 'upstream-ahead-banner',
+                color: theme.noColor ? undefined : theme.colors.warning,
+            }, banner)];
+    })()), 
     // Server-side filter indicator (#776). Only rendered when the user
     // has an active path:/author: prefix; clears when they Ctrl+U.
     ...(state.historyFetchArgs
@@ -36894,16 +37141,20 @@ function LogInkApp(deps) {
             return;
         }
         // Success — close the overlay, reset compose (the staged set is
-        // now empty since the plan committed everything), and pop the
-        // compose view so the user lands on whatever was beneath (usually
-        // status, sometimes history).
+        // now empty since the plan committed everything), and route the
+        // user to the history view so they see the just-landed commits
+        // with the recent-commit marker firing on each row that was
+        // created. Previous behavior popped compose to whatever was
+        // beneath (often status — which now reads "clean worktree" and
+        // gives the user no signal that anything just happened);
+        // history is the natural follow-on surface.
+        //
+        // navigateHome nukes the rest of the stack so `<` after apply
+        // doesn't walk back into the now-empty compose / status state
+        // the user just left behind.
         dispatch({ type: 'clearSplitPlan' });
         dispatch({ type: 'commitCompose', action: { type: 'reset' } });
-        // Only pop if compose is on top — the apply could have been
-        // invoked from a deeper stack and we don't want to over-pop.
-        if (state.activeView === 'compose' && state.viewStack.length > 1) {
-            dispatch({ type: 'popView' });
-        }
+        dispatch({ type: 'navigateHome' });
         // Refresh BEFORE setting the final status so we can peek at the
         // post-apply worktree state and craft a directive next-step hint
         // ("X unstaged + Y untracked remaining — press gs to stage / I
@@ -36953,7 +37204,7 @@ function LogInkApp(deps) {
         }
         const successMessage = formatSplitApplySuccess(commitHashes.length, unstaged, untracked);
         dispatch({ type: 'setStatus', value: successMessage, kind: 'success' });
-    }, [dispatch, git, refreshContext, refreshHistoryRows, refreshWorktreeContext, state.activeView, state.splitPlan, state.viewStack.length]);
+    }, [dispatch, git, refreshContext, refreshHistoryRows, refreshWorktreeContext, state.splitPlan]);
     // Esc inside the overlay — close without applying. Status line gets
     // a confirmation so the user knows the operation was abandoned.
     const cancelCommitSplit = React.useCallback(() => {
@@ -37460,6 +37711,41 @@ function LogInkApp(deps) {
             'fetch-remotes': async () => fetchRemotes(git),
             'pull-current-branch': async () => pullCurrentBranch(git),
             'push-current-branch': async () => pushCurrentBranch(git),
+            // Per-branch fetch / pull / push that operate on the cursored
+            // row in the branches sidebar. inkInput.ts dispatches these
+            // when F / U / P fire from the sidebar; the *-current-branch
+            // / fetch-remotes variants above still handle the same keys
+            // from any other context.
+            'fetch-selected-branch': async () => {
+                const all = sortBranches(context.branches?.localBranches || [], state.branchSort);
+                const visible = state.filter
+                    ? all.filter((b) => matchesPromotedFilter([b.shortName, b.upstream || ''], state.filter))
+                    : all;
+                const branch = visible[Math.min(state.selectedBranchIndex, visible.length - 1)];
+                if (!branch)
+                    return { ok: false, message: 'No branch selected' };
+                return fetchBranch(git, branch);
+            },
+            'pull-selected-branch': async () => {
+                const all = sortBranches(context.branches?.localBranches || [], state.branchSort);
+                const visible = state.filter
+                    ? all.filter((b) => matchesPromotedFilter([b.shortName, b.upstream || ''], state.filter))
+                    : all;
+                const branch = visible[Math.min(state.selectedBranchIndex, visible.length - 1)];
+                if (!branch)
+                    return { ok: false, message: 'No branch selected' };
+                return pullBranch(git, branch, context.branches?.currentBranch);
+            },
+            'push-selected-branch': async () => {
+                const all = sortBranches(context.branches?.localBranches || [], state.branchSort);
+                const visible = state.filter
+                    ? all.filter((b) => matchesPromotedFilter([b.shortName, b.upstream || ''], state.filter))
+                    : all;
+                const branch = visible[Math.min(state.selectedBranchIndex, visible.length - 1)];
+                if (!branch)
+                    return { ok: false, message: 'No branch selected' };
+                return pushBranch(git, branch);
+            },
             'rename-branch': async () => {
                 const newName = payload?.trim();
                 if (!newName)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-coco",
-  "version": "0.52.0",
+  "version": "0.53.0",
   "description": "zero-effort git commits with coco.",
   "author": "gfargo <ghfargo@gmail.com>",
   "license": "MIT",
@@ -41,7 +41,7 @@
     "test:publish": "npm run lint && npm run build && npm run test:cli && npm pack --dry-run",
     "test:cli": "tsx bin/smokeCli.ts",
     "bench": "tsx bin/benchmark.ts",
-    "scenario": "git-scenarios",
+    "scenario": "tsx bin/scenarioRunner.ts",
     "eval:structural-extract": "tsx bin/structuralExtractEval.ts",
     "pretest:jest": "npm run build:info && node bin/copyTreeSitterWasm.mjs",
     "test:jest": "cross-env NODE_OPTIONS=--experimental-vm-modules jest",
@@ -61,7 +61,7 @@
   },
   "devDependencies": {
     "@commitlint/types": "^20.5.0",
-    "@gfargo/git-scenarios": "^0.3.0",
+    "@gfargo/git-scenarios": "^0.3.3",
     "@rollup/plugin-commonjs": "^29.0.0",
     "@rollup/plugin-eslint": "^9.0.5",
     "@rollup/plugin-json": "^6.0.0",