@gitkraken/core-gitlens 0.1.0 → 0.3.0

package/src/git/providers/operations.ts

@@ -1,5 +1,6 @@
 import type { GitBranchReference, GitReference } from '../models/reference.js';
 import type { GitConflictFile } from '../models/staging.js';
+import type { GitRunOptions } from '../run.types.js';
 
 export interface GitOperationResult {
 	readonly conflicted: boolean;
@@ -7,16 +8,51 @@ export interface GitOperationResult {
 	readonly conflicts?: GitConflictFile[];
 }
 
+/**
+ * Spawn-layer overrides callers can pass to user-initiated git operations to inject per-call
+ * environment variables, an `AbortSignal` for cancellation, or a custom `timeout`. Forwarded
+ * verbatim to the underlying `git.run(...)` invocation; cannot override op-owned fields like
+ * `cwd`, `configs`, `errors`, or `stdin`.
+ *
+ * Note: passing `timeout` overrides per-op safety defaults. `merge`, `rebase`, and `revert`
+ * intentionally disable the timeout (set it to 0) because those operations can take a long
+ * time; a caller-supplied `timeout` will replace that "no timeout" setting, so use with care.
+ */
+export type GitOperationRunOptions = Pick<GitRunOptions, 'env' | 'cancellation' | 'timeout'>;
+
 export interface GitOperationsSubProvider {
 	checkout(
 		repoPath: string,
 		ref: string,
 		options?: { createBranch?: string | undefined } | { path?: string | undefined },
+		runOptions?: GitOperationRunOptions,
+	): Promise<void>;
+	/**
+	 * Checks out one side of a conflicted path during a paused merge/rebase/cherry-pick.
+	 * Executes `git checkout --ours|--theirs -- <path>`, leaving the file unstaged.
+	 */
+	checkoutConflictedPath(
+		repoPath: string,
+		path: string,
+		side: 'ours' | 'theirs',
+		runOptions?: GitOperationRunOptions,
+	): Promise<void>;
+	/**
+	 * Checks out one side for multiple conflicted paths during a paused merge/rebase/cherry-pick.
+	 * Batches paths into `git checkout --ours|--theirs -- <paths...>`, chunked to stay under the
+	 * CLI length limit. Leaves files unstaged.
+	 */
+	checkoutConflictedPaths(
+		repoPath: string,
+		paths: string[],
+		side: 'ours' | 'theirs',
+		runOptions?: GitOperationRunOptions,
 	): Promise<void>;
 	cherryPick(
 		repoPath: string,
 		revs: string[],
-		options?: { edit?: boolean; noCommit?: boolean },
+		options?: { edit?: boolean; noCommit?: boolean; source?: unknown },
+		runOptions?: GitOperationRunOptions,
 	): Promise<GitOperationResult>;
 	commit(
 		repoPath: string,
@@ -28,7 +64,9 @@ export interface GitOperationsSubProvider {
 			author?: string;
 			date?: string;
 			signoff?: boolean;
+			source?: unknown;
 		},
+		runOptions?: GitOperationRunOptions,
 	): Promise<void>;
 	fetch(
 		repoPath: string,
@@ -39,11 +77,13 @@ export interface GitOperationsSubProvider {
 			pull?: boolean | undefined;
 			remote?: string | undefined;
 		},
+		runOptions?: GitOperationRunOptions,
 	): Promise<void>;
 	merge(
 		repoPath: string,
 		ref: string,
-		options?: { fastForward?: boolean | 'only'; noCommit?: boolean; squash?: boolean },
+		options?: { fastForward?: boolean | 'only'; noCommit?: boolean; squash?: boolean; source?: unknown },
+		runOptions?: GitOperationRunOptions,
 	): Promise<GitOperationResult>;
 	pull(
 		repoPath: string,
@@ -51,7 +91,9 @@ export interface GitOperationsSubProvider {
 			branch?: GitBranchReference | undefined;
 			rebase?: boolean | undefined;
 			tags?: boolean | undefined;
+			source?: unknown;
 		},
+		runOptions?: GitOperationRunOptions,
 	): Promise<void>;
 	push(
 		repoPath: string,
@@ -60,6 +102,7 @@ export interface GitOperationsSubProvider {
 			force?: boolean | undefined;
 			publish?: { remote: string };
 		},
+		runOptions?: GitOperationRunOptions,
 	): Promise<void>;
 	rebase(
 		repoPath: string,
@@ -71,12 +114,20 @@ export interface GitOperationsSubProvider {
 			interactive?: boolean;
 			onto?: string;
 			updateRefs?: boolean;
+			source?: unknown;
 		},
+		runOptions?: GitOperationRunOptions,
 	): Promise<GitOperationResult>;
 	reset(
 		repoPath: string,
 		rev: string,
 		options?: { mode?: 'hard' | 'keep' | 'merge' | 'mixed' | 'soft' },
+		runOptions?: GitOperationRunOptions,
 	): Promise<void>;
-	revert(repoPath: string, refs: string[], options?: { editMessage?: boolean }): Promise<GitOperationResult>;
+	revert(
+		repoPath: string,
+		refs: string[],
+		options?: { editMessage?: boolean; source?: unknown },
+		runOptions?: GitOperationRunOptions,
+	): Promise<GitOperationResult>;
 }

package/src/git/providers/pausedOperations.ts

@@ -3,6 +3,7 @@ import type { GitPausedOperationStatus } from '../models/pausedOperationStatus.j
 export interface GitPausedOperationsSubProvider {
 	getPausedOperationStatus(
 		repoPath: string,
+		options?: { force?: boolean },
 		cancellation?: AbortSignal,
 	): Promise<GitPausedOperationStatus | undefined>;
 	abortPausedOperation(repoPath: string, options?: { quit?: boolean }): Promise<void>;

package/src/git/providers/refs.ts

@@ -1,7 +1,8 @@
 import type { Uri } from '../../utils/uri.js';
 import type { GitBranch } from '../models/branch.js';
-import type { GitReference } from '../models/reference.js';
+import type { GitReference, GitRefTip } from '../models/reference.js';
 import type { GitTag } from '../models/tag.js';
+import type { GitCommandPriority } from '../run.types.js';
 
 export interface GitRefsSubProvider {
 	checkIfCouldBeValidBranchOrTagName(repoPath: string, ref: string): Promise<boolean>;
@@ -9,11 +10,39 @@ export interface GitRefsSubProvider {
 		repoPath: string,
 		ref1: string,
 		ref2: string,
-		options?: { forkPoint?: boolean | undefined },
+		options?: { forkPoint?: boolean | undefined; priority?: GitCommandPriority },
 		cancellation?: AbortSignal,
 	): Promise<string | undefined>;
 	getReference(repoPath: string, ref: string, cancellation?: AbortSignal): Promise<GitReference | undefined>;
-	getSymbolicReferenceName?(repoPath: string, ref: string, cancellation?: AbortSignal): Promise<string | undefined>;
+	/**
+	 * Lightweight enumeration of ref tips (heads/remotes/tags) — no enrichment.
+	 * Use this when you need a SHA-to-refs map; use `getBranches`/`getTags` for full models.
+	 */
+	getRefTips(
+		repoPath: string,
+		options?: { include?: ReadonlyArray<'heads' | 'remotes' | 'tags'> },
+		cancellation?: AbortSignal,
+	): Promise<GitRefTip[]>;
+	/**
+	 * Batch reachability — for each input SHA, the refs whose tips contain it.
+	 *
+	 * One bounded `git rev-list --topo-order --parents --all ^<oldestSha>^@` walk; ref-set
+	 * propagation runs in memory. Cost is O(walked subgraph), not O(N × refs) like the per-sha
+	 * `getBranchesWithCommits([sha])` pattern. Pass the oldest SHA in your dataset to bound the walk.
+	 */
+	getRefsContainingShas(
+		repoPath: string,
+		shas: ReadonlySet<string> | readonly string[],
+		oldestSha: string,
+		options?: { include?: ReadonlyArray<'heads' | 'remotes' | 'tags'> },
+		cancellation?: AbortSignal,
+	): Promise<Map<string, GitRefTip[]>>;
+	getSymbolicReferenceName?(
+		repoPath: string,
+		ref: string,
+		options?: { priority?: GitCommandPriority },
+		cancellation?: AbortSignal,
+	): Promise<string | undefined>;
 	hasBranchOrTag(
 		repoPath: string | undefined,
 		options?: {

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,18 @@ 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>;
+	/**
+	 * Removes a file from both the working tree and the index in a single operation
+	 * (`git rm [-f] -- <path>`). Use during conflict resolution when the user has chosen a
+	 * side that is itself a deletion — atomic, so it can't leave a working-tree-modified
+	 * file accidentally staged with content. Pass `force: true` to discard local
+	 * modifications (required for conflicted files).
+	 */
+	removeFile(repoPath: string, pathOrUri: string | Uri, options?: { force?: boolean }): Promise<void>;
+	/**
+	 * Batched form of {@link removeFile}. Chunks paths to stay under the CLI length limit.
+	 */
+	removeFiles(repoPath: string, pathsOrUris: (string | Uri)[], options?: { force?: boolean }): Promise<void>;
+	stageAll(repoPath: string): Promise<void>;
+	unstageAll(repoPath: string): Promise<void>;
 }

package/src/git/providers/status.ts

@@ -3,6 +3,7 @@ import type { GitFile } from '../models/file.js';
 import type { GitConflictFile } from '../models/staging.js';
 import type { GitStatus } from '../models/status.js';
 import type { GitStatusFile } from '../models/statusFile.js';
+import type { GitCommandPriority } from '../run.types.js';
 
 export interface GitWorkingChangesState {
 	staged: boolean;
@@ -11,7 +12,11 @@ export interface GitWorkingChangesState {
 }
 
 export interface GitStatusSubProvider {
-	getStatus(repoPath: string | undefined, cancellation?: AbortSignal): Promise<GitStatus | undefined>;
+	getStatus(
+		repoPath: string | undefined,
+		options?: { priority?: GitCommandPriority },
+		cancellation?: AbortSignal,
+	): Promise<GitStatus | undefined>;
 	getStatusForFile?(
 		repoPath: string,
 		pathOrUri: string | Uri,

package/src/git/remotes/azure-devops.ts

@@ -34,6 +34,7 @@ function parseVstsHttpsUrl(url: URL): [string, string, string] {
 	const owner = getVSTSOwner(url);
 	const match = azureProjectRepoRegex.exec(url.pathname);
 	if (match == null) throw new Error(`Invalid VSTS URL: ${url.toString()}`);
+
 	const [, project, repo] = match;
 	return [owner, project, repo];
 }
@@ -43,6 +44,7 @@ const azureHttpsUrlRegex2 = /([^/]+)\/([^/]+)\/_git\/([^/]+)/;
 function parseAzureNewStyleUrl(url: URL): [string, string, string] {
 	const match = azureHttpsUrlRegex2.exec(url.pathname);
 	if (match == null) throw new Error(`Invalid Azure URL: ${url.toString()}`);
+
 	const [, owner, project, repo] = match;
 	return [owner, project, repo];
 }

package/src/git/{exec.types.ts → run.types.ts}

@@ -27,11 +27,11 @@ export interface GitResultCache {
  * Priority levels for git commands.
  * - `interactive`: User-initiated operations (blame, hover) - highest priority
  * - `normal`: Standard operations (status, config) - default priority
- * - `background`: Expensive operations (log, graph) - can be throttled
+ * - `background`: Expensive operations (graph rendering, full history walks) - can be throttled
  */
 export type GitCommandPriority = 'interactive' | 'normal' | 'background';
 
-export interface GitExecOptions {
+export interface GitRunOptions {
 	cancellation?: AbortSignal;
 	configs?: readonly string[];
 	readonly correlationKey?: string;
@@ -63,6 +63,26 @@ export interface GitExecOptions {
 	readonly timeout?: number;
 }
 
+/**
+ * Untyped escape hatch for raw `git <args>` invocation, returned by
+ * `GlGitProvider.createUnsafeGit`.
+ *
+ * "Unsafe" here means **bypasses the typed safety net** the rest of GitLens relies on
+ * — sub-provider cancellation/caching/decorator behaviors and signing-awareness do
+ * not apply when commands are issued through this object. It does NOT imply command
+ * injection risk; the caller still controls the args.
+ *
+ * Hand instances to libraries that need to issue arbitrary git commands
+ * (`@gitkraken/compose-tools`, `@gitkraken/shared-tools` undo). Inside GitLens
+ * itself, prefer the typed sub-providers on `RepositoryService` (`branches`,
+ * `commits`, `diff`, `staging`, `stash`, `status`, …). Holding an `UnsafeGit`
+ * just to call `run(...)` for an ad-hoc command is almost always wrong — the
+ * abstraction exists so it can be handed off, not used directly.
+ */
+export interface UnsafeGit {
+	run(args: readonly string[], options?: GitRunOptions): Promise<GitResult>;
+}
+
 export interface GitSpawnOptions {
 	cancellation?: AbortSignal;
 	configs?: readonly string[];

package/src/git/service.ts

@@ -77,6 +77,7 @@ export class GitService implements UnifiedDisposable {
 		if (GitService._instance != null) {
 			throw new Error('GitService already exists — only one instance is allowed');
 		}
+
 		const instance = new GitService(watchingProvider);
 		GitService._instance = instance;
 		return instance;

package/src/git/utils/autolink.utils.ts

@@ -179,6 +179,7 @@ export function getBranchAutolinks(
 			for (const regex of ref.branchNameRegexes) {
 				match = branchName.match(regex);
 				if (!match?.groups) continue;
+
 				num = match.groups.issueKeyNumber;
 				const linkUrl = ref.url?.replace(numRegex, num);
 				autolinks.set(linkUrl, {

package/src/git/utils/blame.utils.ts

@@ -249,6 +249,7 @@ export function buildDirtyBlame(cleanBlame: GitBlame, mapping: LineMappingResult
 	const lineCountsBySha = new Map<string, number>();
 	for (const blameLine of dirtyBlameLines) {
 		if (blameLine == null) continue;
+
 		lineCountsBySha.set(blameLine.sha, (lineCountsBySha.get(blameLine.sha) ?? 0) + 1);
 	}
 
@@ -276,6 +277,7 @@ export function buildDirtyBlame(cleanBlame: GitBlame, mapping: LineMappingResult
 	for (const [, c] of commits) {
 		if (!c.author.name) continue;
 		if (authors.has(c.author.name)) continue;
+
 		authors.set(c.author.name, { name: c.author.name, lineCount: 0, current: c.author.current });
 	}
 

package/src/git/utils/conflictResolution.utils.ts

@@ -0,0 +1,31 @@
+import type { GitFileConflictStatus } from '../models/fileStatus.js';
+
+export type ConflictResolutionAction = 'take-ours' | 'take-theirs' | 'delete' | 'unsupported';
+
+export function classifyConflictAction(
+	status: GitFileConflictStatus,
+	resolution: 'current' | 'incoming',
+): ConflictResolutionAction {
+	const takeCurrent = resolution === 'current';
+
+	if (status === 'DD') return 'delete';
+	if (status === 'UD' && !takeCurrent) return 'delete';
+	if (status === 'DU' && takeCurrent) return 'delete';
+
+	// `git checkout --{ours,theirs}` fails when the requested stage is absent.
+	// Single-file UI filters these out; bulk resolve surfaces them as failures.
+	if (status === 'UA' && takeCurrent) return 'unsupported';
+	if (status === 'AU' && !takeCurrent) return 'unsupported';
+
+	return takeCurrent ? 'take-ours' : 'take-theirs';
+}
+
+// Stage Current is invalid when the current side has no content to take (added/deleted only by them, or both deleted)
+export function canStageCurrent(status: GitFileConflictStatus): boolean {
+	return status !== 'UA' && status !== 'DD';
+}
+
+// Stage Incoming is invalid when the incoming side has no content to take (added/deleted only by us, or both deleted)
+export function canStageIncoming(status: GitFileConflictStatus): boolean {
+	return status !== 'AU' && status !== 'DD';
+}

package/src/git/utils/fileStatus.utils.ts

@@ -1,4 +1,4 @@
-import type { GitFileStatus } from '../models/fileStatus.js';
+import type { GitFileConflictStatus, GitFileStatus } from '../models/fileStatus.js';
 
 const statusIconsMap = {
 	'.': undefined,
@@ -47,3 +47,9 @@ const statusTextMap = {
 export function getGitFileStatusText(status: GitFileStatus | keyof typeof statusTextMap): string {
 	return statusTextMap[status] ?? 'Unknown';
 }
+
+const conflictStatuses = new Set<string>(['U', 'AA', 'AU', 'UA', 'DD', 'DU', 'UD', 'UU']);
+
+export function isConflictStatus(status: string | undefined): status is 'U' | GitFileConflictStatus {
+	return status != null && conflictStatuses.has(status);
+}

package/src/git/utils/search.utils.ts

@@ -274,6 +274,8 @@ export function parseSearchQueryGitCommand(
 							searchArgs.add('--no-walk');
 						} else if (value === 'tip') {
 							filters.type = 'tip';
+						} else if (value === 'wip') {
+							filters.type = 'wip';
 						}
 					}
 

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,42 @@ 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;
+}
+
+// Hoisted from `compareRefTips` so we don't re-allocate the lookup per sort iteration.
+const refTipTypeOrder = { branch: 0, remote: 1, tag: 2 } as const;
+
+/**
+ * Comparator for `GitRefTip` arrays — local branch < remote branch < tag, tags by version desc.
+ * Mirrors `compareReachableRefs` for the lighter ref-tip shape.
+ */
+export function compareRefTips(a: { type: 'branch' | 'remote' | 'tag'; name: string }, b: typeof a): number {
+	if (a.type !== b.type) {
+		return refTipTypeOrder[a.type] - refTipTypeOrder[b.type];
+	}
+	if (a.type === '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/utils/status.utils.ts

@@ -69,6 +69,7 @@ export function getUpstreamStatus(
 	},
 ): string {
 	if (upstream == null) return options?.empty ?? '';
+
 	const {
 		state: { ahead, behind },
 	} = upstream;

package/src/git/watching/classifyChange.ts

@@ -17,6 +17,15 @@ const classifyRegex =
  *   handles it as a last-fetched timestamp).
  */
 export function classifyGitDirChange(relativePath: string): RepositoryChange[] | undefined {
+	// User-edited todo file (and its backup) — handled by VS Code's TextDocument
+	// events in the rebase webview (see `rebaseWebviewProvider.ts`). Suppress here
+	// to avoid thrashing the repo update path on every save during an interactive
+	// rebase; rebase lifecycle (start/stop/step) still fires from sibling files
+	// in `rebase-merge/` and the directory itself.
+	if (relativePath.endsWith('/git-rebase-todo') || relativePath.endsWith('/git-rebase-todo.backup')) {
+		return undefined;
+	}
+
 	const match = classifyRegex.exec(relativePath);
 	if (match == null) return undefined;
 

package/src/git/watching/gitIgnoreFilter.ts

@@ -1,7 +1,7 @@
-import { getScopedCounter } from '../../utils/counter.js';
-import { fileUri } from '../../utils/uri.js';
 import type { Ignore } from 'ignore';
 import ignore from 'ignore';
+import { getScopedCounter } from '../../utils/counter.js';
+import { fileUri } from '../../utils/uri.js';
 import type { FileSystemProvider } from '../context.js';
 
 export interface GitIgnoreFilterOptions {

package/src/git/watching/initWatcher.ts

@@ -36,6 +36,7 @@ export class RepositoryInitWatcher implements UnifiedDisposable {
 
 	dispose(): void {
 		if (this._disposed) return;
+
 		this._disposed = true;
 
 		for (const watcher of this.watchers.values()) {
@@ -60,6 +61,7 @@ export class RepositoryInitWatcher implements UnifiedDisposable {
 
 		const watcher = this.provider.createWatcher(basePath, gitInitGlob, event => {
 			if (event.reason !== 'create') return;
+
 			this.emitter.fire({ path: event.path, basePath: basePath });
 		});
 

package/src/git/watching/watchGroup.ts

@@ -54,6 +54,7 @@ export class WatchGroup implements UnifiedDisposable {
 	/** Dispose the entire group (common watcher + all root watchers). */
 	dispose(): void {
 		if (this._disposed) return;
+
 		this._disposed = true;
 
 		for (const entry of this._sessions.values()) {
@@ -132,6 +133,7 @@ export class WatchGroup implements UnifiedDisposable {
 	private onCommonEvent(event: FileWatchEvent): void {
 		// Compute relative path from common git dir
 		if (!isDescendant(event.path, this.commonGitDir)) return;
+
 		const relativePath = relative(this.commonGitDir, event.path);
 		if (shouldIgnoreRepoPath(relativePath)) return;
 
@@ -161,6 +163,7 @@ export class WatchGroup implements UnifiedDisposable {
 
 	private onRootEvent(event: FileWatchEvent, entry: SessionEntry): void {
 		if (!isDescendant(event.path, entry.gitDirPath)) return;
+
 		const relativePath = relative(entry.gitDirPath, event.path);
 		if (shouldIgnoreRepoPath(relativePath)) return;
 

package/src/git/watching/watchService.ts

@@ -38,7 +38,16 @@ export interface WatchHandle {
 interface SessionRecord {
 	readonly session: RepositoryWatchSession;
 	readonly gitDir: GitDir;
-	readonly watchHooks?: WatchHooks;
+	/**
+	 * Hooks contributed by all current `watch()` callers for this repo path. Earlier
+	 * implementations stored just the first caller's hooks (`WatchHooks | undefined`) and
+	 * silently dropped subsequent callers' hooks — that broke the case where a low-level
+	 * subscriber (e.g. the Graph's secondary-worktree WIP watcher) opened the session
+	 * first without hooks, and a later `Repository.setupWatching` for the same path lost
+	 * its `markFetched` / `onIgnoresChanged` wiring. Each `watch()` call adds its hooks
+	 * to this set and removes them on dispose; fire sites iterate the set.
+	 */
+	readonly watchHooks: Set<WatchHooks>;
 	refCount: number;
 }
 
@@ -83,6 +92,7 @@ export class RepositoryWatchService implements UnifiedDisposable {
 
 	dispose(): void {
 		if (this._disposed) return;
+
 		this._disposed = true;
 
 		for (const record of this.sessionMap.values()) {
@@ -117,6 +127,9 @@ export class RepositoryWatchService implements UnifiedDisposable {
 		let record = this.sessionMap.get(repoPath);
 		if (record != null) {
 			record.refCount++;
+			if (watchHooks != null) {
+				record.watchHooks.add(watchHooks);
+			}
 		} else {
 			const session = new RepositoryWatchSession({
 				repoPath: repoPath,
@@ -150,10 +163,15 @@ export class RepositoryWatchService implements UnifiedDisposable {
 				},
 			});
 
+			const watchHooksSet = new Set<WatchHooks>();
+			if (watchHooks != null) {
+				watchHooksSet.add(watchHooks);
+			}
+
 			record = {
 				session: session,
 				gitDir: gitDir,
-				watchHooks: watchHooks,
+				watchHooks: watchHooksSet,
 				refCount: 1,
 			};
 			this.sessionMap.set(repoPath, record);
@@ -166,12 +184,16 @@ export class RepositoryWatchService implements UnifiedDisposable {
 			session: sessionRef,
 			dispose: (): void => {
 				if (handleDisposed) return;
+
 				handleDisposed = true;
 
 				const rec = this.sessionMap.get(repoPath);
 				if (rec == null) return;
 
 				rec.refCount--;
+				if (watchHooks != null) {
+					rec.watchHooks.delete(watchHooks);
+				}
 				if (rec.refCount <= 0) {
 					this.sessionMap.delete(repoPath);
 					this.disposeSessionRecord(rec);
@@ -229,11 +251,18 @@ export class RepositoryWatchService implements UnifiedDisposable {
 				session.pushRepoChanges(changes);
 			},
 			onFetchHeadChanged: function (repoPath: string): void {
-				watchHooks?.onFetchHeadChanged?.(repoPath);
+				// Iterate at fire time so callers that joined after the group was wired up
+				// still receive events (e.g. a `Repository.setupWatching` whose hooks landed
+				// after a hookless `GitRepositoryService.watch` registered first).
+				for (const h of watchHooks) {
+					h.onFetchHeadChanged?.(repoPath);
+				}
 			},
 			onIgnoresChanged: (repoPath: string): void => {
 				this.refreshWorkingTreeFilter(repoPath);
-				watchHooks?.onIgnoresChanged?.(repoPath);
+				for (const h of watchHooks) {
+					h.onIgnoresChanged?.(repoPath);
+				}
 			},
 		};
 
@@ -293,7 +322,10 @@ export class RepositoryWatchService implements UnifiedDisposable {
 				if (filter != null) {
 					void filter.refresh();
 				}
-				watchHooks?.onGitIgnoreChanged?.(repoPath);
+				// See `connectToWatchGroup` for the iterate-at-fire-time rationale.
+				for (const h of watchHooks) {
+					h.onGitIgnoreChanged?.(repoPath);
+				}
 				// Don't push .gitignore itself as a working tree change
 				return;
 			}
@@ -341,6 +373,7 @@ function filterWorkingTreePaths(absolutePaths: string[], repoPath: string, filte
 	const result: string[] = [];
 	for (const p of absolutePaths) {
 		if (!isDescendant(p, repoPath)) continue;
+
 		const relativePath = relative(repoPath, p);
 		if (!filter.isIgnored(relativePath)) {
 			result.push(p);