git-coco 0.41.0 → 0.41.2

package/dist/index.esm.mjs

@@ -53,7 +53,7 @@ import { pathToFileURL } from 'url';
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.41.0";
+const BUILD_VERSION = "0.41.2";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -6750,13 +6750,35 @@ async function getCommitLogRangeDetails(from, to, { noMerges, git }) {
 }
 
 /**
- * Retrieves the name of the current branch.
+ * Retrieve the name of the current branch.
  *
- * @param {GetCurrentBranchName} options - The options for retrieving the branch name.
- * @returns {Promise<string>} - A promise that resolves to the name of the current branch.
+ * The first-choice path uses `git rev-parse --abbrev-ref HEAD`, which
+ * returns the active branch on a normal repo. On an initial-commit
+ * repo (fresh `git init` with no commits yet) HEAD does not resolve
+ * and rev-parse fails fatally — but `git symbolic-ref --short HEAD`
+ * still reports the configured initial branch name, so we fall
+ * through to that. Final fallback is an empty string for genuinely
+ * detached / corrupt states; every caller treats that as "no branch
+ * context", which is the right semantics for a no-HEAD repo.
+ *
+ * Without this resilience, every command that depends on the branch
+ * name (e.g. the post-summary step in `coco commit`) would crash
+ * with `fatal: ambiguous argument 'HEAD'` after the entire diff
+ * pipeline already ran (#844).
  */
 async function getCurrentBranchName({ git }) {
-    return await git.revparse(['--abbrev-ref', 'HEAD']);
+    try {
+        return await git.revparse(['--abbrev-ref', 'HEAD']);
+    }
+    catch {
+        try {
+            const ref = await git.raw(['symbolic-ref', '--short', 'HEAD']);
+            return ref.trim();
+        }
+        catch {
+            return '';
+        }
+    }
 }
 
 /**
@@ -14951,6 +14973,19 @@ function getLogInkWorkflowActions() {
             kind: 'destructive',
             requiresConfirmation: true,
         },
+        {
+            // Per-view-only — the inkInput handler scopes this to the
+            // worktrees surface so the global `D` keystroke (delete-branch)
+            // keeps working from elsewhere. The empty `key` keeps the
+            // workflow palette-discoverable but does not register a global
+            // hotkey that would collide with delete-branch.
+            id: 'remove-worktree-and-branch',
+            key: '',
+            label: 'Remove worktree + delete branch',
+            description: 'Remove the selected worktree and delete the branch it was tracking after confirmation.',
+            kind: 'destructive',
+            requiresConfirmation: true,
+        },
         {
             id: 'abort-operation',
             key: 'A',
@@ -18415,6 +18450,16 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
     if (inputValue === 'R' && isTagActionTarget(state) && context.tagCount) {
         return [action({ type: 'setPendingConfirmation', value: 'delete-remote-tag' })];
     }
+    // Per-view worktree action: `D` removes the worktree AND deletes
+    // the branch it was tracking (#838). Scoped to the worktrees
+    // surface so it intercepts BEFORE the global workflow-by-key
+    // dispatcher would otherwise route `D` to delete-branch (which
+    // would silently target whatever was last cursored on the branches
+    // surface instead of acting on the worktree under the cursor here).
+    // `W` keeps its existing "remove worktree only" semantics.
+    if (inputValue === 'D' && isWorktreeActionTarget(state) && context.worktreeListCount) {
+        return [action({ type: 'setPendingConfirmation', value: 'remove-worktree-and-branch' })];
+    }
     // #783 — full PR action panel keys, scoped to the pull-request view.
     // All five wrap a `gh pr <verb>` invocation; merge / request-changes /
     // comment open prompts first, the rest route through the y-confirm
@@ -21485,6 +21530,56 @@ function worktreePathAction(worktree) {
         message: `Worktree path: ${worktree.path}`,
     };
 }
+/**
+ * Remove a worktree AND delete the branch it was tracking (#838). The
+ * canonical "I'm done with this side branch" wind-down: removes the
+ * worktree directory, then runs `git branch -d` on the previously
+ * checked-out branch.
+ *
+ * Both pre-flight guards inherit from the underlying helpers:
+ *   - removeWorktree refuses the current worktree and dirty worktrees
+ *   - deleteBranch refuses the current branch and uses `-d` (safe
+ *     delete, refuses unmerged commits)
+ *
+ * Aborts cleanly at any failure point and surfaces a message that
+ * names which step broke. When the worktree had no branch (detached
+ * HEAD) the branch step is silently skipped — there's nothing to
+ * delete and the worktree removal alone counts as success.
+ */
+async function removeWorktreeAndBranch(git, worktree, branchRefs) {
+    const removeResult = await removeWorktree(git, worktree);
+    if (!removeResult.ok) {
+        return removeResult;
+    }
+    const branchName = worktree.branch;
+    if (!branchName) {
+        return {
+            ok: true,
+            message: `Removed worktree ${worktree.path} (no branch to delete)`,
+        };
+    }
+    // Look up the local BranchRef for the branch this worktree was on.
+    // deleteBranch needs the full ref (not just the name) so its
+    // current-branch and local-only guards apply correctly.
+    const branch = branchRefs.find((entry) => entry.type === 'local' && entry.shortName === branchName);
+    if (!branch) {
+        return {
+            ok: true,
+            message: `Removed worktree ${worktree.path} (branch ${branchName} not found in local branches)`,
+        };
+    }
+    const deleteResult = await deleteBranch(git, branch);
+    if (!deleteResult.ok) {
+        return {
+            ok: false,
+            message: `Removed worktree ${worktree.path}, but branch delete failed: ${deleteResult.message}`,
+        };
+    }
+    return {
+        ok: true,
+        message: `Removed worktree ${worktree.path} and deleted branch ${branchName}`,
+    };
+}
 
 function shortBranch(branch) {
     return branch?.replace(/^refs\/heads\//, '');
@@ -24536,12 +24631,27 @@ function LogInkApp(deps) {
     }, [git, selected?.hash]);
     // #806 follow-up — auto-jump the history view to whichever branch /
     // tag the user is currently cursoring in the sidebar (or the
-    // dedicated branches / tags view). Debounced so cursor-scrolling
-    // through a long branch list doesn't dispatch on every keystroke.
+    // dedicated branches / tags view).
+    //
+    // Originally this fired on a 150ms trailing-edge debounce. The user
+    // reported the sync feeling inconsistent (#839) — the trailing
+    // pattern means a fast scroll through a long branch list cancels
+    // the timer on every keystroke and only fires once on release; the
+    // user never sees the cursor follow their navigation. Switched to
+    // synchronous fire-on-effect so each cursor move snaps the history
+    // graph immediately. The dispatch is cheap (O(n) findIndex on the
+    // filtered commits + a state spread); React batches the re-renders
+    // so even rapid scroll only paints the final position. Tracks the
+    // last-dispatched hash via a ref so we don't fire setStatus
+    // repeatedly when several adjacent branches all point at the same
+    // commit (very common with squash-merged feature branches that all
+    // converge on `main`'s tip).
+    //
     // No-op when the cursored ref's tip isn't in the loaded commit
     // window (under compact mode the cursored branch's tip may not be
     // fetched yet); a status hint surfaces in that case so the user
     // knows to toggle full graph or load older commits.
+    const lastSyncedHashRef = React.useRef(undefined);
     React.useEffect(() => {
         const onBranchTab = state.activeView === 'branches' ||
             (state.focus === 'sidebar' && state.sidebarTab === 'branches');
@@ -24549,58 +24659,58 @@ function LogInkApp(deps) {
             (state.focus === 'sidebar' && state.sidebarTab === 'tags');
         if (!onBranchTab && !onTagTab)
             return;
-        let cancelled = false;
-        const timer = setTimeout(() => {
-            if (cancelled)
-                return;
-            let targetHash;
-            let targetLabel;
-            if (onBranchTab) {
-                const all = sortBranches(context.branches?.localBranches || [], state.branchSort);
-                const visible = state.filter
-                    ? all.filter((b) => matchesPromotedFilter([b.shortName, b.upstream || ''], state.filter))
-                    : all;
-                const branch = visible[Math.min(state.selectedBranchIndex, Math.max(0, visible.length - 1))];
-                if (branch) {
-                    targetHash = branch.hash;
-                    targetLabel = `branch ${branch.shortName}`;
-                }
-            }
-            else if (onTagTab) {
-                const all = sortTags(context.tags?.tags || [], state.tagSort);
-                const visible = state.filter
-                    ? all.filter((t) => matchesPromotedFilter([t.name, t.subject], state.filter))
-                    : all;
-                const tag = visible[Math.min(state.selectedTagIndex, Math.max(0, visible.length - 1))];
-                if (tag) {
-                    targetHash = tag.hash;
-                    targetLabel = `tag ${tag.name}`;
-                }
-            }
-            if (!targetHash)
-                return;
-            const loaded = state.filteredCommits.some((commit) => commit.hash === targetHash || commit.shortHash === targetHash);
-            if (loaded) {
-                dispatch({ type: 'selectCommitByHash', hash: targetHash });
-                // Confirmation status message so the user gets feedback even
-                // when the dedicated branches / tags view is occupying the
-                // main panel and the history cursor moves invisibly behind it.
-                dispatch({
-                    type: 'setStatus',
-                    value: `Synced history to ${targetLabel} tip`,
-                });
+        let targetHash;
+        let targetLabel;
+        if (onBranchTab) {
+            const all = sortBranches(context.branches?.localBranches || [], state.branchSort);
+            const visible = state.filter
+                ? all.filter((b) => matchesPromotedFilter([b.shortName, b.upstream || ''], state.filter))
+                : all;
+            const branch = visible[Math.min(state.selectedBranchIndex, Math.max(0, visible.length - 1))];
+            if (branch) {
+                targetHash = branch.hash;
+                targetLabel = `branch ${branch.shortName}`;
             }
-            else {
-                dispatch({
-                    type: 'setStatus',
-                    value: `${targetLabel} tip not in loaded window — press \\ for full graph or Ctrl+L to load more`,
-                });
+        }
+        else if (onTagTab) {
+            const all = sortTags(context.tags?.tags || [], state.tagSort);
+            const visible = state.filter
+                ? all.filter((t) => matchesPromotedFilter([t.name, t.subject], state.filter))
+                : all;
+            const tag = visible[Math.min(state.selectedTagIndex, Math.max(0, visible.length - 1))];
+            if (tag) {
+                targetHash = tag.hash;
+                targetLabel = `tag ${tag.name}`;
             }
-        }, 150);
-        return () => {
-            cancelled = true;
-            clearTimeout(timer);
-        };
+        }
+        if (!targetHash)
+            return;
+        // Skip the dispatch + status churn when the cursor hasn't
+        // actually changed which commit it's targeting (the case for
+        // rapid navigation through a cluster of branches that all point
+        // at the same commit). Without this guard the user sees a stream
+        // of "Synced history to <branch> tip" status messages even
+        // though the history cursor never moved.
+        if (targetHash === lastSyncedHashRef.current)
+            return;
+        const loaded = state.filteredCommits.some((commit) => commit.hash === targetHash || commit.shortHash === targetHash);
+        if (loaded) {
+            lastSyncedHashRef.current = targetHash;
+            dispatch({ type: 'selectCommitByHash', hash: targetHash });
+            // Confirmation status message so the user gets feedback even
+            // when the dedicated branches / tags view is occupying the
+            // main panel and the history cursor moves invisibly behind it.
+            dispatch({
+                type: 'setStatus',
+                value: `Synced history to ${targetLabel} tip`,
+            });
+        }
+        else {
+            dispatch({
+                type: 'setStatus',
+                value: `${targetLabel} tip not in loaded window — press \\ for full graph or Ctrl+L to load more`,
+            });
+        }
     }, [
         dispatch, context.branches, context.tags,
         state.activeView, state.focus, state.sidebarTab,
@@ -24608,6 +24718,18 @@ function LogInkApp(deps) {
         state.branchSort, state.tagSort, state.filter,
         state.filteredCommits,
     ]);
+    // Reset the dedup ref when the user moves focus away from the
+    // sidebar branches / tags tab so re-entering re-fires the sync
+    // even if the cursored branch is the same as before.
+    React.useEffect(() => {
+        const onBranchTab = state.activeView === 'branches' ||
+            (state.focus === 'sidebar' && state.sidebarTab === 'branches');
+        const onTagTab = state.activeView === 'tags' ||
+            (state.focus === 'sidebar' && state.sidebarTab === 'tags');
+        if (!onBranchTab && !onTagTab) {
+            lastSyncedHashRef.current = undefined;
+        }
+    }, [state.activeView, state.focus, state.sidebarTab]);
     React.useEffect(() => {
         let active = true;
         async function loadWorktreeDiff() {
@@ -25047,6 +25169,29 @@ function LogInkApp(deps) {
                 }
                 return removeWorktree(git, cursorTarget);
             },
+            'remove-worktree-and-branch': async () => {
+                const all = context.worktreeList?.worktrees || [];
+                const visible = state.filter
+                    ? all.filter((w) => matchesPromotedFilter([w.path, w.branch || ''], state.filter))
+                    : all;
+                const cursorTarget = visible.length
+                    ? visible[Math.min(state.selectedWorktreeListIndex, visible.length - 1)]
+                    : all[Math.min(state.selectedWorktreeListIndex, Math.max(0, all.length - 1))];
+                if (!cursorTarget)
+                    return { ok: false, message: 'No worktree selected' };
+                if (cursorTarget.current) {
+                    return {
+                        ok: false,
+                        message: 'Cannot remove the current worktree — switch to another worktree first.',
+                    };
+                }
+                // The chained helper handles the worktree removal AND the
+                // safe branch delete in one call. Branch refs come from the
+                // live context so the underlying deleteBranch helper sees
+                // the current/local flags it needs to refuse the destructive
+                // path on the wrong target.
+                return removeWorktreeAndBranch(git, cursorTarget, context.branches?.localBranches || []);
+            },
             'abort-operation': async () => {
                 const operation = context.operation?.operation;
                 if (!operation) {
@@ -27225,7 +27370,12 @@ function renderComposeContextPanel(h, components, state, context, contextStatus,
             }, truncate$1(theme.ascii ? '[...] AI draft in progress' : '⏳ AI draft in progress', width - 4))]
         : []), ...(stagedFiles.length
         ? [
-            h(Text, { key: 'compose-context-staged-title', bold: true }, 'Staged'),
+            // Section header carries the total count to match the status
+            // surface's "▾ Staged (n)" treatment (#840). The visible
+            // file list is sliced at 12 rows; using `worktree.stagedCount`
+            // (the total) avoids a misleading "Staged (12)" label when
+            // there are actually more staged files below the slice.
+            h(Text, { key: 'compose-context-staged-title', bold: true }, `Staged (${worktree?.stagedCount ?? stagedFiles.length})`),
             ...stagedFiles.map((file, index) => h(Text, {
                 key: `compose-context-staged-${index}`,
                 color: theme.noColor ? undefined : theme.colors.gitAdded,
@@ -27234,7 +27384,7 @@ function renderComposeContextPanel(h, components, state, context, contextStatus,
         ]
         : []), ...(unstagedFiles.length
         ? [
-            h(Text, { key: 'compose-context-unstaged-title', bold: true }, 'Unstaged'),
+            h(Text, { key: 'compose-context-unstaged-title', bold: true }, `Unstaged (${worktree?.unstagedCount ?? unstagedFiles.length})`),
             ...unstagedFiles.map((file, index) => h(Text, {
                 key: `compose-context-unstaged-${index}`,
                 color: theme.noColor ? undefined : theme.colors.gitModified,

package/dist/index.js

@@ -78,7 +78,7 @@ var readline__namespace = /*#__PURE__*/_interopNamespaceDefault(readline);
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.41.0";
+const BUILD_VERSION = "0.41.2";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -6775,13 +6775,35 @@ async function getCommitLogRangeDetails(from, to, { noMerges, git }) {
 }
 
 /**
- * Retrieves the name of the current branch.
+ * Retrieve the name of the current branch.
  *
- * @param {GetCurrentBranchName} options - The options for retrieving the branch name.
- * @returns {Promise<string>} - A promise that resolves to the name of the current branch.
+ * The first-choice path uses `git rev-parse --abbrev-ref HEAD`, which
+ * returns the active branch on a normal repo. On an initial-commit
+ * repo (fresh `git init` with no commits yet) HEAD does not resolve
+ * and rev-parse fails fatally — but `git symbolic-ref --short HEAD`
+ * still reports the configured initial branch name, so we fall
+ * through to that. Final fallback is an empty string for genuinely
+ * detached / corrupt states; every caller treats that as "no branch
+ * context", which is the right semantics for a no-HEAD repo.
+ *
+ * Without this resilience, every command that depends on the branch
+ * name (e.g. the post-summary step in `coco commit`) would crash
+ * with `fatal: ambiguous argument 'HEAD'` after the entire diff
+ * pipeline already ran (#844).
  */
 async function getCurrentBranchName({ git }) {
-    return await git.revparse(['--abbrev-ref', 'HEAD']);
+    try {
+        return await git.revparse(['--abbrev-ref', 'HEAD']);
+    }
+    catch {
+        try {
+            const ref = await git.raw(['symbolic-ref', '--short', 'HEAD']);
+            return ref.trim();
+        }
+        catch {
+            return '';
+        }
+    }
 }
 
 /**
@@ -14976,6 +14998,19 @@ function getLogInkWorkflowActions() {
             kind: 'destructive',
             requiresConfirmation: true,
         },
+        {
+            // Per-view-only — the inkInput handler scopes this to the
+            // worktrees surface so the global `D` keystroke (delete-branch)
+            // keeps working from elsewhere. The empty `key` keeps the
+            // workflow palette-discoverable but does not register a global
+            // hotkey that would collide with delete-branch.
+            id: 'remove-worktree-and-branch',
+            key: '',
+            label: 'Remove worktree + delete branch',
+            description: 'Remove the selected worktree and delete the branch it was tracking after confirmation.',
+            kind: 'destructive',
+            requiresConfirmation: true,
+        },
         {
             id: 'abort-operation',
             key: 'A',
@@ -18440,6 +18475,16 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
     if (inputValue === 'R' && isTagActionTarget(state) && context.tagCount) {
         return [action({ type: 'setPendingConfirmation', value: 'delete-remote-tag' })];
     }
+    // Per-view worktree action: `D` removes the worktree AND deletes
+    // the branch it was tracking (#838). Scoped to the worktrees
+    // surface so it intercepts BEFORE the global workflow-by-key
+    // dispatcher would otherwise route `D` to delete-branch (which
+    // would silently target whatever was last cursored on the branches
+    // surface instead of acting on the worktree under the cursor here).
+    // `W` keeps its existing "remove worktree only" semantics.
+    if (inputValue === 'D' && isWorktreeActionTarget(state) && context.worktreeListCount) {
+        return [action({ type: 'setPendingConfirmation', value: 'remove-worktree-and-branch' })];
+    }
     // #783 — full PR action panel keys, scoped to the pull-request view.
     // All five wrap a `gh pr <verb>` invocation; merge / request-changes /
     // comment open prompts first, the rest route through the y-confirm
@@ -21510,6 +21555,56 @@ function worktreePathAction(worktree) {
         message: `Worktree path: ${worktree.path}`,
     };
 }
+/**
+ * Remove a worktree AND delete the branch it was tracking (#838). The
+ * canonical "I'm done with this side branch" wind-down: removes the
+ * worktree directory, then runs `git branch -d` on the previously
+ * checked-out branch.
+ *
+ * Both pre-flight guards inherit from the underlying helpers:
+ *   - removeWorktree refuses the current worktree and dirty worktrees
+ *   - deleteBranch refuses the current branch and uses `-d` (safe
+ *     delete, refuses unmerged commits)
+ *
+ * Aborts cleanly at any failure point and surfaces a message that
+ * names which step broke. When the worktree had no branch (detached
+ * HEAD) the branch step is silently skipped — there's nothing to
+ * delete and the worktree removal alone counts as success.
+ */
+async function removeWorktreeAndBranch(git, worktree, branchRefs) {
+    const removeResult = await removeWorktree(git, worktree);
+    if (!removeResult.ok) {
+        return removeResult;
+    }
+    const branchName = worktree.branch;
+    if (!branchName) {
+        return {
+            ok: true,
+            message: `Removed worktree ${worktree.path} (no branch to delete)`,
+        };
+    }
+    // Look up the local BranchRef for the branch this worktree was on.
+    // deleteBranch needs the full ref (not just the name) so its
+    // current-branch and local-only guards apply correctly.
+    const branch = branchRefs.find((entry) => entry.type === 'local' && entry.shortName === branchName);
+    if (!branch) {
+        return {
+            ok: true,
+            message: `Removed worktree ${worktree.path} (branch ${branchName} not found in local branches)`,
+        };
+    }
+    const deleteResult = await deleteBranch(git, branch);
+    if (!deleteResult.ok) {
+        return {
+            ok: false,
+            message: `Removed worktree ${worktree.path}, but branch delete failed: ${deleteResult.message}`,
+        };
+    }
+    return {
+        ok: true,
+        message: `Removed worktree ${worktree.path} and deleted branch ${branchName}`,
+    };
+}
 
 function shortBranch(branch) {
     return branch?.replace(/^refs\/heads\//, '');
@@ -24561,12 +24656,27 @@ function LogInkApp(deps) {
     }, [git, selected?.hash]);
     // #806 follow-up — auto-jump the history view to whichever branch /
     // tag the user is currently cursoring in the sidebar (or the
-    // dedicated branches / tags view). Debounced so cursor-scrolling
-    // through a long branch list doesn't dispatch on every keystroke.
+    // dedicated branches / tags view).
+    //
+    // Originally this fired on a 150ms trailing-edge debounce. The user
+    // reported the sync feeling inconsistent (#839) — the trailing
+    // pattern means a fast scroll through a long branch list cancels
+    // the timer on every keystroke and only fires once on release; the
+    // user never sees the cursor follow their navigation. Switched to
+    // synchronous fire-on-effect so each cursor move snaps the history
+    // graph immediately. The dispatch is cheap (O(n) findIndex on the
+    // filtered commits + a state spread); React batches the re-renders
+    // so even rapid scroll only paints the final position. Tracks the
+    // last-dispatched hash via a ref so we don't fire setStatus
+    // repeatedly when several adjacent branches all point at the same
+    // commit (very common with squash-merged feature branches that all
+    // converge on `main`'s tip).
+    //
     // No-op when the cursored ref's tip isn't in the loaded commit
     // window (under compact mode the cursored branch's tip may not be
     // fetched yet); a status hint surfaces in that case so the user
     // knows to toggle full graph or load older commits.
+    const lastSyncedHashRef = React.useRef(undefined);
     React.useEffect(() => {
         const onBranchTab = state.activeView === 'branches' ||
             (state.focus === 'sidebar' && state.sidebarTab === 'branches');
@@ -24574,58 +24684,58 @@ function LogInkApp(deps) {
             (state.focus === 'sidebar' && state.sidebarTab === 'tags');
         if (!onBranchTab && !onTagTab)
             return;
-        let cancelled = false;
-        const timer = setTimeout(() => {
-            if (cancelled)
-                return;
-            let targetHash;
-            let targetLabel;
-            if (onBranchTab) {
-                const all = sortBranches(context.branches?.localBranches || [], state.branchSort);
-                const visible = state.filter
-                    ? all.filter((b) => matchesPromotedFilter([b.shortName, b.upstream || ''], state.filter))
-                    : all;
-                const branch = visible[Math.min(state.selectedBranchIndex, Math.max(0, visible.length - 1))];
-                if (branch) {
-                    targetHash = branch.hash;
-                    targetLabel = `branch ${branch.shortName}`;
-                }
-            }
-            else if (onTagTab) {
-                const all = sortTags(context.tags?.tags || [], state.tagSort);
-                const visible = state.filter
-                    ? all.filter((t) => matchesPromotedFilter([t.name, t.subject], state.filter))
-                    : all;
-                const tag = visible[Math.min(state.selectedTagIndex, Math.max(0, visible.length - 1))];
-                if (tag) {
-                    targetHash = tag.hash;
-                    targetLabel = `tag ${tag.name}`;
-                }
-            }
-            if (!targetHash)
-                return;
-            const loaded = state.filteredCommits.some((commit) => commit.hash === targetHash || commit.shortHash === targetHash);
-            if (loaded) {
-                dispatch({ type: 'selectCommitByHash', hash: targetHash });
-                // Confirmation status message so the user gets feedback even
-                // when the dedicated branches / tags view is occupying the
-                // main panel and the history cursor moves invisibly behind it.
-                dispatch({
-                    type: 'setStatus',
-                    value: `Synced history to ${targetLabel} tip`,
-                });
+        let targetHash;
+        let targetLabel;
+        if (onBranchTab) {
+            const all = sortBranches(context.branches?.localBranches || [], state.branchSort);
+            const visible = state.filter
+                ? all.filter((b) => matchesPromotedFilter([b.shortName, b.upstream || ''], state.filter))
+                : all;
+            const branch = visible[Math.min(state.selectedBranchIndex, Math.max(0, visible.length - 1))];
+            if (branch) {
+                targetHash = branch.hash;
+                targetLabel = `branch ${branch.shortName}`;
             }
-            else {
-                dispatch({
-                    type: 'setStatus',
-                    value: `${targetLabel} tip not in loaded window — press \\ for full graph or Ctrl+L to load more`,
-                });
+        }
+        else if (onTagTab) {
+            const all = sortTags(context.tags?.tags || [], state.tagSort);
+            const visible = state.filter
+                ? all.filter((t) => matchesPromotedFilter([t.name, t.subject], state.filter))
+                : all;
+            const tag = visible[Math.min(state.selectedTagIndex, Math.max(0, visible.length - 1))];
+            if (tag) {
+                targetHash = tag.hash;
+                targetLabel = `tag ${tag.name}`;
             }
-        }, 150);
-        return () => {
-            cancelled = true;
-            clearTimeout(timer);
-        };
+        }
+        if (!targetHash)
+            return;
+        // Skip the dispatch + status churn when the cursor hasn't
+        // actually changed which commit it's targeting (the case for
+        // rapid navigation through a cluster of branches that all point
+        // at the same commit). Without this guard the user sees a stream
+        // of "Synced history to <branch> tip" status messages even
+        // though the history cursor never moved.
+        if (targetHash === lastSyncedHashRef.current)
+            return;
+        const loaded = state.filteredCommits.some((commit) => commit.hash === targetHash || commit.shortHash === targetHash);
+        if (loaded) {
+            lastSyncedHashRef.current = targetHash;
+            dispatch({ type: 'selectCommitByHash', hash: targetHash });
+            // Confirmation status message so the user gets feedback even
+            // when the dedicated branches / tags view is occupying the
+            // main panel and the history cursor moves invisibly behind it.
+            dispatch({
+                type: 'setStatus',
+                value: `Synced history to ${targetLabel} tip`,
+            });
+        }
+        else {
+            dispatch({
+                type: 'setStatus',
+                value: `${targetLabel} tip not in loaded window — press \\ for full graph or Ctrl+L to load more`,
+            });
+        }
     }, [
         dispatch, context.branches, context.tags,
         state.activeView, state.focus, state.sidebarTab,
@@ -24633,6 +24743,18 @@ function LogInkApp(deps) {
         state.branchSort, state.tagSort, state.filter,
         state.filteredCommits,
     ]);
+    // Reset the dedup ref when the user moves focus away from the
+    // sidebar branches / tags tab so re-entering re-fires the sync
+    // even if the cursored branch is the same as before.
+    React.useEffect(() => {
+        const onBranchTab = state.activeView === 'branches' ||
+            (state.focus === 'sidebar' && state.sidebarTab === 'branches');
+        const onTagTab = state.activeView === 'tags' ||
+            (state.focus === 'sidebar' && state.sidebarTab === 'tags');
+        if (!onBranchTab && !onTagTab) {
+            lastSyncedHashRef.current = undefined;
+        }
+    }, [state.activeView, state.focus, state.sidebarTab]);
     React.useEffect(() => {
         let active = true;
         async function loadWorktreeDiff() {
@@ -25072,6 +25194,29 @@ function LogInkApp(deps) {
                 }
                 return removeWorktree(git, cursorTarget);
             },
+            'remove-worktree-and-branch': async () => {
+                const all = context.worktreeList?.worktrees || [];
+                const visible = state.filter
+                    ? all.filter((w) => matchesPromotedFilter([w.path, w.branch || ''], state.filter))
+                    : all;
+                const cursorTarget = visible.length
+                    ? visible[Math.min(state.selectedWorktreeListIndex, visible.length - 1)]
+                    : all[Math.min(state.selectedWorktreeListIndex, Math.max(0, all.length - 1))];
+                if (!cursorTarget)
+                    return { ok: false, message: 'No worktree selected' };
+                if (cursorTarget.current) {
+                    return {
+                        ok: false,
+                        message: 'Cannot remove the current worktree — switch to another worktree first.',
+                    };
+                }
+                // The chained helper handles the worktree removal AND the
+                // safe branch delete in one call. Branch refs come from the
+                // live context so the underlying deleteBranch helper sees
+                // the current/local flags it needs to refuse the destructive
+                // path on the wrong target.
+                return removeWorktreeAndBranch(git, cursorTarget, context.branches?.localBranches || []);
+            },
             'abort-operation': async () => {
                 const operation = context.operation?.operation;
                 if (!operation) {
@@ -27250,7 +27395,12 @@ function renderComposeContextPanel(h, components, state, context, contextStatus,
             }, truncate$1(theme.ascii ? '[...] AI draft in progress' : '⏳ AI draft in progress', width - 4))]
         : []), ...(stagedFiles.length
         ? [
-            h(Text, { key: 'compose-context-staged-title', bold: true }, 'Staged'),
+            // Section header carries the total count to match the status
+            // surface's "▾ Staged (n)" treatment (#840). The visible
+            // file list is sliced at 12 rows; using `worktree.stagedCount`
+            // (the total) avoids a misleading "Staged (12)" label when
+            // there are actually more staged files below the slice.
+            h(Text, { key: 'compose-context-staged-title', bold: true }, `Staged (${worktree?.stagedCount ?? stagedFiles.length})`),
             ...stagedFiles.map((file, index) => h(Text, {
                 key: `compose-context-staged-${index}`,
                 color: theme.noColor ? undefined : theme.colors.gitAdded,
@@ -27259,7 +27409,7 @@ function renderComposeContextPanel(h, components, state, context, contextStatus,
         ]
         : []), ...(unstagedFiles.length
         ? [
-            h(Text, { key: 'compose-context-unstaged-title', bold: true }, 'Unstaged'),
+            h(Text, { key: 'compose-context-unstaged-title', bold: true }, `Unstaged (${worktree?.unstagedCount ?? unstagedFiles.length})`),
             ...unstagedFiles.map((file, index) => h(Text, {
                 key: `compose-context-unstaged-${index}`,
                 color: theme.noColor ? undefined : theme.colors.gitModified,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-coco",
-  "version": "0.41.0",
+  "version": "0.41.2",
   "description": "zero-effort git commits with coco.",
   "author": "gfargo <ghfargo@gmail.com>",
   "license": "MIT",