@gitkraken/core-gitlens 0.5.113 → 0.5.114

package/src/git-cli/cliGitProvider.ts

@@ -23,6 +23,7 @@ import { ConfigGitSubProvider } from './providers/config.js';
 import { ContributorsGitSubProvider } from './providers/contributors.js';
 import { DiffGitSubProvider } from './providers/diff.js';
 import { GraphGitSubProvider } from './providers/graph.js';
+import { MaintenanceGitSubProvider } from './providers/maintenance.js';
 import { OperationsGitSubProvider } from './providers/operations.js';
 import { PatchGitSubProvider } from './providers/patch.js';
 import { PausedOperationsGitSubProvider } from './providers/pausedOperations.js';
@@ -46,6 +47,13 @@ export interface CliGitProviderOptions {
 	git?: Git;
 	/** Git execution options (timeout, trust, queue config, hooks, etc.) */
 	gitOptions?: GitOptions;
+	/**
+	 * Whether repositories reached through this provider are on the LOCAL filesystem. `false` disables the
+	 * maintenance sub-provider entirely (Live Share): its probes stat local paths, and its writes are
+	 * rejected by the host's command allowlist, so inheriting it yields empty reports and swallowed
+	 * failures rather than an honest "unsupported here". Defaults to `true`.
+	 */
+	localRepositories?: boolean;
 }
 
 /**
@@ -83,9 +91,11 @@ export class CliGitProvider implements GitProvider {
 	private readonly _git: Git;
 
 	readonly context: GitServiceContext;
+	private readonly _localRepositories: boolean;
 
 	constructor(options: CliGitProviderOptions) {
 		this.context = options.context;
+		this._localRepositories = options.localRepositories ?? true;
 		this._git =
 			options.git ??
 			new Git(options.locator, {
@@ -220,6 +230,21 @@ export class CliGitProvider implements GitProvider {
 		));
 	}
 
+	private _maintenance: MaintenanceGitSubProvider | undefined;
+	// Optional so subclasses whose repos aren't local can report the capability as absent — see
+	// `VslsGitProvider`. Consumers already treat `maintenance == null` as "unsupported here" (web builds
+	// never register it at all).
+	get maintenance(): MaintenanceGitSubProvider | undefined {
+		if (!this._localRepositories) return undefined;
+
+		return (this._maintenance ??= new MaintenanceGitSubProvider(
+			this.context,
+			this._git,
+			this._cache,
+			this as unknown as CliGitProviderInternal,
+		));
+	}
+
 	private _ops: OperationsGitSubProvider | undefined;
 	get ops(): OperationsGitSubProvider {
 		return (this._ops ??= new OperationsGitSubProvider(

package/src/git-cli/exec/git.ts

@@ -8,6 +8,7 @@ import type {
 	CommitErrorReason,
 	FetchErrorReason,
 	GitCommandError,
+	GitSearchErrorReason,
 	GitWarningKey,
 	MergeErrorReason,
 	PausedOperationAbortErrorReason,
@@ -45,7 +46,7 @@ import type { GitCommandPriority, GitResult, GitRunOptions, GitSpawnOptions } fr
 import type { FilteredGitFeatures, GitFeatureOrPrefix, GitFeatures } from './features.js';
 import { gitFeaturesByVersion } from './features.js';
 import type { GitQueueConfig } from './gitQueue.js';
-import { GitQueue, inferGitCommandPriority } from './gitQueue.js';
+import { getPrimaryGitCommand, GitQueue, inferGitCommandPriority } from './gitQueue.js';
 import type { GitLocation } from './locator.js';
 
 const slowCallWarningThreshold = 2000;
@@ -62,7 +63,7 @@ export const gitConfigsStatus = ['-c', 'color.status=false'] as const;
 export const GitErrors = {
 	alreadyCheckedOut: /already checked out/i,
 	alreadyExists: /already exists/i,
-	ambiguousArgument: /fatal:\s*ambiguous argument ['"].+['"]: unknown revision or path not in the working tree/i,
+	ambiguousArgument: /fatal:\s*ambiguous argument ['"](.+?)['"]: unknown revision or path not in the working tree/i,
 	badObject: /fatal:\s*bad object (.*?)/i,
 	badRevision: /bad revision '(.*?)'/i,
 	branchAlreadyExists: /fatal:\s*A branch named '.+?' already exists/i,
@@ -83,6 +84,10 @@ export const GitErrors = {
 	invalidLineCount: /file .+? has only (\d+) lines/i,
 	invalidObjectName: /invalid object name: (.*)\s/i,
 	invalidObjectNameList: /could not open object name list: (.*)\s/i,
+	// Regcomp failure reasons from `-G`/pathspec regex compilation (search); matched without a known
+	// prefix as a fallback when the reason appears in an unrecognized stderr shape
+	invalidSearchPattern:
+		/Unmatched \( or \\\(|Unmatched \[|Unmatched \) or \\\)|Invalid content of \\\{\\\}|Invalid preceding regular expression|Invalid regular expression|Trailing backslash|invalid regex/i,
 	invalidTagName: /invalid tag name/i,
 	mainWorkingTree: /is a main working tree/i,
 	mergeAborted: /merge.*aborted/i,
@@ -100,6 +105,7 @@ export const GitErrors = {
 		/no merge (?:in progress|to abort)|no cherry-pick(?: or revert)? in progress|no rebase in progress/i,
 	permissionDenied: /Permission.*denied/i,
 	previousOperationEmpty: /The previous (?:cherry-pick|revert) is now empty/i,
+	problemWithEditor: /there was a problem with the editor/i,
 	pushRejected: /^error:\s*failed to push some refs to\b/m,
 	pushRejectedRefDoesNotExists: /error:\s*unable to delete '(.*?)': remote ref does not exist/m,
 	rebaseAborted: /Nothing to do|rebase.*aborted/i,
@@ -277,6 +283,9 @@ const errorToReasonMap = new Map<GitCommand, [RegExp, GitCommandToReasonMap[GitC
 	[
 		'paused-operation-continue',
 		[
+			// Kept FIRST: an editor failure's stderr can also carry broader messages ("could not
+			// commit staged changes", …) that later patterns would otherwise claim
+			[GitErrors.problemWithEditor, 'messageEditFailed'],
 			[GitErrors.previousOperationEmpty, 'emptyCommit'],
 			[GitErrors.noPausedOperation, 'nothingToContinue'],
 			[GitErrors.uncommittedChanges, 'uncommittedChanges'],
@@ -316,8 +325,11 @@ const errorToReasonMap = new Map<GitCommand, [RegExp, GitCommandToReasonMap[GitC
 		[
 			[GitErrors.remoteAhead, 'remoteAhead'],
 			[GitWarnings.tipBehind, 'tipBehind'],
-			[GitErrors.pushRejected, 'rejected'],
+			// Kept BEFORE the generic push rejection: a failed `push -d` of a missing ref reports both
+			// "unable to delete '<ref>': remote ref does not exist" and "failed to push some refs to ...",
+			// and the specific reason is the actionable one.
 			[GitErrors.pushRejectedRefDoesNotExists, 'rejectedRefDoesNotExist'],
+			[GitErrors.pushRejected, 'rejected'],
 			[GitErrors.permissionDenied, 'permissionDenied'],
 			[GitErrors.remoteConnectionFailed, 'remoteConnectionFailed'],
 			[GitErrors.noUpstream, 'noUpstream'],
@@ -383,6 +395,7 @@ const errorToReasonMap = new Map<GitCommand, [RegExp, GitCommandToReasonMap[GitC
 			[GitErrors.tagNotFound, 'notFound'],
 			[GitErrors.permissionDenied, 'permissionDenied'],
 			[GitErrors.remoteRejected, 'remoteRejected'],
+			[GitErrors.tagConflict, 'tagConflict'],
 		],
 	],
 	[
@@ -469,6 +482,44 @@ export function inferSigningFormatFromError(ex: unknown): SigningFormat | undefi
 	return undefined;
 }
 
+export interface SearchErrorClassification {
+	reason: GitSearchErrorReason;
+	detail?: string;
+}
+
+/**
+ * Classifies a graph search failure from its stderr into an {@link GitSearchErrorReason}, with the
+ * offending pattern/ref text (when git reports one) as `detail`. Returns `undefined` when the error
+ * isn't a `GitError` with stderr, or the stderr doesn't match a recognized shape.
+ */
+export function classifySearchError(ex: unknown): SearchErrorClassification | undefined {
+	if (!(ex instanceof GitError) || !ex.stderr) return undefined;
+
+	const stderr = ex.stderr;
+
+	// `-G<pattern>`/pathspec regex compile failures report one of two shapes:
+	//   fatal: command line, '<pattern>': <regcomp reason>
+	//   fatal: invalid regex: <regcomp reason>
+	// The pattern itself may contain "': ", so anchor on the known prefixes and let the greedy `.*`
+	// resolve to the LAST matching delimiter rather than splitting on the first occurrence.
+	const patternDetail =
+		/^fatal:\s*command line,\s*'.*':\s*(.+)$/im.exec(stderr)?.[1] ??
+		/^fatal:\s*invalid regex:\s*(.+)$/im.exec(stderr)?.[1];
+	if (patternDetail != null) return { reason: 'invalidPattern', detail: patternDetail.trim() };
+
+	if (GitErrors.invalidSearchPattern.test(stderr)) return { reason: 'invalidPattern' };
+
+	const ambiguous = GitErrors.ambiguousArgument.exec(stderr);
+	if (ambiguous != null) return { reason: 'invalidRef', detail: ambiguous[1] };
+
+	const badRevision = GitErrors.badRevision.exec(stderr);
+	if (badRevision != null) return { reason: 'invalidRef', detail: badRevision[1] };
+
+	if (/unknown revision/i.test(stderr)) return { reason: 'invalidRef' };
+
+	return undefined;
+}
+
 export interface GitOptions {
 	/** Custom environment variables to add to every git command */
 	env?: Record<string, string | undefined>;
@@ -504,6 +555,12 @@ export interface GitHooks {
 		queued: Record<GitCommandPriority, number>;
 		maxConcurrent: number;
 	}): void;
+	/**
+	 * Called once per git command that ran slowly (over the slow-call threshold). Fired only for the
+	 * command that actually executed, never for a deduplicated rider that merely awaited it, so a single
+	 * slow subprocess counts once. `operation` is the primary git subcommand (e.g. `status`, `rev-list`).
+	 */
+	onSlowCommand?(info: { operation: string | undefined; cwd: string | undefined; duration: number }): void;
 }
 
 const emptyArray: readonly never[] = Object.freeze([]);
@@ -709,6 +766,7 @@ export class Git {
 			errors: errorHandling,
 			encoding,
 			runLocally: _,
+			selfMaintenance,
 			...opts
 		} = options;
 
@@ -726,6 +784,9 @@ export class Git {
 			options?.stdin != null ? `${uniqueCounterForStdin.next()}:` : ''
 		}${cancellation != null ? `${getAbortSignalId(cancellation)}:` : ''}${gitCommand}`;
 
+		// When the subprocess actually started — `start` includes GitQueue wait, which is congestion rather
+		// than anything the repository did. Stays undefined for a dedup rider or a command aborted while queued.
+		let execStart: ReturnType<typeof hrtime> | undefined;
 		let waiting;
 		let promise = this.pendingCommands.get(cacheKey);
 		if (promise == null) {
@@ -758,7 +819,14 @@ export class Git {
 			// Execute through the queue (interactive/normal run immediately, background is throttled)
 			const gitPath = await this.path();
 			void this._queue
-				.run(priority, () => runSpawn<T>(gitPath, args, encoding ?? 'utf8', runOpts), cancellation)
+				.run(
+					priority,
+					() => {
+						execStart = hrtime();
+						return runSpawn<T>(gitPath, args, encoding ?? 'utf8', runOpts);
+					},
+					cancellation,
+				)
 				.then(deferred.fulfill, (e: unknown) => deferred.cancel(e instanceof Error ? e : new Error(String(e))))
 				.finally(() => {
 					this.pendingCommands.delete(cacheKey);
@@ -908,7 +976,17 @@ export class Git {
 				completion: { status: 'warned', warning: warning, error: swallowed },
 			};
 		} finally {
-			this.logGitCommandComplete(gitCommand, exception, getDurationMilliseconds(start), waiting);
+			this.logGitCommandComplete(
+				gitCommand,
+				exception,
+				getDurationMilliseconds(start),
+				// 0 when the subprocess never started — there is no execution time to attribute. Also 0 for
+				// GitLens's own maintenance work, which is slow by design and must not read as repo slowness.
+				execStart == null || selfMaintenance ? 0 : getDurationMilliseconds(execStart),
+				waiting,
+				options.cwd,
+				args,
+			);
 		}
 	}
 
@@ -1013,7 +1091,20 @@ export class Git {
 			try {
 				proc.removeAllListeners();
 			} catch {}
-			this.logGitCommandComplete(gitCommand, exception, getDurationMilliseconds(start), false, streamId);
+			// Streaming spawns directly, with no GitQueue wait to exclude. It isn't pure subprocess time
+			// either — the generator applies backpressure, so a slow consumer stalls the pipe and inflates
+			// this — but there's no separate signal to measure here.
+			const duration = getDurationMilliseconds(start);
+			this.logGitCommandComplete(
+				gitCommand,
+				exception,
+				duration,
+				duration,
+				false,
+				spawnOpts.cwd as string | undefined,
+				runArgs,
+				streamId,
+			);
 		};
 
 		try {
@@ -1175,12 +1266,35 @@ export class Git {
 		command: string,
 		ex: Error | undefined,
 		duration: number,
+		/** Subprocess-only duration (excludes GitQueue wait); 0 when it never ran. */
+		execDuration: number,
 		waiting: boolean,
+		cwd: string | undefined,
+		args: readonly (string | undefined)[] | undefined,
 		id?: number,
 	): void {
 		const slow = duration > slowCallWarningThreshold;
 		const status = slow && waiting ? ' (slow, waiting)' : waiting ? ' (waiting)' : slow ? ' (slow)' : '';
 
+		// The health signal is gated on the SUBPROCESS time, not the total: time spent queued behind other
+		// git work is congestion, not repository slowness, and counting it would let a busy queue (including
+		// our own background maintenance holding slots) manufacture the evidence that recommends more
+		// maintenance. Logging keeps the total — the wait is exactly what you want to see when diagnosing.
+		//
+		// A deduplicated rider (`waiting`) shares the executed command's duration, so counting it too
+		// would double-count a single slow subprocess — fire only for the command that actually ran.
+		// Guarded: this runs inside the command's `finally`, so a hook throw would otherwise replace
+		// the command's real result/error for the caller.
+		if (execDuration > slowCallWarningThreshold && !waiting) {
+			try {
+				this.options.hooks?.onSlowCommand?.({
+					operation: args != null ? getPrimaryGitCommand(args) : undefined,
+					cwd: cwd,
+					duration: execDuration,
+				});
+			} catch {}
+		}
+
 		if (ex != null) {
 			Logger.error(
 				undefined,

package/src/git-cli/exec/gitQueue.ts

@@ -278,20 +278,8 @@ const optionsTakingValue = new Set([
 	'--list-cmds',
 ]);
 
-/**
- * Infers a queue priority from the git command being invoked.
- *
- * Intentionally narrow: only returns 'background' for commands that are
- * *always* read-only AND *always* potentially expensive. Polymorphic commands
- * like `log` and `rev-list` (which can be quick bounded lookups or full-history
- * walks) are deliberately omitted — call sites that perform heavy walks must
- * pass `priority: 'background'` explicitly. Never upgrades to 'interactive'.
- *
- * No subcommand awareness (e.g. `stash list`, `branch -l`): the risk of
- * misclassifying a write subcommand as background outweighs the gain.
- */
-export function inferGitCommandPriority(args: readonly (string | undefined)[]): GitCommandPriority {
-	let command: string | undefined;
+/** Extracts the primary git subcommand from an arg list, skipping global options and their values. */
+export function getPrimaryGitCommand(args: readonly (string | undefined)[]): string | undefined {
 	for (let i = 0; i < args.length; i++) {
 		const a = args[i];
 		if (a == null) continue;
@@ -304,11 +292,25 @@ export function inferGitCommandPriority(args: readonly (string | undefined)[]):
 		}
 		if (a.startsWith('-')) continue;
 
-		command = a;
-		break;
+		return a;
 	}
+	return undefined;
+}
 
-	switch (command) {
+/**
+ * Infers a queue priority from the git command being invoked.
+ *
+ * Intentionally narrow: only returns 'background' for commands that are
+ * *always* read-only AND *always* potentially expensive. Polymorphic commands
+ * like `log` and `rev-list` (which can be quick bounded lookups or full-history
+ * walks) are deliberately omitted — call sites that perform heavy walks must
+ * pass `priority: 'background'` explicitly. Never upgrades to 'interactive'.
+ *
+ * No subcommand awareness (e.g. `stash list`, `branch -l`): the risk of
+ * misclassifying a write subcommand as background outweighs the gain.
+ */
+export function inferGitCommandPriority(args: readonly (string | undefined)[]): GitCommandPriority {
+	switch (getPrimaryGitCommand(args)) {
 		case 'for-each-ref':
 		case 'shortlog':
 		case 'reflog':

package/src/git-cli/parsers/logParser.ts

@@ -2,7 +2,7 @@ import type { GitFileIndexStatus } from '../../git/models/fileStatus.js';
 import { diffHunkRegex, diffRegex } from '../../git/parsers/diffParser.js';
 import { joinPaths, normalizePath } from '../../utils/path.js';
 import { maybeStopWatch } from '../../utils/stopwatch.js';
-import { iterateAsyncByDelimiter, iterateByDelimiter } from '../../utils/string.js';
+import { flattenString, iterateAsyncByDelimiter, iterateByDelimiter } from '../../utils/string.js';
 import type { ExtractAll } from '../../utils/types.js';
 
 const commitsMapping = {
@@ -389,6 +389,9 @@ export function createLogParser<T extends Record<string, string>>(mapping: Extra
 	// semantics exactly: fields beyond the mapping are ignored, and every mapped field is
 	// terminated by a field separator (the format string appends one after each field).
 	function parseRecord(record: string): LogParsedEntry<T> {
+		// Fields sliced out of the record become long-lived (graph rows); flatten the record so they
+		// pin a record-sized copy rather than the full walk output the record was sliced from.
+		record = flattenString(record);
 		const entry = {} as unknown as LogParsedEntry<T>;
 		let start = 0;
 		for (const key of keys) {

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

@@ -1,5 +1,6 @@
 import { stat } from 'fs/promises';
 import type { Cache } from '../../git/cache.js';
+import { shouldEvictBlameCacheEntry } from '../../git/cache.js';
 import { BlameIgnoreRevsFileBadRevisionError, BlameIgnoreRevsFileError } from '../../git/errors.js';
 import type {
 	GitBlame,
@@ -75,8 +76,9 @@ export class BlameGitSubProvider implements GitBlameSubProvider {
 		return this.cache.blame.getOrCreate(
 			repoPath,
 			cacheKey,
-			() => this.getProgressiveBlameCore(repoPath, path, cacheKey, rev, contents, options),
+			() => this.getProgressiveBlameCore(repoPath, path, rev, contents, options),
 			{
+				evictWhen: shouldEvictBlameCacheEntry,
 				onError: ex => {
 					if (ex instanceof BlameIgnoreRevsFileError || ex instanceof BlameIgnoreRevsFileBadRevisionError) {
 						// Non-retriable — cache as undefined for 5 minutes
@@ -92,7 +94,6 @@ export class BlameGitSubProvider implements GitBlameSubProvider {
 	private async getProgressiveBlameCore(
 		repoPath: string,
 		path: string,
-		cacheKey: string,
 		rev?: string,
 		contents?: string,
 		options?: GitBlameOptions,
@@ -112,12 +113,6 @@ export class BlameGitSubProvider implements GitBlameSubProvider {
 		// Start streaming in the background
 		void this.streamBlame(writer, repoPath, path, blameOptions, user, mtime);
 
-		// If streaming fails, progressive.completed rejects. Evict the cache entry
-		// so the next call retries instead of serving the failed GitBlameProgressive.
-		void progressive.completed.catch(() => {
-			this.cache.blame.delete(repoPath, cacheKey);
-		});
-
 		return progressive;
 	}
 

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

@@ -938,13 +938,21 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 				});
 			}
 
-			throw new BranchError(
-				{
-					action: options?.force ? 'force delete' : 'delete',
-					branch: branches.join(', '),
-					gitCommand: { repoPath: repoPath, args: args },
-				},
+			// Classify the failure (e.g. not fully merged) so consumers like the delete wizard can offer a
+			// force retry — without this the reason would be undefined and every failure reads as 'other'.
+			throw getGitCommandError(
+				'branch',
 				ex,
+				reason =>
+					new BranchError(
+						{
+							reason: reason ?? 'other',
+							action: options?.force ? 'force delete' : 'delete',
+							branch: branches.join(', '),
+							gitCommand: { repoPath: repoPath, args: args },
+						},
+						ex,
+					),
 			);
 		}
 	}
@@ -1022,9 +1030,21 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 				});
 			}
 
-			throw new BranchError(
-				{ action: 'delete', branch: branches.join(', '), gitCommand: { repoPath: repoPath, args: args } },
+			// Classify against the underlying `git push -d` failure modes; map the "remote ref does not
+			// exist" case onto BranchError's noRemoteReference so consumers get an actionable reason.
+			throw getGitCommandError(
+				'push',
 				ex,
+				reason =>
+					new BranchError(
+						{
+							reason: reason === 'rejectedRefDoesNotExist' ? 'noRemoteReference' : 'other',
+							action: 'delete',
+							branch: branches.join(', '),
+							gitCommand: { repoPath: repoPath, args: args },
+						},
+						ex,
+					),
 			);
 		}
 	}

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

@@ -1383,6 +1383,12 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 			search = (await this.context.searchQuery?.preprocessQuery?.(search, options?.source)) ?? search;
 		}
 
+		// The conversion failed — `search.query` is still the raw English sentence, not a query; running
+		// it as an ERE would produce a regex error about text the user never wrote.
+		if (typeof search.naturalLanguage === 'object' && search.naturalLanguage.error) {
+			return { search: search, log: undefined };
+		}
+
 		try {
 			const cfg = this.context.config;
 			const currentUser = await this.provider.config.getCurrentUser(repoPath);
@@ -1399,6 +1405,11 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 			];
 
 			const { args: searchArgs, files, shas, filters } = parseSearchQueryGitCommand(search, currentUser);
+			// Stash commits have 2-3 parents, so `--merges` matches them; excluded in parseCommits.
+			// Derived from the args git actually runs rather than `filters.type`, since a multi-value
+			// `type:` query (e.g. `type:merge type:tip`) leaves `--merges` in the args while
+			// `filters.type` reflects only the last value parsed
+			const mergesOnly = searchArgs.includes('--merges');
 
 			let stashes: Map<string, GitStashCommit> | undefined;
 			let stdin: string | undefined;
@@ -1431,9 +1442,22 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 			} else if (!filters.refs) {
 				// Don't include stashes when using ref: filter, as they would add unrelated commits
 				// There *HAS* to be a better way to get git log to return stashes, but this is the best we've found
-				({ stdin, stashes } = convertStashesToStdin(
+				const converted = convertStashesToStdin(
+					await this.provider.stash?.getStash(repoPath, undefined, cancellation),
+				);
+				stashes = converted.stashes;
+				// `--all` already surfaces refs/stash's tip on its own, so when merges-only there's no need
+				// to walk the rest of the stash stack via stdin -- parseCommits still excludes any stash
+				// sha that slips through via refs/stash
+				stdin = mergesOnly ? undefined : converted.stdin;
+			} else if (mergesOnly) {
+				// `ref:` skips walking stashes into the results (they're unrelated to the ref), but a
+				// stash's tip can still leak in via `--merges` if the ref reaches refs/stash -- fetch
+				// stashes here purely so parseCommits can exclude them, without widening the walk via
+				// stdin
+				stashes = convertStashesToStdin(
 					await this.provider.stash?.getStash(repoPath, undefined, cancellation),
-				));
+				).stashes;
 			}
 
 			if (stdin) {
@@ -1481,6 +1505,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 				stashes,
 				currentUser,
 				filters,
+				mergesOnly,
 			);
 
 			const log: GitLog = {
@@ -1710,6 +1735,11 @@ async function parseCommits(
 	stashes: Map<string, GitStashCommit> | undefined,
 	currentUser: GitUser | undefined,
 	searchFilters?: SearchQueryFilters,
+	// Stash commits have 2-3 parents, so `--merges` matches them; excluded below. Passed in by the
+	// caller (derived from the args git actually runs) rather than re-derived from `searchFilters.type`
+	// here, since a multi-value `type:` query (e.g. `type:merge type:tip`) leaves `--merges` in the
+	// args while `searchFilters.type` reflects only the last value parsed
+	mergesOnly: boolean = false,
 ): Promise<{ commits: Map<string, GitCommit>; count: number; countStashChildCommits: number }> {
 	let count = 0;
 	let countStashChildCommits = 0;
@@ -1729,6 +1759,7 @@ async function parseCommits(
 
 			for (const c of parser.parse(result.stdout)) {
 				if (stashesOnly && !stashes?.has(c.sha)) continue;
+				if (mergesOnly && stashes?.has(c.sha)) continue;
 				if (tipsOnly && !c.tips) continue;
 
 				count++;
@@ -1781,6 +1812,7 @@ async function parseCommits(
 
 		for await (const c of parser.parseAsync(resultOrStream)) {
 			if (stashesOnly && !stashes?.has(c.sha)) continue;
+			if (mergesOnly && stashes?.has(c.sha)) continue;
 			if (tipsOnly && !c.tips) continue;
 
 			count++;

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

@@ -36,7 +36,7 @@ const gkConfigAllPattern = '.';
  * 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.
  */
-function canonicalizeGitConfigKey(key: string): string {
+export function canonicalizeGitConfigKey(key: string): string {
 	const first = key.indexOf('.');
 	if (first === -1) return key.toLowerCase();
 
@@ -50,8 +50,22 @@ function canonicalizeGitConfigKey(key: string): string {
 /**
  * Parses git config --get-regex output into a Map.
  * The output format is "key value" per line, where key and value are space-separated.
+ *
+ * A line with NO space at all is git's rendering of a bareword/valueless entry (`key`, no `=`) — git's
+ * OWN config parser reads that as boolean TRUE (git-config(1): "a variable defined without `= <value>`
+ * is taken as true"), confirmed against git's `format_config` (builtin/config.c): the key-delimiter is
+ * appended unconditionally, then backed out ONLY when the stored value is NULL (the bareword case) —
+ * an explicit empty value (`key =`) is a real, non-NULL empty string, so its line KEEPS the trailing
+ * space and is already handled by the branch below, byte-distinct from a bareword line.
+ *
+ * By default a bareword line is skipped (the historical behavior, which reads as "unset" — wrong, but
+ * safe); pass `includeValueless` to map it to the literal string `'true'` instead, so `parseGitBoolean`
+ * and callers checking `.has()` for "configured" both read it correctly.
  */
-function parseConfigRegexOutput(data: string | undefined): Map<string, string> {
+export function parseConfigRegexOutput(
+	data: string | undefined,
+	options?: { includeValueless?: boolean },
+): Map<string, string> {
 	const configMap = new Map<string, string>();
 	if (!data) return configMap;
 
@@ -59,7 +73,12 @@ function parseConfigRegexOutput(data: string | undefined): Map<string, string> {
 		if (!line) continue;
 
 		const spaceIndex = line.indexOf(' ');
-		if (spaceIndex === -1) continue;
+		if (spaceIndex === -1) {
+			if (options?.includeValueless) {
+				configMap.set(line, 'true');
+			}
+			continue;
+		}
 
 		configMap.set(line.substring(0, spaceIndex), line.substring(spaceIndex + 1));
 	}
@@ -67,13 +86,21 @@ function parseConfigRegexOutput(data: string | undefined): Map<string, string> {
 	return configMap;
 }
 
-function parseGitBoolean(value: string | undefined): boolean {
+export function parseGitBoolean(value: string | undefined): boolean {
 	if (value == null) return false;
 
 	const normalized = value.toLowerCase().trim();
 	return normalized === 'true' || normalized === 'yes' || normalized === 'on' || normalized === '1';
 }
 
+/** Whether a git config value spells boolean-false (`false`/`no`/`off`/`0`/empty), per git's maybe-bool parsing. */
+export function isGitBooleanFalse(value: string): boolean {
+	const normalized = value.toLowerCase().trim();
+	return (
+		normalized === '' || normalized === 'false' || normalized === 'no' || normalized === 'off' || normalized === '0'
+	);
+}
+
 export class ConfigGitSubProvider implements GitConfigSubProvider {
 	constructor(
 		private readonly context: GitServiceContext,
@@ -163,7 +190,10 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 			{ cwd: repoPath ?? '', errors: 'ignore', runLocally: options?.runGitLocally },
 			...args,
 		);
-		return parseConfigRegexOutput(result.stdout.trim());
+		// Deliberately NOT `.trim()`-ed: an explicit-empty value's LAST line ends in a meaningful trailing
+		// space, and `.trim()`-ing the whole (possibly multi-line) buffer strips it — `parseConfigRegexOutput`
+		// already skips the blank line a trailing newline produces, so no trim is needed.
+		return parseConfigRegexOutput(result.stdout);
 	}
 
 	@debug()
@@ -400,7 +430,9 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 		// `--get-regex` exits 1 when nothing matches, which IS an answer (an empty gk config).
 		const exited = result.completion.status === 'exited';
 		return {
-			map: parseConfigRegexOutput(result.stdout.trim()),
+			// Deliberately NOT `.trim()`-ed — see `getConfigRegexCore`'s comment: it strips the trailing
+			// space that marks an explicit-empty value's LAST line, silently dropping it from the map.
+			map: parseConfigRegexOutput(result.stdout),
 			failed: !exited || (result.exitCode !== 0 && result.exitCode !== 1),
 		};
 	}