@gitkraken/core-gitlens 0.12.0 → 0.14.0

package/dist/git-cli/providers/branches.js

@@ -1,33 +1,74 @@
+import { sum } from "../../utils/iterable.js";
 import { ensureArray, filterMap } from "../../utils/array.js";
 import { CancellationError, isCancellationError } from "../../utils/cancellation.js";
 import { Logger as _logger } from "../../utils/logger.js";
 import { getScopedLogger } from "../../utils/logger.scoped.js";
-import { getSettledValue } from "../../utils/promise.js";
-import { debug } from "../../utils/decorators/log.js";
+import { getSettledValue, mapBounded } from "../../utils/promise.js";
+import { debug, trace } from "../../utils/decorators/log.js";
 import { getBranchId } from "../../utils/gitRefs.js";
 import { normalizePath } from "../../utils/path.js";
 import { createRevisionRange, shortenRevision } from "../../git/utils/revision.utils.js";
+import { formatDetachedHeadName, getLocalBranchByUpstream, isDetachedHead, isRemoteHEAD, parseBranchMetadataGkConfigKey, parseRefName, parseUpstream, setBranchMetadataValue } from "../../git/utils/branch.utils.js";
 import { createReference } from "../../git/utils/reference.utils.js";
 import __decorate from "../../_virtual/@oxc-project+runtime/helpers/esm/decorate.js";
 import { BranchError, GitWarnings } from "../../git/errors.js";
+import { mayWriteTracking } from "../exec/commandClassifier.js";
+import { KeyedSequencer } from "../exec/indexLock.js";
 import { GitError, GitErrors, getGitCommandError, gitConfigsBranch, gitConfigsLog } from "../exec/git.js";
 import { maybeStopWatch } from "../../utils/stopwatch.js";
 import _usingCtx from "../../_virtual/@oxc-project+runtime/helpers/esm/usingCtx.js";
-import { formatDetachedHeadName, getLocalBranchByUpstream, isDetachedHead, isRemoteHEAD, parseRefName, parseUpstream } from "../../git/utils/branch.utils.js";
 import { GitBranch } from "../../git/models/branch.js";
 import { createConflictDetectionError } from "../../git/utils/mergeConflicts.utils.js";
 import { sortBranches, sortContributors } from "../../git/utils/sorting.js";
-import { debounce } from "../../utils/decorators/debounce.js";
+import { LruMap } from "../../utils/lruMap.js";
 import { PageableResult, emptyPagedResult } from "../../utils/paging.js";
 import { parseMergeTreeConflict } from "../parsers/mergeTreeParser.js";
+import { resolveBranchRemote } from "./branchRemote.js";
 //#region ../git-cli/src/providers/branches.ts
 /** Minimum time between writes to the config for last accessed/modified dates */
 const dateMetadataStaleThresholdMs = 3e5;
+/**
+* Run options that keep an unrequested remote read from prompting for credentials or hanging on a dead host.
+* An empty `GIT_ASKPASS` also stops git consulting `core.askPass` and `SSH_ASKPASS` itself.
+*/
+const nonInteractiveNetworkOptions = {
+	configs: ["-c", "credential.interactive=false"],
+	env: {
+		GIT_TERMINAL_PROMPT: "0",
+		GIT_ASKPASS: "",
+		SSH_ASKPASS: "",
+		SSH_ASKPASS_REQUIRE: "never",
+		GCM_INTERACTIVE: "never"
+	},
+	timeout: 1e4
+};
+const branchActivityKeys = [
+	"gk-last-accessed",
+	"gk-last-modified",
+	"gk-agent-last-activity"
+];
 var BranchesGitSubProvider = class {
 	context;
 	git;
 	cache;
 	provider;
+	/** Ahead/behind counts by `<baseSha>...<tipSha>` range, from the per-tip fallback; a pair of commits always counts the same */
+	aheadBehindBySha = new LruMap(4096);
+	/**
+	* When each `commonPath\0branch\0key` was last stamped by this process. Bounded: a dropped entry only costs a
+	* read of the stored stamp, which still holds off a write under 5 minutes old
+	*/
+	_branchActivityStamps = new LruMap(1024);
+	/** One call per `commonPath\0branch` at a time, so a call held off by another's write in flight settles after it */
+	_branchActivityCalls = new KeyedSequencer();
+	/**
+	* What each `commonPath\0branch`'s reflog says it was created from, as git wrote it; `undefined` when it says
+	* nothing. A branch's creation never changes, so the base read, which reruns on every commit and ref move, reads
+	* it once
+	*/
+	_branchCreatedFrom = new LruMap(1024);
+	/** Bumped each time a key's created-from is forgotten, so a reflog read in flight across that doesn't store it */
+	_branchCreatedFromGenerations = new LruMap(1024);
 	constructor(context, git, cache, provider) {
 		this.context = context;
 		this.git = git;
@@ -116,7 +157,7 @@ var BranchesGitSubProvider = class {
 						const fullName = record.name;
 						if (!fullName.startsWith("refs/heads/") && !fullName.startsWith("refs/remotes/")) continue;
 						if (isRemoteHEAD(fullName)) continue;
-						const upstream = parseUpstream(record.upstream, record.upstreamTracking);
+						const upstream = parseUpstream(record.upstream, record.upstreamTracking, record.upstreamRemote);
 						const metadata = metadataMap.get(parseRefName(fullName).name);
 						const worktreePath = record.worktreePath ? normalizePath(record.worktreePath) : void 0;
 						branches.push(new GitBranch(commonPath, fullName, false, record.committerDate ? new Date(record.committerDate) : void 0, metadata, record.objectname, upstream, worktreePathSupported ? worktreePath ? {
@@ -134,7 +175,8 @@ var BranchesGitSubProvider = class {
 							remote: false,
 							upstream: branch.upstream?.name ? {
 								name: branch.upstream.name,
-								missing: branch.upstream.missing
+								missing: branch.upstream.missing,
+								remote: branch.upstream.remote
 							} : void 0,
 							sha: branch.sha
 						});
@@ -246,7 +288,8 @@ var BranchesGitSubProvider = class {
 				if (pr?.refs?.base != null) {
 					const branch = await this.getBranch(repoPath, ref, void 0, cancellation);
 					if (branch == null) return void 0;
-					const prTarget = `${branch.remoteName}/${pr.refs.base.branch}`;
+					const { remote: remoteName } = await resolveBranchRemote(this.provider, repoPath, branch, cancellation);
+					const prTarget = `${remoteName}/${pr.refs.base.branch}`;
 					const { missing } = await this.provider.refs.getSymbolicReferenceNameOrMissing(repoPath, prTarget, priorityOpts, cancellation);
 					if (!missing) {
 						mergeTarget = prTarget;
@@ -431,6 +474,23 @@ var BranchesGitSubProvider = class {
 			}
 		}, cancellation);
 	}
+	/**
+	* Writes the missing `refs/remotes/<remote>/HEAD` symref from the remote (`remote set-head -a`) in the background,
+	* never prompting for credentials; nothing runs past the cached local check when the symref exists. Rejects when
+	* the remote can't be read.
+	*/
+	async setRemoteHeadIfMissing(repoPath, remote) {
+		if (await this.getDefaultBranchName(repoPath, remote, {
+			priority: "background",
+			local: true
+		}) != null) return;
+		await this.git.run({
+			cwd: repoPath,
+			priority: "background",
+			...nonInteractiveNetworkOptions
+		}, "remote", "set-head", "-a", remote);
+		this.cache.deleteDefaultBranchName(repoPath, `${remote}:local`);
+	}
 	async createBranch(repoPath, name, ref, options) {
 		const args = [
 			"branch",
@@ -441,8 +501,7 @@ var BranchesGitSubProvider = class {
 		try {
 			await this.git.run({ cwd: repoPath }, ...args);
 			this.cache.deleteBaseBranchName(repoPath, name);
-			this.context.hooks?.cache?.onReset?.(repoPath, "branches");
-			this.context.hooks?.repository?.onChanged?.(repoPath, ["heads"]);
+			this.forgetBranchCreatedFrom(repoPath, name);
 		} catch (ex) {
 			throw getGitCommandError("branch", ex, (reason) => new BranchError({
 				reason: reason ?? "other",
@@ -453,6 +512,9 @@ var BranchesGitSubProvider = class {
 					args
 				}
 			}, ex));
+		} finally {
+			this.context.hooks?.cache?.onReset?.(repoPath, "branches");
+			this.context.hooks?.repository?.onChanged?.(repoPath, mayWriteTracking(ref, options?.noTracking) ? ["config", "heads"] : ["heads"]);
 		}
 	}
 	async deleteLocalBranch(repoPath, names, options) {
@@ -466,11 +528,11 @@ var BranchesGitSubProvider = class {
 			await this.git.run({ cwd: repoPath }, ...args);
 			for (const branch of branches) await this.forgetDeletedBranch(repoPath, branch);
 			this.context.hooks?.cache?.onReset?.(repoPath, "branches");
-			this.context.hooks?.repository?.onChanged?.(repoPath, ["heads"]);
+			this.context.hooks?.repository?.onChanged?.(repoPath, ["config", "heads"]);
 		} catch (ex) {
 			if (await this.cleanupDeletedBranchMetadata(repoPath, branches)) {
 				this.context.hooks?.cache?.onReset?.(repoPath, "branches");
-				this.context.hooks?.repository?.onChanged?.(repoPath, ["heads"]);
+				this.context.hooks?.repository?.onChanged?.(repoPath, ["config", "heads"]);
 			}
 			if (ex instanceof BranchError) throw ex.update({
 				action: options?.force ? "force delete" : "delete",
@@ -500,6 +562,8 @@ var BranchesGitSubProvider = class {
 	async forgetDeletedBranch(repoPath, name) {
 		this.cache.deleteBaseBranchName(repoPath, name);
 		await this.provider.config.removeGkConfigBranchSection(repoPath, name);
+		this.clearBranchActivityStamps(repoPath, name);
+		this.forgetBranchCreatedFrom(repoPath, name);
 	}
 	/**
 	* Drops the cached and persisted per-branch metadata for whichever of `names` no longer exists. Only
@@ -539,8 +603,6 @@ var BranchesGitSubProvider = class {
 		];
 		try {
 			await this.git.run({ cwd: repoPath }, ...args);
-			this.context.hooks?.cache?.onReset?.(repoPath, "branches");
-			this.context.hooks?.repository?.onChanged?.(repoPath, ["remotes"]);
 		} catch (ex) {
 			if (ex instanceof BranchError) throw ex.update({
 				action: "delete",
@@ -559,6 +621,9 @@ var BranchesGitSubProvider = class {
 					args
 				}
 			}, ex));
+		} finally {
+			this.context.hooks?.cache?.onReset?.(repoPath, "branches");
+			this.context.hooks?.repository?.onChanged?.(repoPath, ["remotes"]);
 		}
 	}
 	async getBranchMergedStatus(repoPath, branch, into, cancellation) {
@@ -908,33 +973,26 @@ var BranchesGitSubProvider = class {
 		const priority = options?.priority;
 		const priorityOpts = priority != null ? { priority } : void 0;
 		try {
-			let entries = await this.provider.refs.getReflogEntries(repoPath, ref, {
-				grep: "branch: Created from *.",
-				priority
-			}, cancellation);
-			if (entries.length !== 1) return {
+			const createdFrom = await this.getReflogCreatedFrom(repoPath, ref, priority, cancellation);
+			if (createdFrom == null) return {
 				branch: void 0,
 				failed: false
 			};
-			let match = entries[0].message.match(/branch: Created from (.*)$/);
-			if (match?.length === 2) {
-				let name = match[1];
-				if (name !== "HEAD") {
-					if (options?.upstream) {
-						const upstream = await this.provider.refs.getSymbolicReferenceName(repoPath, `${name}@{u}`, priorityOpts);
-						if (upstream) return {
-							branch: upstream,
-							failed: false
-						};
-					}
-					name = await this.provider.refs.getSymbolicReferenceName(repoPath, name, priorityOpts);
-					if (name) return {
-						branch: name,
+			if (createdFrom !== "HEAD") {
+				if (options?.upstream) {
+					const upstream = await this.provider.refs.getSymbolicReferenceName(repoPath, `${createdFrom}@{u}`, priorityOpts);
+					if (upstream) return {
+						branch: upstream,
 						failed: false
 					};
 				}
+				const name = await this.provider.refs.getSymbolicReferenceName(repoPath, createdFrom, priorityOpts);
+				if (name) return {
+					branch: name,
+					failed: false
+				};
 			}
-			entries = await this.provider.refs.getReflogEntries(repoPath, "HEAD", {
+			const entries = await this.provider.refs.getReflogEntries(repoPath, "HEAD", {
 				grep: `checkout: moving from .* to ${ref.replace("refs/heads/", "")}`,
 				priority
 			}, cancellation);
@@ -942,7 +1000,7 @@ var BranchesGitSubProvider = class {
 				branch: void 0,
 				failed: false
 			};
-			match = entries.at(-1).message.match(/checkout: moving from ([^\s]+)\s/);
+			const match = entries.at(-1).message.match(/checkout: moving from ([^\s]+)\s/);
 			if (match?.length === 2) {
 				let name = match[1];
 				if (options?.upstream) {
@@ -976,59 +1034,320 @@ var BranchesGitSubProvider = class {
 			failed: false
 		};
 	}
-	async getAheadOfBase(repoPath, branch, cancellation) {
-		if (isDetachedHead(branch)) return {
-			base: void 0,
-			dependsOn: []
-		};
-		const dependsOn = /* @__PURE__ */ new Set([`refs/heads/${branch}`]);
+	/**
+	* The start point `ref`'s own reflog says it was created from (`branch: Created from <name>`), as git wrote it:
+	* a branch, `HEAD`, a sha, a tag or any other revision. `undefined` unless exactly one entry says so. Rejects
+	* when the reflog can't be read, including for a ref that doesn't exist.
+	*/
+	async getReflogCreatedFrom(repoPath, ref, priority, cancellation) {
+		const entries = await this.provider.refs.getReflogEntries(repoPath, ref, {
+			grep: "branch: Created from *.",
+			priority
+		}, cancellation);
+		if (entries.length !== 1) return void 0;
+		return entries[0].message.match(/branch: Created from (.*)$/)?.[1];
+	}
+	/**
+	* The branch `branch` was created from, as a base for {@link getAheadOfBaseInOrder}: the name its own reflog
+	* gives, when that is a local or remote-tracking branch in the cached ref list and not `branch` itself or its
+	* copy on a remote (`git switch <branch>` creates it from `<remote>/<branch>`). Never the checkout history in
+	* HEAD's reflog, which on a long-lived checkout names whatever was checked out last.
+	*/
+	async getCreatedFromTarget(repoPath, branch, cancellation) {
+		const key = this.getBranchActivityKey(repoPath, branch);
+		let name;
+		if (this._branchCreatedFrom.has(key)) name = this._branchCreatedFrom.get(key);
+		else {
+			const generation = this._branchCreatedFromGenerations.get(key);
+			try {
+				name = await this.getReflogCreatedFrom(repoPath, `refs/heads/${branch}`, void 0, cancellation);
+			} catch (ex) {
+				if (isCancellationError(ex)) throw ex;
+				return;
+			}
+			if (cancellation?.aborted) throw new CancellationError();
+			if (this._branchCreatedFromGenerations.get(key) === generation) this._branchCreatedFrom.set(key, name);
+		}
+		if (!name || name === "HEAD" || name.startsWith("-")) return void 0;
+		const records = await this.provider.refs.getRefs(repoPath, cancellation);
+		const fullNames = name.startsWith("refs/heads/") || name.startsWith("refs/remotes/") ? [name] : [`refs/heads/${name}`, `refs/remotes/${name}`];
+		let listed = false;
+		for (const fullName of fullNames) if (await this.getRefTip(repoPath, records, fullName, cancellation) != null) {
+			listed = true;
+			break;
+		}
+		if (!listed) return void 0;
+		if (await this.isSelfRef(repoPath, name, branch, cancellation)) return void 0;
+		return name;
+	}
+	async getAheadOfBase(repoPath, branch, options, cancellation) {
+		if (branch != null && isDetachedHead(branch)) branch = void 0;
+		const dependsOn = new Set(branch != null ? [`refs/heads/${branch}`] : []);
+		const preferredTarget = options?.preferredTarget?.trim() || void 0;
+		if (preferredTarget == null) return this.getAheadOfBaseInOrder(repoPath, branch, options?.skipUserTarget, dependsOn, cancellation);
+		let target = await this.getNearestForkTarget(repoPath, branch, preferredTarget, dependsOn, cancellation);
+		if (target != null && branch != null && await this.isSelfAtHead(repoPath, target.ref, branch, cancellation)) target = void 0;
+		if (cancellation?.aborted) throw new CancellationError();
+		if (target != null) return this.measureAheadOfBase(repoPath, target, "preferred", dependsOn, cancellation);
+		return this.getAheadOfBaseInOrder(repoPath, branch, options?.skipUserTarget, dependsOn, cancellation);
+	}
+	/**
+	* Resolves the base from the recorded candidates, then the branch it was created from or the default branch, for
+	* {@link getAheadOfBase}
+	*/
+	async getAheadOfBaseInOrder(repoPath, branch, skipUserTarget, dependsOn, cancellation) {
 		let target;
-		for (const candidate of await this.getRecordedBaseCandidates(repoPath, branch)) {
-			target = await this.getNearestForkTarget(repoPath, branch, candidate, dependsOn, cancellation);
-			if (target != null) break;
+		let tier = "default";
+		if (branch != null) for (const candidate of await this.getRecordedBaseCandidates(repoPath, branch, skipUserTarget)) {
+			target = await this.getNearestForkTarget(repoPath, branch, candidate.ref, dependsOn, cancellation);
+			if (target != null) {
+				tier = candidate.tier;
+				break;
+			}
 		}
 		if (target == null) {
 			const defaultBranch = await this.getLocalDefaultBranchName(repoPath, dependsOn, cancellation);
-			target = await this.getNearestForkTarget(repoPath, branch, defaultBranch, dependsOn, cancellation);
+			if (branch != null && defaultBranch === branch) return this.measureAheadOfSelfUpstream(repoPath, branch, dependsOn, cancellation);
+			const createdFrom = branch != null ? await this.getCreatedFromTarget(repoPath, branch, cancellation) : void 0;
+			if (createdFrom != null) {
+				const created = await this.getCreatedFromForkTarget(repoPath, branch, createdFrom, defaultBranch, dependsOn, cancellation);
+				if (created != null) ({target, tier} = created);
+			} else target = await this.getUpstreamNearestForkTarget(repoPath, branch, defaultBranch, dependsOn, cancellation);
 		}
 		if (cancellation?.aborted) throw new CancellationError();
-		if (target == null) return {
+		if (target == null) {
+			let unborn = false;
+			if (branch != null) try {
+				unborn = findRefTip(await this.provider.refs.getRefs(repoPath, cancellation), `refs/heads/${branch}`) == null && await this.isUnbornHead(repoPath, cancellation);
+			} catch (ex) {
+				if (isCancellationError(ex)) throw ex;
+			}
+			return {
+				base: void 0,
+				reason: unborn ? "unborn" : "none",
+				dependsOn: [...dependsOn]
+			};
+		}
+		if (branch != null && await this.isSelfAtHead(repoPath, target.ref, branch, cancellation)) return {
+			base: void 0,
+			reason: "self",
+			dependsOn: [...dependsOn]
+		};
+		return this.measureAheadOfBase(repoPath, target, tier, dependsOn, cancellation);
+	}
+	/**
+	* The base for a branch created from `createdFrom`: that branch, unless the default branch forked strictly nearer
+	* HEAD, as it does once `createdFrom` merged into it and the branch was rebased onto it. A stacked branch's
+	* unmerged parent forked nearer, and stays its base. `undefined` when neither is usable.
+	*/
+	async getCreatedFromForkTarget(repoPath, branch, createdFrom, defaultBranch, dependsOn, cancellation) {
+		const skipDefault = defaultBranch == null || createdFrom === defaultBranch || createdFrom === `refs/heads/${defaultBranch}` || createdFrom === `refs/remotes/${defaultBranch}`;
+		const [created, fallback] = await Promise.all([this.getUpstreamNearestForkTarget(repoPath, branch, createdFrom, dependsOn, cancellation), skipDefault ? void 0 : this.getUpstreamNearestForkTarget(repoPath, branch, defaultBranch, dependsOn, cancellation)]);
+		if (created == null) return fallback != null ? {
+			target: fallback,
+			tier: "default"
+		} : void 0;
+		if (created.forkPoint != null && fallback?.forkPoint != null && created.forkPoint !== fallback.forkPoint && await this.provider.commits.isAncestorOf(repoPath, created.forkPoint, fallback.forkPoint, cancellation)) return {
+			target: fallback,
+			tier: "default"
+		};
+		return {
+			target: created,
+			tier: "created"
+		};
+	}
+	/** Counts HEAD's commits past `target` for {@link getAheadOfBase} */
+	async measureAheadOfBase(repoPath, target, tier, dependsOn, cancellation) {
+		const [countsResult, refsResult] = await Promise.allSettled([this.countAgainstBase(repoPath, target.ref, cancellation), this.provider.refs.getRefs(repoPath, cancellation)]);
+		if (cancellation?.aborted) throw new CancellationError();
+		if (countsResult.status === "rejected") throw countsResult.reason;
+		const counts = countsResult.value;
+		if (counts == null) return {
+			base: void 0,
+			reason: "unborn",
+			dependsOn: [...dependsOn]
+		};
+		return {
+			base: {
+				ref: target.ref,
+				ahead: counts.right,
+				sha: findRefTip(getSettledValue(refsResult, []), target.ref),
+				forkPoint: target.forkPoint,
+				tier
+			},
+			dependsOn: [...dependsOn]
+		};
+	}
+	/** Counts the default branch's own commits past its upstream (see {@link getSelfUpstreamTarget}) for {@link getAheadOfBase} */
+	async measureAheadOfSelfUpstream(repoPath, branch, dependsOn, cancellation) {
+		const upstream = await this.getSelfUpstreamTarget(repoPath, branch, dependsOn, cancellation);
+		if (cancellation?.aborted) throw new CancellationError();
+		if (upstream == null) return {
 			base: void 0,
+			reason: "self",
 			dependsOn: [...dependsOn]
 		};
-		if (await this.isSelfAtHead(repoPath, target, branch, cancellation)) return {
+		const counts = await this.countAgainstBase(repoPath, upstream.ref, cancellation);
+		if (counts == null) return {
 			base: void 0,
+			reason: "unborn",
 			dependsOn: [...dependsOn]
 		};
-		const range = createRevisionRange(target, "HEAD", "...");
-		const [countsResult, refsResult] = await Promise.allSettled([this.provider.commits.getLeftRightCommitCount(repoPath, range, void 0, cancellation), this.provider.refs.getRefs(repoPath, cancellation)]);
+		if (counts.left === 0 && counts.right === 0) return {
+			base: void 0,
+			reason: "self",
+			dependsOn: [...dependsOn]
+		};
+		const forkPoint = counts.left === 0 ? upstream.sha : await this.getForkPoint(repoPath, upstream.ref, cancellation);
 		if (cancellation?.aborted) throw new CancellationError();
-		let counts = getSettledValue(countsResult);
-		if (counts == null) try {
-			counts = await this.getLeftRightCountUncached(repoPath, range, cancellation);
-		} catch (ex) {
-			if (isCancellationError(ex)) throw ex;
-			if (await this.isUnbornHead(repoPath, cancellation)) return {
-				base: void 0,
-				dependsOn: [...dependsOn]
-			};
-			throw ex;
-		}
 		return {
 			base: {
-				ref: target,
+				ref: upstream.ref,
 				ahead: counts.right,
-				sha: findRefTip(getSettledValue(refsResult, []), target)
+				sha: upstream.sha,
+				forkPoint,
+				tier: "upstream"
 			},
 			dependsOn: [...dependsOn]
 		};
 	}
-	/** Counts `range` with a fresh `rev-list`, bypassing the cached count. Rejects on any failure, with git's error */
-	async getLeftRightCountUncached(repoPath, range, cancellation) {
+	/**
+	* HEAD's count against `ref` from their merge base: `left` only `ref` has, `right` only HEAD has. `undefined`
+	* before HEAD's first commit, when there is nothing to count; any other failure rejects with git's error.
+	*/
+	async countAgainstBase(repoPath, ref, cancellation) {
+		const range = createRevisionRange(ref, "HEAD", "...");
+		let counts;
+		try {
+			counts = await this.provider.commits.getLeftRightCommitCount(repoPath, range, void 0, cancellation);
+		} catch (ex) {
+			if (isCancellationError(ex)) throw ex;
+		}
+		if (cancellation?.aborted) throw new CancellationError();
+		if (counts != null) return counts;
+		try {
+			return await this.getLeftRightCountUncached(repoPath, range, cancellation);
+		} catch (ex) {
+			if (isCancellationError(ex)) throw ex;
+			if (await this.isUnbornHead(repoPath, cancellation)) return void 0;
+			throw ex;
+		}
+	}
+	async getAheadBehindCounts(repoPath, base, options, cancellation) {
+		const counts = /* @__PURE__ */ new Map();
+		const refs = options?.refs != null ? new Set(options.refs) : void 0;
+		if (refs?.size === 0) return counts;
+		let patterns;
+		if (refs == null) patterns = options?.remotes ? ["refs/heads", "refs/remotes"] : ["refs/heads"];
+		else if (sum(refs, (r) => r.length + 1) < 15e3) patterns = [...refs];
+		else patterns = ["refs/heads", "refs/remotes"];
+		if (!base.includes(")") && await this.git.supports("git:for-each-ref:ahead-behind")) {
+			const result = await this.git.run({
+				cwd: repoPath,
+				cancellation,
+				errors: "throw"
+			}, "for-each-ref", `--format=%(refname)%09%(symref)%09%(ahead-behind:${base})`, ...patterns);
+			if (result.completion.status === "cancelled" || cancellation?.aborted) throw new CancellationError();
+			for (const line of result.stdout.split("\n")) {
+				if (!line) continue;
+				const [ref, symref, counted] = line.split("	");
+				if (symref || refs != null && !refs.has(ref)) continue;
+				const [ahead, behind] = (counted ?? "").split(" ").map((n) => parseInt(n, 10));
+				if (isNaN(ahead) || isNaN(behind)) throw new Error(`Unexpected output counting the commits ahead of and behind '${base}': ${line}`);
+				counts.set(ref, {
+					ahead,
+					behind
+				});
+			}
+			return counts;
+		}
+		if (base.startsWith("-")) throw new Error(`Invalid base '${base}'`);
+		const [refsResult, baseResult] = await Promise.allSettled([this.git.run({
+			cwd: repoPath,
+			cancellation,
+			errors: "throw"
+		}, "for-each-ref", "--format=%(refname)%09%(symref)%09%(objectname)", ...patterns), this.git.run({
+			cwd: repoPath,
+			cancellation,
+			errors: "throw"
+		}, "rev-parse", "--is-shallow-repository", "--verify", `${base}^{commit}`)]);
+		if (refsResult.status === "rejected") throw refsResult.reason;
+		const result = refsResult.value;
+		if (result.completion.status === "cancelled" || cancellation?.aborted) throw new CancellationError();
+		const refsByTip = /* @__PURE__ */ new Map();
+		for (const line of result.stdout.split("\n")) {
+			const [ref, symref, sha] = line.split("	");
+			if (!ref || symref || !sha || refs != null && !refs.has(ref)) continue;
+			const tipRefs = refsByTip.get(sha);
+			if (tipRefs == null) refsByTip.set(sha, [ref]);
+			else tipRefs.push(ref);
+		}
+		if (!refsByTip.size) return counts;
+		if (baseResult.status === "rejected") throw baseResult.reason;
+		if (baseResult.value.completion.status === "cancelled" || cancellation?.aborted) throw new CancellationError();
+		const [shallow, baseSha] = baseResult.value.stdout.trim().split("\n");
+		const cacheable = shallow === "false";
+		const countsByTip = /* @__PURE__ */ new Map();
+		const uncounted = [];
+		for (const sha of refsByTip.keys()) {
+			if (sha === baseSha) {
+				countsByTip.set(sha, {
+					ahead: 0,
+					behind: 0
+				});
+				continue;
+			}
+			const range = createRevisionRange(baseSha, sha, "...");
+			const cached = cacheable ? this.aheadBehindBySha.get(range) : void 0;
+			if (cached != null) {
+				this.aheadBehindBySha.touch(range);
+				countsByTip.set(sha, cached);
+			} else uncounted.push(sha);
+		}
+		const results = await mapBounded(uncounted, 8, async (sha) => {
+			const range = createRevisionRange(baseSha, sha, "...");
+			const lr = await this.getLeftRightCountUncached(repoPath, range, cancellation, "background");
+			const tipCounts = {
+				ahead: lr.right,
+				behind: lr.left
+			};
+			if (cacheable) this.aheadBehindBySha.set(range, tipCounts);
+			return {
+				sha,
+				counts: tipCounts
+			};
+		});
+		for (const { sha, counts: tipCounts } of results) countsByTip.set(sha, tipCounts);
+		for (const [sha, tipRefs] of refsByTip) {
+			const tipCounts = countsByTip.get(sha);
+			for (const ref of tipRefs) counts.set(ref, { ...tipCounts });
+		}
+		return counts;
+	}
+	async getMergedBranches(repoPath, into, options, cancellation) {
+		const patterns = options?.remotes ? ["refs/heads", "refs/remotes"] : ["refs/heads"];
 		const result = await this.git.run({
 			cwd: repoPath,
 			cancellation,
 			errors: "throw"
+		}, "for-each-ref", `--merged=${into}`, "--format=%(refname)%09%(symref)", ...patterns);
+		if (result.completion.status === "cancelled" || cancellation?.aborted) throw new CancellationError();
+		const merged = /* @__PURE__ */ new Set();
+		for (const line of result.stdout.split("\n")) {
+			if (!line) continue;
+			const [ref, symref] = line.split("	");
+			if (symref) continue;
+			merged.add(ref);
+		}
+		return merged;
+	}
+	/** Counts `range` with a fresh `rev-list`, bypassing the cached count. Rejects on any failure, with git's error */
+	async getLeftRightCountUncached(repoPath, range, cancellation, priority) {
+		const result = await this.git.run({
+			cwd: repoPath,
+			cancellation,
+			errors: "throw",
+			priority
 		}, "rev-list", "--left-right", "--count", range, "--");
 		if (result.completion.status === "cancelled" || cancellation?.aborted) throw new CancellationError();
 		const parts = result.stdout.split("	");
@@ -1050,20 +1369,27 @@ var BranchesGitSubProvider = class {
 		}, "rev-parse", "--verify", "--quiet", "HEAD")).exitCode === 1;
 	}
 	/**
-	* Whether `ref` names `branch` itself: the same name, or `<remote>/<branch>` for one of the repo's actual remotes.
-	* Splitting at the first slash instead would call a local `release/main` the same branch as `main`.
+	* Whether `ref` names `branch` itself: the same name, or `<remote>/<branch>` for one of the repo's actual remotes,
+	* short or as a full ref. Splitting at the first slash instead would call a local `release/main` the same branch
+	* as `main`.
 	*/
 	async isSelfRef(repoPath, ref, branch, cancellation) {
+		if (ref.startsWith("refs/heads/")) return ref.slice(11) === branch;
+		if (ref.startsWith("refs/remotes/")) ref = ref.slice(13);
 		if (ref === branch) return true;
 		const suffix = `/${branch}`;
 		if (!ref.endsWith(suffix)) return false;
 		const remoteName = ref.slice(0, -suffix.length);
 		if (!remoteName) return false;
+		return (await this.getRemoteNames(repoPath, cancellation)).includes(remoteName);
+	}
+	/** The repo's remote names from the cached remote list; empty when it can't be read */
+	async getRemoteNames(repoPath, cancellation) {
 		try {
-			return (await this.provider.remotes.getRemotes(repoPath, void 0, cancellation)).some((r) => r.name === remoteName);
+			return (await this.provider.remotes.getRemotes(repoPath, void 0, cancellation)).map((r) => r.name);
 		} catch (ex) {
 			if (isCancellationError(ex)) throw ex;
-			return false;
+			return [];
 		}
 	}
 	/** Whether `ref` names `branch` itself (see {@link isSelfRef}) and sits at HEAD's commit; tips are read only after the name matched */
@@ -1077,7 +1403,7 @@ var BranchesGitSubProvider = class {
 	* base a launch recorded. Only the stored value of the latter — `getBaseBranchName` would fall back to a reflog
 	* guess, which on a long-lived checkout names whatever branch was last checked out from. A failed read is absent.
 	*/
-	async getRecordedBaseCandidates(repoPath, branch) {
+	async getRecordedBaseCandidates(repoPath, branch, skipUserTarget) {
 		const tolerate = async (read) => {
 			try {
 				return (await read())?.trim() || void 0;
@@ -1087,28 +1413,56 @@ var BranchesGitSubProvider = class {
 			}
 		};
 		const reads = await Promise.all([
-			tolerate(() => this.getStoredUserMergeTargetBranchName(repoPath, branch)),
+			skipUserTarget ? void 0 : tolerate(() => this.getStoredUserMergeTargetBranchName(repoPath, branch)),
 			tolerate(() => this.getStoredDetectedMergeTargetBranchName(repoPath, branch)),
 			tolerate(() => this.provider.config.getGkConfig(repoPath, `branch.${branch}.gk-merge-base`))
 		]);
+		const tiers = [
+			"user",
+			"detected",
+			"recorded"
+		];
 		const candidates = [];
-		for (const candidate of reads) if (candidate && !candidates.includes(candidate)) candidates.push(candidate);
+		for (const [i, ref] of reads.entries()) if (ref && !candidates.some((c) => c.ref === ref)) candidates.push({
+			ref,
+			tier: tiers[i]
+		});
 		return candidates;
 	}
 	/**
-	* The repo's default branch from local refs only: the `origin/HEAD` symref as its local name, else
-	* `init.defaultBranch`, else `main`, else `master` — each only if it names a commit.
+	* The repo's default branch from local refs only, never the network: the `HEAD` symref of the `upstream` remote,
+	* else of `origin`, else of the first remote, as its local branch or else as the remote ref; then, in the same
+	* remote order, `<remote>/main` or `<remote>/master`, again as the local branch of that name or else the remote
+	* ref; then `init.defaultBranch`, `main`, `master` — each only if it names a commit.
 	*/
 	async getLocalDefaultBranchName(repoPath, dependsOn, cancellation) {
-		dependsOn.add("refs/remotes/origin/HEAD");
-		const symref = await this.getDefaultBranchName(repoPath, "origin", { local: true }, cancellation);
-		if (symref) {
-			const slash = symref.indexOf("/");
-			const local = slash >= 0 ? symref.slice(slash + 1) : symref;
-			if (local) {
-				addRefDependencies(dependsOn, local);
-				if (await this.provider.refs.validateReference(repoPath, local, void 0, cancellation)) return local;
-			}
+		let records;
+		const exists = async (ref) => {
+			records ??= await this.provider.refs.getRefs(repoPath, cancellation);
+			return await this.getRefTip(repoPath, records, ref, cancellation) != null;
+		};
+		const remotes = await this.getRemoteNames(repoPath, cancellation);
+		const preferred = new Set([
+			remotes.find((r) => r === "upstream"),
+			remotes.find((r) => r === "origin"),
+			remotes.at(0)
+		].filter((r) => r != null));
+		for (const remote of preferred) {
+			dependsOn.add(`refs/remotes/${remote}/HEAD`);
+			const symref = await this.getDefaultBranchName(repoPath, remote, { local: true }, cancellation);
+			const local = symref?.startsWith(`${remote}/`) ? symref.slice(remote.length + 1) : void 0;
+			if (!symref || !local) continue;
+			addRefDependencies(dependsOn, local);
+			if (await exists(local)) return local;
+			addRefDependencies(dependsOn, symref);
+			if (await exists(symref)) return symref;
+		}
+		for (const remote of preferred) for (const name of ["main", "master"]) {
+			const remoteRef = `refs/remotes/${remote}/${name}`;
+			dependsOn.add(remoteRef);
+			if (!await exists(remoteRef)) continue;
+			addRefDependencies(dependsOn, name);
+			return await exists(name) ? name : `${remote}/${name}`;
 		}
 		let fromConfig;
 		try {
@@ -1121,20 +1475,55 @@ var BranchesGitSubProvider = class {
 		]) {
 			if (!candidate) continue;
 			addRefDependencies(dependsOn, candidate);
-			if (await this.provider.refs.validateReference(repoPath, candidate, void 0, cancellation)) return candidate;
+			if (await exists(candidate)) return candidate;
+		}
+	}
+	/**
+	* `upstream/<name>` for a created-from or default base `<name>` (or `<remote>/<name>`), as another ref that base
+	* is measured against: in a fork whose `main` tracks `origin/main`, a branch taken off (or since rebased onto) a
+	* newer `upstream/main` would otherwise count the commits `origin` hasn't caught up on. Read from the cached
+	* remote and ref lists; `undefined` when there is no `upstream` remote, it lacks the branch, or the base is that
+	* ref itself.
+	*/
+	async getUpstreamContender(repoPath, base, dependsOn, cancellation) {
+		if (!base) return void 0;
+		const remotes = await this.getRemoteNames(repoPath, cancellation);
+		if (!remotes.includes("upstream")) return void 0;
+		const records = await this.provider.refs.getRefs(repoPath, cancellation);
+		let name = base;
+		if (name.startsWith("refs/heads/")) name = name.slice(11);
+		else {
+			const isRemoteRef = name.startsWith("refs/remotes/");
+			if (isRemoteRef) name = name.slice(13);
+			if (isRemoteRef || findRefTip(records, `refs/heads/${name}`) == null) {
+				const remote = remotes.find((r) => name.startsWith(`${r}/`));
+				if (remote != null) name = name.slice(remote.length + 1);
+			}
 		}
+		const contender = `upstream/${name}`;
+		const remoteRef = `refs/remotes/${contender}`;
+		if (contender === base || remoteRef === base || findRefTip(records, remoteRef) == null) return void 0;
+		dependsOn.add(remoteRef);
+		return contender;
+	}
+	/** {@link getNearestForkTarget} with the `upstream` remote's copy of `candidate` as its contender */
+	async getUpstreamNearestForkTarget(repoPath, branch, candidate, dependsOn, cancellation) {
+		return this.getNearestForkTarget(repoPath, branch, candidate, dependsOn, cancellation, { contender: await this.getUpstreamContender(repoPath, candidate, dependsOn, cancellation) });
 	}
 	/**
 	* A candidate base as the ref HEAD is measured against: the candidate or its tracking ref, whichever forked
 	* nearer HEAD, so a stale local base defers to its upstream while one carrying unpushed work wins over it. A
-	* candidate neither forks from is used as-is if it names a commit. `undefined` when the candidate is unusable.
+	* `contender` other than the tracking ref is taken only when it forked strictly nearer than both, so a tie keeps
+	* the candidate's own pick. A candidate none forks from is used as-is if it names a commit. `undefined` when the
+	* candidate is unusable.
 	*/
-	async getNearestForkTarget(repoPath, branch, candidate, dependsOn, cancellation) {
+	async getNearestForkTarget(repoPath, branch, candidate, dependsOn, cancellation, options) {
 		if (!candidate || candidate.startsWith("-")) return void 0;
-		if (candidate === branch) return void 0;
+		if (candidate === branch || candidate === `refs/heads/${branch}`) return void 0;
 		addRefDependencies(dependsOn, candidate);
+		const upstreamName = this.provider.refs.getSymbolicReferenceName(repoPath, `${candidate}@{u}`, void 0, cancellation);
 		const getUpstreamFork = async () => {
-			const upstream = await this.provider.refs.getSymbolicReferenceName(repoPath, `${candidate}@{u}`, void 0, cancellation);
+			const upstream = await upstreamName;
 			if (!upstream || upstream.startsWith("-")) return void 0;
 			addRefDependencies(dependsOn, upstream);
 			return {
@@ -1142,7 +1531,23 @@ var BranchesGitSubProvider = class {
 				mergeBase: await this.getForkPoint(repoPath, upstream, cancellation)
 			};
 		};
-		const [candidateMergeBase, upstreamFork] = await Promise.all([this.getForkPoint(repoPath, candidate, cancellation), getUpstreamFork()]);
+		const contender = options?.contender;
+		const getContenderMergeBase = async () => {
+			if (contender == null) return void 0;
+			const records = await this.provider.refs.getRefs(repoPath, cancellation);
+			const tip = findRefTip(records, contender);
+			if (tip != null) {
+				if (tip === findRefTip(records, candidate)) return void 0;
+				const upstream = await upstreamName;
+				if (upstream && tip === findRefTip(records, upstream)) return void 0;
+			}
+			return this.getForkPoint(repoPath, contender, cancellation);
+		};
+		const [candidateMergeBase, upstreamFork, contenderMergeBase] = await Promise.all([
+			this.getForkPoint(repoPath, candidate, cancellation),
+			getUpstreamFork(),
+			getContenderMergeBase()
+		]);
 		let nearest;
 		for (const fork of [{
 			ref: candidate,
@@ -1154,8 +1559,59 @@ var BranchesGitSubProvider = class {
 				mergeBase: fork.mergeBase
 			};
 		}
-		if (nearest != null) return nearest.ref;
-		return await this.provider.refs.validateReference(repoPath, candidate, void 0, cancellation) ? candidate : void 0;
+		if (contender != null && contender !== upstreamFork?.ref && contenderMergeBase != null && nearest != null && nearest.mergeBase !== contenderMergeBase && await this.provider.commits.isAncestorOf(repoPath, nearest.mergeBase, contenderMergeBase, cancellation)) nearest = {
+			ref: contender,
+			mergeBase: contenderMergeBase
+		};
+		if (nearest != null) return {
+			ref: nearest.ref,
+			forkPoint: nearest.mergeBase
+		};
+		return await this.provider.refs.validateReference(repoPath, candidate, void 0, cancellation) ? {
+			ref: candidate,
+			forkPoint: void 0
+		} : void 0;
+	}
+	/**
+	* The base for a branch that is itself the default branch, with its tip: its own upstream, `upstream/<branch>`
+	* when an `upstream` remote has it, else `<branch>@{u}`. Read from the cached ref and branch lists; only a
+	* `<branch>` that isn't checked out spawns, for its `@{u}`. `undefined` when there is neither, or its ref is gone.
+	*/
+	async getSelfUpstreamTarget(repoPath, branch, dependsOn, cancellation) {
+		const records = await this.provider.refs.getRefs(repoPath, cancellation);
+		let upstream;
+		if ((await this.getRemoteNames(repoPath, cancellation)).includes("upstream")) {
+			const remoteRef = `refs/remotes/upstream/${branch}`;
+			dependsOn.add(remoteRef);
+			if (await this.getRefTip(repoPath, records, remoteRef, cancellation) != null) upstream = `upstream/${branch}`;
+		}
+		if (upstream == null) {
+			let tracking;
+			const current = await this.getBranch(repoPath, void 0, void 0, cancellation);
+			if (current?.name === branch && !current.detached && !current.remote) {
+				tracking = current.upstream?.name;
+				if (tracking && current.upstream?.missing) {
+					addRefDependencies(dependsOn, tracking);
+					return;
+				}
+			} else tracking = await this.provider.refs.getSymbolicReferenceName(repoPath, `${branch}@{u}`, void 0, cancellation);
+			if (!tracking || tracking.startsWith("-")) return void 0;
+			addRefDependencies(dependsOn, tracking);
+			upstream = tracking;
+		}
+		const sha = await this.getRefTip(repoPath, records, upstream, cancellation);
+		return sha != null ? {
+			ref: upstream,
+			sha
+		} : void 0;
+	}
+	/**
+	* {@link findRefTip} in `records`, the cached ref list. `getRefs` answers a failed enumeration with an empty list,
+	* so an empty one is asked of git instead, rather than read as every ref being absent.
+	*/
+	async getRefTip(repoPath, records, name, cancellation) {
+		if (records.length) return findRefTip(records, name);
+		return this.provider.refs.validateReference(repoPath, name, void 0, cancellation);
 	}
 	/** The merge base of HEAD and `ref`, preferring git's fork-point reading of `ref`'s reflog when it has one */
 	async getForkPoint(repoPath, ref, cancellation) {
@@ -1191,25 +1647,61 @@ var BranchesGitSubProvider = class {
 	async getStoredUserMergeTargetBranchName(repoPath, ref) {
 		return (await this.provider.config.getGkConfig(repoPath, `branch.${ref}.gk-merge-target-user`))?.trim() || void 0;
 	}
-	/** Updates the last accessed timestamp for the current branch */
-	async onCurrentBranchAccessed(repoPath) {
-		const branch = await this.getBranch(repoPath);
-		if (branch == null || branch.remote || branch.detached) return;
-		await this.storeBranchMetadata(repoPath, "gk-last-accessed", branch.name, /* @__PURE__ */ new Date());
-	}
-	/** Updates the last accessed and modified timestamp for the current branch */
-	async onCurrentBranchModified(repoPath) {
-		const branch = await this.getBranch(repoPath);
-		if (branch == null || branch.remote || branch.detached) return;
-		const now = /* @__PURE__ */ new Date();
-		await this.storeBranchMetadata(repoPath, "gk-last-accessed", branch.name, now);
-		await this.storeBranchMetadata(repoPath, "gk-last-modified", branch.name, now);
-	}
-	/** Updates the agent last activity timestamp for the current branch */
-	async onCurrentBranchAgentActivity(repoPath) {
-		const branch = await this.getBranch(repoPath);
-		if (branch == null || branch.remote || branch.detached) return;
-		await this.storeBranchMetadata(repoPath, "gk-agent-last-activity", branch.name, /* @__PURE__ */ new Date());
+	onCurrentBranchAccessed(repoPath) {
+		return this.recordBranchActivity(repoPath, ["gk-last-accessed"]);
+	}
+	onCurrentBranchModified(repoPath) {
+		return this.recordBranchActivity(repoPath, ["gk-last-accessed", "gk-last-modified"]);
+	}
+	onCurrentBranchAgentActivity(repoPath) {
+		return this.recordBranchActivity(repoPath, ["gk-agent-last-activity"]);
+	}
+	getBranchActivityKey(repoPath, name) {
+		return `${this.cache.getCommonPath(repoPath)}\0${name}`;
+	}
+	forgetBranchCreatedFrom(repoPath, name) {
+		const key = this.getBranchActivityKey(repoPath, name);
+		this._branchCreatedFrom.delete(key);
+		this._branchCreatedFromGenerations.set(key, (this._branchCreatedFromGenerations.get(key) ?? 0) + 1);
+	}
+	/** Forgets this process's throttle marks for `name`, so its next activity re-reads the stored stamps */
+	clearBranchActivityStamps(repoPath, name) {
+		const branchKey = this.getBranchActivityKey(repoPath, name);
+		for (const key of branchActivityKeys) this._branchActivityStamps.delete(`${branchKey}\0${key}`);
+	}
+	/** Never rejects — activity stamps are bookkeeping and callers fire them without a catch */
+	async recordBranchActivity(repoPath, keys) {
+		const scope = getScopedLogger();
+		try {
+			const branch = await this.getBranch(repoPath);
+			if (branch == null || branch.remote || branch.detached) return;
+			const branchKey = this.getBranchActivityKey(repoPath, branch.name);
+			await this._branchActivityCalls.run(branchKey, void 0, async () => {
+				const now = Date.now();
+				const due = [];
+				for (const key of keys) {
+					const stampKey = `${branchKey}\0${key}`;
+					const last = this._branchActivityStamps.get(stampKey);
+					if (last != null && now - last < dateMetadataStaleThresholdMs) continue;
+					this._branchActivityStamps.set(stampKey, now);
+					due.push(key);
+				}
+				if (!due.length) return;
+				const stored = await Promise.allSettled(due.map((key) => this.provider.config.getGkConfig(repoPath, `branch.${branch.name}.${key}`)));
+				const value = new Date(now).toISOString();
+				for (const [i, key] of due.entries()) {
+					const stamp = getSettledValue(stored[i]);
+					const last = stamp != null ? new Date(stamp).getTime() : NaN;
+					if (now - last < dateMetadataStaleThresholdMs) {
+						this._branchActivityStamps.set(`${branchKey}\0${key}`, last);
+						continue;
+					}
+					await this.provider.config.setGkConfig(repoPath, `branch.${branch.name}.${key}`, value);
+				}
+			});
+		} catch (ex) {
+			scope?.error(ex, `Failed to record branch activity (${keys.join(", ")})`);
+		}
 	}
 	async renameBranch(repoPath, oldName, newName) {
 		const args = [
@@ -1223,8 +1715,10 @@ var BranchesGitSubProvider = class {
 			await this.provider.config.renameGkConfigBranchSection(repoPath, oldName, newName);
 			this.cache.deleteBaseBranchName(repoPath, oldName);
 			this.cache.deleteBaseBranchName(repoPath, newName);
-			this.context.hooks?.cache?.onReset?.(repoPath, "branches");
-			this.context.hooks?.repository?.onChanged?.(repoPath, ["heads"]);
+			this.clearBranchActivityStamps(repoPath, oldName);
+			this.clearBranchActivityStamps(repoPath, newName);
+			this.forgetBranchCreatedFrom(repoPath, oldName);
+			this.forgetBranchCreatedFrom(repoPath, newName);
 		} catch (ex) {
 			throw getGitCommandError("branch", ex, (reason) => new BranchError({
 				reason: reason ?? "other",
@@ -1235,6 +1729,9 @@ var BranchesGitSubProvider = class {
 					args
 				}
 			}, ex));
+		} finally {
+			this.context.hooks?.cache?.onReset?.(repoPath, "branches");
+			this.context.hooks?.repository?.onChanged?.(repoPath, ["config", "heads"]);
 		}
 	}
 	async setUpstreamBranch(repoPath, name, upstream) {
@@ -1250,8 +1747,6 @@ var BranchesGitSubProvider = class {
 		];
 		try {
 			await this.git.run({ cwd: repoPath }, ...args);
-			this.context.hooks?.cache?.onReset?.(repoPath, "branches");
-			this.context.hooks?.repository?.onChanged?.(repoPath, ["heads"]);
 		} catch (ex) {
 			throw getGitCommandError("branch", ex, (reason) => new BranchError({
 				reason: reason ?? "other",
@@ -1262,6 +1757,9 @@ var BranchesGitSubProvider = class {
 					args
 				}
 			}, ex));
+		} finally {
+			this.context.hooks?.cache?.onReset?.(repoPath, "branches");
+			this.context.hooks?.repository?.onChanged?.(repoPath, ["config", "heads"]);
 		}
 	}
 	async storeBaseBranchName(repoPath, ref, base, options) {
@@ -1286,22 +1784,14 @@ var BranchesGitSubProvider = class {
 				const configMap = await this.provider.config.getGkConfigRegex(commonPath, "^branch\\..*\\.gk-(last-(accessed|modified)|disposition|agent-last-activity)$");
 				if (!configMap.size) return metadataMap;
 				for (const [key, value] of configMap) {
-					if (!key.startsWith("branch.")) continue;
-					const keyParts = key.split(".");
-					if (keyParts.length < 3) continue;
-					const metaKey = keyParts.at(-1);
-					const branchName = keyParts.slice(1, -1).join(".");
-					let metadata = metadataMap.get(branchName);
+					const parsed = parseBranchMetadataGkConfigKey(key);
+					if (parsed == null) continue;
+					let metadata = metadataMap.get(parsed.branch);
 					if (metadata == null) {
 						metadata = {};
-						metadataMap.set(branchName, metadata);
-					}
-					if (metaKey === "gk-last-accessed") metadata.lastAccessedAt = value;
-					else if (metaKey === "gk-last-modified") metadata.lastModifiedAt = value;
-					else if (metaKey === "gk-agent-last-activity") metadata.agentLastActivityAt = value;
-					else if (metaKey === "gk-disposition") {
-						if (value === "starred" || value === "archived") metadata.disposition = value;
+						metadataMap.set(parsed.branch, metadata);
 					}
+					setBranchMetadataValue(metadata, parsed.key, value);
 				}
 			} catch (ex) {
 				debugger;
@@ -1310,11 +1800,6 @@ var BranchesGitSubProvider = class {
 			return metadataMap;
 		});
 	}
-	async storeBranchMetadata(repoPath, key, ref, date) {
-		const value = await this.provider.config.getGkConfig(repoPath, `branch.${ref}.${key}`);
-		if (value != null && date.getTime() - new Date(value).getTime() < dateMetadataStaleThresholdMs) return;
-		return this.provider.config.setGkConfig(repoPath, `branch.${ref}.${key}`, date.toISOString());
-	}
 	async setBranchDisposition(repoPath, branchName, disposition) {
 		await this.provider.config.setGkConfig(repoPath, `branch.${branchName}.gk-disposition`, disposition);
 		this.context.hooks?.cache?.onReset?.(repoPath, "branches");
@@ -1327,6 +1812,7 @@ __decorate([debug()], BranchesGitSubProvider.prototype, "getBranchContributionsO
 __decorate([debug()], BranchesGitSubProvider.prototype, "getBranchesWithCommits", null);
 __decorate([debug()], BranchesGitSubProvider.prototype, "getCurrentBranchReference", null);
 __decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getDefaultBranchName", null);
+__decorate([debug()], BranchesGitSubProvider.prototype, "setRemoteHeadIfMissing", null);
 __decorate([debug()], BranchesGitSubProvider.prototype, "createBranch", null);
 __decorate([debug()], BranchesGitSubProvider.prototype, "deleteLocalBranch", null);
 __decorate([debug()], BranchesGitSubProvider.prototype, "deleteRemoteBranch", null);
@@ -1337,22 +1823,32 @@ __decorate([debug()], BranchesGitSubProvider.prototype, "getPotentialMergeConfli
 __decorate([debug()], BranchesGitSubProvider.prototype, "getPotentialStashReapplyConflicts", null);
 __decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getBaseBranchName", null);
 __decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getAheadOfBase", null);
+__decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getAheadBehindCounts", null);
+__decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getMergedBranches", null);
 __decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getStoredMergeTargetBranchName", null);
 __decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getStoredDetectedMergeTargetBranchName", null);
 __decorate([debug()], BranchesGitSubProvider.prototype, "getStoredUserMergeTargetBranchName", null);
-__decorate([debounce(15e4), debug()], BranchesGitSubProvider.prototype, "onCurrentBranchAccessed", null);
-__decorate([debounce(15e4), debug()], BranchesGitSubProvider.prototype, "onCurrentBranchModified", null);
-__decorate([debounce(15e4), debug()], BranchesGitSubProvider.prototype, "onCurrentBranchAgentActivity", null);
+__decorate([trace()], BranchesGitSubProvider.prototype, "onCurrentBranchAccessed", null);
+__decorate([trace()], BranchesGitSubProvider.prototype, "onCurrentBranchModified", null);
+__decorate([trace()], BranchesGitSubProvider.prototype, "onCurrentBranchAgentActivity", null);
 __decorate([debug()], BranchesGitSubProvider.prototype, "renameBranch", null);
 __decorate([debug()], BranchesGitSubProvider.prototype, "setUpstreamBranch", null);
 __decorate([debug()], BranchesGitSubProvider.prototype, "storeBaseBranchName", null);
 __decorate([debug()], BranchesGitSubProvider.prototype, "storeMergeTargetBranchName", null);
 __decorate([debug()], BranchesGitSubProvider.prototype, "storeUserMergeTargetBranchName", null);
+/** Each ref list {@link findRefTip} searched, by full name: one base read looks up many names in the same cached list */
+const refRecordsByName = /* @__PURE__ */ new WeakMap();
 /**
 * The commit `name` resolves to among `records`, tried in git's own order for a short name (`refs/tags/` before
 * `refs/heads/` before `refs/remotes/`); annotated tags peel to their commit. `undefined` when no listed ref matches.
 */
 function findRefTip(records, name) {
+	let byName = refRecordsByName.get(records);
+	if (byName == null) {
+		byName = /* @__PURE__ */ new Map();
+		for (const record of records) if (!byName.has(record.name)) byName.set(record.name, record);
+		refRecordsByName.set(records, byName);
+	}
 	for (const candidate of [
 		name,
 		`refs/${name}`,
@@ -1361,7 +1857,7 @@ function findRefTip(records, name) {
 		`refs/remotes/${name}`,
 		`refs/remotes/${name}/HEAD`
 	]) {
-		const record = records.find((r) => r.name === candidate);
+		const record = byName.get(candidate);
 		if (record != null) return record.peeledObjectname || record.objectname;
 	}
 }