@gitkraken/core-gitlens 0.1.0 → 0.2.0

package/src/git/providers/branches.ts

@@ -12,6 +12,8 @@ export interface BranchContributionsOverview extends GitCommitStats<number> {
 	readonly branch: string;
 	readonly mergeTarget: string;
 	readonly mergeBase: string;
+	/** Committer date of the merge-base commit. Lets consumers (e.g. the graph minimap scope window) anchor on the same date semantics as the minimap aggregation without a separate commit fetch. */
+	readonly mergeBaseDate: Date | undefined;
 
 	readonly commits: number;
 	readonly latestCommitDate: Date | undefined;
@@ -98,6 +100,7 @@ export interface GitBranchesSubProvider {
 	getStoredUserMergeTargetBranchName?(repoPath: string, ref: string): Promise<string | undefined>;
 	onCurrentBranchAccessed?(repoPath: string): Promise<void>;
 	onCurrentBranchModified?(repoPath: string): Promise<void>;
+	onCurrentBranchAgentActivity?(repoPath: string): Promise<void>;
 	renameBranch?(repoPath: string, oldName: string, newName: string): Promise<void>;
 	setUpstreamBranch?(repoPath: string, name: string, upstream: string | undefined): Promise<void>;
 	setBranchDisposition?(

package/src/git/providers/commits.ts

@@ -68,6 +68,7 @@ export interface IncomingActivityOptions extends GitLogOptionsBase {
 }
 
 export interface GitCommitReachability {
+	readonly partial?: boolean;
 	readonly refs: (
 		| { readonly refType: 'branch'; readonly name: string; readonly remote: boolean; readonly current?: boolean }
 		| { readonly refType: 'tag'; readonly name: string; readonly current?: never }
@@ -77,6 +78,12 @@ export interface GitCommitReachability {
 export interface GitCommitsSubProvider {
 	getCommit(repoPath: string, rev: string, cancellation?: AbortSignal): Promise<GitCommit | undefined>;
 	getCommitCount(repoPath: string, rev: string, cancellation?: AbortSignal): Promise<number | undefined>;
+	/** Cheap author/committer date lookup for a single revision. Skips the full commit parse (no files, parents, or message) — use when only the dates are needed. Pass a full SHA so caching stays correct (commits are immutable; refs are not). */
+	getCommitDates?(
+		repoPath: string,
+		rev: string,
+		cancellation?: AbortSignal,
+	): Promise<{ authorDate: Date; committerDate: Date } | undefined>;
 	getCommitFiles(repoPath: string, rev: string, cancellation?: AbortSignal): Promise<GitFileChange[]>;
 	getCommitForFile(
 		repoPath: string,

package/src/git/providers/config.ts

@@ -36,6 +36,8 @@ export type GkConfigKeys =
 	| `branch.${string}.gk-last-accessed`
 	/** `gk-last-modified` — ISO 8601 timestamp of when the branch last received a commit */
 	| `branch.${string}.gk-last-modified`
+	/** `gk-agent-last-activity` — ISO 8601 timestamp of when an AI agent was last active on this branch */
+	| `branch.${string}.gk-agent-last-activity`
 	/** `gk-disposition` — user-assigned branch disposition: 'starred' or 'archived' */
 	| `branch.${string}.gk-disposition`
 	/** `gk.defaultRemote` — the user-designated default remote for the repository */

package/src/git/providers/diff.ts

@@ -32,7 +32,7 @@ export interface GitDiffSubProvider {
 		repoPath: string,
 		to?: string,
 		from?: string,
-		options?: { uris?: (string | Uri)[] },
+		options?: { uris?: (string | Uri)[]; includeUntracked?: boolean },
 		cancellation?: AbortSignal,
 	): Promise<GitDiffShortStat | undefined>;
 	getDiff?(
@@ -70,7 +70,13 @@ export interface GitDiffSubProvider {
 		repoPath: string,
 		ref1OrRange: string | GitRevisionRange,
 		ref2?: string,
-		options?: { filters?: GitDiffFilter[]; path?: string; renameLimit?: number; similarityThreshold?: number },
+		options?: {
+			filters?: GitDiffFilter[];
+			includeUntracked?: boolean;
+			path?: string;
+			renameLimit?: number;
+			similarityThreshold?: number;
+		},
 	): Promise<GitFile[] | undefined>;
 	getDiffTool?(repoPath?: string): Promise<string | undefined>;
 	getNextComparisonUris(

package/src/git/providers/operations.ts

@@ -16,7 +16,7 @@ export interface GitOperationsSubProvider {
 	cherryPick(
 		repoPath: string,
 		revs: string[],
-		options?: { edit?: boolean; noCommit?: boolean },
+		options?: { edit?: boolean; noCommit?: boolean; source?: unknown },
 	): Promise<GitOperationResult>;
 	commit(
 		repoPath: string,
@@ -28,6 +28,7 @@ export interface GitOperationsSubProvider {
 			author?: string;
 			date?: string;
 			signoff?: boolean;
+			source?: unknown;
 		},
 	): Promise<void>;
 	fetch(
@@ -43,7 +44,7 @@ export interface GitOperationsSubProvider {
 	merge(
 		repoPath: string,
 		ref: string,
-		options?: { fastForward?: boolean | 'only'; noCommit?: boolean; squash?: boolean },
+		options?: { fastForward?: boolean | 'only'; noCommit?: boolean; squash?: boolean; source?: unknown },
 	): Promise<GitOperationResult>;
 	pull(
 		repoPath: string,
@@ -51,6 +52,7 @@ export interface GitOperationsSubProvider {
 			branch?: GitBranchReference | undefined;
 			rebase?: boolean | undefined;
 			tags?: boolean | undefined;
+			source?: unknown;
 		},
 	): Promise<void>;
 	push(
@@ -71,6 +73,7 @@ export interface GitOperationsSubProvider {
 			interactive?: boolean;
 			onto?: string;
 			updateRefs?: boolean;
+			source?: unknown;
 		},
 	): Promise<GitOperationResult>;
 	reset(
@@ -78,5 +81,9 @@ export interface GitOperationsSubProvider {
 		rev: string,
 		options?: { mode?: 'hard' | 'keep' | 'merge' | 'mixed' | 'soft' },
 	): Promise<void>;
-	revert(repoPath: string, refs: string[], options?: { editMessage?: boolean }): Promise<GitOperationResult>;
+	revert(
+		repoPath: string,
+		refs: string[],
+		options?: { editMessage?: boolean; source?: unknown },
+	): Promise<GitOperationResult>;
 }

package/src/git/providers/revision.ts

@@ -17,7 +17,11 @@ export interface ResolvedRevision {
 }
 
 export interface GitRevisionSubProvider {
-	exists?(repoPath: string, path: string, revOrOptions?: string | { untracked?: boolean }): Promise<boolean>;
+	exists?(
+		repoPath: string,
+		path: string,
+		revOrOptions?: string | { untracked?: 'only' | 'include' },
+	): Promise<boolean>;
 	getRevisionContent(repoPath: string, path: string, rev: string): Promise<Uint8Array | undefined>;
 	getSubmoduleHead?(repoPath: string, submodulePath: string): Promise<string | undefined>;
 	/** Gets tracked file paths from the index (reflects working tree state, even during rebase) */

package/src/git/providers/staging.ts

@@ -19,4 +19,6 @@ export interface GitStagingSubProvider {
 	unstageFile(repoPath: string, pathOrUri: string | Uri): Promise<void>;
 	unstageFiles(repoPath: string, pathsOrUris: (string | Uri)[]): Promise<void>;
 	unstageDirectory(repoPath: string, directoryOrUri: string | Uri): Promise<void>;
+	stageAll(repoPath: string): Promise<void>;
+	unstageAll(repoPath: string): Promise<void>;
 }

package/src/git/utils/sorting.ts

@@ -1,9 +1,11 @@
 import { sortCompare } from '../../utils/string.js';
+import { compareByVersionDescending } from '../../utils/version.js';
 import type { GitBranch } from '../models/branch.js';
 import type { GitContributor } from '../models/contributor.js';
 import type { GitRemote } from '../models/remote.js';
 import type { GitTag } from '../models/tag.js';
 import type { GitWorktree } from '../models/worktree.js';
+import type { GitCommitReachability } from '../providers/commits.js';
 
 export type BranchSorting = 'date:desc' | 'date:asc' | 'name:asc' | 'name:desc';
 export type TagSorting = 'date:desc' | 'date:asc' | 'name:asc' | 'name:desc';
@@ -25,6 +27,25 @@ export interface BranchSortOptions {
 	openedWorktreesByBranch?: Set<string>;
 }
 
+/**
+ * Comparator for sorting reachable refs to match `git for-each-ref` ordering: current first,
+ * local before remote, tags by version descending. Use with `.sort()` or `.toSorted()`.
+ */
+export function compareReachableRefs(
+	a: GitCommitReachability['refs'][number],
+	b: GitCommitReachability['refs'][number],
+): number {
+	if (a.current && !b.current) return -1;
+	if (!a.current && b.current) return 1;
+	if (a.refType === 'branch' && b.refType === 'branch') {
+		if (a.remote !== b.remote) return a.remote ? 1 : -1;
+	}
+	if (a.refType === 'tag' && b.refType === 'tag') {
+		return compareByVersionDescending(a.name, b.name);
+	}
+	return 0;
+}
+
 export function sortBranches(branches: GitBranch[], options?: BranchSortOptions): GitBranch[] {
 	options = { current: true, groupByType: true, orderBy: 'date:desc', ...options };
 

package/src/git-cli/cliGitProvider.ts

@@ -146,7 +146,7 @@ export class CliGitProvider implements GitProvider {
 			folderPath = joinPaths(parentPath, `${remoteName}-${count}`);
 		}
 
-		await this._git.exec({ cwd: parentPath }, 'clone', url, folderPath);
+		await this._git.run({ cwd: parentPath }, 'clone', url, folderPath);
 
 		return folderPath;
 	}

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

@@ -17,6 +17,7 @@ import type {
 	ResetErrorReason,
 	RevertErrorReason,
 	ShowErrorReason,
+	SigningErrorReason,
 	StashApplyErrorReason,
 	StashPushErrorReason,
 	TagErrorReason,
@@ -24,6 +25,7 @@ import type {
 	WorktreeDeleteErrorReason,
 } from '../../git/errors.js';
 import { WorkspaceUntrustedError } from '../../git/errors.js';
+import type { SigningFormat } from '../../git/models/signature.js';
 import { CancellationError, getAbortSignalId, isCancellationError } from '../../utils/cancellation.js';
 import { getScopedCounter } from '../../utils/counter.js';
 import { getDurationMilliseconds, hrtime } from '../../utils/hrtime.js';
@@ -74,6 +76,8 @@ export const GitErrors = {
 	detachedHead: /You are in 'detached HEAD' state/i,
 	entryNotUpToDate: /error:\s*Entry ['"].+['"] not uptodate\. Cannot merge\./i,
 	failedToDeleteDirectoryNotEmpty: /failed to delete '(.*?)': Directory not empty/i,
+	gpgNotFound: /gpg:?\s*(?:command\s+)?not found|'gpg' is not recognized as|cannot run gpg:/i,
+	gpgSignFailed: /^error:\s*gpg failed to sign the data/im,
 	invalidName: /fatal:\s*'.+?' is not a valid branch name/i,
 	invalidLineCount: /file .+? has only (\d+) lines/i,
 	invalidObjectName: /invalid object name: (.*)\s/i,
@@ -106,6 +110,8 @@ export const GitErrors = {
 	remoteAhead: /rejected because the remote contains work/i,
 	remoteConnectionFailed: /Could not read from remote repository/i,
 	remoteRejected: /rejected because the remote contains work/i,
+	signingKeyNotAvailable: /secret key not available|no secret key|no signing key/i,
+	sshNotFound: /ssh-keygen[^\n]*(?:not found|No such file or directory|is not recognized)/i,
 	stashConflictingStagedAndUnstagedLines: /Cannot remove worktree changes/i,
 	stashNothingToSave: /No local changes to save/i,
 	stashSavedWorkingDirAndIndexState: /Saved working directory and index state/i,
@@ -413,6 +419,52 @@ export function getGitCommandError<T extends GitCommand, TReturn extends GitComm
 	return creator(undefined);
 }
 
+function extractSigningErrorText(ex: unknown): string {
+	if (ex == null) return '';
+	if (ex instanceof GitError) return ex.stderr || ex.stdout || ex.message || '';
+	if (ex instanceof Error) return ex.message || '';
+	if (typeof ex === 'string') return ex;
+	if (typeof ex === 'number' || typeof ex === 'boolean' || typeof ex === 'bigint') return String(ex);
+	if (typeof ex === 'object' && 'message' in ex && typeof ex.message === 'string') return ex.message;
+	return '';
+}
+
+/**
+ * Classifies a Git error as a signing-related failure using the {@link GitErrors}
+ * signing regexes. Returns the matched {@link SigningErrorReason}, or `undefined`
+ * when the error is not a recognized signing failure.
+ *
+ * Precedence is significant: `passphraseFailed` (gpg sign failure) is checked
+ * before `noKey`, matching the ordering used historically in patch.ts — a
+ * combined stderr like "error: gpg failed to sign … gpg: No secret key"
+ * resolves to `passphraseFailed`, the outer cause.
+ */
+export function classifySigningError(ex: unknown): SigningErrorReason | undefined {
+	const text = extractSigningErrorText(ex);
+	if (!text) return undefined;
+	if (GitErrors.gpgSignFailed.test(text)) return 'passphraseFailed';
+	if (GitErrors.signingKeyNotAvailable.test(text)) return 'noKey';
+	if (GitErrors.gpgNotFound.test(text)) return 'gpgNotFound';
+	if (GitErrors.sshNotFound.test(text)) return 'sshNotFound';
+	return undefined;
+}
+
+/**
+ * Infers the {@link SigningFormat} from stderr hints (e.g., mentions of
+ * `ssh-keygen` or `gpg.ssh.*` config keys). Returns `undefined` when no hints
+ * are present so callers can supply their own default (typically `'gpg'`).
+ *
+ * Used as a fallback when `config.getSigningConfig` is unavailable or rejects
+ * on the error path.
+ */
+export function inferSigningFormatFromError(ex: unknown): SigningFormat | undefined {
+	const text = extractSigningErrorText(ex);
+	if (!text) return undefined;
+	if (/\bssh-keygen\b|gpg\.ssh\.(?:program|allowedsignersfile)/i.test(text)) return 'ssh';
+	if (/\bgpg\b/i.test(text)) return 'gpg';
+	return undefined;
+}
+
 export interface GitOptions {
 	/** Custom environment variables to add to every git command */
 	env?: Record<string, string | undefined>;
@@ -579,15 +631,15 @@ export class Git {
 		);
 	}
 
-	async exec(
+	async run(
 		options: ExitCodeOnlyGitCommandOptions,
 		...args: readonly (string | undefined)[]
 	): Promise<GitResult<unknown>>;
-	async exec<T extends string | Buffer = string>(
+	async run<T extends string | Buffer = string>(
 		options: GitExecOptions,
 		...args: readonly (string | undefined)[]
 	): Promise<GitResult<T>>;
-	async exec<T extends string | Buffer = string>(
+	async run<T extends string | Buffer = string>(
 		options: GitExecOptions,
 		...args: readonly (string | undefined)[]
 	): Promise<GitResult<T | unknown>> {
@@ -602,7 +654,7 @@ export class Git {
 				options.caching.commonPath ?? options.cwd!,
 				gitCommand,
 				async cacheable => {
-					const result = await this.execCore<T>({ ...options, caching: undefined }, runArgs, gitCommand);
+					const result = await this.runCore<T>({ ...options, caching: undefined }, runArgs, gitCommand);
 					if (result.exitCode !== 0) {
 						cacheable.invalidate();
 					}
@@ -612,10 +664,10 @@ export class Git {
 			);
 		}
 
-		return this.execCore<T>(options, runArgs, gitCommand);
+		return this.runCore<T>(options, runArgs, gitCommand);
 	}
 
-	private async execCore<T extends string | Buffer>(
+	private async runCore<T extends string | Buffer>(
 		options: GitExecOptions,
 		args: string[],
 		gitCommand: string,
@@ -679,7 +731,7 @@ export class Git {
 			// Execute through the queue (interactive/normal run immediately, background is throttled)
 			const gitPath = await this.path();
 			void this._queue
-				.execute(priority, () => runSpawn<T>(gitPath, args, encoding ?? 'utf8', runOpts))
+				.run(priority, () => 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);
@@ -695,8 +747,8 @@ export class Git {
 		try {
 			result = await promise;
 			return {
-				stdout: result.stdout as T,
-				stderr: result.stderr as T | undefined,
+				stdout: result.stdout,
+				stderr: result.stderr,
 				exitCode: result.exitCode ?? 0,
 			};
 		} catch (ex) {
@@ -723,15 +775,15 @@ export class Git {
 			if (errorHandling === 'ignore') {
 				if (ex instanceof RunError) {
 					return {
-						stdout: ex.stdout as T,
-						stderr: ex.stderr as T | undefined,
+						stdout: ex.stdout,
+						stderr: ex.stderr,
 						exitCode: ex.code != null ? (typeof ex.code === 'number' ? ex.code : parseInt(ex.code, 10)) : 0,
 						cancelled: ex instanceof CancelledRunError,
 					};
 				}
 
 				return {
-					stdout: '' as T,
+					stdout: '',
 					stderr: undefined,
 					exitCode: 0,
 					cancelled: ex instanceof CancelledRunError,
@@ -747,7 +799,7 @@ export class Git {
 
 			defaultExceptionHandler(exception, options.cwd, start);
 			exception = undefined;
-			return { stdout: '' as T, stderr: result?.stderr as T | undefined, exitCode: result?.exitCode ?? 0 };
+			return { stdout: '', stderr: result?.stderr, exitCode: result?.exitCode ?? 0 };
 		} finally {
 			this.logGitCommandComplete(gitCommand, exception, getDurationMilliseconds(start), waiting);
 		}
@@ -888,7 +940,7 @@ export class Git {
 						for await (const chunk of proc.stdout) {
 							buffers.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
 						}
-						yield await decode(Buffer.concat(buffers as ReadonlyArray<Uint8Array>), { encoding: enc });
+						yield await decode(Buffer.concat(buffers), { encoding: enc });
 					}
 				}
 			} finally {
@@ -914,7 +966,7 @@ export class Git {
 	}
 
 	async rev_parse__git_dir(cwd: string): Promise<{ path: string; commonPath?: string } | undefined> {
-		const result = await this.exec({ cwd: cwd, errors: 'ignore' }, 'rev-parse', '--git-dir', '--git-common-dir');
+		const result = await this.run({ cwd: cwd, errors: 'ignore' }, 'rev-parse', '--git-dir', '--git-common-dir');
 		if (!result.stdout) return undefined;
 
 		// Keep trailing spaces which are part of the directory name
@@ -946,7 +998,7 @@ export class Git {
 			// Check if the folder is a bare clone: if it has a file named HEAD && `rev-parse --show-cdup` is empty
 			if (await fsExists(joinPaths(cwd, 'HEAD'))) {
 				try {
-					result = await this.exec(
+					result = await this.run(
 						{ cwd: cwd, errors: 'throw', configs: ['-C', cwd] },
 						'rev-parse',
 						'--show-cdup',
@@ -962,7 +1014,7 @@ export class Git {
 		}
 
 		try {
-			result = await this.exec({ cwd: cwd, errors: 'throw' }, 'rev-parse', '--show-toplevel');
+			result = await this.run({ cwd: cwd, errors: 'throw' }, 'rev-parse', '--show-toplevel');
 			// Make sure to normalize: https://github.com/git-for-windows/git/issues/2478
 			// Keep trailing spaces which are part of the directory name
 			return !result.stdout
@@ -985,7 +1037,7 @@ export class Git {
 			const inDotGit = GitWarnings.mustRunInWorkTree.test(ex.stderr ?? '');
 			// Check if we are in a bare clone
 			if (inDotGit && this.options.isTrusted?.() !== false) {
-				result = await this.exec({ cwd: cwd, errors: 'ignore' }, 'rev-parse', '--is-bare-repository');
+				result = await this.run({ cwd: cwd, errors: 'ignore' }, 'rev-parse', '--is-bare-repository');
 				if (result.stdout.trim() === 'true') {
 					const result = await this.rev_parse__git_dir(cwd);
 					const repoPath = result?.commonPath ?? result?.path;

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

@@ -1,11 +1,13 @@
 import type { GitCommandPriority } from './exec.types.js';
 
 interface QueuedCommand {
-	execute: () => Promise<unknown>;
+	run: () => Promise<unknown>;
 	resolve: (value: unknown) => void;
 	reject: (reason: unknown) => void;
 	queuedAt: number;
 	priority: GitCommandPriority;
+	signal?: AbortSignal;
+	abortHandler?: () => void;
 }
 
 /** Priority levels in descending order (highest first) */
@@ -14,6 +16,10 @@ const priorities: GitCommandPriority[] = ['interactive', 'normal', 'background']
 /** How many extra slots interactive commands can use when at capacity */
 const interactiveBurstCapacity = 2;
 
+function abortReason(signal: AbortSignal): Error {
+	return signal.reason instanceof Error ? signal.reason : new Error('Aborted');
+}
+
 export interface GitQueueConfig {
 	/** Maximum number of concurrent git processes. Defaults to 7. */
 	maxConcurrent?: number;
@@ -67,6 +73,9 @@ export class GitQueue {
 		this._disposed = true;
 		for (const queue of this._queues.values()) {
 			for (const cmd of queue) {
+				if (cmd.signal != null && cmd.abortHandler != null) {
+					cmd.signal.removeEventListener('abort', cmd.abortHandler);
+				}
 				cmd.reject(new Error('GitQueue disposed'));
 			}
 			queue.length = 0;
@@ -89,7 +98,7 @@ export class GitQueue {
 	}
 
 	/** Check if a command at the given priority can execute immediately */
-	private canExecuteNow(priority: GitCommandPriority): boolean {
+	private canRunNow(priority: GitCommandPriority): boolean {
 		// Must yield to higher priority waiting
 		if (this.hasHigherPriorityWaiting(priority)) return false;
 
@@ -115,20 +124,32 @@ export class GitQueue {
 		return false;
 	}
 
-	/** Execute a git command with the specified priority */
-	execute<T>(priority: GitCommandPriority, fn: () => Promise<T>): Promise<T> {
+	/**
+	 * Execute a git command with the specified priority.
+	 *
+	 * When `signal` is provided:
+	 * - If already aborted, rejects immediately without running.
+	 * - If aborted while queued, the command is removed from the queue and rejected before it ever runs.
+	 * - If aborted while running, the in-flight spawn must honor the same signal separately
+	 *   (callers pass it via `runOpts.cancellation`); the queue does not interrupt running work.
+	 */
+	run<T>(priority: GitCommandPriority, fn: () => Promise<T>, signal?: AbortSignal): Promise<T> {
 		if (this._disposed) {
 			return Promise.reject(new Error('GitQueue disposed'));
 		}
 
-		if (!this.canExecuteNow(priority)) {
-			return this.enqueue(fn, priority);
+		if (signal?.aborted) {
+			return Promise.reject(abortReason(signal));
 		}
 
-		return this.run(fn);
+		if (!this.canRunNow(priority)) {
+			return this.enqueue(fn, priority, signal);
+		}
+
+		return this.runcore(fn);
 	}
 
-	private async run<T>(fn: () => Promise<T>): Promise<T> {
+	private async runcore<T>(fn: () => Promise<T>): Promise<T> {
 		this._activeCount++;
 		try {
 			return await fn();
@@ -138,7 +159,7 @@ export class GitQueue {
 		}
 	}
 
-	private enqueue<T>(fn: () => Promise<T>, priority: GitCommandPriority): Promise<T> {
+	private enqueue<T>(fn: () => Promise<T>, priority: GitCommandPriority, signal?: AbortSignal): Promise<T> {
 		const queue = this._queues.get(priority)!;
 		const maxDepth = this._config.maxQueueDepth ?? 500;
 		if (maxDepth > 0 && queue.length >= maxDepth) {
@@ -146,13 +167,29 @@ export class GitQueue {
 		}
 
 		return new Promise<T>((resolve, reject) => {
-			queue.push({
-				execute: fn as () => Promise<unknown>,
+			const cmd: QueuedCommand = {
+				run: fn,
 				resolve: resolve as (value: unknown) => void,
 				reject: reject,
 				queuedAt: Date.now(),
 				priority: priority,
-			});
+				signal: signal,
+			};
+
+			if (signal != null) {
+				cmd.abortHandler = () => {
+					const idx = queue.indexOf(cmd);
+					// If still queued, remove and reject so it never runs.
+					// If already dequeued, the running command should honor the signal at its own layer.
+					if (idx !== -1) {
+						queue.splice(idx, 1);
+						cmd.reject(abortReason(signal));
+					}
+				};
+				signal.addEventListener('abort', cmd.abortHandler, { once: true });
+			}
+
+			queue.push(cmd);
 		});
 	}
 
@@ -172,6 +209,13 @@ export class GitQueue {
 	}
 
 	private runQueued(cmd: QueuedCommand): void {
+		// Detach the abort listener now that the command has left the queue — any subsequent
+		// abort must be handled by the running spawn itself (via runOpts.cancellation).
+		if (cmd.signal != null && cmd.abortHandler != null) {
+			cmd.signal.removeEventListener('abort', cmd.abortHandler);
+			cmd.abortHandler = undefined;
+		}
+
 		const waitTime = Date.now() - cmd.queuedAt;
 		if (waitTime > 1000) {
 			this._hooks.onSlowQueue?.({
@@ -189,7 +233,7 @@ export class GitQueue {
 
 		this._activeCount++;
 		try {
-			cmd.execute()
+			cmd.run()
 				.then(cmd.resolve, cmd.reject)
 				.finally(() => {
 					this._activeCount--;

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

@@ -176,6 +176,10 @@ const stashMapping = {
 	parents: '%P',
 	stashName: '%gd',
 	summary: '%gs',
+	// %s (commit subject) is git's authoritative `On <branch>: …` / `WIP on <branch>: …` record,
+	// present even when the reflog message (%gs) was customized (autostash, `git stash store -m`).
+	// Used downstream to extract `stashOnRef` reliably.
+	commitSubject: '%s',
 };
 
 type StashLogParser = LogParser<typeof stashMapping>;
@@ -882,7 +886,7 @@ function createLogParserWithPatch<T extends Record<string, string>>(
 		}
 
 		return {
-			status: (fileMatch[1] === 'rename' ? 'R' : 'M') as GitFileIndexStatus,
+			status: (fileMatch[1] === 'rename' ? 'R' : 'M') satisfies GitFileIndexStatus,
 			path: fileMatch[2],
 			originalPath: fileMatch[1] === 'rename' ? fileMatch[3] : undefined,
 			range: range,

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

@@ -393,7 +393,7 @@ export class BlameGitSubProvider implements GitBlameSubProvider {
 		const { root, file, params, stdin } = await this.buildBlameArgs(repoPath, fileName, options);
 
 		try {
-			return await this.git.exec({ cwd: root, stdin: stdin }, ...params, '--', file);
+			return await this.git.run({ cwd: root, stdin: stdin }, ...params, '--', file);
 		} catch (ex) {
 			// Since `-c blame.ignoreRevsFile=` doesn't work (despite what the docs suggest),
 			// detect the error and throw a more helpful one