@gitkraken/core-gitlens 0.5.110 → 0.5.111

package/src/git/models/pullRequest.ts

@@ -11,7 +11,6 @@ export type { PullRequestState };
 
 export interface PullRequestShape extends IssueOrPullRequest {
 	readonly author: PullRequestMember;
-	readonly body?: string;
 	/**
 	 * Canonical base-repository identity returned by the provider. Some providers
 	 * scope pull-request ids to a repository, so consumers must not have to infer
@@ -23,6 +22,8 @@ export interface PullRequestShape extends IssueOrPullRequest {
 	readonly isDraft?: boolean;
 	readonly additions?: number;
 	readonly deletions?: number;
+	readonly filesChanged?: number;
+	readonly body?: string;
 	readonly mergeableState?: PullRequestMergeableState;
 	readonly reviewDecision?: PullRequestReviewDecision;
 	readonly reviewRequests?: PullRequestReviewer[];
@@ -37,6 +38,7 @@ export interface PullRequestShape extends IssueOrPullRequest {
 	readonly latestReviews?: PullRequestReviewer[];
 	readonly assignees?: PullRequestMember[];
 	readonly project?: IssueProject;
+	readonly stack?: PullRequestStackInfo;
 	readonly number?: number;
 	readonly authoredByMe?: boolean;
 }
@@ -74,6 +76,12 @@ export class PullRequest implements PullRequestShape {
 		public readonly statusCheckRollupState?: PullRequestStatusCheckRollupState,
 		public readonly project?: IssueProject,
 		public readonly version?: number,
+		/** Commits on the head that aren't on the base. Appended rather than slotted with the other counts:
+		 *  this constructor is positional and every mapper passes through it. */
+		public readonly commitCount?: number,
+		public readonly stack?: PullRequestStackInfo,
+		public readonly filesChanged?: number,
+		/** The pull request's description, as markdown. */
 		public readonly body?: string,
 		public readonly number?: number,
 		public readonly authoredByMe?: boolean,
@@ -154,6 +162,10 @@ export interface PullRequestMember {
 	 * presentation.
 	 */
 	name?: string;
+	/** The provider's handle for this person, when it has one — GitHub's login, Azure's `uniqueName` (a UPN,
+	 *  so an email), Bitbucket's mutable `nickname`. Display/labelling only: it is neither guaranteed present
+	 *  (GitLab's native mapper has none) nor a stable identity, so never key a match off it. */
+	username?: string;
 	avatarUrl?: string;
 	url?: string;
 }
@@ -299,6 +311,26 @@ export interface PullRequestRefs {
 	isCrossRepository: boolean;
 }
 
+/**
+ * A pull request's membership in a stack — an ordered chain of dependent pull requests where each
+ * targets the branch of the one below it.
+ *
+ * `baseRef` is the stack's ultimate target (its trunk) and is NOT the same as `refs.base`, which for
+ * anything above the bottom layer names the layer below. Use `refs.base` to diff a single layer; use
+ * `baseRef` to answer where the work ultimately lands.
+ */
+export interface PullRequestStackInfo {
+	id: string;
+	/** Identifies the stack within its repository. */
+	number: number;
+	/** Total pull requests in the stack. */
+	size: number;
+	/** This pull request's layer, 1-based, where 1 is closest to `baseRef`. */
+	position: number;
+	/** The branch the bottom of the stack targets. */
+	baseRef: string;
+}
+
 export interface PullRequestReviewer {
 	isCodeOwner?: boolean;
 	reviewer: PullRequestMember;

package/src/git/models/repository.ts

@@ -7,12 +7,12 @@ import type { UnifiedDisposable } from '../../utils/disposable.js';
 import { createDisposable } from '../../utils/disposable.js';
 import type { Event } from '../../utils/event.js';
 import { Emitter } from '../../utils/event.js';
-import { basename, normalizePath } from '../../utils/path.js';
+import { some } from '../../utils/iterable.js';
+import { basename, isDescendant, normalizePath } from '../../utils/path.js';
 import type { Uri } from '../../utils/uri.js';
-import { fileUri } from '../../utils/uri.js';
 import type { GitProviderDescriptor } from '../providers/types.js';
 import { getCommonRepositoryUri } from '../utils/repository.utils.js';
-import type { WatcherRepoChangeEvent } from '../watching/changeEvent.js';
+import type { WatcherRepoChangeEvent, WorkingTreeChangeEvent } from '../watching/changeEvent.js';
 import type { RepositoryWatchService, WatchHandle, WatchHooks } from '../watching/watchService.js';
 import type { RepositorySubscription } from '../watching/watchSession.js';
 import { RepositoryChangeEvent } from './repositoryChangeEvent.js';
@@ -107,10 +107,44 @@ export interface RepositoryInit {
 	readonly watchService: RepositoryWatchService;
 }
 
-export interface RepositoryWorkingTreeChangeEvent {
-	readonly repository: Repository;
-	/** URIs of changed files */
-	readonly uris: ReadonlySet<Uri>;
+/**
+ * An event describing working tree file changes.
+ *
+ * Deliberately exposes no path collection. Consumers react by refreshing, and a refresh re-reads current
+ * state — so the paths only ever gate whether to bother, never what the answer is. A partial set would
+ * read as usable while quietly licensing the one harmful outcome (concluding a file did NOT change), so
+ * {@link changed} is the only way to ask.
+ */
+export class RepositoryWorkingTreeChangeEvent {
+	constructor(
+		readonly repository: Repository,
+		/** Absolute paths changed in this batch; partial when {@link incomplete}. */
+		private readonly paths: ReadonlySet<string>,
+		/** Whether paths were dropped, so {@link paths} can't be used to rule anything out. */
+		private readonly incomplete: boolean,
+	) {}
+
+	/**
+	 * Whether `uri` — or anything beneath it, when it's a folder — changed in this batch.
+	 *
+	 * Conservative: `true` whenever the batch is incomplete, since a miss would then prove nothing. Matches
+	 * on paths rather than URIs so nothing has to be allocated to answer.
+	 */
+	changed(uri: Uri): boolean {
+		if (this.incomplete) return true;
+
+		const path = uri.fsPath;
+		return some(this.paths, p => p === path || isDescendant(p, path));
+	}
+
+	toString(): string {
+		if (this.incomplete) return `{ repository: ${this.repository.name ?? ''}, paths: incomplete }`;
+
+		const [first] = this.paths;
+		return `{ repository: ${this.repository.name ?? ''}, paths(${this.paths.size}): [${first ?? ''}${
+			this.paths.size > 1 ? ', ...' : ''
+		}] }`;
+	}
 }
 
 export class Repository {
@@ -140,7 +174,8 @@ export class Repository {
 	protected _watchHandle: WatchHandle | undefined;
 	protected readonly _watchService: RepositoryWatchService;
 
-	private _pendingWorkingTreeChange?: RepositoryWorkingTreeChangeEvent;
+	private _pendingWorkingTreePaths?: Set<string>;
+	private _pendingWorkingTreeIncomplete = false;
 	private _pendingWorkingTreeFlush = false;
 	private _repoChangeListener: UnifiedDisposable | undefined;
 	/** Outstanding leases on the shared {@link _watchHandle} across `watch()` + `watchWorkingTree()`. */
@@ -318,7 +353,7 @@ export class Repository {
 		if (acquired == null) return createDisposable(() => {});
 
 		const sub = acquired.handle.session.subscribeToWorkingTree({ delayMs: delay });
-		const listener = sub.onDidChangeWorkingTree(e => this.onWorkingTreeChanged(e.paths));
+		const listener = sub.onDidChangeWorkingTree(e => this.onWorkingTreeChanged(e));
 
 		return createDisposable(
 			() => {
@@ -409,24 +444,30 @@ export class Repository {
 	 * `_onDidChangeWorkingTree` emission. Without this coalescing, every WIP-dependent listener
 	 * (graph, file history, compare branch, etc.) would fire N times for N active subscriptions.
 	 */
-	protected onWorkingTreeChanged(paths: ReadonlySet<string>): void {
+	/** Takes the session event whole rather than spreading it across parameters — a subclass override that
+	 *  dropped a trailing positional argument silently defeated this pipeline once already. */
+	protected onWorkingTreeChanged(e: WorkingTreeChangeEvent): void {
 		this._updatedAt = Date.now();
 
-		this._pendingWorkingTreeChange ??= { repository: this, uris: new Set<Uri>() };
-		for (const p of paths) {
-			(this._pendingWorkingTreeChange.uris as Set<Uri>).add(fileUri(p));
+		this._pendingWorkingTreePaths ??= new Set<string>();
+		for (const p of e.paths) {
+			this._pendingWorkingTreePaths.add(p);
 		}
+		this._pendingWorkingTreeIncomplete ||= e.incomplete;
 
 		if (this._pendingWorkingTreeFlush) return;
 
 		this._pendingWorkingTreeFlush = true;
 		queueMicrotask(() => {
 			this._pendingWorkingTreeFlush = false;
-			const e = this._pendingWorkingTreeChange;
-			if (e == null) return;
+			const paths = this._pendingWorkingTreePaths;
+			if (paths == null) return;
+
+			const incomplete = this._pendingWorkingTreeIncomplete;
+			this._pendingWorkingTreePaths = undefined;
+			this._pendingWorkingTreeIncomplete = false;
 
-			this._pendingWorkingTreeChange = undefined;
-			this._onDidChangeWorkingTree.fire(e);
+			this._onDidChangeWorkingTree.fire(new RepositoryWorkingTreeChangeEvent(this, paths, incomplete));
 		});
 	}
 

package/src/git/models/statusFile.ts

@@ -86,6 +86,9 @@ export class GitStatusFile implements GitFile {
 				case 'M':
 					this.workingTreeStatus = GitFileWorkingTreeStatus.Modified;
 					break;
+				case 'T':
+					this.workingTreeStatus = GitFileWorkingTreeStatus.TypeChanged;
+					break;
 			}
 		}
 	}

package/src/git/providers/branches.ts

@@ -102,6 +102,12 @@ export interface GitBranchesSubProvider {
 		targetBranch: string,
 		cancellation?: AbortSignal,
 	): Promise<ConflictDetectionResult>;
+	/** Detects conflicts when an autostash is reapplied onto the tree an integration produced */
+	getPotentialStashReapplyConflicts?(
+		repoPath: string,
+		ontoTreeOid: string,
+		cancellation?: AbortSignal,
+	): Promise<ConflictDetectionResult>;
 	getBaseBranchName?(
 		repoPath: string,
 		ref: string,

package/src/git/providers/commits.ts

@@ -8,6 +8,7 @@ import type { GitRevisionRange } from '../models/revision.js';
 import type { SearchQuery } from '../models/search.js';
 import type { CommitSignature, SshSignedCommit } from '../models/signature.js';
 import type { GitUser } from '../models/user.js';
+import type { GitCommandPriority } from '../run.types.js';
 import type { DiffRange } from './types.js';
 
 export interface LeftRightCommitCountResult {
@@ -82,6 +83,16 @@ export interface GitCommitsSubProvider {
 	 *  Cheap early-exit probe (`rev-list --not --remotes <rev> -n 1`) — it does NOT count them. Returns
 	 *  `undefined` when it can't be determined. */
 	hasUnpublishedCommits?(repoPath: string, rev: string, cancellation?: AbortSignal): Promise<boolean | undefined>;
+	/** Batched form of {@link hasUnpublishedCommits}: returns the subset of `shas` with commits not reachable
+	 *  from any remote-tracking ref, in ONE walk rather than a spawn per sha. Pass tips from any worktrees of
+	 *  the same repo — the object store and `refs/remotes` are shared, so a single `repoPath` covers them all.
+	 *  Callers should skip this when the repo has no remotes (every local commit would qualify). */
+	filterUnpublishedShas?(
+		repoPath: string,
+		shas: readonly string[],
+		options?: { priority?: GitCommandPriority },
+		cancellation?: AbortSignal,
+	): Promise<Set<string>>;
 	/** 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,

package/src/git/providers/config.ts

@@ -13,8 +13,16 @@ export type GitCoreConfigKeys =
 	| 'gpg.ssh.program'
 	| 'gpg.ssh.allowedSignersFile'
 	| 'init.defaultBranch'
+	/** `merge.autoStash` — whether `git merge` (and so a merging `git pull`) stashes and reapplies uncommitted changes */
+	| 'merge.autoStash'
+	/** `pull.autoStash` — overrides `merge.autoStash`/`rebase.autoStash` for `git pull`, in either mode */
+	| 'pull.autoStash'
 	/** `pull.rebase` — whether `git pull` rebases instead of merging; also accepts `merges`/`interactive` */
 	| 'pull.rebase'
+	/** `rebase.autoStash` — whether `git rebase` (and so a rebasing `git pull`) stashes and reapplies uncommitted changes */
+	| 'rebase.autoStash'
+	/** `rebase.updateRefs` — whether `git rebase` also updates branches pointing to the rebased commits */
+	| 'rebase.updateRefs'
 	| 'user.email'
 	| 'user.name'
 	| 'user.signingkey';
@@ -100,6 +108,16 @@ export interface GitConfigSubProvider {
 		value: string | undefined,
 		options?: { skipInvalidation?: readonly GkConfigInvalidationTarget[] },
 	): Promise<void>;
+	/**
+	 * Drops every gk key stored for `ref` — call when a branch stops existing under that name. Deliberately
+	 * includes user-owned values (`gk-merge-target-user`, `gk-disposition`, `gk-associated-issues`): the
+	 * branch is confirmed gone, and leaving them would hand the next branch reusing that name a dead one's
+	 * starred state and issue links. Only call where git guarantees the name is free —
+	 * a completed delete.
+	 */
+	removeGkConfigBranchSection?(repoPath: string, ref: string): Promise<void>;
+	/** Moves every gk key stored for `oldRef` to `newRef` — call when a branch is renamed. */
+	renameGkConfigBranchSection?(repoPath: string, oldRef: string, newRef: string): Promise<void>;
 
 	getSigningConfig?(repoPath: string): Promise<SigningConfig>;
 	getSigningConfigFlags?(config: SigningConfig): string[];

package/src/git/providers/operations.ts

@@ -112,6 +112,7 @@ export interface GitOperationsSubProvider {
 			 */
 			messageEditor?: string;
 			onto?: string;
+			/** `true` → `--update-refs`, `false` → `--no-update-refs`, omitted → git config (`rebase.updateRefs`) decides. */
 			updateRefs?: boolean;
 			source?: unknown;
 		},

package/src/git/providers/pausedOperations.ts

@@ -10,6 +10,8 @@ export interface GitPausedOperationsSubProvider {
 	continuePausedOperation(
 		repoPath: string,
 		options?: {
+			/** Records the empty commit the operation refused to create, then concludes it (cherry-pick/revert) */
+			allowEmpty?: boolean;
 			skip?: boolean;
 			/** Editor command used if the operation needs to edit a commit message (e.g. `true` to keep the original message without opening an editor) */
 			messageEditor?: string;

package/src/git/providers/status.ts

@@ -37,6 +37,7 @@ export interface GitStatusSubProvider {
 			unstaged?: boolean;
 			untracked?: boolean;
 			throwOnError?: boolean;
+			priority?: GitCommandPriority;
 		},
 		cancellation?: AbortSignal,
 	): Promise<boolean>;

package/src/git/utils/config.utils.ts

@@ -0,0 +1,8 @@
+const falseValues = new Set(['', 'false', 'no', 'off', '0']);
+
+/** Interprets a git config value with git's boolean semantics; `undefined` in → `undefined` out (unset). */
+export function parseGitBoolean(value: string | null | undefined): boolean | undefined {
+	if (value == null) return undefined;
+
+	return !falseValues.has(value.trim().toLowerCase());
+}

package/src/git/utils/issue.utils.ts

@@ -134,6 +134,7 @@ export function serializeIssue(value: IssueShape): IssueShape {
 				: {
 						id: value.author.id,
 						name: value.author.name,
+						username: value.author.username,
 						avatarUrl: value.author.avatarUrl,
 						url: value.author.url,
 					},
@@ -157,6 +158,7 @@ export function serializeIssue(value: IssueShape): IssueShape {
 		assignees: value.assignees.map(assignee => ({
 			id: assignee.id,
 			name: assignee.name,
+			username: assignee.username,
 			avatarUrl: assignee.avatarUrl,
 			url: assignee.url,
 		})),

package/src/git/utils/pausedOperationStatus.utils.ts

@@ -23,30 +23,58 @@ export function getConflictCurrentRef(status: GitPausedOperationStatus): GitRefe
 	return status.current;
 }
 
+/** `name` is the Title Case form for buttons/actions; `prose` is the sentence form ("Cherry-pick paused"). */
 export const pausedOperationStatusStringsByType = {
 	'cherry-pick': {
+		name: 'Cherry Pick',
+		prose: 'Cherry-pick',
 		label: 'Cherry picking',
 		conflicts: 'Resolve conflicts to continue cherry picking',
 		directionality: 'into',
 	},
 	merge: {
+		name: 'Merge',
+		prose: 'Merge',
 		label: 'Merging',
 		conflicts: 'Resolve conflicts to continue merging',
 		directionality: 'into',
 	},
 	rebase: {
+		name: 'Rebase',
+		prose: 'Rebase',
 		label: 'Rebasing',
 		conflicts: 'Resolve conflicts to continue rebasing',
 		directionality: 'onto',
 		pending: 'Pending rebase of',
 	},
 	revert: {
+		name: 'Revert',
+		prose: 'Revert',
 		label: 'Reverting',
 		conflicts: 'Resolve conflicts to continue reverting',
 		directionality: 'in',
 	},
 } as const;
 
+export type PausedOperationVariant = 'conflicts' | 'pending' | 'ready';
+
+/** Codicon per variant — shared so the bar and the WIP badge can't drift. */
+export const pausedOperationVariantIcons: Record<PausedOperationVariant, string> = {
+	conflicts: 'warning',
+	pending: 'circle-outline',
+	ready: 'check',
+};
+
+/** Unresolved conflicts outrank a rebase that hasn't reached its first step — neither can continue, but only conflicts are actionable. */
+export function getPausedOperationVariant(
+	status: GitPausedOperationStatus,
+	hasConflicts: boolean,
+): PausedOperationVariant {
+	if (hasConflicts) return 'conflicts';
+	if (status.type === 'rebase' && status.steps.total === 0) return 'pending';
+	return 'ready';
+}
+
 /**
  * Resolves the correct file paths for each side of a merge conflict diff when the file may have been renamed.
  *

package/src/git/utils/pullRequest.utils.ts

@@ -6,9 +6,23 @@ import type {
 	PullRequestShape,
 	PullRequestSortField,
 	PullRequestSorting,
+	PullRequestStackInfo,
 } from '../models/pullRequest.js';
 import { shortenRevision } from './revision.utils.js';
 
+/** How many pull requests a merge action affects — unstacked is always 1; a stacked merge lands either
+ *  just this layer and everything below it (`position`), or the whole stack (`wholeStack`). The one
+ *  source every merge-confirmation and merge-action label counts from, so they can't drift apart.
+ *  Takes only the two fields it needs (not the full {@link PullRequestStackInfo}) since callers on the
+ *  webview side carry narrower serialized stack shapes. */
+export function getStackedMergeCount(
+	stack: Pick<PullRequestStackInfo, 'position' | 'size'> | undefined,
+	options?: { wholeStack?: boolean },
+): number {
+	if (stack == null) return 1;
+	return options?.wholeStack ? stack.size : stack.position;
+}
+
 /**
  * How each sort field is read off a {@link PullRequestShape}, for the filtered PR search, which MERGES its
  * relationship × state facets in the facade and so has to order the union itself instead of trusting the
@@ -90,6 +104,18 @@ export function getPullRequestIdentityFromMaybeUrl(search: string): PullRequestU
 	return prNumber == null ? undefined : { ownerAndRepo: undefined, prNumber: prNumber, provider: undefined };
 }
 
+/** A pull request's display number from its url, or `undefined` for a url naming no pull request. Anchors
+ *  on the provider's pull request path segment (GitHub `pull`, Bitbucket `pull-requests`, GitLab
+ *  `merge_requests`, Azure `pullrequest`) so a digit-leading owner (`github.com/1Password/x/pull/123`)
+ *  can't win. */
+export function getPullRequestNumberFromUrl(url: string): string | undefined {
+	// No loose fallback: `getPullRequestIdentityFromMaybeUrl` scans for any `/<digits>`, which reads a bare
+	// repository url like `github.com/1Password/sdk` as pull request #1. Callers that hold a real pull
+	// request fall back to its id instead, and the one that asks whether a pasted url names a pull request
+	// needs "no" for an answer.
+	return url.match(/(?:pull|pull-requests|merge_requests|pullrequest)\/(\d+)(?:\b|\/|$)/)?.[1];
+}
+
 export function getRepositoryIdentityForPullRequest(
 	pr: PullRequest,
 	headRepo: boolean = true,
@@ -152,6 +178,7 @@ export function serializePullRequest(value: PullRequest): PullRequestShape {
 		author: {
 			id: value.author.id,
 			name: value.author.name,
+			username: value.author.username,
 			avatarUrl: value.author.avatarUrl,
 			url: value.author.url,
 		},
@@ -203,6 +230,15 @@ export function serializePullRequest(value: PullRequest): PullRequestShape {
 					resourceName: value.project.resourceName,
 				}
 			: undefined,
+		stack: value.stack
+			? {
+					id: value.stack.id,
+					number: value.stack.number,
+					size: value.stack.size,
+					position: value.stack.position,
+					baseRef: value.stack.baseRef,
+				}
+			: undefined,
 	};
 	return serialized;
 }

package/src/git/watching/changeEvent.ts

@@ -85,6 +85,11 @@ export class WatcherRepoChangeEvent {
  */
 export interface WorkingTreeChangeEvent {
 	readonly repoPath: string;
-	/** Absolute paths of changed files (post-gitignore filtering) */
+	/** Absolute paths of changed files (post-gitignore filtering). Partial when {@link incomplete}. */
 	readonly paths: ReadonlySet<string>;
+	/**
+	 * `true` when more paths changed than the accumulator retains, so {@link paths} is a partial set and a
+	 * miss does NOT mean the file is unchanged. Consumers testing membership must treat this as a match.
+	 */
+	readonly incomplete: boolean;
 }

package/src/git/watching/classifyChange.ts

@@ -1,7 +1,7 @@
 import type { RepositoryChange } from '../models/repository.js';
 
 const classifyRegex =
-	/(worktrees|index|HEAD|FETCH_HEAD|ORIG_HEAD|CHERRY_PICK_HEAD|MERGE_HEAD|REBASE_HEAD|rebase-merge|rebase-apply|sequencer|REVERT_HEAD|config|gk\/config|info\/exclude|refs\/(?:heads|remotes|stash|tags))/;
+	/(worktrees|index|HEAD|FETCH_HEAD|ORIG_HEAD|CHERRY_PICK_HEAD|MERGE_HEAD|REBASE_HEAD|rebase-merge|rebase-apply|sequencer|REVERT_HEAD|config|gk\/config|info\/exclude|refs\/(?:heads|remotes|stash|tags)|packed-refs)/;
 
 /**
  * Maps a path relative to a `.git` directory to the corresponding
@@ -69,6 +69,13 @@ export function classifyGitDirChange(relativePath: string): RepositoryChange[] |
 		case 'sequencer':
 			return ['pausedOp'];
 
+		// `'heads'` is deliberately the ONLY thing a `refs/heads/*` event yields, including a create. It is
+		// tempting to read a create as "a new branch exists under this name" and use it to drop anything
+		// derived from the old branch's identity (its base, its merge target). That signal does not mean
+		// what it looks like: git rewrites an EXISTING loose ref by writing `<name>.lock` and renaming it
+		// over the file, which watchers report as a create of the destination — so every ordinary commit
+		// would look like a new branch and discard a live branch's metadata. Nothing here can distinguish
+		// the two; identity changes are handled where GitLens performs the operation itself.
 		case 'refs/heads':
 			return ['heads'];
 
@@ -81,6 +88,13 @@ export function classifyGitDirChange(relativePath: string): RepositoryChange[] |
 		case 'refs/tags':
 			return ['tags'];
 
+		// A `packed-refs` rewrite (after `git pack-refs` or `git gc`) changes ref state
+		// WITHOUT any `refs/**` file event — deleting a packed branch, for example, only
+		// rewrites this file. The file content is not inspected here, so classification
+		// is deliberately broad: it can add, remove, or move refs of any of these types.
+		case 'packed-refs':
+			return ['heads', 'remotes', 'tags'];
+
 		case 'worktrees':
 			return ['worktrees'];
 

package/src/git/watching/watchService.ts

@@ -11,6 +11,13 @@ import type { WatchGroupHooks } from './watchGroup.js';
 import { WatchGroup } from './watchGroup.js';
 import { RepositoryWatchSession } from './watchSession.js';
 
+/**
+ * Cap on paths held while the gitignore filter loads. Higher than the session's own cap because these are
+ * pre-filter — most of a build's output is typically gitignored and would be discarded on replay, so a
+ * tighter bound here would mark batches incomplete when they filter down to almost nothing.
+ */
+const maxBufferedWorkingTreePaths = 5000;
+
 export interface WatchServiceOptions {
 	readonly watchingProvider: FileWatchingProvider;
 	/** Default debounce for repo changes when subscriber doesn't specify. Default: 250ms */
@@ -308,6 +315,7 @@ export class RepositoryWatchService implements UnifiedDisposable {
 		// Buffer events while the gitignore filter loads, then replay
 		let filterReady = filter == null;
 		let buffered: string[] | undefined = filter != null ? [] : undefined;
+		let bufferIncomplete = false;
 
 		if (filter != null) {
 			void filter
@@ -316,11 +324,12 @@ export class RepositoryWatchService implements UnifiedDisposable {
 					filterReady = true;
 					if (buffered?.length) {
 						const paths = filterWorkingTreePaths(buffered, repoPath, filter);
-						if (paths.length > 0) {
-							session.pushWorkingTreeChanges(paths);
+						if (paths.length > 0 || bufferIncomplete) {
+							session.pushWorkingTreeChanges(paths, bufferIncomplete);
 						}
 					}
 					buffered = undefined;
+					bufferIncomplete = false;
 				})
 				.catch(() => {
 					filterReady = true;
@@ -351,7 +360,15 @@ export class RepositoryWatchService implements UnifiedDisposable {
 			}
 
 			if (!filterReady) {
-				// Buffer until gitignore filter is ready
+				// Buffer until the gitignore filter is ready. Capped: `ready()` awaits a `core.excludesFile`
+				// read, which queues behind every other git command, so this window can stay open for a long
+				// time — and these paths haven't been gitignore-filtered yet, so a build's output all lands
+				// here. Past the cap, stop retaining and mark the batch partial rather than growing.
+				if (buffered != null && buffered.length >= maxBufferedWorkingTreePaths) {
+					bufferIncomplete = true;
+					return;
+				}
+
 				buffered?.push(event.path);
 				return;
 			}