@gitkraken/core-gitlens 0.2.0 → 0.3.0

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

@@ -1,4 +1,4 @@
-import type { Cache, ConflictDetectionCacheKey } from '../../git/cache.js';
+import type { Cache, ConflictDetectionCacheKey, GkConfigInvalidationTarget } from '../../git/cache.js';
 import type { GitServiceContext } from '../../git/context.js';
 import { BranchError } from '../../git/errors.js';
 import type { BranchDisposition, BranchMetadata } from '../../git/models/branch.js';
@@ -10,6 +10,7 @@ import type {
 	GitBranchesSubProvider,
 	GitBranchMergedStatus,
 } from '../../git/providers/branches.js';
+import type { GitCommandPriority } from '../../git/run.types.js';
 import {
 	formatDetachedHeadName,
 	getBranchId,
@@ -41,7 +42,6 @@ import type { GitResult } from '../exec/exec.types.js';
 import type { Git } from '../exec/git.js';
 import { getGitCommandError, gitConfigsBranch, gitConfigsLog, GitError, GitErrors, GitWarnings } from '../exec/git.js';
 import { parseMergeTreeConflict } from '../parsers/mergeTreeParser.js';
-import { getBranchParser } from '../parsers/refParser.js';
 
 /** Minimum time between writes to the config for last accessed/modified dates */
 const dateMetadataStaleThresholdMs = 5 * 60 * 1000; // 5 minutes
@@ -96,7 +96,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 		const [pausedOpStatusResult, committerDateResult, defaultWorktreePathResult, metadataMapResult] =
 			await Promise.allSettled([
 				isDetachedHead(ref.name)
-					? this.provider.pausedOps?.getPausedOperationStatus(repoPath, cancellation)
+					? this.provider.pausedOps?.getPausedOperationStatus(repoPath, undefined, cancellation)
 					: undefined,
 				this.git
 					.run(
@@ -168,27 +168,22 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 			// own cancellation when bypassing the cache (e.g. paging-cursor path).
 			signal ??= cancellation;
 			try {
-				const supported = await this.git.supported('git:for-each-ref');
-				const parser = getBranchParser(supported);
-
-				const [gitResult, defaultWorktreePathResult, metadataMapResult] = await Promise.allSettled([
-					this.git.run(
-						{ cwd: commonPath, cancellation: signal },
-						'for-each-ref',
-						...parser.arguments,
-						'refs/heads/',
-						'refs/remotes/',
-					),
-					this.provider.config.getDefaultWorktreePath?.(commonPath),
-					this.getBranchMetadataMap(commonPath),
-				]);
-
-				const result = getSettledValue(gitResult);
+				const [recordsResult, supportedResult, defaultWorktreePathResult, metadataMapResult] =
+					await Promise.allSettled([
+						this.provider.refs.getRefs(commonPath, signal),
+						this.git.supported('git:for-each-ref'),
+						this.provider.config.getDefaultWorktreePath?.(commonPath),
+						this.getBranchMetadataMap(commonPath),
+					]);
+
+				const records = getSettledValue(recordsResult) ?? [];
+				const supported = getSettledValue(supportedResult) ?? [];
 				const metadataMap = getSettledValue(metadataMapResult) ?? new Map<string, BranchMetadata>();
 				const defaultWorktreePath = getSettledValue(defaultWorktreePathResult);
+				const worktreePathSupported = supported.includes('git:for-each-ref:worktreePath');
 
 				// If we don't get any data, assume the repo doesn't have any commits yet so check if we have a current branch
-				if (!result?.stdout) {
+				if (!records.length) {
 					const current = await this.getCurrentBranch(
 						commonPath,
 						metadataMap,
@@ -202,25 +197,28 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 
 				const branches: GitBranch[] = [];
 
-				for (const entry of parser.parse(result.stdout)) {
+				for (const record of records) {
+					const fullName = record.name;
+					// Filter to branches and remote-tracking branches; skip tags from the unified records.
+					if (!fullName.startsWith('refs/heads/') && !fullName.startsWith('refs/remotes/')) continue;
 					// Skip HEAD refs in remote branches
-					if (isRemoteHEAD(entry.name)) continue;
+					if (isRemoteHEAD(fullName)) continue;
 
-					const upstream = parseUpstream(entry.upstream, entry.upstreamTracking);
+					const upstream = parseUpstream(record.upstream, record.upstreamTracking);
 
-					const metadata = metadataMap.get(parseRefName(entry.name).name);
-					const worktreePath = entry.worktreePath ? normalizePath(entry.worktreePath) : undefined;
+					const metadata = metadataMap.get(parseRefName(fullName).name);
+					const worktreePath = record.worktreePath ? normalizePath(record.worktreePath) : undefined;
 
 					branches.push(
 						new GitBranch(
 							commonPath,
-							entry.name,
+							fullName,
 							false, // Don't trust %(HEAD) for current as it's per-worktree -- we will set it later
-							entry.date ? new Date(entry.date) : undefined,
+							record.committerDate ? new Date(record.committerDate) : undefined,
 							metadata,
-							entry.sha,
+							record.objectname,
 							upstream,
-							supported.includes('git:for-each-ref:worktreePath')
+							worktreePathSupported
 								? worktreePath
 									? { path: worktreePath, isDefault: worktreePath === defaultWorktreePath }
 									: false
@@ -360,46 +358,23 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 	async getBranchContributionsOverview(
 		repoPath: string,
 		ref: string,
-		options?: { associatedPullRequest?: Promise<{ refs?: { base?: { branch: string } } } | undefined> },
+		options?: {
+			associatedPullRequest?: Promise<{ refs?: { base?: { branch: string } } } | undefined>;
+			priority?: GitCommandPriority;
+		},
 		cancellation?: AbortSignal,
 	): Promise<BranchContributionsOverview | undefined> {
 		const scope = getScopedLogger();
+		const priority = options?.priority;
+		const priorityOpts = priority != null ? { priority: priority } : undefined;
 
-		const getCore = async (
-			_commonPath: string,
-			_cacheable: CacheController | undefined,
+		// Expensive body — runs only on cache miss. Closes over `mergeTarget` so the cache key
+		// (`${ref}|${mergeTarget}`) fully captures every input that affects the result.
+		const fetchBody = async (
+			mergeTarget: string,
 			signal: AbortSignal | undefined,
-			storedTarget: string | undefined,
 		): Promise<BranchContributionsOverview | undefined> => {
-			let mergeTarget: string | undefined;
-
-			// Tier 1: Stored merge target (user-set or previously detected from PR). Caller has
-			// already read this once for the cache decision; reuse rather than re-fetching.
-			if (storedTarget) {
-				const validated = await this.provider.refs.getSymbolicReferenceName(repoPath, storedTarget);
-				mergeTarget = validated || storedTarget;
-			}
-
-			// Tier 2: PR-based lookup. The branch object is only needed here (for `remoteName`),
-			// so lazy-load it on the cold path instead of paying for it on every call.
-			if (mergeTarget == null && options?.associatedPullRequest != null) {
-				const pr = await options.associatedPullRequest;
-				if (pr?.refs?.base != null) {
-					const branch = await this.getBranch(repoPath, ref, signal);
-					if (branch == null) return undefined;
-					mergeTarget = `${branch.remoteName}/${pr.refs.base.branch}`;
-					// Store for future reuse — turns the next call into a Tier 1 cache-eligible path.
-					void this.storeMergeTargetBranchName(repoPath, ref, mergeTarget);
-				}
-			}
-
-			// Tier 3: Base branch, then default branch
-			mergeTarget ??= await this.getBaseBranchName(repoPath, ref, signal);
-			mergeTarget ??= await this.getDefaultBranchName(repoPath, undefined, signal);
-
-			if (mergeTarget == null) return undefined;
-
-			const mergeBase = await this.provider.refs.getMergeBase(repoPath, ref, mergeTarget, undefined, signal);
+			const mergeBase = await this.provider.refs.getMergeBase(repoPath, ref, mergeTarget, priorityOpts, signal);
 			if (mergeBase == null) return undefined;
 
 			// Fetch the merge-base commit's dates in parallel with contributors so consumers
@@ -471,20 +446,61 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 		};
 
 		try {
-			// Pre-check Tier 1: when a stored merge target exists the result is deterministic for
-			// `ref` (Tier 2's PR resolution is short-circuited), so it's safe to cache. Otherwise
-			// the result depends on PR resolution which the cache key can't capture — bypass.
+			// Resolve `mergeTarget` through Tier 1 → Tier 2 → Tier 3. The pieces of each tier are
+			// already individually cached (`getStoredMergeTargetBranchName`, `getBaseBranchName`,
+			// `getDefaultBranchName`), so this resolution path is cheap on warm caches. Only the
+			// expensive body below (`getMergeBase` + `getContributors` w/ stats + `getCommitDates`)
+			// is wrapped by `cache.getBranchOverview`, keyed on the resolved `mergeTarget` so any
+			// caller that resolves to the same target shares; differing targets get independent
+			// slots, which is the correctness constraint that previously forced the Tier 2/3 paths
+			// to bypass the cache entirely.
+			let mergeTarget: string | undefined;
+
+			// Tier 1: Stored merge target (user-set or previously detected from PR).
 			const storedTarget = await this.getStoredMergeTargetBranchName(repoPath, ref);
-			if (storedTarget != null) {
-				return await this.cache.getBranchOverview(
+			if (storedTarget) {
+				const validated = await this.provider.refs.getSymbolicReferenceName(
 					repoPath,
-					ref,
-					(commonPath, cacheable, signal) =>
-						getCore(commonPath, cacheable, signal ?? cancellation, storedTarget),
-					{ cancellation: cancellation },
+					storedTarget,
+					priorityOpts,
+					cancellation,
 				);
+				mergeTarget = validated || storedTarget;
+			}
+
+			// Tier 2: PR-based lookup. The branch object is only needed here (for `remoteName`),
+			// so lazy-load it on the cold path instead of paying for it on every call.
+			if (mergeTarget == null && options?.associatedPullRequest != null) {
+				const pr = await options.associatedPullRequest;
+				if (pr?.refs?.base != null) {
+					const branch = await this.getBranch(repoPath, ref, cancellation);
+					if (branch == null) return undefined;
+
+					mergeTarget = `${branch.remoteName}/${pr.refs.base.branch}`;
+					// Store for future reuse — turns the next call into a Tier 1 path. Skip the
+					// `branchOverviews` invalidation that the write would otherwise trigger: we're
+					// about to populate `${ref}|${mergeTarget}` with this exact target, so evicting
+					// it would just force the next caller to redo the body. (gk-merge-target writes
+					// do not affect `baseBranchName`, so no need to skip that target.)
+					void this.storeMergeTargetBranchName(repoPath, ref, mergeTarget, {
+						skipInvalidation: ['branchOverviews'],
+					});
+				}
 			}
-			return await getCore(repoPath, undefined, cancellation, undefined);
+
+			// Tier 3: Base branch, then default branch.
+			mergeTarget ??= await this.getBaseBranchName(repoPath, ref, priorityOpts, cancellation);
+			mergeTarget ??= await this.getDefaultBranchName(repoPath, undefined, priorityOpts, cancellation);
+
+			if (mergeTarget == null) return undefined;
+
+			const resolvedTarget = mergeTarget;
+			return await this.cache.getBranchOverview(
+				repoPath,
+				`${ref}|${resolvedTarget}`,
+				(_commonPath, _cacheable, signal) => fetchBody(resolvedTarget, signal ?? cancellation),
+				{ cancellation: cancellation },
+			);
 		} catch (ex) {
 			scope?.error(ex);
 			if (isCancellationError(ex)) throw ex;
@@ -624,7 +640,12 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 							}
 
 							if (data == null) {
-								const symbolicRef = await this.getDefaultBranchName(repoPath, 'origin', signal);
+								const symbolicRef = await this.getDefaultBranchName(
+									repoPath,
+									'origin',
+									undefined,
+									signal,
+								);
 								if (symbolicRef != null) {
 									data = [
 										symbolicRef.startsWith('origin/')
@@ -705,18 +726,21 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 	async getDefaultBranchName(
 		repoPath: string | undefined,
 		remote?: string,
+		options?: { priority?: GitCommandPriority },
 		cancellation?: AbortSignal,
 	): Promise<string | undefined> {
 		if (repoPath == null) return undefined;
 
 		remote ??= 'origin';
+		const priority = options?.priority;
+		const priorityOpts = priority != null ? { priority: priority } : undefined;
 
 		return this.cache.getDefaultBranchName(repoPath, remote, async commonPath => {
 			let retried = false;
 			while (true) {
 				try {
 					const result = await this.git.run(
-						{ cwd: commonPath, cancellation: cancellation },
+						{ cwd: commonPath, cancellation: cancellation, ...priorityOpts },
 						'symbolic-ref',
 						'--short',
 						`refs/remotes/${remote}/HEAD`,
@@ -728,7 +752,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 							if (!retried) {
 								retried = true;
 								await this.git.run(
-									{ cwd: commonPath, cancellation: cancellation },
+									{ cwd: commonPath, cancellation: cancellation, ...priorityOpts },
 									'remote',
 									'set-head',
 									'-a',
@@ -738,7 +762,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 							}
 
 							const result = await this.git.run(
-								{ cwd: commonPath, cancellation: cancellation },
+								{ cwd: commonPath, cancellation: cancellation, ...priorityOpts },
 								'ls-remote',
 								'--symref',
 								remote,
@@ -1156,6 +1180,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 			currentTreeOid = treeResult.stdout.trim();
 		} catch (ex) {
 			if (isCancellationError(ex)) throw ex;
+
 			scope?.error(ex, `Failed to resolve target branch '${targetBranch}'`);
 			return createConflictDetectionError('refNotFound');
 		}
@@ -1263,7 +1288,15 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 	}
 
 	@debug({ exit: true })
-	getBaseBranchName(repoPath: string, ref: string, cancellation?: AbortSignal): Promise<string | undefined> {
+	getBaseBranchName(
+		repoPath: string,
+		ref: string,
+		options?: { priority?: GitCommandPriority },
+		cancellation?: AbortSignal,
+	): Promise<string | undefined> {
+		const priority = options?.priority;
+		const priorityOpts = priority != null ? { priority: priority } : undefined;
+
 		return this.cache.getBaseBranchName(
 			repoPath,
 			ref,
@@ -1280,19 +1313,36 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 					}
 
 					if (mergeBase != null) {
-						const branch = await this.provider.refs.getSymbolicReferenceName(commonPath, mergeBase);
+						const branch = await this.provider.refs.getSymbolicReferenceName(
+							commonPath,
+							mergeBase,
+							priorityOpts,
+						);
 						if (branch != null) {
 							if (update) {
-								void this.storeBaseBranchName(commonPath, ref, branch);
+								// Self-write: the value we're storing is exactly what this factory is
+								// returning, so any in-flight `branchOverviews` or `baseBranchName` entry
+								// being populated against this resolution should NOT be evicted.
+								void this.storeBaseBranchName(commonPath, ref, branch, {
+									skipInvalidation: ['branchOverviews', 'baseBranchName'],
+								});
 							}
 							return branch;
 						}
 					}
 				} catch {}
 
-				const branch = await this.getBaseBranchFromReflog(commonPath, ref, { upstream: true }, signal);
+				const branch = await this.getBaseBranchFromReflog(
+					commonPath,
+					ref,
+					{ upstream: true, priority: priority },
+					signal,
+				);
 				if (branch != null) {
-					void this.storeBaseBranchName(commonPath, ref, branch);
+					// Self-write: see comment on the migration path above.
+					void this.storeBaseBranchName(commonPath, ref, branch, {
+						skipInvalidation: ['branchOverviews', 'baseBranchName'],
+					});
 					return branch;
 				}
 
@@ -1305,12 +1355,15 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 	private async getBaseBranchFromReflog(
 		repoPath: string,
 		ref: string,
-		options?: { upstream: true },
+		options?: { upstream: true; priority?: GitCommandPriority },
 		cancellation?: AbortSignal,
 	): Promise<string | undefined> {
+		const priority = options?.priority;
+		const priorityOpts = priority != null ? { priority: priority } : undefined;
+
 		try {
 			let result = await this.git.run(
-				{ cwd: repoPath, cancellation: cancellation },
+				{ cwd: repoPath, cancellation: cancellation, ...priorityOpts },
 				'reflog',
 				ref,
 				'--grep-reflog=branch: Created from *.',
@@ -1325,18 +1378,22 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 				let name: string | undefined = match[1];
 				if (name !== 'HEAD') {
 					if (options?.upstream) {
-						const upstream = await this.provider.refs.getSymbolicReferenceName(repoPath, `${name}@{u}`);
+						const upstream = await this.provider.refs.getSymbolicReferenceName(
+							repoPath,
+							`${name}@{u}`,
+							priorityOpts,
+						);
 						if (upstream) return upstream;
 					}
 
-					name = await this.provider.refs.getSymbolicReferenceName(repoPath, name);
+					name = await this.provider.refs.getSymbolicReferenceName(repoPath, name, priorityOpts);
 					if (name) return name;
 				}
 			}
 
 			// Check if branch was created from HEAD
 			result = await this.git.run(
-				{ cwd: repoPath, cancellation: cancellation },
+				{ cwd: repoPath, cancellation: cancellation, ...priorityOpts },
 				'reflog',
 				'HEAD',
 				`--grep-reflog=checkout: moving from .* to ${ref.replace('refs/heads/', '')}`,
@@ -1349,11 +1406,15 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 			if (match?.length === 2) {
 				let name: string | undefined = match[1];
 				if (options?.upstream) {
-					const upstream = await this.provider.refs.getSymbolicReferenceName(repoPath, `${name}@{u}`);
+					const upstream = await this.provider.refs.getSymbolicReferenceName(
+						repoPath,
+						`${name}@{u}`,
+						priorityOpts,
+					);
 					if (upstream) return upstream;
 				}
 
-				name = await this.provider.refs.getSymbolicReferenceName(repoPath, name);
+				name = await this.provider.refs.getSymbolicReferenceName(repoPath, name, priorityOpts);
 				if (name) return name;
 			}
 		} catch (ex) {
@@ -1469,13 +1530,23 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 	}
 
 	@debug()
-	async storeBaseBranchName(repoPath: string, ref: string, base: string): Promise<void> {
-		await this.provider.config.setGkConfig(repoPath, `branch.${ref}.gk-merge-base`, base);
+	async storeBaseBranchName(
+		repoPath: string,
+		ref: string,
+		base: string,
+		options?: { skipInvalidation?: readonly GkConfigInvalidationTarget[] },
+	): Promise<void> {
+		await this.provider.config.setGkConfig(repoPath, `branch.${ref}.gk-merge-base`, base, options);
 	}
 
 	@debug()
-	async storeMergeTargetBranchName(repoPath: string, ref: string, target: string): Promise<void> {
-		await this.provider.config.setGkConfig(repoPath, `branch.${ref}.gk-merge-target`, target);
+	async storeMergeTargetBranchName(
+		repoPath: string,
+		ref: string,
+		target: string,
+		options?: { skipInvalidation?: readonly GkConfigInvalidationTarget[] },
+	): Promise<void> {
+		await this.provider.config.setGkConfig(repoPath, `branch.${ref}.gk-merge-target`, target, options);
 	}
 
 	@debug()

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

@@ -41,7 +41,7 @@ import { escapeRegex } from '../../utils/string.js';
 import type { Uri } from '../../utils/uri.js';
 import { fileUri, joinUriPath, toFsPath } from '../../utils/uri.js';
 import type { CliGitProviderInternal } from '../cliGitProvider.js';
-import type { GitExecOptions, GitResult } from '../exec/exec.types.js';
+import type { GitResult, GitRunOptions } from '../exec/exec.types.js';
 import type { Git } from '../exec/git.js';
 import { gitConfigsLog, gitConfigsLogWithFiles, GitErrors } from '../exec/git.js';
 import type {
@@ -172,9 +172,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 	async getCommitFiles(repoPath: string, rev: string, cancellation?: AbortSignal): Promise<GitFileChange[]> {
 		const parser = getShaAndFilesAndStatsLogParser();
 		const result = await this.git.run(
-			// Single-commit log is cheap and almost always serves a user-initiated read; override
-			// the inferred 'background' priority so it doesn't queue behind heavier graph/log work.
-			{ cwd: repoPath, cancellation: cancellation, configs: gitConfigsLog, priority: 'normal' },
+			{ cwd: repoPath, cancellation: cancellation, configs: gitConfigsLog },
 			'log',
 			...parser.arguments,
 			'-n1',
@@ -354,7 +352,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 
 		try {
 			const result = await this.git.run(
-				{ cwd: repoPath, cancellation: cancellation, configs: gitConfigsLog },
+				{ cwd: repoPath, cancellation: cancellation, configs: gitConfigsLog, priority: 'background' },
 				'log',
 				...args,
 			);
@@ -479,7 +477,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 		// Cache key: range + excludeMerges. RepositoryChange events affecting branches/remotes
 		// invalidate this cache via clearCaches('branches').
 		const cacheKey = `${range}\x1f${options?.excludeMerges ? 'no-merges' : ''}`;
-		return this.cache.getLeftRightCommitCount(repoPath, cacheKey, run);
+		return this.cache.leftRightCommitCount.getOrCreate(repoPath, cacheKey, run);
 	}
 
 	@debug()
@@ -573,24 +571,15 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 				args.push(`-n${isSingleCommit ? 1 : limit + 1}`);
 			}
 
-			let stashes: Map<string, GitStashCommit> | undefined;
-			let stdin: string | undefined;
-
-			if (!isSingleCommit) {
-				if (options?.stashes) {
-					// 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(
-						typeof options.stashes === 'boolean'
-							? await this.provider.stash?.getStash(repoPath, { reachableFrom: rev }, cancellation)
-							: options.stashes,
-					));
-					if (stashes.size) {
-						rev ??= 'HEAD';
-					}
-				}
+			let stashes: ReadonlyMap<string, GitStashCommit> | undefined;
 
-				if (stdin) {
-					args.push('--stdin');
+			if (!isSingleCommit && options?.stashes) {
+				stashes =
+					typeof options.stashes === 'boolean'
+						? (await this.provider.stash?.getStash(repoPath, { reachableFrom: rev }, cancellation))?.stashes
+						: options.stashes;
+				if (stashes?.size) {
+					rev ??= 'HEAD';
 				}
 			}
 
@@ -628,24 +617,30 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 			const currentUser = await currentUserPromise.catch(() => undefined);
 			if (cancellation?.aborted) throw new CancellationError();
 
-			const cmdOpts: GitExecOptions = {
+			const cmdOpts: GitRunOptions = {
 				cwd: repoPath,
 				cancellation: cancellation,
 				configs: gitConfigsLogWithFiles,
-				stdin: stdin,
-				// Single-commit log is cheap (typically <50ms) and almost always serves a user-
-				// initiated read (commit details, hover, etc.). Override the inferred 'background'
-				// priority so it doesn't queue behind heavier graph/log work — without this, a click
-				// on a commit while the graph is still loading can wait seconds for files to appear.
-				...(isSingleCommit ? { priority: 'normal' as const } : undefined),
+				// Single-commit log serves user-initiated reads (commit details, hover, etc.).
+				// Mirrors getCommitDates: full SHAs are immutable so a 5-min TTL is safe; non-SHA refs
+				// rely on gitResults being cleared on head/heads/remotes events (60s is the failsafe
+				// for watcher latency / web with no fs watcher).
+				...(isSingleCommit && rev
+					? {
+							caching: {
+								cache: this.cache.gitResults,
+								options: { accessTTL: isSha(rev) ? 5 * 60 * 1000 : 60 * 1000 },
+							},
+						}
+					: undefined),
 			};
-			let { commits, count, countStashChildCommits } = await parseCommits(
+			let { commits, count } = await parseCommits(
 				parser,
 				isSingleCommit ? this.git.run(cmdOpts, ...args) : this.git.stream(cmdOpts, ...args),
 				repoPath,
 				pathspec,
 				limit,
-				stashes,
+				undefined,
 				currentUser,
 			);
 
@@ -667,25 +662,67 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 						args.splice(args.length - 1, 1, pathspec);
 					}
 
-					({ commits, count, countStashChildCommits } = await parseCommits(
+					({ commits, count } = await parseCommits(
 						parser,
 						isSingleCommit ? this.git.run(cmdOpts, ...args) : this.git.stream(cmdOpts, ...args),
 						repoPath,
 						pathspec,
 						limit,
-						stashes,
+						undefined,
 						currentUser,
 					));
 				}
 			}
 
+			// Merge stashes in-memory rather than via `git log --stdin <stash>` — git would
+			// walk each stash's parent chains and pull in pre-rebase ancestors that aren't
+			// reachable from <rev>. Slot each stash directly above its first parent; stashes
+			// whose parent isn't in the result (rebased away, or below the current limit) are
+			// dropped — the Stashes view still surfaces them, and they reappear here if the
+			// parent loads via "Load more".
+			if (stashes?.size) {
+				// `stashes` arrives in `git stash list` order (newest @{0} first), so per-parent
+				// groups naturally land newest-first without an explicit sort
+				const stashesByParent = new Map<string, GitStashCommit[]>();
+				for (const stash of stashes.values()) {
+					const parentSha = stash.parents[0];
+					if (parentSha == null || !commits.has(parentSha)) continue;
+
+					const group = stashesByParent.get(parentSha);
+					if (group != null) {
+						group.push(stash);
+					} else {
+						stashesByParent.set(parentSha, [stash]);
+					}
+				}
+
+				if (stashesByParent.size) {
+					const cap = limit > 0 ? limit + 1 : Number.POSITIVE_INFINITY;
+					const merged = new Map<string, GitCommit>();
+					outer: for (const c of commits.values()) {
+						const group = stashesByParent.get(c.sha);
+						if (group != null) {
+							for (const s of group) {
+								if (merged.size >= cap) break outer;
+
+								merged.set(s.sha, s);
+							}
+						}
+						if (merged.size >= cap) break;
+
+						merged.set(c.sha, c);
+					}
+					commits = merged;
+				}
+			}
+
 			const log: GitLog = {
 				repoPath: repoPath,
 				commits: commits,
 				sha: isRevisionRange(rev) ? undefined : rev,
 				count: commits.size,
 				limit: limit,
-				hasMore: overrideHasMore ?? count - countStashChildCommits > commits.size,
+				hasMore: overrideHasMore ?? (limit > 0 && count > limit),
 			};
 
 			if (!isSingleCommit) {
@@ -950,6 +987,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 							filterMap<[string, GitCommit], [string, GitCommit]>(log.commits.entries(), ([sha, c]) => {
 								if (skip) {
 									if (sha !== rev) return undefined;
+
 									skip = false;
 								}
 
@@ -1120,6 +1158,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 			} catch (ex) {
 				scope?.error(ex);
 				if (isCancellationError(ex)) throw ex;
+
 				debugger;
 
 				return [];
@@ -1167,6 +1206,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 		} catch (ex) {
 			scope?.error(ex);
 			if (isCancellationError(ex)) throw ex;
+
 			debugger;
 
 			return undefined;
@@ -1367,7 +1407,10 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 				{
 					cwd: repoPath,
 					errors: 'ignore',
-					caching: { cache: this.cache.gitResults, options: { accessTTL: 60 * 1000 } },
+					caching: {
+						cache: this.cache.gitResults,
+						options: { accessTTL: isSha(sha) ? 5 * 60 * 1000 : 60 * 1000 },
+					},
 					configs: gitConfigsLog,
 				},
 				'log',
@@ -1394,7 +1437,10 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 				{
 					cwd: repoPath,
 					errors: 'ignore',
-					caching: { cache: this.cache.gitResults, options: { accessTTL: 60 * 1000 } },
+					caching: {
+						cache: this.cache.gitResults,
+						options: { accessTTL: isSha(sha) ? 5 * 60 * 1000 : 60 * 1000 },
+					},
 				},
 				'cat-file',
 				'commit',