@gitkraken/core-gitlens 0.1.0 → 0.2.0

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

@@ -6,7 +6,7 @@ import { deletedOrMissing } from '../../git/models/revision.js';
 import type { GitTag } from '../../git/models/tag.js';
 import type { GitRefsSubProvider } from '../../git/providers/refs.js';
 import { createReference } from '../../git/utils/reference.utils.js';
-import { isShaWithOptionalRevisionSuffix, isUncommitted } from '../../git/utils/revision.utils.js';
+import { isSha, isShaWithOptionalRevisionSuffix, isUncommitted } from '../../git/utils/revision.utils.js';
 import { isCancellationError } from '../../utils/cancellation.js';
 import { debug, trace } from '../../utils/decorators/log.js';
 import { getScopedLogger } from '../../utils/logger.scoped.js';
@@ -26,7 +26,7 @@ export class RefsGitSubProvider implements GitRefsSubProvider {
 	@debug()
 	async checkIfCouldBeValidBranchOrTagName(repoPath: string, ref: string): Promise<boolean> {
 		try {
-			const result = await this.git.exec({ cwd: repoPath, errors: 'throw' }, 'check-ref-format', '--branch', ref);
+			const result = await this.git.run({ cwd: repoPath, errors: 'throw' }, 'check-ref-format', '--branch', ref);
 			return Boolean(result.stdout.trim());
 		} catch {
 			return false;
@@ -44,10 +44,13 @@ export class RefsGitSubProvider implements GitRefsSubProvider {
 		const scope = getScopedLogger();
 
 		try {
-			const result = await this.git.exec(
+			const result = await this.git.run(
 				{
 					cwd: repoPath,
 					cancellation: cancellation,
+					// Why: ref1/ref2 are usually branch names; correctness relies on the gitResults cache being
+					// cleared on 'heads'/'remotes' events when refs move. Web (no fs watcher) sees up to
+					// `accessTTL` of staleness — acceptable trade-off for the perf win on graph/branch reads.
 					caching: { cache: this.cache.gitResults, options: { accessTTL: 5 * 60 * 1000 } },
 				},
 				'merge-base',
@@ -105,8 +108,16 @@ export class RefsGitSubProvider implements GitRefsSubProvider {
 	): Promise<string | undefined> {
 		const supportsEndOfOptions = await this.git.supports('git:rev-parse:end-of-options');
 
-		const result = await this.git.exec(
-			{ cwd: repoPath, cancellation: cancellation, errors: 'ignore' },
+		const result = await this.git.run(
+			{
+				cwd: repoPath,
+				cancellation: cancellation,
+				errors: 'ignore',
+				// Why: a fixed ref name's symbolic name is itself stable; only HEAD is mutable, and the
+				// gitResults cache is cleared on 'head' events. 60s TTL is the failsafe for watcher
+				// latency / web — matches the other "resolve symbolic state" calls in commits.ts.
+				caching: { cache: this.cache.gitResults, options: { accessTTL: 60 * 1000 } },
+			},
 			'rev-parse',
 			'--verify',
 			'--quiet',
@@ -164,12 +175,20 @@ export class RefsGitSubProvider implements GitRefsSubProvider {
 
 		const supportsEndOfOptions = await this.git.supports('git:rev-parse:end-of-options');
 
-		const result = await this.git.exec(
+		// Why: a SHA-only validation (no path suffix) is effectively immutable — 5-min TTL is safe.
+		// Otherwise the resolved SHA can shift on ref move (or working-tree change for path-scoped
+		// validation); rely on gitResults being cleared on 'head'/'heads'/'remotes' events, with 60s
+		// TTL as the failsafe for watcher latency / web.
+		const stable = relativePath == null && isSha(ref);
+		const result = await this.git.run(
 			{
 				cwd: repoPath,
 				cancellation: cancellation,
 				errors: 'ignore',
-				caching: { cache: this.cache.gitResults, options: { accessTTL: 5 * 60 * 1000 } },
+				caching: {
+					cache: this.cache.gitResults,
+					options: { accessTTL: stable ? 5 * 60 * 1000 : 60 * 1000 },
+				},
 			},
 			'rev-parse',
 			'--verify',
@@ -184,7 +203,7 @@ export class RefsGitSubProvider implements GitRefsSubProvider {
 		const scope = getScopedLogger();
 
 		try {
-			await this.git.exec({ cwd: repoPath, cancellation: cancellation }, 'update-ref', ref, newRef);
+			await this.git.run({ cwd: repoPath, cancellation: cancellation }, 'update-ref', ref, newRef);
 		} catch (ex) {
 			scope?.error(ex);
 			if (isCancellationError(ex)) throw ex;

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

@@ -41,7 +41,7 @@ export class RemotesGitSubProvider extends RemotesGitProviderBase implements Git
 				const remoteProviderMatcher = createRemoteProviderMatcher(configs, this.context.remotes);
 
 				try {
-					const result = await this.git.exec(
+					const result = await this.git.run(
 						{
 							cwd: repoPath,
 							cancellation: signal,
@@ -79,7 +79,7 @@ export class RemotesGitSubProvider extends RemotesGitProviderBase implements Git
 	@gate()
 	@debug()
 	async addRemote(repoPath: string, name: string, url: string, options?: { fetch?: boolean }): Promise<void> {
-		await this.git.exec({ cwd: repoPath }, 'remote', 'add', options?.fetch ? '-f' : undefined, name, url);
+		await this.git.run({ cwd: repoPath }, 'remote', 'add', options?.fetch ? '-f' : undefined, name, url);
 		this.context.hooks?.cache?.onReset?.(repoPath, 'remotes');
 		this.context.hooks?.repository?.onChanged?.(repoPath, ['remotes']);
 	}
@@ -100,7 +100,7 @@ export class RemotesGitSubProvider extends RemotesGitProviderBase implements Git
 	@gate()
 	@debug()
 	async pruneRemote(repoPath: string, name: string): Promise<void> {
-		await this.git.exec({ cwd: repoPath }, 'remote', 'prune', name);
+		await this.git.run({ cwd: repoPath }, 'remote', 'prune', name);
 		this.context.hooks?.cache?.onReset?.(repoPath, 'remotes', 'branches');
 		this.context.hooks?.repository?.onChanged?.(repoPath, ['remotes']);
 	}
@@ -108,7 +108,7 @@ export class RemotesGitSubProvider extends RemotesGitProviderBase implements Git
 	@gate()
 	@debug()
 	async removeRemote(repoPath: string, name: string): Promise<void> {
-		await this.git.exec({ cwd: repoPath }, 'remote', 'remove', name);
+		await this.git.run({ cwd: repoPath }, 'remote', 'remove', name);
 		this.context.hooks?.cache?.onReset?.(repoPath, 'remotes');
 		this.context.hooks?.repository?.onChanged?.(repoPath, ['remotes']);
 	}

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

@@ -36,16 +36,20 @@ export class RevisionGitSubProvider implements GitRevisionSubProvider {
 		private readonly provider: CliGitProviderInternal,
 	) {}
 
-	exists(repoPath: string, path: string, revOrOptions?: string | { untracked?: boolean }): Promise<boolean> {
+	exists(
+		repoPath: string,
+		path: string,
+		revOrOptions?: string | { untracked?: 'only' | 'include' },
+	): Promise<boolean> {
 		let rev: string | undefined;
-		let untracked: boolean | undefined;
+		let untracked: 'only' | 'include' | undefined;
 		if (typeof revOrOptions === 'string') {
 			rev = revOrOptions;
 		} else if (revOrOptions != null) {
 			untracked = revOrOptions.untracked;
 		}
 
-		const cacheKey = `${path}\0${rev ?? ''}\0${untracked ? 'u' : ''}`;
+		const cacheKey = `${path}\0${rev ?? ''}\0${untracked ?? ''}`;
 		return this.cache.fileExistence.getOrCreate(repoPath, cacheKey, async () => {
 			const args = ['ls-files'];
 			if (rev) {
@@ -54,11 +58,14 @@ export class RevisionGitSubProvider implements GitRevisionSubProvider {
 				} else if (isUncommittedStaged(rev)) {
 					args.push('--stage');
 				}
-			} else if (untracked) {
+			} else if (untracked === 'only') {
 				args.push('-o');
+			} else if (untracked === 'include') {
+				// Tracked (cached) OR untracked (others)
+				args.push('-c', '-o');
 			}
 
-			const result = await this.git.exec({ cwd: repoPath, errors: 'ignore' }, ...args, '--', path);
+			const result = await this.git.run({ cwd: repoPath, errors: 'ignore' }, ...args, '--', path);
 			return Boolean(result.stdout.trim());
 		});
 	}
@@ -79,7 +86,7 @@ export class RevisionGitSubProvider implements GitRevisionSubProvider {
 		const [relativePath, root] = splitPath(submodulePath, repoPath);
 		const submoduleFullPath = this.provider.getAbsoluteUri(relativePath, root).fsPath;
 
-		const result = await this.git.exec({ cwd: submoduleFullPath, errors: 'ignore' }, 'rev-parse', 'HEAD');
+		const result = await this.git.run({ cwd: submoduleFullPath, errors: 'ignore' }, 'rev-parse', 'HEAD');
 		const sha = result.stdout.trim();
 		return sha || undefined;
 	}
@@ -92,7 +99,7 @@ export class RevisionGitSubProvider implements GitRevisionSubProvider {
 		const [relativePath, root] = splitPath(path, repoPath);
 
 		if (isUncommittedStaged(rev)) {
-			let result = await this.git.exec(
+			let result = await this.git.run(
 				{ cwd: root, errors: 'ignore' },
 				'ls-files',
 				'-z',
@@ -105,7 +112,7 @@ export class RevisionGitSubProvider implements GitRevisionSubProvider {
 			if (entries.length === 0) return undefined;
 
 			const entry = entries[0];
-			result = await this.git.exec({ cwd: root }, 'cat-file', '-s', entry.oid);
+			result = await this.git.run({ cwd: root }, 'cat-file', '-s', entry.oid);
 			const size = parseInt(result.stdout.trim(), 10) || 0;
 
 			return { ref: rev, oid: entry.oid, path: relativePath, size: size, type: 'blob' };
@@ -119,7 +126,7 @@ export class RevisionGitSubProvider implements GitRevisionSubProvider {
 	async getTrackedFiles(repoPath: string): Promise<string[]> {
 		if (!repoPath) return [];
 
-		const result = await this.git.exec({ cwd: repoPath, errors: 'ignore' }, 'ls-files', '-z');
+		const result = await this.git.run({ cwd: repoPath, errors: 'ignore' }, 'ls-files', '-z');
 		const data = result.stdout;
 		if (!data) return [];
 
@@ -135,7 +142,7 @@ export class RevisionGitSubProvider implements GitRevisionSubProvider {
 	private async getTreeForRevisionCore(repoPath: string, rev: string, path?: string): Promise<GitTreeEntry[]> {
 		const hasPath = Boolean(path);
 		const args = hasPath ? ['ls-tree', '-l', rev, '--', path] : ['ls-tree', '-lrt', rev, '--'];
-		const result = await this.git.exec({ cwd: repoPath, errors: 'ignore' }, ...args);
+		const result = await this.git.run({ cwd: repoPath, errors: 'ignore' }, ...args);
 		const data = result.stdout.trim();
 		if (!data) return emptyArray as GitTreeEntry[];
 
@@ -168,7 +175,7 @@ export class RevisionGitSubProvider implements GitRevisionSubProvider {
 		const params = ['show', '--textconv', args, '--'];
 
 		try {
-			const result = await this.git.exec<T>(opts, ...params);
+			const result = await this.git.run<T>(opts, ...params);
 			return result.stdout;
 		} catch (ex) {
 			const msg: string = ex?.toString() ?? '';
@@ -261,7 +268,7 @@ export class RevisionGitSubProvider implements GitRevisionSubProvider {
 		const resolvedRevisionCaching = { cache: this.cache.gitResults, options: { accessTTL: 5 * 60 * 1000 } };
 
 		const parser = getShaAndFileSummaryLogParser();
-		let result = await this.git.exec(
+		let result = await this.git.run(
 			{ cwd: repoPath, errors: 'ignore', caching: resolvedRevisionCaching },
 			'log',
 			...parser.arguments,
@@ -293,7 +300,7 @@ export class RevisionGitSubProvider implements GitRevisionSubProvider {
 
 		if (file.status === 'D') {
 			// If the file was deleted, check if it was moved or renamed
-			result = await this.git.exec(
+			result = await this.git.run(
 				{ cwd: repoPath, errors: 'ignore', caching: resolvedRevisionCaching },
 				'log',
 				...parser.arguments,

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

@@ -64,7 +64,7 @@ export class StagingGitSubProvider implements GitStagingSubProvider {
 					if (ref == null) throw new Error(`ref is required when from is 'ref'`);
 
 					// Create the temp index file from a base ref/sha
-					const newIndexResult = await this.git.exec(
+					const newIndexResult = await this.git.run(
 						{ cwd: repoPath, env: env },
 						'ls-tree',
 						'-z',
@@ -75,7 +75,7 @@ export class StagingGitSubProvider implements GitStagingSubProvider {
 
 					if (newIndexResult.stdout.trim()) {
 						// Write the tree to our temp index
-						await this.git.exec(
+						await this.git.run(
 							{ cwd: repoPath, env: env, stdin: newIndexResult.stdout },
 							'update-index',
 							'-z',
@@ -98,7 +98,7 @@ export class StagingGitSubProvider implements GitStagingSubProvider {
 
 	@debug()
 	async stageFile(repoPath: string, pathOrUri: string | Uri): Promise<void> {
-		await this.git.exec({ cwd: repoPath }, 'add', '-A', '--', toFsPath(pathOrUri));
+		await this.git.run({ cwd: repoPath }, 'add', '-A', '--', toFsPath(pathOrUri));
 	}
 
 	@debug()
@@ -117,7 +117,7 @@ export class StagingGitSubProvider implements GitStagingSubProvider {
 		// Process files in batches (will be a single batch if under the limit)
 		const batches = chunk(paths, batchSize);
 		for (const batch of batches) {
-			await this.git.exec(
+			await this.git.run(
 				{ cwd: repoPath, env: options?.index?.env },
 				'add',
 				options?.intentToAdd ? '-N' : '-A',
@@ -129,12 +129,12 @@ export class StagingGitSubProvider implements GitStagingSubProvider {
 
 	@debug()
 	async stageDirectory(repoPath: string, directoryOrUri: string | Uri): Promise<void> {
-		await this.git.exec({ cwd: repoPath }, 'add', '-A', '--', toFsPath(directoryOrUri));
+		await this.git.run({ cwd: repoPath }, 'add', '-A', '--', toFsPath(directoryOrUri));
 	}
 
 	@debug()
 	async unstageFile(repoPath: string, pathOrUri: string | Uri): Promise<void> {
-		await this.git.exec({ cwd: repoPath }, 'reset', '-q', '--', toFsPath(pathOrUri));
+		await this.git.run({ cwd: repoPath }, 'reset', '-q', '--', toFsPath(pathOrUri));
 	}
 
 	@debug()
@@ -149,12 +149,22 @@ export class StagingGitSubProvider implements GitStagingSubProvider {
 		// Process files in batches (will be a single batch if under the limit)
 		const batches = chunk(paths, batchSize);
 		for (const batch of batches) {
-			await this.git.exec({ cwd: repoPath }, 'reset', '-q', '--', ...batch);
+			await this.git.run({ cwd: repoPath }, 'reset', '-q', '--', ...batch);
 		}
 	}
 
 	@debug()
 	async unstageDirectory(repoPath: string, directoryOrUri: string | Uri): Promise<void> {
-		await this.git.exec({ cwd: repoPath }, 'reset', '-q', '--', toFsPath(directoryOrUri));
+		await this.git.run({ cwd: repoPath }, 'reset', '-q', '--', toFsPath(directoryOrUri));
+	}
+
+	@debug()
+	async stageAll(repoPath: string): Promise<void> {
+		await this.git.run({ cwd: repoPath }, 'add', '-A');
+	}
+
+	@debug()
+	async unstageAll(repoPath: string): Promise<void> {
+		await this.git.run({ cwd: repoPath }, 'reset', '-q');
 	}
 }

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

@@ -1,7 +1,7 @@
 import type { Cache } from '../../git/cache.js';
 import type { GitServiceContext } from '../../git/context.js';
 import { StashApplyError, StashPushError } from '../../git/errors.js';
-import type { GitStashCommit, GitStashParentInfo } from '../../git/models/commit.js';
+import type { GitStashCommit } from '../../git/models/commit.js';
 import { GitCommit, GitCommitIdentity } from '../../git/models/commit.js';
 import { GitFileChange } from '../../git/models/fileChange.js';
 import type { GitFileStatus } from '../../git/models/fileStatus.js';
@@ -12,8 +12,7 @@ import type { GitStashSubProvider, StashApplyResult } from '../../git/providers/
 import { countStringLength } from '../../utils/array.js';
 import { gate } from '../../utils/decorators/gate.js';
 import { debug } from '../../utils/decorators/log.js';
-import { min, skip } from '../../utils/iterable.js';
-import { Logger } from '../../utils/logger.js';
+import { skip } from '../../utils/iterable.js';
 import { normalizePath, splitPath } from '../../utils/path.js';
 import { getSettledValue } from '../../utils/promise.js';
 import type { Uri } from '../../utils/uri.js';
@@ -23,7 +22,7 @@ import { gitFeaturesByVersion } from '../exec/features.js';
 import type { Git } from '../exec/git.js';
 import { getGitCommandError, GitError, GitErrors, maxGitCliLength } from '../exec/git.js';
 import type { ParsedStash, ParsedStashWithFiles } from '../parsers/logParser.js';
-import { getShaAndDatesLogParser, getStashFilesOnlyLogParser, getStashLogParser } from '../parsers/logParser.js';
+import { getStashFilesOnlyLogParser, getStashLogParser } from '../parsers/logParser.js';
 import { createCommitFileset } from './commitFilesetUtils.js';
 
 export class StashGitSubProvider implements GitStashSubProvider {
@@ -57,7 +56,7 @@ export class StashGitSubProvider implements GitStashSubProvider {
 		conflictCommand: 'stash-apply' | 'stash-pop',
 	): Promise<StashApplyResult> {
 		try {
-			await this.git.exec({ cwd: repoPath }, ...args);
+			await this.git.run({ cwd: repoPath }, ...args);
 			this.context.hooks?.cache?.onReset?.(repoPath, 'stashes');
 			this.context.hooks?.repository?.onChanged?.(repoPath, ['stash']);
 			return { conflicted: false };
@@ -94,7 +93,7 @@ export class StashGitSubProvider implements GitStashSubProvider {
 			args.push(message);
 		}
 
-		const result = await this.git.exec({ cwd: repoPath }, ...args);
+		const result = await this.git.run({ cwd: repoPath }, ...args);
 		return result.stdout.trim() || undefined;
 	}
 
@@ -110,135 +109,81 @@ export class StashGitSubProvider implements GitStashSubProvider {
 	): Promise<GitStash | undefined> {
 		if (repoPath == null) return undefined;
 
+		// Resolve options against config up front so the cache key reflects the actual values used
+		// to produce the cached payload — undefined inputs aren't conflated across config changes.
 		const cfg = this.context.config;
+		const includeFiles = options?.includeFiles ?? cfg?.commits.includeFileDetails ?? true;
+		const similarityThreshold = includeFiles
+			? (options?.similarityThreshold ?? cfg?.commits.similarityThreshold ?? null)
+			: null;
+		const reachableFrom = options?.reachableFrom;
+
+		// Cache only the unfiltered stash list; reachability projection runs below by testing each
+		// distinct stash parent against `reachableFrom` directly, so re-projecting is cheap
+		const cacheKey = `f${includeFiles ? 1 : 0}|s${similarityThreshold ?? ''}`;
+
 		const stash = await this.cache.getStash(
 			repoPath,
+			cacheKey,
 			async (commonPath, _cacheable, signal) => {
 				// Prefer the aggregate signal from the cache; fall back to the caller's cancellation.
 				signal ??= cancellation;
-				const includeFiles = options?.includeFiles ?? cfg?.commits.includeFileDetails ?? true;
 				const parser = getStashLogParser(includeFiles);
 				const args = [...parser.arguments];
 
 				if (includeFiles) {
-					const similarityThreshold = options?.similarityThreshold ?? cfg?.commits.similarityThreshold;
 					args.push(`-M${similarityThreshold == null ? '' : `${similarityThreshold}%`}`);
 				}
 
-				const result = await this.git.exec({ cwd: repoPath, cancellation: signal }, 'stash', 'list', ...args);
+				const result = await this.git.run({ cwd: repoPath, cancellation: signal }, 'stash', 'list', ...args);
 
 				const currentUser = await this.provider.config.getCurrentUser(repoPath);
 
 				const stashes = new Map<string, GitStashCommit>();
-				const parentShas = new Set<string>();
-
-				// First pass: create stashes and collect parent SHAs
 				for (const s of parser.parse(result.stdout)) {
 					stashes.set(s.sha, createStash(s, commonPath, currentUser));
-					// Collect all parent SHAs for timestamp lookup
-					if (s.parents) {
-						for (const parentSha of s.parents.split(' ')) {
-							if (parentSha.trim()) {
-								parentShas.add(parentSha.trim());
-							}
-						}
-					}
-				}
-
-				// Second pass: fetch parent timestamps if we have any parents
-				const parentTimestamps = new Map<string, { authorDate: number; committerDate: number }>();
-				if (parentShas.size > 0) {
-					try {
-						const datesParser = getShaAndDatesLogParser();
-						const parentResult = await this.git.exec(
-							{
-								cwd: repoPath,
-								cancellation: signal,
-								stdin: [...parentShas].join('\n'),
-							},
-							'log',
-							...datesParser.arguments,
-							'--no-walk',
-							'--stdin',
-						);
-
-						for (const entry of datesParser.parse(parentResult.stdout)) {
-							parentTimestamps.set(entry.sha, {
-								authorDate: Number(entry.authorDate),
-								committerDate: Number(entry.committerDate),
-							});
-						}
-					} catch (ex) {
-						Logger.debug(`Failed to fetch parent timestamps for stash commits: ${ex}`);
-					}
-				}
-
-				// Third pass: update stashes with parent timestamp information
-				for (const sha of stashes.keys()) {
-					const stashCommit = stashes.get(sha);
-					if (stashCommit?.parents.length) {
-						const parentsWithTimestamps: GitStashParentInfo[] = stashCommit.parents.map(parentSha => ({
-							sha: parentSha,
-							authorDate: parentTimestamps.get(parentSha)?.authorDate,
-							committerDate: parentTimestamps.get(parentSha)?.committerDate,
-						}));
-						// Store the parent timestamp information on the stash
-						stashes.set(sha, stashCommit.with({ parentTimestamps: parentsWithTimestamps }));
-					}
 				}
 
 				return { repoPath: commonPath, stashes: stashes };
 			},
-			cancellation,
+			{ cancellation: cancellation },
 		);
 
-		if (stash == null) return undefined;
-		if (!options?.reachableFrom || !stash?.stashes.size) return stash;
+		if (stash == null || !reachableFrom || !stash.stashes.size) return stash;
 
-		// Return only reachable stashes from the given ref
-		// Create a copy because we are going to modify it and we don't want to mutate the cache
+		// Copy because the cached `stash.stashes` map is shared and must not be mutated.
 		const stashes = new Map(stash.stashes);
 
-		const oldestStashDate = new Date(findOldestStashTimestamp(stash.stashes.values())).toISOString();
-
-		const { reachableFrom } = options;
-		const reachableShas = await this.provider.commits.getLogShas(repoPath, reachableFrom, {
-			since: oldestStashDate,
-			ordering: 'date',
-			limit: 0,
-		});
-		const reachableCommits = new Set(reachableShas);
+		const reachableStashes = new Set<string>();
 
-		if (reachableCommits.size) {
-			const reachableStashes = new Set<string>();
+		// Metadata pass: a stash belongs on `reachableFrom` iff git's auto-prepended
+		// `On <branch>: …` (or `WIP on <branch>: …`) prefix in the stash commit subject names
+		// this branch. `stashOnRef` is parsed from %s in createStash, so this covers autostashes
+		// and custom-reflog stashes too.
+		for (const [sha, s] of stash.stashes) {
+			if (s.stashOnRef === reachableFrom) {
+				reachableStashes.add(sha);
+			}
+		}
 
-			// First pass: mark directly reachable stashes
+		// Transitive pass for the rare detached-HEAD-on-stash chain (stash B created while HEAD
+		// pointed at stash A). Such stashes have no `stashOnRef`, but if their parent is a stash
+		// already marked reachable they should follow.
+		let changed;
+		do {
+			changed = false;
 			for (const [sha, s] of stash.stashes) {
-				if (s.parents.some(p => p === reachableFrom || reachableCommits.has(p))) {
+				if (!reachableStashes.has(sha) && s.parents.some(p => reachableStashes.has(p))) {
 					reachableStashes.add(sha);
+					changed = true;
 				}
 			}
+		} while (changed);
 
-			// Second pass: mark stashes that build upon reachable stashes
-			let changed;
-			do {
-				changed = false;
-				for (const [sha, s] of stash.stashes) {
-					if (!reachableStashes.has(sha) && s.parents.some(p => reachableStashes.has(p))) {
-						reachableStashes.add(sha);
-						changed = true;
-					}
-				}
-			} while (changed);
-
-			// Remove unreachable stashes
-			for (const [sha] of stash.stashes) {
-				if (!reachableStashes.has(sha)) {
-					stashes.delete(sha);
-				}
+		for (const [sha] of stash.stashes) {
+			if (!reachableStashes.has(sha)) {
+				stashes.delete(sha);
 			}
-		} else {
-			stashes.clear();
 		}
 
 		return { ...stash, stashes: stashes };
@@ -288,7 +233,7 @@ export class StashGitSubProvider implements GitStashSubProvider {
 		}
 
 		const parser = getStashFilesOnlyLogParser();
-		const result = await this.git.exec(
+		const result = await this.git.run(
 			{ cwd: repoPath, cancellation: cancellation },
 			'stash',
 			'show',
@@ -343,7 +288,7 @@ export class StashGitSubProvider implements GitStashSubProvider {
 
 		let result;
 		if (sha) {
-			result = await this.git.exec(
+			result = await this.git.run(
 				{ cwd: repoPath, errors: 'ignore' },
 				'show',
 				'--format=%H',
@@ -355,7 +300,7 @@ export class StashGitSubProvider implements GitStashSubProvider {
 			}
 		}
 
-		result = await this.git.exec({ cwd: repoPath }, 'stash', 'drop', stashName);
+		result = await this.git.run({ cwd: repoPath }, 'stash', 'drop', stashName);
 		return result.stdout;
 	}
 
@@ -368,7 +313,7 @@ export class StashGitSubProvider implements GitStashSubProvider {
 		stashOnRef?: string,
 	): Promise<void> {
 		await this.deleteStashCore(repoPath, stashName, sha);
-		await this.git.exec(
+		await this.git.run(
 			{ cwd: repoPath },
 			'stash',
 			'store',
@@ -478,7 +423,7 @@ export class StashGitSubProvider implements GitStashSubProvider {
 		}
 
 		try {
-			const result = await this.git.exec({ cwd: repoPath, stdin: stdin }, ...params);
+			const result = await this.git.run({ cwd: repoPath, stdin: stdin }, ...params);
 			if (GitErrors.stashNothingToSave.test(result.stdout)) {
 				throw new StashPushError({
 					reason: 'nothingToSave',
@@ -502,7 +447,7 @@ export class StashGitSubProvider implements GitStashSubProvider {
 
 	@debug()
 	async saveSnapshot(repoPath: string, message?: string): Promise<void> {
-		const result = await this.git.exec({ cwd: repoPath }, 'stash', 'create');
+		const result = await this.git.run({ cwd: repoPath }, 'stash', 'create');
 		const id = result.stdout.trim() || undefined;
 		if (id == null) return;
 
@@ -510,7 +455,7 @@ export class StashGitSubProvider implements GitStashSubProvider {
 		if (message) {
 			args.push('-m', message);
 		}
-		await this.git.exec({ cwd: repoPath }, 'stash', 'store', ...args, id);
+		await this.git.run({ cwd: repoPath }, 'stash', 'store', ...args, id);
 
 		this.context.hooks?.repository?.onChanged?.(repoPath, ['stash']);
 		this.context.hooks?.cache?.onReset?.(repoPath, 'stashes');
@@ -557,18 +502,25 @@ function createStash(
 	repoPath: string,
 	currentUser: GitUser | undefined,
 ): GitStashCommit {
-	let message = s.summary.trim();
-
-	let onRef;
-	let summary;
-	const match = stashSummaryRegex.exec(message);
-	if (match?.groups != null) {
-		onRef = match.groups.onref;
-		summary = match.groups.summary.trim();
+	// `onRef` comes from the commit subject (%s), which git always prefixes with `On <branch>: …`
+	// or `WIP on <branch>: …`. This holds even when the reflog message was customized
+	// (autostash, `git stash store -m "…"`), so it's a reliable source
+	let onRef: string | undefined;
+	const subjectMatch = stashSummaryRegex.exec((s.commitSubject ?? '').trim());
+	if (subjectMatch?.groups?.onref) {
+		onRef = subjectMatch.groups.onref;
+	}
 
+	// The user-visible display message is derived from the reflog subject (%gs) so that short
+	// custom messages like "wip", "q", or "show args" stay as the user wrote them instead of
+	// being replaced by the verbose git-auto subject
+	let message = s.summary.trim();
+	const reflogMatch = stashSummaryRegex.exec(message);
+	if (reflogMatch?.groups != null) {
+		const summary = reflogMatch.groups.summary.trim();
 		if (summary.length === 0) {
 			message = 'WIP';
-		} else if (match.groups.wip) {
+		} else if (reflogMatch.groups.wip) {
 			message = `WIP: ${summary}`;
 		} else {
 			message = summary;
@@ -605,22 +557,3 @@ function createStash(
 		onRef,
 	) as GitStashCommit;
 }
-
-/**
- * Finds the oldest timestamp among stash commits and their parent commits.
- * This includes both the stash commit dates and all parent commit timestamps (author and committer dates).
- *
- * @param stashes - Collection of stash commits to analyze
- * @returns The oldest timestamp in milliseconds, or Infinity if no stashes provided
- */
-export function findOldestStashTimestamp(stashes: Iterable<GitStashCommit>): number {
-	return min(stashes, c => {
-		return Math.min(
-			c.committer.date.getTime(),
-			...(c.parentTimestamps
-				?.flatMap(p => [p.authorDate, p.committerDate])
-				.filter((x): x is number => x != null)
-				.map(x => x * 1000) ?? []),
-		);
-	});
-}