@gitkraken/core-gitlens 0.25.0 → 0.26.0

package/CHANGELOG.md

@@ -6,6 +6,18 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/) and this p
 
 ## [Unreleased]
 
+## [0.26.0] - 2026-11-02
+
+### Added
+
+- Adds `refreshIndexAfterWrites?: boolean` to `CliGitProviderOptions` and `createCliGitService`'s options, off by default. When on, `checkout`, `restore`, `merge`, `pull`, `reset`, `cherryPick`, `revert`, `rebase`, `createWorktree`, `clone`, stash apply, pop and push, and abort and continue of a paused operation refresh the checkout's index in the background when the write rewrote it, including one that stops on conflicts. Files written in the index's own second are "racily clean", so every later status or diff re-hashed them (~600 ms on 8,000 files) until something rewrote the index, which core's status reads (run with `GIT_OPTIONAL_LOCKS=0`) never do. Once the clock passes that second, one `git status --porcelain -uno --ignore-submodules=all` with optional locks on and rename detection off writes the refreshed index (~7 ms reads after). A write that left the index alone (already up to date, a soft reset) schedules none; writes to one checkout share one refresh. Each costs a background status of the whole checkout, worth it only where that checkout will be read again, so it is off by default (git-cli)
+- Adds `scheduleIndexRefresh?(repoPath)` to `GitOperationsSubProvider` (`service.forRepo(path).ops?.scheduleIndexRefresh?.()`), for a host that rewrote a checkout through a raw git command: it joins the per-checkout background index refresh core's own writes schedule under `refreshIndexAfterWrites`, and runs whether or not that is on (git, git-cli)
+
+### Changed
+
+- Changes `getGitDir` to read the git dir and common git dir of a main or linked worktree from disk (its `.git` folder or file, `commondir`), instead of spawning `git rev-parse`, with the same answer. It still asks git for any other layout: a submodule, a bare repository, a worktree nested inside another repository's working tree (including its own main checkout), a `.git` file without `commondir`, `core.worktree`, `core.bare` or an `include` in its config, `GIT_DIR`/`GIT_COMMON_DIR`/`GIT_WORK_TREE`/`GIT_CEILING_DIRECTORIES` in git's environment, a folder owned by another user (not checked on Windows, where the process has no uid), or an untrusted workspace. Resolving N sibling worktrees now runs no git process (was N). `onGitDirResolveFailed` fires only when git is asked (git-cli)
+- Changes `WorktreeSummaryService` to check a subscribed worktree's own branch, its upstream and the ahead/behind counts against it as core's cached `getBranch` answers them, and its base tips against core's cached ref list (one `for-each-ref` shared by the repository's checkouts), when a change may have moved them without naming them — a packed-refs rewrite (deleting a packed branch, `git pack-refs`), a ref directory, an overflow or a poll — and to read only the groups whose refs moved. Deleting a packed branch now costs each subscribed worktree no git process of its own (was ~6–8: `diff --quiet HEAD`, `ls-files --others`, `merge-base --fork-point` ×2, `@{u}`, `rev-list --left-right --count`). A base ref the check finds moved is re-measured rather than read in full (git)
+
 ## [0.25.0] - 2026-10-30
 
 ### Added
@@ -1048,7 +1060,8 @@ 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.25.0...HEAD
+[unreleased]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.26.0...HEAD
+[0.26.0]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.25.0...gitkraken:releases/core/v0.26.0
 [0.25.0]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.24.0...gitkraken:releases/core/v0.25.0
 [0.24.0]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.23.0...gitkraken:releases/core/v0.24.0
 [0.23.0]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.22.1...gitkraken:releases/core/v0.23.0

package/dist/git/providers/operations.d.ts

@@ -149,6 +149,21 @@ export interface GitOperationsSubProvider {
     editMessage?: boolean;
     source?: unknown;
   }, runOptions?: GitOperationRunOptions): Promise<GitOperationResult>;
+  /**
+   * Refreshes, in the background, the index of the checkout at `repoPath` once the clock has moved past the second it
+   * was written in, so that git trusts the timestamps of the files written alongside it. A write that rewrites many
+   * files (a clone, a worktree add, a branch switch, a fast-forward) leaves them all "racily clean", and every later
+   * status or diff re-hashes them until something rewrites the index, which core's own status reads (run with
+   * `GIT_OPTIONAL_LOCKS=0`) never do.
+   *
+   * With the git-cli provider's `refreshIndexAfterWrites` on, core's own `checkout`, `restore`, `merge`, `pull`,
+   * `reset`, `cherryPick`, `revert` and `rebase`, stash apply, pop and push, abort and continue of a paused operation,
+   * and worktree and clone writes do this themselves, including one that stops on conflicts, so only a host that
+   * rewrote the checkout through a raw git command needs to call it; it runs whether or not that option is on. Calls
+   * share one queue per checkout: one made while a refresh is waiting joins it, and one made while its status runs
+   * causes one more after it. Never throws.
+   */
+  scheduleIndexRefresh?(repoPath: string): void;
 }
 //#endregion
 //# sourceMappingURL=operations.d.ts.map

package/dist/git/watching/worktreeSummary.d.ts

@@ -159,9 +159,13 @@ export interface WorktreeSummaryServiceOptions {
  * inputs its last base read consulted (every branch's tracking but those of branches it didn't depend on), the stored
  * values, HEAD's commit or the upstream changed, unless it was confined to the
  * `branch.<name>` sections of branches the summary neither is on, tracks nor bases on (its `configBranches`), which
- * reads nothing; the checked-out branch moving, or a HEAD change, reads all of them. Stash, unrelated tags and
- * branches, and the like read nothing. One run is in flight per worktree at a time, at most four per repository (the
- * worktrees sharing a common git directory), and at most eight across the service. Runs take turns first come, first
+ * reads nothing; the checked-out branch moving, or a HEAD change, reads all of them. A change that may have moved one
+ * of those refs without naming it (a packed-refs rewrite, as deleting a packed branch makes, a ref directory, an
+ * overflow or a poll) first checks HEAD, the upstream and the counts against it as core's cached `getBranch` answers
+ * them, and the tips the base was read from against core's cached ref list, both shared by the repository's
+ * checkouts, and reads only the groups that moved, by the same rules — nothing when none did.
+ * Stash, unrelated tags and branches, and the like read nothing. One run is in flight per worktree at a time, at most
+ * four per repository (the worktrees sharing a common git directory), and at most eight across the service. Runs take turns first come, first
  * served, except that one whose repository is at its cap lets later runs of other repositories go first, so a burst in
  * one repository never delays another's reads: events while a run waits for its turn join it, and events during a run
  * are merged into a single follow-up run.
@@ -251,6 +255,14 @@ export declare class WorktreeSummaryService implements UnifiedDisposable {
    * the `HEAD` symrefs of `remotes` (every remote's when `undefined`); without `statIndex`, the index is unknown
    */
   private probeUnwatched;
+  /**
+   * A subscribed run's {@link ReadProbe}, from cached answers: HEAD when the branch is due or a tip check is, the ref
+   * tips (kept in `probed`), and the `HEAD` symrefs of the remotes the base depends on when the base may be read or a
+   * tip check is due — every remote's for a first read, which can come to depend on any. A tip check widens `fields` as
+   * {@link getTipCheckFields} finds, and is read in full when the probe fails; any other probe that fails leaves
+   * the tips its groups read unknown.
+   */
+  private probeRead;
   getResourceUsage(): ResourceUsage;
   private start;
   /**

package/dist/git/watching/worktreeSummary.js

@@ -20,6 +20,14 @@ const baseConfigField = 16;
 * the base's own ref just moved forward, it is re-measured rather than resolved again. {@link baseField} overrides it.
 */
 const baseMoveField = 32;
+/**
+* Checks the summary against what a probe finds now, for a change that may have moved one of its refs without naming it
+* (a packed-refs rewrite, a ref directory, an overflow or a poll): HEAD, the upstream and the counts against it as
+* `getBranch` answers them, and the refs the base depends on against the tips it was read from (see {@link ReadTips});
+* reads the groups that moved, as an unwatched read would — everything when HEAD's branch or commit did — and nothing
+* when none did
+*/
+const tipCheckField = 64;
 /** Every group a full read covers — a base read refreshes the {@link BaseKeys} snapshot itself */
 const allFields = 7;
 const maxConcurrentReadsPerRepository = 4;
@@ -27,6 +35,7 @@ const maxConcurrentReads = 8;
 const maxUnwatchedReads = 256;
 const maxDeferredDirtyMs = 1e4;
 const emptyRefs = Object.freeze([]);
+const noRemotes = /* @__PURE__ */ new Set();
 const noBaseKeys = [
 	void 0,
 	void 0,
@@ -125,9 +134,13 @@ var SummarySubscription = class {
 * inputs its last base read consulted (every branch's tracking but those of branches it didn't depend on), the stored
 * values, HEAD's commit or the upstream changed, unless it was confined to the
 * `branch.<name>` sections of branches the summary neither is on, tracks nor bases on (its `configBranches`), which
-* reads nothing; the checked-out branch moving, or a HEAD change, reads all of them. Stash, unrelated tags and
-* branches, and the like read nothing. One run is in flight per worktree at a time, at most four per repository (the
-* worktrees sharing a common git directory), and at most eight across the service. Runs take turns first come, first
+* reads nothing; the checked-out branch moving, or a HEAD change, reads all of them. A change that may have moved one
+* of those refs without naming it (a packed-refs rewrite, as deleting a packed branch makes, a ref directory, an
+* overflow or a poll) first checks HEAD, the upstream and the counts against it as core's cached `getBranch` answers
+* them, and the tips the base was read from against core's cached ref list, both shared by the repository's
+* checkouts, and reads only the groups that moved, by the same rules — nothing when none did.
+* Stash, unrelated tags and branches, and the like read nothing. One run is in flight per worktree at a time, at most
+* four per repository (the worktrees sharing a common git directory), and at most eight across the service. Runs take turns first come, first
 * served, except that one whose repository is at its cap lets later runs of other repositories go first, so a burst in
 * one repository never delays another's reads: events while a run waits for its turn join it, and events during a run
 * are merged into a single follow-up run.
@@ -370,13 +383,11 @@ var WorktreeSummaryService = class {
 	* the `HEAD` symrefs of `remotes` (every remote's when `undefined`); without `statIndex`, the index is unknown
 	*/
 	async probeUnwatched(repo, remotes, statIndex, signal) {
-		const remoteHeads = /* @__PURE__ */ new Map();
 		const stat = statIndex ? this.stat : void 0;
-		const [current, tips, gitDir] = await Promise.all([
+		const [current, refs, gitDir] = await Promise.all([
 			repo.branches.getBranch(void 0, void 0, signal),
-			repo.refs.getRefTips(void 0, signal),
-			stat != null ? getGitDir(repo) : void 0,
-			readRemoteHeads(repo, remoteHeads, remotes, signal)
+			probeRefs(repo, remotes, signal),
+			stat != null ? getGitDir(repo) : void 0
 		]);
 		let index;
 		if (stat != null && gitDir != null) try {
@@ -387,15 +398,59 @@ var WorktreeSummaryService = class {
 		}
 		const detached = current?.detached ?? false;
 		return {
+			current,
 			branch: detached ? void 0 : current?.name || void 0,
 			detached,
 			sha: current?.sha,
 			upstream: current?.upstream?.name,
-			tips: getTipsByName(tips),
-			remoteHeads,
+			tips: refs.tips,
+			remoteHeads: refs.remoteHeads,
 			index
 		};
 	}
+	/**
+	* A subscribed run's {@link ReadProbe}, from cached answers: HEAD when the branch is due or a tip check is, the ref
+	* tips (kept in `probed`), and the `HEAD` symrefs of the remotes the base depends on when the base may be read or a
+	* tip check is due — every remote's for a first read, which can come to depend on any. A tip check widens `fields` as
+	* {@link getTipCheckFields} finds, and is read in full when the probe fails; any other probe that fails leaves
+	* the tips its groups read unknown.
+	*/
+	async probeRead(repo, previous, tips, fields, baseMoves, probed, signal) {
+		const check = (fields & tipCheckField) !== 0 && previous != null && (fields & allFields) !== allFields;
+		fields &= -65;
+		const remotes = previous == null ? void 0 : check || (fields & 60) !== 0 ? getHeadRemotes(previous.baseDependsOn) : noRemotes;
+		try {
+			if (!check && (fields & branchField) === 0) {
+				probed.refs = await probeRefs(repo, remotes, signal);
+				return {
+					fields,
+					baseMoves
+				};
+			}
+			const probe = await this.probeUnwatched(repo, remotes, false, signal);
+			probed.refs = probe;
+			const head = { branch: probe.current };
+			if (!check) return {
+				fields,
+				baseMoves,
+				head
+			};
+			const moved = getTipCheckFields(probe, previous, tips);
+			if (moved.baseMoves != null && baseMoves != null) for (const ref of baseMoves) moved.baseMoves.add(ref);
+			return {
+				fields: fields | moved.fields,
+				baseMoves: moved.baseMoves ?? baseMoves,
+				head
+			};
+		} catch (ex) {
+			if (isCancellationError(ex)) throw ex;
+			probed.refs = void 0;
+			return {
+				fields: check ? fields | allFields : fields,
+				baseMoves
+			};
+		}
+	}
 	getResourceUsage() {
 		return { "worktreeSummary.entries.count": this.entries.size };
 	}
@@ -424,6 +479,7 @@ var WorktreeSummaryService = class {
 			entry.baseKeys = last.result.baseKeys;
 			entry.baseConfigKey = last.result.baseConfigKey;
 			entry.baseDefaultBranch = last.result.baseDefaultBranch;
+			entry.tips = { base: last.inputs.baseTips };
 		} else entry.pending |= 23;
 		entry.handle = handle;
 		entry.slotsKey = getRepositoryKey(gitDir.commonUri ?? gitDir.uri);
@@ -501,17 +557,23 @@ var WorktreeSummaryService = class {
 		if (e.changed("index", "ignores")) fields |= dirtyField;
 		if (e.changed("config") && e.mayHaveChangedConfig(getConfigRelevantRefs(value))) fields |= 26;
 		if (e.changed("gkConfig")) fields |= baseKeysField;
-		if (value.branch != null && e.mayHaveChangedRef(`refs/heads/${value.branch}`)) fields |= allFields;
-		if (value.upstream != null && (e.mayHaveChangedRef(`refs/remotes/${value.upstream.name}`) || e.mayHaveChangedRef(`refs/heads/${value.upstream.name}`))) fields |= branchField;
+		if (value.branch != null) {
+			const ref = `refs/heads/${value.branch}`;
+			if (e.mayHaveChangedRef(ref)) fields |= isNamedRef(e, ref) ? allFields : tipCheckField;
+		}
+		if (value.upstream != null) {
+			const remoteRef = `refs/remotes/${value.upstream.name}`;
+			if (e.mayHaveChangedRef(remoteRef)) fields |= isNamedRef(e, remoteRef) ? branchField : tipCheckField;
+			const localRef = `refs/heads/${value.upstream.name}`;
+			if (e.mayHaveChangedRef(localRef)) fields |= isNamedRef(e, localRef) ? branchField : tipCheckField;
+		}
 		let baseMoves;
 		if ((fields & baseField) === 0) {
 			for (const ref of value.baseDependsOn) {
 				if (!e.mayHaveChangedRef(ref)) continue;
-				const kind = getRefChangeKind(ref);
-				if (!e.refs.has(ref) || kind == null || e.unnamedRefKinds.has(kind)) {
-					fields |= baseField;
-					baseMoves = void 0;
-					break;
+				if (!isNamedRef(e, ref)) {
+					fields |= tipCheckField;
+					continue;
 				}
 				baseMoves ??= [];
 				baseMoves.push(ref);
@@ -612,13 +674,16 @@ var WorktreeSummaryService = class {
 		return true;
 	}
 	async run(entry, fields, baseMoves) {
-		const { value, seed } = entry;
+		const { value, seed, tips } = entry;
 		const previous = value ?? seed;
+		if (previous?.stale) fields |= 23;
+		const probed = {};
 		let result;
 		try {
 			const repo = this.getRepository(entry.key);
 			if (repo == null) throw new Error(`No repository found for '${entry.key}'`);
-			result = await readSummary(repo, entry.key, fields, previous, entry.baseKeys, entry.baseConfigKey, entry.baseDefaultBranch, baseMoves, entry.abort.signal, this.verifyBaseRemeasure);
+			const signal = entry.abort.signal;
+			result = await readSummary(repo, entry.key, fields, previous, entry.baseKeys, entry.baseConfigKey, entry.baseDefaultBranch, baseMoves, signal, this.verifyBaseRemeasure, (due, moves) => this.probeRead(repo, previous, tips, due, moves, probed, signal));
 		} catch (ex) {
 			if (entry.disposed || isCancellationError(ex)) return;
 			this.fail(entry, ex);
@@ -628,6 +693,7 @@ var WorktreeSummaryService = class {
 		if (result.summary.stale && (previous == null || !previous.stale)) _logger.warn(`WorktreeSummaryService: reading the base of '${entry.key}' failed: ${String(result.baseError)}`);
 		entry.error = void 0;
 		entry.seed = void 0;
+		entry.tips = getReadTips(tips, probed.refs, result);
 		entry.baseKeys = result.baseKeys;
 		entry.baseConfigKey = entry.pending & baseConfigField ? void 0 : result.baseConfigKey;
 		entry.baseDefaultBranch = result.baseDefaultBranch;
@@ -687,6 +753,7 @@ var WorktreeSummaryService = class {
 		entry.baseKeys = void 0;
 		entry.baseConfigKey = void 0;
 		entry.baseDefaultBranch = void 0;
+		entry.tips = void 0;
 		entry.pending = 0;
 		entry.baseMoves = void 0;
 		entry.running = void 0;
@@ -709,6 +776,7 @@ function dropSeed(entry) {
 	entry.baseKeys = void 0;
 	entry.baseConfigKey = void 0;
 	entry.baseDefaultBranch = void 0;
+	entry.tips = void 0;
 }
 function clearDeferredDirty(entry) {
 	entry.dirtyReadAt = void 0;
@@ -730,6 +798,7 @@ function createEntry(key) {
 		baseKeys: void 0,
 		baseConfigKey: void 0,
 		baseDefaultBranch: void 0,
+		tips: void 0,
 		error: void 0,
 		pending: 0,
 		baseMoves: void 0,
@@ -747,7 +816,7 @@ function createEntry(key) {
 * answer. A failed base read doesn't fail the rest: the summary comes back stale, keeping the previous
 * base and `baseDependsOn` only while the branch is the same.
 */
-async function readSummary(repo, key, fields, previous, previousBaseKeys, previousBaseConfigKey, previousBaseDefaultBranch, baseMoves, signal, verifyBaseRemeasure) {
+async function readSummary(repo, key, fields, previous, previousBaseKeys, previousBaseConfigKey, previousBaseDefaultBranch, baseMoves, signal, verifyBaseRemeasure, probe) {
 	if (previous == null) fields |= allFields;
 	let dirtyReadAt;
 	const startDirtyRead = () => {
@@ -755,6 +824,12 @@ async function readSummary(repo, key, fields, previous, previousBaseKeys, previo
 		return readDirty(repo, signal);
 	};
 	let dirtyRead = fields & dirtyField ? startDirtyRead() : void 0;
+	let head;
+	if (probe != null && fields & 102) {
+		const probed = await probe(fields, baseMoves);
+		({fields, baseMoves, head} = probed);
+		if (fields & dirtyField) dirtyRead ??= startDirtyRead();
+	}
 	let branch = previous?.branch;
 	let detached = previous?.detached ?? false;
 	let sha = previous?.sha;
@@ -762,7 +837,7 @@ async function readSummary(repo, key, fields, previous, previousBaseKeys, previo
 	let ahead = previous?.ahead ?? 0;
 	let behind = previous?.behind ?? 0;
 	if (fields & branchField) {
-		const current = await repo.branches.getBranch(void 0, void 0, signal);
+		const current = head != null ? head.branch : await repo.branches.getBranch(void 0, void 0, signal);
 		detached = current?.detached ?? false;
 		branch = detached ? void 0 : current?.name || void 0;
 		sha = current?.sha;
@@ -867,7 +942,8 @@ async function readSummary(repo, key, fields, previous, previousBaseKeys, previo
 		baseConfigKey,
 		baseDefaultBranch,
 		baseError,
-		dirtyReadAt
+		dirtyReadAt,
+		fields
 	};
 }
 async function getGitDir(repo) {
@@ -878,6 +954,18 @@ async function getGitDir(repo) {
 		return;
 	}
 }
+/**
+* Reads the ref tips and the `HEAD` symrefs of `remotes` (every remote's when `undefined`), as core's caches answer
+* them: one ref list shared by the repository's worktrees
+*/
+async function probeRefs(repo, remotes, signal) {
+	const remoteHeads = /* @__PURE__ */ new Map();
+	const [tips] = await Promise.all([repo.refs.getRefTips(void 0, signal), readRemoteHeads(repo, remoteHeads, remotes, signal)]);
+	return {
+		tips: getTipsByName(tips),
+		remoteHeads
+	};
+}
 /** Each ref list's tips by full name, built once per list, which core's cache shares across a repository's worktrees */
 const tipsByNameCache = /* @__PURE__ */ new WeakMap();
 function getTipsByName(tips) {
@@ -901,14 +989,10 @@ async function getMovedFields(repo, last, probe, probeDirty, signal) {
 	const previous = last.result.summary;
 	if (probe.branch !== inputs.branch || probe.detached !== inputs.detached || probe.sha !== inputs.sha) fields |= allFields;
 	else {
+		fields |= getUpstreamFields(probe.current, previous);
 		if (probe.upstream !== inputs.upstream) fields |= 18;
 		else if (getUpstreamTips(probe.tips, probe.upstream) !== inputs.upstreamTips) fields |= branchField;
-		for (const ref of previous.baseDependsOn) {
-			const value = getBaseInput(probe, ref);
-			if (value !== null && value === inputs.baseTips.get(ref)) continue;
-			baseMoves ??= /* @__PURE__ */ new Set();
-			baseMoves.add(ref);
-		}
+		baseMoves = getMovedBaseRefs(probe, previous.baseDependsOn, inputs.baseTips);
 		if (baseMoves != null) fields |= baseMoveField;
 		if ((fields & baseConfigField) === 0 && last.result.baseConfigKey != null && repo.branches.getAheadOfBase != null && (probe.detached || probe.branch != null)) {
 			const configKey = getBaseConfigKey(await readBaseConfig(repo, signal), previous);
@@ -921,6 +1005,61 @@ async function getMovedFields(repo, last, probe, probeDirty, signal) {
 		baseMoves
 	};
 }
+/**
+* The read groups a tip check (see {@link tipCheckField}) finds moved since `previous` was read, with the refs the base
+* depends on as `tips` has them: everything when HEAD's branch or commit isn't the one `previous` has, else those
+* {@link getUpstreamFields} finds, and the base's refs that moved
+*/
+function getTipCheckFields(probe, previous, tips) {
+	if (probe.branch !== previous.branch || probe.detached !== previous.detached || probe.sha !== previous.sha) return {
+		fields: allFields,
+		baseMoves: void 0
+	};
+	let fields = getUpstreamFields(probe.current, previous);
+	const baseMoves = getMovedBaseRefs(probe, previous.baseDependsOn, tips?.base);
+	if (baseMoves != null) fields |= baseMoveField;
+	return {
+		fields,
+		baseMoves
+	};
+}
+/**
+* The read groups `current`, HEAD as `getBranch` answers it, finds moved in what `previous` has of the upstream: another
+* upstream reads the branch and the config inputs, which read the base again when the upstream's identity changed;
+* one gone or back, or other counts against it, the branch. Core drops its cached branches, counts and all, with its
+* ref list on any change to branches or remote-tracking refs, the changes a tip check follows, so a probe after one
+* answers them as of that change.
+*/
+function getUpstreamFields(current, previous) {
+	const upstream = current?.upstream;
+	if (upstream?.name !== previous.upstream?.name) return 18;
+	if (upstream?.missing !== previous.upstream?.missing || (upstream?.state.ahead ?? 0) !== previous.ahead || (upstream?.state.behind ?? 0) !== previous.behind) return branchField;
+	return 0;
+}
+/**
+* The refs of `baseDependsOn` that `probe` finds moved since `baseTips`; `undefined` when none did. A tip that's unknown
+* (`null`, or not kept) moved.
+*/
+function getMovedBaseRefs(probe, baseDependsOn, baseTips) {
+	let baseMoves;
+	for (const ref of baseDependsOn) {
+		const value = getBaseInput(probe, ref);
+		if (value !== null && baseTips?.has(ref) && value === baseTips.get(ref)) continue;
+		baseMoves ??= /* @__PURE__ */ new Set();
+		baseMoves.add(ref);
+	}
+	return baseMoves;
+}
+/**
+* The tips a subscribed run leaves its summary read from: from the refs its probe found (`refs`) when it read the base,
+* unknown when it read it without a probe, and else `last`'s
+*/
+function getReadTips(last, refs, result) {
+	const { summary, fields } = result;
+	let base = last?.base;
+	if (fields & 36) base = refs != null && !summary.stale ? getBaseTips(refs, summary.baseDependsOn) : void 0;
+	return { base };
+}
 /** The upstream's tips as a remote-tracking and as a local branch, since its short name doesn't say which */
 function getUpstreamTips(tips, upstream) {
 	if (upstream == null) return void 0;
@@ -973,18 +1112,22 @@ function getBaseInput(probe, ref) {
 }
 /** The inputs `summary` was read from, as the probe before its read found them */
 function toUnwatchedInputs(probe, summary) {
-	const baseTips = /* @__PURE__ */ new Map();
-	for (const ref of summary.baseDependsOn) baseTips.set(ref, getBaseInput(probe, ref));
 	return {
 		branch: probe.branch,
 		detached: probe.detached,
 		sha: probe.sha,
 		upstream: probe.upstream,
 		upstreamTips: getUpstreamTips(probe.tips, probe.upstream),
-		baseTips,
+		baseTips: getBaseTips(probe, summary.baseDependsOn),
 		index: probe.index
 	};
 }
+/** What `refs` found of each of `baseDependsOn` (see {@link getBaseInput}) */
+function getBaseTips(refs, baseDependsOn) {
+	const baseTips = /* @__PURE__ */ new Map();
+	for (const ref of baseDependsOn) baseTips.set(ref, getBaseInput(refs, ref));
+	return baseTips;
+}
 async function readBaseConfig(repo, signal) {
 	try {
 		if (repo.branches.getAheadOfBaseConfigEntries != null) return await repo.branches.getAheadOfBaseConfigEntries(signal);
@@ -1076,6 +1219,11 @@ async function toSummaryUpstream(repo, upstream, signal) {
 		missing
 	};
 }
+/** Whether `e` names `ref` exactly, so it's known to be a ref that moved rather than one that may have */
+function isNamedRef(e, ref) {
+	const kind = getRefChangeKind(ref);
+	return kind != null && e.refs.has(ref) && !e.unnamedRefKinds.has(kind);
+}
 function upstreamsEqual(a, b) {
 	return a === b || a != null && b != null && a.name === b.name && a.remote === b.remote && a.branch === b.branch && a.missing === b.missing;
 }