@gitkraken/core-gitlens 0.2.0 → 0.3.1

package/src/git/models/graph.ts

@@ -19,6 +19,14 @@ export interface GitGraphRowHead {
 	isCurrentHead: boolean;
 	context?: string | object;
 	upstream?: { name: string; id: string };
+	/** Set when this branch is checked out in a (non-default) worktree. Grouped so producers can't
+	 *  half-populate id-without-path or vice versa. GitLens consumers should read this field. */
+	worktree?: { id: string; path: string };
+	/** Upstream-component-compatibility mirror of `worktree?.id`. The bundled
+	 *  `@gitkraken/gitkraken-components` library still reads `worktreeId` to switch between
+	 *  WORKTREE and HEAD ref-badge styling — keeping it populated preserves the visual cue.
+	 *  Producers MUST set this whenever they set `worktree`; do not read it from GitLens code,
+	 *  read `worktree.id` instead. */
 	worktreeId?: string;
 }
 
@@ -40,11 +48,43 @@ export interface GitGraphRowTag {
 	context?: string | object;
 }
 
+/**
+ * Compact, host-computed flags for a commit/stash row, shipped instead of the bulky serialized
+ * `contexts.row`/`contexts.avatar` blobs (which duplicated sha/message/repoPath already on the row).
+ * The webview reconstructs the full webview-item contexts from these flags + row fields + repoPath.
+ * Bit 0: reachable-from-HEAD (`+current`); Bit 1: unique-to-one-local-branch (`+unique`);
+ * Bit 2: has-children — set ONLY on undo-eligible tip rows (active HEAD + worktree HEADs) that have a
+ * child, to gate Undo Commit to leaf tips (undoing a commit other work is stacked on is unsafe). It is
+ * NOT a general has-children signal: non-tip rows never carry it (the host only computes it for tips);
+ * Bit 3: unpushed/ahead-of-upstream (`+unpublished`).
+ * Bit 4: history-rewriteable (`+rewriteable`) — on the first-parent chain from HEAD up to (excluding)
+ * the first merge commit, so a plain (non-`--rebase-merges`) interactive rebase can safely rewrite it;
+ * gates squash/drop/reword/modify. Strictly narrower than `+current` (reachable-from-HEAD includes a
+ * merge's other-parent ancestry, which is NOT safely rewriteable).
+ * (`+HEAD` derives from `row.heads[].isCurrentHead`; contributor `+current` from `row.isCurrentUser`.)
+ */
+export const enum GitGraphRowContextFlags {
+	None = 0,
+	ReachableFromHead = 1 << 0,
+	UniqueToBranch = 1 << 1,
+	HasChildren = 1 << 2,
+	Unpublished = 1 << 3,
+	RewriteableFromHead = 1 << 4,
+}
+
 /**
  * Context data attached to graph row regions for command/menu handling.
  * Structurally compatible with @gitkraken/gitkraken-components RowContexts.
  */
 export interface GitGraphRowContexts {
+	/** Compact replacement for the serialized commit `row`/`avatar` contexts; see {@link GitGraphRowContextFlags}. */
+	flags?: GitGraphRowContextFlags;
+	/**
+	 * Index into the per-graph `GraphReachabilityTable.sets` for this row's reachable-refs set,
+	 * shipped instead of the per-row `reachability` object (which dominated the graph payload). The
+	 * webview rebuilds `row.reachability` from the shared table. Absent ⇒ no reachability for this row.
+	 */
+	reachabilityIndex?: number;
 	row?: string | object;
 	ref?: string | object;
 	refGroups?: Record<string, string | object>;
@@ -63,6 +103,28 @@ export interface GitGraphRowStats {
 	deletions: number;
 }
 
+/**
+ * Wire encoding for per-row reachability, shipped once per graph payload instead of inline on every
+ * row. Git reachability is monotone (adjacent commits share ref-sets), so the rows collapse to a
+ * relatively small number of distinct sets over the repo's ref universe — `dictionary` (the shared
+ * ref list) + `sets` (distinct membership bitmaps, base64; bit i ⇒ `dictionary[i]` reachable) + a
+ * per-row index (`GitGraphRowContexts.reachabilityIndex`) reconstructs every row's `reachability`
+ * client-side for a fraction of the bytes the inline objects cost. `current` is a per-ref property
+ * (the checked-out HEAD branch) and lives in the dictionary entry.
+ *
+ * The table is append-only within a graph generation, so the host ships only the entries appended
+ * since its last push (a delta) on same-generation pagination and the full table on a new generation;
+ * `id` lets the webview tell the two apart (same `id` ⇒ append the delta, new `id` ⇒ replace + reset
+ * its decode cache). A fresh `getGraph` walk mints a new `id`; `more()` keeps the same one.
+ */
+export interface GraphReachabilityTable {
+	/** Generation id — stable across `more()` pagination, new per fresh graph walk. */
+	readonly id: number;
+	readonly dictionary: GitCommitReachability['refs'];
+	/** Distinct ref-membership bitmaps, base64-encoded `Uint8Array` of `ceil(dictionary.length/8)` bytes. */
+	readonly sets: string[];
+}
+
 /** Library-owned graph row type. Structurally compatible with @gitkraken/gitkraken-components GraphRow. */
 export interface GitGraphRow {
 	sha: string;
@@ -78,6 +140,12 @@ export interface GitGraphRow {
 	tags?: GitGraphRowTag[];
 	contexts?: GitGraphRowContexts;
 	stats?: GitGraphRowStats;
+	/**
+	 * Transient, set only for the duration of {@link GraphRowProcessor.processRow} (the row processor's
+	 * `+unique` decision reads it). The provider strips it before pushing the row and records the
+	 * reachable-ref set into the shared {@link GitGraph.reachability} table instead (see
+	 * {@link GitGraphRowContexts.reachabilityIndex}), so emitted rows do NOT retain the per-row arrays.
+	 */
 	reachability?: GitCommitReachability;
 	isCurrentUser?: boolean;
 }
@@ -99,6 +167,22 @@ export interface GitGraph {
 	/** SHAs reachable from HEAD (for enrichment: marking commits on the current branch) */
 	readonly reachableFromHEAD?: ReadonlySet<string>;
 
+	/**
+	 * SHAs on the first-parent chain from HEAD up to (excluding) the first merge commit — i.e. the
+	 * commits a plain interactive rebase can safely rewrite. Empty when HEAD itself is a merge. Used by
+	 * the graph's history-rewriting commands (squash/drop/reword/modify) to validate selections.
+	 */
+	readonly rewriteableFromHEAD?: ReadonlySet<string>;
+
+	/**
+	 * Shared, append-only reachability table for the loaded rows (the primary representation — rows
+	 * carry only a {@link GitGraphRowContexts.reachabilityIndex} into it, not per-row ref arrays).
+	 * Grows monotonically across {@link more} pagination within a graph session: indices already
+	 * assigned never change, so consumers can decode any row on demand and cache by index. Absent ⇒
+	 * no row in the graph has reachability. See {@link GraphReachabilityTable}.
+	 */
+	readonly reachability?: GraphReachabilityTable;
+
 	/** The rows for the set of commits requested */
 	readonly rows: GitGraphRow[];
 	readonly id?: string;
@@ -178,5 +262,18 @@ export interface GraphContext {
 	readonly branchIdOfMainWorktree: string | undefined;
 	readonly stashes: ReadonlyMap<string, GitStashCommit> | undefined;
 	readonly reachableFromHEAD: ReadonlySet<string>;
+	/** SHAs on the first-parent chain from HEAD up to (excluding) the first merge commit — the commits
+	 *  a plain interactive rebase can safely rewrite. Empty when HEAD is a merge. Sets the
+	 *  {@link GitGraphRowContextFlags.RewriteableFromHead} flag, gating squash/drop/reword/modify. */
+	readonly rewriteableFromHEAD: ReadonlySet<string>;
+	/** The subset of undo-eligible tip shas (active HEAD + worktree HEADs) that have at least one
+	 *  child — i.e. are NOT leaves. Scoped to tips (not all commits) for performance; do not treat as
+	 *  a general has-children signal. Sets the {@link GitGraphRowContextFlags.HasChildren} flag, which
+	 *  gates Undo Commit to leaf tips. */
+	readonly tipShasWithChildren: ReadonlySet<string>;
+	/** SHAs reachable from HEAD's tracking-upstream tip, or `undefined` when HEAD has no upstream.
+	 * A commit reachable from HEAD but NOT from this set is unpushed (`+unpublished`); `undefined`
+	 * means there's no upstream to be ahead of, so nothing is flagged. */
+	readonly reachableFromHeadUpstream: ReadonlySet<string> | undefined;
 	readonly avatars: Map<string, string>;
 }

package/src/git/models/reference.ts

@@ -45,3 +45,36 @@ export interface GitTagReference {
 }
 
 export type GitReference = GitBranchReference | GitRevisionReference | GitStashReference | GitTagReference;
+
+/**
+ * Lightweight ref-tip tuple — the minimum needed to map a SHA back to the refs that point at it.
+ * No upstream tracking, ahead/behind, annotation, etc. — use `GitBranch`/`GitTag` for those.
+ */
+export interface GitRefTip {
+	readonly type: 'branch' | 'remote' | 'tag';
+	/** Short name: `main`, `origin/main`, `v1.2.0` */
+	readonly name: string;
+	/** Full refname: `refs/heads/main`, `refs/remotes/origin/main`, `refs/tags/v1.2.0` */
+	readonly fullName: string;
+	/** Tip object SHA. For annotated tags, the peeled commit SHA */
+	readonly sha: string;
+}
+
+/**
+ * Raw parsed `git for-each-ref` record covering every field the unified format emits.
+ * Inapplicable fields come back as empty strings from git (e.g. `upstream` on a tag,
+ * `peeledObjectname` on a branch).
+ */
+export interface RefRecord {
+	current: string;
+	name: string;
+	objectname: string;
+	peeledObjectname: string;
+	upstream: string;
+	upstreamTracking: string;
+	committerDate: string;
+	creatorDate: string;
+	authorDate: string;
+	subject: string;
+	worktreePath?: string;
+}

package/src/git/models/remote.ts

@@ -71,6 +71,7 @@ export class GitRemote<TProvider extends RemoteProvider | undefined = RemoteProv
 	matches(urlOrDomain: string, path?: string): boolean {
 		if (path == null) {
 			if (equalsIgnoreCase(urlOrDomain, this.url)) return true;
+
 			[, urlOrDomain, path] = parseGitRemoteUrl(urlOrDomain);
 		}
 

package/src/git/models/remoteProvider.ts

@@ -74,6 +74,7 @@ export interface RemotesUrlsConfig {
 	readonly fileInCommit: string;
 	readonly fileLine: string;
 	readonly fileRange: string;
+	readonly avatar?: string;
 }
 
 export abstract class RemoteProvider<T extends ResourceDescriptor = ResourceDescriptor> implements ProviderReference {

package/src/git/models/repository.ts

@@ -7,7 +7,6 @@ import type { UnifiedDisposable } from '../../utils/disposable.js';
 import { createDisposable } from '../../utils/disposable.js';
 import type { Event } from '../../utils/event.js';
 import { Emitter } from '../../utils/event.js';
-import { getScopedLogger } from '../../utils/logger.scoped.js';
 import { basename, normalizePath } from '../../utils/path.js';
 import type { Uri } from '../../utils/uri.js';
 import { fileUri } from '../../utils/uri.js';
@@ -84,8 +83,6 @@ export interface RepositoryInit {
 	readonly gitDir: GitDir | undefined;
 	readonly index: number;
 	readonly root: boolean;
-	readonly closed?: boolean;
-	readonly suspended?: boolean;
 	readonly watchService: RepositoryWatchService;
 }
 
@@ -118,19 +115,21 @@ export class Repository {
 	readonly root: boolean;
 
 	protected readonly _gitDir: GitDir | undefined;
-	protected _pendingResumeTimer: ReturnType<typeof setTimeout> | undefined;
 	protected _repoSubscription: RepositorySubscription | undefined;
-	protected _suspended: boolean;
 	protected _watchHandle: WatchHandle | undefined;
 	protected readonly _watchService: RepositoryWatchService;
 
 	private _pendingWorkingTreeChange?: RepositoryWorkingTreeChangeEvent;
 	private _pendingWorkingTreeFlush = false;
 	private _repoChangeListener: UnifiedDisposable | undefined;
+	/** Outstanding leases on the shared {@link _watchHandle} across `watch()` + `watchWorkingTree()`. */
+	private _watchHandleRefs = 0;
+	/** Outstanding `watch()` (repo-change) leases; drives the single shared bridge subscription. */
+	private _watchRefs = 0;
+	private _disposed = false;
 
 	constructor(init: RepositoryInit) {
 		({
-			closed: this._closed = init.closed ?? false,
 			id: this.id,
 			index: this.index,
 			gitDir: this._gitDir,
@@ -138,7 +137,6 @@ export class Repository {
 			path: this.path,
 			provider: this.provider,
 			root: this.root,
-			suspended: this._suspended = init.suspended ?? false,
 			uri: this.uri,
 			watchService: this._watchService,
 		} = init);
@@ -156,45 +154,25 @@ export class Repository {
 				this._name = `${prefix}${this._name}`;
 			}
 		}
-
-		this.setupWatching();
 	}
 
 	dispose(): void {
-		clearTimeout(this._pendingResumeTimer);
+		this._disposed = true;
 		this._repoChangeListener?.dispose();
 		this._repoChangeListener = undefined;
 		this._repoSubscription?.dispose();
 		this._repoSubscription = undefined;
 		this._watchHandle?.dispose();
 		this._watchHandle = undefined;
+		this._watchHandleRefs = 0;
+		this._watchRefs = 0;
 		this._onDidChange.dispose();
 		this._onDidChangeWorkingTree.dispose();
 	}
 
-	protected _closed: boolean;
-	get closed(): boolean {
-		return this._closed;
-	}
-	set closed(value: boolean) {
-		const changed = this._closed !== value;
-		this._closed = value;
-		if (changed) {
-			if (this._closed) {
-				// When closing, fire immediately even if suspended
-				this.fireChange('closed', true);
-
-				this._repoChangeListener?.dispose();
-				this._repoChangeListener = undefined;
-				this._repoSubscription?.dispose();
-				this._repoSubscription = undefined;
-			} else {
-				this.setupWatching();
-				this.fireChange('opened');
-			}
-
-			this.onClosedChanged(value);
-		}
+	/** Indicates whether this repository currently has an active `watch()` (repo-change) lease. */
+	get watching(): boolean {
+		return this._watchRefs > 0;
 	}
 
 	get etag(): number {
@@ -249,41 +227,6 @@ export class Repository {
 		return this.provider.virtual;
 	}
 
-	@trace({ onlyExit: true })
-	suspend(): void {
-		this._suspended = true;
-		this._watchHandle?.session.suspend();
-
-		if (this._pendingResumeTimer != null) {
-			clearTimeout(this._pendingResumeTimer);
-			this._pendingResumeTimer = undefined;
-		}
-	}
-
-	@trace({ onlyExit: true })
-	resume(delayMs?: number): void {
-		if (delayMs) {
-			if (this._pendingResumeTimer != null) {
-				clearTimeout(this._pendingResumeTimer);
-			}
-			this._pendingResumeTimer = setTimeout(() => {
-				this._pendingResumeTimer = undefined;
-				this.resume();
-			}, delayMs);
-			return;
-		}
-
-		const scope = getScopedLogger();
-
-		if (!this._suspended) {
-			scope?.addExitInfo('ignored; not suspended');
-			return;
-		}
-
-		this._suspended = false;
-		this._watchHandle?.session.resume();
-	}
-
 	waitForRepoChange(timeoutMs: number): Promise<boolean> {
 		let timeoutId: ReturnType<typeof setTimeout> | undefined;
 		let listener: UnifiedDisposable | undefined;
@@ -313,17 +256,57 @@ export class Repository {
 		]);
 	}
 
+	/**
+	 * Starts watching this repository's `.git` directory for repo-change events (delivered via
+	 * {@link onDidChange}) and returns a lease. Ref-counted: the underlying watch handle is acquired
+	 * on the first lease (across `watch()` and {@link watchWorkingTree}) and released when the last
+	 * is disposed. The model is inert until watched. No-ops (returns a disposable that does nothing)
+	 * for repositories without a git directory (e.g. virtual repos).
+	 */
+	@trace({ onlyExit: true })
+	watch(): UnifiedDisposable {
+		const acquired = this.acquireWatchHandle();
+		if (acquired == null) return createDisposable(() => {});
+
+		if (this._watchRefs++ === 0) {
+			const sub = acquired.handle.session.subscribe();
+			this._repoSubscription = sub;
+			this._repoChangeListener = sub.onDidChange(e => this.onSessionRepoChange(e));
+		}
+
+		return createDisposable(
+			() => {
+				// Repo already torn down — its handle/subscriptions are gone; skip to avoid a negative refcount
+				if (this._disposed) return;
+
+				if (--this._watchRefs === 0) {
+					this._repoChangeListener?.dispose();
+					this._repoChangeListener = undefined;
+					this._repoSubscription?.dispose();
+					this._repoSubscription = undefined;
+				}
+				acquired.lease.dispose();
+			},
+			{ once: true },
+		);
+	}
+
 	@trace({ onlyExit: true })
 	watchWorkingTree(delay: number = 2500): UnifiedDisposable {
-		const sub = this._watchHandle?.session.subscribeToWorkingTree({ delayMs: delay });
-		if (sub == null) return createDisposable(() => {});
+		const acquired = this.acquireWatchHandle();
+		if (acquired == null) return createDisposable(() => {});
 
+		const sub = acquired.handle.session.subscribeToWorkingTree({ delayMs: delay });
 		const listener = sub.onDidChangeWorkingTree(e => this.onWorkingTreeChanged(e.paths));
 
-		return createDisposable(() => {
-			listener.dispose();
-			sub.dispose();
-		});
+		return createDisposable(
+			() => {
+				listener.dispose();
+				sub.dispose();
+				acquired.lease.dispose();
+			},
+			{ once: true },
+		);
 	}
 
 	/**
@@ -338,7 +321,7 @@ export class Repository {
 	protected fireChange(change: RepositoryChange, force: boolean): void;
 	@trace()
 	protected fireChange(...args: RepositoryChange[] | [RepositoryChange, boolean]): void {
-		const lastArg = args[args.length - 1];
+		const lastArg = args.at(-1);
 		const force = typeof lastArg === 'boolean' ? lastArg : false;
 		const changes = (force ? args.slice(0, -1) : args) as RepositoryChange[];
 
@@ -353,14 +336,28 @@ export class Repository {
 		this._watchHandle?.session.fireChange(...changes);
 	}
 
-	/** Called when the closed state changes. Override to add behavior (e.g., branch access tracking). */
-	protected onClosedChanged(_closed: boolean): void {}
-
 	/** Called when the watch service notifies of FETCH_HEAD changes. */
 	protected onFetchHeadChanged(): void {
-		this._lastFetched = undefined;
-		// Force-fire so the event arrives immediately (no debounce); downstream consumers must
-		// invalidate any cached fetch timestamp before reading a fresh value.
+		// Don't reset `_lastFetched` here: the FS watcher can fire even when the on-disk mtime
+		// hasn't advanced (atomic-rename / lock-file activity emits `change` events without an
+		// mtime bump), and wiping would clobber a fresher value set by `markFetched()`.
+		// `getLastFetched()` reconciles in-memory vs FS via `Math.max`. Force-fire so consumers
+		// invalidate their caches and re-read.
+		this.fireChange('lastFetched', true);
+	}
+
+	/**
+	 * Marks the repository as having just been fetched. Use after a GitLens-initiated fetch/pull
+	 * completes so the "last fetched" UI tracks the attempt even when git skipped rewriting
+	 * `.git/FETCH_HEAD` (modern git omits the rewrite when all refs are up-to-date). The
+	 * in-memory timestamp is reconciled with the on-disk mtime by {@link getLastFetched} via
+	 * `Math.max`, so this is monotonic.
+	 */
+	markFetched(timestamp: number = Date.now()): void {
+		const next = Math.max(this._lastFetched ?? 0, timestamp);
+		if (next === this._lastFetched) return;
+
+		this._lastFetched = next;
 		this.fireChange('lastFetched', true);
 	}
 
@@ -397,38 +394,50 @@ export class Repository {
 			(this._pendingWorkingTreeChange.uris as Set<Uri>).add(fileUri(p));
 		}
 
-		if (this._suspended) return;
 		if (this._pendingWorkingTreeFlush) return;
 
 		this._pendingWorkingTreeFlush = true;
 		queueMicrotask(() => {
 			this._pendingWorkingTreeFlush = false;
 			const e = this._pendingWorkingTreeChange;
-			if (e == null || this._suspended) return;
+			if (e == null) return;
+
 			this._pendingWorkingTreeChange = undefined;
 			this._onDidChangeWorkingTree.fire(e);
 		});
 	}
 
-	@trace({ onlyExit: true })
-	private setupWatching(): void {
-		if (this._gitDir == null || this._closed) return;
-		if (this._repoSubscription != null) return;
-
-		const scope = getScopedLogger();
+	/**
+	 * Lazily acquires (and ref-counts) the shared {@link _watchHandle} for this repository, returning
+	 * the handle plus a one-shot lease whose disposal decrements the ref count (releasing the handle
+	 * when the last lease is gone). Returns `undefined` for repositories without a git directory.
+	 */
+	private acquireWatchHandle(): { handle: WatchHandle; lease: UnifiedDisposable } | undefined {
+		if (this._gitDir == null || this._disposed) return undefined;
 
 		this._watchHandle ??= this._watchService.watch(this.path, this._gitDir, {
 			onFetchHeadChanged: () => this.onFetchHeadChanged(),
 			onGitIgnoreChanged: () => this.onGitIgnoreChanged(),
 			onIgnoresChanged: () => this.onIgnoresChanged(),
 		} satisfies WatchHooks);
-		if (this._watchHandle == null) return;
-
-		const sub = this._watchHandle.session.subscribe();
-		this._repoSubscription = sub;
-		this._repoChangeListener = sub.onDidChange(e => this.onSessionRepoChange(e));
-
-		scope?.trace(`subscribed to repo changes for '${this.uri.toString()}'`);
+		const handle = this._watchHandle;
+		if (handle == null) return undefined;
+
+		this._watchHandleRefs++;
+		const lease = createDisposable(
+			() => {
+				// Repo already torn down — the handle is gone; skip to avoid a negative refcount
+				if (this._disposed) return;
+
+				if (--this._watchHandleRefs === 0) {
+					this._watchHandle?.dispose();
+					this._watchHandle = undefined;
+				}
+			},
+			{ once: true },
+		);
+
+		return { handle: handle, lease: lease };
 	}
 
 	static is(repository: unknown): repository is Repository {

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/statusFile.ts

@@ -94,6 +94,18 @@ export class GitStatusFile implements GitFile {
 		return this.conflictStatus != null;
 	}
 
+	/**
+	 * True when the file has both staged (index) and unstaged (working-tree) changes and is not
+	 * conflicted. Used by the host-side discard flows to apply partial-discard semantics — drop the
+	 * working-tree delta while preserving the staged portion. Centralized here so those host paths
+	 * agree on what "mixed" means. (The webview button predicate can't consume this getter — it
+	 * runs against the wire `GitFileChangeShape` and infers the same state from the duplicate
+	 * staged/unstaged rows the WIP feed emits per mixed path.)
+	 */
+	get mixed(): boolean {
+		return this.indexStatus != null && this.workingTreeStatus != null && this.conflictStatus == null;
+	}
+
 	get staged(): boolean {
 		return this.indexStatus != null;
 	}

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/commits.ts

@@ -78,6 +78,10 @@ export interface GitCommitReachability {
 export interface GitCommitsSubProvider {
 	getCommit(repoPath: string, rev: string, cancellation?: AbortSignal): Promise<GitCommit | undefined>;
 	getCommitCount(repoPath: string, rev: string, cancellation?: AbortSignal): Promise<number | undefined>;
+	/** Whether `rev` has any commits not reachable from any remote-tracking ref (i.e. unpushed/unpublished).
+	 *  Cheap early-exit probe (`rev-list --not --remotes <rev> -n 1`) — it does NOT count them. Returns
+	 *  `undefined` when it can't be determined. */
+	hasUnpublishedCommits?(repoPath: string, rev: string, cancellation?: AbortSignal): Promise<boolean | undefined>;
 	/** Cheap author/committer date lookup for a single revision. Skips the full commit parse (no files, parents, or message) — use when only the dates are needed. Pass a full SHA so caching stays correct (commits are immutable; refs are not). */
 	getCommitDates?(
 		repoPath: string,