@gitkraken/core-gitlens 0.5.113 → 0.5.114

package/src/git/providers/config.ts

@@ -8,6 +8,8 @@ export type GitCoreConfigKeys =
 	| 'core.excludesFile'
 	| 'diff.guitool'
 	| 'diff.tool'
+	/** `fetch.prune` — whether `git fetch` removes remote-tracking branches that no longer exist on the remote */
+	| 'fetch.prune'
 	| 'gpg.format'
 	| 'gpg.program'
 	| 'gpg.ssh.program'
@@ -15,14 +17,20 @@ export type GitCoreConfigKeys =
 	| 'init.defaultBranch'
 	/** `merge.autoStash` — whether `git merge` (and so a merging `git pull`) stashes and reapplies uncommitted changes */
 	| 'merge.autoStash'
+	/** `merge.ff` — whether `git merge` fast-forwards when possible; also accepts `'only'` to require it */
+	| 'merge.ff'
 	/** `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.autosquash` — whether `git rebase` automatically folds `fixup!`/`squash!` commits into the commits they target */
+	| 'rebase.autosquash'
 	/** `rebase.updateRefs` — whether `git rebase` also updates branches pointing to the rebased commits */
 	| 'rebase.updateRefs'
+	/** `remote.pushDefault` — the remote `git push` targets when a branch has no explicit push remote configured */
+	| 'remote.pushDefault'
 	| 'user.email'
 	| 'user.name'
 	| 'user.signingkey';
@@ -54,7 +62,40 @@ export type GkConfigKeys =
 	/** `gk-disposition` — user-assigned branch disposition: 'starred' or 'archived' */
 	| `branch.${string}.gk-disposition`
 	/** `gk.defaultRemote` — the user-designated default remote for the repository */
-	| 'gk.defaultRemote';
+	| 'gk.defaultRemote'
+	/** `gk.maintenanceLastRun` — ISO 8601 timestamp of the last auto-tier git-optimization maintenance pass */
+	| 'gk.maintenanceLastRun'
+	/** `gk.commitGraphDisabled` — `'true'` once the user disables GitLens's automatic commit-graph maintenance for this repo */
+	| 'gk.commitGraphDisabled'
+	/** `gk.fsmonitorNotApplicable` — `'true'` once FSMonitor failed to enable for this repo, so it's never re-suggested */
+	| 'gk.fsmonitorNotApplicable'
+	/** `gk.untrackedCacheNotApplicable` — `'true'` once the untracked cache failed git's filesystem probe here, so it's never re-suggested */
+	| 'gk.untrackedCacheNotApplicable'
+	/**
+	 * `gk.applied.*` — Git Health ownership + undo markers under `[gk "applied"]`. Each value is the lever's
+	 * prior LOCAL-scope value (so undo restores it exactly) or the literal `unset` sentinel when it was absent;
+	 * the marker's mere presence also means "applied by GitLens" (so undo is never offered for a user-enabled
+	 * lever). `backgroundMaintenance` is a presence-only ownership flag (registration is global; undo =
+	 * unregister), and `maintenanceAuto` holds the prior `maintenance.auto` that `git maintenance start` sets
+	 * to false and unregister does not restore.
+	 */
+	| 'gk.applied.untrackedCache'
+	| 'gk.applied.fsmonitor'
+	| 'gk.applied.manyFiles'
+	| 'gk.applied.skipHash'
+	| 'gk.applied.backgroundMaintenance'
+	| 'gk.applied.maintenanceAuto'
+	/** `git maintenance register` sets `maintenance.strategy` too, and `unregister` does NOT restore it. */
+	| 'gk.applied.maintenanceStrategy'
+	/**
+	 * Write-ahead records for direct Git Health config mutations. A pending record is finalized into the
+	 * corresponding `gk.applied.*` marker only after the local config write succeeds; interrupted records are
+	 * reconciled on the next probe so a crash cannot silently lose ownership or claim a failed write.
+	 */
+	| 'gk.pending.untrackedCache'
+	| 'gk.pending.fsmonitor'
+	| 'gk.pending.manyFiles'
+	| 'gk.pending.skipHash';
 
 export type DeprecatedGkConfigKeys = `branch.${string}.gk-target-base`;
 

package/src/git/providers/graph.ts

@@ -80,4 +80,16 @@ export interface GitGraphSubProvider {
 		options?: { limit?: number },
 		cancellation?: AbortSignal,
 	): AsyncGenerator<GitGraphSearchProgress, GitGraphSearch, void>;
+	/**
+	 * Counts commits matching `search` without materializing results — used to probe whether a relaxed
+	 * (broadened) variant of a zero-result search would actually find anything, before offering it as a
+	 * calm inline chip. Optional: providers that can't cheaply count (e.g. GitHub) simply omit it, and
+	 * callers treat a missing implementation the same as "no relaxations available" (never an error).
+	 */
+	countSearchResults?(
+		repoPath: string,
+		search: SearchQuery,
+		options?: { maxCount?: number },
+		cancellation?: AbortSignal,
+	): Promise<number>;
 }

package/src/git/providers/maintenance.ts

@@ -0,0 +1,224 @@
+/**
+ * Git maintenance / optimization sub-provider — the data plane behind the Git Health feature.
+ *
+ * Two tiers of levers (see `.work/dev/git-health/spec.md`):
+ * - **Auto tier** — inert, repo-local maintenance applied silently: the demand-cadence commit-graph
+ *   write and `git maintenance run` one-shots. No config levers — the auto tier never rewrites config.
+ * - **Ask tier** — config levers surfaced for one-click apply/undo (`core.untrackedCache`,
+ *   `core.fsmonitor`, `git maintenance start`, `feature.manyFiles`).
+ *
+ * The commit-graph is a task OF this service, not a thing beside it: `MaintenanceGitSubProvider` owns its
+ * implementation (a direct `git commit-graph write --reachable --split` — usable at 2.24, unlike the 2.30
+ * `maintenance run --task=commit-graph`), its policy, and its demand cadence (minutes throttle + single-flight
+ * keyed by common git dir). `GraphGitSubProvider` and the repo-open shape probe merely `request(...)` it.
+ *
+ * Every method is repo-path-first (so the `RepositoryService` proxy can auto-inject `repoPath`) and
+ * `AbortSignal`-able. The provider is optional — it exists only on the desktop CLI provider, so web
+ * builds and virtual repos never register it (availability is a per-repo capability, `repo.git.maintenance`).
+ */
+
+/**
+ * Auto-tier maintenance tasks. `commit-graph` runs a DIRECT `git commit-graph write --reachable --split`
+ * (2.24+); the others run their native `git maintenance run --task=…` implementations.
+ */
+export type GitMaintenanceTask = 'commit-graph' | 'loose-objects' | 'incremental-repack' | 'pack-refs';
+
+/** The uniform apply/revert surface for every optimization lever (auto + ask). */
+export type GitOptimizationId = 'untrackedCache' | 'fsmonitor' | 'backgroundMaintenance' | 'manyFiles' | 'sparseIndex';
+
+/**
+ * Cheap per-session shape probe — filesystem stats + config reads only, no expensive git walks. Shared
+ * across worktrees (keyed by common path). Everything here is derivable without inflating objects.
+ */
+export interface GitHealthSnapshot {
+	/** Repository shape that changes how the remaining measurements should be interpreted. */
+	readonly repository: {
+		/** Whether local history stops at an intentional shallow boundary; `undefined` when detection failed. */
+		readonly shallow: boolean | undefined;
+		/** Whether missing objects may be supplied by a promisor remote; `undefined` when detection failed. */
+		readonly partial: boolean | undefined;
+		/** Whether the worktree is populated from a sparse specification; `undefined` when config was unreadable. */
+		readonly sparseCheckout: boolean | undefined;
+		/** Whether sparse checkout uses directory-based cone mode; `undefined` when config was unreadable. */
+		readonly sparseCheckoutCone: boolean | undefined;
+		/** Whether the index is configured to use sparse-directory entries; `undefined` when config was unreadable. */
+		readonly sparseIndex: boolean | undefined;
+		/** Whether this worktree uses a split index; `undefined` when detection failed. */
+		readonly splitIndex: boolean | undefined;
+		/** Reference storage selected by the repository format. */
+		readonly refFormat: 'files' | 'reftable' | 'unknown';
+	};
+	/** Bounded loose-reference count for the files ref backend; exact unless the probe reached its cap. */
+	readonly looseRefs: { readonly count: number; readonly exact: boolean };
+	/** Presence + mtime of `objects/info/commit-graph` (or the split `commit-graphs/` chain), and changed-path Bloom filter state. */
+	readonly commitGraph: {
+		readonly present: boolean;
+		readonly mtime: number | undefined;
+		/** Whether the NEWEST graph layer carries changed-path Bloom filters (`BIDX` chunk). */
+		readonly changedPaths: boolean;
+		/** Whether this repo can write them (Git 2.31+ and not a partial clone). */
+		readonly changedPathsSupported: boolean;
+		/** `true` once the user disabled GitLens's automatic commit-graph maintenance for this repo (`gk.commitGraphDisabled`). */
+		readonly disabled: boolean;
+		/**
+		 * `true` when `core.commitGraph` is EXPLICITLY false in the user's git config — git won't read the
+		 * cache, and `ensureCommitGraph` honors the same setting as a write opt-out, so the view must not
+		 * claim the graph is (or will be) maintained.
+		 */
+		readonly readDisabled: boolean;
+	};
+	/** Presence of a classic or incremental multi-pack-index. */
+	readonly multiPackIndex: boolean;
+	/** Whether Git is configured to read/write the multi-pack-index; `undefined` when config was unreadable. */
+	readonly multiPackIndexEnabled: boolean | undefined;
+	/** Count of `*.pack` files in `objects/pack`. */
+	readonly packCount: number;
+	/** Pack files not represented by the active multi-pack-index; `undefined` when it could not be established. */
+	readonly packsOutsideMultiPackIndex: number | undefined;
+	/** Effective `maintenance.incremental-repack.auto` threshold; `undefined` when invalid or unreadable. */
+	readonly incrementalRepackAutoThreshold: number | undefined;
+	/** Total bytes of all `*.pack` files. */
+	readonly packBytes: number;
+	/** Raw loose-object sample (a handful of the 256 fanout dirs); the host extrapolates the estimate. */
+	readonly looseObjects: { readonly objectsInSampledDirs: number; readonly dirsSampled: number };
+	/** Size of the worktree index in bytes (including the largest shared base for a split index). */
+	readonly indexBytes: number;
+	/**
+	 * Entry count from the index header (`DIRC`, version, count — all big-endian). For a normal index this is
+	 * the exact tracked-file count; for a sparse index it counts the populated working set plus sparse-directory
+	 * entries. It is deliberately `undefined` for a split index, whose header covers only its mutable layer,
+	 * and during conflicts, whose stage entries duplicate paths.
+	 */
+	readonly indexEntryCount: number | undefined;
+	/** How {@link indexEntryCount} should be interpreted. */
+	readonly indexEntryCountType: 'full' | 'sparse' | 'split' | 'conflicted' | 'unavailable';
+	/** Current state of the config levers this feature toggles. */
+	readonly config: {
+		readonly fsmonitor: boolean;
+		readonly untrackedCache: boolean;
+		/**
+		 * Whether `core.untrackedCache` carries an explicit value in ANY scope (local/global/system).
+		 * {@link untrackedCache} alone can't tell "unset" from a deliberate `false`/`keep`, and this is the
+		 * one lever the auto tier applies silently — so it only ever fills in an unset value.
+		 */
+		readonly untrackedCacheConfigured: boolean;
+		readonly manyFiles: boolean;
+	};
+	/**
+	 * Whether this repo is registered for system-scheduled `git maintenance` (global `maintenance.repo`).
+	 * `undefined` when the registration list could not be read — never treat that as "not registered": a
+	 * repo the user registered themselves would read as unregistered, get suggested again, and a later
+	 * Undo would silently remove their registration.
+	 */
+	readonly maintenanceRegistered: boolean | undefined;
+	/** `true` once FSMonitor failed to enable here (from the `gk.fsmonitorNotApplicable` marker) — never re-suggest. */
+	readonly fsmonitorNotApplicable: boolean;
+	/** `true` once the untracked cache failed git's filesystem probe here (`gk.untrackedCacheNotApplicable`) — never re-suggest. */
+	readonly untrackedCacheNotApplicable: boolean;
+	/**
+	 * Which levers GitLens itself applied (from the `gk.applied.*` ownership markers). Lets the view render a
+	 * lever the user turned on themselves as "already enabled" (no Undo) versus one GitLens applied (Apply/Undo).
+	 * Distinct from {@link config}, which reports the effective state regardless of who set it.
+	 */
+	readonly applied: {
+		readonly untrackedCache: boolean;
+		readonly fsmonitor: boolean;
+		readonly manyFiles: boolean;
+		readonly backgroundMaintenance: boolean;
+		/** Worktree-scoped ownership; sparse indexes are not shared between linked worktrees. */
+		readonly sparseIndex: boolean;
+	};
+	/** Whether the installed git supports `git maintenance run` (2.30+) — gates the auto-tier tasks. */
+	readonly supportsMaintenanceRun: boolean;
+	/** Whether the installed git includes the `pack-refs` maintenance task (2.31+). */
+	readonly supportsPackRefsMaintenance: boolean;
+}
+
+/** On-demand detail computed only when the Git Health view opens (cheap-ish git walks). */
+export interface GitHealthDetails {
+	/** `git rev-list --count --all` — total reachable commits. `undefined` if the walk failed. */
+	readonly commitCount: number | undefined;
+	/**
+	 * Parsed `git count-objects -v` breakdown. `undefined` if it failed. The `size`, `sizePack`, and
+	 * `sizeGarbage` fields are normalized to BYTES — git itself reports them in KiB.
+	 */
+	readonly countObjects:
+		| {
+				readonly count: number;
+				readonly size: number;
+				readonly inPack: number;
+				readonly packs: number;
+				readonly sizePack: number;
+				readonly prunePackable: number;
+				readonly garbage: number;
+				readonly sizeGarbage: number;
+		  }
+		| undefined;
+}
+
+/** Whether a given optimization lever is available for a repo, with a user-facing reason when it isn't. */
+export interface GitOptimizationCapability {
+	readonly id: GitOptimizationId;
+	readonly supported: boolean;
+	/** Present only when `supported` is `false` — why (git version, platform, virtual FS). */
+	readonly reason?: string;
+	/** Optional caveat to surface even when supported (e.g. `manyFiles` enabling an index older tools can't read). */
+	readonly note?: string;
+}
+
+export interface GitMaintenanceSubProvider {
+	/** Cheap filesystem + config probe of the repo's object store and lever states. */
+	getHealthSnapshot(repoPath: string, cancellation?: AbortSignal): Promise<GitHealthSnapshot>;
+	/** On-demand commit count + `count-objects` breakdown (only when the view opens). */
+	getHealthDetails(repoPath: string, cancellation?: AbortSignal): Promise<GitHealthDetails>;
+	/** Availability of each optimization lever (git version + platform gated). */
+	getCapabilities(repoPath: string): Promise<GitOptimizationCapability[]>;
+	/**
+	 * Hint that a task's cache is worth refreshing now, applying that task's cadence policy. Callers normally
+	 * ignore the returned promise; consumers that need freshness may await it. It resolves `true` only when a
+	 * write completed and `false` when a supported request was gated or failed, and never rejects.
+	 * `commit-graph` runs the demand cadence (minutes throttle + single-flight, both keyed by common git dir),
+	 * fully gated on the auto-tier switches; `loose-objects`/`incremental-repack` are no-ops here (the daily
+	 * pass owns them) and return `undefined`.
+	 */
+	request(repoPath: string, task: GitMaintenanceTask): Promise<boolean> | undefined;
+	/**
+	 * Atomically claims the once-per-`intervalMs` maintenance pass for this repo, stamping the shared
+	 * `gk.maintenanceLastRun` if and only if the claim succeeds. Returns `false` when another window already
+	 * holds it. Read-then-write from the host would not be atomic across VS Code windows, so the claim lives
+	 * here where it can be taken under a real file lock.
+	 */
+	claimMaintenancePass(repoPath: string, intervalMs: number): Promise<boolean>;
+	/**
+	 * Runs a single maintenance task. Resolves `true` when a supported invocation completed and `false` when
+	 * it is not applicable. With `auto`, Git evaluates its native condition and may intentionally do no work.
+	 * A genuine command failure THROWS. `commit-graph` writes directly (2.24+); other tasks go through
+	 * `git maintenance run --task=…` (2.30+).
+	 */
+	runMaintenanceTask(
+		repoPath: string,
+		task: GitMaintenanceTask,
+		options?: { readonly auto?: boolean; readonly cancellation?: AbortSignal },
+	): Promise<boolean>;
+	/**
+	 * Applies an optimization lever. Returns `true` when it took effect; `false` for a legitimate
+	 * not-applicable outcome (e.g. the FSMonitor daemon wouldn't start, or the untracked cache failed git's
+	 * filesystem probe — the config is restored and the repo recorded not-applicable so it's never
+	 * re-suggested). A genuine command failure (config write refused, `maintenance start` errored) THROWS.
+	 * Before mutating, the lever's prior value is recorded so {@link revertOptimization} can restore it.
+	 */
+	applyOptimization(repoPath: string, id: GitOptimizationId, cancellation?: AbortSignal): Promise<boolean>;
+	/**
+	 * Reverts a lever GitLens applied back to its recorded prior value (never a hardcoded inverse). A no-op
+	 * when GitLens didn't apply it (no ownership marker) — a user-enabled lever is never touched. A genuine
+	 * command failure THROWS.
+	 */
+	revertOptimization(repoPath: string, id: GitOptimizationId, cancellation?: AbortSignal): Promise<void>;
+	/**
+	 * Enables or disables GitLens's automatic commit-graph maintenance for this repo — a per-repository off
+	 * switch, distinct from the global `gitlens.gitOptimizations.enabled` master switch. Writes the
+	 * `gk.commitGraphDisabled` marker when disabling; clears it when re-enabling (tolerating an
+	 * already-absent marker). User-clicked, so a genuine write failure THROWS.
+	 */
+	setCommitGraphDisabled(repoPath: string, disabled: boolean, cancellation?: AbortSignal): Promise<void>;
+}

package/src/git/providers/operations.ts

@@ -104,6 +104,16 @@ export interface GitOperationsSubProvider {
 			 * emit `p` instead of `pick`). Both honor the user's git config otherwise.
 			 */
 			programmaticEditor?: boolean;
+			/**
+			 * Tri-state autosquash control. `true` passes `--autosquash`, folding every pending
+			 * `fixup!`/`squash!` commit into its target and reordering the todo accordingly; `false` passes
+			 * `--no-autosquash`, explicitly overriding a `rebase.autosquash=true` git config (omitting the
+			 * flag would let the config fold anyway); `undefined` passes neither, deferring to git config.
+			 * `true` is mutually exclusive with {@link programmaticEditor}, which forces
+			 * `rebase.autosquash=false` so its script-based editor sees a plain, natural-order todo —
+			 * combining them is a programmer error; the CLI provider throws rather than silently dropping one.
+			 */
+			autosquash?: boolean;
 			/**
 			 * Command git uses to edit per-commit messages (the combined message a `squash` produces, or a
 			 * `reword`). Applied as `GIT_EDITOR` — which git's interactive-rebase `reword`/`squash` step honors,

package/src/git/providers/pausedOperations.ts

@@ -15,6 +15,9 @@ export interface GitPausedOperationsSubProvider {
 			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;
+			/** Extra environment for the git process, for `messageEditor` commands that need it (e.g. a
+			 *  wrapper script reading the real editor from the environment) */
+			editorEnv?: Record<string, string>;
 		},
 	): Promise<void>;
 }

package/src/git/providers/provider.ts

@@ -7,6 +7,7 @@ import type { GitConfigSubProvider } from './config.js';
 import type { GitContributorsSubProvider } from './contributors.js';
 import type { GitDiffSubProvider } from './diff.js';
 import type { GitGraphSubProvider } from './graph.js';
+import type { GitMaintenanceSubProvider } from './maintenance.js';
 import type { GitOperationsSubProvider } from './operations.js';
 import type { GitPatchSubProvider } from './patch.js';
 import type { GitPausedOperationsSubProvider } from './pausedOperations.js';
@@ -53,6 +54,7 @@ export interface GitProvider {
 	readonly tags: GitTagsSubProvider;
 
 	readonly blame?: GitBlameSubProvider;
+	readonly maintenance?: GitMaintenanceSubProvider;
 	readonly ops?: GitOperationsSubProvider;
 	readonly patch?: GitPatchSubProvider;
 	readonly pausedOps?: GitPausedOperationsSubProvider;

package/src/git/providers/tags.ts

@@ -25,4 +25,5 @@ export interface GitTagsSubProvider {
 
 	createTag?(repoPath: string, name: string, sha: string, message?: string): Promise<void>;
 	deleteTag?(repoPath: string, name: string): Promise<void>;
+	pushTag?(repoPath: string, name: string | string[], remote: string, options?: { force?: boolean }): Promise<void>;
 }

package/src/git/repositoryService.ts

@@ -49,6 +49,7 @@ export interface RepositoryService {
 
 	// Optional sub-providers
 	readonly blame?: SubProviderForRepo<NonNullable<GitProvider['blame']>>;
+	readonly maintenance?: SubProviderForRepo<NonNullable<GitProvider['maintenance']>>;
 	readonly ops?: SubProviderForRepo<NonNullable<GitProvider['ops']>>;
 	readonly patch?: SubProviderForRepo<NonNullable<GitProvider['patch']>>;
 	readonly pausedOps?: SubProviderForRepo<NonNullable<GitProvider['pausedOps']>>;

package/src/git/run.types.ts

@@ -90,6 +90,14 @@ export interface GitRunOptions {
 	priority?: GitCommandPriority;
 	/** Specifies that this command should always be executed locally if possible (for live share sessions) */
 	runLocally?: boolean;
+	/**
+	 * Marks a command GitLens issues as its OWN maintenance work (the Git Health auto pass, the
+	 * commit-graph write, an explicit "Run Maintenance Now"). Such commands are legitimately slow by
+	 * design, so they are excluded from the `onSlowCommand` health signal — otherwise our own
+	 * optimization work becomes the evidence that recommends more of it. Matching on the git
+	 * subcommand can't express this: the same `update-index`/`status` also serve real user work.
+	 */
+	selfMaintenance?: boolean;
 
 	/**
 	 * If provided, cache the command's result (stdout, stderr, exitCode) in this store via an auto-generated cache key

package/src/git/service.ts

@@ -344,6 +344,9 @@ function createRepositoryService(
 		get blame() {
 			return getProxy('blame', provider.blame);
 		},
+		get maintenance() {
+			return getProxy('maintenance', provider.maintenance);
+		},
 		get ops() {
 			return getProxy('ops', provider.ops);
 		},

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

@@ -174,6 +174,11 @@ export function parseSearchQuery(search: SearchQuery, validate: boolean = false)
 		}
 	}
 
+	if (validate && operations.get('message:')?.size && operations.get('-message:')?.size) {
+		errors ??= [];
+		errors.push("Cannot combine 'message:' and '-message:' in the same query");
+	}
+
 	return {
 		operations: operations,
 		...(errors?.length && { errors: errors }),
@@ -232,6 +237,38 @@ export function parseSearchQueryGitCommand(
 
 					break;
 
+				case '-message:': {
+					// --invert-grep flips ALL --grep patterns in the command, so a query mixing positive
+					// message: terms with negative -message: terms can't be represented in one git invocation.
+					// parseSearchQuery's validate path rejects that combination up front; this is a defensive
+					// fallback for callers that skip validation -- drop the excluded terms rather than
+					// silently inverting the positive matches.
+					if (operations.get('message:')?.size) break;
+
+					let hasValue = false;
+					for (let value of values) {
+						if (!value) continue;
+
+						if (value.startsWith('"') && value.endsWith('"')) {
+							value = value.slice(1, -1);
+							if (!value) continue;
+						}
+
+						if (search.matchWholeWord && search.matchRegex) {
+							value = `\\b${value}\\b`;
+						}
+
+						searchArgs.add(`--grep=${value}`);
+						hasValue = true;
+					}
+
+					if (hasValue) {
+						searchArgs.add('--invert-grep');
+					}
+
+					break;
+				}
+
 				case 'author:':
 					for (let value of values) {
 						if (!value) continue;
@@ -260,6 +297,34 @@ export function parseSearchQueryGitCommand(
 
 					break;
 
+				case 'committer:':
+					for (let value of values) {
+						if (!value) continue;
+
+						if (value.startsWith('"') && value.endsWith('"')) {
+							value = value.slice(1, -1);
+							if (!value) continue;
+						}
+
+						if (value === '@me') {
+							if (!currentUser?.name) continue;
+
+							value = currentUser.name;
+						}
+
+						if (value.startsWith('@')) {
+							value = value.slice(1);
+						}
+
+						if (search.matchWholeWord && search.matchRegex) {
+							value = `\\b${value}\\b`;
+						}
+
+						searchArgs.add(`--committer=${value}`);
+					}
+
+					break;
+
 				case 'type:':
 					for (let value of values) {
 						if (!value) continue;
@@ -276,6 +341,9 @@ export function parseSearchQueryGitCommand(
 							filters.type = 'tip';
 						} else if (value === 'wip') {
 							filters.type = 'wip';
+						} else if (value === 'merge') {
+							filters.type = 'merge';
+							searchArgs.add('--merges');
 						}
 					}
 
@@ -348,6 +416,10 @@ export function parseSearchQueryGitCommand(
 							if (!value) continue;
 						}
 
+						// A value starting with `-` would be consumed by git as an option rather than a ref
+						// (e.g. `ref:--author=x` injecting a flag), so drop it instead of passing it through
+						if (value.startsWith('-')) continue;
+
 						filters.refs = true;
 						// Replace --all with the specific ref or ref range
 						searchArgs.delete('--all');
@@ -358,8 +430,13 @@ export function parseSearchQueryGitCommand(
 			}
 		}
 
-		// Add regex/string matching flags if we have (--grep, --author) patterns
-		if (some(searchArgs.values(), arg => arg.startsWith('--grep=') || arg.startsWith('--author='))) {
+		// Add regex/string matching flags if we have (--grep, --author, --committer) patterns
+		if (
+			some(
+				searchArgs.values(),
+				arg => arg.startsWith('--grep=') || arg.startsWith('--author=') || arg.startsWith('--committer='),
+			)
+		) {
 			searchArgs.add(search.matchRegex ? '--extended-regexp' : '--fixed-strings');
 			if (search.matchRegex && !search.matchCase) {
 				searchArgs.add('--regexp-ignore-case');
@@ -404,6 +481,26 @@ export function parseSearchQueryGitHubCommand(
 				}
 				break;
 
+			case '-message:':
+				for (let value of values) {
+					if (!value) continue;
+
+					if (value.startsWith('"') && value.endsWith('"')) {
+						value = value.slice(1, -1);
+						if (!value) continue;
+					}
+
+					if (search.matchWholeWord && search.matchRegex) {
+						value = `\\b${value}\\b`;
+					}
+
+					// GitHub's search treats a leading '-' on a bare term as an exclusion, so unlike git's
+					// --invert-grep (which flips every --grep in the command), positive and negative message
+					// terms can coexist here -- no mixed-query guard needed for this degradation.
+					queryArgs.push(`-${value.replace(/ /g, '+')}`);
+				}
+				break;
+
 			case 'author:': {
 				for (let value of values) {
 					if (!value) continue;
@@ -414,14 +511,13 @@ export function parseSearchQueryGitHubCommand(
 					}
 
 					if (value === '@me') {
-						if (!currentUser?.name) continue;
+						if (!currentUser?.username) continue;
 
 						value = `@${currentUser.username}`;
 					}
 
 					value = value.replace(/ /g, '+');
 					if (value.startsWith('@')) {
-						value = value.slice(1);
 						queryArgs.push(`author:${value.slice(1)}`);
 					} else if (value.includes('@')) {
 						queryArgs.push(`author-email:${value}`);
@@ -433,11 +529,39 @@ export function parseSearchQueryGitHubCommand(
 				break;
 			}
 
+			case 'committer:': {
+				for (let value of values) {
+					if (!value) continue;
+
+					if (value.startsWith('"') && value.endsWith('"')) {
+						value = value.slice(1, -1);
+						if (!value) continue;
+					}
+
+					if (value === '@me') {
+						if (!currentUser?.username) continue;
+
+						value = `@${currentUser.username}`;
+					}
+
+					value = value.replace(/ /g, '+');
+					if (value.startsWith('@')) {
+						queryArgs.push(`committer:${value.slice(1)}`);
+					} else if (value.includes('@')) {
+						queryArgs.push(`committer-email:${value}`);
+					} else {
+						queryArgs.push(`committer-name:${value}`);
+					}
+				}
+
+				break;
+			}
+
 			case 'type:':
 			case 'file:':
 			case 'change:':
 			case 'ref:':
-				// Not supported in GitHub search
+				// Not supported in GitHub search (type:'s values, including 'merge', have no GitHub commit-search equivalent)
 				break;
 
 			case 'after:':

package/src/git/watching/watchService.ts

@@ -2,6 +2,7 @@ import type { UnifiedDisposable } from '../../utils/disposable.js';
 import type { Event } from '../../utils/event.js';
 import { Emitter } from '../../utils/event.js';
 import { isDescendant, relative } from '../../utils/path.js';
+import type { ResourceUsage } from '../../utils/resourceUsage.js';
 import type { GitDir, RepositoryChange } from '../models/repository.js';
 import type { WatcherRepoChangeEvent } from './changeEvent.js';
 import type { GitIgnoreFilter } from './gitIgnoreFilter.js';
@@ -228,6 +229,15 @@ export class RepositoryWatchService implements UnifiedDisposable {
 		return this.sessionMap.get(repoPath)?.session;
 	}
 
+	/** Resource usage retained by repository watchers. */
+	getResourceUsage(): ResourceUsage {
+		return {
+			'watch.sessions.count': this.sessionMap.size,
+			'watch.groups.count': this.watchGroups.size,
+			'watch.workingTreeWatchers.count': this.wtWatchers.size,
+		};
+	}
+
 	/** Suspend all sessions and mark the service suspended so late-joining sessions start suspended */
 	suspendAll(): void {
 		this._suspended = true;