@gitkraken/core-gitlens 0.2.0 → 0.3.0

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

@@ -1,7 +1,7 @@
 import { promises as fs } from 'fs';
 import { hostname, userInfo } from 'os';
 import { env as process_env } from 'process';
-import type { Cache } from '../../git/cache.js';
+import type { Cache, GkConfigInvalidationTarget } from '../../git/cache.js';
 import type { GitServiceContext } from '../../git/context.js';
 import { WorkspaceUntrustedError } from '../../git/errors.js';
 import type { GitDir } from '../../git/models/repository.js';
@@ -34,6 +34,8 @@ const emptyArray: readonly never[] = Object.freeze([]);
  */
 const gkConfigCacheableSets: readonly { match: RegExp; pattern: string }[] = [
 	{ match: /^branch\..+\.gk-associated-issues$/, pattern: '^branch\\..+\\.gk-associated-issues$' },
+	{ match: /^branch\..+\.gk-merge-base$/, pattern: '^branch\\..+\\.gk-merge-base$' },
+	{ match: /^branch\..+\.gk-merge-target$/, pattern: '^branch\\..+\\.gk-merge-target$' },
 	{ match: /^branch\..+\.gk-merge-target-user$/, pattern: '^branch\\..+\\.gk-merge-target-user$' },
 ];
 
@@ -59,6 +61,7 @@ function parseConfigRegexOutput(data: string | undefined): Map<string, string> {
 
 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';
 }
@@ -71,6 +74,13 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 		private readonly provider: CliGitProviderInternal,
 	) {}
 
+	/**
+	 * Pending `setGkConfig` writes keyed by `(commonPath, key, value, skip-option)`. Concurrent
+	 * callers writing the same `(key, value)` pair share the in-flight Promise so only one
+	 * `git config --set` subprocess actually runs. Cleared on settle.
+	 */
+	private readonly _pendingGkConfigWrites = new Map<string, Promise<void>>();
+
 	@trace()
 	getConfig(
 		repoPath: string | undefined,
@@ -243,6 +253,7 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 	async getDefaultWorktreePath(repoPath: string): Promise<string | undefined> {
 		const gitDir = await this.getGitDir(repoPath);
 		if (gitDir == null) return undefined;
+
 		const basePath = (gitDir.commonUri ?? gitDir.uri).fsPath;
 		return getBestPath(normalizePath(joinPaths(basePath, '..')));
 	}
@@ -291,6 +302,7 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 	private async getGkConfigPath(repoPath: string): Promise<string | undefined> {
 		const gitDir = await this.getGitDir(repoPath);
 		if (gitDir == null) return undefined;
+
 		// Use commonUri (main .git dir) for worktrees, otherwise use uri
 		const basePath = (gitDir.commonUri ?? gitDir.uri).fsPath;
 		return joinPaths(basePath, 'gk', 'config');
@@ -349,6 +361,31 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 		repoPath: string,
 		key: GkConfigKeys | DeprecatedGkConfigKeys,
 		value: string | undefined,
+		options?: { skipInvalidation?: readonly GkConfigInvalidationTarget[] },
+	): Promise<void> {
+		// Encode the skip-invalidation option in the dedup key: a self-write (with skip targets)
+		// and a user-driven write of the same `(key, value)` (no skip targets) have different
+		// cache-invalidation semantics, so sharing their Promise would silently let the user-driven
+		// write skip invalidation. Sort the array so callers passing the same targets in different
+		// orders share a single in-flight write.
+		const commonPath = this.cache.getCommonPath(repoPath);
+		const skipKey = options?.skipInvalidation?.length ? options.skipInvalidation.toSorted().join(',') : '';
+		const dedupKey = `${commonPath}\0${key}\0${value ?? ''}\0${skipKey}`;
+
+		const pending = this._pendingGkConfigWrites.get(dedupKey);
+		if (pending != null) return pending;
+
+		const promise = this.setGkConfigCore(repoPath, key, value, options);
+		this._pendingGkConfigWrites.set(dedupKey, promise);
+		void promise.finally(() => this._pendingGkConfigWrites.delete(dedupKey));
+		return promise;
+	}
+
+	private async setGkConfigCore(
+		repoPath: string,
+		key: GkConfigKeys | DeprecatedGkConfigKeys,
+		value: string | undefined,
+		options?: { skipInvalidation?: readonly GkConfigInvalidationTarget[] },
 	): Promise<void> {
 		const scope = getScopedLogger();
 
@@ -362,7 +399,7 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 		await this.setConfigCore(repoPath, key, value, { file: gkConfigPath });
 
 		// Invalidate the cached value for this key and clear all regex patterns for this scope
-		this.cache.deleteGkConfig(repoPath, key);
+		this.cache.deleteGkConfig(repoPath, key, options);
 	}
 
 	@debug()
@@ -648,6 +685,7 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 			this._migratedRepos.add(repoPath);
 			return;
 		}
+
 		const gkConfigFolder = joinPaths(gkConfigPath, '..');
 
 		// If .git/gk/config already exists, consider migration done — it was either
@@ -662,6 +700,7 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 
 		// If .git/gk/config doesn't exist, create an empty file to prevent multiple migration attempts in future sessions
 		if (!(await this.ensureGkConfigFolder(gkConfigFolder, scope))) return;
+
 		try {
 			await fs.writeFile(gkConfigPath, new Uint8Array());
 		} catch (ex) {

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

@@ -105,7 +105,7 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 			return stat;
 		} catch (ex) {
 			const msg: string = ex?.toString() ?? '';
-			if (GitErrors.noMergeBase.test(msg)) {
+			if (GitErrors.noMergeBase.test(msg) || GitErrors.badRevision.test(msg)) {
 				return undefined;
 			}
 
@@ -258,6 +258,7 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 					for (const file of untracked) {
 						if (seen.has(file.path)) continue;
 						if (options.path && options.path !== file.path) continue;
+
 						files.push(file);
 					}
 				}
@@ -328,7 +329,12 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 			// Follow file history and specify the file path
 			args.push('--follow', '--', relativePath);
 
-			const result = await this.git.run({ cwd: repoPath, configs: gitConfigsLog }, ...args);
+			// Unbounded --follow walk over file history can be slow on long histories — queue as background
+			// so it doesn't compete with interactive work.
+			const result = await this.git.run(
+				{ cwd: repoPath, configs: gitConfigsLog, priority: 'background' },
+				...args,
+			);
 
 			let currentSha;
 			let currentPath;

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

@@ -234,7 +234,14 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 					// - SHA + limit = 0: Find SHA, stop immediately
 					// - No SHA + limit > 0: Load exactly `limit` commits
 					// - No SHA + limit = 0: Load everything remaining
-					if ((limit && count >= limit && (!sha || found)) || (!limit && sha && found)) {
+					// - SHA + limit > 0 + still unfound past 10× limit: defensive cap so an unreachable
+					//   SHA (e.g. a stale merge-base the webview hasn't yet seen invalidated) can't
+					//   walk the entire history. `hasMore=true` lets callers retry; the graph-wrapper
+					//   side deduplicates re-requests so the cap doesn't loop.
+					if (
+						(limit && count >= limit && (!sha || found || count >= limit * 10)) ||
+						(!limit && sha && found)
+					) {
 						hasMore = true;
 						aborter.abort();
 						break;
@@ -250,6 +257,7 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 					total++;
 					shaOrRemapped = remappedIds.get(commit.sha);
 					if (shaOrRemapped && ids.has(shaOrRemapped)) continue;
+
 					shaOrRemapped ??= commit.sha;
 
 					ids.add(shaOrRemapped);
@@ -464,7 +472,7 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 							args.push(`--${ordering}-order`, '--all');
 
 							const statsResult = await this.git.run(
-								{ cwd: repoPath, configs: gitConfigsLog, stdin: stdin },
+								{ cwd: repoPath, configs: gitConfigsLog, stdin: stdin, priority: 'background' },
 								'log',
 								stdin ? '--stdin' : undefined,
 								...args,
@@ -725,6 +733,7 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 							runningTotal: results.size,
 							hasMore: true,
 						};
+
 						batch.length = 0;
 						lastProgressTime = Date.now();
 					}

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

@@ -16,7 +16,11 @@ import {
 import type { GitBranchReference, GitReference } from '../../git/models/reference.js';
 import type { SigningFormat } from '../../git/models/signature.js';
 import type { GitConflictFile } from '../../git/models/staging.js';
-import type { GitOperationResult, GitOperationsSubProvider } from '../../git/providers/operations.js';
+import type {
+	GitOperationResult,
+	GitOperationRunOptions,
+	GitOperationsSubProvider,
+} from '../../git/providers/operations.js';
 import { getBranchNameAndRemote, getBranchTrackingWithoutRemote } from '../../git/utils/branch.utils.js';
 import { isBranchReference } from '../../git/utils/reference.utils.js';
 import { debug } from '../../utils/decorators/log.js';
@@ -32,6 +36,7 @@ import {
 	gitConfigsPull,
 	GitErrors,
 	inferSigningFormatFromError,
+	maxGitCliLength,
 } from '../exec/git.js';
 
 export class OperationsGitSubProvider implements GitOperationsSubProvider {
@@ -47,11 +52,12 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		repoPath: string,
 		ref: string,
 		options?: { createBranch?: string } | { path?: string },
+		runOptions?: GitOperationRunOptions,
 	): Promise<void> {
 		const scope = getScopedLogger();
 
 		try {
-			await this.checkoutCore(repoPath, ref, options);
+			await this.checkoutCore(repoPath, ref, options, runOptions);
 			this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status');
 			this.context.hooks?.repository?.onChanged?.(repoPath, ['head', 'heads', 'index']);
 		} catch (ex) {
@@ -64,6 +70,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		repoPath: string,
 		ref: string,
 		{ createBranch, path }: { createBranch?: string; path?: string } = {},
+		runOptions?: GitOperationRunOptions,
 	): Promise<void> {
 		const params = ['checkout'];
 		if (createBranch) {
@@ -78,7 +85,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		}
 
 		try {
-			await this.git.run({ cwd: repoPath }, ...params);
+			await this.git.run({ cwd: repoPath, ...runOptions }, ...params);
 		} catch (ex) {
 			throw getGitCommandError(
 				'checkout',
@@ -92,12 +99,101 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		}
 	}
 
+	@debug()
+	async checkoutConflictedPath(
+		repoPath: string,
+		path: string,
+		side: 'ours' | 'theirs',
+		runOptions?: GitOperationRunOptions,
+	): Promise<void> {
+		const scope = getScopedLogger();
+
+		[path, repoPath] = splitPath(path, repoPath, true);
+		const params = ['checkout', `--${side}`, '--', path];
+
+		try {
+			await this.git.run({ cwd: repoPath, ...runOptions }, ...params);
+			this.context.hooks?.cache?.onReset?.(repoPath, 'status');
+			this.context.hooks?.repository?.onChanged?.(repoPath, ['index']);
+		} catch (ex) {
+			scope?.error(ex);
+			throw getGitCommandError(
+				'checkout',
+				ex,
+				reason =>
+					new CheckoutError(
+						{ reason: reason ?? 'other', ref: side, gitCommand: { repoPath: repoPath, args: params } },
+						ex,
+					),
+			);
+		}
+	}
+
+	@debug()
+	async checkoutConflictedPaths(
+		repoPath: string,
+		paths: string[],
+		side: 'ours' | 'theirs',
+		runOptions?: GitOperationRunOptions,
+	): Promise<void> {
+		if (!paths.length) return;
+
+		const scope = getScopedLogger();
+		const normalized = paths.map(p => splitPath(p, repoPath, true)[0]);
+
+		// Build batches by accumulating the length of each path + a small per-arg overhead (separator +
+		// possible quoting), so a single long path — or just the overhead itself — can't push a batch
+		// past the CLI length limit. Always keep at least one path per batch, even if a lone path is
+		// longer than the limit (the OS may still accept it on some platforms).
+		const perArgOverhead = 3;
+		const batches: string[][] = [];
+		let current: string[] = [];
+		let currentLen = 0;
+		for (const p of normalized) {
+			const cost = p.length + perArgOverhead;
+			if (current.length > 0 && currentLen + cost > maxGitCliLength) {
+				batches.push(current);
+				current = [];
+				currentLen = 0;
+			}
+			current.push(p);
+			currentLen += cost;
+		}
+		if (current.length) {
+			batches.push(current);
+		}
+
+		try {
+			for (const batch of batches) {
+				await this.git.run({ cwd: repoPath, ...runOptions }, 'checkout', `--${side}`, '--', ...batch);
+			}
+			this.context.hooks?.cache?.onReset?.(repoPath, 'status');
+			this.context.hooks?.repository?.onChanged?.(repoPath, ['index']);
+		} catch (ex) {
+			scope?.error(ex);
+			throw getGitCommandError(
+				'checkout',
+				ex,
+				reason =>
+					new CheckoutError(
+						{
+							reason: reason ?? 'other',
+							ref: side,
+							gitCommand: { repoPath: repoPath, args: ['checkout', `--${side}`, '--', ...normalized] },
+						},
+						ex,
+					),
+			);
+		}
+	}
+
 	@sequentialize({ getQueueKey: rp => rp })
 	@debug()
 	async cherryPick(
 		repoPath: string,
 		revs: string[],
 		options?: { edit?: boolean; noCommit?: boolean; source?: unknown },
+		runOptions?: GitOperationRunOptions,
 	): Promise<GitOperationResult> {
 		const scope = getScopedLogger();
 
@@ -110,7 +206,8 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		}
 
 		if (revs.length > 1) {
-			// Sort commits in topological order (oldest ancestor first) so cherry-pick applies them correctly
+			// Sort commits in topological order (oldest ancestor first) so cherry-pick applies them correctly.
+			// This is a local read-only pre-flight, not the user-initiated op — don't subject it to caller env/timeout.
 			const revsSet = new Set(revs);
 			const result = await this.git.run({ cwd: repoPath }, 'rev-list', '--topo-order', '--reverse', ...revs);
 
@@ -131,7 +228,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		args.push(...revs);
 
 		try {
-			await this.git.run({ cwd: repoPath, errors: 'throw' }, ...args);
+			await this.git.run({ cwd: repoPath, errors: 'throw', ...runOptions }, ...args);
 			this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status');
 			this.context.hooks?.repository?.onChanged?.(repoPath, ['head', 'heads', 'index']);
 			return { conflicted: false };
@@ -168,6 +265,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 			signoff?: boolean;
 			source?: unknown;
 		},
+		runOptions?: GitOperationRunOptions,
 	): Promise<void> {
 		const scope = getScopedLogger();
 
@@ -194,7 +292,10 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		params.push('-F', '-');
 
 		try {
-			await this.git.run({ cwd: repoPath, stdin: message, stdinEncoding: 'utf8', errors: 'throw' }, ...params);
+			await this.git.run(
+				{ cwd: repoPath, stdin: message, stdinEncoding: 'utf8', errors: 'throw', ...runOptions },
+				...params,
+			);
 			this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status');
 			this.context.hooks?.repository?.onChanged?.(repoPath, ['head', 'heads', 'index']);
 		} catch (ex) {
@@ -217,6 +318,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 	async fetch(
 		repoPath: string,
 		options?: { all?: boolean; branch?: GitBranchReference; prune?: boolean; pull?: boolean; remote?: string },
+		runOptions?: GitOperationRunOptions,
 	): Promise<void> {
 		const scope = getScopedLogger();
 
@@ -226,14 +328,18 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 				const [branchName, remoteName] = getBranchNameAndRemote(branch);
 				if (remoteName == null) return;
 
-				await this.fetchCore(repoPath, {
-					branch: branchName,
-					remote: remoteName,
-					upstream: getBranchTrackingWithoutRemote(branch)!,
-					pull: options?.pull,
-				});
+				await this.fetchCore(
+					repoPath,
+					{
+						branch: branchName,
+						remote: remoteName,
+						upstream: getBranchTrackingWithoutRemote(branch)!,
+						pull: options?.pull,
+					},
+					runOptions,
+				);
 			} else {
-				await this.fetchCore(repoPath, opts);
+				await this.fetchCore(repoPath, opts, runOptions);
 			}
 
 			this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'tags');
@@ -256,6 +362,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 					remote: string;
 					upstream: string;
 			  },
+		runOptions?: GitOperationRunOptions,
 	): Promise<void> {
 		const params = ['fetch'];
 
@@ -276,7 +383,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		}
 
 		try {
-			await this.git.run({ cwd: repoPath }, ...params);
+			await this.git.run({ cwd: repoPath, ...runOptions }, ...params);
 		} catch (ex) {
 			throw getGitCommandError(
 				'fetch',
@@ -301,6 +408,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		repoPath: string,
 		ref: string,
 		options?: { fastForward?: boolean | 'only'; noCommit?: boolean; squash?: boolean; source?: unknown },
+		runOptions?: GitOperationRunOptions,
 	): Promise<GitOperationResult> {
 		const scope = getScopedLogger();
 
@@ -325,7 +433,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		try {
 			await this.git.run(
 				// Avoid a timeout since merges can take a long time (set to 0 to disable)
-				{ cwd: repoPath, errors: 'throw', timeout: 0 },
+				{ cwd: repoPath, errors: 'throw', timeout: 0, ...runOptions },
 				...args,
 			);
 
@@ -356,6 +464,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 	async pull(
 		repoPath: string,
 		options?: { branch?: GitBranchReference; rebase?: boolean; tags?: boolean; source?: unknown },
+		runOptions?: GitOperationRunOptions,
 	): Promise<void> {
 		const scope = getScopedLogger();
 
@@ -369,25 +478,33 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 				);
 				if (worktree != null) {
 					// Branch is checked out in a worktree — run git pull in that worktree's directory
-					await this.pullCore(normalizePath(worktree.uri.fsPath), {
-						rebase: options?.rebase,
-						tags: options?.tags,
-						source: options?.source,
-					});
+					await this.pullCore(
+						normalizePath(worktree.uri.fsPath),
+						{
+							rebase: options?.rebase,
+							tags: options?.tags,
+							source: options?.source,
+						},
+						runOptions,
+					);
 					this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status', 'tags');
 					this.context.hooks?.repository?.onChanged?.(repoPath, ['head', 'heads', 'remotes', 'index']);
 				} else {
 					// Branch is not checked out anywhere — can only fetch (no working tree to merge into)
-					await this.fetch(repoPath, { branch: branch });
+					await this.fetch(repoPath, { branch: branch }, runOptions);
 				}
 				return;
 			}
 
-			await this.pullCore(repoPath, {
-				rebase: options?.rebase,
-				tags: options?.tags,
-				source: options?.source,
-			});
+			await this.pullCore(
+				repoPath,
+				{
+					rebase: options?.rebase,
+					tags: options?.tags,
+					source: options?.source,
+				},
+				runOptions,
+			);
 
 			this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status', 'tags');
 			this.context.hooks?.repository?.onChanged?.(repoPath, ['head', 'heads', 'remotes', 'index']);
@@ -400,6 +517,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 	private async pullCore(
 		repoPath: string,
 		options: { rebase?: boolean; tags?: boolean; source?: unknown },
+		runOptions?: GitOperationRunOptions,
 	): Promise<void> {
 		const params = ['pull'];
 
@@ -412,7 +530,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		}
 
 		try {
-			await this.git.run({ cwd: repoPath, configs: gitConfigsPull }, ...params);
+			await this.git.run({ cwd: repoPath, configs: gitConfigsPull, ...runOptions }, ...params);
 		} catch (ex) {
 			await this.throwIfSigningError(repoPath, params, ex, options.source);
 			throw getGitCommandError(
@@ -429,6 +547,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 	async push(
 		repoPath: string,
 		options?: { reference?: GitReference; force?: boolean; publish?: { remote: string } },
+		runOptions?: GitOperationRunOptions,
 	): Promise<void> {
 		const scope = getScopedLogger();
 
@@ -487,27 +606,40 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		}
 
 		try {
-			await this.pushCore(repoPath, {
-				branch: branchName,
-				remote: remoteName,
-				upstream: upstreamName,
-				force: forceOpts,
-				publish: options?.publish != null,
-			});
-
-			// Since Git can't setup upstream tracking when publishing a new branch to a specific commit, do it now
+			await this.pushCore(
+				repoPath,
+				{
+					branch: branchName,
+					remote: remoteName,
+					upstream: upstreamName,
+					force: forceOpts,
+					publish: options?.publish != null,
+				},
+				runOptions,
+			);
+
+			// Since Git can't setup upstream tracking when publishing a new branch to a specific commit, do it now.
+			// Soft-fail: the push already succeeded, so don't let a local upstream-tracking failure (cancellation
+			// arriving mid-spawn, transient git error) suppress the post-push hook fan-out below.
 			if (setUpstream != null) {
-				await this.git.run(
-					{ cwd: repoPath },
-					'branch',
-					'--set-upstream-to',
-					`${setUpstream.remote}/${setUpstream.remoteBranch}`,
-					setUpstream.branch,
-				);
+				try {
+					await this.git.run(
+						{ cwd: repoPath, ...runOptions },
+						'branch',
+						'--set-upstream-to',
+						`${setUpstream.remote}/${setUpstream.remoteBranch}`,
+						setUpstream.branch,
+					);
+				} catch (ex) {
+					scope?.error(ex, 'Unable to set upstream tracking after publish');
+				}
 			}
 
 			this.context.hooks?.cache?.onReset?.(repoPath, 'branches');
-			this.context.hooks?.repository?.onChanged?.(repoPath, ['remotes']);
+			this.context.hooks?.repository?.onChanged?.(
+				repoPath,
+				options?.publish != null ? ['config', 'heads', 'remotes'] : ['remotes'],
+			);
 		} catch (ex) {
 			scope?.error(ex);
 			throw ex;
@@ -524,6 +656,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 			upstream?: string;
 			delete?: { remote: string; branch: string };
 		},
+		runOptions?: GitOperationRunOptions,
 	): Promise<void> {
 		const params = ['push'];
 
@@ -555,7 +688,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		}
 
 		try {
-			await this.git.run({ cwd: repoPath }, ...params);
+			await this.git.run({ cwd: repoPath, ...runOptions }, ...params);
 		} catch (ex) {
 			const error = getGitCommandError(
 				'push',
@@ -629,6 +762,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 			updateRefs?: boolean;
 			source?: unknown;
 		},
+		runOptions?: GitOperationRunOptions,
 	): Promise<GitOperationResult> {
 		const scope = getScopedLogger();
 
@@ -664,7 +798,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		try {
 			await this.git.run(
 				// Avoid a timeout since rebases can take a long time (set to 0 to disable)
-				{ cwd: repoPath, errors: 'throw', configs: configs, timeout: 0 },
+				{ cwd: repoPath, errors: 'throw', configs: configs, timeout: 0, ...runOptions },
 				...args,
 			);
 			this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status');
@@ -698,11 +832,12 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		repoPath: string,
 		rev: string,
 		options?: { mode?: 'hard' | 'keep' | 'merge' | 'mixed' | 'soft' },
+		runOptions?: GitOperationRunOptions,
 	): Promise<void> {
 		const scope = getScopedLogger();
 
 		try {
-			await this.resetCore(repoPath, rev, options?.mode);
+			await this.resetCore(repoPath, rev, options?.mode, runOptions);
 			this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status');
 			this.context.hooks?.repository?.onChanged?.(repoPath, ['head', 'heads', 'index']);
 		} catch (ex) {
@@ -715,6 +850,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		repoPath: string,
 		rev: string,
 		mode?: 'hard' | 'keep' | 'merge' | 'mixed' | 'soft',
+		runOptions?: GitOperationRunOptions,
 	): Promise<void> {
 		const params = ['reset', '-q'];
 		if (mode) {
@@ -723,7 +859,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		params.push(rev, '--');
 
 		try {
-			await this.git.run({ cwd: repoPath }, ...params);
+			await this.git.run({ cwd: repoPath, ...runOptions }, ...params);
 		} catch (ex) {
 			throw getGitCommandError(
 				'reset',
@@ -740,6 +876,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		repoPath: string,
 		refs: string[],
 		options?: { editMessage?: boolean; source?: unknown },
+		runOptions?: GitOperationRunOptions,
 	): Promise<GitOperationResult> {
 		const scope = getScopedLogger();
 
@@ -756,7 +893,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		try {
 			await this.git.run(
 				// Avoid a timeout since reverts can take a long time (set to 0 to disable)
-				{ cwd: repoPath, errors: 'throw', timeout: 0 },
+				{ cwd: repoPath, errors: 'throw', timeout: 0, ...runOptions },
 				...args,
 			);
 

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

@@ -113,6 +113,7 @@ export class PatchGitSubProvider implements GitPatchSubProvider {
 			}
 		} catch (ex) {
 			if (ex instanceof ApplyPatchCommitError) throw ex;
+
 			scope?.error(ex);
 
 			if (CherryPickError.is(ex, 'wouldOverwriteChanges')) {

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

@@ -43,10 +43,18 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 	@debug()
 	getPausedOperationStatus(
 		repoPath: string,
+		options?: { force?: boolean },
 		cancellation?: AbortSignal,
 	): Promise<GitPausedOperationStatus | undefined> {
 		const scope = getScopedLogger();
 
+		// Self-heal callers (WIP refresh) bypass the cache so a missed `'pausedOp'` FS-watcher
+		// event (CLI-driven completion, torn-down secondary-worktree watcher) can't leave the
+		// status stuck — the readdir-based detection is cheap enough to repeat on every tick.
+		if (options?.force) {
+			this.cache.pausedOperationStatus.delete(repoPath);
+		}
+
 		const status = this.cache.pausedOperationStatus.getOrCreate(repoPath, async _cancellable => {
 			const gitDir = await this.provider.config.getGitDir(repoPath);