@gitkraken/core-gitlens 0.2.0 → 0.3.0

package/src/git/models/search.ts

@@ -96,8 +96,8 @@ export interface ParsedSearchQuery {
 export interface SearchQueryFilters {
 	/** Specifies whether the search results will be filtered to specific files */
 	files: boolean;
-	/** Specifies whether the search results will be filtered to a specific type, only `stash` and `tip` are supported */
-	type?: 'stash' | 'tip';
+	/** Specifies whether the search results will be filtered to a specific type, only `stash`, `tip`, and `wip` are supported */
+	type?: 'stash' | 'tip' | 'wip';
 	/** Specifies whether the search results will be filtered to a specific ref or ref range */
 	refs: boolean;
 }

package/src/git/models/worktree.ts

@@ -6,6 +6,7 @@ import { basename, normalizePath, relative } from '../../utils/path.js';
 import type { Shape } from '../../utils/types.js';
 import type { Uri } from '../../utils/uri.js';
 import { getRepositoryService } from '../repositoryService.js';
+import type { GitCommandPriority } from '../run.types.js';
 import { getRepositoryOrWorktreePath } from '../utils/repository.utils.js';
 import { shortenRevision } from '../utils/revision.utils.js';
 import type { GitBranch } from './branch.js';
@@ -73,6 +74,7 @@ export class GitWorktree {
 			const relativePath = normalizePath(relative(this.workspaceFolder.uri.fsPath, this.uri.fsPath));
 			return relativePath || this.workspaceFolder.name;
 		}
+
 		const relativePath = normalizePath(relative(this.repoPath, this.uri.fsPath));
 		return relativePath || normalizePath(this.uri.fsPath);
 	}
@@ -135,10 +137,15 @@ export class GitWorktree {
 			: GitWorktree.formatDateFromNow(worktree);
 	}
 
-	static async getStatus(worktree: GitWorktree, cancellation?: AbortSignal): Promise<GitStatus | undefined> {
+	static async getStatus(
+		worktree: GitWorktree,
+		options?: { priority?: GitCommandPriority },
+		cancellation?: AbortSignal,
+	): Promise<GitStatus | undefined> {
 		if (worktree.type === 'bare') return undefined;
+
 		const repo = getRepositoryService(worktree.path);
-		return repo?.status.getStatus(cancellation);
+		return repo?.status.getStatus(options, cancellation);
 	}
 
 	static async hasWorkingChanges(
@@ -146,6 +153,7 @@ export class GitWorktree {
 		options?: { staged?: boolean; unstaged?: boolean; untracked?: boolean },
 	): Promise<boolean | undefined> {
 		if (worktree.type === 'bare') return undefined;
+
 		const repo = getRepositoryService(worktree.path);
 		return repo?.status.hasWorkingChanges(options);
 	}

package/src/git/parsers/diffParser.ts

@@ -413,6 +413,7 @@ export function parseGitDiffNumStatFiles(data: string, repoPath: string): GitFil
 			i++;
 			continue;
 		}
+
 		const tabIndex2 = field.indexOf('\t', tabIndex1 + 1);
 		if (tabIndex2 === -1) {
 			i++;
@@ -427,6 +428,7 @@ export function parseGitDiffNumStatFiles(data: string, repoPath: string): GitFil
 		if (path === '') {
 			// Rename or copy: next two fields are oldPath and newPath (summary pass distinguishes R vs C)
 			if (i + 2 >= fields.length) break;
+
 			originalPath = fields[++i];
 			path = fields[++i];
 		}

package/src/git/providers/branches.ts

@@ -1,10 +1,12 @@
 import type { PagedResult, PagingOptions } from '../../utils/paging.js';
+import type { GkConfigInvalidationTarget } from '../cache.js';
 import type { BranchDisposition, GitBranch } from '../models/branch.js';
 import type { GitCommitStats } from '../models/commit.js';
 import type { GitContributor } from '../models/contributor.js';
 import type { ConflictDetectionResult } from '../models/mergeConflicts.js';
 import type { PullRequest } from '../models/pullRequest.js';
 import type { GitBranchReference } from '../models/reference.js';
+import type { GitCommandPriority } from '../run.types.js';
 import type { BranchSortOptions } from '../utils/sorting.js';
 
 export interface BranchContributionsOverview extends GitCommitStats<number> {
@@ -43,7 +45,7 @@ export interface GitBranchesSubProvider {
 	getBranchContributionsOverview(
 		repoPath: string,
 		ref: string,
-		options?: { associatedPullRequest?: Promise<PullRequest | undefined> },
+		options?: { associatedPullRequest?: Promise<PullRequest | undefined>; priority?: GitCommandPriority },
 		cancellation?: AbortSignal,
 	): Promise<BranchContributionsOverview | undefined>;
 	getBranchesWithCommits(
@@ -58,6 +60,7 @@ export interface GitBranchesSubProvider {
 	getDefaultBranchName(
 		repoPath: string | undefined,
 		remote?: string,
+		options?: { priority?: GitCommandPriority },
 		cancellation?: AbortSignal,
 	): Promise<string | undefined>;
 
@@ -94,7 +97,12 @@ export interface GitBranchesSubProvider {
 		targetBranch: string,
 		cancellation?: AbortSignal,
 	): Promise<ConflictDetectionResult>;
-	getBaseBranchName?(repoPath: string, ref: string, cancellation?: AbortSignal): Promise<string | undefined>;
+	getBaseBranchName?(
+		repoPath: string,
+		ref: string,
+		options?: { priority?: GitCommandPriority },
+		cancellation?: AbortSignal,
+	): Promise<string | undefined>;
 	getStoredMergeTargetBranchName?(repoPath: string, ref: string): Promise<string | undefined>;
 	getStoredDetectedMergeTargetBranchName?(repoPath: string, ref: string): Promise<string | undefined>;
 	getStoredUserMergeTargetBranchName?(repoPath: string, ref: string): Promise<string | undefined>;
@@ -108,7 +116,17 @@ export interface GitBranchesSubProvider {
 		branchName: string,
 		disposition: BranchDisposition | undefined,
 	): Promise<void>;
-	storeBaseBranchName?(repoPath: string, ref: string, base: string): Promise<void>;
-	storeMergeTargetBranchName?(repoPath: string, ref: string, target: string): Promise<void>;
+	storeBaseBranchName?(
+		repoPath: string,
+		ref: string,
+		base: string,
+		options?: { skipInvalidation?: readonly GkConfigInvalidationTarget[] },
+	): Promise<void>;
+	storeMergeTargetBranchName?(
+		repoPath: string,
+		ref: string,
+		target: string,
+		options?: { skipInvalidation?: readonly GkConfigInvalidationTarget[] },
+	): Promise<void>;
 	storeUserMergeTargetBranchName?(repoPath: string, ref: string, target: string | undefined): Promise<void>;
 }

package/src/git/providers/config.ts

@@ -1,3 +1,4 @@
+import type { GkConfigInvalidationTarget } from '../cache.js';
 import type { GitDir } from '../models/repository.js';
 import type { SigningConfig, ValidationResult } from '../models/signature.js';
 import type { GitUser } from '../models/user.js';
@@ -97,6 +98,7 @@ export interface GitConfigSubProvider {
 		repoPath: string,
 		key: GkConfigKeys | DeprecatedGkConfigKeys,
 		value: string | undefined,
+		options?: { skipInvalidation?: readonly GkConfigInvalidationTarget[] },
 	): Promise<void>;
 
 	getSigningConfig?(repoPath: string): Promise<SigningConfig>;

package/src/git/providers/operations.ts

@@ -1,5 +1,6 @@
 import type { GitBranchReference, GitReference } from '../models/reference.js';
 import type { GitConflictFile } from '../models/staging.js';
+import type { GitRunOptions } from '../run.types.js';
 
 export interface GitOperationResult {
 	readonly conflicted: boolean;
@@ -7,16 +8,51 @@ export interface GitOperationResult {
 	readonly conflicts?: GitConflictFile[];
 }
 
+/**
+ * Spawn-layer overrides callers can pass to user-initiated git operations to inject per-call
+ * environment variables, an `AbortSignal` for cancellation, or a custom `timeout`. Forwarded
+ * verbatim to the underlying `git.run(...)` invocation; cannot override op-owned fields like
+ * `cwd`, `configs`, `errors`, or `stdin`.
+ *
+ * Note: passing `timeout` overrides per-op safety defaults. `merge`, `rebase`, and `revert`
+ * intentionally disable the timeout (set it to 0) because those operations can take a long
+ * time; a caller-supplied `timeout` will replace that "no timeout" setting, so use with care.
+ */
+export type GitOperationRunOptions = Pick<GitRunOptions, 'env' | 'cancellation' | 'timeout'>;
+
 export interface GitOperationsSubProvider {
 	checkout(
 		repoPath: string,
 		ref: string,
 		options?: { createBranch?: string | undefined } | { path?: string | undefined },
+		runOptions?: GitOperationRunOptions,
+	): Promise<void>;
+	/**
+	 * Checks out one side of a conflicted path during a paused merge/rebase/cherry-pick.
+	 * Executes `git checkout --ours|--theirs -- <path>`, leaving the file unstaged.
+	 */
+	checkoutConflictedPath(
+		repoPath: string,
+		path: string,
+		side: 'ours' | 'theirs',
+		runOptions?: GitOperationRunOptions,
+	): Promise<void>;
+	/**
+	 * Checks out one side for multiple conflicted paths during a paused merge/rebase/cherry-pick.
+	 * Batches paths into `git checkout --ours|--theirs -- <paths...>`, chunked to stay under the
+	 * CLI length limit. Leaves files unstaged.
+	 */
+	checkoutConflictedPaths(
+		repoPath: string,
+		paths: string[],
+		side: 'ours' | 'theirs',
+		runOptions?: GitOperationRunOptions,
 	): Promise<void>;
 	cherryPick(
 		repoPath: string,
 		revs: string[],
 		options?: { edit?: boolean; noCommit?: boolean; source?: unknown },
+		runOptions?: GitOperationRunOptions,
 	): Promise<GitOperationResult>;
 	commit(
 		repoPath: string,
@@ -30,6 +66,7 @@ export interface GitOperationsSubProvider {
 			signoff?: boolean;
 			source?: unknown;
 		},
+		runOptions?: GitOperationRunOptions,
 	): Promise<void>;
 	fetch(
 		repoPath: string,
@@ -40,11 +77,13 @@ export interface GitOperationsSubProvider {
 			pull?: boolean | undefined;
 			remote?: string | undefined;
 		},
+		runOptions?: GitOperationRunOptions,
 	): Promise<void>;
 	merge(
 		repoPath: string,
 		ref: string,
 		options?: { fastForward?: boolean | 'only'; noCommit?: boolean; squash?: boolean; source?: unknown },
+		runOptions?: GitOperationRunOptions,
 	): Promise<GitOperationResult>;
 	pull(
 		repoPath: string,
@@ -54,6 +93,7 @@ export interface GitOperationsSubProvider {
 			tags?: boolean | undefined;
 			source?: unknown;
 		},
+		runOptions?: GitOperationRunOptions,
 	): Promise<void>;
 	push(
 		repoPath: string,
@@ -62,6 +102,7 @@ export interface GitOperationsSubProvider {
 			force?: boolean | undefined;
 			publish?: { remote: string };
 		},
+		runOptions?: GitOperationRunOptions,
 	): Promise<void>;
 	rebase(
 		repoPath: string,
@@ -75,15 +116,18 @@ export interface GitOperationsSubProvider {
 			updateRefs?: boolean;
 			source?: unknown;
 		},
+		runOptions?: GitOperationRunOptions,
 	): Promise<GitOperationResult>;
 	reset(
 		repoPath: string,
 		rev: string,
 		options?: { mode?: 'hard' | 'keep' | 'merge' | 'mixed' | 'soft' },
+		runOptions?: GitOperationRunOptions,
 	): Promise<void>;
 	revert(
 		repoPath: string,
 		refs: string[],
 		options?: { editMessage?: boolean; source?: unknown },
+		runOptions?: GitOperationRunOptions,
 	): Promise<GitOperationResult>;
 }

package/src/git/providers/pausedOperations.ts

@@ -3,6 +3,7 @@ import type { GitPausedOperationStatus } from '../models/pausedOperationStatus.j
 export interface GitPausedOperationsSubProvider {
 	getPausedOperationStatus(
 		repoPath: string,
+		options?: { force?: boolean },
 		cancellation?: AbortSignal,
 	): Promise<GitPausedOperationStatus | undefined>;
 	abortPausedOperation(repoPath: string, options?: { quit?: boolean }): Promise<void>;

package/src/git/providers/refs.ts

@@ -1,7 +1,8 @@
 import type { Uri } from '../../utils/uri.js';
 import type { GitBranch } from '../models/branch.js';
-import type { GitReference } from '../models/reference.js';
+import type { GitReference, GitRefTip } from '../models/reference.js';
 import type { GitTag } from '../models/tag.js';
+import type { GitCommandPriority } from '../run.types.js';
 
 export interface GitRefsSubProvider {
 	checkIfCouldBeValidBranchOrTagName(repoPath: string, ref: string): Promise<boolean>;
@@ -9,11 +10,39 @@ export interface GitRefsSubProvider {
 		repoPath: string,
 		ref1: string,
 		ref2: string,
-		options?: { forkPoint?: boolean | undefined },
+		options?: { forkPoint?: boolean | undefined; priority?: GitCommandPriority },
 		cancellation?: AbortSignal,
 	): Promise<string | undefined>;
 	getReference(repoPath: string, ref: string, cancellation?: AbortSignal): Promise<GitReference | undefined>;
-	getSymbolicReferenceName?(repoPath: string, ref: string, cancellation?: AbortSignal): Promise<string | undefined>;
+	/**
+	 * Lightweight enumeration of ref tips (heads/remotes/tags) — no enrichment.
+	 * Use this when you need a SHA-to-refs map; use `getBranches`/`getTags` for full models.
+	 */
+	getRefTips(
+		repoPath: string,
+		options?: { include?: ReadonlyArray<'heads' | 'remotes' | 'tags'> },
+		cancellation?: AbortSignal,
+	): Promise<GitRefTip[]>;
+	/**
+	 * Batch reachability — for each input SHA, the refs whose tips contain it.
+	 *
+	 * One bounded `git rev-list --topo-order --parents --all ^<oldestSha>^@` walk; ref-set
+	 * propagation runs in memory. Cost is O(walked subgraph), not O(N × refs) like the per-sha
+	 * `getBranchesWithCommits([sha])` pattern. Pass the oldest SHA in your dataset to bound the walk.
+	 */
+	getRefsContainingShas(
+		repoPath: string,
+		shas: ReadonlySet<string> | readonly string[],
+		oldestSha: string,
+		options?: { include?: ReadonlyArray<'heads' | 'remotes' | 'tags'> },
+		cancellation?: AbortSignal,
+	): Promise<Map<string, GitRefTip[]>>;
+	getSymbolicReferenceName?(
+		repoPath: string,
+		ref: string,
+		options?: { priority?: GitCommandPriority },
+		cancellation?: AbortSignal,
+	): Promise<string | undefined>;
 	hasBranchOrTag(
 		repoPath: string | undefined,
 		options?: {

package/src/git/providers/staging.ts

@@ -19,6 +19,18 @@ export interface GitStagingSubProvider {
 	unstageFile(repoPath: string, pathOrUri: string | Uri): Promise<void>;
 	unstageFiles(repoPath: string, pathsOrUris: (string | Uri)[]): Promise<void>;
 	unstageDirectory(repoPath: string, directoryOrUri: string | Uri): Promise<void>;
+	/**
+	 * Removes a file from both the working tree and the index in a single operation
+	 * (`git rm [-f] -- <path>`). Use during conflict resolution when the user has chosen a
+	 * side that is itself a deletion — atomic, so it can't leave a working-tree-modified
+	 * file accidentally staged with content. Pass `force: true` to discard local
+	 * modifications (required for conflicted files).
+	 */
+	removeFile(repoPath: string, pathOrUri: string | Uri, options?: { force?: boolean }): Promise<void>;
+	/**
+	 * Batched form of {@link removeFile}. Chunks paths to stay under the CLI length limit.
+	 */
+	removeFiles(repoPath: string, pathsOrUris: (string | Uri)[], options?: { force?: boolean }): Promise<void>;
 	stageAll(repoPath: string): Promise<void>;
 	unstageAll(repoPath: string): Promise<void>;
 }

package/src/git/providers/status.ts

@@ -3,6 +3,7 @@ import type { GitFile } from '../models/file.js';
 import type { GitConflictFile } from '../models/staging.js';
 import type { GitStatus } from '../models/status.js';
 import type { GitStatusFile } from '../models/statusFile.js';
+import type { GitCommandPriority } from '../run.types.js';
 
 export interface GitWorkingChangesState {
 	staged: boolean;
@@ -11,7 +12,11 @@ export interface GitWorkingChangesState {
 }
 
 export interface GitStatusSubProvider {
-	getStatus(repoPath: string | undefined, cancellation?: AbortSignal): Promise<GitStatus | undefined>;
+	getStatus(
+		repoPath: string | undefined,
+		options?: { priority?: GitCommandPriority },
+		cancellation?: AbortSignal,
+	): Promise<GitStatus | undefined>;
 	getStatusForFile?(
 		repoPath: string,
 		pathOrUri: string | Uri,

package/src/git/remotes/azure-devops.ts

@@ -34,6 +34,7 @@ function parseVstsHttpsUrl(url: URL): [string, string, string] {
 	const owner = getVSTSOwner(url);
 	const match = azureProjectRepoRegex.exec(url.pathname);
 	if (match == null) throw new Error(`Invalid VSTS URL: ${url.toString()}`);
+
 	const [, project, repo] = match;
 	return [owner, project, repo];
 }
@@ -43,6 +44,7 @@ const azureHttpsUrlRegex2 = /([^/]+)\/([^/]+)\/_git\/([^/]+)/;
 function parseAzureNewStyleUrl(url: URL): [string, string, string] {
 	const match = azureHttpsUrlRegex2.exec(url.pathname);
 	if (match == null) throw new Error(`Invalid Azure URL: ${url.toString()}`);
+
 	const [, owner, project, repo] = match;
 	return [owner, project, repo];
 }

package/src/git/{exec.types.ts → run.types.ts}

@@ -27,11 +27,11 @@ export interface GitResultCache {
  * Priority levels for git commands.
  * - `interactive`: User-initiated operations (blame, hover) - highest priority
  * - `normal`: Standard operations (status, config) - default priority
- * - `background`: Expensive operations (log, graph) - can be throttled
+ * - `background`: Expensive operations (graph rendering, full history walks) - can be throttled
  */
 export type GitCommandPriority = 'interactive' | 'normal' | 'background';
 
-export interface GitExecOptions {
+export interface GitRunOptions {
 	cancellation?: AbortSignal;
 	configs?: readonly string[];
 	readonly correlationKey?: string;
@@ -63,6 +63,26 @@ export interface GitExecOptions {
 	readonly timeout?: number;
 }
 
+/**
+ * Untyped escape hatch for raw `git <args>` invocation, returned by
+ * `GlGitProvider.createUnsafeGit`.
+ *
+ * "Unsafe" here means **bypasses the typed safety net** the rest of GitLens relies on
+ * — sub-provider cancellation/caching/decorator behaviors and signing-awareness do
+ * not apply when commands are issued through this object. It does NOT imply command
+ * injection risk; the caller still controls the args.
+ *
+ * Hand instances to libraries that need to issue arbitrary git commands
+ * (`@gitkraken/compose-tools`, `@gitkraken/shared-tools` undo). Inside GitLens
+ * itself, prefer the typed sub-providers on `RepositoryService` (`branches`,
+ * `commits`, `diff`, `staging`, `stash`, `status`, …). Holding an `UnsafeGit`
+ * just to call `run(...)` for an ad-hoc command is almost always wrong — the
+ * abstraction exists so it can be handed off, not used directly.
+ */
+export interface UnsafeGit {
+	run(args: readonly string[], options?: GitRunOptions): Promise<GitResult>;
+}
+
 export interface GitSpawnOptions {
 	cancellation?: AbortSignal;
 	configs?: readonly string[];

package/src/git/service.ts

@@ -77,6 +77,7 @@ export class GitService implements UnifiedDisposable {
 		if (GitService._instance != null) {
 			throw new Error('GitService already exists — only one instance is allowed');
 		}
+
 		const instance = new GitService(watchingProvider);
 		GitService._instance = instance;
 		return instance;

package/src/git/utils/autolink.utils.ts

@@ -179,6 +179,7 @@ export function getBranchAutolinks(
 			for (const regex of ref.branchNameRegexes) {
 				match = branchName.match(regex);
 				if (!match?.groups) continue;
+
 				num = match.groups.issueKeyNumber;
 				const linkUrl = ref.url?.replace(numRegex, num);
 				autolinks.set(linkUrl, {

package/src/git/utils/blame.utils.ts

@@ -249,6 +249,7 @@ export function buildDirtyBlame(cleanBlame: GitBlame, mapping: LineMappingResult
 	const lineCountsBySha = new Map<string, number>();
 	for (const blameLine of dirtyBlameLines) {
 		if (blameLine == null) continue;
+
 		lineCountsBySha.set(blameLine.sha, (lineCountsBySha.get(blameLine.sha) ?? 0) + 1);
 	}
 
@@ -276,6 +277,7 @@ export function buildDirtyBlame(cleanBlame: GitBlame, mapping: LineMappingResult
 	for (const [, c] of commits) {
 		if (!c.author.name) continue;
 		if (authors.has(c.author.name)) continue;
+
 		authors.set(c.author.name, { name: c.author.name, lineCount: 0, current: c.author.current });
 	}
 

package/src/git/utils/conflictResolution.utils.ts

@@ -0,0 +1,31 @@
+import type { GitFileConflictStatus } from '../models/fileStatus.js';
+
+export type ConflictResolutionAction = 'take-ours' | 'take-theirs' | 'delete' | 'unsupported';
+
+export function classifyConflictAction(
+	status: GitFileConflictStatus,
+	resolution: 'current' | 'incoming',
+): ConflictResolutionAction {
+	const takeCurrent = resolution === 'current';
+
+	if (status === 'DD') return 'delete';
+	if (status === 'UD' && !takeCurrent) return 'delete';
+	if (status === 'DU' && takeCurrent) return 'delete';
+
+	// `git checkout --{ours,theirs}` fails when the requested stage is absent.
+	// Single-file UI filters these out; bulk resolve surfaces them as failures.
+	if (status === 'UA' && takeCurrent) return 'unsupported';
+	if (status === 'AU' && !takeCurrent) return 'unsupported';
+
+	return takeCurrent ? 'take-ours' : 'take-theirs';
+}
+
+// Stage Current is invalid when the current side has no content to take (added/deleted only by them, or both deleted)
+export function canStageCurrent(status: GitFileConflictStatus): boolean {
+	return status !== 'UA' && status !== 'DD';
+}
+
+// Stage Incoming is invalid when the incoming side has no content to take (added/deleted only by us, or both deleted)
+export function canStageIncoming(status: GitFileConflictStatus): boolean {
+	return status !== 'AU' && status !== 'DD';
+}

package/src/git/utils/fileStatus.utils.ts

@@ -1,4 +1,4 @@
-import type { GitFileStatus } from '../models/fileStatus.js';
+import type { GitFileConflictStatus, GitFileStatus } from '../models/fileStatus.js';
 
 const statusIconsMap = {
 	'.': undefined,
@@ -47,3 +47,9 @@ const statusTextMap = {
 export function getGitFileStatusText(status: GitFileStatus | keyof typeof statusTextMap): string {
 	return statusTextMap[status] ?? 'Unknown';
 }
+
+const conflictStatuses = new Set<string>(['U', 'AA', 'AU', 'UA', 'DD', 'DU', 'UD', 'UU']);
+
+export function isConflictStatus(status: string | undefined): status is 'U' | GitFileConflictStatus {
+	return status != null && conflictStatuses.has(status);
+}

package/src/git/utils/search.utils.ts

@@ -274,6 +274,8 @@ export function parseSearchQueryGitCommand(
 							searchArgs.add('--no-walk');
 						} else if (value === 'tip') {
 							filters.type = 'tip';
+						} else if (value === 'wip') {
+							filters.type = 'wip';
 						}
 					}
 

package/src/git/utils/sorting.ts

@@ -46,6 +46,23 @@ export function compareReachableRefs(
 	return 0;
 }
 
+// Hoisted from `compareRefTips` so we don't re-allocate the lookup per sort iteration.
+const refTipTypeOrder = { branch: 0, remote: 1, tag: 2 } as const;
+
+/**
+ * Comparator for `GitRefTip` arrays — local branch < remote branch < tag, tags by version desc.
+ * Mirrors `compareReachableRefs` for the lighter ref-tip shape.
+ */
+export function compareRefTips(a: { type: 'branch' | 'remote' | 'tag'; name: string }, b: typeof a): number {
+	if (a.type !== b.type) {
+		return refTipTypeOrder[a.type] - refTipTypeOrder[b.type];
+	}
+	if (a.type === 'tag') {
+		return compareByVersionDescending(a.name, b.name);
+	}
+	return 0;
+}
+
 export function sortBranches(branches: GitBranch[], options?: BranchSortOptions): GitBranch[] {
 	options = { current: true, groupByType: true, orderBy: 'date:desc', ...options };
 

package/src/git/utils/status.utils.ts

@@ -69,6 +69,7 @@ export function getUpstreamStatus(
 	},
 ): string {
 	if (upstream == null) return options?.empty ?? '';
+
 	const {
 		state: { ahead, behind },
 	} = upstream;

package/src/git/watching/classifyChange.ts

@@ -17,6 +17,15 @@ const classifyRegex =
  *   handles it as a last-fetched timestamp).
  */
 export function classifyGitDirChange(relativePath: string): RepositoryChange[] | undefined {
+	// User-edited todo file (and its backup) — handled by VS Code's TextDocument
+	// events in the rebase webview (see `rebaseWebviewProvider.ts`). Suppress here
+	// to avoid thrashing the repo update path on every save during an interactive
+	// rebase; rebase lifecycle (start/stop/step) still fires from sibling files
+	// in `rebase-merge/` and the directory itself.
+	if (relativePath.endsWith('/git-rebase-todo') || relativePath.endsWith('/git-rebase-todo.backup')) {
+		return undefined;
+	}
+
 	const match = classifyRegex.exec(relativePath);
 	if (match == null) return undefined;
 

package/src/git/watching/gitIgnoreFilter.ts

@@ -1,7 +1,7 @@
-import { getScopedCounter } from '../../utils/counter.js';
-import { fileUri } from '../../utils/uri.js';
 import type { Ignore } from 'ignore';
 import ignore from 'ignore';
+import { getScopedCounter } from '../../utils/counter.js';
+import { fileUri } from '../../utils/uri.js';
 import type { FileSystemProvider } from '../context.js';
 
 export interface GitIgnoreFilterOptions {

package/src/git/watching/initWatcher.ts

@@ -36,6 +36,7 @@ export class RepositoryInitWatcher implements UnifiedDisposable {
 
 	dispose(): void {
 		if (this._disposed) return;
+
 		this._disposed = true;
 
 		for (const watcher of this.watchers.values()) {
@@ -60,6 +61,7 @@ export class RepositoryInitWatcher implements UnifiedDisposable {
 
 		const watcher = this.provider.createWatcher(basePath, gitInitGlob, event => {
 			if (event.reason !== 'create') return;
+
 			this.emitter.fire({ path: event.path, basePath: basePath });
 		});
 

package/src/git/watching/watchGroup.ts

@@ -54,6 +54,7 @@ export class WatchGroup implements UnifiedDisposable {
 	/** Dispose the entire group (common watcher + all root watchers). */
 	dispose(): void {
 		if (this._disposed) return;
+
 		this._disposed = true;
 
 		for (const entry of this._sessions.values()) {
@@ -132,6 +133,7 @@ export class WatchGroup implements UnifiedDisposable {
 	private onCommonEvent(event: FileWatchEvent): void {
 		// Compute relative path from common git dir
 		if (!isDescendant(event.path, this.commonGitDir)) return;
+
 		const relativePath = relative(this.commonGitDir, event.path);
 		if (shouldIgnoreRepoPath(relativePath)) return;
 
@@ -161,6 +163,7 @@ export class WatchGroup implements UnifiedDisposable {
 
 	private onRootEvent(event: FileWatchEvent, entry: SessionEntry): void {
 		if (!isDescendant(event.path, entry.gitDirPath)) return;
+
 		const relativePath = relative(entry.gitDirPath, event.path);
 		if (shouldIgnoreRepoPath(relativePath)) return;