@gitkraken/core-gitlens 0.15.7 → 0.16.1

package/dist/git-cli/exec/headState.js

@@ -0,0 +1,78 @@
+import { fileUri, joinUriPath } from "../../utils/uri.js";
+import { FileType } from "../../git/context.js";
+import { resolve } from "node:path";
+//#region ../git-cli/src/exec/headState.ts
+const headBranchRegex = /^ref:\s*(refs\/heads\/\S+)\s*$/;
+const headShaRegex = /^(?:[0-9a-f]{40}|[0-9a-f]{64})\s*$/;
+const gitFileRegex = /^gitdir:\s*(.+?)\s*$/m;
+/**
+* Reads `repoPath`'s HEAD from the worktree's own `HEAD` file, without running git: read around a write, it says which
+* branch that write moved, whatever a switch outside core left in the caches. The git dir is the cached one, else the
+* one `<repoPath>/.git` is or points to, so a worktree core never registered is read without spawning git either.
+* A reftable repository's `HEAD` file holds the placeholder `refs/heads/.invalid` (its real HEAD is in the tables),
+* which is no branch name git allows, so it reads as unknown, as does a branch that is a symbolic ref to another (a
+* `master` kept pointing at `main`), since git follows it and a write moves the target. An object id is detached only
+* when the git dir's listing doesn't flag `HEAD` as a symlink (a host's `stat` may follow the link): read as detached,
+* a symlinked HEAD would say a write on its branch moved no branch. Never rejects.
+*/
+async function readHeadState(repoPath, fs, cache) {
+	try {
+		const cached = cache.gitDir.get(repoPath);
+		const gitDir = cached != null ? {
+			uri: cached.uri,
+			commonUri: cached.commonUri
+		} : await findGitDir(repoPath, fs);
+		if (gitDir == null) return void 0;
+		const decoder = new TextDecoder();
+		const head = decoder.decode(await fs.readFile(joinUriPath(gitDir.uri, "HEAD")));
+		if (headShaRegex.test(head)) return (await fs.readDirectory(gitDir.uri)).some(([name, type]) => name === "HEAD" && (type & FileType.SymbolicLink) !== 0) ? void 0 : "detached";
+		const ref = headBranchRegex.exec(head)?.[1];
+		if (ref == null || ref.split("/").some((part) => part.startsWith("."))) return void 0;
+		let target;
+		try {
+			target = decoder.decode(await fs.readFile(joinUriPath(gitDir.commonUri ?? gitDir.uri, ref)));
+		} catch {}
+		return target?.startsWith("ref:") ? void 0 : { branch: ref };
+	} catch {
+		return;
+	}
+}
+/**
+* The git dir `<repoPath>/.git` is: the folder itself, or the one a linked worktree's `gitdir:` file names, whose
+* `commondir` file names the repository's shared one
+*/
+async function findGitDir(repoPath, fs) {
+	const dotGit = joinUriPath(fileUri(repoPath), ".git");
+	const stat = await fs.stat(dotGit);
+	if (stat == null) return void 0;
+	if (stat.type & FileType.Directory) return {
+		uri: dotGit,
+		commonUri: void 0
+	};
+	const dir = gitFileRegex.exec(new TextDecoder().decode(await fs.readFile(dotGit)))?.[1];
+	if (dir == null) return void 0;
+	const gitDir = resolve(repoPath, dir);
+	let commonDir;
+	try {
+		commonDir = new TextDecoder().decode(await fs.readFile(joinUriPath(fileUri(gitDir), "commondir"))).trim();
+	} catch {}
+	return {
+		uri: fileUri(gitDir),
+		commonUri: commonDir ? fileUri(resolve(gitDir, commonDir)) : void 0
+	};
+}
+/**
+* Which branch a write that moves only HEAD's branch moved, from HEAD read before and after it: that branch when HEAD
+* was on the same one both times, `'detached'` (no branch) when it was detached both times, otherwise `undefined` — a
+* hook or an outside switch moved HEAD meanwhile, or a read failed, so the moved branch is unknown.
+*/
+function getMovedHead(before, after) {
+	if (before == null || after == null) return void 0;
+	if (before === "detached") return after === "detached" ? "detached" : void 0;
+	if (after === "detached") return void 0;
+	return before.branch === after.branch ? before : void 0;
+}
+//#endregion
+export { getMovedHead, readHeadState };
+
+//# sourceMappingURL=headState.js.map

package/dist/git-cli/exec/headState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"headState.js","names":["resolvePath"],"sources":["../../../../git-cli/src/exec/headState.ts"],"sourcesContent":["import { resolve as resolvePath } from 'node:path';\nimport type { Cache } from '@gitlens/git/cache.js';\nimport type { FileSystemProvider } from '@gitlens/git/context.js';\nimport { FileType } from '@gitlens/git/context.js';\nimport type { Uri } from '@gitlens/utils/uri.js';\nimport { fileUri, joinUriPath } from '@gitlens/utils/uri.js';\n\n/**\n * What a worktree's HEAD is on: the full name of its branch (`refs/heads/main`), `'detached'`, or `undefined` when\n * unknown — unreadable, not a branch name git allows, or a HEAD kept as a symlink to its branch\n * (`core.preferSymlinkRefs`). Reading such a HEAD follows the link to the branch's object id, as a detached HEAD\n * reads, so it is unknown when the git dir's listing flags it as a link, and `'detached'` on a host whose listing\n * doesn't.\n */\nexport type HeadState = { readonly branch: string } | 'detached' | undefined;\n\nconst headBranchRegex = /^ref:\\s*(refs\\/heads\\/\\S+)\\s*$/;\nconst headShaRegex = /^(?:[0-9a-f]{40}|[0-9a-f]{64})\\s*$/;\nconst gitFileRegex = /^gitdir:\\s*(.+?)\\s*$/m;\n\n/**\n * Reads `repoPath`'s HEAD from the worktree's own `HEAD` file, without running git: read around a write, it says which\n * branch that write moved, whatever a switch outside core left in the caches. The git dir is the cached one, else the\n * one `<repoPath>/.git` is or points to, so a worktree core never registered is read without spawning git either.\n * A reftable repository's `HEAD` file holds the placeholder `refs/heads/.invalid` (its real HEAD is in the tables),\n * which is no branch name git allows, so it reads as unknown, as does a branch that is a symbolic ref to another (a\n * `master` kept pointing at `main`), since git follows it and a write moves the target. An object id is detached only\n * when the git dir's listing doesn't flag `HEAD` as a symlink (a host's `stat` may follow the link): read as detached,\n * a symlinked HEAD would say a write on its branch moved no branch. Never rejects.\n */\nexport async function readHeadState(repoPath: string, fs: FileSystemProvider, cache: Cache): Promise<HeadState> {\n\ttry {\n\t\tconst cached = cache.gitDir.get(repoPath);\n\t\tconst gitDir =\n\t\t\tcached != null ? { uri: cached.uri, commonUri: cached.commonUri } : await findGitDir(repoPath, fs);\n\t\tif (gitDir == null) return undefined;\n\n\t\tconst decoder = new TextDecoder();\n\t\tconst head = decoder.decode(await fs.readFile(joinUriPath(gitDir.uri, 'HEAD')));\n\t\tif (headShaRegex.test(head)) {\n\t\t\tconst entries = await fs.readDirectory(gitDir.uri);\n\t\t\tconst linked = entries.some(([name, type]) => name === 'HEAD' && (type & FileType.SymbolicLink) !== 0);\n\t\t\treturn linked ? undefined : 'detached';\n\t\t}\n\n\t\tconst ref = headBranchRegex.exec(head)?.[1];\n\t\tif (ref == null || ref.split('/').some(part => part.startsWith('.'))) return undefined;\n\n\t\t// Packed refs can't hold a symbolic ref, so a missing loose file is a plain branch\n\t\tlet target: string | undefined;\n\t\ttry {\n\t\t\ttarget = decoder.decode(await fs.readFile(joinUriPath(gitDir.commonUri ?? gitDir.uri, ref)));\n\t\t} catch {}\n\t\treturn target?.startsWith('ref:') ? undefined : { branch: ref };\n\t} catch {\n\t\treturn undefined;\n\t}\n}\n\n/**\n * The git dir `<repoPath>/.git` is: the folder itself, or the one a linked worktree's `gitdir:` file names, whose\n * `commondir` file names the repository's shared one\n */\nasync function findGitDir(\n\trepoPath: string,\n\tfs: FileSystemProvider,\n): Promise<{ readonly uri: Uri; readonly commonUri: Uri | undefined } | undefined> {\n\tconst dotGit = joinUriPath(fileUri(repoPath), '.git');\n\tconst stat = await fs.stat(dotGit);\n\tif (stat == null) return undefined;\n\tif (stat.type & FileType.Directory) return { uri: dotGit, commonUri: undefined };\n\n\tconst dir = gitFileRegex.exec(new TextDecoder().decode(await fs.readFile(dotGit)))?.[1];\n\tif (dir == null) return undefined;\n\n\tconst gitDir = resolvePath(repoPath, dir);\n\tlet commonDir: string | undefined;\n\ttry {\n\t\tcommonDir = new TextDecoder().decode(await fs.readFile(joinUriPath(fileUri(gitDir), 'commondir'))).trim();\n\t} catch {}\n\treturn { uri: fileUri(gitDir), commonUri: commonDir ? fileUri(resolvePath(gitDir, commonDir)) : undefined };\n}\n\n/**\n * Which branch a write that moves only HEAD's branch moved, from HEAD read before and after it: that branch when HEAD\n * was on the same one both times, `'detached'` (no branch) when it was detached both times, otherwise `undefined` — a\n * hook or an outside switch moved HEAD meanwhile, or a read failed, so the moved branch is unknown.\n */\nexport function getMovedHead(before: HeadState, after: HeadState): HeadState {\n\tif (before == null || after == null) return undefined;\n\tif (before === 'detached') return after === 'detached' ? 'detached' : undefined;\n\tif (after === 'detached') return undefined;\n\n\treturn before.branch === after.branch ? before : undefined;\n}\n"],"mappings":";;;;AAgBA,MAAM,kBAAkB;AACxB,MAAM,eAAe;AACrB,MAAM,eAAe;;;;;;;;;;;AAYrB,eAAsB,cAAc,UAAkB,IAAwB,OAAkC;CAC/G,IAAI;EACH,MAAM,SAAS,MAAM,OAAO,IAAI,QAAQ;EACxC,MAAM,SACL,UAAU,OAAO;GAAE,KAAK,OAAO;GAAK,WAAW,OAAO;EAAU,IAAI,MAAM,WAAW,UAAU,EAAE;EAClG,IAAI,UAAU,MAAM,OAAO,KAAA;EAE3B,MAAM,UAAU,IAAI,YAAY;EAChC,MAAM,OAAO,QAAQ,OAAO,MAAM,GAAG,SAAS,YAAY,OAAO,KAAK,MAAM,CAAC,CAAC;EAC9E,IAAI,aAAa,KAAK,IAAI,GAGzB,QADe,MADO,GAAG,cAAc,OAAO,GAAG,EAAA,CAC1B,MAAM,CAAC,MAAM,UAAU,SAAS,WAAW,OAAO,SAAS,kBAAkB,CACxF,IAAI,KAAA,IAAY;EAG7B,MAAM,MAAM,gBAAgB,KAAK,IAAI,CAAC,GAAG;EACzC,IAAI,OAAO,QAAQ,IAAI,MAAM,GAAG,CAAC,CAAC,MAAK,SAAQ,KAAK,WAAW,GAAG,CAAC,GAAG,OAAO,KAAA;EAG7E,IAAI;EACJ,IAAI;GACH,SAAS,QAAQ,OAAO,MAAM,GAAG,SAAS,YAAY,OAAO,aAAa,OAAO,KAAK,GAAG,CAAC,CAAC;EAC5F,QAAQ,CAAC;EACT,OAAO,QAAQ,WAAW,MAAM,IAAI,KAAA,IAAY,EAAE,QAAQ,IAAI;CAC/D,QAAQ;EACP;CACD;AACD;;;;;AAMA,eAAe,WACd,UACA,IACkF;CAClF,MAAM,SAAS,YAAY,QAAQ,QAAQ,GAAG,MAAM;CACpD,MAAM,OAAO,MAAM,GAAG,KAAK,MAAM;CACjC,IAAI,QAAQ,MAAM,OAAO,KAAA;CACzB,IAAI,KAAK,OAAO,SAAS,WAAW,OAAO;EAAE,KAAK;EAAQ,WAAW,KAAA;CAAU;CAE/E,MAAM,MAAM,aAAa,KAAK,IAAI,YAAY,CAAC,CAAC,OAAO,MAAM,GAAG,SAAS,MAAM,CAAC,CAAC,CAAC,GAAG;CACrF,IAAI,OAAO,MAAM,OAAO,KAAA;CAExB,MAAM,SAASA,QAAY,UAAU,GAAG;CACxC,IAAI;CACJ,IAAI;EACH,YAAY,IAAI,YAAY,CAAC,CAAC,OAAO,MAAM,GAAG,SAAS,YAAY,QAAQ,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,KAAK;CACzG,QAAQ,CAAC;CACT,OAAO;EAAE,KAAK,QAAQ,MAAM;EAAG,WAAW,YAAY,QAAQA,QAAY,QAAQ,SAAS,CAAC,IAAI,KAAA;CAAU;AAC3G;;;;;;AAOA,SAAgB,aAAa,QAAmB,OAA6B;CAC5E,IAAI,UAAU,QAAQ,SAAS,MAAM,OAAO,KAAA;CAC5C,IAAI,WAAW,YAAY,OAAO,UAAU,aAAa,aAAa,KAAA;CACtE,IAAI,UAAU,YAAY,OAAO,KAAA;CAEjC,OAAO,OAAO,WAAW,MAAM,SAAS,SAAS,KAAA;AAClD"}

package/dist/git-cli/providers/branches.d.ts

@@ -17,6 +17,13 @@ export declare class BranchesGitSubProvider implements GitBranchesSubProvider {
   private readonly provider;
   /** Ahead/behind counts by `<baseSha>...<tipSha>` range, from the per-tip fallback; a pair of commits always counts the same */
   private readonly aheadBehindBySha;
+  /**
+   * For a base that moved only forward, the commits its reflog reaches off the new tip's history (else `false`), by
+   * `<ref>\0<oldSha>\0<newSha>`, for each cached ref list it was read against: a ref write replaces that list, along
+   * with the reflog the answer came from. `undefined` when git couldn't say, which isn't kept. A fetch moves one base
+   * under every worktree at once, so they share the one check, joining it while it runs
+   */
+  private readonly baseMovedForward;
   /**
    * 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
@@ -32,6 +39,12 @@ export declare class BranchesGitSubProvider implements GitBranchesSubProvider {
   private readonly _branchCreatedFrom;
   /** Bumped each time a key's created-from is forgotten, so a reflog read in flight across that doesn't store it */
   private readonly _branchCreatedFromGenerations;
+  /**
+   * The repositories (by common path) whose last config listing showed config that can differ by checkout, so a linked
+   * checkout reads its own listing without first waiting on the main checkout's. Only a shortcut: a listing that shows
+   * otherwise drops the repository again
+   */
+  private readonly _configDiffersByCheckout;
   constructor(context: GitServiceContext, git: Git, cache: Cache, provider: CliGitProviderInternal);
   getBranch(repoPath: string, name?: string, options?: {
     force?: boolean;
@@ -137,10 +150,47 @@ export declare class BranchesGitSubProvider implements GitBranchesSubProvider {
    */
   private getCreatedFromTarget;
   getAheadOfBaseConfigKey(repoPath: string, cancellation?: AbortSignal): Promise<string | undefined>;
+  getAheadOfBaseConfigEntries(repoPath: string, cancellation?: AbortSignal): Promise<readonly (readonly [key: string, value: string | undefined])[] | undefined>;
+  /**
+   * A checkout's listing of the config inputs to {@link getAheadOfBase}. Every checkout of a repository shares the main
+   * checkout's, unless it shows config that can differ by checkout (see `mayConfigDifferByCheckout`); then
+   * each linked checkout reads its own, and keeps doing so until one of its own reads shows config no longer can.
+   */
+  private getAheadOfBaseConfigListing;
+  private readAheadOfBaseConfigListing;
   getAheadOfBase(repoPath: string, branch: string | undefined, options?: {
     skipUserTarget?: boolean;
     preferredTarget?: string;
   }, cancellation?: AbortSignal): Promise<AheadOfBase>;
+  getAheadOfBaseAfterBaseMove(repoPath: string, branch: string | undefined, previous: {
+    readonly head: string;
+    readonly base: NonNullable<AheadOfBase['base']>;
+    readonly dependsOn: readonly string[];
+    readonly defaultBranch?: string | null;
+  }, moved: readonly string[], cancellation?: AbortSignal): Promise<AheadOfBase | undefined>;
+  /**
+   * Whether the repository is shallow, by its common git directory's `shallow` file, which spawns nothing; `undefined`
+   * when it can't be read
+   */
+  private isShallowRepository;
+  /** Whether `ref` is a `refs/remotes/<remote>/HEAD` symref pointing at `target`, from the cached local symref */
+  private isRemoteHeadOf;
+  /**
+   * For `ref` (a full name in `records`, the cached ref list) moving from `oldTip` to `newTip`, the commits its reflog
+   * reaches off `newTip`'s history when it moved only forward: `oldTip` and every value its reflog took after it are in
+   * `newTip`'s history. `--fork-point` reads every reflog entry, so one in between that shares more of HEAD's history
+   * than `newTip` does (a branch's commit that landed and was force-pushed away) moves the fork point while the count
+   * stands; an older one off `newTip`'s history may hold such a commit too, which each worktree's count checks for.
+   * Without a reflog it reads only the tip. `undefined` when it didn't move only forward, or git can't say.
+   */
+  private getMovedForward;
+  /**
+   * Reads {@link getMovedForward} from git, in `commonPath`, which holds the refs, their reflogs and the objects for
+   * every worktree. Not bound to one caller's cancellation, since every worktree the move reached rides this one
+   * read. `false` when the ref didn't move only forward, or reaches too much history off `newTip`'s to tell;
+   * `undefined` when git couldn't say.
+   */
+  private readMovedForward;
   /**
    * Resolves the base from the recorded candidates, then the branch it was created from or the default branch, for
    * {@link getAheadOfBase}

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

@@ -6,6 +6,7 @@ import { getScopedLogger } from "../../utils/logger.scoped.js";
 import { getSettledValue, mapBounded } from "../../utils/promise.js";
 import { debug, trace } from "../../utils/decorators/log.js";
 import { getBranchId } from "../../utils/gitRefs.js";
+import { joinUriPath } from "../../utils/uri.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, splitRemoteBranchName } from "../../git/utils/branch.utils.js";
@@ -13,6 +14,7 @@ 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 { readHeadState } from "../exec/headState.js";
 import { KeyedSequencer } from "../exec/indexLock.js";
 import { GitError, GitErrors, getGitCommandError, gitConfigsBranch, gitConfigsLog } from "../exec/git.js";
 import { maybeStopWatch } from "../../utils/stopwatch.js";
@@ -24,6 +26,7 @@ import { LruMap } from "../../utils/lruMap.js";
 import { PageableResult, emptyPagedResult } from "../../utils/paging.js";
 import { parseMergeTreeConflict } from "../parsers/mergeTreeParser.js";
 import { resolveBranchRemote } from "./branchRemote.js";
+import { isGitBooleanFalse } from "./config.js";
 //#region ../git-cli/src/providers/branches.ts
 /** Minimum time between writes to the config for last accessed/modified dates */
 const dateMetadataStaleThresholdMs = 3e5;
@@ -47,6 +50,12 @@ const branchActivityKeys = [
 	"gk-last-modified",
 	"gk-agent-last-activity"
 ];
+/**
+* The most commits a base's reflog may reach off its new tip's history for a re-measure: every worktree's count
+* excludes each of them on its command line, and more come only from a long history force-pushed away, where a full
+* read costs less
+*/
+const maxOffHistoryCommits = 64;
 var BranchesGitSubProvider = class {
 	context;
 	git;
@@ -55,6 +64,13 @@ var BranchesGitSubProvider = class {
 	/** Ahead/behind counts by `<baseSha>...<tipSha>` range, from the per-tip fallback; a pair of commits always counts the same */
 	aheadBehindBySha = new LruMap(4096);
 	/**
+	* For a base that moved only forward, the commits its reflog reaches off the new tip's history (else `false`), by
+	* `<ref>\0<oldSha>\0<newSha>`, for each cached ref list it was read against: a ref write replaces that list, along
+	* with the reflog the answer came from. `undefined` when git couldn't say, which isn't kept. A fetch moves one base
+	* under every worktree at once, so they share the one check, joining it while it runs
+	*/
+	baseMovedForward = /* @__PURE__ */ new WeakMap();
+	/**
 	* 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
 	*/
@@ -69,6 +85,12 @@ var BranchesGitSubProvider = class {
 	_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);
+	/**
+	* The repositories (by common path) whose last config listing showed config that can differ by checkout, so a linked
+	* checkout reads its own listing without first waiting on the main checkout's. Only a shortcut: a listing that shows
+	* otherwise drops the repository again
+	*/
+	_configDiffersByCheckout = /* @__PURE__ */ new Set();
 	constructor(context, git, cache, provider) {
 		this.context = context;
 		this.git = git;
@@ -742,14 +764,23 @@ var BranchesGitSubProvider = class {
 		const records = await this.provider.refs.getRefs(repoPath, cancellation);
 		if (!records.length) return { known: false };
 		if (branch == null) {
-			const current = await this.getCurrentBranchReference(repoPath, cancellation);
-			if (current == null) return { known: false };
-			if (current.remote || isDetachedHead(current.name)) return {
+			const head = await readHeadState(repoPath, this.context.fs, this.cache);
+			if (head === "detached") return {
 				known: true,
 				push: void 0,
 				upstream: void 0
 			};
-			branch = current.name;
+			if (head != null) branch = head.branch;
+			else {
+				const current = await this.getCurrentBranchReference(repoPath, cancellation);
+				if (current == null) return { known: false };
+				if (current.remote || isDetachedHead(current.name)) return {
+					known: true,
+					push: void 0,
+					upstream: void 0
+				};
+				branch = current.name;
+			}
 		}
 		const record = findRefRecord(records, branch.startsWith("refs/heads/") ? branch : `refs/heads/${branch}`);
 		return {
@@ -1129,20 +1160,50 @@ var BranchesGitSubProvider = class {
 		return name;
 	}
 	getAheadOfBaseConfigKey(repoPath, cancellation) {
+		return this.getAheadOfBaseConfigListing(repoPath, cancellation);
+	}
+	async getAheadOfBaseConfigEntries(repoPath, cancellation) {
+		const listing = await this.getAheadOfBaseConfigListing(repoPath, cancellation);
+		return listing != null ? parseConfigListing(listing) : void 0;
+	}
+	/**
+	* A checkout's listing of the config inputs to {@link getAheadOfBase}. Every checkout of a repository shares the main
+	* checkout's, unless it shows config that can differ by checkout (see `mayConfigDifferByCheckout`); then
+	* each linked checkout reads its own, and keeps doing so until one of its own reads shows config no longer can.
+	*/
+	getAheadOfBaseConfigListing(repoPath, cancellation) {
 		return this.cache.getAheadOfBaseConfigKey(repoPath, async (checkoutPath, cacheable, signal) => {
-			const result = await this.git.run({
-				cwd: checkoutPath,
-				cancellation: signal,
-				expectedExitCodes: [1]
-			}, "config", "--null", "--get-regexp", "^(branch\\..*\\.(remote|merge)|remote\\..*|init\\.defaultbranch)$");
-			if (signal?.aborted) throw new CancellationError();
-			if (result.completion.status !== "exited") {
-				cacheable.invalidate();
-				return;
+			const commonPath = this.cache.getCommonPath(checkoutPath);
+			const isMain = checkoutPath === commonPath;
+			if (isMain || !this._configDiffersByCheckout.has(commonPath)) {
+				const shared = await this.cache.getAheadOfBaseConfigListing(checkoutPath, (path, sharedCacheable, sharedSignal) => this.readAheadOfBaseConfigListing(path, sharedCacheable, sharedSignal), signal);
+				if (isMain) {
+					if (shared == null) cacheable.invalidate();
+					return shared;
+				}
+				if (shared != null) {
+					if (!mayConfigDifferByCheckout(shared)) return shared;
+					this._configDiffersByCheckout.add(commonPath);
+				}
 			}
-			return result.stdout;
+			const own = await this.readAheadOfBaseConfigListing(checkoutPath, cacheable, signal);
+			if (own != null && !mayConfigDifferByCheckout(own)) this._configDiffersByCheckout.delete(commonPath);
+			return own;
 		}, cancellation);
 	}
+	async readAheadOfBaseConfigListing(cwd, cacheable, cancellation) {
+		const result = await this.git.run({
+			cwd,
+			cancellation,
+			expectedExitCodes: [1]
+		}, "config", "--null", "--get-regexp", "^(branch\\..*\\.(remote|merge)|remote\\..*|init\\.defaultbranch|includeif\\..*|extensions\\.worktreeconfig)$");
+		if (cancellation?.aborted) throw new CancellationError();
+		if (result.completion.status !== "exited") {
+			cacheable.invalidate();
+			return;
+		}
+		return result.stdout;
+	}
 	async getAheadOfBase(repoPath, branch, options, cancellation) {
 		if (branch != null && isDetachedHead(branch)) branch = void 0;
 		const dependsOn = new Set(branch != null ? [`refs/heads/${branch}`] : []);
@@ -1154,6 +1215,152 @@ var BranchesGitSubProvider = class {
 		if (target != null) return this.measureAheadOfBase(repoPath, target, "preferred", dependsOn, cancellation);
 		return this.getAheadOfBaseInOrder(repoPath, branch, options?.skipUserTarget, dependsOn, cancellation);
 	}
+	async getAheadOfBaseAfterBaseMove(repoPath, branch, previous, moved, cancellation) {
+		const { head, base } = previous;
+		const oldTip = base.sha;
+		if (oldTip == null || !moved.length) return void 0;
+		if (base.tier === "preferred" || base.tier === "upstream" && base.forkPoint === oldTip) return void 0;
+		try {
+			const records = await this.provider.refs.getRefs(repoPath, cancellation);
+			const record = records.length ? resolveRefRecord(records, base.ref) : void 0;
+			if (record == null || !moved.includes(record.name)) return void 0;
+			if (isAmbiguousRefName(records, base.ref)) return void 0;
+			const newTip = record.peeledObjectname || record.objectname;
+			if (!newTip || newTip === oldTip) return void 0;
+			if (branch != null && !isDetachedHead(branch) && findRefTip(records, `refs/heads/${branch}`) !== head) return;
+			let remoteHeadMoved = false;
+			for (const ref of moved) {
+				if (ref === record.name) continue;
+				if (findRefTip(records, ref) !== newTip || !await this.isRemoteHeadOf(repoPath, ref, record.name, cancellation)) return;
+				remoteHeadMoved = true;
+			}
+			if (remoteHeadMoved && previous.defaultBranch === void 0) return void 0;
+			if (previous.defaultBranch !== void 0) {
+				const defaultBranch = await this.getLocalDefaultBranchName(repoPath, /* @__PURE__ */ new Set(), cancellation);
+				if (cancellation?.aborted) throw new CancellationError();
+				if ((defaultBranch ?? null) !== previous.defaultBranch) return void 0;
+			}
+			if (previous.dependsOn.some((r) => r.startsWith("refs/remotes/upstream/") && !r.endsWith("/HEAD"))) for (const ref of previous.dependsOn) {
+				if (ref === record.name || ref.endsWith("/HEAD")) continue;
+				const tip = findRefTip(records, ref);
+				if (tip === oldTip || tip === newTip) return void 0;
+			}
+			if (await this.isShallowRepository(repoPath) !== false) return void 0;
+			const offHistory = await this.getMovedForward(repoPath, records, record.name, oldTip, newTip);
+			if (cancellation?.aborted) throw new CancellationError();
+			if (!offHistory) return void 0;
+			const result = await this.git.run({
+				cwd: repoPath,
+				cancellation,
+				errors: "ignore"
+			}, "rev-list", "--count", head, "--not", newTip, ...base.forkPoint != null ? [base.forkPoint] : [], ...offHistory, "--");
+			if (cancellation?.aborted) throw new CancellationError();
+			if (result.completion.status !== "exited" || result.exitCode !== 0) return void 0;
+			if (parseInt(result.stdout.trim(), 10) !== base.ahead) return void 0;
+			return withDefaultBranch({
+				base: {
+					...base,
+					sha: newTip
+				},
+				dependsOn: [...previous.dependsOn]
+			}, previous.defaultBranch);
+		} catch (ex) {
+			if (isCancellationError(ex)) throw ex;
+			return;
+		}
+	}
+	/**
+	* Whether the repository is shallow, by its common git directory's `shallow` file, which spawns nothing; `undefined`
+	* when it can't be read
+	*/
+	async isShallowRepository(repoPath) {
+		try {
+			const gitDir = await this.provider.config.getGitDir(repoPath);
+			return await this.context.fs.stat(joinUriPath(gitDir.commonUri ?? gitDir.uri, "shallow")) != null;
+		} catch {
+			return;
+		}
+	}
+	/** Whether `ref` is a `refs/remotes/<remote>/HEAD` symref pointing at `target`, from the cached local symref */
+	async isRemoteHeadOf(repoPath, ref, target, cancellation) {
+		if (!ref.startsWith("refs/remotes/") || !ref.endsWith("/HEAD")) return false;
+		const remote = ref.slice(13, -5);
+		if (!remote) return false;
+		const symref = await this.getDefaultBranchName(repoPath, remote, { local: true }, cancellation);
+		return symref != null && `refs/remotes/${symref}` === target;
+	}
+	/**
+	* For `ref` (a full name in `records`, the cached ref list) moving from `oldTip` to `newTip`, the commits its reflog
+	* reaches off `newTip`'s history when it moved only forward: `oldTip` and every value its reflog took after it are in
+	* `newTip`'s history. `--fork-point` reads every reflog entry, so one in between that shares more of HEAD's history
+	* than `newTip` does (a branch's commit that landed and was force-pushed away) moves the fork point while the count
+	* stands; an older one off `newTip`'s history may hold such a commit too, which each worktree's count checks for.
+	* Without a reflog it reads only the tip. `undefined` when it didn't move only forward, or git can't say.
+	*/
+	async getMovedForward(repoPath, records, ref, oldTip, newTip) {
+		let checks = this.baseMovedForward.get(records);
+		if (checks == null) {
+			checks = /* @__PURE__ */ new Map();
+			this.baseMovedForward.set(records, checks);
+		}
+		const key = `${ref}\0${oldTip}\0${newTip}`;
+		let check = checks.get(key);
+		if (check == null) {
+			check = this.readMovedForward(this.cache.getCommonPath(repoPath), ref, oldTip, newTip);
+			checks.set(key, check);
+		}
+		const offHistory = await check;
+		if (offHistory == null && checks.get(key) === check) checks.delete(key);
+		return offHistory || void 0;
+	}
+	/**
+	* Reads {@link getMovedForward} from git, in `commonPath`, which holds the refs, their reflogs and the objects for
+	* every worktree. Not bound to one caller's cancellation, since every worktree the move reached rides this one
+	* read. `false` when the ref didn't move only forward, or reaches too much history off `newTip`'s to tell;
+	* `undefined` when git couldn't say.
+	*/
+	async readMovedForward(commonPath, ref, oldTip, newTip) {
+		let since = /* @__PURE__ */ new Set([oldTip]);
+		let logged = /* @__PURE__ */ new Set([oldTip]);
+		try {
+			const entries = await this.provider.refs.getReflogEntries(commonPath, ref);
+			if (entries.length) {
+				if (entries[0].sha !== newTip) return false;
+				const oldest = entries.findLastIndex((e) => e.sha === oldTip);
+				if (oldest < 0) return false;
+				since = new Set(entries.slice(1, oldest + 1).map((e) => e.sha));
+				logged = new Set(entries.map((e) => e.sha));
+				const before = await this.git.run({
+					cwd: commonPath,
+					errors: "ignore"
+				}, "rev-parse", "--verify", `${ref}@{${entries.length}}`);
+				if (before.completion.status !== "exited") return void 0;
+				if (before.exitCode === 0) {
+					const sha = before.stdout.trim();
+					if (!sha) return void 0;
+					logged.add(sha);
+				} else if (!before.stderr?.includes(" only has ")) return;
+				else if (!await this.git.supports("git:rev-parse:reflog-oldest-old-value")) return false;
+				logged.delete(newTip);
+			}
+		} catch {
+			return;
+		}
+		try {
+			const result = await this.git.run({
+				cwd: commonPath,
+				errors: "ignore",
+				stdin: `${[...logged, `^${newTip}`].join("\n")}\n`
+			}, "rev-list", `--max-count=65`, "--stdin");
+			if (result.completion.status !== "exited" || result.exitCode !== 0) return void 0;
+			const off = result.stdout.split("\n").filter((sha) => sha.length > 0);
+			if (off.length > maxOffHistoryCommits) return false;
+			if (off.some((sha) => since.has(sha))) return false;
+			return off;
+		} catch {
+			return;
+		}
+	}
 	/**
 	* Resolves the base from the recorded candidates, then the branch it was created from or the default branch, for
 	* {@link getAheadOfBase}
@@ -1161,6 +1368,7 @@ var BranchesGitSubProvider = class {
 	async getAheadOfBaseInOrder(repoPath, branch, skipUserTarget, dependsOn, cancellation) {
 		let target;
 		let tier = "default";
+		let resolvedDefault;
 		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) {
@@ -1170,7 +1378,8 @@ var BranchesGitSubProvider = class {
 		}
 		if (target == null) {
 			const defaultBranch = await this.getLocalDefaultBranchName(repoPath, dependsOn, cancellation);
-			if (branch != null && defaultBranch === branch) return this.measureAheadOfSelfUpstream(repoPath, branch, dependsOn, cancellation);
+			resolvedDefault = defaultBranch ?? null;
+			if (branch != null && defaultBranch === branch) return withDefaultBranch(await this.measureAheadOfSelfUpstream(repoPath, branch, dependsOn, cancellation), resolvedDefault);
 			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);
@@ -1185,18 +1394,18 @@ var BranchesGitSubProvider = class {
 			} catch (ex) {
 				if (isCancellationError(ex)) throw ex;
 			}
-			return {
+			return withDefaultBranch({
 				base: void 0,
 				reason: unborn ? "unborn" : "none",
 				dependsOn: [...dependsOn]
-			};
+			}, resolvedDefault);
 		}
-		if (branch != null && await this.isSelfAtHead(repoPath, target.ref, branch, cancellation)) return {
+		if (branch != null && await this.isSelfAtHead(repoPath, target.ref, branch, cancellation)) return withDefaultBranch({
 			base: void 0,
 			reason: "self",
 			dependsOn: [...dependsOn]
-		};
-		return this.measureAheadOfBase(repoPath, target, tier, dependsOn, cancellation);
+		}, resolvedDefault);
+		return withDefaultBranch(await this.measureAheadOfBase(repoPath, target, tier, dependsOn, cancellation), resolvedDefault);
 	}
 	/**
 	* The base for a branch created from `createdFrom`: that branch, unless the default branch forked strictly nearer
@@ -1895,7 +2104,9 @@ __decorate([debug()], BranchesGitSubProvider.prototype, "getPotentialMergeConfli
 __decorate([debug()], BranchesGitSubProvider.prototype, "getPotentialStashReapplyConflicts", null);
 __decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getBaseBranchName", null);
 __decorate([trace()], BranchesGitSubProvider.prototype, "getAheadOfBaseConfigKey", null);
+__decorate([trace()], BranchesGitSubProvider.prototype, "getAheadOfBaseConfigEntries", null);
 __decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getAheadOfBase", null);
+__decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getAheadOfBaseAfterBaseMove", 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);
@@ -1924,18 +2135,38 @@ const refRecordsByName = /* @__PURE__ */ new WeakMap();
 * `refs/heads/` before `refs/remotes/`); annotated tags peel to their commit. `undefined` when no listed ref matches.
 */
 function findRefTip(records, name) {
+	const record = resolveRefRecord(records, name);
+	return record != null ? record.peeledObjectname || record.objectname : void 0;
+}
+/** The listed ref `name` resolves to, in {@link findRefTip}'s order */
+function resolveRefRecord(records, name) {
+	const byName = getRefRecordsByName(records);
+	for (const candidate of getRefNameCandidates(name)) {
+		const record = byName.get(candidate);
+		if (record != null) return record;
+	}
+}
+/** Whether more than one listed ref answers to `name`, which git calls ambiguous and resolves in {@link findRefTip}'s order */
+function isAmbiguousRefName(records, name) {
 	const byName = getRefRecordsByName(records);
-	for (const candidate of [
+	let found = false;
+	for (const candidate of getRefNameCandidates(name)) {
+		if (!byName.has(candidate)) continue;
+		if (found) return true;
+		found = true;
+	}
+	return false;
+}
+/** The full ref names `name` may stand for, in git's own order for a short name */
+function getRefNameCandidates(name) {
+	return [
 		name,
 		`refs/${name}`,
 		`refs/tags/${name}`,
 		`refs/heads/${name}`,
 		`refs/remotes/${name}`,
 		`refs/remotes/${name}/HEAD`
-	]) {
-		const record = byName.get(candidate);
-		if (record != null) return record.peeledObjectname || record.objectname;
-	}
+	];
 }
 function getRefRecordsByName(records) {
 	let byName = refRecordsByName.get(records);
@@ -1969,6 +2200,44 @@ function mayHaveUpstream(records, name) {
 	if (findRefTip(records, `refs/heads/${name}`) != null) return true;
 	return findRefTip(records, name) == null;
 }
+/** `answer` with the default branch its read resolved, when it consulted one (see `AheadOfBase.defaultBranch`) */
+function withDefaultBranch(answer, defaultBranch) {
+	return defaultBranch !== void 0 ? {
+		...answer,
+		defaultBranch
+	} : answer;
+}
+/** Splits `git config --null --get-regexp` output into its entries, in order; a key set without a value has none */
+function parseConfigListing(listing) {
+	const entries = [];
+	for (const entry of listing.split("\0")) {
+		if (!entry) continue;
+		const separator = entry.indexOf("\n");
+		entries.push(separator < 0 ? [entry, void 0] : [entry.substring(0, separator), entry.substring(separator + 1)]);
+	}
+	return entries;
+}
+/**
+* Whether `listing` shows config that can differ by checkout over time: `extensions.worktreeConfig` (each checkout's
+* `config.worktree`), or a conditional include that is neither `hasconfig:` nor `gitdir:`, since `onbranch:` follows
+* each checkout's HEAD and an unknown condition might follow anything. A `gitdir:` include matching only some
+* checkouts is accepted as shared: it is the common identity setup, and treating it as differing would end sharing for
+* nearly everyone. The cost is a known gap: an edit to a file only those checkouts include goes unseen there, since
+* nothing watches it, until a change the shared listing does see.
+*/
+function mayConfigDifferByCheckout(listing) {
+	for (const [key, value] of parseConfigListing(listing)) {
+		if (key === "extensions.worktreeconfig") {
+			if (value == null || !isGitBooleanFalse(value)) return true;
+			continue;
+		}
+		if (!key.startsWith("includeif.")) continue;
+		const condition = key.substring(10, key.lastIndexOf("."));
+		if (condition.startsWith("hasconfig:") || condition.startsWith("gitdir:") || condition.startsWith("gitdir/i:")) continue;
+		return true;
+	}
+	return false;
+}
 /**
 * Adds the full ref names a `.git/refs` watcher would report for `name`. A short name can't be told tag from local
 * from remote without a spawn, so it adds every form, including the tag git resolves it to first; a spurious one