@gitkraken/core-gitlens 0.3.0 → 0.3.1

package/src/git/utils/reachability.utils.ts

@@ -0,0 +1,109 @@
+import { base64, fromBase64 } from '../../utils/base64.js';
+import type { GraphReachabilityTable } from '../models/graph.js';
+import type { GitCommitReachability } from '../providers/commits.js';
+
+type ReachableRef = GitCommitReachability['refs'][number];
+
+/**
+ * Canonical dictionary key for a reachable ref. The `r`/`l` discriminator keeps a remote branch from
+ * colliding with a local branch of the same name; the `refType` prefix separates tags from branches.
+ * Single-sourced here so the encoder ({@link createReachabilityTableBuilder}) and any future consumer
+ * can't drift on the convention.
+ */
+export function reachableRefKey(ref: ReachableRef): string {
+	return `${ref.refType}:${ref.refType === 'branch' && ref.remote ? 'r' : 'l'}:${ref.name}`;
+}
+
+// Monotonic generation counter — each builder (i.e. each fresh graph walk) gets a distinct id, while a
+// builder reused across `more()` pagination keeps its id. Only ever incremented host-side (the encoder);
+// the webview treats the id as opaque. Module-scoped so ids are unique across a session's builders.
+let nextReachabilityTableId = 0;
+
+/**
+ * Builds a {@link GraphReachabilityTable} incrementally: interns refs into a shared dictionary and
+ * distinct membership bitmaps into a deduplicated set list. Kept next to {@link decodeReachabilitySet}
+ * (its exact inverse) so the wire format — first-seen dictionary indexing, LSB-first bit packing,
+ * base64 — has a single owner and a round-trippable test, rather than an encoder and decoder that can
+ * silently diverge across packages.
+ *
+ * Append-only by construction: an index, once assigned, is never reused — so a builder kept alive
+ * across paginated loads accumulates a table whose existing indices stay valid as it grows.
+ */
+export function createReachabilityTableBuilder(): {
+	intern: (refs: Iterable<ReachableRef> | undefined) => number | undefined;
+	build: () => GraphReachabilityTable | undefined;
+} {
+	const id = ++nextReachabilityTableId;
+	const dictionary: GitCommitReachability['refs'] = [];
+	const refKeyToIndex = new Map<string, number>();
+	const sets: string[] = [];
+	const setKeyToIndex = new Map<string, number>();
+
+	return {
+		/** Interns a ref set, returning its index into `sets`, or undefined when the set is empty. */
+		intern: (refs: Iterable<ReachableRef> | undefined): number | undefined => {
+			if (refs == null) return undefined;
+
+			let maxIndex = -1;
+			const indices: number[] = [];
+			for (const ref of refs) {
+				const key = reachableRefKey(ref);
+				let index = refKeyToIndex.get(key);
+				if (index == null) {
+					index = dictionary.length;
+					refKeyToIndex.set(key, index);
+					dictionary.push(ref);
+				}
+				indices.push(index);
+				if (index > maxIndex) {
+					maxIndex = index;
+				}
+			}
+			if (indices.length === 0) return undefined;
+
+			// Pack into a bitset sized to this set's high-water dictionary index, then intern by base64.
+			const bytes = new Uint8Array((maxIndex >> 3) + 1);
+			for (const index of indices) {
+				bytes[index >> 3] |= 1 << (index & 7);
+			}
+			const encoded = base64(bytes);
+			let setIndex = setKeyToIndex.get(encoded);
+			if (setIndex == null) {
+				setIndex = sets.length;
+				setKeyToIndex.set(encoded, setIndex);
+				sets.push(encoded);
+			}
+			return setIndex;
+		},
+
+		/** The accumulated table, or undefined when nothing was interned. */
+		build: (): GraphReachabilityTable | undefined =>
+			dictionary.length ? { id: id, dictionary: dictionary, sets: sets } : undefined,
+	};
+}
+
+/**
+ * Decodes the membership bitmap at `index` in a {@link GraphReachabilityTable} back into its list of
+ * reachable refs. Refs come back in the table's first-seen dictionary order — callers that need the
+ * canonical display order (current-first / local-before-remote / tags newest-first) sort the result
+ * with `compareReachableRefs`. Returns an empty array for an out-of-range/missing set index.
+ *
+ * The bitmap is at most `ceil(dictionary.length / 8)` bytes; earlier (shorter) bitmaps packed against
+ * a smaller dictionary stay valid — only bits actually present can be set, so the loop stops at the
+ * shorter of the dictionary length and the bitmap's bit count rather than scanning a guaranteed-zero tail.
+ */
+export function decodeReachabilitySet(table: GraphReachabilityTable, index: number): GitCommitReachability['refs'] {
+	const { dictionary, sets } = table;
+	const encoded = sets[index];
+	if (encoded == null) return [];
+
+	const bytes = fromBase64(encoded);
+	const refs: GitCommitReachability['refs'] = [];
+	const count = Math.min(dictionary.length, bytes.length * 8);
+	for (let i = 0; i < count; i++) {
+		if ((bytes[i >> 3] ?? 0) & (1 << (i & 7))) {
+			refs.push(dictionary[i]);
+		}
+	}
+	return refs;
+}

package/src/git/watching/watchService.ts

@@ -43,7 +43,7 @@ interface SessionRecord {
 	 * implementations stored just the first caller's hooks (`WatchHooks | undefined`) and
 	 * silently dropped subsequent callers' hooks — that broke the case where a low-level
 	 * subscriber (e.g. the Graph's secondary-worktree WIP watcher) opened the session
-	 * first without hooks, and a later `Repository.setupWatching` for the same path lost
+	 * first without hooks, and a later `Repository.watch()` for the same path lost
 	 * its `markFetched` / `onIgnoresChanged` wiring. Each `watch()` call adds its hooks
 	 * to this set and removes them on dispose; fire sites iterate the set.
 	 */
@@ -78,6 +78,8 @@ export class RepositoryWatchService implements UnifiedDisposable {
 	private readonly watchGroups = new Map<string, WatchGroup>();
 	private readonly wtWatchers = new Map<string, { watcher: FileWatcher; filter?: GitIgnoreFilter }>();
 	private _disposed = false;
+	/** Global suspend state (driven by window focus); inherited by sessions created via {@link watch}. */
+	private _suspended = false;
 
 	constructor(options: WatchServiceOptions) {
 		this.provider = options.watchingProvider;
@@ -135,6 +137,7 @@ export class RepositoryWatchService implements UnifiedDisposable {
 				repoPath: repoPath,
 				defaultRepoDelayMs: this.defaultRepoDelayMs,
 				defaultWorkingTreeDelayMs: this.defaultWorkingTreeDelayMs,
+				suspended: this._suspended,
 				lifecycle: {
 					onFirstRepoSubscriber: (): void => {
 						const rec = this.sessionMap.get(repoPath);
@@ -207,15 +210,17 @@ export class RepositoryWatchService implements UnifiedDisposable {
 		return this.sessionMap.get(repoPath)?.session;
 	}
 
-	/** Suspend all sessions */
+	/** Suspend all sessions and mark the service suspended so late-joining sessions start suspended */
 	suspendAll(): void {
+		this._suspended = true;
 		for (const record of this.sessionMap.values()) {
 			record.session.suspend();
 		}
 	}
 
-	/** Resume all sessions, with optional per-session delay */
+	/** Resume all sessions (clearing the global suspend state), with optional per-session delay */
 	resumeAll(getDelay?: (session: RepositoryWatchSession) => number): void {
+		this._suspended = false;
 		for (const record of this.sessionMap.values()) {
 			const delayMs = getDelay?.(record.session);
 			record.session.resume(delayMs);
@@ -252,7 +257,7 @@ export class RepositoryWatchService implements UnifiedDisposable {
 			},
 			onFetchHeadChanged: function (repoPath: string): void {
 				// Iterate at fire time so callers that joined after the group was wired up
-				// still receive events (e.g. a `Repository.setupWatching` whose hooks landed
+				// still receive events (e.g. a `Repository.watch()` whose hooks landed
 				// after a hookless `GitRepositoryService.watch` registered first).
 				for (const h of watchHooks) {
 					h.onFetchHeadChanged?.(repoPath);

package/src/git/watching/watchSession.ts

@@ -37,6 +37,8 @@ export interface WatchSessionOptions {
 	/** Default debounce for working tree changes. Default: 2500ms */
 	readonly defaultWorkingTreeDelayMs?: number;
 	readonly lifecycle?: WatchSessionLifecycle;
+	/** Initial suspended state — new sessions inherit the service-global suspend state. Default: false */
+	readonly suspended?: boolean;
 	/**
 	 * Called whenever a debounced repo change event is dispatched to subscribers.
 	 * Does NOT count as a subscriber — used by WatchService for
@@ -66,16 +68,16 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 	private effectiveRepoMs: number;
 	private readonly defaultRepoMs: number;
 
-	private readonly wtEmitter = new Emitter<WorkingTreeChangeEvent>();
-	private readonly wtDelays = new Map<number, number>();
-	private wtNextId = 0;
-	private pendingWTPaths = new Set<string>();
-	private wtTimer: ReturnType<typeof setTimeout> | undefined;
-	private effectiveWTMs: number;
-	private readonly defaultWTMs: number;
+	private readonly workingTreeEmitter = new Emitter<WorkingTreeChangeEvent>();
+	private readonly workingTreeDelays = new Map<number, number>();
+	private workingTreeNextId = 0;
+	private pendingWorkingTreePaths = new Set<string>();
+	private workingTreeTimer: ReturnType<typeof setTimeout> | undefined;
+	private effectiveWorkingTreeMs: number;
+	private readonly defaultWorkingTreeMs: number;
 
 	private _etagWorkingTree = 0;
-	private _suspended = false;
+	private _suspended: boolean;
 	private _disposed = false;
 
 	private readonly lifecycle?: WatchSessionLifecycle;
@@ -84,11 +86,12 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 	constructor(options: WatchSessionOptions) {
 		this.repoPath = options.repoPath;
 		this.defaultRepoMs = options.defaultRepoDelayMs ?? defaultRepoDelay;
-		this.defaultWTMs = options.defaultWorkingTreeDelayMs ?? defaultWorkingTreeDelay;
+		this.defaultWorkingTreeMs = options.defaultWorkingTreeDelayMs ?? defaultWorkingTreeDelay;
 		this.effectiveRepoMs = this.defaultRepoMs;
-		this.effectiveWTMs = this.defaultWTMs;
+		this.effectiveWorkingTreeMs = this.defaultWorkingTreeMs;
 		this.lifecycle = options.lifecycle;
 		this.onDidFireRepoChangeCallback = options.onDidFireRepoChange;
+		this._suspended = options.suspended ?? false;
 	}
 
 	[Symbol.dispose](): void {
@@ -101,15 +104,15 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 		this._disposed = true;
 
 		this.cancelRepoTimer();
-		this.cancelWTTimer();
+		this.cancelWorkingTreeTimer();
 
 		this.pendingRepoEvent = undefined;
-		this.pendingWTPaths.clear();
+		this.pendingWorkingTreePaths.clear();
 		this.repoDelays.clear();
-		this.wtDelays.clear();
+		this.workingTreeDelays.clear();
 
 		this.repoEmitter.dispose();
-		this.wtEmitter.dispose();
+		this.workingTreeEmitter.dispose();
 	}
 
 	get suspended(): boolean {
@@ -117,7 +120,7 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 	}
 
 	get hasPendingChanges(): boolean {
-		return this.pendingRepoEvent != null || this.pendingWTPaths.size > 0;
+		return this.pendingRepoEvent != null || this.pendingWorkingTreePaths.size > 0;
 	}
 
 	get repoSubscriberCount(): number {
@@ -125,7 +128,7 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 	}
 
 	get workingTreeSubscriberCount(): number {
-		return this.wtDelays.size;
+		return this.workingTreeDelays.size;
 	}
 
 	/**
@@ -197,26 +200,26 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 			return Object.assign(
 				createDisposable(() => {}),
 				{
-					onDidChangeWorkingTree: this.wtEmitter.event,
+					onDidChangeWorkingTree: this.workingTreeEmitter.event,
 				},
 			);
 		}
 
-		const id = this.wtNextId++;
-		const delay = opts?.delayMs ?? this.defaultWTMs;
-		const wasEmpty = this.wtDelays.size === 0;
-		const prevDelay = this.effectiveWTMs;
+		const id = this.workingTreeNextId++;
+		const delay = opts?.delayMs ?? this.defaultWorkingTreeMs;
+		const wasEmpty = this.workingTreeDelays.size === 0;
+		const prevDelay = this.effectiveWorkingTreeMs;
 
-		this.wtDelays.set(id, delay);
-		this.recalcWTDelay();
+		this.workingTreeDelays.set(id, delay);
+		this.recalcWorkingTreeDelay();
 
 		if (wasEmpty) {
 			this.lifecycle?.onFirstWorkingTreeSubscriber?.();
 		}
 
 		// If the effective delay got shorter while a timer is running, reschedule sooner
-		if (this.effectiveWTMs < prevDelay && this.wtTimer != null) {
-			this.scheduleWTFlush();
+		if (this.effectiveWorkingTreeMs < prevDelay && this.workingTreeTimer != null) {
+			this.scheduleWorkingTreeFlush();
 		}
 
 		let subDisposed = false;
@@ -226,16 +229,16 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 
 				subDisposed = true;
 
-				this.wtDelays.delete(id);
-				this.recalcWTDelay();
+				this.workingTreeDelays.delete(id);
+				this.recalcWorkingTreeDelay();
 
-				if (this.wtDelays.size === 0) {
-					this.cancelWTTimer();
-					this.pendingWTPaths.clear();
+				if (this.workingTreeDelays.size === 0) {
+					this.cancelWorkingTreeTimer();
+					this.pendingWorkingTreePaths.clear();
 					this.lifecycle?.onLastWorkingTreeSubscriber?.();
 				}
 			}),
-			{ onDidChangeWorkingTree: this.wtEmitter.event },
+			{ onDidChangeWorkingTree: this.workingTreeEmitter.event },
 		);
 	}
 
@@ -243,7 +246,7 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 		this._suspended = true;
 		// Cancel active timers — events continue to coalesce but don't fire
 		this.cancelRepoTimer();
-		this.cancelWTTimer();
+		this.cancelWorkingTreeTimer();
 	}
 
 	resume(delayMs?: number): void {
@@ -255,8 +258,8 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 		if (this.pendingRepoEvent != null) {
 			this.scheduleRepoFlush(delayMs);
 		}
-		if (this.pendingWTPaths.size > 0) {
-			this.scheduleWTFlush(delayMs);
+		if (this.pendingWorkingTreePaths.size > 0) {
+			this.scheduleWorkingTreeFlush(delayMs);
 		}
 	}
 
@@ -286,7 +289,7 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 		if (this._disposed) return;
 
 		this._etagWorkingTree++;
-		this.coalesceWT(paths);
+		this.coalesceWorkingTrees(paths);
 	}
 
 	private static minDelay(delays: Map<number, number>, fallback: number): number {
@@ -305,8 +308,11 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 		this.effectiveRepoMs = RepositoryWatchSession.minDelay(this.repoDelays, this.defaultRepoMs);
 	}
 
-	private recalcWTDelay(): void {
-		this.effectiveWTMs = RepositoryWatchSession.minDelay(this.wtDelays, this.defaultWTMs);
+	private recalcWorkingTreeDelay(): void {
+		this.effectiveWorkingTreeMs = RepositoryWatchSession.minDelay(
+			this.workingTreeDelays,
+			this.defaultWorkingTreeMs,
+		);
 	}
 
 	private flushRepo(): void {
@@ -339,29 +345,29 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 		this.scheduleRepoFlush();
 	}
 
-	private flushWT(): void {
-		this.wtTimer = undefined;
-		if (this.pendingWTPaths.size === 0) return;
+	private flushWorkingTree(): void {
+		this.workingTreeTimer = undefined;
+		if (this.pendingWorkingTreePaths.size === 0) return;
 
-		const paths = this.pendingWTPaths;
-		this.pendingWTPaths = new Set();
-		this.wtEmitter.fire({ repoPath: this.repoPath, paths: paths });
+		const paths = this.pendingWorkingTreePaths;
+		this.pendingWorkingTreePaths = new Set();
+		this.workingTreeEmitter.fire({ repoPath: this.repoPath, paths: paths });
 	}
 
-	private scheduleWTFlush(delayOverride?: number): void {
-		if (this._suspended || this.pendingWTPaths.size === 0) return;
+	private scheduleWorkingTreeFlush(delayOverride?: number): void {
+		if (this._suspended || this.pendingWorkingTreePaths.size === 0) return;
 
-		if (this.wtTimer != null) {
-			clearTimeout(this.wtTimer);
+		if (this.workingTreeTimer != null) {
+			clearTimeout(this.workingTreeTimer);
 		}
-		this.wtTimer = setTimeout(() => this.flushWT(), delayOverride ?? this.effectiveWTMs);
+		this.workingTreeTimer = setTimeout(() => this.flushWorkingTree(), delayOverride ?? this.effectiveWorkingTreeMs);
 	}
 
-	private coalesceWT(paths: Iterable<string>): void {
+	private coalesceWorkingTrees(paths: Iterable<string>): void {
 		for (const p of paths) {
-			this.pendingWTPaths.add(p);
+			this.pendingWorkingTreePaths.add(p);
 		}
-		this.scheduleWTFlush();
+		this.scheduleWorkingTreeFlush();
 	}
 
 	private cancelRepoTimer(): void {
@@ -371,10 +377,10 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 		}
 	}
 
-	private cancelWTTimer(): void {
-		if (this.wtTimer != null) {
-			clearTimeout(this.wtTimer);
-			this.wtTimer = undefined;
+	private cancelWorkingTreeTimer(): void {
+		if (this.workingTreeTimer != null) {
+			clearTimeout(this.workingTreeTimer);
+			this.workingTreeTimer = undefined;
 		}
 	}
 }

package/src/git-cli/providers/branches.ts

@@ -232,6 +232,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 				// Pre-populate current branch cache for worktrees based on worktreePath info
 				// This eliminates the need for rev-parse calls during branch reconstruction
 				for (const branch of branches) {
+					// oxlint-disable-next-line typescript/prefer-optional-chain
 					if (branch.worktree && branch.worktree.path) {
 						const { name } = parseRefName(branch.refName);
 						const reference = createReference(name, branch.worktree.path, {

package/src/git-cli/providers/commits.ts

@@ -129,6 +129,30 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 		return isNaN(count) ? undefined : count;
 	}
 
+	@debug({ exit: true })
+	async hasUnpublishedCommits(
+		repoPath: string,
+		rev: string,
+		cancellation?: AbortSignal,
+	): Promise<boolean | undefined> {
+		// `<rev> --not --remotes` = commits reachable from `rev` but not from any remote-tracking ref.
+		// `--max-count=1` early-exits at the first such commit, so this is a presence probe, not a count.
+		const result = await this.git.run(
+			{ cwd: repoPath, cancellation: cancellation, errors: 'ignore' },
+			'rev-list',
+			'--max-count=1',
+			rev,
+			'--not',
+			'--remotes',
+			'--',
+		);
+		if (result.cancelled || cancellation?.aborted) {
+			throw new CancellationError();
+		}
+
+		return result.stdout.trim().length > 0;
+	}
+
 	@debug({ exit: true })
 	async getCommitDates(
 		repoPath: string,

package/src/git-cli/providers/config.ts

@@ -27,17 +27,24 @@ import type { Git } from '../exec/git.js';
 const mappedAuthorRegex = /(.+)\s<(.+)>/;
 const emptyArray: readonly never[] = Object.freeze([]);
 
+/** Catch-all pattern matching every key in `.git/gk/config` for the one-shot bulk read. */
+const gkConfigAllPattern = '.';
+
 /**
- * Namespaces whose individual reads should be served from one --get-regex fetch instead
- * of one `git config --get` per key. The regex cache backing getGkConfigRegex dedupes
- * concurrent callers so a burst of per-branch reads produces a single subprocess.
+ * Canonicalizes a git config key for lookup against `--get-regexp` output, which git emits with the
+ * section and variable-name lowercased and only the subsection case-preserved. Without this a
+ * subsection-less key like `gk.defaultRemote` would miss the lowercased `gk.defaultremote` in the map.
  */
-const gkConfigCacheableSets: readonly { match: RegExp; pattern: string }[] = [
-	{ match: /^branch\..+\.gk-associated-issues$/, pattern: '^branch\\..+\\.gk-associated-issues$' },
-	{ match: /^branch\..+\.gk-merge-base$/, pattern: '^branch\\..+\\.gk-merge-base$' },
-	{ match: /^branch\..+\.gk-merge-target$/, pattern: '^branch\\..+\\.gk-merge-target$' },
-	{ match: /^branch\..+\.gk-merge-target-user$/, pattern: '^branch\\..+\\.gk-merge-target-user$' },
-];
+function canonicalizeGitConfigKey(key: string): string {
+	const first = key.indexOf('.');
+	if (first === -1) return key.toLowerCase();
+
+	const last = key.lastIndexOf('.');
+	// `section.name` (no subsection) → fully lowercased; `section.subsection.name` → lowercase
+	// section + name, preserve the case-sensitive subsection in the middle.
+	if (first === last) return key.toLowerCase();
+	return `${key.slice(0, first).toLowerCase()}${key.slice(first, last)}${key.slice(last).toLowerCase()}`;
+}
 
 /**
  * Parses git config --get-regex output into a Map.
@@ -309,45 +316,49 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 	}
 
 	@debug()
-	async getGkConfig(
-		repoPath: string,
-		key: GkConfigKeys | DeprecatedGkConfigKeys,
-		options?: { type?: GitConfigType },
-	): Promise<string | undefined> {
-		await this.migrateGkConfigFromGitConfig(this.cache.getCommonPath(repoPath));
+	async getGkConfig(repoPath: string, key: GkConfigKeys | DeprecatedGkConfigKeys): Promise<string | undefined> {
+		// Served in-memory from a single bulk read of the whole `.git/gk/config` (no gk read needs `--type`).
+		// Canonicalize the key the way git does for `--get-regexp` output so subsection-less keys
+		// (e.g. `gk.defaultRemote`) match, and coerce an empty value to undefined to match the old
+		// `git config --get` (`.trim() || undefined`) contract.
+		return (await this.getGkConfigMap(repoPath)).get(canonicalizeGitConfigKey(key)) || undefined;
+	}
 
-		// Per-branch keys are commonly read in fan-out loops (e.g. Home overview enrichment).
-		// Satisfy the read from a single --get-regex over the namespace instead of spawning
-		// one `git config --get` per branch.
-		const set = gkConfigCacheableSets.find(s => s.match.test(key));
-		if (set != null) {
-			return this.cache.getGkConfig(repoPath, key, async () => {
-				const entries = await this.getGkConfigRegex(repoPath, set.pattern);
-				return entries.get(key);
-			});
-		}
+	@debug()
+	async getGkConfigRegex(repoPath: string, pattern: string): Promise<Map<string, string>> {
+		const all = await this.getGkConfigMap(repoPath);
 
-		return this.cache.getGkConfig(repoPath, key, () => this.getGkConfigCore(repoPath, key, options));
-	}
+		// Filter the bulk map in-memory. The old path passed `pattern` to `git config --get-regex`
+		// (errors ignored → empty result on a bad pattern); preserve that no-throw contract here
+		// rather than letting an invalid-JS pattern reject the read.
+		let re: RegExp;
+		try {
+			re = new RegExp(pattern);
+		} catch {
+			return new Map();
+		}
 
-	private async getGkConfigCore(
-		repoPath: string,
-		key: string,
-		options?: { type?: GitConfigType },
-	): Promise<string | undefined> {
-		const gkConfigPath = await this.getGkConfigPath(repoPath);
-		if (!gkConfigPath) return undefined;
-		return this.getConfigCore(repoPath, key, {
-			...options,
-			runGitLocally: true,
-			file: gkConfigPath,
-		});
+		const result = new Map<string, string>();
+		for (const [k, v] of all) {
+			if (re.test(k)) {
+				result.set(k, v);
+			}
+		}
+		return result;
 	}
 
-	@debug()
-	async getGkConfigRegex(repoPath: string, pattern: string): Promise<Map<string, string>> {
+	/**
+	 * Reads the entire `.git/gk/config` in one `git config --get-regexp` and caches the parsed map
+	 * per commonPath. Per-key (getGkConfig) and per-namespace (getGkConfigRegex) lookups are served
+	 * from this single cached read — so a branch-overview render that fans out across several gk
+	 * namespaces costs one `git config` call instead of one per namespace.
+	 */
+	private async getGkConfigMap(repoPath: string): Promise<Map<string, string>> {
+		// Migrate BEFORE populating the cache, not inside the factory: a first-time migration calls
+		// clearCaches('gkConfig'), which would otherwise evict the in-flight gkConfigMap entry the
+		// cache wrapper synchronously stored and force a redundant bulk re-read.
 		await this.migrateGkConfigFromGitConfig(this.cache.getCommonPath(repoPath));
-		return this.cache.getGkConfigRegex(repoPath, pattern, () => this.getGkConfigRegexCore(repoPath, pattern));
+		return this.cache.getGkConfigMap(repoPath, () => this.getGkConfigRegexCore(repoPath, gkConfigAllPattern));
 	}
 
 	private async getGkConfigRegexCore(repoPath: string, pattern: string): Promise<Map<string, string>> {
@@ -377,7 +388,9 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 
 		const promise = this.setGkConfigCore(repoPath, key, value, options);
 		this._pendingGkConfigWrites.set(dedupKey, promise);
-		void promise.finally(() => this._pendingGkConfigWrites.delete(dedupKey));
+		// Swallow the cleanup chain's rejection so a failed write doesn't surface as an unhandled
+		// rejection separate from the caller's own handling of the returned promise.
+		void promise.finally(() => this._pendingGkConfigWrites.delete(dedupKey)).catch(() => {});
 		return promise;
 	}
 
@@ -398,7 +411,9 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 
 		await this.setConfigCore(repoPath, key, value, { file: gkConfigPath });
 
-		// Invalidate the cached value for this key and clear all regex patterns for this scope
+		// Invalidate the bulk map (so the next read re-fetches) and the derived caches for this key's
+		// ref. The `.git/gk/config` file-watcher also fires `'gkConfig'` shortly after, which clears
+		// the same caches coarsely — both paths are idempotent.
 		this.cache.deleteGkConfig(repoPath, key, options);
 	}
 
@@ -418,11 +433,10 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 		const sshProgram = configMap.get('gpg.ssh.program');
 		const allowedSignersFile = configMap.get('gpg.ssh.allowedsignersfile');
 
-		// Check if git config has commit signing enabled
-		const isEnabled = parseGitBoolean(enabledRaw);
-
-		// Note: To override commit signing, pass it via the host/caller.
-		// The library no longer reads a config for this.
+		// Check if git config has commit signing enabled, falling back to the host-level override
+		// (e.g. VS Code's `git.enableCommitSigning`) when `commit.gpgsign` is unset/false. The host
+		// override can only enable signing, never force it off.
+		const isEnabled = parseGitBoolean(enabledRaw) || this.context.config?.signing?.enabled === true;
 
 		return {
 			enabled: isEnabled,

package/src/git-cli/providers/diff.ts

@@ -218,7 +218,8 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 		},
 	): Promise<GitFile[] | undefined> {
 		try {
-			const similarityThreshold = options?.similarityThreshold;
+			const similarityThreshold =
+				options?.similarityThreshold ?? this.context.config?.commits.similarityThreshold;
 			const configs =
 				options?.renameLimit != null
 					? [...gitConfigsDiff, '-c', `diff.renameLimit=${options.renameLimit}`]