@gitkraken/core-gitlens 0.15.3 → 0.15.5

package/CHANGELOG.md

@@ -6,6 +6,48 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/) and this p
 
 ## [Unreleased]
 
+## [0.15.5] - 2026-10-22
+
+### Added
+
+- Adds optional `refs` and `options.configConfinedToRefs` to `GitServiceHooks.repository.onChanged`: `refs` are the full ref names a write created, moved or deleted, and a ref kind with names among them is fully described by them, so a host can skip work for refs it doesn't follow; `configConfinedToRefs` says the write changed `.git/config` only in the `branch.<name>` sections of the local branches `refs` names. Siblings sharing the repository hear the names and the flag with the shared kinds. Branch create, delete, rename and upstream changes, `checkout -b`, a worktree's new branch, a commit (its branch, read from the worktree's `HEAD` before and after the run, and named only when both agree) and stash writes (`refs/stash`, by a pop only when it dropped the entry) name their refs; a host that ignores them treats every kind as unnamed, as before (git, git-cli)
+
+### Changed
+
+- Changes how the watch layer tells a write's own reports from outside changes once announcements name refs: a raw report is the write's echo only when every ref it names, or every branch whose config section it changed, is among those the write announced (or it reports `HEAD`, which a commit locks, under a write that announced `head`), and it arrives within the debounce delay of the announcement, so an outside change to another ref or config section, or a later change to the same ref, is kept and reaches its subscribers unannounced. A watch group now diffs the shared `.git/config` by section on each report (one read for every worktree of the repository) and delivers a change confined to `branch.<name>` sections as confined to those branches (`WatcherRepoChangeEvent.configBranches`, `mayHaveChangedConfig`), whoever wrote it; anything else, an unreadable or unparsable file, a read that doesn't settle within 5 seconds, or another config file is unconfined. Ref-filtered subscriptions and worktree summaries narrow a confined change like a named ref (git)
+
+### Fixed
+
+- Fixes worktree summaries keeping an outdated ahead-of-base target after checkout-specific Git configuration changes. Each checkout now compares its effective configuration, including branch-conditional includes, with the configuration used for its current base.
+- Fixes a fetch announcing `remotes` to every worktree of the repository, and resetting the branch and tag caches, whether or not anything moved, so each worktree summary re-read its base after every fetch: in a Kepler daemon with ~60 worktrees one task launch cost ~490 git processes. A fetch now compares the refs it can write (its refspecs' destinations, the fetched remotes' configured destinations, symref targets included, and tags) before and after it runs, announces nothing when none moved, and otherwise names exactly what moved; a snapshot it can't read falls back to the previous announcement (git-cli)
+- Fixes deleting, creating or renaming a branch making every worktree of the repository re-read its base, since the write's `.git/config` change and the watcher's later report of it reached every subscriber; one task removal cost ~460 git processes over ~60 worktrees (git, git-cli)
+
+## [0.15.4] - 2026-10-22
+
+### Added
+
+- Adds an optional `getPushTarget` to `GitBranchesSubProvider`: where a branch (the checked-out one by default) pushes to and its upstream, each as a full ref name with its commit, read from the cached ref list so a warm call runs no git. The destination is git's own `%(push)`, which follows `push.default`, `remote.pushDefault`, `branch.<name>.pushRemote`, push refspecs and mirror remotes, and is named even before its ref exists (with no commit). `known: false` means the ref list couldn't be read; a detached HEAD has no destination. The shared `for-each-ref` now reads `%(push)` for every ref, so `RefRecord` gains a `push` field (git, git-cli)
+- Adds an optional `getAheadOfBaseConfigKey` to `GitBranchesSubProvider`, an opaque snapshot of the Git config inputs to `getAheadOfBase` (every branch's tracking, the remotes and `init.defaultBranch`, not the stored gk merge targets or base): two equal snapshots mean that config can't have changed the base. `undefined` means it couldn't be read; the CLI provider reads it once for every worktree of a repository, and a provider without it leaves a worktree summary re-reading its base on every config change (git, git-cli)
+
+### Changed
+
+- Changes the `ref` that `WatchGroupHooks.onRepoChanged` and `RepositoryWatchSession.pushRepoChanges` take to `string | false`, where `false` reports a `.git/config` (or `config.worktree`) change that moved no ref. Its change kinds (`config`, `remotes`) still clear caches as before, but the event's `mayHaveChangedRef` no longer answers `true` for every remote-tracking ref because of it. A poll now also reads the `refs/remotes` directory, which `git remote remove` and `git remote rename` change whether the remote's refs are loose or packed, so a polled repository still reports a removed or renamed remote's refs as possibly moved, while a config write alone, like `git branch --set-upstream-to`, names no ref (git)
+- Changes `getGkConfig`, `getGkConfigRegex`, `getStoredDetectedMergeTargetBranchName` and `getStoredUserMergeTargetBranchName` to log at trace level rather than debug, and a gk config lookup to no longer enter (and log) the one-time `.git/gk/config` migration once it ran for the repository: they are served from the cached map, and a cold read's `git config` still logs its own line (git-cli)
+
+### Fixed
+
+- Fixes Azure DevOps filtered work item searches failing across large sets of project workflows or when workflow metadata changes during pagination. Search and count queries stay within the server's query length limit, preserve its ordering, and can be canceled without interrupting other reads ([#6041](https://github.com/gitkraken/vscode-gitlens/issues/6041)).
+- Fixes every checkout sharing a `.git/gk/config` re-reading the whole file (a `git config --get-regex` each) when the watcher reports a change to it, core's own writes included, so a branch-activity stamp reported by three checkouts read it four times. A report of a file unchanged since the cached map was read (same inode, size and change times, with the read's stat taken safely after the file's last change: 2 seconds for a filesystem keeping whole-second times, 50 ms otherwise) now keeps the map, and still diffs it against the reconcile's baseline, so a read landing between another process's write and its report doesn't lose the change; a changed file is re-read as before (git, git-cli)
+- Fixes `getAheadOfBase` spawning a failing `git rev-parse <ref>@{u}` on every read whose candidate base is a remote-tracking ref or a tag (`origin/main`, the usual default branch), since git can't cache a failed lookup: a candidate the cached ref list shows can't have an upstream is no longer asked for one, and the result is unchanged. The base a branch's reflog says it was created from is checked the same way (git-cli)
+- Fixes a `.git/config` write making every subscribed worktree summary of the repository re-read its base at once, a full `getAheadOfBase` each: in a Kepler daemon over ~100 worktrees of one repository, one write cost ~65 reads in a burst. A summary now keeps its base when the config inputs to it (every branch's tracking, the remotes and `init.defaultBranch`), its stored merge targets, HEAD and upstream are unchanged, and at most four summaries of a repository, and eight across repositories, read at once, so a burst in one repository, or reads hung in it, never holds up another repository's summaries, and a start over many repositories never runs four reads for each. The config read itself (`git config --null --get-regexp`) is shared by every worktree of the repository rather than spawned by each, and any config change hard-evicts it, core's own writes included, so a read after the change never joins one that started before it (git, git-cli)
+- Fixes Azure DevOps Services account-wide pull request reads (`listPullRequestsPage`, the sweeps and the Launchpad search) returning no authored or review-requested pull requests, and failing the group read with "Azure DevOps returned no group membership for the current user", for accounts whose profile id differs from their identity in an organization: the creator and reviewer filters, the group read and each row's `viewer` and `authoredByMe` now use the user's identity in that organization, read from its `ConnectionData` once per credential and organization (in parallel, dropped on a re-sync), as Azure DevOps Server already did per collection; `getPullRequestsBatch` and `getPullRequestsForBranches` match authorship the same way. An organization whose identity can't be read is reported as a failure scoped to it while the others' pull requests are kept, as Azure DevOps Server already did per collection; an organization or collection refusing the credential (a 401 or 403) is now scoped the same way, where it failed the whole read, and a credential refused everywhere still fails it. A row with reviewers or assignees but no author now gets a `viewer`, and its `authoredByMe` is `undefined` rather than `false`, for every provider ([#6032](https://github.com/gitkraken/vscode-gitlens/issues/6032)) (plus/integrations)
+- Fixes Azure DevOps Server repository scopes that a caller parsed from a remote. Before, they were settled once to order `listIssuesPage` and then again for the read. Now the read gets the scopes that were counted, and a discovery that expires in between can't change them. Other fixes in the same reads:
+  - A scope that settles to a repository the connection doesn't serve is read as given and flagged as unsettled. A batch or branch miss for it is now rejected, and a list read reports it in a warning, instead of reporting a proven absence.
+  - When the connection addresses a collection, a scope naming that collection is read as given while the collection list can't be read. Before, it was flagged as unsettled, and its batch and branch misses were rejected. The address is presumed to name a collection when its collection list answers 404 and the collection's own connection data can't be read, for as long as that failed discovery is kept.
+  - A connection path segment with an encoded `/` no longer splits into two virtual directory segments, which left a scope below it unsettled.
+
+  `resolveRepositoryScopes` now returns `{ repos, unsettled }`. A failure to settle is reported as `{ error }` instead of returning the scopes as given ([#6040](https://github.com/gitkraken/vscode-gitlens/issues/6040)) (plus/integrations)
+
 ## [0.15.3] - 2026-10-21
 
 ### Fixed
@@ -804,7 +846,9 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/) and this p
 
 - Initial release. Bundles `@gitlens/utils`, `@gitlens/git`, `@gitlens/git-cli`, `@gitlens/ai`, and `@gitlens/git-github` into a single core npm package with subpath exports.
 
-[unreleased]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.15.3...HEAD
+[unreleased]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.15.5...HEAD
+[0.15.5]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.15.4...gitkraken:releases/core/v0.15.5
+[0.15.4]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.15.3...gitkraken:releases/core/v0.15.4
 [0.15.3]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.15.2...gitkraken:releases/core/v0.15.3
 [0.15.2]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.15.1...gitkraken:releases/core/v0.15.2
 [0.15.1]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.15.0...gitkraken:releases/core/v0.15.1

package/dist/git/cache.d.ts

@@ -109,6 +109,7 @@ export declare class Cache implements Disposable {
   dispose(): void;
   /** Resource usage retained by instantiated sub-caches and their bookkeeping maps. */
   getResourceUsage(): ResourceUsage;
+  get aheadOfBaseConfigKey(): PromiseMap<RepoPath, string | undefined>;
   get bestRemotes(): PromiseMap<RepoPath, GitRemote<RemoteProvider>[]>;
   get blame(): RepoPromiseCacheMap<string, ProgressiveGitBlame | undefined>;
   get diff(): RepoPromiseCacheMap<string, ParsedGitDiffHunks | undefined>;
@@ -237,17 +238,17 @@ export declare class Cache implements Disposable {
    * Call this when a worktree is deleted or a repo is closed so stale registry entries
    * and derived cache entries don't persist.
    *
-   * Targeted — does NOT cascade to sibling worktrees sharing the same commonPath. The
-   * shared commonPath entry in each shared cache is only evicted when unregistering the
-   * last remaining worktree for that commonPath (otherwise siblings still depend on it).
-   *
-   * Uses soft-invalidate where supported so any in-flight factory/mapper keeps its abort
+   * Targeted — does NOT cascade to sibling worktrees sharing the same commonPath. Shared caches
+   * stay warm until the last worktree closes, except raw git results co-located with a closing main
+   * checkout: those must retire with its config fingerprint so reopening cannot attest an old command
+   * with new config. Detached promises keep their existing callers and abort wiring. Other entries
+   * use soft-invalidate where supported so any in-flight factory/mapper keeps its abort
    * wiring intact — a caller whose signal aborts after unregister can still propagate
    * cancellation into the underlying work rather than leaving it orphaned. Controller-backed
    * entries self-evict on settle; plain `.set()`-based entries hard-delete immediately.
    *
-   * Cache eviction is a no-op if `repoPath` is not registered, but the status clock is advanced
-   * unconditionally (a fresh registration must not let a post-reopen read join a pre-close one).
+   * The status clock advances even for an unregistered path so a fresh registration cannot join a
+   * status read that started before it.
    */
   unregisterRepoPath(repoPath: string): void;
   reset(): void;
@@ -267,12 +268,12 @@ export declare class Cache implements Disposable {
     worktreeOnly?: boolean;
   }): CachedGitTypes[];
   /**
-   * Handles a watcher-observed `'gkConfig'` change. Always evicts the cached bulk map (forcing the
-   * next read to hit disk). If a reconciler is registered (see {@link setGkConfigReconciler}),
-   * defers to it instead of coarsely clearing `baseBranchName`/`branchOverviews` — it re-reads the
-   * map and diffs it against the snapshot captured here (i.e. as it stood right before this change),
-   * cascading only the refs whose merge-relevant keys actually changed. Falls back to the coarse
-   * clear when no reconciler is registered (e.g. the GitHub provider) so nothing can go stale.
+   * Handles a watcher-observed `'gkConfig'` change. If a reconciler is registered (see {@link setGkConfigReconciler}),
+   * defers to it instead of coarsely clearing `baseBranchName`/`branchOverviews` — it evicts the cached bulk map
+   * unless the file is unchanged since the map was read, reads it, and diffs it against the snapshot captured here
+   * (i.e. as it stood right before this change), cascading only the refs whose merge-relevant keys actually
+   * changed. Falls back to evicting the map and the coarse clear when no reconciler is registered (e.g. the GitHub
+   * provider) so nothing can go stale.
    */
   private handleGkConfigChanged;
   /**
@@ -298,9 +299,9 @@ export declare class Cache implements Disposable {
   /**
    * The whole `.git/gk/config` is read once and cached as a single map per commonPath; per-key and
    * per-namespace gk lookups are served from it in-memory (see `getGkConfigMap` in the CLI config
-   * sub-provider). Invalidated by `deleteGkConfig` (write) and, on a watcher `'gkConfig'` event, by
-   * `handleGkConfigChanged` (reconciled precisely when a reconciler is registered, or the coarse
-   * clear otherwise). The first fresh read seeds the snapshot used by
+   * sub-provider). Invalidated by `deleteGkConfig` (write) and, on a watcher `'gkConfig'` event, by the
+   * reconciler when the file changed since the map was read (see {@link setGkConfigReconciler}), or by
+   * `handleGkConfigChanged`'s coarse clear when none is registered. The first fresh read seeds the snapshot used by
    * `reconcileGkConfigMap`; later refreshes of that snapshot are owned by the reconcile itself.
    */
   getGkConfigMap(repoPath: string, factory: (cacheable: CacheController) => PromiseOrValue<Map<string, string>>): Promise<Map<string, string>>;
@@ -343,11 +344,18 @@ export declare class Cache implements Disposable {
    * `'gkConfig'` change. Only one reconciler is kept — later registrations replace earlier ones,
    * which is harmless since every CLI config sub-provider sharing this `Cache` reconciles the same
    * underlying `.git/gk/config` file identically.
+   *
+   * The reconciler owns the cached bulk map: it is called synchronously as the change is reported, and must
+   * hard-delete the map ({@link deleteGkConfigMap}) before it returns unless it knows the map still reflects the
+   * file — a read after the change must see it, and the reconcile's own read must not ride a bulk read that
+   * started before it. Only the reconciler can inspect the file, and keeping the map spares a re-read for every
+   * report of an unchanged file (one per worktree sharing it, and one for each of core's own writes).
    */
   setGkConfigReconciler(reconciler: (repoPath: string, priorSnapshot: ReadonlyMap<string, string> | undefined) => PromiseOrValue<GkReconcileOutcome>): void;
   /**
-   * Diffs a freshly-read gk config map's tracked subset against `priorSnapshot` (captured by
-   * `handleGkConfigChanged` before the reconcile started, so it reflects the pre-change state), cascading
+   * Diffs the tracked subset of a gk config map (read after the change, or kept as still reflecting the file)
+   * against `priorSnapshot` (captured by `handleGkConfigChanged` before the reconcile started, so it reflects the
+   * pre-change state), cascading
    * `baseBranchName`/`branchOverviews` for every ref whose merge-relevant key actually changed, then firing
    * {@link onDidChangeMergeTargets} naming those refs. Changed branch metadata keys (another process's
    * activity stamps or disposition) are patched into the cached branches in one call, and never fire the event.
@@ -415,6 +423,8 @@ export declare class Cache implements Disposable {
    */
   deleteBranchMetadata(repoPath: string): void;
   getBranchMergedStatus(repoPath: string, cacheKey: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<GitBranchMergedStatus>, cancellation?: AbortSignal): Promise<GitBranchMergedStatus>;
+  /** Config can differ by checkout through config.worktree and conditional includes. */
+  getAheadOfBaseConfigKey(repoPath: string, factory: (repoPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<string | undefined>, cancellation?: AbortSignal): Promise<string | undefined>;
   getBranchMetadataMap(repoPath: string, factory: (commonPath: string) => PromiseOrValue<Map<string, BranchMetadata>>): Promise<Map<string, BranchMetadata>>;
   getDefaultBranchName(repoPath: string, remote: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<string | undefined>, cancellation?: AbortSignal): Promise<string | undefined>;
   /** Clears the cached default branch for one `remote` key (the networked lookup or its `:local` variant). */

package/dist/git/cache.js

@@ -81,6 +81,7 @@ const sharedCacheKeys = new Set(exhaustiveArray()([
 ]));
 function createEmptyCaches() {
 	return {
+		aheadOfBaseConfigKey: void 0,
 		baseBranchName: void 0,
 		bestRemotes: void 0,
 		blame: void 0,
@@ -183,6 +184,9 @@ var Cache = class Cache {
 		usage["cache.gkConfigSnapshots.entries.count"] = this._gkConfigSnapshots.size;
 		return usage;
 	}
+	get aheadOfBaseConfigKey() {
+		return this._caches.aheadOfBaseConfigKey ??= new PromiseMap();
+	}
 	get bestRemotes() {
 		return this._caches.bestRemotes ??= new PromiseMap();
 	}
@@ -414,7 +418,10 @@ var Cache = class Cache {
 				keysToClear.add("reachability");
 				keysToClear.add("resolvedRevisions");
 			}
-			if (types.includes("branch")) keysToClear.add("baseBranchName");
+			if (types.includes("branch")) {
+				keysToClear.add("aheadOfBaseConfigKey");
+				keysToClear.add("baseBranchName");
+			}
 			if (types.includes("branches")) {
 				keysToClear.add("branchMetadataMap");
 				keysToClear.add("branches");
@@ -426,6 +433,7 @@ var Cache = class Cache {
 				keysToClear.add("refTips");
 			}
 			if (types.includes("config")) {
+				keysToClear.add("aheadOfBaseConfigKey");
 				keysToClear.add("baseBranchName");
 				keysToClear.add("configKeys");
 				keysToClear.add("configPatterns");
@@ -482,8 +490,12 @@ var Cache = class Cache {
 			const cache = this._caches[key];
 			if (cache == null) continue;
 			if (repoPath == null) cache.clear();
+			else if (key === "aheadOfBaseConfigKey" && !worktreeOnly && (!types.length || types.includes("config"))) this.evictShared(key, repoPath, "evict");
 			else if (sharedCacheKeys.has(key)) {
-				if (!worktreeOnly) this.evictShared(key, repoPath, inFlight);
+				if (!worktreeOnly) {
+					const hardEvict = key === "gitResults" && (types.includes("config") || types.includes("branch"));
+					this.evictShared(key, repoPath, hardEvict ? "evict" : inFlight);
+				}
 			} else cache.delete(repoPath);
 		}
 	}
@@ -590,6 +602,12 @@ var Cache = class Cache {
 	registerRepoPath(repoPath, gitDir) {
 		const normalizedPath = getRepositoryOrWorktreePath(repoPath);
 		const commonPath = gitDir.commonUri != null ? getCommonRepositoryPath(gitDir.commonUri) : normalizedPath;
+		const previousCommonPath = this._commonPathRegistry.get(normalizedPath);
+		if (previousCommonPath != null && previousCommonPath !== commonPath) this.unregisterRepoPath(normalizedPath);
+		if (previousCommonPath !== commonPath) {
+			this._caches.aheadOfBaseConfigKey?.delete(normalizedPath);
+			this._caches.gitResults?.delete(normalizedPath);
+		}
 		this._commonPathRegistry.set(normalizedPath, commonPath);
 		let worktrees = this._worktreesByCommonPath.get(commonPath);
 		if (worktrees == null) {
@@ -605,17 +623,17 @@ var Cache = class Cache {
 	* Call this when a worktree is deleted or a repo is closed so stale registry entries
 	* and derived cache entries don't persist.
 	*
-	* Targeted — does NOT cascade to sibling worktrees sharing the same commonPath. The
-	* shared commonPath entry in each shared cache is only evicted when unregistering the
-	* last remaining worktree for that commonPath (otherwise siblings still depend on it).
-	*
-	* Uses soft-invalidate where supported so any in-flight factory/mapper keeps its abort
+	* Targeted — does NOT cascade to sibling worktrees sharing the same commonPath. Shared caches
+	* stay warm until the last worktree closes, except raw git results co-located with a closing main
+	* checkout: those must retire with its config fingerprint so reopening cannot attest an old command
+	* with new config. Detached promises keep their existing callers and abort wiring. Other entries
+	* use soft-invalidate where supported so any in-flight factory/mapper keeps its abort
 	* wiring intact — a caller whose signal aborts after unregister can still propagate
 	* cancellation into the underlying work rather than leaving it orphaned. Controller-backed
 	* entries self-evict on settle; plain `.set()`-based entries hard-delete immediately.
 	*
-	* Cache eviction is a no-op if `repoPath` is not registered, but the status clock is advanced
-	* unconditionally (a fresh registration must not let a post-reopen read join a pre-close one).
+	* The status clock advances even for an unregistered path so a fresh registration cannot join a
+	* status read that started before it.
 	*/
 	unregisterRepoPath(repoPath) {
 		this.incrementStatusGeneration(repoPath);
@@ -626,6 +644,11 @@ var Cache = class Cache {
 		for (const key of Object.keys(this._caches)) {
 			const cache = this._caches[key];
 			if (cache == null) continue;
+			if (key === "aheadOfBaseConfigKey" || key === "gitResults") {
+				cache.delete(repoPath);
+				if (key === "gitResults" && isLastWorktree && repoPath !== commonPath) cache.delete(commonPath);
+				continue;
+			}
 			const invalidate = cache.invalidate;
 			const evict = typeof invalidate === "function" ? (k) => invalidate.call(cache, k) : (k) => cache.delete(k);
 			if (sharedCacheKeys.has(key)) {
@@ -681,7 +704,11 @@ var Cache = class Cache {
 			types.add("fileLog");
 		}
 		if (hasAny("index")) types.add("tracking");
-		if (hasAny("config")) types.add("config");
+		if (hasAny("config")) {
+			types.add("config");
+			types.add("branches");
+			types.add("worktrees");
+		}
 		if (hasAny("heads")) {
 			types.add("branches");
 			types.add("contributors");
@@ -708,22 +735,30 @@ var Cache = class Cache {
 		return [...types];
 	}
 	/**
-	* Handles a watcher-observed `'gkConfig'` change. Always evicts the cached bulk map (forcing the
-	* next read to hit disk). If a reconciler is registered (see {@link setGkConfigReconciler}),
-	* defers to it instead of coarsely clearing `baseBranchName`/`branchOverviews` — it re-reads the
-	* map and diffs it against the snapshot captured here (i.e. as it stood right before this change),
-	* cascading only the refs whose merge-relevant keys actually changed. Falls back to the coarse
-	* clear when no reconciler is registered (e.g. the GitHub provider) so nothing can go stale.
+	* Handles a watcher-observed `'gkConfig'` change. If a reconciler is registered (see {@link setGkConfigReconciler}),
+	* defers to it instead of coarsely clearing `baseBranchName`/`branchOverviews` — it evicts the cached bulk map
+	* unless the file is unchanged since the map was read, reads it, and diffs it against the snapshot captured here
+	* (i.e. as it stood right before this change), cascading only the refs whose merge-relevant keys actually
+	* changed. Falls back to evicting the map and the coarse clear when no reconciler is registered (e.g. the GitHub
+	* provider) so nothing can go stale.
 	*/
 	handleGkConfigChanged(repoPath) {
 		const commonPath = this.getCommonPath(repoPath);
-		this._caches.gkConfigMap?.delete(commonPath);
 		if (this._gkConfigReconciler == null) {
+			this._caches.gkConfigMap?.delete(commonPath);
 			this.clearGkConfigCoarsely(repoPath);
 			return;
 		}
 		const priorSnapshot = this._gkConfigSnapshots.get(commonPath);
-		Promise.resolve(this._gkConfigReconciler(repoPath, priorSnapshot)).then((outcome) => {
+		let outcome;
+		try {
+			outcome = this._gkConfigReconciler(repoPath, priorSnapshot);
+		} catch {
+			this._caches.gkConfigMap?.delete(commonPath);
+			this.clearGkConfigCoarsely(repoPath);
+			return;
+		}
+		Promise.resolve(outcome).then((outcome) => {
 			if (outcome === "failed") this.clearGkConfigCoarsely(repoPath);
 		}, () => this.clearGkConfigCoarsely(repoPath));
 	}
@@ -798,9 +833,9 @@ var Cache = class Cache {
 	/**
 	* The whole `.git/gk/config` is read once and cached as a single map per commonPath; per-key and
 	* per-namespace gk lookups are served from it in-memory (see `getGkConfigMap` in the CLI config
-	* sub-provider). Invalidated by `deleteGkConfig` (write) and, on a watcher `'gkConfig'` event, by
-	* `handleGkConfigChanged` (reconciled precisely when a reconciler is registered, or the coarse
-	* clear otherwise). The first fresh read seeds the snapshot used by
+	* sub-provider). Invalidated by `deleteGkConfig` (write) and, on a watcher `'gkConfig'` event, by the
+	* reconciler when the file changed since the map was read (see {@link setGkConfigReconciler}), or by
+	* `handleGkConfigChanged`'s coarse clear when none is registered. The first fresh read seeds the snapshot used by
 	* `reconcileGkConfigMap`; later refreshes of that snapshot are owned by the reconcile itself.
 	*/
 	getGkConfigMap(repoPath, factory) {
@@ -877,13 +912,20 @@ var Cache = class Cache {
 	* `'gkConfig'` change. Only one reconciler is kept — later registrations replace earlier ones,
 	* which is harmless since every CLI config sub-provider sharing this `Cache` reconciles the same
 	* underlying `.git/gk/config` file identically.
+	*
+	* The reconciler owns the cached bulk map: it is called synchronously as the change is reported, and must
+	* hard-delete the map ({@link deleteGkConfigMap}) before it returns unless it knows the map still reflects the
+	* file — a read after the change must see it, and the reconcile's own read must not ride a bulk read that
+	* started before it. Only the reconciler can inspect the file, and keeping the map spares a re-read for every
+	* report of an unchanged file (one per worktree sharing it, and one for each of core's own writes).
 	*/
 	setGkConfigReconciler(reconciler) {
 		this._gkConfigReconciler = reconciler;
 	}
 	/**
-	* Diffs a freshly-read gk config map's tracked subset against `priorSnapshot` (captured by
-	* `handleGkConfigChanged` before the reconcile started, so it reflects the pre-change state), cascading
+	* Diffs the tracked subset of a gk config map (read after the change, or kept as still reflecting the file)
+	* against `priorSnapshot` (captured by `handleGkConfigChanged` before the reconcile started, so it reflects the
+	* pre-change state), cascading
 	* `baseBranchName`/`branchOverviews` for every ref whose merge-relevant key actually changed, then firing
 	* {@link onDidChangeMergeTargets} naming those refs. Changed branch metadata keys (another process's
 	* activity stamps or disposition) are patched into the cached branches in one call, and never fire the event.
@@ -1083,6 +1125,10 @@ var Cache = class Cache {
 			};
 		}, { cancellation });
 	}
+	/** Config can differ by checkout through config.worktree and conditional includes. */
+	getAheadOfBaseConfigKey(repoPath, factory, cancellation) {
+		return this.aheadOfBaseConfigKey.getOrCreate(repoPath, (cacheable, signal) => Promise.resolve(factory(repoPath, cacheable, signal)), cancellation);
+	}
 	getBranchMetadataMap(repoPath, factory) {
 		return this.getSharedSimple(this.branchMetadataMap, repoPath, factory);
 	}
@@ -1176,10 +1222,10 @@ var Cache = class Cache {
 		}
 		return sharedPromise;
 	}
-	async getSharedSimple(cache, repoPath, factory) {
+	async getSharedSimple(cache, repoPath, factory, cancellation) {
 		const commonPath = this.getCommonPath(repoPath);
 		if (cache instanceof PromiseCache) return cache.getOrCreate(commonPath, (cacheable) => Promise.resolve(factory(commonPath, cacheable)));
-		return cache.getOrCreate(commonPath, (cacheable) => Promise.resolve(factory(commonPath, cacheable)));
+		return cache.getOrCreate(commonPath, (cacheable, signal) => Promise.resolve(factory(commonPath, cacheable, signal)), cancellation);
 	}
 	async getSharedSimpleWithKey(cache, repoPath, cacheKey, factory, options) {
 		const commonPath = this.getCommonPath(repoPath);